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