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