Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | /* wd.c: A WD80x3 ethernet driver for linux. */ |
| 2 | /* |
| 3 | Written 1993-94 by Donald Becker. |
| 4 | |
| 5 | Copyright 1993 United States Government as represented by the |
| 6 | Director, National Security Agency. |
| 7 | |
| 8 | This software may be used and distributed according to the terms |
| 9 | of the GNU General Public License, incorporated herein by reference. |
| 10 | |
| 11 | The author may be reached as becker@scyld.com, or C/O |
| 12 | Scyld Computing Corporation |
| 13 | 410 Severn Ave., Suite 210 |
| 14 | Annapolis MD 21403 |
| 15 | |
| 16 | This is a driver for WD8003 and WD8013 "compatible" ethercards. |
| 17 | |
| 18 | Thanks to Russ Nelson (nelson@crnwyr.com) for loaning me a WD8013. |
| 19 | |
| 20 | Changelog: |
| 21 | |
| 22 | Paul Gortmaker : multiple card support for module users, support |
| 23 | for non-standard memory sizes. |
| 24 | |
| 25 | |
| 26 | */ |
| 27 | |
| 28 | static const char version[] = |
| 29 | "wd.c:v1.10 9/23/94 Donald Becker (becker@cesdis.gsfc.nasa.gov)\n"; |
| 30 | |
| 31 | #include <linux/module.h> |
| 32 | #include <linux/kernel.h> |
| 33 | #include <linux/errno.h> |
| 34 | #include <linux/string.h> |
| 35 | #include <linux/init.h> |
| 36 | #include <linux/interrupt.h> |
| 37 | #include <linux/delay.h> |
| 38 | #include <linux/netdevice.h> |
| 39 | #include <linux/etherdevice.h> |
| 40 | |
| 41 | #include <asm/io.h> |
| 42 | #include <asm/system.h> |
| 43 | |
| 44 | #include "8390.h" |
| 45 | |
| 46 | #define DRV_NAME "wd" |
| 47 | |
| 48 | /* A zero-terminated list of I/O addresses to be probed. */ |
| 49 | static unsigned int wd_portlist[] __initdata = |
| 50 | {0x300, 0x280, 0x380, 0x240, 0}; |
| 51 | |
| 52 | static int wd_probe1(struct net_device *dev, int ioaddr); |
| 53 | |
| 54 | static int wd_open(struct net_device *dev); |
| 55 | static void wd_reset_8390(struct net_device *dev); |
| 56 | static void wd_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, |
| 57 | int ring_page); |
| 58 | static void wd_block_input(struct net_device *dev, int count, |
| 59 | struct sk_buff *skb, int ring_offset); |
| 60 | static void wd_block_output(struct net_device *dev, int count, |
| 61 | const unsigned char *buf, int start_page); |
| 62 | static int wd_close(struct net_device *dev); |
| 63 | |
Jeff Garzik | 6aa20a2 | 2006-09-13 13:24:59 -0400 | [diff] [blame] | 64 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 65 | #define WD_START_PG 0x00 /* First page of TX buffer */ |
| 66 | #define WD03_STOP_PG 0x20 /* Last page +1 of RX ring */ |
| 67 | #define WD13_STOP_PG 0x40 /* Last page +1 of RX ring */ |
| 68 | |
| 69 | #define WD_CMDREG 0 /* Offset to ASIC command register. */ |
| 70 | #define WD_RESET 0x80 /* Board reset, in WD_CMDREG. */ |
| 71 | #define WD_MEMENB 0x40 /* Enable the shared memory. */ |
| 72 | #define WD_CMDREG5 5 /* Offset to 16-bit-only ASIC register 5. */ |
| 73 | #define ISA16 0x80 /* Enable 16 bit access from the ISA bus. */ |
| 74 | #define NIC16 0x40 /* Enable 16 bit access from the 8390. */ |
| 75 | #define WD_NIC_OFFSET 16 /* Offset to the 8390 from the base_addr. */ |
| 76 | #define WD_IO_EXTENT 32 |
| 77 | |
Jeff Garzik | 6aa20a2 | 2006-09-13 13:24:59 -0400 | [diff] [blame] | 78 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 79 | /* Probe for the WD8003 and WD8013. These cards have the station |
| 80 | address PROM at I/O ports <base>+8 to <base>+13, with a checksum |
| 81 | following. A Soundblaster can have the same checksum as an WDethercard, |
| 82 | so we have an extra exclusionary check for it. |
| 83 | |
| 84 | The wd_probe1() routine initializes the card and fills the |
| 85 | station address field. */ |
| 86 | |
| 87 | static int __init do_wd_probe(struct net_device *dev) |
| 88 | { |
| 89 | int i; |
| 90 | struct resource *r; |
| 91 | int base_addr = dev->base_addr; |
| 92 | int irq = dev->irq; |
| 93 | int mem_start = dev->mem_start; |
| 94 | int mem_end = dev->mem_end; |
| 95 | |
| 96 | SET_MODULE_OWNER(dev); |
| 97 | |
| 98 | if (base_addr > 0x1ff) { /* Check a user specified location. */ |
| 99 | r = request_region(base_addr, WD_IO_EXTENT, "wd-probe"); |
| 100 | if ( r == NULL) |
| 101 | return -EBUSY; |
| 102 | i = wd_probe1(dev, base_addr); |
Jeff Garzik | 6aa20a2 | 2006-09-13 13:24:59 -0400 | [diff] [blame] | 103 | if (i != 0) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 104 | release_region(base_addr, WD_IO_EXTENT); |
| 105 | else |
| 106 | r->name = dev->name; |
| 107 | return i; |
| 108 | } |
| 109 | else if (base_addr != 0) /* Don't probe at all. */ |
| 110 | return -ENXIO; |
| 111 | |
| 112 | for (i = 0; wd_portlist[i]; i++) { |
| 113 | int ioaddr = wd_portlist[i]; |
| 114 | r = request_region(ioaddr, WD_IO_EXTENT, "wd-probe"); |
| 115 | if (r == NULL) |
| 116 | continue; |
| 117 | if (wd_probe1(dev, ioaddr) == 0) { |
| 118 | r->name = dev->name; |
| 119 | return 0; |
| 120 | } |
| 121 | release_region(ioaddr, WD_IO_EXTENT); |
| 122 | dev->irq = irq; |
| 123 | dev->mem_start = mem_start; |
| 124 | dev->mem_end = mem_end; |
| 125 | } |
| 126 | |
| 127 | return -ENODEV; |
| 128 | } |
| 129 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 130 | #ifndef MODULE |
| 131 | struct net_device * __init wd_probe(int unit) |
| 132 | { |
| 133 | struct net_device *dev = alloc_ei_netdev(); |
| 134 | int err; |
| 135 | |
| 136 | if (!dev) |
| 137 | return ERR_PTR(-ENOMEM); |
| 138 | |
| 139 | sprintf(dev->name, "eth%d", unit); |
| 140 | netdev_boot_setup_check(dev); |
| 141 | |
| 142 | err = do_wd_probe(dev); |
| 143 | if (err) |
| 144 | goto out; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 145 | return dev; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 146 | out: |
| 147 | free_netdev(dev); |
| 148 | return ERR_PTR(err); |
| 149 | } |
| 150 | #endif |
| 151 | |
| 152 | static int __init wd_probe1(struct net_device *dev, int ioaddr) |
| 153 | { |
| 154 | int i; |
| b1fc550 | 2005-05-12 20:11:55 -0400 | [diff] [blame] | 155 | int err; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 156 | int checksum = 0; |
| 157 | int ancient = 0; /* An old card without config registers. */ |
| 158 | int word16 = 0; /* 0 = 8 bit, 1 = 16 bit */ |
| 159 | const char *model_name; |
| 160 | static unsigned version_printed; |
| 161 | |
| 162 | for (i = 0; i < 8; i++) |
| 163 | checksum += inb(ioaddr + 8 + i); |
| 164 | if (inb(ioaddr + 8) == 0xff /* Extra check to avoid soundcard. */ |
| 165 | || inb(ioaddr + 9) == 0xff |
| 166 | || (checksum & 0xff) != 0xFF) |
| 167 | return -ENODEV; |
| 168 | |
| 169 | /* Check for semi-valid mem_start/end values if supplied. */ |
| 170 | if ((dev->mem_start % 0x2000) || (dev->mem_end % 0x2000)) { |
| 171 | printk(KERN_WARNING "wd.c: user supplied mem_start or mem_end not on 8kB boundary - ignored.\n"); |
| 172 | dev->mem_start = 0; |
| 173 | dev->mem_end = 0; |
| 174 | } |
| 175 | |
| 176 | if (ei_debug && version_printed++ == 0) |
| 177 | printk(version); |
| 178 | |
| 179 | printk("%s: WD80x3 at %#3x,", dev->name, ioaddr); |
| 180 | for (i = 0; i < 6; i++) |
| 181 | printk(" %2.2X", dev->dev_addr[i] = inb(ioaddr + 8 + i)); |
| 182 | |
| 183 | /* The following PureData probe code was contributed by |
| 184 | Mike Jagdis <jaggy@purplet.demon.co.uk>. Puredata does software |
| 185 | configuration differently from others so we have to check for them. |
| 186 | This detects an 8 bit, 16 bit or dumb (Toshiba, jumpered) card. |
| 187 | */ |
| 188 | if (inb(ioaddr+0) == 'P' && inb(ioaddr+1) == 'D') { |
| 189 | unsigned char reg5 = inb(ioaddr+5); |
| 190 | |
| 191 | switch (inb(ioaddr+2)) { |
| 192 | case 0x03: word16 = 0; model_name = "PDI8023-8"; break; |
| 193 | case 0x05: word16 = 0; model_name = "PDUC8023"; break; |
| 194 | case 0x0a: word16 = 1; model_name = "PDI8023-16"; break; |
| 195 | /* Either 0x01 (dumb) or they've released a new version. */ |
| 196 | default: word16 = 0; model_name = "PDI8023"; break; |
| 197 | } |
| 198 | dev->mem_start = ((reg5 & 0x1c) + 0xc0) << 12; |
| 199 | dev->irq = (reg5 & 0xe0) == 0xe0 ? 10 : (reg5 >> 5) + 1; |
| 200 | } else { /* End of PureData probe */ |
| 201 | /* This method of checking for a 16-bit board is borrowed from the |
| 202 | we.c driver. A simpler method is just to look in ASIC reg. 0x03. |
| 203 | I'm comparing the two method in alpha test to make certain they |
| 204 | return the same result. */ |
| 205 | /* Check for the old 8 bit board - it has register 0/8 aliasing. |
| 206 | Do NOT check i>=6 here -- it hangs the old 8003 boards! */ |
| 207 | for (i = 0; i < 6; i++) |
| 208 | if (inb(ioaddr+i) != inb(ioaddr+8+i)) |
| 209 | break; |
| 210 | if (i >= 6) { |
| 211 | ancient = 1; |
| 212 | model_name = "WD8003-old"; |
| 213 | word16 = 0; |
| 214 | } else { |
| 215 | int tmp = inb(ioaddr+1); /* fiddle with 16bit bit */ |
| 216 | outb( tmp ^ 0x01, ioaddr+1 ); /* attempt to clear 16bit bit */ |
| 217 | if (((inb( ioaddr+1) & 0x01) == 0x01) /* A 16 bit card */ |
| 218 | && (tmp & 0x01) == 0x01 ) { /* In a 16 slot. */ |
| 219 | int asic_reg5 = inb(ioaddr+WD_CMDREG5); |
| 220 | /* Magic to set ASIC to word-wide mode. */ |
| 221 | outb( NIC16 | (asic_reg5&0x1f), ioaddr+WD_CMDREG5); |
| 222 | outb(tmp, ioaddr+1); |
| 223 | model_name = "WD8013"; |
| 224 | word16 = 1; /* We have a 16bit board here! */ |
| 225 | } else { |
| 226 | model_name = "WD8003"; |
| 227 | word16 = 0; |
| 228 | } |
| 229 | outb(tmp, ioaddr+1); /* Restore original reg1 value. */ |
| 230 | } |
| 231 | #ifndef final_version |
| 232 | if ( !ancient && (inb(ioaddr+1) & 0x01) != (word16 & 0x01)) |
| 233 | printk("\nWD80?3: Bus width conflict, %d (probe) != %d (reg report).", |
| 234 | word16 ? 16 : 8, (inb(ioaddr+1) & 0x01) ? 16 : 8); |
| 235 | #endif |
| 236 | } |
| 237 | |
| 238 | #if defined(WD_SHMEM) && WD_SHMEM > 0x80000 |
| 239 | /* Allow a compile-time override. */ |
| 240 | dev->mem_start = WD_SHMEM; |
| 241 | #else |
| 242 | if (dev->mem_start == 0) { |
| 243 | /* Sanity and old 8003 check */ |
| 244 | int reg0 = inb(ioaddr); |
| 245 | if (reg0 == 0xff || reg0 == 0) { |
| 246 | /* Future plan: this could check a few likely locations first. */ |
| 247 | dev->mem_start = 0xd0000; |
| 248 | printk(" assigning address %#lx", dev->mem_start); |
| 249 | } else { |
| 250 | int high_addr_bits = inb(ioaddr+WD_CMDREG5) & 0x1f; |
| 251 | /* Some boards don't have the register 5 -- it returns 0xff. */ |
| 252 | if (high_addr_bits == 0x1f || word16 == 0) |
| 253 | high_addr_bits = 0x01; |
| 254 | dev->mem_start = ((reg0&0x3f) << 13) + (high_addr_bits << 19); |
| 255 | } |
| 256 | } |
| 257 | #endif |
| 258 | |
| 259 | /* The 8390 isn't at the base address -- the ASIC regs are there! */ |
| 260 | dev->base_addr = ioaddr+WD_NIC_OFFSET; |
| 261 | |
| 262 | if (dev->irq < 2) { |
| 263 | int irqmap[] = {9,3,5,7,10,11,15,4}; |
| 264 | int reg1 = inb(ioaddr+1); |
| 265 | int reg4 = inb(ioaddr+4); |
| 266 | if (ancient || reg1 == 0xff) { /* Ack!! No way to read the IRQ! */ |
| 267 | short nic_addr = ioaddr+WD_NIC_OFFSET; |
| 268 | unsigned long irq_mask; |
| 269 | |
| 270 | /* We have an old-style ethercard that doesn't report its IRQ |
| 271 | line. Do autoirq to find the IRQ line. Note that this IS NOT |
| 272 | a reliable way to trigger an interrupt. */ |
| 273 | outb_p(E8390_NODMA + E8390_STOP, nic_addr); |
| 274 | outb(0x00, nic_addr+EN0_IMR); /* Disable all intrs. */ |
Jeff Garzik | 6aa20a2 | 2006-09-13 13:24:59 -0400 | [diff] [blame] | 275 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 276 | irq_mask = probe_irq_on(); |
| 277 | outb_p(0xff, nic_addr + EN0_IMR); /* Enable all interrupts. */ |
| 278 | outb_p(0x00, nic_addr + EN0_RCNTLO); |
| 279 | outb_p(0x00, nic_addr + EN0_RCNTHI); |
| 280 | outb(E8390_RREAD+E8390_START, nic_addr); /* Trigger it... */ |
| 281 | mdelay(20); |
| 282 | dev->irq = probe_irq_off(irq_mask); |
Jeff Garzik | 6aa20a2 | 2006-09-13 13:24:59 -0400 | [diff] [blame] | 283 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 284 | outb_p(0x00, nic_addr+EN0_IMR); /* Mask all intrs. again. */ |
| 285 | |
| 286 | if (ei_debug > 2) |
| 287 | printk(" autoirq is %d", dev->irq); |
| 288 | if (dev->irq < 2) |
| 289 | dev->irq = word16 ? 10 : 5; |
| 290 | } else |
| 291 | dev->irq = irqmap[((reg4 >> 5) & 0x03) + (reg1 & 0x04)]; |
| 292 | } else if (dev->irq == 2) /* Fixup bogosity: IRQ2 is really IRQ9 */ |
| 293 | dev->irq = 9; |
| 294 | |
| 295 | /* Snarf the interrupt now. There's no point in waiting since we cannot |
| 296 | share and the board will usually be enabled. */ |
| 297 | i = request_irq(dev->irq, ei_interrupt, 0, DRV_NAME, dev); |
| 298 | if (i) { |
| 299 | printk (" unable to get IRQ %d.\n", dev->irq); |
| 300 | return i; |
| 301 | } |
| 302 | |
| 303 | /* OK, were are certain this is going to work. Setup the device. */ |
| 304 | ei_status.name = model_name; |
| 305 | ei_status.word16 = word16; |
| 306 | ei_status.tx_start_page = WD_START_PG; |
| 307 | ei_status.rx_start_page = WD_START_PG + TX_PAGES; |
| 308 | |
| 309 | /* Don't map in the shared memory until the board is actually opened. */ |
| 310 | |
| 311 | /* Some cards (eg WD8003EBT) can be jumpered for more (32k!) memory. */ |
| 312 | if (dev->mem_end != 0) { |
| 313 | ei_status.stop_page = (dev->mem_end - dev->mem_start)/256; |
| 314 | ei_status.priv = dev->mem_end - dev->mem_start; |
| 315 | } else { |
| 316 | ei_status.stop_page = word16 ? WD13_STOP_PG : WD03_STOP_PG; |
| 317 | dev->mem_end = dev->mem_start + (ei_status.stop_page - WD_START_PG)*256; |
| 318 | ei_status.priv = (ei_status.stop_page - WD_START_PG)*256; |
| 319 | } |
| 320 | |
| 321 | ei_status.mem = ioremap(dev->mem_start, ei_status.priv); |
| 322 | if (!ei_status.mem) { |
| 323 | free_irq(dev->irq, dev); |
| 324 | return -ENOMEM; |
| 325 | } |
| 326 | |
| 327 | printk(" %s, IRQ %d, shared memory at %#lx-%#lx.\n", |
| 328 | model_name, dev->irq, dev->mem_start, dev->mem_end-1); |
| 329 | |
| 330 | ei_status.reset_8390 = &wd_reset_8390; |
| 331 | ei_status.block_input = &wd_block_input; |
| 332 | ei_status.block_output = &wd_block_output; |
| 333 | ei_status.get_8390_hdr = &wd_get_8390_hdr; |
| 334 | dev->open = &wd_open; |
| 335 | dev->stop = &wd_close; |
| 336 | #ifdef CONFIG_NET_POLL_CONTROLLER |
| 337 | dev->poll_controller = ei_poll; |
| 338 | #endif |
| 339 | NS8390_init(dev, 0); |
| 340 | |
| 341 | #if 1 |
| 342 | /* Enable interrupt generation on softconfig cards -- M.U */ |
| 343 | /* .. but possibly potentially unsafe - Donald */ |
| 344 | if (inb(ioaddr+14) & 0x20) |
| 345 | outb(inb(ioaddr+4)|0x80, ioaddr+4); |
| 346 | #endif |
| 347 | |
| b1fc550 | 2005-05-12 20:11:55 -0400 | [diff] [blame] | 348 | err = register_netdev(dev); |
| 349 | if (err) |
| 350 | free_irq(dev->irq, dev); |
| 351 | return err; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 352 | } |
| 353 | |
| 354 | static int |
| 355 | wd_open(struct net_device *dev) |
| 356 | { |
| 357 | int ioaddr = dev->base_addr - WD_NIC_OFFSET; /* WD_CMDREG */ |
| 358 | |
| 359 | /* Map in the shared memory. Always set register 0 last to remain |
| 360 | compatible with very old boards. */ |
| 361 | ei_status.reg0 = ((dev->mem_start>>13) & 0x3f) | WD_MEMENB; |
| 362 | ei_status.reg5 = ((dev->mem_start>>19) & 0x1f) | NIC16; |
| 363 | |
| 364 | if (ei_status.word16) |
| 365 | outb(ei_status.reg5, ioaddr+WD_CMDREG5); |
| 366 | outb(ei_status.reg0, ioaddr); /* WD_CMDREG */ |
| 367 | |
| 368 | ei_open(dev); |
| 369 | return 0; |
| 370 | } |
| 371 | |
| 372 | static void |
| 373 | wd_reset_8390(struct net_device *dev) |
| 374 | { |
| 375 | int wd_cmd_port = dev->base_addr - WD_NIC_OFFSET; /* WD_CMDREG */ |
| 376 | |
| 377 | outb(WD_RESET, wd_cmd_port); |
| 378 | if (ei_debug > 1) printk("resetting the WD80x3 t=%lu...", jiffies); |
| 379 | ei_status.txing = 0; |
| 380 | |
| 381 | /* Set up the ASIC registers, just in case something changed them. */ |
| 382 | outb((((dev->mem_start>>13) & 0x3f)|WD_MEMENB), wd_cmd_port); |
| 383 | if (ei_status.word16) |
| 384 | outb(NIC16 | ((dev->mem_start>>19) & 0x1f), wd_cmd_port+WD_CMDREG5); |
| 385 | |
| 386 | if (ei_debug > 1) printk("reset done\n"); |
| 387 | return; |
| 388 | } |
| 389 | |
| 390 | /* Grab the 8390 specific header. Similar to the block_input routine, but |
| 391 | we don't need to be concerned with ring wrap as the header will be at |
| 392 | the start of a page, so we optimize accordingly. */ |
| 393 | |
| 394 | static void |
| 395 | wd_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page) |
| 396 | { |
| 397 | |
| 398 | int wd_cmdreg = dev->base_addr - WD_NIC_OFFSET; /* WD_CMDREG */ |
| 399 | void __iomem *hdr_start = ei_status.mem + ((ring_page - WD_START_PG)<<8); |
| 400 | |
| 401 | /* We'll always get a 4 byte header read followed by a packet read, so |
| 402 | we enable 16 bit mode before the header, and disable after the body. */ |
| 403 | if (ei_status.word16) |
| 404 | outb(ISA16 | ei_status.reg5, wd_cmdreg+WD_CMDREG5); |
| 405 | |
| 406 | #ifdef __BIG_ENDIAN |
| 407 | /* Officially this is what we are doing, but the readl() is faster */ |
| 408 | /* unfortunately it isn't endian aware of the struct */ |
| 409 | memcpy_fromio(hdr, hdr_start, sizeof(struct e8390_pkt_hdr)); |
| 410 | hdr->count = le16_to_cpu(hdr->count); |
| 411 | #else |
| 412 | ((unsigned int*)hdr)[0] = readl(hdr_start); |
| 413 | #endif |
| 414 | } |
| 415 | |
| 416 | /* Block input and output are easy on shared memory ethercards, and trivial |
| 417 | on the Western digital card where there is no choice of how to do it. |
| 418 | The only complications are that the ring buffer wraps, and need to map |
| 419 | switch between 8- and 16-bit modes. */ |
| 420 | |
| 421 | static void |
| 422 | wd_block_input(struct net_device *dev, int count, struct sk_buff *skb, int ring_offset) |
| 423 | { |
| 424 | int wd_cmdreg = dev->base_addr - WD_NIC_OFFSET; /* WD_CMDREG */ |
| 425 | unsigned long offset = ring_offset - (WD_START_PG<<8); |
| 426 | void __iomem *xfer_start = ei_status.mem + offset; |
| 427 | |
| 428 | if (offset + count > ei_status.priv) { |
| 429 | /* We must wrap the input move. */ |
| 430 | int semi_count = ei_status.priv - offset; |
| 431 | memcpy_fromio(skb->data, xfer_start, semi_count); |
| 432 | count -= semi_count; |
| 433 | memcpy_fromio(skb->data + semi_count, ei_status.mem + TX_PAGES * 256, count); |
| 434 | } else { |
| 435 | /* Packet is in one chunk -- we can copy + cksum. */ |
| 436 | eth_io_copy_and_sum(skb, xfer_start, count, 0); |
| 437 | } |
| 438 | |
| 439 | /* Turn off 16 bit access so that reboot works. ISA brain-damage */ |
| 440 | if (ei_status.word16) |
| 441 | outb(ei_status.reg5, wd_cmdreg+WD_CMDREG5); |
| 442 | } |
| 443 | |
| 444 | static void |
| 445 | wd_block_output(struct net_device *dev, int count, const unsigned char *buf, |
| 446 | int start_page) |
| 447 | { |
| 448 | int wd_cmdreg = dev->base_addr - WD_NIC_OFFSET; /* WD_CMDREG */ |
| 449 | void __iomem *shmem = ei_status.mem + ((start_page - WD_START_PG)<<8); |
| 450 | |
| 451 | |
| 452 | if (ei_status.word16) { |
| 453 | /* Turn on and off 16 bit access so that reboot works. */ |
| 454 | outb(ISA16 | ei_status.reg5, wd_cmdreg+WD_CMDREG5); |
| 455 | memcpy_toio(shmem, buf, count); |
| 456 | outb(ei_status.reg5, wd_cmdreg+WD_CMDREG5); |
| 457 | } else |
| 458 | memcpy_toio(shmem, buf, count); |
| 459 | } |
| 460 | |
| 461 | |
| 462 | static int |
| 463 | wd_close(struct net_device *dev) |
| 464 | { |
| 465 | int wd_cmdreg = dev->base_addr - WD_NIC_OFFSET; /* WD_CMDREG */ |
| 466 | |
| 467 | if (ei_debug > 1) |
| 468 | printk("%s: Shutting down ethercard.\n", dev->name); |
| 469 | ei_close(dev); |
| 470 | |
| 471 | /* Change from 16-bit to 8-bit shared memory so reboot works. */ |
| 472 | if (ei_status.word16) |
| 473 | outb(ei_status.reg5, wd_cmdreg + WD_CMDREG5 ); |
| 474 | |
| 475 | /* And disable the shared memory. */ |
| 476 | outb(ei_status.reg0 & ~WD_MEMENB, wd_cmdreg); |
| 477 | |
| 478 | return 0; |
| 479 | } |
| 480 | |
Jeff Garzik | 6aa20a2 | 2006-09-13 13:24:59 -0400 | [diff] [blame] | 481 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 482 | #ifdef MODULE |
| 483 | #define MAX_WD_CARDS 4 /* Max number of wd cards per module */ |
| 484 | static struct net_device *dev_wd[MAX_WD_CARDS]; |
| 485 | static int io[MAX_WD_CARDS]; |
| 486 | static int irq[MAX_WD_CARDS]; |
| 487 | static int mem[MAX_WD_CARDS]; |
| 488 | static int mem_end[MAX_WD_CARDS]; /* for non std. mem size */ |
| 489 | |
| 490 | module_param_array(io, int, NULL, 0); |
| 491 | module_param_array(irq, int, NULL, 0); |
| 492 | module_param_array(mem, int, NULL, 0); |
| 493 | module_param_array(mem_end, int, NULL, 0); |
| 494 | MODULE_PARM_DESC(io, "I/O base address(es)"); |
| 495 | MODULE_PARM_DESC(irq, "IRQ number(s) (ignored for PureData boards)"); |
| 496 | MODULE_PARM_DESC(mem, "memory base address(es)(ignored for PureData boards)"); |
| 497 | MODULE_PARM_DESC(mem_end, "memory end address(es)"); |
| 498 | MODULE_DESCRIPTION("ISA Western Digital wd8003/wd8013 ; SMC Elite, Elite16 ethernet driver"); |
| 499 | MODULE_LICENSE("GPL"); |
| 500 | |
| 501 | /* This is set up so that only a single autoprobe takes place per call. |
| 502 | ISA device autoprobes on a running machine are not recommended. */ |
Andrew Morton | 5e5fa01 | 2006-08-14 23:00:06 -0700 | [diff] [blame] | 503 | |
| 504 | int __init init_module(void) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 505 | { |
| 506 | struct net_device *dev; |
| 507 | int this_dev, found = 0; |
| 508 | |
| 509 | for (this_dev = 0; this_dev < MAX_WD_CARDS; this_dev++) { |
| 510 | if (io[this_dev] == 0) { |
| 511 | if (this_dev != 0) break; /* only autoprobe 1st one */ |
| 512 | printk(KERN_NOTICE "wd.c: Presently autoprobing (not recommended) for a single card.\n"); |
| 513 | } |
| 514 | dev = alloc_ei_netdev(); |
| 515 | if (!dev) |
| 516 | break; |
| 517 | dev->irq = irq[this_dev]; |
| 518 | dev->base_addr = io[this_dev]; |
| 519 | dev->mem_start = mem[this_dev]; |
| 520 | dev->mem_end = mem_end[this_dev]; |
| 521 | if (do_wd_probe(dev) == 0) { |
| b1fc550 | 2005-05-12 20:11:55 -0400 | [diff] [blame] | 522 | dev_wd[found++] = dev; |
| 523 | continue; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 524 | } |
| 525 | free_netdev(dev); |
| 526 | printk(KERN_WARNING "wd.c: No wd80x3 card found (i/o = 0x%x).\n", io[this_dev]); |
| 527 | break; |
| 528 | } |
| 529 | if (found) |
| 530 | return 0; |
| 531 | return -ENXIO; |
| 532 | } |
| 533 | |
Denis Vlasenko | 64916f1 | 2006-01-05 22:45:47 -0800 | [diff] [blame] | 534 | static void cleanup_card(struct net_device *dev) |
| 535 | { |
| 536 | free_irq(dev->irq, dev); |
| 537 | release_region(dev->base_addr - WD_NIC_OFFSET, WD_IO_EXTENT); |
| 538 | iounmap(ei_status.mem); |
| 539 | } |
| 540 | |
Al Viro | afc8eb4 | 2006-06-14 18:50:53 -0400 | [diff] [blame^] | 541 | void __exit |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 542 | cleanup_module(void) |
| 543 | { |
| 544 | int this_dev; |
| 545 | |
| 546 | for (this_dev = 0; this_dev < MAX_WD_CARDS; this_dev++) { |
| 547 | struct net_device *dev = dev_wd[this_dev]; |
| 548 | if (dev) { |
| 549 | unregister_netdev(dev); |
| 550 | cleanup_card(dev); |
| 551 | free_netdev(dev); |
| 552 | } |
| 553 | } |
| 554 | } |
| 555 | #endif /* MODULE */ |