tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
fork atom

[PATCH] irq-flags: scsi: Use the new IRQF_ constants

Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: "David S. Miller" <davem@davemloft.net>
Cc: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Cc: James Bottomley <James.Bottomley@steeleye.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>

authored by

Thomas Gleixner and committed by
Linus Torvalds 1d6f359a 5d8c8a2e

+108 -108
unified split
+1 -1
drivers/scsi/3w-9xxx.c
··· 2122 2122 TW_PARAM_PORTCOUNT, TW_PARAM_PORTCOUNT_LENGTH))); 2123 2123 2124 2124 /* Now setup the interrupt handler */ 2125 - retval = request_irq(pdev->irq, twa_interrupt, SA_SHIRQ, "3w-9xxx", tw_dev); 2125 + retval = request_irq(pdev->irq, twa_interrupt, IRQF_SHARED, "3w-9xxx", tw_dev); 2126 2126 if (retval) { 2127 2127 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x30, "Error requesting IRQ"); 2128 2128 goto out_remove_host;
+1 -1
drivers/scsi/3w-xxxx.c
··· 2397 2397 printk(KERN_WARNING "3w-xxxx: scsi%d: Found a 3ware Storage Controller at 0x%x, IRQ: %d.\n", host->host_no, tw_dev->base_addr, pdev->irq); 2398 2398 2399 2399 /* Now setup the interrupt handler */ 2400 - retval = request_irq(pdev->irq, tw_interrupt, SA_SHIRQ, "3w-xxxx", tw_dev); 2400 + retval = request_irq(pdev->irq, tw_interrupt, IRQF_SHARED, "3w-xxxx", tw_dev); 2401 2401 if (retval) { 2402 2402 printk(KERN_WARNING "3w-xxxx: Error requesting IRQ."); 2403 2403 goto out_remove_host;
+2 -2
drivers/scsi/53c7xx.c
··· 1070 1070 1071 1071 NCR53c7x0_driver_init (host); 1072 1072 1073 - if (request_irq(host->irq, NCR53c7x0_intr, SA_SHIRQ, "53c7xx", host)) 1073 + if (request_irq(host->irq, NCR53c7x0_intr, IRQF_SHARED, "53c7xx", host)) 1074 1074 { 1075 1075 printk("scsi%d : IRQ%d not free, detaching\n", 1076 1076 host->host_no, host->irq); ··· 4232 4232 * Purpose : handle NCR53c7x0 interrupts for all NCR devices sharing 4233 4233 * the same IRQ line. 4234 4234 * 4235 - * Inputs : Since we're using the SA_INTERRUPT interrupt handler 4235 + * Inputs : Since we're using the IRQF_DISABLED interrupt handler 4236 4236 * semantics, irq indicates the interrupt which invoked 4237 4237 * this handler. 4238 4238 *
+1 -1
drivers/scsi/BusLogic.c
··· 1844 1844 /* 1845 1845 Acquire shared access to the IRQ Channel. 1846 1846 */ 1847 - if (request_irq(HostAdapter->IRQ_Channel, BusLogic_InterruptHandler, SA_SHIRQ, HostAdapter->FullModelName, HostAdapter) < 0) { 1847 + if (request_irq(HostAdapter->IRQ_Channel, BusLogic_InterruptHandler, IRQF_SHARED, HostAdapter->FullModelName, HostAdapter) < 0) { 1848 1848 BusLogic_Error("UNABLE TO ACQUIRE IRQ CHANNEL %d - DETACHING\n", HostAdapter, HostAdapter->IRQ_Channel); 1849 1849 return false; 1850 1850 }
+1 -1
drivers/scsi/NCR5380.c
··· 585 585 NCR5380_setup(instance); 586 586 587 587 for (trying_irqs = i = 0, mask = 1; i < 16; ++i, mask <<= 1) 588 - if ((mask & possible) && (request_irq(i, &probe_intr, SA_INTERRUPT, "NCR-probe", NULL) == 0)) 588 + if ((mask & possible) && (request_irq(i, &probe_intr, IRQF_DISABLED, "NCR-probe", NULL) == 0)) 589 589 trying_irqs |= mask; 590 590 591 591 timeout = jiffies + (250 * HZ / 1000);
+1 -1
drivers/scsi/NCR_D700.c
··· 320 320 memset(p, '\0', sizeof(*p)); 321 321 p->dev = dev; 322 322 snprintf(p->name, sizeof(p->name), "D700(%s)", dev->bus_id); 323 - if (request_irq(irq, NCR_D700_intr, SA_SHIRQ, p->name, p)) { 323 + if (request_irq(irq, NCR_D700_intr, IRQF_SHARED, p->name, p)) { 324 324 printk(KERN_ERR "D700: request_irq failed\n"); 325 325 kfree(p); 326 326 return -EBUSY;
+1 -1
drivers/scsi/NCR_Q720.c
··· 265 265 p->irq = irq; 266 266 p->siops = siops; 267 267 268 - if (request_irq(irq, NCR_Q720_intr, SA_SHIRQ, "NCR_Q720", p)) { 268 + if (request_irq(irq, NCR_Q720_intr, IRQF_SHARED, "NCR_Q720", p)) { 269 269 printk(KERN_ERR "NCR_Q720: request irq %d failed\n", irq); 270 270 goto out_release; 271 271 }
+1 -1
drivers/scsi/a100u2w.c
··· 1120 1120 shost->sg_tablesize = TOTAL_SG_ENTRY; 1121 1121 1122 1122 /* Initial orc chip */ 1123 - error = request_irq(pdev->irq, inia100_intr, SA_SHIRQ, 1123 + error = request_irq(pdev->irq, inia100_intr, IRQF_SHARED, 1124 1124 "inia100", shost); 1125 1125 if (error < 0) { 1126 1126 printk(KERN_WARNING "inia100: unable to get irq %d\n",
+1 -1
drivers/scsi/a2091.c
··· 208 208 regs.SASR = &(DMA(instance)->SASR); 209 209 regs.SCMD = &(DMA(instance)->SCMD); 210 210 wd33c93_init(instance, regs, dma_setup, dma_stop, WD33C93_FS_8_10); 211 - request_irq(IRQ_AMIGA_PORTS, a2091_intr, SA_SHIRQ, "A2091 SCSI", 211 + request_irq(IRQ_AMIGA_PORTS, a2091_intr, IRQF_SHARED, "A2091 SCSI", 212 212 instance); 213 213 DMA(instance)->CNTR = CNTR_PDMD | CNTR_INTEN; 214 214 num_a2091++;
+1 -1
drivers/scsi/a3000.c
··· 190 190 regs.SASR = &(DMA(a3000_host)->SASR); 191 191 regs.SCMD = &(DMA(a3000_host)->SCMD); 192 192 wd33c93_init(a3000_host, regs, dma_setup, dma_stop, WD33C93_FS_12_15); 193 - if (request_irq(IRQ_AMIGA_PORTS, a3000_intr, SA_SHIRQ, "A3000 SCSI", 193 + if (request_irq(IRQ_AMIGA_PORTS, a3000_intr, IRQF_SHARED, "A3000 SCSI", 194 194 a3000_intr)) 195 195 goto fail_irq; 196 196 DMA(a3000_host)->CNTR = CNTR_PDMD | CNTR_INTEN;
+1 -1
drivers/scsi/aacraid/rkt.c
··· 453 453 } 454 454 msleep(1); 455 455 } 456 - if (request_irq(dev->scsi_host_ptr->irq, aac_rkt_intr, SA_SHIRQ|SA_INTERRUPT, "aacraid", (void *)dev)<0) 456 + if (request_irq(dev->scsi_host_ptr->irq, aac_rkt_intr, IRQF_SHARED|IRQF_DISABLED, "aacraid", (void *)dev)<0) 457 457 { 458 458 printk(KERN_ERR "%s%d: Interrupt unavailable.\n", name, instance); 459 459 goto error_iounmap;
+1 -1
drivers/scsi/aacraid/rx.c
··· 453 453 } 454 454 msleep(1); 455 455 } 456 - if (request_irq(dev->scsi_host_ptr->irq, aac_rx_intr, SA_SHIRQ|SA_INTERRUPT, "aacraid", (void *)dev)<0) 456 + if (request_irq(dev->scsi_host_ptr->irq, aac_rx_intr, IRQF_SHARED|IRQF_DISABLED, "aacraid", (void *)dev)<0) 457 457 { 458 458 printk(KERN_ERR "%s%d: Interrupt unavailable.\n", name, instance); 459 459 goto error_iounmap;
+1 -1
drivers/scsi/aacraid/sa.c
··· 327 327 msleep(1); 328 328 } 329 329 330 - if (request_irq(dev->scsi_host_ptr->irq, aac_sa_intr, SA_SHIRQ|SA_INTERRUPT, "aacraid", (void *)dev ) < 0) { 330 + if (request_irq(dev->scsi_host_ptr->irq, aac_sa_intr, IRQF_SHARED|IRQF_DISABLED, "aacraid", (void *)dev ) < 0) { 331 331 printk(KERN_WARNING "%s%d: Interrupt unavailable.\n", name, instance); 332 332 goto error_iounmap; 333 333 }
+9 -9
drivers/scsi/advansys.c
··· 371 371 372 372 1.5 (8/8/96): 373 373 1. Add support for ABP-940U (PCI Ultra) adapter. 374 - 2. Add support for IRQ sharing by setting the SA_SHIRQ flag for 374 + 2. Add support for IRQ sharing by setting the IRQF_SHARED flag for 375 375 request_irq and supplying a dev_id pointer to both request_irq() 376 376 and free_irq(). 377 377 3. In AscSearchIOPortAddr11() restore a call to check_region() which ··· 504 504 3. For v2.1.93 and newer kernels use CONFIG_PCI and new PCI BIOS 505 505 access functions. 506 506 4. Update board serial number printing. 507 - 5. Try allocating an IRQ both with and without the SA_INTERRUPT 507 + 5. Try allocating an IRQ both with and without the IRQF_DISABLED 508 508 flag set to allow IRQ sharing with drivers that do not set 509 - the SA_INTERRUPT flag. Also display a more descriptive error 509 + the IRQF_DISABLED flag. Also display a more descriptive error 510 510 message if request_irq() fails. 511 511 6. Update to latest Asc and Adv Libraries. 512 512 ··· 5202 5202 /* Register IRQ Number. */ 5203 5203 ASC_DBG1(2, "advansys_detect: request_irq() %d\n", shp->irq); 5204 5204 /* 5205 - * If request_irq() fails with the SA_INTERRUPT flag set, 5206 - * then try again without the SA_INTERRUPT flag set. This 5205 + * If request_irq() fails with the IRQF_DISABLED flag set, 5206 + * then try again without the IRQF_DISABLED flag set. This 5207 5207 * allows IRQ sharing to work even with other drivers that 5208 - * do not set the SA_INTERRUPT flag. 5208 + * do not set the IRQF_DISABLED flag. 5209 5209 * 5210 - * If SA_INTERRUPT is not set, then interrupts are enabled 5210 + * If IRQF_DISABLED is not set, then interrupts are enabled 5211 5211 * before the driver interrupt function is called. 5212 5212 */ 5213 5213 if (((ret = request_irq(shp->irq, advansys_interrupt, 5214 - SA_INTERRUPT | (share_irq == TRUE ? SA_SHIRQ : 0), 5214 + IRQF_DISABLED | (share_irq == TRUE ? IRQF_SHARED : 0), 5215 5215 "advansys", boardp)) != 0) && 5216 5216 ((ret = request_irq(shp->irq, advansys_interrupt, 5217 - (share_irq == TRUE ? SA_SHIRQ : 0), 5217 + (share_irq == TRUE ? IRQF_SHARED : 0), 5218 5218 "advansys", boardp)) != 0)) 5219 5219 { 5220 5220 if (ret == -EBUSY) {
+2 -2
drivers/scsi/aha152x.c
··· 855 855 SETPORT(SIMODE0, 0); 856 856 SETPORT(SIMODE1, 0); 857 857 858 - if( request_irq(shpnt->irq, swintr, SA_INTERRUPT|SA_SHIRQ, "aha152x", shpnt) ) { 858 + if( request_irq(shpnt->irq, swintr, IRQF_DISABLED|IRQF_SHARED, "aha152x", shpnt) ) { 859 859 printk(KERN_ERR "aha152x%d: irq %d busy.\n", shpnt->host_no, shpnt->irq); 860 860 goto out_host_put; 861 861 } ··· 889 889 SETPORT(SSTAT0, 0x7f); 890 890 SETPORT(SSTAT1, 0xef); 891 891 892 - if ( request_irq(shpnt->irq, intr, SA_INTERRUPT|SA_SHIRQ, "aha152x", shpnt) ) { 892 + if ( request_irq(shpnt->irq, intr, IRQF_DISABLED|IRQF_SHARED, "aha152x", shpnt) ) { 893 893 printk(KERN_ERR "aha152x%d: failed to reassign irq %d.\n", shpnt->host_no, shpnt->irq); 894 894 goto out_host_put; 895 895 }
+1 -1
drivers/scsi/aha1740.c
··· 634 634 } 635 635 636 636 DEB(printk("aha1740_probe: enable interrupt channel %d\n",irq_level)); 637 - if (request_irq(irq_level,aha1740_intr_handle,irq_type ? 0 : SA_SHIRQ, 637 + if (request_irq(irq_level,aha1740_intr_handle,irq_type ? 0 : IRQF_SHARED, 638 638 "aha1740",shpnt)) { 639 639 printk(KERN_ERR "aha1740_probe: Unable to allocate IRQ %d.\n", 640 640 irq_level);
+1 -1
drivers/scsi/ahci.c
··· 1371 1371 probe_ent->port_ops = ahci_port_info[board_idx].port_ops; 1372 1372 1373 1373 probe_ent->irq = pdev->irq; 1374 - probe_ent->irq_flags = SA_SHIRQ; 1374 + probe_ent->irq_flags = IRQF_SHARED; 1375 1375 probe_ent->mmio_base = mmio_base; 1376 1376 probe_ent->private_data = hpriv; 1377 1377
+1 -1
drivers/scsi/aic7xxx/aic7770_osm.c
··· 65 65 66 66 shared = 0; 67 67 if ((ahc->flags & AHC_EDGE_INTERRUPT) == 0) 68 - shared = SA_SHIRQ; 68 + shared = IRQF_SHARED; 69 69 70 70 error = request_irq(irq, ahc_linux_isr, shared, "aic7xxx", ahc); 71 71 if (error == 0)
+1 -1
drivers/scsi/aic7xxx/aic79xx_osm_pci.c
··· 342 342 int error; 343 343 344 344 error = request_irq(ahd->dev_softc->irq, ahd_linux_isr, 345 - SA_SHIRQ, "aic79xx", ahd); 345 + IRQF_SHARED, "aic79xx", ahd); 346 346 if (!error) 347 347 ahd->platform_data->irq = ahd->dev_softc->irq; 348 348
+1 -1
drivers/scsi/aic7xxx/aic7xxx_osm_pci.c
··· 375 375 int error; 376 376 377 377 error = request_irq(ahc->dev_softc->irq, ahc_linux_isr, 378 - SA_SHIRQ, "aic7xxx", ahc); 378 + IRQF_SHARED, "aic7xxx", ahc); 379 379 if (error == 0) 380 380 ahc->platform_data->irq = ahc->dev_softc->irq; 381 381
+2 -2
drivers/scsi/aic7xxx_old.c
··· 8322 8322 } 8323 8323 else 8324 8324 { 8325 - result = (request_irq(p->irq, do_aic7xxx_isr, SA_SHIRQ, 8325 + result = (request_irq(p->irq, do_aic7xxx_isr, IRQF_SHARED, 8326 8326 "aic7xxx", p)); 8327 8327 if (result < 0) 8328 8328 { 8329 - result = (request_irq(p->irq, do_aic7xxx_isr, SA_INTERRUPT | SA_SHIRQ, 8329 + result = (request_irq(p->irq, do_aic7xxx_isr, IRQF_DISABLED | IRQF_SHARED, 8330 8330 "aic7xxx", p)); 8331 8331 } 8332 8332 }
+1 -1
drivers/scsi/arm/acornscsi.c
··· 3030 3030 if (!request_region(host->io_port, 2048, "acornscsi(ram)")) 3031 3031 goto err_5; 3032 3032 3033 - ret = request_irq(host->irq, acornscsi_intr, SA_INTERRUPT, "acornscsi", ashost); 3033 + ret = request_irq(host->irq, acornscsi_intr, IRQF_DISABLED, "acornscsi", ashost); 3034 3034 if (ret) { 3035 3035 printk(KERN_CRIT "scsi%d: IRQ%d not free: %d\n", 3036 3036 host->host_no, ashost->scsi.irq, ret);
+1 -1
drivers/scsi/arm/cumana_1.c
··· 277 277 ((struct NCR5380_hostdata *)host->hostdata)->ctrl = 0; 278 278 outb(0x00, host->io_port - 577); 279 279 280 - ret = request_irq(host->irq, cumanascsi_intr, SA_INTERRUPT, 280 + ret = request_irq(host->irq, cumanascsi_intr, IRQF_DISABLED, 281 281 "CumanaSCSI-1", host); 282 282 if (ret) { 283 283 printk("scsi%d: IRQ%d not free: %d\n",
+1 -1
drivers/scsi/arm/cumana_2.c
··· 460 460 goto out_free; 461 461 462 462 ret = request_irq(ec->irq, cumanascsi_2_intr, 463 - SA_INTERRUPT, "cumanascsi2", info); 463 + IRQF_DISABLED, "cumanascsi2", info); 464 464 if (ret) { 465 465 printk("scsi%d: IRQ%d not free: %d\n", 466 466 host->host_no, ec->irq, ret);
+1 -1
drivers/scsi/arm/powertec.c
··· 373 373 goto out_free; 374 374 375 375 ret = request_irq(ec->irq, powertecscsi_intr, 376 - SA_INTERRUPT, "powertec", info); 376 + IRQF_DISABLED, "powertec", info); 377 377 if (ret) { 378 378 printk("scsi%d: IRQ%d not free: %d\n", 379 379 host->host_no, ec->irq, ret);
+3 -3
drivers/scsi/atp870u.c
··· 2751 2751 goto unregister; 2752 2752 } 2753 2753 2754 - if (request_irq(pdev->irq, atp870u_intr_handle, SA_SHIRQ, "atp880i", shpnt)) { 2754 + if (request_irq(pdev->irq, atp870u_intr_handle, IRQF_SHARED, "atp880i", shpnt)) { 2755 2755 printk(KERN_ERR "Unable to allocate IRQ%d for Acard controller.\n", pdev->irq); 2756 2756 goto free_tables; 2757 2757 } ··· 2822 2822 #ifdef ED_DBGP 2823 2823 printk("request_irq() shpnt %p hostdata %p\n", shpnt, p); 2824 2824 #endif 2825 - if (request_irq(pdev->irq, atp870u_intr_handle, SA_SHIRQ, "atp870u", shpnt)) { 2825 + if (request_irq(pdev->irq, atp870u_intr_handle, IRQF_SHARED, "atp870u", shpnt)) { 2826 2826 printk(KERN_ERR "Unable to allocate IRQ for Acard controller.\n"); 2827 2827 goto free_tables; 2828 2828 } ··· 3004 3004 if (atp870u_init_tables(shpnt) < 0) 3005 3005 goto unregister; 3006 3006 3007 - if (request_irq(pdev->irq, atp870u_intr_handle, SA_SHIRQ, "atp870i", shpnt)) { 3007 + if (request_irq(pdev->irq, atp870u_intr_handle, IRQF_SHARED, "atp870i", shpnt)) { 3008 3008 printk(KERN_ERR "Unable to allocate IRQ%d for Acard controller.\n", pdev->irq); 3009 3009 goto free_tables; 3010 3010 }
+1 -1
drivers/scsi/blz1230.c
··· 172 172 173 173 esp->irq = IRQ_AMIGA_PORTS; 174 174 esp->slot = board+REAL_BLZ1230_ESP_ADDR; 175 - if (request_irq(IRQ_AMIGA_PORTS, esp_intr, SA_SHIRQ, 175 + if (request_irq(IRQ_AMIGA_PORTS, esp_intr, IRQF_SHARED, 176 176 "Blizzard 1230 SCSI IV", esp->ehost)) 177 177 goto err_out; 178 178
+1 -1
drivers/scsi/blz2060.c
··· 146 146 esp->esp_command_dvma = virt_to_bus((void *)cmd_buffer); 147 147 148 148 esp->irq = IRQ_AMIGA_PORTS; 149 - request_irq(IRQ_AMIGA_PORTS, esp_intr, SA_SHIRQ, 149 + request_irq(IRQ_AMIGA_PORTS, esp_intr, IRQF_SHARED, 150 150 "Blizzard 2060 SCSI", esp->ehost); 151 151 152 152 /* Figure out our scsi ID on the bus */
+1 -1
drivers/scsi/cyberstorm.c
··· 172 172 esp->esp_command_dvma = virt_to_bus((void *)cmd_buffer); 173 173 174 174 esp->irq = IRQ_AMIGA_PORTS; 175 - request_irq(IRQ_AMIGA_PORTS, esp_intr, SA_SHIRQ, 175 + request_irq(IRQ_AMIGA_PORTS, esp_intr, IRQF_SHARED, 176 176 "CyberStorm SCSI", esp->ehost); 177 177 /* Figure out our scsi ID on the bus */ 178 178 /* The DMA cond flag contains a hardcoded jumper bit
+1 -1
drivers/scsi/cyberstormII.c
··· 153 153 esp->esp_command_dvma = virt_to_bus((void *)cmd_buffer); 154 154 155 155 esp->irq = IRQ_AMIGA_PORTS; 156 - request_irq(IRQ_AMIGA_PORTS, esp_intr, SA_SHIRQ, 156 + request_irq(IRQ_AMIGA_PORTS, esp_intr, IRQF_SHARED, 157 157 "CyberStorm SCSI Mk II", esp->ehost); 158 158 159 159 /* Figure out our scsi ID on the bus */
+1 -1
drivers/scsi/dc395x.c
··· 4562 4562 acb->io_port_base = io_port; 4563 4563 acb->io_port_len = io_port_len; 4564 4564 4565 - if (request_irq(irq, dc395x_interrupt, SA_SHIRQ, DC395X_NAME, acb)) { 4565 + if (request_irq(irq, dc395x_interrupt, IRQF_SHARED, DC395X_NAME, acb)) { 4566 4566 /* release the region we just claimed */ 4567 4567 dprintkl(KERN_INFO, "Failed to register IRQ\n"); 4568 4568 goto failed;
+5 -5
drivers/scsi/dec_esp.c
··· 202 202 203 203 esp_initialize(esp); 204 204 205 - if (request_irq(esp->irq, esp_intr, SA_INTERRUPT, 205 + if (request_irq(esp->irq, esp_intr, IRQF_DISABLED, 206 206 "ncr53c94", esp->ehost)) 207 207 goto err_dealloc; 208 208 if (request_irq(dec_interrupt[DEC_IRQ_ASC_MERR], 209 - scsi_dma_merr_int, SA_INTERRUPT, 209 + scsi_dma_merr_int, IRQF_DISABLED, 210 210 "ncr53c94 error", esp->ehost)) 211 211 goto err_free_irq; 212 212 if (request_irq(dec_interrupt[DEC_IRQ_ASC_ERR], 213 - scsi_dma_err_int, SA_INTERRUPT, 213 + scsi_dma_err_int, IRQF_DISABLED, 214 214 "ncr53c94 overrun", esp->ehost)) 215 215 goto err_free_irq_merr; 216 216 if (request_irq(dec_interrupt[DEC_IRQ_ASC_DMA], 217 - scsi_dma_int, SA_INTERRUPT, 217 + scsi_dma_int, IRQF_DISABLED, 218 218 "ncr53c94 dma", esp->ehost)) 219 219 goto err_free_irq_err; 220 220 ··· 276 276 esp->dma_mmu_release_scsi_sgl = 0; 277 277 esp->dma_advance_sg = 0; 278 278 279 - if (request_irq(esp->irq, esp_intr, SA_INTERRUPT, 279 + if (request_irq(esp->irq, esp_intr, IRQF_DISABLED, 280 280 "PMAZ_AA", esp->ehost)) { 281 281 esp_deallocate(esp); 282 282 release_tc_card(slot);
+1 -1
drivers/scsi/dmx3191d.c
··· 94 94 95 95 NCR5380_init(shost, FLAG_NO_PSEUDO_DMA | FLAG_DTC3181E); 96 96 97 - if (request_irq(pdev->irq, NCR5380_intr, SA_SHIRQ, 97 + if (request_irq(pdev->irq, NCR5380_intr, IRQF_SHARED, 98 98 DMX3191D_DRIVER_NAME, shost)) { 99 99 /* 100 100 * Steam powered scsi controllers run without an IRQ anyway
+1 -1
drivers/scsi/dpt_i2o.c
··· 1009 1009 printk(KERN_INFO" BAR1 %p - size= %x\n",msg_addr_virt,hba_map1_area_size); 1010 1010 } 1011 1011 1012 - if (request_irq (pDev->irq, adpt_isr, SA_SHIRQ, pHba->name, pHba)) { 1012 + if (request_irq (pDev->irq, adpt_isr, IRQF_SHARED, pHba->name, pHba)) { 1013 1013 printk(KERN_ERR"%s: Couldn't register IRQ %d\n", pHba->name, pDev->irq); 1014 1014 adpt_i2o_delete_hba(pHba); 1015 1015 return -EINVAL;
+1 -1
drivers/scsi/dtc.c
··· 280 280 /* With interrupts enabled, it will sometimes hang when doing heavy 281 281 * reads. So better not enable them until I finger it out. */ 282 282 if (instance->irq != SCSI_IRQ_NONE) 283 - if (request_irq(instance->irq, dtc_intr, SA_INTERRUPT, "dtc", instance)) { 283 + if (request_irq(instance->irq, dtc_intr, IRQF_DISABLED, "dtc", instance)) { 284 284 printk(KERN_ERR "scsi%d : IRQ%d not free, interrupts disabled\n", instance->host_no, instance->irq); 285 285 instance->irq = SCSI_IRQ_NONE; 286 286 }
+1 -1
drivers/scsi/eata.c
··· 1221 1221 1222 1222 /* Board detected, allocate its IRQ */ 1223 1223 if (request_irq(irq, do_interrupt_handler, 1224 - SA_INTERRUPT | ((subversion == ESA) ? SA_SHIRQ : 0), 1224 + IRQF_DISABLED | ((subversion == ESA) ? IRQF_SHARED : 0), 1225 1225 driver_name, (void *)&sha[j])) { 1226 1226 printk("%s: unable to allocate IRQ %u, detaching.\n", name, 1227 1227 irq);
+2 -2
drivers/scsi/eata_pio.c
··· 731 731 return 0; 732 732 733 733 if (!reg_IRQ[gc->IRQ]) { /* Interrupt already registered ? */ 734 - if (!request_irq(gc->IRQ, do_eata_pio_int_handler, SA_INTERRUPT, "EATA-PIO", sh)) { 734 + if (!request_irq(gc->IRQ, do_eata_pio_int_handler, IRQF_DISABLED, "EATA-PIO", sh)) { 735 735 reg_IRQ[gc->IRQ]++; 736 736 if (!gc->IRQ_TR) 737 737 reg_IRQL[gc->IRQ] = 1; /* IRQ is edge triggered */ ··· 965 965 966 966 for (i = 0; i <= MAXIRQ; i++) 967 967 if (reg_IRQ[i]) 968 - request_irq(i, do_eata_pio_int_handler, SA_INTERRUPT, "EATA-PIO", NULL); 968 + request_irq(i, do_eata_pio_int_handler, IRQF_DISABLED, "EATA-PIO", NULL); 969 969 970 970 HBA_ptr = first_HBA; 971 971
+1 -1
drivers/scsi/esp.c
··· 778 778 * sanely maintain. 779 779 */ 780 780 if (request_irq(esp->ehost->irq, esp_intr, 781 - SA_SHIRQ, "ESP SCSI", esp)) { 781 + IRQF_SHARED, "ESP SCSI", esp)) { 782 782 printk("esp%d: Cannot acquire irq line\n", 783 783 esp->esp_id); 784 784 return -1;
+1 -1
drivers/scsi/fastlane.c
··· 210 210 211 211 esp->irq = IRQ_AMIGA_PORTS; 212 212 esp->slot = board+FASTLANE_ESP_ADDR; 213 - if (request_irq(IRQ_AMIGA_PORTS, esp_intr, SA_SHIRQ, 213 + if (request_irq(IRQ_AMIGA_PORTS, esp_intr, IRQF_SHARED, 214 214 "Fastlane SCSI", esp->ehost)) { 215 215 printk(KERN_WARNING "Fastlane: Could not get IRQ%d, aborting.\n", IRQ_AMIGA_PORTS); 216 216 goto err_unmap;
+1 -1
drivers/scsi/fd_mcs.c
··· 400 400 mca_set_adapter_name(slot - 1, fd_mcs_adapters[loop].name); 401 401 402 402 /* check irq/region */ 403 - if (request_irq(irq, fd_mcs_intr, SA_SHIRQ, "fd_mcs", hosts)) { 403 + if (request_irq(irq, fd_mcs_intr, IRQF_SHARED, "fd_mcs", hosts)) { 404 404 printk(KERN_ERR "fd_mcs: interrupt is not available, skipping...\n"); 405 405 continue; 406 406 }
+1 -1
drivers/scsi/fdomain.c
··· 949 949 /* Register the IRQ with the kernel */ 950 950 951 951 retcode = request_irq( interrupt_level, 952 - do_fdomain_16x0_intr, pdev?SA_SHIRQ:0, "fdomain", shpnt); 952 + do_fdomain_16x0_intr, pdev?IRQF_SHARED:0, "fdomain", shpnt); 953 953 954 954 if (retcode < 0) { 955 955 if (retcode == -EINVAL) {
+1 -1
drivers/scsi/g_NCR5380.c
··· 461 461 instance->irq = NCR5380_probe_irq(instance, 0xffff); 462 462 463 463 if (instance->irq != SCSI_IRQ_NONE) 464 - if (request_irq(instance->irq, generic_NCR5380_intr, SA_INTERRUPT, "NCR5380", instance)) { 464 + if (request_irq(instance->irq, generic_NCR5380_intr, IRQF_DISABLED, "NCR5380", instance)) { 465 465 printk(KERN_WARNING "scsi%d : IRQ%d not free, interrupts disabled\n", instance->host_no, instance->irq); 466 466 instance->irq = SCSI_IRQ_NONE; 467 467 }
+3 -3
drivers/scsi/gdth.c
··· 4350 4350 printk("Configuring GDT-ISA HA at BIOS 0x%05X IRQ %u DRQ %u\n", 4351 4351 isa_bios,ha->irq,ha->drq); 4352 4352 4353 - if (request_irq(ha->irq,gdth_interrupt,SA_INTERRUPT,"gdth",ha)) { 4353 + if (request_irq(ha->irq,gdth_interrupt,IRQF_DISABLED,"gdth",ha)) { 4354 4354 printk("GDT-ISA: Unable to allocate IRQ\n"); 4355 4355 scsi_unregister(shp); 4356 4356 continue; ··· 4476 4476 printk("Configuring GDT-EISA HA at Slot %d IRQ %u\n", 4477 4477 eisa_slot>>12,ha->irq); 4478 4478 4479 - if (request_irq(ha->irq,gdth_interrupt,SA_INTERRUPT,"gdth",ha)) { 4479 + if (request_irq(ha->irq,gdth_interrupt,IRQF_DISABLED,"gdth",ha)) { 4480 4480 printk("GDT-EISA: Unable to allocate IRQ\n"); 4481 4481 scsi_unregister(shp); 4482 4482 continue; ··· 4603 4603 pcistr[ctr].bus,PCI_SLOT(pcistr[ctr].device_fn),ha->irq); 4604 4604 4605 4605 if (request_irq(ha->irq, gdth_interrupt, 4606 - SA_INTERRUPT|SA_SHIRQ, "gdth", ha)) 4606 + IRQF_DISABLED|IRQF_SHARED, "gdth", ha)) 4607 4607 { 4608 4608 printk("GDT-PCI: Unable to allocate IRQ\n"); 4609 4609 scsi_unregister(shp);
+1 -1
drivers/scsi/gvp11.c
··· 328 328 (epc & GVP_SCSICLKMASK) ? WD33C93_FS_8_10 329 329 : WD33C93_FS_12_15); 330 330 331 - request_irq(IRQ_AMIGA_PORTS, gvp11_intr, SA_SHIRQ, "GVP11 SCSI", 331 + request_irq(IRQ_AMIGA_PORTS, gvp11_intr, IRQF_SHARED, "GVP11 SCSI", 332 332 instance); 333 333 DMA(instance)->CNTR = GVP11_DMAC_INT_ENABLE; 334 334 num_gvp11++;
+1 -1
drivers/scsi/hptiop.c
··· 1304 1304 1305 1305 pci_set_drvdata(pcidev, host); 1306 1306 1307 - if (request_irq(pcidev->irq, hptiop_intr, SA_SHIRQ, 1307 + if (request_irq(pcidev->irq, hptiop_intr, IRQF_SHARED, 1308 1308 driver_name, hba)) { 1309 1309 printk(KERN_ERR "scsi%d: request irq %d failed\n", 1310 1310 hba->host->host_no, pcidev->irq);
+3 -3
drivers/scsi/ibmmca.c
··· 1510 1510 #endif 1511 1511 1512 1512 /* get interrupt request level */ 1513 - if (request_irq(IM_IRQ, interrupt_handler, SA_SHIRQ, "ibmmcascsi", hosts)) { 1513 + if (request_irq(IM_IRQ, interrupt_handler, IRQF_SHARED, "ibmmcascsi", hosts)) { 1514 1514 printk(KERN_ERR "IBM MCA SCSI: Unable to get shared IRQ %d.\n", IM_IRQ); 1515 1515 return 0; 1516 1516 } else ··· 1635 1635 /* IRQ11 is used by SCSI-2 F/W Adapter/A */ 1636 1636 printk(KERN_DEBUG "IBM MCA SCSI: SCSI-2 F/W adapter needs IRQ 11.\n"); 1637 1637 /* get interrupt request level */ 1638 - if (request_irq(IM_IRQ_FW, interrupt_handler, SA_SHIRQ, "ibmmcascsi", hosts)) { 1638 + if (request_irq(IM_IRQ_FW, interrupt_handler, IRQF_SHARED, "ibmmcascsi", hosts)) { 1639 1639 printk(KERN_ERR "IBM MCA SCSI: Unable to get shared IRQ %d.\n", IM_IRQ_FW); 1640 1640 } else 1641 1641 IRQ11_registered++; ··· 1696 1696 /* IRQ11 is used by SCSI-2 F/W Adapter/A */ 1697 1697 printk(KERN_DEBUG "IBM MCA SCSI: SCSI-2 F/W adapter needs IRQ 11.\n"); 1698 1698 /* get interrupt request level */ 1699 - if (request_irq(IM_IRQ_FW, interrupt_handler, SA_SHIRQ, "ibmmcascsi", hosts)) 1699 + if (request_irq(IM_IRQ_FW, interrupt_handler, IRQF_SHARED, "ibmmcascsi", hosts)) 1700 1700 printk(KERN_ERR "IBM MCA SCSI: Unable to get shared IRQ %d.\n", IM_IRQ_FW); 1701 1701 else 1702 1702 IRQ11_registered++;
+1 -1
drivers/scsi/in2000.c
··· 2015 2015 write1_io(0, IO_FIFO_READ); /* start fifo out in read mode */ 2016 2016 write1_io(0, IO_INTR_MASK); /* allow all ints */ 2017 2017 x = int_tab[(switches & (SW_INT0 | SW_INT1)) >> SW_INT_SHIFT]; 2018 - if (request_irq(x, in2000_intr, SA_INTERRUPT, "in2000", instance)) { 2018 + if (request_irq(x, in2000_intr, IRQF_DISABLED, "in2000", instance)) { 2019 2019 printk("in2000_detect: Unable to allocate IRQ.\n"); 2020 2020 detect_count--; 2021 2021 continue;
+1 -1
drivers/scsi/initio.c
··· 2867 2867 hreg->sg_tablesize = TOTAL_SG_ENTRY; /* Maximun support is 32 */ 2868 2868 2869 2869 /* Initial tulip chip */ 2870 - ok = request_irq(pHCB->HCS_Intr, i91u_intr, SA_INTERRUPT | SA_SHIRQ, "i91u", hreg); 2870 + ok = request_irq(pHCB->HCS_Intr, i91u_intr, IRQF_DISABLED | IRQF_SHARED, "i91u", hreg); 2871 2871 if (ok < 0) { 2872 2872 printk(KERN_WARNING "i91u: unable to request IRQ %d\n\n", pHCB->HCS_Intr); 2873 2873 return 0;
+1 -1
drivers/scsi/ipr.c
··· 6428 6428 ioa_cfg->needs_hard_reset = 1; 6429 6429 6430 6430 ipr_mask_and_clear_interrupts(ioa_cfg, ~IPR_PCII_IOA_TRANS_TO_OPER); 6431 - rc = request_irq(pdev->irq, ipr_isr, SA_SHIRQ, IPR_NAME, ioa_cfg); 6431 + rc = request_irq(pdev->irq, ipr_isr, IRQF_SHARED, IPR_NAME, ioa_cfg); 6432 6432 6433 6433 if (rc) { 6434 6434 dev_err(&pdev->dev, "Couldn't register IRQ %d! rc=%d\n",
+2 -2
drivers/scsi/ips.c
··· 7007 7007 memcpy(ha, oldha, sizeof (ips_ha_t)); 7008 7008 free_irq(oldha->irq, oldha); 7009 7009 /* Install the interrupt handler with the new ha */ 7010 - if (request_irq(ha->irq, do_ipsintr, SA_SHIRQ, ips_name, ha)) { 7010 + if (request_irq(ha->irq, do_ipsintr, IRQF_SHARED, ips_name, ha)) { 7011 7011 IPS_PRINTK(KERN_WARNING, ha->pcidev, 7012 7012 "Unable to install interrupt handler\n"); 7013 7013 scsi_host_put(sh); ··· 7419 7419 } 7420 7420 7421 7421 /* Install the interrupt handler */ 7422 - if (request_irq(ha->irq, do_ipsintr, SA_SHIRQ, ips_name, ha)) { 7422 + if (request_irq(ha->irq, do_ipsintr, IRQF_SHARED, ips_name, ha)) { 7423 7423 IPS_PRINTK(KERN_WARNING, ha->pcidev, 7424 7424 "Unable to install interrupt handler\n"); 7425 7425 return ips_abort_init(ha, index);
+1 -1
drivers/scsi/jazz_esp.c
··· 131 131 esp->esp_command_dvma = vdma_alloc(CPHYSADDR(cmd_buffer), sizeof (cmd_buffer)); 132 132 133 133 esp->irq = JAZZ_SCSI_IRQ; 134 - request_irq(JAZZ_SCSI_IRQ, esp_intr, SA_INTERRUPT, "JAZZ SCSI", 134 + request_irq(JAZZ_SCSI_IRQ, esp_intr, IRQF_DISABLED, "JAZZ SCSI", 135 135 esp->ehost); 136 136 137 137 /*
+1 -1
drivers/scsi/lasi700.c
··· 131 131 host->this_id = 7; 132 132 host->base = base; 133 133 host->irq = dev->irq; 134 - if(request_irq(dev->irq, NCR_700_intr, SA_SHIRQ, "lasi700", host)) { 134 + if(request_irq(dev->irq, NCR_700_intr, IRQF_SHARED, "lasi700", host)) { 135 135 printk(KERN_ERR "lasi700: request_irq failed!\n"); 136 136 goto out_put_host; 137 137 }
+1 -1
drivers/scsi/libata-bmdma.c
··· 853 853 return NULL; 854 854 855 855 probe_ent->irq = pdev->irq; 856 - probe_ent->irq_flags = SA_SHIRQ; 856 + probe_ent->irq_flags = IRQF_SHARED; 857 857 probe_ent->private_data = port[0]->private_data; 858 858 859 859 if (ports & ATA_PORT_PRIMARY) {
+1 -1
drivers/scsi/lpfc/lpfc_init.c
··· 1620 1620 if (error) 1621 1621 goto out_remove_host; 1622 1622 1623 - error = request_irq(phba->pcidev->irq, lpfc_intr_handler, SA_SHIRQ, 1623 + error = request_irq(phba->pcidev->irq, lpfc_intr_handler, IRQF_SHARED, 1624 1624 LPFC_DRIVER_NAME, phba); 1625 1625 if (error) { 1626 1626 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+1 -1
drivers/scsi/megaraid.c
··· 4714 4714 4715 4715 if (request_irq(irq, (adapter->flag & BOARD_MEMMAP) ? 4716 4716 megaraid_isr_memmapped : megaraid_isr_iomapped, 4717 - SA_SHIRQ, "megaraid", adapter)) { 4717 + IRQF_SHARED, "megaraid", adapter)) { 4718 4718 printk(KERN_WARNING 4719 4719 "megaraid: Couldn't register IRQ %d!\n", irq); 4720 4720 goto out_free_scb_list;
+1 -1
drivers/scsi/megaraid/megaraid_mbox.c
··· 767 767 // 768 768 769 769 // request IRQ and register the interrupt service routine 770 - if (request_irq(adapter->irq, megaraid_isr, SA_SHIRQ, "megaraid", 770 + if (request_irq(adapter->irq, megaraid_isr, IRQF_SHARED, "megaraid", 771 771 adapter)) { 772 772 773 773 con_log(CL_ANN, (KERN_WARNING
+1 -1
drivers/scsi/megaraid/megaraid_sas.c
··· 2191 2191 /* 2192 2192 * Register IRQ 2193 2193 */ 2194 - if (request_irq(pdev->irq, megasas_isr, SA_SHIRQ, "megasas", instance)) { 2194 + if (request_irq(pdev->irq, megasas_isr, IRQF_SHARED, "megasas", instance)) { 2195 2195 printk(KERN_DEBUG "megasas: Failed to register IRQ\n"); 2196 2196 goto fail_irq; 2197 2197 }
+1 -1
drivers/scsi/nsp32.c
··· 2867 2867 nsp32_do_bus_reset(data); 2868 2868 2869 2869 ret = request_irq(host->irq, do_nsp32_isr, 2870 - SA_SHIRQ | SA_SAMPLE_RANDOM, "nsp32", data); 2870 + IRQF_SHARED | IRQF_SAMPLE_RANDOM, "nsp32", data); 2871 2871 if (ret < 0) { 2872 2872 nsp32_msg(KERN_ERR, "Unable to allocate IRQ for NinjaSCSI32 " 2873 2873 "SCSI PCI controller. Interrupt: %d", host->irq);
+1 -1
drivers/scsi/oktagon_esp.c
··· 197 197 esp->esp_command_dvma = (__u32) cmd_buffer; 198 198 199 199 esp->irq = IRQ_AMIGA_PORTS; 200 - request_irq(IRQ_AMIGA_PORTS, esp_intr, SA_SHIRQ, 200 + request_irq(IRQ_AMIGA_PORTS, esp_intr, IRQF_SHARED, 201 201 "BSC Oktagon SCSI", esp->ehost); 202 202 203 203 /* Figure out our scsi ID on the bus */
+1 -1
drivers/scsi/pas16.c
··· 454 454 instance->irq = NCR5380_probe_irq(instance, PAS16_IRQS); 455 455 456 456 if (instance->irq != SCSI_IRQ_NONE) 457 - if (request_irq(instance->irq, pas16_intr, SA_INTERRUPT, "pas16", instance)) { 457 + if (request_irq(instance->irq, pas16_intr, IRQF_DISABLED, "pas16", instance)) { 458 458 printk("scsi%d : IRQ%d not free, interrupts disabled\n", 459 459 instance->host_no, instance->irq); 460 460 instance->irq = SCSI_IRQ_NONE;
+1 -1
drivers/scsi/pcmcia/nsp_cs.c
··· 1623 1623 /* Interrupt handler */ 1624 1624 link->irq.Handler = &nspintr; 1625 1625 link->irq.Instance = info; 1626 - link->irq.Attributes |= (SA_SHIRQ | SA_SAMPLE_RANDOM); 1626 + link->irq.Attributes |= (IRQF_SHARED | IRQF_SAMPLE_RANDOM); 1627 1627 1628 1628 /* General socket configuration */ 1629 1629 link->conf.Attributes = CONF_ENABLE_IRQ;
+1 -1
drivers/scsi/pcmcia/sym53c500_cs.c
··· 799 799 data = (struct sym53c500_data *)host->hostdata; 800 800 801 801 if (irq_level > 0) { 802 - if (request_irq(irq_level, SYM53C500_intr, SA_SHIRQ, "SYM53C500", host)) { 802 + if (request_irq(irq_level, SYM53C500_intr, IRQF_SHARED, "SYM53C500", host)) { 803 803 printk("SYM53C500: unable to allocate IRQ %d\n", irq_level); 804 804 goto err_free_scsi; 805 805 }
+1 -1
drivers/scsi/pdc_adma.c
··· 690 690 probe_ent->port_ops = adma_port_info[board_idx].port_ops; 691 691 692 692 probe_ent->irq = pdev->irq; 693 - probe_ent->irq_flags = SA_SHIRQ; 693 + probe_ent->irq_flags = IRQF_SHARED; 694 694 probe_ent->mmio_base = mmio_base; 695 695 probe_ent->n_ports = ADMA_PORTS; 696 696
+2 -2
drivers/scsi/qla1280.c
··· 192 192 - Don't walk the entire list in qla1280_putq_t() just to directly 193 193 grab the pointer to the last element afterwards 194 194 Rev 3.23.5 Beta August 9, 2001, Jes Sorensen 195 - - Don't use SA_INTERRUPT, it's use is deprecated for this kinda driver 195 + - Don't use IRQF_DISABLED, it's use is deprecated for this kinda driver 196 196 Rev 3.23.4 Beta August 8, 2001, Jes Sorensen 197 197 - Set dev->max_sectors to 1024 198 198 Rev 3.23.3 Beta August 6, 2001, Jes Sorensen ··· 4369 4369 /* Disable ISP interrupts. */ 4370 4370 qla1280_disable_intrs(ha); 4371 4371 4372 - if (request_irq(pdev->irq, qla1280_intr_handler, SA_SHIRQ, 4372 + if (request_irq(pdev->irq, qla1280_intr_handler, IRQF_SHARED, 4373 4373 "qla1280", ha)) { 4374 4374 printk("qla1280 : Failed to reserve interrupt %d already " 4375 4375 "in use\n", pdev->irq);
+1 -1
drivers/scsi/qla2xxx/qla_os.c
··· 1541 1541 host->transportt = qla2xxx_transport_template; 1542 1542 1543 1543 ret = request_irq(pdev->irq, ha->isp_ops.intr_handler, 1544 - SA_INTERRUPT|SA_SHIRQ, QLA2XXX_DRIVER_NAME, ha); 1544 + IRQF_DISABLED|IRQF_SHARED, QLA2XXX_DRIVER_NAME, ha); 1545 1545 if (ret) { 1546 1546 qla_printk(KERN_WARNING, ha, 1547 1547 "Failed to reserve interrupt %d already in use.\n",
+1 -1
drivers/scsi/qlogicpti.c
··· 718 718 * sanely maintain. 719 719 */ 720 720 if (request_irq(qpti->irq, qpti_intr, 721 - SA_SHIRQ, "Qlogic/PTI", qpti)) 721 + IRQF_SHARED, "Qlogic/PTI", qpti)) 722 722 goto fail; 723 723 724 724 printk("qpti%d: IRQ %d ", qpti->qpti_id, qpti->irq);
+1 -1
drivers/scsi/sata_mv.c
··· 2395 2395 probe_ent->port_ops = mv_port_info[board_idx].port_ops; 2396 2396 2397 2397 probe_ent->irq = pdev->irq; 2398 - probe_ent->irq_flags = SA_SHIRQ; 2398 + probe_ent->irq_flags = IRQF_SHARED; 2399 2399 probe_ent->mmio_base = mmio_base; 2400 2400 probe_ent->private_data = hpriv; 2401 2401
+1 -1
drivers/scsi/sata_promise.c
··· 743 743 probe_ent->port_ops = pdc_port_info[board_idx].port_ops; 744 744 745 745 probe_ent->irq = pdev->irq; 746 - probe_ent->irq_flags = SA_SHIRQ; 746 + probe_ent->irq_flags = IRQF_SHARED; 747 747 probe_ent->mmio_base = mmio_base; 748 748 749 749 pdc_ata_setup_port(&probe_ent->port[0], base + 0x200);
+1 -1
drivers/scsi/sata_qstor.c
··· 680 680 probe_ent->port_ops = qs_port_info[board_idx].port_ops; 681 681 682 682 probe_ent->irq = pdev->irq; 683 - probe_ent->irq_flags = SA_SHIRQ; 683 + probe_ent->irq_flags = IRQF_SHARED; 684 684 probe_ent->mmio_base = mmio_base; 685 685 probe_ent->n_ports = QS_PORTS; 686 686
+1 -1
drivers/scsi/sata_sil.c
··· 608 608 probe_ent->mwdma_mask = sil_port_info[ent->driver_data].mwdma_mask; 609 609 probe_ent->udma_mask = sil_port_info[ent->driver_data].udma_mask; 610 610 probe_ent->irq = pdev->irq; 611 - probe_ent->irq_flags = SA_SHIRQ; 611 + probe_ent->irq_flags = IRQF_SHARED; 612 612 probe_ent->host_flags = sil_port_info[ent->driver_data].host_flags; 613 613 614 614 mmio_base = pci_iomap(pdev, 5, 0);
+1 -1
drivers/scsi/sata_sil24.c
··· 1041 1041 probe_ent->n_ports = SIL24_FLAG2NPORTS(pinfo->host_flags); 1042 1042 1043 1043 probe_ent->irq = pdev->irq; 1044 - probe_ent->irq_flags = SA_SHIRQ; 1044 + probe_ent->irq_flags = IRQF_SHARED; 1045 1045 probe_ent->mmio_base = port_base; 1046 1046 probe_ent->private_data = hpriv; 1047 1047
+1 -1
drivers/scsi/sata_svw.c
··· 428 428 probe_ent->port_ops = &k2_sata_ops; 429 429 probe_ent->n_ports = 4; 430 430 probe_ent->irq = pdev->irq; 431 - probe_ent->irq_flags = SA_SHIRQ; 431 + probe_ent->irq_flags = IRQF_SHARED; 432 432 probe_ent->mmio_base = mmio_base; 433 433 434 434 /* We don't care much about the PIO/UDMA masks, but the core won't like us
+1 -1
drivers/scsi/sata_sx4.c
··· 1436 1436 probe_ent->port_ops = pdc_port_info[board_idx].port_ops; 1437 1437 1438 1438 probe_ent->irq = pdev->irq; 1439 - probe_ent->irq_flags = SA_SHIRQ; 1439 + probe_ent->irq_flags = IRQF_SHARED; 1440 1440 probe_ent->mmio_base = mmio_base; 1441 1441 1442 1442 probe_ent->private_data = hpriv;
+1 -1
drivers/scsi/sata_via.c
··· 242 242 probe_ent->port_ops = &svia_sata_ops; 243 243 probe_ent->n_ports = N_PORTS; 244 244 probe_ent->irq = pdev->irq; 245 - probe_ent->irq_flags = SA_SHIRQ; 245 + probe_ent->irq_flags = IRQF_SHARED; 246 246 probe_ent->pio_mask = 0x1f; 247 247 probe_ent->mwdma_mask = 0x07; 248 248 probe_ent->udma_mask = 0x7f;
+1 -1
drivers/scsi/sata_vsc.c
··· 400 400 probe_ent->port_ops = &vsc_sata_ops; 401 401 probe_ent->n_ports = 4; 402 402 probe_ent->irq = pdev->irq; 403 - probe_ent->irq_flags = SA_SHIRQ; 403 + probe_ent->irq_flags = IRQF_SHARED; 404 404 probe_ent->mmio_base = mmio_base; 405 405 406 406 /* We don't care much about the PIO/UDMA masks, but the core won't like us
+1 -1
drivers/scsi/seagate.c
··· 497 497 return 0; 498 498 499 499 hostno = instance->host_no; 500 - if (request_irq (irq, do_seagate_reconnect_intr, SA_INTERRUPT, (controller_type == SEAGATE) ? "seagate" : "tmc-8xx", instance)) { 500 + if (request_irq (irq, do_seagate_reconnect_intr, IRQF_DISABLED, (controller_type == SEAGATE) ? "seagate" : "tmc-8xx", instance)) { 501 501 printk(KERN_ERR "scsi%d : unable to allocate IRQ%d\n", hostno, irq); 502 502 return 0; 503 503 }
+1 -1
drivers/scsi/sim710.c
··· 133 133 host->this_id = scsi_id; 134 134 host->base = base_addr; 135 135 host->irq = irq; 136 - if (request_irq(irq, NCR_700_intr, SA_SHIRQ, "sim710", host)) { 136 + if (request_irq(irq, NCR_700_intr, IRQF_SHARED, "sim710", host)) { 137 137 printk(KERN_ERR "sim710: request_irq failed\n"); 138 138 goto out_put_host; 139 139 }
+1 -1
drivers/scsi/sun3x_esp.c
··· 97 97 esp->esp_command_dvma = dvma_vtob((unsigned long)esp->esp_command); 98 98 99 99 esp->irq = 2; 100 - if (request_irq(esp->irq, esp_intr, SA_INTERRUPT, 100 + if (request_irq(esp->irq, esp_intr, IRQF_DISABLED, 101 101 "SUN3X SCSI", esp->ehost)) { 102 102 esp_deallocate(esp); 103 103 return 0;
+1 -1
drivers/scsi/sym53c8xx_2/sym_glue.c
··· 1547 1547 * If we synchonize the C code with SCRIPTS on interrupt, 1548 1548 * we do not want to share the INTR line at all. 1549 1549 */ 1550 - if (request_irq(pdev->irq, sym53c8xx_intr, SA_SHIRQ, NAME53C8XX, np)) { 1550 + if (request_irq(pdev->irq, sym53c8xx_intr, IRQF_SHARED, NAME53C8XX, np)) { 1551 1551 printf_err("%s: request irq %d failure\n", 1552 1552 sym_name(np), pdev->irq); 1553 1553 goto attach_failed;
+1 -1
drivers/scsi/t128.c
··· 260 260 instance->irq = NCR5380_probe_irq(instance, T128_IRQS); 261 261 262 262 if (instance->irq != SCSI_IRQ_NONE) 263 - if (request_irq(instance->irq, t128_intr, SA_INTERRUPT, "t128", instance)) { 263 + if (request_irq(instance->irq, t128_intr, IRQF_DISABLED, "t128", instance)) { 264 264 printk("scsi%d : IRQ%d not free, interrupts disabled\n", 265 265 instance->host_no, instance->irq); 266 266 instance->irq = SCSI_IRQ_NONE;
+1 -1
drivers/scsi/tmscsim.c
··· 2584 2584 /* Reset Pending INT */ 2585 2585 DC390_read8_(INT_Status, io_port); 2586 2586 2587 - if (request_irq(pdev->irq, do_DC390_Interrupt, SA_SHIRQ, 2587 + if (request_irq(pdev->irq, do_DC390_Interrupt, IRQF_SHARED, 2588 2588 "tmscsim", pACB)) { 2589 2589 printk(KERN_ERR "DC390: register IRQ error!\n"); 2590 2590 goto out_release_region;
+1 -1
drivers/scsi/u14-34f.c
··· 872 872 873 873 /* Board detected, allocate its IRQ */ 874 874 if (request_irq(irq, do_interrupt_handler, 875 - SA_INTERRUPT | ((subversion == ESA) ? SA_SHIRQ : 0), 875 + IRQF_DISABLED | ((subversion == ESA) ? IRQF_SHARED : 0), 876 876 driver_name, (void *) &sha[j])) { 877 877 printk("%s: unable to allocate IRQ %u, detaching.\n", name, irq); 878 878 goto freelock;
+1 -1
drivers/scsi/wd7000.c
··· 1250 1250 return 0; 1251 1251 1252 1252 1253 - if (request_irq(host->irq, wd7000_intr, SA_INTERRUPT, "wd7000", host)) { 1253 + if (request_irq(host->irq, wd7000_intr, IRQF_DISABLED, "wd7000", host)) { 1254 1254 printk("wd7000_init: can't get IRQ %d.\n", host->irq); 1255 1255 return (0); 1256 1256 }
+1 -1
drivers/scsi/zalon.c
··· 136 136 if (!host) 137 137 goto fail; 138 138 139 - if (request_irq(dev->irq, ncr53c8xx_intr, SA_SHIRQ, "zalon", host)) { 139 + if (request_irq(dev->irq, ncr53c8xx_intr, IRQF_SHARED, "zalon", host)) { 140 140 printk(KERN_ERR "%s: irq problem with %d, detaching\n ", 141 141 dev->dev.bus_id, dev->irq); 142 142 goto fail;