static void hwif_register (ide_hwif_t *hwif)
 {
+       int ret;
+
        /* register with global device tree */
        strlcpy(hwif->gendev.bus_id,hwif->name,BUS_ID_SIZE);
        hwif->gendev.driver_data = hwif;
                        hwif->gendev.parent = NULL;
        }
        hwif->gendev.release = hwif_release_dev;
-       device_register(&hwif->gendev);
+       ret = device_register(&hwif->gendev);
+       if (ret < 0)
+               printk(KERN_WARNING "IDE: %s: device_register error: %d\n",
+                       __FUNCTION__, ret);
 }
 
 static int wait_hwif_ready(ide_hwif_t *hwif)
 
        if (hwif->present) {
                u16 unit = 0;
+               int ret;
+
                for (unit = 0; unit < MAX_DRIVES; ++unit) {
                        ide_drive_t *drive = &hwif->drives[unit];
                        /* For now don't attach absent drives, we may
                           want them on default or a new "empty" class
                           for hotplug reprobing ? */
                        if (drive->present) {
-                               device_register(&drive->gendev);
+                               ret = device_register(&drive->gendev);
+                               if (ret < 0)
+                                       printk(KERN_WARNING "IDE: %s: "
+                                               "device_register error: %d\n",
+                                               __FUNCTION__, ret);
                        }
                }
        }
                        if (hwif->chipset == ide_unknown || hwif->chipset == ide_forced)
                                hwif->chipset = ide_generic;
                        for (unit = 0; unit < MAX_DRIVES; ++unit)
-                               if (hwif->drives[unit].present)
-                                       device_register(&hwif->drives[unit].gendev);
+                               if (hwif->drives[unit].present) {
+                                       int ret = device_register(
+                                               &hwif->drives[unit].gendev);
+                                       if (ret < 0)
+                                               printk(KERN_WARNING "IDE: %s: "
+                                                       "device_register error: %d\n",
+                                                       __FUNCTION__, ret);
+                               }
                }
        }
        return 0;
 
 {
        struct device *dev = &drive->gendev;
        int ret = 1;
+       int err;
 
        down_write(&dev->bus->subsys.rwsem);
        device_release_driver(dev);
        /* FIXME: device can still be in use by previous driver */
        strlcpy(drive->driver_req, driver, sizeof(drive->driver_req));
-       device_attach(dev);
+       err = device_attach(dev);
+       if (err < 0)
+               printk(KERN_WARNING "IDE: %s: device_attach error: %d\n",
+                       __FUNCTION__, err);
        drive->driver_req[0] = 0;
-       if (dev->driver == NULL)
-               device_attach(dev);
+       if (dev->driver == NULL) {
+               err = device_attach(dev);
+               if (err < 0)
+                       printk(KERN_WARNING
+                               "IDE: %s: device_attach(2) error: %d\n",
+                               __FUNCTION__, err);
+       }
        if (dev->driver && !strcmp(dev->driver->name, driver))
                ret = 0;
        up_write(&dev->bus->subsys.rwsem);
 
 static int ide_drivers_show(struct seq_file *s, void *p)
 {
-       bus_for_each_drv(&ide_bus_type, NULL, s, proc_print_driver);
+       int err;
+
+       err = bus_for_each_drv(&ide_bus_type, NULL, s, proc_print_driver);
+       if (err < 0)
+               printk(KERN_WARNING "IDE: %s: bus_for_each_drv error: %d\n",
+                       __FUNCTION__, err);
        return 0;
 }
 
 
  */
 static int __init ide_init(void)
 {
+       int ret;
+
        printk(KERN_INFO "Uniform Multi-Platform E-IDE driver " REVISION "\n");
        system_bus_speed = ide_system_bus_speed();
 
-       bus_register(&ide_bus_type);
+       ret = bus_register(&ide_bus_type);
+       if (ret < 0) {
+               printk(KERN_WARNING "IDE: bus_register error: %d\n", ret);
+               return ret;
+       }
 
        init_ide_data();