Version:  2.0.40 2.2.26 2.4.37 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5

Linux/drivers/acpi/sbs.c

  1 /*
  2  *  sbs.c - ACPI Smart Battery System Driver ($Revision: 2.0 $)
  3  *
  4  *  Copyright (c) 2007 Alexey Starikovskiy <astarikovskiy@suse.de>
  5  *  Copyright (c) 2005-2007 Vladimir Lebedev <vladimir.p.lebedev@intel.com>
  6  *  Copyright (c) 2005 Rich Townsend <rhdt@bartol.udel.edu>
  7  *
  8  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  9  *
 10  *  This program is free software; you can redistribute it and/or modify
 11  *  it under the terms of the GNU General Public License as published by
 12  *  the Free Software Foundation; either version 2 of the License, or (at
 13  *  your option) any later version.
 14  *
 15  *  This program is distributed in the hope that it will be useful, but
 16  *  WITHOUT ANY WARRANTY; without even the implied warranty of
 17  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 18  *  General Public License for more details.
 19  *
 20  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 21  */
 22 
 23 #include <linux/init.h>
 24 #include <linux/slab.h>
 25 #include <linux/module.h>
 26 #include <linux/moduleparam.h>
 27 #include <linux/kernel.h>
 28 
 29 #include <linux/acpi.h>
 30 #include <linux/timer.h>
 31 #include <linux/jiffies.h>
 32 #include <linux/delay.h>
 33 #include <linux/power_supply.h>
 34 #include <linux/dmi.h>
 35 
 36 #include "sbshc.h"
 37 #include "battery.h"
 38 
 39 #define PREFIX "ACPI: "
 40 
 41 #define ACPI_SBS_CLASS                  "sbs"
 42 #define ACPI_AC_CLASS                   "ac_adapter"
 43 #define ACPI_SBS_DEVICE_NAME            "Smart Battery System"
 44 #define ACPI_SBS_FILE_INFO              "info"
 45 #define ACPI_SBS_FILE_STATE             "state"
 46 #define ACPI_SBS_FILE_ALARM             "alarm"
 47 #define ACPI_BATTERY_DIR_NAME           "BAT%i"
 48 #define ACPI_AC_DIR_NAME                "AC0"
 49 
 50 #define ACPI_SBS_NOTIFY_STATUS          0x80
 51 #define ACPI_SBS_NOTIFY_INFO            0x81
 52 
 53 MODULE_AUTHOR("Alexey Starikovskiy <astarikovskiy@suse.de>");
 54 MODULE_DESCRIPTION("Smart Battery System ACPI interface driver");
 55 MODULE_LICENSE("GPL");
 56 
 57 static unsigned int cache_time = 1000;
 58 module_param(cache_time, uint, 0644);
 59 MODULE_PARM_DESC(cache_time, "cache time in milliseconds");
 60 
 61 static bool sbs_manager_broken;
 62 
 63 #define MAX_SBS_BAT                     4
 64 #define ACPI_SBS_BLOCK_MAX              32
 65 
 66 static const struct acpi_device_id sbs_device_ids[] = {
 67         {"ACPI0002", 0},
 68         {"", 0},
 69 };
 70 MODULE_DEVICE_TABLE(acpi, sbs_device_ids);
 71 
 72 struct acpi_battery {
 73         struct power_supply *bat;
 74         struct power_supply_desc bat_desc;
 75         struct acpi_sbs *sbs;
 76         unsigned long update_time;
 77         char name[8];
 78         char manufacturer_name[ACPI_SBS_BLOCK_MAX];
 79         char device_name[ACPI_SBS_BLOCK_MAX];
 80         char device_chemistry[ACPI_SBS_BLOCK_MAX];
 81         u16 alarm_capacity;
 82         u16 full_charge_capacity;
 83         u16 design_capacity;
 84         u16 design_voltage;
 85         u16 serial_number;
 86         u16 cycle_count;
 87         u16 temp_now;
 88         u16 voltage_now;
 89         s16 rate_now;
 90         s16 rate_avg;
 91         u16 capacity_now;
 92         u16 state_of_charge;
 93         u16 state;
 94         u16 mode;
 95         u16 spec;
 96         u8 id;
 97         u8 present:1;
 98         u8 have_sysfs_alarm:1;
 99 };
100 
101 #define to_acpi_battery(x) power_supply_get_drvdata(x)
102 
103 struct acpi_sbs {
104         struct power_supply *charger;
105         struct acpi_device *device;
106         struct acpi_smb_hc *hc;
107         struct mutex lock;
108         struct acpi_battery battery[MAX_SBS_BAT];
109         u8 batteries_supported:4;
110         u8 manager_present:1;
111         u8 charger_present:1;
112         u8 charger_exists:1;
113 };
114 
115 #define to_acpi_sbs(x) power_supply_get_drvdata(x)
116 
117 static int acpi_sbs_remove(struct acpi_device *device);
118 static int acpi_battery_get_state(struct acpi_battery *battery);
119 
120 static inline int battery_scale(int log)
121 {
122         int scale = 1;
123         while (log--)
124                 scale *= 10;
125         return scale;
126 }
127 
128 static inline int acpi_battery_vscale(struct acpi_battery *battery)
129 {
130         return battery_scale((battery->spec & 0x0f00) >> 8);
131 }
132 
133 static inline int acpi_battery_ipscale(struct acpi_battery *battery)
134 {
135         return battery_scale((battery->spec & 0xf000) >> 12);
136 }
137 
138 static inline int acpi_battery_mode(struct acpi_battery *battery)
139 {
140         return (battery->mode & 0x8000);
141 }
142 
143 static inline int acpi_battery_scale(struct acpi_battery *battery)
144 {
145         return (acpi_battery_mode(battery) ? 10 : 1) *
146             acpi_battery_ipscale(battery);
147 }
148 
149 static int sbs_get_ac_property(struct power_supply *psy,
150                                enum power_supply_property psp,
151                                union power_supply_propval *val)
152 {
153         struct acpi_sbs *sbs = to_acpi_sbs(psy);
154         switch (psp) {
155         case POWER_SUPPLY_PROP_ONLINE:
156                 val->intval = sbs->charger_present;
157                 break;
158         default:
159                 return -EINVAL;
160         }
161         return 0;
162 }
163 
164 static int acpi_battery_technology(struct acpi_battery *battery)
165 {
166         if (!strcasecmp("NiCd", battery->device_chemistry))
167                 return POWER_SUPPLY_TECHNOLOGY_NiCd;
168         if (!strcasecmp("NiMH", battery->device_chemistry))
169                 return POWER_SUPPLY_TECHNOLOGY_NiMH;
170         if (!strcasecmp("LION", battery->device_chemistry))
171                 return POWER_SUPPLY_TECHNOLOGY_LION;
172         if (!strcasecmp("LiP", battery->device_chemistry))
173                 return POWER_SUPPLY_TECHNOLOGY_LIPO;
174         return POWER_SUPPLY_TECHNOLOGY_UNKNOWN;
175 }
176 
177 static int acpi_sbs_battery_get_property(struct power_supply *psy,
178                                          enum power_supply_property psp,
179                                          union power_supply_propval *val)
180 {
181         struct acpi_battery *battery = to_acpi_battery(psy);
182 
183         if ((!battery->present) && psp != POWER_SUPPLY_PROP_PRESENT)
184                 return -ENODEV;
185 
186         acpi_battery_get_state(battery);
187         switch (psp) {
188         case POWER_SUPPLY_PROP_STATUS:
189                 if (battery->rate_now < 0)
190                         val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
191                 else if (battery->rate_now > 0)
192                         val->intval = POWER_SUPPLY_STATUS_CHARGING;
193                 else
194                         val->intval = POWER_SUPPLY_STATUS_FULL;
195                 break;
196         case POWER_SUPPLY_PROP_PRESENT:
197                 val->intval = battery->present;
198                 break;
199         case POWER_SUPPLY_PROP_TECHNOLOGY:
200                 val->intval = acpi_battery_technology(battery);
201                 break;
202         case POWER_SUPPLY_PROP_CYCLE_COUNT:
203                 val->intval = battery->cycle_count;
204                 break;
205         case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
206                 val->intval = battery->design_voltage *
207                         acpi_battery_vscale(battery) * 1000;
208                 break;
209         case POWER_SUPPLY_PROP_VOLTAGE_NOW:
210                 val->intval = battery->voltage_now *
211                                 acpi_battery_vscale(battery) * 1000;
212                 break;
213         case POWER_SUPPLY_PROP_CURRENT_NOW:
214         case POWER_SUPPLY_PROP_POWER_NOW:
215                 val->intval = abs(battery->rate_now) *
216                                 acpi_battery_ipscale(battery) * 1000;
217                 val->intval *= (acpi_battery_mode(battery)) ?
218                                 (battery->voltage_now *
219                                 acpi_battery_vscale(battery) / 1000) : 1;
220                 break;
221         case POWER_SUPPLY_PROP_CURRENT_AVG:
222         case POWER_SUPPLY_PROP_POWER_AVG:
223                 val->intval = abs(battery->rate_avg) *
224                                 acpi_battery_ipscale(battery) * 1000;
225                 val->intval *= (acpi_battery_mode(battery)) ?
226                                 (battery->voltage_now *
227                                 acpi_battery_vscale(battery) / 1000) : 1;
228                 break;
229         case POWER_SUPPLY_PROP_CAPACITY:
230                 val->intval = battery->state_of_charge;
231                 break;
232         case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
233         case POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN:
234                 val->intval = battery->design_capacity *
235                         acpi_battery_scale(battery) * 1000;
236                 break;
237         case POWER_SUPPLY_PROP_CHARGE_FULL:
238         case POWER_SUPPLY_PROP_ENERGY_FULL:
239                 val->intval = battery->full_charge_capacity *
240                         acpi_battery_scale(battery) * 1000;
241                 break;
242         case POWER_SUPPLY_PROP_CHARGE_NOW:
243         case POWER_SUPPLY_PROP_ENERGY_NOW:
244                 val->intval = battery->capacity_now *
245                                 acpi_battery_scale(battery) * 1000;
246                 break;
247         case POWER_SUPPLY_PROP_TEMP:
248                 val->intval = battery->temp_now - 2730; // dK -> dC
249                 break;
250         case POWER_SUPPLY_PROP_MODEL_NAME:
251                 val->strval = battery->device_name;
252                 break;
253         case POWER_SUPPLY_PROP_MANUFACTURER:
254                 val->strval = battery->manufacturer_name;
255                 break;
256         default:
257                 return -EINVAL;
258         }
259         return 0;
260 }
261 
262 static enum power_supply_property sbs_ac_props[] = {
263         POWER_SUPPLY_PROP_ONLINE,
264 };
265 
266 static enum power_supply_property sbs_charge_battery_props[] = {
267         POWER_SUPPLY_PROP_STATUS,
268         POWER_SUPPLY_PROP_PRESENT,
269         POWER_SUPPLY_PROP_TECHNOLOGY,
270         POWER_SUPPLY_PROP_CYCLE_COUNT,
271         POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
272         POWER_SUPPLY_PROP_VOLTAGE_NOW,
273         POWER_SUPPLY_PROP_CURRENT_NOW,
274         POWER_SUPPLY_PROP_CURRENT_AVG,
275         POWER_SUPPLY_PROP_CAPACITY,
276         POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
277         POWER_SUPPLY_PROP_CHARGE_FULL,
278         POWER_SUPPLY_PROP_CHARGE_NOW,
279         POWER_SUPPLY_PROP_TEMP,
280         POWER_SUPPLY_PROP_MODEL_NAME,
281         POWER_SUPPLY_PROP_MANUFACTURER,
282 };
283 
284 static enum power_supply_property sbs_energy_battery_props[] = {
285         POWER_SUPPLY_PROP_STATUS,
286         POWER_SUPPLY_PROP_PRESENT,
287         POWER_SUPPLY_PROP_TECHNOLOGY,
288         POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
289         POWER_SUPPLY_PROP_VOLTAGE_NOW,
290         POWER_SUPPLY_PROP_CURRENT_NOW,
291         POWER_SUPPLY_PROP_CURRENT_AVG,
292         POWER_SUPPLY_PROP_POWER_NOW,
293         POWER_SUPPLY_PROP_POWER_AVG,
294         POWER_SUPPLY_PROP_CAPACITY,
295         POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN,
296         POWER_SUPPLY_PROP_ENERGY_FULL,
297         POWER_SUPPLY_PROP_ENERGY_NOW,
298         POWER_SUPPLY_PROP_TEMP,
299         POWER_SUPPLY_PROP_MODEL_NAME,
300         POWER_SUPPLY_PROP_MANUFACTURER,
301 };
302 
303 static const struct power_supply_desc acpi_sbs_charger_desc = {
304         .name           = "sbs-charger",
305         .type           = POWER_SUPPLY_TYPE_MAINS,
306         .properties     = sbs_ac_props,
307         .num_properties = ARRAY_SIZE(sbs_ac_props),
308         .get_property   = sbs_get_ac_property,
309 };
310 
311 /* --------------------------------------------------------------------------
312                             Smart Battery System Management
313    -------------------------------------------------------------------------- */
314 
315 struct acpi_battery_reader {
316         u8 command;             /* command for battery */
317         u8 mode;                /* word or block? */
318         size_t offset;          /* offset inside struct acpi_sbs_battery */
319 };
320 
321 static struct acpi_battery_reader info_readers[] = {
322         {0x01, SMBUS_READ_WORD, offsetof(struct acpi_battery, alarm_capacity)},
323         {0x03, SMBUS_READ_WORD, offsetof(struct acpi_battery, mode)},
324         {0x10, SMBUS_READ_WORD, offsetof(struct acpi_battery, full_charge_capacity)},
325         {0x17, SMBUS_READ_WORD, offsetof(struct acpi_battery, cycle_count)},
326         {0x18, SMBUS_READ_WORD, offsetof(struct acpi_battery, design_capacity)},
327         {0x19, SMBUS_READ_WORD, offsetof(struct acpi_battery, design_voltage)},
328         {0x1a, SMBUS_READ_WORD, offsetof(struct acpi_battery, spec)},
329         {0x1c, SMBUS_READ_WORD, offsetof(struct acpi_battery, serial_number)},
330         {0x20, SMBUS_READ_BLOCK, offsetof(struct acpi_battery, manufacturer_name)},
331         {0x21, SMBUS_READ_BLOCK, offsetof(struct acpi_battery, device_name)},
332         {0x22, SMBUS_READ_BLOCK, offsetof(struct acpi_battery, device_chemistry)},
333 };
334 
335 static struct acpi_battery_reader state_readers[] = {
336         {0x08, SMBUS_READ_WORD, offsetof(struct acpi_battery, temp_now)},
337         {0x09, SMBUS_READ_WORD, offsetof(struct acpi_battery, voltage_now)},
338         {0x0a, SMBUS_READ_WORD, offsetof(struct acpi_battery, rate_now)},
339         {0x0b, SMBUS_READ_WORD, offsetof(struct acpi_battery, rate_avg)},
340         {0x0f, SMBUS_READ_WORD, offsetof(struct acpi_battery, capacity_now)},
341         {0x0e, SMBUS_READ_WORD, offsetof(struct acpi_battery, state_of_charge)},
342         {0x16, SMBUS_READ_WORD, offsetof(struct acpi_battery, state)},
343 };
344 
345 static int acpi_manager_get_info(struct acpi_sbs *sbs)
346 {
347         int result = 0;
348         u16 battery_system_info;
349 
350         result = acpi_smbus_read(sbs->hc, SMBUS_READ_WORD, ACPI_SBS_MANAGER,
351                                  0x04, (u8 *)&battery_system_info);
352         if (!result)
353                 sbs->batteries_supported = battery_system_info & 0x000f;
354         return result;
355 }
356 
357 static int acpi_battery_get_info(struct acpi_battery *battery)
358 {
359         int i, result = 0;
360 
361         for (i = 0; i < ARRAY_SIZE(info_readers); ++i) {
362                 result = acpi_smbus_read(battery->sbs->hc,
363                                          info_readers[i].mode,
364                                          ACPI_SBS_BATTERY,
365                                          info_readers[i].command,
366                                          (u8 *) battery +
367                                                 info_readers[i].offset);
368                 if (result)
369                         break;
370         }
371         return result;
372 }
373 
374 static int acpi_battery_get_state(struct acpi_battery *battery)
375 {
376         int i, result = 0;
377 
378         if (battery->update_time &&
379             time_before(jiffies, battery->update_time +
380                                 msecs_to_jiffies(cache_time)))
381                 return 0;
382         for (i = 0; i < ARRAY_SIZE(state_readers); ++i) {
383                 result = acpi_smbus_read(battery->sbs->hc,
384                                          state_readers[i].mode,
385                                          ACPI_SBS_BATTERY,
386                                          state_readers[i].command,
387                                          (u8 *)battery +
388                                                 state_readers[i].offset);
389                 if (result)
390                         goto end;
391         }
392       end:
393         battery->update_time = jiffies;
394         return result;
395 }
396 
397 static int acpi_battery_get_alarm(struct acpi_battery *battery)
398 {
399         return acpi_smbus_read(battery->sbs->hc, SMBUS_READ_WORD,
400                                  ACPI_SBS_BATTERY, 0x01,
401                                  (u8 *)&battery->alarm_capacity);
402 }
403 
404 static int acpi_battery_set_alarm(struct acpi_battery *battery)
405 {
406         struct acpi_sbs *sbs = battery->sbs;
407         u16 value, sel = 1 << (battery->id + 12);
408 
409         int ret;
410 
411 
412         if (sbs->manager_present) {
413                 ret = acpi_smbus_read(sbs->hc, SMBUS_READ_WORD, ACPI_SBS_MANAGER,
414                                 0x01, (u8 *)&value);
415                 if (ret)
416                         goto end;
417                 if ((value & 0xf000) != sel) {
418                         value &= 0x0fff;
419                         value |= sel;
420                         ret = acpi_smbus_write(sbs->hc, SMBUS_WRITE_WORD,
421                                          ACPI_SBS_MANAGER,
422                                          0x01, (u8 *)&value, 2);
423                         if (ret)
424                                 goto end;
425                 }
426         }
427         ret = acpi_smbus_write(sbs->hc, SMBUS_WRITE_WORD, ACPI_SBS_BATTERY,
428                                 0x01, (u8 *)&battery->alarm_capacity, 2);
429       end:
430         return ret;
431 }
432 
433 static int acpi_ac_get_present(struct acpi_sbs *sbs)
434 {
435         int result;
436         u16 status;
437 
438         result = acpi_smbus_read(sbs->hc, SMBUS_READ_WORD, ACPI_SBS_CHARGER,
439                                  0x13, (u8 *) & status);
440 
441         if (result)
442                 return result;
443 
444         /*
445          * The spec requires that bit 4 always be 1. If it's not set, assume
446          * that the implementation doesn't support an SBS charger
447          */
448         if (!((status >> 4) & 0x1))
449                 return -ENODEV;
450 
451         sbs->charger_present = (status >> 15) & 0x1;
452         return 0;
453 }
454 
455 static ssize_t acpi_battery_alarm_show(struct device *dev,
456                                         struct device_attribute *attr,
457                                         char *buf)
458 {
459         struct acpi_battery *battery = to_acpi_battery(dev_get_drvdata(dev));
460         acpi_battery_get_alarm(battery);
461         return sprintf(buf, "%d\n", battery->alarm_capacity *
462                                 acpi_battery_scale(battery) * 1000);
463 }
464 
465 static ssize_t acpi_battery_alarm_store(struct device *dev,
466                                         struct device_attribute *attr,
467                                         const char *buf, size_t count)
468 {
469         unsigned long x;
470         struct acpi_battery *battery = to_acpi_battery(dev_get_drvdata(dev));
471         if (sscanf(buf, "%lu\n", &x) == 1)
472                 battery->alarm_capacity = x /
473                         (1000 * acpi_battery_scale(battery));
474         if (battery->present)
475                 acpi_battery_set_alarm(battery);
476         return count;
477 }
478 
479 static struct device_attribute alarm_attr = {
480         .attr = {.name = "alarm", .mode = 0644},
481         .show = acpi_battery_alarm_show,
482         .store = acpi_battery_alarm_store,
483 };
484 
485 /* --------------------------------------------------------------------------
486                                  Driver Interface
487    -------------------------------------------------------------------------- */
488 static int acpi_battery_read(struct acpi_battery *battery)
489 {
490         int result = 0, saved_present = battery->present;
491         u16 state;
492 
493         if (battery->sbs->manager_present) {
494                 result = acpi_smbus_read(battery->sbs->hc, SMBUS_READ_WORD,
495                                 ACPI_SBS_MANAGER, 0x01, (u8 *)&state);
496                 if (!result)
497                         battery->present = state & (1 << battery->id);
498                 state &= 0x0fff;
499                 state |= 1 << (battery->id + 12);
500                 acpi_smbus_write(battery->sbs->hc, SMBUS_WRITE_WORD,
501                                   ACPI_SBS_MANAGER, 0x01, (u8 *)&state, 2);
502         } else if (battery->id == 0)
503                 battery->present = 1;
504 
505         if (result || !battery->present)
506                 return result;
507 
508         if (saved_present != battery->present) {
509                 battery->update_time = 0;
510                 result = acpi_battery_get_info(battery);
511                 if (result) {
512                         battery->present = 0;
513                         return result;
514                 }
515         }
516         result = acpi_battery_get_state(battery);
517         if (result)
518                 battery->present = 0;
519         return result;
520 }
521 
522 /* Smart Battery */
523 static int acpi_battery_add(struct acpi_sbs *sbs, int id)
524 {
525         struct acpi_battery *battery = &sbs->battery[id];
526         struct power_supply_config psy_cfg = { .drv_data = battery, };
527         int result;
528 
529         battery->id = id;
530         battery->sbs = sbs;
531         result = acpi_battery_read(battery);
532         if (result)
533                 return result;
534 
535         sprintf(battery->name, ACPI_BATTERY_DIR_NAME, id);
536         battery->bat_desc.name = battery->name;
537         battery->bat_desc.type = POWER_SUPPLY_TYPE_BATTERY;
538         if (!acpi_battery_mode(battery)) {
539                 battery->bat_desc.properties = sbs_charge_battery_props;
540                 battery->bat_desc.num_properties =
541                     ARRAY_SIZE(sbs_charge_battery_props);
542         } else {
543                 battery->bat_desc.properties = sbs_energy_battery_props;
544                 battery->bat_desc.num_properties =
545                     ARRAY_SIZE(sbs_energy_battery_props);
546         }
547         battery->bat_desc.get_property = acpi_sbs_battery_get_property;
548         battery->bat = power_supply_register(&sbs->device->dev,
549                                         &battery->bat_desc, &psy_cfg);
550         if (IS_ERR(battery->bat)) {
551                 result = PTR_ERR(battery->bat);
552                 battery->bat = NULL;
553                 goto end;
554         }
555 
556         result = device_create_file(&battery->bat->dev, &alarm_attr);
557         if (result)
558                 goto end;
559         battery->have_sysfs_alarm = 1;
560       end:
561         printk(KERN_INFO PREFIX "%s [%s]: Battery Slot [%s] (battery %s)\n",
562                ACPI_SBS_DEVICE_NAME, acpi_device_bid(sbs->device),
563                battery->name, battery->present ? "present" : "absent");
564         return result;
565 }
566 
567 static void acpi_battery_remove(struct acpi_sbs *sbs, int id)
568 {
569         struct acpi_battery *battery = &sbs->battery[id];
570 
571         if (battery->bat) {
572                 if (battery->have_sysfs_alarm)
573                         device_remove_file(&battery->bat->dev, &alarm_attr);
574                 power_supply_unregister(battery->bat);
575         }
576 }
577 
578 static int acpi_charger_add(struct acpi_sbs *sbs)
579 {
580         int result;
581         struct power_supply_config psy_cfg = { .drv_data = sbs, };
582 
583         result = acpi_ac_get_present(sbs);
584         if (result)
585                 goto end;
586 
587         sbs->charger_exists = 1;
588         sbs->charger = power_supply_register(&sbs->device->dev,
589                                         &acpi_sbs_charger_desc, &psy_cfg);
590         if (IS_ERR(sbs->charger)) {
591                 result = PTR_ERR(sbs->charger);
592                 sbs->charger = NULL;
593         }
594         printk(KERN_INFO PREFIX "%s [%s]: AC Adapter [%s] (%s)\n",
595                ACPI_SBS_DEVICE_NAME, acpi_device_bid(sbs->device),
596                ACPI_AC_DIR_NAME, sbs->charger_present ? "on-line" : "off-line");
597       end:
598         return result;
599 }
600 
601 static void acpi_charger_remove(struct acpi_sbs *sbs)
602 {
603         if (sbs->charger)
604                 power_supply_unregister(sbs->charger);
605 }
606 
607 static void acpi_sbs_callback(void *context)
608 {
609         int id;
610         struct acpi_sbs *sbs = context;
611         struct acpi_battery *bat;
612         u8 saved_charger_state = sbs->charger_present;
613         u8 saved_battery_state;
614 
615         if (sbs->charger_exists) {
616                 acpi_ac_get_present(sbs);
617                 if (sbs->charger_present != saved_charger_state)
618                         kobject_uevent(&sbs->charger->dev.kobj, KOBJ_CHANGE);
619         }
620 
621         if (sbs->manager_present) {
622                 for (id = 0; id < MAX_SBS_BAT; ++id) {
623                         if (!(sbs->batteries_supported & (1 << id)))
624                                 continue;
625                         bat = &sbs->battery[id];
626                         saved_battery_state = bat->present;
627                         acpi_battery_read(bat);
628                         if (saved_battery_state == bat->present)
629                                 continue;
630                         kobject_uevent(&bat->bat->dev.kobj, KOBJ_CHANGE);
631                 }
632         }
633 }
634 
635 static int disable_sbs_manager(const struct dmi_system_id *d)
636 {
637         sbs_manager_broken = true;
638         return 0;
639 }
640 
641 static struct dmi_system_id acpi_sbs_dmi_table[] = {
642         {
643                 .callback = disable_sbs_manager,
644                 .ident = "Apple",
645                 .matches = {
646                         DMI_MATCH(DMI_SYS_VENDOR, "Apple Inc.")
647                 },
648         },
649         { },
650 };
651 
652 static int acpi_sbs_add(struct acpi_device *device)
653 {
654         struct acpi_sbs *sbs;
655         int result = 0;
656         int id;
657 
658         dmi_check_system(acpi_sbs_dmi_table);
659 
660         sbs = kzalloc(sizeof(struct acpi_sbs), GFP_KERNEL);
661         if (!sbs) {
662                 result = -ENOMEM;
663                 goto end;
664         }
665 
666         mutex_init(&sbs->lock);
667 
668         sbs->hc = acpi_driver_data(device->parent);
669         sbs->device = device;
670         strcpy(acpi_device_name(device), ACPI_SBS_DEVICE_NAME);
671         strcpy(acpi_device_class(device), ACPI_SBS_CLASS);
672         device->driver_data = sbs;
673 
674         result = acpi_charger_add(sbs);
675         if (result && result != -ENODEV)
676                 goto end;
677 
678         result = 0;
679 
680         if (!sbs_manager_broken) {
681                 result = acpi_manager_get_info(sbs);
682                 if (!result) {
683                         sbs->manager_present = 1;
684                         for (id = 0; id < MAX_SBS_BAT; ++id)
685                                 if ((sbs->batteries_supported & (1 << id)))
686                                         acpi_battery_add(sbs, id);
687                 }
688         }
689 
690         if (!sbs->manager_present)
691                 acpi_battery_add(sbs, 0);
692 
693         acpi_smbus_register_callback(sbs->hc, acpi_sbs_callback, sbs);
694       end:
695         if (result)
696                 acpi_sbs_remove(device);
697         return result;
698 }
699 
700 static int acpi_sbs_remove(struct acpi_device *device)
701 {
702         struct acpi_sbs *sbs;
703         int id;
704 
705         if (!device)
706                 return -EINVAL;
707         sbs = acpi_driver_data(device);
708         if (!sbs)
709                 return -EINVAL;
710         mutex_lock(&sbs->lock);
711         acpi_smbus_unregister_callback(sbs->hc);
712         for (id = 0; id < MAX_SBS_BAT; ++id)
713                 acpi_battery_remove(sbs, id);
714         acpi_charger_remove(sbs);
715         mutex_unlock(&sbs->lock);
716         mutex_destroy(&sbs->lock);
717         kfree(sbs);
718         return 0;
719 }
720 
721 #ifdef CONFIG_PM_SLEEP
722 static int acpi_sbs_resume(struct device *dev)
723 {
724         struct acpi_sbs *sbs;
725         if (!dev)
726                 return -EINVAL;
727         sbs = to_acpi_device(dev)->driver_data;
728         acpi_sbs_callback(sbs);
729         return 0;
730 }
731 #else
732 #define acpi_sbs_resume NULL
733 #endif
734 
735 static SIMPLE_DEV_PM_OPS(acpi_sbs_pm, NULL, acpi_sbs_resume);
736 
737 static struct acpi_driver acpi_sbs_driver = {
738         .name = "sbs",
739         .class = ACPI_SBS_CLASS,
740         .ids = sbs_device_ids,
741         .ops = {
742                 .add = acpi_sbs_add,
743                 .remove = acpi_sbs_remove,
744                 },
745         .drv.pm = &acpi_sbs_pm,
746 };
747 
748 static int __init acpi_sbs_init(void)
749 {
750         int result = 0;
751 
752         if (acpi_disabled)
753                 return -ENODEV;
754 
755         result = acpi_bus_register_driver(&acpi_sbs_driver);
756         if (result < 0)
757                 return -ENODEV;
758 
759         return 0;
760 }
761 
762 static void __exit acpi_sbs_exit(void)
763 {
764         acpi_bus_unregister_driver(&acpi_sbs_driver);
765         return;
766 }
767 
768 module_init(acpi_sbs_init);
769 module_exit(acpi_sbs_exit);
770 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us