File: /usr/src/linux/drivers/net/tokenring/smctr.c
1 /*
2 * smctr.c: A network driver for the SMC Token Ring Adapters.
3 *
4 * Written by Jay Schulist <jschlst@samba.org>
5 *
6 * This software may be used and distributed according to the terms
7 * of the GNU General Public License, incorporated herein by reference.
8 *
9 * This device driver works with the following SMC adapters:
10 * - SMC TokenCard Elite (8115T, chips 825/584)
11 * - SMC TokenCard Elite/A MCA (8115T/A, chips 825/594)
12 *
13 * Source(s):
14 * - SMC TokenCard SDK.
15 *
16 * Maintainer(s):
17 * JS Jay Schulist <jschlst@samba.org>
18 *
19 * Changes:
20 * 07102000 JS Fixed a timing problem in smctr_wait_cmd();
21 * Also added a bit more discriptive error msgs.
22 * 07122000 JS Fixed problem with detecting a card with
23 * module io/irq/mem specified.
24 *
25 * To do:
26 * 1. Multicast support.
27 */
28
29 #ifdef MODULE
30 #include <linux/module.h>
31 #include <linux/version.h>
32 #endif
33
34 #include <linux/config.h>
35 #include <linux/kernel.h>
36 #include <linux/sched.h>
37 #include <linux/types.h>
38 #include <linux/fcntl.h>
39 #include <linux/interrupt.h>
40 #include <linux/ptrace.h>
41 #include <linux/ioport.h>
42 #include <linux/in.h>
43 #include <linux/slab.h>
44 #include <linux/string.h>
45 #include <linux/time.h>
46 #include <asm/system.h>
47 #include <asm/bitops.h>
48 #include <asm/io.h>
49 #include <asm/dma.h>
50 #include <asm/irq.h>
51 #include <linux/errno.h>
52 #include <linux/init.h>
53 #include <linux/pci.h>
54 #include <linux/mca.h>
55 #include <linux/delay.h>
56
57 #include <linux/netdevice.h>
58 #include <linux/etherdevice.h>
59 #include <linux/skbuff.h>
60 #include <linux/trdevice.h>
61
62 #if BITS_PER_LONG == 64
63 #error FIXME: driver does not support 64-bit platforms
64 #endif
65
66 #include "smctr.h" /* Our Stuff */
67 #include "smctr_firmware.h" /* SMC adapter firmware */
68
69 static char version[] __initdata = KERN_INFO "smctr.c: v1.4 7/12/00 by jschlst@samba.org\n";
70 static const char cardname[] = "smctr";
71
72
73 #define SMCTR_IO_EXTENT 20
74
75 /* A zero-terminated list of I/O addresses to be probed. */
76 static unsigned int smctr_portlist[] __initdata = {
77 0x200, 0x220, 0x240, 0x260, 0x280, 0x2A0, 0x2C0, 0x2E0, 0x300,
78 0x320, 0x340, 0x360, 0x380,
79 0
80 };
81
82 #ifdef CONFIG_MCA
83 static unsigned int smctr_posid = 0x6ec6;
84 #endif
85
86 static int ringspeed;
87
88 /* SMC Name of the Adapter. */
89 static char smctr_name[] = "SMC TokenCard";
90 char *smctr_model = "Unknown";
91
92 /* Use 0 for production, 1 for verification, 2 for debug, and
93 * 3 for very verbose debug.
94 */
95 #ifndef SMCTR_DEBUG
96 #define SMCTR_DEBUG 1
97 #endif
98 static unsigned int smctr_debug = SMCTR_DEBUG;
99
100 /* smctr.c prototypes and functions are arranged alphabeticly
101 * for clearity, maintainability and pure old fashion fun.
102 */
103 /* A */
104 static int smctr_alloc_shared_memory(struct net_device *dev);
105
106 /* B */
107 static int smctr_bypass_state(struct net_device *dev);
108
109 /* C */
110 static int smctr_checksum_firmware(struct net_device *dev);
111 static int __init smctr_chk_isa(struct net_device *dev);
112 static int smctr_chg_rx_mask(struct net_device *dev);
113 static int smctr_clear_int(struct net_device *dev);
114 static int smctr_clear_trc_reset(int ioaddr);
115 static int smctr_close(struct net_device *dev);
116
117 /* D */
118 static int smctr_decode_firmware(struct net_device *dev);
119 static int smctr_disable_16bit(struct net_device *dev);
120 static int smctr_disable_adapter_ctrl_store(struct net_device *dev);
121 static int smctr_disable_bic_int(struct net_device *dev);
122
123 /* E */
124 static int smctr_enable_16bit(struct net_device *dev);
125 static int smctr_enable_adapter_ctrl_store(struct net_device *dev);
126 static int smctr_enable_adapter_ram(struct net_device *dev);
127 static int smctr_enable_bic_int(struct net_device *dev);
128
129 /* G */
130 static int __init smctr_get_boardid(struct net_device *dev, int mca);
131 static int smctr_get_group_address(struct net_device *dev);
132 static int smctr_get_functional_address(struct net_device *dev);
133 static unsigned int smctr_get_num_rx_bdbs(struct net_device *dev);
134 static int smctr_get_physical_drop_number(struct net_device *dev);
135 static __u8 *smctr_get_rx_pointer(struct net_device *dev, short queue);
136 static int smctr_get_station_id(struct net_device *dev);
137 static struct net_device_stats *smctr_get_stats(struct net_device *dev);
138 static FCBlock *smctr_get_tx_fcb(struct net_device *dev, __u16 queue,
139 __u16 bytes_count);
140 static int smctr_get_upstream_neighbor_addr(struct net_device *dev);
141
142 /* H */
143 static int smctr_hardware_send_packet(struct net_device *dev,
144 struct net_local *tp);
145 /* I */
146 static int smctr_init_acbs(struct net_device *dev);
147 static int smctr_init_adapter(struct net_device *dev);
148 static int __init smctr_init_card(struct net_device *dev);
149 static int smctr_init_card_real(struct net_device *dev);
150 static int smctr_init_rx_bdbs(struct net_device *dev);
151 static int smctr_init_rx_fcbs(struct net_device *dev);
152 static int smctr_init_shared_memory(struct net_device *dev);
153 static int smctr_init_tx_bdbs(struct net_device *dev);
154 static int smctr_init_tx_fcbs(struct net_device *dev);
155 static int smctr_internal_self_test(struct net_device *dev);
156 static void smctr_interrupt(int irq, void *dev_id, struct pt_regs *regs);
157 static int smctr_issue_enable_int_cmd(struct net_device *dev,
158 __u16 interrupt_enable_mask);
159 static int smctr_issue_int_ack(struct net_device *dev, __u16 iack_code,
160 __u16 ibits);
161 static int smctr_issue_init_timers_cmd(struct net_device *dev);
162 static int smctr_issue_init_txrx_cmd(struct net_device *dev);
163 static int smctr_issue_insert_cmd(struct net_device *dev);
164 static int smctr_issue_read_ring_status_cmd(struct net_device *dev);
165 static int smctr_issue_read_word_cmd(struct net_device *dev, __u16 aword_cnt);
166 static int smctr_issue_remove_cmd(struct net_device *dev);
167 static int smctr_issue_resume_acb_cmd(struct net_device *dev);
168 static int smctr_issue_resume_rx_bdb_cmd(struct net_device *dev, __u16 queue);
169 static int smctr_issue_resume_rx_fcb_cmd(struct net_device *dev, __u16 queue);
170 static int smctr_issue_resume_tx_fcb_cmd(struct net_device *dev, __u16 queue);
171 static int smctr_issue_test_internal_rom_cmd(struct net_device *dev);
172 static int smctr_issue_test_hic_cmd(struct net_device *dev);
173 static int smctr_issue_test_mac_reg_cmd(struct net_device *dev);
174 static int smctr_issue_trc_loopback_cmd(struct net_device *dev);
175 static int smctr_issue_tri_loopback_cmd(struct net_device *dev);
176 static int smctr_issue_write_byte_cmd(struct net_device *dev,
177 short aword_cnt, void *byte);
178 static int smctr_issue_write_word_cmd(struct net_device *dev,
179 short aword_cnt, void *word);
180
181 /* J */
182 static int smctr_join_complete_state(struct net_device *dev);
183
184 /* L */
185 static int smctr_link_tx_fcbs_to_bdbs(struct net_device *dev);
186 static int smctr_load_firmware(struct net_device *dev);
187 static int smctr_load_node_addr(struct net_device *dev);
188 static int smctr_lobe_media_test(struct net_device *dev);
189 static int smctr_lobe_media_test_cmd(struct net_device *dev);
190 static int smctr_lobe_media_test_state(struct net_device *dev);
191
192 /* M */
193 static int smctr_make_8025_hdr(struct net_device *dev,
194 MAC_HEADER *rmf, MAC_HEADER *tmf, __u16 ac_fc);
195 static int smctr_make_access_pri(struct net_device *dev,
196 MAC_SUB_VECTOR *tsv);
197 static int smctr_make_addr_mod(struct net_device *dev, MAC_SUB_VECTOR *tsv);
198 static int smctr_make_auth_funct_class(struct net_device *dev,
199 MAC_SUB_VECTOR *tsv);
200 static int smctr_make_corr(struct net_device *dev,
201 MAC_SUB_VECTOR *tsv, __u16 correlator);
202 static int smctr_make_funct_addr(struct net_device *dev,
203 MAC_SUB_VECTOR *tsv);
204 static int smctr_make_group_addr(struct net_device *dev,
205 MAC_SUB_VECTOR *tsv);
206 static int smctr_make_phy_drop_num(struct net_device *dev,
207 MAC_SUB_VECTOR *tsv);
208 static int smctr_make_product_id(struct net_device *dev, MAC_SUB_VECTOR *tsv);
209 static int smctr_make_station_id(struct net_device *dev, MAC_SUB_VECTOR *tsv);
210 static int smctr_make_ring_station_status(struct net_device *dev,
211 MAC_SUB_VECTOR *tsv);
212 static int smctr_make_ring_station_version(struct net_device *dev,
213 MAC_SUB_VECTOR *tsv);
214 static int smctr_make_tx_status_code(struct net_device *dev,
215 MAC_SUB_VECTOR *tsv, __u16 tx_fstatus);
216 static int smctr_make_upstream_neighbor_addr(struct net_device *dev,
217 MAC_SUB_VECTOR *tsv);
218 static int smctr_make_wrap_data(struct net_device *dev,
219 MAC_SUB_VECTOR *tsv);
220
221 /* O */
222 static int smctr_open(struct net_device *dev);
223 static int smctr_open_tr(struct net_device *dev);
224
225 /* P */
226 int __init smctr_probe (struct net_device *dev);
227 static int __init smctr_probe1(struct net_device *dev, int ioaddr);
228 static int smctr_process_rx_packet(MAC_HEADER *rmf, __u16 size,
229 struct net_device *dev, __u16 rx_status);
230
231 /* R */
232 static int smctr_ram_memory_test(struct net_device *dev);
233 static int smctr_rcv_chg_param(struct net_device *dev, MAC_HEADER *rmf,
234 __u16 *correlator);
235 static int smctr_rcv_init(struct net_device *dev, MAC_HEADER *rmf,
236 __u16 *correlator);
237 static int smctr_rcv_tx_forward(struct net_device *dev, MAC_HEADER *rmf);
238 static int smctr_rcv_rq_addr_state_attch(struct net_device *dev,
239 MAC_HEADER *rmf, __u16 *correlator);
240 static int smctr_rcv_unknown(struct net_device *dev, MAC_HEADER *rmf,
241 __u16 *correlator);
242 static int smctr_reset_adapter(struct net_device *dev);
243 static int smctr_restart_tx_chain(struct net_device *dev, short queue);
244 static int smctr_ring_status_chg(struct net_device *dev);
245 static int smctr_rx_frame(struct net_device *dev);
246
247 /* S */
248 static int smctr_send_dat(struct net_device *dev);
249 static int smctr_send_packet(struct sk_buff *skb, struct net_device *dev);
250 static int smctr_send_lobe_media_test(struct net_device *dev);
251 static int smctr_send_rpt_addr(struct net_device *dev, MAC_HEADER *rmf,
252 __u16 correlator);
253 static int smctr_send_rpt_attch(struct net_device *dev, MAC_HEADER *rmf,
254 __u16 correlator);
255 static int smctr_send_rpt_state(struct net_device *dev, MAC_HEADER *rmf,
256 __u16 correlator);
257 static int smctr_send_rpt_tx_forward(struct net_device *dev,
258 MAC_HEADER *rmf, __u16 tx_fstatus);
259 static int smctr_send_rsp(struct net_device *dev, MAC_HEADER *rmf,
260 __u16 rcode, __u16 correlator);
261 static int smctr_send_rq_init(struct net_device *dev);
262 static int smctr_send_tx_forward(struct net_device *dev, MAC_HEADER *rmf,
263 __u16 *tx_fstatus);
264 static int smctr_set_auth_access_pri(struct net_device *dev,
265 MAC_SUB_VECTOR *rsv);
266 static int smctr_set_auth_funct_class(struct net_device *dev,
267 MAC_SUB_VECTOR *rsv);
268 static int smctr_set_corr(struct net_device *dev, MAC_SUB_VECTOR *rsv,
269 __u16 *correlator);
270 static int smctr_set_error_timer_value(struct net_device *dev,
271 MAC_SUB_VECTOR *rsv);
272 static int smctr_set_frame_forward(struct net_device *dev,
273 MAC_SUB_VECTOR *rsv, __u8 dc_sc);
274 static int smctr_set_local_ring_num(struct net_device *dev,
275 MAC_SUB_VECTOR *rsv);
276 static unsigned short smctr_set_ctrl_attention(struct net_device *dev);
277 static void smctr_set_multicast_list(struct net_device *dev);
278 static int smctr_set_page(struct net_device *dev, __u8 *buf);
279 static int smctr_set_phy_drop(struct net_device *dev,
280 MAC_SUB_VECTOR *rsv);
281 static int smctr_set_ring_speed(struct net_device *dev);
282 static int smctr_set_rx_look_ahead(struct net_device *dev);
283 static int smctr_set_trc_reset(int ioaddr);
284 static int smctr_setup_single_cmd(struct net_device *dev,
285 __u16 command, __u16 subcommand);
286 static int smctr_setup_single_cmd_w_data(struct net_device *dev,
287 __u16 command, __u16 subcommand);
288 static char *smctr_malloc(struct net_device *dev, __u16 size);
289 static int smctr_status_chg(struct net_device *dev);
290
291 /* T */
292 static void smctr_timeout(struct net_device *dev);
293 static int smctr_trc_send_packet(struct net_device *dev, FCBlock *fcb,
294 __u16 queue);
295 static __u16 smctr_tx_complete(struct net_device *dev, __u16 queue);
296 static unsigned short smctr_tx_move_frame(struct net_device *dev,
297 struct sk_buff *skb, __u8 *pbuff, unsigned int bytes);
298
299 /* U */
300 static int smctr_update_err_stats(struct net_device *dev);
301 static int smctr_update_rx_chain(struct net_device *dev, __u16 queue);
302 static int smctr_update_tx_chain(struct net_device *dev, FCBlock *fcb,
303 __u16 queue);
304
305 /* W */
306 static int smctr_wait_cmd(struct net_device *dev);
307 static int smctr_wait_while_cbusy(struct net_device *dev);
308
309 #define TO_256_BYTE_BOUNDRY(X) (((X + 0xff) & 0xff00) - X)
310 #define TO_PARAGRAPH_BOUNDRY(X) (((X + 0x0f) & 0xfff0) - X)
311 #define PARAGRAPH_BOUNDRY(X) smctr_malloc(dev, TO_PARAGRAPH_BOUNDRY(X))
312
313 /* Allocate Adapter Shared Memory.
314 * IMPORTANT NOTE: Any changes to this function MUST be mirrored in the
315 * function "get_num_rx_bdbs" below!!!
316 *
317 * Order of memory allocation:
318 *
319 * 0. Initial System Configuration Block Pointer
320 * 1. System Configuration Block
321 * 2. System Control Block
322 * 3. Action Command Block
323 * 4. Interrupt Status Block
324 *
325 * 5. MAC TX FCB'S
326 * 6. NON-MAC TX FCB'S
327 * 7. MAC TX BDB'S
328 * 8. NON-MAC TX BDB'S
329 * 9. MAC RX FCB'S
330 * 10. NON-MAC RX FCB'S
331 * 11. MAC RX BDB'S
332 * 12. NON-MAC RX BDB'S
333 * 13. MAC TX Data Buffer( 1, 256 byte buffer)
334 * 14. MAC RX Data Buffer( 1, 256 byte buffer)
335 *
336 * 15. NON-MAC TX Data Buffer
337 * 16. NON-MAC RX Data Buffer
338 */
339 static int smctr_alloc_shared_memory(struct net_device *dev)
340 {
341 struct net_local *tp = (struct net_local *)dev->priv;
342
343 if(smctr_debug > 10)
344 printk("%s: smctr_alloc_shared_memory\n", dev->name);
345
346 /* Allocate initial System Control Block pointer.
347 * This pointer is located in the last page, last offset - 4.
348 */
349 tp->iscpb_ptr = (ISCPBlock *)(tp->ram_access + ((__u32)64 * 0x400)
350 - (long)ISCP_BLOCK_SIZE);
351
352 /* Allocate System Control Blocks. */
353 tp->scgb_ptr = (SCGBlock *)smctr_malloc(dev, sizeof(SCGBlock));
354 PARAGRAPH_BOUNDRY(tp->sh_mem_used);
355
356 tp->sclb_ptr = (SCLBlock *)smctr_malloc(dev, sizeof(SCLBlock));
357 PARAGRAPH_BOUNDRY(tp->sh_mem_used);
358
359 tp->acb_head = (ACBlock *)smctr_malloc(dev,
360 sizeof(ACBlock)*tp->num_acbs);
361 PARAGRAPH_BOUNDRY(tp->sh_mem_used);
362
363 tp->isb_ptr = (ISBlock *)smctr_malloc(dev, sizeof(ISBlock));
364 PARAGRAPH_BOUNDRY(tp->sh_mem_used);
365
366 tp->misc_command_data = (__u16 *)smctr_malloc(dev, MISC_DATA_SIZE);
367 PARAGRAPH_BOUNDRY(tp->sh_mem_used);
368
369 /* Allocate transmit FCBs. */
370 tp->tx_fcb_head[MAC_QUEUE] = (FCBlock *)smctr_malloc(dev,
371 sizeof(FCBlock) * tp->num_tx_fcbs[MAC_QUEUE]);
372
373 tp->tx_fcb_head[NON_MAC_QUEUE] = (FCBlock *)smctr_malloc(dev,
374 sizeof(FCBlock) * tp->num_tx_fcbs[NON_MAC_QUEUE]);
375
376 tp->tx_fcb_head[BUG_QUEUE] = (FCBlock *)smctr_malloc(dev,
377 sizeof(FCBlock) * tp->num_tx_fcbs[BUG_QUEUE]);
378
379 /* Allocate transmit BDBs. */
380 tp->tx_bdb_head[MAC_QUEUE] = (BDBlock *)smctr_malloc(dev,
381 sizeof(BDBlock) * tp->num_tx_bdbs[MAC_QUEUE]);
382
383 tp->tx_bdb_head[NON_MAC_QUEUE] = (BDBlock *)smctr_malloc(dev,
384 sizeof(BDBlock) * tp->num_tx_bdbs[NON_MAC_QUEUE]);
385
386 tp->tx_bdb_head[BUG_QUEUE] = (BDBlock *)smctr_malloc(dev,
387 sizeof(BDBlock) * tp->num_tx_bdbs[BUG_QUEUE]);
388
389 /* Allocate receive FCBs. */
390 tp->rx_fcb_head[MAC_QUEUE] = (FCBlock *)smctr_malloc(dev,
391 sizeof(FCBlock) * tp->num_rx_fcbs[MAC_QUEUE]);
392
393 tp->rx_fcb_head[NON_MAC_QUEUE] = (FCBlock *)smctr_malloc(dev,
394 sizeof(FCBlock) * tp->num_rx_fcbs[NON_MAC_QUEUE]);
395
396 /* Allocate receive BDBs. */
397 tp->rx_bdb_head[MAC_QUEUE] = (BDBlock *)smctr_malloc(dev,
398 sizeof(BDBlock) * tp->num_rx_bdbs[MAC_QUEUE]);
399
400 tp->rx_bdb_end[MAC_QUEUE] = (BDBlock *)smctr_malloc(dev, 0);
401
402 tp->rx_bdb_head[NON_MAC_QUEUE] = (BDBlock *)smctr_malloc(dev,
403 sizeof(BDBlock) * tp->num_rx_bdbs[NON_MAC_QUEUE]);
404
405 tp->rx_bdb_end[NON_MAC_QUEUE] = (BDBlock *)smctr_malloc(dev, 0);
406
407 /* Allocate MAC transmit buffers.
408 * MAC Tx Buffers doen't have to be on an ODD Boundry.
409 */
410 tp->tx_buff_head[MAC_QUEUE]
411 = (__u16 *)smctr_malloc(dev, tp->tx_buff_size[MAC_QUEUE]);
412 tp->tx_buff_curr[MAC_QUEUE] = tp->tx_buff_head[MAC_QUEUE];
413 tp->tx_buff_end [MAC_QUEUE] = (__u16 *)smctr_malloc(dev, 0);
414
415 /* Allocate BUG transmit buffers. */
416 tp->tx_buff_head[BUG_QUEUE]
417 = (__u16 *)smctr_malloc(dev, tp->tx_buff_size[BUG_QUEUE]);
418 tp->tx_buff_curr[BUG_QUEUE] = tp->tx_buff_head[BUG_QUEUE];
419 tp->tx_buff_end[BUG_QUEUE] = (__u16 *)smctr_malloc(dev, 0);
420
421 /* Allocate MAC receive data buffers.
422 * MAC Rx buffer doesn't have to be on a 256 byte boundry.
423 */
424 tp->rx_buff_head[MAC_QUEUE] = (__u16 *)smctr_malloc(dev,
425 RX_DATA_BUFFER_SIZE * tp->num_rx_bdbs[MAC_QUEUE]);
426 tp->rx_buff_end[MAC_QUEUE] = (__u16 *)smctr_malloc(dev, 0);
427
428 /* Allocate Non-MAC transmit buffers.
429 * ?? For maximum Netware performance, put Tx Buffers on
430 * ODD Boundry and then restore malloc to Even Boundrys.
431 */
432 smctr_malloc(dev, 1L);
433 tp->tx_buff_head[NON_MAC_QUEUE]
434 = (__u16 *)smctr_malloc(dev, tp->tx_buff_size[NON_MAC_QUEUE]);
435 tp->tx_buff_curr[NON_MAC_QUEUE] = tp->tx_buff_head[NON_MAC_QUEUE];
436 tp->tx_buff_end [NON_MAC_QUEUE] = (__u16 *)smctr_malloc(dev, 0);
437 smctr_malloc(dev, 1L);
438
439 /* Allocate Non-MAC receive data buffers.
440 * To guarantee a minimum of 256 contigous memory to
441 * UM_Receive_Packet's lookahead pointer, before a page
442 * change or ring end is encountered, place each rx buffer on
443 * a 256 byte boundry.
444 */
445 smctr_malloc(dev, TO_256_BYTE_BOUNDRY(tp->sh_mem_used));
446 tp->rx_buff_head[NON_MAC_QUEUE] = (__u16 *)smctr_malloc(dev,
447 RX_DATA_BUFFER_SIZE * tp->num_rx_bdbs[NON_MAC_QUEUE]);
448 tp->rx_buff_end[NON_MAC_QUEUE] = (__u16 *)smctr_malloc(dev, 0);
449
450 return (0);
451 }
452
453 /* Enter Bypass state. */
454 static int smctr_bypass_state(struct net_device *dev)
455 {
456 int err;
457
458 if(smctr_debug > 10)
459 printk("%s: smctr_bypass_state\n", dev->name);
460
461 err = smctr_setup_single_cmd(dev, ACB_CMD_CHANGE_JOIN_STATE,
462 JS_BYPASS_STATE);
463
464 return (err);
465 }
466
467 static int smctr_checksum_firmware(struct net_device *dev)
468 {
469 struct net_local *tp = (struct net_local *)dev->priv;
470 __u16 i, checksum = 0;
471
472 if(smctr_debug > 10)
473 printk("%s: smctr_checksum_firmware\n", dev->name);
474
475 smctr_enable_adapter_ctrl_store(dev);
476
477 for(i = 0; i < CS_RAM_SIZE; i += 2)
478 checksum += *((__u16 *)(tp->ram_access + i));
479
480 tp->microcode_version = *(__u16 *)(tp->ram_access
481 + CS_RAM_VERSION_OFFSET);
482 tp->microcode_version >>= 8;
483
484 smctr_disable_adapter_ctrl_store(dev);
485
486 if(checksum)
487 return (checksum);
488
489 return (0);
490 }
491
492 static int smctr_chk_mca(struct net_device *dev)
493 {
494 #ifdef CONFIG_MCA
495 struct net_local *tp = (struct net_local *)dev->priv;
496 int current_slot;
497 __u8 r1, r2, r3, r4, r5;
498
499 current_slot = mca_find_unused_adapter(smctr_posid, 0);
500 if(current_slot == MCA_NOTFOUND)
501 return (-ENODEV);
502
503 mca_set_adapter_name(current_slot, smctr_name);
504 mca_mark_as_used(current_slot);
505 tp->slot_num = current_slot;
506
507 r1 = mca_read_stored_pos(tp->slot_num, 2);
508 r2 = mca_read_stored_pos(tp->slot_num, 3);
509
510 if(tp->slot_num)
511 outb(CNFG_POS_CONTROL_REG, (__u8)((tp->slot_num - 1) | CNFG_SLOT_ENABLE_BIT));
512 else
513 outb(CNFG_POS_CONTROL_REG, (__u8)((tp->slot_num) | CNFG_SLOT_ENABLE_BIT));
514
515 r1 = inb(CNFG_POS_REG1);
516 r2 = inb(CNFG_POS_REG0);
517
518 tp->bic_type = BIC_594_CHIP;
519
520 /* IO */
521 r2 = mca_read_stored_pos(tp->slot_num, 2);
522 r2 &= 0xF0;
523 dev->base_addr = ((__u16)r2 << 8) + (__u16)0x800;
524 request_region(dev->base_addr, SMCTR_IO_EXTENT, smctr_name);
525
526 /* IRQ */
527 r5 = mca_read_stored_pos(tp->slot_num, 5);
528 r5 &= 0xC;
529 switch(r5)
530 {
531 case 0:
532 dev->irq = 3;
533 break;
534
535 case 0x4:
536 dev->irq = 4;
537 break;
538
539 case 0x8:
540 dev->irq = 10;
541 break;
542
543 default:
544 dev->irq = 15;
545 break;
546 }
547 if(request_irq(dev->irq, smctr_interrupt, SA_SHIRQ, smctr_name, dev))
548 return (-ENODEV);
549
550 /* Get RAM base */
551 r3 = mca_read_stored_pos(tp->slot_num, 3);
552 if(r3 & 0x8)
553 {
554 if(r3 & 0x80)
555 tp->ram_base = ((__u32)(r3 & 0x7) << 13) + 0xFD0000;
556 else
557 tp->ram_base = ((__u32)(r3 & 0x7) << 13) + 0x0D0000;
558 }
559 else
560 {
561 if(r3 & 0x80)
562 tp->ram_base = ((__u32)(r3 & 0x7) << 13) + 0xFC0000;
563 else
564 tp->ram_base = ((__u32)(r3 & 0x7) << 13) + 0x0C0000;
565 }
566
567 /* Get Ram Size */
568 r3 &= 0x30;
569 r3 >>= 4;
570
571 tp->ram_usable = (__u16)CNFG_SIZE_8KB << r3;
572 tp->ram_size = (__u16)CNFG_SIZE_64KB;
573 tp->board_id |= TOKEN_MEDIA;
574
575 r4 = mca_read_stored_pos(tp->slot_num, 4);
576 if(r4 & 0x8)
577 tp->rom_base = ((__u32)(r4 & 0x7) << 13) + 0xD0000;
578 else
579 tp->rom_base = ((__u32)(r4 & 0x7) << 13) + 0xC0000;
580
581 /* Get ROM size. */
582 r4 >>= 4;
583 if(r4 == 0)
584 tp->rom_size = CNFG_SIZE_8KB;
585 else
586 {
587 if(r4 == 1)
588 tp->rom_size = CNFG_SIZE_16KB;
589 else
590 {
591 if(r4 == 2)
592 tp->rom_size = CNFG_SIZE_32KB;
593 else
594 tp->rom_size = ROM_DISABLE;
595 }
596 }
597
598 /* Get Media Type. */
599 r5 = mca_read_stored_pos(tp->slot_num, 5);
600 r5 &= CNFG_MEDIA_TYPE_MASK;
601 switch(r5)
602 {
603 case (0):
604 tp->media_type = MEDIA_STP_4;
605 break;
606
607 case (1):
608 tp->media_type = MEDIA_STP_16;
609 break;
610
611 case (3):
612 tp->media_type = MEDIA_UTP_16;
613 break;
614
615 default:
616 tp->media_type = MEDIA_UTP_4;
617 break;
618 }
619 tp->media_menu = 14;
620
621 r2 = mca_read_stored_pos(tp->slot_num, 2);
622 if(!(r2 & 0x02))
623 tp->mode_bits |= EARLY_TOKEN_REL;
624
625 /* Disable slot */
626 outb(CNFG_POS_CONTROL_REG, 0);
627
628 tp->board_id = smctr_get_boardid(dev, 1);
629 switch(tp->board_id & 0xffff)
630 {
631 case WD8115TA:
632 smctr_model = "8115T/A";
633 break;
634
635 case WD8115T:
636 if(tp->extra_info & CHIP_REV_MASK)
637 smctr_model = "8115T rev XE";
638 else
639 smctr_model = "8115T rev XD";
640 break;
641
642 default:
643 smctr_model = "Unknown";
644 break;
645 }
646
647 return (0);
648 #else
649 return (-1);
650 #endif /* CONFIG_MCA */
651 }
652
653 static int smctr_chg_rx_mask(struct net_device *dev)
654 {
655 struct net_local *tp = (struct net_local *)dev->priv;
656 int err = 0;
657
658 if(smctr_debug > 10)
659 printk("%s: smctr_chg_rx_mask\n", dev->name);
660
661 smctr_enable_16bit(dev);
662 smctr_set_page(dev, (__u8 *)tp->ram_access);
663
664 if(tp->mode_bits & LOOPING_MODE_MASK)
665 tp->config_word0 |= RX_OWN_BIT;
666 else
667 tp->config_word0 &= ~RX_OWN_BIT;
668
669 if(tp->receive_mask & PROMISCUOUS_MODE)
670 tp->config_word0 |= PROMISCUOUS_BIT;
671 else
672 tp->config_word0 &= ~PROMISCUOUS_BIT;
673
674 if(tp->receive_mask & ACCEPT_ERR_PACKETS)
675 tp->config_word0 |= SAVBAD_BIT;
676 else
677 tp->config_word0 &= ~SAVBAD_BIT;
678
679 if(tp->receive_mask & ACCEPT_ATT_MAC_FRAMES)
680 tp->config_word0 |= RXATMAC;
681 else
682 tp->config_word0 &= ~RXATMAC;
683
684 if(tp->receive_mask & ACCEPT_MULTI_PROM)
685 tp->config_word1 |= MULTICAST_ADDRESS_BIT;
686 else
687 tp->config_word1 &= ~MULTICAST_ADDRESS_BIT;
688
689 if(tp->receive_mask & ACCEPT_SOURCE_ROUTING_SPANNING)
690 tp->config_word1 |= SOURCE_ROUTING_SPANNING_BITS;
691 else
692 {
693 if(tp->receive_mask & ACCEPT_SOURCE_ROUTING)
694 tp->config_word1 |= SOURCE_ROUTING_EXPLORER_BIT;
695 else
696 tp->config_word1 &= ~SOURCE_ROUTING_SPANNING_BITS;
697 }
698
699 if((err = smctr_issue_write_word_cmd(dev, RW_CONFIG_REGISTER_0,
700 &tp->config_word0)))
701 {
702 return (err);
703 }
704
705 if((err = smctr_issue_write_word_cmd(dev, RW_CONFIG_REGISTER_1,
706 &tp->config_word1)))
707 {
708 return (err);
709 }
710
711 smctr_disable_16bit(dev);
712
713 return (0);
714 }
715
716 static int smctr_clear_int(struct net_device *dev)
717 {
718 struct net_local *tp = (struct net_local *)dev->priv;
719
720 outb((tp->trc_mask | CSR_CLRTINT), dev->base_addr + CSR);
721
722 return (0);
723 }
724
725 static int smctr_clear_trc_reset(int ioaddr)
726 {
727 __u8 r;
728
729 r = inb(ioaddr + MSR);
730 outb(~MSR_RST & r, ioaddr + MSR);
731
732 return (0);
733 }
734
735 /*
736 * The inverse routine to smctr_open().
737 */
738 static int smctr_close(struct net_device *dev)
739 {
740 struct net_local *tp = (struct net_local *)dev->priv;
741 struct sk_buff *skb;
742 int err;
743
744 netif_stop_queue(dev);
745
746 #ifdef MODULE
747 MOD_DEC_USE_COUNT;
748 #endif
749
750 tp->cleanup = 1;
751
752 /* Check to see if adapter is already in a closed state. */
753 if(tp->status != OPEN)
754 return (0);
755
756 smctr_enable_16bit(dev);
757 smctr_set_page(dev, (__u8 *)tp->ram_access);
758
759 if((err = smctr_issue_remove_cmd(dev)))
760 {
761 smctr_disable_16bit(dev);
762 return (err);
763 }
764
765 for(;;)
766 {
767 skb = skb_dequeue(&tp->SendSkbQueue);
768 if(skb == NULL)
769 break;
770 tp->QueueSkb++;
771 dev_kfree_skb(skb);
772 }
773
774
775 return (0);
776 }
777
778 static int smctr_decode_firmware(struct net_device *dev)
779 {
780 struct net_local *tp = (struct net_local *)dev->priv;
781 short bit = 0x80, shift = 12;
782 DECODE_TREE_NODE *tree;
783 short branch, tsize;
784 __u16 buff = 0;
785 long weight;
786 __u8 *ucode;
787 __u16 *mem;
788
789 if(smctr_debug > 10)
790 printk("%s: smctr_decode_firmware\n", dev->name);
791
792 weight = *(long *)(tp->ptr_ucode + WEIGHT_OFFSET);
793 tsize = *(__u8 *)(tp->ptr_ucode + TREE_SIZE_OFFSET);
794 tree = (DECODE_TREE_NODE *)(tp->ptr_ucode + TREE_OFFSET);
795 ucode = (__u8 *)(tp->ptr_ucode + TREE_OFFSET
796 + (tsize * sizeof(DECODE_TREE_NODE)));
797 mem = (__u16 *)(tp->ram_access);
798
799 while(weight)
800 {
801 branch = ROOT;
802 while((tree + branch)->tag != LEAF && weight)
803 {
804 branch = *ucode & bit ? (tree + branch)->llink
805 : (tree + branch)->rlink;
806
807 bit >>= 1;
808 weight--;
809
810 if(bit == 0)
811 {
812 bit = 0x80;
813 ucode++;
814 }
815 }
816
817 buff |= (tree + branch)->info << shift;
818 shift -= 4;
819
820 if(shift < 0)
821 {
822 *(mem++) = SWAP_BYTES(buff);
823 buff = 0;
824 shift = 12;
825 }
826 }
827
828 /* The following assumes the Control Store Memory has
829 * been initialized to zero. If the last partial word
830 * is zero, it will not be written.
831 */
832 if(buff)
833 *(mem++) = SWAP_BYTES(buff);
834
835 return (0);
836 }
837
838 static int smctr_disable_16bit(struct net_device *dev)
839 {
840 return (0);
841 }
842
843 /*
844 * On Exit, Adapter is:
845 * 1. TRC is in a reset state and un-initialized.
846 * 2. Adapter memory is enabled.
847 * 3. Control Store memory is out of context (-WCSS is 1).
848 */
849 static int smctr_disable_adapter_ctrl_store(struct net_device *dev)
850 {
851 struct net_local *tp = (struct net_local *)dev->priv;
852 int ioaddr = dev->base_addr;
853
854 if(smctr_debug > 10)
855 printk("%s: smctr_disable_adapter_ctrl_store\n", dev->name);
856
857 tp->trc_mask |= CSR_WCSS;
858 outb(tp->trc_mask, ioaddr + CSR);
859
860 return (0);
861 }
862
863 static int smctr_disable_bic_int(struct net_device *dev)
864 {
865 struct net_local *tp = (struct net_local *)dev->priv;
866 int ioaddr = dev->base_addr;
867
868 tp->trc_mask = CSR_MSK_ALL | CSR_MSKCBUSY
869 | CSR_MSKTINT | CSR_WCSS;
870 outb(tp->trc_mask, ioaddr + CSR);
871
872 return (0);
873 }
874
875 static int smctr_enable_16bit(struct net_device *dev)
876 {
877 struct net_local *tp = (struct net_local *)dev->priv;
878 __u8 r;
879
880 if(tp->adapter_bus == BUS_ISA16_TYPE)
881 {
882 r = inb(dev->base_addr + LAAR);
883 outb((r | LAAR_MEM16ENB), dev->base_addr + LAAR);
884 }
885
886 return (0);
887 }
888
889 /*
890 * To enable the adapter control store memory:
891 * 1. Adapter must be in a RESET state.
892 * 2. Adapter memory must be enabled.
893 * 3. Control Store Memory is in context (-WCSS is 0).
894 */
895 static int smctr_enable_adapter_ctrl_store(struct net_device *dev)
896 {
897 struct net_local *tp = (struct net_local *)dev->priv;
898 int ioaddr = dev->base_addr;
899
900 if(smctr_debug > 10)
901 printk("%s: smctr_enable_adapter_ctrl_store\n", dev->name);
902
903 smctr_set_trc_reset(ioaddr);
904 smctr_enable_adapter_ram(dev);
905
906 tp->trc_mask &= ~CSR_WCSS;
907 outb(tp->trc_mask, ioaddr + CSR);
908
909 return (0);
910 }
911
912 static int smctr_enable_adapter_ram(struct net_device *dev)
913 {
914 int ioaddr = dev->base_addr;
915 __u8 r;
916
917 if(smctr_debug > 10)
918 printk("%s: smctr_enable_adapter_ram\n", dev->name);
919
920 r = inb(ioaddr + MSR);
921 outb(MSR_MEMB | r, ioaddr + MSR);
922
923 return (0);
924 }
925
926 static int smctr_enable_bic_int(struct net_device *dev)
927 {
928 struct net_local *tp = (struct net_local *)dev->priv;
929 int ioaddr = dev->base_addr;
930 __u8 r;
931
932 switch(tp->bic_type)
933 {
934 case (BIC_584_CHIP):
935 tp->trc_mask = CSR_MSKCBUSY | CSR_WCSS;
936 outb(tp->trc_mask, ioaddr + CSR);
937 r = inb(ioaddr + IRR);
938 outb(r | IRR_IEN, ioaddr + IRR);
939 break;
940
941 case (BIC_594_CHIP):
942 tp->trc_mask = CSR_MSKCBUSY | CSR_WCSS;
943 outb(tp->trc_mask, ioaddr + CSR);
944 r = inb(ioaddr + IMCCR);
945 outb(r | IMCCR_EIL, ioaddr + IMCCR);
946 break;
947 }
948
949 return (0);
950 }
951
952 static int __init smctr_chk_isa(struct net_device *dev)
953 {
954 struct net_local *tp = (struct net_local *)dev->priv;
955 int ioaddr = dev->base_addr;
956 __u8 r1, r2, b, chksum = 0;
957 __u16 r;
958 int i;
959
960 if(smctr_debug > 10)
961 printk("%s: smctr_chk_isa %#4x\n", dev->name, ioaddr);
962
963 if((ioaddr & 0x1F) != 0)
964 return (-ENODEV);
965
966 /* Checksum SMC node address */
967 for(i = 0; i < 8; i++)
968 {
969 b = inb(ioaddr + LAR0 + i);
970 chksum += b;
971 }
972
973 if(chksum != NODE_ADDR_CKSUM)
974 return (-ENODEV); /* Adapter Not Found */
975
976 /* Grab the region so that no one else tries to probe our ioports. */
977 request_region(ioaddr, SMCTR_IO_EXTENT, smctr_name);
978
979 b = inb(ioaddr + BDID);
980 if(b != BRD_ID_8115T)
981 {
982 printk("%s: The adapter found is not supported\n", dev->name);
983 return (-1);
984 }
985
986 /* Check for 8115T Board ID */
987 r2 = 0;
988 for(r = 0; r < 8; r++)
989 {
990 r1 = inb(ioaddr + 0x8 + r);
991 r2 += r1;
992 }
993
994 /* value of RegF adds up the sum to 0xFF */
995 if((r2 != 0xFF) && (r2 != 0xEE))
996 return (-1);
997
998 /* Get adapter ID */
999 tp->board_id = smctr_get_boardid(dev, 0);
1000 switch(tp->board_id & 0xffff)
1001 {
1002 case WD8115TA:
1003 smctr_model = "8115T/A";
1004 break;
1005
1006 case WD8115T:
1007 if(tp->extra_info & CHIP_REV_MASK)
1008 smctr_model = "8115T rev XE";
1009 else
1010 smctr_model = "8115T rev XD";
1011 break;
1012
1013 default:
1014 smctr_model = "Unknown";
1015 break;
1016 }
1017
1018 /* Store BIC type. */
1019 tp->bic_type = BIC_584_CHIP;
1020 tp->nic_type = NIC_825_CHIP;
1021
1022 /* Copy Ram Size */
1023 tp->ram_usable = CNFG_SIZE_16KB;
1024 tp->ram_size = CNFG_SIZE_64KB;
1025
1026 /* Get 58x Ram Base */
1027 r1 = inb(ioaddr);
1028 r1 &= 0x3F;
1029
1030 r2 = inb(ioaddr + CNFG_LAAR_584);
1031 r2 &= CNFG_LAAR_MASK;
1032 r2 <<= 3;
1033 r2 |= ((r1 & 0x38) >> 3);
1034
1035 tp->ram_base = ((__u32)r2 << 16) + (((__u32)(r1 & 0x7)) << 13);
1036
1037 /* Get 584 Irq */
1038 r1 = 0;
1039 r1 = inb(ioaddr + CNFG_ICR_583);
1040 r1 &= CNFG_ICR_IR2_584;
1041
1042 r2 = inb(ioaddr + CNFG_IRR_583);
1043 r2 &= CNFG_IRR_IRQS; /* 0x60 */
1044 r2 >>= 5;
1045
1046 switch(r2)
1047 {
1048 case 0:
1049 if(r1 == 0)
1050 dev->irq = 2;
1051 else
1052 dev->irq = 10;
1053 break;
1054
1055 case 1:
1056 if(r1 == 0)
1057 dev->irq = 3;
1058 else
1059 dev->irq = 11;
1060 break;
1061
1062 case 2:
1063 if(r1 == 0)
1064 {
1065 if(tp->extra_info & ALTERNATE_IRQ_BIT)
1066 dev->irq = 5;
1067 else
1068 dev->irq = 4;
1069 }
1070 else
1071 dev->irq = 15;
1072 break;
1073
1074 case 3:
1075 if(r1 == 0)
1076 dev->irq = 7;
1077 else
1078 dev->irq = 4;
1079 break;
1080
1081 default:
1082 printk("%s: No IRQ found aborting\n", dev->name);
1083 return(-1);
1084 }
1085
1086 if(request_irq(dev->irq, smctr_interrupt, SA_SHIRQ, smctr_name, dev))
1087 return (-ENODEV);
1088
1089 /* Get 58x Rom Base */
1090 r1 = inb(ioaddr + CNFG_BIO_583);
1091 r1 &= 0x3E;
1092 r1 |= 0x40;
1093
1094 tp->rom_base = (__u32)r1 << 13;
1095
1096 /* Get 58x Rom Size */
1097 r1 = inb(ioaddr + CNFG_BIO_583);
1098 r1 &= 0xC0;
1099 if(r1 == 0)
1100 tp->rom_size = ROM_DISABLE;
1101 else
1102 {
1103 r1 >>= 6;
1104 tp->rom_size = (__u16)CNFG_SIZE_8KB << r1;
1105 }
1106
1107 /* Get 58x Boot Status */
1108 r1 = inb(ioaddr + CNFG_GP2);
1109
1110 tp->mode_bits &= (~BOOT_STATUS_MASK);
1111
1112 if(r1 & CNFG_GP2_BOOT_NIBBLE)
1113 tp->mode_bits |= BOOT_TYPE_1;
1114
1115 /* Get 58x Zero Wait State */
1116 tp->mode_bits &= (~ZERO_WAIT_STATE_MASK);
1117
1118 r1 = inb(ioaddr + CNFG_IRR_583);
1119
1120 if(r1 & CNFG_IRR_ZWS)
1121 tp->mode_bits |= ZERO_WAIT_STATE_8_BIT;
1122
1123 if(tp->board_id & BOARD_16BIT)
1124 {
1125 r1 = inb(ioaddr + CNFG_LAAR_584);
1126
1127 if(r1 & CNFG_LAAR_ZWS)
1128 tp->mode_bits |= ZERO_WAIT_STATE_16_BIT;
1129 }
1130
1131 /* Get 584 Media Menu */
1132 tp->media_menu = 14;
1133 r1 = inb(ioaddr + CNFG_IRR_583);
1134
1135 tp->mode_bits &= 0xf8ff; /* (~CNFG_INTERFACE_TYPE_MASK) */
1136 if((tp->board_id & TOKEN_MEDIA) == TOKEN_MEDIA)
1137 {
1138 /* Get Advanced Features */
1139 if(((r1 & 0x6) >> 1) == 0x3)
1140 tp->media_type |= MEDIA_UTP_16;
1141 else
1142 {
1143 if(((r1 & 0x6) >> 1) == 0x2)
1144 tp->media_type |= MEDIA_STP_16;
1145 else
1146 {
1147 if(((r1 & 0x6) >> 1) == 0x1)
1148 tp->media_type |= MEDIA_UTP_4;
1149
1150 else
1151 tp->media_type |= MEDIA_STP_4;
1152 }
1153 }
1154
1155 r1 = inb(ioaddr + CNFG_GP2);
1156 if(!(r1 & 0x2) ) /* GP2_ETRD */
1157 tp->mode_bits |= EARLY_TOKEN_REL;
1158
1159 /* see if the chip is corrupted
1160 if(smctr_read_584_chksum(ioaddr))
1161 {
1162 printk("%s: EEPROM Checksum Failure\n", dev->name);
1163 return(-1);
1164 }
1165 */
1166 }
1167
1168 return (0);
1169 }
1170
1171 static int __init smctr_get_boardid(struct net_device *dev, int mca)
1172 {
1173 struct net_local *tp = (struct net_local *)dev->priv;
1174 int ioaddr = dev->base_addr;
1175 __u8 r, r1, IdByte;
1176 __u16 BoardIdMask;
1177
1178 tp->board_id = BoardIdMask = 0;
1179
1180 if(mca)
1181 {
1182 BoardIdMask |= (MICROCHANNEL+INTERFACE_CHIP+TOKEN_MEDIA+PAGED_RAM+BOARD_16BIT);
1183 tp->extra_info |= (INTERFACE_594_CHIP+RAM_SIZE_64K+NIC_825_BIT+ALTERNATE_IRQ_BIT+SLOT_16BIT);
1184 }
1185 else
1186 {
1187 BoardIdMask|=(INTERFACE_CHIP+TOKEN_MEDIA+PAGED_RAM+BOARD_16BIT);
1188 tp->extra_info |= (INTERFACE_584_CHIP + RAM_SIZE_64K
1189 + NIC_825_BIT + ALTERNATE_IRQ_BIT);
1190 }
1191
1192 if(!mca)
1193 {
1194 r = inb(ioaddr + BID_REG_1);
1195 r &= 0x0c;
1196 outb(r, ioaddr + BID_REG_1);
1197 r = inb(ioaddr + BID_REG_1);
1198
1199 if(r & BID_SIXTEEN_BIT_BIT)
1200 {
1201 tp->extra_info |= SLOT_16BIT;
1202 tp->adapter_bus = BUS_ISA16_TYPE;
1203 }
1204 else
1205 tp->adapter_bus = BUS_ISA8_TYPE;
1206 }
1207 else
1208 tp->adapter_bus = BUS_MCA_TYPE;
1209
1210 /* Get Board Id Byte */
1211 IdByte = inb(ioaddr + BID_BOARD_ID_BYTE);
1212
1213 /* if Major version > 1.0 then
1214 * return;
1215 */
1216 if(IdByte & 0xF8)
1217 return (-1);
1218
1219 r1 = inb(ioaddr + BID_REG_1);
1220 r1 &= BID_ICR_MASK;
1221 r1 |= BID_OTHER_BIT;
1222
1223 outb(r1, ioaddr + BID_REG_1);
1224 r1 = inb(ioaddr + BID_REG_3);
1225
1226 r1 &= BID_EAR_MASK;
1227 r1 |= BID_ENGR_PAGE;
1228
1229 outb(r1, ioaddr + BID_REG_3);
1230 r1 = inb(ioaddr + BID_REG_1);
1231 r1 &= BID_ICR_MASK;
1232 r1 |= (BID_RLA | BID_OTHER_BIT);
1233
1234 outb(r1, ioaddr + BID_REG_1);
1235
1236 r1 = inb(ioaddr + BID_REG_1);
1237 while(r1 & BID_RECALL_DONE_MASK)
1238 r1 = inb(ioaddr + BID_REG_1);
1239
1240 r = inb(ioaddr + BID_LAR_0 + BID_REG_6);
1241
1242 /* clear chip rev bits */
1243 tp->extra_info &= ~CHIP_REV_MASK;
1244 tp->extra_info |= ((r & BID_EEPROM_CHIP_REV_MASK) << 6);
1245
1246 r1 = inb(ioaddr + BID_REG_1);
1247 r1 &= BID_ICR_MASK;
1248 r1 |= BID_OTHER_BIT;
1249
1250 outb(r1, ioaddr + BID_REG_1);
1251 r1 = inb(ioaddr + BID_REG_3);
1252
1253 r1 &= BID_EAR_MASK;
1254 r1 |= BID_EA6;
1255
1256 outb(r1, ioaddr + BID_REG_3);
1257 r1 = inb(ioaddr + BID_REG_1);
1258
1259 r1 &= BID_ICR_MASK;
1260 r1 |= BID_RLA;
1261
1262 outb(r1, ioaddr + BID_REG_1);
1263 r1 = inb(ioaddr + BID_REG_1);
1264
1265 while(r1 & BID_RECALL_DONE_MASK)
1266 r1 = inb(ioaddr + BID_REG_1);
1267
1268 return (BoardIdMask);
1269 }
1270
1271 static int smctr_get_group_address(struct net_device *dev)
1272 {
1273 smctr_issue_read_word_cmd(dev, RW_INDIVIDUAL_GROUP_ADDR);
1274
1275 return(smctr_wait_cmd(dev));
1276 }
1277
1278 static int smctr_get_functional_address(struct net_device *dev)
1279 {
1280 smctr_issue_read_word_cmd(dev, RW_FUNCTIONAL_ADDR);
1281
1282 return(smctr_wait_cmd(dev));
1283 }
1284
1285 /* Calculate number of Non-MAC receive BDB's and data buffers.
1286 * This function must simulate allocateing shared memory exactly
1287 * as the allocate_shared_memory function above.
1288 */
1289 static unsigned int smctr_get_num_rx_bdbs(struct net_device *dev)
1290 {
1291 struct net_local *tp = (struct net_local *)dev->priv;
1292 unsigned int mem_used = 0;
1293
1294 /* Allocate System Control Blocks. */
1295 mem_used += sizeof(SCGBlock);
1296
1297 mem_used += TO_PARAGRAPH_BOUNDRY(mem_used);
1298 mem_used += sizeof(SCLBlock);
1299
1300 mem_used += TO_PARAGRAPH_BOUNDRY(mem_used);
1301 mem_used += sizeof(ACBlock) * tp->num_acbs;
1302
1303 mem_used += TO_PARAGRAPH_BOUNDRY(mem_used);
1304 mem_used += sizeof(ISBlock);
1305
1306 mem_used += TO_PARAGRAPH_BOUNDRY(mem_used);
1307 mem_used += MISC_DATA_SIZE;
1308
1309 /* Allocate transmit FCB's. */
1310 mem_used += TO_PARAGRAPH_BOUNDRY(mem_used);
1311
1312 mem_used += sizeof(FCBlock) * tp->num_tx_fcbs[MAC_QUEUE];
1313 mem_used += sizeof(FCBlock) * tp->num_tx_fcbs[NON_MAC_QUEUE];
1314 mem_used += sizeof(FCBlock) * tp->num_tx_fcbs[BUG_QUEUE];
1315
1316 /* Allocate transmit BDBs. */
1317 mem_used += sizeof(BDBlock) * tp->num_tx_bdbs[MAC_QUEUE];
1318 mem_used += sizeof(BDBlock) * tp->num_tx_bdbs[NON_MAC_QUEUE];
1319 mem_used += sizeof(BDBlock) * tp->num_tx_bdbs[BUG_QUEUE];
1320
1321 /* Allocate receive FCBs. */
1322 mem_used += sizeof(FCBlock) * tp->num_rx_fcbs[MAC_QUEUE];
1323 mem_used += sizeof(FCBlock) * tp->num_rx_fcbs[NON_MAC_QUEUE];
1324
1325 /* Allocate receive BDBs. */
1326 mem_used += sizeof(BDBlock) * tp->num_rx_bdbs[MAC_QUEUE];
1327
1328 /* Allocate MAC transmit buffers.
1329 * MAC transmit buffers don't have to be on an ODD Boundry.
1330 */
1331 mem_used += tp->tx_buff_size[MAC_QUEUE];
1332
1333 /* Allocate BUG transmit buffers. */
1334 mem_used += tp->tx_buff_size[BUG_QUEUE];
1335
1336 /* Allocate MAC receive data buffers.
1337 * MAC receive buffers don't have to be on a 256 byte boundry.
1338 */
1339 mem_used += RX_DATA_BUFFER_SIZE * tp->num_rx_bdbs[MAC_QUEUE];
1340
1341 /* Allocate Non-MAC transmit buffers.
1342 * For maximum Netware performance, put Tx Buffers on
1343 * ODD Boundry,and then restore malloc to Even Boundrys.
1344 */
1345 mem_used += 1L;
1346 mem_used += tp->tx_buff_size[NON_MAC_QUEUE];
1347 mem_used += 1L;
1348
1349 /* CALCULATE NUMBER OF NON-MAC RX BDB'S
1350 * AND NON-MAC RX DATA BUFFERS
1351 *
1352 * Make sure the mem_used offset at this point is the
1353 * same as in allocate_shared memory or the following
1354 * boundry adjustment will be incorrect (i.e. not allocating
1355 * the non-mac receive buffers above cannot change the 256
1356 * byte offset).
1357 *
1358 * Since this cannot be guaranteed, adding the full 256 bytes
1359 * to the amount of shared memory used at this point will guaranteed
1360 * that the rx data buffers do not overflow shared memory.
1361 */
1362 mem_used += 0x100;
1363
1364 return((0xffff - mem_used) / (RX_DATA_BUFFER_SIZE + sizeof(BDBlock)));
1365 }
1366
1367 static int smctr_get_physical_drop_number(struct net_device *dev)
1368 {
1369 smctr_issue_read_word_cmd(dev, RW_PHYSICAL_DROP_NUMBER);
1370
1371 return(smctr_wait_cmd(dev));
1372 }
1373
1374 static __u8 * smctr_get_rx_pointer(struct net_device *dev, short queue)
1375 {
1376 struct net_local *tp = (struct net_local *)dev->priv;
1377 BDBlock *bdb;
1378
1379 bdb = (BDBlock *)((__u32)tp->ram_access
1380 + (__u32)(tp->rx_fcb_curr[queue]->trc_bdb_ptr));
1381
1382 tp->rx_fcb_curr[queue]->bdb_ptr = bdb;
1383
1384 return ((__u8 *)bdb->data_block_ptr);
1385 }
1386
1387 static int smctr_get_station_id(struct net_device *dev)
1388 {
1389 smctr_issue_read_word_cmd(dev, RW_INDIVIDUAL_MAC_ADDRESS);
1390
1391 return(smctr_wait_cmd(dev));
1392 }
1393
1394 /*
1395 * Get the current statistics. This may be called with the card open
1396 * or closed.
1397 */
1398 static struct net_device_stats *smctr_get_stats(struct net_device *dev)
1399 {
1400 struct net_local *tp = (struct net_local *)dev->priv;
1401
1402 return ((struct net_device_stats *)&tp->MacStat);
1403 }
1404
1405 static FCBlock *smctr_get_tx_fcb(struct net_device *dev, __u16 queue,
1406 __u16 bytes_count)
1407 {
1408 struct net_local *tp = (struct net_local *)dev->priv;
1409 FCBlock *pFCB;
1410 BDBlock *pbdb;
1411 unsigned short alloc_size;
1412 unsigned short *temp;
1413
1414 if(smctr_debug > 20)
1415 printk("smctr_get_tx_fcb\n");
1416
1417 /* check if there is enough FCB blocks */
1418 if(tp->num_tx_fcbs_used[queue] >= tp->num_tx_fcbs[queue])
1419 return ((FCBlock *)(-1L));
1420
1421 /* round off the input pkt size to the nearest even number */
1422 alloc_size = (bytes_count + 1) & 0xfffe;
1423
1424 /* check if enough mem */
1425 if((tp->tx_buff_used[queue] + alloc_size) > tp->tx_buff_size[queue])
1426 return ((FCBlock *)(-1L));
1427
1428 /* check if past the end ;
1429 * if exactly enough mem to end of ring, alloc from front.
1430 * this avoids update of curr when curr = end
1431 */
1432 if(((unsigned long)(tp->tx_buff_curr[queue]) + alloc_size)
1433 >= (unsigned long)(tp->tx_buff_end[queue]))
1434 {
1435 /* check if enough memory from ring head */
1436 alloc_size = alloc_size +
1437 (__u16)((__u32)tp->tx_buff_end[queue]
1438 - (__u32)tp->tx_buff_curr[queue]);
1439
1440 if((tp->tx_buff_used[queue] + alloc_size)
1441 > tp->tx_buff_size[queue])
1442 {
1443 return ((FCBlock *)(-1L));
1444 }
1445
1446 /* ring wrap */
1447 tp->tx_buff_curr[queue] = tp->tx_buff_head[queue];
1448 }
1449
1450 tp->tx_buff_used[queue] += alloc_size;
1451 tp->num_tx_fcbs_used[queue]++;
1452 tp->tx_fcb_curr[queue]->frame_length = bytes_count;
1453 tp->tx_fcb_curr[queue]->memory_alloc = alloc_size;
1454 temp = tp->tx_buff_curr[queue];
1455 tp->tx_buff_curr[queue]
1456 = (__u16 *)((__u32)temp + (__u32)((bytes_count + 1) & 0xfffe));
1457
1458 pbdb = tp->tx_fcb_curr[queue]->bdb_ptr;
1459 pbdb->buffer_length = bytes_count;
1460 pbdb->data_block_ptr = temp;
1461 pbdb->trc_data_block_ptr = TRC_POINTER(temp);
1462
1463 pFCB = tp->tx_fcb_curr[queue];
1464 tp->tx_fcb_curr[queue] = tp->tx_fcb_curr[queue]->next_ptr;
1465
1466 return (pFCB);
1467 }
1468
1469 static int smctr_get_upstream_neighbor_addr(struct net_device *dev)
1470 {
1471 smctr_issue_read_word_cmd(dev, RW_UPSTREAM_NEIGHBOR_ADDRESS);
1472
1473 return(smctr_wait_cmd(dev));
1474 }
1475
1476 static int smctr_hardware_send_packet(struct net_device *dev,
1477 struct net_local *tp)
1478 {
1479 struct tr_statistics *tstat = &tp->MacStat;
1480 struct sk_buff *skb;
1481 FCBlock *fcb;
1482
1483 if(smctr_debug > 10)
1484 printk("%s: smctr_hardware_send_packet\n", dev->name);
1485
1486 if(tp->status != OPEN)
1487 return (-1);
1488
1489 if(tp->monitor_state_ready != 1)
1490 return (-1);
1491
1492 for(;;)
1493 {
1494 /* Send first buffer from queue */
1495 skb = skb_dequeue(&tp->SendSkbQueue);
1496 if(skb == NULL)
1497 return (-1);
1498
1499 tp->QueueSkb++;
1500
1501 if(skb->len < SMC_HEADER_SIZE || skb->len > tp->max_packet_size) return (-1);
1502
1503 smctr_enable_16bit(dev);
1504 smctr_set_page(dev, (__u8 *)tp->ram_access);
1505
1506 if((fcb = smctr_get_tx_fcb(dev, NON_MAC_QUEUE, skb->len))
1507 == (FCBlock *)(-1L))
1508 {
1509 smctr_disable_16bit(dev);
1510 return (-1);
1511 }
1512
1513 smctr_tx_move_frame(dev, skb,
1514 (__u8 *)fcb->bdb_ptr->data_block_ptr, skb->len);
1515
1516 smctr_set_page(dev, (__u8 *)fcb);
1517
1518 smctr_trc_send_packet(dev, fcb, NON_MAC_QUEUE);
1519 dev_kfree_skb(skb);
1520
1521 tstat->tx_packets++;
1522
1523 smctr_disable_16bit(dev);
1524 }
1525
1526 return (0);
1527 }
1528
1529 static int smctr_init_acbs(struct net_device *dev)
1530 {
1531 struct net_local *tp = (struct net_local *)dev->priv;
1532 unsigned int i;
1533 ACBlock *acb;
1534
1535 if(smctr_debug > 10)
1536 printk("%s: smctr_init_acbs\n", dev->name);
1537
1538 acb = tp->acb_head;
1539 acb->cmd_done_status = (ACB_COMMAND_DONE | ACB_COMMAND_SUCCESSFUL);
1540 acb->cmd_info = ACB_CHAIN_END;
1541 acb->cmd = 0;
1542 acb->subcmd = 0;
1543 acb->data_offset_lo = 0;
1544 acb->data_offset_hi = 0;
1545 acb->next_ptr
1546 = (ACBlock *)(((char *)acb) + sizeof(ACBlock));
1547 acb->trc_next_ptr = TRC_POINTER(acb->next_ptr);
1548
1549 for(i = 1; i < tp->num_acbs; i++)
1550 {
1551 acb = acb->next_ptr;
1552 acb->cmd_done_status
1553 = (ACB_COMMAND_DONE | ACB_COMMAND_SUCCESSFUL);
1554 acb->cmd_info = ACB_CHAIN_END;
1555 acb->cmd = 0;
1556 acb->subcmd = 0;
1557 acb->data_offset_lo = 0;
1558 acb->data_offset_hi = 0;
1559 acb->next_ptr
1560 = (ACBlock *)(((char *)acb) + sizeof(ACBlock));
1561 acb->trc_next_ptr = TRC_POINTER(acb->next_ptr);
1562 }
1563
1564 acb->next_ptr = tp->acb_head;
1565 acb->trc_next_ptr = TRC_POINTER(tp->acb_head);
1566 tp->acb_next = tp->acb_head->next_ptr;
1567 tp->acb_curr = tp->acb_head->next_ptr;
1568 tp->num_acbs_used = 0;
1569
1570 return (0);
1571 }
1572
1573 static int smctr_init_adapter(struct net_device *dev)
1574 {
1575 struct net_local *tp = (struct net_local *)dev->priv;
1576 int err;
1577
1578 if(smctr_debug > 10)
1579 printk("%s: smctr_init_adapter\n", dev->name);
1580
1581 tp->status = CLOSED;
1582 tp->page_offset_mask = (tp->ram_usable * 1024) - 1;
1583 skb_queue_head_init(&tp->SendSkbQueue);
1584 tp->QueueSkb = MAX_TX_QUEUE;
1585
1586 if(!(tp->group_address_0 & 0x0080))
1587 tp->group_address_0 |= 0x00C0;
1588
1589 if(!(tp->functional_address_0 & 0x00C0))
1590 tp->functional_address_0 |= 0x00C0;
1591
1592 tp->functional_address[0] &= 0xFF7F;
1593
1594 if(tp->authorized_function_classes == 0)
1595 tp->authorized_function_classes = 0x7FFF;
1596
1597 if(tp->authorized_access_priority == 0)
1598 tp->authorized_access_priority = 0x06;
1599
1600 smctr_disable_bic_int(dev);
1601 smctr_set_trc_reset(dev->base_addr);
1602
1603 smctr_enable_16bit(dev);
1604 smctr_set_page(dev, (__u8 *)tp->ram_access);
1605
1606 if(smctr_checksum_firmware(dev))
1607 {
1608 printk("%s: Previously loaded firmware is missing\n",dev->name); return (-ENOENT);
1609 }
1610
1611 if((err = smctr_ram_memory_test(dev)))
1612 {
1613 printk("%s: RAM memory test failed.\n", dev->name);
1614 return (-EIO);
1615 }
1616
1617 smctr_set_rx_look_ahead(dev);
1618 smctr_load_node_addr(dev);
1619
1620 /* Initialize adapter for Internal Self Test. */
1621 smctr_reset_adapter(dev);
1622 if((err = smctr_init_card_real(dev)))
1623 {
1624 printk("%s: Initialization of card failed (%d)\n",
1625 dev->name, err);
1626 return (-EINVAL);
1627 }
1628
1629 /* This routine clobbers the TRC's internal registers. */
1630 if((err = smctr_internal_self_test(dev)))
1631 {
1632 printk("%s: Card failed internal self test (%d)\n",
1633 dev->name, err);
1634 return (-EINVAL);
1635 }
1636
1637 /* Re-Initialize adapter's internal registers */
1638 smctr_reset_adapter(dev);
1639 if((err = smctr_init_card_real(dev)))
1640 {
1641 printk("%s: Initialization of card failed (%d)\n",
1642 dev->name, err);
1643 return (-EINVAL);
1644 }
1645
1646 smctr_enable_bic_int(dev);
1647
1648 if((err = smctr_issue_enable_int_cmd(dev, TRC_INTERRUPT_ENABLE_MASK)))
1649 return (err);
1650
1651 smctr_disable_16bit(dev);
1652
1653 return (0);
1654 }
1655
1656 /* Dummy function */
1657 static int __init smctr_init_card(struct net_device *dev)
1658 {
1659 if(smctr_debug > 10)
1660 printk("%s: smctr_init_card\n", dev->name);
1661
1662 return (0);
1663 }
1664
1665 static int smctr_init_card_real(struct net_device *dev)
1666 {
1667 struct net_local *tp = (struct net_local *)dev->priv;
1668 int err = 0;
1669
1670 if(smctr_debug > 10)
1671 printk("%s: smctr_init_card_real\n", dev->name);
1672
1673 tp->sh_mem_used = 0;
1674 tp->num_acbs = NUM_OF_ACBS;
1675
1676 /* Range Check Max Packet Size */
1677 if(tp->max_packet_size < 256)
1678 tp->max_packet_size = 256;
1679 else
1680 {
1681 if(tp->max_packet_size > NON_MAC_TX_BUFFER_MEMORY)
1682 tp->max_packet_size = NON_MAC_TX_BUFFER_MEMORY;
1683 }
1684
1685 tp->num_of_tx_buffs = (NON_MAC_TX_BUFFER_MEMORY
1686 / tp->max_packet_size) - 1;
1687
1688 if(tp->num_of_tx_buffs > NUM_NON_MAC_TX_FCBS)
1689 tp->num_of_tx_buffs = NUM_NON_MAC_TX_FCBS;
1690 else
1691 {
1692 if(tp->num_of_tx_buffs == 0)
1693 tp->num_of_tx_buffs = 1;
1694 }
1695
1696 /* Tx queue constants */
1697 tp->num_tx_fcbs [BUG_QUEUE] = NUM_BUG_TX_FCBS;
1698 tp->num_tx_bdbs [BUG_QUEUE] = NUM_BUG_TX_BDBS;
1699 tp->tx_buff_size [BUG_QUEUE] = BUG_TX_BUFFER_MEMORY;
1700 tp->tx_buff_used [BUG_QUEUE] = 0;
1701 tp->tx_queue_status [BUG_QUEUE] = NOT_TRANSMITING;
1702
1703 tp->num_tx_fcbs [MAC_QUEUE] = NUM_MAC_TX_FCBS;
1704 tp->num_tx_bdbs [MAC_QUEUE] = NUM_MAC_TX_BDBS;
1705 tp->tx_buff_size [MAC_QUEUE] = MAC_TX_BUFFER_MEMORY;
1706 tp->tx_buff_used [MAC_QUEUE] = 0;
1707 tp->tx_queue_status [MAC_QUEUE] = NOT_TRANSMITING;
1708
1709 tp->num_tx_fcbs [NON_MAC_QUEUE] = NUM_NON_MAC_TX_FCBS;
1710 tp->num_tx_bdbs [NON_MAC_QUEUE] = NUM_NON_MAC_TX_BDBS;
1711 tp->tx_buff_size [NON_MAC_QUEUE] = NON_MAC_TX_BUFFER_MEMORY;
1712 tp->tx_buff_used [NON_MAC_QUEUE] = 0;
1713 tp->tx_queue_status [NON_MAC_QUEUE] = NOT_TRANSMITING;
1714
1715 /* Receive Queue Constants */
1716 tp->num_rx_fcbs[MAC_QUEUE] = NUM_MAC_RX_FCBS;
1717 tp->num_rx_bdbs[MAC_QUEUE] = NUM_MAC_RX_BDBS;
1718
1719 if(tp->extra_info & CHIP_REV_MASK)
1720 tp->num_rx_fcbs[NON_MAC_QUEUE] = 78; /* 825 Rev. XE */
1721 else
1722 tp->num_rx_fcbs[NON_MAC_QUEUE] = 7; /* 825 Rev. XD */
1723
1724 tp->num_rx_bdbs[NON_MAC_QUEUE] = smctr_get_num_rx_bdbs(dev);
1725
1726 smctr_alloc_shared_memory(dev);
1727 smctr_init_shared_memory(dev);
1728
1729 if((err = smctr_issue_init_timers_cmd(dev)))
1730 return (err);
1731
1732 if((err = smctr_issue_init_txrx_cmd(dev)))
1733 {
1734 printk("%s: Hardware failure\n", dev->name);
1735 return (err);
1736 }
1737
1738 return (0);
1739 }
1740
1741 static int smctr_init_rx_bdbs(struct net_device *dev)
1742 {
1743 struct net_local *tp = (struct net_local *)dev->priv;
1744 unsigned int i, j;
1745 BDBlock *bdb;
1746 __u16 *buf;
1747
1748 if(smctr_debug > 10)
1749 printk("%s: smctr_init_rx_bdbs\n", dev->name);
1750
1751 for(i = 0; i < NUM_RX_QS_USED; i++)
1752 {
1753 bdb = tp->rx_bdb_head[i];
1754 buf = tp->rx_buff_head[i];
1755 bdb->info = (BDB_CHAIN_END | BDB_NO_WARNING);
1756 bdb->buffer_length = RX_DATA_BUFFER_SIZE;
1757 bdb->next_ptr = (BDBlock *)(((char *)bdb) + sizeof(BDBlock));
1758 bdb->data_block_ptr = buf;
1759 bdb->trc_next_ptr = TRC_POINTER(bdb->next_ptr);
1760
1761 if(i == NON_MAC_QUEUE)
1762 bdb->trc_data_block_ptr = RX_BUFF_TRC_POINTER(buf);
1763 else
1764 bdb->trc_data_block_ptr = TRC_POINTER(buf);
1765
1766 for(j = 1; j < tp->num_rx_bdbs[i]; j++)
1767 {
1768 bdb->next_ptr->back_ptr = bdb;
1769 bdb = bdb->next_ptr;
1770 buf = (__u16 *)((char *)buf + RX_DATA_BUFFER_SIZE);
1771 bdb->info = (BDB_NOT_CHAIN_END | BDB_NO_WARNING);
1772 bdb->buffer_length = RX_DATA_BUFFER_SIZE;
1773 bdb->next_ptr = (BDBlock *)(((char *)bdb) + sizeof(BDBlock));
1774 bdb->data_block_ptr = buf;
1775 bdb->trc_next_ptr = TRC_POINTER(bdb->next_ptr);
1776
1777 if(i == NON_MAC_QUEUE)
1778 bdb->trc_data_block_ptr = RX_BUFF_TRC_POINTER(buf);
1779 else
1780 bdb->trc_data_block_ptr = TRC_POINTER(buf);
1781 }
1782
1783 bdb->next_ptr = tp->rx_bdb_head[i];
1784 bdb->trc_next_ptr = TRC_POINTER(tp->rx_bdb_head[i]);
1785
1786 tp->rx_bdb_head[i]->back_ptr = bdb;
1787 tp->rx_bdb_curr[i] = tp->rx_bdb_head[i]->next_ptr;
1788 }
1789
1790 return (0);
1791 }
1792
1793 static int smctr_init_rx_fcbs(struct net_device *dev)
1794 {
1795 struct net_local *tp = (struct net_local *)dev->priv;
1796 unsigned int i, j;
1797 FCBlock *fcb;
1798
1799 for(i = 0; i < NUM_RX_QS_USED; i++)
1800 {
1801 fcb = tp->rx_fcb_head[i];
1802 fcb->frame_status = 0;
1803 fcb->frame_length = 0;
1804 fcb->info = FCB_CHAIN_END;
1805 fcb->next_ptr = (FCBlock *)(((char*)fcb) + sizeof(FCBlock));
1806 if(i == NON_MAC_QUEUE)
1807 fcb->trc_next_ptr = RX_FCB_TRC_POINTER(fcb->next_ptr);
1808 else
1809 fcb->trc_next_ptr = TRC_POINTER(fcb->next_ptr);
1810
1811 for(j = 1; j < tp->num_rx_fcbs[i]; j++)
1812 {
1813 fcb->next_ptr->back_ptr = fcb;
1814 fcb = fcb->next_ptr;
1815 fcb->frame_status = 0;
1816 fcb->frame_length = 0;
1817 fcb->info = FCB_WARNING;
1818 fcb->next_ptr
1819 = (FCBlock *)(((char *)fcb) + sizeof(FCBlock));
1820
1821 if(i == NON_MAC_QUEUE)
1822 fcb->trc_next_ptr
1823 = RX_FCB_TRC_POINTER(fcb->next_ptr);
1824 else
1825 fcb->trc_next_ptr
1826 = TRC_POINTER(fcb->next_ptr);
1827 }
1828
1829 fcb->next_ptr = tp->rx_fcb_head[i];
1830
1831 if(i == NON_MAC_QUEUE)
1832 fcb->trc_next_ptr = RX_FCB_TRC_POINTER(fcb->next_ptr);
1833 else
1834 fcb->trc_next_ptr = TRC_POINTER(fcb->next_ptr);
1835
1836 tp->rx_fcb_head[i]->back_ptr = fcb;
1837 tp->rx_fcb_curr[i] = tp->rx_fcb_head[i]->next_ptr;
1838 }
1839
1840 return(0);
1841 }
1842
1843 static int smctr_init_shared_memory(struct net_device *dev)
1844 {
1845 struct net_local *tp = (struct net_local *)dev->priv;
1846 unsigned int i;
1847 __u32 *iscpb;
1848
1849 if(smctr_debug > 10)
1850 printk("%s: smctr_init_shared_memory\n", dev->name);
1851
1852 smctr_set_page(dev, (__u8 *)(unsigned int)tp->iscpb_ptr);
1853
1854 /* Initialize Initial System Configuration Point. (ISCP) */
1855 iscpb = (__u32 *)PAGE_POINTER(&tp->iscpb_ptr->trc_scgb_ptr);
1856 *iscpb = (__u32)(SWAP_WORDS(TRC_POINTER(tp->scgb_ptr)));
1857
1858 smctr_set_page(dev, (__u8 *)tp->ram_access);
1859
1860 /* Initialize System Configuration Pointers. (SCP) */
1861 tp->scgb_ptr->config = (SCGB_ADDRESS_POINTER_FORMAT
1862 | SCGB_MULTI_WORD_CONTROL | SCGB_DATA_FORMAT
1863 | SCGB_BURST_LENGTH);
1864
1865 tp->scgb_ptr->trc_sclb_ptr = TRC_POINTER(tp->sclb_ptr);
1866 tp->scgb_ptr->trc_acb_ptr = TRC_POINTER(tp->acb_head);
1867 tp->scgb_ptr->trc_isb_ptr = TRC_POINTER(tp->isb_ptr);
1868 tp->scgb_ptr->isbsiz = (sizeof(ISBlock)) - 2;
1869
1870 /* Initialize System Control Block. (SCB) */
1871 tp->sclb_ptr->valid_command = SCLB_VALID | SCLB_CMD_NOP;
1872 tp->sclb_ptr->iack_code = 0;
1873 tp->sclb_ptr->resume_control = 0;
1874 tp->sclb_ptr->int_mask_control = 0;
1875 tp->sclb_ptr->int_mask_state = 0;
1876
1877 /* Initialize Interrupt Status Block. (ISB) */
1878 for(i = 0; i < NUM_OF_INTERRUPTS; i++)
1879 {
1880 tp->isb_ptr->IStatus[i].IType = 0xf0;
1881 tp->isb_ptr->IStatus[i].ISubtype = 0;
1882 }
1883
1884 tp->current_isb_index = 0;
1885
1886 /* Initialize Action Command Block. (ACB) */
1887 smctr_init_acbs(dev);
1888
1889 /* Initialize transmit FCB's and BDB's. */
1890 smctr_link_tx_fcbs_to_bdbs(dev);
1891 smctr_init_tx_bdbs(dev);
1892 smctr_init_tx_fcbs(dev);
1893
1894 /* Initialize receive FCB's and BDB's. */
1895 smctr_init_rx_bdbs(dev);
1896 smctr_init_rx_fcbs(dev);
1897
1898 return (0);
1899 }
1900
1901 static int smctr_init_tx_bdbs(struct net_device *dev)
1902 {
1903 struct net_local *tp = (struct net_local *)dev->priv;
1904 unsigned int i, j;
1905 BDBlock *bdb;
1906
1907 for(i = 0; i < NUM_TX_QS_USED; i++)
1908 {
1909 bdb = tp->tx_bdb_head[i];
1910 bdb->info = (BDB_NOT_CHAIN_END | BDB_NO_WARNING);
1911 bdb->next_ptr = (BDBlock *)(((char *)bdb) + sizeof(BDBlock));
1912 bdb->trc_next_ptr = TRC_POINTER(bdb->next_ptr);
1913
1914 for(j = 1; j < tp->num_tx_bdbs[i]; j++)
1915 {
1916 bdb->next_ptr->back_ptr = bdb;
1917 bdb = bdb->next_ptr;
1918 bdb->info = (BDB_NOT_CHAIN_END | BDB_NO_WARNING);
1919 bdb->next_ptr
1920 = (BDBlock *)(((char *)bdb) + sizeof( BDBlock)); bdb->trc_next_ptr = TRC_POINTER(bdb->next_ptr);
1921 }
1922
1923 bdb->next_ptr = tp->tx_bdb_head[i];
1924 bdb->trc_next_ptr = TRC_POINTER(tp->tx_bdb_head[i]);
1925 tp->tx_bdb_head[i]->back_ptr = bdb;
1926 }
1927
1928 return (0);
1929 }
1930
1931 static int smctr_init_tx_fcbs(struct net_device *dev)
1932 {
1933 struct net_local *tp = (struct net_local *)dev->priv;
1934 unsigned int i, j;
1935 FCBlock *fcb;
1936
1937 for(i = 0; i < NUM_TX_QS_USED; i++)
1938 {
1939 fcb = tp->tx_fcb_head[i];
1940 fcb->frame_status = 0;
1941 fcb->frame_length = 0;
1942 fcb->info = FCB_CHAIN_END;
1943 fcb->next_ptr = (FCBlock *)(((char *)fcb) + sizeof(FCBlock));
1944 fcb->trc_next_ptr = TRC_POINTER(fcb->next_ptr);
1945
1946 for(j = 1; j < tp->num_tx_fcbs[i]; j++)
1947 {
1948 fcb->next_ptr->back_ptr = fcb;
1949 fcb = fcb->next_ptr;
1950 fcb->frame_status = 0;
1951 fcb->frame_length = 0;
1952 fcb->info = FCB_CHAIN_END;
1953 fcb->next_ptr
1954 = (FCBlock *)(((char *)fcb) + sizeof(FCBlock));
1955 fcb->trc_next_ptr = TRC_POINTER(fcb->next_ptr);
1956 }
1957
1958 fcb->next_ptr = tp->tx_fcb_head[i];
1959 fcb->trc_next_ptr = TRC_POINTER(tp->tx_fcb_head[i]);
1960
1961 tp->tx_fcb_head[i]->back_ptr = fcb;
1962 tp->tx_fcb_end[i] = tp->tx_fcb_head[i]->next_ptr;
1963 tp->tx_fcb_curr[i] = tp->tx_fcb_head[i]->next_ptr;
1964 tp->num_tx_fcbs_used[i] = 0;
1965 }
1966
1967 return (0);
1968 }
1969
1970 static int smctr_internal_self_test(struct net_device *dev)
1971 {
1972 struct net_local *tp = (struct net_local *)dev->priv;
1973 int err;
1974
1975 if((err = smctr_issue_test_internal_rom_cmd(dev)))
1976 return (err);
1977
1978 if((err = smctr_wait_cmd(dev)))
1979 return (err);
1980
1981 if(tp->acb_head->cmd_done_status & 0xff)
1982 return (-1);
1983
1984 if((err = smctr_issue_test_hic_cmd(dev)))
1985 return (err);
1986
1987 if((err = smctr_wait_cmd(dev)))
1988 return (err);
1989
1990 if(tp->acb_head->cmd_done_status & 0xff)
1991 return (-1);
1992
1993 if((err = smctr_issue_test_mac_reg_cmd(dev)))
1994 return (err);
1995
1996 if((err = smctr_wait_cmd(dev)))
1997 return (err);
1998
1999 if(tp->acb_head->cmd_done_status & 0xff)
2000 return (-1);
2001
2002 return (0);
2003 }
2004
2005 /*
2006 * The typical workload of the driver: Handle the network interface interrupts.
2007 */
2008 static void smctr_interrupt(int irq, void *dev_id, struct pt_regs *regs)
2009 {
2010 struct net_device *dev = dev_id;
2011 struct net_local *tp;
2012 int ioaddr;
2013 __u16 interrupt_unmask_bits = 0, interrupt_ack_code = 0xff00;
2014 __u16 err1, err = NOT_MY_INTERRUPT;
2015 __u8 isb_type, isb_subtype;
2016 __u16 isb_index;
2017
2018 if(dev == NULL)
2019 {
2020 printk("%s: irq %d for unknown device.\n", dev->name, irq);
2021 return;
2022 }
2023
2024 ioaddr = dev->base_addr;
2025 tp = (struct net_local *)dev->priv;
2026
2027 if(tp->status == NOT_INITIALIZED)
2028 return;
2029
2030 smctr_disable_bic_int(dev);
2031 smctr_enable_16bit(dev);
2032
2033 smctr_clear_int(dev);
2034
2035 /* First read the LSB */
2036 while((tp->isb_ptr->IStatus[tp->current_isb_index].IType & 0xf0) == 0)
2037 {
2038 isb_index = tp->current_isb_index;
2039 isb_type = tp->isb_ptr->IStatus[isb_index].IType;
2040 isb_subtype = tp->isb_ptr->IStatus[isb_index].ISubtype;
2041
2042 (tp->current_isb_index)++;
2043 if(tp->current_isb_index == NUM_OF_INTERRUPTS)
2044 tp->current_isb_index = 0;
2045
2046 if(isb_type >= 0x10)
2047 {
2048 smctr_disable_16bit(dev);
2049 return;
2050 }
2051
2052 err = HARDWARE_FAILED;
2053 interrupt_ack_code = isb_index;
2054 tp->isb_ptr->IStatus[isb_index].IType |= 0xf0;
2055
2056 interrupt_unmask_bits |= (1 << (__u16)isb_type);
2057
2058 switch(isb_type)
2059 {
2060 case ISB_IMC_MAC_TYPE_3:
2061 smctr_disable_16bit(dev);
2062
2063 switch(isb_subtype)
2064 {
2065 case 0:
2066 tp->monitor_state
2067 = MS_MONITOR_FSM_INACTIVE;
2068 break;
2069
2070 case 1:
2071 tp->monitor_state
2072 = MS_REPEAT_BEACON_STATE;
2073 break;
2074
2075 case 2:
2076 tp->monitor_state
2077 = MS_REPEAT_CLAIM_TOKEN_STATE;
2078 break;
2079
2080 case 3:
2081 tp->monitor_state
2082 = MS_TRANSMIT_CLAIM_TOKEN_STATE; break;
2083
2084 case 4:
2085 tp->monitor_state
2086 = MS_STANDBY_MONITOR_STATE;
2087 break;
2088
2089 case 5:
2090 tp->monitor_state
2091 = MS_TRANSMIT_BEACON_STATE;
2092 break;
2093
2094 case 6:
2095 tp->monitor_state
2096 = MS_ACTIVE_MONITOR_STATE;
2097 break;
2098
2099 case 7:
2100 tp->monitor_state
2101 = MS_TRANSMIT_RING_PURGE_STATE;
2102 break;
2103
2104 case 8: /* diagnostic state */
2105 break;
2106
2107 case 9:
2108 tp->monitor_state
2109 = MS_BEACON_TEST_STATE;
2110 if(smctr_lobe_media_test(dev))
2111 {
2112 tp->ring_status_flags
2113 = RING_STATUS_CHANGED;
2114 tp->ring_status
2115 = AUTO_REMOVAL_ERROR;
2116 smctr_ring_status_chg(dev);
2117 smctr_bypass_state(dev);
2118 }
2119 else
2120 smctr_issue_insert_cmd(dev);
2121 break;
2122
2123 /* case 0x0a-0xff, illegal states */
2124 default:
2125 break;
2126 }
2127
2128 tp->ring_status_flags = MONITOR_STATE_CHANGED;
2129 err = smctr_ring_status_chg(dev);
2130
2131 smctr_enable_16bit(dev);
2132 break;
2133
2134 /* Type 0x02 - MAC Error Counters Interrupt
2135 * One or more MAC Error Counter is half full
2136 * MAC Error Counters
2137 * Lost_FR_Error_Counter
2138 * RCV_Congestion_Counter
2139 * FR_copied_Error_Counter
2140 * FREQ_Error_Counter
2141 * Token_Error_Counter
2142 * Line_Error_Counter
2143 * Internal_Error_Count
2144 */
2145 case ISB_IMC_MAC_ERROR_COUNTERS:
2146 /* Read 802.5 Error Counters */
2147 err = smctr_issue_read_ring_status_cmd(dev);
2148 break;
2149
2150 /* Type 0x04 - MAC Type 2 Interrupt
2151 * HOST needs to enqueue MAC Frame for transmission
2152 * SubType Bit 15 - RQ_INIT_PDU( Request Initialization) * Changed from RQ_INIT_PDU to
2153 * TRC_Status_Changed_Indicate
2154 */
2155 case ISB_IMC_MAC_TYPE_2:
2156 err = smctr_issue_read_ring_status_cmd(dev);
2157 break;
2158
2159
2160 /* Type 0x05 - TX Frame Interrupt (FI). */
2161 case ISB_IMC_TX_FRAME:
2162 /* BUG QUEUE for TRC stuck receive BUG */
2163 if(isb_subtype & TX_PENDING_PRIORITY_2)
2164 {
2165 if((err = smctr_tx_complete(dev,
2166 BUG_QUEUE)) != SUCCESS)
2167 break;
2168 }
2169
2170 /* NON-MAC frames only */
2171 if(isb_subtype & TX_PENDING_PRIORITY_1)
2172 {
2173 if((err = smctr_tx_complete(dev,
2174 NON_MAC_QUEUE)) != SUCCESS)
2175 break;
2176 }
2177
2178 /* MAC frames only */
2179 if(isb_subtype & TX_PENDING_PRIORITY_0)
2180 err = smctr_tx_complete(dev, MAC_QUEUE); break;
2181
2182 /* Type 0x06 - TX END OF QUEUE (FE) */
2183 case ISB_IMC_END_OF_TX_QUEUE:
2184 /* BUG queue */
2185 if(isb_subtype & TX_PENDING_PRIORITY_2)
2186 {
2187 /* ok to clear Receive FIFO overrun
2188 * imask send_BUG now completes.
2189 */
2190 interrupt_unmask_bits |= 0x800;
2191
2192 tp->tx_queue_status[BUG_QUEUE]
2193 = NOT_TRANSMITING;
2194 if((err = smctr_tx_complete(dev,
2195 BUG_QUEUE)) != SUCCESS)
2196 break;
2197 if((err = smctr_restart_tx_chain(dev,
2198 BUG_QUEUE)) != SUCCESS)
2199 break;
2200 }
2201
2202 /* NON-MAC queue only */
2203 if(isb_subtype & TX_PENDING_PRIORITY_1)
2204 {
2205 tp->tx_queue_status[NON_MAC_QUEUE]
2206 = NOT_TRANSMITING;
2207 if((err = smctr_tx_complete(dev,
2208 NON_MAC_QUEUE)) != SUCCESS)
2209 break;
2210 if((err = smctr_restart_tx_chain(dev,
2211 NON_MAC_QUEUE)) != SUCCESS)
2212 break;
2213 }
2214
2215 /* MAC queue only */
2216 if(isb_subtype & TX_PENDING_PRIORITY_0)
2217 {
2218 tp->tx_queue_status[MAC_QUEUE]
2219 = NOT_TRANSMITING;
2220 if((err = smctr_tx_complete(dev,
2221 MAC_QUEUE)) != SUCCESS)
2222 break;
2223
2224 err = smctr_restart_tx_chain(dev,
2225 MAC_QUEUE);
2226 }
2227 break;
2228
2229 /* Type 0x07 - NON-MAC RX Resource Interrupt
2230 * Subtype bit 12 - (BW) BDB warning
2231 * Subtype bit 13 - (FW) FCB warning
2232 * Subtype bit 14 - (BE) BDB End of chain
2233 * Subtype bit 15 - (FE) FCB End of chain
2234 */
2235 case ISB_IMC_NON_MAC_RX_RESOURCE:
2236 tp->rx_fifo_overrun_count = 0;
2237 tp->receive_queue_number = NON_MAC_QUEUE;
2238 err1 = smctr_rx_frame(dev);
2239
2240 if(isb_subtype & NON_MAC_RX_RESOURCE_FE)
2241 {
2242 if((err = smctr_issue_resume_rx_fcb_cmd( dev, NON_MAC_QUEUE)) != SUCCESS) break;
2243
2244 if(tp->ptr_rx_fcb_overruns)
2245 (*tp->ptr_rx_fcb_overruns)++;
2246 }
2247
2248 if(isb_subtype & NON_MAC_RX_RESOURCE_BE)
2249 {
2250 if((err = smctr_issue_resume_rx_bdb_cmd( dev, NON_MAC_QUEUE)) != SUCCESS) break;
2251
2252 if(tp->ptr_rx_bdb_overruns)
2253 (*tp->ptr_rx_bdb_overruns)++;
2254 }
2255 err = err1;
2256 break;
2257
2258 /* Type 0x08 - MAC RX Resource Interrupt
2259 * Subtype bit 12 - (BW) BDB warning
2260 * Subtype bit 13 - (FW) FCB warning
2261 * Subtype bit 14 - (BE) BDB End of chain
2262 * Subtype bit 15 - (FE) FCB End of chain
2263 */
2264 case ISB_IMC_MAC_RX_RESOURCE:
2265 tp->receive_queue_number = MAC_QUEUE;
2266 err1 = smctr_rx_frame(dev);
2267
2268 if(isb_subtype & MAC_RX_RESOURCE_FE)
2269 {
2270 if((err = smctr_issue_resume_rx_fcb_cmd( dev, MAC_QUEUE)) != SUCCESS)
2271 break;
2272
2273 if(tp->ptr_rx_fcb_overruns)
2274 (*tp->ptr_rx_fcb_overruns)++;
2275 }
2276
2277 if(isb_subtype & MAC_RX_RESOURCE_BE)
2278 {
2279 if((err = smctr_issue_resume_rx_bdb_cmd( dev, MAC_QUEUE)) != SUCCESS)
2280 break;
2281
2282 if(tp->ptr_rx_bdb_overruns)
2283 (*tp->ptr_rx_bdb_overruns)++;
2284 }
2285 err = err1;
2286 break;
2287
2288 /* Type 0x09 - NON_MAC RX Frame Interrupt */
2289 case ISB_IMC_NON_MAC_RX_FRAME:
2290 tp->rx_fifo_overrun_count = 0;
2291 tp->receive_queue_number = NON_MAC_QUEUE;
2292 err = smctr_rx_frame(dev);
2293 break;
2294
2295 /* Type 0x0A - MAC RX Frame Interrupt */
2296 case ISB_IMC_MAC_RX_FRAME:
2297 tp->receive_queue_number = MAC_QUEUE;
2298 err = smctr_rx_frame(dev);
2299 break;
2300
2301 /* Type 0x0B - TRC status
2302 * TRC has encountered an error condition
2303 * subtype bit 14 - transmit FIFO underrun
2304 * subtype bit 15 - receive FIFO overrun
2305 */
2306 case ISB_IMC_TRC_FIFO_STATUS:
2307 if(isb_subtype & TRC_FIFO_STATUS_TX_UNDERRUN)
2308 {
2309 if(tp->ptr_tx_fifo_underruns)
2310 (*tp->ptr_tx_fifo_underruns)++;
2311 }
2312
2313 if(isb_subtype & TRC_FIFO_STATUS_RX_OVERRUN)
2314 {
2315 /* update overrun stuck receive counter
2316 * if >= 3, has to clear it by sending
2317 * back to back frames. We pick
2318 * DAT(duplicate address MAC frame)
2319 */
2320 tp->rx_fifo_overrun_count++;
2321
2322 if(tp->rx_fifo_overrun_count >= 3)
2323 {
2324 tp->rx_fifo_overrun_count = 0;
2325
2326 /* delay clearing fifo overrun
2327 * imask till send_BUG tx
2328 * complete posted
2329 */
2330 interrupt_unmask_bits &= (~0x800);
2331 printk("Jay please send bug\n");// smctr_send_bug(dev);
2332 }
2333
2334 if(tp->ptr_rx_fifo_overruns)
2335 (*tp->ptr_rx_fifo_overruns)++;
2336 }
2337
2338 err = SUCCESS;
2339 break;
2340
2341 /* Type 0x0C - Action Command Status Interrupt
2342 * Subtype bit 14 - CB end of command chain (CE)
2343 * Subtype bit 15 - CB command interrupt (CI)
2344 */
2345 case ISB_IMC_COMMAND_STATUS:
2346 err = SUCCESS;
2347 if(tp->acb_head->cmd == ACB_CMD_HIC_NOP)
2348 {
2349 printk("i1\n");
2350 smctr_disable_16bit(dev);
2351
2352 /* XXXXXXXXXXXXXXXXX */
2353 /* err = UM_Interrupt(dev); */
2354
2355 smctr_enable_16bit(dev);
2356 }
2357 else
2358 {
2359 if((tp->acb_head->cmd
2360 == ACB_CMD_READ_TRC_STATUS)
2361 && (tp->acb_head->subcmd
2362 == RW_TRC_STATUS_BLOCK))
2363 {
2364 if(tp->ptr_bcn_type != 0)
2365 {
2366 *(tp->ptr_bcn_type)
2367 = (__u32)((SBlock *)tp->misc_command_data)->BCN_Type;
2368 }
2369
2370 if(((SBlock *)tp->misc_command_data)->Status_CHG_Indicate & ERROR_COUNTERS_CHANGED)
2371 {
2372 smctr_update_err_stats(dev);
2373 }
2374
2375 if(((SBlock *)tp->misc_command_data)->Status_CHG_Indicate & TI_NDIS_RING_STATUS_CHANGED)
2376 {
2377 tp->ring_status
2378 = ((SBlock*)tp->misc_command_data)->TI_NDIS_Ring_Status;
2379 smctr_disable_16bit(dev);
2380 err = smctr_ring_status_chg(dev);
2381 smctr_enable_16bit(dev);
2382 if((tp->ring_status & REMOVE_RECEIVED)
2383 && (tp->config_word0 & NO_AUTOREMOVE))
2384 {
2385 smctr_issue_remove_cmd(dev);
2386 }
2387
2388 if(err != SUCCESS)
2389 {
2390 tp->acb_pending
2391 = 0;
2392 break;
2393 }
2394 }
2395
2396 if(((SBlock *)tp->misc_command_data)->Status_CHG_Indicate & UNA_CHANGED)
2397 {
2398 if(tp->ptr_una)
2399 {
2400 tp->ptr_una[0]
2401 = SWAP_BYTES(((SBlock *)tp->misc_command_data)->UNA[0]);
2402 tp->ptr_una[1]
2403 = SWAP_BYTES(((SBlock *)tp->misc_command_data)->UNA[1]);
2404 tp->ptr_una[2]
2405 = SWAP_BYTES(((SBlock *)tp->misc_command_data)->UNA[2]);
2406 }
2407
2408 }
2409
2410 if(((SBlock *)tp->misc_command_data)->Status_CHG_Indicate
2411 & READY_TO_SEND_RQ_INIT) {
2412 err = smctr_send_rq_init(dev);
2413 }
2414 }
2415 }
2416
2417 tp->acb_pending = 0;
2418 break;
2419
2420 /* Type 0x0D - MAC Type 1 interrupt
2421 * Subtype -- 00 FR_BCN received at S12
2422 * 01 FR_BCN received at S21
2423 * 02 FR_DAT(DA=MA, A<>0) received at S21
2424 * 03 TSM_EXP at S21
2425 * 04 FR_REMOVE received at S42
2426 * 05 TBR_EXP, BR_FLAG_SET at S42
2427 * 06 TBT_EXP at S53
2428 */
2429 case ISB_IMC_MAC_TYPE_1:
2430 if(isb_subtype > 8)
2431 {
2432 err = HARDWARE_FAILED;
2433 break;
2434 }
2435
2436 err = SUCCESS;
2437 switch(isb_subtype)
2438 {
2439 case 0:
2440 tp->join_state = JS_BYPASS_STATE;
2441 if(tp->status != CLOSED)
2442 {
2443 tp->status = CLOSED;
2444 err = smctr_status_chg(dev);
2445 }
2446 break;
2447
2448 case 1:
2449 tp->join_state
2450 = JS_LOBE_TEST_STATE;
2451 break;
2452
2453 case 2:
2454 tp->join_state
2455 = JS_DETECT_MONITOR_PRESENT_STATE;
2456 break;
2457
2458 case 3:
2459 tp->join_state
2460 = JS_AWAIT_NEW_MONITOR_STATE;
2461 break;
2462
2463 case 4:
2464 tp->join_state
2465 = JS_DUPLICATE_ADDRESS_TEST_STATE;
2466 break;
2467
2468 case 5:
2469 tp->join_state
2470 = JS_NEIGHBOR_NOTIFICATION_STATE;
2471 break;
2472
2473 case 6:
2474 tp->join_state
2475 = JS_REQUEST_INITIALIZATION_STATE;
2476 break;
2477
2478 case 7:
2479 tp->join_state
2480 = JS_JOIN_COMPLETE_STATE;
2481 tp->status = OPEN;
2482 err = smctr_status_chg(dev);
2483 break;
2484
2485 case 8:
2486 tp->join_state
2487 = JS_BYPASS_WAIT_STATE;
2488 break;
2489 }
2490 break ;
2491
2492 /* Type 0x0E - TRC Initialization Sequence Interrupt
2493 * Subtype -- 00-FF Initializatin sequence complete
2494 */
2495 case ISB_IMC_TRC_INTRNL_TST_STATUS:
2496 tp->status = INITIALIZED;
2497 smctr_disable_16bit(dev);
2498 err = smctr_status_chg(dev);
2499 smctr_enable_16bit(dev);
2500 break;
2501
2502 /* other interrupt types, illegal */
2503 default:
2504 break;
2505 }
2506
2507 if(err != SUCCESS)
2508 break;
2509 }
2510
2511 /* Checking the ack code instead of the unmask bits here is because :
2512 * while fixing the stuck receive, DAT frame are sent and mask off
2513 * FIFO overrun interrupt temporarily (interrupt_unmask_bits = 0)
2514 * but we still want to issue ack to ISB
2515 */
2516 if(!(interrupt_ack_code & 0xff00))
2517 smctr_issue_int_ack(dev, interrupt_ack_code,
2518 interrupt_unmask_bits);
2519
2520 smctr_disable_16bit(dev);
2521 smctr_enable_bic_int(dev);
2522
2523 return;
2524 }
2525
2526 static int smctr_issue_enable_int_cmd(struct net_device *dev,
2527 __u16 interrupt_enable_mask)
2528 {
2529 struct net_local *tp = (struct net_local *)dev->priv;
2530 int err;
2531
2532 if((err = smctr_wait_while_cbusy(dev)))
2533 return (err);
2534
2535 tp->sclb_ptr->int_mask_control = interrupt_enable_mask;
2536 tp->sclb_ptr->valid_command = SCLB_VALID
2537 | SCLB_CMD_CLEAR_INTERRUPT_MASK;
2538
2539 smctr_set_ctrl_attention(dev);
2540
2541 return (0);
2542 }
2543
2544 static int smctr_issue_int_ack(struct net_device *dev, __u16 iack_code,
2545 __u16 ibits)
2546 {
2547 struct net_local *tp = (struct net_local *)dev->priv;
2548
2549 if(smctr_wait_while_cbusy(dev))
2550 return (-1);
2551
2552 tp->sclb_ptr->int_mask_control = ibits;
2553 tp->sclb_ptr->iack_code = iack_code << 1; /* use the offset from base */ tp->sclb_ptr->resume_control = 0;
2554 tp->sclb_ptr->valid_command =
2555 SCLB_VALID | SCLB_IACK_CODE_VALID
2556 | SCLB_CMD_CLEAR_INTERRUPT_MASK;
2557
2558 smctr_set_ctrl_attention(dev);
2559
2560 return (0);
2561 }
2562
2563 static int smctr_issue_init_timers_cmd(struct net_device *dev)
2564 {
2565 struct net_local *tp = (struct net_local *)dev->priv;
2566 unsigned int i;
2567 int err;
2568 __u16 *pTimer_Struc = (__u16 *)tp->misc_command_data;
2569
2570 if((err = smctr_wait_while_cbusy(dev)))
2571 return (err);
2572
2573 if((err = smctr_wait_cmd(dev)))
2574 return (err);
2575
2576 tp->config_word0 = THDREN | DMA_TRIGGER | USETPT | NO_AUTOREMOVE;
2577 tp->config_word1 = 0;
2578
2579 if((tp->media_type == MEDIA_STP_16)
2580 || (tp->media_type == MEDIA_UTP_16)
2581 || (tp->media_type == MEDIA_STP_16_UTP_16))
2582 {
2583 tp->config_word0 |= FREQ_16MB_BIT;
2584 }
2585
2586 if(tp->mode_bits & EARLY_TOKEN_REL)
2587 tp->config_word0 |= ETREN;
2588
2589 if(tp->mode_bits & LOOPING_MODE_MASK)
2590 tp->config_word0 |= RX_OWN_BIT;
2591 else
2592 tp->config_word0 &= ~RX_OWN_BIT;
2593
2594 if(tp->receive_mask & PROMISCUOUS_MODE)
2595 tp->config_word0 |= PROMISCUOUS_BIT;
2596 else
2597 tp->config_word0 &= ~PROMISCUOUS_BIT;
2598
2599 if(tp->receive_mask & ACCEPT_ERR_PACKETS)
2600 tp->config_word0 |= SAVBAD_BIT;
2601 else
2602 tp->config_word0 &= ~SAVBAD_BIT;
2603
2604 if(tp->receive_mask & ACCEPT_ATT_MAC_FRAMES)
2605 tp->config_word0 |= RXATMAC;
2606 else
2607 tp->config_word0 &= ~RXATMAC;
2608
2609 if(tp->receive_mask & ACCEPT_MULTI_PROM)
2610 tp->config_word1 |= MULTICAST_ADDRESS_BIT;
2611 else
2612 tp->config_word1 &= ~MULTICAST_ADDRESS_BIT;
2613
2614 if(tp->receive_mask & ACCEPT_SOURCE_ROUTING_SPANNING)
2615 tp->config_word1 |= SOURCE_ROUTING_SPANNING_BITS;
2616 else
2617 {
2618 if(tp->receive_mask & ACCEPT_SOURCE_ROUTING)
2619 tp->config_word1 |= SOURCE_ROUTING_EXPLORER_BIT;
2620 else
2621 tp->config_word1 &= ~SOURCE_ROUTING_SPANNING_BITS;
2622 }
2623
2624 if((tp->media_type == MEDIA_STP_16)
2625 || (tp->media_type == MEDIA_UTP_16)
2626 || (tp->media_type == MEDIA_STP_16_UTP_16))
2627 {
2628 tp->config_word1 |= INTERFRAME_SPACING_16;
2629 }
2630 else
2631 tp->config_word1 |= INTERFRAME_SPACING_4;
2632
2633 *pTimer_Struc++ = tp->config_word0;
2634 *pTimer_Struc++ = tp->config_word1;
2635
2636 if((tp->media_type == MEDIA_STP_4)
2637 || (tp->media_type == MEDIA_UTP_4)
2638 || (tp->media_type == MEDIA_STP_4_UTP_4))
2639 {
2640 *pTimer_Struc++ = 0x00FA; /* prescale */
2641 *pTimer_Struc++ = 0x2710; /* TPT_limit */
2642 *pTimer_Struc++ = 0x2710; /* TQP_limit */
2643 *pTimer_Struc++ = 0x0A28; /* TNT_limit */
2644 *pTimer_Struc++ = 0x3E80; /* TBT_limit */
2645 *pTimer_Struc++ = 0x3A98; /* TSM_limit */
2646 *pTimer_Struc++ = 0x1B58; /* TAM_limit */
2647 *pTimer_Struc++ = 0x00C8; /* TBR_limit */
2648 *pTimer_Struc++ = 0x07D0; /* TER_limit */
2649 *pTimer_Struc++ = 0x000A; /* TGT_limit */
2650 *pTimer_Struc++ = 0x1162; /* THT_limit */
2651 *pTimer_Struc++ = 0x07D0; /* TRR_limit */
2652 *pTimer_Struc++ = 0x1388; /* TVX_limit */
2653 *pTimer_Struc++ = 0x0000; /* reserved */
2654 }
2655 else
2656 {
2657 *pTimer_Struc++ = 0x03E8; /* prescale */
2658 *pTimer_Struc++ = 0x9C40; /* TPT_limit */
2659 *pTimer_Struc++ = 0x9C40; /* TQP_limit */
2660 *pTimer_Struc++ = 0x0A28; /* TNT_limit */
2661 *pTimer_Struc++ = 0x3E80; /* TBT_limit */
2662 *pTimer_Struc++ = 0x3A98; /* TSM_limit */
2663 *pTimer_Struc++ = 0x1B58; /* TAM_limit */
2664 *pTimer_Struc++ = 0x00C8; /* TBR_limit */
2665 *pTimer_Struc++ = 0x07D0; /* TER_limit */
2666 *pTimer_Struc++ = 0x000A; /* TGT_limit */
2667 *pTimer_Struc++ = 0x4588; /* THT_limit */
2668 *pTimer_Struc++ = 0x1F40; /* TRR_limit */
2669 *pTimer_Struc++ = 0x4E20; /* TVX_limit */
2670 *pTimer_Struc++ = 0x0000; /* reserved */
2671 }
2672
2673 /* Set node address. */
2674 *pTimer_Struc++ = dev->dev_addr[0] << 8
2675 | (dev->dev_addr[1] & 0xFF);
2676 *pTimer_Struc++ = dev->dev_addr[2] << 8
2677 | (dev->dev_addr[3] & 0xFF);
2678 *pTimer_Struc++ = dev->dev_addr[4] << 8
2679 | (dev->dev_addr[5] & 0xFF);
2680
2681 /* Set group address. */
2682 *pTimer_Struc++ = tp->group_address_0 << 8
2683 | tp->group_address_0 >> 8;
2684 *pTimer_Struc++ = tp->group_address[0] << 8
2685 | tp->group_address[0] >> 8;
2686 *pTimer_Struc++ = tp->group_address[1] << 8
2687 | tp->group_address[1] >> 8;
2688
2689 /* Set functional address. */
2690 *pTimer_Struc++ = tp->functional_address_0 << 8
2691 | tp->functional_address_0 >> 8;
2692 *pTimer_Struc++ = tp->functional_address[0] << 8
2693 | tp->functional_address[0] >> 8;
2694 *pTimer_Struc++ = tp->functional_address[1] << 8
2695 | tp->functional_address[1] >> 8;
2696
2697 /* Set Bit-Wise group address. */
2698 *pTimer_Struc++ = tp->bitwise_group_address[0] << 8
2699 | tp->bitwise_group_address[0] >> 8;
2700 *pTimer_Struc++ = tp->bitwise_group_address[1] << 8
2701 | tp->bitwise_group_address[1] >> 8;
2702
2703 /* Set ring number address. */
2704 *pTimer_Struc++ = tp->source_ring_number;
2705 *pTimer_Struc++ = tp->target_ring_number;
2706
2707 /* Physical drop number. */
2708 *pTimer_Struc++ = (unsigned short)0;
2709 *pTimer_Struc++ = (unsigned short)0;
2710
2711 /* Product instance ID. */
2712 for(i = 0; i < 9; i++)
2713 *pTimer_Struc++ = (unsigned short)0;
2714
2715 err = smctr_setup_single_cmd_w_data(dev, ACB_CMD_INIT_TRC_TIMERS, 0);
2716
2717 return (err);
2718 }
2719
2720 static int smctr_issue_init_txrx_cmd(struct net_device *dev)
2721 {
2722 struct net_local *tp = (struct net_local *)dev->priv;
2723 unsigned int i;
2724 int err;
2725 void **txrx_ptrs = (void *)tp->misc_command_data;
2726
2727 if((err = smctr_wait_while_cbusy(dev)))
2728 return (err);
2729
2730 if((err = smctr_wait_cmd(dev)))
2731 {
2732 printk("%s: Hardware failure\n", dev->name);
2733 return (err);
2734 }
2735
2736 /* Initialize Transmit Queue Pointers that are used, to point to
2737 * a single FCB.
2738 */
2739 for(i = 0; i < NUM_TX_QS_USED; i++)
2740 *txrx_ptrs++ = (void *)TRC_POINTER(tp->tx_fcb_head[i]);
2741
2742 /* Initialize Transmit Queue Pointers that are NOT used to ZERO. */
2743 for(; i < MAX_TX_QS; i++)
2744 *txrx_ptrs++ = (void *)0;
2745
2746 /* Initialize Receive Queue Pointers (MAC and Non-MAC) that are
2747 * used, to point to a single FCB and a BDB chain of buffers.
2748 */
2749 for(i = 0; i < NUM_RX_QS_USED; i++)
2750 {
2751 *txrx_ptrs++ = (void *)TRC_POINTER(tp->rx_fcb_head[i]);
2752 *txrx_ptrs++ = (void *)TRC_POINTER(tp->rx_bdb_head[i]);
2753 }
2754
2755 /* Initialize Receive Queue Pointers that are NOT used to ZERO. */
2756 for(; i < MAX_RX_QS; i++)
2757 {
2758 *txrx_ptrs++ = (void *)0;
2759 *txrx_ptrs++ = (void *)0;
2760 }
2761
2762 err = smctr_setup_single_cmd_w_data(dev, ACB_CMD_INIT_TX_RX, 0);
2763
2764 return (err);
2765 }
2766
2767 static int smctr_issue_insert_cmd(struct net_device *dev)
2768 {
2769 int err;
2770
2771 err = smctr_setup_single_cmd(dev, ACB_CMD_INSERT, ACB_SUB_CMD_NOP);
2772
2773 return (err);
2774 }
2775
2776 static int smctr_issue_read_ring_status_cmd(struct net_device *dev)
2777 {
2778 int err;
2779
2780 if((err = smctr_wait_while_cbusy(dev)))
2781 return (err);
2782
2783 if((err = smctr_wait_cmd(dev)))
2784 return (err);
2785
2786 err = smctr_setup_single_cmd_w_data(dev, ACB_CMD_READ_TRC_STATUS,
2787 RW_TRC_STATUS_BLOCK);
2788
2789 return (err);
2790 }
2791
2792 static int smctr_issue_read_word_cmd(struct net_device *dev, __u16 aword_cnt)
2793 {
2794 int err;
2795
2796 if((err = smctr_wait_while_cbusy(dev)))
2797 return (err);
2798
2799 if((err = smctr_wait_cmd(dev)))
2800 return (err);
2801
2802 err = smctr_setup_single_cmd_w_data(dev, ACB_CMD_MCT_READ_VALUE,
2803 aword_cnt);
2804
2805 return (err);
2806 }
2807
2808 static int smctr_issue_remove_cmd(struct net_device *dev)
2809 {
2810 struct net_local *tp = (struct net_local *)dev->priv;
2811 int err;
2812
2813 if((err = smctr_wait_while_cbusy(dev)))
2814 return (err);
2815
2816 tp->sclb_ptr->resume_control = 0;
2817 tp->sclb_ptr->valid_command = SCLB_VALID | SCLB_CMD_REMOVE;
2818
2819 smctr_set_ctrl_attention(dev);
2820
2821 return (0);
2822 }
2823
2824 static int smctr_issue_resume_acb_cmd(struct net_device *dev)
2825 {
2826 struct net_local *tp = (struct net_local *)dev->priv;
2827 int err;
2828
2829 if((err = smctr_wait_while_cbusy(dev)))
2830 return (err);
2831
2832 tp->sclb_ptr->resume_control = SCLB_RC_ACB;
2833 tp->sclb_ptr->valid_command = SCLB_VALID | SCLB_RESUME_CONTROL_VALID;
2834
2835 tp->acb_pending = 1;
2836
2837 smctr_set_ctrl_attention(dev);
2838
2839 return (0);
2840 }
2841
2842 static int smctr_issue_resume_rx_bdb_cmd(struct net_device *dev, __u16 queue)
2843 {
2844 struct net_local *tp = (struct net_local *)dev->priv;
2845 int err;
2846
2847 if((err = smctr_wait_while_cbusy(dev)))
2848 return (err);
2849
2850 if(queue == MAC_QUEUE)
2851 tp->sclb_ptr->resume_control = SCLB_RC_RX_MAC_BDB;
2852 else
2853 tp->sclb_ptr->resume_control = SCLB_RC_RX_NON_MAC_BDB;
2854
2855 tp->sclb_ptr->valid_command = SCLB_VALID | SCLB_RESUME_CONTROL_VALID;
2856
2857 smctr_set_ctrl_attention(dev);
2858
2859 return (0);
2860 }
2861
2862 static int smctr_issue_resume_rx_fcb_cmd(struct net_device *dev, __u16 queue)
2863 {
2864 struct net_local *tp = (struct net_local *)dev->priv;
2865
2866 if(smctr_debug > 10)
2867 printk("%s: smctr_issue_resume_rx_fcb_cmd\n", dev->name);
2868
2869 if(smctr_wait_while_cbusy(dev))
2870 return (-1);
2871
2872 if(queue == MAC_QUEUE)
2873 tp->sclb_ptr->resume_control = SCLB_RC_RX_MAC_FCB;
2874 else
2875 tp->sclb_ptr->resume_control = SCLB_RC_RX_NON_MAC_FCB;
2876
2877 tp->sclb_ptr->valid_command = SCLB_VALID | SCLB_RESUME_CONTROL_VALID;
2878
2879 smctr_set_ctrl_attention(dev);
2880
2881 return (0);
2882 }
2883
2884 static int smctr_issue_resume_tx_fcb_cmd(struct net_device *dev, __u16 queue)
2885 {
2886 struct net_local *tp = (struct net_local *)dev->priv;
2887
2888 if(smctr_debug > 10)
2889 printk("%s: smctr_issue_resume_tx_fcb_cmd\n", dev->name);
2890
2891 if(smctr_wait_while_cbusy(dev))
2892 return (-1);
2893
2894 tp->sclb_ptr->resume_control = (SCLB_RC_TFCB0 << queue);
2895 tp->sclb_ptr->valid_command = SCLB_RESUME_CONTROL_VALID | SCLB_VALID;
2896
2897 smctr_set_ctrl_attention(dev);
2898
2899 return (0);
2900 }
2901
2902 static int smctr_issue_test_internal_rom_cmd(struct net_device *dev)
2903 {
2904 int err;
2905
2906 err = smctr_setup_single_cmd(dev, ACB_CMD_MCT_TEST,
2907 TRC_INTERNAL_ROM_TEST);
2908
2909 return (err);
2910 }
2911
2912 static int smctr_issue_test_hic_cmd(struct net_device *dev)
2913 {
2914 int err;
2915
2916 err = smctr_setup_single_cmd(dev, ACB_CMD_HIC_TEST,
2917 TRC_HOST_INTERFACE_REG_TEST);
2918
2919 return (err);
2920 }
2921
2922 static int smctr_issue_test_mac_reg_cmd(struct net_device *dev)
2923 {
2924 int err;
2925
2926 err = smctr_setup_single_cmd(dev, ACB_CMD_MCT_TEST,
2927 TRC_MAC_REGISTERS_TEST);
2928
2929 return (err);
2930 }
2931
2932 static int smctr_issue_trc_loopback_cmd(struct net_device *dev)
2933 {
2934 int err;
2935
2936 err = smctr_setup_single_cmd(dev, ACB_CMD_MCT_TEST,
2937 TRC_INTERNAL_LOOPBACK);
2938
2939 return (err);
2940 }
2941
2942 static int smctr_issue_tri_loopback_cmd(struct net_device *dev)
2943 {
2944 int err;
2945
2946 err = smctr_setup_single_cmd(dev, ACB_CMD_MCT_TEST,
2947 TRC_TRI_LOOPBACK);
2948
2949 return (err);
2950 }
2951
2952 static int smctr_issue_write_byte_cmd(struct net_device *dev,
2953 short aword_cnt, void *byte)
2954 {
2955 struct net_local *tp = (struct net_local *)dev->priv;
2956 unsigned int iword, ibyte;
2957 int err;
2958
2959 if((err = smctr_wait_while_cbusy(dev)))
2960 return (err);
2961
2962 if((err = smctr_wait_cmd(dev)))
2963 return (err);
2964
2965 for(iword = 0, ibyte = 0; iword < (unsigned int)(aword_cnt & 0xff);
2966 iword++, ibyte += 2)
2967 {
2968 tp->misc_command_data[iword] = (*((__u8 *)byte + ibyte) << 8)
2969 | (*((__u8 *)byte + ibyte + 1));
2970 }
2971
2972 return (smctr_setup_single_cmd_w_data(dev, ACB_CMD_MCT_WRITE_VALUE,
2973 aword_cnt));
2974 }
2975
2976 static int smctr_issue_write_word_cmd(struct net_device *dev,
2977 short aword_cnt, void *word)
2978 {
2979 struct net_local *tp = (struct net_local *)dev->priv;
2980 unsigned int i, err;
2981
2982 if((err = smctr_wait_while_cbusy(dev)))
2983 return (err);
2984
2985 if((err = smctr_wait_cmd(dev)))
2986 return (err);
2987
2988 for(i = 0; i < (unsigned int)(aword_cnt & 0xff); i++)
2989 tp->misc_command_data[i] = *((__u16 *)word + i);
2990
2991 err = smctr_setup_single_cmd_w_data(dev, ACB_CMD_MCT_WRITE_VALUE,
2992 aword_cnt);
2993
2994 return (err);
2995 }
2996
2997 static int smctr_join_complete_state(struct net_device *dev)
2998 {
2999 int err;
3000
3001 err = smctr_setup_single_cmd(dev, ACB_CMD_CHANGE_JOIN_STATE,
3002 JS_JOIN_COMPLETE_STATE);
3003
3004 return (err);
3005 }
3006
3007 static int smctr_link_tx_fcbs_to_bdbs(struct net_device *dev)
3008 {
3009 struct net_local *tp = (struct net_local *)dev->priv;
3010 unsigned int i, j;
3011 FCBlock *fcb;
3012 BDBlock *bdb;
3013
3014 for(i = 0; i < NUM_TX_QS_USED; i++)
3015 {
3016 fcb = tp->tx_fcb_head[i];
3017 bdb = tp->tx_bdb_head[i];
3018
3019 for(j = 0; j < tp->num_tx_fcbs[i]; j++)
3020 {
3021 fcb->bdb_ptr = bdb;
3022 fcb->trc_bdb_ptr = TRC_POINTER(bdb);
3023 fcb = (FCBlock *)((char *)fcb + sizeof(FCBlock));
3024 bdb = (BDBlock *)((char *)bdb + sizeof(BDBlock));
3025 }
3026 }
3027
3028 return (0);
3029 }
3030
3031 static int smctr_load_firmware(struct net_device *dev)
3032 {
3033 struct net_local *tp = (struct net_local *)dev->priv;
3034 __u16 i, checksum = 0;
3035 int err = 0;
3036
3037 if(smctr_debug > 10)
3038 printk("%s: smctr_load_firmware\n", dev->name);
3039
3040 tp->ptr_ucode = smctr_code;
3041 tp->num_of_tx_buffs = 4;
3042 tp->mode_bits |= UMAC;
3043 tp->receive_mask = 0;
3044 tp->max_packet_size = 4177;
3045
3046 /* Can only upload the firmware once per adapter reset. */
3047 if(tp->microcode_version != 0)
3048 return (UCODE_PRESENT);
3049
3050 /* Verify the firmware exists and is there in the right amount. */
3051 if((tp->ptr_ucode == 0L)
3052 || (*(tp->ptr_ucode + UCODE_VERSION_OFFSET) < UCODE_VERSION))
3053 {
3054 return (UCODE_NOT_PRESENT);
3055 }
3056
3057 /* UCODE_SIZE is not included in Checksum. */
3058 for(i = 0; i < *((__u16 *)(tp->ptr_ucode + UCODE_SIZE_OFFSET)); i += 2)
3059 checksum += *((__u16 *)(tp->ptr_ucode + 2 + i));
3060 if(checksum)
3061 return (UCODE_NOT_PRESENT);
3062
3063 /* At this point we have a valid firmware image, lets kick it on up. */
3064 smctr_enable_adapter_ram(dev);
3065 smctr_enable_16bit(dev);
3066 smctr_set_page(dev, (__u8 *)tp->ram_access);
3067
3068 if((smctr_checksum_firmware(dev))
3069 || (*(tp->ptr_ucode + UCODE_VERSION_OFFSET)
3070 > tp->microcode_version))
3071 {
3072 smctr_enable_adapter_ctrl_store(dev);
3073
3074 /* Zero out ram space for firmware. */
3075 for(i = 0; i < CS_RAM_SIZE; i += 2)
3076 *((__u16 *)(tp->ram_access + i)) = 0;
3077
3078 smctr_decode_firmware(dev);
3079
3080 tp->microcode_version = *(tp->ptr_ucode + UCODE_VERSION_OFFSET); *((__u16 *)(tp->ram_access + CS_RAM_VERSION_OFFSET))
3081 = (tp->microcode_version << 8);
3082 *((__u16 *)(tp->ram_access + CS_RAM_CHECKSUM_OFFSET))
3083 = ~(tp->microcode_version << 8) + 1;
3084
3085 smctr_disable_adapter_ctrl_store(dev);
3086
3087 if(smctr_checksum_firmware(dev))
3088 err = HARDWARE_FAILED;
3089 }
3090 else
3091 err = UCODE_PRESENT;
3092
3093 smctr_disable_16bit(dev);
3094
3095 return (err);
3096 }
3097
3098 static int smctr_load_node_addr(struct net_device *dev)
3099 {
3100 int ioaddr = dev->base_addr;
3101 unsigned int i;
3102 __u8 r;
3103
3104 /* Check if node address has been specified by user. (non-0) */
3105 for(i = 0; ((i < 6) && (dev->dev_addr[i] == 0)); i++);
3106 {
3107 if(i != 6)
3108 {
3109 for(i = 0; i < 6; i++)
3110 {
3111 r = inb(ioaddr + LAR0 + i);
3112 dev->dev_addr[i] = (char)r;
3113 }
3114 dev->addr_len = 6;
3115 }
3116 else /* Node addr. not given by user, read it from board. */
3117 {
3118 for(i = 0; i < 6; i++)
3119 {
3120 r = inb(ioaddr + LAR0 + i);
3121 dev->dev_addr[i] = (char)r;
3122 }
3123 dev->addr_len = 6;
3124 }
3125 }
3126
3127 return (0);
3128 }
3129
3130 /* Lobe Media Test.
3131 * During the transmission of the initial 1500 lobe media MAC frames,
3132 * the phase lock loop in the 805 chip may lock, and then un-lock, causing
3133 * the 825 to go into a PURGE state. When performing a PURGE, the MCT
3134 * microcode will not transmit any frames given to it by the host, and
3135 * will consequently cause a timeout.
3136 *
3137 * NOTE 1: If the monitor_state is MS_BEACON_TEST_STATE, all transmit
3138 * queues other then the one used for the lobe_media_test should be
3139 * disabled.!?
3140 *
3141 * NOTE 2: If the monitor_state is MS_BEACON_TEST_STATE and the receive_mask
3142 * has any multi-cast or promiscous bits set, the receive_mask needs to
3143 * be changed to clear the multi-cast or promiscous mode bits, the lobe_test
3144 * run, and then the receive mask set back to its original value if the test
3145 * is successful.
3146 */
3147 static int smctr_lobe_media_test(struct net_device *dev)
3148 {
3149 struct net_local *tp = (struct net_local *)dev->priv;
3150 unsigned int i, perror = 0;
3151 unsigned short saved_rcv_mask;
3152
3153 if(smctr_debug > 10)
3154 printk("%s: smctr_lobe_media_test\n", dev->name);
3155
3156 /* Clear receive mask for lobe test. */
3157 saved_rcv_mask = tp->receive_mask;
3158 tp->receive_mask = 0;
3159
3160 smctr_chg_rx_mask(dev);
3161
3162 /* Setup the lobe media test. */
3163 smctr_lobe_media_test_cmd(dev);
3164 if(smctr_wait_cmd(dev))
3165 {
3166 smctr_reset_adapter(dev);
3167 tp->status = CLOSED;
3168 return (LOBE_MEDIA_TEST_FAILED);
3169 }
3170
3171 /* Tx lobe media test frames. */
3172 for(i = 0; i < 1500; ++i)
3173 {
3174 if(smctr_send_lobe_media_test(dev))
3175 {
3176 if(perror)
3177 {
3178 smctr_reset_adapter(dev);
3179 tp->state = CLOSED;
3180 return (LOBE_MEDIA_TEST_FAILED);
3181 }
3182 else
3183 {
3184 perror = 1;
3185 if(smctr_lobe_media_test_cmd(dev))
3186 {
3187 smctr_reset_adapter(dev);
3188 tp->state = CLOSED;
3189 return (LOBE_MEDIA_TEST_FAILED);
3190 }
3191 }
3192 }
3193 }
3194
3195 if(smctr_send_dat(dev))
3196 {
3197 if(smctr_send_dat(dev))
3198 {
3199 smctr_reset_adapter(dev);
3200 tp->state = CLOSED;
3201 return (LOBE_MEDIA_TEST_FAILED);
3202 }
3203 }
3204
3205 /* Check if any frames received during test. */
3206 if((tp->rx_fcb_curr[MAC_QUEUE]->frame_status)
3207 || (tp->rx_fcb_curr[NON_MAC_QUEUE]->frame_status))
3208 {
3209 smctr_reset_adapter(dev);
3210 tp->state = CLOSED;
3211 return (LOBE_MEDIA_TEST_FAILED);
3212 }
3213
3214 /* Set receive mask to "Promisc" mode. */
3215 tp->receive_mask = saved_rcv_mask;
3216
3217 smctr_chg_rx_mask(dev);
3218
3219 return (0);
3220 }
3221
3222 static int smctr_lobe_media_test_cmd(struct net_device *dev)
3223 {
3224 struct net_local *tp = (struct net_local *)dev->priv;
3225 int err;
3226
3227 if(smctr_debug > 10)
3228 printk("%s: smctr_lobe_media_test_cmd\n", dev->name);
3229
3230 /* Change to lobe media test state. */
3231 if(tp->monitor_state != MS_BEACON_TEST_STATE)
3232 {
3233 smctr_lobe_media_test_state(dev);
3234 if(smctr_wait_cmd(dev))
3235 {
3236 printk("Lobe Failed test state\n");
3237 return (LOBE_MEDIA_TEST_FAILED);
3238 }
3239 }
3240
3241 err = smctr_setup_single_cmd(dev, ACB_CMD_MCT_TEST,
3242 TRC_LOBE_MEDIA_TEST);
3243
3244 return (err);
3245 }
3246
3247 static int smctr_lobe_media_test_state(struct net_device *dev)
3248 {
3249 int err;
3250
3251 err = smctr_setup_single_cmd(dev, ACB_CMD_CHANGE_JOIN_STATE,
3252 JS_LOBE_TEST_STATE);
3253
3254 return (err);
3255 }
3256
3257 static int smctr_make_8025_hdr(struct net_device *dev,
3258 MAC_HEADER *rmf, MAC_HEADER *tmf, __u16 ac_fc)
3259 {
3260 tmf->ac = MSB(ac_fc); /* msb is access control */
3261 tmf->fc = LSB(ac_fc); /* lsb is frame control */
3262
3263 tmf->sa[0] = dev->dev_addr[0];
3264 tmf->sa[1] = dev->dev_addr[1];
3265 tmf->sa[2] = dev->dev_addr[2];
3266 tmf->sa[3] = dev->dev_addr[3];
3267 tmf->sa[4] = dev->dev_addr[4];
3268 tmf->sa[5] = dev->dev_addr[5];
3269
3270 switch(tmf->vc)
3271 {
3272 /* Send RQ_INIT to RPS */
3273 case RQ_INIT:
3274 tmf->da[0] = 0xc0;
3275 tmf->da[1] = 0x00;
3276 tmf->da[2] = 0x00;
3277 tmf->da[3] = 0x00;
3278 tmf->da[4] = 0x00;
3279 tmf->da[5] = 0x02;
3280 break;
3281
3282 /* Send RPT_TX_FORWARD to CRS */
3283 case RPT_TX_FORWARD:
3284 tmf->da[0] = 0xc0;
3285 tmf->da[1] = 0x00;
3286 tmf->da[2] = 0x00;
3287 tmf->da[3] = 0x00;
3288 tmf->da[4] = 0x00;
3289 tmf->da[5] = 0x10;
3290 break;
3291
3292 /* Everything else goes to sender */
3293 default:
3294 tmf->da[0] = rmf->sa[0];
3295 tmf->da[1] = rmf->sa[1];
3296 tmf->da[2] = rmf->sa[2];
3297 tmf->da[3] = rmf->sa[3];
3298 tmf->da[4] = rmf->sa[4];
3299 tmf->da[5] = rmf->sa[5];
3300 break;
3301 }
3302
3303 return (0);
3304 }
3305
3306 static int smctr_make_access_pri(struct net_device *dev, MAC_SUB_VECTOR *tsv)
3307 {
3308 struct net_local *tp = (struct net_local *)dev->priv;
3309
3310 tsv->svi = AUTHORIZED_ACCESS_PRIORITY;
3311 tsv->svl = S_AUTHORIZED_ACCESS_PRIORITY;
3312
3313 tsv->svv[0] = MSB(tp->authorized_access_priority);
3314 tsv->svv[1] = LSB(tp->authorized_access_priority);
3315
3316 return (0);
3317 }
3318
3319 static int smctr_make_addr_mod(struct net_device *dev, MAC_SUB_VECTOR *tsv)
3320 {
3321 tsv->svi = ADDRESS_MODIFER;
3322 tsv->svl = S_ADDRESS_MODIFER;
3323
3324 tsv->svv[0] = 0;
3325 tsv->svv[1] = 0;
3326
3327 return (0);
3328 }
3329
3330 static int smctr_make_auth_funct_class(struct net_device *dev,
3331 MAC_SUB_VECTOR *tsv)
3332 {
3333 struct net_local *tp = (struct net_local *)dev->priv;
3334
3335 tsv->svi = AUTHORIZED_FUNCTION_CLASS;
3336 tsv->svl = S_AUTHORIZED_FUNCTION_CLASS;
3337
3338 tsv->svv[0] = MSB(tp->authorized_function_classes);
3339 tsv->svv[1] = LSB(tp->authorized_function_classes);
3340
3341 return (0);
3342 }
3343
3344 static int smctr_make_corr(struct net_device *dev,
3345 MAC_SUB_VECTOR *tsv, __u16 correlator)
3346 {
3347 tsv->svi = CORRELATOR;
3348 tsv->svl = S_CORRELATOR;
3349
3350 tsv->svv[0] = MSB(correlator);
3351 tsv->svv[1] = LSB(correlator);
3352
3353 return (0);
3354 }
3355
3356 static int smctr_make_funct_addr(struct net_device *dev, MAC_SUB_VECTOR *tsv)
3357 {
3358 struct net_local *tp = (struct net_local *)dev->priv;
3359
3360 smctr_get_functional_address(dev);
3361
3362 tsv->svi = FUNCTIONAL_ADDRESS;
3363 tsv->svl = S_FUNCTIONAL_ADDRESS;
3364
3365 tsv->svv[0] = MSB(tp->misc_command_data[0]);
3366 tsv->svv[1] = LSB(tp->misc_command_data[0]);
3367
3368 tsv->svv[2] = MSB(tp->misc_command_data[1]);
3369 tsv->svv[3] = LSB(tp->misc_command_data[1]);
3370
3371 return (0);
3372 }
3373
3374 static int smctr_make_group_addr(struct net_device *dev, MAC_SUB_VECTOR *tsv)
3375 {
3376 struct net_local *tp = (struct net_local *)dev->priv;
3377
3378 smctr_get_group_address(dev);
3379
3380 tsv->svi = GROUP_ADDRESS;
3381 tsv->svl = S_GROUP_ADDRESS;
3382
3383 tsv->svv[0] = MSB(tp->misc_command_data[0]);
3384 tsv->svv[1] = LSB(tp->misc_command_data[0]);
3385
3386 tsv->svv[2] = MSB(tp->misc_command_data[1]);
3387 tsv->svv[3] = LSB(tp->misc_command_data[1]);
3388
3389 /* Set Group Address Sub-vector to all zeros if only the
3390 * Group Address/Functional Address Indicator is set.
3391 */
3392 if(tsv->svv[0] == 0x80 && tsv->svv[1] == 0x00
3393 && tsv->svv[2] == 0x00 && tsv->svv[3] == 0x00)
3394 tsv->svv[0] = 0x00;
3395
3396 return (0);
3397 }
3398
3399 static int smctr_make_phy_drop_num(struct net_device *dev,
3400 MAC_SUB_VECTOR *tsv)
3401 {
3402 struct net_local *tp = (struct net_local *)dev->priv;
3403
3404 smctr_get_physical_drop_number(dev);
3405
3406 tsv->svi = PHYSICAL_DROP;
3407 tsv->svl = S_PHYSICAL_DROP;
3408
3409 tsv->svv[0] = MSB(tp->misc_command_data[0]);
3410 tsv->svv[1] = LSB(tp->misc_command_data[0]);
3411
3412 tsv->svv[2] = MSB(tp->misc_command_data[1]);
3413 tsv->svv[3] = LSB(tp->misc_command_data[1]);
3414
3415 return (0);
3416 }
3417
3418 static int smctr_make_product_id(struct net_device *dev, MAC_SUB_VECTOR *tsv)
3419 {
3420 int i;
3421
3422 tsv->svi = PRODUCT_INSTANCE_ID;
3423 tsv->svl = S_PRODUCT_INSTANCE_ID;
3424
3425 for(i = 0; i < 18; i++)
3426 tsv->svv[i] = 0xF0;
3427
3428 return (0);
3429 }
3430
3431 static int smctr_make_station_id(struct net_device *dev, MAC_SUB_VECTOR *tsv)
3432 {
3433 struct net_local *tp = (struct net_local *)dev->priv;
3434
3435 smctr_get_station_id(dev);
3436
3437 tsv->svi = STATION_IDENTIFER;
3438 tsv->svl = S_STATION_IDENTIFER;
3439
3440 tsv->svv[0] = MSB(tp->misc_command_data[0]);
3441 tsv->svv[1] = LSB(tp->misc_command_data[0]);
3442
3443 tsv->svv[2] = MSB(tp->misc_command_data[1]);
3444 tsv->svv[3] = LSB(tp->misc_command_data[1]);
3445
3446 tsv->svv[4] = MSB(tp->misc_command_data[2]);
3447 tsv->svv[5] = LSB(tp->misc_command_data[2]);
3448
3449 return (0);
3450 }
3451
3452 static int smctr_make_ring_station_status(struct net_device *dev,
3453 MAC_SUB_VECTOR * tsv)
3454 {
3455 tsv->svi = RING_STATION_STATUS;
3456 tsv->svl = S_RING_STATION_STATUS;
3457
3458 tsv->svv[0] = 0;
3459 tsv->svv[1] = 0;
3460 tsv->svv[2] = 0;
3461 tsv->svv[3] = 0;
3462 tsv->svv[4] = 0;
3463 tsv->svv[5] = 0;
3464
3465 return (0);
3466 }
3467
3468 static int smctr_make_ring_station_version(struct net_device *dev,
3469 MAC_SUB_VECTOR *tsv)
3470 {
3471 struct net_local *tp = (struct net_local *)dev->priv;
3472
3473 tsv->svi = RING_STATION_VERSION_NUMBER;
3474 tsv->svl = S_RING_STATION_VERSION_NUMBER;
3475
3476 tsv->svv[0] = 0xe2; /* EBCDIC - S */
3477 tsv->svv[1] = 0xd4; /* EBCDIC - M */
3478 tsv->svv[2] = 0xc3; /* EBCDIC - C */
3479 tsv->svv[3] = 0x40; /* EBCDIC - */
3480 tsv->svv[4] = 0xe5; /* EBCDIC - V */
3481 tsv->svv[5] = 0xF0 + (tp->microcode_version >> 4);
3482 tsv->svv[6] = 0xF0 + (tp->microcode_version & 0x0f);
3483 tsv->svv[7] = 0x40; /* EBCDIC - */
3484 tsv->svv[8] = 0xe7; /* EBCDIC - X */
3485
3486 if(tp->extra_info & CHIP_REV_MASK)
3487 tsv->svv[9] = 0xc5; /* EBCDIC - E */
3488 else
3489 tsv->svv[9] = 0xc4; /* EBCDIC - D */
3490
3491 return (0);
3492 }
3493
3494 static int smctr_make_tx_status_code(struct net_device *dev,
3495 MAC_SUB_VECTOR *tsv, __u16 tx_fstatus)
3496 {
3497 tsv->svi = TRANSMIT_STATUS_CODE;
3498 tsv->svl = S_TRANSMIT_STATUS_CODE;
3499
3500 tsv->svv[0] = ((tx_fstatus & 0x0100 >> 6) || IBM_PASS_SOURCE_ADDR);
3501
3502 /* Stripped frame status of Transmitted Frame */
3503 tsv->svv[1] = tx_fstatus & 0xff;
3504
3505 return (0);
3506 }
3507
3508 static int smctr_make_upstream_neighbor_addr(struct net_device *dev,
3509 MAC_SUB_VECTOR *tsv)
3510 {
3511 struct net_local *tp = (struct net_local *)dev->priv;
3512
3513 smctr_get_upstream_neighbor_addr(dev);
3514
3515 tsv->svi = UPSTREAM_NEIGHBOR_ADDRESS;
3516 tsv->svl = S_UPSTREAM_NEIGHBOR_ADDRESS;
3517
3518 tsv->svv[0] = MSB(tp->misc_command_data[0]);
3519 tsv->svv[1] = LSB(tp->misc_command_data[0]);
3520
3521 tsv->svv[2] = MSB(tp->misc_command_data[1]);
3522 tsv->svv[3] = LSB(tp->misc_command_data[1]);
3523
3524 tsv->svv[4] = MSB(tp->misc_command_data[2]);
3525 tsv->svv[5] = LSB(tp->misc_command_data[2]);
3526
3527 return (0);
3528 }
3529
3530 static int smctr_make_wrap_data(struct net_device *dev, MAC_SUB_VECTOR *tsv)
3531 {
3532 tsv->svi = WRAP_DATA;
3533 tsv->svl = S_WRAP_DATA;
3534
3535 return (0);
3536 }
3537
3538 /*
3539 * Open/initialize the board. This is called sometime after
3540 * booting when the 'ifconfig' program is run.
3541 *
3542 * This routine should set everything up anew at each open, even
3543 * registers that "should" only need to be set once at boot, so that
3544 * there is non-reboot way to recover if something goes wrong.
3545 */
3546 static int smctr_open(struct net_device *dev)
3547 {
3548 int err;
3549
3550 if(smctr_debug > 10)
3551 printk("%s: smctr_open\n", dev->name);
3552
3553 err = smctr_init_adapter(dev);
3554 if(err < 0)
3555 return (err);
3556
3557 #ifdef MODULE
3558 MOD_INC_USE_COUNT;
3559 #endif
3560
3561 return (err);
3562 }
3563
3564 /* Interrupt driven open of Token card. */
3565 static int smctr_open_tr(struct net_device *dev)
3566 {
3567 struct net_local *tp = (struct net_local *)dev->priv;
3568 unsigned long flags;
3569 int err;
3570
3571 if(smctr_debug > 10)
3572 printk("%s: smctr_open_tr\n", dev->name);
3573
3574 /* Now we can actually open the adapter. */
3575 if(tp->status == OPEN)
3576 return (0);
3577 if(tp->status != INITIALIZED)
3578 return (-1);
3579
3580 save_flags(flags);
3581 cli();
3582
3583 smctr_set_page(dev, (__u8 *)tp->ram_access);
3584
3585 if((err = smctr_issue_resume_rx_fcb_cmd(dev, (short)MAC_QUEUE)))
3586 goto out;
3587
3588 if((err = smctr_issue_resume_rx_bdb_cmd(dev, (short)MAC_QUEUE)))
3589 goto out;
3590
3591 if((err = smctr_issue_resume_rx_fcb_cmd(dev, (short)NON_MAC_QUEUE)))
3592 goto out;
3593
3594 if((err = smctr_issue_resume_rx_bdb_cmd(dev, (short)NON_MAC_QUEUE)))
3595 goto out;
3596
3597 tp->status = CLOSED;
3598
3599 /* Insert into the Ring or Enter Loopback Mode. */
3600 if((tp->mode_bits & LOOPING_MODE_MASK) == LOOPBACK_MODE_1)
3601 {
3602 tp->status = CLOSED;
3603
3604 if(!(err = smctr_issue_trc_loopback_cmd(dev)))
3605 {
3606 if(!(err = smctr_wait_cmd(dev)))
3607 tp->status = OPEN;
3608 }
3609
3610 smctr_status_chg(dev);
3611 }
3612 else
3613 {
3614 if((tp->mode_bits & LOOPING_MODE_MASK) == LOOPBACK_MODE_2)
3615 {
3616 tp->status = CLOSED;
3617 if(!(err = smctr_issue_tri_loopback_cmd(dev)))
3618 {
3619 if(!(err = smctr_wait_cmd(dev)))
3620 tp->status = OPEN;
3621 }
3622
3623 smctr_status_chg(dev);
3624 }
3625 else
3626 {
3627 if((tp->mode_bits & LOOPING_MODE_MASK)
3628 == LOOPBACK_MODE_3)
3629 {
3630 tp->status = CLOSED;
3631 if(!(err = smctr_lobe_media_test_cmd(dev)))
3632 {
3633 if(!(err = smctr_wait_cmd(dev)))
3634 tp->status = OPEN;
3635 }
3636 smctr_status_chg(dev);
3637 }
3638 else
3639 {
3640 if(!(err = smctr_lobe_media_test(dev)))
3641 err = smctr_issue_insert_cmd(dev);
3642 else
3643 {
3644 if(err == LOBE_MEDIA_TEST_FAILED)
3645 printk("%s: Lobe Media Test Failure - Check cable?\n", dev->name);
3646 }
3647 }
3648 }
3649 }
3650
3651 out:
3652 restore_flags(flags);
3653
3654 return (err);
3655 }
3656
3657 /* Check for a network adapter of this type, and return '0 if one exists.
3658 * If dev->base_addr == 0, probe all likely locations.
3659 * If dev->base_addr == 1, always return failure.
3660 */
3661 int __init smctr_probe (struct net_device *dev)
3662 {
3663 int i;
3664 int base_addr = dev ? dev->base_addr : 0;
3665
3666 if(base_addr > 0x1ff) /* Check a single specified location. */
3667 return (smctr_probe1(dev, base_addr));
3668 else if(base_addr != 0) /* Don't probe at all. */
3669 return (-ENXIO);
3670
3671 for(i = 0; smctr_portlist[i]; i++)
3672 {
3673 int ioaddr = smctr_portlist[i];
3674 if(check_region(ioaddr, SMCTR_IO_EXTENT))
3675 continue;
3676 if (!smctr_probe1(dev, ioaddr))
3677 return (0);
3678 }
3679
3680 return (-ENODEV);
3681 }
3682
3683 static int __init smctr_probe1(struct net_device *dev, int ioaddr)
3684 {
3685 static unsigned version_printed;
3686 struct net_local *tp;
3687 int err;
3688 __u32 *ram;
3689
3690 if(smctr_debug && version_printed++ == 0)
3691 printk(version);
3692
3693 #ifndef MODULE
3694 dev = init_trdev(dev, 0);
3695 if(dev == NULL)
3696 return (-ENOMEM);
3697 #endif
3698
3699 /* Setup this devices private information structure */
3700 tp = (struct net_local *)kmalloc(sizeof(struct net_local),
3701 GFP_KERNEL);
3702 if(tp == NULL) {
3703 err = -ENOMEM;
3704 goto out;
3705 }
3706 memset(tp, 0, sizeof(struct net_local));
3707 dev->priv = tp;
3708 dev->base_addr = ioaddr;
3709
3710 /* Actually detect an adapter now. */
3711 err = smctr_chk_isa(dev);
3712 if(err < 0)
3713 {
3714 if ((err = smctr_chk_mca(dev)) < 0) {
3715 err = -ENODEV;
3716 goto out_tp;
3717 }
3718 }
3719
3720 tp = (struct net_local *)dev->priv;
3721 dev->rmem_start = dev->mem_start = tp->ram_base;
3722 dev->rmem_end = dev->mem_end = dev->mem_start + 0x10000;
3723 ram = (__u32 *)phys_to_virt(dev->mem_start);
3724 tp->ram_access = *(__u32 *)&ram;
3725 tp->status = NOT_INITIALIZED;
3726
3727 err = smctr_load_firmware(dev);
3728 if(err != UCODE_PRESENT && err != SUCCESS)
3729 {
3730 printk("%s: Firmware load failed (%d)\n", dev->name, err);
3731 err = -EIO;
3732 goto out_tp;
3733 }
3734
3735 /* Allow user to specify ring speed on module insert. */
3736 if(ringspeed == 4)
3737 tp->media_type = MEDIA_UTP_4;
3738 else
3739 tp->media_type = MEDIA_UTP_16;
3740
3741 printk("%s: %s %s at Io %#4x, Irq %d, Rom %#4x, Ram %#4x.\n",
3742 dev->name, smctr_name, smctr_model,
3743 (unsigned int)dev->base_addr,
3744 dev->irq, tp->rom_base, tp->ram_base);
3745
3746 /* AKPM: there's no point in this */
3747 dev->init = smctr_init_card;
3748 dev->open = smctr_open;
3749 dev->stop = smctr_close;
3750 dev->hard_start_xmit = smctr_send_packet;
3751 dev->tx_timeout = smctr_timeout;
3752 dev->watchdog_timeo = HZ;
3753 dev->get_stats = smctr_get_stats;
3754 dev->set_multicast_list = &smctr_set_multicast_list;
3755 return (0);
3756
3757 out_tp:
3758 kfree(tp);
3759 out:
3760 return err;
3761 }
3762
3763 static int smctr_process_rx_packet(MAC_HEADER *rmf, __u16 size,
3764 struct net_device *dev, __u16 rx_status)
3765 {
3766 struct net_local *tp = (struct net_local *)dev->priv;
3767 struct sk_buff *skb;
3768 __u16 rcode, correlator;
3769 int err = 0;
3770 __u8 xframe = 1;
3771 __u16 tx_fstatus;
3772
3773 rmf->vl = SWAP_BYTES(rmf->vl);
3774 if(rx_status & FCB_RX_STATUS_DA_MATCHED)
3775 {
3776 switch(rmf->vc)
3777 {
3778 /* Received MAC Frames Processed by RS. */
3779 case INIT:
3780 if((rcode = smctr_rcv_init(dev, rmf,
3781 &correlator)) == HARDWARE_FAILED)
3782 {
3783 return (rcode);
3784 }
3785
3786 if((err = smctr_send_rsp(dev, rmf, rcode,
3787 correlator)))
3788 {
3789 return (err);
3790 }
3791 break;
3792
3793 case CHG_PARM:
3794 if((rcode = smctr_rcv_chg_param(dev, rmf,
3795 &correlator)) ==HARDWARE_FAILED)
3796 {
3797 return (rcode);
3798 }
3799
3800 if((err = smctr_send_rsp(dev, rmf, rcode,
3801 correlator)))
3802 {
3803 return (err);
3804 }
3805 break;
3806
3807 case RQ_ADDR:
3808 if((rcode = smctr_rcv_rq_addr_state_attch(dev,
3809 rmf, &correlator)) != POSITIVE_ACK)
3810 {
3811 if(rcode == HARDWARE_FAILED)
3812 return (rcode);
3813 else
3814 return (smctr_send_rsp(dev, rmf,
3815 rcode, correlator));
3816 }
3817
3818 if((err = smctr_send_rpt_addr(dev, rmf,
3819 correlator)))
3820 {
3821 return (err);
3822 }
3823 break;
3824
3825 case RQ_ATTCH:
3826 if((rcode = smctr_rcv_rq_addr_state_attch(dev,
3827 rmf, &correlator)) != POSITIVE_ACK)
3828 {
3829 if(rcode == HARDWARE_FAILED)
3830 return (rcode);
3831 else
3832 return (smctr_send_rsp(dev, rmf,
3833 rcode,
3834 correlator));
3835 }
3836
3837 if((err = smctr_send_rpt_attch(dev, rmf,
3838 correlator)))
3839 {
3840 return (err);
3841 }
3842 break;
3843
3844 case RQ_STATE:
3845 if((rcode = smctr_rcv_rq_addr_state_attch(dev,
3846 rmf, &correlator)) != POSITIVE_ACK)
3847 {
3848 if(rcode == HARDWARE_FAILED)
3849 return (rcode);
3850 else
3851 return (smctr_send_rsp(dev, rmf,
3852 rcode,
3853 correlator));
3854 }
3855
3856 if((err = smctr_send_rpt_state(dev, rmf,
3857 correlator)))
3858 {
3859 return (err);
3860 }
3861 break;
3862
3863 case TX_FORWARD:
3864 if((rcode = smctr_rcv_tx_forward(dev, rmf))
3865 != POSITIVE_ACK)
3866 {
3867 if(rcode == HARDWARE_FAILED)
3868 return (rcode);
3869 else
3870 return (smctr_send_rsp(dev, rmf,
3871 rcode,
3872 correlator));
3873 }
3874
3875 if((err = smctr_send_tx_forward(dev, rmf,
3876 &tx_fstatus)) == HARDWARE_FAILED)
3877 {
3878 return (err);
3879 }
3880
3881 if(err == A_FRAME_WAS_FORWARDED)
3882 {
3883 if((err = smctr_send_rpt_tx_forward(dev,
3884 rmf, tx_fstatus))
3885 == HARDWARE_FAILED)
3886 {
3887 return (err);
3888 }
3889 }
3890 break;
3891
3892 /* Received MAC Frames Processed by CRS/REM/RPS. */
3893 case RSP:
3894 case RQ_INIT:
3895 case RPT_NEW_MON:
3896 case RPT_SUA_CHG:
3897 case RPT_ACTIVE_ERR:
3898 case RPT_NN_INCMP:
3899 case RPT_ERROR:
3900 case RPT_ATTCH:
3901 case RPT_STATE:
3902 case RPT_ADDR:
3903 break;
3904
3905 /* Rcvd Att. MAC Frame (if RXATMAC set) or UNKNOWN */
3906 default:
3907 xframe = 0;
3908 if(!(tp->receive_mask & ACCEPT_ATT_MAC_FRAMES))
3909 {
3910 rcode = smctr_rcv_unknown(dev, rmf,
3911 &correlator);
3912 if((err = smctr_send_rsp(dev, rmf,rcode,
3913 correlator)))
3914 {
3915 return (err);
3916 }
3917 }
3918
3919 break;
3920 }
3921 }
3922 else
3923 {
3924 /* 1. DA doesn't match (Promiscuous Mode).
3925 * 2. Parse for Extended MAC Frame Type.
3926 */
3927 switch(rmf->vc)
3928 {
3929 case RSP:
3930 case INIT:
3931 case RQ_INIT:
3932 case RQ_ADDR:
3933 case RQ_ATTCH:
3934 case RQ_STATE:
3935 case CHG_PARM:
3936 case RPT_ADDR:
3937 case RPT_ERROR:
3938 case RPT_ATTCH:
3939 case RPT_STATE:
3940 case RPT_NEW_MON:
3941 case RPT_SUA_CHG:
3942 case RPT_NN_INCMP:
3943 case RPT_ACTIVE_ERR:
3944 break;
3945
3946 default:
3947 xframe = 0;
3948 break;
3949 }
3950 }
3951
3952 /* NOTE: UNKNOWN MAC frames will NOT be passed up unless
3953 * ACCEPT_ATT_MAC_FRAMES is set.
3954 */
3955 if(((tp->receive_mask & ACCEPT_ATT_MAC_FRAMES)
3956 && (xframe == (__u8)0))
3957 || ((tp->receive_mask & ACCEPT_EXT_MAC_FRAMES)
3958 && (xframe == (__u8)1)))
3959 {
3960 rmf->vl = SWAP_BYTES(rmf->vl);
3961
3962 if (!(skb = dev_alloc_skb(size)))
3963 return -ENOMEM;
3964 skb->len = size;
3965
3966 /* Slide data into a sleek skb. */
3967 skb_put(skb, skb->len);
3968 memcpy(skb->data, rmf, skb->len);
3969
3970 /* Update Counters */
3971 tp->MacStat.rx_packets++;
3972 tp->MacStat.rx_bytes += skb->len;
3973
3974 /* Kick the packet on up. */
3975 skb->dev = dev;
3976 skb->protocol = tr_type_trans(skb, dev);
3977 netif_rx(skb);
3978 dev->last_rx = jiffies;
3979 err = 0;
3980 }
3981
3982 return (err);
3983 }
3984
3985 /* Adapter RAM test. Incremental word ODD boundry data test. */
3986 static int smctr_ram_memory_test(struct net_device *dev)
3987 {
3988 struct net_local *tp = (struct net_local *)dev->priv;
3989 __u16 page, pages_of_ram, start_pattern = 0, word_pattern = 0,
3990 word_read = 0, err_word = 0, err_pattern = 0;
3991 unsigned int err_offset;
3992 __u32 j, pword;
3993 __u8 err = 0;
3994
3995 if(smctr_debug > 10)
3996 printk("%s: smctr_ram_memory_test\n", dev->name);
3997
3998 start_pattern = 0x0001;
3999 pages_of_ram = tp->ram_size / tp->ram_usable;
4000 pword = tp->ram_access;
4001
4002 /* Incremental word ODD boundry test. */
4003 for(page = 0; (page < pages_of_ram) && (~err);
4004 page++, start_pattern += 0x8000)
4005 {
4006 smctr_set_page(dev, (__u8 *)(tp->ram_access
4007 + (page * tp->ram_usable * 1024) + 1));
4008 word_pattern = start_pattern;
4009
4010 for(j = 1; j < (__u32)(tp->ram_usable * 1024) - 1; j += 2)
4011 *(__u16 *)(pword + j) = word_pattern++;
4012
4013 word_pattern = start_pattern;
4014
4015 for(j = 1; j < (__u32)(tp->ram_usable * 1024) - 1
4016 && (~err); j += 2, word_pattern++)
4017 {
4018 word_read = *(__u16 *)(pword + j);
4019 if(word_read != word_pattern)
4020 {
4021 err = (__u8)1;
4022 err_offset = j;
4023 err_word = word_read;
4024 err_pattern = word_pattern;
4025 return (RAM_TEST_FAILED);
4026 }
4027 }
4028 }
4029
4030 /* Zero out memory. */
4031 for(page = 0; page < pages_of_ram && (~err); page++)
4032 {
4033 smctr_set_page(dev, (__u8 *)(tp->ram_access
4034 + (page * tp->ram_usable * 1024)));
4035 word_pattern = 0;
4036
4037 for(j = 0; j < (__u32)tp->ram_usable * 1024; j +=2)
4038 *(__u16 *)(pword + j) = word_pattern;
4039
4040 for(j =0; j < (__u32)tp->ram_usable * 1024
4041 && (~err); j += 2)
4042 {
4043 word_read = *(__u16 *)(pword + j);
4044 if(word_read != word_pattern)
4045 {
4046 err = (__u8)1;
4047 err_offset = j;
4048 err_word = word_read;
4049 err_pattern = word_pattern;
4050 return (RAM_TEST_FAILED);
4051 }
4052 }
4053 }
4054
4055 smctr_set_page(dev, (__u8 *)tp->ram_access);
4056
4057 return (0);
4058 }
4059
4060 static int smctr_rcv_chg_param(struct net_device *dev, MAC_HEADER *rmf,
4061 __u16 *correlator)
4062 {
4063 MAC_SUB_VECTOR *rsv;
4064 signed short vlen;
4065 __u16 rcode = POSITIVE_ACK;
4066 unsigned int svectors = F_NO_SUB_VECTORS_FOUND;
4067
4068 /* This Frame can only come from a CRS */
4069 if((rmf->dc_sc & SC_MASK) != SC_CRS)
4070 return(E_INAPPROPRIATE_SOURCE_CLASS);
4071
4072 /* Remove MVID Length from total length. */
4073 vlen = (signed short)rmf->vl - 4;
4074
4075 /* Point to First SVID */
4076 rsv = (MAC_SUB_VECTOR *)((__u32)rmf + sizeof(MAC_HEADER));
4077
4078 /* Search for Appropriate SVID's. */
4079 while((vlen > 0) && (rcode == POSITIVE_ACK))
4080 {
4081 switch(rsv->svi)
4082 {
4083 case CORRELATOR:
4084 svectors |= F_CORRELATOR;
4085 rcode = smctr_set_corr(dev, rsv, correlator);
4086 break;
4087
4088 case LOCAL_RING_NUMBER:
4089 svectors |= F_LOCAL_RING_NUMBER;
4090 rcode = smctr_set_local_ring_num(dev, rsv);
4091 break;
4092
4093 case ASSIGN_PHYSICAL_DROP:
4094 svectors |= F_ASSIGN_PHYSICAL_DROP;
4095 rcode = smctr_set_phy_drop(dev, rsv);
4096 break;
4097
4098 case ERROR_TIMER_VALUE:
4099 svectors |= F_ERROR_TIMER_VALUE;
4100 rcode = smctr_set_error_timer_value(dev, rsv);
4101 break;
4102
4103 case AUTHORIZED_FUNCTION_CLASS:
4104 svectors |= F_AUTHORIZED_FUNCTION_CLASS;
4105 rcode = smctr_set_auth_funct_class(dev, rsv);
4106 break;
4107
4108 case AUTHORIZED_ACCESS_PRIORITY:
4109 svectors |= F_AUTHORIZED_ACCESS_PRIORITY;
4110 rcode = smctr_set_auth_access_pri(dev, rsv);
4111 break;
4112
4113 default:
4114 rcode = E_SUB_VECTOR_UNKNOWN;
4115 break;
4116 }
4117
4118 /* Let Sender Know if SUM of SV length's is
4119 * larger then length in MVID length field
4120 */
4121 if((vlen -= rsv->svl) < 0)
4122 rcode = E_VECTOR_LENGTH_ERROR;
4123
4124 rsv = (MAC_SUB_VECTOR *)((__u32)rsv + rsv->svl);
4125 }
4126
4127 if(rcode == POSITIVE_ACK)
4128 {
4129 /* Let Sender Know if MVID length field
4130 * is larger then SUM of SV length's
4131 */
4132 if(vlen != 0)
4133 rcode = E_VECTOR_LENGTH_ERROR;
4134 else
4135 {
4136 /* Let Sender Know if Expected SVID Missing */
4137 if((svectors & R_CHG_PARM) ^ R_CHG_PARM)
4138 rcode = E_MISSING_SUB_VECTOR;
4139 }
4140 }
4141
4142 return (rcode);
4143 }
4144
4145 static int smctr_rcv_init(struct net_device *dev, MAC_HEADER *rmf,
4146 __u16 *correlator)
4147 {
4148 MAC_SUB_VECTOR *rsv;
4149 signed short vlen;
4150 __u16 rcode = POSITIVE_ACK;
4151 unsigned int svectors = F_NO_SUB_VECTORS_FOUND;
4152
4153 /* This Frame can only come from a RPS */
4154 if((rmf->dc_sc & SC_MASK) != SC_RPS)
4155 return (E_INAPPROPRIATE_SOURCE_CLASS);
4156
4157 /* Remove MVID Length from total length. */
4158 vlen = (signed short)rmf->vl - 4;
4159
4160 /* Point to First SVID */
4161 rsv = (MAC_SUB_VECTOR *)((__u32)rmf + sizeof(MAC_HEADER));
4162
4163 /* Search for Appropriate SVID's */
4164 while((vlen > 0) && (rcode == POSITIVE_ACK))
4165 {
4166 switch(rsv->svi)
4167 {
4168 case CORRELATOR:
4169 svectors |= F_CORRELATOR;
4170 rcode = smctr_set_corr(dev, rsv, correlator);
4171 break;
4172
4173 case LOCAL_RING_NUMBER:
4174 svectors |= F_LOCAL_RING_NUMBER;
4175 rcode = smctr_set_local_ring_num(dev, rsv);
4176 break;
4177
4178 case ASSIGN_PHYSICAL_DROP:
4179 svectors |= F_ASSIGN_PHYSICAL_DROP;
4180 rcode = smctr_set_phy_drop(dev, rsv);
4181 break;
4182
4183 case ERROR_TIMER_VALUE:
4184 svectors |= F_ERROR_TIMER_VALUE;
4185 rcode = smctr_set_error_timer_value(dev, rsv);
4186 break;
4187
4188 default:
4189 rcode = E_SUB_VECTOR_UNKNOWN;
4190 break;
4191 }
4192
4193 /* Let Sender Know if SUM of SV length's is
4194 * larger then length in MVID length field
4195 */
4196 if((vlen -= rsv->svl) < 0)
4197 rcode = E_VECTOR_LENGTH_ERROR;
4198
4199 rsv = (MAC_SUB_VECTOR *)((__u32)rsv + rsv->svl);
4200 }
4201
4202 if(rcode == POSITIVE_ACK)
4203 {
4204 /* Let Sender Know if MVID length field
4205 * is larger then SUM of SV length's
4206 */
4207 if(vlen != 0)
4208 rcode = E_VECTOR_LENGTH_ERROR;
4209 else
4210 {
4211 /* Let Sender Know if Expected SV Missing */
4212 if((svectors & R_INIT) ^ R_INIT)
4213 rcode = E_MISSING_SUB_VECTOR;
4214 }
4215 }
4216
4217 return (rcode);
4218 }
4219
4220 static int smctr_rcv_tx_forward(struct net_device *dev, MAC_HEADER *rmf)
4221 {
4222 MAC_SUB_VECTOR *rsv;
4223 signed short vlen;
4224 __u16 rcode = POSITIVE_ACK;
4225 unsigned int svectors = F_NO_SUB_VECTORS_FOUND;
4226
4227 /* This Frame can only come from a CRS */
4228 if((rmf->dc_sc & SC_MASK) != SC_CRS)
4229 return (E_INAPPROPRIATE_SOURCE_CLASS);
4230
4231 /* Remove MVID Length from total length */
4232 vlen = (signed short)rmf->vl - 4;
4233
4234 /* Point to First SVID */
4235 rsv = (MAC_SUB_VECTOR *)((__u32)rmf + sizeof(MAC_HEADER));
4236
4237 /* Search for Appropriate SVID's */
4238 while((vlen > 0) && (rcode == POSITIVE_ACK))
4239 {
4240 switch(rsv->svi)
4241 {
4242 case FRAME_FORWARD:
4243 svectors |= F_FRAME_FORWARD;
4244 rcode = smctr_set_frame_forward(dev, rsv,
4245 rmf->dc_sc);
4246 break;
4247
4248 default:
4249 rcode = E_SUB_VECTOR_UNKNOWN;
4250 break;
4251 }
4252
4253 /* Let Sender Know if SUM of SV length's is
4254 * larger then length in MVID length field
4255 */
4256 if((vlen -= rsv->svl) < 0)
4257 rcode = E_VECTOR_LENGTH_ERROR;
4258
4259 rsv = (MAC_SUB_VECTOR *)((__u32)rsv + rsv->svl);
4260 }
4261
4262 if(rcode == POSITIVE_ACK)
4263 {
4264 /* Let Sender Know if MVID length field
4265 * is larger then SUM of SV length's
4266 */
4267 if(vlen != 0)
4268 rcode = E_VECTOR_LENGTH_ERROR;
4269 else
4270 {
4271 /* Let Sender Know if Expected SV Missing */
4272 if((svectors & R_TX_FORWARD) ^ R_TX_FORWARD)
4273 rcode = E_MISSING_SUB_VECTOR;
4274 }
4275 }
4276
4277 return (rcode);
4278 }
4279
4280 static int smctr_rcv_rq_addr_state_attch(struct net_device *dev,
4281 MAC_HEADER *rmf, __u16 *correlator)
4282 {
4283 MAC_SUB_VECTOR *rsv;
4284 signed short vlen;
4285 __u16 rcode = POSITIVE_ACK;
4286 unsigned int svectors = F_NO_SUB_VECTORS_FOUND;
4287
4288 /* Remove MVID Length from total length */
4289 vlen = (signed short)rmf->vl - 4;
4290
4291 /* Point to First SVID */
4292 rsv = (MAC_SUB_VECTOR *)((__u32)rmf + sizeof(MAC_HEADER));
4293
4294 /* Search for Appropriate SVID's */
4295 while((vlen > 0) && (rcode == POSITIVE_ACK))
4296 {
4297 switch(rsv->svi)
4298 {
4299 case CORRELATOR:
4300 svectors |= F_CORRELATOR;
4301 rcode = smctr_set_corr(dev, rsv, correlator);
4302 break;
4303
4304 default:
4305 rcode = E_SUB_VECTOR_UNKNOWN;
4306 break;
4307 }
4308
4309 /* Let Sender Know if SUM of SV length's is
4310 * larger then length in MVID length field
4311 */
4312 if((vlen -= rsv->svl) < 0)
4313 rcode = E_VECTOR_LENGTH_ERROR;
4314
4315 rsv = (MAC_SUB_VECTOR *)((__u32)rsv + rsv->svl);
4316 }
4317
4318 if(rcode == POSITIVE_ACK)
4319 {
4320 /* Let Sender Know if MVID length field
4321 * is larger then SUM of SV length's
4322 */
4323 if(vlen != 0)
4324 rcode = E_VECTOR_LENGTH_ERROR;
4325 else
4326 {
4327 /* Let Sender Know if Expected SVID Missing */
4328 if((svectors & R_RQ_ATTCH_STATE_ADDR)
4329 ^ R_RQ_ATTCH_STATE_ADDR)
4330 rcode = E_MISSING_SUB_VECTOR;
4331 }
4332 }
4333
4334 return (rcode);
4335 }
4336
4337 static int smctr_rcv_unknown(struct net_device *dev, MAC_HEADER *rmf,
4338 __u16 *correlator)
4339 {
4340 MAC_SUB_VECTOR *rsv;
4341 signed short vlen;
4342
4343 *correlator = 0;
4344
4345 /* Remove MVID Length from total length */
4346 vlen = (signed short)rmf->vl - 4;
4347
4348 /* Point to First SVID */
4349 rsv = (MAC_SUB_VECTOR *)((__u32)rmf + sizeof(MAC_HEADER));
4350
4351 /* Search for CORRELATOR for RSP to UNKNOWN */
4352 while((vlen > 0) && (*correlator == 0))
4353 {
4354 switch(rsv->svi)
4355 {
4356 case CORRELATOR:
4357 smctr_set_corr(dev, rsv, correlator);
4358 break;
4359
4360 default:
4361 break;
4362 }
4363
4364 vlen -= rsv->svl;
4365 rsv = (MAC_SUB_VECTOR *)((__u32)rsv + rsv->svl);
4366 }
4367
4368 return (E_UNRECOGNIZED_VECTOR_ID);
4369 }
4370
4371 /*
4372 * Reset the 825 NIC and exit w:
4373 * 1. The NIC reset cleared (non-reset state), halted and un-initialized.
4374 * 2. TINT masked.
4375 * 3. CBUSY masked.
4376 * 4. TINT clear.
4377 * 5. CBUSY clear.
4378 */
4379 static int smctr_reset_adapter(struct net_device *dev)
4380 {
4381 struct net_local *tp = (struct net_local *)dev->priv;
4382 int ioaddr = dev->base_addr;
4383
4384 /* Reseting the NIC will put it in a halted and un-initialized state. */ smctr_set_trc_reset(ioaddr);
4385 mdelay(200); /* ~2 ms */
4386
4387 smctr_clear_trc_reset(ioaddr);
4388 mdelay(200); /* ~2 ms */
4389
4390 /* Remove any latched interrupts that occurred prior to reseting the
4391 * adapter or possibily caused by line glitches due to the reset.
4392 */
4393 outb(tp->trc_mask | CSR_CLRTINT | CSR_CLRCBUSY, ioaddr + CSR);
4394
4395 return (0);
4396 }
4397
4398 static int smctr_restart_tx_chain(struct net_device *dev, short queue)
4399 {
4400 struct net_local *tp = (struct net_local *)dev->priv;
4401 int err = 0;
4402
4403 if(smctr_debug > 10)
4404 printk("%s: smctr_restart_tx_chain\n", dev->name);
4405
4406 if(tp->num_tx_fcbs_used[queue] != 0
4407 && tp->tx_queue_status[queue] == NOT_TRANSMITING)
4408 {
4409 tp->tx_queue_status[queue] = TRANSMITING;
4410 err = smctr_issue_resume_tx_fcb_cmd(dev, queue);
4411 }
4412
4413 return (err);
4414 }
4415
4416 static int smctr_ring_status_chg(struct net_device *dev)
4417 {
4418 struct net_local *tp = (struct net_local *)dev->priv;
4419
4420 if(smctr_debug > 10)
4421 printk("%s: smctr_ring_status_chg\n", dev->name);
4422
4423 /* Check for ring_status_flag: whenever MONITOR_STATE_BIT
4424 * Bit is set, check value of monitor_state, only then we
4425 * enable and start transmit/receive timeout (if and only
4426 * if it is MS_ACTIVE_MONITOR_STATE or MS_STANDBY_MONITOR_STATE)
4427 */
4428 if(tp->ring_status_flags == MONITOR_STATE_CHANGED)
4429 {
4430 if((tp->monitor_state == MS_ACTIVE_MONITOR_STATE)
4431 || (tp->monitor_state == MS_STANDBY_MONITOR_STATE))
4432 {
4433 tp->monitor_state_ready = 1;
4434 }
4435 else
4436 {
4437 /* if adapter is NOT in either active monitor
4438 * or standby monitor state => Disable
4439 * transmit/receive timeout.
4440 */
4441 tp->monitor_state_ready = 0;
4442
4443 /* Ring speed problem, switching to auto mode. */
4444 if(tp->monitor_state == MS_MONITOR_FSM_INACTIVE
4445 && !tp->cleanup)
4446 {
4447 printk(KERN_INFO "%s: Incorrect ring speed switching.\n",
4448 dev->name);
4449 smctr_set_ring_speed(dev);
4450 }
4451 }
4452 }
4453
4454 if(!(tp->ring_status_flags & RING_STATUS_CHANGED))
4455 return (0);
4456
4457 switch(tp->ring_status)
4458 {
4459 case RING_RECOVERY:
4460 printk(KERN_INFO "%s: Ring Recovery\n", dev->name);
4461 tp->current_ring_status |= RING_RECOVERY;
4462 break;
4463
4464 case SINGLE_STATION:
4465 printk(KERN_INFO "%s: Single Statinon\n", dev->name);
4466 tp->current_ring_status |= SINGLE_STATION;
4467 break;
4468
4469 case COUNTER_OVERFLOW:
4470 printk(KERN_INFO "%s: Counter Overflow\n", dev->name);
4471 tp->current_ring_status |= COUNTER_OVERFLOW;
4472 break;
4473
4474 case REMOVE_RECEIVED:
4475 printk(KERN_INFO "%s: Remove Received\n", dev->name);
4476 tp->current_ring_status |= REMOVE_RECEIVED;
4477 break;
4478
4479 case AUTO_REMOVAL_ERROR:
4480 printk(KERN_INFO "%s: Auto Remove Error\n", dev->name);
4481 tp->current_ring_status |= AUTO_REMOVAL_ERROR;
4482 break;
4483
4484 case LOBE_WIRE_FAULT:
4485 printk(KERN_INFO "%s: Lobe Wire Fault\n", dev->name);
4486 tp->current_ring_status |= LOBE_WIRE_FAULT;
4487 break;
4488
4489 case TRANSMIT_BEACON:
4490 printk(KERN_INFO "%s: Transmit Beacon\n", dev->name);
4491 tp->current_ring_status |= TRANSMIT_BEACON;
4492 break;
4493
4494 case SOFT_ERROR:
4495 printk(KERN_INFO "%s: Soft Error\n", dev->name);
4496 tp->current_ring_status |= SOFT_ERROR;
4497 break;
4498
4499 case HARD_ERROR:
4500 printk(KERN_INFO "%s: Hard Error\n", dev->name);
4501 tp->current_ring_status |= HARD_ERROR;
4502 break;
4503
4504 case SIGNAL_LOSS:
4505 printk(KERN_INFO "%s: Singal Loss\n", dev->name);
4506 tp->current_ring_status |= SIGNAL_LOSS;
4507 break;
4508
4509 default:
4510 printk(KERN_INFO "%s: Unknown ring status change\n",
4511 dev->name);
4512 break;
4513 }
4514
4515 return (0);
4516 }
4517
4518 static int smctr_rx_frame(struct net_device *dev)
4519 {
4520 struct net_local *tp = (struct net_local *)dev->priv;
4521 __u16 queue, status, rx_size, err = 0;
4522 __u8 *pbuff;
4523
4524 if(smctr_debug > 10)
4525 printk("%s: smctr_rx_frame\n", dev->name);
4526
4527 cli();
4528 queue = tp->receive_queue_number;
4529
4530 while((status = tp->rx_fcb_curr[queue]->frame_status) != SUCCESS)
4531 {
4532 err = HARDWARE_FAILED;
4533
4534 if(((status & 0x007f) == 0)
4535 || ((tp->receive_mask & ACCEPT_ERR_PACKETS) != 0))
4536 {
4537 /* frame length less the CRC (4 bytes) + FS (1 byte) */
4538 rx_size = tp->rx_fcb_curr[queue]->frame_length - 5;
4539
4540 pbuff = smctr_get_rx_pointer(dev, queue);
4541
4542 smctr_set_page(dev, pbuff);
4543 smctr_disable_16bit(dev);
4544
4545 /* pbuff points to addr within one page */
4546 pbuff = (__u8 *)PAGE_POINTER(pbuff);
4547
4548 if(queue == NON_MAC_QUEUE)
4549 {
4550 struct sk_buff *skb;
4551
4552 skb = dev_alloc_skb(rx_size);
4553 if (skb) {
4554 skb_put(skb, rx_size);
4555
4556 memcpy(skb->data, pbuff, rx_size);
4557 sti();
4558
4559 /* Update Counters */
4560 tp->MacStat.rx_packets++;
4561 tp->MacStat.rx_bytes += skb->len;
4562
4563 /* Kick the packet on up. */
4564 skb->dev = dev;
4565 skb->protocol = tr_type_trans(skb, dev);
4566 netif_rx(skb);
4567 dev->last_rx = jiffies;
4568 } else {
4569 sti();
4570 }
4571 }
4572 else
4573 smctr_process_rx_packet((MAC_HEADER *)pbuff,
4574 rx_size, dev, status);
4575 }
4576
4577 smctr_enable_16bit(dev);
4578 smctr_set_page(dev, (__u8 *)tp->ram_access);
4579 smctr_update_rx_chain(dev, queue);
4580
4581 if(err != SUCCESS)
4582 break;
4583 }
4584
4585 return (err);
4586 }
4587
4588 static int smctr_send_dat(struct net_device *dev)
4589 {
4590 struct net_local *tp = (struct net_local *)dev->priv;
4591 unsigned int i, err;
4592 MAC_HEADER *tmf;
4593 FCBlock *fcb;
4594
4595 if(smctr_debug > 10)
4596 printk("%s: smctr_send_dat\n", dev->name);
4597
4598 if((fcb = smctr_get_tx_fcb(dev, MAC_QUEUE,
4599 sizeof(MAC_HEADER))) == (FCBlock *)(-1L))
4600 {
4601 return (OUT_OF_RESOURCES);
4602 }
4603
4604 /* Initialize DAT Data Fields. */
4605 tmf = (MAC_HEADER *)fcb->bdb_ptr->data_block_ptr;
4606 tmf->ac = MSB(AC_FC_DAT);
4607 tmf->fc = LSB(AC_FC_DAT);
4608
4609 for(i = 0; i < 6; i++)
4610 {
4611 tmf->sa[i] = dev->dev_addr[i];
4612 tmf->da[i] = dev->dev_addr[i];
4613
4614 }
4615
4616 tmf->vc = DAT;
4617 tmf->dc_sc = DC_RS | SC_RS;
4618 tmf->vl = 4;
4619 tmf->vl = SWAP_BYTES(tmf->vl);
4620
4621 /* Start Transmit. */
4622 if((err = smctr_trc_send_packet(dev, fcb, MAC_QUEUE)))
4623 return (err);
4624
4625 /* Wait for Transmit to Complete */
4626 for(i = 0; i < 10000; i++)
4627 {
4628 if(fcb->frame_status & FCB_COMMAND_DONE)
4629 break;
4630 mdelay(1);
4631 }
4632
4633 /* Check if GOOD frame Tx'ed. */
4634 if(!(fcb->frame_status & FCB_COMMAND_DONE)
4635 || fcb->frame_status & (FCB_TX_STATUS_E | FCB_TX_AC_BITS))
4636 {
4637 return (INITIALIZE_FAILED);
4638 }
4639
4640 /* De-allocated Tx FCB and Frame Buffer
4641 * The FCB must be de-allocated manually if executing with
4642 * interrupts disabled, other wise the ISR (LM_Service_Events)
4643 * will de-allocate it when the interrupt occurs.
4644 */
4645 tp->tx_queue_status[MAC_QUEUE] = NOT_TRANSMITING;
4646 smctr_update_tx_chain(dev, fcb, MAC_QUEUE);
4647
4648 return (0);
4649 }
4650
4651 static void smctr_timeout(struct net_device *dev)
4652 {
4653 /*
4654 * If we get here, some higher level has decided we are broken.
4655 * There should really be a "kick me" function call instead.
4656 *
4657 * Resetting the token ring adapter takes a long time so just
4658 * fake transmission time and go on trying. Our own timeout
4659 * routine is in sktr_timer_chk()
4660 */
4661 dev->trans_start = jiffies;
4662 netif_wake_queue(dev);
4663 }
4664
4665 /*
4666 * Gets skb from system, queues it and checks if it can be sent
4667 */
4668 static int smctr_send_packet(struct sk_buff *skb, struct net_device *dev)
4669 {
4670 struct net_local *tp = (struct net_local *)dev->priv;
4671
4672 if(smctr_debug > 10)
4673 printk("%s: smctr_send_packet\n", dev->name);
4674
4675 /*
4676 * Block a transmit overlap
4677 */
4678
4679 netif_stop_queue(dev);
4680
4681 if(tp->QueueSkb == 0)
4682 return (1); /* Return with tbusy set: queue full */
4683
4684 tp->QueueSkb--;
4685 skb_queue_tail(&tp->SendSkbQueue, skb);
4686 smctr_hardware_send_packet(dev, tp);
4687 if(tp->QueueSkb > 0)
4688 netif_wake_queue(dev);
4689
4690 return (0);
4691 }
4692
4693 static int smctr_send_lobe_media_test(struct net_device *dev)
4694 {
4695 struct net_local *tp = (struct net_local *)dev->priv;
4696 MAC_SUB_VECTOR *tsv;
4697 MAC_HEADER *tmf;
4698 FCBlock *fcb;
4699 __u32 i;
4700 int err;
4701
4702 if(smctr_debug > 15)
4703 printk("%s: smctr_send_lobe_media_test\n", dev->name);
4704
4705 if((fcb = smctr_get_tx_fcb(dev, MAC_QUEUE, sizeof(struct trh_hdr)
4706 + S_WRAP_DATA + S_WRAP_DATA)) == (FCBlock *)(-1L))
4707 {
4708 return (OUT_OF_RESOURCES);
4709 }
4710
4711 /* Initialize DAT Data Fields. */
4712 tmf = (MAC_HEADER *)fcb->bdb_ptr->data_block_ptr;
4713 tmf->ac = MSB(AC_FC_LOBE_MEDIA_TEST);
4714 tmf->fc = LSB(AC_FC_LOBE_MEDIA_TEST);
4715
4716 for(i = 0; i < 6; i++)
4717 {
4718 tmf->da[i] = 0;
4719 tmf->sa[i] = dev->dev_addr[i];
4720 }
4721
4722 tmf->vc = LOBE_MEDIA_TEST;
4723 tmf->dc_sc = DC_RS | SC_RS;
4724 tmf->vl = 4;
4725
4726 tsv = (MAC_SUB_VECTOR *)((__u32)tmf + sizeof(MAC_HEADER));
4727 smctr_make_wrap_data(dev, tsv);
4728 tmf->vl += tsv->svl;
4729
4730 tsv = (MAC_SUB_VECTOR *)((__u32)tsv + tsv->svl);
4731 smctr_make_wrap_data(dev, tsv);
4732 tmf->vl += tsv->svl;
4733
4734 /* Start Transmit. */
4735 tmf->vl = SWAP_BYTES(tmf->vl);
4736 if((err = smctr_trc_send_packet(dev, fcb, MAC_QUEUE)))
4737 return (err);
4738
4739 /* Wait for Transmit to Complete. (10 ms). */
4740 for(i=0; i < 10000; i++)
4741 {
4742 if(fcb->frame_status & FCB_COMMAND_DONE)
4743 break;
4744 mdelay(1);
4745 }
4746
4747 /* Check if GOOD frame Tx'ed */
4748 if(!(fcb->frame_status & FCB_COMMAND_DONE)
4749 || fcb->frame_status & (FCB_TX_STATUS_E | FCB_TX_AC_BITS))
4750 {
4751 return (LOBE_MEDIA_TEST_FAILED);
4752 }
4753
4754 /* De-allocated Tx FCB and Frame Buffer
4755 * The FCB must be de-allocated manually if executing with
4756 * interrupts disabled, other wise the ISR (LM_Service_Events)
4757 * will de-allocate it when the interrupt occurs.
4758 */
4759 tp->tx_queue_status[MAC_QUEUE] = NOT_TRANSMITING;
4760 smctr_update_tx_chain(dev, fcb, MAC_QUEUE);
4761
4762 return (0);
4763 }
4764
4765 static int smctr_send_rpt_addr(struct net_device *dev, MAC_HEADER *rmf,
4766 __u16 correlator)
4767 {
4768 MAC_HEADER *tmf;
4769 MAC_SUB_VECTOR *tsv;
4770 FCBlock *fcb;
4771
4772 if((fcb = smctr_get_tx_fcb(dev, MAC_QUEUE, sizeof(MAC_HEADER)
4773 + S_CORRELATOR + S_PHYSICAL_DROP + S_UPSTREAM_NEIGHBOR_ADDRESS
4774 + S_ADDRESS_MODIFER + S_GROUP_ADDRESS + S_FUNCTIONAL_ADDRESS))
4775 == (FCBlock *)(-1L))
4776 {
4777 return (0);
4778 }
4779
4780 tmf = (MAC_HEADER *)fcb->bdb_ptr->data_block_ptr;
4781 tmf->vc = RPT_ADDR;
4782 tmf->dc_sc = (rmf->dc_sc & SC_MASK) << 4;
4783 tmf->vl = 4;
4784
4785 smctr_make_8025_hdr(dev, rmf, tmf, AC_FC_RPT_ADDR);
4786
4787 tsv = (MAC_SUB_VECTOR *)((__u32)tmf + sizeof(MAC_HEADER));
4788 smctr_make_corr(dev, tsv, correlator);
4789
4790 tmf->vl += tsv->svl;
4791 tsv = (MAC_SUB_VECTOR *)((__u32)tsv + tsv->svl);
4792 smctr_make_phy_drop_num(dev, tsv);
4793
4794 tmf->vl += tsv->svl;
4795 tsv = (MAC_SUB_VECTOR *)((__u32)tsv + tsv->svl);
4796 smctr_make_upstream_neighbor_addr(dev, tsv);
4797
4798 tmf->vl += tsv->svl;
4799 tsv = (MAC_SUB_VECTOR *)((__u32)tsv + tsv->svl);
4800 smctr_make_addr_mod(dev, tsv);
4801
4802 tmf->vl += tsv->svl;
4803 tsv = (MAC_SUB_VECTOR *)((__u32)tsv + tsv->svl);
4804 smctr_make_group_addr(dev, tsv);
4805
4806 tmf->vl += tsv->svl;
4807 tsv = (MAC_SUB_VECTOR *)((__u32)tsv + tsv->svl);
4808 smctr_make_funct_addr(dev, tsv);
4809
4810 tmf->vl += tsv->svl;
4811
4812 /* Subtract out MVID and MVL which is
4813 * include in both vl and MAC_HEADER
4814 */
4815 /* fcb->frame_length = tmf->vl + sizeof(MAC_HEADER) - 4;
4816 fcb->bdb_ptr->buffer_length = tmf->vl + sizeof(MAC_HEADER) - 4;
4817 */
4818 tmf->vl = SWAP_BYTES(tmf->vl);
4819
4820 return (smctr_trc_send_packet(dev, fcb, MAC_QUEUE));
4821 }
4822
4823 static int smctr_send_rpt_attch(struct net_device *dev, MAC_HEADER *rmf,
4824 __u16 correlator)
4825 {
4826 MAC_HEADER *tmf;
4827 MAC_SUB_VECTOR *tsv;
4828 FCBlock *fcb;
4829
4830 if((fcb = smctr_get_tx_fcb(dev, MAC_QUEUE, sizeof(MAC_HEADER)
4831 + S_CORRELATOR + S_PRODUCT_INSTANCE_ID + S_FUNCTIONAL_ADDRESS
4832 + S_AUTHORIZED_FUNCTION_CLASS + S_AUTHORIZED_ACCESS_PRIORITY))
4833 == (FCBlock *)(-1L))
4834 {
4835 return (0);
4836 }
4837
4838 tmf = (MAC_HEADER *)fcb->bdb_ptr->data_block_ptr;
4839 tmf->vc = RPT_ATTCH;
4840 tmf->dc_sc = (rmf->dc_sc & SC_MASK) << 4;
4841 tmf->vl = 4;
4842
4843 smctr_make_8025_hdr(dev, rmf, tmf, AC_FC_RPT_ATTCH);
4844
4845 tsv = (MAC_SUB_VECTOR *)((__u32)tmf + sizeof(MAC_HEADER));
4846 smctr_make_corr(dev, tsv, correlator);
4847
4848 tmf->vl += tsv->svl;
4849 tsv = (MAC_SUB_VECTOR *)((__u32)tsv + tsv->svl);
4850 smctr_make_product_id(dev, tsv);
4851
4852 tmf->vl += tsv->svl;
4853 tsv = (MAC_SUB_VECTOR *)((__u32)tsv + tsv->svl);
4854 smctr_make_funct_addr(dev, tsv);
4855
4856 tmf->vl += tsv->svl;
4857 tsv = (MAC_SUB_VECTOR *)((__u32)tsv + tsv->svl);
4858 smctr_make_auth_funct_class(dev, tsv);
4859
4860 tmf->vl += tsv->svl;
4861 tsv = (MAC_SUB_VECTOR *)((__u32)tsv + tsv->svl);
4862 smctr_make_access_pri(dev, tsv);
4863
4864 tmf->vl += tsv->svl;
4865
4866 /* Subtract out MVID and MVL which is
4867 * include in both vl and MAC_HEADER
4868 */
4869 /* fcb->frame_length = tmf->vl + sizeof(MAC_HEADER) - 4;
4870 fcb->bdb_ptr->buffer_length = tmf->vl + sizeof(MAC_HEADER) - 4;
4871 */
4872 tmf->vl = SWAP_BYTES(tmf->vl);
4873
4874 return (smctr_trc_send_packet(dev, fcb, MAC_QUEUE));
4875 }
4876
4877 static int smctr_send_rpt_state(struct net_device *dev, MAC_HEADER *rmf,
4878 __u16 correlator)
4879 {
4880 MAC_HEADER *tmf;
4881 MAC_SUB_VECTOR *tsv;
4882 FCBlock *fcb;
4883
4884 if((fcb = smctr_get_tx_fcb(dev, MAC_QUEUE, sizeof(MAC_HEADER)
4885 + S_CORRELATOR + S_RING_STATION_VERSION_NUMBER
4886 + S_RING_STATION_STATUS + S_STATION_IDENTIFER))
4887 == (FCBlock *)(-1L))
4888 {
4889 return (0);
4890 }
4891
4892 tmf = (MAC_HEADER *)fcb->bdb_ptr->data_block_ptr;
4893 tmf->vc = RPT_STATE;
4894 tmf->dc_sc = (rmf->dc_sc & SC_MASK) << 4;
4895 tmf->vl = 4;
4896
4897 smctr_make_8025_hdr(dev, rmf, tmf, AC_FC_RPT_STATE);
4898
4899 tsv = (MAC_SUB_VECTOR *)((__u32)tmf + sizeof(MAC_HEADER));
4900 smctr_make_corr(dev, tsv, correlator);
4901
4902 tmf->vl += tsv->svl;
4903 tsv = (MAC_SUB_VECTOR *)((__u32)tsv + tsv->svl);
4904 smctr_make_ring_station_version(dev, tsv);
4905
4906 tmf->vl += tsv->svl;
4907 tsv = (MAC_SUB_VECTOR *)((__u32)tsv + tsv->svl);
4908 smctr_make_ring_station_status(dev, tsv);
4909
4910 tmf->vl += tsv->svl;
4911 tsv = (MAC_SUB_VECTOR *)((__u32)tsv + tsv->svl);
4912 smctr_make_station_id(dev, tsv);
4913
4914 tmf->vl += tsv->svl;
4915
4916 /* Subtract out MVID and MVL which is
4917 * include in both vl and MAC_HEADER
4918 */
4919 /* fcb->frame_length = tmf->vl + sizeof(MAC_HEADER) - 4;
4920 fcb->bdb_ptr->buffer_length = tmf->vl + sizeof(MAC_HEADER) - 4;
4921 */
4922 tmf->vl = SWAP_BYTES(tmf->vl);
4923
4924 return (smctr_trc_send_packet(dev, fcb, MAC_QUEUE));
4925 }
4926
4927 static int smctr_send_rpt_tx_forward(struct net_device *dev,
4928 MAC_HEADER *rmf, __u16 tx_fstatus)
4929 {
4930 MAC_HEADER *tmf;
4931 MAC_SUB_VECTOR *tsv;
4932 FCBlock *fcb;
4933
4934 if((fcb = smctr_get_tx_fcb(dev, MAC_QUEUE, sizeof(MAC_HEADER)
4935 + S_TRANSMIT_STATUS_CODE)) == (FCBlock *)(-1L))
4936 {
4937 return (0);
4938 }
4939
4940 tmf = (MAC_HEADER *)fcb->bdb_ptr->data_block_ptr;
4941 tmf->vc = RPT_TX_FORWARD;
4942 tmf->dc_sc = (rmf->dc_sc & SC_MASK) << 4;
4943 tmf->vl = 4;
4944
4945 smctr_make_8025_hdr(dev, rmf, tmf, AC_FC_RPT_TX_FORWARD);
4946
4947 tsv = (MAC_SUB_VECTOR *)((__u32)tmf + sizeof(MAC_HEADER));
4948 smctr_make_tx_status_code(dev, tsv, tx_fstatus);
4949
4950 tmf->vl += tsv->svl;
4951
4952 /* Subtract out MVID and MVL which is
4953 * include in both vl and MAC_HEADER
4954 */
4955 /* fcb->frame_length = tmf->vl + sizeof(MAC_HEADER) - 4;
4956 fcb->bdb_ptr->buffer_length = tmf->vl + sizeof(MAC_HEADER) - 4;
4957 */
4958 tmf->vl = SWAP_BYTES(tmf->vl);
4959
4960 return(smctr_trc_send_packet(dev, fcb, MAC_QUEUE));
4961 }
4962
4963 static int smctr_send_rsp(struct net_device *dev, MAC_HEADER *rmf,
4964 __u16 rcode, __u16 correlator)
4965 {
4966 MAC_HEADER *tmf;
4967 MAC_SUB_VECTOR *tsv;
4968 FCBlock *fcb;
4969
4970 if((fcb = smctr_get_tx_fcb(dev, MAC_QUEUE, sizeof(MAC_HEADER)
4971 + S_CORRELATOR + S_RESPONSE_CODE)) == (FCBlock *)(-1L))
4972 {
4973 return (0);
4974 }
4975
4976 tmf = (MAC_HEADER *)fcb->bdb_ptr->data_block_ptr;
4977 tmf->vc = RSP;
4978 tmf->dc_sc = (rmf->dc_sc & SC_MASK) << 4;
4979 tmf->vl = 4;
4980
4981 smctr_make_8025_hdr(dev, rmf, tmf, AC_FC_RSP);
4982
4983 tsv = (MAC_SUB_VECTOR *)((__u32)tmf + sizeof(MAC_HEADER));
4984 smctr_make_corr(dev, tsv, correlator);
4985
4986 return (0);
4987 }
4988
4989 static int smctr_send_rq_init(struct net_device *dev)
4990 {
4991 struct net_local *tp = (struct net_local *)dev->priv;
4992 MAC_HEADER *tmf;
4993 MAC_SUB_VECTOR *tsv;
4994 FCBlock *fcb;
4995 unsigned int i, count = 0;
4996 __u16 fstatus;
4997 int err;
4998
4999 do {
5000 if(((fcb = smctr_get_tx_fcb(dev, MAC_QUEUE, sizeof(MAC_HEADER)
5001 + S_PRODUCT_INSTANCE_ID + S_UPSTREAM_NEIGHBOR_ADDRESS
5002 + S_RING_STATION_VERSION_NUMBER + S_ADDRESS_MODIFER))
5003 == (FCBlock *)(-1L)))
5004 {
5005 return (0);
5006 }
5007
5008 tmf = (MAC_HEADER *)fcb->bdb_ptr->data_block_ptr;
5009 tmf->vc = RQ_INIT;
5010 tmf->dc_sc = DC_RPS | SC_RS;
5011 tmf->vl = 4;
5012
5013 smctr_make_8025_hdr(dev, 0L, tmf, AC_FC_RQ_INIT);
5014
5015 tsv = (MAC_SUB_VECTOR *)((__u32)tmf + sizeof(MAC_HEADER));
5016 smctr_make_product_id(dev, tsv);
5017
5018 tmf->vl += tsv->svl;
5019 tsv = (MAC_SUB_VECTOR *)((__u32)tsv + tsv->svl);
5020 smctr_make_upstream_neighbor_addr(dev, tsv);
5021
5022 tmf->vl += tsv->svl;
5023 tsv = (MAC_SUB_VECTOR *)((__u32)tsv + tsv->svl);
5024 smctr_make_ring_station_version(dev, tsv);
5025
5026 tmf->vl += tsv->svl;
5027 tsv = (MAC_SUB_VECTOR *)((__u32)tsv + tsv->svl);
5028 smctr_make_addr_mod(dev, tsv);
5029
5030 tmf->vl += tsv->svl;
5031
5032 /* Subtract out MVID and MVL which is
5033 * include in both vl and MAC_HEADER
5034 */
5035 /* fcb->frame_length = tmf->vl + sizeof(MAC_HEADER) - 4;
5036 fcb->bdb_ptr->buffer_length = tmf->vl + sizeof(MAC_HEADER) - 4;
5037 */
5038 tmf->vl = SWAP_BYTES(tmf->vl);
5039
5040 if((err = smctr_trc_send_packet(dev, fcb, MAC_QUEUE)))
5041 return (err);
5042
5043 /* Wait for Transmit to Complete */
5044 for(i = 0; i < 10000; i++)
5045 {
5046 if(fcb->frame_status & FCB_COMMAND_DONE)
5047 break;
5048 mdelay(1);
5049 }
5050
5051 /* Check if GOOD frame Tx'ed */
5052 fstatus = fcb->frame_status;
5053
5054 if(!(fstatus & FCB_COMMAND_DONE))
5055 return (HARDWARE_FAILED);
5056
5057 if(!(fstatus & FCB_TX_STATUS_E))
5058 count++;
5059
5060 /* De-allocated Tx FCB and Frame Buffer
5061 * The FCB must be de-allocated manually if executing with
5062 * interrupts disabled, other wise the ISR (LM_Service_Events)
5063 * will de-allocate it when the interrupt occurs.
5064 */
5065 tp->tx_queue_status[MAC_QUEUE] = NOT_TRANSMITING;
5066 smctr_update_tx_chain(dev, fcb, MAC_QUEUE);
5067 } while(count < 4 && ((fstatus & FCB_TX_AC_BITS) ^ FCB_TX_AC_BITS));
5068
5069 return (smctr_join_complete_state(dev));
5070 }
5071
5072 static int smctr_send_tx_forward(struct net_device *dev, MAC_HEADER *rmf,
5073 __u16 *tx_fstatus)
5074 {
5075 struct net_local *tp = (struct net_local *)dev->priv;
5076 FCBlock *fcb;
5077 unsigned int i;
5078 int err;
5079
5080 /* Check if this is the END POINT of the Transmit Forward Chain. */
5081 if(rmf->vl <= 18)
5082 return (0);
5083
5084 /* Allocate Transmit FCB only by requesting 0 bytes
5085 * of data buffer.
5086 */
5087 if((fcb = smctr_get_tx_fcb(dev, MAC_QUEUE, 0)) == (FCBlock *)(-1L))
5088 return (0);
5089
5090 /* Set pointer to Transmit Frame Buffer to the data
5091 * portion of the received TX Forward frame, making
5092 * sure to skip over the Vector Code (vc) and Vector
5093 * length (vl).
5094 */
5095 fcb->bdb_ptr->trc_data_block_ptr = TRC_POINTER((__u32)rmf
5096 + sizeof(MAC_HEADER) + 2);
5097 fcb->bdb_ptr->data_block_ptr = (__u16 *)((__u32)rmf
5098 + sizeof(MAC_HEADER) + 2);
5099
5100 fcb->frame_length = rmf->vl - 4 - 2;
5101 fcb->bdb_ptr->buffer_length = rmf->vl - 4 - 2;
5102
5103 if((err = smctr_trc_send_packet(dev, fcb, MAC_QUEUE)))
5104 return (err);
5105
5106 /* Wait for Transmit to Complete */
5107 for(i = 0; i < 10000; i++)
5108 {
5109 if(fcb->frame_status & FCB_COMMAND_DONE)
5110 break;
5111 mdelay(1);
5112 }
5113
5114 /* Check if GOOD frame Tx'ed */
5115 if(!(fcb->frame_status & FCB_COMMAND_DONE))
5116 {
5117 if((err = smctr_issue_resume_tx_fcb_cmd(dev, MAC_QUEUE)))
5118 return (err);
5119
5120 for(i = 0; i < 10000; i++)
5121 {
5122 if(fcb->frame_status & FCB_COMMAND_DONE)
5123 break;
5124 mdelay(1);
5125 }
5126
5127 if(!(fcb->frame_status & FCB_COMMAND_DONE))
5128 return (HARDWARE_FAILED);
5129 }
5130
5131 *tx_fstatus = fcb->frame_status;
5132
5133 return (A_FRAME_WAS_FORWARDED);
5134 }
5135
5136 static int smctr_set_auth_access_pri(struct net_device *dev,
5137 MAC_SUB_VECTOR *rsv)
5138 {
5139 struct net_local *tp = (struct net_local *)dev->priv;
5140
5141 if(rsv->svl != S_AUTHORIZED_ACCESS_PRIORITY)
5142 return (E_SUB_VECTOR_LENGTH_ERROR);
5143
5144 tp->authorized_access_priority = (rsv->svv[0] << 8 | rsv->svv[1]);
5145
5146 return (POSITIVE_ACK);
5147 }
5148
5149 static int smctr_set_auth_funct_class(struct net_device *dev,
5150 MAC_SUB_VECTOR *rsv)
5151 {
5152 struct net_local *tp = (struct net_local *)dev->priv;
5153
5154 if(rsv->svl != S_AUTHORIZED_FUNCTION_CLASS)
5155 return (E_SUB_VECTOR_LENGTH_ERROR);
5156
5157 tp->authorized_function_classes = (rsv->svv[0] << 8 | rsv->svv[1]);
5158
5159 return (POSITIVE_ACK);
5160 }
5161
5162 static int smctr_set_corr(struct net_device *dev, MAC_SUB_VECTOR *rsv,
5163 __u16 *correlator)
5164 {
5165 if(rsv->svl != S_CORRELATOR)
5166 return (E_SUB_VECTOR_LENGTH_ERROR);
5167
5168 *correlator = (rsv->svv[0] << 8 | rsv->svv[1]);
5169
5170 return (POSITIVE_ACK);
5171 }
5172
5173 static int smctr_set_error_timer_value(struct net_device *dev,
5174 MAC_SUB_VECTOR *rsv)
5175 {
5176 __u16 err_tval;
5177 int err;
5178
5179 if(rsv->svl != S_ERROR_TIMER_VALUE)
5180 return (E_SUB_VECTOR_LENGTH_ERROR);
5181
5182 err_tval = (rsv->svv[0] << 8 | rsv->svv[1])*10;
5183
5184 smctr_issue_write_word_cmd(dev, RW_TER_THRESHOLD, &err_tval);
5185
5186 if((err = smctr_wait_cmd(dev)))
5187 return (err);
5188
5189 return (POSITIVE_ACK);
5190 }
5191
5192 static int smctr_set_frame_forward(struct net_device *dev,
5193 MAC_SUB_VECTOR *rsv, __u8 dc_sc)
5194 {
5195 if((rsv->svl < 2) || (rsv->svl > S_FRAME_FORWARD))
5196 return (E_SUB_VECTOR_LENGTH_ERROR);
5197
5198 if((dc_sc & DC_MASK) != DC_CRS)
5199 {
5200 if(rsv->svl >= 2 && rsv->svl < 20)
5201 return (E_TRANSMIT_FORWARD_INVALID);
5202
5203 if((rsv->svv[0] != 0) || (rsv->svv[1] != 0))
5204 return (E_TRANSMIT_FORWARD_INVALID);
5205 }
5206
5207 return (POSITIVE_ACK);
5208 }
5209
5210 static int smctr_set_local_ring_num(struct net_device *dev,
5211 MAC_SUB_VECTOR *rsv)
5212 {
5213 struct net_local *tp = (struct net_local *)dev->priv;
5214
5215 if(rsv->svl != S_LOCAL_RING_NUMBER)
5216 return (E_SUB_VECTOR_LENGTH_ERROR);
5217
5218 if(tp->ptr_local_ring_num)
5219 *(__u16 *)(tp->ptr_local_ring_num)
5220 = (rsv->svv[0] << 8 | rsv->svv[1]);
5221
5222 return (POSITIVE_ACK);
5223 }
5224
5225 static unsigned short smctr_set_ctrl_attention(struct net_device *dev)
5226 {
5227 struct net_local *tp = (struct net_local *)dev->priv;
5228 int ioaddr = dev->base_addr;
5229
5230 if(tp->bic_type == BIC_585_CHIP)
5231 outb((tp->trc_mask | HWR_CA), ioaddr + HWR);
5232 else
5233 {
5234 outb((tp->trc_mask | CSR_CA), ioaddr + CSR);
5235 outb(tp->trc_mask, ioaddr + CSR);
5236 }
5237
5238 return (0);
5239 }
5240
5241 static void smctr_set_multicast_list(struct net_device *dev)
5242 {
5243 if(smctr_debug > 10)
5244 printk("%s: smctr_set_multicast_list\n", dev->name);
5245
5246 return;
5247 }
5248
5249 static int smctr_set_page(struct net_device *dev, __u8 *buf)
5250 {
5251 struct net_local *tp = (struct net_local *)dev->priv;
5252 __u8 amask;
5253 __u32 tptr;
5254
5255 tptr = (__u32)buf - (__u32)tp->ram_access;
5256 amask = (__u8)((tptr & PR_PAGE_MASK) >> 8);
5257 outb(amask, dev->base_addr + PR);
5258
5259 return (0);
5260 }
5261
5262 static int smctr_set_phy_drop(struct net_device *dev, MAC_SUB_VECTOR *rsv)
5263 {
5264 int err;
5265
5266 if(rsv->svl != S_PHYSICAL_DROP)
5267 return (E_SUB_VECTOR_LENGTH_ERROR);
5268
5269 smctr_issue_write_byte_cmd(dev, RW_PHYSICAL_DROP_NUMBER, &rsv->svv[0]);
5270 if((err = smctr_wait_cmd(dev)))
5271 return (err);
5272
5273 return (POSITIVE_ACK);
5274 }
5275
5276 /* Reset the ring speed to the opposite of what it was. This auto-pilot
5277 * mode requires a complete reset and re-init of the adapter.
5278 */
5279 static int smctr_set_ring_speed(struct net_device *dev)
5280 {
5281 struct net_local *tp = (struct net_local *)dev->priv;
5282 int err;
5283
5284 if(tp->media_type == MEDIA_UTP_16)
5285 tp->media_type = MEDIA_UTP_4;
5286 else
5287 tp->media_type = MEDIA_UTP_16;
5288
5289 smctr_enable_16bit(dev);
5290
5291 /* Re-Initialize adapter's internal registers */
5292 smctr_reset_adapter(dev);
5293
5294 if((err = smctr_init_card_real(dev)))
5295 return (err);
5296
5297 smctr_enable_bic_int(dev);
5298
5299 if((err = smctr_issue_enable_int_cmd(dev, TRC_INTERRUPT_ENABLE_MASK)))
5300 return (err);
5301
5302 smctr_disable_16bit(dev);
5303
5304 return (0);
5305 }
5306
5307 static int smctr_set_rx_look_ahead(struct net_device *dev)
5308 {
5309 struct net_local *tp = (struct net_local *)dev->priv;
5310 __u16 sword, rword;
5311
5312 if(smctr_debug > 10)
5313 printk("%s: smctr_set_rx_look_ahead_flag\n", dev->name);
5314
5315 tp->adapter_flags &= ~(FORCED_16BIT_MODE);
5316 tp->adapter_flags |= RX_VALID_LOOKAHEAD;
5317
5318 if(tp->adapter_bus == BUS_ISA16_TYPE)
5319 {
5320 sword = *((__u16 *)(tp->ram_access));
5321 *((__u16 *)(tp->ram_access)) = 0x1234;
5322
5323 smctr_disable_16bit(dev);
5324 rword = *((__u16 *)(tp->ram_access));
5325 smctr_enable_16bit(dev);
5326
5327 if(rword != 0x1234)
5328 tp->adapter_flags |= FORCED_16BIT_MODE;
5329
5330 *((__u16 *)(tp->ram_access)) = sword;
5331 }
5332
5333 return (0);
5334 }
5335
5336 static int smctr_set_trc_reset(int ioaddr)
5337 {
5338 __u8 r;
5339
5340 r = inb(ioaddr + MSR);
5341 outb(MSR_RST | r, ioaddr + MSR);
5342
5343 return (0);
5344 }
5345
5346 /*
5347 * This function can be called if the adapter is busy or not.
5348 */
5349 static int smctr_setup_single_cmd(struct net_device *dev,
5350 __u16 command, __u16 subcommand)
5351 {
5352 struct net_local *tp = (struct net_local *)dev->priv;
5353 unsigned int err;
5354
5355 if(smctr_debug > 10)
5356 printk("%s: smctr_setup_single_cmd\n", dev->name);
5357
5358 if((err = smctr_wait_while_cbusy(dev)))
5359 return (err);
5360
5361 if((err = (unsigned int)smctr_wait_cmd(dev)))
5362 return (err);
5363
5364 tp->acb_head->cmd_done_status = 0;
5365 tp->acb_head->cmd = command;
5366 tp->acb_head->subcmd = subcommand;
5367
5368 err = smctr_issue_resume_acb_cmd(dev);
5369
5370 return (err);
5371 }
5372
5373 /*
5374 * This function can not be called with the adapter busy.
5375 */
5376 static int smctr_setup_single_cmd_w_data(struct net_device *dev,
5377 __u16 command, __u16 subcommand)
5378 {
5379 struct net_local *tp = (struct net_local *)dev->priv;
5380
5381 tp->acb_head->cmd_done_status = ACB_COMMAND_NOT_DONE;
5382 tp->acb_head->cmd = command;
5383 tp->acb_head->subcmd = subcommand;
5384 tp->acb_head->data_offset_lo
5385 = (__u16)TRC_POINTER(tp->misc_command_data);
5386
5387 return(smctr_issue_resume_acb_cmd(dev));
5388 }
5389
5390 static char *smctr_malloc(struct net_device *dev, __u16 size)
5391 {
5392 struct net_local *tp = (struct net_local *)dev->priv;
5393 char *m;
5394
5395 m = (char *)(tp->ram_access + tp->sh_mem_used);
5396 tp->sh_mem_used += (__u32)size;
5397
5398 return (m);
5399 }
5400
5401 static int smctr_status_chg(struct net_device *dev)
5402 {
5403 struct net_local *tp = (struct net_local *)dev->priv;
5404
5405 if(smctr_debug > 10)
5406 printk("%s: smctr_status_chg\n", dev->name);
5407
5408 switch(tp->status)
5409 {
5410 case OPEN:
5411 break;
5412
5413 case CLOSED:
5414 break;
5415
5416 /* Interrupt driven open() completion. XXX */
5417 case INITIALIZED:
5418 tp->group_address_0 = 0;
5419 tp->group_address[0] = 0;
5420 tp->group_address[1] = 0;
5421 tp->functional_address_0 = 0;
5422 tp->functional_address[0] = 0;
5423 tp->functional_address[1] = 0;
5424 smctr_open_tr(dev);
5425 break;
5426
5427 default:
5428 printk(KERN_INFO "%s: status change unknown %x\n",
5429 dev->name, tp->status);
5430 break;
5431 }
5432
5433 return (0);
5434 }
5435
5436 static int smctr_trc_send_packet(struct net_device *dev, FCBlock *fcb,
5437 __u16 queue)
5438 {
5439 struct net_local *tp = (struct net_local *)dev->priv;
5440 int err = 0;
5441
5442 if(smctr_debug > 10)
5443 printk("%s: smctr_trc_send_packet\n", dev->name);
5444
5445 fcb->info = FCB_CHAIN_END | FCB_ENABLE_TFS;
5446 if(tp->num_tx_fcbs[queue] != 1)
5447 fcb->back_ptr->info = FCB_INTERRUPT_ENABLE | FCB_ENABLE_TFS;
5448
5449 if(tp->tx_queue_status[queue] == NOT_TRANSMITING)
5450 {
5451 tp->tx_queue_status[queue] = TRANSMITING;
5452 err = smctr_issue_resume_tx_fcb_cmd(dev, queue);
5453 }
5454
5455 return (err);
5456 }
5457
5458 static __u16 smctr_tx_complete(struct net_device *dev, __u16 queue)
5459 {
5460 struct net_local *tp = (struct net_local *)dev->priv;
5461 __u16 status, err = 0;
5462 int cstatus;
5463
5464 if(smctr_debug > 10)
5465 printk("%s: smctr_tx_complete\n", dev->name);
5466
5467 while((status = tp->tx_fcb_end[queue]->frame_status) != SUCCESS)
5468 {
5469 if(status & 0x7e00 )
5470 {
5471 err = HARDWARE_FAILED;
5472 break;
5473 }
5474
5475 if((err = smctr_update_tx_chain(dev, tp->tx_fcb_end[queue],
5476 queue)) != SUCCESS)
5477 break;
5478
5479 smctr_disable_16bit(dev);
5480
5481 if(tp->mode_bits & UMAC)
5482 {
5483 if(!(status & (FCB_TX_STATUS_AR1 | FCB_TX_STATUS_AR2)))
5484 cstatus = NO_SUCH_DESTINATION;
5485 else
5486 {
5487 if(!(status & (FCB_TX_STATUS_CR1 | FCB_TX_STATUS_CR2)))
5488 cstatus = DEST_OUT_OF_RESOURCES;
5489 else
5490 {
5491 if(status & FCB_TX_STATUS_E)
5492 cstatus = MAX_COLLISIONS;
5493 else
5494 cstatus = SUCCESS;
5495 }
5496 }
5497 }
5498 else
5499 cstatus = SUCCESS;
5500
5501 if(queue == BUG_QUEUE)
5502 err = SUCCESS;
5503
5504 smctr_enable_16bit(dev);
5505 if(err != SUCCESS)
5506 break;
5507 }
5508
5509 return (err);
5510 }
5511
5512 static unsigned short smctr_tx_move_frame(struct net_device *dev,
5513 struct sk_buff *skb, __u8 *pbuff, unsigned int bytes)
5514 {
5515 struct net_local *tp = (struct net_local *)dev->priv;
5516 unsigned int ram_usable;
5517 __u32 flen, len, offset = 0;
5518 __u8 *frag, *page;
5519
5520 if(smctr_debug > 10)
5521 printk("%s: smctr_tx_move_frame\n", dev->name);
5522
5523 ram_usable = ((unsigned int)tp->ram_usable) << 10;
5524 frag = skb->data;
5525 flen = skb->len;
5526
5527 while(flen > 0 && bytes > 0)
5528 {
5529 smctr_set_page(dev, pbuff);
5530
5531 offset = SMC_PAGE_OFFSET(pbuff);
5532
5533 if(offset + flen > ram_usable)
5534 len = ram_usable - offset;
5535 else
5536 len = flen;
5537
5538 if(len > bytes)
5539 len = bytes;
5540
5541 page = (char *) (offset + tp->ram_access);
5542 memcpy(page, frag, len);
5543
5544 flen -=len;
5545 bytes -= len;
5546 frag += len;
5547 pbuff += len;
5548 }
5549
5550 return (0);
5551 }
5552
5553 /* Update the error statistic counters for this adapter. */
5554 static int smctr_update_err_stats(struct net_device *dev)
5555 {
5556 struct net_local *tp = (struct net_local *)dev->priv;
5557 struct tr_statistics *tstat = &tp->MacStat;
5558
5559 if(tstat->internal_errors)
5560 tstat->internal_errors
5561 += *(tp->misc_command_data + 0) & 0x00ff;
5562
5563 if(tstat->line_errors)
5564 tstat->line_errors += *(tp->misc_command_data + 0) >> 8;
5565
5566 if(tstat->A_C_errors)
5567 tstat->A_C_errors += *(tp->misc_command_data + 1) & 0x00ff;
5568
5569 if(tstat->burst_errors)
5570 tstat->burst_errors += *(tp->misc_command_data + 1) >> 8;
5571
5572 if(tstat->abort_delimiters)
5573 tstat->abort_delimiters += *(tp->misc_command_data + 2) >> 8;
5574
5575 if(tstat->recv_congest_count)
5576 tstat->recv_congest_count
5577 += *(tp->misc_command_data + 3) & 0x00ff;
5578
5579 if(tstat->lost_frames)
5580 tstat->lost_frames
5581 += *(tp->misc_command_data + 3) >> 8;
5582
5583 if(tstat->frequency_errors)
5584 tstat->frequency_errors += *(tp->misc_command_data + 4) & 0x00ff;
5585
5586 if(tstat->frame_copied_errors)
5587 tstat->frame_copied_errors
5588 += *(tp->misc_command_data + 4) >> 8;
5589
5590 if(tstat->token_errors)
5591 tstat->token_errors += *(tp->misc_command_data + 5) >> 8;
5592
5593 return (0);
5594 }
5595
5596 static int smctr_update_rx_chain(struct net_device *dev, __u16 queue)
5597 {
5598 struct net_local *tp = (struct net_local *)dev->priv;
5599 FCBlock *fcb;
5600 BDBlock *bdb;
5601 __u16 size, len;
5602
5603 fcb = tp->rx_fcb_curr[queue];
5604 len = fcb->frame_length;
5605
5606 fcb->frame_status = 0;
5607 fcb->info = FCB_CHAIN_END;
5608 fcb->back_ptr->info = FCB_WARNING;
5609
5610 tp->rx_fcb_curr[queue] = tp->rx_fcb_curr[queue]->next_ptr;
5611
5612 /* update RX BDBs */
5613 size = (len >> RX_BDB_SIZE_SHIFT);
5614 if(len & RX_DATA_BUFFER_SIZE_MASK)
5615 size += sizeof(BDBlock);
5616 size &= (~RX_BDB_SIZE_MASK);
5617
5618 /* check if wrap around */
5619 bdb = (BDBlock *)((__u32)(tp->rx_bdb_curr[queue]) + (__u32)(size));
5620 if((__u32)bdb >= (__u32)tp->rx_bdb_end[queue])
5621 {
5622 bdb = (BDBlock *)((__u32)(tp->rx_bdb_head[queue])
5623 + (__u32)(bdb) - (__u32)(tp->rx_bdb_end[queue]));
5624 }
5625
5626 bdb->back_ptr->info = BDB_CHAIN_END;
5627 tp->rx_bdb_curr[queue]->back_ptr->info = BDB_NOT_CHAIN_END;
5628 tp->rx_bdb_curr[queue] = bdb;
5629
5630 return (0);
5631 }
5632
5633 static int smctr_update_tx_chain(struct net_device *dev, FCBlock *fcb,
5634 __u16 queue)
5635 {
5636 struct net_local *tp = (struct net_local *)dev->priv;
5637
5638 if(smctr_debug > 20)
5639 printk("smctr_update_tx_chain\n");
5640
5641 if(tp->num_tx_fcbs_used[queue] <= 0)
5642 return (HARDWARE_FAILED);
5643 else
5644 {
5645 if(tp->tx_buff_used[queue] < fcb->memory_alloc)
5646 {
5647 tp->tx_buff_used[queue] = 0;
5648 return (HARDWARE_FAILED);
5649 }
5650
5651 tp->tx_buff_used[queue] -= fcb->memory_alloc;
5652
5653 /* if all transmit buffer are cleared
5654 * need to set the tx_buff_curr[] to tx_buff_head[]
5655 * otherwise, tx buffer will be segregate and cannot
5656 * accomodate and buffer greater than (curr - head) and
5657 * (end - curr) since we do not allow wrap around allocation.
5658 */
5659 if(tp->tx_buff_used[queue] == 0)
5660 tp->tx_buff_curr[queue] = tp->tx_buff_head[queue];
5661
5662 tp->num_tx_fcbs_used[queue]--;
5663 fcb->frame_status = 0;
5664 tp->tx_fcb_end[queue] = fcb->next_ptr;
5665 netif_wake_queue(dev);
5666 return (0);
5667 }
5668 }
5669
5670 static int smctr_wait_cmd(struct net_device *dev)
5671 {
5672 struct net_local *tp = (struct net_local *)dev->priv;
5673 unsigned int loop_count = 0x20000;
5674
5675 if(smctr_debug > 10)
5676 printk("%s: smctr_wait_cmd\n", dev->name);
5677
5678 while(loop_count)
5679 {
5680 if(tp->acb_head->cmd_done_status & ACB_COMMAND_DONE)
5681 break;
5682 udelay(1);
5683 loop_count--;
5684 }
5685
5686 if(loop_count == 0)
5687 return(HARDWARE_FAILED);
5688
5689 if(tp->acb_head->cmd_done_status & 0xff)
5690 return(HARDWARE_FAILED);
5691
5692 return (0);
5693 }
5694
5695 static int smctr_wait_while_cbusy(struct net_device *dev)
5696 {
5697 struct net_local *tp = (struct net_local *)dev->priv;
5698 unsigned int timeout = 0x20000;
5699 int ioaddr = dev->base_addr;
5700 __u8 r;
5701
5702 if(tp->bic_type == BIC_585_CHIP)
5703 {
5704 while(timeout)
5705 {
5706 r = inb(ioaddr + HWR);
5707 if((r & HWR_CBUSY) == 0)
5708 break;
5709 timeout--;
5710 }
5711 }
5712 else
5713 {
5714 while(timeout)
5715 {
5716 r = inb(ioaddr + CSR);
5717 if((r & CSR_CBUSY) == 0)
5718 break;
5719 timeout--;
5720 }
5721 }
5722
5723 if(timeout)
5724 return (0);
5725 else
5726 return (HARDWARE_FAILED);
5727 }
5728
5729 #ifdef MODULE
5730
5731 static struct net_device* dev_smctr[SMCTR_MAX_ADAPTERS];
5732 static int io[SMCTR_MAX_ADAPTERS];
5733 static int irq[SMCTR_MAX_ADAPTERS];
5734 static int mem[SMCTR_MAX_ADAPTERS];
5735
5736 MODULE_LICENSE("GPL");
5737
5738 MODULE_PARM(io, "1-" __MODULE_STRING(SMCTR_MAX_ADAPTERS) "i");
5739 MODULE_PARM(irq, "1-" __MODULE_STRING(SMCTR_MAX_ADAPTERS) "i");
5740 MODULE_PARM(mem, "1-" __MODULE_STRING(SMCTR_MAX_ADAPTERS) "i");
5741 MODULE_PARM(ringspeed, "1-" __MODULE_STRING(SMCTR_MAX_ADAPTERS) "i");
5742
5743 int init_module(void)
5744 {
5745 int i;
5746
5747 for(i = 0; i < SMCTR_MAX_ADAPTERS; i++)
5748 {
5749 irq[i] = 0;
5750 mem[i] = 0;
5751 dev_smctr[i] = NULL;
5752 dev_smctr[i] = init_trdev(dev_smctr[i], 0);
5753 if(dev_smctr[i] == NULL)
5754 return (-ENOMEM);
5755
5756 dev_smctr[i]->base_addr = io[i];
5757 dev_smctr[i]->irq = irq[i];
5758 dev_smctr[i]->mem_start = mem[i];
5759 dev_smctr[i]->init = &smctr_probe;
5760
5761 if(register_trdev(dev_smctr[i]) != 0)
5762 {
5763 kfree(dev_smctr[i]);
5764 dev_smctr[i] = NULL;
5765 if(i == 0)
5766 {
5767 printk("%s: register_trdev() returned (<0).\n",
5768 cardname);
5769 return (-EIO);
5770 }
5771 else
5772 return (0);
5773 }
5774 }
5775
5776 return (0);
5777 }
5778
5779 void cleanup_module(void)
5780 {
5781 int i;
5782
5783 for(i = 0; i < SMCTR_MAX_ADAPTERS; i++)
5784 {
5785 if(dev_smctr[i])
5786 {
5787 #ifdef CONFIG_MCA
5788 struct net_local *tp
5789 = (struct net_local *)dev_smctr[i]->priv;
5790 if(tp->slot_num)
5791 mca_mark_as_unused(tp->slot_num);
5792 #endif
5793 unregister_trdev(dev_smctr[i]);
5794 release_region(dev_smctr[i]->base_addr,
5795 SMCTR_IO_EXTENT);
5796 if(dev_smctr[i]->irq)
5797 free_irq(dev_smctr[i]->irq, dev_smctr[i]);
5798 if(dev_smctr[i]->priv)
5799 kfree(dev_smctr[i]->priv);
5800 kfree(dev_smctr[i]);
5801 dev_smctr[i] = NULL;
5802 }
5803 }
5804 }
5805 #endif /* MODULE */
5806