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