drivers/net/ethernet/8390/ne2k-pci.c

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
ne2k_pci_init_one
set_realtek_fdx
set_holtek_fdx
ne2k_pci_set_fdx
ne2k_pci_open
ne2k_pci_close
ne2k_pci_reset_8390
ne2k_pci_get_8390_hdr
ne2k_pci_block_input
ne2k_pci_block_output
ne2k_pci_get_drvinfo
ne2k_pci_get_msglevel
ne2k_pci_set_msglevel
ne2k_pci_remove_one
ne2k_pci_suspend
ne2k_pci_resume
ne2k_pci_init
ne2k_pci_cleanup
   1 /* ne2k-pci.c: A NE2000 clone on PCI bus driver for Linux. */
   2 /*
   3         A Linux device driver for PCI NE2000 clones.
   4 
   5         Authors and other copyright holders:
   6         1992-2000 by Donald Becker, NE2000 core and various modifications.
   7         1995-1998 by Paul Gortmaker, core modifications and PCI support.
   8         Copyright 1993 assigned to the United States Government as represented
   9         by the Director, National Security Agency.
  10 
  11         This software may be used and distributed according to the terms of
  12         the GNU General Public License (GPL), incorporated herein by reference.
  13         Drivers based on or derived from this code fall under the GPL and must
  14         retain the authorship, copyright and license notice.  This file is not
  15         a complete program and may only be used when the entire operating
  16         system is licensed under the GPL.
  17 
  18         The author may be reached as becker@scyld.com, or C/O
  19         Scyld Computing Corporation
  20         410 Severn Ave., Suite 210
  21         Annapolis MD 21403
  22 
  23         Issues remaining:
  24         People are making PCI ne2000 clones! Oh the horror, the horror...
  25         Limited full-duplex support.
  26 */
  27 
  28 #define DRV_NAME        "ne2k-pci"
  29 #define DRV_VERSION     "1.03"
  30 #define DRV_RELDATE     "9/22/2003"
  31 
  32 
  33 /* The user-configurable values.
  34    These may be modified when a driver module is loaded.*/
  35 
  36 #define MAX_UNITS 8                             /* More are supported, limit only on options */
  37 /* Used to pass the full-duplex flag, etc. */
  38 static int full_duplex[MAX_UNITS];
  39 static int options[MAX_UNITS];
  40 
  41 /* Force a non std. amount of memory.  Units are 256 byte pages. */
  42 /* #define PACKETBUF_MEMSIZE    0x40 */
  43 
  44 
  45 #include <linux/module.h>
  46 #include <linux/kernel.h>
  47 #include <linux/errno.h>
  48 #include <linux/pci.h>
  49 #include <linux/init.h>
  50 #include <linux/interrupt.h>
  51 #include <linux/ethtool.h>
  52 #include <linux/netdevice.h>
  53 #include <linux/etherdevice.h>
  54 
  55 #include <asm/io.h>
  56 #include <asm/irq.h>
  57 #include <linux/uaccess.h>
  58 
  59 #include "8390.h"
  60 
  61 static u32 ne2k_msg_enable;
  62 
  63 /* These identify the driver base version and may not be removed. */
  64 static const char version[] =
  65         KERN_INFO DRV_NAME ".c:v" DRV_VERSION " " DRV_RELDATE
  66         " D. Becker/P. Gortmaker\n";
  67 
  68 #if defined(__powerpc__)
  69 #define inl_le(addr)  le32_to_cpu(inl(addr))
  70 #define inw_le(addr)  le16_to_cpu(inw(addr))
  71 #endif
  72 
  73 #define PFX DRV_NAME ": "
  74 
  75 MODULE_AUTHOR("Donald Becker / Paul Gortmaker");
  76 MODULE_DESCRIPTION("PCI NE2000 clone driver");
  77 MODULE_LICENSE("GPL");
  78 
  79 module_param_named(msg_enable, ne2k_msg_enable, uint, 0444);
  80 module_param_array(options, int, NULL, 0);
  81 module_param_array(full_duplex, int, NULL, 0);
  82 MODULE_PARM_DESC(msg_enable, "Debug message level (see linux/netdevice.h for bitmap)");
  83 MODULE_PARM_DESC(options, "Bit 5: full duplex");
  84 MODULE_PARM_DESC(full_duplex, "full duplex setting(s) (1)");
  85 
  86 /* Some defines that people can play with if so inclined. */
  87 
  88 /* Use 32 bit data-movement operations instead of 16 bit. */
  89 #define USE_LONGIO
  90 
  91 /* Do we implement the read before write bugfix ? */
  92 /* #define NE_RW_BUGFIX */
  93 
  94 /* Flags.  We rename an existing ei_status field to store flags! */
  95 /* Thus only the low 8 bits are usable for non-init-time flags. */
  96 #define ne2k_flags reg0
  97 enum {
  98         ONLY_16BIT_IO=8, ONLY_32BIT_IO=4,       /* Chip can do only 16/32-bit xfers. */
  99         FORCE_FDX=0x20,                                         /* User override. */
 100         REALTEK_FDX=0x40, HOLTEK_FDX=0x80,
 101         STOP_PG_0x60=0x100,
 102 };
 103 
 104 enum ne2k_pci_chipsets {
 105         CH_RealTek_RTL_8029 = 0,
 106         CH_Winbond_89C940,
 107         CH_Compex_RL2000,
 108         CH_KTI_ET32P2,
 109         CH_NetVin_NV5000SC,
 110         CH_Via_86C926,
 111         CH_SureCom_NE34,
 112         CH_Winbond_W89C940F,
 113         CH_Holtek_HT80232,
 114         CH_Holtek_HT80229,
 115         CH_Winbond_89C940_8c4a,
 116 };
 117 
 118 
 119 static struct {
 120         char *name;
 121         int flags;
 122 } pci_clone_list[] = {
 123         {"RealTek RTL-8029", REALTEK_FDX},
 124         {"Winbond 89C940", 0},
 125         {"Compex RL2000", 0},
 126         {"KTI ET32P2", 0},
 127         {"NetVin NV5000SC", 0},
 128         {"Via 86C926", ONLY_16BIT_IO},
 129         {"SureCom NE34", 0},
 130         {"Winbond W89C940F", 0},
 131         {"Holtek HT80232", ONLY_16BIT_IO | HOLTEK_FDX},
 132         {"Holtek HT80229", ONLY_32BIT_IO | HOLTEK_FDX | STOP_PG_0x60 },
 133         {"Winbond W89C940(misprogrammed)", 0},
 134         {NULL,}
 135 };
 136 
 137 
 138 static const struct pci_device_id ne2k_pci_tbl[] = {
 139         { 0x10ec, 0x8029, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_RealTek_RTL_8029 },
 140         { 0x1050, 0x0940, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_Winbond_89C940 },
 141         { 0x11f6, 0x1401, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_Compex_RL2000 },
 142         { 0x8e2e, 0x3000, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_KTI_ET32P2 },
 143         { 0x4a14, 0x5000, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_NetVin_NV5000SC },
 144         { 0x1106, 0x0926, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_Via_86C926 },
 145         { 0x10bd, 0x0e34, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_SureCom_NE34 },
 146         { 0x1050, 0x5a5a, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_Winbond_W89C940F },
 147         { 0x12c3, 0x0058, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_Holtek_HT80232 },
 148         { 0x12c3, 0x5598, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_Holtek_HT80229 },
 149         { 0x8c4a, 0x1980, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_Winbond_89C940_8c4a },
 150         { 0, }
 151 };
 152 MODULE_DEVICE_TABLE(pci, ne2k_pci_tbl);
 153 
 154 
 155 /* ---- No user-serviceable parts below ---- */
 156 
 157 #define NE_BASE  (dev->base_addr)
 158 #define NE_CMD          0x00
 159 #define NE_DATAPORT     0x10    /* NatSemi-defined port window offset. */
 160 #define NE_RESET        0x1f    /* Issue a read to reset, a write to clear. */
 161 #define NE_IO_EXTENT    0x20
 162 
 163 #define NESM_START_PG   0x40    /* First page of TX buffer */
 164 #define NESM_STOP_PG    0x80    /* Last page +1 of RX ring */
 165 
 166 
 167 static int ne2k_pci_open(struct net_device *dev);
 168 static int ne2k_pci_close(struct net_device *dev);
 169 
 170 static void ne2k_pci_reset_8390(struct net_device *dev);
 171 static void ne2k_pci_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr,
 172                           int ring_page);
 173 static void ne2k_pci_block_input(struct net_device *dev, int count,
 174                           struct sk_buff *skb, int ring_offset);
 175 static void ne2k_pci_block_output(struct net_device *dev, const int count,
 176                 const unsigned char *buf, const int start_page);
 177 static const struct ethtool_ops ne2k_pci_ethtool_ops;
 178 
 179 
 180 
 181 /* There is no room in the standard 8390 structure for extra info we need,
 182    so we build a meta/outer-wrapper structure.. */
 183 struct ne2k_pci_card {
 184         struct net_device *dev;
 185         struct pci_dev *pci_dev;
 186 };
 187 
 188 
 189 
 190 /*
 191   NEx000-clone boards have a Station Address (SA) PROM (SAPROM) in the packet
 192   buffer memory space.  By-the-spec NE2000 clones have 0x57,0x57 in bytes
 193   0x0e,0x0f of the SAPROM, while other supposed NE2000 clones must be
 194   detected by their SA prefix.
 195 
 196   Reading the SAPROM from a word-wide card with the 8390 set in byte-wide
 197   mode results in doubled values, which can be detected and compensated for.
 198 
 199   The probe is also responsible for initializing the card and filling
 200   in the 'dev' and 'ei_status' structures.
 201 */
 202 
 203 static const struct net_device_ops ne2k_netdev_ops = {
 204         .ndo_open               = ne2k_pci_open,
 205         .ndo_stop               = ne2k_pci_close,
 206         .ndo_start_xmit         = ei_start_xmit,
 207         .ndo_tx_timeout         = ei_tx_timeout,
 208         .ndo_get_stats          = ei_get_stats,
 209         .ndo_set_rx_mode        = ei_set_multicast_list,
 210         .ndo_validate_addr      = eth_validate_addr,
 211         .ndo_set_mac_address    = eth_mac_addr,
 212 #ifdef CONFIG_NET_POLL_CONTROLLER
 213         .ndo_poll_controller = ei_poll,
 214 #endif
 215 };
 216 
 217 static int ne2k_pci_init_one(struct pci_dev *pdev,
 218                              const struct pci_device_id *ent)
 219 {
 220         struct net_device *dev;
 221         int i;
 222         unsigned char SA_prom[32];
 223         int start_page, stop_page;
 224         int irq, reg0, chip_idx = ent->driver_data;
 225         static unsigned int fnd_cnt;
 226         long ioaddr;
 227         int flags = pci_clone_list[chip_idx].flags;
 228         struct ei_device *ei_local;
 229 
 230 /* when built into the kernel, we only print version if device is found */
 231 #ifndef MODULE
 232         static int printed_version;
 233         if (!printed_version++)
 234                 printk(version);
 235 #endif
 236 
 237         fnd_cnt++;
 238 
 239         i = pci_enable_device (pdev);
 240         if (i)
 241                 return i;
 242 
 243         ioaddr = pci_resource_start (pdev, 0);
 244         irq = pdev->irq;
 245 
 246         if (!ioaddr || ((pci_resource_flags (pdev, 0) & IORESOURCE_IO) == 0)) {
 247                 dev_err(&pdev->dev, "no I/O resource at PCI BAR #0\n");
 248                 goto err_out;
 249         }
 250 
 251         if (request_region (ioaddr, NE_IO_EXTENT, DRV_NAME) == NULL) {
 252                 dev_err(&pdev->dev, "I/O resource 0x%x @ 0x%lx busy\n",
 253                         NE_IO_EXTENT, ioaddr);
 254                 goto err_out;
 255         }
 256 
 257         reg0 = inb(ioaddr);
 258         if (reg0 == 0xFF)
 259                 goto err_out_free_res;
 260 
 261         /* Do a preliminary verification that we have a 8390. */
 262         {
 263                 int regd;
 264                 outb(E8390_NODMA+E8390_PAGE1+E8390_STOP, ioaddr + E8390_CMD);
 265                 regd = inb(ioaddr + 0x0d);
 266                 outb(0xff, ioaddr + 0x0d);
 267                 outb(E8390_NODMA+E8390_PAGE0, ioaddr + E8390_CMD);
 268                 inb(ioaddr + EN0_COUNTER0); /* Clear the counter by reading. */
 269                 if (inb(ioaddr + EN0_COUNTER0) != 0) {
 270                         outb(reg0, ioaddr);
 271                         outb(regd, ioaddr + 0x0d);      /* Restore the old values. */
 272                         goto err_out_free_res;
 273                 }
 274         }
 275 
 276         /* Allocate net_device, dev->priv; fill in 8390 specific dev fields. */
 277         dev = alloc_ei_netdev();
 278         if (!dev) {
 279                 dev_err(&pdev->dev, "cannot allocate ethernet device\n");
 280                 goto err_out_free_res;
 281         }
 282         dev->netdev_ops = &ne2k_netdev_ops;
 283         ei_local = netdev_priv(dev);
 284         ei_local->msg_enable = ne2k_msg_enable;
 285 
 286         SET_NETDEV_DEV(dev, &pdev->dev);
 287 
 288         /* Reset card. Who knows what dain-bramaged state it was left in. */
 289         {
 290                 unsigned long reset_start_time = jiffies;
 291 
 292                 outb(inb(ioaddr + NE_RESET), ioaddr + NE_RESET);
 293 
 294                 /* This looks like a horrible timing loop, but it should never take
 295                    more than a few cycles.
 296                 */
 297                 while ((inb(ioaddr + EN0_ISR) & ENISR_RESET) == 0)
 298                         /* Limit wait: '2' avoids jiffy roll-over. */
 299                         if (jiffies - reset_start_time > 2) {
 300                                 dev_err(&pdev->dev,
 301                                         "Card failure (no reset ack).\n");
 302                                 goto err_out_free_netdev;
 303                         }
 304 
 305                 outb(0xff, ioaddr + EN0_ISR);           /* Ack all intr. */
 306         }
 307 
 308         /* Read the 16 bytes of station address PROM.
 309            We must first initialize registers, similar to NS8390_init(eifdev, 0).
 310            We can't reliably read the SAPROM address without this.
 311            (I learned the hard way!). */
 312         {
 313                 struct {unsigned char value, offset; } program_seq[] = {
 314                         {E8390_NODMA+E8390_PAGE0+E8390_STOP, E8390_CMD}, /* Select page 0*/
 315                         {0x49,  EN0_DCFG},      /* Set word-wide access. */
 316                         {0x00,  EN0_RCNTLO},    /* Clear the count regs. */
 317                         {0x00,  EN0_RCNTHI},
 318                         {0x00,  EN0_IMR},       /* Mask completion irq. */
 319                         {0xFF,  EN0_ISR},
 320                         {E8390_RXOFF, EN0_RXCR},        /* 0x20  Set to monitor */
 321                         {E8390_TXOFF, EN0_TXCR},        /* 0x02  and loopback mode. */
 322                         {32,    EN0_RCNTLO},
 323                         {0x00,  EN0_RCNTHI},
 324                         {0x00,  EN0_RSARLO},    /* DMA starting at 0x0000. */
 325                         {0x00,  EN0_RSARHI},
 326                         {E8390_RREAD+E8390_START, E8390_CMD},
 327                 };
 328                 for (i = 0; i < ARRAY_SIZE(program_seq); i++)
 329                         outb(program_seq[i].value, ioaddr + program_seq[i].offset);
 330 
 331         }
 332 
 333         /* Note: all PCI cards have at least 16 bit access, so we don't have
 334            to check for 8 bit cards.  Most cards permit 32 bit access. */
 335         if (flags & ONLY_32BIT_IO) {
 336                 for (i = 0; i < 4 ; i++)
 337                         ((u32 *)SA_prom)[i] = le32_to_cpu(inl(ioaddr + NE_DATAPORT));
 338         } else
 339                 for(i = 0; i < 32 /*sizeof(SA_prom)*/; i++)
 340                         SA_prom[i] = inb(ioaddr + NE_DATAPORT);
 341 
 342         /* We always set the 8390 registers for word mode. */
 343         outb(0x49, ioaddr + EN0_DCFG);
 344         start_page = NESM_START_PG;
 345 
 346         stop_page = flags & STOP_PG_0x60 ? 0x60 : NESM_STOP_PG;
 347 
 348         /* Set up the rest of the parameters. */
 349         dev->irq = irq;
 350         dev->base_addr = ioaddr;
 351         pci_set_drvdata(pdev, dev);
 352 
 353         ei_status.name = pci_clone_list[chip_idx].name;
 354         ei_status.tx_start_page = start_page;
 355         ei_status.stop_page = stop_page;
 356         ei_status.word16 = 1;
 357         ei_status.ne2k_flags = flags;
 358         if (fnd_cnt < MAX_UNITS) {
 359                 if (full_duplex[fnd_cnt] > 0  ||  (options[fnd_cnt] & FORCE_FDX))
 360                         ei_status.ne2k_flags |= FORCE_FDX;
 361         }
 362 
 363         ei_status.rx_start_page = start_page + TX_PAGES;
 364 #ifdef PACKETBUF_MEMSIZE
 365         /* Allow the packet buffer size to be overridden by know-it-alls. */
 366         ei_status.stop_page = ei_status.tx_start_page + PACKETBUF_MEMSIZE;
 367 #endif
 368 
 369         ei_status.reset_8390 = &ne2k_pci_reset_8390;
 370         ei_status.block_input = &ne2k_pci_block_input;
 371         ei_status.block_output = &ne2k_pci_block_output;
 372         ei_status.get_8390_hdr = &ne2k_pci_get_8390_hdr;
 373         ei_status.priv = (unsigned long) pdev;
 374 
 375         dev->ethtool_ops = &ne2k_pci_ethtool_ops;
 376         NS8390_init(dev, 0);
 377 
 378         memcpy(dev->dev_addr, SA_prom, dev->addr_len);
 379 
 380         i = register_netdev(dev);
 381         if (i)
 382                 goto err_out_free_netdev;
 383 
 384         netdev_info(dev, "%s found at %#lx, IRQ %d, %pM.\n",
 385                     pci_clone_list[chip_idx].name, ioaddr, dev->irq,
 386                     dev->dev_addr);
 387 
 388         return 0;
 389 
 390 err_out_free_netdev:
 391         free_netdev (dev);
 392 err_out_free_res:
 393         release_region (ioaddr, NE_IO_EXTENT);
 394 err_out:
 395         pci_disable_device(pdev);
 396         return -ENODEV;
 397 }
 398 
 399 /*
 400  * Magic incantation sequence for full duplex on the supported cards.
 401  */
 402 static inline int set_realtek_fdx(struct net_device *dev)
 403 {
 404         long ioaddr = dev->base_addr;
 405 
 406         outb(0xC0 + E8390_NODMA, ioaddr + NE_CMD); /* Page 3 */
 407         outb(0xC0, ioaddr + 0x01); /* Enable writes to CONFIG3 */
 408         outb(0x40, ioaddr + 0x06); /* Enable full duplex */
 409         outb(0x00, ioaddr + 0x01); /* Disable writes to CONFIG3 */
 410         outb(E8390_PAGE0 + E8390_NODMA, ioaddr + NE_CMD); /* Page 0 */
 411         return 0;
 412 }
 413 
 414 static inline int set_holtek_fdx(struct net_device *dev)
 415 {
 416         long ioaddr = dev->base_addr;
 417 
 418         outb(inb(ioaddr + 0x20) | 0x80, ioaddr + 0x20);
 419         return 0;
 420 }
 421 
 422 static int ne2k_pci_set_fdx(struct net_device *dev)
 423 {
 424         if (ei_status.ne2k_flags & REALTEK_FDX)
 425                 return set_realtek_fdx(dev);
 426         else if (ei_status.ne2k_flags & HOLTEK_FDX)
 427                 return set_holtek_fdx(dev);
 428 
 429         return -EOPNOTSUPP;
 430 }
 431 
 432 static int ne2k_pci_open(struct net_device *dev)
 433 {
 434         int ret = request_irq(dev->irq, ei_interrupt, IRQF_SHARED, dev->name, dev);
 435         if (ret)
 436                 return ret;
 437 
 438         if (ei_status.ne2k_flags & FORCE_FDX)
 439                 ne2k_pci_set_fdx(dev);
 440 
 441         ei_open(dev);
 442         return 0;
 443 }
 444 
 445 static int ne2k_pci_close(struct net_device *dev)
 446 {
 447         ei_close(dev);
 448         free_irq(dev->irq, dev);
 449         return 0;
 450 }
 451 
 452 /* Hard reset the card.  This used to pause for the same period that a
 453    8390 reset command required, but that shouldn't be necessary. */
 454 static void ne2k_pci_reset_8390(struct net_device *dev)
 455 {
 456         unsigned long reset_start_time = jiffies;
 457         struct ei_device *ei_local = netdev_priv(dev);
 458 
 459         netif_dbg(ei_local, hw, dev, "resetting the 8390 t=%ld...\n",
 460                   jiffies);
 461 
 462         outb(inb(NE_BASE + NE_RESET), NE_BASE + NE_RESET);
 463 
 464         ei_status.txing = 0;
 465         ei_status.dmaing = 0;
 466 
 467         /* This check _should_not_ be necessary, omit eventually. */
 468         while ((inb(NE_BASE+EN0_ISR) & ENISR_RESET) == 0)
 469                 if (jiffies - reset_start_time > 2) {
 470                         netdev_err(dev, "ne2k_pci_reset_8390() did not complete.\n");
 471                         break;
 472                 }
 473         outb(ENISR_RESET, NE_BASE + EN0_ISR);   /* Ack intr. */
 474 }
 475 
 476 /* Grab the 8390 specific header. Similar to the block_input routine, but
 477    we don't need to be concerned with ring wrap as the header will be at
 478    the start of a page, so we optimize accordingly. */
 479 
 480 static void ne2k_pci_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
 481 {
 482 
 483         long nic_base = dev->base_addr;
 484 
 485         /* This *shouldn't* happen. If it does, it's the last thing you'll see */
 486         if (ei_status.dmaing) {
 487                 netdev_err(dev, "DMAing conflict in ne2k_pci_get_8390_hdr "
 488                            "[DMAstat:%d][irqlock:%d].\n",
 489                            ei_status.dmaing, ei_status.irqlock);
 490                 return;
 491         }
 492 
 493         ei_status.dmaing |= 0x01;
 494         outb(E8390_NODMA+E8390_PAGE0+E8390_START, nic_base+ NE_CMD);
 495         outb(sizeof(struct e8390_pkt_hdr), nic_base + EN0_RCNTLO);
 496         outb(0, nic_base + EN0_RCNTHI);
 497         outb(0, nic_base + EN0_RSARLO);         /* On page boundary */
 498         outb(ring_page, nic_base + EN0_RSARHI);
 499         outb(E8390_RREAD+E8390_START, nic_base + NE_CMD);
 500 
 501         if (ei_status.ne2k_flags & ONLY_16BIT_IO) {
 502                 insw(NE_BASE + NE_DATAPORT, hdr, sizeof(struct e8390_pkt_hdr)>>1);
 503         } else {
 504                 *(u32*)hdr = le32_to_cpu(inl(NE_BASE + NE_DATAPORT));
 505                 le16_to_cpus(&hdr->count);
 506         }
 507 
 508         outb(ENISR_RDC, nic_base + EN0_ISR);    /* Ack intr. */
 509         ei_status.dmaing &= ~0x01;
 510 }
 511 
 512 /* Block input and output, similar to the Crynwr packet driver.  If you
 513    are porting to a new ethercard, look at the packet driver source for hints.
 514    The NEx000 doesn't share the on-board packet memory -- you have to put
 515    the packet out through the "remote DMA" dataport using outb. */
 516 
 517 static void ne2k_pci_block_input(struct net_device *dev, int count,
 518                                  struct sk_buff *skb, int ring_offset)
 519 {
 520         long nic_base = dev->base_addr;
 521         char *buf = skb->data;
 522 
 523         /* This *shouldn't* happen. If it does, it's the last thing you'll see */
 524         if (ei_status.dmaing) {
 525                 netdev_err(dev, "DMAing conflict in ne2k_pci_block_input "
 526                            "[DMAstat:%d][irqlock:%d].\n",
 527                            ei_status.dmaing, ei_status.irqlock);
 528                 return;
 529         }
 530         ei_status.dmaing |= 0x01;
 531         if (ei_status.ne2k_flags & ONLY_32BIT_IO)
 532                 count = (count + 3) & 0xFFFC;
 533         outb(E8390_NODMA+E8390_PAGE0+E8390_START, nic_base+ NE_CMD);
 534         outb(count & 0xff, nic_base + EN0_RCNTLO);
 535         outb(count >> 8, nic_base + EN0_RCNTHI);
 536         outb(ring_offset & 0xff, nic_base + EN0_RSARLO);
 537         outb(ring_offset >> 8, nic_base + EN0_RSARHI);
 538         outb(E8390_RREAD+E8390_START, nic_base + NE_CMD);
 539 
 540         if (ei_status.ne2k_flags & ONLY_16BIT_IO) {
 541                 insw(NE_BASE + NE_DATAPORT,buf,count>>1);
 542                 if (count & 0x01) {
 543                         buf[count-1] = inb(NE_BASE + NE_DATAPORT);
 544                 }
 545         } else {
 546                 insl(NE_BASE + NE_DATAPORT, buf, count>>2);
 547                 if (count & 3) {
 548                         buf += count & ~3;
 549                         if (count & 2) {
 550                                 __le16 *b = (__le16 *)buf;
 551 
 552                                 *b++ = cpu_to_le16(inw(NE_BASE + NE_DATAPORT));
 553                                 buf = (char *)b;
 554                         }
 555                         if (count & 1)
 556                                 *buf = inb(NE_BASE + NE_DATAPORT);
 557                 }
 558         }
 559 
 560         outb(ENISR_RDC, nic_base + EN0_ISR);    /* Ack intr. */
 561         ei_status.dmaing &= ~0x01;
 562 }
 563 
 564 static void ne2k_pci_block_output(struct net_device *dev, int count,
 565                                   const unsigned char *buf, const int start_page)
 566 {
 567         long nic_base = NE_BASE;
 568         unsigned long dma_start;
 569 
 570         /* On little-endian it's always safe to round the count up for
 571            word writes. */
 572         if (ei_status.ne2k_flags & ONLY_32BIT_IO)
 573                 count = (count + 3) & 0xFFFC;
 574         else
 575                 if (count & 0x01)
 576                         count++;
 577 
 578         /* This *shouldn't* happen. If it does, it's the last thing you'll see */
 579         if (ei_status.dmaing) {
 580                 netdev_err(dev, "DMAing conflict in ne2k_pci_block_output."
 581                            "[DMAstat:%d][irqlock:%d]\n",
 582                            ei_status.dmaing, ei_status.irqlock);
 583                 return;
 584         }
 585         ei_status.dmaing |= 0x01;
 586         /* We should already be in page 0, but to be safe... */
 587         outb(E8390_PAGE0+E8390_START+E8390_NODMA, nic_base + NE_CMD);
 588 
 589 #ifdef NE8390_RW_BUGFIX
 590         /* Handle the read-before-write bug the same way as the
 591            Crynwr packet driver -- the NatSemi method doesn't work.
 592            Actually this doesn't always work either, but if you have
 593            problems with your NEx000 this is better than nothing! */
 594         outb(0x42, nic_base + EN0_RCNTLO);
 595         outb(0x00, nic_base + EN0_RCNTHI);
 596         outb(0x42, nic_base + EN0_RSARLO);
 597         outb(0x00, nic_base + EN0_RSARHI);
 598         outb(E8390_RREAD+E8390_START, nic_base + NE_CMD);
 599 #endif
 600         outb(ENISR_RDC, nic_base + EN0_ISR);
 601 
 602    /* Now the normal output. */
 603         outb(count & 0xff, nic_base + EN0_RCNTLO);
 604         outb(count >> 8,   nic_base + EN0_RCNTHI);
 605         outb(0x00, nic_base + EN0_RSARLO);
 606         outb(start_page, nic_base + EN0_RSARHI);
 607         outb(E8390_RWRITE+E8390_START, nic_base + NE_CMD);
 608         if (ei_status.ne2k_flags & ONLY_16BIT_IO) {
 609                 outsw(NE_BASE + NE_DATAPORT, buf, count>>1);
 610         } else {
 611                 outsl(NE_BASE + NE_DATAPORT, buf, count>>2);
 612                 if (count & 3) {
 613                         buf += count & ~3;
 614                         if (count & 2) {
 615                                 __le16 *b = (__le16 *)buf;
 616 
 617                                 outw(le16_to_cpu(*b++), NE_BASE + NE_DATAPORT);
 618                                 buf = (char *)b;
 619                         }
 620                 }
 621         }
 622 
 623         dma_start = jiffies;
 624 
 625         while ((inb(nic_base + EN0_ISR) & ENISR_RDC) == 0)
 626                 if (jiffies - dma_start > 2) {                  /* Avoid clock roll-over. */
 627                         netdev_warn(dev, "timeout waiting for Tx RDC.\n");
 628                         ne2k_pci_reset_8390(dev);
 629                         NS8390_init(dev,1);
 630                         break;
 631                 }
 632 
 633         outb(ENISR_RDC, nic_base + EN0_ISR);    /* Ack intr. */
 634         ei_status.dmaing &= ~0x01;
 635 }
 636 
 637 static void ne2k_pci_get_drvinfo(struct net_device *dev,
 638                                  struct ethtool_drvinfo *info)
 639 {
 640         struct ei_device *ei = netdev_priv(dev);
 641         struct pci_dev *pci_dev = (struct pci_dev *) ei->priv;
 642 
 643         strlcpy(info->driver, DRV_NAME, sizeof(info->driver));
 644         strlcpy(info->version, DRV_VERSION, sizeof(info->version));
 645         strlcpy(info->bus_info, pci_name(pci_dev), sizeof(info->bus_info));
 646 }
 647 
 648 static u32 ne2k_pci_get_msglevel(struct net_device *dev)
 649 {
 650         struct ei_device *ei_local = netdev_priv(dev);
 651 
 652         return ei_local->msg_enable;
 653 }
 654 
 655 static void ne2k_pci_set_msglevel(struct net_device *dev, u32 v)
 656 {
 657         struct ei_device *ei_local = netdev_priv(dev);
 658 
 659         ei_local->msg_enable = v;
 660 }
 661 
 662 static const struct ethtool_ops ne2k_pci_ethtool_ops = {
 663         .get_drvinfo            = ne2k_pci_get_drvinfo,
 664         .get_msglevel           = ne2k_pci_get_msglevel,
 665         .set_msglevel           = ne2k_pci_set_msglevel,
 666 };
 667 
 668 static void ne2k_pci_remove_one(struct pci_dev *pdev)
 669 {
 670         struct net_device *dev = pci_get_drvdata(pdev);
 671 
 672         BUG_ON(!dev);
 673         unregister_netdev(dev);
 674         release_region(dev->base_addr, NE_IO_EXTENT);
 675         free_netdev(dev);
 676         pci_disable_device(pdev);
 677 }
 678 
 679 #ifdef CONFIG_PM
 680 static int ne2k_pci_suspend (struct pci_dev *pdev, pm_message_t state)
 681 {
 682         struct net_device *dev = pci_get_drvdata (pdev);
 683 
 684         netif_device_detach(dev);
 685         pci_save_state(pdev);
 686         pci_disable_device(pdev);
 687         pci_set_power_state(pdev, pci_choose_state(pdev, state));
 688 
 689         return 0;
 690 }
 691 
 692 static int ne2k_pci_resume (struct pci_dev *pdev)
 693 {
 694         struct net_device *dev = pci_get_drvdata (pdev);
 695         int rc;
 696 
 697         pci_set_power_state(pdev, PCI_D0);
 698         pci_restore_state(pdev);
 699 
 700         rc = pci_enable_device(pdev);
 701         if (rc)
 702                 return rc;
 703 
 704         NS8390_init(dev, 1);
 705         netif_device_attach(dev);
 706 
 707         return 0;
 708 }
 709 
 710 #endif /* CONFIG_PM */
 711 
 712 
 713 static struct pci_driver ne2k_driver = {
 714         .name           = DRV_NAME,
 715         .probe          = ne2k_pci_init_one,
 716         .remove         = ne2k_pci_remove_one,
 717         .id_table       = ne2k_pci_tbl,
 718 #ifdef CONFIG_PM
 719         .suspend        = ne2k_pci_suspend,
 720         .resume         = ne2k_pci_resume,
 721 #endif /* CONFIG_PM */
 722 
 723 };
 724 
 725 
 726 static int __init ne2k_pci_init(void)
 727 {
 728 /* when a module, this is printed whether or not devices are found in probe */
 729 #ifdef MODULE
 730         printk(version);
 731 #endif
 732         return pci_register_driver(&ne2k_driver);
 733 }
 734 
 735 
 736 static void __exit ne2k_pci_cleanup(void)
 737 {
 738         pci_unregister_driver (&ne2k_driver);
 739 }
 740 
 741 module_init(ne2k_pci_init);
 742 module_exit(ne2k_pci_cleanup);
/* [<][>][^][v][top][bottom][index][help] */
root/drivers/net/ethernet/8390/ne2k-pci.c

DEFINITIONS
