drivers/net/fddi/skfp/h/hwmtm.h

   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