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