static int __init zorro_init(void) { struct zorro_dev *z; unsigned int i; if (!MACH_IS_AMIGA || !AMIGAHW_PRESENT(ZORRO)) return 0; pr_info("Zorro: Probing AutoConfig expansion devices: %d device%s\n", zorro_num_autocon, zorro_num_autocon == 1 ? "" : "s"); /* Initialize the Zorro bus */ INIT_LIST_HEAD(&zorro_bus.devices); strcpy(zorro_bus.dev.bus_id, "zorro"); device_register(&zorro_bus.dev); /* Request the resources */ zorro_bus.num_resources = AMIGAHW_PRESENT(ZORRO3) ? 4 : 2; for (i = 0; i < zorro_bus.num_resources; i++) request_resource(&iomem_resource, &zorro_bus.resources[i]); /* Register all devices */ for (i = 0; i < zorro_num_autocon; i++) { z = &zorro_autocon[i]; z->id = (z->rom.er_Manufacturer<<16) | (z->rom.er_Product<<8); if (z->id == ZORRO_PROD_GVP_EPC_BASE) { /* GVP quirk */ unsigned long magic = zorro_resource_start(z)+0x8000; z->id |= *(u16 *)ZTWO_VADDR(magic) & GVP_PRODMASK; } sprintf(z->name, "Zorro device %08x", z->id); zorro_name_device(z); z->resource.name = z->name; if (request_resource(zorro_find_parent_resource(z), &z->resource)) printk(KERN_ERR "Zorro: Address space collision on device %s " "[%lx:%lx]\n", z->name, (unsigned long)zorro_resource_start(z), (unsigned long)zorro_resource_end(z)); sprintf(z->dev.bus_id, "%02x", i); z->dev.parent = &zorro_bus.dev; z->dev.bus = &zorro_bus_type; device_register(&z->dev); zorro_create_sysfs_dev_files(z); } /* Mark all available Zorro II memory */ zorro_for_each_dev(z) { if (z->rom.er_Type & ERTF_MEMLIST) mark_region(zorro_resource_start(z), zorro_resource_end(z)+1, 1); } /* Unmark all used Zorro II memory */ for (i = 0; i < m68k_num_memory; i++) if (m68k_memory[i].addr < 16*1024*1024) mark_region(m68k_memory[i].addr, m68k_memory[i].addr+m68k_memory[i].size, 0); return 0; }
static int __init amiga_init_bus(void) { if (!MACH_IS_AMIGA || !AMIGAHW_PRESENT(ZORRO)) return -ENODEV; platform_device_register_simple("amiga-zorro", -1, zorro_resources, AMIGAHW_PRESENT(ZORRO3) ? 4 : 2); return 0; }
int a3000_detect(Scsi_Host_Template *tpnt) { static unsigned char called = 0; if (called) return 0; if (!MACH_IS_AMIGA || !AMIGAHW_PRESENT(A3000_SCSI)) return 0; tpnt->proc_dir = &proc_scsi_a3000; tpnt->proc_info = &wd33c93_proc_info; a3000_host = scsi_register (tpnt, sizeof(struct WD33C93_hostdata)); a3000_host->base = (unsigned char *)ZTWO_VADDR(0xDD0000); a3000_host->irq = IRQ_AMIGA_PORTS & ~IRQ_MACHSPEC; DMA(a3000_host)->DAWR = DAWR_A3000; wd33c93_init(a3000_host, (wd33c93_regs *)&(DMA(a3000_host)->SASR), dma_setup, dma_stop, WD33C93_FS_12_15); request_irq(IRQ_AMIGA_PORTS, a3000_intr, 0, "A3000 SCSI", a3000_intr); DMA(a3000_host)->CNTR = CNTR_PDMD | CNTR_INTEN; called = 1; return 1; }
void amiga_chip_init (void) { struct chip_desc *dp; if (!AMIGAHW_PRESENT(CHIP_RAM)) return; chipsize = boot_info.bi_amiga.chip_size; /* initialize start boundary */ dp = DP(chipaddr); dp->first = 1; dp->alloced = 0; dp->length = chipsize - 2*sizeof(*dp); /* initialize end boundary */ dp = DP(chipaddr + chipsize) - 1; dp->last = 1; dp->alloced = 0; dp->length = chipsize - 2*sizeof(*dp); #ifdef DEBUG printk ("chipram end boundary is %p, length is %d\n", dp, dp->length); #endif }
static int __init amimouse_init(void) { int err; if (!MACH_IS_AMIGA || !AMIGAHW_PRESENT(AMI_MOUSE)) return -ENODEV; amimouse_dev = input_allocate_device(); if (!amimouse_dev) return -ENOMEM; amimouse_dev->name = "Amiga mouse"; amimouse_dev->phys = "amimouse/input0"; amimouse_dev->id.bustype = BUS_AMIGA; amimouse_dev->id.vendor = 0x0001; amimouse_dev->id.product = 0x0002; amimouse_dev->id.version = 0x0100; amimouse_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REL); amimouse_dev->relbit[0] = BIT_MASK(REL_X) | BIT_MASK(REL_Y); amimouse_dev->keybit[BIT_WORD(BTN_LEFT)] = BIT_MASK(BTN_LEFT) | BIT_MASK(BTN_MIDDLE) | BIT_MASK(BTN_RIGHT); amimouse_dev->open = amimouse_open; amimouse_dev->close = amimouse_close; err = input_register_device(amimouse_dev); if (err) { input_free_device(amimouse_dev); return err; } return 0; }
static int __init amiga_init_bus(void) { struct platform_device *pdev; unsigned int n; if (!MACH_IS_AMIGA || !AMIGAHW_PRESENT(ZORRO)) return -ENODEV; n = AMIGAHW_PRESENT(ZORRO3) ? 4 : 2; pdev = platform_device_register_simple("amiga-zorro", -1, zorro_resources, n); if (IS_ERR(pdev)) return PTR_ERR(pdev); return 0; }
static int amiga_set_clock_mmss (unsigned long nowtime) { short real_seconds = nowtime % 60, real_minutes = (nowtime / 60) % 60; if (AMIGAHW_PRESENT(A3000_CLK)) { volatile struct tod3000 *tod = TOD_3000; tod->cntrl1 = TOD3000_CNTRL1_HOLD; tod->second1 = real_seconds / 10; tod->second2 = real_seconds % 10; tod->minute1 = real_minutes / 10; tod->minute2 = real_minutes % 10; tod->cntrl1 = TOD3000_CNTRL1_FREE; } else /* if (AMIGAHW_PRESENT(A2000_CLK)) */ { volatile struct tod2000 *tod = TOD_2000; tod->cntrl1 = TOD2000_CNTRL1_HOLD; while (tod->cntrl1 & TOD2000_CNTRL1_BUSY) ; tod->second1 = real_seconds / 10; tod->second2 = real_seconds % 10; tod->minute1 = real_minutes / 10; tod->minute2 = real_minutes % 10; tod->cntrl1 &= ~TOD2000_CNTRL1_HOLD; } return 0; }
void __init amiga_init_IRQ(void) { int i; /* initialize handlers */ for (i = 0; i < AMI_STD_IRQS; i++) { if (ami_servers[i]) { ami_irq_list[i] = NULL; } else { ami_irq_list[i] = new_irq_node(); ami_irq_list[i]->handler = ami_badint; ami_irq_list[i]->flags = 0; ami_irq_list[i]->dev_id = NULL; ami_irq_list[i]->devname = NULL; ami_irq_list[i]->next = NULL; } } for (i = 0; i < AMI_IRQS; i++) ami_ablecount[i] = 0; /* turn off PCMCIA interrupts */ if (AMIGAHW_PRESENT(PCMCIA)) gayle.inten = GAYLE_IRQ_IDE; /* turn off all interrupts and enable the master interrupt bit */ custom.intena = 0x7fff; custom.intreq = 0x7fff; custom.intena = IF_SETCLR | IF_INTEN; cia_init_IRQ(&ciaa_base); cia_init_IRQ(&ciab_base); }
__init void amiga_init_IRQ(void) { int i; for (i = 0; i < AMI_IRQS; i++) ami_ablecount[i] = 0; /* turn off PCMCIA interrupts */ if (AMIGAHW_PRESENT(PCMCIA)) gayle.inten = GAYLE_IRQ_IDE; /* turn off all interrupts... */ amiga_custom.intena = 0x7fff; amiga_custom.intreq = 0x7fff; #ifdef CONFIG_APUS /* Clear any inter-CPU interrupt requests. Circumvents bug in Blizzard IPL emulation HW (or so it appears). */ APUS_WRITE(APUS_INT_LVL, INTLVL_SETRESET | INTLVL_MASK); /* Init IPL emulation. */ APUS_WRITE(APUS_REG_INT, REGINT_INTMASTER | REGINT_ENABLEIPL); APUS_WRITE(APUS_IPL_EMU, IPLEMU_DISABLEINT); APUS_WRITE(APUS_IPL_EMU, IPLEMU_SETRESET | IPLEMU_IPLMASK); #endif /* ... and enable the master interrupt bit */ amiga_custom.intena = IF_SETCLR | IF_INTEN; cia_init_IRQ(&ciaa_base); cia_init_IRQ(&ciab_base); }
static int __devinit a4000t_probe(struct device *dev) { struct Scsi_Host * host = NULL; struct NCR_700_Host_Parameters *hostdata; if (!(MACH_IS_AMIGA && AMIGAHW_PRESENT(A4000_SCSI))) goto out; if (!request_mem_region(A4000T_SCSI_ADDR, 0x1000, "A4000T builtin SCSI")) goto out; hostdata = kmalloc(sizeof(struct NCR_700_Host_Parameters), GFP_KERNEL); if (hostdata == NULL) { printk(KERN_ERR "a4000t-scsi: Failed to allocate host data\n"); goto out_release; } memset(hostdata, 0, sizeof(struct NCR_700_Host_Parameters)); /* Fill in the required pieces of hostdata */ hostdata->base = (void __iomem *)ZTWO_VADDR(A4000T_SCSI_ADDR); hostdata->clock = 50; hostdata->chip710 = 1; hostdata->dmode_extra = DMODE_FC2; hostdata->dcntl_extra = EA_710; /* and register the chip */ host = NCR_700_detect(&a4000t_scsi_driver_template, hostdata, dev); if (!host) { printk(KERN_ERR "a4000t-scsi: No host detected; " "board configuration problem?\n"); goto out_free; } host->this_id = 7; host->base = A4000T_SCSI_ADDR; host->irq = IRQ_AMIGA_PORTS; if (request_irq(host->irq, NCR_700_intr, IRQF_SHARED, "a4000t-scsi", host)) { printk(KERN_ERR "a4000t-scsi: request_irq failed\n"); goto out_put_host; } dev_set_drvdata(dev, host); scsi_scan_host(host); return 0; out_put_host: scsi_host_put(host); out_free: kfree(hostdata); out_release: release_mem_region(A4000T_SCSI_ADDR, 0x1000); out: return -ENODEV; }
void __init zorro_init(void) { struct zorro_dev *dev; u_int i; if (!MACH_IS_AMIGA || !AMIGAHW_PRESENT(ZORRO)) return; printk("Zorro: Probing AutoConfig expansion devices: %d device%s\n", zorro_num_autocon, zorro_num_autocon == 1 ? "" : "s"); /* Request the resources */ zorro_num_res = AMIGAHW_PRESENT(ZORRO3) ? 4 : 2; for (i = 0; i < zorro_num_res; i++) request_resource(&iomem_resource, &zorro_res[i]); for (i = 0; i < zorro_num_autocon; i++) { dev = &zorro_autocon[i]; dev->id = (dev->rom.er_Manufacturer<<16) | (dev->rom.er_Product<<8); if (dev->id == ZORRO_PROD_GVP_EPC_BASE) { /* GVP quirk */ unsigned long magic = dev->resource.start+0x8000; dev->id |= *(u16 *)ZTWO_VADDR(magic) & GVP_PRODMASK; } sprintf(dev->name, "Zorro device %08x", dev->id); zorro_name_device(dev); dev->resource.name = dev->name; if (request_resource(zorro_find_parent_resource(dev), &dev->resource)) printk(KERN_ERR "Zorro: Address space collision on device %s " "[%lx:%lx]\n", dev->name, dev->resource.start, dev->resource.end); } /* Mark all available Zorro II memory */ for (i = 0; i < zorro_num_autocon; i++) { dev = &zorro_autocon[i]; if (dev->rom.er_Type & ERTF_MEMLIST) mark_region(dev->resource.start, dev->resource.end+1, 1); } /* Unmark all used Zorro II memory */ for (i = 0; i < m68k_num_memory; i++) if (m68k_memory[i].addr < 16*1024*1024) mark_region(m68k_memory[i].addr, m68k_memory[i].addr+m68k_memory[i].size, 0); }
void __init amiga_chip_init(void) { if (!AMIGAHW_PRESENT(CHIP_RAM)) return; chipram_res.end = CHIP_PHYSADDR + amiga_chip_size - 1; request_resource(&iomem_resource, &chipram_res); atomic_set(&chipavail, amiga_chip_size); }
static int __init zorro_proc_init(void) { unsigned int slot; if (MACH_IS_AMIGA && AMIGAHW_PRESENT(ZORRO)) { proc_bus_zorro_dir = proc_mkdir("bus/zorro", NULL); proc_create_seq("devices", 0, proc_bus_zorro_dir, &zorro_devices_seq_ops); for (slot = 0; slot < zorro_num_autocon; slot++) zorro_proc_attach_device(slot); } return 0; }
struct zorro_dev *zorro_find_device(zorro_id id, struct zorro_dev *from) { struct zorro_dev *z; if (!MACH_IS_AMIGA || !AMIGAHW_PRESENT(ZORRO)) return NULL; for (z = from ? from+1 : &zorro_autocon[0]; z < zorro_autocon+zorro_num_autocon; z++) if (id == ZORRO_WILDCARD || id == z->id) return z; return NULL; }
void __init amiga_chip_init(void) { if (!AMIGAHW_PRESENT(CHIP_RAM)) return; /* * Remove the first 4 pages where PPC exception handlers will be located */ amiga_chip_size -= 0x4000; chipram_res.end = amiga_chip_size-1; request_resource(&iomem_resource, &chipram_res); chipavail = amiga_chip_size; }
__init void amiga_init_IRQ(void) { int i; /* initialize handlers */ for (i = 0; i < AMI_STD_IRQS; i++) { if (ami_servers[i]) { ami_irq_list[i] = NULL; } else { ami_irq_list[i] = new_irq_node(); ami_irq_list[i]->handler = ami_badint; ami_irq_list[i]->flags = 0; ami_irq_list[i]->dev_id = NULL; ami_irq_list[i]->devname = NULL; ami_irq_list[i]->next = NULL; } } for (i = 0; i < AMI_IRQS; i++) ami_ablecount[i] = 0; /* turn off PCMCIA interrupts */ if (AMIGAHW_PRESENT(PCMCIA)) pcmcia_disable_irq(); /* turn off all interrupts... */ custom.intena = 0x7fff; custom.intreq = 0x7fff; #ifdef CONFIG_APUS /* Clear any inter-CPU interrupt requests. Circumvents bug in Blizzard IPL emulation HW (or so it appears). */ APUS_WRITE(APUS_INT_LVL, INTLVL_SETRESET | INTLVL_MASK); /* Init IPL emulation. */ APUS_WRITE(APUS_REG_INT, REGINT_INTMASTER | REGINT_ENABLEIPL); APUS_WRITE(APUS_IPL_EMU, IPLEMU_DISABLEINT); APUS_WRITE(APUS_IPL_EMU, IPLEMU_SETRESET | IPLEMU_IPLMASK); #endif /* ... and enable the master interrupt bit */ custom.intena = IF_SETCLR | IF_INTEN; cia_init_IRQ(&ciaa_base); cia_init_IRQ(&ciab_base); }
int __init amiga7xx_detect(struct scsi_host_template *tpnt) { static unsigned char called = 0; int num = 0; if (called || !MACH_IS_AMIGA) return 0; tpnt->proc_name = "Amiga7xx"; if (AMIGAHW_PRESENT(A4000_SCSI)) num += amiga7xx_register_one(tpnt, 0xdd0040); #ifdef CONFIG_ZORRO num += amiga7xx_zorro_detect(tpnt); #endif called = 1; return num; }
int __init parport_amiga_init(void) { struct parport *p; int err; if (!MACH_IS_AMIGA || !AMIGAHW_PRESENT(AMI_PARALLEL)) return -ENODEV; err = -EBUSY; if (!request_mem_region(CIAA_PHYSADDR-1+0x100, 0x100, "parallel")) goto out_mem; ciaa.ddrb = 0xff; ciab.ddra &= 0xf8; mb(); p = parport_register_port((unsigned long)&ciaa.prb, IRQ_AMIGA_CIAA_FLG, PARPORT_DMA_NONE, &pp_amiga_ops); if (!p) goto out_port; err = request_irq(IRQ_AMIGA_CIAA_FLG, amiga_interrupt, 0, p->name, p); if (err) goto out_irq; this_port = p; printk(KERN_INFO "%s: Amiga built-in port using irq\n", p->name); /* XXX: set operating mode */ parport_proc_register(p); parport_announce_port(p); return 0; out_irq: parport_unregister_port(p); out_port: release_mem_region(CIAA_PHYSADDR-1+0x100, 0x100); out_mem: return err; }
void __init amiga_init_IRQ(void) { request_irq(IRQ_AUTO_1, ami_int1, 0, "int1", NULL); request_irq(IRQ_AUTO_3, ami_int3, 0, "int3", NULL); request_irq(IRQ_AUTO_4, ami_int4, 0, "int4", NULL); request_irq(IRQ_AUTO_5, ami_int5, 0, "int5", NULL); m68k_setup_irq_controller(&amiga_irq_controller, IRQ_USER, AMI_STD_IRQS); /* turn off PCMCIA interrupts */ if (AMIGAHW_PRESENT(PCMCIA)) gayle.inten = GAYLE_IRQ_IDE; /* turn off all interrupts and enable the master interrupt bit */ amiga_custom.intena = 0x7fff; amiga_custom.intreq = 0x7fff; amiga_custom.intena = IF_SETCLR | IF_INTEN; cia_init_IRQ(&ciaa_base); cia_init_IRQ(&ciab_base); }
void __init amiga_init_IRQ(void) { m68k_setup_irq_controller(&amiga_irq_chip, handle_simple_irq, IRQ_USER, AMI_STD_IRQS); irq_set_chained_handler(IRQ_AUTO_1, ami_int1); irq_set_chained_handler(IRQ_AUTO_3, ami_int3); irq_set_chained_handler(IRQ_AUTO_4, ami_int4); irq_set_chained_handler(IRQ_AUTO_5, ami_int5); /* turn off PCMCIA interrupts */ if (AMIGAHW_PRESENT(PCMCIA)) gayle.inten = GAYLE_IRQ_IDE; /* turn off all interrupts and enable the master interrupt bit */ amiga_custom.intena = 0x7fff; amiga_custom.intreq = 0x7fff; amiga_custom.intena = IF_SETCLR | IF_INTEN; cia_init_IRQ(&ciaa_base); cia_init_IRQ(&ciab_base); }
int zorro_find(int manuf, int prod, int part, int index) { int key; struct ConfigDev *cd; if (!MACH_IS_AMIGA || !AMIGAHW_PRESENT(ZORRO)) return(0); if ((part < 0) || (part > 31)) { printk("zorro_find: bad part %d\n", part); return(0); } for (key = index + 1; key <= boot_info.bi_amiga.num_autocon; key++) { cd = &boot_info.bi_amiga.autocon[key-1]; if ((cd->cd_Rom.er_Manufacturer == manuf) && (cd->cd_Rom.er_Product == prod) && !(BoardPartFlags[key-1] & (1<<part))) break; } return(key <= boot_info.bi_amiga.num_autocon ? key : 0); }
int __init a3000_detect(struct scsi_host_template *tpnt) { wd33c93_regs regs; if (!MACH_IS_AMIGA || !AMIGAHW_PRESENT(A3000_SCSI)) return 0; if (!request_mem_region(0xDD0000, 256, "wd33c93")) return 0; tpnt->proc_name = "A3000"; tpnt->proc_info = &wd33c93_proc_info; a3000_host = scsi_register (tpnt, sizeof(struct WD33C93_hostdata)); if (a3000_host == NULL) goto fail_register; a3000_host->base = ZTWO_VADDR(0xDD0000); a3000_host->irq = IRQ_AMIGA_PORTS; DMA(a3000_host)->DAWR = DAWR_A3000; regs.SASR = &(DMA(a3000_host)->SASR); regs.SCMD = &(DMA(a3000_host)->SCMD); HDATA(a3000_host)->no_sync = 0xff; HDATA(a3000_host)->fast = 0; HDATA(a3000_host)->dma_mode = CTRL_DMA; wd33c93_init(a3000_host, regs, dma_setup, dma_stop, WD33C93_FS_12_15); if (request_irq(IRQ_AMIGA_PORTS, a3000_intr, IRQF_SHARED, "A3000 SCSI", a3000_intr)) goto fail_irq; DMA(a3000_host)->CNTR = CNTR_PDMD | CNTR_INTEN; return 1; fail_irq: wd33c93_release(); scsi_unregister(a3000_host); fail_register: release_mem_region(0xDD0000, 256); return 0; }
static int __init amikbd_init(void) { int i; if (!AMIGAHW_PRESENT(AMI_KEYBOARD)) return -EIO; if (!request_mem_region(CIAA_PHYSADDR-1+0xb00, 0x100, "amikeyb")) return -EBUSY; amikbd_dev = input_allocate_device(); if (!amikbd_dev) { printk(KERN_ERR "amikbd: not enough memory for input device\n"); release_mem_region(CIAA_PHYSADDR - 1 + 0xb00, 0x100); return -ENOMEM; } amikbd_dev->name = "Amiga Keyboard"; amikbd_dev->phys = "amikbd/input0"; amikbd_dev->id.bustype = BUS_AMIGA; amikbd_dev->id.vendor = 0x0001; amikbd_dev->id.product = 0x0001; amikbd_dev->id.version = 0x0100; amikbd_dev->evbit[0] = BIT(EV_KEY) | BIT(EV_REP); amikbd_dev->keycode = amikbd_keycode; amikbd_dev->keycodesize = sizeof(unsigned char); amikbd_dev->keycodemax = ARRAY_SIZE(amikbd_keycode); for (i = 0; i < 0x78; i++) if (amikbd_keycode[i]) set_bit(amikbd_keycode[i], amikbd_dev->keybit); ciaa.cra &= ~0x41; /* serial data in, turn off TA */ request_irq(IRQ_AMIGA_CIAA_SP, amikbd_interrupt, 0, "amikbd", amikbd_interrupt); input_register_device(amikbd_dev); return 0; }
void __init amiga_chip_init (void) { struct chip_desc *dp; if (!AMIGAHW_PRESENT(CHIP_RAM)) return; #ifndef CONFIG_APUS_FAST_EXCEPT /* * Remove the first 4 pages where PPC exception handlers will * be located. */ amiga_chip_size -= 0x4000; #endif chipram.end = amiga_chip_size-1; request_resource(&iomem_resource, &chipram); /* initialize start boundary */ dp = DP(chipaddr); dp->first = 1; dp->alloced = 0; dp->length = amiga_chip_size - 2*sizeof(*dp); /* initialize end boundary */ dp = DP(chipaddr + amiga_chip_size) - 1; dp->last = 1; dp->alloced = 0; dp->length = amiga_chip_size - 2*sizeof(*dp); chipavail = dp->length; /*MILAN*/ #ifdef DEBUG printk ("chipram end boundary is %p, length is %d\n", dp, dp->length); #endif }
static int __init amikbd_init(void) { int i; if (!AMIGAHW_PRESENT(AMI_KEYBOARD)) return -EIO; if (!request_mem_region(CIAA_PHYSADDR-1+0xb00, 0x100, "amikeyb")) return -EBUSY; init_input_dev(&amikbd_dev); amikbd_dev.evbit[0] = BIT(EV_KEY) | BIT(EV_REP); amikbd_dev.keycode = amikbd_keycode; amikbd_dev.keycodesize = sizeof(unsigned char); amikbd_dev.keycodemax = ARRAY_SIZE(amikbd_keycode); for (i = 0; i < 0x78; i++) if (amikbd_keycode[i]) set_bit(amikbd_keycode[i], amikbd_dev.keybit); ciaa.cra &= ~0x41; /* serial data in, turn off TA */ request_irq(IRQ_AMIGA_CIAA_SP, amikbd_interrupt, 0, "amikbd", amikbd_interrupt); amikbd_dev.name = amikbd_name; amikbd_dev.phys = amikbd_phys; amikbd_dev.id.bustype = BUS_AMIGA; amikbd_dev.id.vendor = 0x0001; amikbd_dev.id.product = 0x0001; amikbd_dev.id.version = 0x0100; input_register_device(&amikbd_dev); printk(KERN_INFO "input: %s\n", amikbd_name); return 0; }
__initfunc(int parport_amiga_init(void)) { struct parport *p; if (MACH_IS_AMIGA && AMIGAHW_PRESENT(AMI_PARALLEL)) { ciaa.ddrb = 0xff; ciab.ddra &= 0xf8; if (!(p = parport_register_port((unsigned long)&ciaa.prb, IRQ_AMIGA_CIAA_FLG, PARPORT_DMA_NONE, &pp_amiga_ops))) return 0; this_port = p; printk(KERN_INFO "%s: Amiga built-in port using irq\n", p->name); /* XXX: set operating mode */ parport_proc_register(p); p->flags |= PARPORT_FLAG_COMA; if (parport_probe_hook) (*parport_probe_hook)(p); return 1; } return 0; }
static int __init amiga_init_devices(void) { struct platform_device *pdev; if (!MACH_IS_AMIGA) return -ENODEV; if (AMIGAHW_PRESENT(AMI_VIDEO)) platform_device_register_simple("amiga-video", -1, NULL, 0); if (AMIGAHW_PRESENT(AMI_AUDIO)) platform_device_register_simple("amiga-audio", -1, NULL, 0); if (AMIGAHW_PRESENT(AMI_FLOPPY)) platform_device_register_simple("amiga-floppy", -1, NULL, 0); if (AMIGAHW_PRESENT(A3000_SCSI)) platform_device_register_simple("amiga-a3000-scsi", -1, &a3000_scsi_resource, 1); if (AMIGAHW_PRESENT(A4000_SCSI)) platform_device_register_simple("amiga-a4000t-scsi", -1, &a4000t_scsi_resource, 1); if (AMIGAHW_PRESENT(A1200_IDE) || z_dev_present(ZORRO_PROD_MTEC_VIPER_MK_V_E_MATRIX_530_SCSI_IDE)) { pdev = platform_device_register_simple("amiga-gayle-ide", -1, &a1200_ide_resource, 1); platform_device_add_data(pdev, &a1200_ide_pdata, sizeof(a1200_ide_pdata)); } if (AMIGAHW_PRESENT(A4000_IDE)) { pdev = platform_device_register_simple("amiga-gayle-ide", -1, &a4000_ide_resource, 1); platform_device_add_data(pdev, &a4000_ide_pdata, sizeof(a4000_ide_pdata)); } if (AMIGAHW_PRESENT(AMI_KEYBOARD)) platform_device_register_simple("amiga-keyboard", -1, NULL, 0); if (AMIGAHW_PRESENT(AMI_MOUSE)) platform_device_register_simple("amiga-mouse", -1, NULL, 0); if (AMIGAHW_PRESENT(AMI_SERIAL)) platform_device_register_simple("amiga-serial", -1, NULL, 0); if (AMIGAHW_PRESENT(AMI_PARALLEL)) platform_device_register_simple("amiga-parallel", -1, NULL, 0); if (AMIGAHW_PRESENT(A2000_CLK)) platform_device_register_simple("rtc-msm6242", -1, &amiga_rtc_resource, 1); if (AMIGAHW_PRESENT(A3000_CLK)) platform_device_register_simple("rtc-rp5c01", -1, &amiga_rtc_resource, 1); return 0; }
static int __init amikbd_init(void) { int i, j, err; if (!AMIGAHW_PRESENT(AMI_KEYBOARD)) return -ENODEV; if (!request_mem_region(CIAA_PHYSADDR-1+0xb00, 0x100, "amikeyb")) return -EBUSY; amikbd_dev = input_allocate_device(); if (!amikbd_dev) { printk(KERN_ERR "amikbd: not enough memory for input device\n"); err = -ENOMEM; goto fail1; } amikbd_dev->name = "Amiga Keyboard"; amikbd_dev->phys = "amikbd/input0"; amikbd_dev->id.bustype = BUS_AMIGA; amikbd_dev->id.vendor = 0x0001; amikbd_dev->id.product = 0x0001; amikbd_dev->id.version = 0x0100; amikbd_dev->evbit[0] = BIT(EV_KEY) | BIT(EV_REP); for (i = 0; i < 0x78; i++) set_bit(i, amikbd_dev->keybit); for (i = 0; i < MAX_NR_KEYMAPS; i++) { static u_short temp_map[NR_KEYS] __initdata; if (!key_maps[i]) continue; memset(temp_map, 0, sizeof(temp_map)); for (j = 0; j < 0x78; j++) { if (!amikbd_keycode[j]) continue; temp_map[j] = key_maps[i][amikbd_keycode[j]]; } for (j = 0; j < NR_KEYS; j++) { if (!temp_map[j]) temp_map[j] = 0xf200; } memcpy(key_maps[i], temp_map, sizeof(temp_map)); } ciaa.cra &= ~0x41; /* serial data in, turn off TA */ if (request_irq(IRQ_AMIGA_CIAA_SP, amikbd_interrupt, 0, "amikbd", amikbd_interrupt)) { err = -EBUSY; goto fail2; } err = input_register_device(amikbd_dev); if (err) goto fail3; return 0; fail3: free_irq(IRQ_AMIGA_CIAA_SP, amikbd_interrupt); fail2: input_free_device(amikbd_dev); fail1: release_mem_region(CIAA_PHYSADDR - 1 + 0xb00, 0x100); return err; }
int __init amiga7xx_detect(Scsi_Host_Template *tpnt) { static unsigned char called = 0; int num = 0, clock; long long options; struct zorro_dev *z = NULL; unsigned long address; if (called || !MACH_IS_AMIGA) return 0; tpnt->proc_name = "Amiga7xx"; #ifdef CONFIG_A4000T_SCSI if (AMIGAHW_PRESENT(A4000_SCSI)) { address = 0xdd0040; if (request_mem_region(address, 0x1000, "ncr53c710")) { address = ZTWO_VADDR(address); options = OPTION_MEMORY_MAPPED | OPTION_DEBUG_TEST1 | OPTION_INTFLY | OPTION_SYNCHRONOUS | OPTION_ALWAYS_SYNCHRONOUS | OPTION_DISCONNECT; clock = 50000000; /* 50MHz SCSI Clock */ ncr53c7xx_init(tpnt, 0, 710, address, 0, IRQ_AMIGA_PORTS, DMA_NONE, options, clock); num++; } } #endif while ((z = zorro_find_device(ZORRO_WILDCARD, z))) { unsigned long address = z->resource.start; unsigned long size = z->resource.end-z->resource.start+1; switch (z->id) { #ifdef CONFIG_BLZ603EPLUS_SCSI case ZORRO_PROD_PHASE5_BLIZZARD_603E_PLUS: address = 0xf40000; if (request_mem_region(address, 0x1000, "ncr53c710")) { address = ZTWO_VADDR(address); options = OPTION_MEMORY_MAPPED | OPTION_DEBUG_TEST1 | OPTION_INTFLY | OPTION_SYNCHRONOUS | OPTION_ALWAYS_SYNCHRONOUS | OPTION_DISCONNECT; clock = 50000000; /* 50MHz SCSI Clock */ ncr53c7xx_init(tpnt, 0, 710, address, 0, IRQ_AMIGA_PORTS, DMA_NONE, options, clock); num++; } break; #endif #ifdef CONFIG_WARPENGINE_SCSI case ZORRO_PROD_MACROSYSTEMS_WARP_ENGINE_40xx: if (request_mem_region(address+0x40000, 0x1000, "ncr53c710")) { address = (unsigned long)z_ioremap(address, size); options = OPTION_MEMORY_MAPPED | OPTION_DEBUG_TEST1 | OPTION_INTFLY | OPTION_SYNCHRONOUS | OPTION_ALWAYS_SYNCHRONOUS | OPTION_DISCONNECT; clock = 50000000; /* 50MHz SCSI Clock */ ncr53c7xx_init(tpnt, 0, 710, address+0x40000, 0, IRQ_AMIGA_PORTS, DMA_NONE, options, clock); num++; } break; #endif #ifdef CONFIG_A4091_SCSI case ZORRO_PROD_CBM_A4091_1: case ZORRO_PROD_CBM_A4091_2: if (request_mem_region(address+0x800000, 0x1000, "ncr53c710")) { address = (unsigned long)z_ioremap(address, size); options = OPTION_MEMORY_MAPPED | OPTION_DEBUG_TEST1 | OPTION_INTFLY | OPTION_SYNCHRONOUS | OPTION_ALWAYS_SYNCHRONOUS | OPTION_DISCONNECT; clock = 50000000; /* 50MHz SCSI Clock */ ncr53c7xx_init(tpnt, 0, 710, address+0x800000, 0, IRQ_AMIGA_PORTS, DMA_NONE, options, clock); num++; } break; #endif #ifdef CONFIG_GVP_TURBO_SCSI case ZORRO_PROD_GVP_GFORCE_040_060: if (request_mem_region(address+0x40000, 0x1000, "ncr53c710")) { address = ZTWO_VADDR(address); options = OPTION_MEMORY_MAPPED | OPTION_DEBUG_TEST1 | OPTION_INTFLY | OPTION_SYNCHRONOUS | OPTION_ALWAYS_SYNCHRONOUS | OPTION_DISCONNECT; clock = 50000000; /* 50MHz SCSI Clock */ ncr53c7xx_init(tpnt, 0, 710, address+0x40000, 0, IRQ_AMIGA_PORTS, DMA_NONE, options, clock); num++; } #endif } } called = 1; return num; }
static int __init gayle_init(void) { int a4000, i; u8 idx[4] = { 0xff, 0xff, 0xff, 0xff }; if (!MACH_IS_AMIGA) return -ENODEV; if ((a4000 = AMIGAHW_PRESENT(A4000_IDE)) || AMIGAHW_PRESENT(A1200_IDE)) goto found; #ifdef CONFIG_ZORRO if (zorro_find_device(ZORRO_PROD_MTEC_VIPER_MK_V_E_MATRIX_530_SCSI_IDE, NULL)) goto found; #endif return -ENODEV; found: printk(KERN_INFO "ide: Gayle IDE controller (A%d style%s)\n", a4000 ? 4000 : 1200, #ifdef CONFIG_BLK_DEV_IDEDOUBLER ide_doubler ? ", IDE doubler" : #endif ""); for (i = 0; i < GAYLE_NUM_PROBE_HWIFS; i++) { unsigned long base, ctrlport, irqport; ide_ack_intr_t *ack_intr; hw_regs_t hw; ide_hwif_t *hwif; unsigned long phys_base, res_start, res_n; if (a4000) { phys_base = GAYLE_BASE_4000; irqport = (unsigned long)ZTWO_VADDR(GAYLE_IRQ_4000); ack_intr = gayle_ack_intr_a4000; } else { phys_base = GAYLE_BASE_1200; irqport = (unsigned long)ZTWO_VADDR(GAYLE_IRQ_1200); ack_intr = gayle_ack_intr_a1200; } /* * FIXME: we now have selectable modes between mmio v/s iomio */ phys_base += i*GAYLE_NEXT_PORT; res_start = ((unsigned long)phys_base) & ~(GAYLE_NEXT_PORT-1); res_n = GAYLE_IDEREG_SIZE; if (!request_mem_region(res_start, res_n, "IDE")) continue; base = (unsigned long)ZTWO_VADDR(phys_base); ctrlport = GAYLE_HAS_CONTROL_REG ? (base + GAYLE_CONTROL) : 0; gayle_setup_ports(&hw, base, ctrlport, irqport, ack_intr); hwif = ide_find_port(); if (hwif) { u8 index = hwif->index; ide_init_port_hw(hwif, &hw); idx[i] = index; } else release_mem_region(res_start, res_n); } ide_device_add(idx, NULL); return 0; }