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 93 struct 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 101 struct 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 109 struct 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 153 struct 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, ...) \ 168 do { \ 169 if (DB_P.d_os.hwm_rx >= (lev)) \ 170 printf(fmt "\n", ##__VA_ARGS__); \ 171 } while (0) 172 #define DB_TX(lev, fmt, ...) \ 173 do { \ 174 if (DB_P.d_os.hwm_tx >= (lev)) \ 175 printf(fmt "\n", ##__VA_ARGS__); \ 176 } while (0) 177 #define DB_GEN(lev, fmt, ...) \ 178 do { \ 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 399