自学教程：C++ AMIGAHW_PRESENT函数代码示例

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;}

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);}

__initvoid 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 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;}

__initvoid 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;}