?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
treewide: remove redundant IS_ERR() before error code check
[linux/fpc-iii.git] / drivers / net / fddi / skfp / fplustm.c
blob02966d141948faffe79134d93325cf66e530345f
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 /*
14 * FORMAC+ Driver for tag mode
15 */
16
17 #include "h/types.h"
18 #include "h/fddi.h"
19 #include "h/smc.h"
20 #include "h/supern_2.h"
21 #include <linux/bitrev.h>
22 #include <linux/etherdevice.h>
23
24 #ifndef lint
25 static const char ID_sccs[] = "@(#)fplustm.c 1.32 99/02/23 (C) SK " ;
26 #endif
27
28 #ifndef UNUSED
29 #ifdef lint
30 #define UNUSED(x) (x) = (x)
31 #else
32 #define UNUSED(x)
33 #endif
34 #endif
35
36 #define FM_ADDRX (FM_ADDET|FM_EXGPA0|FM_EXGPA1)
37 #define MS2BCLK(x) ((x)*12500L)
38 #define US2BCLK(x) ((x)*1250L)
39
40 /*
41 * prototypes for static function
42 */
43 static void build_claim_beacon(struct s_smc *smc, u_long t_request);
44 static int init_mac(struct s_smc *smc, int all);
45 static void rtm_init(struct s_smc *smc);
46 static void smt_split_up_fifo(struct s_smc *smc);
47
48 #if (!defined(NO_SMT_PANIC) || defined(DEBUG))
49 static char write_mdr_warning [] = "E350 write_mdr() FM_SNPPND is set\n";
50 static char cam_warning [] = "E_SMT_004: CAM still busy\n";
51 #endif
52
53 #define DUMMY_READ() smc->hw.mc_dummy = (u_short) inp(ADDR(B0_RAP))
54
55 #define CHECK_NPP() { unsigned int k = 10000 ;\
56 while ((inpw(FM_A(FM_STMCHN)) & FM_SNPPND) && k) k--;\
57 if (!k) { \
58 SMT_PANIC(smc,SMT_E0130, SMT_E0130_MSG) ; \
59 } \
60 }
61
62 #define CHECK_CAM() { unsigned int k = 10 ;\
63 while (!(inpw(FM_A(FM_AFSTAT)) & FM_DONE) && k) k--;\
64 if (!k) { \
65 SMT_PANIC(smc,SMT_E0131, SMT_E0131_MSG) ; \
66 } \
67 }
68
69 const struct fddi_addr fddi_broadcast = {{0xff,0xff,0xff,0xff,0xff,0xff}};
70 static const struct fddi_addr null_addr = {{0,0,0,0,0,0}};
71 static const struct fddi_addr dbeacon_multi = {{0x01,0x80,0xc2,0x00,0x01,0x00}};
72
73 static const u_short my_said = 0xffff ; /* short address (n.u.) */
74 static const u_short my_sagp = 0xffff ; /* short group address (n.u.) */
75
76 /*
77 * define my address
78 */
79 #ifdef USE_CAN_ADDR
80 #define MA smc->hw.fddi_canon_addr
81 #else
82 #define MA smc->hw.fddi_home_addr
83 #endif
84
85
86 /*
87 * useful interrupt bits
88 */
89 static const int mac_imsk1u = FM_STXABRS | FM_STXABRA0 | FM_SXMTABT ;
90 static const int mac_imsk1l = FM_SQLCKS | FM_SQLCKA0 | FM_SPCEPDS | FM_SPCEPDA0|
91 FM_STBURS | FM_STBURA0 ;
92
93 /* delete FM_SRBFL after tests */
94 static const int mac_imsk2u = FM_SERRSF | FM_SNFSLD | FM_SRCVOVR | FM_SRBFL |
95 FM_SMYCLM ;
96 static const int mac_imsk2l = FM_STRTEXR | FM_SDUPCLM | FM_SFRMCTR |
97 FM_SERRCTR | FM_SLSTCTR |
98 FM_STRTEXP | FM_SMULTDA | FM_SRNGOP ;
99
100 static const int mac_imsk3u = FM_SRCVOVR2 | FM_SRBFL2 ;
101 static const int mac_imsk3l = FM_SRPERRQ2 | FM_SRPERRQ1 ;
102
103 static const int mac_beacon_imsk2u = FM_SOTRBEC | FM_SMYBEC | FM_SBEC |
104 FM_SLOCLM | FM_SHICLM | FM_SMYCLM | FM_SCLM ;
105
106
107 static u_long mac_get_tneg(struct s_smc *smc)
108 {
109 u_long tneg ;
110
111 tneg = (u_long)((long)inpw(FM_A(FM_TNEG))<<5) ;
112 return (u_long)((tneg + ((inpw(FM_A(FM_TMRS))>>10)&0x1f)) |
113 0xffe00000L) ;
114 }
115
116 void mac_update_counter(struct s_smc *smc)
117 {
118 smc->mib.m[MAC0].fddiMACFrame_Ct =
119 (smc->mib.m[MAC0].fddiMACFrame_Ct & 0xffff0000L)
120 + (u_short) inpw(FM_A(FM_FCNTR)) ;
121 smc->mib.m[MAC0].fddiMACLost_Ct =
122 (smc->mib.m[MAC0].fddiMACLost_Ct & 0xffff0000L)
123 + (u_short) inpw(FM_A(FM_LCNTR)) ;
124 smc->mib.m[MAC0].fddiMACError_Ct =
125 (smc->mib.m[MAC0].fddiMACError_Ct & 0xffff0000L)
126 + (u_short) inpw(FM_A(FM_ECNTR)) ;
127 smc->mib.m[MAC0].fddiMACT_Neg = mac_get_tneg(smc) ;
128 #ifdef SMT_REAL_TOKEN_CT
129 /*
130 * If the token counter is emulated it is updated in smt_event.
131 */
132 TBD
133 #else
134 smt_emulate_token_ct( smc, MAC0 );
135 #endif
136 }
137
138 /*
139 * write long value into buffer memory over memory data register (MDR),
140 */
141 static void write_mdr(struct s_smc *smc, u_long val)
142 {
143 CHECK_NPP() ;
144 MDRW(val) ;
145 }
146
147 #if 0
148 /*
149 * read long value from buffer memory over memory data register (MDR),
150 */
151 static u_long read_mdr(struct s_smc *smc, unsigned int addr)
152 {
153 long p ;
154 CHECK_NPP() ;
155 MARR(addr) ;
156 outpw(FM_A(FM_CMDREG1),FM_IRMEMWO) ;
157 CHECK_NPP() ; /* needed for PCI to prevent from timeing violations */
158 /* p = MDRR() ; */ /* bad read values if the workaround */
159 /* smc->hw.mc_dummy = *((short volatile far *)(addr)))*/
160 /* is used */
161 p = (u_long)inpw(FM_A(FM_MDRU))<<16 ;
162 p += (u_long)inpw(FM_A(FM_MDRL)) ;
163 return p;
164 }
165 #endif
166
167 /*
168 * clear buffer memory
169 */
170 static void init_ram(struct s_smc *smc)
171 {
172 u_short i ;
173
174 smc->hw.fp.fifo.rbc_ram_start = 0 ;
175 smc->hw.fp.fifo.rbc_ram_end =
176 smc->hw.fp.fifo.rbc_ram_start + RBC_MEM_SIZE ;
177 CHECK_NPP() ;
178 MARW(smc->hw.fp.fifo.rbc_ram_start) ;
179 for (i = smc->hw.fp.fifo.rbc_ram_start;
180 i < (u_short) (smc->hw.fp.fifo.rbc_ram_end-1); i++)
181 write_mdr(smc,0L) ;
182 /* Erase the last byte too */
183 write_mdr(smc,0L) ;
184 }
185
186 /*
187 * set receive FIFO pointer
188 */
189 static void set_recvptr(struct s_smc *smc)
190 {
191 /*
192 * initialize the pointer for receive queue 1
193 */
194 outpw(FM_A(FM_RPR1),smc->hw.fp.fifo.rx1_fifo_start) ; /* RPR1 */
195 outpw(FM_A(FM_SWPR1),smc->hw.fp.fifo.rx1_fifo_start) ; /* SWPR1 */
196 outpw(FM_A(FM_WPR1),smc->hw.fp.fifo.rx1_fifo_start) ; /* WPR1 */
197 outpw(FM_A(FM_EARV1),smc->hw.fp.fifo.tx_s_start-1) ; /* EARV1 */
198
199 /*
200 * initialize the pointer for receive queue 2
201 */
202 if (smc->hw.fp.fifo.rx2_fifo_size) {
203 outpw(FM_A(FM_RPR2),smc->hw.fp.fifo.rx2_fifo_start) ;
204 outpw(FM_A(FM_SWPR2),smc->hw.fp.fifo.rx2_fifo_start) ;
205 outpw(FM_A(FM_WPR2),smc->hw.fp.fifo.rx2_fifo_start) ;
206 outpw(FM_A(FM_EARV2),smc->hw.fp.fifo.rbc_ram_end-1) ;
207 }
208 else {
209 outpw(FM_A(FM_RPR2),smc->hw.fp.fifo.rbc_ram_end-1) ;
210 outpw(FM_A(FM_SWPR2),smc->hw.fp.fifo.rbc_ram_end-1) ;
211 outpw(FM_A(FM_WPR2),smc->hw.fp.fifo.rbc_ram_end-1) ;
212 outpw(FM_A(FM_EARV2),smc->hw.fp.fifo.rbc_ram_end-1) ;
213 }
214 }
215
216 /*
217 * set transmit FIFO pointer
218 */
219 static void set_txptr(struct s_smc *smc)
220 {
221 outpw(FM_A(FM_CMDREG2),FM_IRSTQ) ; /* reset transmit queues */
222
223 /*
224 * initialize the pointer for asynchronous transmit queue
225 */
226 outpw(FM_A(FM_RPXA0),smc->hw.fp.fifo.tx_a0_start) ; /* RPXA0 */
227 outpw(FM_A(FM_SWPXA0),smc->hw.fp.fifo.tx_a0_start) ; /* SWPXA0 */
228 outpw(FM_A(FM_WPXA0),smc->hw.fp.fifo.tx_a0_start) ; /* WPXA0 */
229 outpw(FM_A(FM_EAA0),smc->hw.fp.fifo.rx2_fifo_start-1) ; /* EAA0 */
230
231 /*
232 * initialize the pointer for synchronous transmit queue
233 */
234 if (smc->hw.fp.fifo.tx_s_size) {
235 outpw(FM_A(FM_RPXS),smc->hw.fp.fifo.tx_s_start) ;
236 outpw(FM_A(FM_SWPXS),smc->hw.fp.fifo.tx_s_start) ;
237 outpw(FM_A(FM_WPXS),smc->hw.fp.fifo.tx_s_start) ;
238 outpw(FM_A(FM_EAS),smc->hw.fp.fifo.tx_a0_start-1) ;
239 }
240 else {
241 outpw(FM_A(FM_RPXS),smc->hw.fp.fifo.tx_a0_start-1) ;
242 outpw(FM_A(FM_SWPXS),smc->hw.fp.fifo.tx_a0_start-1) ;
243 outpw(FM_A(FM_WPXS),smc->hw.fp.fifo.tx_a0_start-1) ;
244 outpw(FM_A(FM_EAS),smc->hw.fp.fifo.tx_a0_start-1) ;
245 }
246 }
247
248 /*
249 * init memory buffer management registers
250 */
251 static void init_rbc(struct s_smc *smc)
252 {
253 u_short rbc_ram_addr ;
254
255 /*
256 * set unused pointers or permanent pointers
257 */
258 rbc_ram_addr = smc->hw.fp.fifo.rx2_fifo_start - 1 ;
259
260 outpw(FM_A(FM_RPXA1),rbc_ram_addr) ; /* a1-send pointer */
261 outpw(FM_A(FM_WPXA1),rbc_ram_addr) ;
262 outpw(FM_A(FM_SWPXA1),rbc_ram_addr) ;
263 outpw(FM_A(FM_EAA1),rbc_ram_addr) ;
264
265 set_recvptr(smc) ;
266 set_txptr(smc) ;
267 }
268
269 /*
270 * init rx pointer
271 */
272 static void init_rx(struct s_smc *smc)
273 {
274 struct s_smt_rx_queue *queue ;
275
276 /*
277 * init all tx data structures for receive queue 1
278 */
279 smc->hw.fp.rx[QUEUE_R1] = queue = &smc->hw.fp.rx_q[QUEUE_R1] ;
280 queue->rx_bmu_ctl = (HW_PTR) ADDR(B0_R1_CSR) ;
281 queue->rx_bmu_dsc = (HW_PTR) ADDR(B4_R1_DA) ;
282
283 /*
284 * init all tx data structures for receive queue 2
285 */
286 smc->hw.fp.rx[QUEUE_R2] = queue = &smc->hw.fp.rx_q[QUEUE_R2] ;
287 queue->rx_bmu_ctl = (HW_PTR) ADDR(B0_R2_CSR) ;
288 queue->rx_bmu_dsc = (HW_PTR) ADDR(B4_R2_DA) ;
289 }
290
291 /*
292 * set the TSYNC register of the FORMAC to regulate synchronous transmission
293 */
294 void set_formac_tsync(struct s_smc *smc, long sync_bw)
295 {
296 outpw(FM_A(FM_TSYNC),(unsigned int) (((-sync_bw) >> 5) & 0xffff) ) ;
297 }
298
299 /*
300 * init all tx data structures
301 */
302 static void init_tx(struct s_smc *smc)
303 {
304 struct s_smt_tx_queue *queue ;
305
306 /*
307 * init all tx data structures for the synchronous queue
308 */
309 smc->hw.fp.tx[QUEUE_S] = queue = &smc->hw.fp.tx_q[QUEUE_S] ;
310 queue->tx_bmu_ctl = (HW_PTR) ADDR(B0_XS_CSR) ;
311 queue->tx_bmu_dsc = (HW_PTR) ADDR(B5_XS_DA) ;
312
313 #ifdef ESS
314 set_formac_tsync(smc,smc->ess.sync_bw) ;
315 #endif
316
317 /*
318 * init all tx data structures for the asynchronous queue 0
319 */
320 smc->hw.fp.tx[QUEUE_A0] = queue = &smc->hw.fp.tx_q[QUEUE_A0] ;
321 queue->tx_bmu_ctl = (HW_PTR) ADDR(B0_XA_CSR) ;
322 queue->tx_bmu_dsc = (HW_PTR) ADDR(B5_XA_DA) ;
323
324
325 llc_recover_tx(smc) ;
326 }
327
328 static void mac_counter_init(struct s_smc *smc)
329 {
330 int i ;
331 u_long *ec ;
332
333 /*
334 * clear FORMAC+ frame-, lost- and error counter
335 */
336 outpw(FM_A(FM_FCNTR),0) ;
337 outpw(FM_A(FM_LCNTR),0) ;
338 outpw(FM_A(FM_ECNTR),0) ;
339 /*
340 * clear internal error counter structure
341 */
342 ec = (u_long *)&smc->hw.fp.err_stats ;
343 for (i = (sizeof(struct err_st)/sizeof(long)) ; i ; i--)
344 *ec++ = 0L ;
345 smc->mib.m[MAC0].fddiMACRingOp_Ct = 0 ;
346 }
347
348 /*
349 * set FORMAC address, and t_request
350 */
351 static void set_formac_addr(struct s_smc *smc)
352 {
353 long t_requ = smc->mib.m[MAC0].fddiMACT_Req ;
354
355 outpw(FM_A(FM_SAID),my_said) ; /* set short address */
356 outpw(FM_A(FM_LAIL),(unsigned short)((smc->hw.fddi_home_addr.a[4]<<8) +
357 smc->hw.fddi_home_addr.a[5])) ;
358 outpw(FM_A(FM_LAIC),(unsigned short)((smc->hw.fddi_home_addr.a[2]<<8) +
359 smc->hw.fddi_home_addr.a[3])) ;
360 outpw(FM_A(FM_LAIM),(unsigned short)((smc->hw.fddi_home_addr.a[0]<<8) +
361 smc->hw.fddi_home_addr.a[1])) ;
362
363 outpw(FM_A(FM_SAGP),my_sagp) ; /* set short group address */
364
365 outpw(FM_A(FM_LAGL),(unsigned short)((smc->hw.fp.group_addr.a[4]<<8) +
366 smc->hw.fp.group_addr.a[5])) ;
367 outpw(FM_A(FM_LAGC),(unsigned short)((smc->hw.fp.group_addr.a[2]<<8) +
368 smc->hw.fp.group_addr.a[3])) ;
369 outpw(FM_A(FM_LAGM),(unsigned short)((smc->hw.fp.group_addr.a[0]<<8) +
370 smc->hw.fp.group_addr.a[1])) ;
371
372 /* set r_request regs. (MSW & LSW of TRT ) */
373 outpw(FM_A(FM_TREQ1),(unsigned short)(t_requ>>16)) ;
374 outpw(FM_A(FM_TREQ0),(unsigned short)t_requ) ;
375 }
376
377 static void set_int(char *p, int l)
378 {
379 p[0] = (char)(l >> 24) ;
380 p[1] = (char)(l >> 16) ;
381 p[2] = (char)(l >> 8) ;
382 p[3] = (char)(l >> 0) ;
383 }
384
385 /*
386 * copy TX descriptor to buffer mem
387 * append FC field and MAC frame
388 * if more bit is set in descr
389 * append pointer to descriptor (endless loop)
390 * else
391 * append 'end of chain' pointer
392 */
393 static void copy_tx_mac(struct s_smc *smc, u_long td, struct fddi_mac *mac,
394 unsigned int off, int len)
395 /* u_long td; transmit descriptor */
396 /* struct fddi_mac *mac; mac frame pointer */
397 /* unsigned int off; start address within buffer memory */
398 /* int len ; length of the frame including the FC */
399 {
400 int i ;
401 __le32 *p ;
402
403 CHECK_NPP() ;
404 MARW(off) ; /* set memory address reg for writes */
405
406 p = (__le32 *) mac ;
407 for (i = (len + 3)/4 ; i ; i--) {
408 if (i == 1) {
409 /* last word, set the tag bit */
410 outpw(FM_A(FM_CMDREG2),FM_ISTTB) ;
411 }
412 write_mdr(smc,le32_to_cpu(*p)) ;
413 p++ ;
414 }
415
416 outpw(FM_A(FM_CMDREG2),FM_ISTTB) ; /* set the tag bit */
417 write_mdr(smc,td) ; /* write over memory data reg to buffer */
418 }
419
420 /*
421 BEGIN_MANUAL_ENTRY(module;tests;3)
422 How to test directed beacon frames
423 ----------------------------------------------------------------
424
425 o Insert a break point in the function build_claim_beacon()
426 before calling copy_tx_mac() for building the claim frame.
427 o Modify the RM3_DETECT case so that the RM6_DETECT state
428 will always entered from the RM3_DETECT state (function rmt_fsm(),
429 rmt.c)
430 o Compile the driver.
431 o Set the parameter TREQ in the protocol.ini or net.cfg to a
432 small value to make sure your station will win the claim
433 process.
434 o Start the driver.
435 o When you reach the break point, modify the SA and DA address
436 of the claim frame (e.g. SA = DA = 10005affffff).
437 o When you see RM3_DETECT and RM6_DETECT, observe the direct
438 beacon frames on the UPPSLANA.
439
440 END_MANUAL_ENTRY
441 */
442 static void directed_beacon(struct s_smc *smc)
443 {
444 SK_LOC_DECL(__le32,a[2]) ;
445
446 /*
447 * set UNA in frame
448 * enable FORMAC to send endless queue of directed beacon
449 * important: the UNA starts at byte 1 (not at byte 0)
450 */
451 * (char *) a = (char) ((long)DBEACON_INFO<<24L) ;
452 a[1] = 0 ;
453 memcpy((char *)a+1, (char *) &smc->mib.m[MAC0].fddiMACUpstreamNbr, ETH_ALEN);
454
455 CHECK_NPP() ;
456 /* set memory address reg for writes */
457 MARW(smc->hw.fp.fifo.rbc_ram_start+DBEACON_FRAME_OFF+4) ;
458 write_mdr(smc,le32_to_cpu(a[0])) ;
459 outpw(FM_A(FM_CMDREG2),FM_ISTTB) ; /* set the tag bit */
460 write_mdr(smc,le32_to_cpu(a[1])) ;
461
462 outpw(FM_A(FM_SABC),smc->hw.fp.fifo.rbc_ram_start + DBEACON_FRAME_OFF) ;
463 }
464
465 /*
466 setup claim & beacon pointer
467 NOTE :
468 special frame packets end with a pointer to their own
469 descriptor, and the MORE bit is set in the descriptor
470 */
471 static void build_claim_beacon(struct s_smc *smc, u_long t_request)
472 {
473 u_int td ;
474 int len ;
475 struct fddi_mac_sf *mac ;
476
477 /*
478 * build claim packet
479 */
480 len = 17 ;
481 td = TX_DESCRIPTOR | ((((u_int)len-1)&3)<<27) ;
482 mac = &smc->hw.fp.mac_sfb ;
483 mac->mac_fc = FC_CLAIM ;
484 /* DA == SA in claim frame */
485 mac->mac_source = mac->mac_dest = MA ;
486 /* 2's complement */
487 set_int((char *)mac->mac_info,(int)t_request) ;
488
489 copy_tx_mac(smc,td,(struct fddi_mac *)mac,
490 smc->hw.fp.fifo.rbc_ram_start + CLAIM_FRAME_OFF,len) ;
491 /* set CLAIM start pointer */
492 outpw(FM_A(FM_SACL),smc->hw.fp.fifo.rbc_ram_start + CLAIM_FRAME_OFF) ;
493
494 /*
495 * build beacon packet
496 */
497 len = 17 ;
498 td = TX_DESCRIPTOR | ((((u_int)len-1)&3)<<27) ;
499 mac->mac_fc = FC_BEACON ;
500 mac->mac_source = MA ;
501 mac->mac_dest = null_addr ; /* DA == 0 in beacon frame */
502 set_int((char *) mac->mac_info,((int)BEACON_INFO<<24) + 0 ) ;
503
504 copy_tx_mac(smc,td,(struct fddi_mac *)mac,
505 smc->hw.fp.fifo.rbc_ram_start + BEACON_FRAME_OFF,len) ;
506 /* set beacon start pointer */
507 outpw(FM_A(FM_SABC),smc->hw.fp.fifo.rbc_ram_start + BEACON_FRAME_OFF) ;
508
509 /*
510 * build directed beacon packet
511 * contains optional UNA
512 */
513 len = 23 ;
514 td = TX_DESCRIPTOR | ((((u_int)len-1)&3)<<27) ;
515 mac->mac_fc = FC_BEACON ;
516 mac->mac_source = MA ;
517 mac->mac_dest = dbeacon_multi ; /* multicast */
518 set_int((char *) mac->mac_info,((int)DBEACON_INFO<<24) + 0 ) ;
519 set_int((char *) mac->mac_info+4,0) ;
520 set_int((char *) mac->mac_info+8,0) ;
521
522 copy_tx_mac(smc,td,(struct fddi_mac *)mac,
523 smc->hw.fp.fifo.rbc_ram_start + DBEACON_FRAME_OFF,len) ;
524
525 /* end of claim/beacon queue */
526 outpw(FM_A(FM_EACB),smc->hw.fp.fifo.rx1_fifo_start-1) ;
527
528 outpw(FM_A(FM_WPXSF),0) ;
529 outpw(FM_A(FM_RPXSF),0) ;
530 }
531
532 static void formac_rcv_restart(struct s_smc *smc)
533 {
534 /* enable receive function */
535 SETMASK(FM_A(FM_MDREG1),smc->hw.fp.rx_mode,FM_ADDRX) ;
536
537 outpw(FM_A(FM_CMDREG1),FM_ICLLR) ; /* clear receive lock */
538 }
539
540 void formac_tx_restart(struct s_smc *smc)
541 {
542 outpw(FM_A(FM_CMDREG1),FM_ICLLS) ; /* clear s-frame lock */
543 outpw(FM_A(FM_CMDREG1),FM_ICLLA0) ; /* clear a-frame lock */
544 }
545
546 static void enable_formac(struct s_smc *smc)
547 {
548 /* set formac IMSK : 0 enables irq */
549 outpw(FM_A(FM_IMSK1U),(unsigned short)~mac_imsk1u);
550 outpw(FM_A(FM_IMSK1L),(unsigned short)~mac_imsk1l);
551 outpw(FM_A(FM_IMSK2U),(unsigned short)~mac_imsk2u);
552 outpw(FM_A(FM_IMSK2L),(unsigned short)~mac_imsk2l);
553 outpw(FM_A(FM_IMSK3U),(unsigned short)~mac_imsk3u);
554 outpw(FM_A(FM_IMSK3L),(unsigned short)~mac_imsk3l);
555 }
556
557 #if 0 /* Removed because the driver should use the ASICs TX complete IRQ. */
558 /* The FORMACs tx complete IRQ should be used any longer */
559
560 /*
561 BEGIN_MANUAL_ENTRY(if,func;others;4)
562
563 void enable_tx_irq(smc, queue)
564 struct s_smc *smc ;
565 u_short queue ;
566
567 Function DOWNCALL (SMT, fplustm.c)
568 enable_tx_irq() enables the FORMACs transmit complete
569 interrupt of the queue.
570
571 Para queue = QUEUE_S: synchronous queue
572 = QUEUE_A0: asynchronous queue
573
574 Note After any ring operational change the transmit complete
575 interrupts are disabled.
576 The operating system dependent module must enable
577 the transmit complete interrupt of a queue,
578 - when it queues the first frame,
579 because of no transmit resources are beeing
580 available and
581 - when it escapes from the function llc_restart_tx
582 while some frames are still queued.
583
584 END_MANUAL_ENTRY
585 */
586 void enable_tx_irq(struct s_smc *smc, u_short queue)
587 /* u_short queue; 0 = synchronous queue, 1 = asynchronous queue 0 */
588 {
589 u_short imask ;
590
591 imask = ~(inpw(FM_A(FM_IMSK1U))) ;
592
593 if (queue == 0) {
594 outpw(FM_A(FM_IMSK1U),~(imask|FM_STEFRMS)) ;
595 }
596 if (queue == 1) {
597 outpw(FM_A(FM_IMSK1U),~(imask|FM_STEFRMA0)) ;
598 }
599 }
600
601 /*
602 BEGIN_MANUAL_ENTRY(if,func;others;4)
603
604 void disable_tx_irq(smc, queue)
605 struct s_smc *smc ;
606 u_short queue ;
607
608 Function DOWNCALL (SMT, fplustm.c)
609 disable_tx_irq disables the FORMACs transmit complete
610 interrupt of the queue
611
612 Para queue = QUEUE_S: synchronous queue
613 = QUEUE_A0: asynchronous queue
614
615 Note The operating system dependent module should disable
616 the transmit complete interrupts if it escapes from the
617 function llc_restart_tx and no frames are queued.
618
619 END_MANUAL_ENTRY
620 */
621 void disable_tx_irq(struct s_smc *smc, u_short queue)
622 /* u_short queue; 0 = synchronous queue, 1 = asynchronous queue 0 */
623 {
624 u_short imask ;
625
626 imask = ~(inpw(FM_A(FM_IMSK1U))) ;
627
628 if (queue == 0) {
629 outpw(FM_A(FM_IMSK1U),~(imask&~FM_STEFRMS)) ;
630 }
631 if (queue == 1) {
632 outpw(FM_A(FM_IMSK1U),~(imask&~FM_STEFRMA0)) ;
633 }
634 }
635 #endif
636
637 static void disable_formac(struct s_smc *smc)
638 {
639 /* clear formac IMSK : 1 disables irq */
640 outpw(FM_A(FM_IMSK1U),MW) ;
641 outpw(FM_A(FM_IMSK1L),MW) ;
642 outpw(FM_A(FM_IMSK2U),MW) ;
643 outpw(FM_A(FM_IMSK2L),MW) ;
644 outpw(FM_A(FM_IMSK3U),MW) ;
645 outpw(FM_A(FM_IMSK3L),MW) ;
646 }
647
648
649 static void mac_ring_up(struct s_smc *smc, int up)
650 {
651 if (up) {
652 formac_rcv_restart(smc) ; /* enable receive function */
653 smc->hw.mac_ring_is_up = TRUE ;
654 llc_restart_tx(smc) ; /* TX queue */
655 }
656 else {
657 /* disable receive function */
658 SETMASK(FM_A(FM_MDREG1),FM_MDISRCV,FM_ADDET) ;
659
660 /* abort current transmit activity */
661 outpw(FM_A(FM_CMDREG2),FM_IACTR) ;
662
663 smc->hw.mac_ring_is_up = FALSE ;
664 }
665 }
666
667 /*--------------------------- ISR handling ----------------------------------*/
668 /*
669 * mac1_irq is in drvfbi.c
670 */
671
672 /*
673 * mac2_irq: status bits for the receive queue 1, and ring status
674 * ring status indication bits
675 */
676 void mac2_irq(struct s_smc *smc, u_short code_s2u, u_short code_s2l)
677 {
678 u_short change_s2l ;
679 u_short change_s2u ;
680
681 /* (jd) 22-Feb-1999
682 * Restart 2_DMax Timer after end of claiming or beaconing
683 */
684 if (code_s2u & (FM_SCLM|FM_SHICLM|FM_SBEC|FM_SOTRBEC)) {
685 queue_event(smc,EVENT_RMT,RM_TX_STATE_CHANGE) ;
686 }
687 else if (code_s2l & (FM_STKISS)) {
688 queue_event(smc,EVENT_RMT,RM_TX_STATE_CHANGE) ;
689 }
690
691 /*
692 * XOR current st bits with the last to avoid useless RMT event queuing
693 */
694 change_s2l = smc->hw.fp.s2l ^ code_s2l ;
695 change_s2u = smc->hw.fp.s2u ^ code_s2u ;
696
697 if ((change_s2l & FM_SRNGOP) ||
698 (!smc->hw.mac_ring_is_up && ((code_s2l & FM_SRNGOP)))) {
699 if (code_s2l & FM_SRNGOP) {
700 mac_ring_up(smc,1) ;
701 queue_event(smc,EVENT_RMT,RM_RING_OP) ;
702 smc->mib.m[MAC0].fddiMACRingOp_Ct++ ;
703 }
704 else {
705 mac_ring_up(smc,0) ;
706 queue_event(smc,EVENT_RMT,RM_RING_NON_OP) ;
707 }
708 goto mac2_end ;
709 }
710 if (code_s2l & FM_SMISFRM) { /* missed frame */
711 smc->mib.m[MAC0].fddiMACNotCopied_Ct++ ;
712 }
713 if (code_s2u & (FM_SRCVOVR | /* recv. FIFO overflow */
714 FM_SRBFL)) { /* recv. buffer full */
715 smc->hw.mac_ct.mac_r_restart_counter++ ;
716 /* formac_rcv_restart(smc) ; */
717 smt_stat_counter(smc,1) ;
718 /* goto mac2_end ; */
719 }
720 if (code_s2u & FM_SOTRBEC)
721 queue_event(smc,EVENT_RMT,RM_OTHER_BEACON) ;
722 if (code_s2u & FM_SMYBEC)
723 queue_event(smc,EVENT_RMT,RM_MY_BEACON) ;
724 if (change_s2u & code_s2u & FM_SLOCLM) {
725 DB_RMTN(2, "RMT : lower claim received");
726 }
727 if ((code_s2u & FM_SMYCLM) && !(code_s2l & FM_SDUPCLM)) {
728 /*
729 * This is my claim and that claim is not detected as a
730 * duplicate one.
731 */
732 queue_event(smc,EVENT_RMT,RM_MY_CLAIM) ;
733 }
734 if (code_s2l & FM_SDUPCLM) {
735 /*
736 * If a duplicate claim frame (same SA but T_Bid != T_Req)
737 * this flag will be set.
738 * In the RMT state machine we need a RM_VALID_CLAIM event
739 * to do the appropriate state change.
740 * RM(34c)
741 */
742 queue_event(smc,EVENT_RMT,RM_VALID_CLAIM) ;
743 }
744 if (change_s2u & code_s2u & FM_SHICLM) {
745 DB_RMTN(2, "RMT : higher claim received");
746 }
747 if ( (code_s2l & FM_STRTEXP) ||
748 (code_s2l & FM_STRTEXR) )
749 queue_event(smc,EVENT_RMT,RM_TRT_EXP) ;
750 if (code_s2l & FM_SMULTDA) {
751 /*
752 * The MAC has found a 2. MAC with the same address.
753 * Signal dup_addr_test = failed to RMT state machine.
754 * RM(25)
755 */
756 smc->r.dup_addr_test = DA_FAILED ;
757 queue_event(smc,EVENT_RMT,RM_DUP_ADDR) ;
758 }
759 if (code_s2u & FM_SBEC)
760 smc->hw.fp.err_stats.err_bec_stat++ ;
761 if (code_s2u & FM_SCLM)
762 smc->hw.fp.err_stats.err_clm_stat++ ;
763 if (code_s2l & FM_STVXEXP)
764 smc->mib.m[MAC0].fddiMACTvxExpired_Ct++ ;
765 if ((code_s2u & (FM_SBEC|FM_SCLM))) {
766 if (!(change_s2l & FM_SRNGOP) && (smc->hw.fp.s2l & FM_SRNGOP)) {
767 mac_ring_up(smc,0) ;
768 queue_event(smc,EVENT_RMT,RM_RING_NON_OP) ;
769
770 mac_ring_up(smc,1) ;
771 queue_event(smc,EVENT_RMT,RM_RING_OP) ;
772 smc->mib.m[MAC0].fddiMACRingOp_Ct++ ;
773 }
774 }
775 if (code_s2l & FM_SPHINV)
776 smc->hw.fp.err_stats.err_phinv++ ;
777 if (code_s2l & FM_SSIFG)
778 smc->hw.fp.err_stats.err_sifg_det++ ;
779 if (code_s2l & FM_STKISS)
780 smc->hw.fp.err_stats.err_tkiss++ ;
781 if (code_s2l & FM_STKERR)
782 smc->hw.fp.err_stats.err_tkerr++ ;
783 if (code_s2l & FM_SFRMCTR)
784 smc->mib.m[MAC0].fddiMACFrame_Ct += 0x10000L ;
785 if (code_s2l & FM_SERRCTR)
786 smc->mib.m[MAC0].fddiMACError_Ct += 0x10000L ;
787 if (code_s2l & FM_SLSTCTR)
788 smc->mib.m[MAC0].fddiMACLost_Ct += 0x10000L ;
789 if (code_s2u & FM_SERRSF) {
790 SMT_PANIC(smc,SMT_E0114, SMT_E0114_MSG) ;
791 }
792 mac2_end:
793 /* notice old status */
794 smc->hw.fp.s2l = code_s2l ;
795 smc->hw.fp.s2u = code_s2u ;
796 outpw(FM_A(FM_IMSK2U),~mac_imsk2u) ;
797 }
798
799 /*
800 * mac3_irq: receive queue 2 bits and address detection bits
801 */
802 void mac3_irq(struct s_smc *smc, u_short code_s3u, u_short code_s3l)
803 {
804 UNUSED(code_s3l) ;
805
806 if (code_s3u & (FM_SRCVOVR2 | /* recv. FIFO overflow */
807 FM_SRBFL2)) { /* recv. buffer full */
808 smc->hw.mac_ct.mac_r_restart_counter++ ;
809 smt_stat_counter(smc,1);
810 }
811
812
813 if (code_s3u & FM_SRPERRQ2) { /* parity error receive queue 2 */
814 SMT_PANIC(smc,SMT_E0115, SMT_E0115_MSG) ;
815 }
816 if (code_s3u & FM_SRPERRQ1) { /* parity error receive queue 2 */
817 SMT_PANIC(smc,SMT_E0116, SMT_E0116_MSG) ;
818 }
819 }
820
821
822 /*
823 * take formac offline
824 */
825 static void formac_offline(struct s_smc *smc)
826 {
827 outpw(FM_A(FM_CMDREG2),FM_IACTR) ;/* abort current transmit activity */
828
829 /* disable receive function */
830 SETMASK(FM_A(FM_MDREG1),FM_MDISRCV,FM_ADDET) ;
831
832 /* FORMAC+ 'Initialize Mode' */
833 SETMASK(FM_A(FM_MDREG1),FM_MINIT,FM_MMODE) ;
834
835 disable_formac(smc) ;
836 smc->hw.mac_ring_is_up = FALSE ;
837 smc->hw.hw_state = STOPPED ;
838 }
839
840 /*
841 * bring formac online
842 */
843 static void formac_online(struct s_smc *smc)
844 {
845 enable_formac(smc) ;
846 SETMASK(FM_A(FM_MDREG1),FM_MONLINE | FM_SELRA | MDR1INIT |
847 smc->hw.fp.rx_mode, FM_MMODE | FM_SELRA | FM_ADDRX) ;
848 }
849
850 /*
851 * FORMAC+ full init. (tx, rx, timer, counter, claim & beacon)
852 */
853 int init_fplus(struct s_smc *smc)
854 {
855 smc->hw.fp.nsa_mode = FM_MRNNSAFNMA ;
856 smc->hw.fp.rx_mode = FM_MDAMA ;
857 smc->hw.fp.group_addr = fddi_broadcast ;
858 smc->hw.fp.func_addr = 0 ;
859 smc->hw.fp.frselreg_init = 0 ;
860
861 init_driver_fplus(smc) ;
862 if (smc->s.sas == SMT_DAS)
863 smc->hw.fp.mdr3init |= FM_MENDAS ;
864
865 smc->hw.mac_ct.mac_nobuf_counter = 0 ;
866 smc->hw.mac_ct.mac_r_restart_counter = 0 ;
867
868 smc->hw.fp.fm_st1u = (HW_PTR) ADDR(B0_ST1U) ;
869 smc->hw.fp.fm_st1l = (HW_PTR) ADDR(B0_ST1L) ;
870 smc->hw.fp.fm_st2u = (HW_PTR) ADDR(B0_ST2U) ;
871 smc->hw.fp.fm_st2l = (HW_PTR) ADDR(B0_ST2L) ;
872 smc->hw.fp.fm_st3u = (HW_PTR) ADDR(B0_ST3U) ;
873 smc->hw.fp.fm_st3l = (HW_PTR) ADDR(B0_ST3L) ;
874
875 smc->hw.fp.s2l = smc->hw.fp.s2u = 0 ;
876 smc->hw.mac_ring_is_up = 0 ;
877
878 mac_counter_init(smc) ;
879
880 /* convert BCKL units to symbol time */
881 smc->hw.mac_pa.t_neg = (u_long)0 ;
882 smc->hw.mac_pa.t_pri = (u_long)0 ;
883
884 /* make sure all PCI settings are correct */
885 mac_do_pci_fix(smc) ;
886
887 return init_mac(smc, 1);
888 /* enable_formac(smc) ; */
889 }
890
891 static int init_mac(struct s_smc *smc, int all)
892 {
893 u_short t_max,x ;
894 u_long time=0 ;
895
896 /*
897 * clear memory
898 */
899 outpw(FM_A(FM_MDREG1),FM_MINIT) ; /* FORMAC+ init mode */
900 set_formac_addr(smc) ;
901 outpw(FM_A(FM_MDREG1),FM_MMEMACT) ; /* FORMAC+ memory activ mode */
902 /* Note: Mode register 2 is set here, incase parity is enabled. */
903 outpw(FM_A(FM_MDREG2),smc->hw.fp.mdr2init) ;
904
905 if (all) {
906 init_ram(smc) ;
907 }
908 else {
909 /*
910 * reset the HPI, the Master and the BMUs
911 */
912 outp(ADDR(B0_CTRL), CTRL_HPI_SET) ;
913 time = hwt_quick_read(smc) ;
914 }
915
916 /*
917 * set all pointers, frames etc
918 */
919 smt_split_up_fifo(smc) ;
920
921 init_tx(smc) ;
922 init_rx(smc) ;
923 init_rbc(smc) ;
924
925 build_claim_beacon(smc,smc->mib.m[MAC0].fddiMACT_Req) ;
926
927 /* set RX threshold */
928 /* see Errata #SN2 Phantom receive overflow */
929 outpw(FM_A(FM_FRMTHR),14<<12) ; /* switch on */
930
931 /* set formac work mode */
932 outpw(FM_A(FM_MDREG1),MDR1INIT | FM_SELRA | smc->hw.fp.rx_mode) ;
933 outpw(FM_A(FM_MDREG2),smc->hw.fp.mdr2init) ;
934 outpw(FM_A(FM_MDREG3),smc->hw.fp.mdr3init) ;
935 outpw(FM_A(FM_FRSELREG),smc->hw.fp.frselreg_init) ;
936
937 /* set timer */
938 /*
939 * errata #22 fplus:
940 * T_MAX must not be FFFE
941 * or one of FFDF, FFB8, FF91 (-0x27 etc..)
942 */
943 t_max = (u_short)(smc->mib.m[MAC0].fddiMACT_Max/32) ;
944 x = t_max/0x27 ;
945 x *= 0x27 ;
946 if ((t_max == 0xfffe) || (t_max - x == 0x16))
947 t_max-- ;
948 outpw(FM_A(FM_TMAX),(u_short)t_max) ;
949
950 /* BugFix for report #10204 */
951 if (smc->mib.m[MAC0].fddiMACTvxValue < (u_long) (- US2BCLK(52))) {
952 outpw(FM_A(FM_TVX), (u_short) (- US2BCLK(52))/255 & MB) ;
953 } else {
954 outpw(FM_A(FM_TVX),
955 (u_short)((smc->mib.m[MAC0].fddiMACTvxValue/255) & MB)) ;
956 }
957
958 outpw(FM_A(FM_CMDREG1),FM_ICLLS) ; /* clear s-frame lock */
959 outpw(FM_A(FM_CMDREG1),FM_ICLLA0) ; /* clear a-frame lock */
960 outpw(FM_A(FM_CMDREG1),FM_ICLLR); /* clear receive lock */
961
962 /* Auto unlock receice threshold for receive queue 1 and 2 */
963 outpw(FM_A(FM_UNLCKDLY),(0xff|(0xff<<8))) ;
964
965 rtm_init(smc) ; /* RT-Monitor */
966
967 if (!all) {
968 /*
969 * after 10ms, reset the BMUs and repair the rings
970 */
971 hwt_wait_time(smc,time,MS2BCLK(10)) ;
972 outpd(ADDR(B0_R1_CSR),CSR_SET_RESET) ;
973 outpd(ADDR(B0_XA_CSR),CSR_SET_RESET) ;
974 outpd(ADDR(B0_XS_CSR),CSR_SET_RESET) ;
975 outp(ADDR(B0_CTRL), CTRL_HPI_CLR) ;
976 outpd(ADDR(B0_R1_CSR),CSR_CLR_RESET) ;
977 outpd(ADDR(B0_XA_CSR),CSR_CLR_RESET) ;
978 outpd(ADDR(B0_XS_CSR),CSR_CLR_RESET) ;
979 if (!smc->hw.hw_is_64bit) {
980 outpd(ADDR(B4_R1_F), RX_WATERMARK) ;
981 outpd(ADDR(B5_XA_F), TX_WATERMARK) ;
982 outpd(ADDR(B5_XS_F), TX_WATERMARK) ;
983 }
984 smc->hw.hw_state = STOPPED ;
985 mac_drv_repair_descr(smc) ;
986 }
987 smc->hw.hw_state = STARTED ;
988
989 return 0;
990 }
991
992
993 /*
994 * called by CFM
995 */
996 void config_mux(struct s_smc *smc, int mux)
997 {
998 plc_config_mux(smc,mux) ;
999
1000 SETMASK(FM_A(FM_MDREG1),FM_SELRA,FM_SELRA) ;
1001 }
1002
1003 /*
1004 * called by RMT
1005 * enable CLAIM/BEACON interrupts
1006 * (only called if these events are of interest, e.g. in DETECT state
1007 * the interrupt must not be permanently enabled
1008 * RMT calls this function periodically (timer driven polling)
1009 */
1010 void sm_mac_check_beacon_claim(struct s_smc *smc)
1011 {
1012 /* set formac IMSK : 0 enables irq */
1013 outpw(FM_A(FM_IMSK2U),~(mac_imsk2u | mac_beacon_imsk2u)) ;
1014 /* the driver must receive the directed beacons */
1015 formac_rcv_restart(smc) ;
1016 process_receive(smc) ;
1017 }
1018
1019 /*-------------------------- interface functions ----------------------------*/
1020 /*
1021 * control MAC layer (called by RMT)
1022 */
1023 void sm_ma_control(struct s_smc *smc, int mode)
1024 {
1025 switch(mode) {
1026 case MA_OFFLINE :
1027 /* Add to make the MAC offline in RM0_ISOLATED state */
1028 formac_offline(smc) ;
1029 break ;
1030 case MA_RESET :
1031 (void)init_mac(smc,0) ;
1032 break ;
1033 case MA_BEACON :
1034 formac_online(smc) ;
1035 break ;
1036 case MA_DIRECTED :
1037 directed_beacon(smc) ;
1038 break ;
1039 case MA_TREQ :
1040 /*
1041 * no actions necessary, TREQ is already set
1042 */
1043 break ;
1044 }
1045 }
1046
1047 int sm_mac_get_tx_state(struct s_smc *smc)
1048 {
1049 return (inpw(FM_A(FM_STMCHN))>>4) & 7;
1050 }
1051
1052 /*
1053 * multicast functions
1054 */
1055
1056 static struct s_fpmc* mac_get_mc_table(struct s_smc *smc,
1057 struct fddi_addr *user,
1058 struct fddi_addr *own,
1059 int del, int can)
1060 {
1061 struct s_fpmc *tb ;
1062 struct s_fpmc *slot ;
1063 u_char *p ;
1064 int i ;
1065
1066 /*
1067 * set own = can(user)
1068 */
1069 *own = *user ;
1070 if (can) {
1071 p = own->a ;
1072 for (i = 0 ; i < 6 ; i++, p++)
1073 *p = bitrev8(*p);
1074 }
1075 slot = NULL;
1076 for (i = 0, tb = smc->hw.fp.mc.table ; i < FPMAX_MULTICAST ; i++, tb++){
1077 if (!tb->n) { /* not used */
1078 if (!del && !slot) /* if !del save first free */
1079 slot = tb ;
1080 continue ;
1081 }
1082 if (!ether_addr_equal((char *)&tb->a, (char *)own))
1083 continue ;
1084 return tb;
1085 }
1086 return slot; /* return first free or NULL */
1087 }
1088
1089 /*
1090 BEGIN_MANUAL_ENTRY(if,func;others;2)
1091
1092 void mac_clear_multicast(smc)
1093 struct s_smc *smc ;
1094
1095 Function DOWNCALL (SMT, fplustm.c)
1096 Clear all multicast entries
1097
1098 END_MANUAL_ENTRY()
1099 */
1100 void mac_clear_multicast(struct s_smc *smc)
1101 {
1102 struct s_fpmc *tb ;
1103 int i ;
1104
1105 smc->hw.fp.os_slots_used = 0 ; /* note the SMT addresses */
1106 /* will not be deleted */
1107 for (i = 0, tb = smc->hw.fp.mc.table ; i < FPMAX_MULTICAST ; i++, tb++){
1108 if (!tb->perm) {
1109 tb->n = 0 ;
1110 }
1111 }
1112 }
1113
1114 /*
1115 BEGIN_MANUAL_ENTRY(if,func;others;2)
1116
1117 int mac_add_multicast(smc,addr,can)
1118 struct s_smc *smc ;
1119 struct fddi_addr *addr ;
1120 int can ;
1121
1122 Function DOWNCALL (SMC, fplustm.c)
1123 Add an entry to the multicast table
1124
1125 Para addr pointer to a multicast address
1126 can = 0: the multicast address has the physical format
1127 = 1: the multicast address has the canonical format
1128 | 0x80 permanent
1129
1130 Returns 0: success
1131 1: address table full
1132
1133 Note After a 'driver reset' or a 'station set address' all
1134 entries of the multicast table are cleared.
1135 In this case the driver has to fill the multicast table again.
1136 After the operating system dependent module filled
1137 the multicast table it must call mac_update_multicast
1138 to activate the new multicast addresses!
1139
1140 END_MANUAL_ENTRY()
1141 */
1142 int mac_add_multicast(struct s_smc *smc, struct fddi_addr *addr, int can)
1143 {
1144 SK_LOC_DECL(struct fddi_addr,own) ;
1145 struct s_fpmc *tb ;
1146
1147 /*
1148 * check if there are free table entries
1149 */
1150 if (can & 0x80) {
1151 if (smc->hw.fp.smt_slots_used >= SMT_MAX_MULTI) {
1152 return 1;
1153 }
1154 }
1155 else {
1156 if (smc->hw.fp.os_slots_used >= FPMAX_MULTICAST-SMT_MAX_MULTI) {
1157 return 1;
1158 }
1159 }
1160
1161 /*
1162 * find empty slot
1163 */
1164 if (!(tb = mac_get_mc_table(smc,addr,&own,0,can & ~0x80)))
1165 return 1;
1166 tb->n++ ;
1167 tb->a = own ;
1168 tb->perm = (can & 0x80) ? 1 : 0 ;
1169
1170 if (can & 0x80)
1171 smc->hw.fp.smt_slots_used++ ;
1172 else
1173 smc->hw.fp.os_slots_used++ ;
1174
1175 return 0;
1176 }
1177
1178 /*
1179 * mode
1180 */
1181
1182 #define RX_MODE_PROM 0x1
1183 #define RX_MODE_ALL_MULTI 0x2
1184
1185 /*
1186 BEGIN_MANUAL_ENTRY(if,func;others;2)
1187
1188 void mac_update_multicast(smc)
1189 struct s_smc *smc ;
1190
1191 Function DOWNCALL (SMT, fplustm.c)
1192 Update FORMAC multicast registers
1193
1194 END_MANUAL_ENTRY()
1195 */
1196 void mac_update_multicast(struct s_smc *smc)
1197 {
1198 struct s_fpmc *tb ;
1199 u_char *fu ;
1200 int i ;
1201
1202 /*
1203 * invalidate the CAM
1204 */
1205 outpw(FM_A(FM_AFCMD),FM_IINV_CAM) ;
1206
1207 /*
1208 * set the functional address
1209 */
1210 if (smc->hw.fp.func_addr) {
1211 fu = (u_char *) &smc->hw.fp.func_addr ;
1212 outpw(FM_A(FM_AFMASK2),0xffff) ;
1213 outpw(FM_A(FM_AFMASK1),(u_short) ~((fu[0] << 8) + fu[1])) ;
1214 outpw(FM_A(FM_AFMASK0),(u_short) ~((fu[2] << 8) + fu[3])) ;
1215 outpw(FM_A(FM_AFPERS),FM_VALID|FM_DA) ;
1216 outpw(FM_A(FM_AFCOMP2), 0xc000) ;
1217 outpw(FM_A(FM_AFCOMP1), 0x0000) ;
1218 outpw(FM_A(FM_AFCOMP0), 0x0000) ;
1219 outpw(FM_A(FM_AFCMD),FM_IWRITE_CAM) ;
1220 }
1221
1222 /*
1223 * set the mask and the personality register(s)
1224 */
1225 outpw(FM_A(FM_AFMASK0),0xffff) ;
1226 outpw(FM_A(FM_AFMASK1),0xffff) ;
1227 outpw(FM_A(FM_AFMASK2),0xffff) ;
1228 outpw(FM_A(FM_AFPERS),FM_VALID|FM_DA) ;
1229
1230 for (i = 0, tb = smc->hw.fp.mc.table; i < FPMAX_MULTICAST; i++, tb++) {
1231 if (tb->n) {
1232 CHECK_CAM() ;
1233
1234 /*
1235 * write the multicast address into the CAM
1236 */
1237 outpw(FM_A(FM_AFCOMP2),
1238 (u_short)((tb->a.a[0]<<8)+tb->a.a[1])) ;
1239 outpw(FM_A(FM_AFCOMP1),
1240 (u_short)((tb->a.a[2]<<8)+tb->a.a[3])) ;
1241 outpw(FM_A(FM_AFCOMP0),
1242 (u_short)((tb->a.a[4]<<8)+tb->a.a[5])) ;
1243 outpw(FM_A(FM_AFCMD),FM_IWRITE_CAM) ;
1244 }
1245 }
1246 }
1247
1248 /*
1249 BEGIN_MANUAL_ENTRY(if,func;others;3)
1250
1251 void mac_set_rx_mode(smc,mode)
1252 struct s_smc *smc ;
1253 int mode ;
1254
1255 Function DOWNCALL/INTERN (SMT, fplustm.c)
1256 This function enables / disables the selected receive.
1257 Don't call this function if the hardware module is
1258 used -- use mac_drv_rx_mode() instead of.
1259
1260 Para mode = 1 RX_ENABLE_ALLMULTI enable all multicasts
1261 2 RX_DISABLE_ALLMULTI disable "enable all multicasts"
1262 3 RX_ENABLE_PROMISC enable promiscuous
1263 4 RX_DISABLE_PROMISC disable promiscuous
1264 5 RX_ENABLE_NSA enable reception of NSA frames
1265 6 RX_DISABLE_NSA disable reception of NSA frames
1266
1267 Note The selected receive modes will be lost after 'driver reset'
1268 or 'set station address'
1269
1270 END_MANUAL_ENTRY
1271 */
1272 void mac_set_rx_mode(struct s_smc *smc, int mode)
1273 {
1274 switch (mode) {
1275 case RX_ENABLE_ALLMULTI :
1276 smc->hw.fp.rx_prom |= RX_MODE_ALL_MULTI ;
1277 break ;
1278 case RX_DISABLE_ALLMULTI :
1279 smc->hw.fp.rx_prom &= ~RX_MODE_ALL_MULTI ;
1280 break ;
1281 case RX_ENABLE_PROMISC :
1282 smc->hw.fp.rx_prom |= RX_MODE_PROM ;
1283 break ;
1284 case RX_DISABLE_PROMISC :
1285 smc->hw.fp.rx_prom &= ~RX_MODE_PROM ;
1286 break ;
1287 case RX_ENABLE_NSA :
1288 smc->hw.fp.nsa_mode = FM_MDAMA ;
1289 smc->hw.fp.rx_mode = (smc->hw.fp.rx_mode & ~FM_ADDET) |
1290 smc->hw.fp.nsa_mode ;
1291 break ;
1292 case RX_DISABLE_NSA :
1293 smc->hw.fp.nsa_mode = FM_MRNNSAFNMA ;
1294 smc->hw.fp.rx_mode = (smc->hw.fp.rx_mode & ~FM_ADDET) |
1295 smc->hw.fp.nsa_mode ;
1296 break ;
1297 }
1298 if (smc->hw.fp.rx_prom & RX_MODE_PROM) {
1299 smc->hw.fp.rx_mode = FM_MLIMPROM ;
1300 }
1301 else if (smc->hw.fp.rx_prom & RX_MODE_ALL_MULTI) {
1302 smc->hw.fp.rx_mode = smc->hw.fp.nsa_mode | FM_EXGPA0 ;
1303 }
1304 else
1305 smc->hw.fp.rx_mode = smc->hw.fp.nsa_mode ;
1306 SETMASK(FM_A(FM_MDREG1),smc->hw.fp.rx_mode,FM_ADDRX) ;
1307 mac_update_multicast(smc) ;
1308 }
1309
1310 /*
1311 BEGIN_MANUAL_ENTRY(module;tests;3)
1312 How to test the Restricted Token Monitor
1313 ----------------------------------------------------------------
1314
1315 o Insert a break point in the function rtm_irq()
1316 o Remove all stations with a restricted token monitor from the
1317 network.
1318 o Connect a UPPS ISA or EISA station to the network.
1319 o Give the FORMAC of UPPS station the command to send
1320 restricted tokens until the ring becomes instable.
1321 o Now connect your test test client.
1322 o The restricted token monitor should detect the restricted token,
1323 and your break point will be reached.
1324 o You can ovserve how the station will clean the ring.
1325
1326 END_MANUAL_ENTRY
1327 */
1328 void rtm_irq(struct s_smc *smc)
1329 {
1330 outpw(ADDR(B2_RTM_CRTL),TIM_CL_IRQ) ; /* clear IRQ */
1331 if (inpw(ADDR(B2_RTM_CRTL)) & TIM_RES_TOK) {
1332 outpw(FM_A(FM_CMDREG1),FM_ICL) ; /* force claim */
1333 DB_RMT("RMT: fddiPATHT_Rmode expired");
1334 AIX_EVENT(smc, (u_long) FDDI_RING_STATUS,
1335 (u_long) FDDI_SMT_EVENT,
1336 (u_long) FDDI_RTT, smt_get_event_word(smc));
1337 }
1338 outpw(ADDR(B2_RTM_CRTL),TIM_START) ; /* enable RTM monitoring */
1339 }
1340
1341 static void rtm_init(struct s_smc *smc)
1342 {
1343 outpd(ADDR(B2_RTM_INI),0) ; /* timer = 0 */
1344 outpw(ADDR(B2_RTM_CRTL),TIM_START) ; /* enable IRQ */
1345 }
1346
1347 void rtm_set_timer(struct s_smc *smc)
1348 {
1349 /*
1350 * MIB timer and hardware timer have the same resolution of 80nS
1351 */
1352 DB_RMT("RMT: setting new fddiPATHT_Rmode, t = %d ns",
1353 (int)smc->mib.a[PATH0].fddiPATHT_Rmode);
1354 outpd(ADDR(B2_RTM_INI),smc->mib.a[PATH0].fddiPATHT_Rmode) ;
1355 }
1356
1357 static void smt_split_up_fifo(struct s_smc *smc)
1358 {
1359
1360 /*
1361 BEGIN_MANUAL_ENTRY(module;mem;1)
1362 -------------------------------------------------------------
1363 RECEIVE BUFFER MEMORY DIVERSION
1364 -------------------------------------------------------------
1365
1366 R1_RxD == SMT_R1_RXD_COUNT
1367 R2_RxD == SMT_R2_RXD_COUNT
1368
1369 SMT_R1_RXD_COUNT must be unequal zero
1370
1371 | R1_RxD R2_RxD |R1_RxD R2_RxD | R1_RxD R2_RxD
1372 | x 0 | x 1-3 | x < 3
1373 ----------------------------------------------------------------------
1374 | 63,75 kB | 54,75 | R1_RxD
1375 rx queue 1 | RX_FIFO_SPACE | RX_LARGE_FIFO| ------------- * 63,75 kB
1376 | | | R1_RxD+R2_RxD
1377 ----------------------------------------------------------------------
1378 | | 9 kB | R2_RxD
1379 rx queue 2 | 0 kB | RX_SMALL_FIFO| ------------- * 63,75 kB
1380 | (not used) | | R1_RxD+R2_RxD
1381
1382 END_MANUAL_ENTRY
1383 */
1384
1385 if (SMT_R1_RXD_COUNT == 0) {
1386 SMT_PANIC(smc,SMT_E0117, SMT_E0117_MSG) ;
1387 }
1388
1389 switch(SMT_R2_RXD_COUNT) {
1390 case 0:
1391 smc->hw.fp.fifo.rx1_fifo_size = RX_FIFO_SPACE ;
1392 smc->hw.fp.fifo.rx2_fifo_size = 0 ;
1393 break ;
1394 case 1:
1395 case 2:
1396 case 3:
1397 smc->hw.fp.fifo.rx1_fifo_size = RX_LARGE_FIFO ;
1398 smc->hw.fp.fifo.rx2_fifo_size = RX_SMALL_FIFO ;
1399 break ;
1400 default: /* this is not the real defaule */
1401 smc->hw.fp.fifo.rx1_fifo_size = RX_FIFO_SPACE *
1402 SMT_R1_RXD_COUNT/(SMT_R1_RXD_COUNT+SMT_R2_RXD_COUNT) ;
1403 smc->hw.fp.fifo.rx2_fifo_size = RX_FIFO_SPACE *
1404 SMT_R2_RXD_COUNT/(SMT_R1_RXD_COUNT+SMT_R2_RXD_COUNT) ;
1405 break ;
1406 }
1407
1408 /*
1409 BEGIN_MANUAL_ENTRY(module;mem;1)
1410 -------------------------------------------------------------
1411 TRANSMIT BUFFER MEMORY DIVERSION
1412 -------------------------------------------------------------
1413
1414
1415 | no sync bw | sync bw available and | sync bw available and
1416 | available | SynchTxMode = SPLIT | SynchTxMode = ALL
1417 -----------------------------------------------------------------------
1418 sync tx | 0 kB | 32 kB | 55 kB
1419 queue | | TX_MEDIUM_FIFO | TX_LARGE_FIFO
1420 -----------------------------------------------------------------------
1421 async tx | 64 kB | 32 kB | 9 k
1422 queue | TX_FIFO_SPACE| TX_MEDIUM_FIFO | TX_SMALL_FIFO
1423
1424 END_MANUAL_ENTRY
1425 */
1426
1427 /*
1428 * set the tx mode bits
1429 */
1430 if (smc->mib.a[PATH0].fddiPATHSbaPayload) {
1431 #ifdef ESS
1432 smc->hw.fp.fifo.fifo_config_mode |=
1433 smc->mib.fddiESSSynchTxMode | SYNC_TRAFFIC_ON ;
1434 #endif
1435 }
1436 else {
1437 smc->hw.fp.fifo.fifo_config_mode &=
1438 ~(SEND_ASYNC_AS_SYNC|SYNC_TRAFFIC_ON) ;
1439 }
1440
1441 /*
1442 * split up the FIFO
1443 */
1444 if (smc->hw.fp.fifo.fifo_config_mode & SYNC_TRAFFIC_ON) {
1445 if (smc->hw.fp.fifo.fifo_config_mode & SEND_ASYNC_AS_SYNC) {
1446 smc->hw.fp.fifo.tx_s_size = TX_LARGE_FIFO ;
1447 smc->hw.fp.fifo.tx_a0_size = TX_SMALL_FIFO ;
1448 }
1449 else {
1450 smc->hw.fp.fifo.tx_s_size = TX_MEDIUM_FIFO ;
1451 smc->hw.fp.fifo.tx_a0_size = TX_MEDIUM_FIFO ;
1452 }
1453 }
1454 else {
1455 smc->hw.fp.fifo.tx_s_size = 0 ;
1456 smc->hw.fp.fifo.tx_a0_size = TX_FIFO_SPACE ;
1457 }
1458
1459 smc->hw.fp.fifo.rx1_fifo_start = smc->hw.fp.fifo.rbc_ram_start +
1460 RX_FIFO_OFF ;
1461 smc->hw.fp.fifo.tx_s_start = smc->hw.fp.fifo.rx1_fifo_start +
1462 smc->hw.fp.fifo.rx1_fifo_size ;
1463 smc->hw.fp.fifo.tx_a0_start = smc->hw.fp.fifo.tx_s_start +
1464 smc->hw.fp.fifo.tx_s_size ;
1465 smc->hw.fp.fifo.rx2_fifo_start = smc->hw.fp.fifo.tx_a0_start +
1466 smc->hw.fp.fifo.tx_a0_size ;
1467
1468 DB_SMT("FIFO split: mode = %x", smc->hw.fp.fifo.fifo_config_mode);
1469 DB_SMT("rbc_ram_start = %x rbc_ram_end = %x",
1470 smc->hw.fp.fifo.rbc_ram_start, smc->hw.fp.fifo.rbc_ram_end);
1471 DB_SMT("rx1_fifo_start = %x tx_s_start = %x",
1472 smc->hw.fp.fifo.rx1_fifo_start, smc->hw.fp.fifo.tx_s_start);
1473 DB_SMT("tx_a0_start = %x rx2_fifo_start = %x",
1474 smc->hw.fp.fifo.tx_a0_start, smc->hw.fp.fifo.rx2_fifo_start);
1475 }
1476
1477 void formac_reinit_tx(struct s_smc *smc)
1478 {
1479 /*
1480 * Split up the FIFO and reinitialize the MAC if synchronous
1481 * bandwidth becomes available but no synchronous queue is
1482 * configured.
1483 */
1484 if (!smc->hw.fp.fifo.tx_s_size && smc->mib.a[PATH0].fddiPATHSbaPayload){
1485 (void)init_mac(smc,0) ;
1486 }
1487 }
1488
Linux with added FPC-III support