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