ACPI: Battery: Misc clean-ups, no functional changes
Alexey Starikovskiy [Wed, 26 Sep 2007 15:42:58 +0000 (19:42 +0400)]
Signed-off-by: Alexey Starikovskiy <astarikovskiy@suse.de>
Signed-off-by: Len Brown <len.brown@intel.com>

drivers/acpi/battery.c

index faa70a5..db725bf 100644 (file)
@@ -1,6 +1,8 @@
 /*
- *  acpi_battery.c - ACPI Battery Driver ($Revision: 37 $)
+ *  battery.c - ACPI Battery Driver (Revision: 2.0)
  *
+ *  Copyright (C) 2007 Alexey Starikovskiy <astarikovskiy@suse.de>
+ *  Copyright (C) 2004-2007 Vladimir Lebedev <vladimir.p.lebedev@intel.com>
  *  Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
  *  Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
  *
@@ -48,6 +50,7 @@
 ACPI_MODULE_NAME("battery");
 
 MODULE_AUTHOR("Paul Diefenbaugh");
+MODULE_AUTHOR("Alexey Starikovskiy <astarikovskiy@suse.de>");
 MODULE_DESCRIPTION("ACPI Battery Driver");
 MODULE_LICENSE("GPL");
 
@@ -58,31 +61,17 @@ MODULE_PARM_DESC(cache_time, "cache time in milliseconds");
 extern struct proc_dir_entry *acpi_lock_battery_dir(void);
 extern void *acpi_unlock_battery_dir(struct proc_dir_entry *acpi_battery_dir);
 
-static int acpi_battery_add(struct acpi_device *device);
-static int acpi_battery_remove(struct acpi_device *device, int type);
-static int acpi_battery_resume(struct acpi_device *device);
-
 static const struct acpi_device_id battery_device_ids[] = {
        {"PNP0C0A", 0},
        {"", 0},
 };
-MODULE_DEVICE_TABLE(acpi, battery_device_ids);
 
-static struct acpi_driver acpi_battery_driver = {
-       .name = "battery",
-       .class = ACPI_BATTERY_CLASS,
-       .ids = battery_device_ids,
-       .ops = {
-               .add = acpi_battery_add,
-               .resume = acpi_battery_resume,
-               .remove = acpi_battery_remove,
-               },
-};
+MODULE_DEVICE_TABLE(acpi, battery_device_ids);
 
 enum acpi_battery_files {
-       ACPI_BATTERY_INFO = 0,
-       ACPI_BATTERY_STATE,
-       ACPI_BATTERY_ALARM,
+       info_tag = 0,
+       state_tag,
+       alarm_tag,
        ACPI_BATTERY_NUMFILES,
 };
 
@@ -124,7 +113,6 @@ inline char *acpi_battery_units(struct acpi_battery *battery)
 /* --------------------------------------------------------------------------
                                Battery Management
    -------------------------------------------------------------------------- */
-
 struct acpi_offsets {
        size_t offset;          /* offset inside struct acpi_sbs_battery */
        u8 mode;                /* int or string? */
@@ -183,19 +171,16 @@ static int extract_package(struct acpi_battery *battery,
 
 static int acpi_battery_get_status(struct acpi_battery *battery)
 {
-       int result = 0;
-
-       result = acpi_bus_get_status(battery->device);
-       if (result) {
+       if (acpi_bus_get_status(battery->device)) {
                ACPI_EXCEPTION((AE_INFO, AE_ERROR, "Evaluating _STA"));
                return -ENODEV;
        }
-       return result;
+       return 0;
 }
 
 static int acpi_battery_get_info(struct acpi_battery *battery)
 {
-       int result = 0;
+       int result = -EFAULT;
        acpi_status status = 0;
        struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
 
@@ -205,10 +190,12 @@ static int acpi_battery_get_info(struct acpi_battery *battery)
        status = acpi_evaluate_object(battery->device->handle, "_BIF",
                                      NULL, &buffer);
        mutex_unlock(&battery->lock);
+
        if (ACPI_FAILURE(status)) {
                ACPI_EXCEPTION((AE_INFO, status, "Evaluating _BIF"));
                return -ENODEV;
        }
+
        result = extract_package(battery, buffer.pointer,
                                 info_offsets, ARRAY_SIZE(info_offsets));
        kfree(buffer.pointer);
@@ -238,6 +225,7 @@ static int acpi_battery_get_state(struct acpi_battery *battery)
                ACPI_EXCEPTION((AE_INFO, status, "Evaluating _BST"));
                return -ENODEV;
        }
+
        result = extract_package(battery, buffer.pointer,
                                 state_offsets, ARRAY_SIZE(state_offsets));
        battery->update_time = jiffies;
@@ -245,37 +233,26 @@ static int acpi_battery_get_state(struct acpi_battery *battery)
        return result;
 }
 
-static int acpi_battery_get_alarm(struct acpi_battery *battery)
-{
-       return 0;
-}
-
-static int acpi_battery_set_alarm(struct acpi_battery *battery,
-                                 unsigned long alarm)
+static int acpi_battery_set_alarm(struct acpi_battery *battery)
 {
        acpi_status status = 0;
-       union acpi_object arg0 = { ACPI_TYPE_INTEGER };
+       union acpi_object arg0 = { .type = ACPI_TYPE_INTEGER };
        struct acpi_object_list arg_list = { 1, &arg0 };
 
-       if (!acpi_battery_present(battery))
-               return -ENODEV;
-
-       if (!battery->alarm_present)
+       if (!acpi_battery_present(battery)|| !battery->alarm_present)
                return -ENODEV;
 
-       arg0.integer.value = alarm;
+       arg0.integer.value = battery->alarm;
 
        mutex_lock(&battery->lock);
        status = acpi_evaluate_object(battery->device->handle, "_BTP",
                                 &arg_list, NULL);
        mutex_unlock(&battery->lock);
+
        if (ACPI_FAILURE(status))
                return -ENODEV;
 
-       ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Alarm set to %d\n", (u32) alarm));
-
-       battery->alarm = alarm;
-
+       ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Alarm set to %d\n", battery->alarm));
        return 0;
 }
 
@@ -293,7 +270,7 @@ static int acpi_battery_init_alarm(struct acpi_battery *battery)
        battery->alarm_present = 1;
        if (!battery->alarm)
                battery->alarm = battery->design_capacity_warning;
-       return acpi_battery_set_alarm(battery, battery->alarm);
+       return acpi_battery_set_alarm(battery);
 }
 
 static int acpi_battery_update(struct acpi_battery *battery)
@@ -322,130 +299,101 @@ static struct proc_dir_entry *acpi_battery_dir;
 static int acpi_battery_print_info(struct seq_file *seq, int result)
 {
        struct acpi_battery *battery = seq->private;
-       char *units = "?";
 
        if (result)
                goto end;
 
-       if (acpi_battery_present(battery))
-               seq_printf(seq, "present:                 yes\n");
-       else {
-               seq_printf(seq, "present:                 no\n");
+       seq_printf(seq, "present:                 %s\n",
+                  acpi_battery_present(battery)?"yes":"no");
+       if (!acpi_battery_present(battery))
                goto end;
-       }
-
-       /* Battery Units */
-
-       units = acpi_battery_units(battery);
-
        if (battery->design_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
                seq_printf(seq, "design capacity:         unknown\n");
        else
                seq_printf(seq, "design capacity:         %d %sh\n",
-                          (u32) battery->design_capacity, units);
+                          battery->design_capacity,
+                          acpi_battery_units(battery));
 
        if (battery->last_full_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
                seq_printf(seq, "last full capacity:      unknown\n");
        else
                seq_printf(seq, "last full capacity:      %d %sh\n",
-                          (u32) battery->last_full_capacity, units);
-
-       switch ((u32) battery->technology) {
-       case 0:
-               seq_printf(seq, "battery technology:      non-rechargeable\n");
-               break;
-       case 1:
-               seq_printf(seq, "battery technology:      rechargeable\n");
-               break;
-       default:
-               seq_printf(seq, "battery technology:      unknown\n");
-               break;
-       }
+                          battery->last_full_capacity,
+                          acpi_battery_units(battery));
+
+       seq_printf(seq, "battery technology:      %srechargeable\n",
+                  (!battery->technology)?"non-":"");
 
        if (battery->design_voltage == ACPI_BATTERY_VALUE_UNKNOWN)
                seq_printf(seq, "design voltage:          unknown\n");
        else
                seq_printf(seq, "design voltage:          %d mV\n",
-                          (u32) battery->design_voltage);
+                          battery->design_voltage);
        seq_printf(seq, "design capacity warning: %d %sh\n",
-                  (u32) battery->design_capacity_warning, units);
+                  battery->design_capacity_warning,
+                  acpi_battery_units(battery));
        seq_printf(seq, "design capacity low:     %d %sh\n",
-                  (u32) battery->design_capacity_low, units);
+                  battery->design_capacity_low,
+                  acpi_battery_units(battery));
        seq_printf(seq, "capacity granularity 1:  %d %sh\n",
-                  (u32) battery->capacity_granularity_1, units);
+                  battery->capacity_granularity_1,
+                  acpi_battery_units(battery));
        seq_printf(seq, "capacity granularity 2:  %d %sh\n",
-                  (u32) battery->capacity_granularity_2, units);
+                  battery->capacity_granularity_2,
+                  acpi_battery_units(battery));
        seq_printf(seq, "model number:            %s\n", battery->model_number);
        seq_printf(seq, "serial number:           %s\n", battery->serial_number);
        seq_printf(seq, "battery type:            %s\n", battery->type);
        seq_printf(seq, "OEM info:                %s\n", battery->oem_info);
-
       end:
-
        if (result)
                seq_printf(seq, "ERROR: Unable to read battery info\n");
-
        return result;
 }
 
 static int acpi_battery_print_state(struct seq_file *seq, int result)
 {
        struct acpi_battery *battery = seq->private;
-       char *units = "?";
 
        if (result)
                goto end;
 
-       if (acpi_battery_present(battery))
-               seq_printf(seq, "present:                 yes\n");
-       else {
-               seq_printf(seq, "present:                 no\n");
+       seq_printf(seq, "present:                 %s\n",
+                  acpi_battery_present(battery)?"yes":"no");
+       if (!acpi_battery_present(battery))
                goto end;
-       }
-
-       /* Battery Units */
-
-       units = acpi_battery_units(battery);
 
-       if (!(battery->state & 0x04))
-               seq_printf(seq, "capacity state:          ok\n");
-       else
-               seq_printf(seq, "capacity state:          critical\n");
-
-       if ((battery->state & 0x01) && (battery->state & 0x02)) {
+       seq_printf(seq, "capacity state:          %s\n",
+                       (battery->state & 0x04)?"critical":"ok");
+       if ((battery->state & 0x01) && (battery->state & 0x02))
                seq_printf(seq,
                           "charging state:          charging/discharging\n");
-       } else if (battery->state & 0x01)
+       else if (battery->state & 0x01)
                seq_printf(seq, "charging state:          discharging\n");
        else if (battery->state & 0x02)
                seq_printf(seq, "charging state:          charging\n");
-       else {
+       else
                seq_printf(seq, "charging state:          charged\n");
-       }
 
        if (battery->present_rate == ACPI_BATTERY_VALUE_UNKNOWN)
                seq_printf(seq, "present rate:            unknown\n");
        else
                seq_printf(seq, "present rate:            %d %s\n",
-                          (u32) battery->present_rate, units);
+                          battery->present_rate, acpi_battery_units(battery));
 
        if (battery->remaining_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
                seq_printf(seq, "remaining capacity:      unknown\n");
        else
                seq_printf(seq, "remaining capacity:      %d %sh\n",
-                          (u32) battery->remaining_capacity, units);
-
+                          battery->remaining_capacity, acpi_battery_units(battery));
        if (battery->present_voltage == ACPI_BATTERY_VALUE_UNKNOWN)
                seq_printf(seq, "present voltage:         unknown\n");
        else
                seq_printf(seq, "present voltage:         %d mV\n",
-                          (u32) battery->present_voltage);
-
+                          battery->present_voltage);
       end:
-
-       if (result) {
+       if (result)
                seq_printf(seq, "ERROR: Unable to read battery state\n");
-       }
 
        return result;
 }
@@ -453,7 +401,6 @@ static int acpi_battery_print_state(struct seq_file *seq, int result)
 static int acpi_battery_print_alarm(struct seq_file *seq, int result)
 {
        struct acpi_battery *battery = seq->private;
-       char *units = "?";
 
        if (result)
                goto end;
@@ -462,22 +409,15 @@ static int acpi_battery_print_alarm(struct seq_file *seq, int result)
                seq_printf(seq, "present:                 no\n");
                goto end;
        }
-
-       /* Battery Units */
-
-       units = acpi_battery_units(battery);
-
        seq_printf(seq, "alarm:                   ");
        if (!battery->alarm)
                seq_printf(seq, "unsupported\n");
        else
-               seq_printf(seq, "%u %sh\n", battery->alarm, units);
-
+               seq_printf(seq, "%u %sh\n", battery->alarm,
+                               acpi_battery_units(battery));
       end:
-
        if (result)
                seq_printf(seq, "ERROR: Unable to read battery alarm\n");
-
        return result;
 }
 
@@ -506,7 +446,7 @@ static ssize_t acpi_battery_write_alarm(struct file *file,
        }
        alarm_string[count] = '\0';
        battery->alarm = simple_strtol(alarm_string, NULL, 0);
-       result = acpi_battery_set_alarm(battery, battery->alarm);
+       result = acpi_battery_set_alarm(battery);
       end:
        if (!result)
                return count;
@@ -514,95 +454,76 @@ static ssize_t acpi_battery_write_alarm(struct file *file,
 }
 
 typedef int(*print_func)(struct seq_file *seq, int result);
-typedef int(*get_func)(struct acpi_battery *battery);
-
-static struct acpi_read_mux {
-       print_func print;
-       get_func get;
-} acpi_read_funcs[ACPI_BATTERY_NUMFILES] = {
-       {.get = acpi_battery_get_info, .print = acpi_battery_print_info},
-       {.get = acpi_battery_get_state, .print = acpi_battery_print_state},
-       {.get = acpi_battery_get_alarm, .print = acpi_battery_print_alarm},
+
+static print_func acpi_print_funcs[ACPI_BATTERY_NUMFILES] = {
+       acpi_battery_print_info,
+       acpi_battery_print_state,
+       acpi_battery_print_alarm,
 };
 
 static int acpi_battery_read(int fid, struct seq_file *seq)
 {
        struct acpi_battery *battery = seq->private;
        int result = acpi_battery_update(battery);
-       return acpi_read_funcs[fid].print(seq, result);
-}
-
-static int acpi_battery_read_info(struct seq_file *seq, void *offset)
-{
-       return acpi_battery_read(ACPI_BATTERY_INFO, seq);
-}
-
-static int acpi_battery_read_state(struct seq_file *seq, void *offset)
-{
-       return acpi_battery_read(ACPI_BATTERY_STATE, seq);
-}
-
-static int acpi_battery_read_alarm(struct seq_file *seq, void *offset)
-{
-       return acpi_battery_read(ACPI_BATTERY_ALARM, seq);
+       return acpi_print_funcs[fid](seq, result);
 }
 
-static int acpi_battery_info_open_fs(struct inode *inode, struct file *file)
-{
-       return single_open(file, acpi_battery_read_info, PDE(inode)->data);
+#define DECLARE_FILE_FUNCTIONS(_name) \
+static int acpi_battery_read_##_name(struct seq_file *seq, void *offset) \
+{ \
+       return acpi_battery_read(_name##_tag, seq); \
+} \
+static int acpi_battery_##_name##_open_fs(struct inode *inode, struct file *file) \
+{ \
+       return single_open(file, acpi_battery_read_##_name, PDE(inode)->data); \
 }
 
-static int acpi_battery_state_open_fs(struct inode *inode, struct file *file)
-{
-       return single_open(file, acpi_battery_read_state, PDE(inode)->data);
-}
+DECLARE_FILE_FUNCTIONS(info);
+DECLARE_FILE_FUNCTIONS(state);
+DECLARE_FILE_FUNCTIONS(alarm);
+
+#undef DECLARE_FILE_FUNCTIONS
+
+#define FILE_DESCRIPTION_RO(_name) \
+       { \
+       .name = __stringify(_name), \
+       .mode = S_IRUGO, \
+       .ops = { \
+               .open = acpi_battery_##_name##_open_fs, \
+               .read = seq_read, \
+               .llseek = seq_lseek, \
+               .release = single_release, \
+               .owner = THIS_MODULE, \
+               }, \
+       }
 
-static int acpi_battery_alarm_open_fs(struct inode *inode, struct file *file)
-{
-       return single_open(file, acpi_battery_read_alarm, PDE(inode)->data);
-}
+#define FILE_DESCRIPTION_RW(_name) \
+       { \
+       .name = __stringify(_name), \
+       .mode = S_IFREG | S_IRUGO | S_IWUSR, \
+       .ops = { \
+               .open = acpi_battery_##_name##_open_fs, \
+               .read = seq_read, \
+               .llseek = seq_lseek, \
+               .write = acpi_battery_write_##_name, \
+               .release = single_release, \
+               .owner = THIS_MODULE, \
+               }, \
+       }
 
 static struct battery_file {
        struct file_operations ops;
        mode_t mode;
        char *name;
 } acpi_battery_file[] = {
-       {
-       .name = "info",
-       .mode = S_IRUGO,
-       .ops = {
-       .open = acpi_battery_info_open_fs,
-       .read = seq_read,
-       .llseek = seq_lseek,
-       .release = single_release,
-       .owner = THIS_MODULE,
-       },
-       },
-       {
-       .name = "state",
-       .mode = S_IRUGO,
-       .ops = {
-       .open = acpi_battery_state_open_fs,
-       .read = seq_read,
-       .llseek = seq_lseek,
-       .release = single_release,
-       .owner = THIS_MODULE,
-       },
-       },
-       {
-       .name = "alarm",
-       .mode = S_IFREG | S_IRUGO | S_IWUSR,
-       .ops = {
-       .open = acpi_battery_alarm_open_fs,
-       .read = seq_read,
-       .write = acpi_battery_write_alarm,
-       .llseek = seq_lseek,
-       .release = single_release,
-       .owner = THIS_MODULE,
-       },
-       },
+       FILE_DESCRIPTION_RO(info),
+       FILE_DESCRIPTION_RO(state),
+       FILE_DESCRIPTION_RW(alarm),
 };
 
+#undef FILE_DESCRIPTION_RO
+#undef FILE_DESCRIPTION_RW
+
 static int acpi_battery_add_fs(struct acpi_device *device)
 {
        struct proc_dir_entry *entry = NULL;
@@ -627,23 +548,20 @@ static int acpi_battery_add_fs(struct acpi_device *device)
                        entry->owner = THIS_MODULE;
                }
        }
-
        return 0;
 }
 
-static int acpi_battery_remove_fs(struct acpi_device *device)
+static void acpi_battery_remove_fs(struct acpi_device *device)
 {
        int i;
-       if (acpi_device_dir(device)) {
-               for (i = 0; i < ACPI_BATTERY_NUMFILES; ++i) {
-                       remove_proc_entry(acpi_battery_file[i].name,
+       if (!acpi_device_dir(device))
+               return;
+       for (i = 0; i < ACPI_BATTERY_NUMFILES; ++i)
+               remove_proc_entry(acpi_battery_file[i].name,
                                  acpi_device_dir(device));
-               }
-               remove_proc_entry(acpi_device_bid(device), acpi_battery_dir);
-               acpi_device_dir(device) = NULL;
-       }
 
-       return 0;
+       remove_proc_entry(acpi_device_bid(device), acpi_battery_dir);
+       acpi_device_dir(device) = NULL;
 }
 
 /* --------------------------------------------------------------------------
@@ -670,14 +588,11 @@ static int acpi_battery_add(struct acpi_device *device)
        int result = 0;
        acpi_status status = 0;
        struct acpi_battery *battery = NULL;
-
        if (!device)
                return -EINVAL;
-
        battery = kzalloc(sizeof(struct acpi_battery), GFP_KERNEL);
        if (!battery)
                return -ENOMEM;
-
        battery->device = device;
        strcpy(acpi_device_name(device), ACPI_BATTERY_DEVICE_NAME);
        strcpy(acpi_device_class(device), ACPI_BATTERY_CLASS);
@@ -687,7 +602,6 @@ static int acpi_battery_add(struct acpi_device *device)
        result = acpi_battery_add_fs(device);
        if (result)
                goto end;
-
        status = acpi_install_notify_handler(device->handle,
                                             ACPI_ALL_NOTIFY,
                                             acpi_battery_notify, battery);
@@ -696,18 +610,14 @@ static int acpi_battery_add(struct acpi_device *device)
                result = -ENODEV;
                goto end;
        }
-
        printk(KERN_INFO PREFIX "%s Slot [%s] (battery %s)\n",
               ACPI_BATTERY_DEVICE_NAME, acpi_device_bid(device),
               device->status.battery_present ? "present" : "absent");
-
       end:
-
        if (result) {
                acpi_battery_remove_fs(device);
                kfree(battery);
        }
-
        return result;
 }
 
@@ -718,17 +628,13 @@ static int acpi_battery_remove(struct acpi_device *device, int type)
 
        if (!device || !acpi_driver_data(device))
                return -EINVAL;
-
        battery = acpi_driver_data(device);
-
        status = acpi_remove_notify_handler(device->handle,
                                            ACPI_ALL_NOTIFY,
                                            acpi_battery_notify);
-
        acpi_battery_remove_fs(device);
        mutex_destroy(&battery->lock);
        kfree(battery);
-
        return 0;
 }
 
@@ -743,33 +649,35 @@ static int acpi_battery_resume(struct acpi_device *device)
        return 0;
 }
 
+static struct acpi_driver acpi_battery_driver = {
+       .name = "battery",
+       .class = ACPI_BATTERY_CLASS,
+       .ids = battery_device_ids,
+       .ops = {
+               .add = acpi_battery_add,
+               .resume = acpi_battery_resume,
+               .remove = acpi_battery_remove,
+               },
+};
+
 static int __init acpi_battery_init(void)
 {
-       int result;
-
        if (acpi_disabled)
                return -ENODEV;
-
        acpi_battery_dir = acpi_lock_battery_dir();
        if (!acpi_battery_dir)
                return -ENODEV;
-
-       result = acpi_bus_register_driver(&acpi_battery_driver);
-       if (result < 0) {
+       if (acpi_bus_register_driver(&acpi_battery_driver) < 0) {
                acpi_unlock_battery_dir(acpi_battery_dir);
                return -ENODEV;
        }
-
        return 0;
 }
 
 static void __exit acpi_battery_exit(void)
 {
        acpi_bus_unregister_driver(&acpi_battery_driver);
-
        acpi_unlock_battery_dir(acpi_battery_dir);
-
-       return;
 }
 
 module_init(acpi_battery_init);