drivers/net/pcmcia/fmvj18x_cs.c

   1 /*======================================================================
   2     fmvj18x_cs.c 2.8 2002/03/23
   3
   4     A fmvj18x (and its compatibles) PCMCIA client driver
   5
   6     Contributed by Shingo Fujimoto, shingo@flab.fujitsu.co.jp
   7
   8     TDK LAK-CD021 and CONTEC C-NET(PC)C support added by
   9     Nobuhiro Katayama, kata-n@po.iijnet.or.jp
  10
  11     The PCMCIA client code is based on code written by David Hinds.
  12     Network code is based on the "FMV-18x driver" by Yutaka TAMIYA
  13     but is actually largely Donald Becker's AT1700 driver, which
  14     carries the following attribution:
  15
  16     Written 1993-94 by Donald Becker.
  17
  18     Copyright 1993 United States Government as represented by the
  19     Director, National Security Agency.
  20
  21     This software may be used and distributed according to the terms
  22     of the GNU General Public License, incorporated herein by reference.
  23
  24     The author may be reached as becker@scyld.com, or C/O
  25     Scyld Computing Corporation
  26     410 Severn Ave., Suite 210
  27     Annapolis MD 21403
  28
  29 ======================================================================*/
  30
  31 #define DRV_NAME        "fmvj18x_cs"
  32 #define DRV_VERSION     "2.9"
  33
  34 #include <linux/module.h>
  35 #include <linux/kernel.h>
  36 #include <linux/init.h>
  37 #include <linux/ptrace.h>
  38 #include <linux/slab.h>
  39 #include <linux/string.h>
  40 #include <linux/timer.h>
  41 #include <linux/interrupt.h>
  42 #include <linux/in.h>
  43 #include <linux/delay.h>
  44 #include <linux/ethtool.h>
  45 #include <linux/netdevice.h>
  46 #include <linux/etherdevice.h>
  47 #include <linux/skbuff.h>
  48 #include <linux/if_arp.h>
  49 #include <linux/ioport.h>
  50 #include <linux/crc32.h>
  51
  52 #include <pcmcia/cs.h>
  53 #include <pcmcia/cistpl.h>
  54 #include <pcmcia/ciscode.h>
  55 #include <pcmcia/ds.h>
  56
  57 #include <asm/uaccess.h>
  58 #include <asm/io.h>
  59 #include <asm/system.h>
  60
  61 /*====================================================================*/
  62
  63 /* Module parameters */
  64
  65 MODULE_DESCRIPTION("fmvj18x and compatible PCMCIA ethernet driver");
  66 MODULE_LICENSE("GPL");
  67
  68 #define INT_MODULE_PARM(n, v) static int n = v; module_param(n, int, 0)
  69
  70 /* SRAM configuration */
  71 /* 0:4KB*2 TX buffer   else:8KB*2 TX buffer */
  72 INT_MODULE_PARM(sram_config, 0);
  73
  74
  75 /*====================================================================*/
  76 /*
  77     PCMCIA event handlers
  78  */
  79 static int fmvj18x_config(struct pcmcia_device *link);
  80 static int fmvj18x_get_hwinfo(struct pcmcia_device *link, u_char *node_id);
  81 static int fmvj18x_setup_mfc(struct pcmcia_device *link);
  82 static void fmvj18x_release(struct pcmcia_device *link);
  83 static void fmvj18x_detach(struct pcmcia_device *p_dev);
  84
  85 /*
  86     LAN controller(MBH86960A) specific routines
  87  */
  88 static int fjn_config(struct net_device *dev, struct ifmap *map);
  89 static int fjn_open(struct net_device *dev);
  90 static int fjn_close(struct net_device *dev);
  91 static netdev_tx_t fjn_start_xmit(struct sk_buff *skb,
  92                                         struct net_device *dev);
  93 static irqreturn_t fjn_interrupt(int irq, void *dev_id);
  94 static void fjn_rx(struct net_device *dev);
  95 static void fjn_reset(struct net_device *dev);
  96 static void set_rx_mode(struct net_device *dev);
  97 static void fjn_tx_timeout(struct net_device *dev);
  98 static const struct ethtool_ops netdev_ethtool_ops;
  99
 100 /*
 101     card type
 102  */
 103 typedef enum { MBH10302, MBH10304, TDK, CONTEC, LA501, UNGERMANN,
 104                XXX10304, NEC, KME
 105 } cardtype_t;
 106
 107 /*
 108     driver specific data structure
 109 */
 110 typedef struct local_info_t {
 111         struct pcmcia_device    *p_dev;
 112     long open_time;
 113     uint tx_started:1;
 114     uint tx_queue;
 115     u_short tx_queue_len;
 116     cardtype_t cardtype;
 117     u_short sent;
 118     u_char __iomem *base;
 119 } local_info_t;
 120
 121 #define MC_FILTERBREAK 64
 122
 123 /*====================================================================*/
 124 /*
 125     ioport offset from the base address
 126  */
 127 #define TX_STATUS               0 /* transmit status register */
 128 #define RX_STATUS               1 /* receive status register */
 129 #define TX_INTR                 2 /* transmit interrupt mask register */
 130 #define RX_INTR                 3 /* receive interrupt mask register */
 131 #define TX_MODE                 4 /* transmit mode register */
 132 #define RX_MODE                 5 /* receive mode register */
 133 #define CONFIG_0                6 /* configuration register 0 */
 134 #define CONFIG_1                7 /* configuration register 1 */
 135
 136 #define NODE_ID                 8 /* node ID register            (bank 0) */
 137 #define MAR_ADR                 8 /* multicast address registers (bank 1) */
 138
 139 #define DATAPORT                8 /* buffer mem port registers   (bank 2) */
 140 #define TX_START               10 /* transmit start register */
 141 #define COL_CTRL               11 /* 16 collision control register */
 142 #define BMPR12                 12 /* reserved */
 143 #define BMPR13                 13 /* reserved */
 144 #define RX_SKIP                14 /* skip received packet register */
 145
 146 #define LAN_CTRL               16 /* LAN card control register */
 147
 148 #define MAC_ID               0x1a /* hardware address */
 149 #define UNGERMANN_MAC_ID     0x18 /* UNGERMANN-BASS hardware address */
 150
 151 /*
 152     control bits
 153  */
 154 #define ENA_TMT_OK           0x80
 155 #define ENA_TMT_REC          0x20
 156 #define ENA_COL              0x04
 157 #define ENA_16_COL           0x02
 158 #define ENA_TBUS_ERR         0x01
 159
 160 #define ENA_PKT_RDY          0x80
 161 #define ENA_BUS_ERR          0x40
 162 #define ENA_LEN_ERR          0x08
 163 #define ENA_ALG_ERR          0x04
 164 #define ENA_CRC_ERR          0x02
 165 #define ENA_OVR_FLO          0x01
 166
 167 /* flags */
 168 #define F_TMT_RDY            0x80 /* can accept new packet */
 169 #define F_NET_BSY            0x40 /* carrier is detected */
 170 #define F_TMT_OK             0x20 /* send packet successfully */
 171 #define F_SRT_PKT            0x10 /* short packet error */
 172 #define F_COL_ERR            0x04 /* collision error */
 173 #define F_16_COL             0x02 /* 16 collision error */
 174 #define F_TBUS_ERR           0x01 /* bus read error */
 175
 176 #define F_PKT_RDY            0x80 /* packet(s) in buffer */
 177 #define F_BUS_ERR            0x40 /* bus read error */
 178 #define F_LEN_ERR            0x08 /* short packet */
 179 #define F_ALG_ERR            0x04 /* frame error */
 180 #define F_CRC_ERR            0x02 /* CRC error */
 181 #define F_OVR_FLO            0x01 /* overflow error */
 182
 183 #define F_BUF_EMP            0x40 /* receive buffer is empty */
 184
 185 #define F_SKP_PKT            0x05 /* drop packet in buffer */
 186
 187 /* default bitmaps */
 188 #define D_TX_INTR  ( ENA_TMT_OK )
 189 #define D_RX_INTR  ( ENA_PKT_RDY | ENA_LEN_ERR \
 190                    | ENA_ALG_ERR | ENA_CRC_ERR | ENA_OVR_FLO )
 191 #define TX_STAT_M  ( F_TMT_RDY )
 192 #define RX_STAT_M  ( F_PKT_RDY | F_LEN_ERR \
 193                    | F_ALG_ERR | F_CRC_ERR | F_OVR_FLO )
 194
 195 /* commands */
 196 #define D_TX_MODE            0x06 /* no tests, detect carrier */
 197 #define ID_MATCHED           0x02 /* (RX_MODE) */
 198 #define RECV_ALL             0x03 /* (RX_MODE) */
 199 #define CONFIG0_DFL          0x5a /* 16bit bus, 4K x 2 Tx queues */
 200 #define CONFIG0_DFL_1        0x5e /* 16bit bus, 8K x 2 Tx queues */
 201 #define CONFIG0_RST          0xda /* Data Link Controller off (CONFIG_0) */
 202 #define CONFIG0_RST_1        0xde /* Data Link Controller off (CONFIG_0) */
 203 #define BANK_0               0xa0 /* bank 0 (CONFIG_1) */
 204 #define BANK_1               0xa4 /* bank 1 (CONFIG_1) */
 205 #define BANK_2               0xa8 /* bank 2 (CONFIG_1) */
 206 #define CHIP_OFF             0x80 /* contrl chip power off (CONFIG_1) */
 207 #define DO_TX                0x80 /* do transmit packet */
 208 #define SEND_PKT             0x81 /* send a packet */
 209 #define AUTO_MODE            0x07 /* Auto skip packet on 16 col detected */
 210 #define MANU_MODE            0x03 /* Stop and skip packet on 16 col */
 211 #define TDK_AUTO_MODE        0x47 /* Auto skip packet on 16 col detected */
 212 #define TDK_MANU_MODE        0x43 /* Stop and skip packet on 16 col */
 213 #define INTR_OFF             0x0d /* LAN controller ignores interrupts */
 214 #define INTR_ON              0x1d /* LAN controller will catch interrupts */
 215
 216 #define TX_TIMEOUT              ((400*HZ)/1000)
 217
 218 #define BANK_0U              0x20 /* bank 0 (CONFIG_1) */
 219 #define BANK_1U              0x24 /* bank 1 (CONFIG_1) */
 220 #define BANK_2U              0x28 /* bank 2 (CONFIG_1) */
 221
 222 static const struct net_device_ops fjn_netdev_ops = {
 223         .ndo_open               = fjn_open,
 224         .ndo_stop               = fjn_close,
 225         .ndo_start_xmit         = fjn_start_xmit,
 226         .ndo_tx_timeout         = fjn_tx_timeout,
 227         .ndo_set_config         = fjn_config,
 228         .ndo_set_multicast_list = set_rx_mode,
 229         .ndo_change_mtu         = eth_change_mtu,
 230         .ndo_set_mac_address    = eth_mac_addr,
 231         .ndo_validate_addr      = eth_validate_addr,
 232 };
 233
 234 static int fmvj18x_probe(struct pcmcia_device *link)
 235 {
 236     local_info_t *lp;
 237     struct net_device *dev;
 238
 239     dev_dbg(&link->dev, "fmvj18x_attach()\n");
 240
 241     /* Make up a FMVJ18x specific data structure */
 242     dev = alloc_etherdev(sizeof(local_info_t));
 243     if (!dev)
 244         return -ENOMEM;
 245     lp = netdev_priv(dev);
 246     link->priv = dev;
 247     lp->p_dev = link;
 248     lp->base = NULL;
 249
 250     /* The io structure describes IO port mapping */
 251     link->resource[0]->end = 32;
 252     link->resource[0]->flags |= IO_DATA_PATH_WIDTH_AUTO;
 253
 254     /* General socket configuration */
 255     link->conf.Attributes = CONF_ENABLE_IRQ;
 256
 257     dev->netdev_ops = &fjn_netdev_ops;
 258     dev->watchdog_timeo = TX_TIMEOUT;
 259
 260     SET_ETHTOOL_OPS(dev, &netdev_ethtool_ops);
 261
 262     return fmvj18x_config(link);
 263 } /* fmvj18x_attach */
 264
 265 /*====================================================================*/
 266
 267 static void fmvj18x_detach(struct pcmcia_device *link)
 268 {
 269     struct net_device *dev = link->priv;
 270
 271     dev_dbg(&link->dev, "fmvj18x_detach\n");
 272
 273     unregister_netdev(dev);
 274
 275     fmvj18x_release(link);
 276
 277     free_netdev(dev);
 278 } /* fmvj18x_detach */
 279
 280 /*====================================================================*/
 281
 282 static int mfc_try_io_port(struct pcmcia_device *link)
 283 {
 284     int i, ret;
 285     static const unsigned int serial_base[5] =
 286         { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
 287
 288     for (i = 0; i < 5; i++) {
 289         link->resource[1]->start = serial_base[i];
 290         link->resource[1]->flags |= IO_DATA_PATH_WIDTH_8;
 291         if (link->resource[1]->start == 0) {
 292             link->resource[1]->end = 0;
 293             printk(KERN_NOTICE "fmvj18x_cs: out of resource for serial\n");
 294         }
 295         ret = pcmcia_request_io(link);
 296         if (ret == 0)
 297                 return ret;
 298     }
 299     return ret;
 300 }
 301
 302 static int ungermann_try_io_port(struct pcmcia_device *link)
 303 {
 304     int ret;
 305     unsigned int ioaddr;
 306     /*
 307         Ungermann-Bass Access/CARD accepts 0x300,0x320,0x340,0x360
 308         0x380,0x3c0 only for ioport.
 309     */
 310     for (ioaddr = 0x300; ioaddr < 0x3e0; ioaddr += 0x20) {
 311         link->resource[0]->start = ioaddr;
 312         ret = pcmcia_request_io(link);
 313         if (ret == 0) {
 314             /* calculate ConfigIndex value */
 315             link->config_index =
 316                 ((link->resource[0]->start & 0x0f0) >> 3) | 0x22;
 317             return ret;
 318         }
 319     }
 320     return ret; /* RequestIO failed */
 321 }
 322
 323 static int fmvj18x_ioprobe(struct pcmcia_device *p_dev,
 324                            cistpl_cftable_entry_t *cfg,
 325                            cistpl_cftable_entry_t *dflt,
 326                            unsigned int vcc,
 327                            void *priv_data)
 328 {
 329         return 0; /* strange, but that's what the code did already before... */
 330 }
 331
 332 static int fmvj18x_config(struct pcmcia_device *link)
 333 {
 334     struct net_device *dev = link->priv;
 335     local_info_t *lp = netdev_priv(dev);
 336     int i, ret;
 337     unsigned int ioaddr;
 338     cardtype_t cardtype;
 339     char *card_name = "unknown";
 340     u8 *buf;
 341     size_t len;
 342     u_char buggybuf[32];
 343
 344     dev_dbg(&link->dev, "fmvj18x_config\n");
 345
 346     link->io_lines = 5;
 347
 348     len = pcmcia_get_tuple(link, CISTPL_FUNCE, &buf);
 349     kfree(buf);
 350
 351     if (len) {
 352         /* Yes, I have CISTPL_FUNCE. Let's check CISTPL_MANFID */
 353         ret = pcmcia_loop_config(link, fmvj18x_ioprobe, NULL);
 354         if (ret != 0)
 355                 goto failed;
 356
 357         switch (link->manf_id) {
 358         case MANFID_TDK:
 359             cardtype = TDK;
 360             if (link->card_id == PRODID_TDK_GN3410 ||
 361                 link->card_id == PRODID_TDK_NP9610 ||
 362                 link->card_id == PRODID_TDK_MN3200) {
 363                 /* MultiFunction Card */
 364                 link->config_base = 0x800;
 365                 link->config_index = 0x47;
 366                 link->resource[1]->end = 8;
 367             }
 368             break;
 369         case MANFID_NEC:
 370             cardtype = NEC; /* MultiFunction Card */
 371             link->config_base = 0x800;
 372             link->config_index = 0x47;
 373             link->resource[1]->end = 8;
 374             break;
 375         case MANFID_KME:
 376             cardtype = KME; /* MultiFunction Card */
 377             link->config_base = 0x800;
 378             link->config_index = 0x47;
 379             link->resource[1]->end = 8;
 380             break;
 381         case MANFID_CONTEC:
 382             cardtype = CONTEC;
 383             break;
 384         case MANFID_FUJITSU:
 385             if (link->config_base == 0x0fe0)
 386                 cardtype = MBH10302;
 387             else if (link->card_id == PRODID_FUJITSU_MBH10302)
 388                 /* RATOC REX-5588/9822/4886's PRODID are 0004(=MBH10302),
 389                    but these are MBH10304 based card. */
 390                 cardtype = MBH10304;
 391             else if (link->card_id == PRODID_FUJITSU_MBH10304)
 392                 cardtype = MBH10304;
 393             else
 394                 cardtype = LA501;
 395             break;
 396         default:
 397             cardtype = MBH10304;
 398         }
 399     } else {
 400         /* old type card */
 401         switch (link->manf_id) {
 402         case MANFID_FUJITSU:
 403             if (link->card_id == PRODID_FUJITSU_MBH10304) {
 404                 cardtype = XXX10304;    /* MBH10304 with buggy CIS */
 405                 link->config_index = 0x20;
 406             } else {
 407                 cardtype = MBH10302;    /* NextCom NC5310, etc. */
 408                 link->config_index = 1;
 409             }
 410             break;
 411         case MANFID_UNGERMANN:
 412             cardtype = UNGERMANN;
 413             break;
 414         default:
 415             cardtype = MBH10302;
 416             link->config_index = 1;
 417         }
 418     }
 419
 420     if (link->resource[1]->end != 0) {
 421         ret = mfc_try_io_port(link);
 422         if (ret != 0) goto failed;
 423     } else if (cardtype == UNGERMANN) {
 424         ret = ungermann_try_io_port(link);
 425         if (ret != 0) goto failed;
 426     } else {
 427             ret = pcmcia_request_io(link);
 428             if (ret)
 429                     goto failed;
 430     }
 431     ret = pcmcia_request_irq(link, fjn_interrupt);
 432     if (ret)
 433             goto failed;
 434     ret = pcmcia_request_configuration(link, &link->conf);
 435     if (ret)
 436             goto failed;
 437
 438     dev->irq = link->irq;
 439     dev->base_addr = link->resource[0]->start;
 440
 441     if (resource_size(link->resource[1]) != 0) {
 442         ret = fmvj18x_setup_mfc(link);
 443         if (ret != 0) goto failed;
 444     }
 445
 446     ioaddr = dev->base_addr;
 447
 448     /* Reset controller */
 449     if (sram_config == 0)
 450         outb(CONFIG0_RST, ioaddr + CONFIG_0);
 451     else
 452         outb(CONFIG0_RST_1, ioaddr + CONFIG_0);
 453
 454     /* Power On chip and select bank 0 */
 455     if (cardtype == MBH10302)
 456         outb(BANK_0, ioaddr + CONFIG_1);
 457     else
 458         outb(BANK_0U, ioaddr + CONFIG_1);
 459
 460     /* Set hardware address */
 461     switch (cardtype) {
 462     case MBH10304:
 463     case TDK:
 464     case LA501:
 465     case CONTEC:
 466     case NEC:
 467     case KME:
 468         if (cardtype == MBH10304) {
 469             card_name = "FMV-J182";
 470
 471             len = pcmcia_get_tuple(link, CISTPL_FUNCE, &buf);
 472             if (len < 11) {
 473                     kfree(buf);
 474                     goto failed;
 475             }
 476             /* Read MACID from CIS */
 477             for (i = 5; i < 11; i++)
 478                     dev->dev_addr[i] = buf[i];
 479             kfree(buf);
 480         } else {
 481             if (pcmcia_get_mac_from_cis(link, dev))
 482                 goto failed;
 483             if( cardtype == TDK ) {
 484                 card_name = "TDK LAK-CD021";
 485             } else if( cardtype == LA501 ) {
 486                 card_name = "LA501";
 487             } else if( cardtype == NEC ) {
 488                 card_name = "PK-UG-J001";
 489             } else if( cardtype == KME ) {
 490                 card_name = "Panasonic";
 491             } else {
 492                 card_name = "C-NET(PC)C";
 493             }
 494         }
 495         break;
 496     case UNGERMANN:
 497         /* Read MACID from register */
 498         for (i = 0; i < 6; i++)
 499             dev->dev_addr[i] = inb(ioaddr + UNGERMANN_MAC_ID + i);
 500         card_name = "Access/CARD";
 501         break;
 502     case XXX10304:
 503         /* Read MACID from Buggy CIS */
 504         if (fmvj18x_get_hwinfo(link, buggybuf) == -1) {
 505             printk(KERN_NOTICE "fmvj18x_cs: unable to read hardware net address.\n");
 506             goto failed;
 507         }
 508         for (i = 0 ; i < 6; i++) {
 509             dev->dev_addr[i] = buggybuf[i];
 510         }
 511         card_name = "FMV-J182";
 512         break;
 513     case MBH10302:
 514     default:
 515         /* Read MACID from register */
 516         for (i = 0; i < 6; i++)
 517             dev->dev_addr[i] = inb(ioaddr + MAC_ID + i);
 518         card_name = "FMV-J181";
 519         break;
 520     }
 521
 522     lp->cardtype = cardtype;
 523     SET_NETDEV_DEV(dev, &link->dev);
 524
 525     if (register_netdev(dev) != 0) {
 526         printk(KERN_NOTICE "fmvj18x_cs: register_netdev() failed\n");
 527         goto failed;
 528     }
 529
 530     /* print current configuration */
 531     printk(KERN_INFO "%s: %s, sram %s, port %#3lx, irq %d, "
 532            "hw_addr %pM\n",
 533            dev->name, card_name, sram_config == 0 ? "4K TX*2" : "8K TX*2",
 534            dev->base_addr, dev->irq, dev->dev_addr);
 535
 536     return 0;
 537
 538 failed:
 539     fmvj18x_release(link);
 540     return -ENODEV;
 541 } /* fmvj18x_config */
 542 /*====================================================================*/
 543
 544 static int fmvj18x_get_hwinfo(struct pcmcia_device *link, u_char *node_id)
 545 {
 546     u_char __iomem *base;
 547     int i, j;
 548
 549     /* Allocate a small memory window */
 550     link->resource[2]->flags |= WIN_DATA_WIDTH_8|WIN_MEMORY_TYPE_AM|WIN_ENABLE;
 551     link->resource[2]->start = 0; link->resource[2]->end = 0;
 552     i = pcmcia_request_window(link, link->resource[2], 0);
 553     if (i != 0)
 554         return -1;
 555
 556     base = ioremap(link->resource[2]->start, resource_size(link->resource[2]));
 557     pcmcia_map_mem_page(link, link->resource[2], 0);
 558
 559     /*
 560      *  MBH10304 CISTPL_FUNCE_LAN_NODE_ID format
 561      *  22 0d xx xx xx 04 06 yy yy yy yy yy yy ff
 562      *  'xx' is garbage.
 563      *  'yy' is MAC address.
 564     */
 565     for (i = 0; i < 0x200; i++) {
 566         if (readb(base+i*2) == 0x22) {
 567                 if (readb(base+(i-1)*2) == 0xff &&
 568                     readb(base+(i+5)*2) == 0x04 &&
 569                     readb(base+(i+6)*2) == 0x06 &&
 570                     readb(base+(i+13)*2) == 0xff)
 571                         break;
 572         }
 573     }
 574
 575     if (i != 0x200) {
 576         for (j = 0 ; j < 6; j++,i++) {
 577             node_id[j] = readb(base+(i+7)*2);
 578         }
 579     }
 580
 581     iounmap(base);
 582     j = pcmcia_release_window(link, link->resource[2]);
 583     return (i != 0x200) ? 0 : -1;
 584
 585 } /* fmvj18x_get_hwinfo */
 586 /*====================================================================*/
 587
 588 static int fmvj18x_setup_mfc(struct pcmcia_device *link)
 589 {
 590     int i;
 591     struct net_device *dev = link->priv;
 592     unsigned int ioaddr;
 593     local_info_t *lp = netdev_priv(dev);
 594
 595     /* Allocate a small memory window */
 596     link->resource[3]->flags = WIN_DATA_WIDTH_8|WIN_MEMORY_TYPE_AM|WIN_ENABLE;
 597     link->resource[3]->start = link->resource[3]->end = 0;
 598     i = pcmcia_request_window(link, link->resource[3], 0);
 599     if (i != 0)
 600         return -1;
 601
 602     lp->base = ioremap(link->resource[3]->start,
 603                        resource_size(link->resource[3]));
 604     if (lp->base == NULL) {
 605         printk(KERN_NOTICE "fmvj18x_cs: ioremap failed\n");
 606         return -1;
 607     }
 608
 609     i = pcmcia_map_mem_page(link, link->resource[3], 0);
 610     if (i != 0) {
 611         iounmap(lp->base);
 612         lp->base = NULL;
 613         return -1;
 614     }
 615
 616     ioaddr = dev->base_addr;
 617     writeb(0x47, lp->base+0x800);       /* Config Option Register of LAN */
 618     writeb(0x0,  lp->base+0x802);       /* Config and Status Register */
 619
 620     writeb(ioaddr & 0xff, lp->base+0x80a);        /* I/O Base(Low) of LAN */
 621     writeb((ioaddr >> 8) & 0xff, lp->base+0x80c); /* I/O Base(High) of LAN */
 622
 623     writeb(0x45, lp->base+0x820);       /* Config Option Register of Modem */
 624     writeb(0x8,  lp->base+0x822);       /* Config and Status Register */
 625
 626     return 0;
 627
 628 }
 629 /*====================================================================*/
 630
 631 static void fmvj18x_release(struct pcmcia_device *link)
 632 {
 633
 634     struct net_device *dev = link->priv;
 635     local_info_t *lp = netdev_priv(dev);
 636     u_char __iomem *tmp;
 637
 638     dev_dbg(&link->dev, "fmvj18x_release\n");
 639
 640     if (lp->base != NULL) {
 641         tmp = lp->base;
 642         lp->base = NULL;    /* set NULL before iounmap */
 643         iounmap(tmp);
 644     }
 645
 646     pcmcia_disable_device(link);
 647
 648 }
 649
 650 static int fmvj18x_suspend(struct pcmcia_device *link)
 651 {
 652         struct net_device *dev = link->priv;
 653
 654         if (link->open)
 655                 netif_device_detach(dev);
 656
 657         return 0;
 658 }
 659
 660 static int fmvj18x_resume(struct pcmcia_device *link)
 661 {
 662         struct net_device *dev = link->priv;
 663
 664         if (link->open) {
 665                 fjn_reset(dev);
 666                 netif_device_attach(dev);
 667         }
 668
 669         return 0;
 670 }
 671
 672 /*====================================================================*/
 673
 674 static struct pcmcia_device_id fmvj18x_ids[] = {
 675         PCMCIA_DEVICE_MANF_CARD(0x0004, 0x0004),
 676         PCMCIA_DEVICE_PROD_ID12("EAGLE Technology", "NE200 ETHERNET LAN MBH10302 04", 0x528c88c4, 0x74f91e59),
 677         PCMCIA_DEVICE_PROD_ID12("Eiger Labs,Inc", "EPX-10BT PC Card Ethernet 10BT", 0x53af556e, 0x877f9922),
 678         PCMCIA_DEVICE_PROD_ID12("Eiger labs,Inc.", "EPX-10BT PC Card Ethernet 10BT", 0xf47e6c66, 0x877f9922),
 679         PCMCIA_DEVICE_PROD_ID12("FUJITSU", "LAN Card(FMV-J182)", 0x6ee5a3d8, 0x5baf31db),
 680         PCMCIA_DEVICE_PROD_ID12("FUJITSU", "MBH10308", 0x6ee5a3d8, 0x3f04875e),
 681         PCMCIA_DEVICE_PROD_ID12("FUJITSU TOWA", "LA501", 0xb8451188, 0x12939ba2),
 682         PCMCIA_DEVICE_PROD_ID12("HITACHI", "HT-4840-11", 0xf4f43949, 0x773910f4),
 683         PCMCIA_DEVICE_PROD_ID12("NextComK.K.", "NC5310B Ver1.0       ", 0x8cef4d3a, 0x075fc7b6),
 684         PCMCIA_DEVICE_PROD_ID12("NextComK.K.", "NC5310 Ver1.0        ", 0x8cef4d3a, 0xbccf43e6),
 685         PCMCIA_DEVICE_PROD_ID12("RATOC System Inc.", "10BASE_T CARD R280", 0x85c10e17, 0xd9413666),
 686         PCMCIA_DEVICE_PROD_ID12("TDK", "LAC-CD02x", 0x1eae9475, 0x8fa0ee70),
 687         PCMCIA_DEVICE_PROD_ID12("TDK", "LAC-CF010", 0x1eae9475, 0x7683bc9a),
 688         PCMCIA_DEVICE_PROD_ID1("CONTEC Co.,Ltd.", 0x58d8fee2),
 689         PCMCIA_DEVICE_PROD_ID1("PCMCIA LAN MBH10304  ES", 0x2599f454),
 690         PCMCIA_DEVICE_PROD_ID1("PCMCIA MBH10302", 0x8f4005da),
 691         PCMCIA_DEVICE_PROD_ID1("UBKK,V2.0", 0x90888080),
 692         PCMCIA_PFC_DEVICE_PROD_ID12(0, "TDK", "GlobalNetworker 3410/3412", 0x1eae9475, 0xd9a93bed),
 693         PCMCIA_PFC_DEVICE_PROD_ID12(0, "NEC", "PK-UG-J001" ,0x18df0ba0 ,0x831b1064),
 694         PCMCIA_PFC_DEVICE_MANF_CARD(0, 0x0105, 0x0d0a),
 695         PCMCIA_PFC_DEVICE_MANF_CARD(0, 0x0105, 0x0e0a),
 696         PCMCIA_PFC_DEVICE_MANF_CARD(0, 0x0032, 0x0e01),
 697         PCMCIA_PFC_DEVICE_MANF_CARD(0, 0x0032, 0x0a05),
 698         PCMCIA_PFC_DEVICE_MANF_CARD(0, 0x0032, 0x1101),
 699         PCMCIA_DEVICE_NULL,
 700 };
 701 MODULE_DEVICE_TABLE(pcmcia, fmvj18x_ids);
 702
 703 static struct pcmcia_driver fmvj18x_cs_driver = {
 704         .owner          = THIS_MODULE,
 705         .drv            = {
 706                 .name   = "fmvj18x_cs",
 707         },
 708         .probe          = fmvj18x_probe,
 709         .remove         = fmvj18x_detach,
 710         .id_table       = fmvj18x_ids,
 711         .suspend        = fmvj18x_suspend,
 712         .resume         = fmvj18x_resume,
 713 };
 714
 715 static int __init init_fmvj18x_cs(void)
 716 {
 717         return pcmcia_register_driver(&fmvj18x_cs_driver);
 718 }
 719
 720 static void __exit exit_fmvj18x_cs(void)
 721 {
 722         pcmcia_unregister_driver(&fmvj18x_cs_driver);
 723 }
 724
 725 module_init(init_fmvj18x_cs);
 726 module_exit(exit_fmvj18x_cs);
 727
 728 /*====================================================================*/
 729
 730 static irqreturn_t fjn_interrupt(int dummy, void *dev_id)
 731 {
 732     struct net_device *dev = dev_id;
 733     local_info_t *lp = netdev_priv(dev);
 734     unsigned int ioaddr;
 735     unsigned short tx_stat, rx_stat;
 736
 737     ioaddr = dev->base_addr;
 738
 739     /* avoid multiple interrupts */
 740     outw(0x0000, ioaddr + TX_INTR);
 741
 742     /* wait for a while */
 743     udelay(1);
 744
 745     /* get status */
 746     tx_stat = inb(ioaddr + TX_STATUS);
 747     rx_stat = inb(ioaddr + RX_STATUS);
 748
 749     /* clear status */
 750     outb(tx_stat, ioaddr + TX_STATUS);
 751     outb(rx_stat, ioaddr + RX_STATUS);
 752
 753     pr_debug("%s: interrupt, rx_status %02x.\n", dev->name, rx_stat);
 754     pr_debug("               tx_status %02x.\n", tx_stat);
 755
 756     if (rx_stat || (inb(ioaddr + RX_MODE) & F_BUF_EMP) == 0) {
 757         /* there is packet(s) in rx buffer */
 758         fjn_rx(dev);
 759     }
 760     if (tx_stat & F_TMT_RDY) {
 761         dev->stats.tx_packets += lp->sent ;
 762         lp->sent = 0 ;
 763         if (lp->tx_queue) {
 764             outb(DO_TX | lp->tx_queue, ioaddr + TX_START);
 765             lp->sent = lp->tx_queue ;
 766             lp->tx_queue = 0;
 767             lp->tx_queue_len = 0;
 768             dev->trans_start = jiffies;
 769         } else {
 770             lp->tx_started = 0;
 771         }
 772         netif_wake_queue(dev);
 773     }
 774     pr_debug("%s: exiting interrupt,\n", dev->name);
 775     pr_debug("    tx_status %02x, rx_status %02x.\n", tx_stat, rx_stat);
 776
 777     outb(D_TX_INTR, ioaddr + TX_INTR);
 778     outb(D_RX_INTR, ioaddr + RX_INTR);
 779
 780     if (lp->base != NULL) {
 781         /* Ack interrupt for multifunction card */
 782         writeb(0x01, lp->base+0x802);
 783         writeb(0x09, lp->base+0x822);
 784     }
 785
 786     return IRQ_HANDLED;
 787
 788 } /* fjn_interrupt */
 789
 790 /*====================================================================*/
 791
 792 static void fjn_tx_timeout(struct net_device *dev)
 793 {
 794     struct local_info_t *lp = netdev_priv(dev);
 795     unsigned int ioaddr = dev->base_addr;
 796
 797     printk(KERN_NOTICE "%s: transmit timed out with status %04x, %s?\n",
 798            dev->name, htons(inw(ioaddr + TX_STATUS)),
 799            inb(ioaddr + TX_STATUS) & F_TMT_RDY
 800            ? "IRQ conflict" : "network cable problem");
 801     printk(KERN_NOTICE "%s: timeout registers: %04x %04x %04x "
 802            "%04x %04x %04x %04x %04x.\n",
 803            dev->name, htons(inw(ioaddr + 0)),
 804            htons(inw(ioaddr + 2)), htons(inw(ioaddr + 4)),
 805            htons(inw(ioaddr + 6)), htons(inw(ioaddr + 8)),
 806            htons(inw(ioaddr +10)), htons(inw(ioaddr +12)),
 807            htons(inw(ioaddr +14)));
 808     dev->stats.tx_errors++;
 809     /* ToDo: We should try to restart the adaptor... */
 810     local_irq_disable();
 811     fjn_reset(dev);
 812
 813     lp->tx_started = 0;
 814     lp->tx_queue = 0;
 815     lp->tx_queue_len = 0;
 816     lp->sent = 0;
 817     lp->open_time = jiffies;
 818     local_irq_enable();
 819     netif_wake_queue(dev);
 820 }
 821
 822 static netdev_tx_t fjn_start_xmit(struct sk_buff *skb,
 823                                         struct net_device *dev)
 824 {
 825     struct local_info_t *lp = netdev_priv(dev);
 826     unsigned int ioaddr = dev->base_addr;
 827     short length = skb->len;
 828
 829     if (length < ETH_ZLEN)
 830     {
 831         if (skb_padto(skb, ETH_ZLEN))
 832                 return NETDEV_TX_OK;
 833         length = ETH_ZLEN;
 834     }
 835
 836     netif_stop_queue(dev);
 837
 838     {
 839         unsigned char *buf = skb->data;
 840
 841         if (length > ETH_FRAME_LEN) {
 842             printk(KERN_NOTICE "%s: Attempting to send a large packet"
 843                    " (%d bytes).\n", dev->name, length);
 844             return NETDEV_TX_BUSY;
 845         }
 846
 847         pr_debug("%s: Transmitting a packet of length %lu.\n",
 848               dev->name, (unsigned long)skb->len);
 849         dev->stats.tx_bytes += skb->len;
 850
 851         /* Disable both interrupts. */
 852         outw(0x0000, ioaddr + TX_INTR);
 853
 854         /* wait for a while */
 855         udelay(1);
 856
 857         outw(length, ioaddr + DATAPORT);
 858         outsw(ioaddr + DATAPORT, buf, (length + 1) >> 1);
 859
 860         lp->tx_queue++;
 861         lp->tx_queue_len += ((length+3) & ~1);
 862
 863         if (lp->tx_started == 0) {
 864             /* If the Tx is idle, always trigger a transmit. */
 865             outb(DO_TX | lp->tx_queue, ioaddr + TX_START);
 866             lp->sent = lp->tx_queue ;
 867             lp->tx_queue = 0;
 868             lp->tx_queue_len = 0;
 869             lp->tx_started = 1;
 870             netif_start_queue(dev);
 871         } else {
 872             if( sram_config == 0 ) {
 873                 if (lp->tx_queue_len < (4096 - (ETH_FRAME_LEN +2)) )
 874                     /* Yes, there is room for one more packet. */
 875                     netif_start_queue(dev);
 876             } else {
 877                 if (lp->tx_queue_len < (8192 - (ETH_FRAME_LEN +2)) &&
 878                                                 lp->tx_queue < 127 )
 879                     /* Yes, there is room for one more packet. */
 880                     netif_start_queue(dev);
 881             }
 882         }
 883
 884         /* Re-enable interrupts */
 885         outb(D_TX_INTR, ioaddr + TX_INTR);
 886         outb(D_RX_INTR, ioaddr + RX_INTR);
 887     }
 888     dev_kfree_skb (skb);
 889
 890     return NETDEV_TX_OK;
 891 } /* fjn_start_xmit */
 892
 893 /*====================================================================*/
 894
 895 static void fjn_reset(struct net_device *dev)
 896 {
 897     struct local_info_t *lp = netdev_priv(dev);
 898     unsigned int ioaddr = dev->base_addr;
 899     int i;
 900
 901     pr_debug("fjn_reset(%s) called.\n",dev->name);
 902
 903     /* Reset controller */
 904     if( sram_config == 0 )
 905         outb(CONFIG0_RST, ioaddr + CONFIG_0);
 906     else
 907         outb(CONFIG0_RST_1, ioaddr + CONFIG_0);
 908
 909     /* Power On chip and select bank 0 */
 910     if (lp->cardtype == MBH10302)
 911         outb(BANK_0, ioaddr + CONFIG_1);
 912     else
 913         outb(BANK_0U, ioaddr + CONFIG_1);
 914
 915     /* Set Tx modes */
 916     outb(D_TX_MODE, ioaddr + TX_MODE);
 917     /* set Rx modes */
 918     outb(ID_MATCHED, ioaddr + RX_MODE);
 919
 920     /* Set hardware address */
 921     for (i = 0; i < 6; i++)
 922         outb(dev->dev_addr[i], ioaddr + NODE_ID + i);
 923
 924     /* (re)initialize the multicast table */
 925     set_rx_mode(dev);
 926
 927     /* Switch to bank 2 (runtime mode) */
 928     if (lp->cardtype == MBH10302)
 929         outb(BANK_2, ioaddr + CONFIG_1);
 930     else
 931         outb(BANK_2U, ioaddr + CONFIG_1);
 932
 933     /* set 16col ctrl bits */
 934     if( lp->cardtype == TDK || lp->cardtype == CONTEC)
 935         outb(TDK_AUTO_MODE, ioaddr + COL_CTRL);
 936     else
 937         outb(AUTO_MODE, ioaddr + COL_CTRL);
 938
 939     /* clear Reserved Regs */
 940     outb(0x00, ioaddr + BMPR12);
 941     outb(0x00, ioaddr + BMPR13);
 942
 943     /* reset Skip packet reg. */
 944     outb(0x01, ioaddr + RX_SKIP);
 945
 946     /* Enable Tx and Rx */
 947     if( sram_config == 0 )
 948         outb(CONFIG0_DFL, ioaddr + CONFIG_0);
 949     else
 950         outb(CONFIG0_DFL_1, ioaddr + CONFIG_0);
 951
 952     /* Init receive pointer ? */
 953     inw(ioaddr + DATAPORT);
 954     inw(ioaddr + DATAPORT);
 955
 956     /* Clear all status */
 957     outb(0xff, ioaddr + TX_STATUS);
 958     outb(0xff, ioaddr + RX_STATUS);
 959
 960     if (lp->cardtype == MBH10302)
 961         outb(INTR_OFF, ioaddr + LAN_CTRL);
 962
 963     /* Turn on Rx interrupts */
 964     outb(D_TX_INTR, ioaddr + TX_INTR);
 965     outb(D_RX_INTR, ioaddr + RX_INTR);
 966
 967     /* Turn on interrupts from LAN card controller */
 968     if (lp->cardtype == MBH10302)
 969         outb(INTR_ON, ioaddr + LAN_CTRL);
 970 } /* fjn_reset */
 971
 972 /*====================================================================*/
 973
 974 static void fjn_rx(struct net_device *dev)
 975 {
 976     unsigned int ioaddr = dev->base_addr;
 977     int boguscount = 10;        /* 5 -> 10: by agy 19940922 */
 978
 979     pr_debug("%s: in rx_packet(), rx_status %02x.\n",
 980           dev->name, inb(ioaddr + RX_STATUS));
 981
 982     while ((inb(ioaddr + RX_MODE) & F_BUF_EMP) == 0) {
 983         u_short status = inw(ioaddr + DATAPORT);
 984
 985         pr_debug("%s: Rxing packet mode %02x status %04x.\n",
 986               dev->name, inb(ioaddr + RX_MODE), status);
 987 #ifndef final_version
 988         if (status == 0) {
 989             outb(F_SKP_PKT, ioaddr + RX_SKIP);
 990             break;
 991         }
 992 #endif
 993         if ((status & 0xF0) != 0x20) {  /* There was an error. */
 994             dev->stats.rx_errors++;
 995             if (status & F_LEN_ERR) dev->stats.rx_length_errors++;
 996             if (status & F_ALG_ERR) dev->stats.rx_frame_errors++;
 997             if (status & F_CRC_ERR) dev->stats.rx_crc_errors++;
 998             if (status & F_OVR_FLO) dev->stats.rx_over_errors++;
 999         } else {
1000             u_short pkt_len = inw(ioaddr + DATAPORT);
1001             /* Malloc up new buffer. */
1002             struct sk_buff *skb;
1003
1004             if (pkt_len > 1550) {
1005                 printk(KERN_NOTICE "%s: The FMV-18x claimed a very "
1006                        "large packet, size %d.\n", dev->name, pkt_len);
1007                 outb(F_SKP_PKT, ioaddr + RX_SKIP);
1008                 dev->stats.rx_errors++;
1009                 break;
1010             }
1011             skb = dev_alloc_skb(pkt_len+2);
1012             if (skb == NULL) {
1013                 printk(KERN_NOTICE "%s: Memory squeeze, dropping "
1014                        "packet (len %d).\n", dev->name, pkt_len);
1015                 outb(F_SKP_PKT, ioaddr + RX_SKIP);
1016                 dev->stats.rx_dropped++;
1017                 break;
1018             }
1019
1020             skb_reserve(skb, 2);
1021             insw(ioaddr + DATAPORT, skb_put(skb, pkt_len),
1022                  (pkt_len + 1) >> 1);
1023             skb->protocol = eth_type_trans(skb, dev);
1024
1025             {
1026                 int i;
1027                 pr_debug("%s: Rxed packet of length %d: ",
1028                         dev->name, pkt_len);
1029                 for (i = 0; i < 14; i++)
1030                         pr_debug(" %02x", skb->data[i]);
1031                 pr_debug(".\n");
1032             }
1033
1034             netif_rx(skb);
1035             dev->stats.rx_packets++;
1036             dev->stats.rx_bytes += pkt_len;
1037         }
1038         if (--boguscount <= 0)
1039             break;
1040     }
1041
1042     /* If any worth-while packets have been received, dev_rint()
1043            has done a netif_wake_queue() for us and will work on them
1044            when we get to the bottom-half routine. */
1045 /*
1046     if (lp->cardtype != TDK) {
1047         int i;
1048         for (i = 0; i < 20; i++) {
1049             if ((inb(ioaddr + RX_MODE) & F_BUF_EMP) == F_BUF_EMP)
1050                 break;
1051             (void)inw(ioaddr + DATAPORT);  /+ dummy status read +/
1052             outb(F_SKP_PKT, ioaddr + RX_SKIP);
1053         }
1054
1055         if (i > 0)
1056             pr_debug("%s: Exint Rx packet with mode %02x after "
1057                   "%d ticks.\n", dev->name, inb(ioaddr + RX_MODE), i);
1058     }
1059 */
1060 } /* fjn_rx */
1061
1062 /*====================================================================*/
1063
1064 static void netdev_get_drvinfo(struct net_device *dev,
1065                                struct ethtool_drvinfo *info)
1066 {
1067         strcpy(info->driver, DRV_NAME);
1068         strcpy(info->version, DRV_VERSION);
1069         sprintf(info->bus_info, "PCMCIA 0x%lx", dev->base_addr);
1070 }
1071
1072 static const struct ethtool_ops netdev_ethtool_ops = {
1073         .get_drvinfo            = netdev_get_drvinfo,
1074 };
1075
1076 static int fjn_config(struct net_device *dev, struct ifmap *map){
1077     return 0;
1078 }
1079
1080 static int fjn_open(struct net_device *dev)
1081 {
1082     struct local_info_t *lp = netdev_priv(dev);
1083     struct pcmcia_device *link = lp->p_dev;
1084
1085     pr_debug("fjn_open('%s').\n", dev->name);
1086
1087     if (!pcmcia_dev_present(link))
1088         return -ENODEV;
1089
1090     link->open++;
1091
1092     fjn_reset(dev);
1093
1094     lp->tx_started = 0;
1095     lp->tx_queue = 0;
1096     lp->tx_queue_len = 0;
1097     lp->open_time = jiffies;
1098     netif_start_queue(dev);
1099
1100     return 0;
1101 } /* fjn_open */
1102
1103 /*====================================================================*/
1104
1105 static int fjn_close(struct net_device *dev)
1106 {
1107     struct local_info_t *lp = netdev_priv(dev);
1108     struct pcmcia_device *link = lp->p_dev;
1109     unsigned int ioaddr = dev->base_addr;
1110
1111     pr_debug("fjn_close('%s').\n", dev->name);
1112
1113     lp->open_time = 0;
1114     netif_stop_queue(dev);
1115
1116     /* Set configuration register 0 to disable Tx and Rx. */
1117     if( sram_config == 0 )
1118         outb(CONFIG0_RST ,ioaddr + CONFIG_0);
1119     else
1120         outb(CONFIG0_RST_1 ,ioaddr + CONFIG_0);
1121
1122     /* Update the statistics -- ToDo. */
1123
1124     /* Power-down the chip.  Green, green, green! */
1125     outb(CHIP_OFF ,ioaddr + CONFIG_1);
1126
1127     /* Set the ethernet adaptor disable IRQ */
1128     if (lp->cardtype == MBH10302)
1129         outb(INTR_OFF, ioaddr + LAN_CTRL);
1130
1131     link->open--;
1132
1133     return 0;
1134 } /* fjn_close */
1135
1136 /*====================================================================*/
1137
1138 /*
1139   Set the multicast/promiscuous mode for this adaptor.
1140 */
1141
1142 static void set_rx_mode(struct net_device *dev)
1143 {
1144     unsigned int ioaddr = dev->base_addr;
1145     u_char mc_filter[8];                 /* Multicast hash filter */
1146     u_long flags;
1147     int i;
1148
1149     int saved_bank;
1150     int saved_config_0 = inb(ioaddr + CONFIG_0);
1151
1152     local_irq_save(flags);
1153
1154     /* Disable Tx and Rx */
1155     if (sram_config == 0)
1156         outb(CONFIG0_RST, ioaddr + CONFIG_0);
1157     else
1158         outb(CONFIG0_RST_1, ioaddr + CONFIG_0);
1159
1160     if (dev->flags & IFF_PROMISC) {
1161         memset(mc_filter, 0xff, sizeof(mc_filter));
1162         outb(3, ioaddr + RX_MODE);      /* Enable promiscuous mode */
1163     } else if (netdev_mc_count(dev) > MC_FILTERBREAK ||
1164                (dev->flags & IFF_ALLMULTI)) {
1165         /* Too many to filter perfectly -- accept all multicasts. */
1166         memset(mc_filter, 0xff, sizeof(mc_filter));
1167         outb(2, ioaddr + RX_MODE);      /* Use normal mode. */
1168     } else if (netdev_mc_empty(dev)) {
1169         memset(mc_filter, 0x00, sizeof(mc_filter));
1170         outb(1, ioaddr + RX_MODE);      /* Ignore almost all multicasts. */
1171     } else {
1172         struct netdev_hw_addr *ha;
1173
1174         memset(mc_filter, 0, sizeof(mc_filter));
1175         netdev_for_each_mc_addr(ha, dev) {
1176             unsigned int bit = ether_crc_le(ETH_ALEN, ha->addr) >> 26;
1177             mc_filter[bit >> 3] |= (1 << (bit & 7));
1178         }
1179         outb(2, ioaddr + RX_MODE);      /* Use normal mode. */
1180     }
1181
1182     /* Switch to bank 1 and set the multicast table. */
1183     saved_bank = inb(ioaddr + CONFIG_1);
1184     outb(0xe4, ioaddr + CONFIG_1);
1185
1186     for (i = 0; i < 8; i++)
1187         outb(mc_filter[i], ioaddr + MAR_ADR + i);
1188     outb(saved_bank, ioaddr + CONFIG_1);
1189
1190     outb(saved_config_0, ioaddr + CONFIG_0);
1191
1192     local_irq_restore(flags);
1193 }