drivers/net/fddi/skfp/hwmtm.c

   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  *      See the file "skfddi.c" for further information.
   8  *
   9  *      The information in this file is provided "AS IS" without warranty.
  10  *
  11  ******************************************************************************/
  12
  13 #ifndef lint
  14 static char const ID_sccs[] = "@(#)hwmtm.c      1.40 99/05/31 (C) SK" ;
  15 #endif
  16
  17 #define HWMTM
  18
  19 #ifndef FDDI
  20 #define FDDI
  21 #endif
  22
  23 #include "h/types.h"
  24 #include "h/fddi.h"
  25 #include "h/smc.h"
  26 #include "h/supern_2.h"
  27 #include "h/skfbiinc.h"
  28
  29 /*
  30         -------------------------------------------------------------
  31         DOCUMENTATION
  32         -------------------------------------------------------------
  33         BEGIN_MANUAL_ENTRY(DOCUMENTATION)
  34
  35                         T B D
  36
  37         END_MANUAL_ENTRY
  38 */
  39 /*
  40         -------------------------------------------------------------
  41         LOCAL VARIABLES:
  42         -------------------------------------------------------------
  43 */
  44 #ifdef COMMON_MB_POOL
  45 static  SMbuf *mb_start = 0 ;
  46 static  SMbuf *mb_free = 0 ;
  47 static  int mb_init = FALSE ;
  48 static  int call_count = 0 ;
  49 #endif
  50
  51 /*
  52         -------------------------------------------------------------
  53         EXTERNE VARIABLES:
  54         -------------------------------------------------------------
  55 */
  56
  57 #ifdef  DEBUG
  58 #ifndef DEBUG_BRD
  59 extern  struct smt_debug        debug ;
  60 #endif
  61 #endif
  62
  63 #ifdef  NDIS_OS2
  64 extern  u_char  offDepth ;
  65 extern  u_char  force_irq_pending ;
  66 #endif
  67
  68 /*
  69         -------------------------------------------------------------
  70         LOCAL FUNCTIONS:
  71         -------------------------------------------------------------
  72 */
  73
  74 static void queue_llc_rx(struct s_smc *smc, SMbuf *mb);
  75 static void smt_to_llc(struct s_smc *smc, SMbuf *mb);
  76 static void init_txd_ring(struct s_smc *smc);
  77 static void init_rxd_ring(struct s_smc *smc);
  78 static void queue_txd_mb(struct s_smc *smc, SMbuf *mb);
  79 static u_long init_descr_ring(struct s_smc *smc, union s_fp_descr volatile *start,
  80                               int count);
  81 static u_long repair_txd_ring(struct s_smc *smc, struct s_smt_tx_queue *queue);
  82 static u_long repair_rxd_ring(struct s_smc *smc, struct s_smt_rx_queue *queue);
  83 static SMbuf* get_llc_rx(struct s_smc *smc);
  84 static SMbuf* get_txd_mb(struct s_smc *smc);
  85 static void mac_drv_clear_txd(struct s_smc *smc);
  86
  87 /*
  88         -------------------------------------------------------------
  89         EXTERNAL FUNCTIONS:
  90         -------------------------------------------------------------
  91 */
  92 /*      The external SMT functions are listed in cmtdef.h */
  93
  94 extern void* mac_drv_get_space(struct s_smc *smc, unsigned int size);
  95 extern void* mac_drv_get_desc_mem(struct s_smc *smc, unsigned int size);
  96 extern void mac_drv_fill_rxd(struct s_smc *smc);
  97 extern void mac_drv_tx_complete(struct s_smc *smc,
  98                                 volatile struct s_smt_fp_txd *txd);
  99 extern void mac_drv_rx_complete(struct s_smc *smc,
 100                                 volatile struct s_smt_fp_rxd *rxd,
 101                                 int frag_count, int len);
 102 extern void mac_drv_requeue_rxd(struct s_smc *smc,
 103                                 volatile struct s_smt_fp_rxd *rxd,
 104                                 int frag_count);
 105 extern void mac_drv_clear_rxd(struct s_smc *smc,
 106                               volatile struct s_smt_fp_rxd *rxd, int frag_count);
 107
 108 #ifdef  USE_OS_CPY
 109 extern void hwm_cpy_rxd2mb(void);
 110 extern void hwm_cpy_txd2mb(void);
 111 #endif
 112
 113 #ifdef  ALL_RX_COMPLETE
 114 extern void mac_drv_all_receives_complete(void);
 115 #endif
 116
 117 extern u_long mac_drv_virt2phys(struct s_smc *smc, void *virt);
 118 extern u_long dma_master(struct s_smc *smc, void *virt, int len, int flag);
 119
 120 #ifdef  NDIS_OS2
 121 extern void post_proc(void);
 122 #else
 123 extern void dma_complete(struct s_smc *smc, volatile union s_fp_descr *descr,
 124                          int flag);
 125 #endif
 126
 127 extern int mac_drv_rx_init(struct s_smc *smc, int len, int fc, char *look_ahead,
 128                            int la_len);
 129
 130 /*
 131         -------------------------------------------------------------
 132         PUBLIC FUNCTIONS:
 133         -------------------------------------------------------------
 134 */
 135 void process_receive(struct s_smc *smc);
 136 void fddi_isr(struct s_smc *smc);
 137 void smt_free_mbuf(struct s_smc *smc, SMbuf *mb);
 138 void init_driver_fplus(struct s_smc *smc);
 139 void mac_drv_rx_mode(struct s_smc *smc, int mode);
 140 void init_fddi_driver(struct s_smc *smc, u_char *mac_addr);
 141 void mac_drv_clear_tx_queue(struct s_smc *smc);
 142 void mac_drv_clear_rx_queue(struct s_smc *smc);
 143 void hwm_tx_frag(struct s_smc *smc, char far *virt, u_long phys, int len,
 144                  int frame_status);
 145 void hwm_rx_frag(struct s_smc *smc, char far *virt, u_long phys, int len,
 146                  int frame_status);
 147
 148 int mac_drv_init(struct s_smc *smc);
 149 int hwm_tx_init(struct s_smc *smc, u_char fc, int frag_count, int frame_len,
 150                 int frame_status);
 151
 152 u_int mac_drv_check_space(void);
 153
 154 SMbuf* smt_get_mbuf(struct s_smc *smc);
 155
 156 #ifdef DEBUG
 157         void mac_drv_debug_lev(struct s_smc *smc, int flag, int lev);
 158 #endif
 159
 160 /*
 161         -------------------------------------------------------------
 162         MACROS:
 163         -------------------------------------------------------------
 164 */
 165 #ifndef UNUSED
 166 #ifdef  lint
 167 #define UNUSED(x)       (x) = (x)
 168 #else
 169 #define UNUSED(x)
 170 #endif
 171 #endif
 172
 173 #ifdef  USE_CAN_ADDR
 174 #define MA              smc->hw.fddi_canon_addr.a
 175 #define GROUP_ADDR_BIT  0x01
 176 #else
 177 #define MA              smc->hw.fddi_home_addr.a
 178 #define GROUP_ADDR_BIT  0x80
 179 #endif
 180
 181 #define RXD_TXD_COUNT   (HWM_ASYNC_TXD_COUNT+HWM_SYNC_TXD_COUNT+\
 182                         SMT_R1_RXD_COUNT+SMT_R2_RXD_COUNT)
 183
 184 #ifdef  MB_OUTSIDE_SMC
 185 #define EXT_VIRT_MEM    ((RXD_TXD_COUNT+1)*sizeof(struct s_smt_fp_txd) +\
 186                         MAX_MBUF*sizeof(SMbuf))
 187 #define EXT_VIRT_MEM_2  ((RXD_TXD_COUNT+1)*sizeof(struct s_smt_fp_txd))
 188 #else
 189 #define EXT_VIRT_MEM    ((RXD_TXD_COUNT+1)*sizeof(struct s_smt_fp_txd))
 190 #endif
 191
 192         /*
 193          * define critical read for 16 Bit drivers
 194          */
 195 #if     defined(NDIS_OS2) || defined(ODI2)
 196 #define CR_READ(var)    ((var) & 0xffff0000 | ((var) & 0xffff))
 197 #else
 198 #define CR_READ(var)    (__le32)(var)
 199 #endif
 200
 201 #define IMASK_SLOW      (IS_PLINT1 | IS_PLINT2 | IS_TIMINT | IS_TOKEN | \
 202                          IS_MINTR1 | IS_MINTR2 | IS_MINTR3 | IS_R1_P | \
 203                          IS_R1_C | IS_XA_C | IS_XS_C)
 204
 205 /*
 206         -------------------------------------------------------------
 207         INIT- AND SMT FUNCTIONS:
 208         -------------------------------------------------------------
 209 */
 210
 211
 212 /*
 213  *      BEGIN_MANUAL_ENTRY(mac_drv_check_space)
 214  *      u_int mac_drv_check_space()
 215  *
 216  *      function        DOWNCALL        (drvsr.c)
 217  *                      This function calculates the needed non virtual
 218  *                      memory for MBufs, RxD and TxD descriptors etc.
 219  *                      needed by the driver.
 220  *
 221  *      return          u_int   memory in bytes
 222  *
 223  *      END_MANUAL_ENTRY
 224  */
 225 u_int mac_drv_check_space(void)
 226 {
 227 #ifdef  MB_OUTSIDE_SMC
 228 #ifdef  COMMON_MB_POOL
 229         call_count++ ;
 230         if (call_count == 1) {
 231                 return EXT_VIRT_MEM;
 232         }
 233         else {
 234                 return EXT_VIRT_MEM_2;
 235         }
 236 #else
 237         return EXT_VIRT_MEM;
 238 #endif
 239 #else
 240         return 0;
 241 #endif
 242 }
 243
 244 /*
 245  *      BEGIN_MANUAL_ENTRY(mac_drv_init)
 246  *      void mac_drv_init(smc)
 247  *
 248  *      function        DOWNCALL        (drvsr.c)
 249  *                      In this function the hardware module allocates it's
 250  *                      memory.
 251  *                      The operating system dependent module should call
 252  *                      mac_drv_init once, after the adatper is detected.
 253  *      END_MANUAL_ENTRY
 254  */
 255 int mac_drv_init(struct s_smc *smc)
 256 {
 257         if (sizeof(struct s_smt_fp_rxd) % 16) {
 258                 SMT_PANIC(smc,HWM_E0001,HWM_E0001_MSG) ;
 259         }
 260         if (sizeof(struct s_smt_fp_txd) % 16) {
 261                 SMT_PANIC(smc,HWM_E0002,HWM_E0002_MSG) ;
 262         }
 263
 264         /*
 265          * get the required memory for the RxDs and TxDs
 266          */
 267         if (!(smc->os.hwm.descr_p = (union s_fp_descr volatile *)
 268                 mac_drv_get_desc_mem(smc,(u_int)
 269                 (RXD_TXD_COUNT+1)*sizeof(struct s_smt_fp_txd)))) {
 270                 return 1;       /* no space the hwm modul can't work */
 271         }
 272
 273         /*
 274          * get the memory for the SMT MBufs
 275          */
 276 #ifndef MB_OUTSIDE_SMC
 277         smc->os.hwm.mbuf_pool.mb_start=(SMbuf *)(&smc->os.hwm.mbuf_pool.mb[0]) ;
 278 #else
 279 #ifndef COMMON_MB_POOL
 280         if (!(smc->os.hwm.mbuf_pool.mb_start = (SMbuf *) mac_drv_get_space(smc,
 281                 MAX_MBUF*sizeof(SMbuf)))) {
 282                 return 1;       /* no space the hwm modul can't work */
 283         }
 284 #else
 285         if (!mb_start) {
 286                 if (!(mb_start = (SMbuf *) mac_drv_get_space(smc,
 287                         MAX_MBUF*sizeof(SMbuf)))) {
 288                         return 1;       /* no space the hwm modul can't work */
 289                 }
 290         }
 291 #endif
 292 #endif
 293         return 0;
 294 }
 295
 296 /*
 297  *      BEGIN_MANUAL_ENTRY(init_driver_fplus)
 298  *      init_driver_fplus(smc)
 299  *
 300  * Sets hardware modul specific values for the mode register 2
 301  * (e.g. the byte alignment for the received frames, the position of the
 302  *       least significant byte etc.)
 303  *      END_MANUAL_ENTRY
 304  */
 305 void init_driver_fplus(struct s_smc *smc)
 306 {
 307         smc->hw.fp.mdr2init = FM_LSB | FM_BMMODE | FM_ENNPRQ | FM_ENHSRQ | 3 ;
 308
 309 #ifdef  PCI
 310         smc->hw.fp.mdr2init |= FM_CHKPAR | FM_PARITY ;
 311 #endif
 312         smc->hw.fp.mdr3init = FM_MENRQAUNLCK | FM_MENRS ;
 313
 314 #ifdef  USE_CAN_ADDR
 315         /* enable address bit swapping */
 316         smc->hw.fp.frselreg_init = FM_ENXMTADSWAP | FM_ENRCVADSWAP ;
 317 #endif
 318 }
 319
 320 static u_long init_descr_ring(struct s_smc *smc,
 321                               union s_fp_descr volatile *start,
 322                               int count)
 323 {
 324         int i ;
 325         union s_fp_descr volatile *d1 ;
 326         union s_fp_descr volatile *d2 ;
 327         u_long  phys ;
 328
 329         DB_GEN(3, "descr ring starts at = %p", start);
 330         for (i=count-1, d1=start; i ; i--) {
 331                 d2 = d1 ;
 332                 d1++ ;          /* descr is owned by the host */
 333                 d2->r.rxd_rbctrl = cpu_to_le32(BMU_CHECK) ;
 334                 d2->r.rxd_next = &d1->r ;
 335                 phys = mac_drv_virt2phys(smc,(void *)d1) ;
 336                 d2->r.rxd_nrdadr = cpu_to_le32(phys) ;
 337         }
 338         DB_GEN(3, "descr ring ends at = %p", d1);
 339         d1->r.rxd_rbctrl = cpu_to_le32(BMU_CHECK) ;
 340         d1->r.rxd_next = &start->r ;
 341         phys = mac_drv_virt2phys(smc,(void *)start) ;
 342         d1->r.rxd_nrdadr = cpu_to_le32(phys) ;
 343
 344         for (i=count, d1=start; i ; i--) {
 345                 DRV_BUF_FLUSH(&d1->r,DDI_DMA_SYNC_FORDEV) ;
 346                 d1++;
 347         }
 348         return phys;
 349 }
 350
 351 static void init_txd_ring(struct s_smc *smc)
 352 {
 353         struct s_smt_fp_txd volatile *ds ;
 354         struct s_smt_tx_queue *queue ;
 355         u_long  phys ;
 356
 357         /*
 358          * initialize the transmit descriptors
 359          */
 360         ds = (struct s_smt_fp_txd volatile *) ((char *)smc->os.hwm.descr_p +
 361                 SMT_R1_RXD_COUNT*sizeof(struct s_smt_fp_rxd)) ;
 362         queue = smc->hw.fp.tx[QUEUE_A0] ;
 363         DB_GEN(3, "Init async TxD ring, %d TxDs", HWM_ASYNC_TXD_COUNT);
 364         (void)init_descr_ring(smc,(union s_fp_descr volatile *)ds,
 365                 HWM_ASYNC_TXD_COUNT) ;
 366         phys = le32_to_cpu(ds->txd_ntdadr) ;
 367         ds++ ;
 368         queue->tx_curr_put = queue->tx_curr_get = ds ;
 369         ds-- ;
 370         queue->tx_free = HWM_ASYNC_TXD_COUNT ;
 371         queue->tx_used = 0 ;
 372         outpd(ADDR(B5_XA_DA),phys) ;
 373
 374         ds = (struct s_smt_fp_txd volatile *) ((char *)ds +
 375                 HWM_ASYNC_TXD_COUNT*sizeof(struct s_smt_fp_txd)) ;
 376         queue = smc->hw.fp.tx[QUEUE_S] ;
 377         DB_GEN(3, "Init sync TxD ring, %d TxDs", HWM_SYNC_TXD_COUNT);
 378         (void)init_descr_ring(smc,(union s_fp_descr volatile *)ds,
 379                 HWM_SYNC_TXD_COUNT) ;
 380         phys = le32_to_cpu(ds->txd_ntdadr) ;
 381         ds++ ;
 382         queue->tx_curr_put = queue->tx_curr_get = ds ;
 383         queue->tx_free = HWM_SYNC_TXD_COUNT ;
 384         queue->tx_used = 0 ;
 385         outpd(ADDR(B5_XS_DA),phys) ;
 386 }
 387
 388 static void init_rxd_ring(struct s_smc *smc)
 389 {
 390         struct s_smt_fp_rxd volatile *ds ;
 391         struct s_smt_rx_queue *queue ;
 392         u_long  phys ;
 393
 394         /*
 395          * initialize the receive descriptors
 396          */
 397         ds = (struct s_smt_fp_rxd volatile *) smc->os.hwm.descr_p ;
 398         queue = smc->hw.fp.rx[QUEUE_R1] ;
 399         DB_GEN(3, "Init RxD ring, %d RxDs", SMT_R1_RXD_COUNT);
 400         (void)init_descr_ring(smc,(union s_fp_descr volatile *)ds,
 401                 SMT_R1_RXD_COUNT) ;
 402         phys = le32_to_cpu(ds->rxd_nrdadr) ;
 403         ds++ ;
 404         queue->rx_curr_put = queue->rx_curr_get = ds ;
 405         queue->rx_free = SMT_R1_RXD_COUNT ;
 406         queue->rx_used = 0 ;
 407         outpd(ADDR(B4_R1_DA),phys) ;
 408 }
 409
 410 /*
 411  *      BEGIN_MANUAL_ENTRY(init_fddi_driver)
 412  *      void init_fddi_driver(smc,mac_addr)
 413  *
 414  * initializes the driver and it's variables
 415  *
 416  *      END_MANUAL_ENTRY
 417  */
 418 void init_fddi_driver(struct s_smc *smc, u_char *mac_addr)
 419 {
 420         SMbuf   *mb ;
 421         int     i ;
 422
 423         init_board(smc,mac_addr) ;
 424         (void)init_fplus(smc) ;
 425
 426         /*
 427          * initialize the SMbufs for the SMT
 428          */
 429 #ifndef COMMON_MB_POOL
 430         mb = smc->os.hwm.mbuf_pool.mb_start ;
 431         smc->os.hwm.mbuf_pool.mb_free = (SMbuf *)NULL ;
 432         for (i = 0; i < MAX_MBUF; i++) {
 433                 mb->sm_use_count = 1 ;
 434                 smt_free_mbuf(smc,mb)   ;
 435                 mb++ ;
 436         }
 437 #else
 438         mb = mb_start ;
 439         if (!mb_init) {
 440                 mb_free = 0 ;
 441                 for (i = 0; i < MAX_MBUF; i++) {
 442                         mb->sm_use_count = 1 ;
 443                         smt_free_mbuf(smc,mb)   ;
 444                         mb++ ;
 445                 }
 446                 mb_init = TRUE ;
 447         }
 448 #endif
 449
 450         /*
 451          * initialize the other variables
 452          */
 453         smc->os.hwm.llc_rx_pipe = smc->os.hwm.llc_rx_tail = (SMbuf *)NULL ;
 454         smc->os.hwm.txd_tx_pipe = smc->os.hwm.txd_tx_tail = NULL ;
 455         smc->os.hwm.pass_SMT = smc->os.hwm.pass_NSA = smc->os.hwm.pass_DB = 0 ;
 456         smc->os.hwm.pass_llc_promisc = TRUE ;
 457         smc->os.hwm.queued_rx_frames = smc->os.hwm.queued_txd_mb = 0 ;
 458         smc->os.hwm.detec_count = 0 ;
 459         smc->os.hwm.rx_break = 0 ;
 460         smc->os.hwm.rx_len_error = 0 ;
 461         smc->os.hwm.isr_flag = FALSE ;
 462
 463         /*
 464          * make sure that the start pointer is 16 byte aligned
 465          */
 466         i = 16 - ((long)smc->os.hwm.descr_p & 0xf) ;
 467         if (i != 16) {
 468                 DB_GEN(3, "i = %d", i);
 469                 smc->os.hwm.descr_p = (union s_fp_descr volatile *)
 470                         ((char *)smc->os.hwm.descr_p+i) ;
 471         }
 472         DB_GEN(3, "pt to descr area = %p", smc->os.hwm.descr_p);
 473
 474         init_txd_ring(smc) ;
 475         init_rxd_ring(smc) ;
 476         mac_drv_fill_rxd(smc) ;
 477
 478         init_plc(smc) ;
 479 }
 480
 481
 482 SMbuf *smt_get_mbuf(struct s_smc *smc)
 483 {
 484         register SMbuf  *mb ;
 485
 486 #ifndef COMMON_MB_POOL
 487         mb = smc->os.hwm.mbuf_pool.mb_free ;
 488 #else
 489         mb = mb_free ;
 490 #endif
 491         if (mb) {
 492 #ifndef COMMON_MB_POOL
 493                 smc->os.hwm.mbuf_pool.mb_free = mb->sm_next ;
 494 #else
 495                 mb_free = mb->sm_next ;
 496 #endif
 497                 mb->sm_off = 8 ;
 498                 mb->sm_use_count = 1 ;
 499         }
 500         DB_GEN(3, "get SMbuf: mb = %p", mb);
 501         return mb;      /* May be NULL */
 502 }
 503
 504 void smt_free_mbuf(struct s_smc *smc, SMbuf *mb)
 505 {
 506
 507         if (mb) {
 508                 mb->sm_use_count-- ;
 509                 DB_GEN(3, "free_mbuf: sm_use_count = %d", mb->sm_use_count);
 510                 /*
 511                  * If the use_count is != zero the MBuf is queued
 512                  * more than once and must not queued into the
 513                  * free MBuf queue
 514                  */
 515                 if (!mb->sm_use_count) {
 516                         DB_GEN(3, "free SMbuf: mb = %p", mb);
 517 #ifndef COMMON_MB_POOL
 518                         mb->sm_next = smc->os.hwm.mbuf_pool.mb_free ;
 519                         smc->os.hwm.mbuf_pool.mb_free = mb ;
 520 #else
 521                         mb->sm_next = mb_free ;
 522                         mb_free = mb ;
 523 #endif
 524                 }
 525         }
 526         else
 527                 SMT_PANIC(smc,HWM_E0003,HWM_E0003_MSG) ;
 528 }
 529
 530
 531 /*
 532  *      BEGIN_MANUAL_ENTRY(mac_drv_repair_descr)
 533  *      void mac_drv_repair_descr(smc)
 534  *
 535  * function     called from SMT (HWM / hwmtm.c)
 536  *              The BMU is idle when this function is called.
 537  *              Mac_drv_repair_descr sets up the physical address
 538  *              for all receive and transmit queues where the BMU
 539  *              should continue.
 540  *              It may be that the BMU was reseted during a fragmented
 541  *              transfer. In this case there are some fragments which will
 542  *              never completed by the BMU. The OWN bit of this fragments
 543  *              must be switched to be owned by the host.
 544  *
 545  *              Give a start command to the receive BMU.
 546  *              Start the transmit BMUs if transmit frames pending.
 547  *
 548  *      END_MANUAL_ENTRY
 549  */
 550 void mac_drv_repair_descr(struct s_smc *smc)
 551 {
 552         u_long  phys ;
 553
 554         if (smc->hw.hw_state != STOPPED) {
 555                 SK_BREAK() ;
 556                 SMT_PANIC(smc,HWM_E0013,HWM_E0013_MSG) ;
 557                 return ;
 558         }
 559
 560         /*
 561          * repair tx queues: don't start
 562          */
 563         phys = repair_txd_ring(smc,smc->hw.fp.tx[QUEUE_A0]) ;
 564         outpd(ADDR(B5_XA_DA),phys) ;
 565         if (smc->hw.fp.tx_q[QUEUE_A0].tx_used) {
 566                 outpd(ADDR(B0_XA_CSR),CSR_START) ;
 567         }
 568         phys = repair_txd_ring(smc,smc->hw.fp.tx[QUEUE_S]) ;
 569         outpd(ADDR(B5_XS_DA),phys) ;
 570         if (smc->hw.fp.tx_q[QUEUE_S].tx_used) {
 571                 outpd(ADDR(B0_XS_CSR),CSR_START) ;
 572         }
 573
 574         /*
 575          * repair rx queues
 576          */
 577         phys = repair_rxd_ring(smc,smc->hw.fp.rx[QUEUE_R1]) ;
 578         outpd(ADDR(B4_R1_DA),phys) ;
 579         outpd(ADDR(B0_R1_CSR),CSR_START) ;
 580 }
 581
 582 static u_long repair_txd_ring(struct s_smc *smc, struct s_smt_tx_queue *queue)
 583 {
 584         int i ;
 585         int tx_used ;
 586         u_long phys ;
 587         u_long tbctrl ;
 588         struct s_smt_fp_txd volatile *t ;
 589
 590         SK_UNUSED(smc) ;
 591
 592         t = queue->tx_curr_get ;
 593         tx_used = queue->tx_used ;
 594         for (i = tx_used+queue->tx_free-1 ; i ; i-- ) {
 595                 t = t->txd_next ;
 596         }
 597         phys = le32_to_cpu(t->txd_ntdadr) ;
 598
 599         t = queue->tx_curr_get ;
 600         while (tx_used) {
 601                 DRV_BUF_FLUSH(t,DDI_DMA_SYNC_FORCPU) ;
 602                 tbctrl = le32_to_cpu(t->txd_tbctrl) ;
 603
 604                 if (tbctrl & BMU_OWN) {
 605                         if (tbctrl & BMU_STF) {
 606                                 break ;         /* exit the loop */
 607                         }
 608                         else {
 609                                 /*
 610                                  * repair the descriptor
 611                                  */
 612                                 t->txd_tbctrl &= ~cpu_to_le32(BMU_OWN) ;
 613                         }
 614                 }
 615                 phys = le32_to_cpu(t->txd_ntdadr) ;
 616                 DRV_BUF_FLUSH(t,DDI_DMA_SYNC_FORDEV) ;
 617                 t = t->txd_next ;
 618                 tx_used-- ;
 619         }
 620         return phys;
 621 }
 622
 623 /*
 624  * Repairs the receive descriptor ring and returns the physical address
 625  * where the BMU should continue working.
 626  *
 627  *      o The physical address where the BMU was stopped has to be
 628  *        determined. This is the next RxD after rx_curr_get with an OWN
 629  *        bit set.
 630  *      o The BMU should start working at beginning of the next frame.
 631  *        RxDs with an OWN bit set but with a reset STF bit should be
 632  *        skipped and owned by the driver (OWN = 0).
 633  */
 634 static u_long repair_rxd_ring(struct s_smc *smc, struct s_smt_rx_queue *queue)
 635 {
 636         int i ;
 637         int rx_used ;
 638         u_long phys ;
 639         u_long rbctrl ;
 640         struct s_smt_fp_rxd volatile *r ;
 641
 642         SK_UNUSED(smc) ;
 643
 644         r = queue->rx_curr_get ;
 645         rx_used = queue->rx_used ;
 646         for (i = SMT_R1_RXD_COUNT-1 ; i ; i-- ) {
 647                 r = r->rxd_next ;
 648         }
 649         phys = le32_to_cpu(r->rxd_nrdadr) ;
 650
 651         r = queue->rx_curr_get ;
 652         while (rx_used) {
 653                 DRV_BUF_FLUSH(r,DDI_DMA_SYNC_FORCPU) ;
 654                 rbctrl = le32_to_cpu(r->rxd_rbctrl) ;
 655
 656                 if (rbctrl & BMU_OWN) {
 657                         if (rbctrl & BMU_STF) {
 658                                 break ;         /* exit the loop */
 659                         }
 660                         else {
 661                                 /*
 662                                  * repair the descriptor
 663                                  */
 664                                 r->rxd_rbctrl &= ~cpu_to_le32(BMU_OWN) ;
 665                         }
 666                 }
 667                 phys = le32_to_cpu(r->rxd_nrdadr) ;
 668                 DRV_BUF_FLUSH(r,DDI_DMA_SYNC_FORDEV) ;
 669                 r = r->rxd_next ;
 670                 rx_used-- ;
 671         }
 672         return phys;
 673 }
 674
 675
 676 /*
 677         -------------------------------------------------------------
 678         INTERRUPT SERVICE ROUTINE:
 679         -------------------------------------------------------------
 680 */
 681
 682 /*
 683  *      BEGIN_MANUAL_ENTRY(fddi_isr)
 684  *      void fddi_isr(smc)
 685  *
 686  * function     DOWNCALL        (drvsr.c)
 687  *              interrupt service routine, handles the interrupt requests
 688  *              generated by the FDDI adapter.
 689  *
 690  * NOTE:        The operating system dependent module must guarantee that the
 691  *              interrupts of the adapter are disabled when it calls fddi_isr.
 692  *
 693  *      About the USE_BREAK_ISR mechanismn:
 694  *
 695  *      The main requirement of this mechanismn is to force an timer IRQ when
 696  *      leaving process_receive() with leave_isr set. process_receive() may
 697  *      be called at any time from anywhere!
 698  *      To be sure we don't miss such event we set 'force_irq' per default.
 699  *      We have to force and Timer IRQ if 'smc->os.hwm.leave_isr' AND
 700  *      'force_irq' are set. 'force_irq' may be reset if a receive complete
 701  *      IRQ is pending.
 702  *
 703  *      END_MANUAL_ENTRY
 704  */
 705 void fddi_isr(struct s_smc *smc)
 706 {
 707         u_long          is ;            /* ISR source */
 708         u_short         stu, stl ;
 709         SMbuf           *mb ;
 710
 711 #ifdef  USE_BREAK_ISR
 712         int     force_irq ;
 713 #endif
 714
 715 #ifdef  ODI2
 716         if (smc->os.hwm.rx_break) {
 717                 mac_drv_fill_rxd(smc) ;
 718                 if (smc->hw.fp.rx_q[QUEUE_R1].rx_used > 0) {
 719                         smc->os.hwm.rx_break = 0 ;
 720                         process_receive(smc) ;
 721                 }
 722                 else {
 723                         smc->os.hwm.detec_count = 0 ;
 724                         smt_force_irq(smc) ;
 725                 }
 726         }
 727 #endif
 728         smc->os.hwm.isr_flag = TRUE ;
 729
 730 #ifdef  USE_BREAK_ISR
 731         force_irq = TRUE ;
 732         if (smc->os.hwm.leave_isr) {
 733                 smc->os.hwm.leave_isr = FALSE ;
 734                 process_receive(smc) ;
 735         }
 736 #endif
 737
 738         while ((is = GET_ISR() & ISR_MASK)) {
 739                 NDD_TRACE("CH0B",is,0,0) ;
 740                 DB_GEN(7, "ISA = 0x%lx", is);
 741
 742                 if (is & IMASK_SLOW) {
 743                         NDD_TRACE("CH1b",is,0,0) ;
 744                         if (is & IS_PLINT1) {   /* PLC1 */
 745                                 plc1_irq(smc) ;
 746                         }
 747                         if (is & IS_PLINT2) {   /* PLC2 */
 748                                 plc2_irq(smc) ;
 749                         }
 750                         if (is & IS_MINTR1) {   /* FORMAC+ STU1(U/L) */
 751                                 stu = inpw(FM_A(FM_ST1U)) ;
 752                                 stl = inpw(FM_A(FM_ST1L)) ;
 753                                 DB_GEN(6, "Slow transmit complete");
 754                                 mac1_irq(smc,stu,stl) ;
 755                         }
 756                         if (is & IS_MINTR2) {   /* FORMAC+ STU2(U/L) */
 757                                 stu= inpw(FM_A(FM_ST2U)) ;
 758                                 stl= inpw(FM_A(FM_ST2L)) ;
 759                                 DB_GEN(6, "Slow receive complete");
 760                                 DB_GEN(7, "stl = %x : stu = %x", stl, stu);
 761                                 mac2_irq(smc,stu,stl) ;
 762                         }
 763                         if (is & IS_MINTR3) {   /* FORMAC+ STU3(U/L) */
 764                                 stu= inpw(FM_A(FM_ST3U)) ;
 765                                 stl= inpw(FM_A(FM_ST3L)) ;
 766                                 DB_GEN(6, "FORMAC Mode Register 3");
 767                                 mac3_irq(smc,stu,stl) ;
 768                         }
 769                         if (is & IS_TIMINT) {   /* Timer 82C54-2 */
 770                                 timer_irq(smc) ;
 771 #ifdef  NDIS_OS2
 772                                 force_irq_pending = 0 ;
 773 #endif
 774                                 /*
 775                                  * out of RxD detection
 776                                  */
 777                                 if (++smc->os.hwm.detec_count > 4) {
 778                                         /*
 779                                          * check out of RxD condition
 780                                          */
 781                                          process_receive(smc) ;
 782                                 }
 783                         }
 784                         if (is & IS_TOKEN) {    /* Restricted Token Monitor */
 785                                 rtm_irq(smc) ;
 786                         }
 787                         if (is & IS_R1_P) {     /* Parity error rx queue 1 */
 788                                 /* clear IRQ */
 789                                 outpd(ADDR(B4_R1_CSR),CSR_IRQ_CL_P) ;
 790                                 SMT_PANIC(smc,HWM_E0004,HWM_E0004_MSG) ;
 791                         }
 792                         if (is & IS_R1_C) {     /* Encoding error rx queue 1 */
 793                                 /* clear IRQ */
 794                                 outpd(ADDR(B4_R1_CSR),CSR_IRQ_CL_C) ;
 795                                 SMT_PANIC(smc,HWM_E0005,HWM_E0005_MSG) ;
 796                         }
 797                         if (is & IS_XA_C) {     /* Encoding error async tx q */
 798                                 /* clear IRQ */
 799                                 outpd(ADDR(B5_XA_CSR),CSR_IRQ_CL_C) ;
 800                                 SMT_PANIC(smc,HWM_E0006,HWM_E0006_MSG) ;
 801                         }
 802                         if (is & IS_XS_C) {     /* Encoding error sync tx q */
 803                                 /* clear IRQ */
 804                                 outpd(ADDR(B5_XS_CSR),CSR_IRQ_CL_C) ;
 805                                 SMT_PANIC(smc,HWM_E0007,HWM_E0007_MSG) ;
 806                         }
 807                 }
 808
 809                 /*
 810                  *      Fast Tx complete Async/Sync Queue (BMU service)
 811                  */
 812                 if (is & (IS_XS_F|IS_XA_F)) {
 813                         DB_GEN(6, "Fast tx complete queue");
 814                         /*
 815                          * clear IRQ, Note: no IRQ is lost, because
 816                          *      we always service both queues
 817                          */
 818                         outpd(ADDR(B5_XS_CSR),CSR_IRQ_CL_F) ;
 819                         outpd(ADDR(B5_XA_CSR),CSR_IRQ_CL_F) ;
 820                         mac_drv_clear_txd(smc) ;
 821                         llc_restart_tx(smc) ;
 822                 }
 823
 824                 /*
 825                  *      Fast Rx Complete (BMU service)
 826                  */
 827                 if (is & IS_R1_F) {
 828                         DB_GEN(6, "Fast receive complete");
 829                         /* clear IRQ */
 830 #ifndef USE_BREAK_ISR
 831                         outpd(ADDR(B4_R1_CSR),CSR_IRQ_CL_F) ;
 832                         process_receive(smc) ;
 833 #else
 834                         process_receive(smc) ;
 835                         if (smc->os.hwm.leave_isr) {
 836                                 force_irq = FALSE ;
 837                         } else {
 838                                 outpd(ADDR(B4_R1_CSR),CSR_IRQ_CL_F) ;
 839                                 process_receive(smc) ;
 840                         }
 841 #endif
 842                 }
 843
 844 #ifndef NDIS_OS2
 845                 while ((mb = get_llc_rx(smc))) {
 846                         smt_to_llc(smc,mb) ;
 847                 }
 848 #else
 849                 if (offDepth)
 850                         post_proc() ;
 851
 852                 while (!offDepth && (mb = get_llc_rx(smc))) {
 853                         smt_to_llc(smc,mb) ;
 854                 }
 855
 856                 if (!offDepth && smc->os.hwm.rx_break) {
 857                         process_receive(smc) ;
 858                 }
 859 #endif
 860                 if (smc->q.ev_get != smc->q.ev_put) {
 861                         NDD_TRACE("CH2a",0,0,0) ;
 862                         ev_dispatcher(smc) ;
 863                 }
 864 #ifdef  NDIS_OS2
 865                 post_proc() ;
 866                 if (offDepth) {         /* leave fddi_isr because */
 867                         break ;         /* indications not allowed */
 868                 }
 869 #endif
 870 #ifdef  USE_BREAK_ISR
 871                 if (smc->os.hwm.leave_isr) {
 872                         break ;         /* leave fddi_isr */
 873                 }
 874 #endif
 875
 876                 /* NOTE: when the isr is left, no rx is pending */
 877         }       /* end of interrupt source polling loop */
 878
 879 #ifdef  USE_BREAK_ISR
 880         if (smc->os.hwm.leave_isr && force_irq) {
 881                 smt_force_irq(smc) ;
 882         }
 883 #endif
 884         smc->os.hwm.isr_flag = FALSE ;
 885         NDD_TRACE("CH0E",0,0,0) ;
 886 }
 887
 888
 889 /*
 890         -------------------------------------------------------------
 891         RECEIVE FUNCTIONS:
 892         -------------------------------------------------------------
 893 */
 894
 895 #ifndef NDIS_OS2
 896 /*
 897  *      BEGIN_MANUAL_ENTRY(mac_drv_rx_mode)
 898  *      void mac_drv_rx_mode(smc,mode)
 899  *
 900  * function     DOWNCALL        (fplus.c)
 901  *              Corresponding to the parameter mode, the operating system
 902  *              dependent module can activate several receive modes.
 903  *
 904  * para mode    = 1:    RX_ENABLE_ALLMULTI      enable all multicasts
 905  *              = 2:    RX_DISABLE_ALLMULTI     disable "enable all multicasts"
 906  *              = 3:    RX_ENABLE_PROMISC       enable promiscuous
 907  *              = 4:    RX_DISABLE_PROMISC      disable promiscuous
 908  *              = 5:    RX_ENABLE_NSA           enable rec. of all NSA frames
 909  *                      (disabled after 'driver reset' & 'set station address')
 910  *              = 6:    RX_DISABLE_NSA          disable rec. of all NSA frames
 911  *
 912  *              = 21:   RX_ENABLE_PASS_SMT      ( see description )
 913  *              = 22:   RX_DISABLE_PASS_SMT     (  "       "      )
 914  *              = 23:   RX_ENABLE_PASS_NSA      (  "       "      )
 915  *              = 24:   RX_DISABLE_PASS_NSA     (  "       "      )
 916  *              = 25:   RX_ENABLE_PASS_DB       (  "       "      )
 917  *              = 26:   RX_DISABLE_PASS_DB      (  "       "      )
 918  *              = 27:   RX_DISABLE_PASS_ALL     (  "       "      )
 919  *              = 28:   RX_DISABLE_LLC_PROMISC  (  "       "      )
 920  *              = 29:   RX_ENABLE_LLC_PROMISC   (  "       "      )
 921  *
 922  *
 923  *              RX_ENABLE_PASS_SMT / RX_DISABLE_PASS_SMT
 924  *
 925  *              If the operating system dependent module activates the
 926  *              mode RX_ENABLE_PASS_SMT, the hardware module
 927  *              duplicates all SMT frames with the frame control
 928  *              FC_SMT_INFO and passes them to the LLC receive channel
 929  *              by calling mac_drv_rx_init.
 930  *              The SMT Frames which are sent by the local SMT and the NSA
 931  *              frames whose A- and C-Indicator is not set are also duplicated
 932  *              and passed.
 933  *              The receive mode RX_DISABLE_PASS_SMT disables the passing
 934  *              of SMT frames.
 935  *
 936  *              RX_ENABLE_PASS_NSA / RX_DISABLE_PASS_NSA
 937  *
 938  *              If the operating system dependent module activates the
 939  *              mode RX_ENABLE_PASS_NSA, the hardware module
 940  *              duplicates all NSA frames with frame control FC_SMT_NSA
 941  *              and a set A-Indicator and passed them to the LLC
 942  *              receive channel by calling mac_drv_rx_init.
 943  *              All NSA Frames which are sent by the local SMT
 944  *              are also duplicated and passed.
 945  *              The receive mode RX_DISABLE_PASS_NSA disables the passing
 946  *              of NSA frames with the A- or C-Indicator set.
 947  *
 948  * NOTE:        For fear that the hardware module receives NSA frames with
 949  *              a reset A-Indicator, the operating system dependent module
 950  *              has to call mac_drv_rx_mode with the mode RX_ENABLE_NSA
 951  *              before activate the RX_ENABLE_PASS_NSA mode and after every
 952  *              'driver reset' and 'set station address'.
 953  *
 954  *              RX_ENABLE_PASS_DB / RX_DISABLE_PASS_DB
 955  *
 956  *              If the operating system dependent module activates the
 957  *              mode RX_ENABLE_PASS_DB, direct BEACON frames
 958  *              (FC_BEACON frame control) are passed to the LLC receive
 959  *              channel by mac_drv_rx_init.
 960  *              The receive mode RX_DISABLE_PASS_DB disables the passing
 961  *              of direct BEACON frames.
 962  *
 963  *              RX_DISABLE_PASS_ALL
 964  *
 965  *              Disables all special receives modes. It is equal to
 966  *              call mac_drv_set_rx_mode successively with the
 967  *              parameters RX_DISABLE_NSA, RX_DISABLE_PASS_SMT,
 968  *              RX_DISABLE_PASS_NSA and RX_DISABLE_PASS_DB.
 969  *
 970  *              RX_ENABLE_LLC_PROMISC
 971  *
 972  *              (default) all received LLC frames and all SMT/NSA/DBEACON
 973  *              frames depending on the attitude of the flags
 974  *              PASS_SMT/PASS_NSA/PASS_DBEACON will be delivered to the
 975  *              LLC layer
 976  *
 977  *              RX_DISABLE_LLC_PROMISC
 978  *
 979  *              all received SMT/NSA/DBEACON frames depending on the
 980  *              attitude of the flags PASS_SMT/PASS_NSA/PASS_DBEACON
 981  *              will be delivered to the LLC layer.
 982  *              all received LLC frames with a directed address, Multicast
 983  *              or Broadcast address will be delivered to the LLC
 984  *              layer too.
 985  *
 986  *      END_MANUAL_ENTRY
 987  */
 988 void mac_drv_rx_mode(struct s_smc *smc, int mode)
 989 {
 990         switch(mode) {
 991         case RX_ENABLE_PASS_SMT:
 992                 smc->os.hwm.pass_SMT = TRUE ;
 993                 break ;
 994         case RX_DISABLE_PASS_SMT:
 995                 smc->os.hwm.pass_SMT = FALSE ;
 996                 break ;
 997         case RX_ENABLE_PASS_NSA:
 998                 smc->os.hwm.pass_NSA = TRUE ;
 999                 break ;
1000         case RX_DISABLE_PASS_NSA:
1001                 smc->os.hwm.pass_NSA = FALSE ;
1002                 break ;
1003         case RX_ENABLE_PASS_DB:
1004                 smc->os.hwm.pass_DB = TRUE ;
1005                 break ;
1006         case RX_DISABLE_PASS_DB:
1007                 smc->os.hwm.pass_DB = FALSE ;
1008                 break ;
1009         case RX_DISABLE_PASS_ALL:
1010                 smc->os.hwm.pass_SMT = smc->os.hwm.pass_NSA = FALSE ;
1011                 smc->os.hwm.pass_DB = FALSE ;
1012                 smc->os.hwm.pass_llc_promisc = TRUE ;
1013                 mac_set_rx_mode(smc,RX_DISABLE_NSA) ;
1014                 break ;
1015         case RX_DISABLE_LLC_PROMISC:
1016                 smc->os.hwm.pass_llc_promisc = FALSE ;
1017                 break ;
1018         case RX_ENABLE_LLC_PROMISC:
1019                 smc->os.hwm.pass_llc_promisc = TRUE ;
1020                 break ;
1021         case RX_ENABLE_ALLMULTI:
1022         case RX_DISABLE_ALLMULTI:
1023         case RX_ENABLE_PROMISC:
1024         case RX_DISABLE_PROMISC:
1025         case RX_ENABLE_NSA:
1026         case RX_DISABLE_NSA:
1027         default:
1028                 mac_set_rx_mode(smc,mode) ;
1029                 break ;
1030         }
1031 }
1032 #endif  /* ifndef NDIS_OS2 */
1033
1034 /*
1035  * process receive queue
1036  */
1037 void process_receive(struct s_smc *smc)
1038 {
1039         int i ;
1040         int n ;
1041         int frag_count ;                /* number of RxDs of the curr rx buf */
1042         int used_frags ;                /* number of RxDs of the curr frame */
1043         struct s_smt_rx_queue *queue ;  /* points to the queue ctl struct */
1044         struct s_smt_fp_rxd volatile *r ;       /* rxd pointer */
1045         struct s_smt_fp_rxd volatile *rxd ;     /* first rxd of rx frame */
1046         u_long rbctrl ;                 /* receive buffer control word */
1047         u_long rfsw ;                   /* receive frame status word */
1048         u_short rx_used ;
1049         u_char far *virt ;
1050         char far *data ;
1051         SMbuf *mb ;
1052         u_char fc ;                     /* Frame control */
1053         int len ;                       /* Frame length */
1054
1055         smc->os.hwm.detec_count = 0 ;
1056         queue = smc->hw.fp.rx[QUEUE_R1] ;
1057         NDD_TRACE("RHxB",0,0,0) ;
1058         for ( ; ; ) {
1059                 r = queue->rx_curr_get ;
1060                 rx_used = queue->rx_used ;
1061                 frag_count = 0 ;
1062
1063 #ifdef  USE_BREAK_ISR
1064                 if (smc->os.hwm.leave_isr) {
1065                         goto rx_end ;
1066                 }
1067 #endif
1068 #ifdef  NDIS_OS2
1069                 if (offDepth) {
1070                         smc->os.hwm.rx_break = 1 ;
1071                         goto rx_end ;
1072                 }
1073                 smc->os.hwm.rx_break = 0 ;
1074 #endif
1075 #ifdef  ODI2
1076                 if (smc->os.hwm.rx_break) {
1077                         goto rx_end ;
1078                 }
1079 #endif
1080                 n = 0 ;
1081                 do {
1082                         DB_RX(5, "Check RxD %p for OWN and EOF", r);
1083                         DRV_BUF_FLUSH(r,DDI_DMA_SYNC_FORCPU) ;
1084                         rbctrl = le32_to_cpu(CR_READ(r->rxd_rbctrl));
1085
1086                         if (rbctrl & BMU_OWN) {
1087                                 NDD_TRACE("RHxE",r,rfsw,rbctrl) ;
1088                                 DB_RX(4, "End of RxDs");
1089                                 goto rx_end ;
1090                         }
1091                         /*
1092                          * out of RxD detection
1093                          */
1094                         if (!rx_used) {
1095                                 SK_BREAK() ;
1096                                 SMT_PANIC(smc,HWM_E0009,HWM_E0009_MSG) ;
1097                                 /* Either we don't have an RxD or all
1098                                  * RxDs are filled. Therefore it's allowed
1099                                  * for to set the STOPPED flag */
1100                                 smc->hw.hw_state = STOPPED ;
1101                                 mac_drv_clear_rx_queue(smc) ;
1102                                 smc->hw.hw_state = STARTED ;
1103                                 mac_drv_fill_rxd(smc) ;
1104                                 smc->os.hwm.detec_count = 0 ;
1105                                 goto rx_end ;
1106                         }
1107                         rfsw = le32_to_cpu(r->rxd_rfsw) ;
1108                         if ((rbctrl & BMU_STF) != ((rbctrl & BMU_ST_BUF) <<5)) {
1109                                 /*
1110                                  * The BMU_STF bit is deleted, 1 frame is
1111                                  * placed into more than 1 rx buffer
1112                                  *
1113                                  * skip frame by setting the rx len to 0
1114                                  *
1115                                  * if fragment count == 0
1116                                  *      The missing STF bit belongs to the
1117                                  *      current frame, search for the
1118                                  *      EOF bit to complete the frame
1119                                  * else
1120                                  *      the fragment belongs to the next frame,
1121                                  *      exit the loop and process the frame
1122                                  */
1123                                 SK_BREAK() ;
1124                                 rfsw = 0 ;
1125                                 if (frag_count) {
1126                                         break ;
1127                                 }
1128                         }
1129                         n += rbctrl & 0xffff ;
1130                         r = r->rxd_next ;
1131                         frag_count++ ;
1132                         rx_used-- ;
1133                 } while (!(rbctrl & BMU_EOF)) ;
1134                 used_frags = frag_count ;
1135                 DB_RX(5, "EOF set in RxD, used_frags = %d", used_frags);
1136
1137                 /* may be next 2 DRV_BUF_FLUSH() can be skipped, because */
1138                 /* BMU_ST_BUF will not be changed by the ASIC */
1139                 DRV_BUF_FLUSH(r,DDI_DMA_SYNC_FORCPU) ;
1140                 while (rx_used && !(r->rxd_rbctrl & cpu_to_le32(BMU_ST_BUF))) {
1141                         DB_RX(5, "Check STF bit in %p", r);
1142                         r = r->rxd_next ;
1143                         DRV_BUF_FLUSH(r,DDI_DMA_SYNC_FORCPU) ;
1144                         frag_count++ ;
1145                         rx_used-- ;
1146                 }
1147                 DB_RX(5, "STF bit found");
1148
1149                 /*
1150                  * The received frame is finished for the process receive
1151                  */
1152                 rxd = queue->rx_curr_get ;
1153                 queue->rx_curr_get = r ;
1154                 queue->rx_free += frag_count ;
1155                 queue->rx_used = rx_used ;
1156
1157                 /*
1158                  * ASIC Errata no. 7 (STF - Bit Bug)
1159                  */
1160                 rxd->rxd_rbctrl &= cpu_to_le32(~BMU_STF) ;
1161
1162                 for (r=rxd, i=frag_count ; i ; r=r->rxd_next, i--){
1163                         DB_RX(5, "dma_complete for RxD %p", r);
1164                         dma_complete(smc,(union s_fp_descr volatile *)r,DMA_WR);
1165                 }
1166                 smc->hw.fp.err_stats.err_valid++ ;
1167                 smc->mib.m[MAC0].fddiMACCopied_Ct++ ;
1168
1169                 /* the length of the data including the FC */
1170                 len = (rfsw & RD_LENGTH) - 4 ;
1171
1172                 DB_RX(4, "frame length = %d", len);
1173                 /*
1174                  * check the frame_length and all error flags
1175                  */
1176                 if (rfsw & (RX_MSRABT|RX_FS_E|RX_FS_CRC|RX_FS_IMPL)){
1177                         if (rfsw & RD_S_MSRABT) {
1178                                 DB_RX(2, "Frame aborted by the FORMAC");
1179                                 smc->hw.fp.err_stats.err_abort++ ;
1180                         }
1181                         /*
1182                          * check frame status
1183                          */
1184                         if (rfsw & RD_S_SEAC2) {
1185                                 DB_RX(2, "E-Indicator set");
1186                                 smc->hw.fp.err_stats.err_e_indicator++ ;
1187                         }
1188                         if (rfsw & RD_S_SFRMERR) {
1189                                 DB_RX(2, "CRC error");
1190                                 smc->hw.fp.err_stats.err_crc++ ;
1191                         }
1192                         if (rfsw & RX_FS_IMPL) {
1193                                 DB_RX(2, "Implementer frame");
1194                                 smc->hw.fp.err_stats.err_imp_frame++ ;
1195                         }
1196                         goto abort_frame ;
1197                 }
1198                 if (len > FDDI_RAW_MTU-4) {
1199                         DB_RX(2, "Frame too long error");
1200                         smc->hw.fp.err_stats.err_too_long++ ;
1201                         goto abort_frame ;
1202                 }
1203                 /*
1204                  * SUPERNET 3 Bug: FORMAC delivers status words
1205                  * of aborted frames to the BMU
1206                  */
1207                 if (len <= 4) {
1208                         DB_RX(2, "Frame length = 0");
1209                         goto abort_frame ;
1210                 }
1211
1212                 if (len != (n-4)) {
1213                         DB_RX(4, "BMU: rx len differs: [%d:%d]", len, n);
1214                         smc->os.hwm.rx_len_error++ ;
1215                         goto abort_frame ;
1216                 }
1217
1218                 /*
1219                  * Check SA == MA
1220                  */
1221                 virt = (u_char far *) rxd->rxd_virt ;
1222                 DB_RX(2, "FC = %x", *virt);
1223                 if (virt[12] == MA[5] &&
1224                     virt[11] == MA[4] &&
1225                     virt[10] == MA[3] &&
1226                     virt[9] == MA[2] &&
1227                     virt[8] == MA[1] &&
1228                     (virt[7] & ~GROUP_ADDR_BIT) == MA[0]) {
1229                         goto abort_frame ;
1230                 }
1231
1232                 /*
1233                  * test if LLC frame
1234                  */
1235                 if (rfsw & RX_FS_LLC) {
1236                         /*
1237                          * if pass_llc_promisc is disable
1238                          *      if DA != Multicast or Broadcast or DA!=MA
1239                          *              abort the frame
1240                          */
1241                         if (!smc->os.hwm.pass_llc_promisc) {
1242                                 if(!(virt[1] & GROUP_ADDR_BIT)) {
1243                                         if (virt[6] != MA[5] ||
1244                                             virt[5] != MA[4] ||
1245                                             virt[4] != MA[3] ||
1246                                             virt[3] != MA[2] ||
1247                                             virt[2] != MA[1] ||
1248                                             virt[1] != MA[0]) {
1249                                                 DB_RX(2, "DA != MA and not multi- or broadcast");
1250                                                 goto abort_frame ;
1251                                         }
1252                                 }
1253                         }
1254
1255                         /*
1256                          * LLC frame received
1257                          */
1258                         DB_RX(4, "LLC - receive");
1259                         mac_drv_rx_complete(smc,rxd,frag_count,len) ;
1260                 }
1261                 else {
1262                         if (!(mb = smt_get_mbuf(smc))) {
1263                                 smc->hw.fp.err_stats.err_no_buf++ ;
1264                                 DB_RX(4, "No SMbuf; receive terminated");
1265                                 goto abort_frame ;
1266                         }
1267                         data = smtod(mb,char *) - 1 ;
1268
1269                         /*
1270                          * copy the frame into a SMT_MBuf
1271                          */
1272 #ifdef USE_OS_CPY
1273                         hwm_cpy_rxd2mb(rxd,data,len) ;
1274 #else
1275                         for (r=rxd, i=used_frags ; i ; r=r->rxd_next, i--){
1276                                 n = le32_to_cpu(r->rxd_rbctrl) & RD_LENGTH ;
1277                                 DB_RX(6, "cp SMT frame to mb: len = %d", n);
1278                                 memcpy(data,r->rxd_virt,n) ;
1279                                 data += n ;
1280                         }
1281                         data = smtod(mb,char *) - 1 ;
1282 #endif
1283                         fc = *(char *)mb->sm_data = *data ;
1284                         mb->sm_len = len - 1 ;          /* len - fc */
1285                         data++ ;
1286
1287                         /*
1288                          * SMT frame received
1289                          */
1290                         switch(fc) {
1291                         case FC_SMT_INFO :
1292                                 smc->hw.fp.err_stats.err_smt_frame++ ;
1293                                 DB_RX(5, "SMT frame received");
1294
1295                                 if (smc->os.hwm.pass_SMT) {
1296                                         DB_RX(5, "pass SMT frame");
1297                                         mac_drv_rx_complete(smc, rxd,
1298                                                 frag_count,len) ;
1299                                 }
1300                                 else {
1301                                         DB_RX(5, "requeue RxD");
1302                                         mac_drv_requeue_rxd(smc,rxd,frag_count);
1303                                 }
1304
1305                                 smt_received_pack(smc,mb,(int)(rfsw>>25)) ;
1306                                 break ;
1307                         case FC_SMT_NSA :
1308                                 smc->hw.fp.err_stats.err_smt_frame++ ;
1309                                 DB_RX(5, "SMT frame received");
1310
1311                                 /* if pass_NSA set pass the NSA frame or */
1312                                 /* pass_SMT set and the A-Indicator */
1313                                 /* is not set, pass the NSA frame */
1314                                 if (smc->os.hwm.pass_NSA ||
1315                                         (smc->os.hwm.pass_SMT &&
1316                                         !(rfsw & A_INDIC))) {
1317                                         DB_RX(5, "pass SMT frame");
1318                                         mac_drv_rx_complete(smc, rxd,
1319                                                 frag_count,len) ;
1320                                 }
1321                                 else {
1322                                         DB_RX(5, "requeue RxD");
1323                                         mac_drv_requeue_rxd(smc,rxd,frag_count);
1324                                 }
1325
1326                                 smt_received_pack(smc,mb,(int)(rfsw>>25)) ;
1327                                 break ;
1328                         case FC_BEACON :
1329                                 if (smc->os.hwm.pass_DB) {
1330                                         DB_RX(5, "pass DB frame");
1331                                         mac_drv_rx_complete(smc, rxd,
1332                                                 frag_count,len) ;
1333                                 }
1334                                 else {
1335                                         DB_RX(5, "requeue RxD");
1336                                         mac_drv_requeue_rxd(smc,rxd,frag_count);
1337                                 }
1338                                 smt_free_mbuf(smc,mb) ;
1339                                 break ;
1340                         default :
1341                                 /*
1342                                  * unknown FC abort the frame
1343                                  */
1344                                 DB_RX(2, "unknown FC error");
1345                                 smt_free_mbuf(smc,mb) ;
1346                                 DB_RX(5, "requeue RxD");
1347                                 mac_drv_requeue_rxd(smc,rxd,frag_count) ;
1348                                 if ((fc & 0xf0) == FC_MAC)
1349                                         smc->hw.fp.err_stats.err_mac_frame++ ;
1350                                 else
1351                                         smc->hw.fp.err_stats.err_imp_frame++ ;
1352
1353                                 break ;
1354                         }
1355                 }
1356
1357                 DB_RX(3, "next RxD is %p", queue->rx_curr_get);
1358                 NDD_TRACE("RHx1",queue->rx_curr_get,0,0) ;
1359
1360                 continue ;
1361         /*--------------------------------------------------------------------*/
1362 abort_frame:
1363                 DB_RX(5, "requeue RxD");
1364                 mac_drv_requeue_rxd(smc,rxd,frag_count) ;
1365
1366                 DB_RX(3, "next RxD is %p", queue->rx_curr_get);
1367                 NDD_TRACE("RHx2",queue->rx_curr_get,0,0) ;
1368         }
1369 rx_end:
1370 #ifdef  ALL_RX_COMPLETE
1371         mac_drv_all_receives_complete(smc) ;
1372 #endif
1373         return ;        /* lint bug: needs return detect end of function */
1374 }
1375
1376 static void smt_to_llc(struct s_smc *smc, SMbuf *mb)
1377 {
1378         u_char  fc ;
1379
1380         DB_RX(4, "send a queued frame to the llc layer");
1381         smc->os.hwm.r.len = mb->sm_len ;
1382         smc->os.hwm.r.mb_pos = smtod(mb,char *) ;
1383         fc = *smc->os.hwm.r.mb_pos ;
1384         (void)mac_drv_rx_init(smc,(int)mb->sm_len,(int)fc,
1385                 smc->os.hwm.r.mb_pos,(int)mb->sm_len) ;
1386         smt_free_mbuf(smc,mb) ;
1387 }
1388
1389 /*
1390  *      BEGIN_MANUAL_ENTRY(hwm_rx_frag)
1391  *      void hwm_rx_frag(smc,virt,phys,len,frame_status)
1392  *
1393  * function     MACRO           (hardware module, hwmtm.h)
1394  *              This function calls dma_master for preparing the
1395  *              system hardware for the DMA transfer and initializes
1396  *              the current RxD with the length and the physical and
1397  *              virtual address of the fragment. Furthermore, it sets the
1398  *              STF and EOF bits depending on the frame status byte,
1399  *              switches the OWN flag of the RxD, so that it is owned by the
1400  *              adapter and issues an rx_start.
1401  *
1402  * para virt    virtual pointer to the fragment
1403  *      len     the length of the fragment
1404  *      frame_status    status of the frame, see design description
1405  *
1406  * NOTE:        It is possible to call this function with a fragment length
1407  *              of zero.
1408  *
1409  *      END_MANUAL_ENTRY
1410  */
1411 void hwm_rx_frag(struct s_smc *smc, char far *virt, u_long phys, int len,
1412                  int frame_status)
1413 {
1414         struct s_smt_fp_rxd volatile *r ;
1415         __le32  rbctrl;
1416
1417         NDD_TRACE("RHfB",virt,len,frame_status) ;
1418         DB_RX(2, "hwm_rx_frag: len = %d, frame_status = %x", len, frame_status);
1419         r = smc->hw.fp.rx_q[QUEUE_R1].rx_curr_put ;
1420         r->rxd_virt = virt ;
1421         r->rxd_rbadr = cpu_to_le32(phys) ;
1422         rbctrl = cpu_to_le32( (((__u32)frame_status &
1423                 (FIRST_FRAG|LAST_FRAG))<<26) |
1424                 (((u_long) frame_status & FIRST_FRAG) << 21) |
1425                 BMU_OWN | BMU_CHECK | BMU_EN_IRQ_EOF | len) ;
1426         r->rxd_rbctrl = rbctrl ;
1427
1428         DRV_BUF_FLUSH(r,DDI_DMA_SYNC_FORDEV) ;
1429         outpd(ADDR(B0_R1_CSR),CSR_START) ;
1430         smc->hw.fp.rx_q[QUEUE_R1].rx_free-- ;
1431         smc->hw.fp.rx_q[QUEUE_R1].rx_used++ ;
1432         smc->hw.fp.rx_q[QUEUE_R1].rx_curr_put = r->rxd_next ;
1433         NDD_TRACE("RHfE",r,le32_to_cpu(r->rxd_rbadr),0) ;
1434 }
1435
1436 /*
1437  *      BEGINN_MANUAL_ENTRY(mac_drv_clear_rx_queue)
1438  *
1439  * void mac_drv_clear_rx_queue(smc)
1440  * struct s_smc *smc ;
1441  *
1442  * function     DOWNCALL        (hardware module, hwmtm.c)
1443  *              mac_drv_clear_rx_queue is called by the OS-specific module
1444  *              after it has issued a card_stop.
1445  *              In this case, the frames in the receive queue are obsolete and
1446  *              should be removed. For removing mac_drv_clear_rx_queue
1447  *              calls dma_master for each RxD and mac_drv_clear_rxd for each
1448  *              receive buffer.
1449  *
1450  * NOTE:        calling sequence card_stop:
1451  *              CLI_FBI(), card_stop(),
1452  *              mac_drv_clear_tx_queue(), mac_drv_clear_rx_queue(),
1453  *
1454  * NOTE:        The caller is responsible that the BMUs are idle
1455  *              when this function is called.
1456  *
1457  *      END_MANUAL_ENTRY
1458  */
1459 void mac_drv_clear_rx_queue(struct s_smc *smc)
1460 {
1461         struct s_smt_fp_rxd volatile *r ;
1462         struct s_smt_fp_rxd volatile *next_rxd ;
1463         struct s_smt_rx_queue *queue ;
1464         int frag_count ;
1465         int i ;
1466
1467         if (smc->hw.hw_state != STOPPED) {
1468                 SK_BREAK() ;
1469                 SMT_PANIC(smc,HWM_E0012,HWM_E0012_MSG) ;
1470                 return ;
1471         }
1472
1473         queue = smc->hw.fp.rx[QUEUE_R1] ;
1474         DB_RX(5, "clear_rx_queue");
1475
1476         /*
1477          * dma_complete and mac_drv_clear_rxd for all RxDs / receive buffers
1478          */
1479         r = queue->rx_curr_get ;
1480         while (queue->rx_used) {
1481                 DRV_BUF_FLUSH(r,DDI_DMA_SYNC_FORCPU) ;
1482                 DB_RX(5, "switch OWN bit of RxD 0x%p", r);
1483                 r->rxd_rbctrl &= ~cpu_to_le32(BMU_OWN) ;
1484                 frag_count = 1 ;
1485                 DRV_BUF_FLUSH(r,DDI_DMA_SYNC_FORDEV) ;
1486                 r = r->rxd_next ;
1487                 DRV_BUF_FLUSH(r,DDI_DMA_SYNC_FORCPU) ;
1488                 while (r != queue->rx_curr_put &&
1489                         !(r->rxd_rbctrl & cpu_to_le32(BMU_ST_BUF))) {
1490                         DB_RX(5, "Check STF bit in %p", r);
1491                         r->rxd_rbctrl &= ~cpu_to_le32(BMU_OWN) ;
1492                         DRV_BUF_FLUSH(r,DDI_DMA_SYNC_FORDEV) ;
1493                         r = r->rxd_next ;
1494                         DRV_BUF_FLUSH(r,DDI_DMA_SYNC_FORCPU) ;
1495                         frag_count++ ;
1496                 }
1497                 DB_RX(5, "STF bit found");
1498                 next_rxd = r ;
1499
1500                 for (r=queue->rx_curr_get,i=frag_count; i ; r=r->rxd_next,i--){
1501                         DB_RX(5, "dma_complete for RxD %p", r);
1502                         dma_complete(smc,(union s_fp_descr volatile *)r,DMA_WR);
1503                 }
1504
1505                 DB_RX(5, "mac_drv_clear_rxd: RxD %p frag_count %d",
1506                       queue->rx_curr_get, frag_count);
1507                 mac_drv_clear_rxd(smc,queue->rx_curr_get,frag_count) ;
1508
1509                 queue->rx_curr_get = next_rxd ;
1510                 queue->rx_used -= frag_count ;
1511                 queue->rx_free += frag_count ;
1512         }
1513 }
1514
1515
1516 /*
1517         -------------------------------------------------------------
1518         SEND FUNCTIONS:
1519         -------------------------------------------------------------
1520 */
1521
1522 /*
1523  *      BEGIN_MANUAL_ENTRY(hwm_tx_init)
1524  *      int hwm_tx_init(smc,fc,frag_count,frame_len,frame_status)
1525  *
1526  * function     DOWN_CALL       (hardware module, hwmtm.c)
1527  *              hwm_tx_init checks if the frame can be sent through the
1528  *              corresponding send queue.
1529  *
1530  * para fc      the frame control. To determine through which
1531  *              send queue the frame should be transmitted.
1532  *              0x50 - 0x57:    asynchronous LLC frame
1533  *              0xD0 - 0xD7:    synchronous LLC frame
1534  *              0x41, 0x4F:     SMT frame to the network
1535  *              0x42:           SMT frame to the network and to the local SMT
1536  *              0x43:           SMT frame to the local SMT
1537  *      frag_count      count of the fragments for this frame
1538  *      frame_len       length of the frame
1539  *      frame_status    status of the frame, the send queue bit is already
1540  *                      specified
1541  *
1542  * return               frame_status
1543  *
1544  *      END_MANUAL_ENTRY
1545  */
1546 int hwm_tx_init(struct s_smc *smc, u_char fc, int frag_count, int frame_len,
1547                 int frame_status)
1548 {
1549         NDD_TRACE("THiB",fc,frag_count,frame_len) ;
1550         smc->os.hwm.tx_p = smc->hw.fp.tx[frame_status & QUEUE_A0] ;
1551         smc->os.hwm.tx_descr = TX_DESCRIPTOR | (((u_long)(frame_len-1)&3)<<27) ;
1552         smc->os.hwm.tx_len = frame_len ;
1553         DB_TX(3, "hwm_tx_init: fc = %x, len = %d", fc, frame_len);
1554         if ((fc & ~(FC_SYNC_BIT|FC_LLC_PRIOR)) == FC_ASYNC_LLC) {
1555                 frame_status |= LAN_TX ;
1556         }
1557         else {
1558                 switch (fc) {
1559                 case FC_SMT_INFO :
1560                 case FC_SMT_NSA :
1561                         frame_status |= LAN_TX ;
1562                         break ;
1563                 case FC_SMT_LOC :
1564                         frame_status |= LOC_TX ;
1565                         break ;
1566                 case FC_SMT_LAN_LOC :
1567                         frame_status |= LAN_TX | LOC_TX ;
1568                         break ;
1569                 default :
1570                         SMT_PANIC(smc,HWM_E0010,HWM_E0010_MSG) ;
1571                 }
1572         }
1573         if (!smc->hw.mac_ring_is_up) {
1574                 frame_status &= ~LAN_TX ;
1575                 frame_status |= RING_DOWN ;
1576                 DB_TX(2, "Ring is down: terminate LAN_TX");
1577         }
1578         if (frag_count > smc->os.hwm.tx_p->tx_free) {
1579 #ifndef NDIS_OS2
1580                 mac_drv_clear_txd(smc) ;
1581                 if (frag_count > smc->os.hwm.tx_p->tx_free) {
1582                         DB_TX(2, "Out of TxDs, terminate LAN_TX");
1583                         frame_status &= ~LAN_TX ;
1584                         frame_status |= OUT_OF_TXD ;
1585                 }
1586 #else
1587                 DB_TX(2, "Out of TxDs, terminate LAN_TX");
1588                 frame_status &= ~LAN_TX ;
1589                 frame_status |= OUT_OF_TXD ;
1590 #endif
1591         }
1592         DB_TX(3, "frame_status = %x", frame_status);
1593         NDD_TRACE("THiE",frame_status,smc->os.hwm.tx_p->tx_free,0) ;
1594         return frame_status;
1595 }
1596
1597 /*
1598  *      BEGIN_MANUAL_ENTRY(hwm_tx_frag)
1599  *      void hwm_tx_frag(smc,virt,phys,len,frame_status)
1600  *
1601  * function     DOWNCALL        (hardware module, hwmtm.c)
1602  *              If the frame should be sent to the LAN, this function calls
1603  *              dma_master, fills the current TxD with the virtual and the
1604  *              physical address, sets the STF and EOF bits dependent on
1605  *              the frame status, and requests the BMU to start the
1606  *              transmit.
1607  *              If the frame should be sent to the local SMT, an SMT_MBuf
1608  *              is allocated if the FIRST_FRAG bit is set in the frame_status.
1609  *              The fragment of the frame is copied into the SMT MBuf.
1610  *              The function smt_received_pack is called if the LAST_FRAG
1611  *              bit is set in the frame_status word.
1612  *
1613  * para virt    virtual pointer to the fragment
1614  *      len     the length of the fragment
1615  *      frame_status    status of the frame, see design description
1616  *
1617  * return       nothing returned, no parameter is modified
1618  *
1619  * NOTE:        It is possible to invoke this macro with a fragment length
1620  *              of zero.
1621  *
1622  *      END_MANUAL_ENTRY
1623  */
1624 void hwm_tx_frag(struct s_smc *smc, char far *virt, u_long phys, int len,
1625                  int frame_status)
1626 {
1627         struct s_smt_fp_txd volatile *t ;
1628         struct s_smt_tx_queue *queue ;
1629         __le32  tbctrl ;
1630
1631         queue = smc->os.hwm.tx_p ;
1632
1633         NDD_TRACE("THfB",virt,len,frame_status) ;
1634         /* Bug fix: AF / May 31 1999 (#missing)
1635          * snmpinfo problem reported by IBM is caused by invalid
1636          * t-pointer (txd) if LAN_TX is not set but LOC_TX only.
1637          * Set: t = queue->tx_curr_put  here !
1638          */
1639         t = queue->tx_curr_put ;
1640
1641         DB_TX(2, "hwm_tx_frag: len = %d, frame_status = %x", len, frame_status);
1642         if (frame_status & LAN_TX) {
1643                 /* '*t' is already defined */
1644                 DB_TX(3, "LAN_TX: TxD = %p, virt = %p", t, virt);
1645                 t->txd_virt = virt ;
1646                 t->txd_txdscr = cpu_to_le32(smc->os.hwm.tx_descr) ;
1647                 t->txd_tbadr = cpu_to_le32(phys) ;
1648                 tbctrl = cpu_to_le32((((__u32)frame_status &
1649                         (FIRST_FRAG|LAST_FRAG|EN_IRQ_EOF))<< 26) |
1650                         BMU_OWN|BMU_CHECK |len) ;
1651                 t->txd_tbctrl = tbctrl ;
1652
1653 #ifndef AIX
1654                 DRV_BUF_FLUSH(t,DDI_DMA_SYNC_FORDEV) ;
1655                 outpd(queue->tx_bmu_ctl,CSR_START) ;
1656 #else   /* ifndef AIX */
1657                 DRV_BUF_FLUSH(t,DDI_DMA_SYNC_FORDEV) ;
1658                 if (frame_status & QUEUE_A0) {
1659                         outpd(ADDR(B0_XA_CSR),CSR_START) ;
1660                 }
1661                 else {
1662                         outpd(ADDR(B0_XS_CSR),CSR_START) ;
1663                 }
1664 #endif
1665                 queue->tx_free-- ;
1666                 queue->tx_used++ ;
1667                 queue->tx_curr_put = t->txd_next ;
1668                 if (frame_status & LAST_FRAG) {
1669                         smc->mib.m[MAC0].fddiMACTransmit_Ct++ ;
1670                 }
1671         }
1672         if (frame_status & LOC_TX) {
1673                 DB_TX(3, "LOC_TX:");
1674                 if (frame_status & FIRST_FRAG) {
1675                         if(!(smc->os.hwm.tx_mb = smt_get_mbuf(smc))) {
1676                                 smc->hw.fp.err_stats.err_no_buf++ ;
1677                                 DB_TX(4, "No SMbuf; transmit terminated");
1678                         }
1679                         else {
1680                                 smc->os.hwm.tx_data =
1681                                         smtod(smc->os.hwm.tx_mb,char *) - 1 ;
1682 #ifdef USE_OS_CPY
1683 #ifdef PASS_1ST_TXD_2_TX_COMP
1684                                 hwm_cpy_txd2mb(t,smc->os.hwm.tx_data,
1685                                         smc->os.hwm.tx_len) ;
1686 #endif
1687 #endif
1688                         }
1689                 }
1690                 if (smc->os.hwm.tx_mb) {
1691 #ifndef USE_OS_CPY
1692                         DB_TX(3, "copy fragment into MBuf");
1693                         memcpy(smc->os.hwm.tx_data,virt,len) ;
1694                         smc->os.hwm.tx_data += len ;
1695 #endif
1696                         if (frame_status & LAST_FRAG) {
1697 #ifdef  USE_OS_CPY
1698 #ifndef PASS_1ST_TXD_2_TX_COMP
1699                                 /*
1700                                  * hwm_cpy_txd2mb(txd,data,len) copies 'len'
1701                                  * bytes from the virtual pointer in 'rxd'
1702                                  * to 'data'. The virtual pointer of the
1703                                  * os-specific tx-buffer should be written
1704                                  * in the LAST txd.
1705                                  */
1706                                 hwm_cpy_txd2mb(t,smc->os.hwm.tx_data,
1707                                         smc->os.hwm.tx_len) ;
1708 #endif  /* nPASS_1ST_TXD_2_TX_COMP */
1709 #endif  /* USE_OS_CPY */
1710                                 smc->os.hwm.tx_data =
1711                                         smtod(smc->os.hwm.tx_mb,char *) - 1 ;
1712                                 *(char *)smc->os.hwm.tx_mb->sm_data =
1713                                         *smc->os.hwm.tx_data ;
1714                                 smc->os.hwm.tx_data++ ;
1715                                 smc->os.hwm.tx_mb->sm_len =
1716                                         smc->os.hwm.tx_len - 1 ;
1717                                 DB_TX(3, "pass LLC frame to SMT");
1718                                 smt_received_pack(smc,smc->os.hwm.tx_mb,
1719                                                 RD_FS_LOCAL) ;
1720                         }
1721                 }
1722         }
1723         NDD_TRACE("THfE",t,queue->tx_free,0) ;
1724 }
1725
1726
1727 /*
1728  * queues a receive for later send
1729  */
1730 static void queue_llc_rx(struct s_smc *smc, SMbuf *mb)
1731 {
1732         DB_GEN(4, "queue_llc_rx: mb = %p", mb);
1733         smc->os.hwm.queued_rx_frames++ ;
1734         mb->sm_next = (SMbuf *)NULL ;
1735         if (smc->os.hwm.llc_rx_pipe == NULL) {
1736                 smc->os.hwm.llc_rx_pipe = mb ;
1737         }
1738         else {
1739                 smc->os.hwm.llc_rx_tail->sm_next = mb ;
1740         }
1741         smc->os.hwm.llc_rx_tail = mb ;
1742
1743         /*
1744          * force an timer IRQ to receive the data
1745          */
1746         if (!smc->os.hwm.isr_flag) {
1747                 smt_force_irq(smc) ;
1748         }
1749 }
1750
1751 /*
1752  * get a SMbuf from the llc_rx_queue
1753  */
1754 static SMbuf *get_llc_rx(struct s_smc *smc)
1755 {
1756         SMbuf   *mb ;
1757
1758         if ((mb = smc->os.hwm.llc_rx_pipe)) {
1759                 smc->os.hwm.queued_rx_frames-- ;
1760                 smc->os.hwm.llc_rx_pipe = mb->sm_next ;
1761         }
1762         DB_GEN(4, "get_llc_rx: mb = 0x%p", mb);
1763         return mb;
1764 }
1765
1766 /*
1767  * queues a transmit SMT MBuf during the time were the MBuf is
1768  * queued the TxD ring
1769  */
1770 static void queue_txd_mb(struct s_smc *smc, SMbuf *mb)
1771 {
1772         DB_GEN(4, "_rx: queue_txd_mb = %p", mb);
1773         smc->os.hwm.queued_txd_mb++ ;
1774         mb->sm_next = (SMbuf *)NULL ;
1775         if (smc->os.hwm.txd_tx_pipe == NULL) {
1776                 smc->os.hwm.txd_tx_pipe = mb ;
1777         }
1778         else {
1779                 smc->os.hwm.txd_tx_tail->sm_next = mb ;
1780         }
1781         smc->os.hwm.txd_tx_tail = mb ;
1782 }
1783
1784 /*
1785  * get a SMbuf from the txd_tx_queue
1786  */
1787 static SMbuf *get_txd_mb(struct s_smc *smc)
1788 {
1789         SMbuf *mb ;
1790
1791         if ((mb = smc->os.hwm.txd_tx_pipe)) {
1792                 smc->os.hwm.queued_txd_mb-- ;
1793                 smc->os.hwm.txd_tx_pipe = mb->sm_next ;
1794         }
1795         DB_GEN(4, "get_txd_mb: mb = 0x%p", mb);
1796         return mb;
1797 }
1798
1799 /*
1800  *      SMT Send function
1801  */
1802 void smt_send_mbuf(struct s_smc *smc, SMbuf *mb, int fc)
1803 {
1804         char far *data ;
1805         int     len ;
1806         int     n ;
1807         int     i ;
1808         int     frag_count ;
1809         int     frame_status ;
1810         SK_LOC_DECL(char far,*virt[3]) ;
1811         int     frag_len[3] ;
1812         struct s_smt_tx_queue *queue ;
1813         struct s_smt_fp_txd volatile *t ;
1814         u_long  phys ;
1815         __le32  tbctrl;
1816
1817         NDD_TRACE("THSB",mb,fc,0) ;
1818         DB_TX(4, "smt_send_mbuf: mb = 0x%p, fc = 0x%x", mb, fc);
1819
1820         mb->sm_off-- ;  /* set to fc */
1821         mb->sm_len++ ;  /* + fc */
1822         data = smtod(mb,char *) ;
1823         *data = fc ;
1824         if (fc == FC_SMT_LOC)
1825                 *data = FC_SMT_INFO ;
1826
1827         /*
1828          * determine the frag count and the virt addresses of the frags
1829          */
1830         frag_count = 0 ;
1831         len = mb->sm_len ;
1832         while (len) {
1833                 n = SMT_PAGESIZE - ((long)data & (SMT_PAGESIZE-1)) ;
1834                 if (n >= len) {
1835                         n = len ;
1836                 }
1837                 DB_TX(5, "frag: virt/len = 0x%p/%d", data, n);
1838                 virt[frag_count] = data ;
1839                 frag_len[frag_count] = n ;
1840                 frag_count++ ;
1841                 len -= n ;
1842                 data += n ;
1843         }
1844
1845         /*
1846          * determine the frame status
1847          */
1848         queue = smc->hw.fp.tx[QUEUE_A0] ;
1849         if (fc == FC_BEACON || fc == FC_SMT_LOC) {
1850                 frame_status = LOC_TX ;
1851         }
1852         else {
1853                 frame_status = LAN_TX ;
1854                 if ((smc->os.hwm.pass_NSA &&(fc == FC_SMT_NSA)) ||
1855                    (smc->os.hwm.pass_SMT &&(fc == FC_SMT_INFO)))
1856                         frame_status |= LOC_TX ;
1857         }
1858
1859         if (!smc->hw.mac_ring_is_up || frag_count > queue->tx_free) {
1860                 frame_status &= ~LAN_TX;
1861                 if (frame_status) {
1862                         DB_TX(2, "Ring is down: terminate LAN_TX");
1863                 }
1864                 else {
1865                         DB_TX(2, "Ring is down: terminate transmission");
1866                         smt_free_mbuf(smc,mb) ;
1867                         return ;
1868                 }
1869         }
1870         DB_TX(5, "frame_status = 0x%x", frame_status);
1871
1872         if ((frame_status & LAN_TX) && (frame_status & LOC_TX)) {
1873                 mb->sm_use_count = 2 ;
1874         }
1875
1876         if (frame_status & LAN_TX) {
1877                 t = queue->tx_curr_put ;
1878                 frame_status |= FIRST_FRAG ;
1879                 for (i = 0; i < frag_count; i++) {
1880                         DB_TX(5, "init TxD = 0x%p", t);
1881                         if (i == frag_count-1) {
1882                                 frame_status |= LAST_FRAG ;
1883                                 t->txd_txdscr = cpu_to_le32(TX_DESCRIPTOR |
1884                                         (((__u32)(mb->sm_len-1)&3) << 27)) ;
1885                         }
1886                         t->txd_virt = virt[i] ;
1887                         phys = dma_master(smc, (void far *)virt[i],
1888                                 frag_len[i], DMA_RD|SMT_BUF) ;
1889                         t->txd_tbadr = cpu_to_le32(phys) ;
1890                         tbctrl = cpu_to_le32((((__u32)frame_status &
1891                                 (FIRST_FRAG|LAST_FRAG)) << 26) |
1892                                 BMU_OWN | BMU_CHECK | BMU_SMT_TX |frag_len[i]) ;
1893                         t->txd_tbctrl = tbctrl ;
1894 #ifndef AIX
1895                         DRV_BUF_FLUSH(t,DDI_DMA_SYNC_FORDEV) ;
1896                         outpd(queue->tx_bmu_ctl,CSR_START) ;
1897 #else
1898                         DRV_BUF_FLUSH(t,DDI_DMA_SYNC_FORDEV) ;
1899                         outpd(ADDR(B0_XA_CSR),CSR_START) ;
1900 #endif
1901                         frame_status &= ~FIRST_FRAG ;
1902                         queue->tx_curr_put = t = t->txd_next ;
1903                         queue->tx_free-- ;
1904                         queue->tx_used++ ;
1905                 }
1906                 smc->mib.m[MAC0].fddiMACTransmit_Ct++ ;
1907                 queue_txd_mb(smc,mb) ;
1908         }
1909
1910         if (frame_status & LOC_TX) {
1911                 DB_TX(5, "pass Mbuf to LLC queue");
1912                 queue_llc_rx(smc,mb) ;
1913         }
1914
1915         /*
1916          * We need to unqueue the free SMT_MBUFs here, because it may
1917          * be that the SMT want's to send more than 1 frame for one down call
1918          */
1919         mac_drv_clear_txd(smc) ;
1920         NDD_TRACE("THSE",t,queue->tx_free,frag_count) ;
1921 }
1922
1923 /*      BEGIN_MANUAL_ENTRY(mac_drv_clear_txd)
1924  *      void mac_drv_clear_txd(smc)
1925  *
1926  * function     DOWNCALL        (hardware module, hwmtm.c)
1927  *              mac_drv_clear_txd searches in both send queues for TxD's
1928  *              which were finished by the adapter. It calls dma_complete
1929  *              for each TxD. If the last fragment of an LLC frame is
1930  *              reached, it calls mac_drv_tx_complete to release the
1931  *              send buffer.
1932  *
1933  * return       nothing
1934  *
1935  *      END_MANUAL_ENTRY
1936  */
1937 static void mac_drv_clear_txd(struct s_smc *smc)
1938 {
1939         struct s_smt_tx_queue *queue ;
1940         struct s_smt_fp_txd volatile *t1 ;
1941         struct s_smt_fp_txd volatile *t2 = NULL ;
1942         SMbuf *mb ;
1943         u_long  tbctrl ;
1944         int i ;
1945         int frag_count ;
1946         int n ;
1947
1948         NDD_TRACE("THcB",0,0,0) ;
1949         for (i = QUEUE_S; i <= QUEUE_A0; i++) {
1950                 queue = smc->hw.fp.tx[i] ;
1951                 t1 = queue->tx_curr_get ;
1952                 DB_TX(5, "clear_txd: QUEUE = %d (0=sync/1=async)", i);
1953
1954                 for ( ; ; ) {
1955                         frag_count = 0 ;
1956
1957                         do {
1958                                 DRV_BUF_FLUSH(t1,DDI_DMA_SYNC_FORCPU) ;
1959                                 DB_TX(5, "check OWN/EOF bit of TxD 0x%p", t1);
1960                                 tbctrl = le32_to_cpu(CR_READ(t1->txd_tbctrl));
1961
1962                                 if (tbctrl & BMU_OWN || !queue->tx_used){
1963                                         DB_TX(4, "End of TxDs queue %d", i);
1964                                         goto free_next_queue ;  /* next queue */
1965                                 }
1966                                 t1 = t1->txd_next ;
1967                                 frag_count++ ;
1968                         } while (!(tbctrl & BMU_EOF)) ;
1969
1970                         t1 = queue->tx_curr_get ;
1971                         for (n = frag_count; n; n--) {
1972                                 tbctrl = le32_to_cpu(t1->txd_tbctrl) ;
1973                                 dma_complete(smc,
1974                                         (union s_fp_descr volatile *) t1,
1975                                         (int) (DMA_RD |
1976                                         ((tbctrl & BMU_SMT_TX) >> 18))) ;
1977                                 t2 = t1 ;
1978                                 t1 = t1->txd_next ;
1979                         }
1980
1981                         if (tbctrl & BMU_SMT_TX) {
1982                                 mb = get_txd_mb(smc) ;
1983                                 smt_free_mbuf(smc,mb) ;
1984                         }
1985                         else {
1986 #ifndef PASS_1ST_TXD_2_TX_COMP
1987                                 DB_TX(4, "mac_drv_tx_comp for TxD 0x%p", t2);
1988                                 mac_drv_tx_complete(smc,t2) ;
1989 #else
1990                                 DB_TX(4, "mac_drv_tx_comp for TxD 0x%x",
1991                                       queue->tx_curr_get);
1992                                 mac_drv_tx_complete(smc,queue->tx_curr_get) ;
1993 #endif
1994                         }
1995                         queue->tx_curr_get = t1 ;
1996                         queue->tx_free += frag_count ;
1997                         queue->tx_used -= frag_count ;
1998                 }
1999 free_next_queue: ;
2000         }
2001         NDD_TRACE("THcE",0,0,0) ;
2002 }
2003
2004 /*
2005  *      BEGINN_MANUAL_ENTRY(mac_drv_clear_tx_queue)
2006  *
2007  * void mac_drv_clear_tx_queue(smc)
2008  * struct s_smc *smc ;
2009  *
2010  * function     DOWNCALL        (hardware module, hwmtm.c)
2011  *              mac_drv_clear_tx_queue is called from the SMT when
2012  *              the RMT state machine has entered the ISOLATE state.
2013  *              This function is also called by the os-specific module
2014  *              after it has called the function card_stop().
2015  *              In this case, the frames in the send queues are obsolete and
2016  *              should be removed.
2017  *
2018  * note         calling sequence:
2019  *              CLI_FBI(), card_stop(),
2020  *              mac_drv_clear_tx_queue(), mac_drv_clear_rx_queue(),
2021  *
2022  * NOTE:        The caller is responsible that the BMUs are idle
2023  *              when this function is called.
2024  *
2025  *      END_MANUAL_ENTRY
2026  */
2027 void mac_drv_clear_tx_queue(struct s_smc *smc)
2028 {
2029         struct s_smt_fp_txd volatile *t ;
2030         struct s_smt_tx_queue *queue ;
2031         int tx_used ;
2032         int i ;
2033
2034         if (smc->hw.hw_state != STOPPED) {
2035                 SK_BREAK() ;
2036                 SMT_PANIC(smc,HWM_E0011,HWM_E0011_MSG) ;
2037                 return ;
2038         }
2039
2040         for (i = QUEUE_S; i <= QUEUE_A0; i++) {
2041                 queue = smc->hw.fp.tx[i] ;
2042                 DB_TX(5, "clear_tx_queue: QUEUE = %d (0=sync/1=async)", i);
2043
2044                 /*
2045                  * switch the OWN bit of all pending frames to the host
2046                  */
2047                 t = queue->tx_curr_get ;
2048                 tx_used = queue->tx_used ;
2049                 while (tx_used) {
2050                         DRV_BUF_FLUSH(t,DDI_DMA_SYNC_FORCPU) ;
2051                         DB_TX(5, "switch OWN bit of TxD 0x%p", t);
2052                         t->txd_tbctrl &= ~cpu_to_le32(BMU_OWN) ;
2053                         DRV_BUF_FLUSH(t,DDI_DMA_SYNC_FORDEV) ;
2054                         t = t->txd_next ;
2055                         tx_used-- ;
2056                 }
2057         }
2058
2059         /*
2060          * release all TxD's for both send queues
2061          */
2062         mac_drv_clear_txd(smc) ;
2063
2064         for (i = QUEUE_S; i <= QUEUE_A0; i++) {
2065                 queue = smc->hw.fp.tx[i] ;
2066                 t = queue->tx_curr_get ;
2067
2068                 /*
2069                  * write the phys pointer of the NEXT descriptor into the
2070                  * BMU's current address descriptor pointer and set
2071                  * tx_curr_get and tx_curr_put to this position
2072                  */
2073                 if (i == QUEUE_S) {
2074                         outpd(ADDR(B5_XS_DA),le32_to_cpu(t->txd_ntdadr)) ;
2075                 }
2076                 else {
2077                         outpd(ADDR(B5_XA_DA),le32_to_cpu(t->txd_ntdadr)) ;
2078                 }
2079
2080                 queue->tx_curr_put = queue->tx_curr_get->txd_next ;
2081                 queue->tx_curr_get = queue->tx_curr_put ;
2082         }
2083 }
2084
2085
2086 /*
2087         -------------------------------------------------------------
2088         TEST FUNCTIONS:
2089         -------------------------------------------------------------
2090 */
2091
2092 #ifdef  DEBUG
2093 /*
2094  *      BEGIN_MANUAL_ENTRY(mac_drv_debug_lev)
2095  *      void mac_drv_debug_lev(smc,flag,lev)
2096  *
2097  * function     DOWNCALL        (drvsr.c)
2098  *              To get a special debug info the user can assign a debug level
2099  *              to any debug flag.
2100  *
2101  * para flag    debug flag, possible values are:
2102  *                      = 0:    reset all debug flags (the defined level is
2103  *                              ignored)
2104  *                      = 1:    debug.d_smtf
2105  *                      = 2:    debug.d_smt
2106  *                      = 3:    debug.d_ecm
2107  *                      = 4:    debug.d_rmt
2108  *                      = 5:    debug.d_cfm
2109  *                      = 6:    debug.d_pcm
2110  *
2111  *                      = 10:   debug.d_os.hwm_rx (hardware module receive path)
2112  *                      = 11:   debug.d_os.hwm_tx(hardware module transmit path)
2113  *                      = 12:   debug.d_os.hwm_gen(hardware module general flag)
2114  *
2115  *      lev     debug level
2116  *
2117  *      END_MANUAL_ENTRY
2118  */
2119 void mac_drv_debug_lev(struct s_smc *smc, int flag, int lev)
2120 {
2121         switch(flag) {
2122         case (int)NULL:
2123                 DB_P.d_smtf = DB_P.d_smt = DB_P.d_ecm = DB_P.d_rmt = 0 ;
2124                 DB_P.d_cfm = 0 ;
2125                 DB_P.d_os.hwm_rx = DB_P.d_os.hwm_tx = DB_P.d_os.hwm_gen = 0 ;
2126 #ifdef  SBA
2127                 DB_P.d_sba = 0 ;
2128 #endif
2129 #ifdef  ESS
2130                 DB_P.d_ess = 0 ;
2131 #endif
2132                 break ;
2133         case DEBUG_SMTF:
2134                 DB_P.d_smtf = lev ;
2135                 break ;
2136         case DEBUG_SMT:
2137                 DB_P.d_smt = lev ;
2138                 break ;
2139         case DEBUG_ECM:
2140                 DB_P.d_ecm = lev ;
2141                 break ;
2142         case DEBUG_RMT:
2143                 DB_P.d_rmt = lev ;
2144                 break ;
2145         case DEBUG_CFM:
2146                 DB_P.d_cfm = lev ;
2147                 break ;
2148         case DEBUG_PCM:
2149                 DB_P.d_pcm = lev ;
2150                 break ;
2151         case DEBUG_SBA:
2152 #ifdef  SBA
2153                 DB_P.d_sba = lev ;
2154 #endif
2155                 break ;
2156         case DEBUG_ESS:
2157 #ifdef  ESS
2158                 DB_P.d_ess = lev ;
2159 #endif
2160                 break ;
2161         case DB_HWM_RX:
2162                 DB_P.d_os.hwm_rx = lev ;
2163                 break ;
2164         case DB_HWM_TX:
2165                 DB_P.d_os.hwm_tx = lev ;
2166                 break ;
2167         case DB_HWM_GEN:
2168                 DB_P.d_os.hwm_gen = lev ;
2169                 break ;
2170         default:
2171                 break ;
2172         }
2173 }
2174 #endif