int __init init_module(void) { struct net_device *dev; int this_dev, found = 0; for (this_dev = 0; this_dev < MAX_E21_CARDS; this_dev++) { if (io[this_dev] == 0) { if (this_dev != 0) break; /* only autoprobe 1st one */ printk(KERN_NOTICE "e2100.c: Presently autoprobing (not recommended) for a single card.\n"); } dev = alloc_ei_netdev(); if (!dev) break; dev->irq = irq[this_dev]; dev->base_addr = io[this_dev]; dev->mem_start = mem[this_dev]; dev->mem_end = xcvr[this_dev]; /* low 4bits = xcvr sel. */ if (do_e2100_probe(dev) == 0) { dev_e21[found++] = dev; continue; } free_netdev(dev); printk(KERN_WARNING "e2100.c: No E2100 card found (i/o = 0x%x).\n", io[this_dev]); break; } if (found) return 0; return -ENXIO; }
static int __init ac3200_module_init(void) { struct net_device *dev; int this_dev, found = 0; for (this_dev = 0; this_dev < MAX_AC32_CARDS; this_dev++) { if (io[this_dev] == 0 && this_dev != 0) break; dev = alloc_ei_netdev(); if (!dev) break; dev->irq = irq[this_dev]; dev->base_addr = io[this_dev]; dev->mem_start = mem[this_dev]; /* Currently ignored by driver */ if (do_ac3200_probe(dev) == 0) { dev_ac32[found++] = dev; continue; } free_netdev(dev); printk(KERN_WARNING "ac3200.c: No ac3200 card found (i/o = 0x%x).\n", io[this_dev]); break; } if (found) return 0; return -ENXIO; }
/* This is set up so that only a single autoprobe takes place per call. ISA device autoprobes on a running machine are not recommended. */ int __init init_module(void) { struct net_device *dev; int this_dev, found = 0; for (this_dev = 0; this_dev < MAX_HPP_CARDS; this_dev++) { if (io[this_dev] == 0) { if (this_dev != 0) break; /* only autoprobe 1st one */ printk(KERN_NOTICE "hp-plus.c: Presently autoprobing (not recommended) for a single card.\n"); } dev = alloc_ei_netdev(); if (!dev) break; dev->irq = irq[this_dev]; dev->base_addr = io[this_dev]; if (do_hpp_probe(dev) == 0) { dev_hpp[found++] = dev; continue; } free_netdev(dev); printk(KERN_WARNING "hp-plus.c: No HP-Plus card found (i/o = 0x%x).\n", io[this_dev]); break; } if (found) return 0; return -ENXIO; }
int init_module(void) { struct net_device *dev; int this_dev, found = 0; for (this_dev = 0; this_dev < MAX_ES_CARDS; this_dev++) { if (io[this_dev] == 0 && this_dev != 0) break; dev = alloc_ei_netdev(); if (!dev) break; dev->irq = irq[this_dev]; dev->base_addr = io[this_dev]; dev->mem_start = mem[this_dev]; if (do_es_probe(dev) == 0) { if (register_netdev(dev) == 0) { dev_es3210[found++] = dev; continue; } cleanup_card(dev); } free_netdev(dev); printk(KERN_WARNING "es3210.c: No es3210 card found (i/o = 0x%x).\n", io[this_dev]); break; } if (found) return 0; return -ENXIO; }
struct net_device * __init ac3200_probe(int unit) { struct net_device *dev = alloc_ei_netdev(); int err; if (!dev) return ERR_PTR(-ENOMEM); sprintf(dev->name, "eth%d", unit); netdev_boot_setup_check(dev); err = do_ac3200_probe(dev); if (err) goto out; return dev; out: free_netdev(dev); return ERR_PTR(err); }
struct net_device * __init ultra32_probe(int unit) { struct net_device *dev; int base; int irq; int err = -ENODEV; if (!EISA_bus) return ERR_PTR(-ENODEV); dev = alloc_ei_netdev(); if (!dev) return ERR_PTR(-ENOMEM); if (unit >= 0) { sprintf(dev->name, "eth%d", unit); netdev_boot_setup_check(dev); } SET_MODULE_OWNER(dev); irq = dev->irq; /* EISA spec allows for up to 16 slots, but 8 is typical. */ for (base = 0x1000 + ULTRA32_BASE; base < 0x9000; base += 0x1000) { if (ultra32_probe1(dev, base) == 0) break; dev->irq = irq; } if (base >= 0x9000) goto out; err = register_netdev(dev); if (err) goto out1; return dev; out1: cleanup_card(dev); out: free_netdev(dev); return ERR_PTR(err); }
struct net_device * __init es_probe(int unit) { struct net_device *dev = alloc_ei_netdev(); int err; if (!dev) return ERR_PTR(-ENOMEM); sprintf(dev->name, "eth%d", unit); netdev_boot_setup_check(dev); err = do_es_probe(dev); if (err) goto out; err = register_netdev(dev); if (err) goto out1; return dev; out1: cleanup_card(dev); out: free_netdev(dev); return ERR_PTR(err); }
struct net_device * __init mac8390_probe(int unit) { struct net_device *dev; volatile unsigned short *i; int version_disp = 0; struct nubus_dev * ndev = NULL; int err = -ENODEV; struct nubus_dir dir; struct nubus_dirent ent; int offset; static unsigned int slots; enum mac8390_type cardtype; /* probably should check for Nubus instead */ if (!MACH_IS_MAC) return ERR_PTR(-ENODEV); dev = alloc_ei_netdev(); if (!dev) return ERR_PTR(-ENOMEM); if (unit >= 0) sprintf(dev->name, "eth%d", unit); SET_MODULE_OWNER(dev); while ((ndev = nubus_find_type(NUBUS_CAT_NETWORK, NUBUS_TYPE_ETHERNET, ndev))) { /* Have we seen it already? */ if (slots & (1<<ndev->board->slot)) continue; slots |= 1<<ndev->board->slot; if ((cardtype = mac8390_ident(ndev)) == MAC8390_NONE) continue; if (version_disp == 0) { version_disp = 1; printk(version); } dev->irq = SLOT2IRQ(ndev->board->slot); /* This is getting to be a habit */ dev->base_addr = ndev->board->slot_addr | ((ndev->board->slot&0xf) << 20); /* Get some Nubus info - we will trust the card's idea of where its memory and registers are. */ if (nubus_get_func_dir(ndev, &dir) == -1) { printk(KERN_ERR "%s: Unable to get Nubus functional" " directory for slot %X!\n", dev->name, ndev->board->slot); continue; } /* Get the MAC address */ if ((nubus_find_rsrc(&dir, NUBUS_RESID_MAC_ADDRESS, &ent)) == -1) { printk(KERN_INFO "%s: Couldn't get MAC address!\n", dev->name); continue; } else { nubus_get_rsrc_mem(dev->dev_addr, &ent, 6); /* Some Sonic Sys cards masquerade as Farallon */ if (cardtype == MAC8390_FARALLON && dev->dev_addr[0] == 0x0 && dev->dev_addr[1] == 0x40 && dev->dev_addr[2] == 0x10) { /* This is really Sonic Sys card */ cardtype = MAC8390_SONICSYS; } } if (useresources[cardtype] == 1) { nubus_rewinddir(&dir); if (nubus_find_rsrc(&dir, NUBUS_RESID_MINOR_BASEOS, &ent) == -1) { printk(KERN_ERR "%s: Memory offset resource" " for slot %X not found!\n", dev->name, ndev->board->slot); continue; } nubus_get_rsrc_mem(&offset, &ent, 4); dev->mem_start = dev->base_addr + offset; /* yes, this is how the Apple driver does it */ dev->base_addr = dev->mem_start + 0x10000; nubus_rewinddir(&dir); if (nubus_find_rsrc(&dir, NUBUS_RESID_MINOR_LENGTH, &ent) == -1) { printk(KERN_INFO "%s: Memory length resource" " for slot %X not found" ", probing\n", dev->name, ndev->board->slot); offset = mac8390_memsize(dev->mem_start); } else { nubus_get_rsrc_mem(&offset, &ent, 4); } dev->mem_end = dev->mem_start + offset; } else { switch (cardtype) { case MAC8390_KINETICS: case MAC8390_DAYNA: /* it's the same */ dev->base_addr = (int)(ndev->board->slot_addr + DAYNA_8390_BASE); dev->mem_start = (int)(ndev->board->slot_addr + DAYNA_8390_MEM); dev->mem_end = dev->mem_start + mac8390_memsize(dev->mem_start); break; case MAC8390_CABLETRON: dev->base_addr = (int)(ndev->board->slot_addr + CABLETRON_8390_BASE); dev->mem_start = (int)(ndev->board->slot_addr + CABLETRON_8390_MEM); /* The base address is unreadable if 0x00 * has been written to the command register * Reset the chip by writing E8390_NODMA + * E8390_PAGE0 + E8390_STOP just to be * sure */ i = (void *)dev->base_addr; *i = 0x21; dev->mem_end = dev->mem_start + mac8390_memsize(dev->mem_start); break; default: printk(KERN_ERR "Card type %s is" " unsupported, sorry\n", cardname[cardtype]); continue; } } /* Do the nasty 8390 stuff */ if (!mac8390_initdev(dev, ndev, cardtype)) break; } if (!ndev) goto out; err = register_netdev(dev); if (err) goto out; return dev; out: free_netdev(dev); return ERR_PTR(err); }
static int __devinit hydra_init(struct zorro_dev *z) { struct net_device *dev; unsigned long board = ZTWO_VADDR(z->resource.start); unsigned long ioaddr = board+HYDRA_NIC_BASE; const char name[] = "NE2000"; int start_page, stop_page; int j; int err; static u32 hydra_offsets[16] = { 0x00, 0x02, 0x04, 0x06, 0x08, 0x0a, 0x0c, 0x0e, 0x10, 0x12, 0x14, 0x16, 0x18, 0x1a, 0x1c, 0x1e, }; dev = alloc_ei_netdev(); if (!dev) return -ENOMEM; for(j = 0; j < ETHER_ADDR_LEN; j++) dev->dev_addr[j] = *((u8 *)(board + HYDRA_ADDRPROM + 2*j)); /* We must set the 8390 for word mode. */ z_writeb(0x4b, ioaddr + NE_EN0_DCFG); start_page = NESM_START_PG; stop_page = NESM_STOP_PG; dev->base_addr = ioaddr; dev->irq = IRQ_AMIGA_PORTS; /* Install the Interrupt handler */ if (request_irq(IRQ_AMIGA_PORTS, __ei_interrupt, IRQF_SHARED, "Hydra Ethernet", dev)) { free_netdev(dev); return -EAGAIN; } ei_status.name = name; ei_status.tx_start_page = start_page; ei_status.stop_page = stop_page; ei_status.word16 = 1; ei_status.bigendian = 1; ei_status.rx_start_page = start_page + TX_PAGES; ei_status.reset_8390 = &hydra_reset_8390; ei_status.block_input = &hydra_block_input; ei_status.block_output = &hydra_block_output; ei_status.get_8390_hdr = &hydra_get_8390_hdr; ei_status.reg_offset = hydra_offsets; dev->netdev_ops = &hydra_netdev_ops; __NS8390_init(dev, 0); err = register_netdev(dev); if (err) { free_irq(IRQ_AMIGA_PORTS, dev); free_netdev(dev); return err; } zorro_set_drvdata(z, dev); printk(KERN_INFO "%s: Hydra at 0x%08llx, address " "%pM (hydra.c " HYDRA_VERSION ")\n", dev->name, (unsigned long long)z->resource.start, dev->dev_addr); return 0; }
int __init ultramca_probe(struct device *gen_dev) { unsigned short ioaddr; struct net_device *dev; unsigned char reg4, num_pages; struct mca_device *mca_dev = to_mca_device(gen_dev); char slot = mca_dev->slot; unsigned char pos2 = 0xff, pos3 = 0xff, pos4 = 0xff, pos5 = 0xff; int i, rc; int adapter = mca_dev->index; int tbase = 0; int tirq = 0; int base_addr = ultra_io[ultra_found]; int irq = ultra_irq[ultra_found]; if (base_addr || irq) { printk(KERN_INFO "Probing for SMC MCA adapter"); if (base_addr) { printk(KERN_INFO " at I/O address 0x%04x%c", base_addr, irq ? ' ' : '\n'); } if (irq) { printk(KERN_INFO "using irq %d\n", irq); } } tirq = 0; tbase = 0; /* If we're trying to match a specificied irq or io address, * we'll reject the adapter found unless it's the one we're * looking for */ pos2 = mca_device_read_stored_pos(mca_dev, 2); /* io_addr */ pos3 = mca_device_read_stored_pos(mca_dev, 3); /* shared mem */ pos4 = mca_device_read_stored_pos(mca_dev, 4); /* ROM bios addr range */ pos5 = mca_device_read_stored_pos(mca_dev, 5); /* irq, media and RIPL */ /* Test the following conditions: * - If an irq parameter is supplied, compare it * with the irq of the adapter we found * - If a base_addr paramater is given, compare it * with the base_addr of the adapter we found * - Check that the irq and the base_addr of the * adapter we found is not already in use by * this driver */ switch (mca_dev->index) { case _61c8_SMC_Ethercard_PLUS_Elite_A_BNC_AUI_WD8013EP_A: case _61c9_SMC_Ethercard_PLUS_Elite_A_UTP_AUI_WD8013EP_A: case _efd4_IBM_PS2_Adapter_A_for_Ethernet_UTP_AUI_WD8013WP_A: case _efd5_IBM_PS2_Adapter_A_for_Ethernet_BNC_AUI_WD8013WP_A: { tbase = addr_table[(pos2 & 0xf0) >> 4].base_addr; tirq = irq_table[(pos5 & 0xc) >> 2].new_irq; break; } case _6fc0_WD_Ethercard_PLUS_A_WD8003E_A_OR_WD8003ET_A: case _6fc1_WD_Starcard_PLUS_A_WD8003ST_A: case _6fc2_WD_Ethercard_PLUS_10T_A_WD8003W_A: case _efe5_IBM_PS2_Adapter_A_for_Ethernet: { tbase = ((pos2 & 0x0fe) * 0x10); tirq = irq_table[(pos5 & 3)].old_irq; break; } } if(!tirq || !tbase || (irq && irq != tirq) || (base_addr && tbase != base_addr)) /* FIXME: we're trying to force the ordering of the * devices here, there should be a way of getting this * to happen */ return -ENXIO; /* Adapter found. */ dev = alloc_ei_netdev(); if(!dev) return -ENODEV; SET_MODULE_OWNER(dev); SET_NETDEV_DEV(dev, gen_dev); mca_device_set_name(mca_dev, smc_mca_adapter_names[adapter]); mca_device_set_claim(mca_dev, 1); printk(KERN_INFO "smc_mca: %s found in slot %d\n", smc_mca_adapter_names[adapter], slot + 1); ultra_found++; dev->base_addr = ioaddr = mca_device_transform_ioport(mca_dev, tbase); dev->irq = mca_device_transform_irq(mca_dev, tirq); dev->mem_start = 0; num_pages = 40; switch (adapter) { /* card-# in const array above [hs] */ case _61c8_SMC_Ethercard_PLUS_Elite_A_BNC_AUI_WD8013EP_A: case _61c9_SMC_Ethercard_PLUS_Elite_A_UTP_AUI_WD8013EP_A: { for (i = 0; i < 16; i++) { /* taking 16 counts * up to 15 [hs] */ if (mem_table[i].mem_index == (pos3 & ~MEM_MASK)) { dev->mem_start = (unsigned long) mca_device_transform_memory(mca_dev, (void *)mem_table[i].mem_start); num_pages = mem_table[i].num_pages; } } break; } case _6fc0_WD_Ethercard_PLUS_A_WD8003E_A_OR_WD8003ET_A: case _6fc1_WD_Starcard_PLUS_A_WD8003ST_A: case _6fc2_WD_Ethercard_PLUS_10T_A_WD8003W_A: case _efe5_IBM_PS2_Adapter_A_for_Ethernet: { dev->mem_start = (unsigned long) mca_device_transform_memory(mca_dev, (void *)((pos3 & 0xfc) * 0x1000)); num_pages = 0x40; break; } case _efd4_IBM_PS2_Adapter_A_for_Ethernet_UTP_AUI_WD8013WP_A: case _efd5_IBM_PS2_Adapter_A_for_Ethernet_BNC_AUI_WD8013WP_A: { /* courtesy of [email protected], pos3 indicates * the index of the 0x2000 step. * beware different number of pages [hs] */ dev->mem_start = (unsigned long) mca_device_transform_memory(mca_dev, (void *)(0xc0000 + (0x2000 * (pos3 & 0xf)))); num_pages = 0x20 + (2 * (pos3 & 0x10)); break; } } /* sanity check, shouldn't happen */ if (dev->mem_start == 0) { rc = -ENODEV; goto err_unclaim; } if (!request_region(ioaddr, ULTRA_IO_EXTENT, DRV_NAME)) { rc = -ENODEV; goto err_unclaim; } reg4 = inb(ioaddr + 4) & 0x7f; outb(reg4, ioaddr + 4); printk(KERN_INFO "smc_mca[%d]: Parameters: %#3x,", slot + 1, ioaddr); for (i = 0; i < 6; i++) printk(" %2.2X", dev->dev_addr[i] = inb(ioaddr + 8 + i)); /* Switch from the station address to the alternate register set * and read the useful registers there. */ outb(0x80 | reg4, ioaddr + 4); /* Enable FINE16 mode to avoid BIOS ROM width mismatches @ reboot. */ outb(0x80 | inb(ioaddr + 0x0c), ioaddr + 0x0c); /* Switch back to the station address register set so that * the MS-DOS driver can find the card after a warm boot. */ outb(reg4, ioaddr + 4); gen_dev->driver_data = dev; /* The 8390 isn't at the base address, so fake the offset */ dev->base_addr = ioaddr + ULTRA_NIC_OFFSET; ei_status.name = "SMC Ultra MCA"; ei_status.word16 = 1; ei_status.tx_start_page = START_PG; ei_status.rx_start_page = START_PG + TX_PAGES; ei_status.stop_page = num_pages; ei_status.rmem_start = dev->mem_start + TX_PAGES * 256; dev->mem_end = ei_status.rmem_end = dev->mem_start + (ei_status.stop_page - START_PG) * 256; printk(", IRQ %d memory %#lx-%#lx.\n", dev->irq, dev->mem_start, dev->mem_end - 1); ei_status.reset_8390 = &ultramca_reset_8390; ei_status.block_input = &ultramca_block_input; ei_status.block_output = &ultramca_block_output; ei_status.get_8390_hdr = &ultramca_get_8390_hdr; ei_status.priv = slot; dev->open = &ultramca_open; dev->stop = &ultramca_close_card; #ifdef CONFIG_NET_POLL_CONTROLLER dev->poll_controller = ei_poll; #endif NS8390_init(dev, 0); rc = register_netdev(dev); if (rc) goto err_release_region; return 0; err_release_region: release_region(ioaddr, ULTRA_IO_EXTENT); err_unclaim: mca_device_set_claim(mca_dev, 0); free_netdev(dev); return rc; }