drivers/net/pfe/base/pfe.h

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright 2018-2019 NXP
   3  */
   4
   5 #ifndef _PFE_H_
   6 #define _PFE_H_
   7
   8 #include "cbus.h"
   9
  10 /*
  11  * WARNING: non atomic version.
  12  */
  13 static inline void
  14 set_bit(unsigned long nr, void *addr)
  15 {
  16         int *m = ((int *)addr) + (nr >> 5);
  17         *m |= 1 << (nr & 31);
  18 }
  19
  20 static inline int
  21 test_bit(int nr, const void *addr)
  22 {
  23         return (1UL & (((const int *)addr)[nr >> 5] >> (nr & 31))) != 0UL;
  24 }
  25
  26 /*
  27  * WARNING: non atomic version.
  28  */
  29 static inline void
  30 clear_bit(unsigned long nr, void *addr)
  31 {
  32         int *m = ((int *)addr) + (nr >> 5);
  33         *m &= ~(1 << (nr & 31));
  34 }
  35
  36 /*
  37  * WARNING: non atomic version.
  38  */
  39 static inline int
  40 test_and_clear_bit(unsigned long nr, void *addr)
  41 {
  42         unsigned long mask = 1 << (nr & 0x1f);
  43         int *m = ((int *)addr) + (nr >> 5);
  44         int old = *m;
  45
  46         *m = old & ~mask;
  47         return (old & mask) != 0;
  48 }
  49
  50 /*
  51  * WARNING: non atomic version.
  52  */
  53 static inline int
  54 test_and_set_bit(unsigned long nr, void *addr)
  55 {
  56         unsigned long mask = 1 << (nr & 0x1f);
  57         int *m = ((int *)addr) + (nr >> 5);
  58         int old = *m;
  59
  60         *m = old | mask;
  61         return (old & mask) != 0;
  62 }
  63
  64 #ifndef BIT
  65 #define BIT(nr)                (1UL << (nr))
  66 #endif
  67 #define CLASS_DMEM_BASE_ADDR(i) (0x00000000 | ((i) << 20))
  68 /*
  69  * Only valid for mem access register interface
  70  */
  71 #define CLASS_IMEM_BASE_ADDR(i) (0x00000000 | ((i) << 20))
  72 #define CLASS_DMEM_SIZE 0x00002000
  73 #define CLASS_IMEM_SIZE 0x00008000
  74
  75 #define TMU_DMEM_BASE_ADDR(i)   (0x00000000 + ((i) << 20))
  76 /*
  77  * Only valid for mem access register interface
  78  */
  79 #define TMU_IMEM_BASE_ADDR(i)   (0x00000000 + ((i) << 20))
  80 #define TMU_DMEM_SIZE   0x00000800
  81 #define TMU_IMEM_SIZE   0x00002000
  82
  83 #define UTIL_DMEM_BASE_ADDR     0x00000000
  84 #define UTIL_DMEM_SIZE  0x00002000
  85
  86 #define PE_LMEM_BASE_ADDR       0xc3010000
  87 #define PE_LMEM_SIZE    0x8000
  88 #define PE_LMEM_END     (PE_LMEM_BASE_ADDR + PE_LMEM_SIZE)
  89
  90 #define DMEM_BASE_ADDR  0x00000000
  91 #define DMEM_SIZE       0x2000  /* TMU has less... */
  92 #define DMEM_END        (DMEM_BASE_ADDR + DMEM_SIZE)
  93
  94 #define PMEM_BASE_ADDR  0x00010000
  95 #define PMEM_SIZE       0x8000  /* TMU has less... */
  96 #define PMEM_END        (PMEM_BASE_ADDR + PMEM_SIZE)
  97
  98 #define writel(v, p) ({*(volatile unsigned int *)(p) = (v); })
  99 #define readl(p) (*(const volatile unsigned int *)(p))
 100
 101 /* These check memory ranges from PE point of view/memory map */
 102 #define IS_DMEM(addr, len)                              \
 103         ({ typeof(addr) addr_ = (addr);                 \
 104         ((unsigned long)(addr_) >= DMEM_BASE_ADDR) &&   \
 105         (((unsigned long)(addr_) + (len)) <= DMEM_END); })
 106
 107 #define IS_PMEM(addr, len)                              \
 108         ({ typeof(addr) addr_ = (addr);                 \
 109         ((unsigned long)(addr_) >= PMEM_BASE_ADDR) &&   \
 110         (((unsigned long)(addr_) + (len)) <= PMEM_END); })
 111
 112 #define IS_PE_LMEM(addr, len)                           \
 113         ({ typeof(addr) addr_ = (addr);                 \
 114         ((unsigned long)(addr_) >=                      \
 115         PE_LMEM_BASE_ADDR) &&                           \
 116         (((unsigned long)(addr_) +                      \
 117         (len)) <= PE_LMEM_END); })
 118
 119 #define IS_PFE_LMEM(addr, len)                          \
 120         ({ typeof(addr) addr_ = (addr);                 \
 121         ((unsigned long)(addr_) >=                      \
 122         CBUS_VIRT_TO_PFE(LMEM_BASE_ADDR)) &&            \
 123         (((unsigned long)(addr_) + (len)) <=            \
 124         CBUS_VIRT_TO_PFE(LMEM_END)); })
 125
 126 #define __IS_PHYS_DDR(addr, len)                        \
 127         ({ typeof(addr) addr_ = (addr);                 \
 128         ((unsigned long)(addr_) >=                      \
 129         DDR_PHYS_BASE_ADDR) &&                          \
 130         (((unsigned long)(addr_) + (len)) <=            \
 131         DDR_PHYS_END); })
 132
 133 #define IS_PHYS_DDR(addr, len)  __IS_PHYS_DDR(DDR_PFE_TO_PHYS(addr), len)
 134
 135 /*
 136  * If using a run-time virtual address for the cbus base address use this code
 137  */
 138 extern void *cbus_base_addr;
 139 extern void *ddr_base_addr;
 140 extern unsigned long ddr_phys_base_addr;
 141 extern unsigned int ddr_size;
 142
 143 #define CBUS_BASE_ADDR  cbus_base_addr
 144 #define DDR_PHYS_BASE_ADDR      ddr_phys_base_addr
 145 #define DDR_BASE_ADDR   ddr_base_addr
 146 #define DDR_SIZE        ddr_size
 147
 148 #define DDR_PHYS_END    (DDR_PHYS_BASE_ADDR + DDR_SIZE)
 149
 150 #define LS1012A_PFE_RESET_WA    /*
 151                                  * PFE doesn't have global reset and re-init
 152                                  * should takecare few things to make PFE
 153                                  * functional after reset
 154                                  */
 155 #define PFE_CBUS_PHYS_BASE_ADDR 0xc0000000      /* CBUS physical base address
 156                                                  * as seen by PE's.
 157                                                  */
 158 /* CBUS physical base address as seen by PE's. */
 159 #define PFE_CBUS_PHYS_BASE_ADDR_FROM_PFE        0xc0000000
 160
 161 #define DDR_PHYS_TO_PFE(p)      (((unsigned long)(p)) & 0x7FFFFFFF)
 162 #define DDR_PFE_TO_PHYS(p)      (((unsigned long)(p)) | 0x80000000)
 163 #define CBUS_PHYS_TO_PFE(p)     (((p) - PFE_CBUS_PHYS_BASE_ADDR) + \
 164                                 PFE_CBUS_PHYS_BASE_ADDR_FROM_PFE)
 165 /* Translates to PFE address map */
 166
 167 #define DDR_PHYS_TO_VIRT(p)     (((p) - DDR_PHYS_BASE_ADDR) + DDR_BASE_ADDR)
 168 #define DDR_VIRT_TO_PHYS(v)     (((v) - DDR_BASE_ADDR) + DDR_PHYS_BASE_ADDR)
 169 #define DDR_VIRT_TO_PFE(p)      (DDR_PHYS_TO_PFE(DDR_VIRT_TO_PHYS(p)))
 170
 171 #define CBUS_VIRT_TO_PFE(v)     (((v) - CBUS_BASE_ADDR) + \
 172                                 PFE_CBUS_PHYS_BASE_ADDR)
 173 #define CBUS_PFE_TO_VIRT(p)     (((unsigned long)(p) - \
 174                                 PFE_CBUS_PHYS_BASE_ADDR) + CBUS_BASE_ADDR)
 175
 176 /* The below part of the code is used in QOS control driver from host */
 177 #define TMU_APB_BASE_ADDR       0xc1000000      /* TMU base address seen by
 178                                                  * pe's
 179                                                  */
 180
 181 enum {
 182         CLASS0_ID = 0,
 183         CLASS1_ID,
 184         CLASS2_ID,
 185         CLASS3_ID,
 186         CLASS4_ID,
 187         CLASS5_ID,
 188         TMU0_ID,
 189         TMU1_ID,
 190         TMU2_ID,
 191         TMU3_ID,
 192 #if !defined(CONFIG_FSL_PFE_UTIL_DISABLED)
 193         UTIL_ID,
 194 #endif
 195         MAX_PE
 196 };
 197
 198 #define CLASS_MASK      (BIT(CLASS0_ID) | BIT(CLASS1_ID) |\
 199                         BIT(CLASS2_ID) | BIT(CLASS3_ID) |\
 200                         BIT(CLASS4_ID) | BIT(CLASS5_ID))
 201 #define CLASS_MAX_ID    CLASS5_ID
 202
 203 #define TMU_MASK        (BIT(TMU0_ID) | BIT(TMU1_ID) |\
 204                         BIT(TMU3_ID))
 205
 206 #define TMU_MAX_ID      TMU3_ID
 207
 208 #if !defined(CONFIG_FSL_PFE_UTIL_DISABLED)
 209 #define UTIL_MASK       BIT(UTIL_ID)
 210 #endif
 211
 212 struct pe_status {
 213         u32     cpu_state;
 214         u32     activity_counter;
 215         u32     rx;
 216         union {
 217         u32     tx;
 218         u32     tmu_qstatus;
 219         };
 220         u32     drop;
 221 #if defined(CFG_PE_DEBUG)
 222         u32     debug_indicator;
 223         u32     debug[16];
 224 #endif
 225 } __rte_aligned(16);
 226
 227 struct pe_sync_mailbox {
 228         u32 stop;
 229         u32 stopped;
 230 };
 231
 232 /* Drop counter definitions */
 233
 234 #define CLASS_NUM_DROP_COUNTERS 13
 235 #define UTIL_NUM_DROP_COUNTERS  8
 236
 237 /* PE information.
 238  * Structure containing PE's specific information. It is used to create
 239  * generic C functions common to all PE's.
 240  * Before using the library functions this structure needs to be initialized
 241  * with the different registers virtual addresses
 242  * (according to the ARM MMU mmaping). The default initialization supports a
 243  * virtual == physical mapping.
 244  */
 245 struct pe_info {
 246         u32 dmem_base_addr;     /* PE's dmem base address */
 247         u32 pmem_base_addr;     /* PE's pmem base address */
 248         u32 pmem_size;  /* PE's pmem size */
 249
 250         void *mem_access_wdata; /* PE's _MEM_ACCESS_WDATA register
 251                                  * address
 252                                  */
 253         void *mem_access_addr;  /* PE's _MEM_ACCESS_ADDR register
 254                                  * address
 255                                  */
 256         void *mem_access_rdata; /* PE's _MEM_ACCESS_RDATA register
 257                                  * address
 258                                  */
 259 };
 260
 261 void pe_lmem_read(u32 *dst, u32 len, u32 offset);
 262 void pe_lmem_write(u32 *src, u32 len, u32 offset);
 263
 264 void pe_dmem_memcpy_to32(int id, u32 dst, const void *src, unsigned int len);
 265 void pe_pmem_memcpy_to32(int id, u32 dst, const void *src, unsigned int len);
 266
 267 u32 pe_pmem_read(int id, u32 addr, u8 size);
 268
 269 void pe_dmem_write(int id, u32 val, u32 addr, u8 size);
 270 u32 pe_dmem_read(int id, u32 addr, u8 size);
 271 void class_pe_lmem_memcpy_to32(u32 dst, const void *src, unsigned int len);
 272 void class_pe_lmem_memset(u32 dst, int val, unsigned int len);
 273 void class_bus_write(u32 val, u32 addr, u8 size);
 274 u32 class_bus_read(u32 addr, u8 size);
 275
 276 #define class_bus_readl(addr)   class_bus_read(addr, 4)
 277 #define class_bus_readw(addr)   class_bus_read(addr, 2)
 278 #define class_bus_readb(addr)   class_bus_read(addr, 1)
 279
 280 #define class_bus_writel(val, addr)     class_bus_write(val, addr, 4)
 281 #define class_bus_writew(val, addr)     class_bus_write(val, addr, 2)
 282 #define class_bus_writeb(val, addr)     class_bus_write(val, addr, 1)
 283
 284 #define pe_dmem_readl(id, addr) pe_dmem_read(id, addr, 4)
 285 #define pe_dmem_readw(id, addr) pe_dmem_read(id, addr, 2)
 286 #define pe_dmem_readb(id, addr) pe_dmem_read(id, addr, 1)
 287
 288 #define pe_dmem_writel(id, val, addr)   pe_dmem_write(id, val, addr, 4)
 289 #define pe_dmem_writew(id, val, addr)   pe_dmem_write(id, val, addr, 2)
 290 #define pe_dmem_writeb(id, val, addr)   pe_dmem_write(id, val, addr, 1)
 291
 292 /*int pe_load_elf_section(int id, const void *data, elf32_shdr *shdr); */
 293 //int pe_load_elf_section(int id, const void *data, struct elf32_shdr *shdr,
 294 //                      struct device *dev);
 295
 296 void pfe_lib_init(void *cbus_base, void *ddr_base, unsigned long ddr_phys_base,
 297                   unsigned int ddr_size);
 298 void bmu_init(void *base, struct BMU_CFG *cfg);
 299 void bmu_reset(void *base);
 300 void bmu_enable(void *base);
 301 void bmu_disable(void *base);
 302 void bmu_set_config(void *base, struct BMU_CFG *cfg);
 303
 304 /*
 305  * An enumerated type for loopback values.  This can be one of three values, no
 306  * loopback -normal operation, local loopback with internal loopback module of
 307  * MAC or PHY loopback which is through the external PHY.
 308  */
 309 #ifndef __MAC_LOOP_ENUM__
 310 #define __MAC_LOOP_ENUM__
 311 enum mac_loop {LB_NONE, LB_EXT, LB_LOCAL};
 312 #endif
 313
 314 void gemac_init(void *base, void *config);
 315 void gemac_disable_rx_checksum_offload(void *base);
 316 void gemac_enable_rx_checksum_offload(void *base);
 317 void gemac_set_mdc_div(void *base, int mdc_div);
 318 void gemac_set_speed(void *base, enum mac_speed gem_speed);
 319 void gemac_set_duplex(void *base, int duplex);
 320 void gemac_set_mode(void *base, int mode);
 321 void gemac_enable(void *base);
 322 void gemac_tx_disable(void *base);
 323 void gemac_tx_enable(void *base);
 324 void gemac_disable(void *base);
 325 void gemac_reset(void *base);
 326 void gemac_set_address(void *base, struct spec_addr *addr);
 327 struct spec_addr gemac_get_address(void *base);
 328 void gemac_set_loop(void *base, enum mac_loop gem_loop);
 329 void gemac_set_laddr1(void *base, struct pfe_mac_addr *address);
 330 void gemac_set_laddr2(void *base, struct pfe_mac_addr *address);
 331 void gemac_set_laddr3(void *base, struct pfe_mac_addr *address);
 332 void gemac_set_laddr4(void *base, struct pfe_mac_addr *address);
 333 void gemac_set_laddrN(void *base, struct pfe_mac_addr *address,
 334                       unsigned int entry_index);
 335 void gemac_clear_laddr1(void *base);
 336 void gemac_clear_laddr2(void *base);
 337 void gemac_clear_laddr3(void *base);
 338 void gemac_clear_laddr4(void *base);
 339 void gemac_clear_laddrN(void *base, unsigned int entry_index);
 340 struct pfe_mac_addr gemac_get_hash(void *base);
 341 void gemac_set_hash(void *base, struct pfe_mac_addr *hash);
 342 struct pfe_mac_addr gem_get_laddr1(void *base);
 343 struct pfe_mac_addr gem_get_laddr2(void *base);
 344 struct pfe_mac_addr gem_get_laddr3(void *base);
 345 struct pfe_mac_addr gem_get_laddr4(void *base);
 346 struct pfe_mac_addr gem_get_laddrN(void *base, unsigned int entry_index);
 347 void gemac_set_config(void *base, struct gemac_cfg *cfg);
 348 void gemac_allow_broadcast(void *base);
 349 void gemac_no_broadcast(void *base);
 350 void gemac_enable_1536_rx(void *base);
 351 void gemac_disable_1536_rx(void *base);
 352 int gemac_set_rx(void *base, int mtu);
 353 void gemac_enable_rx_jmb(void *base);
 354 void gemac_disable_rx_jmb(void *base);
 355 void gemac_enable_stacked_vlan(void *base);
 356 void gemac_disable_stacked_vlan(void *base);
 357 void gemac_enable_pause_rx(void *base);
 358 void gemac_disable_pause_rx(void *base);
 359 void gemac_enable_pause_tx(void *base);
 360 void gemac_disable_pause_tx(void *base);
 361 void gemac_enable_copy_all(void *base);
 362 void gemac_disable_copy_all(void *base);
 363 void gemac_set_bus_width(void *base, int width);
 364 void gemac_set_wol(void *base, u32 wol_conf);
 365
 366 void gpi_init(void *base, struct gpi_cfg *cfg);
 367 void gpi_reset(void *base);
 368 void gpi_enable(void *base);
 369 void gpi_disable(void *base);
 370 void gpi_set_config(void *base, struct gpi_cfg *cfg);
 371
 372 void hif_init(void);
 373 void hif_tx_enable(void);
 374 void hif_tx_disable(void);
 375 void hif_rx_enable(void);
 376 void hif_rx_disable(void);
 377
 378 /* Get Chip Revision level
 379  *
 380  */
 381 static inline unsigned int CHIP_REVISION(void)
 382 {
 383         /*For LS1012A return always 1 */
 384         return 1;
 385 }
 386
 387 /* Start HIF rx DMA
 388  *
 389  */
 390 static inline void hif_rx_dma_start(void)
 391 {
 392         writel(HIF_CTRL_DMA_EN | HIF_CTRL_BDP_CH_START_WSTB, HIF_RX_CTRL);
 393 }
 394
 395 /* Start HIF tx DMA
 396  *
 397  */
 398 static inline void hif_tx_dma_start(void)
 399 {
 400         writel(HIF_CTRL_DMA_EN | HIF_CTRL_BDP_CH_START_WSTB, HIF_TX_CTRL);
 401 }
 402
 403
 404 static inline void *pfe_mem_ptov(phys_addr_t paddr)
 405 {
 406         return rte_mem_iova2virt(paddr);
 407 }
 408
 409 static phys_addr_t pfe_mem_vtop(uint64_t vaddr) __attribute__((unused));
 410
 411 static inline phys_addr_t pfe_mem_vtop(uint64_t vaddr)
 412 {
 413         const struct rte_memseg *memseg;
 414
 415         memseg = rte_mem_virt2memseg((void *)(uintptr_t)vaddr, NULL);
 416         if (memseg)
 417                 return memseg->phys_addr + RTE_PTR_DIFF(vaddr, memseg->addr);
 418
 419         return (size_t)NULL;
 420 }
 421
 422 #endif /* _PFE_H_ */