tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

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