]>
Commit | Line | Data |
---|---|---|
2874c5fd | 1 | // SPDX-License-Identifier: GPL-2.0-or-later |
1da177e4 LT |
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 | * | |
1da177e4 LT |
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" | |
bc63eb9c | 21 | #include <linux/bitrev.h> |
7c3c299d | 22 | #include <linux/etherdevice.h> |
1da177e4 LT |
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 | ||
89e47d3b | 55 | #define CHECK_NPP() { unsigned int k = 10000 ;\ |
1da177e4 LT |
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 | ||
89e47d3b | 62 | #define CHECK_CAM() { unsigned int k = 10 ;\ |
1da177e4 LT |
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 | */ | |
f71e1309 AV |
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| | |
1da177e4 LT |
91 | FM_STBURS | FM_STBURA0 ; |
92 | ||
93 | /* delete FM_SRBFL after tests */ | |
f71e1309 | 94 | static const int mac_imsk2u = FM_SERRSF | FM_SNFSLD | FM_SRCVOVR | FM_SRBFL | |
1da177e4 | 95 | FM_SMYCLM ; |
f71e1309 | 96 | static const int mac_imsk2l = FM_STRTEXR | FM_SDUPCLM | FM_SFRMCTR | |
1da177e4 LT |
97 | FM_SERRCTR | FM_SLSTCTR | |
98 | FM_STRTEXP | FM_SMULTDA | FM_SRNGOP ; | |
99 | ||
f71e1309 AV |
100 | static const int mac_imsk3u = FM_SRCVOVR2 | FM_SRBFL2 ; |
101 | static const int mac_imsk3l = FM_SRPERRQ2 | FM_SRPERRQ1 ; | |
1da177e4 | 102 | |
f71e1309 | 103 | static const int mac_beacon_imsk2u = FM_SOTRBEC | FM_SMYBEC | FM_SBEC | |
1da177e4 LT |
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) ; | |
807540ba ED |
112 | return (u_long)((tneg + ((inpw(FM_A(FM_TMRS))>>10)&0x1f)) | |
113 | 0xffe00000L) ; | |
1da177e4 LT |
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)) ; | |
807540ba | 163 | return p; |
1da177e4 LT |
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 | /* | |
25985edc | 340 | * clear internal error counter structure |
1da177e4 LT |
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 */ | |
89e47d3b | 356 | outpw(FM_A(FM_LAIL),(unsigned short)((smc->hw.fddi_home_addr.a[4]<<8) + |
1da177e4 | 357 | smc->hw.fddi_home_addr.a[5])) ; |
89e47d3b | 358 | outpw(FM_A(FM_LAIC),(unsigned short)((smc->hw.fddi_home_addr.a[2]<<8) + |
1da177e4 | 359 | smc->hw.fddi_home_addr.a[3])) ; |
89e47d3b | 360 | outpw(FM_A(FM_LAIM),(unsigned short)((smc->hw.fddi_home_addr.a[0]<<8) + |
1da177e4 LT |
361 | smc->hw.fddi_home_addr.a[1])) ; |
362 | ||
363 | outpw(FM_A(FM_SAGP),my_sagp) ; /* set short group address */ | |
364 | ||
89e47d3b | 365 | outpw(FM_A(FM_LAGL),(unsigned short)((smc->hw.fp.group_addr.a[4]<<8) + |
1da177e4 | 366 | smc->hw.fp.group_addr.a[5])) ; |
89e47d3b | 367 | outpw(FM_A(FM_LAGC),(unsigned short)((smc->hw.fp.group_addr.a[2]<<8) + |
1da177e4 | 368 | smc->hw.fp.group_addr.a[3])) ; |
89e47d3b | 369 | outpw(FM_A(FM_LAGM),(unsigned short)((smc->hw.fp.group_addr.a[0]<<8) + |
1da177e4 LT |
370 | smc->hw.fp.group_addr.a[1])) ; |
371 | ||
372 | /* set r_request regs. (MSW & LSW of TRT ) */ | |
89e47d3b | 373 | outpw(FM_A(FM_TREQ1),(unsigned short)(t_requ>>16)) ; |
374 | outpw(FM_A(FM_TREQ0),(unsigned short)t_requ) ; | |
1da177e4 LT |
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, | |
89e47d3b | 394 | unsigned int off, int len) |
1da177e4 LT |
395 | /* u_long td; transmit descriptor */ |
396 | /* struct fddi_mac *mac; mac frame pointer */ | |
89e47d3b | 397 | /* unsigned int off; start address within buffer memory */ |
efad798b | 398 | /* int len ; length of the frame including the FC */ |
1da177e4 LT |
399 | { |
400 | int i ; | |
2f220e30 | 401 | __le32 *p ; |
1da177e4 LT |
402 | |
403 | CHECK_NPP() ; | |
404 | MARW(off) ; /* set memory address reg for writes */ | |
405 | ||
2f220e30 | 406 | p = (__le32 *) mac ; |
1da177e4 LT |
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 | } | |
2f220e30 | 412 | write_mdr(smc,le32_to_cpu(*p)) ; |
1da177e4 LT |
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 | { | |
2f220e30 | 444 | SK_LOC_DECL(__le32,a[2]) ; |
1da177e4 LT |
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 ; | |
d458cdf7 | 453 | memcpy((char *)a+1, (char *) &smc->mib.m[MAC0].fddiMACUpstreamNbr, ETH_ALEN); |
1da177e4 LT |
454 | |
455 | CHECK_NPP() ; | |
456 | /* set memory address reg for writes */ | |
457 | MARW(smc->hw.fp.fifo.rbc_ram_start+DBEACON_FRAME_OFF+4) ; | |
2f220e30 | 458 | write_mdr(smc,le32_to_cpu(a[0])) ; |
1da177e4 | 459 | outpw(FM_A(FM_CMDREG2),FM_ISTTB) ; /* set the tag bit */ |
2f220e30 | 460 | write_mdr(smc,le32_to_cpu(a[1])) ; |
1da177e4 LT |
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 */ | |
3d781a02 AM |
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); | |
1da177e4 LT |
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) { | |
5671e8c1 | 725 | DB_RMTN(2, "RMT : lower claim received"); |
1da177e4 LT |
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) { | |
5671e8c1 | 745 | DB_RMTN(2, "RMT : higher claim received"); |
1da177e4 LT |
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 | ||
807540ba | 887 | return init_mac(smc, 1); |
1da177e4 LT |
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 | ||
807540ba | 989 | return 0; |
1da177e4 LT |
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 | { | |
807540ba | 1049 | return (inpw(FM_A(FM_STMCHN))>>4) & 7; |
1da177e4 LT |
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++) | |
bc63eb9c | 1073 | *p = bitrev8(*p); |
1da177e4 LT |
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 | } | |
7c3c299d | 1082 | if (!ether_addr_equal((char *)&tb->a, (char *)own)) |
1da177e4 | 1083 | continue ; |
807540ba | 1084 | return tb; |
1da177e4 | 1085 | } |
807540ba | 1086 | return slot; /* return first free or NULL */ |
1da177e4 LT |
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 | ||
1da177e4 LT |
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) { | |
807540ba | 1152 | return 1; |
1da177e4 LT |
1153 | } |
1154 | } | |
1155 | else { | |
1156 | if (smc->hw.fp.os_slots_used >= FPMAX_MULTICAST-SMT_MAX_MULTI) { | |
807540ba | 1157 | return 1; |
1da177e4 LT |
1158 | } |
1159 | } | |
1160 | ||
1161 | /* | |
1162 | * find empty slot | |
1163 | */ | |
1164 | if (!(tb = mac_get_mc_table(smc,addr,&own,0,can & ~0x80))) | |
807540ba | 1165 | return 1; |
1da177e4 LT |
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 | ||
807540ba | 1175 | return 0; |
1da177e4 LT |
1176 | } |
1177 | ||
1da177e4 LT |
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" | |
25985edc LDM |
1262 | 3 RX_ENABLE_PROMISC enable promiscuous |
1263 | 4 RX_DISABLE_PROMISC disable promiscuous | |
1da177e4 LT |
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 */ | |
5671e8c1 | 1333 | DB_RMT("RMT: fddiPATHT_Rmode expired"); |
1da177e4 LT |
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 | */ | |
5671e8c1 JP |
1352 | DB_RMT("RMT: setting new fddiPATHT_Rmode, t = %d ns", |
1353 | (int)smc->mib.a[PATH0].fddiPATHT_Rmode); | |
1da177e4 LT |
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 | ||
5671e8c1 JP |
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); | |
1da177e4 LT |
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 |