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