Back to home page

OSCL-LXR
 
 

     

0001 /* 3c509.c: A 3c509 EtherLink3 ethernet driver for linux. */
0002 /*
0003     Written 1993-2000 by Donald Becker.
0004 
0005     Copyright 1994-2000 by Donald Becker.
0006     Copyright 1993 United States Government as represented by the
0007     Director, National Security Agency.  This software may be used and
0008     distributed according to the terms of the GNU General Public License,
0009     incorporated herein by reference.
0010 
0011     This driver is for the 3Com EtherLinkIII series.
0012 
0013     The author may be reached as becker@scyld.com, or C/O
0014     Scyld Computing Corporation
0015     410 Severn Ave., Suite 210
0016     Annapolis MD 21403
0017 
0018     Known limitations:
0019     Because of the way 3c509 ISA detection works it's difficult to predict
0020     a priori which of several ISA-mode cards will be detected first.
0021 
0022     This driver does not use predictive interrupt mode, resulting in higher
0023     packet latency but lower overhead.  If interrupts are disabled for an
0024     unusually long time it could also result in missed packets, but in
0025     practice this rarely happens.
0026 
0027 
0028     FIXES:
0029         Alan Cox:       Removed the 'Unexpected interrupt' bug.
0030         Michael Meskes: Upgraded to Donald Becker's version 1.07.
0031         Alan Cox:   Increased the eeprom delay. Regardless of
0032                 what the docs say some people definitely
0033                 get problems with lower (but in card spec)
0034                 delays
0035         v1.10 4/21/97 Fixed module code so that multiple cards may be detected,
0036                 other cleanups.  -djb
0037         Andrea Arcangeli:   Upgraded to Donald Becker's version 1.12.
0038         Rick Payne: Fixed SMP race condition
0039         v1.13 9/8/97 Made 'max_interrupt_work' an insmod-settable variable -djb
0040         v1.14 10/15/97 Avoided waiting..discard message for fast machines -djb
0041         v1.15 1/31/98 Faster recovery for Tx errors. -djb
0042         v1.16 2/3/98 Different ID port handling to avoid sound cards. -djb
0043         v1.18 12Mar2001 Andrew Morton
0044             - Avoid bogus detect of 3c590's (Andrzej Krzysztofowicz)
0045             - Reviewed against 1.18 from scyld.com
0046         v1.18a 17Nov2001 Jeff Garzik <jgarzik@pobox.com>
0047             - ethtool support
0048         v1.18b 1Mar2002 Zwane Mwaikambo <zwane@commfireservices.com>
0049             - Power Management support
0050         v1.18c 1Mar2002 David Ruggiero <jdr@farfalle.com>
0051             - Full duplex support
0052         v1.19  16Oct2002 Zwane Mwaikambo <zwane@linuxpower.ca>
0053             - Additional ethtool features
0054         v1.19a 28Oct2002 Davud Ruggiero <jdr@farfalle.com>
0055             - Increase *read_eeprom udelay to workaround oops with 2 cards.
0056         v1.19b 08Nov2002 Marc Zyngier <maz@wild-wind.fr.eu.org>
0057             - Introduce driver model for EISA cards.
0058         v1.20  04Feb2008 Ondrej Zary <linux@rainbow-software.org>
0059             - convert to isa_driver and pnp_driver and some cleanups
0060 */
0061 
0062 #define DRV_NAME    "3c509"
0063 
0064 /* A few values that may be tweaked. */
0065 
0066 /* Time in jiffies before concluding the transmitter is hung. */
0067 #define TX_TIMEOUT  (400*HZ/1000)
0068 
0069 #include <linux/module.h>
0070 #include <linux/isa.h>
0071 #include <linux/pnp.h>
0072 #include <linux/string.h>
0073 #include <linux/interrupt.h>
0074 #include <linux/errno.h>
0075 #include <linux/in.h>
0076 #include <linux/ioport.h>
0077 #include <linux/init.h>
0078 #include <linux/netdevice.h>
0079 #include <linux/etherdevice.h>
0080 #include <linux/pm.h>
0081 #include <linux/skbuff.h>
0082 #include <linux/delay.h>    /* for udelay() */
0083 #include <linux/spinlock.h>
0084 #include <linux/ethtool.h>
0085 #include <linux/device.h>
0086 #include <linux/eisa.h>
0087 #include <linux/bitops.h>
0088 
0089 #include <linux/uaccess.h>
0090 #include <asm/io.h>
0091 #include <asm/irq.h>
0092 
0093 #ifdef EL3_DEBUG
0094 static int el3_debug = EL3_DEBUG;
0095 #else
0096 static int el3_debug = 2;
0097 #endif
0098 
0099 /* Used to do a global count of all the cards in the system.  Must be
0100  * a global variable so that the eisa probe routines can increment
0101  * it */
0102 static int el3_cards = 0;
0103 #define EL3_MAX_CARDS 8
0104 
0105 /* To minimize the size of the driver source I only define operating
0106    constants if they are used several times.  You'll need the manual
0107    anyway if you want to understand driver details. */
0108 /* Offsets from base I/O address. */
0109 #define EL3_DATA 0x00
0110 #define EL3_CMD 0x0e
0111 #define EL3_STATUS 0x0e
0112 #define EEPROM_READ 0x80
0113 
0114 #define EL3_IO_EXTENT   16
0115 
0116 #define EL3WINDOW(win_num) outw(SelectWindow + (win_num), ioaddr + EL3_CMD)
0117 
0118 
0119 /* The top five bits written to EL3_CMD are a command, the lower
0120    11 bits are the parameter, if applicable. */
0121 enum c509cmd {
0122     TotalReset = 0<<11, SelectWindow = 1<<11, StartCoax = 2<<11,
0123     RxDisable = 3<<11, RxEnable = 4<<11, RxReset = 5<<11, RxDiscard = 8<<11,
0124     TxEnable = 9<<11, TxDisable = 10<<11, TxReset = 11<<11,
0125     FakeIntr = 12<<11, AckIntr = 13<<11, SetIntrEnb = 14<<11,
0126     SetStatusEnb = 15<<11, SetRxFilter = 16<<11, SetRxThreshold = 17<<11,
0127     SetTxThreshold = 18<<11, SetTxStart = 19<<11, StatsEnable = 21<<11,
0128     StatsDisable = 22<<11, StopCoax = 23<<11, PowerUp = 27<<11,
0129     PowerDown = 28<<11, PowerAuto = 29<<11};
0130 
0131 enum c509status {
0132     IntLatch = 0x0001, AdapterFailure = 0x0002, TxComplete = 0x0004,
0133     TxAvailable = 0x0008, RxComplete = 0x0010, RxEarly = 0x0020,
0134     IntReq = 0x0040, StatsFull = 0x0080, CmdBusy = 0x1000, };
0135 
0136 /* The SetRxFilter command accepts the following classes: */
0137 enum RxFilter {
0138     RxStation = 1, RxMulticast = 2, RxBroadcast = 4, RxProm = 8 };
0139 
0140 /* Register window 1 offsets, the window used in normal operation. */
0141 #define TX_FIFO     0x00
0142 #define RX_FIFO     0x00
0143 #define RX_STATUS   0x08
0144 #define TX_STATUS   0x0B
0145 #define TX_FREE     0x0C        /* Remaining free bytes in Tx buffer. */
0146 
0147 #define WN0_CONF_CTRL   0x04        /* Window 0: Configuration control register */
0148 #define WN0_ADDR_CONF   0x06        /* Window 0: Address configuration register */
0149 #define WN0_IRQ     0x08        /* Window 0: Set IRQ line in bits 12-15. */
0150 #define WN4_MEDIA   0x0A        /* Window 4: Various transcvr/media bits. */
0151 #define MEDIA_TP    0x00C0      /* Enable link beat and jabber for 10baseT. */
0152 #define WN4_NETDIAG 0x06        /* Window 4: Net diagnostic */
0153 #define FD_ENABLE   0x8000      /* Enable full-duplex ("external loopback") */
0154 
0155 /*
0156  * Must be a power of two (we use a binary and in the
0157  * circular queue)
0158  */
0159 #define SKB_QUEUE_SIZE  64
0160 
0161 enum el3_cardtype { EL3_ISA, EL3_PNP, EL3_EISA };
0162 
0163 struct el3_private {
0164     spinlock_t lock;
0165     /* skb send-queue */
0166     int head, size;
0167     struct sk_buff *queue[SKB_QUEUE_SIZE];
0168     enum el3_cardtype type;
0169 };
0170 static int id_port;
0171 static int current_tag;
0172 static struct net_device *el3_devs[EL3_MAX_CARDS];
0173 
0174 /* Parameters that may be passed into the module. */
0175 static int debug = -1;
0176 static int irq[] = {-1, -1, -1, -1, -1, -1, -1, -1};
0177 /* Maximum events (Rx packets, etc.) to handle at each interrupt. */
0178 static int max_interrupt_work = 10;
0179 #ifdef CONFIG_PNP
0180 static int nopnp;
0181 #endif
0182 
0183 static int el3_common_init(struct net_device *dev);
0184 static void el3_common_remove(struct net_device *dev);
0185 static ushort id_read_eeprom(int index);
0186 static ushort read_eeprom(int ioaddr, int index);
0187 static int el3_open(struct net_device *dev);
0188 static netdev_tx_t el3_start_xmit(struct sk_buff *skb, struct net_device *dev);
0189 static irqreturn_t el3_interrupt(int irq, void *dev_id);
0190 static void update_stats(struct net_device *dev);
0191 static struct net_device_stats *el3_get_stats(struct net_device *dev);
0192 static int el3_rx(struct net_device *dev);
0193 static int el3_close(struct net_device *dev);
0194 static void set_multicast_list(struct net_device *dev);
0195 static void el3_tx_timeout (struct net_device *dev, unsigned int txqueue);
0196 static void el3_down(struct net_device *dev);
0197 static void el3_up(struct net_device *dev);
0198 static const struct ethtool_ops ethtool_ops;
0199 #ifdef CONFIG_PM
0200 static int el3_suspend(struct device *, pm_message_t);
0201 static int el3_resume(struct device *);
0202 #else
0203 #define el3_suspend NULL
0204 #define el3_resume NULL
0205 #endif
0206 
0207 
0208 /* generic device remove for all device types */
0209 static int el3_device_remove (struct device *device);
0210 #ifdef CONFIG_NET_POLL_CONTROLLER
0211 static void el3_poll_controller(struct net_device *dev);
0212 #endif
0213 
0214 /* Return 0 on success, 1 on error, 2 when found already detected PnP card */
0215 static int el3_isa_id_sequence(__be16 *phys_addr)
0216 {
0217     short lrs_state = 0xff;
0218     int i;
0219 
0220     /* ISA boards are detected by sending the ID sequence to the
0221        ID_PORT.  We find cards past the first by setting the 'current_tag'
0222        on cards as they are found.  Cards with their tag set will not
0223        respond to subsequent ID sequences. */
0224 
0225     outb(0x00, id_port);
0226     outb(0x00, id_port);
0227     for (i = 0; i < 255; i++) {
0228         outb(lrs_state, id_port);
0229         lrs_state <<= 1;
0230         lrs_state = lrs_state & 0x100 ? lrs_state ^ 0xcf : lrs_state;
0231     }
0232     /* For the first probe, clear all board's tag registers. */
0233     if (current_tag == 0)
0234         outb(0xd0, id_port);
0235     else            /* Otherwise kill off already-found boards. */
0236         outb(0xd8, id_port);
0237     if (id_read_eeprom(7) != 0x6d50)
0238         return 1;
0239     /* Read in EEPROM data, which does contention-select.
0240        Only the lowest address board will stay "on-line".
0241        3Com got the byte order backwards. */
0242     for (i = 0; i < 3; i++)
0243         phys_addr[i] = htons(id_read_eeprom(i));
0244 #ifdef CONFIG_PNP
0245     if (!nopnp) {
0246         /* The ISA PnP 3c509 cards respond to the ID sequence too.
0247            This check is needed in order not to register them twice. */
0248         for (i = 0; i < el3_cards; i++) {
0249             struct el3_private *lp = netdev_priv(el3_devs[i]);
0250             if (lp->type == EL3_PNP &&
0251                 ether_addr_equal((u8 *)phys_addr, el3_devs[i]->dev_addr)) {
0252                 if (el3_debug > 3)
0253                     pr_debug("3c509 with address %02x %02x %02x %02x %02x %02x was found by ISAPnP\n",
0254                         phys_addr[0] & 0xff, phys_addr[0] >> 8,
0255                         phys_addr[1] & 0xff, phys_addr[1] >> 8,
0256                         phys_addr[2] & 0xff, phys_addr[2] >> 8);
0257                 /* Set the adaptor tag so that the next card can be found. */
0258                 outb(0xd0 + ++current_tag, id_port);
0259                 return 2;
0260             }
0261         }
0262     }
0263 #endif /* CONFIG_PNP */
0264     return 0;
0265 
0266 }
0267 
0268 static void el3_dev_fill(struct net_device *dev, __be16 *phys_addr, int ioaddr,
0269              int irq, int if_port, enum el3_cardtype type)
0270 {
0271     struct el3_private *lp = netdev_priv(dev);
0272 
0273     eth_hw_addr_set(dev, (u8 *)phys_addr);
0274     dev->base_addr = ioaddr;
0275     dev->irq = irq;
0276     dev->if_port = if_port;
0277     lp->type = type;
0278 }
0279 
0280 static int el3_isa_match(struct device *pdev, unsigned int ndev)
0281 {
0282     struct net_device *dev;
0283     int ioaddr, isa_irq, if_port, err;
0284     unsigned int iobase;
0285     __be16 phys_addr[3];
0286 
0287     while ((err = el3_isa_id_sequence(phys_addr)) == 2)
0288         ;   /* Skip to next card when PnP card found */
0289     if (err == 1)
0290         return 0;
0291 
0292     iobase = id_read_eeprom(8);
0293     if_port = iobase >> 14;
0294     ioaddr = 0x200 + ((iobase & 0x1f) << 4);
0295     if (irq[el3_cards] > 1 && irq[el3_cards] < 16)
0296         isa_irq = irq[el3_cards];
0297     else
0298         isa_irq = id_read_eeprom(9) >> 12;
0299 
0300     dev = alloc_etherdev(sizeof(struct el3_private));
0301     if (!dev)
0302         return -ENOMEM;
0303 
0304     SET_NETDEV_DEV(dev, pdev);
0305 
0306     if (!request_region(ioaddr, EL3_IO_EXTENT, "3c509-isa")) {
0307         free_netdev(dev);
0308         return 0;
0309     }
0310 
0311     /* Set the adaptor tag so that the next card can be found. */
0312     outb(0xd0 + ++current_tag, id_port);
0313 
0314     /* Activate the adaptor at the EEPROM location. */
0315     outb((ioaddr >> 4) | 0xe0, id_port);
0316 
0317     EL3WINDOW(0);
0318     if (inw(ioaddr) != 0x6d50) {
0319         free_netdev(dev);
0320         return 0;
0321     }
0322 
0323     /* Free the interrupt so that some other card can use it. */
0324     outw(0x0f00, ioaddr + WN0_IRQ);
0325 
0326     el3_dev_fill(dev, phys_addr, ioaddr, isa_irq, if_port, EL3_ISA);
0327     dev_set_drvdata(pdev, dev);
0328     if (el3_common_init(dev)) {
0329         free_netdev(dev);
0330         return 0;
0331     }
0332 
0333     el3_devs[el3_cards++] = dev;
0334     return 1;
0335 }
0336 
0337 static void el3_isa_remove(struct device *pdev,
0338                     unsigned int ndev)
0339 {
0340     el3_device_remove(pdev);
0341     dev_set_drvdata(pdev, NULL);
0342 }
0343 
0344 #ifdef CONFIG_PM
0345 static int el3_isa_suspend(struct device *dev, unsigned int n,
0346                pm_message_t state)
0347 {
0348     current_tag = 0;
0349     return el3_suspend(dev, state);
0350 }
0351 
0352 static int el3_isa_resume(struct device *dev, unsigned int n)
0353 {
0354     struct net_device *ndev = dev_get_drvdata(dev);
0355     int ioaddr = ndev->base_addr, err;
0356     __be16 phys_addr[3];
0357 
0358     while ((err = el3_isa_id_sequence(phys_addr)) == 2)
0359         ;   /* Skip to next card when PnP card found */
0360     if (err == 1)
0361         return 0;
0362     /* Set the adaptor tag so that the next card can be found. */
0363     outb(0xd0 + ++current_tag, id_port);
0364     /* Enable the card */
0365     outb((ioaddr >> 4) | 0xe0, id_port);
0366     EL3WINDOW(0);
0367     if (inw(ioaddr) != 0x6d50)
0368         return 1;
0369     /* Free the interrupt so that some other card can use it. */
0370     outw(0x0f00, ioaddr + WN0_IRQ);
0371     return el3_resume(dev);
0372 }
0373 #endif
0374 
0375 static struct isa_driver el3_isa_driver = {
0376     .match      = el3_isa_match,
0377     .remove     = el3_isa_remove,
0378 #ifdef CONFIG_PM
0379     .suspend    = el3_isa_suspend,
0380     .resume     = el3_isa_resume,
0381 #endif
0382     .driver     = {
0383         .name   = "3c509"
0384     },
0385 };
0386 static int isa_registered;
0387 
0388 #ifdef CONFIG_PNP
0389 static const struct pnp_device_id el3_pnp_ids[] = {
0390     { .id = "TCM5090" }, /* 3Com Etherlink III (TP) */
0391     { .id = "TCM5091" }, /* 3Com Etherlink III */
0392     { .id = "TCM5094" }, /* 3Com Etherlink III (combo) */
0393     { .id = "TCM5095" }, /* 3Com Etherlink III (TPO) */
0394     { .id = "TCM5098" }, /* 3Com Etherlink III (TPC) */
0395     { .id = "PNP80f7" }, /* 3Com Etherlink III compatible */
0396     { .id = "PNP80f8" }, /* 3Com Etherlink III compatible */
0397     { .id = "" }
0398 };
0399 MODULE_DEVICE_TABLE(pnp, el3_pnp_ids);
0400 
0401 static int el3_pnp_probe(struct pnp_dev *pdev, const struct pnp_device_id *id)
0402 {
0403     short i;
0404     int ioaddr, irq, if_port;
0405     __be16 phys_addr[3];
0406     struct net_device *dev = NULL;
0407     int err;
0408 
0409     ioaddr = pnp_port_start(pdev, 0);
0410     if (!request_region(ioaddr, EL3_IO_EXTENT, "3c509-pnp"))
0411         return -EBUSY;
0412     irq = pnp_irq(pdev, 0);
0413     EL3WINDOW(0);
0414     for (i = 0; i < 3; i++)
0415         phys_addr[i] = htons(read_eeprom(ioaddr, i));
0416     if_port = read_eeprom(ioaddr, 8) >> 14;
0417     dev = alloc_etherdev(sizeof(struct el3_private));
0418     if (!dev) {
0419         release_region(ioaddr, EL3_IO_EXTENT);
0420         return -ENOMEM;
0421     }
0422     SET_NETDEV_DEV(dev, &pdev->dev);
0423 
0424     el3_dev_fill(dev, phys_addr, ioaddr, irq, if_port, EL3_PNP);
0425     pnp_set_drvdata(pdev, dev);
0426     err = el3_common_init(dev);
0427 
0428     if (err) {
0429         pnp_set_drvdata(pdev, NULL);
0430         free_netdev(dev);
0431         return err;
0432     }
0433 
0434     el3_devs[el3_cards++] = dev;
0435     return 0;
0436 }
0437 
0438 static void el3_pnp_remove(struct pnp_dev *pdev)
0439 {
0440     el3_common_remove(pnp_get_drvdata(pdev));
0441     pnp_set_drvdata(pdev, NULL);
0442 }
0443 
0444 #ifdef CONFIG_PM
0445 static int el3_pnp_suspend(struct pnp_dev *pdev, pm_message_t state)
0446 {
0447     return el3_suspend(&pdev->dev, state);
0448 }
0449 
0450 static int el3_pnp_resume(struct pnp_dev *pdev)
0451 {
0452     return el3_resume(&pdev->dev);
0453 }
0454 #endif
0455 
0456 static struct pnp_driver el3_pnp_driver = {
0457     .name       = "3c509",
0458     .id_table   = el3_pnp_ids,
0459     .probe      = el3_pnp_probe,
0460     .remove     = el3_pnp_remove,
0461 #ifdef CONFIG_PM
0462     .suspend    = el3_pnp_suspend,
0463     .resume     = el3_pnp_resume,
0464 #endif
0465 };
0466 static int pnp_registered;
0467 #endif /* CONFIG_PNP */
0468 
0469 #ifdef CONFIG_EISA
0470 static const struct eisa_device_id el3_eisa_ids[] = {
0471         { "TCM5090" },
0472         { "TCM5091" },
0473         { "TCM5092" },
0474         { "TCM5093" },
0475         { "TCM5094" },
0476         { "TCM5095" },
0477         { "TCM5098" },
0478         { "" }
0479 };
0480 MODULE_DEVICE_TABLE(eisa, el3_eisa_ids);
0481 
0482 static int el3_eisa_probe (struct device *device);
0483 
0484 static struct eisa_driver el3_eisa_driver = {
0485         .id_table = el3_eisa_ids,
0486         .driver   = {
0487                 .name    = "3c579",
0488                 .probe   = el3_eisa_probe,
0489                 .remove  = el3_device_remove,
0490                 .suspend = el3_suspend,
0491                 .resume  = el3_resume,
0492         }
0493 };
0494 static int eisa_registered;
0495 #endif
0496 
0497 static const struct net_device_ops netdev_ops = {
0498     .ndo_open       = el3_open,
0499     .ndo_stop       = el3_close,
0500     .ndo_start_xmit     = el3_start_xmit,
0501     .ndo_get_stats      = el3_get_stats,
0502     .ndo_set_rx_mode    = set_multicast_list,
0503     .ndo_tx_timeout     = el3_tx_timeout,
0504     .ndo_set_mac_address    = eth_mac_addr,
0505     .ndo_validate_addr  = eth_validate_addr,
0506 #ifdef CONFIG_NET_POLL_CONTROLLER
0507     .ndo_poll_controller    = el3_poll_controller,
0508 #endif
0509 };
0510 
0511 static int el3_common_init(struct net_device *dev)
0512 {
0513     struct el3_private *lp = netdev_priv(dev);
0514     int err;
0515     static const char * const if_names[] = {
0516         "10baseT", "AUI", "undefined", "BNC"
0517     };
0518 
0519     spin_lock_init(&lp->lock);
0520 
0521     if (dev->mem_start & 0x05) { /* xcvr codes 1/3/4/12 */
0522         dev->if_port = (dev->mem_start & 0x0f);
0523     } else { /* xcvr codes 0/8 */
0524         /* use eeprom value, but save user's full-duplex selection */
0525         dev->if_port |= (dev->mem_start & 0x08);
0526     }
0527 
0528     /* The EL3-specific entries in the device structure. */
0529     dev->netdev_ops = &netdev_ops;
0530     dev->watchdog_timeo = TX_TIMEOUT;
0531     dev->ethtool_ops = &ethtool_ops;
0532 
0533     err = register_netdev(dev);
0534     if (err) {
0535         pr_err("Failed to register 3c5x9 at %#3.3lx, IRQ %d.\n",
0536             dev->base_addr, dev->irq);
0537         release_region(dev->base_addr, EL3_IO_EXTENT);
0538         return err;
0539     }
0540 
0541     pr_info("%s: 3c5x9 found at %#3.3lx, %s port, address %pM, IRQ %d.\n",
0542            dev->name, dev->base_addr, if_names[(dev->if_port & 0x03)],
0543            dev->dev_addr, dev->irq);
0544 
0545     return 0;
0546 
0547 }
0548 
0549 static void el3_common_remove (struct net_device *dev)
0550 {
0551     unregister_netdev (dev);
0552     release_region(dev->base_addr, EL3_IO_EXTENT);
0553     free_netdev (dev);
0554 }
0555 
0556 #ifdef CONFIG_EISA
0557 static int el3_eisa_probe(struct device *device)
0558 {
0559     short i;
0560     int ioaddr, irq, if_port;
0561     __be16 phys_addr[3];
0562     struct net_device *dev = NULL;
0563     struct eisa_device *edev;
0564     int err;
0565 
0566     /* Yeepee, The driver framework is calling us ! */
0567     edev = to_eisa_device (device);
0568     ioaddr = edev->base_addr;
0569 
0570     if (!request_region(ioaddr, EL3_IO_EXTENT, "3c579-eisa"))
0571         return -EBUSY;
0572 
0573     /* Change the register set to the configuration window 0. */
0574     outw(SelectWindow | 0, ioaddr + 0xC80 + EL3_CMD);
0575 
0576     irq = inw(ioaddr + WN0_IRQ) >> 12;
0577     if_port = inw(ioaddr + 6)>>14;
0578     for (i = 0; i < 3; i++)
0579         phys_addr[i] = htons(read_eeprom(ioaddr, i));
0580 
0581     /* Restore the "Product ID" to the EEPROM read register. */
0582     read_eeprom(ioaddr, 3);
0583 
0584     dev = alloc_etherdev(sizeof (struct el3_private));
0585     if (dev == NULL) {
0586         release_region(ioaddr, EL3_IO_EXTENT);
0587         return -ENOMEM;
0588     }
0589 
0590     SET_NETDEV_DEV(dev, device);
0591 
0592     el3_dev_fill(dev, phys_addr, ioaddr, irq, if_port, EL3_EISA);
0593     eisa_set_drvdata (edev, dev);
0594     err = el3_common_init(dev);
0595 
0596     if (err) {
0597         eisa_set_drvdata (edev, NULL);
0598         free_netdev(dev);
0599         return err;
0600     }
0601 
0602     el3_devs[el3_cards++] = dev;
0603     return 0;
0604 }
0605 #endif
0606 
0607 /* This remove works for all device types.
0608  *
0609  * The net dev must be stored in the driver data field */
0610 static int el3_device_remove(struct device *device)
0611 {
0612     struct net_device *dev;
0613 
0614     dev = dev_get_drvdata(device);
0615 
0616     el3_common_remove (dev);
0617     return 0;
0618 }
0619 
0620 /* Read a word from the EEPROM using the regular EEPROM access register.
0621    Assume that we are in register window zero.
0622  */
0623 static ushort read_eeprom(int ioaddr, int index)
0624 {
0625     outw(EEPROM_READ + index, ioaddr + 10);
0626     /* Pause for at least 162 us. for the read to take place.
0627        Some chips seem to require much longer */
0628     mdelay(2);
0629     return inw(ioaddr + 12);
0630 }
0631 
0632 /* Read a word from the EEPROM when in the ISA ID probe state. */
0633 static ushort id_read_eeprom(int index)
0634 {
0635     int bit, word = 0;
0636 
0637     /* Issue read command, and pause for at least 162 us. for it to complete.
0638        Assume extra-fast 16Mhz bus. */
0639     outb(EEPROM_READ + index, id_port);
0640 
0641     /* Pause for at least 162 us. for the read to take place. */
0642     /* Some chips seem to require much longer */
0643     mdelay(4);
0644 
0645     for (bit = 15; bit >= 0; bit--)
0646         word = (word << 1) + (inb(id_port) & 0x01);
0647 
0648     if (el3_debug > 3)
0649         pr_debug("  3c509 EEPROM word %d %#4.4x.\n", index, word);
0650 
0651     return word;
0652 }
0653 
0654 
0655 static int
0656 el3_open(struct net_device *dev)
0657 {
0658     int ioaddr = dev->base_addr;
0659     int i;
0660 
0661     outw(TxReset, ioaddr + EL3_CMD);
0662     outw(RxReset, ioaddr + EL3_CMD);
0663     outw(SetStatusEnb | 0x00, ioaddr + EL3_CMD);
0664 
0665     i = request_irq(dev->irq, el3_interrupt, 0, dev->name, dev);
0666     if (i)
0667         return i;
0668 
0669     EL3WINDOW(0);
0670     if (el3_debug > 3)
0671         pr_debug("%s: Opening, IRQ %d    status@%x %4.4x.\n", dev->name,
0672                dev->irq, ioaddr + EL3_STATUS, inw(ioaddr + EL3_STATUS));
0673 
0674     el3_up(dev);
0675 
0676     if (el3_debug > 3)
0677         pr_debug("%s: Opened 3c509  IRQ %d  status %4.4x.\n",
0678                dev->name, dev->irq, inw(ioaddr + EL3_STATUS));
0679 
0680     return 0;
0681 }
0682 
0683 static void
0684 el3_tx_timeout (struct net_device *dev, unsigned int txqueue)
0685 {
0686     int ioaddr = dev->base_addr;
0687 
0688     /* Transmitter timeout, serious problems. */
0689     pr_warn("%s: transmit timed out, Tx_status %2.2x status %4.4x Tx FIFO room %d\n",
0690         dev->name, inb(ioaddr + TX_STATUS), inw(ioaddr + EL3_STATUS),
0691         inw(ioaddr + TX_FREE));
0692     dev->stats.tx_errors++;
0693     netif_trans_update(dev); /* prevent tx timeout */
0694     /* Issue TX_RESET and TX_START commands. */
0695     outw(TxReset, ioaddr + EL3_CMD);
0696     outw(TxEnable, ioaddr + EL3_CMD);
0697     netif_wake_queue(dev);
0698 }
0699 
0700 
0701 static netdev_tx_t
0702 el3_start_xmit(struct sk_buff *skb, struct net_device *dev)
0703 {
0704     struct el3_private *lp = netdev_priv(dev);
0705     int ioaddr = dev->base_addr;
0706     unsigned long flags;
0707 
0708     netif_stop_queue (dev);
0709 
0710     dev->stats.tx_bytes += skb->len;
0711 
0712     if (el3_debug > 4) {
0713         pr_debug("%s: el3_start_xmit(length = %u) called, status %4.4x.\n",
0714                dev->name, skb->len, inw(ioaddr + EL3_STATUS));
0715     }
0716     /*
0717      *  We lock the driver against other processors. Note
0718      *  we don't need to lock versus the IRQ as we suspended
0719      *  that. This means that we lose the ability to take
0720      *  an RX during a TX upload. That sucks a bit with SMP
0721      *  on an original 3c509 (2K buffer)
0722      *
0723      *  Using disable_irq stops us crapping on other
0724      *  time sensitive devices.
0725      */
0726 
0727     spin_lock_irqsave(&lp->lock, flags);
0728 
0729     /* Put out the doubleword header... */
0730     outw(skb->len, ioaddr + TX_FIFO);
0731     outw(0x00, ioaddr + TX_FIFO);
0732     /* ... and the packet rounded to a doubleword. */
0733     outsl(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2);
0734 
0735     if (inw(ioaddr + TX_FREE) > 1536)
0736         netif_start_queue(dev);
0737     else
0738         /* Interrupt us when the FIFO has room for max-sized packet. */
0739         outw(SetTxThreshold + 1536, ioaddr + EL3_CMD);
0740 
0741     spin_unlock_irqrestore(&lp->lock, flags);
0742 
0743     dev_consume_skb_any (skb);
0744 
0745     /* Clear the Tx status stack. */
0746     {
0747         short tx_status;
0748         int i = 4;
0749 
0750         while (--i > 0  &&  (tx_status = inb(ioaddr + TX_STATUS)) > 0) {
0751             if (tx_status & 0x38) dev->stats.tx_aborted_errors++;
0752             if (tx_status & 0x30) outw(TxReset, ioaddr + EL3_CMD);
0753             if (tx_status & 0x3C) outw(TxEnable, ioaddr + EL3_CMD);
0754             outb(0x00, ioaddr + TX_STATUS); /* Pop the status stack. */
0755         }
0756     }
0757     return NETDEV_TX_OK;
0758 }
0759 
0760 /* The EL3 interrupt handler. */
0761 static irqreturn_t
0762 el3_interrupt(int irq, void *dev_id)
0763 {
0764     struct net_device *dev = dev_id;
0765     struct el3_private *lp;
0766     int ioaddr, status;
0767     int i = max_interrupt_work;
0768 
0769     lp = netdev_priv(dev);
0770     spin_lock(&lp->lock);
0771 
0772     ioaddr = dev->base_addr;
0773 
0774     if (el3_debug > 4) {
0775         status = inw(ioaddr + EL3_STATUS);
0776         pr_debug("%s: interrupt, status %4.4x.\n", dev->name, status);
0777     }
0778 
0779     while ((status = inw(ioaddr + EL3_STATUS)) &
0780            (IntLatch | RxComplete | StatsFull)) {
0781 
0782         if (status & RxComplete)
0783             el3_rx(dev);
0784 
0785         if (status & TxAvailable) {
0786             if (el3_debug > 5)
0787                 pr_debug("  TX room bit was handled.\n");
0788             /* There's room in the FIFO for a full-sized packet. */
0789             outw(AckIntr | TxAvailable, ioaddr + EL3_CMD);
0790             netif_wake_queue (dev);
0791         }
0792         if (status & (AdapterFailure | RxEarly | StatsFull | TxComplete)) {
0793             /* Handle all uncommon interrupts. */
0794             if (status & StatsFull)             /* Empty statistics. */
0795                 update_stats(dev);
0796             if (status & RxEarly) {             /* Rx early is unused. */
0797                 el3_rx(dev);
0798                 outw(AckIntr | RxEarly, ioaddr + EL3_CMD);
0799             }
0800             if (status & TxComplete) {          /* Really Tx error. */
0801                 short tx_status;
0802                 int i = 4;
0803 
0804                 while (--i>0 && (tx_status = inb(ioaddr + TX_STATUS)) > 0) {
0805                     if (tx_status & 0x38) dev->stats.tx_aborted_errors++;
0806                     if (tx_status & 0x30) outw(TxReset, ioaddr + EL3_CMD);
0807                     if (tx_status & 0x3C) outw(TxEnable, ioaddr + EL3_CMD);
0808                     outb(0x00, ioaddr + TX_STATUS); /* Pop the status stack. */
0809                 }
0810             }
0811             if (status & AdapterFailure) {
0812                 /* Adapter failure requires Rx reset and reinit. */
0813                 outw(RxReset, ioaddr + EL3_CMD);
0814                 /* Set the Rx filter to the current state. */
0815                 outw(SetRxFilter | RxStation | RxBroadcast
0816                      | (dev->flags & IFF_ALLMULTI ? RxMulticast : 0)
0817                      | (dev->flags & IFF_PROMISC ? RxProm : 0),
0818                      ioaddr + EL3_CMD);
0819                 outw(RxEnable, ioaddr + EL3_CMD); /* Re-enable the receiver. */
0820                 outw(AckIntr | AdapterFailure, ioaddr + EL3_CMD);
0821             }
0822         }
0823 
0824         if (--i < 0) {
0825             pr_err("%s: Infinite loop in interrupt, status %4.4x.\n",
0826                    dev->name, status);
0827             /* Clear all interrupts. */
0828             outw(AckIntr | 0xFF, ioaddr + EL3_CMD);
0829             break;
0830         }
0831         /* Acknowledge the IRQ. */
0832         outw(AckIntr | IntReq | IntLatch, ioaddr + EL3_CMD); /* Ack IRQ */
0833     }
0834 
0835     if (el3_debug > 4) {
0836         pr_debug("%s: exiting interrupt, status %4.4x.\n", dev->name,
0837                inw(ioaddr + EL3_STATUS));
0838     }
0839     spin_unlock(&lp->lock);
0840     return IRQ_HANDLED;
0841 }
0842 
0843 
0844 #ifdef CONFIG_NET_POLL_CONTROLLER
0845 /*
0846  * Polling receive - used by netconsole and other diagnostic tools
0847  * to allow network i/o with interrupts disabled.
0848  */
0849 static void el3_poll_controller(struct net_device *dev)
0850 {
0851     disable_irq(dev->irq);
0852     el3_interrupt(dev->irq, dev);
0853     enable_irq(dev->irq);
0854 }
0855 #endif
0856 
0857 static struct net_device_stats *
0858 el3_get_stats(struct net_device *dev)
0859 {
0860     struct el3_private *lp = netdev_priv(dev);
0861     unsigned long flags;
0862 
0863     /*
0864      *  This is fast enough not to bother with disable IRQ
0865      *  stuff.
0866      */
0867 
0868     spin_lock_irqsave(&lp->lock, flags);
0869     update_stats(dev);
0870     spin_unlock_irqrestore(&lp->lock, flags);
0871     return &dev->stats;
0872 }
0873 
0874 /*  Update statistics.  We change to register window 6, so this should be run
0875     single-threaded if the device is active. This is expected to be a rare
0876     operation, and it's simpler for the rest of the driver to assume that
0877     window 1 is always valid rather than use a special window-state variable.
0878     */
0879 static void update_stats(struct net_device *dev)
0880 {
0881     int ioaddr = dev->base_addr;
0882 
0883     if (el3_debug > 5)
0884         pr_debug("   Updating the statistics.\n");
0885     /* Turn off statistics updates while reading. */
0886     outw(StatsDisable, ioaddr + EL3_CMD);
0887     /* Switch to the stats window, and read everything. */
0888     EL3WINDOW(6);
0889     dev->stats.tx_carrier_errors    += inb(ioaddr + 0);
0890     dev->stats.tx_heartbeat_errors  += inb(ioaddr + 1);
0891     /* Multiple collisions. */     inb(ioaddr + 2);
0892     dev->stats.collisions       += inb(ioaddr + 3);
0893     dev->stats.tx_window_errors += inb(ioaddr + 4);
0894     dev->stats.rx_fifo_errors   += inb(ioaddr + 5);
0895     dev->stats.tx_packets       += inb(ioaddr + 6);
0896     /* Rx packets   */         inb(ioaddr + 7);
0897     /* Tx deferrals */         inb(ioaddr + 8);
0898     inw(ioaddr + 10);   /* Total Rx and Tx octets. */
0899     inw(ioaddr + 12);
0900 
0901     /* Back to window 1, and turn statistics back on. */
0902     EL3WINDOW(1);
0903     outw(StatsEnable, ioaddr + EL3_CMD);
0904 }
0905 
0906 static int
0907 el3_rx(struct net_device *dev)
0908 {
0909     int ioaddr = dev->base_addr;
0910     short rx_status;
0911 
0912     if (el3_debug > 5)
0913         pr_debug("   In rx_packet(), status %4.4x, rx_status %4.4x.\n",
0914                inw(ioaddr+EL3_STATUS), inw(ioaddr+RX_STATUS));
0915     while ((rx_status = inw(ioaddr + RX_STATUS)) > 0) {
0916         if (rx_status & 0x4000) { /* Error, update stats. */
0917             short error = rx_status & 0x3800;
0918 
0919             outw(RxDiscard, ioaddr + EL3_CMD);
0920             dev->stats.rx_errors++;
0921             switch (error) {
0922             case 0x0000:        dev->stats.rx_over_errors++; break;
0923             case 0x0800:        dev->stats.rx_length_errors++; break;
0924             case 0x1000:        dev->stats.rx_frame_errors++; break;
0925             case 0x1800:        dev->stats.rx_length_errors++; break;
0926             case 0x2000:        dev->stats.rx_frame_errors++; break;
0927             case 0x2800:        dev->stats.rx_crc_errors++; break;
0928             }
0929         } else {
0930             short pkt_len = rx_status & 0x7ff;
0931             struct sk_buff *skb;
0932 
0933             skb = netdev_alloc_skb(dev, pkt_len + 5);
0934             if (el3_debug > 4)
0935                 pr_debug("Receiving packet size %d status %4.4x.\n",
0936                        pkt_len, rx_status);
0937             if (skb != NULL) {
0938                 skb_reserve(skb, 2);     /* Align IP on 16 byte */
0939 
0940                 /* 'skb->data' points to the start of sk_buff data area. */
0941                 insl(ioaddr + RX_FIFO, skb_put(skb,pkt_len),
0942                      (pkt_len + 3) >> 2);
0943 
0944                 outw(RxDiscard, ioaddr + EL3_CMD); /* Pop top Rx packet. */
0945                 skb->protocol = eth_type_trans(skb,dev);
0946                 netif_rx(skb);
0947                 dev->stats.rx_bytes += pkt_len;
0948                 dev->stats.rx_packets++;
0949                 continue;
0950             }
0951             outw(RxDiscard, ioaddr + EL3_CMD);
0952             dev->stats.rx_dropped++;
0953             if (el3_debug)
0954                 pr_debug("%s: Couldn't allocate a sk_buff of size %d.\n",
0955                        dev->name, pkt_len);
0956         }
0957         inw(ioaddr + EL3_STATUS);               /* Delay. */
0958         while (inw(ioaddr + EL3_STATUS) & 0x1000)
0959             pr_debug("  Waiting for 3c509 to discard packet, status %x.\n",
0960                    inw(ioaddr + EL3_STATUS) );
0961     }
0962 
0963     return 0;
0964 }
0965 
0966 /*
0967  *     Set or clear the multicast filter for this adaptor.
0968  */
0969 static void
0970 set_multicast_list(struct net_device *dev)
0971 {
0972     unsigned long flags;
0973     struct el3_private *lp = netdev_priv(dev);
0974     int ioaddr = dev->base_addr;
0975     int mc_count = netdev_mc_count(dev);
0976 
0977     if (el3_debug > 1) {
0978         static int old;
0979         if (old != mc_count) {
0980             old = mc_count;
0981             pr_debug("%s: Setting Rx mode to %d addresses.\n",
0982                  dev->name, mc_count);
0983         }
0984     }
0985     spin_lock_irqsave(&lp->lock, flags);
0986     if (dev->flags&IFF_PROMISC) {
0987         outw(SetRxFilter | RxStation | RxMulticast | RxBroadcast | RxProm,
0988              ioaddr + EL3_CMD);
0989     }
0990     else if (mc_count || (dev->flags&IFF_ALLMULTI)) {
0991         outw(SetRxFilter | RxStation | RxMulticast | RxBroadcast, ioaddr + EL3_CMD);
0992     }
0993     else
0994         outw(SetRxFilter | RxStation | RxBroadcast, ioaddr + EL3_CMD);
0995     spin_unlock_irqrestore(&lp->lock, flags);
0996 }
0997 
0998 static int
0999 el3_close(struct net_device *dev)
1000 {
1001     int ioaddr = dev->base_addr;
1002     struct el3_private *lp = netdev_priv(dev);
1003 
1004     if (el3_debug > 2)
1005         pr_debug("%s: Shutting down ethercard.\n", dev->name);
1006 
1007     el3_down(dev);
1008 
1009     free_irq(dev->irq, dev);
1010     /* Switching back to window 0 disables the IRQ. */
1011     EL3WINDOW(0);
1012     if (lp->type != EL3_EISA) {
1013         /* But we explicitly zero the IRQ line select anyway. Don't do
1014          * it on EISA cards, it prevents the module from getting an
1015          * IRQ after unload+reload... */
1016         outw(0x0f00, ioaddr + WN0_IRQ);
1017     }
1018 
1019     return 0;
1020 }
1021 
1022 static int
1023 el3_link_ok(struct net_device *dev)
1024 {
1025     int ioaddr = dev->base_addr;
1026     u16 tmp;
1027 
1028     EL3WINDOW(4);
1029     tmp = inw(ioaddr + WN4_MEDIA);
1030     EL3WINDOW(1);
1031     return tmp & (1<<11);
1032 }
1033 
1034 static void
1035 el3_netdev_get_ecmd(struct net_device *dev, struct ethtool_link_ksettings *cmd)
1036 {
1037     u16 tmp;
1038     int ioaddr = dev->base_addr;
1039     u32 supported;
1040 
1041     EL3WINDOW(0);
1042     /* obtain current transceiver via WN4_MEDIA? */
1043     tmp = inw(ioaddr + WN0_ADDR_CONF);
1044     switch (tmp >> 14) {
1045     case 0:
1046         cmd->base.port = PORT_TP;
1047         break;
1048     case 1:
1049         cmd->base.port = PORT_AUI;
1050         break;
1051     case 3:
1052         cmd->base.port = PORT_BNC;
1053         break;
1054     default:
1055         break;
1056     }
1057 
1058     cmd->base.duplex = DUPLEX_HALF;
1059     supported = 0;
1060     tmp = inw(ioaddr + WN0_CONF_CTRL);
1061     if (tmp & (1<<13))
1062         supported |= SUPPORTED_AUI;
1063     if (tmp & (1<<12))
1064         supported |= SUPPORTED_BNC;
1065     if (tmp & (1<<9)) {
1066         supported |= SUPPORTED_TP | SUPPORTED_10baseT_Half |
1067                 SUPPORTED_10baseT_Full; /* hmm... */
1068         EL3WINDOW(4);
1069         tmp = inw(ioaddr + WN4_NETDIAG);
1070         if (tmp & FD_ENABLE)
1071             cmd->base.duplex = DUPLEX_FULL;
1072     }
1073 
1074     ethtool_convert_legacy_u32_to_link_mode(cmd->link_modes.supported,
1075                         supported);
1076     cmd->base.speed = SPEED_10;
1077     EL3WINDOW(1);
1078 }
1079 
1080 static int
1081 el3_netdev_set_ecmd(struct net_device *dev,
1082             const struct ethtool_link_ksettings *cmd)
1083 {
1084     u16 tmp;
1085     int ioaddr = dev->base_addr;
1086 
1087     if (cmd->base.speed != SPEED_10)
1088         return -EINVAL;
1089     if ((cmd->base.duplex != DUPLEX_HALF) &&
1090         (cmd->base.duplex != DUPLEX_FULL))
1091         return -EINVAL;
1092 
1093     /* change XCVR type */
1094     EL3WINDOW(0);
1095     tmp = inw(ioaddr + WN0_ADDR_CONF);
1096     switch (cmd->base.port) {
1097     case PORT_TP:
1098         tmp &= ~(3<<14);
1099         dev->if_port = 0;
1100         break;
1101     case PORT_AUI:
1102         tmp |= (1<<14);
1103         dev->if_port = 1;
1104         break;
1105     case PORT_BNC:
1106         tmp |= (3<<14);
1107         dev->if_port = 3;
1108         break;
1109     default:
1110         return -EINVAL;
1111     }
1112 
1113     outw(tmp, ioaddr + WN0_ADDR_CONF);
1114     if (dev->if_port == 3) {
1115         /* fire up the DC-DC convertor if BNC gets enabled */
1116         tmp = inw(ioaddr + WN0_ADDR_CONF);
1117         if (tmp & (3 << 14)) {
1118             outw(StartCoax, ioaddr + EL3_CMD);
1119             udelay(800);
1120         } else
1121             return -EIO;
1122     }
1123 
1124     EL3WINDOW(4);
1125     tmp = inw(ioaddr + WN4_NETDIAG);
1126     if (cmd->base.duplex == DUPLEX_FULL)
1127         tmp |= FD_ENABLE;
1128     else
1129         tmp &= ~FD_ENABLE;
1130     outw(tmp, ioaddr + WN4_NETDIAG);
1131     EL3WINDOW(1);
1132 
1133     return 0;
1134 }
1135 
1136 static void el3_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
1137 {
1138     strlcpy(info->driver, DRV_NAME, sizeof(info->driver));
1139 }
1140 
1141 static int el3_get_link_ksettings(struct net_device *dev,
1142                   struct ethtool_link_ksettings *cmd)
1143 {
1144     struct el3_private *lp = netdev_priv(dev);
1145 
1146     spin_lock_irq(&lp->lock);
1147     el3_netdev_get_ecmd(dev, cmd);
1148     spin_unlock_irq(&lp->lock);
1149     return 0;
1150 }
1151 
1152 static int el3_set_link_ksettings(struct net_device *dev,
1153                   const struct ethtool_link_ksettings *cmd)
1154 {
1155     struct el3_private *lp = netdev_priv(dev);
1156     int ret;
1157 
1158     spin_lock_irq(&lp->lock);
1159     ret = el3_netdev_set_ecmd(dev, cmd);
1160     spin_unlock_irq(&lp->lock);
1161     return ret;
1162 }
1163 
1164 static u32 el3_get_link(struct net_device *dev)
1165 {
1166     struct el3_private *lp = netdev_priv(dev);
1167     u32 ret;
1168 
1169     spin_lock_irq(&lp->lock);
1170     ret = el3_link_ok(dev);
1171     spin_unlock_irq(&lp->lock);
1172     return ret;
1173 }
1174 
1175 static u32 el3_get_msglevel(struct net_device *dev)
1176 {
1177     return el3_debug;
1178 }
1179 
1180 static void el3_set_msglevel(struct net_device *dev, u32 v)
1181 {
1182     el3_debug = v;
1183 }
1184 
1185 static const struct ethtool_ops ethtool_ops = {
1186     .get_drvinfo = el3_get_drvinfo,
1187     .get_link = el3_get_link,
1188     .get_msglevel = el3_get_msglevel,
1189     .set_msglevel = el3_set_msglevel,
1190     .get_link_ksettings = el3_get_link_ksettings,
1191     .set_link_ksettings = el3_set_link_ksettings,
1192 };
1193 
1194 static void
1195 el3_down(struct net_device *dev)
1196 {
1197     int ioaddr = dev->base_addr;
1198 
1199     netif_stop_queue(dev);
1200 
1201     /* Turn off statistics ASAP.  We update lp->stats below. */
1202     outw(StatsDisable, ioaddr + EL3_CMD);
1203 
1204     /* Disable the receiver and transmitter. */
1205     outw(RxDisable, ioaddr + EL3_CMD);
1206     outw(TxDisable, ioaddr + EL3_CMD);
1207 
1208     if (dev->if_port == 3)
1209         /* Turn off thinnet power.  Green! */
1210         outw(StopCoax, ioaddr + EL3_CMD);
1211     else if (dev->if_port == 0) {
1212         /* Disable link beat and jabber, if_port may change here next open(). */
1213         EL3WINDOW(4);
1214         outw(inw(ioaddr + WN4_MEDIA) & ~MEDIA_TP, ioaddr + WN4_MEDIA);
1215     }
1216 
1217     outw(SetIntrEnb | 0x0000, ioaddr + EL3_CMD);
1218 
1219     update_stats(dev);
1220 }
1221 
1222 static void
1223 el3_up(struct net_device *dev)
1224 {
1225     int i, sw_info, net_diag;
1226     int ioaddr = dev->base_addr;
1227 
1228     /* Activating the board required and does no harm otherwise */
1229     outw(0x0001, ioaddr + 4);
1230 
1231     /* Set the IRQ line. */
1232     outw((dev->irq << 12) | 0x0f00, ioaddr + WN0_IRQ);
1233 
1234     /* Set the station address in window 2 each time opened. */
1235     EL3WINDOW(2);
1236 
1237     for (i = 0; i < 6; i++)
1238         outb(dev->dev_addr[i], ioaddr + i);
1239 
1240     if ((dev->if_port & 0x03) == 3) /* BNC interface */
1241         /* Start the thinnet transceiver. We should really wait 50ms...*/
1242         outw(StartCoax, ioaddr + EL3_CMD);
1243     else if ((dev->if_port & 0x03) == 0) { /* 10baseT interface */
1244         /* Combine secondary sw_info word (the adapter level) and primary
1245             sw_info word (duplex setting plus other useless bits) */
1246         EL3WINDOW(0);
1247         sw_info = (read_eeprom(ioaddr, 0x14) & 0x400f) |
1248             (read_eeprom(ioaddr, 0x0d) & 0xBff0);
1249 
1250         EL3WINDOW(4);
1251         net_diag = inw(ioaddr + WN4_NETDIAG);
1252         net_diag = (net_diag | FD_ENABLE); /* temporarily assume full-duplex will be set */
1253         pr_info("%s: ", dev->name);
1254         switch (dev->if_port & 0x0c) {
1255             case 12:
1256                 /* force full-duplex mode if 3c5x9b */
1257                 if (sw_info & 0x000f) {
1258                     pr_cont("Forcing 3c5x9b full-duplex mode");
1259                     break;
1260                 }
1261                 fallthrough;
1262             case 8:
1263                 /* set full-duplex mode based on eeprom config setting */
1264                 if ((sw_info & 0x000f) && (sw_info & 0x8000)) {
1265                     pr_cont("Setting 3c5x9b full-duplex mode (from EEPROM configuration bit)");
1266                     break;
1267                 }
1268                 fallthrough;
1269             default:
1270                 /* xcvr=(0 || 4) OR user has an old 3c5x9 non "B" model */
1271                 pr_cont("Setting 3c5x9/3c5x9B half-duplex mode");
1272                 net_diag = (net_diag & ~FD_ENABLE); /* disable full duplex */
1273         }
1274 
1275         outw(net_diag, ioaddr + WN4_NETDIAG);
1276         pr_cont(" if_port: %d, sw_info: %4.4x\n", dev->if_port, sw_info);
1277         if (el3_debug > 3)
1278             pr_debug("%s: 3c5x9 net diag word is now: %4.4x.\n", dev->name, net_diag);
1279         /* Enable link beat and jabber check. */
1280         outw(inw(ioaddr + WN4_MEDIA) | MEDIA_TP, ioaddr + WN4_MEDIA);
1281     }
1282 
1283     /* Switch to the stats window, and clear all stats by reading. */
1284     outw(StatsDisable, ioaddr + EL3_CMD);
1285     EL3WINDOW(6);
1286     for (i = 0; i < 9; i++)
1287         inb(ioaddr + i);
1288     inw(ioaddr + 10);
1289     inw(ioaddr + 12);
1290 
1291     /* Switch to register set 1 for normal use. */
1292     EL3WINDOW(1);
1293 
1294     /* Accept b-case and phys addr only. */
1295     outw(SetRxFilter | RxStation | RxBroadcast, ioaddr + EL3_CMD);
1296     outw(StatsEnable, ioaddr + EL3_CMD); /* Turn on statistics. */
1297 
1298     outw(RxEnable, ioaddr + EL3_CMD); /* Enable the receiver. */
1299     outw(TxEnable, ioaddr + EL3_CMD); /* Enable transmitter. */
1300     /* Allow status bits to be seen. */
1301     outw(SetStatusEnb | 0xff, ioaddr + EL3_CMD);
1302     /* Ack all pending events, and set active indicator mask. */
1303     outw(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq,
1304          ioaddr + EL3_CMD);
1305     outw(SetIntrEnb | IntLatch|TxAvailable|TxComplete|RxComplete|StatsFull,
1306          ioaddr + EL3_CMD);
1307 
1308     netif_start_queue(dev);
1309 }
1310 
1311 /* Power Management support functions */
1312 #ifdef CONFIG_PM
1313 
1314 static int
1315 el3_suspend(struct device *pdev, pm_message_t state)
1316 {
1317     unsigned long flags;
1318     struct net_device *dev;
1319     struct el3_private *lp;
1320     int ioaddr;
1321 
1322     dev = dev_get_drvdata(pdev);
1323     lp = netdev_priv(dev);
1324     ioaddr = dev->base_addr;
1325 
1326     spin_lock_irqsave(&lp->lock, flags);
1327 
1328     if (netif_running(dev))
1329         netif_device_detach(dev);
1330 
1331     el3_down(dev);
1332     outw(PowerDown, ioaddr + EL3_CMD);
1333 
1334     spin_unlock_irqrestore(&lp->lock, flags);
1335     return 0;
1336 }
1337 
1338 static int
1339 el3_resume(struct device *pdev)
1340 {
1341     unsigned long flags;
1342     struct net_device *dev;
1343     struct el3_private *lp;
1344     int ioaddr;
1345 
1346     dev = dev_get_drvdata(pdev);
1347     lp = netdev_priv(dev);
1348     ioaddr = dev->base_addr;
1349 
1350     spin_lock_irqsave(&lp->lock, flags);
1351 
1352     outw(PowerUp, ioaddr + EL3_CMD);
1353     EL3WINDOW(0);
1354     el3_up(dev);
1355 
1356     if (netif_running(dev))
1357         netif_device_attach(dev);
1358 
1359     spin_unlock_irqrestore(&lp->lock, flags);
1360     return 0;
1361 }
1362 
1363 #endif /* CONFIG_PM */
1364 
1365 module_param(debug,int, 0);
1366 module_param_hw_array(irq, int, irq, NULL, 0);
1367 module_param(max_interrupt_work, int, 0);
1368 MODULE_PARM_DESC(debug, "debug level (0-6)");
1369 MODULE_PARM_DESC(irq, "IRQ number(s) (assigned)");
1370 MODULE_PARM_DESC(max_interrupt_work, "maximum events handled per interrupt");
1371 #ifdef CONFIG_PNP
1372 module_param(nopnp, int, 0);
1373 MODULE_PARM_DESC(nopnp, "disable ISA PnP support (0-1)");
1374 #endif  /* CONFIG_PNP */
1375 MODULE_DESCRIPTION("3Com Etherlink III (3c509, 3c509B, 3c529, 3c579) ethernet driver");
1376 MODULE_LICENSE("GPL");
1377 
1378 static int __init el3_init_module(void)
1379 {
1380     int ret = 0;
1381 
1382     if (debug >= 0)
1383         el3_debug = debug;
1384 
1385 #ifdef CONFIG_PNP
1386     if (!nopnp) {
1387         ret = pnp_register_driver(&el3_pnp_driver);
1388         if (!ret)
1389             pnp_registered = 1;
1390     }
1391 #endif
1392     /* Select an open I/O location at 0x1*0 to do ISA contention select. */
1393     /* Start with 0x110 to avoid some sound cards.*/
1394     for (id_port = 0x110 ; id_port < 0x200; id_port += 0x10) {
1395         if (!request_region(id_port, 1, "3c509-control"))
1396             continue;
1397         outb(0x00, id_port);
1398         outb(0xff, id_port);
1399         if (inb(id_port) & 0x01)
1400             break;
1401         else
1402             release_region(id_port, 1);
1403     }
1404     if (id_port >= 0x200) {
1405         id_port = 0;
1406         pr_err("No I/O port available for 3c509 activation.\n");
1407     } else {
1408         ret = isa_register_driver(&el3_isa_driver, EL3_MAX_CARDS);
1409         if (!ret)
1410             isa_registered = 1;
1411     }
1412 #ifdef CONFIG_EISA
1413     ret = eisa_driver_register(&el3_eisa_driver);
1414     if (!ret)
1415         eisa_registered = 1;
1416 #endif
1417 
1418 #ifdef CONFIG_PNP
1419     if (pnp_registered)
1420         ret = 0;
1421 #endif
1422     if (isa_registered)
1423         ret = 0;
1424 #ifdef CONFIG_EISA
1425     if (eisa_registered)
1426         ret = 0;
1427 #endif
1428     return ret;
1429 }
1430 
1431 static void __exit el3_cleanup_module(void)
1432 {
1433 #ifdef CONFIG_PNP
1434     if (pnp_registered)
1435         pnp_unregister_driver(&el3_pnp_driver);
1436 #endif
1437     if (isa_registered)
1438         isa_unregister_driver(&el3_isa_driver);
1439     if (id_port)
1440         release_region(id_port, 1);
1441 #ifdef CONFIG_EISA
1442     if (eisa_registered)
1443         eisa_driver_unregister(&el3_eisa_driver);
1444 #endif
1445 }
1446 
1447 module_init (el3_init_module);
1448 module_exit (el3_cleanup_module);
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!