Gitiles
Code Review Sign In
review.shift-gmbh.com / SHIFTPHONES / kernel / common / afc8eb46c0ea2cab8bc28713b2e0614f015a7516 / . / drivers / net / tokenring / smctr.c
blob: cec282a6f62d40b7ded07994bff8e3e729503227 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]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>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]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
65static char version[] __initdata = KERN_INFO "smctr.c: v1.4 7/12/00 by jschlst@samba.org\n";
66static const char cardname[] = "smctr";
67
68
69#define SMCTR_IO_EXTENT 20
70
71#ifdef CONFIG_MCA_LEGACY
72static unsigned int smctr_posid = 0x6ec6;
73#endif
74
75static int ringspeed;
76
77/* SMC Name of the Adapter. */
78static char smctr_name[] = "SMC TokenCard";
Adrian Bunkde70b4c2005-05-02 03:46:43 +0200[diff] [blame]79static char *smctr_model = "Unknown";
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]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
87static 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 */
93static int smctr_alloc_shared_memory(struct net_device *dev);
94
95/* B */
96static int smctr_bypass_state(struct net_device *dev);
97
98/* C */
99static int smctr_checksum_firmware(struct net_device *dev);
100static int __init smctr_chk_isa(struct net_device *dev);
101static int smctr_chg_rx_mask(struct net_device *dev);
102static int smctr_clear_int(struct net_device *dev);
103static int smctr_clear_trc_reset(int ioaddr);
104static int smctr_close(struct net_device *dev);
105
106/* D */
107static int smctr_decode_firmware(struct net_device *dev);
108static int smctr_disable_16bit(struct net_device *dev);
109static int smctr_disable_adapter_ctrl_store(struct net_device *dev);
110static int smctr_disable_bic_int(struct net_device *dev);
111
112/* E */
113static int smctr_enable_16bit(struct net_device *dev);
114static int smctr_enable_adapter_ctrl_store(struct net_device *dev);
115static int smctr_enable_adapter_ram(struct net_device *dev);
116static int smctr_enable_bic_int(struct net_device *dev);
117
118/* G */
119static int __init smctr_get_boardid(struct net_device *dev, int mca);
120static int smctr_get_group_address(struct net_device *dev);
121static int smctr_get_functional_address(struct net_device *dev);
122static unsigned int smctr_get_num_rx_bdbs(struct net_device *dev);
123static int smctr_get_physical_drop_number(struct net_device *dev);
124static __u8 *smctr_get_rx_pointer(struct net_device *dev, short queue);
125static int smctr_get_station_id(struct net_device *dev);
126static struct net_device_stats *smctr_get_stats(struct net_device *dev);
127static FCBlock *smctr_get_tx_fcb(struct net_device *dev, __u16 queue,
128 __u16 bytes_count);
129static int smctr_get_upstream_neighbor_addr(struct net_device *dev);
130
131/* H */
132static int smctr_hardware_send_packet(struct net_device *dev,
133 struct net_local *tp);
134/* I */
135static int smctr_init_acbs(struct net_device *dev);
136static int smctr_init_adapter(struct net_device *dev);
137static int smctr_init_card_real(struct net_device *dev);
138static int smctr_init_rx_bdbs(struct net_device *dev);
139static int smctr_init_rx_fcbs(struct net_device *dev);
140static int smctr_init_shared_memory(struct net_device *dev);
141static int smctr_init_tx_bdbs(struct net_device *dev);
142static int smctr_init_tx_fcbs(struct net_device *dev);
143static int smctr_internal_self_test(struct net_device *dev);
David Howells7d12e782006-10-05 14:55:46 +0100[diff] [blame]144static irqreturn_t smctr_interrupt(int irq, void *dev_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]145static int smctr_issue_enable_int_cmd(struct net_device *dev,
146 __u16 interrupt_enable_mask);
147static int smctr_issue_int_ack(struct net_device *dev, __u16 iack_code,
148 __u16 ibits);
149static int smctr_issue_init_timers_cmd(struct net_device *dev);
150static int smctr_issue_init_txrx_cmd(struct net_device *dev);
151static int smctr_issue_insert_cmd(struct net_device *dev);
152static int smctr_issue_read_ring_status_cmd(struct net_device *dev);
153static int smctr_issue_read_word_cmd(struct net_device *dev, __u16 aword_cnt);
154static int smctr_issue_remove_cmd(struct net_device *dev);
155static int smctr_issue_resume_acb_cmd(struct net_device *dev);
156static int smctr_issue_resume_rx_bdb_cmd(struct net_device *dev, __u16 queue);
157static int smctr_issue_resume_rx_fcb_cmd(struct net_device *dev, __u16 queue);
158static int smctr_issue_resume_tx_fcb_cmd(struct net_device *dev, __u16 queue);
159static int smctr_issue_test_internal_rom_cmd(struct net_device *dev);
160static int smctr_issue_test_hic_cmd(struct net_device *dev);
161static int smctr_issue_test_mac_reg_cmd(struct net_device *dev);
162static int smctr_issue_trc_loopback_cmd(struct net_device *dev);
163static int smctr_issue_tri_loopback_cmd(struct net_device *dev);
164static int smctr_issue_write_byte_cmd(struct net_device *dev,
165 short aword_cnt, void *byte);
166static int smctr_issue_write_word_cmd(struct net_device *dev,
167 short aword_cnt, void *word);
168
169/* J */
170static int smctr_join_complete_state(struct net_device *dev);
171
172/* L */
173static int smctr_link_tx_fcbs_to_bdbs(struct net_device *dev);
174static int smctr_load_firmware(struct net_device *dev);
175static int smctr_load_node_addr(struct net_device *dev);
176static int smctr_lobe_media_test(struct net_device *dev);
177static int smctr_lobe_media_test_cmd(struct net_device *dev);
178static int smctr_lobe_media_test_state(struct net_device *dev);
179
180/* M */
181static int smctr_make_8025_hdr(struct net_device *dev,
182 MAC_HEADER *rmf, MAC_HEADER *tmf, __u16 ac_fc);
183static int smctr_make_access_pri(struct net_device *dev,
184 MAC_SUB_VECTOR *tsv);
185static int smctr_make_addr_mod(struct net_device *dev, MAC_SUB_VECTOR *tsv);
186static int smctr_make_auth_funct_class(struct net_device *dev,
187 MAC_SUB_VECTOR *tsv);
188static int smctr_make_corr(struct net_device *dev,
189 MAC_SUB_VECTOR *tsv, __u16 correlator);
190static int smctr_make_funct_addr(struct net_device *dev,
191 MAC_SUB_VECTOR *tsv);
192static int smctr_make_group_addr(struct net_device *dev,
193 MAC_SUB_VECTOR *tsv);
194static int smctr_make_phy_drop_num(struct net_device *dev,
195 MAC_SUB_VECTOR *tsv);
196static int smctr_make_product_id(struct net_device *dev, MAC_SUB_VECTOR *tsv);
197static int smctr_make_station_id(struct net_device *dev, MAC_SUB_VECTOR *tsv);
198static int smctr_make_ring_station_status(struct net_device *dev,
199 MAC_SUB_VECTOR *tsv);
200static int smctr_make_ring_station_version(struct net_device *dev,
201 MAC_SUB_VECTOR *tsv);
202static int smctr_make_tx_status_code(struct net_device *dev,
203 MAC_SUB_VECTOR *tsv, __u16 tx_fstatus);
204static int smctr_make_upstream_neighbor_addr(struct net_device *dev,
205 MAC_SUB_VECTOR *tsv);
206static int smctr_make_wrap_data(struct net_device *dev,
207 MAC_SUB_VECTOR *tsv);
208
209/* O */
210static int smctr_open(struct net_device *dev);
211static int smctr_open_tr(struct net_device *dev);
212
213/* P */
214struct net_device *smctr_probe(int unit);
215static int __init smctr_probe1(struct net_device *dev, int ioaddr);
216static int smctr_process_rx_packet(MAC_HEADER *rmf, __u16 size,
217 struct net_device *dev, __u16 rx_status);
218
219/* R */
220static int smctr_ram_memory_test(struct net_device *dev);
221static int smctr_rcv_chg_param(struct net_device *dev, MAC_HEADER *rmf,
222 __u16 *correlator);
223static int smctr_rcv_init(struct net_device *dev, MAC_HEADER *rmf,
224 __u16 *correlator);
225static int smctr_rcv_tx_forward(struct net_device *dev, MAC_HEADER *rmf);
226static int smctr_rcv_rq_addr_state_attch(struct net_device *dev,
227 MAC_HEADER *rmf, __u16 *correlator);
228static int smctr_rcv_unknown(struct net_device *dev, MAC_HEADER *rmf,
229 __u16 *correlator);
230static int smctr_reset_adapter(struct net_device *dev);
231static int smctr_restart_tx_chain(struct net_device *dev, short queue);
232static int smctr_ring_status_chg(struct net_device *dev);
233static int smctr_rx_frame(struct net_device *dev);
234
235/* S */
236static int smctr_send_dat(struct net_device *dev);
237static int smctr_send_packet(struct sk_buff *skb, struct net_device *dev);
238static int smctr_send_lobe_media_test(struct net_device *dev);
239static int smctr_send_rpt_addr(struct net_device *dev, MAC_HEADER *rmf,
240 __u16 correlator);
241static int smctr_send_rpt_attch(struct net_device *dev, MAC_HEADER *rmf,
242 __u16 correlator);
243static int smctr_send_rpt_state(struct net_device *dev, MAC_HEADER *rmf,
244 __u16 correlator);
245static int smctr_send_rpt_tx_forward(struct net_device *dev,
246 MAC_HEADER *rmf, __u16 tx_fstatus);
247static int smctr_send_rsp(struct net_device *dev, MAC_HEADER *rmf,
248 __u16 rcode, __u16 correlator);
249static int smctr_send_rq_init(struct net_device *dev);
250static int smctr_send_tx_forward(struct net_device *dev, MAC_HEADER *rmf,
251 __u16 *tx_fstatus);
252static int smctr_set_auth_access_pri(struct net_device *dev,
253 MAC_SUB_VECTOR *rsv);
254static int smctr_set_auth_funct_class(struct net_device *dev,
255 MAC_SUB_VECTOR *rsv);
256static int smctr_set_corr(struct net_device *dev, MAC_SUB_VECTOR *rsv,
257 __u16 *correlator);
258static int smctr_set_error_timer_value(struct net_device *dev,
259 MAC_SUB_VECTOR *rsv);
260static int smctr_set_frame_forward(struct net_device *dev,
261 MAC_SUB_VECTOR *rsv, __u8 dc_sc);
262static int smctr_set_local_ring_num(struct net_device *dev,
263 MAC_SUB_VECTOR *rsv);
264static unsigned short smctr_set_ctrl_attention(struct net_device *dev);
265static void smctr_set_multicast_list(struct net_device *dev);
266static int smctr_set_page(struct net_device *dev, __u8 *buf);
267static int smctr_set_phy_drop(struct net_device *dev,
268 MAC_SUB_VECTOR *rsv);
269static int smctr_set_ring_speed(struct net_device *dev);
270static int smctr_set_rx_look_ahead(struct net_device *dev);
271static int smctr_set_trc_reset(int ioaddr);
272static int smctr_setup_single_cmd(struct net_device *dev,
273 __u16 command, __u16 subcommand);
274static int smctr_setup_single_cmd_w_data(struct net_device *dev,
275 __u16 command, __u16 subcommand);
276static char *smctr_malloc(struct net_device *dev, __u16 size);
277static int smctr_status_chg(struct net_device *dev);
278
279/* T */
280static void smctr_timeout(struct net_device *dev);
281static int smctr_trc_send_packet(struct net_device *dev, FCBlock *fcb,
282 __u16 queue);
283static __u16 smctr_tx_complete(struct net_device *dev, __u16 queue);
284static unsigned short smctr_tx_move_frame(struct net_device *dev,
285 struct sk_buff *skb, __u8 *pbuff, unsigned int bytes);
286
287/* U */
288static int smctr_update_err_stats(struct net_device *dev);
289static int smctr_update_rx_chain(struct net_device *dev, __u16 queue);
290static int smctr_update_tx_chain(struct net_device *dev, FCBlock *fcb,
291 __u16 queue);
292
293/* W */
294static int smctr_wait_cmd(struct net_device *dev);
295static 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 */
327static 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. */
442static 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
454static 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
479static 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 }
Thomas Gleixner1fb9df52006-07-01 19:29:39 -0700[diff] [blame]534 if (request_irq(dev->irq, smctr_interrupt, IRQF_SHARED, smctr_name, dev)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]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
631static 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
694static 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
703static 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 */
716static 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
752static 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
812static 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 */
823static 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
837static 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
849static 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 */
869static 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
886static 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
900static 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
926static 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
Thomas Gleixner1fb9df52006-07-01 19:29:39 -0700[diff] [blame]1064 if (request_irq(dev->irq, smctr_interrupt, IRQF_SHARED, smctr_name, dev))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]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
1149out2:
1150 release_region(ioaddr, SMCTR_IO_EXTENT);
1151out:
1152 return err;
1153}
1154
1155static 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
1255static 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
1262static 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 */
1273static 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
1351static 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
1358static __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
1371static 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 */
1382static 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
1389static 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
1453static 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
1460static 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
1513static 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
1557static 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
1640static 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
1716static 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
1768static 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
1818static 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
1876static 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
1906static 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
1945static 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 */
David Howells7d12e782006-10-05 14:55:46 +0100[diff] [blame]1983static irqreturn_t smctr_interrupt(int irq, void *dev_id)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]1993 ioaddr = dev->base_addr;
1994 tp = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]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
2463static 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
2480static 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
2496static 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
2653static 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
2700static 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
2709static 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
2725static 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
2741static 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
2757static 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
2775static 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
2795static 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
2817static 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
2835static 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
2845static 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
2855static 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
2865static 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
2875static 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
2885static 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
2909static 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
2930static 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
2940static 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
2964static 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
3031static 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 */
3064static 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
3139static 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
3164static 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
3174static 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
3223static 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
3236static 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
3247static 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
3261static 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
3273static 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
3291static 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
3316static 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
3335static 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
3348static 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
3369static 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
3385static 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
3411static 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
3425static 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
3447static 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 */
3463static 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. */
3478static 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
3565out:
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 */
3574struct 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;
3611out1:
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);
3620out:
3621 free_netdev(dev);
3622 return ERR_PTR(err);
3623}
3624
3625
3626static 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
3684out:
3685 return err;
3686}
3687
3688static 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 memcpy(skb->data, 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->dev = dev;
3900 skb->protocol = tr_type_trans(skb, dev);
3901 netif_rx(skb);
3902 dev->last_rx = jiffies;
3903 err = 0;
3904 }
3905
3906 return (err);
3907}
3908
3909/* Adapter RAM test. Incremental word ODD boundary data test. */
3910static int smctr_ram_memory_test(struct net_device *dev)
3911{
3912 struct net_local *tp = netdev_priv(dev);
3913 __u16 page, pages_of_ram, start_pattern = 0, word_pattern = 0,
3914 word_read = 0, err_word = 0, err_pattern = 0;
3915 unsigned int err_offset;
3916 __u32 j, pword;
3917 __u8 err = 0;
3918
3919 if(smctr_debug > 10)
3920 printk(KERN_DEBUG "%s: smctr_ram_memory_test\n", dev->name);
3921
3922 start_pattern = 0x0001;
3923 pages_of_ram = tp->ram_size / tp->ram_usable;
3924 pword = tp->ram_access;
3925
3926 /* Incremental word ODD boundary test. */
3927 for(page = 0; (page < pages_of_ram) && (~err);
3928 page++, start_pattern += 0x8000)
3929 {
3930 smctr_set_page(dev, (__u8 *)(tp->ram_access
3931 + (page * tp->ram_usable * 1024) + 1));
3932 word_pattern = start_pattern;
3933
3934 for(j = 1; j < (__u32)(tp->ram_usable * 1024) - 1; j += 2)
3935 *(__u16 *)(pword + j) = word_pattern++;
3936
3937 word_pattern = start_pattern;
3938
3939 for(j = 1; j < (__u32)(tp->ram_usable * 1024) - 1
3940 && (~err); j += 2, word_pattern++)
3941 {
3942 word_read = *(__u16 *)(pword + j);
3943 if(word_read != word_pattern)
3944 {
3945 err = (__u8)1;
3946 err_offset = j;
3947 err_word = word_read;
3948 err_pattern = word_pattern;
3949 return (RAM_TEST_FAILED);
3950 }
3951 }
3952 }
3953
3954 /* Zero out memory. */
3955 for(page = 0; page < pages_of_ram && (~err); page++)
3956 {
3957 smctr_set_page(dev, (__u8 *)(tp->ram_access
3958 + (page * tp->ram_usable * 1024)));
3959 word_pattern = 0;
3960
3961 for(j = 0; j < (__u32)tp->ram_usable * 1024; j +=2)
3962 *(__u16 *)(pword + j) = word_pattern;
3963
3964 for(j =0; j < (__u32)tp->ram_usable * 1024
3965 && (~err); j += 2)
3966 {
3967 word_read = *(__u16 *)(pword + j);
3968 if(word_read != word_pattern)
3969 {
3970 err = (__u8)1;
3971 err_offset = j;
3972 err_word = word_read;
3973 err_pattern = word_pattern;
3974 return (RAM_TEST_FAILED);
3975 }
3976 }
3977 }
3978
3979 smctr_set_page(dev, (__u8 *)tp->ram_access);
3980
3981 return (0);
3982}
3983
3984static int smctr_rcv_chg_param(struct net_device *dev, MAC_HEADER *rmf,
3985 __u16 *correlator)
3986{
3987 MAC_SUB_VECTOR *rsv;
3988 signed short vlen;
3989 __u16 rcode = POSITIVE_ACK;
3990 unsigned int svectors = F_NO_SUB_VECTORS_FOUND;
3991
3992 /* This Frame can only come from a CRS */
3993 if((rmf->dc_sc & SC_MASK) != SC_CRS)
3994 return(E_INAPPROPRIATE_SOURCE_CLASS);
3995
3996 /* Remove MVID Length from total length. */
3997 vlen = (signed short)rmf->vl - 4;
3998
3999 /* Point to First SVID */
4000 rsv = (MAC_SUB_VECTOR *)((__u32)rmf + sizeof(MAC_HEADER));
4001
4002 /* Search for Appropriate SVID's. */
4003 while((vlen > 0) && (rcode == POSITIVE_ACK))
4004 {
4005 switch(rsv->svi)
4006 {
4007 case CORRELATOR:
4008 svectors |= F_CORRELATOR;
4009 rcode = smctr_set_corr(dev, rsv, correlator);
4010 break;
4011
4012 case LOCAL_RING_NUMBER:
4013 svectors |= F_LOCAL_RING_NUMBER;
4014 rcode = smctr_set_local_ring_num(dev, rsv);
4015 break;
4016
4017 case ASSIGN_PHYSICAL_DROP:
4018 svectors |= F_ASSIGN_PHYSICAL_DROP;
4019 rcode = smctr_set_phy_drop(dev, rsv);
4020 break;
4021
4022 case ERROR_TIMER_VALUE:
4023 svectors |= F_ERROR_TIMER_VALUE;
4024 rcode = smctr_set_error_timer_value(dev, rsv);
4025 break;
4026
4027 case AUTHORIZED_FUNCTION_CLASS:
4028 svectors |= F_AUTHORIZED_FUNCTION_CLASS;
4029 rcode = smctr_set_auth_funct_class(dev, rsv);
4030 break;
4031
4032 case AUTHORIZED_ACCESS_PRIORITY:
4033 svectors |= F_AUTHORIZED_ACCESS_PRIORITY;
4034 rcode = smctr_set_auth_access_pri(dev, rsv);
4035 break;
4036
4037 default:
4038 rcode = E_SUB_VECTOR_UNKNOWN;
4039 break;
4040 }
4041
4042 /* Let Sender Know if SUM of SV length's is
4043 * larger then length in MVID length field
4044 */
4045 if((vlen -= rsv->svl) < 0)
4046 rcode = E_VECTOR_LENGTH_ERROR;
4047
4048 rsv = (MAC_SUB_VECTOR *)((__u32)rsv + rsv->svl);
4049 }
4050
4051 if(rcode == POSITIVE_ACK)
4052 {
4053 /* Let Sender Know if MVID length field
4054 * is larger then SUM of SV length's
4055 */
4056 if(vlen != 0)
4057 rcode = E_VECTOR_LENGTH_ERROR;
4058 else
4059 {
4060 /* Let Sender Know if Expected SVID Missing */
4061 if((svectors & R_CHG_PARM) ^ R_CHG_PARM)
4062 rcode = E_MISSING_SUB_VECTOR;
4063 }
4064 }
4065
4066 return (rcode);
4067}
4068
4069static int smctr_rcv_init(struct net_device *dev, MAC_HEADER *rmf,
4070 __u16 *correlator)
4071{
4072 MAC_SUB_VECTOR *rsv;
4073 signed short vlen;
4074 __u16 rcode = POSITIVE_ACK;
4075 unsigned int svectors = F_NO_SUB_VECTORS_FOUND;
4076
4077 /* This Frame can only come from a RPS */
4078 if((rmf->dc_sc & SC_MASK) != SC_RPS)
4079 return (E_INAPPROPRIATE_SOURCE_CLASS);
4080
4081 /* Remove MVID Length from total length. */
4082 vlen = (signed short)rmf->vl - 4;
4083
4084 /* Point to First SVID */
4085 rsv = (MAC_SUB_VECTOR *)((__u32)rmf + sizeof(MAC_HEADER));
4086
4087 /* Search for Appropriate SVID's */
4088 while((vlen > 0) && (rcode == POSITIVE_ACK))
4089 {
4090 switch(rsv->svi)
4091 {
4092 case CORRELATOR:
4093 svectors |= F_CORRELATOR;
4094 rcode = smctr_set_corr(dev, rsv, correlator);
4095 break;
4096
4097 case LOCAL_RING_NUMBER:
4098 svectors |= F_LOCAL_RING_NUMBER;
4099 rcode = smctr_set_local_ring_num(dev, rsv);
4100 break;
4101
4102 case ASSIGN_PHYSICAL_DROP:
4103 svectors |= F_ASSIGN_PHYSICAL_DROP;
4104 rcode = smctr_set_phy_drop(dev, rsv);
4105 break;
4106
4107 case ERROR_TIMER_VALUE:
4108 svectors |= F_ERROR_TIMER_VALUE;
4109 rcode = smctr_set_error_timer_value(dev, rsv);
4110 break;
4111
4112 default:
4113 rcode = E_SUB_VECTOR_UNKNOWN;
4114 break;
4115 }
4116
4117 /* Let Sender Know if SUM of SV length's is
4118 * larger then length in MVID length field
4119 */
4120 if((vlen -= rsv->svl) < 0)
4121 rcode = E_VECTOR_LENGTH_ERROR;
4122
4123 rsv = (MAC_SUB_VECTOR *)((__u32)rsv + rsv->svl);
4124 }
4125
4126 if(rcode == POSITIVE_ACK)
4127 {
4128 /* Let Sender Know if MVID length field
4129 * is larger then SUM of SV length's
4130 */
4131 if(vlen != 0)
4132 rcode = E_VECTOR_LENGTH_ERROR;
4133 else
4134 {
4135 /* Let Sender Know if Expected SV Missing */
4136 if((svectors & R_INIT) ^ R_INIT)
4137 rcode = E_MISSING_SUB_VECTOR;
4138 }
4139 }
4140
4141 return (rcode);
4142}
4143
4144static int smctr_rcv_tx_forward(struct net_device *dev, MAC_HEADER *rmf)
4145{
4146 MAC_SUB_VECTOR *rsv;
4147 signed short vlen;
4148 __u16 rcode = POSITIVE_ACK;
4149 unsigned int svectors = F_NO_SUB_VECTORS_FOUND;
4150
4151 /* This Frame can only come from a CRS */
4152 if((rmf->dc_sc & SC_MASK) != SC_CRS)
4153 return (E_INAPPROPRIATE_SOURCE_CLASS);
4154
4155 /* Remove MVID Length from total length */
4156 vlen = (signed short)rmf->vl - 4;
4157
4158 /* Point to First SVID */
4159 rsv = (MAC_SUB_VECTOR *)((__u32)rmf + sizeof(MAC_HEADER));
4160
4161 /* Search for Appropriate SVID's */
4162 while((vlen > 0) && (rcode == POSITIVE_ACK))
4163 {
4164 switch(rsv->svi)
4165 {
4166 case FRAME_FORWARD:
4167 svectors |= F_FRAME_FORWARD;
4168 rcode = smctr_set_frame_forward(dev, rsv,
4169 rmf->dc_sc);
4170 break;
4171
4172 default:
4173 rcode = E_SUB_VECTOR_UNKNOWN;
4174 break;
4175 }
4176
4177 /* Let Sender Know if SUM of SV length's is
4178 * larger then length in MVID length field
4179 */
4180 if((vlen -= rsv->svl) < 0)
4181 rcode = E_VECTOR_LENGTH_ERROR;
4182
4183 rsv = (MAC_SUB_VECTOR *)((__u32)rsv + rsv->svl);
4184 }
4185
4186 if(rcode == POSITIVE_ACK)
4187 {
4188 /* Let Sender Know if MVID length field
4189 * is larger then SUM of SV length's
4190 */
4191 if(vlen != 0)
4192 rcode = E_VECTOR_LENGTH_ERROR;
4193 else
4194 {
4195 /* Let Sender Know if Expected SV Missing */
4196 if((svectors & R_TX_FORWARD) ^ R_TX_FORWARD)
4197 rcode = E_MISSING_SUB_VECTOR;
4198 }
4199 }
4200
4201 return (rcode);
4202}
4203
4204static int smctr_rcv_rq_addr_state_attch(struct net_device *dev,
4205 MAC_HEADER *rmf, __u16 *correlator)
4206{
4207 MAC_SUB_VECTOR *rsv;
4208 signed short vlen;
4209 __u16 rcode = POSITIVE_ACK;
4210 unsigned int svectors = F_NO_SUB_VECTORS_FOUND;
4211
4212 /* Remove MVID Length from total length */
4213 vlen = (signed short)rmf->vl - 4;
4214
4215 /* Point to First SVID */
4216 rsv = (MAC_SUB_VECTOR *)((__u32)rmf + sizeof(MAC_HEADER));
4217
4218 /* Search for Appropriate SVID's */
4219 while((vlen > 0) && (rcode == POSITIVE_ACK))
4220 {
4221 switch(rsv->svi)
4222 {
4223 case CORRELATOR:
4224 svectors |= F_CORRELATOR;
4225 rcode = smctr_set_corr(dev, rsv, correlator);
4226 break;
4227
4228 default:
4229 rcode = E_SUB_VECTOR_UNKNOWN;
4230 break;
4231 }
4232
4233 /* Let Sender Know if SUM of SV length's is
4234 * larger then length in MVID length field
4235 */
4236 if((vlen -= rsv->svl) < 0)
4237 rcode = E_VECTOR_LENGTH_ERROR;
4238
4239 rsv = (MAC_SUB_VECTOR *)((__u32)rsv + rsv->svl);
4240 }
4241
4242 if(rcode == POSITIVE_ACK)
4243 {
4244 /* Let Sender Know if MVID length field
4245 * is larger then SUM of SV length's
4246 */
4247 if(vlen != 0)
4248 rcode = E_VECTOR_LENGTH_ERROR;
4249 else
4250 {
4251 /* Let Sender Know if Expected SVID Missing */
4252 if((svectors & R_RQ_ATTCH_STATE_ADDR)
4253 ^ R_RQ_ATTCH_STATE_ADDR)
4254 rcode = E_MISSING_SUB_VECTOR;
4255 }
4256 }
4257
4258 return (rcode);
4259}
4260
4261static int smctr_rcv_unknown(struct net_device *dev, MAC_HEADER *rmf,
4262 __u16 *correlator)
4263{
4264 MAC_SUB_VECTOR *rsv;
4265 signed short vlen;
4266
4267 *correlator = 0;
4268
4269 /* Remove MVID Length from total length */
4270 vlen = (signed short)rmf->vl - 4;
4271
4272 /* Point to First SVID */
4273 rsv = (MAC_SUB_VECTOR *)((__u32)rmf + sizeof(MAC_HEADER));
4274
4275 /* Search for CORRELATOR for RSP to UNKNOWN */
4276 while((vlen > 0) && (*correlator == 0))
4277 {
4278 switch(rsv->svi)
4279 {
4280 case CORRELATOR:
4281 smctr_set_corr(dev, rsv, correlator);
4282 break;
4283
4284 default:
4285 break;
4286 }
4287
4288 vlen -= rsv->svl;
4289 rsv = (MAC_SUB_VECTOR *)((__u32)rsv + rsv->svl);
4290 }
4291
4292 return (E_UNRECOGNIZED_VECTOR_ID);
4293}
4294
4295/*
4296 * Reset the 825 NIC and exit w:
4297 * 1. The NIC reset cleared (non-reset state), halted and un-initialized.
4298 * 2. TINT masked.
4299 * 3. CBUSY masked.
4300 * 4. TINT clear.
4301 * 5. CBUSY clear.
4302 */
4303static int smctr_reset_adapter(struct net_device *dev)
4304{
4305 struct net_local *tp = netdev_priv(dev);
4306 int ioaddr = dev->base_addr;
4307
4308 /* Reseting the NIC will put it in a halted and un-initialized state. */ smctr_set_trc_reset(ioaddr);
4309 mdelay(200); /* ~2 ms */
4310
4311 smctr_clear_trc_reset(ioaddr);
4312 mdelay(200); /* ~2 ms */
4313
4314 /* Remove any latched interrupts that occurred prior to reseting the
4315 * adapter or possibily caused by line glitches due to the reset.
4316 */
4317 outb(tp->trc_mask | CSR_CLRTINT | CSR_CLRCBUSY, ioaddr + CSR);
4318
4319 return (0);
4320}
4321
4322static int smctr_restart_tx_chain(struct net_device *dev, short queue)
4323{
4324 struct net_local *tp = netdev_priv(dev);
4325 int err = 0;
4326
4327 if(smctr_debug > 10)
4328 printk(KERN_DEBUG "%s: smctr_restart_tx_chain\n", dev->name);
4329
4330 if(tp->num_tx_fcbs_used[queue] != 0
4331 && tp->tx_queue_status[queue] == NOT_TRANSMITING)
4332 {
4333 tp->tx_queue_status[queue] = TRANSMITING;
4334 err = smctr_issue_resume_tx_fcb_cmd(dev, queue);
4335 }
4336
4337 return (err);
4338}
4339
4340static int smctr_ring_status_chg(struct net_device *dev)
4341{
4342 struct net_local *tp = netdev_priv(dev);
4343
4344 if(smctr_debug > 10)
4345 printk(KERN_DEBUG "%s: smctr_ring_status_chg\n", dev->name);
4346
4347 /* Check for ring_status_flag: whenever MONITOR_STATE_BIT
4348 * Bit is set, check value of monitor_state, only then we
4349 * enable and start transmit/receive timeout (if and only
4350 * if it is MS_ACTIVE_MONITOR_STATE or MS_STANDBY_MONITOR_STATE)
4351 */
4352 if(tp->ring_status_flags == MONITOR_STATE_CHANGED)
4353 {
4354 if((tp->monitor_state == MS_ACTIVE_MONITOR_STATE)
4355 || (tp->monitor_state == MS_STANDBY_MONITOR_STATE))
4356 {
4357 tp->monitor_state_ready = 1;
4358 }
4359 else
4360 {
4361 /* if adapter is NOT in either active monitor
4362 * or standby monitor state => Disable
4363 * transmit/receive timeout.
4364 */
4365 tp->monitor_state_ready = 0;
4366
4367 /* Ring speed problem, switching to auto mode. */
4368 if(tp->monitor_state == MS_MONITOR_FSM_INACTIVE
4369 && !tp->cleanup)
4370 {
4371 printk(KERN_INFO "%s: Incorrect ring speed switching.\n",
4372 dev->name);
4373 smctr_set_ring_speed(dev);
4374 }
4375 }
4376 }
4377
4378 if(!(tp->ring_status_flags & RING_STATUS_CHANGED))
4379 return (0);
4380
4381 switch(tp->ring_status)
4382 {
4383 case RING_RECOVERY:
4384 printk(KERN_INFO "%s: Ring Recovery\n", dev->name);
4385 tp->current_ring_status |= RING_RECOVERY;
4386 break;
4387
4388 case SINGLE_STATION:
4389 printk(KERN_INFO "%s: Single Statinon\n", dev->name);
4390 tp->current_ring_status |= SINGLE_STATION;
4391 break;
4392
4393 case COUNTER_OVERFLOW:
4394 printk(KERN_INFO "%s: Counter Overflow\n", dev->name);
4395 tp->current_ring_status |= COUNTER_OVERFLOW;
4396 break;
4397
4398 case REMOVE_RECEIVED:
4399 printk(KERN_INFO "%s: Remove Received\n", dev->name);
4400 tp->current_ring_status |= REMOVE_RECEIVED;
4401 break;
4402
4403 case AUTO_REMOVAL_ERROR:
4404 printk(KERN_INFO "%s: Auto Remove Error\n", dev->name);
4405 tp->current_ring_status |= AUTO_REMOVAL_ERROR;
4406 break;
4407
4408 case LOBE_WIRE_FAULT:
4409 printk(KERN_INFO "%s: Lobe Wire Fault\n", dev->name);
4410 tp->current_ring_status |= LOBE_WIRE_FAULT;
4411 break;
4412
4413 case TRANSMIT_BEACON:
4414 printk(KERN_INFO "%s: Transmit Beacon\n", dev->name);
4415 tp->current_ring_status |= TRANSMIT_BEACON;
4416 break;
4417
4418 case SOFT_ERROR:
4419 printk(KERN_INFO "%s: Soft Error\n", dev->name);
4420 tp->current_ring_status |= SOFT_ERROR;
4421 break;
4422
4423 case HARD_ERROR:
4424 printk(KERN_INFO "%s: Hard Error\n", dev->name);
4425 tp->current_ring_status |= HARD_ERROR;
4426 break;
4427
4428 case SIGNAL_LOSS:
4429 printk(KERN_INFO "%s: Signal Loss\n", dev->name);
4430 tp->current_ring_status |= SIGNAL_LOSS;
4431 break;
4432
4433 default:
4434 printk(KERN_INFO "%s: Unknown ring status change\n",
4435 dev->name);
4436 break;
4437 }
4438
4439 return (0);
4440}
4441
4442static int smctr_rx_frame(struct net_device *dev)
4443{
4444 struct net_local *tp = netdev_priv(dev);
4445 __u16 queue, status, rx_size, err = 0;
4446 __u8 *pbuff;
4447
4448 if(smctr_debug > 10)
4449 printk(KERN_DEBUG "%s: smctr_rx_frame\n", dev->name);
4450
4451 queue = tp->receive_queue_number;
4452
4453 while((status = tp->rx_fcb_curr[queue]->frame_status) != SUCCESS)
4454 {
4455 err = HARDWARE_FAILED;
4456
4457 if(((status & 0x007f) == 0)
4458 || ((tp->receive_mask & ACCEPT_ERR_PACKETS) != 0))
4459 {
4460 /* frame length less the CRC (4 bytes) + FS (1 byte) */
4461 rx_size = tp->rx_fcb_curr[queue]->frame_length - 5;
4462
4463 pbuff = smctr_get_rx_pointer(dev, queue);
4464
4465 smctr_set_page(dev, pbuff);
4466 smctr_disable_16bit(dev);
4467
4468 /* pbuff points to addr within one page */
4469 pbuff = (__u8 *)PAGE_POINTER(pbuff);
4470
4471 if(queue == NON_MAC_QUEUE)
4472 {
4473 struct sk_buff *skb;
4474
4475 skb = dev_alloc_skb(rx_size);
4476 if (skb) {
4477 skb_put(skb, rx_size);
4478
4479 memcpy(skb->data, pbuff, rx_size);
4480
4481 /* Update Counters */
4482 tp->MacStat.rx_packets++;
4483 tp->MacStat.rx_bytes += skb->len;
4484
4485 /* Kick the packet on up. */
4486 skb->dev = dev;
4487 skb->protocol = tr_type_trans(skb, dev);
4488 netif_rx(skb);
4489 dev->last_rx = jiffies;
4490 } else {
4491 }
4492 }
4493 else
4494 smctr_process_rx_packet((MAC_HEADER *)pbuff,
4495 rx_size, dev, status);
4496 }
4497
4498 smctr_enable_16bit(dev);
4499 smctr_set_page(dev, (__u8 *)tp->ram_access);
4500 smctr_update_rx_chain(dev, queue);
4501
4502 if(err != SUCCESS)
4503 break;
4504 }
4505
4506 return (err);
4507}
4508
4509static int smctr_send_dat(struct net_device *dev)
4510{
4511 struct net_local *tp = netdev_priv(dev);
4512 unsigned int i, err;
4513 MAC_HEADER *tmf;
4514 FCBlock *fcb;
4515
4516 if(smctr_debug > 10)
4517 printk(KERN_DEBUG "%s: smctr_send_dat\n", dev->name);
4518
4519 if((fcb = smctr_get_tx_fcb(dev, MAC_QUEUE,
4520 sizeof(MAC_HEADER))) == (FCBlock *)(-1L))
4521 {
4522 return (OUT_OF_RESOURCES);
4523 }
4524
4525 /* Initialize DAT Data Fields. */
4526 tmf = (MAC_HEADER *)fcb->bdb_ptr->data_block_ptr;
4527 tmf->ac = MSB(AC_FC_DAT);
4528 tmf->fc = LSB(AC_FC_DAT);
4529
4530 for(i = 0; i < 6; i++)
4531 {
4532 tmf->sa[i] = dev->dev_addr[i];
4533 tmf->da[i] = dev->dev_addr[i];
4534
4535 }
4536
4537 tmf->vc = DAT;
4538 tmf->dc_sc = DC_RS | SC_RS;
4539 tmf->vl = 4;
4540 tmf->vl = SWAP_BYTES(tmf->vl);
4541
4542 /* Start Transmit. */
4543 if((err = smctr_trc_send_packet(dev, fcb, MAC_QUEUE)))
4544 return (err);
4545
4546 /* Wait for Transmit to Complete */
4547 for(i = 0; i < 10000; i++)
4548 {
4549 if(fcb->frame_status & FCB_COMMAND_DONE)
4550 break;
4551 mdelay(1);
4552 }
4553
4554 /* Check if GOOD frame Tx'ed. */
4555 if(!(fcb->frame_status & FCB_COMMAND_DONE)
4556 || fcb->frame_status & (FCB_TX_STATUS_E | FCB_TX_AC_BITS))
4557 {
4558 return (INITIALIZE_FAILED);
4559 }
4560
4561 /* De-allocated Tx FCB and Frame Buffer
4562 * The FCB must be de-allocated manually if executing with
4563 * interrupts disabled, other wise the ISR (LM_Service_Events)
4564 * will de-allocate it when the interrupt occurs.
4565 */
4566 tp->tx_queue_status[MAC_QUEUE] = NOT_TRANSMITING;
4567 smctr_update_tx_chain(dev, fcb, MAC_QUEUE);
4568
4569 return (0);
4570}
4571
4572static void smctr_timeout(struct net_device *dev)
4573{
4574 /*
4575 * If we get here, some higher level has decided we are broken.
4576 * There should really be a "kick me" function call instead.
4577 *
4578 * Resetting the token ring adapter takes a long time so just
4579 * fake transmission time and go on trying. Our own timeout
4580 * routine is in sktr_timer_chk()
4581 */
4582 dev->trans_start = jiffies;
4583 netif_wake_queue(dev);
4584}
4585
4586/*
4587 * Gets skb from system, queues it and checks if it can be sent
4588 */
4589static int smctr_send_packet(struct sk_buff *skb, struct net_device *dev)
4590{
4591 struct net_local *tp = netdev_priv(dev);
4592
4593 if(smctr_debug > 10)
4594 printk(KERN_DEBUG "%s: smctr_send_packet\n", dev->name);
4595
4596 /*
4597 * Block a transmit overlap
4598 */
4599
4600 netif_stop_queue(dev);
4601
4602 if(tp->QueueSkb == 0)
4603 return (1); /* Return with tbusy set: queue full */
4604
4605 tp->QueueSkb--;
4606 skb_queue_tail(&tp->SendSkbQueue, skb);
4607 smctr_hardware_send_packet(dev, tp);
4608 if(tp->QueueSkb > 0)
4609 netif_wake_queue(dev);
4610
4611 return (0);
4612}
4613
4614static int smctr_send_lobe_media_test(struct net_device *dev)
4615{
4616 struct net_local *tp = netdev_priv(dev);
4617 MAC_SUB_VECTOR *tsv;
4618 MAC_HEADER *tmf;
4619 FCBlock *fcb;
4620 __u32 i;
4621 int err;
4622
4623 if(smctr_debug > 15)
4624 printk(KERN_DEBUG "%s: smctr_send_lobe_media_test\n", dev->name);
4625
4626 if((fcb = smctr_get_tx_fcb(dev, MAC_QUEUE, sizeof(struct trh_hdr)
4627 + S_WRAP_DATA + S_WRAP_DATA)) == (FCBlock *)(-1L))
4628 {
4629 return (OUT_OF_RESOURCES);
4630 }
4631
4632 /* Initialize DAT Data Fields. */
4633 tmf = (MAC_HEADER *)fcb->bdb_ptr->data_block_ptr;
4634 tmf->ac = MSB(AC_FC_LOBE_MEDIA_TEST);
4635 tmf->fc = LSB(AC_FC_LOBE_MEDIA_TEST);
4636
4637 for(i = 0; i < 6; i++)
4638 {
4639 tmf->da[i] = 0;
4640 tmf->sa[i] = dev->dev_addr[i];
4641 }
4642
4643 tmf->vc = LOBE_MEDIA_TEST;
4644 tmf->dc_sc = DC_RS | SC_RS;
4645 tmf->vl = 4;
4646
4647 tsv = (MAC_SUB_VECTOR *)((__u32)tmf + sizeof(MAC_HEADER));
4648 smctr_make_wrap_data(dev, tsv);
4649 tmf->vl += tsv->svl;
4650
4651 tsv = (MAC_SUB_VECTOR *)((__u32)tsv + tsv->svl);
4652 smctr_make_wrap_data(dev, tsv);
4653 tmf->vl += tsv->svl;
4654
4655 /* Start Transmit. */
4656 tmf->vl = SWAP_BYTES(tmf->vl);
4657 if((err = smctr_trc_send_packet(dev, fcb, MAC_QUEUE)))
4658 return (err);
4659
4660 /* Wait for Transmit to Complete. (10 ms). */
4661 for(i=0; i < 10000; i++)
4662 {
4663 if(fcb->frame_status & FCB_COMMAND_DONE)
4664 break;
4665 mdelay(1);
4666 }
4667
4668 /* Check if GOOD frame Tx'ed */
4669 if(!(fcb->frame_status & FCB_COMMAND_DONE)
4670 || fcb->frame_status & (FCB_TX_STATUS_E | FCB_TX_AC_BITS))
4671 {
4672 return (LOBE_MEDIA_TEST_FAILED);
4673 }
4674
4675 /* De-allocated Tx FCB and Frame Buffer
4676 * The FCB must be de-allocated manually if executing with
4677 * interrupts disabled, other wise the ISR (LM_Service_Events)
4678 * will de-allocate it when the interrupt occurs.
4679 */
4680 tp->tx_queue_status[MAC_QUEUE] = NOT_TRANSMITING;
4681 smctr_update_tx_chain(dev, fcb, MAC_QUEUE);
4682
4683 return (0);
4684}
4685
4686static int smctr_send_rpt_addr(struct net_device *dev, MAC_HEADER *rmf,
4687 __u16 correlator)
4688{
4689 MAC_HEADER *tmf;
4690 MAC_SUB_VECTOR *tsv;
4691 FCBlock *fcb;
4692
4693 if((fcb = smctr_get_tx_fcb(dev, MAC_QUEUE, sizeof(MAC_HEADER)
4694 + S_CORRELATOR + S_PHYSICAL_DROP + S_UPSTREAM_NEIGHBOR_ADDRESS
4695 + S_ADDRESS_MODIFER + S_GROUP_ADDRESS + S_FUNCTIONAL_ADDRESS))
4696 == (FCBlock *)(-1L))
4697 {
4698 return (0);
4699 }
4700
4701 tmf = (MAC_HEADER *)fcb->bdb_ptr->data_block_ptr;
4702 tmf->vc = RPT_ADDR;
4703 tmf->dc_sc = (rmf->dc_sc & SC_MASK) << 4;
4704 tmf->vl = 4;
4705
4706 smctr_make_8025_hdr(dev, rmf, tmf, AC_FC_RPT_ADDR);
4707
4708 tsv = (MAC_SUB_VECTOR *)((__u32)tmf + sizeof(MAC_HEADER));
4709 smctr_make_corr(dev, tsv, correlator);
4710
4711 tmf->vl += tsv->svl;
4712 tsv = (MAC_SUB_VECTOR *)((__u32)tsv + tsv->svl);
4713 smctr_make_phy_drop_num(dev, tsv);
4714
4715 tmf->vl += tsv->svl;
4716 tsv = (MAC_SUB_VECTOR *)((__u32)tsv + tsv->svl);
4717 smctr_make_upstream_neighbor_addr(dev, tsv);
4718
4719 tmf->vl += tsv->svl;
4720 tsv = (MAC_SUB_VECTOR *)((__u32)tsv + tsv->svl);
4721 smctr_make_addr_mod(dev, tsv);
4722
4723 tmf->vl += tsv->svl;
4724 tsv = (MAC_SUB_VECTOR *)((__u32)tsv + tsv->svl);
4725 smctr_make_group_addr(dev, tsv);
4726
4727 tmf->vl += tsv->svl;
4728 tsv = (MAC_SUB_VECTOR *)((__u32)tsv + tsv->svl);
4729 smctr_make_funct_addr(dev, tsv);
4730
4731 tmf->vl += tsv->svl;
4732
4733 /* Subtract out MVID and MVL which is
4734 * include in both vl and MAC_HEADER
4735 */
4736/* fcb->frame_length = tmf->vl + sizeof(MAC_HEADER) - 4;
4737 fcb->bdb_ptr->buffer_length = tmf->vl + sizeof(MAC_HEADER) - 4;
4738*/
4739 tmf->vl = SWAP_BYTES(tmf->vl);
4740
4741 return (smctr_trc_send_packet(dev, fcb, MAC_QUEUE));
4742}
4743
4744static int smctr_send_rpt_attch(struct net_device *dev, MAC_HEADER *rmf,
4745 __u16 correlator)
4746{
4747 MAC_HEADER *tmf;
4748 MAC_SUB_VECTOR *tsv;
4749 FCBlock *fcb;
4750
4751 if((fcb = smctr_get_tx_fcb(dev, MAC_QUEUE, sizeof(MAC_HEADER)
4752 + S_CORRELATOR + S_PRODUCT_INSTANCE_ID + S_FUNCTIONAL_ADDRESS
4753 + S_AUTHORIZED_FUNCTION_CLASS + S_AUTHORIZED_ACCESS_PRIORITY))
4754 == (FCBlock *)(-1L))
4755 {
4756 return (0);
4757 }
4758
4759 tmf = (MAC_HEADER *)fcb->bdb_ptr->data_block_ptr;
4760 tmf->vc = RPT_ATTCH;
4761 tmf->dc_sc = (rmf->dc_sc & SC_MASK) << 4;
4762 tmf->vl = 4;
4763
4764 smctr_make_8025_hdr(dev, rmf, tmf, AC_FC_RPT_ATTCH);
4765
4766 tsv = (MAC_SUB_VECTOR *)((__u32)tmf + sizeof(MAC_HEADER));
4767 smctr_make_corr(dev, tsv, correlator);
4768
4769 tmf->vl += tsv->svl;
4770 tsv = (MAC_SUB_VECTOR *)((__u32)tsv + tsv->svl);
4771 smctr_make_product_id(dev, tsv);
4772
4773 tmf->vl += tsv->svl;
4774 tsv = (MAC_SUB_VECTOR *)((__u32)tsv + tsv->svl);
4775 smctr_make_funct_addr(dev, tsv);
4776
4777 tmf->vl += tsv->svl;
4778 tsv = (MAC_SUB_VECTOR *)((__u32)tsv + tsv->svl);
4779 smctr_make_auth_funct_class(dev, tsv);
4780
4781 tmf->vl += tsv->svl;
4782 tsv = (MAC_SUB_VECTOR *)((__u32)tsv + tsv->svl);
4783 smctr_make_access_pri(dev, tsv);
4784
4785 tmf->vl += tsv->svl;
4786
4787 /* Subtract out MVID and MVL which is
4788 * include in both vl and MAC_HEADER
4789 */
4790/* fcb->frame_length = tmf->vl + sizeof(MAC_HEADER) - 4;
4791 fcb->bdb_ptr->buffer_length = tmf->vl + sizeof(MAC_HEADER) - 4;
4792*/
4793 tmf->vl = SWAP_BYTES(tmf->vl);
4794
4795 return (smctr_trc_send_packet(dev, fcb, MAC_QUEUE));
4796}
4797
4798static int smctr_send_rpt_state(struct net_device *dev, MAC_HEADER *rmf,
4799 __u16 correlator)
4800{
4801 MAC_HEADER *tmf;
4802 MAC_SUB_VECTOR *tsv;
4803 FCBlock *fcb;
4804
4805 if((fcb = smctr_get_tx_fcb(dev, MAC_QUEUE, sizeof(MAC_HEADER)
4806 + S_CORRELATOR + S_RING_STATION_VERSION_NUMBER
4807 + S_RING_STATION_STATUS + S_STATION_IDENTIFER))
4808 == (FCBlock *)(-1L))
4809 {
4810 return (0);
4811 }
4812
4813 tmf = (MAC_HEADER *)fcb->bdb_ptr->data_block_ptr;
4814 tmf->vc = RPT_STATE;
4815 tmf->dc_sc = (rmf->dc_sc & SC_MASK) << 4;
4816 tmf->vl = 4;
4817
4818 smctr_make_8025_hdr(dev, rmf, tmf, AC_FC_RPT_STATE);
4819
4820 tsv = (MAC_SUB_VECTOR *)((__u32)tmf + sizeof(MAC_HEADER));
4821 smctr_make_corr(dev, tsv, correlator);
4822
4823 tmf->vl += tsv->svl;
4824 tsv = (MAC_SUB_VECTOR *)((__u32)tsv + tsv->svl);
4825 smctr_make_ring_station_version(dev, tsv);
4826
4827 tmf->vl += tsv->svl;
4828 tsv = (MAC_SUB_VECTOR *)((__u32)tsv + tsv->svl);
4829 smctr_make_ring_station_status(dev, tsv);
4830
4831 tmf->vl += tsv->svl;
4832 tsv = (MAC_SUB_VECTOR *)((__u32)tsv + tsv->svl);
4833 smctr_make_station_id(dev, tsv);
4834
4835 tmf->vl += tsv->svl;
4836
4837 /* Subtract out MVID and MVL which is
4838 * include in both vl and MAC_HEADER
4839 */
4840/* fcb->frame_length = tmf->vl + sizeof(MAC_HEADER) - 4;
4841 fcb->bdb_ptr->buffer_length = tmf->vl + sizeof(MAC_HEADER) - 4;
4842*/
4843 tmf->vl = SWAP_BYTES(tmf->vl);
4844
4845 return (smctr_trc_send_packet(dev, fcb, MAC_QUEUE));
4846}
4847
4848static int smctr_send_rpt_tx_forward(struct net_device *dev,
4849 MAC_HEADER *rmf, __u16 tx_fstatus)
4850{
4851 MAC_HEADER *tmf;
4852 MAC_SUB_VECTOR *tsv;
4853 FCBlock *fcb;
4854
4855 if((fcb = smctr_get_tx_fcb(dev, MAC_QUEUE, sizeof(MAC_HEADER)
4856 + S_TRANSMIT_STATUS_CODE)) == (FCBlock *)(-1L))
4857 {
4858 return (0);
4859 }
4860
4861 tmf = (MAC_HEADER *)fcb->bdb_ptr->data_block_ptr;
4862 tmf->vc = RPT_TX_FORWARD;
4863 tmf->dc_sc = (rmf->dc_sc & SC_MASK) << 4;
4864 tmf->vl = 4;
4865
4866 smctr_make_8025_hdr(dev, rmf, tmf, AC_FC_RPT_TX_FORWARD);
4867
4868 tsv = (MAC_SUB_VECTOR *)((__u32)tmf + sizeof(MAC_HEADER));
4869 smctr_make_tx_status_code(dev, tsv, tx_fstatus);
4870
4871 tmf->vl += tsv->svl;
4872
4873 /* Subtract out MVID and MVL which is
4874 * include in both vl and MAC_HEADER
4875 */
4876/* fcb->frame_length = tmf->vl + sizeof(MAC_HEADER) - 4;
4877 fcb->bdb_ptr->buffer_length = tmf->vl + sizeof(MAC_HEADER) - 4;
4878*/
4879 tmf->vl = SWAP_BYTES(tmf->vl);
4880
4881 return(smctr_trc_send_packet(dev, fcb, MAC_QUEUE));
4882}
4883
4884static int smctr_send_rsp(struct net_device *dev, MAC_HEADER *rmf,
4885 __u16 rcode, __u16 correlator)
4886{
4887 MAC_HEADER *tmf;
4888 MAC_SUB_VECTOR *tsv;
4889 FCBlock *fcb;
4890
4891 if((fcb = smctr_get_tx_fcb(dev, MAC_QUEUE, sizeof(MAC_HEADER)
4892 + S_CORRELATOR + S_RESPONSE_CODE)) == (FCBlock *)(-1L))
4893 {
4894 return (0);
4895 }
4896
4897 tmf = (MAC_HEADER *)fcb->bdb_ptr->data_block_ptr;
4898 tmf->vc = RSP;
4899 tmf->dc_sc = (rmf->dc_sc & SC_MASK) << 4;
4900 tmf->vl = 4;
4901
4902 smctr_make_8025_hdr(dev, rmf, tmf, AC_FC_RSP);
4903
4904 tsv = (MAC_SUB_VECTOR *)((__u32)tmf + sizeof(MAC_HEADER));
4905 smctr_make_corr(dev, tsv, correlator);
4906
4907 return (0);
4908}
4909
4910static int smctr_send_rq_init(struct net_device *dev)
4911{
4912 struct net_local *tp = netdev_priv(dev);
4913 MAC_HEADER *tmf;
4914 MAC_SUB_VECTOR *tsv;
4915 FCBlock *fcb;
4916 unsigned int i, count = 0;
4917 __u16 fstatus;
4918 int err;
4919
4920 do {
4921 if(((fcb = smctr_get_tx_fcb(dev, MAC_QUEUE, sizeof(MAC_HEADER)
4922 + S_PRODUCT_INSTANCE_ID + S_UPSTREAM_NEIGHBOR_ADDRESS
4923 + S_RING_STATION_VERSION_NUMBER + S_ADDRESS_MODIFER))
4924 == (FCBlock *)(-1L)))
4925 {
4926 return (0);
4927 }
4928
4929 tmf = (MAC_HEADER *)fcb->bdb_ptr->data_block_ptr;
4930 tmf->vc = RQ_INIT;
4931 tmf->dc_sc = DC_RPS | SC_RS;
4932 tmf->vl = 4;
4933
4934 smctr_make_8025_hdr(dev, NULL, tmf, AC_FC_RQ_INIT);
4935
4936 tsv = (MAC_SUB_VECTOR *)((__u32)tmf + sizeof(MAC_HEADER));
4937 smctr_make_product_id(dev, tsv);
4938
4939 tmf->vl += tsv->svl;
4940 tsv = (MAC_SUB_VECTOR *)((__u32)tsv + tsv->svl);
4941 smctr_make_upstream_neighbor_addr(dev, tsv);
4942
4943 tmf->vl += tsv->svl;
4944 tsv = (MAC_SUB_VECTOR *)((__u32)tsv + tsv->svl);
4945 smctr_make_ring_station_version(dev, tsv);
4946
4947 tmf->vl += tsv->svl;
4948 tsv = (MAC_SUB_VECTOR *)((__u32)tsv + tsv->svl);
4949 smctr_make_addr_mod(dev, tsv);
4950
4951 tmf->vl += tsv->svl;
4952
4953 /* Subtract out MVID and MVL which is
4954 * include in both vl and MAC_HEADER
4955 */
4956/* fcb->frame_length = tmf->vl + sizeof(MAC_HEADER) - 4;
4957 fcb->bdb_ptr->buffer_length = tmf->vl + sizeof(MAC_HEADER) - 4;
4958*/
4959 tmf->vl = SWAP_BYTES(tmf->vl);
4960
4961 if((err = smctr_trc_send_packet(dev, fcb, MAC_QUEUE)))
4962 return (err);
4963
4964 /* Wait for Transmit to Complete */
4965 for(i = 0; i < 10000; i++)
4966 {
4967 if(fcb->frame_status & FCB_COMMAND_DONE)
4968 break;
4969 mdelay(1);
4970 }
4971
4972 /* Check if GOOD frame Tx'ed */
4973 fstatus = fcb->frame_status;
4974
4975 if(!(fstatus & FCB_COMMAND_DONE))
4976 return (HARDWARE_FAILED);
4977
4978 if(!(fstatus & FCB_TX_STATUS_E))
4979 count++;
4980
4981 /* De-allocated Tx FCB and Frame Buffer
4982 * The FCB must be de-allocated manually if executing with
4983 * interrupts disabled, other wise the ISR (LM_Service_Events)
4984 * will de-allocate it when the interrupt occurs.
4985 */
4986 tp->tx_queue_status[MAC_QUEUE] = NOT_TRANSMITING;
4987 smctr_update_tx_chain(dev, fcb, MAC_QUEUE);
4988 } while(count < 4 && ((fstatus & FCB_TX_AC_BITS) ^ FCB_TX_AC_BITS));
4989
4990 return (smctr_join_complete_state(dev));
4991}
4992
4993static int smctr_send_tx_forward(struct net_device *dev, MAC_HEADER *rmf,
4994 __u16 *tx_fstatus)
4995{
4996 struct net_local *tp = netdev_priv(dev);
4997 FCBlock *fcb;
4998 unsigned int i;
4999 int err;
5000
5001 /* Check if this is the END POINT of the Transmit Forward Chain. */
5002 if(rmf->vl <= 18)
5003 return (0);
5004
5005 /* Allocate Transmit FCB only by requesting 0 bytes
5006 * of data buffer.
5007 */
5008 if((fcb = smctr_get_tx_fcb(dev, MAC_QUEUE, 0)) == (FCBlock *)(-1L))
5009 return (0);
5010
5011 /* Set pointer to Transmit Frame Buffer to the data
5012 * portion of the received TX Forward frame, making
5013 * sure to skip over the Vector Code (vc) and Vector
5014 * length (vl).
5015 */
5016 fcb->bdb_ptr->trc_data_block_ptr = TRC_POINTER((__u32)rmf
5017 + sizeof(MAC_HEADER) + 2);
5018 fcb->bdb_ptr->data_block_ptr = (__u16 *)((__u32)rmf
5019 + sizeof(MAC_HEADER) + 2);
5020
5021 fcb->frame_length = rmf->vl - 4 - 2;
5022 fcb->bdb_ptr->buffer_length = rmf->vl - 4 - 2;
5023
5024 if((err = smctr_trc_send_packet(dev, fcb, MAC_QUEUE)))
5025 return (err);
5026
5027 /* Wait for Transmit to Complete */
5028 for(i = 0; i < 10000; i++)
5029 {
5030 if(fcb->frame_status & FCB_COMMAND_DONE)
5031 break;
5032 mdelay(1);
5033 }
5034
5035 /* Check if GOOD frame Tx'ed */
5036 if(!(fcb->frame_status & FCB_COMMAND_DONE))
5037 {
5038 if((err = smctr_issue_resume_tx_fcb_cmd(dev, MAC_QUEUE)))
5039 return (err);
5040
5041 for(i = 0; i < 10000; i++)
5042 {
5043 if(fcb->frame_status & FCB_COMMAND_DONE)
5044 break;
5045 mdelay(1);
5046 }
5047
5048 if(!(fcb->frame_status & FCB_COMMAND_DONE))
5049 return (HARDWARE_FAILED);
5050 }
5051
5052 *tx_fstatus = fcb->frame_status;
5053
5054 return (A_FRAME_WAS_FORWARDED);
5055}
5056
5057static int smctr_set_auth_access_pri(struct net_device *dev,
5058 MAC_SUB_VECTOR *rsv)
5059{
5060 struct net_local *tp = netdev_priv(dev);
5061
5062 if(rsv->svl != S_AUTHORIZED_ACCESS_PRIORITY)
5063 return (E_SUB_VECTOR_LENGTH_ERROR);
5064
5065 tp->authorized_access_priority = (rsv->svv[0] << 8 | rsv->svv[1]);
5066
5067 return (POSITIVE_ACK);
5068}
5069
5070static int smctr_set_auth_funct_class(struct net_device *dev,
5071 MAC_SUB_VECTOR *rsv)
5072{
5073 struct net_local *tp = netdev_priv(dev);
5074
5075 if(rsv->svl != S_AUTHORIZED_FUNCTION_CLASS)
5076 return (E_SUB_VECTOR_LENGTH_ERROR);
5077
5078 tp->authorized_function_classes = (rsv->svv[0] << 8 | rsv->svv[1]);
5079
5080 return (POSITIVE_ACK);
5081}
5082
5083static int smctr_set_corr(struct net_device *dev, MAC_SUB_VECTOR *rsv,
5084 __u16 *correlator)
5085{
5086 if(rsv->svl != S_CORRELATOR)
5087 return (E_SUB_VECTOR_LENGTH_ERROR);
5088
5089 *correlator = (rsv->svv[0] << 8 | rsv->svv[1]);
5090
5091 return (POSITIVE_ACK);
5092}
5093
5094static int smctr_set_error_timer_value(struct net_device *dev,
5095 MAC_SUB_VECTOR *rsv)
5096{
5097 __u16 err_tval;
5098 int err;
5099
5100 if(rsv->svl != S_ERROR_TIMER_VALUE)
5101 return (E_SUB_VECTOR_LENGTH_ERROR);
5102
5103 err_tval = (rsv->svv[0] << 8 | rsv->svv[1])*10;
5104
5105 smctr_issue_write_word_cmd(dev, RW_TER_THRESHOLD, &err_tval);
5106
5107 if((err = smctr_wait_cmd(dev)))
5108 return (err);
5109
5110 return (POSITIVE_ACK);
5111}
5112
5113static int smctr_set_frame_forward(struct net_device *dev,
5114 MAC_SUB_VECTOR *rsv, __u8 dc_sc)
5115{
5116 if((rsv->svl < 2) || (rsv->svl > S_FRAME_FORWARD))
5117 return (E_SUB_VECTOR_LENGTH_ERROR);
5118
5119 if((dc_sc & DC_MASK) != DC_CRS)
5120 {
5121 if(rsv->svl >= 2 && rsv->svl < 20)
5122 return (E_TRANSMIT_FORWARD_INVALID);
5123
5124 if((rsv->svv[0] != 0) || (rsv->svv[1] != 0))
5125 return (E_TRANSMIT_FORWARD_INVALID);
5126 }
5127
5128 return (POSITIVE_ACK);
5129}
5130
5131static int smctr_set_local_ring_num(struct net_device *dev,
5132 MAC_SUB_VECTOR *rsv)
5133{
5134 struct net_local *tp = netdev_priv(dev);
5135
5136 if(rsv->svl != S_LOCAL_RING_NUMBER)
5137 return (E_SUB_VECTOR_LENGTH_ERROR);
5138
5139 if(tp->ptr_local_ring_num)
5140 *(__u16 *)(tp->ptr_local_ring_num)
5141 = (rsv->svv[0] << 8 | rsv->svv[1]);
5142
5143 return (POSITIVE_ACK);
5144}
5145
5146static unsigned short smctr_set_ctrl_attention(struct net_device *dev)
5147{
5148 struct net_local *tp = netdev_priv(dev);
5149 int ioaddr = dev->base_addr;
5150
5151 if(tp->bic_type == BIC_585_CHIP)
5152 outb((tp->trc_mask | HWR_CA), ioaddr + HWR);
5153 else
5154 {
5155 outb((tp->trc_mask | CSR_CA), ioaddr + CSR);
5156 outb(tp->trc_mask, ioaddr + CSR);
5157 }
5158
5159 return (0);
5160}
5161
5162static void smctr_set_multicast_list(struct net_device *dev)
5163{
5164 if(smctr_debug > 10)
5165 printk(KERN_DEBUG "%s: smctr_set_multicast_list\n", dev->name);
5166
5167 return;
5168}
5169
5170static int smctr_set_page(struct net_device *dev, __u8 *buf)
5171{
5172 struct net_local *tp = netdev_priv(dev);
5173 __u8 amask;
5174 __u32 tptr;
5175
5176 tptr = (__u32)buf - (__u32)tp->ram_access;
5177 amask = (__u8)((tptr & PR_PAGE_MASK) >> 8);
5178 outb(amask, dev->base_addr + PR);
5179
5180 return (0);
5181}
5182
5183static int smctr_set_phy_drop(struct net_device *dev, MAC_SUB_VECTOR *rsv)
5184{
5185 int err;
5186
5187 if(rsv->svl != S_PHYSICAL_DROP)
5188 return (E_SUB_VECTOR_LENGTH_ERROR);
5189
5190 smctr_issue_write_byte_cmd(dev, RW_PHYSICAL_DROP_NUMBER, &rsv->svv[0]);
5191 if((err = smctr_wait_cmd(dev)))
5192 return (err);
5193
5194 return (POSITIVE_ACK);
5195}
5196
5197/* Reset the ring speed to the opposite of what it was. This auto-pilot
5198 * mode requires a complete reset and re-init of the adapter.
5199 */
5200static int smctr_set_ring_speed(struct net_device *dev)
5201{
5202 struct net_local *tp = netdev_priv(dev);
5203 int err;
5204
5205 if(tp->media_type == MEDIA_UTP_16)
5206 tp->media_type = MEDIA_UTP_4;
5207 else
5208 tp->media_type = MEDIA_UTP_16;
5209
5210 smctr_enable_16bit(dev);
5211
5212 /* Re-Initialize adapter's internal registers */
5213 smctr_reset_adapter(dev);
5214
5215 if((err = smctr_init_card_real(dev)))
5216 return (err);
5217
5218 smctr_enable_bic_int(dev);
5219
5220 if((err = smctr_issue_enable_int_cmd(dev, TRC_INTERRUPT_ENABLE_MASK)))
5221 return (err);
5222
5223 smctr_disable_16bit(dev);
5224
5225 return (0);
5226}
5227
5228static int smctr_set_rx_look_ahead(struct net_device *dev)
5229{
5230 struct net_local *tp = netdev_priv(dev);
5231 __u16 sword, rword;
5232
5233 if(smctr_debug > 10)
5234 printk(KERN_DEBUG "%s: smctr_set_rx_look_ahead_flag\n", dev->name);
5235
5236 tp->adapter_flags &= ~(FORCED_16BIT_MODE);
5237 tp->adapter_flags |= RX_VALID_LOOKAHEAD;
5238
5239 if(tp->adapter_bus == BUS_ISA16_TYPE)
5240 {
5241 sword = *((__u16 *)(tp->ram_access));
5242 *((__u16 *)(tp->ram_access)) = 0x1234;
5243
5244 smctr_disable_16bit(dev);
5245 rword = *((__u16 *)(tp->ram_access));
5246 smctr_enable_16bit(dev);
5247
5248 if(rword != 0x1234)
5249 tp->adapter_flags |= FORCED_16BIT_MODE;
5250
5251 *((__u16 *)(tp->ram_access)) = sword;
5252 }
5253
5254 return (0);
5255}
5256
5257static int smctr_set_trc_reset(int ioaddr)
5258{
5259 __u8 r;
5260
5261 r = inb(ioaddr + MSR);
5262 outb(MSR_RST | r, ioaddr + MSR);
5263
5264 return (0);
5265}
5266
5267/*
5268 * This function can be called if the adapter is busy or not.
5269 */
5270static int smctr_setup_single_cmd(struct net_device *dev,
5271 __u16 command, __u16 subcommand)
5272{
5273 struct net_local *tp = netdev_priv(dev);
5274 unsigned int err;
5275
5276 if(smctr_debug > 10)
5277 printk(KERN_DEBUG "%s: smctr_setup_single_cmd\n", dev->name);
5278
5279 if((err = smctr_wait_while_cbusy(dev)))
5280 return (err);
5281
5282 if((err = (unsigned int)smctr_wait_cmd(dev)))
5283 return (err);
5284
5285 tp->acb_head->cmd_done_status = 0;
5286 tp->acb_head->cmd = command;
5287 tp->acb_head->subcmd = subcommand;
5288
5289 err = smctr_issue_resume_acb_cmd(dev);
5290
5291 return (err);
5292}
5293
5294/*
5295 * This function can not be called with the adapter busy.
5296 */
5297static int smctr_setup_single_cmd_w_data(struct net_device *dev,
5298 __u16 command, __u16 subcommand)
5299{
5300 struct net_local *tp = netdev_priv(dev);
5301
5302 tp->acb_head->cmd_done_status = ACB_COMMAND_NOT_DONE;
5303 tp->acb_head->cmd = command;
5304 tp->acb_head->subcmd = subcommand;
5305 tp->acb_head->data_offset_lo
5306 = (__u16)TRC_POINTER(tp->misc_command_data);
5307
5308 return(smctr_issue_resume_acb_cmd(dev));
5309}
5310
5311static char *smctr_malloc(struct net_device *dev, __u16 size)
5312{
5313 struct net_local *tp = netdev_priv(dev);
5314 char *m;
5315
5316 m = (char *)(tp->ram_access + tp->sh_mem_used);
5317 tp->sh_mem_used += (__u32)size;
5318
5319 return (m);
5320}
5321
5322static int smctr_status_chg(struct net_device *dev)
5323{
5324 struct net_local *tp = netdev_priv(dev);
5325
5326 if(smctr_debug > 10)
5327 printk(KERN_DEBUG "%s: smctr_status_chg\n", dev->name);
5328
5329 switch(tp->status)
5330 {
5331 case OPEN:
5332 break;
5333
5334 case CLOSED:
5335 break;
5336
5337 /* Interrupt driven open() completion. XXX */
5338 case INITIALIZED:
5339 tp->group_address_0 = 0;
5340 tp->group_address[0] = 0;
5341 tp->group_address[1] = 0;
5342 tp->functional_address_0 = 0;
5343 tp->functional_address[0] = 0;
5344 tp->functional_address[1] = 0;
5345 smctr_open_tr(dev);
5346 break;
5347
5348 default:
5349 printk(KERN_INFO "%s: status change unknown %x\n",
5350 dev->name, tp->status);
5351 break;
5352 }
5353
5354 return (0);
5355}
5356
5357static int smctr_trc_send_packet(struct net_device *dev, FCBlock *fcb,
5358 __u16 queue)
5359{
5360 struct net_local *tp = netdev_priv(dev);
5361 int err = 0;
5362
5363 if(smctr_debug > 10)
5364 printk(KERN_DEBUG "%s: smctr_trc_send_packet\n", dev->name);
5365
5366 fcb->info = FCB_CHAIN_END | FCB_ENABLE_TFS;
5367 if(tp->num_tx_fcbs[queue] != 1)
5368 fcb->back_ptr->info = FCB_INTERRUPT_ENABLE | FCB_ENABLE_TFS;
5369
5370 if(tp->tx_queue_status[queue] == NOT_TRANSMITING)
5371 {
5372 tp->tx_queue_status[queue] = TRANSMITING;
5373 err = smctr_issue_resume_tx_fcb_cmd(dev, queue);
5374 }
5375
5376 return (err);
5377}
5378
5379static __u16 smctr_tx_complete(struct net_device *dev, __u16 queue)
5380{
5381 struct net_local *tp = netdev_priv(dev);
5382 __u16 status, err = 0;
5383 int cstatus;
5384
5385 if(smctr_debug > 10)
5386 printk(KERN_DEBUG "%s: smctr_tx_complete\n", dev->name);
5387
5388 while((status = tp->tx_fcb_end[queue]->frame_status) != SUCCESS)
5389 {
5390 if(status & 0x7e00 )
5391 {
5392 err = HARDWARE_FAILED;
5393 break;
5394 }
5395
5396 if((err = smctr_update_tx_chain(dev, tp->tx_fcb_end[queue],
5397 queue)) != SUCCESS)
5398 break;
5399
5400 smctr_disable_16bit(dev);
5401
5402 if(tp->mode_bits & UMAC)
5403 {
5404 if(!(status & (FCB_TX_STATUS_AR1 | FCB_TX_STATUS_AR2)))
5405 cstatus = NO_SUCH_DESTINATION;
5406 else
5407 {
5408 if(!(status & (FCB_TX_STATUS_CR1 | FCB_TX_STATUS_CR2)))
5409 cstatus = DEST_OUT_OF_RESOURCES;
5410 else
5411 {
5412 if(status & FCB_TX_STATUS_E)
5413 cstatus = MAX_COLLISIONS;
5414 else
5415 cstatus = SUCCESS;
5416 }
5417 }
5418 }
5419 else
5420 cstatus = SUCCESS;
5421
5422 if(queue == BUG_QUEUE)
5423 err = SUCCESS;
5424
5425 smctr_enable_16bit(dev);
5426 if(err != SUCCESS)
5427 break;
5428 }
5429
5430 return (err);
5431}
5432
5433static unsigned short smctr_tx_move_frame(struct net_device *dev,
5434 struct sk_buff *skb, __u8 *pbuff, unsigned int bytes)
5435{
5436 struct net_local *tp = netdev_priv(dev);
5437 unsigned int ram_usable;
5438 __u32 flen, len, offset = 0;
5439 __u8 *frag, *page;
5440
5441 if(smctr_debug > 10)
5442 printk(KERN_DEBUG "%s: smctr_tx_move_frame\n", dev->name);
5443
5444 ram_usable = ((unsigned int)tp->ram_usable) << 10;
5445 frag = skb->data;
5446 flen = skb->len;
5447
5448 while(flen > 0 && bytes > 0)
5449 {
5450 smctr_set_page(dev, pbuff);
5451
5452 offset = SMC_PAGE_OFFSET(pbuff);
5453
5454 if(offset + flen > ram_usable)
5455 len = ram_usable - offset;
5456 else
5457 len = flen;
5458
5459 if(len > bytes)
5460 len = bytes;
5461
5462 page = (char *) (offset + tp->ram_access);
5463 memcpy(page, frag, len);
5464
5465 flen -=len;
5466 bytes -= len;
5467 frag += len;
5468 pbuff += len;
5469 }
5470
5471 return (0);
5472}
5473
5474/* Update the error statistic counters for this adapter. */
5475static int smctr_update_err_stats(struct net_device *dev)
5476{
5477 struct net_local *tp = netdev_priv(dev);
5478 struct tr_statistics *tstat = &tp->MacStat;
5479
5480 if(tstat->internal_errors)
5481 tstat->internal_errors
5482 += *(tp->misc_command_data + 0) & 0x00ff;
5483
5484 if(tstat->line_errors)
5485 tstat->line_errors += *(tp->misc_command_data + 0) >> 8;
5486
5487 if(tstat->A_C_errors)
5488 tstat->A_C_errors += *(tp->misc_command_data + 1) & 0x00ff;
5489
5490 if(tstat->burst_errors)
5491 tstat->burst_errors += *(tp->misc_command_data + 1) >> 8;
5492
5493 if(tstat->abort_delimiters)
5494 tstat->abort_delimiters += *(tp->misc_command_data + 2) >> 8;
5495
5496 if(tstat->recv_congest_count)
5497 tstat->recv_congest_count
5498 += *(tp->misc_command_data + 3) & 0x00ff;
5499
5500 if(tstat->lost_frames)
5501 tstat->lost_frames
5502 += *(tp->misc_command_data + 3) >> 8;
5503
5504 if(tstat->frequency_errors)
5505 tstat->frequency_errors += *(tp->misc_command_data + 4) & 0x00ff;
5506
5507 if(tstat->frame_copied_errors)
5508 tstat->frame_copied_errors
5509 += *(tp->misc_command_data + 4) >> 8;
5510
5511 if(tstat->token_errors)
5512 tstat->token_errors += *(tp->misc_command_data + 5) >> 8;
5513
5514 return (0);
5515}
5516
5517static int smctr_update_rx_chain(struct net_device *dev, __u16 queue)
5518{
5519 struct net_local *tp = netdev_priv(dev);
5520 FCBlock *fcb;
5521 BDBlock *bdb;
5522 __u16 size, len;
5523
5524 fcb = tp->rx_fcb_curr[queue];
5525 len = fcb->frame_length;
5526
5527 fcb->frame_status = 0;
5528 fcb->info = FCB_CHAIN_END;
5529 fcb->back_ptr->info = FCB_WARNING;
5530
5531 tp->rx_fcb_curr[queue] = tp->rx_fcb_curr[queue]->next_ptr;
5532
5533 /* update RX BDBs */
5534 size = (len >> RX_BDB_SIZE_SHIFT);
5535 if(len & RX_DATA_BUFFER_SIZE_MASK)
5536 size += sizeof(BDBlock);
5537 size &= (~RX_BDB_SIZE_MASK);
5538
5539 /* check if wrap around */
5540 bdb = (BDBlock *)((__u32)(tp->rx_bdb_curr[queue]) + (__u32)(size));
5541 if((__u32)bdb >= (__u32)tp->rx_bdb_end[queue])
5542 {
5543 bdb = (BDBlock *)((__u32)(tp->rx_bdb_head[queue])
5544 + (__u32)(bdb) - (__u32)(tp->rx_bdb_end[queue]));
5545 }
5546
5547 bdb->back_ptr->info = BDB_CHAIN_END;
5548 tp->rx_bdb_curr[queue]->back_ptr->info = BDB_NOT_CHAIN_END;
5549 tp->rx_bdb_curr[queue] = bdb;
5550
5551 return (0);
5552}
5553
5554static int smctr_update_tx_chain(struct net_device *dev, FCBlock *fcb,
5555 __u16 queue)
5556{
5557 struct net_local *tp = netdev_priv(dev);
5558
5559 if(smctr_debug > 20)
5560 printk(KERN_DEBUG "smctr_update_tx_chain\n");
5561
5562 if(tp->num_tx_fcbs_used[queue] <= 0)
5563 return (HARDWARE_FAILED);
5564 else
5565 {
5566 if(tp->tx_buff_used[queue] < fcb->memory_alloc)
5567 {
5568 tp->tx_buff_used[queue] = 0;
5569 return (HARDWARE_FAILED);
5570 }
5571
5572 tp->tx_buff_used[queue] -= fcb->memory_alloc;
5573
5574 /* if all transmit buffer are cleared
5575 * need to set the tx_buff_curr[] to tx_buff_head[]
5576 * otherwise, tx buffer will be segregate and cannot
5577 * accommodate and buffer greater than (curr - head) and
5578 * (end - curr) since we do not allow wrap around allocation.
5579 */
5580 if(tp->tx_buff_used[queue] == 0)
5581 tp->tx_buff_curr[queue] = tp->tx_buff_head[queue];
5582
5583 tp->num_tx_fcbs_used[queue]--;
5584 fcb->frame_status = 0;
5585 tp->tx_fcb_end[queue] = fcb->next_ptr;
5586 netif_wake_queue(dev);
5587 return (0);
5588 }
5589}
5590
5591static int smctr_wait_cmd(struct net_device *dev)
5592{
5593 struct net_local *tp = netdev_priv(dev);
5594 unsigned int loop_count = 0x20000;
5595
5596 if(smctr_debug > 10)
5597 printk(KERN_DEBUG "%s: smctr_wait_cmd\n", dev->name);
5598
5599 while(loop_count)
5600 {
5601 if(tp->acb_head->cmd_done_status & ACB_COMMAND_DONE)
5602 break;
5603 udelay(1);
5604 loop_count--;
5605 }
5606
5607 if(loop_count == 0)
5608 return(HARDWARE_FAILED);
5609
5610 if(tp->acb_head->cmd_done_status & 0xff)
5611 return(HARDWARE_FAILED);
5612
5613 return (0);
5614}
5615
5616static int smctr_wait_while_cbusy(struct net_device *dev)
5617{
5618 struct net_local *tp = netdev_priv(dev);
5619 unsigned int timeout = 0x20000;
5620 int ioaddr = dev->base_addr;
5621 __u8 r;
5622
5623 if(tp->bic_type == BIC_585_CHIP)
5624 {
5625 while(timeout)
5626 {
5627 r = inb(ioaddr + HWR);
5628 if((r & HWR_CBUSY) == 0)
5629 break;
5630 timeout--;
5631 }
5632 }
5633 else
5634 {
5635 while(timeout)
5636 {
5637 r = inb(ioaddr + CSR);
5638 if((r & CSR_CBUSY) == 0)
5639 break;
5640 timeout--;
5641 }
5642 }
5643
5644 if(timeout)
5645 return (0);
5646 else
5647 return (HARDWARE_FAILED);
5648}
5649
5650#ifdef MODULE
5651
5652static struct net_device* dev_smctr[SMCTR_MAX_ADAPTERS];
5653static int io[SMCTR_MAX_ADAPTERS];
5654static int irq[SMCTR_MAX_ADAPTERS];
5655
5656MODULE_LICENSE("GPL");
5657
5658module_param_array(io, int, NULL, 0);
5659module_param_array(irq, int, NULL, 0);
5660module_param(ringspeed, int, 0);
5661
Andrew Mortondaca7cd2006-08-14 23:00:06 -0700[diff] [blame]5662static struct net_device * __init setup_card(int n)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]5663{
5664 struct net_device *dev = alloc_trdev(sizeof(struct net_local));
5665 int err;
5666
5667 if (!dev)
5668 return ERR_PTR(-ENOMEM);
5669
5670 dev->irq = irq[n];
5671 err = smctr_probe1(dev, io[n]);
5672 if (err)
5673 goto out;
5674
5675 err = register_netdev(dev);
5676 if (err)
5677 goto out1;
5678 return dev;
5679 out1:
5680#ifdef CONFIG_MCA_LEGACY
5681 { struct net_local *tp = netdev_priv(dev);
5682 if (tp->slot_num)
5683 mca_mark_as_unused(tp->slot_num);
5684 }
5685#endif
5686 release_region(dev->base_addr, SMCTR_IO_EXTENT);
5687 free_irq(dev->irq, dev);
5688out:
5689 free_netdev(dev);
5690 return ERR_PTR(err);
5691}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]5692
Andrew Mortondaca7cd2006-08-14 23:00:06 -0700[diff] [blame]5693int __init init_module(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]5694{
5695 int i, found = 0;
5696 struct net_device *dev;
5697
5698 for(i = 0; i < SMCTR_MAX_ADAPTERS; i++) {
5699 dev = io[0]? setup_card(i) : smctr_probe(-1);
5700 if (!IS_ERR(dev)) {
5701 ++found;
5702 dev_smctr[i] = dev;
5703 }
5704 }
5705
5706 return found ? 0 : -ENODEV;
5707}
5708
Al Viroafc8eb42006-06-14 18:50:53 -0400[diff] [blame^]5709void __exit cleanup_module(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]5710{
5711 int i;
5712
5713 for(i = 0; i < SMCTR_MAX_ADAPTERS; i++) {
5714 struct net_device *dev = dev_smctr[i];
5715
5716 if (dev) {
5717
5718 unregister_netdev(dev);
5719#ifdef CONFIG_MCA_LEGACY
5720 { struct net_local *tp = netdev_priv(dev);
5721 if (tp->slot_num)
5722 mca_mark_as_unused(tp->slot_num);
5723 }
5724#endif
5725 release_region(dev->base_addr, SMCTR_IO_EXTENT);
5726 if (dev->irq)
5727 free_irq(dev->irq, dev);
5728
5729 free_netdev(dev);
5730 }
5731 }
5732}
5733#endif /* MODULE */