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