retval = pci_hp_register(slot->hotplug_slot,
                                        acpiphp_slot->bridge->pci_bus,
-                                       acpiphp_slot->device);
+                                       acpiphp_slot->device,
+                                       slot->name);
        if (retval == -EBUSY)
                goto error_hpslot;
        if (retval) {
 
                info->attention_status = cpci_get_attention_status(slot);
 
                dbg("registering slot %s", slot->hotplug_slot->name);
-               status = pci_hp_register(slot->hotplug_slot, bus, i);
+               status = pci_hp_register(slot->hotplug_slot, bus, i,
+                                        slot->hotplug_slot->name);
                if (status) {
                        err("pci_hp_register failed with error %d", status);
                        goto error_name;
 
                                slot_number);
                result = pci_hp_register(hotplug_slot,
                                         ctrl->pci_dev->bus,
-                                        slot->device);
+                                        slot->device,
+                                        hotplug_slot->name);
                if (result) {
                        err("pci_hp_register failed with error %d\n", result);
                        goto error_name;
 
        slot->release = &dummy_release;
        slot->private = dslot;
 
-       retval = pci_hp_register(slot, dev->bus, PCI_SLOT(dev->devfn));
+       retval = pci_hp_register(slot, dev->bus, PCI_SLOT(dev->devfn),
+                                slot->name);
        if (retval) {
                err("pci_hp_register failed with error %d\n", retval);
                goto error_dslot;
 
 
                snprintf (tmp_slot->hotplug_slot->name, 30, "%s", create_file_name (tmp_slot));
                pci_hp_register(tmp_slot->hotplug_slot,
-                       pci_find_bus(0, tmp_slot->bus), tmp_slot->device);
+                       pci_find_bus(0, tmp_slot->bus), tmp_slot->device,
+                       tmp_slot->hotplug_slot->name);
        }
 
        print_ebda_hpc ();
 
  * @bus: bus this slot is on
  * @slot: pointer to the &struct hotplug_slot to register
  * @slot_nr: slot number
+ * @name: name registered with kobject core
  *
  * Registers a hotplug slot with the pci hotplug subsystem, which will allow
  * userspace interaction to the slot.
  *
  * Returns 0 if successful, anything else for an error.
  */
-int pci_hp_register(struct hotplug_slot *slot, struct pci_bus *bus, int slot_nr)
+int pci_hp_register(struct hotplug_slot *slot, struct pci_bus *bus, int slot_nr,
+                       const char *name)
 {
        int result;
        struct pci_slot *pci_slot;
        }
 
        /* Check if we have already registered a slot with the same name. */
-       if (get_slot_from_name(slot->name))
+       if (get_slot_from_name(name))
                return -EEXIST;
 
        /*
         * driver and call it here again. If we've already created the
         * pci_slot, the interface will simply bump the refcount.
         */
-       pci_slot = pci_create_slot(bus, slot_nr, slot->name);
+       pci_slot = pci_create_slot(bus, slot_nr, name);
        if (IS_ERR(pci_slot))
                return PTR_ERR(pci_slot);
 
        /*
         * Allow pcihp drivers to override the ACPI_PCI_SLOT name.
         */
-       if (strcmp(kobject_name(&pci_slot->kobj), slot->name)) {
-               result = kobject_rename(&pci_slot->kobj, slot->name);
+       if (strcmp(kobject_name(&pci_slot->kobj), name)) {
+               result = kobject_rename(&pci_slot->kobj, name);
                if (result) {
                        pci_destroy_slot(pci_slot);
                        return result;
 
        result = fs_add_slot(pci_slot);
        kobject_uevent(&pci_slot->kobj, KOBJ_ADD);
-       dbg("Added slot %s to the list\n", slot->name);
-
+       dbg("Added slot %s to the list\n", name);
 
        return result;
 }
 
 duplicate_name:
                retval = pci_hp_register(hotplug_slot,
                                         ctrl->pci_dev->subordinate,
-                                        slot->device);
+                                        slot->device,
+                                        slot->name);
                if (retval) {
                        /*
                         * If slot N already exists, we'll try to create
 
                slotno = PCI_SLOT(PCI_DN(slot->dn->child)->devfn);
        else
                slotno = -1;
-       retval = pci_hp_register(php_slot, slot->bus, slotno);
+       retval = pci_hp_register(php_slot, slot->bus, slotno, slot->name);
        if (retval) {
                err("pci_hp_register failed with error %d\n", retval);
                return retval;
 
                bss_hotplug_slot->ops = &sn_hotplug_slot_ops;
                bss_hotplug_slot->release = &sn_release_slot;
 
-               rc = pci_hp_register(bss_hotplug_slot, pci_bus, device);
+               rc = pci_hp_register(bss_hotplug_slot, pci_bus, device,
+                                    bss_hotplug_slot->name);
                if (rc)
                        goto register_err;
 
 
                    slot->hp_slot, slot->number, ctrl->slot_device_offset);
 duplicate_name:
                retval = pci_hp_register(slot->hotplug_slot,
-                               ctrl->pci_dev->subordinate, slot->device);
+                               ctrl->pci_dev->subordinate, slot->device,
+                               hotplug_slot->name);
                if (retval) {
                        /*
                         * If slot N already exists, we'll try to create
 
 };
 #define to_hotplug_slot(n) container_of(n, struct hotplug_slot, kobj)
 
-extern int pci_hp_register(struct hotplug_slot *, struct pci_bus *, int nr);
+extern int pci_hp_register(struct hotplug_slot *, struct pci_bus *, int nr,
+                          const char *name);
 extern int pci_hp_deregister(struct hotplug_slot *slot);
 extern int __must_check pci_hp_change_slot_info        (struct hotplug_slot *slot,
                                                 struct hotplug_slot_info *info);