if (!mem)
                return -EINVAL;
        irq = platform_get_irq(dev, 0);
+       if (irq < 0)
+               return -ENXIO;
 
        return __locomo_probe(&dev->dev, mem, irq);
 }
 
        if (!mem)
                return -EINVAL;
        irq = platform_get_irq(pdev, 0);
+       if (irq < 0)
+               return -ENXIO;
 
        return __sa1111_probe(&pdev->dev, mem, irq);
 }
 
        /* find the IRQs */
 
        s3c2410_rtc_tickno = platform_get_irq(pdev, 1);
-       if (s3c2410_rtc_tickno <= 0) {
+       if (s3c2410_rtc_tickno < 0) {
                dev_err(&pdev->dev, "no irq for rtc tick\n");
                return -ENOENT;
        }
 
        s3c2410_rtc_alarmno = platform_get_irq(pdev, 0);
-       if (s3c2410_rtc_alarmno <= 0) {
+       if (s3c2410_rtc_alarmno < 0) {
                dev_err(&pdev->dev, "no irq for alarm\n");
                return -ENOENT;
        }
 
 
        wdt->dev = &dev->dev;
        wdt->irq = platform_get_irq(dev, 0);
+       if (wdt->irq < 0) {
+               ret = -ENXIO;
+               goto err_free;
+       }
        wdt->base = ioremap(res->start, res->end - res->start + 1);
        if (!wdt->base) {
                ret = -ENOMEM;
 
 iop3xx_i2c_probe(struct platform_device *pdev)
 {
        struct resource *res;
-       int ret;
+       int ret, irq;
        struct i2c_adapter *new_adapter;
        struct i2c_algo_iop3xx_data *adapter_data;
 
                goto release_region;
        }
 
-       ret = request_irq(platform_get_irq(pdev, 0), iop3xx_i2c_irq_handler, 0,
+       irq = platform_get_irq(pdev, 0);
+       if (irq < 0) {
+               ret = -ENXIO;
+               goto unmap;
+       }
+       ret = request_irq(irq, iop3xx_i2c_irq_handler, 0,
                                pdev->name, adapter_data);
 
        if (ret) {
 
        }
 
        i2c->irq = platform_get_irq(pdev, 0);
+       if (i2c->irq < 0) {
+               result = -ENXIO;
+               goto fail_get_irq;
+       }
        i2c->flags = pdata->device_flags;
        init_waitqueue_head(&i2c->queue);
 
       fail_irq:
        iounmap(i2c->base);
       fail_map:
+      fail_get_irq:
        kfree(i2c);
        return result;
 };
 
        drv_data->freq_m = pdata->freq_m;
        drv_data->freq_n = pdata->freq_n;
        drv_data->irq = platform_get_irq(pd, 0);
+       if (drv_data->irq < 0) {
+               rc = -ENXIO;
+               goto exit_unmap_regs;
+       }
        drv_data->adapter.id = I2C_HW_MV64XXX;
        drv_data->adapter.algo = &mv64xxx_i2c_algo;
        drv_data->adapter.owner = THIS_MODULE;
 
                ret = -ENODEV;
                goto out;
        }
+       if (ahwif->irq < 0) {
+               pr_debug("%s %d: no IRQ\n", DRV_NAME, pdev->id);
+               ret = -ENODEV;
+               goto out;
+       }
 
        if (!request_mem_region (res->start, res->end-res->start, pdev->name)) {
                pr_debug("%s: request_mem_region failed\n", DRV_NAME);
 
 
        r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
        irq = platform_get_irq(pdev, 0);
-       if (!r || irq == NO_IRQ)
+       if (!r || irq < 0)
                return -ENXIO;
 
        r = request_mem_region(r->start, SZ_4K, DRIVER_NAME);
 
        dev->base_addr = res->start;
        dev->irq = platform_get_irq(pdev, 0);
 
-       ret = -ENODEV;
+       ret = -ENODEV;
+       if (dev->irq < 0)
+               goto nodev;
        if (!request_region(dev->base_addr, 0x18, dev->name))
                goto nodev;
 
 
 
        /* Fill out IRQ field */
        fep->interrupt = platform_get_irq(pdev, 0);
+       if (fep->interrupt < 0)
+               return -EINVAL;
 
        /* Attach the memory for the FCC Parameter RAM */
        r = platform_get_resource_byname(pdev, IORESOURCE_MEM, "fcc_pram");
 
        
        /* Fill out IRQ field */
        fep->interrupt = platform_get_irq_byname(pdev,"interrupt");
+       if (fep->interrupt < 0)
+               return -EINVAL;
        
        r = platform_get_resource_byname(pdev, IORESOURCE_MEM, "regs");
        fep->fec.fecp =(void*)r->start;
 
 
        /* Fill out IRQ field */
        fep->interrupt = platform_get_irq_byname(pdev, "interrupt");
+       if (fep->interrupt < 0)
+               return -EINVAL;
 
        r = platform_get_resource_byname(pdev, IORESOURCE_MEM, "regs");
        fep->scc.sccp = (void *)r->start;
 
                priv->interruptTransmit = platform_get_irq_byname(pdev, "tx");
                priv->interruptReceive = platform_get_irq_byname(pdev, "rx");
                priv->interruptError = platform_get_irq_byname(pdev, "error");
+               if (priv->interruptTransmit < 0 || priv->interruptReceive < 0 || priv->interruptError < 0)
+                       goto regs_fail;
        } else {
                priv->interruptTransmit = platform_get_irq(pdev, 0);
+               if (priv->interruptTransmit < 0)
+                       goto regs_fail;
        }
 
        /* get a pointer to the register memory */
 
 
        ndev->dma = (unsigned char)-1;
        ndev->irq = platform_get_irq(pdev, 0);
+       if (ndev->irq < 0) {
+               ret = -ENODEV;
+               goto out_free_netdev;
+       }
 
        ret = smc_request_attrib(pdev);
        if (ret)
 
 
        /* either CFLASH.IREQ (INT_1610_CF) or some GPIO */
        irq = platform_get_irq(pdev, 0);
-       if (!irq)
+       if (irq < 0)
                return -EINVAL;
 
        cf = kcalloc(1, sizeof *cf, GFP_KERNEL);
 
        port->mapbase   = res->start;
        port->membase   = S3C24XX_VA_UART + (res->start - S3C24XX_PA_UART);
        port->irq       = platform_get_irq(platdev, 0);
+       if (port->irq < 0)
+               port->irq = 0;
 
        ourport->clk    = clk_get(&platdev->dev, "uart");
 
 
 int usb_hcd_omap_probe (const struct hc_driver *driver,
                          struct platform_device *pdev)
 {
-       int retval;
+       int retval, irq;
        struct usb_hcd *hcd = 0;
        struct ohci_hcd *ohci;
 
        if (retval < 0)
                goto err2;
 
-       retval = usb_add_hcd(hcd, platform_get_irq(pdev, 0), SA_INTERRUPT);
+       irq = platform_get_irq(pdev, 0);
+       if (irq < 0) {
+               retval = -ENXIO;
+               goto err2;
+       }
+       retval = usb_add_hcd(hcd, irq, SA_INTERRUPT);
        if (retval == 0)
                return retval;
 
 
        int ret, irq;
 
        irq = platform_get_irq(pdev, 0);
-       if (irq <= 0)
+       if (irq < 0)
                return -EINVAL;
 
        if (!request_mem_region(0xb0100000, 0x10000, "LCD"))