int err = 0;
        struct class_device *class_err;
 
-       class_err = class_device_create(cpuid_class, MKDEV(CPUID_MAJOR, i), NULL, "cpu%d",i);
+       class_err = class_device_create(cpuid_class, NULL, MKDEV(CPUID_MAJOR, i), NULL, "cpu%d",i);
        if (IS_ERR(class_err))
                err = PTR_ERR(class_err);
        return err;
 
        int err = 0;
        struct class_device *class_err;
 
-       class_err = class_device_create(msr_class, MKDEV(MSR_MAJOR, i), NULL, "msr%d",i);
+       class_err = class_device_create(msr_class, NULL, MKDEV(MSR_MAJOR, i), NULL, "msr%d",i);
        if (IS_ERR(class_err)) 
                err = PTR_ERR(class_err);
        return err;
 
                return PTR_ERR(aoe_class);
        }
        for (i = 0; i < ARRAY_SIZE(chardevs); ++i)
-               class_device_create(aoe_class,
+               class_device_create(aoe_class, NULL,
                                        MKDEV(AOE_MAJOR, chardevs[i].minor),
                                        NULL, chardevs[i].name);
 
 
        for (unit = 0; unit < PG_UNITS; unit++) {
                struct pg *dev = &devices[unit];
                if (dev->present) {
-                       class_device_create(pg_class, MKDEV(major, unit),
+                       class_device_create(pg_class, NULL, MKDEV(major, unit),
                                        NULL, "pg%u", unit);
                        err = devfs_mk_cdev(MKDEV(major, unit),
                                      S_IFCHR | S_IRUSR | S_IWUSR, "pg/%u",
 
        devfs_mk_dir("pt");
        for (unit = 0; unit < PT_UNITS; unit++)
                if (pt[unit].present) {
-                       class_device_create(pt_class, MKDEV(major, unit),
+                       class_device_create(pt_class, NULL, MKDEV(major, unit),
                                        NULL, "pt%d", unit);
                        err = devfs_mk_cdev(MKDEV(major, unit),
                                      S_IFCHR | S_IRUSR | S_IWUSR,
                                class_device_destroy(pt_class, MKDEV(major, unit));
                                goto out_class;
                        }
-                       class_device_create(pt_class, MKDEV(major, unit + 128),
+                       class_device_create(pt_class, NULL, MKDEV(major, unit + 128),
                                        NULL, "pt%dn", unit);
                        err = devfs_mk_cdev(MKDEV(major, unit + 128),
                                      S_IFCHR | S_IRUSR | S_IWUSR,
 
                err = PTR_ERR(dsp56k_class);
                goto out_chrdev;
        }
-       class_device_create(dsp56k_class, MKDEV(DSP56K_MAJOR, 0), NULL, "dsp56k");
+       class_device_create(dsp56k_class, NULL, MKDEV(DSP56K_MAJOR, 0), NULL, "dsp56k");
 
        err = devfs_mk_cdev(MKDEV(DSP56K_MAJOR, 0),
                      S_IFCHR | S_IRUSR | S_IWUSR, "dsp56k");
 
 
        zft_class = class_create(THIS_MODULE, "zft");
        for (i = 0; i < 4; i++) {
-               class_device_create(zft_class, MKDEV(QIC117_TAPE_MAJOR, i), NULL, "qft%i", i);
+               class_device_create(zft_class, NULL, MKDEV(QIC117_TAPE_MAJOR, i), NULL, "qft%i", i);
                devfs_mk_cdev(MKDEV(QIC117_TAPE_MAJOR, i),
                                S_IFCHR | S_IRUSR | S_IWUSR,
                                "qft%i", i);
-               class_device_create(zft_class, MKDEV(QIC117_TAPE_MAJOR, i + 4), NULL, "nqft%i", i);
+               class_device_create(zft_class, NULL, MKDEV(QIC117_TAPE_MAJOR, i + 4), NULL, "nqft%i", i);
                devfs_mk_cdev(MKDEV(QIC117_TAPE_MAJOR, i + 4),
                                S_IFCHR | S_IRUSR | S_IWUSR,
                                "nqft%i", i);
-               class_device_create(zft_class, MKDEV(QIC117_TAPE_MAJOR, i + 16), NULL, "zqft%i", i);
+               class_device_create(zft_class, NULL, MKDEV(QIC117_TAPE_MAJOR, i + 16), NULL, "zqft%i", i);
                devfs_mk_cdev(MKDEV(QIC117_TAPE_MAJOR, i + 16),
                                S_IFCHR | S_IRUSR | S_IWUSR,
                                "zqft%i", i);
-               class_device_create(zft_class, MKDEV(QIC117_TAPE_MAJOR, i + 20), NULL, "nzqft%i", i);
+               class_device_create(zft_class, NULL, MKDEV(QIC117_TAPE_MAJOR, i + 20), NULL, "nzqft%i", i);
                devfs_mk_cdev(MKDEV(QIC117_TAPE_MAJOR, i + 20),
                                S_IFCHR | S_IRUSR | S_IWUSR,
                                "nzqft%i", i);
-               class_device_create(zft_class, MKDEV(QIC117_TAPE_MAJOR, i + 32), NULL, "rawqft%i", i);
+               class_device_create(zft_class, NULL, MKDEV(QIC117_TAPE_MAJOR, i + 32), NULL, "rawqft%i", i);
                devfs_mk_cdev(MKDEV(QIC117_TAPE_MAJOR, i + 32),
                                S_IFCHR | S_IRUSR | S_IWUSR,
                                "rawqft%i", i);
-               class_device_create(zft_class, MKDEV(QIC117_TAPE_MAJOR, i + 36), NULL, "nrawrawqft%i", i);
+               class_device_create(zft_class, NULL, MKDEV(QIC117_TAPE_MAJOR, i + 36), NULL, "nrawrawqft%i", i);
                devfs_mk_cdev(MKDEV(QIC117_TAPE_MAJOR, i + 36),
                                S_IFCHR | S_IRUSR | S_IWUSR,
                                "nrawqft%i", i);
 
                        }
 
                        if ( NULL != ( pB = i2BoardPtrTable[i] ) ) {
-                               class_device_create(ip2_class, MKDEV(IP2_IPL_MAJOR,
-                                               4 * i), NULL, "ipl%d", i);
+                               class_device_create(ip2_class, NULL,
+                                               MKDEV(IP2_IPL_MAJOR, 4 * i),
+                                               NULL, "ipl%d", i);
                                err = devfs_mk_cdev(MKDEV(IP2_IPL_MAJOR, 4 * i),
                                                S_IRUSR | S_IWUSR | S_IRGRP | S_IFCHR,
                                                "ip2/ipl%d", i);
                                        goto out_class;
                                }
 
-                               class_device_create(ip2_class, MKDEV(IP2_IPL_MAJOR,
-                                               4 * i + 1), NULL, "stat%d", i);
+                               class_device_create(ip2_class, NULL,
+                                               MKDEV(IP2_IPL_MAJOR, 4 * i + 1),
+                                               NULL, "stat%d", i);
                                err = devfs_mk_cdev(MKDEV(IP2_IPL_MAJOR, 4 * i + 1),
                                                S_IRUSR | S_IWUSR | S_IRGRP | S_IFCHR,
                                                "ip2/stat%d", i);
 
        devfs_mk_cdev(dev, S_IFCHR | S_IRUSR | S_IWUSR,
                      "ipmidev/%d", if_num);
 
-       class_device_create(ipmi_class, dev, NULL, "ipmi%d", if_num);
+       class_device_create(ipmi_class, NULL, dev, NULL, "ipmi%d", if_num);
 }
 
 static void ipmi_smi_gone(int if_num)
 
                devfs_mk_cdev(MKDEV(STL_SIOMEMMAJOR, i),
                               S_IFCHR | S_IRUSR | S_IWUSR,
                               "staliomem/%d", i);
-               class_device_create(istallion_class, MKDEV(STL_SIOMEMMAJOR, i),
+               class_device_create(istallion_class, NULL,
+                               MKDEV(STL_SIOMEMMAJOR, i),
                                NULL, "staliomem%d", i);
        }
 
 
        if (reset)
                lp_reset(nr);
 
-       class_device_create(lp_class, MKDEV(LP_MAJOR, nr), NULL,
+       class_device_create(lp_class, NULL, MKDEV(LP_MAJOR, nr), NULL,
                                "lp%d", nr);
        devfs_mk_cdev(MKDEV(LP_MAJOR, nr), S_IFCHR | S_IRUGO | S_IWUGO,
                        "printers/%d", nr);
 
 
        mem_class = class_create(THIS_MODULE, "mem");
        for (i = 0; i < ARRAY_SIZE(devlist); i++) {
-               class_device_create(mem_class, MKDEV(MEM_MAJOR, devlist[i].minor),
+               class_device_create(mem_class, NULL,
+                                       MKDEV(MEM_MAJOR, devlist[i].minor),
                                        NULL, devlist[i].name);
                devfs_mk_cdev(MKDEV(MEM_MAJOR, devlist[i].minor),
                                S_IFCHR | devlist[i].mode, devlist[i].name);
 
        }
        dev = MKDEV(MISC_MAJOR, misc->minor);
 
-       misc->class = class_device_create(misc_class, dev, misc->dev,
+       misc->class = class_device_create(misc_class, NULL, dev, misc->dev,
                                          "%s", misc->name);
        if (IS_ERR(misc->class)) {
                err = PTR_ERR(misc->class);
 
 
 static void pp_attach(struct parport *port)
 {
-       class_device_create(ppdev_class, MKDEV(PP_MAJOR, port->number),
+       class_device_create(ppdev_class, NULL, MKDEV(PP_MAJOR, port->number),
                        NULL, "parport%d", port->number);
 }
 
 
 static void bind_device(struct raw_config_request *rq)
 {
        class_device_destroy(raw_class, MKDEV(RAW_MAJOR, rq->raw_minor));
-       class_device_create(raw_class, MKDEV(RAW_MAJOR, rq->raw_minor),
+       class_device_create(raw_class, NULL, MKDEV(RAW_MAJOR, rq->raw_minor),
                                      NULL, "raw%d", rq->raw_minor);
 }
 
                unregister_chrdev_region(dev, MAX_RAW_MINORS);
                goto error;
        }
-       class_device_create(raw_class, MKDEV(RAW_MAJOR, 0), NULL, "rawctl");
+       class_device_create(raw_class, NULL, MKDEV(RAW_MAJOR, 0), NULL, "rawctl");
 
        devfs_mk_cdev(MKDEV(RAW_MAJOR, 0),
                      S_IFCHR | S_IRUGO | S_IWUGO,
 
                                continue;
                        }
 
-                       class_device_create(snsc_class, dev, NULL,
+                       class_device_create(snsc_class, NULL, dev, NULL,
                                                "%s", devname);
 
                        ia64_sn_irtr_intr_enable(scd->scd_nasid,
 
                devfs_mk_cdev(MKDEV(STL_SIOMEMMAJOR, i),
                                S_IFCHR|S_IRUSR|S_IWUSR,
                                "staliomem/%d", i);
-               class_device_create(stallion_class, MKDEV(STL_SIOMEMMAJOR, i), NULL, "staliomem%d", i);
+               class_device_create(stallion_class, NULL,
+                                   MKDEV(STL_SIOMEMMAJOR, i), NULL,
+                                   "staliomem%d", i);
        }
 
        stl_serial->owner = THIS_MODULE;
 
                goto out;
        }
 
-       class_device_create(tipar_class, MKDEV(TIPAR_MAJOR,
+       class_device_create(tipar_class, NULL, MKDEV(TIPAR_MAJOR,
                        TIPAR_MINOR + nr), NULL, "par%d", nr);
        /* Use devfs, tree: /dev/ticables/par/[0..2] */
        err = devfs_mk_cdev(MKDEV(TIPAR_MAJOR, TIPAR_MINOR + nr),
 
                pty_line_name(driver, index, name);
        else
                tty_line_name(driver, index, name);
-       class_device_create(tty_class, dev, device, name);
+       class_device_create(tty_class, NULL, dev, device, "%s", name);
 }
 
 /**
            register_chrdev_region(MKDEV(TTYAUX_MAJOR, 0), 1, "/dev/tty") < 0)
                panic("Couldn't register /dev/tty driver\n");
        devfs_mk_cdev(MKDEV(TTYAUX_MAJOR, 0), S_IFCHR|S_IRUGO|S_IWUGO, "tty");
-       class_device_create(tty_class, MKDEV(TTYAUX_MAJOR, 0), NULL, "tty");
+       class_device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 0), NULL, "tty");
 
        cdev_init(&console_cdev, &console_fops);
        if (cdev_add(&console_cdev, MKDEV(TTYAUX_MAJOR, 1), 1) ||
            register_chrdev_region(MKDEV(TTYAUX_MAJOR, 1), 1, "/dev/console") < 0)
                panic("Couldn't register /dev/console driver\n");
        devfs_mk_cdev(MKDEV(TTYAUX_MAJOR, 1), S_IFCHR|S_IRUSR|S_IWUSR, "console");
-       class_device_create(tty_class, MKDEV(TTYAUX_MAJOR, 1), NULL, "console");
+       class_device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 1), NULL, "console");
 
 #ifdef CONFIG_UNIX98_PTYS
        cdev_init(&ptmx_cdev, &ptmx_fops);
            register_chrdev_region(MKDEV(TTYAUX_MAJOR, 2), 1, "/dev/ptmx") < 0)
                panic("Couldn't register /dev/ptmx driver\n");
        devfs_mk_cdev(MKDEV(TTYAUX_MAJOR, 2), S_IFCHR|S_IRUGO|S_IWUGO, "ptmx");
-       class_device_create(tty_class, MKDEV(TTYAUX_MAJOR, 2), NULL, "ptmx");
+       class_device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 2), NULL, "ptmx");
 #endif
 
 #ifdef CONFIG_VT
            register_chrdev_region(MKDEV(TTY_MAJOR, 0), 1, "/dev/vc/0") < 0)
                panic("Couldn't register /dev/tty0 driver\n");
        devfs_mk_cdev(MKDEV(TTY_MAJOR, 0), S_IFCHR|S_IRUSR|S_IWUSR, "vc/0");
-       class_device_create(tty_class, MKDEV(TTY_MAJOR, 0), NULL, "tty0");
+       class_device_create(tty_class, NULL, MKDEV(TTY_MAJOR, 0), NULL, "tty0");
 
        vty_init();
 #endif
 
        devfs_mk_cdev(MKDEV(VCS_MAJOR, tty->index + 129),
                        S_IFCHR|S_IRUSR|S_IWUSR,
                        "vcc/a%u", tty->index + 1);
-       class_device_create(vc_class, MKDEV(VCS_MAJOR, tty->index + 1), NULL, "vcs%u", tty->index + 1);
-       class_device_create(vc_class, MKDEV(VCS_MAJOR, tty->index + 129), NULL, "vcsa%u", tty->index + 1);
+       class_device_create(vc_class, NULL, MKDEV(VCS_MAJOR, tty->index + 1),
+                       NULL, "vcs%u", tty->index + 1);
+       class_device_create(vc_class, NULL, MKDEV(VCS_MAJOR, tty->index + 129),
+                       NULL, "vcsa%u", tty->index + 1);
 }
 void vcs_remove_devfs(struct tty_struct *tty)
 {
 
        devfs_mk_cdev(MKDEV(VCS_MAJOR, 0), S_IFCHR|S_IRUSR|S_IWUSR, "vcc/0");
        devfs_mk_cdev(MKDEV(VCS_MAJOR, 128), S_IFCHR|S_IRUSR|S_IWUSR, "vcc/a0");
-       class_device_create(vc_class, MKDEV(VCS_MAJOR, 0), NULL, "vcs");
-       class_device_create(vc_class, MKDEV(VCS_MAJOR, 128), NULL, "vcsa");
+       class_device_create(vc_class, NULL, MKDEV(VCS_MAJOR, 0), NULL, "vcs");
+       class_device_create(vc_class, NULL, MKDEV(VCS_MAJOR, 128), NULL, "vcsa");
        return 0;
 }
 
        state[i].cur_part = 0;
        for (j = 0; j < MAX_PARTITIONS; ++j)
                state[i].part_stat_rwi[j] = VIOT_IDLE;
-       class_device_create(tape_class, MKDEV(VIOTAPE_MAJOR, i), NULL,
+       class_device_create(tape_class, NULL, MKDEV(VIOTAPE_MAJOR, i), NULL,
                        "iseries!vt%d", i);
-       class_device_create(tape_class, MKDEV(VIOTAPE_MAJOR, i | 0x80),
+       class_device_create(tape_class, NULL, MKDEV(VIOTAPE_MAJOR, i | 0x80),
                        NULL, "iseries!nvt%d", i);
        devfs_mk_cdev(MKDEV(VIOTAPE_MAJOR, i), S_IFCHR | S_IRUSR | S_IWUSR,
                        "iseries/vt%d", i);
 
                return ERR_PTR(-ENOMEM);
 
        id = id & MAX_ID_MASK;
-       cdev = class_device_create(hwmon_class, MKDEV(0,0), dev,
+       cdev = class_device_create(hwmon_class, NULL, MKDEV(0,0), dev,
                                        HWMON_ID_FORMAT, id);
 
        if (IS_ERR(cdev))
 
 
        idetape_setup(drive, tape, minor);
 
-       class_device_create(idetape_sysfs_class,
+       class_device_create(idetape_sysfs_class, NULL,
                        MKDEV(IDETAPE_MAJOR, minor), dev, "%s", tape->name);
-       class_device_create(idetape_sysfs_class,
+       class_device_create(idetape_sysfs_class, NULL,
                        MKDEV(IDETAPE_MAJOR, minor + 128), dev, "n%s", tape->name);
 
        devfs_mk_cdev(MKDEV(HWIF(drive)->major, minor),
 
 
        ohci = (struct ti_ohci *)host->hostdata;
 
-       class_device_create(hpsb_protocol_class, MKDEV(
+       class_device_create(hpsb_protocol_class, NULL, MKDEV(
                IEEE1394_MAJOR, IEEE1394_MINOR_BLOCK_DV1394 * 16 + (id<<2)), 
                NULL, "dv1394-%d", id);
        devfs_mk_dir("ieee1394/dv/host%d", id);
 
 
        hpsb_register_highlevel(&raw1394_highlevel);
 
-       if (IS_ERR(class_device_create(hpsb_protocol_class, MKDEV(
+       if (IS_ERR(class_device_create(hpsb_protocol_class, NULL, MKDEV(
                IEEE1394_MAJOR, IEEE1394_MINOR_BLOCK_RAW1394 * 16), 
                NULL, RAW1394_DEVICE_NAME))) {
                ret = -EFAULT;
 
        hpsb_set_hostinfo_key(&video1394_highlevel, host, ohci->host->id);
 
        minor = IEEE1394_MINOR_BLOCK_VIDEO1394 * 16 + ohci->host->id;
-       class_device_create(hpsb_protocol_class, MKDEV(
+       class_device_create(hpsb_protocol_class, NULL, MKDEV(
                IEEE1394_MAJOR, minor), 
                NULL, "%s-%d", VIDEO1394_DRIVER_NAME, ohci->host->id);
        devfs_mk_cdev(MKDEV(IEEE1394_MAJOR, minor),
 
                goto err_class;
        }
 
-       class_device_create(ib_ucm_class, IB_UCM_DEV, NULL, "ucm");
+       class_device_create(ib_ucm_class, NULL, IB_UCM_DEV, NULL, "ucm");
 
        idr_init(&ctx_id_table);
        init_MUTEX(&ctx_id_mutex);
 
 
        devfs_mk_cdev(MKDEV(INPUT_MAJOR, EVDEV_MINOR_BASE + minor),
                        S_IFCHR|S_IRUGO|S_IWUSR, "input/event%d", minor);
-       class_device_create(input_class,
+       class_device_create(input_class, NULL,
                        MKDEV(INPUT_MAJOR, EVDEV_MINOR_BASE + minor),
                        dev->dev, "event%d", minor);
 
 
 
        devfs_mk_cdev(MKDEV(INPUT_MAJOR, JOYDEV_MINOR_BASE + minor),
                        S_IFCHR|S_IRUGO|S_IWUSR, "input/js%d", minor);
-       class_device_create(input_class,
+       class_device_create(input_class, NULL,
                        MKDEV(INPUT_MAJOR, JOYDEV_MINOR_BASE + minor),
                        dev->dev, "js%d", minor);
 
 
 
        devfs_mk_cdev(MKDEV(INPUT_MAJOR, MOUSEDEV_MINOR_BASE + minor),
                        S_IFCHR|S_IRUGO|S_IWUSR, "input/mouse%d", minor);
-       class_device_create(input_class,
+       class_device_create(input_class, NULL,
                        MKDEV(INPUT_MAJOR, MOUSEDEV_MINOR_BASE + minor),
                        dev->dev, "mouse%d", minor);
 
 
        devfs_mk_cdev(MKDEV(INPUT_MAJOR, MOUSEDEV_MINOR_BASE + MOUSEDEV_MIX),
                        S_IFCHR|S_IRUGO|S_IWUSR, "input/mice");
-       class_device_create(input_class,
+       class_device_create(input_class, NULL,
                        MKDEV(INPUT_MAJOR, MOUSEDEV_MINOR_BASE + MOUSEDEV_MIX), NULL, "mice");
 
 #ifdef CONFIG_INPUT_MOUSEDEV_PSAUX
 
                        S_IFCHR|S_IRUGO|S_IWUSR, "input/ts%d", minor);
        devfs_mk_cdev(MKDEV(INPUT_MAJOR, TSDEV_MINOR_BASE + minor + TSDEV_MINORS/2),
                        S_IFCHR|S_IRUGO|S_IWUSR, "input/tsraw%d", minor);
-       class_device_create(input_class,
+       class_device_create(input_class, NULL,
                        MKDEV(INPUT_MAJOR, TSDEV_MINOR_BASE + minor),
                        dev->dev, "ts%d", minor);
 
 
                return PTR_ERR(capi_class);
        }
 
-       class_device_create(capi_class, MKDEV(capi_major, 0), NULL, "capi");
+       class_device_create(capi_class, NULL, MKDEV(capi_major, 0), NULL, "capi");
        devfs_mk_cdev(MKDEV(capi_major, 0), S_IFCHR | S_IRUSR | S_IWUSR,
                        "isdn/capi20");
 
 
        adb_dev_class = class_create(THIS_MODULE, "adb");
        if (IS_ERR(adb_dev_class))
                return;
-       class_device_create(adb_dev_class, MKDEV(ADB_MAJOR, 0), NULL, "adb");
+       class_device_create(adb_dev_class, NULL, MKDEV(ADB_MAJOR, 0), NULL, "adb");
 }
 
                        S_IFCHR | S_IRUSR | S_IWUSR,
                        "dvb/adapter%d/%s%d", adap->num, dnames[type], id);
 
-       class_device_create(dvb_class, MKDEV(DVB_MAJOR, nums2minor(adap->num, type, id)),
+       class_device_create(dvb_class, NULL, MKDEV(DVB_MAJOR, nums2minor(adap->num, type, id)),
                            NULL, "dvb%d.%s%d", adap->num, dnames[type], id);
 
        dprintk("DVB: register adapter%d/%s%d @ minor: %i (0x%02x)\n",
 
                goto iop_reset;
        }
 
-       c->classdev = class_device_create(i2o_controller_class, 0,
+       c->classdev = class_device_create(i2o_controller_class, NULL, MKDEV(0,0),
                        &c->device, "iop%d", c->unit);
        if (IS_ERR(c->classdev)) {
                osm_err("%s: could not add controller class\n", c->name);
 
        if (!mtd)
                return;
 
-       class_device_create(mtd_class, MKDEV(MTD_CHAR_MAJOR, mtd->index*2),
+       class_device_create(mtd_class, NULL, MKDEV(MTD_CHAR_MAJOR, mtd->index*2),
                            NULL, "mtd%d", mtd->index);
        
-       class_device_create(mtd_class, 
+       class_device_create(mtd_class, NULL,
                            MKDEV(MTD_CHAR_MAJOR, mtd->index*2+1),
                            NULL, "mtd%dro", mtd->index);
 }
 
                        err = PTR_ERR(ppp_class);
                        goto out_chrdev;
                }
-               class_device_create(ppp_class, MKDEV(PPP_MAJOR, 0), NULL, "ppp");
+               class_device_create(ppp_class, NULL, MKDEV(PPP_MAJOR, 0), NULL, "ppp");
                err = devfs_mk_cdev(MKDEV(PPP_MAJOR, 0),
                                S_IFCHR|S_IRUSR|S_IWUSR, "ppp");
                if (err)
 
                goto out_chrdev;
        }
        for (i=0; i<nr_cards; i++) {
-               class_device_create(cosa_class, MKDEV(cosa_major, i),
+               class_device_create(cosa_class, NULL, MKDEV(cosa_major, i),
                                NULL, "cosa%d", i);
                err = devfs_mk_cdev(MKDEV(cosa_major, i),
                                S_IFCHR|S_IRUSR|S_IWUSR,
 
 
        tcd->class_device = class_device_create(
                                tape_class,
+                               NULL,
                                tcd->char_device->dev,
                                device,
                                "%s", tcd->device_name
 
                return ret;
        }
        priv->class_device = class_device_create(
+                               NULL,
                                vmlogrdr_class,
                                MKDEV(vmlogrdr_major, priv->minor_num),
                                dev,
 
        if (init)
                ch_init_elem(ch);
 
-       class_device_create(ch_sysfs_class,
+       class_device_create(ch_sysfs_class, NULL,
                            MKDEV(SCSI_CHANGER_MAJOR,ch->minor),
                            dev, "s%s", ch->name);
 
 
 
        if (!osst_sysfs_valid) return;
 
-       osst_class_member = class_device_create(osst_sysfs_class, dev, device, "%s", name);
+       osst_class_member = class_device_create(osst_sysfs_class, NULL, dev, device, "%s", name);
        if (IS_ERR(osst_class_member)) {
                printk(KERN_WARNING "osst :W: Unable to add sysfs class member %s\n", name);
                return;
 
        if (sg_sysfs_valid) {
                struct class_device * sg_class_member;
 
-               sg_class_member = class_device_create(sg_sysfs_class,
+               sg_class_member = class_device_create(sg_sysfs_class, NULL,
                                MKDEV(SCSI_GENERIC_MAJOR, k), 
                                cl_dev->dev, "%s", 
                                disk->disk_name);
 
                snprintf(name, 10, "%s%s%s", rew ? "n" : "",
                         STp->disk->disk_name, st_formats[i]);
                st_class_member =
-                       class_device_create(st_sysfs_class,
+                       class_device_create(st_sysfs_class, NULL,
                                            MKDEV(SCSI_TAPE_MAJOR,
                                                  TAPE_MINOR(dev_num, mode, rew)),
                                            &STp->device->sdev_gendev, "%s", name);
 
 {
        int minor = ((dev->bus->busnum-1) * 128) + (dev->devnum-1);
 
-       dev->class_dev = class_device_create(usb_device_class,
+       dev->class_dev = class_device_create(usb_device_class, NULL,
                                MKDEV(USB_DEVICE_MAJOR, minor), &dev->dev,
                                "usbdev%d.%d", dev->bus->busnum, dev->devnum);
 
 
                ++temp;
        else
                temp = name;
-       intf->class_dev = class_device_create(usb_class, MKDEV(USB_MAJOR, minor), &intf->dev, "%s", temp);
+       intf->class_dev = class_device_create(usb_class, NULL,
+                                             MKDEV(USB_MAJOR, minor),
+                                             &intf->dev, "%s", temp);
        if (IS_ERR(intf->class_dev)) {
                spin_lock (&minor_lock);
                usb_minors[intf->minor] = NULL;
 
                return -E2BIG;
        }
 
-       bus->class_dev = class_device_create(usb_host_class, MKDEV(0,0), bus->controller, "usb_host%d", busnum);
+       bus->class_dev = class_device_create(usb_host_class, NULL, MKDEV(0,0),
+                                            bus->controller, "usb_host%d", busnum);
        if (IS_ERR(bus->class_dev)) {
                clear_bit(busnum, busmap.busmap);
                up(&usb_bus_list_lock);
 
                        break;
        fb_info->node = i;
 
-       fb_info->class_device = class_device_create(fb_class, MKDEV(FB_MAJOR, i),
+       fb_info->class_device = class_device_create(fb_class, NULL, MKDEV(FB_MAJOR, i),
                                    fb_info->device, "fb%d", i);
        if (IS_ERR(fb_info->class_device)) {
                /* Not fatal */
 
        }               
        devfs_mk_dir ("coda");
        for (i = 0; i < MAX_CODADEVS; i++) {
-               class_device_create(coda_psdev_class, MKDEV(CODA_PSDEV_MAJOR,i),
-                               NULL, "cfs%d", i);
+               class_device_create(coda_psdev_class, NULL,
+                               MKDEV(CODA_PSDEV_MAJOR,i), NULL, "cfs%d", i);
                err = devfs_mk_cdev(MKDEV(CODA_PSDEV_MAJOR, i),
                                S_IFCHR|S_IRUSR|S_IWUSR, "coda/%d", i);
                if (err)
 
                devfs_mk_cdev(MKDEV(major, minor), S_IFCHR | device_mode, "snd/%s", name);
        if (card)
                device = card->dev;
-       class_device_create(sound_class, MKDEV(major, minor), device, "%s", name);
+       class_device_create(sound_class, NULL, MKDEV(major, minor), device, "%s", name);
 
        up(&sound_mutex);
        return 0;
 
                devfs_mk_cdev(MKDEV(SOUND_MAJOR, dev_list[i].minor),
                                S_IFCHR | dev_list[i].mode,
                                "sound/%s", dev_list[i].name);
-               class_device_create(sound_class,
+               class_device_create(sound_class, NULL,
                                    MKDEV(SOUND_MAJOR, dev_list[i].minor),
                                    NULL, "%s", dev_list[i].name);
 
                                                dev_list[i].minor + (j*0x10)),
                                        S_IFCHR | dev_list[i].mode,
                                        "sound/%s%d", dev_list[i].name, j);
-                       class_device_create(sound_class,
+                       class_device_create(sound_class, NULL,
                                            MKDEV(SOUND_MAJOR, dev_list[i].minor + (j*0x10)),
                                            NULL, "%s%d", dev_list[i].name, j);
                }
 
 
        devfs_mk_cdev(MKDEV(SOUND_MAJOR, s->unit_minor),
                        S_IFCHR | mode, s->name);
-       class_device_create(sound_class, MKDEV(SOUND_MAJOR, s->unit_minor),
+       class_device_create(sound_class, NULL, MKDEV(SOUND_MAJOR, s->unit_minor),
                            dev, s->name+6);
        return r;