hwmtm.h (11023B)
1/* SPDX-License-Identifier: GPL-2.0-or-later */ 2/****************************************************************************** 3 * 4 * (C)Copyright 1998,1999 SysKonnect, 5 * a business unit of Schneider & Koch & Co. Datensysteme GmbH. 6 * 7 * The information in this file is provided "AS IS" without warranty. 8 * 9 ******************************************************************************/ 10 11#ifndef _HWM_ 12#define _HWM_ 13 14#include "mbuf.h" 15 16/* 17 * MACRO for DMA synchronization: 18 * The descriptor 'desc' is flushed for the device 'flag'. 19 * Devices are the CPU (DDI_DMA_SYNC_FORCPU) and the 20 * adapter (DDI_DMA_SYNC_FORDEV). 21 * 22 * 'desc' Pointer to a Rx or Tx descriptor. 23 * 'flag' Flag for direction (view for CPU or DEVICE) that 24 * should be synchronized. 25 * 26 * Empty macros and defines are specified here. The real macro 27 * is os-specific and should be defined in osdef1st.h. 28 */ 29#ifndef DRV_BUF_FLUSH 30#define DRV_BUF_FLUSH(desc,flag) 31#define DDI_DMA_SYNC_FORCPU 32#define DDI_DMA_SYNC_FORDEV 33#endif 34 35 /* 36 * hardware modul dependent receive modes 37 */ 38#define RX_ENABLE_PASS_SMT 21 39#define RX_DISABLE_PASS_SMT 22 40#define RX_ENABLE_PASS_NSA 23 41#define RX_DISABLE_PASS_NSA 24 42#define RX_ENABLE_PASS_DB 25 43#define RX_DISABLE_PASS_DB 26 44#define RX_DISABLE_PASS_ALL 27 45#define RX_DISABLE_LLC_PROMISC 28 46#define RX_ENABLE_LLC_PROMISC 29 47 48 49#ifndef DMA_RD 50#define DMA_RD 1 /* memory -> hw */ 51#endif 52#ifndef DMA_WR 53#define DMA_WR 2 /* hw -> memory */ 54#endif 55#define SMT_BUF 0x80 56 57 /* 58 * bits of the frame status byte 59 */ 60#define EN_IRQ_EOF 0x02 /* get IRQ after end of frame transmission */ 61#define LOC_TX 0x04 /* send frame to the local SMT */ 62#define LAST_FRAG 0x08 /* last TxD of the frame */ 63#define FIRST_FRAG 0x10 /* first TxD of the frame */ 64#define LAN_TX 0x20 /* send frame to network if set */ 65#define RING_DOWN 0x40 /* error: unable to send, ring down */ 66#define OUT_OF_TXD 0x80 /* error: not enough TxDs available */ 67 68 69#ifndef NULL 70#define NULL 0 71#endif 72 73#define C_INDIC (1L<<25) 74#define A_INDIC (1L<<26) 75#define RD_FS_LOCAL 0x80 76 77 /* 78 * DEBUG FLAGS 79 */ 80#define DEBUG_SMTF 1 81#define DEBUG_SMT 2 82#define DEBUG_ECM 3 83#define DEBUG_RMT 4 84#define DEBUG_CFM 5 85#define DEBUG_PCM 6 86#define DEBUG_SBA 7 87#define DEBUG_ESS 8 88 89#define DB_HWM_RX 10 90#define DB_HWM_TX 11 91#define DB_HWM_GEN 12 92 93struct s_mbuf_pool { 94#ifndef MB_OUTSIDE_SMC 95 SMbuf mb[MAX_MBUF] ; /* mbuf pool */ 96#endif 97 SMbuf *mb_start ; /* points to the first mb */ 98 SMbuf *mb_free ; /* free queue */ 99} ; 100 101struct hwm_r { 102 /* 103 * hardware modul specific receive variables 104 */ 105 u_int len ; /* length of the whole frame */ 106 char *mb_pos ; /* SMbuf receive position */ 107} ; 108 109struct hw_modul { 110 /* 111 * All hardware modul specific variables 112 */ 113 struct s_mbuf_pool mbuf_pool ; 114 struct hwm_r r ; 115 116 union s_fp_descr volatile *descr_p ; /* points to the desriptor area */ 117 118 u_short pass_SMT ; /* pass SMT frames */ 119 u_short pass_NSA ; /* pass all NSA frames */ 120 u_short pass_DB ; /* pass Direct Beacon Frames */ 121 u_short pass_llc_promisc ; /* pass all llc frames (default ON) */ 122 123 SMbuf *llc_rx_pipe ; /* points to the first queued llc fr */ 124 SMbuf *llc_rx_tail ; /* points to the last queued llc fr */ 125 int queued_rx_frames ; /* number of queued frames */ 126 127 SMbuf *txd_tx_pipe ; /* points to first mb in the txd ring */ 128 SMbuf *txd_tx_tail ; /* points to last mb in the txd ring */ 129 int queued_txd_mb ; /* number of SMT MBufs in txd ring */ 130 131 int rx_break ; /* rev. was breaked because ind. off */ 132 int leave_isr ; /* leave fddi_isr immedeately if set */ 133 int isr_flag ; /* set, when HWM is entered from isr */ 134 /* 135 * variables for the current transmit frame 136 */ 137 struct s_smt_tx_queue *tx_p ; /* pointer to the transmit queue */ 138 u_long tx_descr ; /* tx descriptor for FORMAC+ */ 139 int tx_len ; /* tx frame length */ 140 SMbuf *tx_mb ; /* SMT tx MBuf pointer */ 141 char *tx_data ; /* data pointer to the SMT tx Mbuf */ 142 143 int detec_count ; /* counter for out of RxD condition */ 144 u_long rx_len_error ; /* rx len FORMAC != sum of fragments */ 145} ; 146 147 148/* 149 * DEBUG structs and macros 150 */ 151 152#ifdef DEBUG 153struct os_debug { 154 int hwm_rx ; 155 int hwm_tx ; 156 int hwm_gen ; 157} ; 158#endif 159 160#ifdef DEBUG 161#ifdef DEBUG_BRD 162#define DB_P smc->debug 163#else 164#define DB_P debug 165#endif 166 167#define DB_RX(lev, fmt, ...) \ 168do { \ 169 if (DB_P.d_os.hwm_rx >= (lev)) \ 170 printf(fmt "\n", ##__VA_ARGS__); \ 171} while (0) 172#define DB_TX(lev, fmt, ...) \ 173do { \ 174 if (DB_P.d_os.hwm_tx >= (lev)) \ 175 printf(fmt "\n", ##__VA_ARGS__); \ 176} while (0) 177#define DB_GEN(lev, fmt, ...) \ 178do { \ 179 if (DB_P.d_os.hwm_gen >= (lev)) \ 180 printf(fmt "\n", ##__VA_ARGS__); \ 181} while (0) 182#else /* DEBUG */ 183#define DB_RX(lev, fmt, ...) no_printk(fmt "\n", ##__VA_ARGS__) 184#define DB_TX(lev, fmt, ...) no_printk(fmt "\n", ##__VA_ARGS__) 185#define DB_GEN(lev, fmt, ...) no_printk(fmt "\n", ##__VA_ARGS__) 186#endif /* DEBUG */ 187 188#ifndef SK_BREAK 189#define SK_BREAK() 190#endif 191 192 193/* 194 * HWM Macros 195 */ 196 197/* 198 * BEGIN_MANUAL_ENTRY(HWM_GET_TX_PHYS) 199 * u_long HWM_GET_TX_PHYS(txd) 200 * 201 * function MACRO (hardware module, hwmtm.h) 202 * This macro may be invoked by the OS-specific module to read 203 * the physical address of the specified TxD. 204 * 205 * para txd pointer to the TxD 206 * 207 * END_MANUAL_ENTRY 208 */ 209#define HWM_GET_TX_PHYS(txd) (u_long)AIX_REVERSE((txd)->txd_tbadr) 210 211/* 212 * BEGIN_MANUAL_ENTRY(HWM_GET_TX_LEN) 213 * int HWM_GET_TX_LEN(txd) 214 * 215 * function MACRO (hardware module, hwmtm.h) 216 * This macro may be invoked by the OS-specific module to read 217 * the fragment length of the specified TxD 218 * 219 * para rxd pointer to the TxD 220 * 221 * return the length of the fragment in bytes 222 * 223 * END_MANUAL_ENTRY 224 */ 225#define HWM_GET_TX_LEN(txd) ((int)AIX_REVERSE((txd)->txd_tbctrl)& RD_LENGTH) 226 227/* 228 * BEGIN_MANUAL_ENTRY(HWM_GET_TX_USED) 229 * txd *HWM_GET_TX_USED(smc,queue) 230 * 231 * function MACRO (hardware module, hwmtm.h) 232 * This macro may be invoked by the OS-specific module to get the 233 * number of used TxDs for the queue, specified by the index. 234 * 235 * para queue the number of the send queue: Can be specified by 236 * QUEUE_A0, QUEUE_S or (frame_status & QUEUE_A0) 237 * 238 * return number of used TxDs for this send queue 239 * 240 * END_MANUAL_ENTRY 241 */ 242#define HWM_GET_TX_USED(smc,queue) (int) (smc)->hw.fp.tx_q[queue].tx_used 243 244/* 245 * BEGIN_MANUAL_ENTRY(HWM_GET_CURR_TXD) 246 * txd *HWM_GET_CURR_TXD(smc,queue) 247 * 248 * function MACRO (hardware module, hwmtm.h) 249 * This macro may be invoked by the OS-specific module to get the 250 * pointer to the TxD which points to the current queue put 251 * position. 252 * 253 * para queue the number of the send queue: Can be specified by 254 * QUEUE_A0, QUEUE_S or (frame_status & QUEUE_A0) 255 * 256 * return pointer to the current TxD 257 * 258 * END_MANUAL_ENTRY 259 */ 260#define HWM_GET_CURR_TXD(smc,queue) (struct s_smt_fp_txd volatile *)\ 261 (smc)->hw.fp.tx_q[queue].tx_curr_put 262 263/* 264 * BEGIN_MANUAL_ENTRY(HWM_GET_RX_FRAG_LEN) 265 * int HWM_GET_RX_FRAG_LEN(rxd) 266 * 267 * function MACRO (hardware module, hwmtm.h) 268 * This macro may be invoked by the OS-specific module to read 269 * the fragment length of the specified RxD 270 * 271 * para rxd pointer to the RxD 272 * 273 * return the length of the fragment in bytes 274 * 275 * END_MANUAL_ENTRY 276 */ 277#define HWM_GET_RX_FRAG_LEN(rxd) ((int)AIX_REVERSE((rxd)->rxd_rbctrl)& \ 278 RD_LENGTH) 279 280/* 281 * BEGIN_MANUAL_ENTRY(HWM_GET_RX_PHYS) 282 * u_long HWM_GET_RX_PHYS(rxd) 283 * 284 * function MACRO (hardware module, hwmtm.h) 285 * This macro may be invoked by the OS-specific module to read 286 * the physical address of the specified RxD. 287 * 288 * para rxd pointer to the RxD 289 * 290 * return the RxD's physical pointer to the data fragment 291 * 292 * END_MANUAL_ENTRY 293 */ 294#define HWM_GET_RX_PHYS(rxd) (u_long)AIX_REVERSE((rxd)->rxd_rbadr) 295 296/* 297 * BEGIN_MANUAL_ENTRY(HWM_GET_RX_USED) 298 * int HWM_GET_RX_USED(smc) 299 * 300 * function MACRO (hardware module, hwmtm.h) 301 * This macro may be invoked by the OS-specific module to get 302 * the count of used RXDs in receive queue 1. 303 * 304 * return the used RXD count of receive queue 1 305 * 306 * NOTE: Remember, because of an ASIC bug at least one RXD should be unused 307 * in the descriptor ring ! 308 * 309 * END_MANUAL_ENTRY 310 */ 311#define HWM_GET_RX_USED(smc) ((int)(smc)->hw.fp.rx_q[QUEUE_R1].rx_used) 312 313/* 314 * BEGIN_MANUAL_ENTRY(HWM_GET_RX_FREE) 315 * int HWM_GET_RX_FREE(smc) 316 * 317 * function MACRO (hardware module, hwmtm.h) 318 * This macro may be invoked by the OS-specific module to get 319 * the rxd_free count of receive queue 1. 320 * 321 * return the rxd_free count of receive queue 1 322 * 323 * END_MANUAL_ENTRY 324 */ 325#define HWM_GET_RX_FREE(smc) ((int)(smc)->hw.fp.rx_q[QUEUE_R1].rx_free-1) 326 327/* 328 * BEGIN_MANUAL_ENTRY(HWM_GET_CURR_RXD) 329 * rxd *HWM_GET_CURR_RXD(smc) 330 * 331 * function MACRO (hardware module, hwmtm.h) 332 * This macro may be invoked by the OS-specific module to get the 333 * pointer to the RxD which points to the current queue put 334 * position. 335 * 336 * return pointer to the current RxD 337 * 338 * END_MANUAL_ENTRY 339 */ 340#define HWM_GET_CURR_RXD(smc) (struct s_smt_fp_rxd volatile *)\ 341 (smc)->hw.fp.rx_q[QUEUE_R1].rx_curr_put 342 343/* 344 * BEGIN_MANUAL_ENTRY(HWM_RX_CHECK) 345 * void HWM_RX_CHECK(smc,low_water) 346 * 347 * function MACRO (hardware module, hwmtm.h) 348 * This macro is invoked by the OS-specific before it left the 349 * function mac_drv_rx_complete. This macro calls mac_drv_fill_rxd 350 * if the number of used RxDs is equal or lower than the 351 * the given low water mark. 352 * 353 * para low_water low water mark of used RxD's 354 * 355 * END_MANUAL_ENTRY 356 */ 357#ifndef HWM_NO_FLOW_CTL 358#define HWM_RX_CHECK(smc,low_water) {\ 359 if ((low_water) >= (smc)->hw.fp.rx_q[QUEUE_R1].rx_used) {\ 360 mac_drv_fill_rxd(smc) ;\ 361 }\ 362} 363#else 364#define HWM_RX_CHECK(smc,low_water) mac_drv_fill_rxd(smc) 365#endif 366 367#ifndef HWM_EBASE 368#define HWM_EBASE 500 369#endif 370 371#define HWM_E0001 HWM_EBASE + 1 372#define HWM_E0001_MSG "HWM: Wrong size of s_rxd_os struct" 373#define HWM_E0002 HWM_EBASE + 2 374#define HWM_E0002_MSG "HWM: Wrong size of s_txd_os struct" 375#define HWM_E0003 HWM_EBASE + 3 376#define HWM_E0003_MSG "HWM: smt_free_mbuf() called with NULL pointer" 377#define HWM_E0004 HWM_EBASE + 4 378#define HWM_E0004_MSG "HWM: Parity error rx queue 1" 379#define HWM_E0005 HWM_EBASE + 5 380#define HWM_E0005_MSG "HWM: Encoding error rx queue 1" 381#define HWM_E0006 HWM_EBASE + 6 382#define HWM_E0006_MSG "HWM: Encoding error async tx queue" 383#define HWM_E0007 HWM_EBASE + 7 384#define HWM_E0007_MSG "HWM: Encoding error sync tx queue" 385#define HWM_E0008 HWM_EBASE + 8 386#define HWM_E0008_MSG "" 387#define HWM_E0009 HWM_EBASE + 9 388#define HWM_E0009_MSG "HWM: Out of RxD condition detected" 389#define HWM_E0010 HWM_EBASE + 10 390#define HWM_E0010_MSG "HWM: A protocol layer has tried to send a frame with an invalid frame control" 391#define HWM_E0011 HWM_EBASE + 11 392#define HWM_E0011_MSG "HWM: mac_drv_clear_tx_queue was called although the hardware wasn't stopped" 393#define HWM_E0012 HWM_EBASE + 12 394#define HWM_E0012_MSG "HWM: mac_drv_clear_rx_queue was called although the hardware wasn't stopped" 395#define HWM_E0013 HWM_EBASE + 13 396#define HWM_E0013_MSG "HWM: mac_drv_repair_descr was called although the hardware wasn't stopped" 397 398#endif