drivers/net/ethernet/fujitsu/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 pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  32
  33 #define DRV_NAME        "fmvj18x_cs"
  34 #define DRV_VERSION     "2.9"
  35
  36 #include <linux/module.h>
  37 #include <linux/kernel.h>
  38 #include <linux/ptrace.h>
  39 #include <linux/slab.h>
  40 #include <linux/string.h>
  41 #include <linux/timer.h>
  42 #include <linux/interrupt.h>
  43 #include <linux/in.h>
  44 #include <linux/delay.h>
  45 #include <linux/ethtool.h>
  46 #include <linux/netdevice.h>
  47 #include <linux/etherdevice.h>
  48 #include <linux/skbuff.h>
  49 #include <linux/if_arp.h>
  50 #include <linux/ioport.h>
  51 #include <linux/crc32.h>
  52
  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
  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 enum cardtype { MBH10302, MBH10304, TDK, CONTEC, LA501, UNGERMANN,
 103                XXX10304, NEC, KME
 104 };
 105
 106 /*
 107     driver specific data structure
 108 */
 109 struct local_info {
 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     enum cardtype cardtype;
 116     u_short sent;
 117     u_char __iomem *base;
 118 };
 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_rx_mode        = 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     struct local_info *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(struct local_info));
 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     dev->ethtool_ops = &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             pr_notice("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     struct local_info *lp = netdev_priv(dev);
 331     int i, ret;
 332     unsigned int ioaddr;
 333     enum cardtype 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 = 0; i < 6; i++)
 473                     dev->dev_addr[i] = buf[i + 5];
 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             pr_notice("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         pr_notice("register_netdev() failed\n");
 522         goto failed;
 523     }
 524
 525     /* print current configuration */
 526     netdev_info(dev, "%s, sram %s, port %#3lx, irq %d, hw_addr %pM\n",
 527                 card_name, sram_config == 0 ? "4K TX*2" : "8K TX*2",
 528                 dev->base_addr, dev->irq, dev->dev_addr);
 529
 530     return 0;
 531
 532 failed:
 533     fmvj18x_release(link);
 534     return -ENODEV;
 535 } /* fmvj18x_config */
 536 /*====================================================================*/
 537
 538 static int fmvj18x_get_hwinfo(struct pcmcia_device *link, u_char *node_id)
 539 {
 540     u_char __iomem *base;
 541     int i, j;
 542
 543     /* Allocate a small memory window */
 544     link->resource[2]->flags |= WIN_DATA_WIDTH_8|WIN_MEMORY_TYPE_AM|WIN_ENABLE;
 545     link->resource[2]->start = 0; link->resource[2]->end = 0;
 546     i = pcmcia_request_window(link, link->resource[2], 0);
 547     if (i != 0)
 548         return -1;
 549
 550     base = ioremap(link->resource[2]->start, resource_size(link->resource[2]));
 551     if (!base) {
 552         pcmcia_release_window(link, link->resource[2]);
 553         return -1;
 554     }
 555
 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     struct local_info *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         netdev_notice(dev, "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     struct local_info *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 const 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, 0x0b05),
 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         .name           = "fmvj18x_cs",
 706         .probe          = fmvj18x_probe,
 707         .remove         = fmvj18x_detach,
 708         .id_table       = fmvj18x_ids,
 709         .suspend        = fmvj18x_suspend,
 710         .resume         = fmvj18x_resume,
 711 };
 712 module_pcmcia_driver(fmvj18x_cs_driver);
 713
 714 /*====================================================================*/
 715
 716 static irqreturn_t fjn_interrupt(int dummy, void *dev_id)
 717 {
 718     struct net_device *dev = dev_id;
 719     struct local_info *lp = netdev_priv(dev);
 720     unsigned int ioaddr;
 721     unsigned short tx_stat, rx_stat;
 722
 723     ioaddr = dev->base_addr;
 724
 725     /* avoid multiple interrupts */
 726     outw(0x0000, ioaddr + TX_INTR);
 727
 728     /* wait for a while */
 729     udelay(1);
 730
 731     /* get status */
 732     tx_stat = inb(ioaddr + TX_STATUS);
 733     rx_stat = inb(ioaddr + RX_STATUS);
 734
 735     /* clear status */
 736     outb(tx_stat, ioaddr + TX_STATUS);
 737     outb(rx_stat, ioaddr + RX_STATUS);
 738
 739     pr_debug("%s: interrupt, rx_status %02x.\n", dev->name, rx_stat);
 740     pr_debug("               tx_status %02x.\n", tx_stat);
 741
 742     if (rx_stat || (inb(ioaddr + RX_MODE) & F_BUF_EMP) == 0) {
 743         /* there is packet(s) in rx buffer */
 744         fjn_rx(dev);
 745     }
 746     if (tx_stat & F_TMT_RDY) {
 747         dev->stats.tx_packets += lp->sent ;
 748         lp->sent = 0 ;
 749         if (lp->tx_queue) {
 750             outb(DO_TX | lp->tx_queue, ioaddr + TX_START);
 751             lp->sent = lp->tx_queue ;
 752             lp->tx_queue = 0;
 753             lp->tx_queue_len = 0;
 754             netif_trans_update(dev);
 755         } else {
 756             lp->tx_started = 0;
 757         }
 758         netif_wake_queue(dev);
 759     }
 760     pr_debug("%s: exiting interrupt,\n", dev->name);
 761     pr_debug("    tx_status %02x, rx_status %02x.\n", tx_stat, rx_stat);
 762
 763     outb(D_TX_INTR, ioaddr + TX_INTR);
 764     outb(D_RX_INTR, ioaddr + RX_INTR);
 765
 766     if (lp->base != NULL) {
 767         /* Ack interrupt for multifunction card */
 768         writeb(0x01, lp->base+0x802);
 769         writeb(0x09, lp->base+0x822);
 770     }
 771
 772     return IRQ_HANDLED;
 773
 774 } /* fjn_interrupt */
 775
 776 /*====================================================================*/
 777
 778 static void fjn_tx_timeout(struct net_device *dev)
 779 {
 780     struct local_info *lp = netdev_priv(dev);
 781     unsigned int ioaddr = dev->base_addr;
 782
 783     netdev_notice(dev, "transmit timed out with status %04x, %s?\n",
 784                   htons(inw(ioaddr + TX_STATUS)),
 785                   inb(ioaddr + TX_STATUS) & F_TMT_RDY
 786                   ? "IRQ conflict" : "network cable problem");
 787     netdev_notice(dev, "timeout registers: %04x %04x %04x "
 788                   "%04x %04x %04x %04x %04x.\n",
 789                   htons(inw(ioaddr + 0)), htons(inw(ioaddr + 2)),
 790                   htons(inw(ioaddr + 4)), htons(inw(ioaddr + 6)),
 791                   htons(inw(ioaddr + 8)), htons(inw(ioaddr + 10)),
 792                   htons(inw(ioaddr + 12)), htons(inw(ioaddr + 14)));
 793     dev->stats.tx_errors++;
 794     /* ToDo: We should try to restart the adaptor... */
 795     local_irq_disable();
 796     fjn_reset(dev);
 797
 798     lp->tx_started = 0;
 799     lp->tx_queue = 0;
 800     lp->tx_queue_len = 0;
 801     lp->sent = 0;
 802     lp->open_time = jiffies;
 803     local_irq_enable();
 804     netif_wake_queue(dev);
 805 }
 806
 807 static netdev_tx_t fjn_start_xmit(struct sk_buff *skb,
 808                                         struct net_device *dev)
 809 {
 810     struct local_info *lp = netdev_priv(dev);
 811     unsigned int ioaddr = dev->base_addr;
 812     short length = skb->len;
 813
 814     if (length < ETH_ZLEN)
 815     {
 816         if (skb_padto(skb, ETH_ZLEN))
 817                 return NETDEV_TX_OK;
 818         length = ETH_ZLEN;
 819     }
 820
 821     netif_stop_queue(dev);
 822
 823     {
 824         unsigned char *buf = skb->data;
 825
 826         if (length > ETH_FRAME_LEN) {
 827             netdev_notice(dev, "Attempting to send a large packet (%d bytes)\n",
 828                           length);
 829             return NETDEV_TX_BUSY;
 830         }
 831
 832         netdev_dbg(dev, "Transmitting a packet of length %lu\n",
 833                    (unsigned long)skb->len);
 834         dev->stats.tx_bytes += skb->len;
 835
 836         /* Disable both interrupts. */
 837         outw(0x0000, ioaddr + TX_INTR);
 838
 839         /* wait for a while */
 840         udelay(1);
 841
 842         outw(length, ioaddr + DATAPORT);
 843         outsw(ioaddr + DATAPORT, buf, (length + 1) >> 1);
 844
 845         lp->tx_queue++;
 846         lp->tx_queue_len += ((length+3) & ~1);
 847
 848         if (lp->tx_started == 0) {
 849             /* If the Tx is idle, always trigger a transmit. */
 850             outb(DO_TX | lp->tx_queue, ioaddr + TX_START);
 851             lp->sent = lp->tx_queue ;
 852             lp->tx_queue = 0;
 853             lp->tx_queue_len = 0;
 854             lp->tx_started = 1;
 855             netif_start_queue(dev);
 856         } else {
 857             if( sram_config == 0 ) {
 858                 if (lp->tx_queue_len < (4096 - (ETH_FRAME_LEN +2)) )
 859                     /* Yes, there is room for one more packet. */
 860                     netif_start_queue(dev);
 861             } else {
 862                 if (lp->tx_queue_len < (8192 - (ETH_FRAME_LEN +2)) &&
 863                                                 lp->tx_queue < 127 )
 864                     /* Yes, there is room for one more packet. */
 865                     netif_start_queue(dev);
 866             }
 867         }
 868
 869         /* Re-enable interrupts */
 870         outb(D_TX_INTR, ioaddr + TX_INTR);
 871         outb(D_RX_INTR, ioaddr + RX_INTR);
 872     }
 873     dev_kfree_skb (skb);
 874
 875     return NETDEV_TX_OK;
 876 } /* fjn_start_xmit */
 877
 878 /*====================================================================*/
 879
 880 static void fjn_reset(struct net_device *dev)
 881 {
 882     struct local_info *lp = netdev_priv(dev);
 883     unsigned int ioaddr = dev->base_addr;
 884     int i;
 885
 886     netdev_dbg(dev, "fjn_reset() called\n");
 887
 888     /* Reset controller */
 889     if( sram_config == 0 )
 890         outb(CONFIG0_RST, ioaddr + CONFIG_0);
 891     else
 892         outb(CONFIG0_RST_1, ioaddr + CONFIG_0);
 893
 894     /* Power On chip and select bank 0 */
 895     if (lp->cardtype == MBH10302)
 896         outb(BANK_0, ioaddr + CONFIG_1);
 897     else
 898         outb(BANK_0U, ioaddr + CONFIG_1);
 899
 900     /* Set Tx modes */
 901     outb(D_TX_MODE, ioaddr + TX_MODE);
 902     /* set Rx modes */
 903     outb(ID_MATCHED, ioaddr + RX_MODE);
 904
 905     /* Set hardware address */
 906     for (i = 0; i < 6; i++)
 907         outb(dev->dev_addr[i], ioaddr + NODE_ID + i);
 908
 909     /* (re)initialize the multicast table */
 910     set_rx_mode(dev);
 911
 912     /* Switch to bank 2 (runtime mode) */
 913     if (lp->cardtype == MBH10302)
 914         outb(BANK_2, ioaddr + CONFIG_1);
 915     else
 916         outb(BANK_2U, ioaddr + CONFIG_1);
 917
 918     /* set 16col ctrl bits */
 919     if( lp->cardtype == TDK || lp->cardtype == CONTEC)
 920         outb(TDK_AUTO_MODE, ioaddr + COL_CTRL);
 921     else
 922         outb(AUTO_MODE, ioaddr + COL_CTRL);
 923
 924     /* clear Reserved Regs */
 925     outb(0x00, ioaddr + BMPR12);
 926     outb(0x00, ioaddr + BMPR13);
 927
 928     /* reset Skip packet reg. */
 929     outb(0x01, ioaddr + RX_SKIP);
 930
 931     /* Enable Tx and Rx */
 932     if( sram_config == 0 )
 933         outb(CONFIG0_DFL, ioaddr + CONFIG_0);
 934     else
 935         outb(CONFIG0_DFL_1, ioaddr + CONFIG_0);
 936
 937     /* Init receive pointer ? */
 938     inw(ioaddr + DATAPORT);
 939     inw(ioaddr + DATAPORT);
 940
 941     /* Clear all status */
 942     outb(0xff, ioaddr + TX_STATUS);
 943     outb(0xff, ioaddr + RX_STATUS);
 944
 945     if (lp->cardtype == MBH10302)
 946         outb(INTR_OFF, ioaddr + LAN_CTRL);
 947
 948     /* Turn on Rx interrupts */
 949     outb(D_TX_INTR, ioaddr + TX_INTR);
 950     outb(D_RX_INTR, ioaddr + RX_INTR);
 951
 952     /* Turn on interrupts from LAN card controller */
 953     if (lp->cardtype == MBH10302)
 954         outb(INTR_ON, ioaddr + LAN_CTRL);
 955 } /* fjn_reset */
 956
 957 /*====================================================================*/
 958
 959 static void fjn_rx(struct net_device *dev)
 960 {
 961     unsigned int ioaddr = dev->base_addr;
 962     int boguscount = 10;        /* 5 -> 10: by agy 19940922 */
 963
 964     pr_debug("%s: in rx_packet(), rx_status %02x.\n",
 965           dev->name, inb(ioaddr + RX_STATUS));
 966
 967     while ((inb(ioaddr + RX_MODE) & F_BUF_EMP) == 0) {
 968         u_short status = inw(ioaddr + DATAPORT);
 969
 970         netdev_dbg(dev, "Rxing packet mode %02x status %04x.\n",
 971                    inb(ioaddr + RX_MODE), status);
 972 #ifndef final_version
 973         if (status == 0) {
 974             outb(F_SKP_PKT, ioaddr + RX_SKIP);
 975             break;
 976         }
 977 #endif
 978         if ((status & 0xF0) != 0x20) {  /* There was an error. */
 979             dev->stats.rx_errors++;
 980             if (status & F_LEN_ERR) dev->stats.rx_length_errors++;
 981             if (status & F_ALG_ERR) dev->stats.rx_frame_errors++;
 982             if (status & F_CRC_ERR) dev->stats.rx_crc_errors++;
 983             if (status & F_OVR_FLO) dev->stats.rx_over_errors++;
 984         } else {
 985             u_short pkt_len = inw(ioaddr + DATAPORT);
 986             /* Malloc up new buffer. */
 987             struct sk_buff *skb;
 988
 989             if (pkt_len > 1550) {
 990                 netdev_notice(dev, "The FMV-18x claimed a very large packet, size %d\n",
 991                               pkt_len);
 992                 outb(F_SKP_PKT, ioaddr + RX_SKIP);
 993                 dev->stats.rx_errors++;
 994                 break;
 995             }
 996             skb = netdev_alloc_skb(dev, pkt_len + 2);
 997             if (skb == NULL) {
 998                 outb(F_SKP_PKT, ioaddr + RX_SKIP);
 999                 dev->stats.rx_dropped++;
1000                 break;
1001             }
1002
1003             skb_reserve(skb, 2);
1004             insw(ioaddr + DATAPORT, skb_put(skb, pkt_len),
1005                  (pkt_len + 1) >> 1);
1006             skb->protocol = eth_type_trans(skb, dev);
1007
1008             {
1009                 int i;
1010                 pr_debug("%s: Rxed packet of length %d: ",
1011                         dev->name, pkt_len);
1012                 for (i = 0; i < 14; i++)
1013                         pr_debug(" %02x", skb->data[i]);
1014                 pr_debug(".\n");
1015             }
1016
1017             netif_rx(skb);
1018             dev->stats.rx_packets++;
1019             dev->stats.rx_bytes += pkt_len;
1020         }
1021         if (--boguscount <= 0)
1022             break;
1023     }
1024
1025     /* If any worth-while packets have been received, dev_rint()
1026            has done a netif_wake_queue() for us and will work on them
1027            when we get to the bottom-half routine. */
1028 /*
1029     if (lp->cardtype != TDK) {
1030         int i;
1031         for (i = 0; i < 20; i++) {
1032             if ((inb(ioaddr + RX_MODE) & F_BUF_EMP) == F_BUF_EMP)
1033                 break;
1034             (void)inw(ioaddr + DATAPORT);  /+ dummy status read +/
1035             outb(F_SKP_PKT, ioaddr + RX_SKIP);
1036         }
1037
1038         if (i > 0)
1039             pr_debug("%s: Exint Rx packet with mode %02x after "
1040                   "%d ticks.\n", dev->name, inb(ioaddr + RX_MODE), i);
1041     }
1042 */
1043 } /* fjn_rx */
1044
1045 /*====================================================================*/
1046
1047 static void netdev_get_drvinfo(struct net_device *dev,
1048                                struct ethtool_drvinfo *info)
1049 {
1050         strlcpy(info->driver, DRV_NAME, sizeof(info->driver));
1051         strlcpy(info->version, DRV_VERSION, sizeof(info->version));
1052         snprintf(info->bus_info, sizeof(info->bus_info),
1053                 "PCMCIA 0x%lx", dev->base_addr);
1054 }
1055
1056 static const struct ethtool_ops netdev_ethtool_ops = {
1057         .get_drvinfo            = netdev_get_drvinfo,
1058 };
1059
1060 static int fjn_config(struct net_device *dev, struct ifmap *map){
1061     return 0;
1062 }
1063
1064 static int fjn_open(struct net_device *dev)
1065 {
1066     struct local_info *lp = netdev_priv(dev);
1067     struct pcmcia_device *link = lp->p_dev;
1068
1069     pr_debug("fjn_open('%s').\n", dev->name);
1070
1071     if (!pcmcia_dev_present(link))
1072         return -ENODEV;
1073
1074     link->open++;
1075
1076     fjn_reset(dev);
1077
1078     lp->tx_started = 0;
1079     lp->tx_queue = 0;
1080     lp->tx_queue_len = 0;
1081     lp->open_time = jiffies;
1082     netif_start_queue(dev);
1083
1084     return 0;
1085 } /* fjn_open */
1086
1087 /*====================================================================*/
1088
1089 static int fjn_close(struct net_device *dev)
1090 {
1091     struct local_info *lp = netdev_priv(dev);
1092     struct pcmcia_device *link = lp->p_dev;
1093     unsigned int ioaddr = dev->base_addr;
1094
1095     pr_debug("fjn_close('%s').\n", dev->name);
1096
1097     lp->open_time = 0;
1098     netif_stop_queue(dev);
1099
1100     /* Set configuration register 0 to disable Tx and Rx. */
1101     if( sram_config == 0 )
1102         outb(CONFIG0_RST ,ioaddr + CONFIG_0);
1103     else
1104         outb(CONFIG0_RST_1 ,ioaddr + CONFIG_0);
1105
1106     /* Update the statistics -- ToDo. */
1107
1108     /* Power-down the chip.  Green, green, green! */
1109     outb(CHIP_OFF ,ioaddr + CONFIG_1);
1110
1111     /* Set the ethernet adaptor disable IRQ */
1112     if (lp->cardtype == MBH10302)
1113         outb(INTR_OFF, ioaddr + LAN_CTRL);
1114
1115     link->open--;
1116
1117     return 0;
1118 } /* fjn_close */
1119
1120 /*====================================================================*/
1121
1122 /*
1123   Set the multicast/promiscuous mode for this adaptor.
1124 */
1125
1126 static void set_rx_mode(struct net_device *dev)
1127 {
1128     unsigned int ioaddr = dev->base_addr;
1129     u_char mc_filter[8];                 /* Multicast hash filter */
1130     u_long flags;
1131     int i;
1132
1133     int saved_bank;
1134     int saved_config_0 = inb(ioaddr + CONFIG_0);
1135
1136     local_irq_save(flags);
1137
1138     /* Disable Tx and Rx */
1139     if (sram_config == 0)
1140         outb(CONFIG0_RST, ioaddr + CONFIG_0);
1141     else
1142         outb(CONFIG0_RST_1, ioaddr + CONFIG_0);
1143
1144     if (dev->flags & IFF_PROMISC) {
1145         memset(mc_filter, 0xff, sizeof(mc_filter));
1146         outb(3, ioaddr + RX_MODE);      /* Enable promiscuous mode */
1147     } else if (netdev_mc_count(dev) > MC_FILTERBREAK ||
1148                (dev->flags & IFF_ALLMULTI)) {
1149         /* Too many to filter perfectly -- accept all multicasts. */
1150         memset(mc_filter, 0xff, sizeof(mc_filter));
1151         outb(2, ioaddr + RX_MODE);      /* Use normal mode. */
1152     } else if (netdev_mc_empty(dev)) {
1153         memset(mc_filter, 0x00, sizeof(mc_filter));
1154         outb(1, ioaddr + RX_MODE);      /* Ignore almost all multicasts. */
1155     } else {
1156         struct netdev_hw_addr *ha;
1157
1158         memset(mc_filter, 0, sizeof(mc_filter));
1159         netdev_for_each_mc_addr(ha, dev) {
1160             unsigned int bit = ether_crc_le(ETH_ALEN, ha->addr) >> 26;
1161             mc_filter[bit >> 3] |= (1 << (bit & 7));
1162         }
1163         outb(2, ioaddr + RX_MODE);      /* Use normal mode. */
1164     }
1165
1166     /* Switch to bank 1 and set the multicast table. */
1167     saved_bank = inb(ioaddr + CONFIG_1);
1168     outb(0xe4, ioaddr + CONFIG_1);
1169
1170     for (i = 0; i < 8; i++)
1171         outb(mc_filter[i], ioaddr + MAR_ADR + i);
1172     outb(saved_bank, ioaddr + CONFIG_1);
1173
1174     outb(saved_config_0, ioaddr + CONFIG_0);
1175
1176     local_irq_restore(flags);
1177 }