extern int event_is_open;
 
-int acpi_bus_generate_proc_event(struct acpi_device *device, u8 type, int data)
+int acpi_bus_generate_proc_event4(const char *device_class, const char *bus_id, u8 type, int data)
 {
-       struct acpi_bus_event *event = NULL;
+       struct acpi_bus_event *event;
        unsigned long flags = 0;
 
-
-       if (!device)
-               return -EINVAL;
-
        /* drop event on the floor if no one's listening */
        if (!event_is_open)
                return 0;
        if (!event)
                return -ENOMEM;
 
-       strcpy(event->device_class, device->pnp.device_class);
-       strcpy(event->bus_id, device->pnp.bus_id);
+       strcpy(event->device_class, device_class);
+       strcpy(event->bus_id, bus_id);
        event->type = type;
        event->data = data;
 
        wake_up_interruptible(&acpi_bus_event_queue);
 
        return 0;
+
+}
+
+EXPORT_SYMBOL_GPL(acpi_bus_generate_proc_event4);
+
+int acpi_bus_generate_proc_event(struct acpi_device *device, u8 type, int data)
+{
+       if (!device)
+               return -EINVAL;
+       return acpi_bus_generate_proc_event4(device->pnp.device_class,
+                                            device->pnp.bus_id, type, data);
 }
 
 EXPORT_SYMBOL(acpi_bus_generate_proc_event);
 
        return 0;
 }
 
-static int acpi_sbs_generate_event(struct acpi_device *device,
-                                  int event, int state, char *bid, char *class)
-{
-       char bid_saved[5];
-       char class_saved[20];
-       int result = 0;
-
-       strcpy(bid_saved, acpi_device_bid(device));
-       strcpy(class_saved, acpi_device_class(device));
-
-       strcpy(acpi_device_bid(device), bid);
-       strcpy(acpi_device_class(device), class);
-
-       result = acpi_bus_generate_proc_event(device, event, state);
-
-       strcpy(acpi_device_bid(device), bid_saved);
-       strcpy(acpi_device_class(device), class_saved);
-
-       acpi_bus_generate_netlink_event(class, bid, event, state);
-       return result;
-}
-
 static int acpi_battery_get_present(struct acpi_battery *battery)
 {
        s16 state;
        }
 
        if (do_ac_init) {
-               result = acpi_sbs_generate_event(sbs->device,
-                                                ACPI_SBS_AC_NOTIFY_STATUS,
-                                                new_ac_present,
+               result = acpi_bus_generate_proc_event4(ACPI_AC_CLASS,
                                                 ACPI_AC_DIR_NAME,
-                                                ACPI_AC_CLASS);
+                                                ACPI_SBS_AC_NOTIFY_STATUS,
+                                                new_ac_present);
                if (result) {
                        ACPI_EXCEPTION((AE_INFO, AE_ERROR,
-                                       "acpi_sbs_generate_event() failed"));
+                                       "acpi_bus_generate_event4() failed"));
                }
+               acpi_bus_generate_netlink_event(ACPI_AC_CLASS, ACPI_AC_DIR_NAME,
+                                               ACPI_SBS_AC_NOTIFY_STATUS,
+                                               new_ac_present);
        }
 
        if (data_type == DATA_TYPE_COMMON) {
                    old_remaining_capacity !=
                    battery->state.remaining_capacity) {
                        sprintf(dir_name, ACPI_BATTERY_DIR_NAME, id);
-                       result = acpi_sbs_generate_event(sbs->device,
-                                                        ACPI_SBS_BATTERY_NOTIFY_STATUS,
-                                                        new_battery_present,
+                       result = acpi_bus_generate_proc_event4(ACPI_BATTERY_CLASS,
                                                         dir_name,
-                                                        ACPI_BATTERY_CLASS);
+                                                        ACPI_SBS_BATTERY_NOTIFY_STATUS,
+                                                        new_battery_present);
+                       acpi_bus_generate_netlink_event(ACPI_BATTERY_CLASS, dir_name,
+                                                       ACPI_SBS_BATTERY_NOTIFY_STATUS,
+                                                       new_battery_present);
                        if (result) {
                                ACPI_EXCEPTION((AE_INFO, AE_ERROR,
-                                               "acpi_sbs_generate_event() "
+                                               "acpi_bus_generate_proc_event4() "
                                                "failed"));
                        }
                }
 
 int acpi_bus_set_power(acpi_handle handle, int state);
 #ifdef CONFIG_ACPI_PROC_EVENT
 int acpi_bus_generate_proc_event(struct acpi_device *device, u8 type, int data);
+int acpi_bus_generate_proc_event4(const char *class, const char *bid, u8 type, int data);
 int acpi_bus_receive_event(struct acpi_bus_event *event);
 #else
 static inline int acpi_bus_generate_proc_event(struct acpi_device *device, u8 type, int data)