Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | /* hp-plus.c: A HP PCLAN/plus ethernet driver for linux. */ |
| 2 | /* |
| 3 | Written 1994 by Donald Becker. |
| 4 | |
| 5 | This driver is for the Hewlett Packard PC LAN (27***) plus ethercards. |
| 6 | These cards are sold under several model numbers, usually 2724*. |
| 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 | As is often the case, a great deal of credit is owed to Russ Nelson. |
| 17 | The Crynwr packet driver was my primary source of HP-specific |
| 18 | programming information. |
| 19 | */ |
| 20 | |
| 21 | static const char version[] = |
| 22 | "hp-plus.c:v1.10 9/24/94 Donald Becker (becker@cesdis.gsfc.nasa.gov)\n"; |
| 23 | |
| 24 | #include <linux/module.h> |
| 25 | |
| 26 | #include <linux/string.h> /* Important -- this inlines word moves. */ |
| 27 | #include <linux/kernel.h> |
| 28 | #include <linux/errno.h> |
| 29 | #include <linux/ioport.h> |
| 30 | #include <linux/netdevice.h> |
| 31 | #include <linux/etherdevice.h> |
| 32 | #include <linux/init.h> |
| 33 | #include <linux/delay.h> |
| 34 | |
| 35 | #include <asm/system.h> |
| 36 | #include <asm/io.h> |
| 37 | |
| 38 | #include "8390.h" |
| 39 | |
| 40 | #define DRV_NAME "hp-plus" |
| 41 | |
| 42 | /* A zero-terminated list of I/O addresses to be probed. */ |
| 43 | static unsigned int hpplus_portlist[] __initdata = |
| 44 | {0x200, 0x240, 0x280, 0x2C0, 0x300, 0x320, 0x340, 0}; |
| 45 | |
| 46 | /* |
| 47 | The HP EtherTwist chip implementation is a fairly routine DP8390 |
| 48 | implementation. It allows both shared memory and programmed-I/O buffer |
| 49 | access, using a custom interface for both. The programmed-I/O mode is |
| 50 | entirely implemented in the HP EtherTwist chip, bypassing the problem |
| 51 | ridden built-in 8390 facilities used on NE2000 designs. The shared |
| 52 | memory mode is likewise special, with an offset register used to make |
| 53 | packets appear at the shared memory base. Both modes use a base and bounds |
| 54 | page register to hide the Rx ring buffer wrap -- a packet that spans the |
| 55 | end of physical buffer memory appears continuous to the driver. (c.f. the |
| 56 | 3c503 and Cabletron E2100) |
| 57 | |
| 58 | A special note: the internal buffer of the board is only 8 bits wide. |
| 59 | This lays several nasty traps for the unaware: |
| 60 | - the 8390 must be programmed for byte-wide operations |
| 61 | - all I/O and memory operations must work on whole words (the access |
| 62 | latches are serially preloaded and have no byte-swapping ability). |
| 63 | |
| 64 | This board is laid out in I/O space much like the earlier HP boards: |
| 65 | the first 16 locations are for the board registers, and the second 16 are |
| 66 | for the 8390. The board is easy to identify, with both a dedicated 16 bit |
| 67 | ID register and a constant 0x530* value in the upper bits of the paging |
| 68 | register. |
| 69 | */ |
| 70 | |
| 71 | #define HP_ID 0x00 /* ID register, always 0x4850. */ |
| 72 | #define HP_PAGING 0x02 /* Registers visible @ 8-f, see PageName. */ |
| 73 | #define HPP_OPTION 0x04 /* Bitmapped options, see HP_Option. */ |
| 74 | #define HPP_OUT_ADDR 0x08 /* I/O output location in Perf_Page. */ |
| 75 | #define HPP_IN_ADDR 0x0A /* I/O input location in Perf_Page. */ |
| 76 | #define HP_DATAPORT 0x0c /* I/O data transfer in Perf_Page. */ |
| 77 | #define NIC_OFFSET 0x10 /* Offset to the 8390 registers. */ |
| 78 | #define HP_IO_EXTENT 32 |
| 79 | |
| 80 | #define HP_START_PG 0x00 /* First page of TX buffer */ |
| 81 | #define HP_STOP_PG 0x80 /* Last page +1 of RX ring */ |
| 82 | |
| 83 | /* The register set selected in HP_PAGING. */ |
| 84 | enum PageName { |
| 85 | Perf_Page = 0, /* Normal operation. */ |
| 86 | MAC_Page = 1, /* The ethernet address (+checksum). */ |
| 87 | HW_Page = 2, /* EEPROM-loaded hardware parameters. */ |
| 88 | LAN_Page = 4, /* Transceiver selection, testing, etc. */ |
| 89 | ID_Page = 6 }; |
| 90 | |
| 91 | /* The bit definitions for the HPP_OPTION register. */ |
| 92 | enum HP_Option { |
| 93 | NICReset = 1, ChipReset = 2, /* Active low, really UNreset. */ |
| 94 | EnableIRQ = 4, FakeIntr = 8, BootROMEnb = 0x10, IOEnb = 0x20, |
| 95 | MemEnable = 0x40, ZeroWait = 0x80, MemDisable = 0x1000, }; |
| 96 | |
| 97 | static int hpp_probe1(struct net_device *dev, int ioaddr); |
| 98 | |
| 99 | static void hpp_reset_8390(struct net_device *dev); |
| 100 | static int hpp_open(struct net_device *dev); |
| 101 | static int hpp_close(struct net_device *dev); |
| 102 | static void hpp_mem_block_input(struct net_device *dev, int count, |
| 103 | struct sk_buff *skb, int ring_offset); |
| 104 | static void hpp_mem_block_output(struct net_device *dev, int count, |
| 105 | const unsigned char *buf, int start_page); |
| 106 | static void hpp_mem_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, |
| 107 | int ring_page); |
| 108 | static void hpp_io_block_input(struct net_device *dev, int count, |
| 109 | struct sk_buff *skb, int ring_offset); |
| 110 | static void hpp_io_block_output(struct net_device *dev, int count, |
| 111 | const unsigned char *buf, int start_page); |
| 112 | static void hpp_io_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, |
| 113 | int ring_page); |
| 114 | |
| 115 | |
| 116 | /* Probe a list of addresses for an HP LAN+ adaptor. |
| 117 | This routine is almost boilerplate. */ |
| 118 | |
| 119 | static int __init do_hpp_probe(struct net_device *dev) |
| 120 | { |
| 121 | int i; |
| 122 | int base_addr = dev->base_addr; |
| 123 | int irq = dev->irq; |
| 124 | |
| 125 | SET_MODULE_OWNER(dev); |
| 126 | |
| 127 | if (base_addr > 0x1ff) /* Check a single specified location. */ |
| 128 | return hpp_probe1(dev, base_addr); |
| 129 | else if (base_addr != 0) /* Don't probe at all. */ |
| 130 | return -ENXIO; |
| 131 | |
| 132 | for (i = 0; hpplus_portlist[i]; i++) { |
| 133 | if (hpp_probe1(dev, hpplus_portlist[i]) == 0) |
| 134 | return 0; |
| 135 | dev->irq = irq; |
| 136 | } |
| 137 | |
| 138 | return -ENODEV; |
| 139 | } |
| 140 | |
| 141 | static void cleanup_card(struct net_device *dev) |
| 142 | { |
| 143 | /* NB: hpp_close() handles free_irq */ |
| 144 | release_region(dev->base_addr - NIC_OFFSET, HP_IO_EXTENT); |
| 145 | } |
| 146 | |
| 147 | #ifndef MODULE |
| 148 | struct net_device * __init hp_plus_probe(int unit) |
| 149 | { |
| 150 | struct net_device *dev = alloc_ei_netdev(); |
| 151 | int err; |
| 152 | |
| 153 | if (!dev) |
| 154 | return ERR_PTR(-ENOMEM); |
| 155 | |
| 156 | sprintf(dev->name, "eth%d", unit); |
| 157 | netdev_boot_setup_check(dev); |
| 158 | |
| 159 | err = do_hpp_probe(dev); |
| 160 | if (err) |
| 161 | goto out; |
| 162 | err = register_netdev(dev); |
| 163 | if (err) |
| 164 | goto out1; |
| 165 | return dev; |
| 166 | out1: |
| 167 | cleanup_card(dev); |
| 168 | out: |
| 169 | free_netdev(dev); |
| 170 | return ERR_PTR(err); |
| 171 | } |
| 172 | #endif |
| 173 | |
| 174 | /* Do the interesting part of the probe at a single address. */ |
| 175 | static int __init hpp_probe1(struct net_device *dev, int ioaddr) |
| 176 | { |
| 177 | int i, retval; |
| 178 | unsigned char checksum = 0; |
| 179 | const char name[] = "HP-PC-LAN+"; |
| 180 | int mem_start; |
| 181 | static unsigned version_printed; |
| 182 | |
| 183 | if (!request_region(ioaddr, HP_IO_EXTENT, DRV_NAME)) |
| 184 | return -EBUSY; |
| 185 | |
| 186 | /* Check for the HP+ signature, 50 48 0x 53. */ |
| 187 | if (inw(ioaddr + HP_ID) != 0x4850 |
| 188 | || (inw(ioaddr + HP_PAGING) & 0xfff0) != 0x5300) { |
| 189 | retval = -ENODEV; |
| 190 | goto out; |
| 191 | } |
| 192 | |
| 193 | if (ei_debug && version_printed++ == 0) |
| 194 | printk(version); |
| 195 | |
| 196 | printk("%s: %s at %#3x,", dev->name, name, ioaddr); |
| 197 | |
| 198 | /* Retrieve and checksum the station address. */ |
| 199 | outw(MAC_Page, ioaddr + HP_PAGING); |
| 200 | |
| 201 | for(i = 0; i < ETHER_ADDR_LEN; i++) { |
| 202 | unsigned char inval = inb(ioaddr + 8 + i); |
| 203 | dev->dev_addr[i] = inval; |
| 204 | checksum += inval; |
| 205 | printk(" %2.2x", inval); |
| 206 | } |
| 207 | checksum += inb(ioaddr + 14); |
| 208 | |
| 209 | if (checksum != 0xff) { |
| 210 | printk(" bad checksum %2.2x.\n", checksum); |
| 211 | retval = -ENODEV; |
| 212 | goto out; |
| 213 | } else { |
| 214 | /* Point at the Software Configuration Flags. */ |
| 215 | outw(ID_Page, ioaddr + HP_PAGING); |
| 216 | printk(" ID %4.4x", inw(ioaddr + 12)); |
| 217 | } |
| 218 | |
| 219 | /* Read the IRQ line. */ |
| 220 | outw(HW_Page, ioaddr + HP_PAGING); |
| 221 | { |
| 222 | int irq = inb(ioaddr + 13) & 0x0f; |
| 223 | int option = inw(ioaddr + HPP_OPTION); |
| 224 | |
| 225 | dev->irq = irq; |
| 226 | if (option & MemEnable) { |
| 227 | mem_start = inw(ioaddr + 9) << 8; |
| 228 | printk(", IRQ %d, memory address %#x.\n", irq, mem_start); |
| 229 | } else { |
| 230 | mem_start = 0; |
| 231 | printk(", IRQ %d, programmed-I/O mode.\n", irq); |
| 232 | } |
| 233 | } |
| 234 | |
| 235 | /* Set the wrap registers for string I/O reads. */ |
| 236 | outw((HP_START_PG + TX_PAGES/2) | ((HP_STOP_PG - 1) << 8), ioaddr + 14); |
| 237 | |
| 238 | /* Set the base address to point to the NIC, not the "real" base! */ |
| 239 | dev->base_addr = ioaddr + NIC_OFFSET; |
| 240 | |
| 241 | dev->open = &hpp_open; |
| 242 | dev->stop = &hpp_close; |
| 243 | #ifdef CONFIG_NET_POLL_CONTROLLER |
| 244 | dev->poll_controller = ei_poll; |
| 245 | #endif |
| 246 | |
| 247 | ei_status.name = name; |
| 248 | ei_status.word16 = 0; /* Agggghhhhh! Debug time: 2 days! */ |
| 249 | ei_status.tx_start_page = HP_START_PG; |
| 250 | ei_status.rx_start_page = HP_START_PG + TX_PAGES/2; |
| 251 | ei_status.stop_page = HP_STOP_PG; |
| 252 | |
| 253 | ei_status.reset_8390 = &hpp_reset_8390; |
| 254 | ei_status.block_input = &hpp_io_block_input; |
| 255 | ei_status.block_output = &hpp_io_block_output; |
| 256 | ei_status.get_8390_hdr = &hpp_io_get_8390_hdr; |
| 257 | |
| 258 | /* Check if the memory_enable flag is set in the option register. */ |
| 259 | if (mem_start) { |
| 260 | ei_status.block_input = &hpp_mem_block_input; |
| 261 | ei_status.block_output = &hpp_mem_block_output; |
| 262 | ei_status.get_8390_hdr = &hpp_mem_get_8390_hdr; |
| 263 | dev->mem_start = mem_start; |
| 264 | ei_status.rmem_start = dev->mem_start + TX_PAGES/2*256; |
| 265 | dev->mem_end = ei_status.rmem_end |
| 266 | = dev->mem_start + (HP_STOP_PG - HP_START_PG)*256; |
| 267 | } |
| 268 | |
| 269 | outw(Perf_Page, ioaddr + HP_PAGING); |
| 270 | NS8390_init(dev, 0); |
| 271 | /* Leave the 8390 and HP chip reset. */ |
| 272 | outw(inw(ioaddr + HPP_OPTION) & ~EnableIRQ, ioaddr + HPP_OPTION); |
| 273 | |
| 274 | return 0; |
| 275 | out: |
| 276 | release_region(ioaddr, HP_IO_EXTENT); |
| 277 | return retval; |
| 278 | } |
| 279 | |
| 280 | static int |
| 281 | hpp_open(struct net_device *dev) |
| 282 | { |
| 283 | int ioaddr = dev->base_addr - NIC_OFFSET; |
| 284 | int option_reg; |
| 285 | int retval; |
| 286 | |
| 287 | if ((retval = request_irq(dev->irq, ei_interrupt, 0, dev->name, dev))) { |
| 288 | return retval; |
| 289 | } |
| 290 | |
| 291 | /* Reset the 8390 and HP chip. */ |
| 292 | option_reg = inw(ioaddr + HPP_OPTION); |
| 293 | outw(option_reg & ~(NICReset + ChipReset), ioaddr + HPP_OPTION); |
| 294 | udelay(5); |
| 295 | /* Unreset the board and enable interrupts. */ |
| 296 | outw(option_reg | (EnableIRQ + NICReset + ChipReset), ioaddr + HPP_OPTION); |
| 297 | |
| 298 | /* Set the wrap registers for programmed-I/O operation. */ |
| 299 | outw(HW_Page, ioaddr + HP_PAGING); |
| 300 | outw((HP_START_PG + TX_PAGES/2) | ((HP_STOP_PG - 1) << 8), ioaddr + 14); |
| 301 | |
| 302 | /* Select the operational page. */ |
| 303 | outw(Perf_Page, ioaddr + HP_PAGING); |
| 304 | |
| 305 | ei_open(dev); |
| 306 | return 0; |
| 307 | } |
| 308 | |
| 309 | static int |
| 310 | hpp_close(struct net_device *dev) |
| 311 | { |
| 312 | int ioaddr = dev->base_addr - NIC_OFFSET; |
| 313 | int option_reg = inw(ioaddr + HPP_OPTION); |
| 314 | |
| 315 | free_irq(dev->irq, dev); |
| 316 | ei_close(dev); |
| 317 | outw((option_reg & ~EnableIRQ) | MemDisable | NICReset | ChipReset, |
| 318 | ioaddr + HPP_OPTION); |
| 319 | |
| 320 | return 0; |
| 321 | } |
| 322 | |
| 323 | static void |
| 324 | hpp_reset_8390(struct net_device *dev) |
| 325 | { |
| 326 | int ioaddr = dev->base_addr - NIC_OFFSET; |
| 327 | int option_reg = inw(ioaddr + HPP_OPTION); |
| 328 | |
| 329 | if (ei_debug > 1) printk("resetting the 8390 time=%ld...", jiffies); |
| 330 | |
| 331 | outw(option_reg & ~(NICReset + ChipReset), ioaddr + HPP_OPTION); |
| 332 | /* Pause a few cycles for the hardware reset to take place. */ |
| 333 | udelay(5); |
| 334 | ei_status.txing = 0; |
| 335 | outw(option_reg | (EnableIRQ + NICReset + ChipReset), ioaddr + HPP_OPTION); |
| 336 | |
| 337 | udelay(5); |
| 338 | |
| 339 | |
| 340 | if ((inb_p(ioaddr+NIC_OFFSET+EN0_ISR) & ENISR_RESET) == 0) |
| 341 | printk("%s: hp_reset_8390() did not complete.\n", dev->name); |
| 342 | |
| 343 | if (ei_debug > 1) printk("8390 reset done (%ld).", jiffies); |
| 344 | return; |
| 345 | } |
| 346 | |
| 347 | /* The programmed-I/O version of reading the 4 byte 8390 specific header. |
| 348 | Note that transfer with the EtherTwist+ must be on word boundaries. */ |
| 349 | |
| 350 | static void |
| 351 | hpp_io_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page) |
| 352 | { |
| 353 | int ioaddr = dev->base_addr - NIC_OFFSET; |
| 354 | |
| 355 | outw((ring_page<<8), ioaddr + HPP_IN_ADDR); |
| 356 | insw(ioaddr + HP_DATAPORT, hdr, sizeof(struct e8390_pkt_hdr)>>1); |
| 357 | } |
| 358 | |
| 359 | /* Block input and output, similar to the Crynwr packet driver. */ |
| 360 | |
| 361 | static void |
| 362 | hpp_io_block_input(struct net_device *dev, int count, struct sk_buff *skb, int ring_offset) |
| 363 | { |
| 364 | int ioaddr = dev->base_addr - NIC_OFFSET; |
| 365 | char *buf = skb->data; |
| 366 | |
| 367 | outw(ring_offset, ioaddr + HPP_IN_ADDR); |
| 368 | insw(ioaddr + HP_DATAPORT, buf, count>>1); |
| 369 | if (count & 0x01) |
| 370 | buf[count-1] = inw(ioaddr + HP_DATAPORT); |
| 371 | } |
| 372 | |
| 373 | /* The corresponding shared memory versions of the above 2 functions. */ |
| 374 | |
| 375 | static void |
| 376 | hpp_mem_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page) |
| 377 | { |
| 378 | int ioaddr = dev->base_addr - NIC_OFFSET; |
| 379 | int option_reg = inw(ioaddr + HPP_OPTION); |
| 380 | |
| 381 | outw((ring_page<<8), ioaddr + HPP_IN_ADDR); |
| 382 | outw(option_reg & ~(MemDisable + BootROMEnb), ioaddr + HPP_OPTION); |
| 383 | isa_memcpy_fromio(hdr, dev->mem_start, sizeof(struct e8390_pkt_hdr)); |
| 384 | outw(option_reg, ioaddr + HPP_OPTION); |
| 385 | hdr->count = (le16_to_cpu(hdr->count) + 3) & ~3; /* Round up allocation. */ |
| 386 | } |
| 387 | |
| 388 | static void |
| 389 | hpp_mem_block_input(struct net_device *dev, int count, struct sk_buff *skb, int ring_offset) |
| 390 | { |
| 391 | int ioaddr = dev->base_addr - NIC_OFFSET; |
| 392 | int option_reg = inw(ioaddr + HPP_OPTION); |
| 393 | |
| 394 | outw(ring_offset, ioaddr + HPP_IN_ADDR); |
| 395 | |
| 396 | outw(option_reg & ~(MemDisable + BootROMEnb), ioaddr + HPP_OPTION); |
| 397 | |
| 398 | /* Caution: this relies on get_8390_hdr() rounding up count! |
| 399 | Also note that we *can't* use eth_io_copy_and_sum() because |
| 400 | it will not always copy "count" bytes (e.g. padded IP). */ |
| 401 | |
| 402 | isa_memcpy_fromio(skb->data, dev->mem_start, count); |
| 403 | outw(option_reg, ioaddr + HPP_OPTION); |
| 404 | } |
| 405 | |
| 406 | /* A special note: we *must* always transfer >=16 bit words. |
| 407 | It's always safe to round up, so we do. */ |
| 408 | static void |
| 409 | hpp_io_block_output(struct net_device *dev, int count, |
| 410 | const unsigned char *buf, int start_page) |
| 411 | { |
| 412 | int ioaddr = dev->base_addr - NIC_OFFSET; |
| 413 | outw(start_page << 8, ioaddr + HPP_OUT_ADDR); |
| 414 | outsl(ioaddr + HP_DATAPORT, buf, (count+3)>>2); |
| 415 | return; |
| 416 | } |
| 417 | |
| 418 | static void |
| 419 | hpp_mem_block_output(struct net_device *dev, int count, |
| 420 | const unsigned char *buf, int start_page) |
| 421 | { |
| 422 | int ioaddr = dev->base_addr - NIC_OFFSET; |
| 423 | int option_reg = inw(ioaddr + HPP_OPTION); |
| 424 | |
| 425 | outw(start_page << 8, ioaddr + HPP_OUT_ADDR); |
| 426 | outw(option_reg & ~(MemDisable + BootROMEnb), ioaddr + HPP_OPTION); |
| 427 | isa_memcpy_toio(dev->mem_start, buf, (count + 3) & ~3); |
| 428 | outw(option_reg, ioaddr + HPP_OPTION); |
| 429 | |
| 430 | return; |
| 431 | } |
| 432 | |
| 433 | |
| 434 | #ifdef MODULE |
| 435 | #define MAX_HPP_CARDS 4 /* Max number of HPP cards per module */ |
| 436 | static struct net_device *dev_hpp[MAX_HPP_CARDS]; |
| 437 | static int io[MAX_HPP_CARDS]; |
| 438 | static int irq[MAX_HPP_CARDS]; |
| 439 | |
| 440 | module_param_array(io, int, NULL, 0); |
| 441 | module_param_array(irq, int, NULL, 0); |
| 442 | MODULE_PARM_DESC(io, "I/O port address(es)"); |
| 443 | MODULE_PARM_DESC(irq, "IRQ number(s); ignored if properly detected"); |
| 444 | MODULE_DESCRIPTION("HP PC-LAN+ ISA ethernet driver"); |
| 445 | MODULE_LICENSE("GPL"); |
| 446 | |
| 447 | /* This is set up so that only a single autoprobe takes place per call. |
| 448 | ISA device autoprobes on a running machine are not recommended. */ |
| 449 | int |
| 450 | init_module(void) |
| 451 | { |
| 452 | struct net_device *dev; |
| 453 | int this_dev, found = 0; |
| 454 | |
| 455 | for (this_dev = 0; this_dev < MAX_HPP_CARDS; this_dev++) { |
| 456 | if (io[this_dev] == 0) { |
| 457 | if (this_dev != 0) break; /* only autoprobe 1st one */ |
| 458 | printk(KERN_NOTICE "hp-plus.c: Presently autoprobing (not recommended) for a single card.\n"); |
| 459 | } |
| 460 | dev = alloc_ei_netdev(); |
| 461 | if (!dev) |
| 462 | break; |
| 463 | dev->irq = irq[this_dev]; |
| 464 | dev->base_addr = io[this_dev]; |
| 465 | if (do_hpp_probe(dev) == 0) { |
| 466 | if (register_netdev(dev) == 0) { |
| 467 | dev_hpp[found++] = dev; |
| 468 | continue; |
| 469 | } |
| 470 | cleanup_card(dev); |
| 471 | } |
| 472 | free_netdev(dev); |
| 473 | printk(KERN_WARNING "hp-plus.c: No HP-Plus card found (i/o = 0x%x).\n", io[this_dev]); |
| 474 | break; |
| 475 | } |
| 476 | if (found) |
| 477 | return 0; |
| 478 | return -ENXIO; |
| 479 | } |
| 480 | |
| 481 | void |
| 482 | cleanup_module(void) |
| 483 | { |
| 484 | int this_dev; |
| 485 | |
| 486 | for (this_dev = 0; this_dev < MAX_HPP_CARDS; this_dev++) { |
| 487 | struct net_device *dev = dev_hpp[this_dev]; |
| 488 | if (dev) { |
| 489 | unregister_netdev(dev); |
| 490 | cleanup_card(dev); |
| 491 | free_netdev(dev); |
| 492 | } |
| 493 | } |
| 494 | } |
| 495 | #endif /* MODULE */ |