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, void *priv_data)
 323 {
 324         return 0; /* strange, but that's what the code did already before... */
 325 }
 326
 327 static int fmvj18x_config(struct pcmcia_device *link)
 328 {
 329     struct net_device *dev = link->priv;
 330     local_info_t *lp = netdev_priv(dev);
 331     int i, ret;
 332     unsigned int ioaddr;
 333     cardtype_t cardtype;
 334     char *card_name = "unknown";
 335     u8 *buf;
 336     size_t len;
 337     u_char buggybuf[32];
 338
 339     dev_dbg(&link->dev, "fmvj18x_config\n");
 340
 341     link->io_lines = 5;
 342
 343     len = pcmcia_get_tuple(link, CISTPL_FUNCE, &buf);
 344     kfree(buf);
 345
 346     if (len) {
 347         /* Yes, I have CISTPL_FUNCE. Let's check CISTPL_MANFID */
 348         ret = pcmcia_loop_config(link, fmvj18x_ioprobe, NULL);
 349         if (ret != 0)
 350                 goto failed;
 351
 352         switch (link->manf_id) {
 353         case MANFID_TDK:
 354             cardtype = TDK;
 355             if (link->card_id == PRODID_TDK_GN3410 ||
 356                 link->card_id == PRODID_TDK_NP9610 ||
 357                 link->card_id == PRODID_TDK_MN3200) {
 358                 /* MultiFunction Card */
 359                 link->config_base = 0x800;
 360                 link->config_index = 0x47;
 361                 link->resource[1]->end = 8;
 362             }
 363             break;
 364         case MANFID_NEC:
 365             cardtype = NEC; /* MultiFunction Card */
 366             link->config_base = 0x800;
 367             link->config_index = 0x47;
 368             link->resource[1]->end = 8;
 369             break;
 370         case MANFID_KME:
 371             cardtype = KME; /* MultiFunction Card */
 372             link->config_base = 0x800;
 373             link->config_index = 0x47;
 374             link->resource[1]->end = 8;
 375             break;
 376         case MANFID_CONTEC:
 377             cardtype = CONTEC;
 378             break;
 379         case MANFID_FUJITSU:
 380             if (link->config_base == 0x0fe0)
 381                 cardtype = MBH10302;
 382             else if (link->card_id == PRODID_FUJITSU_MBH10302)
 383                 /* RATOC REX-5588/9822/4886's PRODID are 0004(=MBH10302),
 384                    but these are MBH10304 based card. */
 385                 cardtype = MBH10304;
 386             else if (link->card_id == PRODID_FUJITSU_MBH10304)
 387                 cardtype = MBH10304;
 388             else
 389                 cardtype = LA501;
 390             break;
 391         default:
 392             cardtype = MBH10304;
 393         }
 394     } else {
 395         /* old type card */
 396         switch (link->manf_id) {
 397         case MANFID_FUJITSU:
 398             if (link->card_id == PRODID_FUJITSU_MBH10304) {
 399                 cardtype = XXX10304;    /* MBH10304 with buggy CIS */
 400                 link->config_index = 0x20;
 401             } else {
 402                 cardtype = MBH10302;    /* NextCom NC5310, etc. */
 403                 link->config_index = 1;
 404             }
 405             break;
 406         case MANFID_UNGERMANN:
 407             cardtype = UNGERMANN;
 408             break;
 409         default:
 410             cardtype = MBH10302;
 411             link->config_index = 1;
 412         }
 413     }
 414
 415     if (link->resource[1]->end != 0) {
 416         ret = mfc_try_io_port(link);
 417         if (ret != 0) goto failed;
 418     } else if (cardtype == UNGERMANN) {
 419         ret = ungermann_try_io_port(link);
 420         if (ret != 0) goto failed;
 421     } else {
 422             ret = pcmcia_request_io(link);
 423             if (ret)
 424                     goto failed;
 425     }
 426     ret = pcmcia_request_irq(link, fjn_interrupt);
 427     if (ret)
 428             goto failed;
 429     ret = pcmcia_enable_device(link);
 430     if (ret)
 431             goto failed;
 432
 433     dev->irq = link->irq;
 434     dev->base_addr = link->resource[0]->start;
 435
 436     if (resource_size(link->resource[1]) != 0) {
 437         ret = fmvj18x_setup_mfc(link);
 438         if (ret != 0) goto failed;
 439     }
 440
 441     ioaddr = dev->base_addr;
 442
 443     /* Reset controller */
 444     if (sram_config == 0)
 445         outb(CONFIG0_RST, ioaddr + CONFIG_0);
 446     else
 447         outb(CONFIG0_RST_1, ioaddr + CONFIG_0);
 448
 449     /* Power On chip and select bank 0 */
 450     if (cardtype == MBH10302)
 451         outb(BANK_0, ioaddr + CONFIG_1);
 452     else
 453         outb(BANK_0U, ioaddr + CONFIG_1);
 454
 455     /* Set hardware address */
 456     switch (cardtype) {
 457     case MBH10304:
 458     case TDK:
 459     case LA501:
 460     case CONTEC:
 461     case NEC:
 462     case KME:
 463         if (cardtype == MBH10304) {
 464             card_name = "FMV-J182";
 465
 466             len = pcmcia_get_tuple(link, CISTPL_FUNCE, &buf);
 467             if (len < 11) {
 468                     kfree(buf);
 469                     goto failed;
 470             }
 471             /* Read MACID from CIS */
 472             for (i = 5; i < 11; i++)
 473                     dev->dev_addr[i] = buf[i];
 474             kfree(buf);
 475         } else {
 476             if (pcmcia_get_mac_from_cis(link, dev))
 477                 goto failed;
 478             if( cardtype == TDK ) {
 479                 card_name = "TDK LAK-CD021";
 480             } else if( cardtype == LA501 ) {
 481                 card_name = "LA501";
 482             } else if( cardtype == NEC ) {
 483                 card_name = "PK-UG-J001";
 484             } else if( cardtype == KME ) {
 485                 card_name = "Panasonic";
 486             } else {
 487                 card_name = "C-NET(PC)C";
 488             }
 489         }
 490         break;
 491     case UNGERMANN:
 492         /* Read MACID from register */
 493         for (i = 0; i < 6; i++)
 494             dev->dev_addr[i] = inb(ioaddr + UNGERMANN_MAC_ID + i);
 495         card_name = "Access/CARD";
 496         break;
 497     case XXX10304:
 498         /* Read MACID from Buggy CIS */
 499         if (fmvj18x_get_hwinfo(link, buggybuf) == -1) {
 500             printk(KERN_NOTICE "fmvj18x_cs: unable to read hardware net address.\n");
 501             goto failed;
 502         }
 503         for (i = 0 ; i < 6; i++) {
 504             dev->dev_addr[i] = buggybuf[i];
 505         }
 506         card_name = "FMV-J182";
 507         break;
 508     case MBH10302:
 509     default:
 510         /* Read MACID from register */
 511         for (i = 0; i < 6; i++)
 512             dev->dev_addr[i] = inb(ioaddr + MAC_ID + i);
 513         card_name = "FMV-J181";
 514         break;
 515     }
 516
 517     lp->cardtype = cardtype;
 518     SET_NETDEV_DEV(dev, &link->dev);
 519
 520     if (register_netdev(dev) != 0) {
 521         printk(KERN_NOTICE "fmvj18x_cs: register_netdev() failed\n");
 522         goto failed;
 523     }
 524
 525     /* print current configuration */
 526     printk(KERN_INFO "%s: %s, sram %s, port %#3lx, irq %d, "
 527            "hw_addr %pM\n",
 528            dev->name, card_name, sram_config == 0 ? "4K TX*2" : "8K TX*2",
 529            dev->base_addr, dev->irq, dev->dev_addr);
 530
 531     return 0;
 532
 533 failed:
 534     fmvj18x_release(link);
 535     return -ENODEV;
 536 } /* fmvj18x_config */
 537 /*====================================================================*/
 538
 539 static int fmvj18x_get_hwinfo(struct pcmcia_device *link, u_char *node_id)
 540 {
 541     u_char __iomem *base;
 542     int i, j;
 543
 544     /* Allocate a small memory window */
 545     link->resource[2]->flags |= WIN_DATA_WIDTH_8|WIN_MEMORY_TYPE_AM|WIN_ENABLE;
 546     link->resource[2]->start = 0; link->resource[2]->end = 0;
 547     i = pcmcia_request_window(link, link->resource[2], 0);
 548     if (i != 0)
 549         return -1;
 550
 551     base = ioremap(link->resource[2]->start, resource_size(link->resource[2]));
 552     pcmcia_map_mem_page(link, link->resource[2], 0);
 553
 554     /*
 555      *  MBH10304 CISTPL_FUNCE_LAN_NODE_ID format
 556      *  22 0d xx xx xx 04 06 yy yy yy yy yy yy ff
 557      *  'xx' is garbage.
 558      *  'yy' is MAC address.
 559     */
 560     for (i = 0; i < 0x200; i++) {
 561         if (readb(base+i*2) == 0x22) {
 562                 if (readb(base+(i-1)*2) == 0xff &&
 563                     readb(base+(i+5)*2) == 0x04 &&
 564                     readb(base+(i+6)*2) == 0x06 &&
 565                     readb(base+(i+13)*2) == 0xff)
 566                         break;
 567         }
 568     }
 569
 570     if (i != 0x200) {
 571         for (j = 0 ; j < 6; j++,i++) {
 572             node_id[j] = readb(base+(i+7)*2);
 573         }
 574     }
 575
 576     iounmap(base);
 577     j = pcmcia_release_window(link, link->resource[2]);
 578     return (i != 0x200) ? 0 : -1;
 579
 580 } /* fmvj18x_get_hwinfo */
 581 /*====================================================================*/
 582
 583 static int fmvj18x_setup_mfc(struct pcmcia_device *link)
 584 {
 585     int i;
 586     struct net_device *dev = link->priv;
 587     unsigned int ioaddr;
 588     local_info_t *lp = netdev_priv(dev);
 589
 590     /* Allocate a small memory window */
 591     link->resource[3]->flags = WIN_DATA_WIDTH_8|WIN_MEMORY_TYPE_AM|WIN_ENABLE;
 592     link->resource[3]->start = link->resource[3]->end = 0;
 593     i = pcmcia_request_window(link, link->resource[3], 0);
 594     if (i != 0)
 595         return -1;
 596
 597     lp->base = ioremap(link->resource[3]->start,
 598                        resource_size(link->resource[3]));
 599     if (lp->base == NULL) {
 600         printk(KERN_NOTICE "fmvj18x_cs: ioremap failed\n");
 601         return -1;
 602     }
 603
 604     i = pcmcia_map_mem_page(link, link->resource[3], 0);
 605     if (i != 0) {
 606         iounmap(lp->base);
 607         lp->base = NULL;
 608         return -1;
 609     }
 610
 611     ioaddr = dev->base_addr;
 612     writeb(0x47, lp->base+0x800);       /* Config Option Register of LAN */
 613     writeb(0x0,  lp->base+0x802);       /* Config and Status Register */
 614
 615     writeb(ioaddr & 0xff, lp->base+0x80a);        /* I/O Base(Low) of LAN */
 616     writeb((ioaddr >> 8) & 0xff, lp->base+0x80c); /* I/O Base(High) of LAN */
 617
 618     writeb(0x45, lp->base+0x820);       /* Config Option Register of Modem */
 619     writeb(0x8,  lp->base+0x822);       /* Config and Status Register */
 620
 621     return 0;
 622
 623 }
 624 /*====================================================================*/
 625
 626 static void fmvj18x_release(struct pcmcia_device *link)
 627 {
 628
 629     struct net_device *dev = link->priv;
 630     local_info_t *lp = netdev_priv(dev);
 631     u_char __iomem *tmp;
 632
 633     dev_dbg(&link->dev, "fmvj18x_release\n");
 634
 635     if (lp->base != NULL) {
 636         tmp = lp->base;
 637         lp->base = NULL;    /* set NULL before iounmap */
 638         iounmap(tmp);
 639     }
 640
 641     pcmcia_disable_device(link);
 642
 643 }
 644
 645 static int fmvj18x_suspend(struct pcmcia_device *link)
 646 {
 647         struct net_device *dev = link->priv;
 648
 649         if (link->open)
 650                 netif_device_detach(dev);
 651
 652         return 0;
 653 }
 654
 655 static int fmvj18x_resume(struct pcmcia_device *link)
 656 {
 657         struct net_device *dev = link->priv;
 658
 659         if (link->open) {
 660                 fjn_reset(dev);
 661                 netif_device_attach(dev);
 662         }
 663
 664         return 0;
 665 }
 666
 667 /*====================================================================*/
 668
 669 static struct pcmcia_device_id fmvj18x_ids[] = {
 670         PCMCIA_DEVICE_MANF_CARD(0x0004, 0x0004),
 671         PCMCIA_DEVICE_PROD_ID12("EAGLE Technology", "NE200 ETHERNET LAN MBH10302 04", 0x528c88c4, 0x74f91e59),
 672         PCMCIA_DEVICE_PROD_ID12("Eiger Labs,Inc", "EPX-10BT PC Card Ethernet 10BT", 0x53af556e, 0x877f9922),
 673         PCMCIA_DEVICE_PROD_ID12("Eiger labs,Inc.", "EPX-10BT PC Card Ethernet 10BT", 0xf47e6c66, 0x877f9922),
 674         PCMCIA_DEVICE_PROD_ID12("FUJITSU", "LAN Card(FMV-J182)", 0x6ee5a3d8, 0x5baf31db),
 675         PCMCIA_DEVICE_PROD_ID12("FUJITSU", "MBH10308", 0x6ee5a3d8, 0x3f04875e),
 676         PCMCIA_DEVICE_PROD_ID12("FUJITSU TOWA", "LA501", 0xb8451188, 0x12939ba2),
 677         PCMCIA_DEVICE_PROD_ID12("HITACHI", "HT-4840-11", 0xf4f43949, 0x773910f4),
 678         PCMCIA_DEVICE_PROD_ID12("NextComK.K.", "NC5310B Ver1.0       ", 0x8cef4d3a, 0x075fc7b6),
 679         PCMCIA_DEVICE_PROD_ID12("NextComK.K.", "NC5310 Ver1.0        ", 0x8cef4d3a, 0xbccf43e6),
 680         PCMCIA_DEVICE_PROD_ID12("RATOC System Inc.", "10BASE_T CARD R280", 0x85c10e17, 0xd9413666),
 681         PCMCIA_DEVICE_PROD_ID12("TDK", "LAC-CD02x", 0x1eae9475, 0x8fa0ee70),
 682         PCMCIA_DEVICE_PROD_ID12("TDK", "LAC-CF010", 0x1eae9475, 0x7683bc9a),
 683         PCMCIA_DEVICE_PROD_ID1("CONTEC Co.,Ltd.", 0x58d8fee2),
 684         PCMCIA_DEVICE_PROD_ID1("PCMCIA LAN MBH10304  ES", 0x2599f454),
 685         PCMCIA_DEVICE_PROD_ID1("PCMCIA MBH10302", 0x8f4005da),
 686         PCMCIA_DEVICE_PROD_ID1("UBKK,V2.0", 0x90888080),
 687         PCMCIA_PFC_DEVICE_PROD_ID12(0, "TDK", "GlobalNetworker 3410/3412", 0x1eae9475, 0xd9a93bed),
 688         PCMCIA_PFC_DEVICE_PROD_ID12(0, "NEC", "PK-UG-J001" ,0x18df0ba0 ,0x831b1064),
 689         PCMCIA_PFC_DEVICE_MANF_CARD(0, 0x0105, 0x0d0a),
 690         PCMCIA_PFC_DEVICE_MANF_CARD(0, 0x0105, 0x0e0a),
 691         PCMCIA_PFC_DEVICE_MANF_CARD(0, 0x0032, 0x0e01),
 692         PCMCIA_PFC_DEVICE_MANF_CARD(0, 0x0032, 0x0a05),
 693         PCMCIA_PFC_DEVICE_MANF_CARD(0, 0x0032, 0x1101),
 694         PCMCIA_DEVICE_NULL,
 695 };
 696 MODULE_DEVICE_TABLE(pcmcia, fmvj18x_ids);
 697
 698 static struct pcmcia_driver fmvj18x_cs_driver = {
 699         .owner          = THIS_MODULE,
 700         .drv            = {
 701                 .name   = "fmvj18x_cs",
 702         },
 703         .probe          = fmvj18x_probe,
 704         .remove         = fmvj18x_detach,
 705         .id_table       = fmvj18x_ids,
 706         .suspend        = fmvj18x_suspend,
 707         .resume         = fmvj18x_resume,
 708 };
 709
 710 static int __init init_fmvj18x_cs(void)
 711 {
 712         return pcmcia_register_driver(&fmvj18x_cs_driver);
 713 }
 714
 715 static void __exit exit_fmvj18x_cs(void)
 716 {
 717         pcmcia_unregister_driver(&fmvj18x_cs_driver);
 718 }
 719
 720 module_init(init_fmvj18x_cs);
 721 module_exit(exit_fmvj18x_cs);
 722
 723 /*====================================================================*/
 724
 725 static irqreturn_t fjn_interrupt(int dummy, void *dev_id)
 726 {
 727     struct net_device *dev = dev_id;
 728     local_info_t *lp = netdev_priv(dev);
 729     unsigned int ioaddr;
 730     unsigned short tx_stat, rx_stat;
 731
 732     ioaddr = dev->base_addr;
 733
 734     /* avoid multiple interrupts */
 735     outw(0x0000, ioaddr + TX_INTR);
 736
 737     /* wait for a while */
 738     udelay(1);
 739
 740     /* get status */
 741     tx_stat = inb(ioaddr + TX_STATUS);
 742     rx_stat = inb(ioaddr + RX_STATUS);
 743
 744     /* clear status */
 745     outb(tx_stat, ioaddr + TX_STATUS);
 746     outb(rx_stat, ioaddr + RX_STATUS);
 747
 748     pr_debug("%s: interrupt, rx_status %02x.\n", dev->name, rx_stat);
 749     pr_debug("               tx_status %02x.\n", tx_stat);
 750
 751     if (rx_stat || (inb(ioaddr + RX_MODE) & F_BUF_EMP) == 0) {
 752         /* there is packet(s) in rx buffer */
 753         fjn_rx(dev);
 754     }
 755     if (tx_stat & F_TMT_RDY) {
 756         dev->stats.tx_packets += lp->sent ;
 757         lp->sent = 0 ;
 758         if (lp->tx_queue) {
 759             outb(DO_TX | lp->tx_queue, ioaddr + TX_START);
 760             lp->sent = lp->tx_queue ;
 761             lp->tx_queue = 0;
 762             lp->tx_queue_len = 0;
 763             dev->trans_start = jiffies;
 764         } else {
 765             lp->tx_started = 0;
 766         }
 767         netif_wake_queue(dev);
 768     }
 769     pr_debug("%s: exiting interrupt,\n", dev->name);
 770     pr_debug("    tx_status %02x, rx_status %02x.\n", tx_stat, rx_stat);
 771
 772     outb(D_TX_INTR, ioaddr + TX_INTR);
 773     outb(D_RX_INTR, ioaddr + RX_INTR);
 774
 775     if (lp->base != NULL) {
 776         /* Ack interrupt for multifunction card */
 777         writeb(0x01, lp->base+0x802);
 778         writeb(0x09, lp->base+0x822);
 779     }
 780
 781     return IRQ_HANDLED;
 782
 783 } /* fjn_interrupt */
 784
 785 /*====================================================================*/
 786
 787 static void fjn_tx_timeout(struct net_device *dev)
 788 {
 789     struct local_info_t *lp = netdev_priv(dev);
 790     unsigned int ioaddr = dev->base_addr;
 791
 792     printk(KERN_NOTICE "%s: transmit timed out with status %04x, %s?\n",
 793            dev->name, htons(inw(ioaddr + TX_STATUS)),
 794            inb(ioaddr + TX_STATUS) & F_TMT_RDY
 795            ? "IRQ conflict" : "network cable problem");
 796     printk(KERN_NOTICE "%s: timeout registers: %04x %04x %04x "
 797            "%04x %04x %04x %04x %04x.\n",
 798            dev->name, htons(inw(ioaddr + 0)),
 799            htons(inw(ioaddr + 2)), htons(inw(ioaddr + 4)),
 800            htons(inw(ioaddr + 6)), htons(inw(ioaddr + 8)),
 801            htons(inw(ioaddr +10)), htons(inw(ioaddr +12)),
 802            htons(inw(ioaddr +14)));
 803     dev->stats.tx_errors++;
 804     /* ToDo: We should try to restart the adaptor... */
 805     local_irq_disable();
 806     fjn_reset(dev);
 807
 808     lp->tx_started = 0;
 809     lp->tx_queue = 0;
 810     lp->tx_queue_len = 0;
 811     lp->sent = 0;
 812     lp->open_time = jiffies;
 813     local_irq_enable();
 814     netif_wake_queue(dev);
 815 }
 816
 817 static netdev_tx_t fjn_start_xmit(struct sk_buff *skb,
 818                                         struct net_device *dev)
 819 {
 820     struct local_info_t *lp = netdev_priv(dev);
 821     unsigned int ioaddr = dev->base_addr;
 822     short length = skb->len;
 823
 824     if (length < ETH_ZLEN)
 825     {
 826         if (skb_padto(skb, ETH_ZLEN))
 827                 return NETDEV_TX_OK;
 828         length = ETH_ZLEN;
 829     }
 830
 831     netif_stop_queue(dev);
 832
 833     {
 834         unsigned char *buf = skb->data;
 835
 836         if (length > ETH_FRAME_LEN) {
 837             printk(KERN_NOTICE "%s: Attempting to send a large packet"
 838                    " (%d bytes).\n", dev->name, length);
 839             return NETDEV_TX_BUSY;
 840         }
 841
 842         pr_debug("%s: Transmitting a packet of length %lu.\n",
 843               dev->name, (unsigned long)skb->len);
 844         dev->stats.tx_bytes += skb->len;
 845
 846         /* Disable both interrupts. */
 847         outw(0x0000, ioaddr + TX_INTR);
 848
 849         /* wait for a while */
 850         udelay(1);
 851
 852         outw(length, ioaddr + DATAPORT);
 853         outsw(ioaddr + DATAPORT, buf, (length + 1) >> 1);
 854
 855         lp->tx_queue++;
 856         lp->tx_queue_len += ((length+3) & ~1);
 857
 858         if (lp->tx_started == 0) {
 859             /* If the Tx is idle, always trigger a transmit. */
 860             outb(DO_TX | lp->tx_queue, ioaddr + TX_START);
 861             lp->sent = lp->tx_queue ;
 862             lp->tx_queue = 0;
 863             lp->tx_queue_len = 0;
 864             lp->tx_started = 1;
 865             netif_start_queue(dev);
 866         } else {
 867             if( sram_config == 0 ) {
 868                 if (lp->tx_queue_len < (4096 - (ETH_FRAME_LEN +2)) )
 869                     /* Yes, there is room for one more packet. */
 870                     netif_start_queue(dev);
 871             } else {
 872                 if (lp->tx_queue_len < (8192 - (ETH_FRAME_LEN +2)) &&
 873                                                 lp->tx_queue < 127 )
 874                     /* Yes, there is room for one more packet. */
 875                     netif_start_queue(dev);
 876             }
 877         }
 878
 879         /* Re-enable interrupts */
 880         outb(D_TX_INTR, ioaddr + TX_INTR);
 881         outb(D_RX_INTR, ioaddr + RX_INTR);
 882     }
 883     dev_kfree_skb (skb);
 884
 885     return NETDEV_TX_OK;
 886 } /* fjn_start_xmit */
 887
 888 /*====================================================================*/
 889
 890 static void fjn_reset(struct net_device *dev)
 891 {
 892     struct local_info_t *lp = netdev_priv(dev);
 893     unsigned int ioaddr = dev->base_addr;
 894     int i;
 895
 896     pr_debug("fjn_reset(%s) called.\n",dev->name);
 897
 898     /* Reset controller */
 899     if( sram_config == 0 )
 900         outb(CONFIG0_RST, ioaddr + CONFIG_0);
 901     else
 902         outb(CONFIG0_RST_1, ioaddr + CONFIG_0);
 903
 904     /* Power On chip and select bank 0 */
 905     if (lp->cardtype == MBH10302)
 906         outb(BANK_0, ioaddr + CONFIG_1);
 907     else
 908         outb(BANK_0U, ioaddr + CONFIG_1);
 909
 910     /* Set Tx modes */
 911     outb(D_TX_MODE, ioaddr + TX_MODE);
 912     /* set Rx modes */
 913     outb(ID_MATCHED, ioaddr + RX_MODE);
 914
 915     /* Set hardware address */
 916     for (i = 0; i < 6; i++)
 917         outb(dev->dev_addr[i], ioaddr + NODE_ID + i);
 918
 919     /* (re)initialize the multicast table */
 920     set_rx_mode(dev);
 921
 922     /* Switch to bank 2 (runtime mode) */
 923     if (lp->cardtype == MBH10302)
 924         outb(BANK_2, ioaddr + CONFIG_1);
 925     else
 926         outb(BANK_2U, ioaddr + CONFIG_1);
 927
 928     /* set 16col ctrl bits */
 929     if( lp->cardtype == TDK || lp->cardtype == CONTEC)
 930         outb(TDK_AUTO_MODE, ioaddr + COL_CTRL);
 931     else
 932         outb(AUTO_MODE, ioaddr + COL_CTRL);
 933
 934     /* clear Reserved Regs */
 935     outb(0x00, ioaddr + BMPR12);
 936     outb(0x00, ioaddr + BMPR13);
 937
 938     /* reset Skip packet reg. */
 939     outb(0x01, ioaddr + RX_SKIP);
 940
 941     /* Enable Tx and Rx */
 942     if( sram_config == 0 )
 943         outb(CONFIG0_DFL, ioaddr + CONFIG_0);
 944     else
 945         outb(CONFIG0_DFL_1, ioaddr + CONFIG_0);
 946
 947     /* Init receive pointer ? */
 948     inw(ioaddr + DATAPORT);
 949     inw(ioaddr + DATAPORT);
 950
 951     /* Clear all status */
 952     outb(0xff, ioaddr + TX_STATUS);
 953     outb(0xff, ioaddr + RX_STATUS);
 954
 955     if (lp->cardtype == MBH10302)
 956         outb(INTR_OFF, ioaddr + LAN_CTRL);
 957
 958     /* Turn on Rx interrupts */
 959     outb(D_TX_INTR, ioaddr + TX_INTR);
 960     outb(D_RX_INTR, ioaddr + RX_INTR);
 961
 962     /* Turn on interrupts from LAN card controller */
 963     if (lp->cardtype == MBH10302)
 964         outb(INTR_ON, ioaddr + LAN_CTRL);
 965 } /* fjn_reset */
 966
 967 /*====================================================================*/
 968
 969 static void fjn_rx(struct net_device *dev)
 970 {
 971     unsigned int ioaddr = dev->base_addr;
 972     int boguscount = 10;        /* 5 -> 10: by agy 19940922 */
 973
 974     pr_debug("%s: in rx_packet(), rx_status %02x.\n",
 975           dev->name, inb(ioaddr + RX_STATUS));
 976
 977     while ((inb(ioaddr + RX_MODE) & F_BUF_EMP) == 0) {
 978         u_short status = inw(ioaddr + DATAPORT);
 979
 980         pr_debug("%s: Rxing packet mode %02x status %04x.\n",
 981               dev->name, inb(ioaddr + RX_MODE), status);
 982 #ifndef final_version
 983         if (status == 0) {
 984             outb(F_SKP_PKT, ioaddr + RX_SKIP);
 985             break;
 986         }
 987 #endif
 988         if ((status & 0xF0) != 0x20) {  /* There was an error. */
 989             dev->stats.rx_errors++;
 990             if (status & F_LEN_ERR) dev->stats.rx_length_errors++;
 991             if (status & F_ALG_ERR) dev->stats.rx_frame_errors++;
 992             if (status & F_CRC_ERR) dev->stats.rx_crc_errors++;
 993             if (status & F_OVR_FLO) dev->stats.rx_over_errors++;
 994         } else {
 995             u_short pkt_len = inw(ioaddr + DATAPORT);
 996             /* Malloc up new buffer. */
 997             struct sk_buff *skb;
 998
 999             if (pkt_len > 1550) {
1000                 printk(KERN_NOTICE "%s: The FMV-18x claimed a very "
1001                        "large packet, size %d.\n", dev->name, pkt_len);
1002                 outb(F_SKP_PKT, ioaddr + RX_SKIP);
1003                 dev->stats.rx_errors++;
1004                 break;
1005             }
1006             skb = dev_alloc_skb(pkt_len+2);
1007             if (skb == NULL) {
1008                 printk(KERN_NOTICE "%s: Memory squeeze, dropping "
1009                        "packet (len %d).\n", dev->name, pkt_len);
1010                 outb(F_SKP_PKT, ioaddr + RX_SKIP);
1011                 dev->stats.rx_dropped++;
1012                 break;
1013             }
1014
1015             skb_reserve(skb, 2);
1016             insw(ioaddr + DATAPORT, skb_put(skb, pkt_len),
1017                  (pkt_len + 1) >> 1);
1018             skb->protocol = eth_type_trans(skb, dev);
1019
1020             {
1021                 int i;
1022                 pr_debug("%s: Rxed packet of length %d: ",
1023                         dev->name, pkt_len);
1024                 for (i = 0; i < 14; i++)
1025                         pr_debug(" %02x", skb->data[i]);
1026                 pr_debug(".\n");
1027             }
1028
1029             netif_rx(skb);
1030             dev->stats.rx_packets++;
1031             dev->stats.rx_bytes += pkt_len;
1032         }
1033         if (--boguscount <= 0)
1034             break;
1035     }
1036
1037     /* If any worth-while packets have been received, dev_rint()
1038            has done a netif_wake_queue() for us and will work on them
1039            when we get to the bottom-half routine. */
1040 /*
1041     if (lp->cardtype != TDK) {
1042         int i;
1043         for (i = 0; i < 20; i++) {
1044             if ((inb(ioaddr + RX_MODE) & F_BUF_EMP) == F_BUF_EMP)
1045                 break;
1046             (void)inw(ioaddr + DATAPORT);  /+ dummy status read +/
1047             outb(F_SKP_PKT, ioaddr + RX_SKIP);
1048         }
1049
1050         if (i > 0)
1051             pr_debug("%s: Exint Rx packet with mode %02x after "
1052                   "%d ticks.\n", dev->name, inb(ioaddr + RX_MODE), i);
1053     }
1054 */
1055 } /* fjn_rx */
1056
1057 /*====================================================================*/
1058
1059 static void netdev_get_drvinfo(struct net_device *dev,
1060                                struct ethtool_drvinfo *info)
1061 {
1062         strcpy(info->driver, DRV_NAME);
1063         strcpy(info->version, DRV_VERSION);
1064         sprintf(info->bus_info, "PCMCIA 0x%lx", dev->base_addr);
1065 }
1066
1067 static const struct ethtool_ops netdev_ethtool_ops = {
1068         .get_drvinfo            = netdev_get_drvinfo,
1069 };
1070
1071 static int fjn_config(struct net_device *dev, struct ifmap *map){
1072     return 0;
1073 }
1074
1075 static int fjn_open(struct net_device *dev)
1076 {
1077     struct local_info_t *lp = netdev_priv(dev);
1078     struct pcmcia_device *link = lp->p_dev;
1079
1080     pr_debug("fjn_open('%s').\n", dev->name);
1081
1082     if (!pcmcia_dev_present(link))
1083         return -ENODEV;
1084
1085     link->open++;
1086
1087     fjn_reset(dev);
1088
1089     lp->tx_started = 0;
1090     lp->tx_queue = 0;
1091     lp->tx_queue_len = 0;
1092     lp->open_time = jiffies;
1093     netif_start_queue(dev);
1094
1095     return 0;
1096 } /* fjn_open */
1097
1098 /*====================================================================*/
1099
1100 static int fjn_close(struct net_device *dev)
1101 {
1102     struct local_info_t *lp = netdev_priv(dev);
1103     struct pcmcia_device *link = lp->p_dev;
1104     unsigned int ioaddr = dev->base_addr;
1105
1106     pr_debug("fjn_close('%s').\n", dev->name);
1107
1108     lp->open_time = 0;
1109     netif_stop_queue(dev);
1110
1111     /* Set configuration register 0 to disable Tx and Rx. */
1112     if( sram_config == 0 )
1113         outb(CONFIG0_RST ,ioaddr + CONFIG_0);
1114     else
1115         outb(CONFIG0_RST_1 ,ioaddr + CONFIG_0);
1116
1117     /* Update the statistics -- ToDo. */
1118
1119     /* Power-down the chip.  Green, green, green! */
1120     outb(CHIP_OFF ,ioaddr + CONFIG_1);
1121
1122     /* Set the ethernet adaptor disable IRQ */
1123     if (lp->cardtype == MBH10302)
1124         outb(INTR_OFF, ioaddr + LAN_CTRL);
1125
1126     link->open--;
1127
1128     return 0;
1129 } /* fjn_close */
1130
1131 /*====================================================================*/
1132
1133 /*
1134   Set the multicast/promiscuous mode for this adaptor.
1135 */
1136
1137 static void set_rx_mode(struct net_device *dev)
1138 {
1139     unsigned int ioaddr = dev->base_addr;
1140     u_char mc_filter[8];                 /* Multicast hash filter */
1141     u_long flags;
1142     int i;
1143
1144     int saved_bank;
1145     int saved_config_0 = inb(ioaddr + CONFIG_0);
1146
1147     local_irq_save(flags);
1148
1149     /* Disable Tx and Rx */
1150     if (sram_config == 0)
1151         outb(CONFIG0_RST, ioaddr + CONFIG_0);
1152     else
1153         outb(CONFIG0_RST_1, ioaddr + CONFIG_0);
1154
1155     if (dev->flags & IFF_PROMISC) {
1156         memset(mc_filter, 0xff, sizeof(mc_filter));
1157         outb(3, ioaddr + RX_MODE);      /* Enable promiscuous mode */
1158     } else if (netdev_mc_count(dev) > MC_FILTERBREAK ||
1159                (dev->flags & IFF_ALLMULTI)) {
1160         /* Too many to filter perfectly -- accept all multicasts. */
1161         memset(mc_filter, 0xff, sizeof(mc_filter));
1162         outb(2, ioaddr + RX_MODE);      /* Use normal mode. */
1163     } else if (netdev_mc_empty(dev)) {
1164         memset(mc_filter, 0x00, sizeof(mc_filter));
1165         outb(1, ioaddr + RX_MODE);      /* Ignore almost all multicasts. */
1166     } else {
1167         struct netdev_hw_addr *ha;
1168
1169         memset(mc_filter, 0, sizeof(mc_filter));
1170         netdev_for_each_mc_addr(ha, dev) {
1171             unsigned int bit = ether_crc_le(ETH_ALEN, ha->addr) >> 26;
1172             mc_filter[bit >> 3] |= (1 << (bit & 7));
1173         }
1174         outb(2, ioaddr + RX_MODE);      /* Use normal mode. */
1175     }
1176
1177     /* Switch to bank 1 and set the multicast table. */
1178     saved_bank = inb(ioaddr + CONFIG_1);
1179     outb(0xe4, ioaddr + CONFIG_1);
1180
1181     for (i = 0; i < 8; i++)
1182         outb(mc_filter[i], ioaddr + MAR_ADR + i);
1183     outb(saved_bank, ioaddr + CONFIG_1);
1184
1185     outb(saved_config_0, ioaddr + CONFIG_0);
1186
1187     local_irq_restore(flags);
1188 }