/* Grab the 8390 specific header. Similar to the block_input routine, but * we don't need to be concerned with ring wrap as the header will be at * the start of a page, so we optimize accordingly. */ static void zorro8390_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page) { int nic_base = dev->base_addr; int cnt; short *ptrs; /* This *shouldn't* happen. * If it does, it's the last thing you'll see */ if (ei_status.dmaing) { netdev_err(dev, "%s: DMAing conflict [DMAstat:%d][irqlock:%d]\n", __func__, ei_status.dmaing, ei_status.irqlock); return; } ei_status.dmaing |= 0x01; z_writeb(E8390_NODMA + E8390_PAGE0 + E8390_START, nic_base + NE_CMD); z_writeb(ENISR_RDC, nic_base + NE_EN0_ISR); z_writeb(sizeof(struct e8390_pkt_hdr), nic_base + NE_EN0_RCNTLO); z_writeb(0, nic_base + NE_EN0_RCNTHI); z_writeb(0, nic_base + NE_EN0_RSARLO); /* On page boundary */ z_writeb(ring_page, nic_base + NE_EN0_RSARHI); z_writeb(E8390_RREAD+E8390_START, nic_base + NE_CMD); ptrs = (short *)hdr; for (cnt = 0; cnt < sizeof(struct e8390_pkt_hdr) >> 1; cnt++) *ptrs++ = z_readw(NE_BASE + NE_DATAPORT); z_writeb(ENISR_RDC, nic_base + NE_EN0_ISR); /* Ack intr */ hdr->count = WORDSWAP(hdr->count); ei_status.dmaing &= ~0x01; }
static void gayle_a1200_clear_irq(ide_drive_t *drive) { ide_hwif_t *hwif = drive->hwif; (void)z_readb(hwif->io_ports.status_addr); z_writeb(0x7c, hwif->io_ports.irq_addr); }
static void xsurf_clear_irq(ide_drive_t *drive) { /* * X-Surf needs 0 written to IRQ register to ensure ISA bit A11 stays at 0 */ z_writeb(0, drive->hwif->io_ports.irq_addr); }
static int xsurf_ack_intr(ide_hwif_t *hwif) { unsigned char ch; ch = z_readb(hwif->io_ports[IDE_IRQ_OFFSET]); /* X-Surf needs a 0 written to IRQ register to ensure ISA bit A11 stays at 0 */ z_writeb(0, hwif->io_ports[IDE_IRQ_OFFSET]); if (!(ch & 0x80)) return 0; return 1; }
static int gayle_ack_intr_a1200(ide_hwif_t *hwif) { unsigned char ch; ch = z_readb(hwif->io_ports.irq_addr); if (!(ch & GAYLE_IRQ_IDE)) return 0; (void)z_readb(hwif->io_ports.status_addr); z_writeb(0x7c, hwif->io_ports.irq_addr); return 1; }
/* Hard reset the card. This used to pause for the same period that a * 8390 reset command required, but that shouldn't be necessary. */ static void zorro8390_reset_8390(struct net_device *dev) { unsigned long reset_start_time = jiffies; struct ei_device *ei_local = netdev_priv(dev); netif_dbg(ei_local, hw, dev, "resetting - t=%ld...\n", jiffies); z_writeb(z_readb(NE_BASE + NE_RESET), NE_BASE + NE_RESET); ei_status.txing = 0; ei_status.dmaing = 0; /* This check _should_not_ be necessary, omit eventually. */ while ((z_readb(NE_BASE + NE_EN0_ISR) & ENISR_RESET) == 0) if (time_after(jiffies, reset_start_time + 2 * HZ / 100)) { netdev_warn(dev, "%s: did not complete\n", __func__); break; } z_writeb(ENISR_RESET, NE_BASE + NE_EN0_ISR); /* Ack intr */ }
static int gayle_ack_intr_a1200(ide_hwif_t *hwif) { unsigned char ch; ch = z_readb(hwif->io_ports[IDE_IRQ_OFFSET]); if (!(ch & GAYLE_IRQ_IDE)) return 0; (void)z_readb(hwif->io_ports[IDE_STATUS_OFFSET]); z_writeb(0x7c, hwif->io_ports[IDE_IRQ_OFFSET]); return 1; }
static void zorro8390_block_output(struct net_device *dev, int count, const unsigned char *buf, const int start_page) { int nic_base = NE_BASE; unsigned long dma_start; short *ptrs; int cnt; /* Round the count up for word writes. Do we need to do this? * What effect will an odd byte count have on the 8390? * I should check someday. */ if (count & 0x01) count++; /* This *shouldn't* happen. * If it does, it's the last thing you'll see */ if (ei_status.dmaing) { netdev_err(dev, "%s: DMAing conflict [DMAstat:%d][irqlock:%d]\n", __func__, ei_status.dmaing, ei_status.irqlock); return; } ei_status.dmaing |= 0x01; /* We should already be in page 0, but to be safe... */ z_writeb(E8390_PAGE0+E8390_START+E8390_NODMA, nic_base + NE_CMD); z_writeb(ENISR_RDC, nic_base + NE_EN0_ISR); /* Now the normal output. */ z_writeb(count & 0xff, nic_base + NE_EN0_RCNTLO); z_writeb(count >> 8, nic_base + NE_EN0_RCNTHI); z_writeb(0x00, nic_base + NE_EN0_RSARLO); z_writeb(start_page, nic_base + NE_EN0_RSARHI); z_writeb(E8390_RWRITE + E8390_START, nic_base + NE_CMD); ptrs = (short *)buf; for (cnt = 0; cnt < count >> 1; cnt++) z_writew(*ptrs++, NE_BASE + NE_DATAPORT); dma_start = jiffies; while ((z_readb(NE_BASE + NE_EN0_ISR) & ENISR_RDC) == 0) if (time_after(jiffies, dma_start + 2 * HZ / 100)) { /* 20ms */ netdev_warn(dev, "timeout waiting for Tx RDC\n"); zorro8390_reset_8390(dev); __NS8390_init(dev, 1); break; } z_writeb(ENISR_RDC, nic_base + NE_EN0_ISR); /* Ack intr */ ei_status.dmaing &= ~0x01; }
/* Block input and output, similar to the Crynwr packet driver. * If you are porting to a new ethercard, look at the packet driver source * for hints. The NEx000 doesn't share the on-board packet memory -- * you have to put the packet out through the "remote DMA" dataport * using z_writeb. */ static void zorro8390_block_input(struct net_device *dev, int count, struct sk_buff *skb, int ring_offset) { int nic_base = dev->base_addr; char *buf = skb->data; short *ptrs; int cnt; /* This *shouldn't* happen. * If it does, it's the last thing you'll see */ if (ei_status.dmaing) { netdev_err(dev, "%s: DMAing conflict [DMAstat:%d][irqlock:%d]\n", __func__, ei_status.dmaing, ei_status.irqlock); return; } ei_status.dmaing |= 0x01; z_writeb(E8390_NODMA + E8390_PAGE0 + E8390_START, nic_base + NE_CMD); z_writeb(ENISR_RDC, nic_base + NE_EN0_ISR); z_writeb(count & 0xff, nic_base + NE_EN0_RCNTLO); z_writeb(count >> 8, nic_base + NE_EN0_RCNTHI); z_writeb(ring_offset & 0xff, nic_base + NE_EN0_RSARLO); z_writeb(ring_offset >> 8, nic_base + NE_EN0_RSARHI); z_writeb(E8390_RREAD+E8390_START, nic_base + NE_CMD); ptrs = (short *)buf; for (cnt = 0; cnt < count >> 1; cnt++) *ptrs++ = z_readw(NE_BASE + NE_DATAPORT); if (count & 0x01) buf[count - 1] = z_readb(NE_BASE + NE_DATAPORT); z_writeb(ENISR_RDC, nic_base + NE_EN0_ISR); /* Ack intr */ ei_status.dmaing &= ~0x01; }
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(0); 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; <<<<<<< HEAD
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(0); 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); pr_info("%s: Hydra at %pR, address %pM (hydra.c " HYDRA_VERSION ")\n", dev->name, &z->resource, dev->dev_addr); return 0; }
void __init buddha_init(void) { hw_regs_t hw; ide_hwif_t *hwif; int i, index; struct zorro_dev *z = NULL; u_long buddha_board = 0; BuddhaType type; int buddha_num_hwifs; while ((z = zorro_find_device(ZORRO_WILDCARD, z))) { unsigned long board; if (z->id == ZORRO_PROD_INDIVIDUAL_COMPUTERS_BUDDHA) { buddha_num_hwifs = BUDDHA_NUM_HWIFS; type=BOARD_BUDDHA; } else if (z->id == ZORRO_PROD_INDIVIDUAL_COMPUTERS_CATWEASEL) { buddha_num_hwifs = CATWEASEL_NUM_HWIFS; type=BOARD_CATWEASEL; } else if (z->id == ZORRO_PROD_INDIVIDUAL_COMPUTERS_X_SURF) { buddha_num_hwifs = XSURF_NUM_HWIFS; type=BOARD_XSURF; } else continue; board = z->resource.start; /* * FIXME: we now have selectable mmio v/s iomio transports. */ if(type != BOARD_XSURF) { if (!request_mem_region(board+BUDDHA_BASE1, 0x800, "IDE")) continue; } else { if (!request_mem_region(board+XSURF_BASE1, 0x1000, "IDE")) continue; if (!request_mem_region(board+XSURF_BASE2, 0x1000, "IDE")) goto fail_base2; if (!request_mem_region(board+XSURF_IRQ1, 0x8, "IDE")) { release_mem_region(board+XSURF_BASE2, 0x1000); fail_base2: release_mem_region(board+XSURF_BASE1, 0x1000); continue; } } buddha_board = ZTWO_VADDR(board); /* write to BUDDHA_IRQ_MR to enable the board IRQ */ /* X-Surf doesn't have this. IRQs are always on */ if (type != BOARD_XSURF) z_writeb(0, buddha_board+BUDDHA_IRQ_MR); for(i=0;i<buddha_num_hwifs;i++) { if(type != BOARD_XSURF) { ide_setup_ports(&hw, (buddha_board+buddha_bases[i]), buddha_offsets, 0, (buddha_board+buddha_irqports[i]), buddha_ack_intr, // budda_iops, IRQ_AMIGA_PORTS); } else { ide_setup_ports(&hw, (buddha_board+xsurf_bases[i]), xsurf_offsets, 0, (buddha_board+xsurf_irqports[i]), xsurf_ack_intr, // xsurf_iops, IRQ_AMIGA_PORTS); } index = ide_register_hw(&hw, NULL, 1, &hwif); if (index != -1) { hwif->mmio = 1; printk("ide%d: ", index); switch(type) { case BOARD_BUDDHA: printk("Buddha"); break; case BOARD_CATWEASEL: printk("Catweasel"); break; case BOARD_XSURF: printk("X-Surf"); break; } printk(" IDE interface\n"); } } } }
static int zorro8390_init(struct net_device *dev, unsigned long board, const char *name, void __iomem *ioaddr) { int i; int err; unsigned char SA_prom[32]; int start_page, stop_page; struct ei_device *ei_local = netdev_priv(dev); static u32 zorro8390_offsets[16] = { 0x00, 0x02, 0x04, 0x06, 0x08, 0x0a, 0x0c, 0x0e, 0x10, 0x12, 0x14, 0x16, 0x18, 0x1a, 0x1c, 0x1e, }; /* Reset card. Who knows what dain-bramaged state it was left in. */ { unsigned long reset_start_time = jiffies; z_writeb(z_readb(ioaddr + NE_RESET), ioaddr + NE_RESET); while ((z_readb(ioaddr + NE_EN0_ISR) & ENISR_RESET) == 0) if (time_after(jiffies, reset_start_time + 2 * HZ / 100)) { netdev_warn(dev, "not found (no reset ack)\n"); return -ENODEV; } z_writeb(0xff, ioaddr + NE_EN0_ISR); /* Ack all intr. */ } /* Read the 16 bytes of station address PROM. * We must first initialize registers, * similar to NS8390_init(eifdev, 0). * We can't reliably read the SAPROM address without this. * (I learned the hard way!). */ { static const struct { u32 value; u32 offset; } program_seq[] = { {E8390_NODMA + E8390_PAGE0 + E8390_STOP, NE_CMD}, /* Select page 0 */ {0x48, NE_EN0_DCFG}, /* 0x48: Set byte-wide access */ {0x00, NE_EN0_RCNTLO}, /* Clear the count regs */ {0x00, NE_EN0_RCNTHI}, {0x00, NE_EN0_IMR}, /* Mask completion irq */ {0xFF, NE_EN0_ISR}, {E8390_RXOFF, NE_EN0_RXCR}, /* 0x20 Set to monitor */ {E8390_TXOFF, NE_EN0_TXCR}, /* 0x02 and loopback mode */ {32, NE_EN0_RCNTLO}, {0x00, NE_EN0_RCNTHI}, {0x00, NE_EN0_RSARLO}, /* DMA starting at 0x0000 */ {0x00, NE_EN0_RSARHI}, {E8390_RREAD + E8390_START, NE_CMD}, }; for (i = 0; i < ARRAY_SIZE(program_seq); i++) z_writeb(program_seq[i].value, ioaddr + program_seq[i].offset); } for (i = 0; i < 16; i++) { SA_prom[i] = z_readb(ioaddr + NE_DATAPORT); (void)z_readb(ioaddr + NE_DATAPORT); } /* We must set the 8390 for word mode. */ z_writeb(0x49, ioaddr + NE_EN0_DCFG); start_page = NESM_START_PG; stop_page = NESM_STOP_PG; dev->base_addr = (unsigned long)ioaddr; dev->irq = IRQ_AMIGA_PORTS; /* Install the Interrupt handler */ i = request_irq(IRQ_AMIGA_PORTS, __ei_interrupt, IRQF_SHARED, DRV_NAME, dev); if (i) return i; for (i = 0; i < ETH_ALEN; i++) dev->dev_addr[i] = SA_prom[i]; pr_debug("Found ethernet address: %pM\n", dev->dev_addr); ei_status.name = name; ei_status.tx_start_page = start_page; ei_status.stop_page = stop_page; ei_status.word16 = 1; ei_status.rx_start_page = start_page + TX_PAGES; ei_status.reset_8390 = zorro8390_reset_8390; ei_status.block_input = zorro8390_block_input; ei_status.block_output = zorro8390_block_output; ei_status.get_8390_hdr = zorro8390_get_8390_hdr; ei_status.reg_offset = zorro8390_offsets; dev->netdev_ops = &zorro8390_netdev_ops; __NS8390_init(dev, 0); ei_local->msg_enable = zorro8390_msg_enable; err = register_netdev(dev); if (err) { free_irq(IRQ_AMIGA_PORTS, dev); return err; } netdev_info(dev, "%s at 0x%08lx, Ethernet Address %pM\n", name, board, dev->dev_addr); return 0; }
static int __init buddha_init(void) { hw_regs_t hw; ide_hwif_t *hwif; int i; struct zorro_dev *z = NULL; u_long buddha_board = 0; BuddhaType type; int buddha_num_hwifs; while ((z = zorro_find_device(ZORRO_WILDCARD, z))) { unsigned long board; u8 idx[4] = { 0xff, 0xff, 0xff, 0xff }; if (z->id == ZORRO_PROD_INDIVIDUAL_COMPUTERS_BUDDHA) { buddha_num_hwifs = BUDDHA_NUM_HWIFS; type=BOARD_BUDDHA; } else if (z->id == ZORRO_PROD_INDIVIDUAL_COMPUTERS_CATWEASEL) { buddha_num_hwifs = CATWEASEL_NUM_HWIFS; type=BOARD_CATWEASEL; } else if (z->id == ZORRO_PROD_INDIVIDUAL_COMPUTERS_X_SURF) { buddha_num_hwifs = XSURF_NUM_HWIFS; type=BOARD_XSURF; } else continue; board = z->resource.start; /* * FIXME: we now have selectable mmio v/s iomio transports. */ if(type != BOARD_XSURF) { if (!request_mem_region(board+BUDDHA_BASE1, 0x800, "IDE")) continue; } else { if (!request_mem_region(board+XSURF_BASE1, 0x1000, "IDE")) continue; if (!request_mem_region(board+XSURF_BASE2, 0x1000, "IDE")) goto fail_base2; if (!request_mem_region(board+XSURF_IRQ1, 0x8, "IDE")) { release_mem_region(board+XSURF_BASE2, 0x1000); fail_base2: release_mem_region(board+XSURF_BASE1, 0x1000); continue; } } buddha_board = ZTWO_VADDR(board); /* write to BUDDHA_IRQ_MR to enable the board IRQ */ /* X-Surf doesn't have this. IRQs are always on */ if (type != BOARD_XSURF) z_writeb(0, buddha_board+BUDDHA_IRQ_MR); printk(KERN_INFO "ide: %s IDE controller\n", buddha_board_name[type]); for (i = 0; i < buddha_num_hwifs; i++) { unsigned long base, ctl, irq_port; ide_ack_intr_t *ack_intr; if (type != BOARD_XSURF) { base = buddha_board + buddha_bases[i]; ctl = base + BUDDHA_CONTROL; irq_port = buddha_board + buddha_irqports[i]; ack_intr = buddha_ack_intr; } else { base = buddha_board + xsurf_bases[i]; /* X-Surf has no CS1* (Control/AltStat) */ ctl = 0; irq_port = buddha_board + xsurf_irqports[i]; ack_intr = xsurf_ack_intr; } buddha_setup_ports(&hw, base, ctl, irq_port, ack_intr); hwif = ide_find_port(hw.io_ports[IDE_DATA_OFFSET]); if (hwif) { u8 index = hwif->index; ide_init_port_data(hwif, index); ide_init_port_hw(hwif, &hw); hwif->mmio = 1; idx[i] = index; } } ide_device_add(idx, NULL); } return 0; }
static int __init buddha_init(void) { struct zorro_dev *z = NULL; u_long buddha_board = 0; BuddhaType type; int buddha_num_hwifs, i; while ((z = zorro_find_device(ZORRO_WILDCARD, z))) { unsigned long board; struct ide_hw hw[MAX_NUM_HWIFS], *hws[MAX_NUM_HWIFS]; struct ide_port_info d = buddha_port_info; if (z->id == ZORRO_PROD_INDIVIDUAL_COMPUTERS_BUDDHA) { buddha_num_hwifs = BUDDHA_NUM_HWIFS; type=BOARD_BUDDHA; } else if (z->id == ZORRO_PROD_INDIVIDUAL_COMPUTERS_CATWEASEL) { buddha_num_hwifs = CATWEASEL_NUM_HWIFS; type=BOARD_CATWEASEL; } else if (z->id == ZORRO_PROD_INDIVIDUAL_COMPUTERS_X_SURF) { buddha_num_hwifs = XSURF_NUM_HWIFS; type=BOARD_XSURF; d.port_ops = &xsurf_port_ops; } else continue; board = z->resource.start; if(type != BOARD_XSURF) { if (!request_mem_region(board+BUDDHA_BASE1, 0x800, "IDE")) continue; } else { if (!request_mem_region(board+XSURF_BASE1, 0x1000, "IDE")) continue; if (!request_mem_region(board+XSURF_BASE2, 0x1000, "IDE")) goto fail_base2; if (!request_mem_region(board+XSURF_IRQ1, 0x8, "IDE")) { release_mem_region(board+XSURF_BASE2, 0x1000); fail_base2: release_mem_region(board+XSURF_BASE1, 0x1000); continue; } } buddha_board = ZTWO_VADDR(board); /* write to BUDDHA_IRQ_MR to enable the board IRQ */ /* X-Surf doesn't have this. IRQs are always on */ if (type != BOARD_XSURF) z_writeb(0, buddha_board+BUDDHA_IRQ_MR); printk(KERN_INFO "ide: %s IDE controller\n", buddha_board_name[type]); for (i = 0; i < buddha_num_hwifs; i++) { unsigned long base, ctl, irq_port; if (type != BOARD_XSURF) { base = buddha_board + buddha_bases[i]; ctl = base + BUDDHA_CONTROL; irq_port = buddha_board + buddha_irqports[i]; } else { base = buddha_board + xsurf_bases[i]; /* X-Surf has no CS1* (Control/AltStat) */ ctl = 0; irq_port = buddha_board + xsurf_irqports[i]; } buddha_setup_ports(&hw[i], base, ctl, irq_port); hws[i] = &hw[i]; } ide_host_add(&d, hws, i, NULL); } return 0; }
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; SET_MODULE_OWNER(dev); 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, SA_SHIRQ, "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->open = &hydra_open; dev->stop = &hydra_close; #ifdef CONFIG_NET_POLL_CONTROLLER dev->poll_controller = ei_poll; #endif 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%08lx, address " "%02x:%02x:%02x:%02x:%02x:%02x (hydra.c " HYDRA_VERSION ")\n", dev->name, z->resource.start, dev->dev_addr[0], dev->dev_addr[1], dev->dev_addr[2], dev->dev_addr[3], dev->dev_addr[4], dev->dev_addr[5]); return 0; }