drivers/net/tokenring/smctr.c

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