/* Thread to carry out delayed SCSI-device scanning */ static int rtsx_scan_thread(void *__dev) { struct rtsx_dev *dev = __dev; struct rtsx_chip *chip = dev->chip; /* Wait for the timeout to expire or for a disconnect */ if (delay_use > 0) { dev_info(&dev->pci->dev, "%s: waiting for device to settle before scanning\n", CR_DRIVER_NAME); wait_event_interruptible_timeout(dev->delay_wait, rtsx_chk_stat(chip, RTSX_STAT_DISCONNECT), delay_use * HZ); } /* If the device is still connected, perform the scanning */ if (!rtsx_chk_stat(chip, RTSX_STAT_DISCONNECT)) { scsi_scan_host(rtsx_to_host(dev)); dev_info(&dev->pci->dev, "%s: device scan complete\n", CR_DRIVER_NAME); /* Should we unbind if no devices were detected? */ } complete_and_exit(&dev->scanning_done, 0); }
static int rtsx_scan_thread(void * __dev) { struct rtsx_dev *dev = (struct rtsx_dev *)__dev; struct rtsx_chip *chip = dev->chip; if (delay_use > 0) { printk(KERN_INFO "%s: waiting for device " "to settle before scanning\n", CR_DRIVER_NAME); wait_event_interruptible_timeout(dev->delay_wait, rtsx_chk_stat(chip, RTSX_STAT_DISCONNECT), delay_use * HZ); } if (!rtsx_chk_stat(chip, RTSX_STAT_DISCONNECT)) { scsi_scan_host(rtsx_to_host(dev)); printk(KERN_INFO "%s: device scan complete\n", CR_DRIVER_NAME); } scsi_host_put(rtsx_to_host(dev)); complete_and_exit(&threads_gone, 0); }
static int rts51x_scan_thread(void *__chip) { struct rts51x_chip *chip = (struct rts51x_chip *)__chip; printk(KERN_DEBUG "rts51x: device found at %d\n", chip->usb->pusb_dev->devnum); set_freezable(); if (delay_use > 0) { printk(KERN_DEBUG "rts51x: waiting for device " "to settle before scanning\n"); wait_event_freezable_timeout(chip->usb->delay_wait, test_bit(FLIDX_DONT_SCAN, &chip->usb->dflags), delay_use * HZ); } if (!test_bit(FLIDX_DONT_SCAN, &chip->usb->dflags)) { scsi_scan_host(rts51x_to_host(chip)); printk(KERN_DEBUG "rts51x: device scan complete\n"); } complete_and_exit(&chip->usb->scanning_done, 0); }
static int __devinit a2091_probe(struct zorro_dev *z, const struct zorro_device_id *ent) { struct Scsi_Host *instance; int error; struct a2091_scsiregs *regs; wd33c93_regs wdregs; struct a2091_hostdata *hdata; if (!request_mem_region(z->resource.start, 256, "wd33c93")) return -EBUSY; instance = scsi_host_alloc(&a2091_scsi_template, sizeof(struct a2091_hostdata)); if (!instance) { error = -ENOMEM; goto fail_alloc; } instance->irq = IRQ_AMIGA_PORTS; instance->unique_id = z->slotaddr; regs = (struct a2091_scsiregs *)ZTWO_VADDR(z->resource.start); regs->DAWR = DAWR_A2091; wdregs.SASR = ®s->SASR; wdregs.SCMD = ®s->SCMD; hdata = shost_priv(instance); hdata->wh.no_sync = 0xff; hdata->wh.fast = 0; hdata->wh.dma_mode = CTRL_DMA; hdata->regs = regs; wd33c93_init(instance, wdregs, dma_setup, dma_stop, WD33C93_FS_8_10); error = request_irq(IRQ_AMIGA_PORTS, a2091_intr, IRQF_SHARED, "A2091 SCSI", instance); if (error) goto fail_irq; regs->CNTR = CNTR_PDMD | CNTR_INTEN; error = scsi_add_host(instance, NULL); if (error) goto fail_host; zorro_set_drvdata(z, instance); scsi_scan_host(instance); return 0; fail_host: free_irq(IRQ_AMIGA_PORTS, instance); fail_irq: scsi_host_put(instance); fail_alloc: release_mem_region(z->resource.start, 256); return error; }
static int __init mvme147_init(void) { wd33c93_regs regs; struct WD33C93_hostdata *hdata; int error = -ENOMEM; if (!MACH_IS_MVME147) return 0; mvme147_shost = scsi_host_alloc(&mvme147_host_template, sizeof(struct WD33C93_hostdata)); if (!mvme147_shost) goto err_out; mvme147_shost->base = 0xfffe4000; mvme147_shost->irq = MVME147_IRQ_SCSI_PORT; regs.SASR = (volatile unsigned char *)0xfffe4000; regs.SCMD = (volatile unsigned char *)0xfffe4001; hdata = shost_priv(mvme147_shost); hdata->no_sync = 0xff; hdata->fast = 0; hdata->dma_mode = CTRL_DMA; wd33c93_init(mvme147_shost, regs, dma_setup, dma_stop, WD33C93_FS_8_10); error = request_irq(MVME147_IRQ_SCSI_PORT, mvme147_intr, 0, "MVME147 SCSI PORT", mvme147_shost); if (error) goto err_unregister; error = request_irq(MVME147_IRQ_SCSI_DMA, mvme147_intr, 0, "MVME147 SCSI DMA", mvme147_shost); if (error) goto err_free_irq; #if 0 /* Disabled; causes problems booting */ m147_pcc->scsi_interrupt = 0x10; /* Assert SCSI bus reset */ udelay(100); m147_pcc->scsi_interrupt = 0x00; /* Negate SCSI bus reset */ udelay(2000); m147_pcc->scsi_interrupt = 0x40; /* Clear bus reset interrupt */ #endif m147_pcc->scsi_interrupt = 0x09; /* Enable interrupt */ m147_pcc->dma_cntrl = 0x00; /* ensure DMA is stopped */ m147_pcc->dma_intr = 0x89; /* Ack and enable ints */ error = scsi_add_host(mvme147_shost, NULL); if (error) goto err_free_irq; scsi_scan_host(mvme147_shost); return 0; err_free_irq: free_irq(MVME147_IRQ_SCSI_PORT, mvme147_shost); err_unregister: scsi_host_put(mvme147_shost); err_out: return error; }
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; }
static __devinit int sim710_probe_common(struct device *dev, unsigned long base_addr, int irq, int clock, int differential, int scsi_id) { struct Scsi_Host * host = NULL; struct NCR_700_Host_Parameters *hostdata = kzalloc(sizeof(struct NCR_700_Host_Parameters), GFP_KERNEL); ; // printk(KERN_NOTICE "sim710: irq = %d, clock = %d, base = 0x%lx, scsi_id = %d\n", ; if(hostdata == NULL) { ; goto out; } if(request_region(base_addr, 64, "sim710") == NULL) { // printk(KERN_ERR "sim710: Failed to reserve IO region 0x%lx\n", ; goto out_free; } /* Fill in the three required pieces of hostdata */ hostdata->base = ioport_map(base_addr, 64); hostdata->differential = differential; hostdata->clock = clock; hostdata->chip710 = 1; hostdata->burst_length = 8; /* and register the chip */ if((host = NCR_700_detect(&sim710_driver_template, hostdata, dev)) == NULL) { ; goto out_release; } host->this_id = scsi_id; host->base = base_addr; host->irq = irq; if (request_irq(irq, NCR_700_intr, IRQF_SHARED, "sim710", host)) { ; goto out_put_host; } dev_set_drvdata(dev, host); scsi_scan_host(host); return 0; out_put_host: scsi_host_put(host); out_release: release_region(base_addr, 64); out_free: kfree(hostdata); out: return -ENODEV; }
static int dmx3191d_probe_one(struct pci_dev *pdev, const struct pci_device_id *id) { struct Scsi_Host *shost; struct NCR5380_hostdata *hostdata; unsigned long io; int error = -ENODEV; if (pci_enable_device(pdev)) goto out; io = pci_resource_start(pdev, 0); if (!request_region(io, DMX3191D_REGION_LEN, DMX3191D_DRIVER_NAME)) { printk(KERN_ERR "dmx3191: region 0x%lx-0x%lx already reserved\n", io, io + DMX3191D_REGION_LEN); goto out_disable_device; } shost = scsi_host_alloc(&dmx3191d_driver_template, sizeof(struct NCR5380_hostdata)); if (!shost) goto out_release_region; hostdata = shost_priv(shost); hostdata->base = io; /* This card does not seem to raise an interrupt on pdev->irq. * Steam-powered SCSI controllers run without an IRQ anyway. */ shost->irq = NO_IRQ; error = NCR5380_init(shost, 0); if (error) goto out_host_put; NCR5380_maybe_reset_bus(shost); pci_set_drvdata(pdev, shost); error = scsi_add_host(shost, &pdev->dev); if (error) goto out_exit; scsi_scan_host(shost); return 0; out_exit: NCR5380_exit(shost); out_host_put: scsi_host_put(shost); out_release_region: release_region(io, DMX3191D_REGION_LEN); out_disable_device: pci_disable_device(pdev); out: return error; }
static int __devinit cumanascsi1_probe(struct expansion_card *ec, const struct ecard_id *id) { struct Scsi_Host *host; int ret = -ENOMEM; host = scsi_host_alloc(&cumanascsi_template, sizeof(struct NCR5380_hostdata)); if (!host) goto out; host->io_port = ecard_address(ec, ECARD_IOC, ECARD_SLOW) + 0x800; host->irq = ec->irq; NCR5380_init(host, 0); host->n_io_port = 255; if (!(request_region(host->io_port, host->n_io_port, "CumanaSCSI-1"))) { ret = -EBUSY; goto out_free; } ((struct NCR5380_hostdata *)host->hostdata)->ctrl = 0; outb(0x00, host->io_port - 577); ret = request_irq(host->irq, cumanascsi_intr, SA_INTERRUPT, "CumanaSCSI-1", host); if (ret) { printk("scsi%d: IRQ%d not free: %d\n", host->host_no, host->irq, ret); goto out_release; } printk("scsi%d: at port 0x%08lx irq %d", host->host_no, host->io_port, host->irq); printk(" options CAN_QUEUE=%d CMD_PER_LUN=%d release=%d", host->can_queue, host->cmd_per_lun, CUMANASCSI_PUBLIC_RELEASE); printk("\nscsi%d:", host->host_no); NCR5380_print_options(host); printk("\n"); ret = scsi_add_host(host, &ec->dev); if (ret) goto out_free_irq; scsi_scan_host(host); goto out; out_free_irq: free_irq(host->irq, host); out_release: release_region(host->io_port, host->n_io_port); out_free: scsi_host_put(host); out: return ret; }
static int __init lasi700_probe(struct parisc_device *dev) { unsigned long base = dev->hpa + LASI_SCSI_CORE_OFFSET; struct NCR_700_Host_Parameters *hostdata; struct Scsi_Host *host; hostdata = kmalloc(sizeof(*hostdata), GFP_KERNEL); if (!hostdata) { printk(KERN_ERR "%s: Failed to allocate host data\n", dev->dev.bus_id); return -ENOMEM; } memset(hostdata, 0, sizeof(struct NCR_700_Host_Parameters)); hostdata->dev = &dev->dev; dma_set_mask(&dev->dev, DMA_32BIT_MASK); hostdata->base = ioremap(base, 0x100); hostdata->differential = 0; if (dev->id.sversion == LASI_700_SVERSION) { hostdata->clock = LASI700_CLOCK; hostdata->force_le_on_be = 1; } else { hostdata->clock = LASI710_CLOCK; hostdata->force_le_on_be = 0; hostdata->chip710 = 1; hostdata->dmode_extra = DMODE_FC2; } NCR_700_set_mem_mapped(hostdata); host = NCR_700_detect(&lasi700_template, hostdata, &dev->dev); if (!host) goto out_kfree; host->this_id = 7; host->base = base; host->irq = dev->irq; if(request_irq(dev->irq, NCR_700_intr, SA_SHIRQ, "lasi700", host)) { printk(KERN_ERR "lasi700: request_irq failed!\n"); goto out_put_host; } dev_set_drvdata(&dev->dev, host); scsi_scan_host(host); return 0; out_put_host: scsi_host_put(host); out_kfree: iounmap(hostdata->base); kfree(hostdata); return -ENODEV; }
static struct Scsi_Host *qlogic_detect(struct scsi_host_template *host, struct pcmcia_device *link, int qbase, int qlirq) { int qltyp; /* type of chip */ int qinitid; struct Scsi_Host *shost; /* registered host structure */ struct qlogicfas408_priv *priv; qltyp = qlogicfas408_get_chip_type(qbase, INT_TYPE); qinitid = host->this_id; if (qinitid < 0) qinitid = 7; /* if no ID, use 7 */ qlogicfas408_setup(qbase, qinitid, INT_TYPE); host->name = qlogic_name; shost = scsi_host_alloc(host, sizeof(struct qlogicfas408_priv)); if (!shost) goto err; shost->io_port = qbase; shost->n_io_port = 16; shost->dma_channel = -1; if (qlirq != -1) shost->irq = qlirq; priv = get_priv_by_host(shost); priv->qlirq = qlirq; priv->qbase = qbase; priv->qinitid = qinitid; priv->shost = shost; priv->int_type = INT_TYPE; if (request_irq(qlirq, qlogicfas408_ihandl, 0, qlogic_name, shost)) goto free_scsi_host; sprintf(priv->qinfo, "Qlogicfas Driver version 0.46, chip %02X at %03X, IRQ %d, TPdma:%d", qltyp, qbase, qlirq, QL_TURBO_PDMA); if (scsi_add_host(shost, NULL)) goto free_interrupt; scsi_scan_host(shost); return shost; free_interrupt: free_irq(qlirq, shost); free_scsi_host: scsi_host_put(shost); err: return NULL; }
static int __devinit dmx3191d_probe_one(struct pci_dev *pdev, const struct pci_device_id *id) { struct Scsi_Host *shost; unsigned long io; int error = -ENODEV; if (pci_enable_device(pdev)) goto out; io = pci_resource_start(pdev, 0); if (!request_region(io, DMX3191D_REGION_LEN, DMX3191D_DRIVER_NAME)) { printk(KERN_ERR "dmx3191: region 0x%lx-0x%lx already reserved\n", io, io + DMX3191D_REGION_LEN); goto out_disable_device; } shost = scsi_host_alloc(&dmx3191d_driver_template, sizeof(struct NCR5380_hostdata)); if (!shost) goto out_release_region; shost->io_port = io; shost->irq = pdev->irq; NCR5380_init(shost, FLAG_NO_PSEUDO_DMA | FLAG_DTC3181E); if (request_irq(pdev->irq, NCR5380_intr, IRQF_SHARED, DMX3191D_DRIVER_NAME, shost)) { /* * Steam powered scsi controllers run without an IRQ anyway */ printk(KERN_WARNING "dmx3191: IRQ %d not available - " "switching to polled mode.\n", pdev->irq); shost->irq = SCSI_IRQ_NONE; } pci_set_drvdata(pdev, shost); error = scsi_add_host(shost, &pdev->dev); if (error) goto out_free_irq; scsi_scan_host(shost); return 0; out_free_irq: free_irq(shost->irq, shost); out_release_region: release_region(io, DMX3191D_REGION_LEN); out_disable_device: pci_disable_device(pdev); out: return error; }
static __devinit int bvme6000_probe(struct platform_device *dev) { struct Scsi_Host *host; struct NCR_700_Host_Parameters *hostdata; if (!MACH_IS_BVME6000) goto out; hostdata = kzalloc(sizeof(struct NCR_700_Host_Parameters), GFP_KERNEL); if (!hostdata) { printk(KERN_ERR "bvme6000-scsi: " "Failed to allocate host data\n"); goto out; } hostdata->base = (void __iomem *)BVME_NCR53C710_BASE; hostdata->clock = 40; hostdata->chip710 = 1; hostdata->dmode_extra = DMODE_FC2; hostdata->dcntl_extra = EA_710; hostdata->ctest7_extra = CTEST7_TT1; host = NCR_700_detect(&bvme6000_scsi_driver_template, hostdata, &dev->dev); if (!host) { printk(KERN_ERR "bvme6000-scsi: No host detected; " "board configuration problem?\n"); goto out_free; } host->base = BVME_NCR53C710_BASE; host->this_id = 7; host->irq = BVME_IRQ_SCSI; if (request_irq(BVME_IRQ_SCSI, NCR_700_intr, 0, "bvme6000-scsi", host)) { printk(KERN_ERR "bvme6000-scsi: request_irq failed\n"); goto out_put_host; } platform_set_drvdata(dev, host); scsi_scan_host(host); return 0; out_put_host: scsi_host_put(host); out_free: kfree(hostdata); out: return -ENODEV; }
static int __devinit oakscsi_probe(struct expansion_card *ec, const struct ecard_id *id) { struct Scsi_Host *host; int ret = -ENOMEM; ret = ecard_request_resources(ec); if (ret) goto out; host = scsi_host_alloc(&oakscsi_template, sizeof(struct NCR5380_hostdata)); if (!host) { ret = -ENOMEM; goto release; } priv(host)->base = ioremap(ecard_resource_start(ec, ECARD_RES_MEMC), ecard_resource_len(ec, ECARD_RES_MEMC)); if (!priv(host)->base) { ret = -ENOMEM; goto unreg; } host->irq = IRQ_NONE; host->n_io_port = 255; NCR5380_init(host, 0); printk("scsi%d: at port 0x%08lx irqs disabled", host->host_no, host->io_port); printk(" options CAN_QUEUE=%d CMD_PER_LUN=%d release=%d", host->can_queue, host->cmd_per_lun, OAKSCSI_PUBLIC_RELEASE); printk("\nscsi%d:", host->host_no); NCR5380_print_options(host); printk("\n"); ret = scsi_add_host(host, &ec->dev); if (ret) goto out_unmap; scsi_scan_host(host); goto out; out_unmap: iounmap(priv(host)->base); unreg: scsi_host_put(host); release: ecard_release_resources(ec); out: return ret; }
static int __init snirm710_probe(struct platform_device *dev) { unsigned long base; struct NCR_700_Host_Parameters *hostdata; struct Scsi_Host *host; struct resource *res; res = platform_get_resource(dev, IORESOURCE_MEM, 0); if (!res) return -ENODEV; base = res->start; hostdata = kzalloc(sizeof(*hostdata), GFP_KERNEL); if (!hostdata) { printk(KERN_ERR "%s: Failed to allocate host data\n", dev->dev.bus_id); return -ENOMEM; } hostdata->dev = &dev->dev; dma_set_mask(&dev->dev, DMA_32BIT_MASK); hostdata->base = ioremap_nocache(CPHYSADDR(base), 0x100); hostdata->differential = 0; hostdata->clock = SNIRM710_CLOCK; hostdata->force_le_on_be = 1; hostdata->chip710 = 1; hostdata->burst_length = 4; host = NCR_700_detect(&snirm710_template, hostdata, &dev->dev); if (!host) goto out_kfree; host->this_id = 7; host->base = base; host->irq = platform_get_irq(dev, 0); if(request_irq(host->irq, NCR_700_intr, SA_SHIRQ, "snirm710", host)) { printk(KERN_ERR "snirm710: request_irq failed!\n"); goto out_put_host; } dev_set_drvdata(&dev->dev, host); scsi_scan_host(host); return 0; out_put_host: scsi_host_put(host); out_kfree: iounmap(hostdata->base); kfree(hostdata); return -ENODEV; }
static int __devinit NCR_D700_probe_one(struct NCR_D700_private *p, int siop, int irq, int slot, u32 region, int differential) { struct NCR_700_Host_Parameters *hostdata; struct Scsi_Host *host; int ret; hostdata = kzalloc(sizeof(*hostdata), GFP_KERNEL); if (!hostdata) { // printk(KERN_ERR "NCR D700: SIOP%d: Failed to allocate host" ; return -ENOMEM; } if (!request_region(region, 64, "NCR_D700")) { // printk(KERN_ERR "NCR D700: Failed to reserve IO region 0x%x\n", ; ret = -ENODEV; goto region_failed; } /* Fill in the three required pieces of hostdata */ hostdata->base = ioport_map(region, 64); hostdata->differential = (((1<<siop) & differential) != 0); hostdata->clock = NCR_D700_CLOCK_MHZ; hostdata->burst_length = 8; /* and register the siop */ host = NCR_700_detect(&NCR_D700_driver_template, hostdata, p->dev); if (!host) { ret = -ENOMEM; goto detect_failed; } p->hosts[siop] = host; /* FIXME: read this from SUS */ host->this_id = id_array[slot * 2 + siop]; host->irq = irq; host->base = region; scsi_scan_host(host); return 0; detect_failed: release_region(region, 64); region_failed: kfree(hostdata); return ret; }
static int oakscsi_probe(struct expansion_card *ec, const struct ecard_id *id) { struct Scsi_Host *host; int ret = -ENOMEM; ret = ecard_request_resources(ec); if (ret) goto out; host = scsi_host_alloc(&oakscsi_template, sizeof(struct NCR5380_hostdata)); if (!host) { ret = -ENOMEM; goto release; } priv(host)->base = ioremap(ecard_resource_start(ec, ECARD_RES_MEMC), ecard_resource_len(ec, ECARD_RES_MEMC)); if (!priv(host)->base) { ret = -ENOMEM; goto unreg; } host->irq = NO_IRQ; host->n_io_port = 255; ret = NCR5380_init(host, 0); if (ret) goto out_unmap; NCR5380_maybe_reset_bus(host); ret = scsi_add_host(host, &ec->dev); if (ret) goto out_exit; scsi_scan_host(host); goto out; out_exit: NCR5380_exit(host); out_unmap: iounmap(priv(host)->base); unreg: scsi_host_put(host); release: ecard_release_resources(ec); out: return ret; }
static int __init lasi700_probe(struct parisc_device *dev) { unsigned long base = dev->hpa + LASI_SCSI_CORE_OFFSET; struct NCR_700_Host_Parameters *hostdata; struct Scsi_Host *host; hostdata = kmalloc(sizeof(*hostdata), GFP_KERNEL); if (!hostdata) { printk(KERN_ERR "%s: Failed to allocate host data\n", dev->dev.bus_id); return -ENOMEM; } memset(hostdata, 0, sizeof(struct NCR_700_Host_Parameters)); hostdata->dev = &dev->dev; dma_set_mask(&dev->dev, 0xffffffffUL); hostdata->base = base; hostdata->differential = 0; if (dev->id.sversion == LASI_700_SVERSION) { hostdata->clock = LASI700_CLOCK; hostdata->force_le_on_be = 1; } else { hostdata->clock = LASI710_CLOCK; hostdata->force_le_on_be = 0; hostdata->chip710 = 1; hostdata->dmode_extra = DMODE_FC2; } NCR_700_set_mem_mapped(hostdata); host = NCR_700_detect(&lasi700_template, hostdata, &dev->dev, dev->irq, 7); if (!host) goto out_kfree; dev_set_drvdata(&dev->dev, host); scsi_scan_host(host); return 0; out_kfree: kfree(hostdata); return -ENODEV; }
static int fdomain_config(struct pcmcia_device *link) { scsi_info_t *info = link->priv; int ret; char str[22]; struct Scsi_Host *host; dev_dbg(&link->dev, "fdomain_config\n"); ret = pcmcia_loop_config(link, fdomain_config_check, NULL); if (ret) goto failed; if (!link->irq) goto failed; ret = pcmcia_enable_device(link); if (ret) goto failed; /* A bad hack... */ release_region(link->resource[0]->start, resource_size(link->resource[0])); /* Set configuration options for the fdomain driver */ sprintf(str, "%d,%d", (unsigned int) link->resource[0]->start, link->irq); fdomain_setup(str); host = __fdomain_16x0_detect(&fdomain_driver_template); if (!host) { printk(KERN_INFO "fdomain_cs: no SCSI devices found\n"); goto failed; } if (scsi_add_host(host, NULL)) goto failed; scsi_scan_host(host); info->host = host; return 0; failed: fdomain_release(link); return -ENODEV; } /* fdomain_config */
/** * megaraid_io_attach - attach a device with the IO subsystem * @adapter : controller's soft state * * Attach this device with the IO subsystem. */ static int megaraid_io_attach(adapter_t *adapter) { struct Scsi_Host *host; // Initialize SCSI Host structure host = scsi_host_alloc(&megaraid_template_g, 8); if (!host) { con_log(CL_ANN, (KERN_WARNING "megaraid mbox: scsi_register failed\n")); return -1; } SCSIHOST2ADAP(host) = (caddr_t)adapter; adapter->host = host; host->irq = adapter->irq; host->unique_id = adapter->unique_id; host->can_queue = adapter->max_cmds; host->this_id = adapter->init_id; host->sg_tablesize = adapter->sglen; host->max_sectors = adapter->max_sectors; host->cmd_per_lun = adapter->cmd_per_lun; host->max_channel = adapter->max_channel; host->max_id = adapter->max_target; host->max_lun = adapter->max_lun; // notify mid-layer about the new controller if (scsi_add_host(host, &adapter->pdev->dev)) { con_log(CL_ANN, (KERN_WARNING "megaraid mbox: scsi_add_host failed\n")); scsi_host_put(host); return -1; } scsi_scan_host(host); return 0; }
static int __devinit oakscsi_probe(struct expansion_card *ec, const struct ecard_id *id) { struct Scsi_Host *host; int ret = -ENOMEM; host = scsi_host_alloc(&oakscsi_template, sizeof(struct NCR5380_hostdata)); if (!host) goto out; host->io_port = ecard_address(ec, ECARD_MEMC, 0); host->irq = IRQ_NONE; host->n_io_port = 255; ret = -EBUSY; if (!request_region (host->io_port, host->n_io_port, "Oak SCSI")) goto unreg; NCR5380_init(host, 0); printk("scsi%d: at port 0x%08lx irqs disabled", host->host_no, host->io_port); printk(" options CAN_QUEUE=%d CMD_PER_LUN=%d release=%d", host->can_queue, host->cmd_per_lun, OAKSCSI_PUBLIC_RELEASE); printk("\nscsi%d:", host->host_no); NCR5380_print_options(host); printk("\n"); ret = scsi_add_host(host, &ec->dev); if (ret) goto out_release; scsi_scan_host(host); goto out; out_release: release_region(host->io_port, host->n_io_port); unreg: scsi_host_put(host); out: return ret; }
/* Delayed-work routine to carry out SCSI-device scanning */ static void usb_stor_scan_dwork(struct work_struct *work) { struct us_data *us = container_of(work, struct us_data, scan_dwork.work); struct device *dev = &us->pusb_intf->dev; //--------------------------- pr_info("19 usb stor scan dwork\n"); dev_dbg(dev, "starting scan\n"); /* For bulk-only devices, determine the max LUN value */ if (us->protocol == USB_PR_BULK && !(us->fflags & US_FL_SINGLE_LUN)) { mutex_lock(&us->dev_mutex); us->max_lun = usb_stor_Bulk_max_lun(us); mutex_unlock(&us->dev_mutex); } scsi_scan_host(us_to_host(us)); dev_dbg(dev, "scan complete\n"); /* Should we unbind if no devices were detected? */ usb_autopm_put_interface(us->pusb_intf); clear_bit(US_FLIDX_SCAN_PENDING, &us->dflags); }
static void fdomain_config(dev_link_t *link) { client_handle_t handle = link->handle; scsi_info_t *info = link->priv; tuple_t tuple; cisparse_t parse; int i, last_ret, last_fn; u_char tuple_data[64]; char str[16]; struct Scsi_Host *host; DEBUG(0, "fdomain_config(0x%p)\n", link); tuple.DesiredTuple = CISTPL_CONFIG; tuple.TupleData = tuple_data; tuple.TupleDataMax = 64; tuple.TupleOffset = 0; CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(handle, &tuple)); CS_CHECK(GetTupleData, pcmcia_get_tuple_data(handle, &tuple)); CS_CHECK(ParseTuple, pcmcia_parse_tuple(handle, &tuple, &parse)); link->conf.ConfigBase = parse.config.base; /* Configure card */ link->state |= DEV_CONFIG; tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY; CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(handle, &tuple)); while (1) { if (pcmcia_get_tuple_data(handle, &tuple) != 0 || pcmcia_parse_tuple(handle, &tuple, &parse) != 0) goto next_entry; link->conf.ConfigIndex = parse.cftable_entry.index; link->io.BasePort1 = parse.cftable_entry.io.win[0].base; i = pcmcia_request_io(handle, &link->io); if (i == CS_SUCCESS) break; next_entry: CS_CHECK(GetNextTuple, pcmcia_get_next_tuple(handle, &tuple)); } CS_CHECK(RequestIRQ, pcmcia_request_irq(handle, &link->irq)); CS_CHECK(RequestConfiguration, pcmcia_request_configuration(handle, &link->conf)); /* A bad hack... */ release_region(link->io.BasePort1, link->io.NumPorts1); /* Set configuration options for the fdomain driver */ sprintf(str, "%d,%d", link->io.BasePort1, link->irq.AssignedIRQ); fdomain_setup(str); host = __fdomain_16x0_detect(&fdomain_driver_template); if (!host) { printk(KERN_INFO "fdomain_cs: no SCSI devices found\n"); goto cs_failed; } scsi_add_host(host, NULL); /* XXX handle failure */ scsi_scan_host(host); sprintf(info->node.dev_name, "scsi%d", host->host_no); link->dev = &info->node; info->host = host; link->state &= ~DEV_CONFIG_PENDING; return; cs_failed: cs_error(link->handle, last_fn, last_ret); fdomain_release(link); return; } /* fdomain_config */
static int esas2r_probe(struct pci_dev *pcid, const struct pci_device_id *id) { struct Scsi_Host *host = NULL; struct esas2r_adapter *a; int err; size_t host_alloc_size = sizeof(struct esas2r_adapter) + ((num_requests) + 1) * sizeof(struct esas2r_request); esas2r_log_dev(ESAS2R_LOG_DEBG, &(pcid->dev), "esas2r_probe() 0x%02x 0x%02x 0x%02x 0x%02x", pcid->vendor, pcid->device, pcid->subsystem_vendor, pcid->subsystem_device); esas2r_log_dev(ESAS2R_LOG_INFO, &(pcid->dev), "before pci_enable_device() " "enable_cnt: %d", pcid->enable_cnt.counter); err = pci_enable_device(pcid); if (err != 0) { esas2r_log_dev(ESAS2R_LOG_CRIT, &(pcid->dev), "pci_enable_device() FAIL (%d)", err); return -ENODEV; } esas2r_log_dev(ESAS2R_LOG_INFO, &(pcid->dev), "pci_enable_device() OK"); esas2r_log_dev(ESAS2R_LOG_INFO, &(pcid->dev), "after pci_enable_device() enable_cnt: %d", pcid->enable_cnt.counter); host = scsi_host_alloc(&driver_template, host_alloc_size); if (host == NULL) { esas2r_log(ESAS2R_LOG_CRIT, "scsi_host_alloc() FAIL"); return -ENODEV; } memset(host->hostdata, 0, host_alloc_size); a = (struct esas2r_adapter *)host->hostdata; esas2r_log(ESAS2R_LOG_INFO, "scsi_host_alloc() OK host: %p", host); /* override max LUN and max target id */ host->max_id = ESAS2R_MAX_ID + 1; host->max_lun = 255; /* we can handle 16-byte CDbs */ host->max_cmd_len = 16; host->can_queue = can_queue; host->cmd_per_lun = cmd_per_lun; host->this_id = host->max_id + 1; host->max_channel = 0; host->unique_id = found_adapters; host->sg_tablesize = sg_tablesize; host->max_sectors = esas2r_max_sectors; /* set to bus master for BIOses that don't do it for us */ esas2r_log(ESAS2R_LOG_INFO, "pci_set_master() called"); pci_set_master(pcid); if (!esas2r_init_adapter(host, pcid, found_adapters)) { esas2r_log(ESAS2R_LOG_CRIT, "unable to initialize device at PCI bus %x:%x", pcid->bus->number, pcid->devfn); esas2r_log_dev(ESAS2R_LOG_INFO, &(host->shost_gendev), "scsi_host_put() called"); scsi_host_put(host); return 0; } esas2r_log(ESAS2R_LOG_INFO, "pci_set_drvdata(%p, %p) called", pcid, host->hostdata); pci_set_drvdata(pcid, host); esas2r_log(ESAS2R_LOG_INFO, "scsi_add_host() called"); err = scsi_add_host(host, &pcid->dev); if (err) { esas2r_log(ESAS2R_LOG_CRIT, "scsi_add_host returned %d", err); esas2r_log_dev(ESAS2R_LOG_CRIT, &(host->shost_gendev), "scsi_add_host() FAIL"); esas2r_log_dev(ESAS2R_LOG_INFO, &(host->shost_gendev), "scsi_host_put() called"); scsi_host_put(host); esas2r_log_dev(ESAS2R_LOG_INFO, &(host->shost_gendev), "pci_set_drvdata(%p, NULL) called", pcid); pci_set_drvdata(pcid, NULL); return -ENODEV; } esas2r_fw_event_on(a); esas2r_log_dev(ESAS2R_LOG_INFO, &(host->shost_gendev), "scsi_scan_host() called"); scsi_scan_host(host); /* Add sysfs binary files */ if (sysfs_create_bin_file(&host->shost_dev.kobj, &bin_attr_fw)) esas2r_log_dev(ESAS2R_LOG_WARN, &(host->shost_gendev), "Failed to create sysfs binary file: fw"); else a->sysfs_fw_created = 1; if (sysfs_create_bin_file(&host->shost_dev.kobj, &bin_attr_fs)) esas2r_log_dev(ESAS2R_LOG_WARN, &(host->shost_gendev), "Failed to create sysfs binary file: fs"); else a->sysfs_fs_created = 1; if (sysfs_create_bin_file(&host->shost_dev.kobj, &bin_attr_vda)) esas2r_log_dev(ESAS2R_LOG_WARN, &(host->shost_gendev), "Failed to create sysfs binary file: vda"); else a->sysfs_vda_created = 1; if (sysfs_create_bin_file(&host->shost_dev.kobj, &bin_attr_hw)) esas2r_log_dev(ESAS2R_LOG_WARN, &(host->shost_gendev), "Failed to create sysfs binary file: hw"); else a->sysfs_hw_created = 1; if (sysfs_create_bin_file(&host->shost_dev.kobj, &bin_attr_live_nvram)) esas2r_log_dev(ESAS2R_LOG_WARN, &(host->shost_gendev), "Failed to create sysfs binary file: live_nvram"); else a->sysfs_live_nvram_created = 1; if (sysfs_create_bin_file(&host->shost_dev.kobj, &bin_attr_default_nvram)) esas2r_log_dev(ESAS2R_LOG_WARN, &(host->shost_gendev), "Failed to create sysfs binary file: default_nvram"); else a->sysfs_default_nvram_created = 1; found_adapters++; return 0; }
static __devinit int mvme16x_probe(struct device *dev) { struct Scsi_Host * host = NULL; struct NCR_700_Host_Parameters *hostdata; if (!MACH_IS_MVME16x) goto out; if (mvme16x_config & MVME16x_CONFIG_NO_SCSICHIP) { printk(KERN_INFO "mvme16x-scsi: detection disabled, " "SCSI chip not present\n"); goto out; } hostdata = kzalloc(sizeof(struct NCR_700_Host_Parameters), GFP_KERNEL); if (hostdata == NULL) { printk(KERN_ERR "mvme16x-scsi: " "Failed to allocate host data\n"); goto out; } /* Fill in the required pieces of hostdata */ hostdata->base = (void __iomem *)0xfff47000UL; hostdata->clock = 50; /* XXX - depends on the CPU clock! */ hostdata->chip710 = 1; hostdata->dmode_extra = DMODE_FC2; hostdata->dcntl_extra = EA_710; hostdata->ctest7_extra = CTEST7_TT1; /* and register the chip */ host = NCR_700_detect(&mvme16x_scsi_driver_template, hostdata, dev); if (!host) { printk(KERN_ERR "mvme16x-scsi: No host detected; " "board configuration problem?\n"); goto out_free; } host->this_id = 7; host->base = 0xfff47000UL; host->irq = MVME16x_IRQ_SCSI; if (request_irq(host->irq, NCR_700_intr, 0, "mvme16x-scsi", host)) { printk(KERN_ERR "mvme16x-scsi: request_irq failed\n"); goto out_put_host; } /* Enable scsi chip ints */ { volatile unsigned long v; /* Enable scsi interrupts at level 4 in PCCchip2 */ v = in_be32(0xfff4202c); v = (v & ~0xff) | 0x10 | 4; out_be32(0xfff4202c, v); } dev_set_drvdata(dev, host); scsi_scan_host(host); return 0; out_put_host: scsi_host_put(host); out_free: kfree(hostdata); out: return -ENODEV; }
static int __devinit zorro7xx_init_one(struct zorro_dev *z, const struct zorro_device_id *ent) { struct Scsi_Host * host = NULL; struct NCR_700_Host_Parameters *hostdata; struct zorro_driver_data *zdd; unsigned long board, ioaddr; board = zorro_resource_start(z); zdd = (struct zorro_driver_data *)ent->driver_data; if (zdd->absolute) { ioaddr = zdd->offset; } else { ioaddr = board + zdd->offset; } if (!zorro_request_device(z, zdd->name)) { printk(KERN_ERR "zorro7xx: cannot reserve region 0x%lx, abort\n", board); return -EBUSY; } hostdata = kmalloc(sizeof(struct NCR_700_Host_Parameters), GFP_KERNEL); if (hostdata == NULL) { printk(KERN_ERR "zorro7xx: 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 */ if (ioaddr > 0x01000000) hostdata->base = ioremap(ioaddr, zorro_resource_len(z)); else hostdata->base = (void __iomem *)ZTWO_VADDR(ioaddr); hostdata->clock = 50; hostdata->chip710 = 1; /* Settings for at least WarpEngine 40xx */ hostdata->ctest7_extra = CTEST7_TT1; zorro7xx_scsi_driver_template.name = zdd->name; /* and register the chip */ host = NCR_700_detect(&zorro7xx_scsi_driver_template, hostdata, &z->dev); if (!host) { printk(KERN_ERR "zorro7xx: No host detected; " "board configuration problem?\n"); goto out_free; } host->this_id = 7; host->base = ioaddr; host->irq = IRQ_AMIGA_PORTS; if (request_irq(host->irq, NCR_700_intr, IRQF_SHARED, "zorro7xx-scsi", host)) { printk(KERN_ERR "zorro7xx: request_irq failed\n"); goto out_put_host; } zorro_set_drvdata(z, host); scsi_scan_host(host); return 0; out_put_host: scsi_host_put(host); out_free: if (ioaddr > 0x01000000) iounmap(hostdata->base); kfree(hostdata); out_release: zorro_release_device(z); return -ENODEV; }
static struct Scsi_Host *__qlogicfas_detect(struct scsi_host_template *host, int qbase, int qlirq) { int qltyp; int qinitid; struct Scsi_Host *hreg; struct qlogicfas408_priv *priv; if (!qbase || qlirq == -1) goto err; if (!request_region(qbase, 0x10, qlogicfas_name)) { printk(KERN_INFO "%s: address %#x is busy\n", qlogicfas_name, qbase); goto err; } if (!qlogicfas408_detect(qbase, INT_TYPE)) { printk(KERN_WARNING "%s: probe failed for %#x\n", qlogicfas_name, qbase); goto err_release_mem; } printk(KERN_INFO "%s: Using preset base address of %03x," " IRQ %d\n", qlogicfas_name, qbase, qlirq); qltyp = qlogicfas408_get_chip_type(qbase, INT_TYPE); qinitid = host->this_id; if (qinitid < 0) qinitid = 7; qlogicfas408_setup(qbase, qinitid, INT_TYPE); hreg = scsi_host_alloc(host, sizeof(struct qlogicfas408_priv)); if (!hreg) goto err_release_mem; priv = get_priv_by_host(hreg); hreg->io_port = qbase; hreg->n_io_port = 16; hreg->dma_channel = -1; if (qlirq != -1) hreg->irq = qlirq; priv->qbase = qbase; priv->qlirq = qlirq; priv->qinitid = qinitid; priv->shost = hreg; priv->int_type = INT_TYPE; sprintf(priv->qinfo, "Qlogicfas Driver version 0.46, chip %02X at %03X, IRQ %d, TPdma:%d", qltyp, qbase, qlirq, QL_TURBO_PDMA); host->name = qlogicfas_name; if (request_irq(qlirq, qlogicfas408_ihandl, 0, qlogicfas_name, hreg)) goto free_scsi_host; if (scsi_add_host(hreg, NULL)) goto free_interrupt; scsi_scan_host(hreg); return hreg; free_interrupt: free_irq(qlirq, hreg); free_scsi_host: scsi_host_put(hreg); err_release_mem: release_region(qbase, 0x10); err: return NULL; }
static int __devinit pvscsi_probe(struct pci_dev *pdev, const struct pci_device_id *id) { struct pvscsi_adapter *adapter; struct Scsi_Host *host; unsigned int i; unsigned long flags = 0; int error; error = -ENODEV; if (pci_enable_device(pdev)) return error; if (pci_set_dma_mask(pdev, DMA_BIT_MASK(64)) == 0 && pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64)) == 0) { printk(KERN_INFO "vmw_pvscsi: using 64bit dma\n"); } else if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32)) == 0 && pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32)) == 0) { printk(KERN_INFO "vmw_pvscsi: using 32bit dma\n"); } else { printk(KERN_ERR "vmw_pvscsi: failed to set DMA mask\n"); goto out_disable_device; } pvscsi_template.can_queue = min(PVSCSI_MAX_NUM_PAGES_REQ_RING, pvscsi_ring_pages) * PVSCSI_MAX_NUM_REQ_ENTRIES_PER_PAGE; pvscsi_template.cmd_per_lun = min(pvscsi_template.can_queue, pvscsi_cmd_per_lun); host = scsi_host_alloc(&pvscsi_template, sizeof(struct pvscsi_adapter)); if (!host) { printk(KERN_ERR "vmw_pvscsi: failed to allocate host\n"); goto out_disable_device; } adapter = shost_priv(host); memset(adapter, 0, sizeof(*adapter)); adapter->dev = pdev; adapter->host = host; spin_lock_init(&adapter->hw_lock); host->max_channel = 0; host->max_id = 16; host->max_lun = 1; host->max_cmd_len = 16; adapter->rev = pdev->revision; if (pci_request_regions(pdev, "vmw_pvscsi")) { printk(KERN_ERR "vmw_pvscsi: pci memory selection failed\n"); goto out_free_host; } for (i = 0; i < DEVICE_COUNT_RESOURCE; i++) { if ((pci_resource_flags(pdev, i) & PCI_BASE_ADDRESS_SPACE_IO)) continue; if (pci_resource_len(pdev, i) < PVSCSI_MEM_SPACE_SIZE) continue; break; } if (i == DEVICE_COUNT_RESOURCE) { printk(KERN_ERR "vmw_pvscsi: adapter has no suitable MMIO region\n"); goto out_release_resources; } adapter->mmioBase = pci_iomap(pdev, i, PVSCSI_MEM_SPACE_SIZE); if (!adapter->mmioBase) { printk(KERN_ERR "vmw_pvscsi: can't iomap for BAR %d memsize %lu\n", i, PVSCSI_MEM_SPACE_SIZE); goto out_release_resources; } pci_set_master(pdev); pci_set_drvdata(pdev, host); ll_adapter_reset(adapter); adapter->use_msg = pvscsi_setup_msg_workqueue(adapter); error = pvscsi_allocate_rings(adapter); if (error) { printk(KERN_ERR "vmw_pvscsi: unable to allocate ring memory\n"); goto out_release_resources; } /* * From this point on we should reset the adapter if anything goes * wrong. */ pvscsi_setup_all_rings(adapter); adapter->cmd_map = kcalloc(adapter->req_depth, sizeof(struct pvscsi_ctx), GFP_KERNEL); if (!adapter->cmd_map) { printk(KERN_ERR "vmw_pvscsi: failed to allocate memory.\n"); error = -ENOMEM; goto out_reset_adapter; } INIT_LIST_HEAD(&adapter->cmd_pool); for (i = 0; i < adapter->req_depth; i++) { struct pvscsi_ctx *ctx = adapter->cmd_map + i; list_add(&ctx->list, &adapter->cmd_pool); } error = pvscsi_allocate_sg(adapter); if (error) { printk(KERN_ERR "vmw_pvscsi: unable to allocate s/g table\n"); goto out_reset_adapter; } if (!pvscsi_disable_msix && pvscsi_setup_msix(adapter, &adapter->irq) == 0) { printk(KERN_INFO "vmw_pvscsi: using MSI-X\n"); adapter->use_msix = 1; } else if (!pvscsi_disable_msi && pci_enable_msi(pdev) == 0) { printk(KERN_INFO "vmw_pvscsi: using MSI\n"); adapter->use_msi = 1; adapter->irq = pdev->irq; } else { printk(KERN_INFO "vmw_pvscsi: using INTx\n"); adapter->irq = pdev->irq; flags = IRQF_SHARED; } error = request_irq(adapter->irq, pvscsi_isr, flags, "vmw_pvscsi", adapter); if (error) { printk(KERN_ERR "vmw_pvscsi: unable to request IRQ: %d\n", error); adapter->irq = 0; goto out_reset_adapter; } error = scsi_add_host(host, &pdev->dev); if (error) { printk(KERN_ERR "vmw_pvscsi: scsi_add_host failed: %d\n", error); goto out_reset_adapter; } dev_info(&pdev->dev, "VMware PVSCSI rev %d host #%u\n", adapter->rev, host->host_no); pvscsi_unmask_intr(adapter); scsi_scan_host(host); return 0; out_reset_adapter: ll_adapter_reset(adapter); out_release_resources: pvscsi_release_resources(adapter); out_free_host: scsi_host_put(host); out_disable_device: pci_set_drvdata(pdev, NULL); pci_disable_device(pdev); return error; }
static int __init amiga_a3000_scsi_probe(struct platform_device *pdev) { struct resource *res; struct Scsi_Host *instance; int error; struct a3000_scsiregs *regs; wd33c93_regs wdregs; struct a3000_hostdata *hdata; res = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (!res) return -ENODEV; if (!request_mem_region(res->start, resource_size(res), "wd33c93")) return -EBUSY; instance = scsi_host_alloc(&amiga_a3000_scsi_template, sizeof(struct a3000_hostdata)); if (!instance) { error = -ENOMEM; goto fail_alloc; } instance->irq = IRQ_AMIGA_PORTS; regs = (struct a3000_scsiregs *)ZTWO_VADDR(res->start); regs->DAWR = DAWR_A3000; wdregs.SASR = ®s->SASR; wdregs.SCMD = ®s->SCMD; hdata = shost_priv(instance); hdata->wh.no_sync = 0xff; hdata->wh.fast = 0; hdata->wh.dma_mode = CTRL_DMA; hdata->regs = regs; wd33c93_init(instance, wdregs, dma_setup, dma_stop, WD33C93_FS_12_15); error = request_irq(IRQ_AMIGA_PORTS, a3000_intr, IRQF_SHARED, "A3000 SCSI", instance); if (error) goto fail_irq; regs->CNTR = CNTR_PDMD | CNTR_INTEN; error = scsi_add_host(instance, NULL); if (error) goto fail_host; platform_set_drvdata(pdev, instance); scsi_scan_host(instance); return 0; fail_host: free_irq(IRQ_AMIGA_PORTS, instance); fail_irq: scsi_host_put(instance); fail_alloc: release_mem_region(res->start, resource_size(res)); return error; }
static struct Scsi_Host *__qlogicfas_detect(struct scsi_host_template *host, int qbase, int qlirq) { int qltyp; /* type of chip */ int qinitid; struct Scsi_Host *hreg; /* registered host structure */ struct qlogicfas408_priv *priv; /* Qlogic Cards only exist at 0x230 or 0x330 (the chip itself * decodes the address - I check 230 first since MIDI cards are * typically at 0x330 * * Theoretically, two Qlogic cards can coexist in the same system. * This should work by simply using this as a loadable module for * the second card, but I haven't tested this. */ if (!qbase || qlirq == -1) goto err; if (!request_region(qbase, 0x10, qlogicfas_name)) { printk(KERN_INFO "%s: address %#x is busy\n", qlogicfas_name, qbase); goto err; } if (!qlogicfas408_detect(qbase, INT_TYPE)) { printk(KERN_WARNING "%s: probe failed for %#x\n", qlogicfas_name, qbase); goto err_release_mem; } printk(KERN_INFO "%s: Using preset base address of %03x," " IRQ %d\n", qlogicfas_name, qbase, qlirq); qltyp = qlogicfas408_get_chip_type(qbase, INT_TYPE); qinitid = host->this_id; if (qinitid < 0) qinitid = 7; /* if no ID, use 7 */ qlogicfas408_setup(qbase, qinitid, INT_TYPE); hreg = scsi_host_alloc(host, sizeof(struct qlogicfas408_priv)); if (!hreg) goto err_release_mem; priv = get_priv_by_host(hreg); hreg->io_port = qbase; hreg->n_io_port = 16; hreg->dma_channel = -1; if (qlirq != -1) hreg->irq = qlirq; priv->qbase = qbase; priv->qlirq = qlirq; priv->qinitid = qinitid; priv->shost = hreg; priv->int_type = INT_TYPE; sprintf(priv->qinfo, "Qlogicfas Driver version 0.46, chip %02X at %03X, IRQ %d, TPdma:%d", qltyp, qbase, qlirq, QL_TURBO_PDMA); host->name = qlogicfas_name; if (request_irq(qlirq, qlogicfas408_ihandl, 0, qlogicfas_name, hreg)) goto free_scsi_host; if (scsi_add_host(hreg, NULL)) goto free_interrupt; scsi_scan_host(hreg); return hreg; free_interrupt: free_irq(qlirq, hreg); free_scsi_host: scsi_host_put(hreg); err_release_mem: release_region(qbase, 0x10); err: return NULL; }