/*      $Id: rmixl_fmnvar.h,v 1.5 2024/06/06 21:18:41 andvar Exp $      */
/*-
* Copyright (c) 2010 The NetBSD Foundation, Inc.
* All rights reserved.
*
* This code is derived from software contributed to The NetBSD Foundation
* by Cliff Neighbors.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/

#ifndef _ARCH_MIPS_RMIXL_RMIXL_FMNVAR_H_
#define _ARCH_MIPS_RMIXL_RMIXL_FMNVAR_H_

#include <mips/cpuregs.h>

#define RMIXL_FMN_CODE_PSB_WAKEUP       200     /* firmware MSGRNG_CODE_BOOT_WAKEUP */
#define RMIXL_FMN_CODE_HELLO_REQ        201
#define RMIXL_FMN_CODE_HELLO_ACK        202

#define RMIXL_FMN_HELLO_REQ_SZ          4
#define RMIXL_FMN_HELLO_ACK_SZ          4

typedef struct rmixl_fmn_msg {
       uint64_t data[4];
} rmixl_fmn_msg_t;

typedef struct rmixl_fmn_rxmsg {
       u_int rxsid;
       u_int code;
       u_int size;
       rmixl_fmn_msg_t msg;
} rmixl_fmn_rxmsg_t;


/*
* compute FMN dest_id from MIPS cpuid
* - each Core FMN station has 8 buckets
* - each Core has 4 threads
* - here we use 1 bucket per thread
*   (the first four buckets)
* - if we need { hi, lo } priority buckets per thread
*   need to adjust the RMIXL_FMN_DESTID macro
*   and use the 'pri' parameter
* - i.e. for now there is only one priority
*/
#define RMIXL_CPU_CORE(cpuid)   ((uint32_t)((cpuid) & __BITS(9,0)) >> 2)
#define RMIXL_CPU_THREAD(cpuid) ((uint32_t)((cpuid) & __BITS(1,0)))
#define RMIXL_FMN_CORE_DESTID(core, bucket)     \
                (((core) << 3) | (bucket))


#define RMIXL_DMFC2(regnum, sel, rv)                                    \
do {                                                                    \
       uint64_t __val;                                                 \
                                                                       \
       __asm volatile(                                                 \
               ".set push"                     "\n\t"                  \
               ".set mips64"                   "\n\t"                  \
               ".set noat"                     "\n\t"                  \
               "dmfc2 %0,$%1,%2"               "\n\t"                  \
               ".set pop"                      "\n\t"                  \
           : "=r"(__val) : "n"(regnum), "n"(sel));                     \
       rv = __val;                                                     \
} while (0)

#define RMIXL_DMTC2(regnum, sel, val)                                   \
do {                                                                    \
       uint64_t __val = val;                                           \
                                                                       \
       __asm volatile(                                                 \
               ".set push"                     "\n\t"                  \
               ".set mips64"                   "\n\t"                  \
               ".set noat"                     "\n\t"                  \
               "dmtc2 %0,$%1,%2"               "\n\t"                  \
               ".set pop"                      "\n\t"                  \
           :: "r"(__val), "n"(regnum), "n"(sel));                      \
} while (0)

#define RMIXL_MFC2(regnum, sel, rv)                                     \
do {                                                                    \
       uint32_t __val;                                                 \
                                                                       \
       __asm volatile(                                                 \
               ".set push"                     "\n\t"                  \
               ".set mips64"                   "\n\t"                  \
               "mfc2 %0,$%1,%2"                "\n\t"                  \
               ".set pop"                      "\n\t"                  \
           : "=r"(__val) : "n"(regnum), "n"(sel));                     \
       rv = __val;                                                     \
} while (0)

#define RMIXL_MTC2(regnum, sel, val)                                    \
do {                                                                    \
       uint32_t __val = val;                                           \
                                                                       \
       __asm volatile(                                                 \
               ".set push"                     "\n\t"                  \
               ".set mips64"                   "\n\t"                  \
               "mtc2 %0,$%1,%2"                "\n\t"                  \
               ".set pop"                      "\n\t"                  \
           :: "r"(__val), "n"(regnum), "n"(sel));                      \
} while (0)

#define CPU2_PRINT_8(regno, sel)                                        \
do {                                                                    \
       uint64_t r;                                                     \
       RMIXL_DMFC2(regno, sel, r);                                     \
       printf("%s: CP2(%d,%d) = %#"PRIx64"\n",                         \
               __func__, regno, sel, r);                               \
} while (0)

#define CPU2_PRINT_4(regno, sel)                                        \
do {                                                                    \
       uint32_t r;                                                     \
       RMIXL_MFC2(regno, sel, r);                                      \
       printf("%s: CP2(%d,%d) = %#x\n",                                \
               __func__, regno, sel, r);                               \
} while (0)


/*
* encode 'dest' for msgsnd op 'rt'
*/
#define RMIXL_MSGSND_DESC(size, code, dest_id)  \
               ((((size) - 1) << 16) | ((code) << 8) | (dest_id))

static inline void
rmixl_msgsnd(uint32_t desc)
{
       __asm__ volatile (
               ".set push"             "\n\t"
               ".set noreorder"        "\n\t"
               ".set arch=xlr"         "\n\t"
               "sync"                  "\n\t"
               "msgsnd %0"             "\n\t"
               ".set pop"              "\n\t"
                       :: "r"(desc));
}

static inline void
rmixl_msgld(uint32_t bucket)
{
       __asm__ volatile (
               ".set push"             "\n\t"
               ".set noreorder"        "\n\t"
               ".set arch=xlr"         "\n\t"
               "msgld %0"              "\n\t"
               ".set pop"              "\n\t"
                       :: "r"(bucket));
}

/*
* the seemingly-spurious add is recommended by RMI
* see XLS PRM (rev. 3.21) 5.3.9
*/
static inline void
rmixl_fmn_msgwait(u_int mask)
{
       __asm__ volatile (
               ".set push"             "\n\t"
               ".set noreorder"        "\n\t"
               ".set arch=xlr"         "\n\t"
               "addu %0,%0,0"          "\n\t"
               "msgwait %0"            "\n\t"
               ".set pop"              "\n\t"
                       :: "r"(mask));
}

static inline uint32_t
rmixl_cp2_enable(void)
{
       uint32_t rv;
       uint32_t cu2;

       KASSERT(curcpu()->ci_cpl == IPL_HIGH);
       __asm volatile(
               ".set push"             "\n\t"
               ".set noreorder"        "\n\t"
               "li     %1,%3"          "\n\t"
               "mfc0   %0,$%2"         "\n\t"
               "or     %1,%1,%0"       "\n\t"
               "mtc0   %1,$%2"         "\n\t"
               ".set pop"              "\n\t"
                       : "=r"(rv), "=r"(cu2)
                       : "n"(MIPS_COP_0_STATUS), "n"(1 << 30));

       return (rv & (1 << 30));
}

static inline void
rmixl_cp2_restore(uint32_t ocu)
{
       uint32_t cu2;
       uint32_t mask = ~(1 << 30);

       KASSERT(curcpu()->ci_cpl == IPL_HIGH);
       __asm volatile(
               ".set push"             "\n\t"
               ".set noreorder"        "\n\t"
               "mfc0   %0,$%1"         "\n\t"
               "and    %0,%2,%0"       "\n\t"
               "or     %0,%3,%0"       "\n\t"
               "mtc0   %0,$%1"         "\n\t"
               ".set pop"              "\n\t"
                       : "=r"(cu2)
                       : "n"(MIPS_COP_0_STATUS), "r"(mask), "r"(ocu));
}

/*
* logical station IDs for RMI XLR
* see Table 13.2 "Addressable Buckets" in the XLR PRM
*/
#define RMIXLR_FMN_STID_CORE0                   0
#define RMIXLR_FMN_STID_CORE1                   1
#define RMIXLR_FMN_STID_CORE2                   2
#define RMIXLR_FMN_STID_CORE3                   3
#define RMIXLR_FMN_STID_CORE4                   4
#define RMIXLR_FMN_STID_CORE5                   5
#define RMIXLR_FMN_STID_CORE6                   6
#define RMIXLR_FMN_STID_CORE7                   7
#define RMIXLR_FMN_STID_TXRX_0                  8
#define RMIXLR_FMN_STID_TXRX_1                  9
#define RMIXLR_FMN_STID_RGMII                   10
#define RMIXLR_FMN_STID_DMA                     11
#define RMIXLR_FMN_STID_FREE_0                  12
#define RMIXLR_FMN_STID_FREE_1                  13
#define RMIXLR_FMN_STID_SAE                     14
#define RMIXLR_FMN_NSTID                        (RMIXLR_FMN_STID_SAE+1)
#define RMIXLR_FMN_STID_RESERVED                -1

/*
* logical station IDs for RMI XLS
* see Table 12.1 "Stations and Addressable Buckets ..." in the XLS PRM
*/
#define RMIXLS_FMN_STID_CORE0                   0
#define RMIXLS_FMN_STID_CORE1                   1
#define RMIXLS_FMN_STID_CORE2                   2
#define RMIXLS_FMN_STID_CORE3                   3
#define RMIXLS_FMN_STID_GMAC_Q0                 4
#define RMIXLS_FMN_STID_GMAC_Q1                 5
#define RMIXLS_FMN_STID_DMA                     6
#define RMIXLS_FMN_STID_CDE                     7
#define RMIXLS_FMN_STID_PCIE                    8
#define RMIXLS_FMN_STID_SAE                     9
#define RMIXLS_FMN_NSTID                        (RMIXLS_FMN_STID_SAE+1)
#define RMIXLS_FMN_STID_RESERVED                -1

/*
* logical station IDs for RMI XLP
* TBD!
*/
#define RMIXLP_FMN_NSTID                        0       /* XXX */


#define RMIXL_FMN_NSTID         \
               MAX(MAX(RMIXLR_FMN_NSTID, RMIXLS_FMN_NSTID), RMIXLP_FMN_NSTID)


#define RMIXL_FMN_INTR_IPL      IPL_HIGH

void    rmixl_fmn_init(void);
void    rmixl_fmn_init_core(void);
void    rmixl_fmn_init_cpu_intr(void);
void   *rmixl_fmn_intr_establish(int, int (*)(void *, rmixl_fmn_rxmsg_t *), void *);
void    rmixl_fmn_intr_disestablish(void *);
void    rmixl_fmn_intr_poll(u_int, rmixl_fmn_rxmsg_t *);
int     rmixl_fmn_msg_send(u_int, u_int, u_int, rmixl_fmn_msg_t *);
int     rmixl_fmn_msg_recv(u_int, rmixl_fmn_rxmsg_t *);



#endif  /* _ARCH_MIPS_RMIXL_RMIXL_FMNVAR_H_ */

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.