开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
hwmtm.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：55k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

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