Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  *  sbs.c - ACPI Smart Battery System Driver ($Revision: 2.0 $)
0004  *
0005  *  Copyright (c) 2007 Alexey Starikovskiy <astarikovskiy@suse.de>
0006  *  Copyright (c) 2005-2007 Vladimir Lebedev <vladimir.p.lebedev@intel.com>
0007  *  Copyright (c) 2005 Rich Townsend <rhdt@bartol.udel.edu>
0008  */
0009 
0010 #define pr_fmt(fmt) "ACPI: " fmt
0011 
0012 #include <linux/init.h>
0013 #include <linux/slab.h>
0014 #include <linux/module.h>
0015 #include <linux/moduleparam.h>
0016 #include <linux/kernel.h>
0017 
0018 #include <linux/acpi.h>
0019 #include <linux/timer.h>
0020 #include <linux/jiffies.h>
0021 #include <linux/delay.h>
0022 #include <linux/power_supply.h>
0023 #include <linux/platform_data/x86/apple.h>
0024 #include <acpi/battery.h>
0025 
0026 #include "sbshc.h"
0027 
0028 #define ACPI_SBS_CLASS          "sbs"
0029 #define ACPI_AC_CLASS           "ac_adapter"
0030 #define ACPI_SBS_DEVICE_NAME        "Smart Battery System"
0031 #define ACPI_BATTERY_DIR_NAME       "BAT%i"
0032 #define ACPI_AC_DIR_NAME        "AC0"
0033 
0034 #define ACPI_SBS_NOTIFY_STATUS      0x80
0035 #define ACPI_SBS_NOTIFY_INFO        0x81
0036 
0037 MODULE_AUTHOR("Alexey Starikovskiy <astarikovskiy@suse.de>");
0038 MODULE_DESCRIPTION("Smart Battery System ACPI interface driver");
0039 MODULE_LICENSE("GPL");
0040 
0041 static unsigned int cache_time = 1000;
0042 module_param(cache_time, uint, 0644);
0043 MODULE_PARM_DESC(cache_time, "cache time in milliseconds");
0044 
0045 #define MAX_SBS_BAT         4
0046 #define ACPI_SBS_BLOCK_MAX      32
0047 
0048 static const struct acpi_device_id sbs_device_ids[] = {
0049     {"ACPI0002", 0},
0050     {"", 0},
0051 };
0052 MODULE_DEVICE_TABLE(acpi, sbs_device_ids);
0053 
0054 struct acpi_battery {
0055     struct power_supply *bat;
0056     struct power_supply_desc bat_desc;
0057     struct acpi_sbs *sbs;
0058     unsigned long update_time;
0059     char name[8];
0060     char manufacturer_name[ACPI_SBS_BLOCK_MAX];
0061     char device_name[ACPI_SBS_BLOCK_MAX];
0062     char device_chemistry[ACPI_SBS_BLOCK_MAX];
0063     u16 alarm_capacity;
0064     u16 full_charge_capacity;
0065     u16 design_capacity;
0066     u16 design_voltage;
0067     u16 serial_number;
0068     u16 cycle_count;
0069     u16 temp_now;
0070     u16 voltage_now;
0071     s16 rate_now;
0072     s16 rate_avg;
0073     u16 capacity_now;
0074     u16 state_of_charge;
0075     u16 state;
0076     u16 mode;
0077     u16 spec;
0078     u8 id;
0079     u8 present:1;
0080     u8 have_sysfs_alarm:1;
0081 };
0082 
0083 #define to_acpi_battery(x) power_supply_get_drvdata(x)
0084 
0085 struct acpi_sbs {
0086     struct power_supply *charger;
0087     struct acpi_device *device;
0088     struct acpi_smb_hc *hc;
0089     struct mutex lock;
0090     struct acpi_battery battery[MAX_SBS_BAT];
0091     u8 batteries_supported:4;
0092     u8 manager_present:1;
0093     u8 charger_present:1;
0094     u8 charger_exists:1;
0095 };
0096 
0097 #define to_acpi_sbs(x) power_supply_get_drvdata(x)
0098 
0099 static int acpi_sbs_remove(struct acpi_device *device);
0100 static int acpi_battery_get_state(struct acpi_battery *battery);
0101 
0102 static inline int battery_scale(int log)
0103 {
0104     int scale = 1;
0105     while (log--)
0106         scale *= 10;
0107     return scale;
0108 }
0109 
0110 static inline int acpi_battery_vscale(struct acpi_battery *battery)
0111 {
0112     return battery_scale((battery->spec & 0x0f00) >> 8);
0113 }
0114 
0115 static inline int acpi_battery_ipscale(struct acpi_battery *battery)
0116 {
0117     return battery_scale((battery->spec & 0xf000) >> 12);
0118 }
0119 
0120 static inline int acpi_battery_mode(struct acpi_battery *battery)
0121 {
0122     return (battery->mode & 0x8000);
0123 }
0124 
0125 static inline int acpi_battery_scale(struct acpi_battery *battery)
0126 {
0127     return (acpi_battery_mode(battery) ? 10 : 1) *
0128         acpi_battery_ipscale(battery);
0129 }
0130 
0131 static int sbs_get_ac_property(struct power_supply *psy,
0132                    enum power_supply_property psp,
0133                    union power_supply_propval *val)
0134 {
0135     struct acpi_sbs *sbs = to_acpi_sbs(psy);
0136     switch (psp) {
0137     case POWER_SUPPLY_PROP_ONLINE:
0138         val->intval = sbs->charger_present;
0139         break;
0140     default:
0141         return -EINVAL;
0142     }
0143     return 0;
0144 }
0145 
0146 static int acpi_battery_technology(struct acpi_battery *battery)
0147 {
0148     if (!strcasecmp("NiCd", battery->device_chemistry))
0149         return POWER_SUPPLY_TECHNOLOGY_NiCd;
0150     if (!strcasecmp("NiMH", battery->device_chemistry))
0151         return POWER_SUPPLY_TECHNOLOGY_NiMH;
0152     if (!strcasecmp("LION", battery->device_chemistry))
0153         return POWER_SUPPLY_TECHNOLOGY_LION;
0154     if (!strcasecmp("LiP", battery->device_chemistry))
0155         return POWER_SUPPLY_TECHNOLOGY_LIPO;
0156     return POWER_SUPPLY_TECHNOLOGY_UNKNOWN;
0157 }
0158 
0159 static int acpi_sbs_battery_get_property(struct power_supply *psy,
0160                      enum power_supply_property psp,
0161                      union power_supply_propval *val)
0162 {
0163     struct acpi_battery *battery = to_acpi_battery(psy);
0164 
0165     if ((!battery->present) && psp != POWER_SUPPLY_PROP_PRESENT)
0166         return -ENODEV;
0167 
0168     acpi_battery_get_state(battery);
0169     switch (psp) {
0170     case POWER_SUPPLY_PROP_STATUS:
0171         if (battery->rate_now < 0)
0172             val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
0173         else if (battery->rate_now > 0)
0174             val->intval = POWER_SUPPLY_STATUS_CHARGING;
0175         else
0176             val->intval = POWER_SUPPLY_STATUS_FULL;
0177         break;
0178     case POWER_SUPPLY_PROP_PRESENT:
0179         val->intval = battery->present;
0180         break;
0181     case POWER_SUPPLY_PROP_TECHNOLOGY:
0182         val->intval = acpi_battery_technology(battery);
0183         break;
0184     case POWER_SUPPLY_PROP_CYCLE_COUNT:
0185         val->intval = battery->cycle_count;
0186         break;
0187     case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
0188         val->intval = battery->design_voltage *
0189             acpi_battery_vscale(battery) * 1000;
0190         break;
0191     case POWER_SUPPLY_PROP_VOLTAGE_NOW:
0192         val->intval = battery->voltage_now *
0193                 acpi_battery_vscale(battery) * 1000;
0194         break;
0195     case POWER_SUPPLY_PROP_CURRENT_NOW:
0196     case POWER_SUPPLY_PROP_POWER_NOW:
0197         val->intval = abs(battery->rate_now) *
0198                 acpi_battery_ipscale(battery) * 1000;
0199         val->intval *= (acpi_battery_mode(battery)) ?
0200                 (battery->voltage_now *
0201                 acpi_battery_vscale(battery) / 1000) : 1;
0202         break;
0203     case POWER_SUPPLY_PROP_CURRENT_AVG:
0204     case POWER_SUPPLY_PROP_POWER_AVG:
0205         val->intval = abs(battery->rate_avg) *
0206                 acpi_battery_ipscale(battery) * 1000;
0207         val->intval *= (acpi_battery_mode(battery)) ?
0208                 (battery->voltage_now *
0209                 acpi_battery_vscale(battery) / 1000) : 1;
0210         break;
0211     case POWER_SUPPLY_PROP_CAPACITY:
0212         val->intval = battery->state_of_charge;
0213         break;
0214     case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
0215     case POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN:
0216         val->intval = battery->design_capacity *
0217             acpi_battery_scale(battery) * 1000;
0218         break;
0219     case POWER_SUPPLY_PROP_CHARGE_FULL:
0220     case POWER_SUPPLY_PROP_ENERGY_FULL:
0221         val->intval = battery->full_charge_capacity *
0222             acpi_battery_scale(battery) * 1000;
0223         break;
0224     case POWER_SUPPLY_PROP_CHARGE_NOW:
0225     case POWER_SUPPLY_PROP_ENERGY_NOW:
0226         val->intval = battery->capacity_now *
0227                 acpi_battery_scale(battery) * 1000;
0228         break;
0229     case POWER_SUPPLY_PROP_TEMP:
0230         val->intval = battery->temp_now - 2730; // dK -> dC
0231         break;
0232     case POWER_SUPPLY_PROP_MODEL_NAME:
0233         val->strval = battery->device_name;
0234         break;
0235     case POWER_SUPPLY_PROP_MANUFACTURER:
0236         val->strval = battery->manufacturer_name;
0237         break;
0238     default:
0239         return -EINVAL;
0240     }
0241     return 0;
0242 }
0243 
0244 static enum power_supply_property sbs_ac_props[] = {
0245     POWER_SUPPLY_PROP_ONLINE,
0246 };
0247 
0248 static enum power_supply_property sbs_charge_battery_props[] = {
0249     POWER_SUPPLY_PROP_STATUS,
0250     POWER_SUPPLY_PROP_PRESENT,
0251     POWER_SUPPLY_PROP_TECHNOLOGY,
0252     POWER_SUPPLY_PROP_CYCLE_COUNT,
0253     POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
0254     POWER_SUPPLY_PROP_VOLTAGE_NOW,
0255     POWER_SUPPLY_PROP_CURRENT_NOW,
0256     POWER_SUPPLY_PROP_CURRENT_AVG,
0257     POWER_SUPPLY_PROP_CAPACITY,
0258     POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
0259     POWER_SUPPLY_PROP_CHARGE_FULL,
0260     POWER_SUPPLY_PROP_CHARGE_NOW,
0261     POWER_SUPPLY_PROP_TEMP,
0262     POWER_SUPPLY_PROP_MODEL_NAME,
0263     POWER_SUPPLY_PROP_MANUFACTURER,
0264 };
0265 
0266 static enum power_supply_property sbs_energy_battery_props[] = {
0267     POWER_SUPPLY_PROP_STATUS,
0268     POWER_SUPPLY_PROP_PRESENT,
0269     POWER_SUPPLY_PROP_TECHNOLOGY,
0270     POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
0271     POWER_SUPPLY_PROP_VOLTAGE_NOW,
0272     POWER_SUPPLY_PROP_CURRENT_NOW,
0273     POWER_SUPPLY_PROP_CURRENT_AVG,
0274     POWER_SUPPLY_PROP_POWER_NOW,
0275     POWER_SUPPLY_PROP_POWER_AVG,
0276     POWER_SUPPLY_PROP_CAPACITY,
0277     POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN,
0278     POWER_SUPPLY_PROP_ENERGY_FULL,
0279     POWER_SUPPLY_PROP_ENERGY_NOW,
0280     POWER_SUPPLY_PROP_TEMP,
0281     POWER_SUPPLY_PROP_MODEL_NAME,
0282     POWER_SUPPLY_PROP_MANUFACTURER,
0283 };
0284 
0285 static const struct power_supply_desc acpi_sbs_charger_desc = {
0286     .name       = "sbs-charger",
0287     .type       = POWER_SUPPLY_TYPE_MAINS,
0288     .properties = sbs_ac_props,
0289     .num_properties = ARRAY_SIZE(sbs_ac_props),
0290     .get_property   = sbs_get_ac_property,
0291 };
0292 
0293 /* --------------------------------------------------------------------------
0294                             Smart Battery System Management
0295    -------------------------------------------------------------------------- */
0296 
0297 struct acpi_battery_reader {
0298     u8 command;     /* command for battery */
0299     u8 mode;        /* word or block? */
0300     size_t offset;      /* offset inside struct acpi_sbs_battery */
0301 };
0302 
0303 static struct acpi_battery_reader info_readers[] = {
0304     {0x01, SMBUS_READ_WORD, offsetof(struct acpi_battery, alarm_capacity)},
0305     {0x03, SMBUS_READ_WORD, offsetof(struct acpi_battery, mode)},
0306     {0x10, SMBUS_READ_WORD, offsetof(struct acpi_battery, full_charge_capacity)},
0307     {0x17, SMBUS_READ_WORD, offsetof(struct acpi_battery, cycle_count)},
0308     {0x18, SMBUS_READ_WORD, offsetof(struct acpi_battery, design_capacity)},
0309     {0x19, SMBUS_READ_WORD, offsetof(struct acpi_battery, design_voltage)},
0310     {0x1a, SMBUS_READ_WORD, offsetof(struct acpi_battery, spec)},
0311     {0x1c, SMBUS_READ_WORD, offsetof(struct acpi_battery, serial_number)},
0312     {0x20, SMBUS_READ_BLOCK, offsetof(struct acpi_battery, manufacturer_name)},
0313     {0x21, SMBUS_READ_BLOCK, offsetof(struct acpi_battery, device_name)},
0314     {0x22, SMBUS_READ_BLOCK, offsetof(struct acpi_battery, device_chemistry)},
0315 };
0316 
0317 static struct acpi_battery_reader state_readers[] = {
0318     {0x08, SMBUS_READ_WORD, offsetof(struct acpi_battery, temp_now)},
0319     {0x09, SMBUS_READ_WORD, offsetof(struct acpi_battery, voltage_now)},
0320     {0x0a, SMBUS_READ_WORD, offsetof(struct acpi_battery, rate_now)},
0321     {0x0b, SMBUS_READ_WORD, offsetof(struct acpi_battery, rate_avg)},
0322     {0x0f, SMBUS_READ_WORD, offsetof(struct acpi_battery, capacity_now)},
0323     {0x0e, SMBUS_READ_WORD, offsetof(struct acpi_battery, state_of_charge)},
0324     {0x16, SMBUS_READ_WORD, offsetof(struct acpi_battery, state)},
0325 };
0326 
0327 static int acpi_manager_get_info(struct acpi_sbs *sbs)
0328 {
0329     int result = 0;
0330     u16 battery_system_info;
0331 
0332     result = acpi_smbus_read(sbs->hc, SMBUS_READ_WORD, ACPI_SBS_MANAGER,
0333                  0x04, (u8 *)&battery_system_info);
0334     if (!result)
0335         sbs->batteries_supported = battery_system_info & 0x000f;
0336     return result;
0337 }
0338 
0339 static int acpi_battery_get_info(struct acpi_battery *battery)
0340 {
0341     int i, result = 0;
0342 
0343     for (i = 0; i < ARRAY_SIZE(info_readers); ++i) {
0344         result = acpi_smbus_read(battery->sbs->hc,
0345                      info_readers[i].mode,
0346                      ACPI_SBS_BATTERY,
0347                      info_readers[i].command,
0348                      (u8 *) battery +
0349                         info_readers[i].offset);
0350         if (result)
0351             break;
0352     }
0353     return result;
0354 }
0355 
0356 static int acpi_battery_get_state(struct acpi_battery *battery)
0357 {
0358     int i, result = 0;
0359 
0360     if (battery->update_time &&
0361         time_before(jiffies, battery->update_time +
0362                 msecs_to_jiffies(cache_time)))
0363         return 0;
0364     for (i = 0; i < ARRAY_SIZE(state_readers); ++i) {
0365         result = acpi_smbus_read(battery->sbs->hc,
0366                      state_readers[i].mode,
0367                      ACPI_SBS_BATTERY,
0368                      state_readers[i].command,
0369                      (u8 *)battery +
0370                         state_readers[i].offset);
0371         if (result)
0372             goto end;
0373     }
0374       end:
0375     battery->update_time = jiffies;
0376     return result;
0377 }
0378 
0379 static int acpi_battery_get_alarm(struct acpi_battery *battery)
0380 {
0381     return acpi_smbus_read(battery->sbs->hc, SMBUS_READ_WORD,
0382                  ACPI_SBS_BATTERY, 0x01,
0383                  (u8 *)&battery->alarm_capacity);
0384 }
0385 
0386 static int acpi_battery_set_alarm(struct acpi_battery *battery)
0387 {
0388     struct acpi_sbs *sbs = battery->sbs;
0389     u16 value, sel = 1 << (battery->id + 12);
0390 
0391     int ret;
0392 
0393 
0394     if (sbs->manager_present) {
0395         ret = acpi_smbus_read(sbs->hc, SMBUS_READ_WORD, ACPI_SBS_MANAGER,
0396                 0x01, (u8 *)&value);
0397         if (ret)
0398             goto end;
0399         if ((value & 0xf000) != sel) {
0400             value &= 0x0fff;
0401             value |= sel;
0402             ret = acpi_smbus_write(sbs->hc, SMBUS_WRITE_WORD,
0403                      ACPI_SBS_MANAGER,
0404                      0x01, (u8 *)&value, 2);
0405             if (ret)
0406                 goto end;
0407         }
0408     }
0409     ret = acpi_smbus_write(sbs->hc, SMBUS_WRITE_WORD, ACPI_SBS_BATTERY,
0410                 0x01, (u8 *)&battery->alarm_capacity, 2);
0411       end:
0412     return ret;
0413 }
0414 
0415 static int acpi_ac_get_present(struct acpi_sbs *sbs)
0416 {
0417     int result;
0418     u16 status;
0419 
0420     result = acpi_smbus_read(sbs->hc, SMBUS_READ_WORD, ACPI_SBS_CHARGER,
0421                  0x13, (u8 *) & status);
0422 
0423     if (result)
0424         return result;
0425 
0426     /*
0427      * The spec requires that bit 4 always be 1. If it's not set, assume
0428      * that the implementation doesn't support an SBS charger.
0429      *
0430      * And on some MacBooks a status of 0xffff is always returned, no
0431      * matter whether the charger is plugged in or not, which is also
0432      * wrong, so ignore the SBS charger for those too.
0433      */
0434     if (!((status >> 4) & 0x1) || status == 0xffff)
0435         return -ENODEV;
0436 
0437     sbs->charger_present = (status >> 15) & 0x1;
0438     return 0;
0439 }
0440 
0441 static ssize_t acpi_battery_alarm_show(struct device *dev,
0442                     struct device_attribute *attr,
0443                     char *buf)
0444 {
0445     struct acpi_battery *battery = to_acpi_battery(dev_get_drvdata(dev));
0446     acpi_battery_get_alarm(battery);
0447     return sprintf(buf, "%d\n", battery->alarm_capacity *
0448                 acpi_battery_scale(battery) * 1000);
0449 }
0450 
0451 static ssize_t acpi_battery_alarm_store(struct device *dev,
0452                     struct device_attribute *attr,
0453                     const char *buf, size_t count)
0454 {
0455     unsigned long x;
0456     struct acpi_battery *battery = to_acpi_battery(dev_get_drvdata(dev));
0457     if (sscanf(buf, "%lu\n", &x) == 1)
0458         battery->alarm_capacity = x /
0459             (1000 * acpi_battery_scale(battery));
0460     if (battery->present)
0461         acpi_battery_set_alarm(battery);
0462     return count;
0463 }
0464 
0465 static const struct device_attribute alarm_attr = {
0466     .attr = {.name = "alarm", .mode = 0644},
0467     .show = acpi_battery_alarm_show,
0468     .store = acpi_battery_alarm_store,
0469 };
0470 
0471 /* --------------------------------------------------------------------------
0472                                  Driver Interface
0473    -------------------------------------------------------------------------- */
0474 static int acpi_battery_read(struct acpi_battery *battery)
0475 {
0476     int result = 0, saved_present = battery->present;
0477     u16 state;
0478 
0479     if (battery->sbs->manager_present) {
0480         result = acpi_smbus_read(battery->sbs->hc, SMBUS_READ_WORD,
0481                 ACPI_SBS_MANAGER, 0x01, (u8 *)&state);
0482         if (!result)
0483             battery->present = state & (1 << battery->id);
0484         state &= 0x0fff;
0485         state |= 1 << (battery->id + 12);
0486         acpi_smbus_write(battery->sbs->hc, SMBUS_WRITE_WORD,
0487                   ACPI_SBS_MANAGER, 0x01, (u8 *)&state, 2);
0488     } else if (battery->id == 0)
0489         battery->present = 1;
0490 
0491     if (result || !battery->present)
0492         return result;
0493 
0494     if (saved_present != battery->present) {
0495         battery->update_time = 0;
0496         result = acpi_battery_get_info(battery);
0497         if (result) {
0498             battery->present = 0;
0499             return result;
0500         }
0501     }
0502     result = acpi_battery_get_state(battery);
0503     if (result)
0504         battery->present = 0;
0505     return result;
0506 }
0507 
0508 /* Smart Battery */
0509 static int acpi_battery_add(struct acpi_sbs *sbs, int id)
0510 {
0511     struct acpi_battery *battery = &sbs->battery[id];
0512     struct power_supply_config psy_cfg = { .drv_data = battery, };
0513     int result;
0514 
0515     battery->id = id;
0516     battery->sbs = sbs;
0517     result = acpi_battery_read(battery);
0518     if (result)
0519         return result;
0520 
0521     sprintf(battery->name, ACPI_BATTERY_DIR_NAME, id);
0522     battery->bat_desc.name = battery->name;
0523     battery->bat_desc.type = POWER_SUPPLY_TYPE_BATTERY;
0524     if (!acpi_battery_mode(battery)) {
0525         battery->bat_desc.properties = sbs_charge_battery_props;
0526         battery->bat_desc.num_properties =
0527             ARRAY_SIZE(sbs_charge_battery_props);
0528     } else {
0529         battery->bat_desc.properties = sbs_energy_battery_props;
0530         battery->bat_desc.num_properties =
0531             ARRAY_SIZE(sbs_energy_battery_props);
0532     }
0533     battery->bat_desc.get_property = acpi_sbs_battery_get_property;
0534     battery->bat = power_supply_register(&sbs->device->dev,
0535                     &battery->bat_desc, &psy_cfg);
0536     if (IS_ERR(battery->bat)) {
0537         result = PTR_ERR(battery->bat);
0538         battery->bat = NULL;
0539         goto end;
0540     }
0541 
0542     result = device_create_file(&battery->bat->dev, &alarm_attr);
0543     if (result)
0544         goto end;
0545     battery->have_sysfs_alarm = 1;
0546       end:
0547     pr_info("%s [%s]: Battery Slot [%s] (battery %s)\n",
0548            ACPI_SBS_DEVICE_NAME, acpi_device_bid(sbs->device),
0549            battery->name, battery->present ? "present" : "absent");
0550     return result;
0551 }
0552 
0553 static void acpi_battery_remove(struct acpi_sbs *sbs, int id)
0554 {
0555     struct acpi_battery *battery = &sbs->battery[id];
0556 
0557     if (battery->bat) {
0558         if (battery->have_sysfs_alarm)
0559             device_remove_file(&battery->bat->dev, &alarm_attr);
0560         power_supply_unregister(battery->bat);
0561     }
0562 }
0563 
0564 static int acpi_charger_add(struct acpi_sbs *sbs)
0565 {
0566     int result;
0567     struct power_supply_config psy_cfg = { .drv_data = sbs, };
0568 
0569     result = acpi_ac_get_present(sbs);
0570     if (result)
0571         goto end;
0572 
0573     sbs->charger_exists = 1;
0574     sbs->charger = power_supply_register(&sbs->device->dev,
0575                     &acpi_sbs_charger_desc, &psy_cfg);
0576     if (IS_ERR(sbs->charger)) {
0577         result = PTR_ERR(sbs->charger);
0578         sbs->charger = NULL;
0579     }
0580     pr_info("%s [%s]: AC Adapter [%s] (%s)\n",
0581            ACPI_SBS_DEVICE_NAME, acpi_device_bid(sbs->device),
0582            ACPI_AC_DIR_NAME, sbs->charger_present ? "on-line" : "off-line");
0583 end:
0584     return result;
0585 }
0586 
0587 static void acpi_charger_remove(struct acpi_sbs *sbs)
0588 {
0589     if (sbs->charger)
0590         power_supply_unregister(sbs->charger);
0591 }
0592 
0593 static void acpi_sbs_callback(void *context)
0594 {
0595     int id;
0596     struct acpi_sbs *sbs = context;
0597     struct acpi_battery *bat;
0598     u8 saved_charger_state = sbs->charger_present;
0599     u8 saved_battery_state;
0600 
0601     if (sbs->charger_exists) {
0602         acpi_ac_get_present(sbs);
0603         if (sbs->charger_present != saved_charger_state)
0604             kobject_uevent(&sbs->charger->dev.kobj, KOBJ_CHANGE);
0605     }
0606 
0607     if (sbs->manager_present) {
0608         for (id = 0; id < MAX_SBS_BAT; ++id) {
0609             if (!(sbs->batteries_supported & (1 << id)))
0610                 continue;
0611             bat = &sbs->battery[id];
0612             saved_battery_state = bat->present;
0613             acpi_battery_read(bat);
0614             if (saved_battery_state == bat->present)
0615                 continue;
0616             kobject_uevent(&bat->bat->dev.kobj, KOBJ_CHANGE);
0617         }
0618     }
0619 }
0620 
0621 static int acpi_sbs_add(struct acpi_device *device)
0622 {
0623     struct acpi_sbs *sbs;
0624     int result = 0;
0625     int id;
0626 
0627     sbs = kzalloc(sizeof(struct acpi_sbs), GFP_KERNEL);
0628     if (!sbs) {
0629         result = -ENOMEM;
0630         goto end;
0631     }
0632 
0633     mutex_init(&sbs->lock);
0634 
0635     sbs->hc = acpi_driver_data(device->parent);
0636     sbs->device = device;
0637     strcpy(acpi_device_name(device), ACPI_SBS_DEVICE_NAME);
0638     strcpy(acpi_device_class(device), ACPI_SBS_CLASS);
0639     device->driver_data = sbs;
0640 
0641     result = acpi_charger_add(sbs);
0642     if (result && result != -ENODEV)
0643         goto end;
0644 
0645     result = 0;
0646 
0647     if (!x86_apple_machine) {
0648         result = acpi_manager_get_info(sbs);
0649         if (!result) {
0650             sbs->manager_present = 1;
0651             for (id = 0; id < MAX_SBS_BAT; ++id)
0652                 if ((sbs->batteries_supported & (1 << id)))
0653                     acpi_battery_add(sbs, id);
0654         }
0655     }
0656 
0657     if (!sbs->manager_present)
0658         acpi_battery_add(sbs, 0);
0659 
0660     acpi_smbus_register_callback(sbs->hc, acpi_sbs_callback, sbs);
0661 end:
0662     if (result)
0663         acpi_sbs_remove(device);
0664     return result;
0665 }
0666 
0667 static int acpi_sbs_remove(struct acpi_device *device)
0668 {
0669     struct acpi_sbs *sbs;
0670     int id;
0671 
0672     if (!device)
0673         return -EINVAL;
0674     sbs = acpi_driver_data(device);
0675     if (!sbs)
0676         return -EINVAL;
0677     mutex_lock(&sbs->lock);
0678     acpi_smbus_unregister_callback(sbs->hc);
0679     for (id = 0; id < MAX_SBS_BAT; ++id)
0680         acpi_battery_remove(sbs, id);
0681     acpi_charger_remove(sbs);
0682     mutex_unlock(&sbs->lock);
0683     mutex_destroy(&sbs->lock);
0684     kfree(sbs);
0685     return 0;
0686 }
0687 
0688 #ifdef CONFIG_PM_SLEEP
0689 static int acpi_sbs_resume(struct device *dev)
0690 {
0691     struct acpi_sbs *sbs;
0692     if (!dev)
0693         return -EINVAL;
0694     sbs = to_acpi_device(dev)->driver_data;
0695     acpi_sbs_callback(sbs);
0696     return 0;
0697 }
0698 #else
0699 #define acpi_sbs_resume NULL
0700 #endif
0701 
0702 static SIMPLE_DEV_PM_OPS(acpi_sbs_pm, NULL, acpi_sbs_resume);
0703 
0704 static struct acpi_driver acpi_sbs_driver = {
0705     .name = "sbs",
0706     .class = ACPI_SBS_CLASS,
0707     .ids = sbs_device_ids,
0708     .ops = {
0709         .add = acpi_sbs_add,
0710         .remove = acpi_sbs_remove,
0711         },
0712     .drv.pm = &acpi_sbs_pm,
0713 };
0714 module_acpi_driver(acpi_sbs_driver);
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!