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