Merge tag 'for-v4.1' of git://git.infradead.org/battery-2.6

Pull power supply and reset changes from Sebastian Reichel:

 - new API for safe access of power supply function attrs

 - devres support for power supply (un)registration

 - new drivers / chips:
     - generic syscon based poweroff driver
     - iio & charger driver for da9150
     - fuel gauge driver for axp288
     - bq27x00: add support for bq27510
     - bq2415x: add support for bq24157s

 - twl4030-madc-battery: convert to iio consumer

 - misc fixes

* tag 'for-v4.1' of git://git.infradead.org/battery-2.6: (66 commits)
  power: twl4030_madc_battery: Add missing MODULE_ALIAS
  power: twl4030-madc-battery: Convert to iio consumer.
  dt: power: Add docs for generic SYSCON poweroff driver.
  power: reset: Add generic SYSCON register mapped poweroff.
  power: max17042_battery: add missed blank
  power: max17042_battery: Use reg type instead of chip type
  power/reset: at91: big endian fixes for atsama5d3x
  power_supply: charger-manager: Fix dereferencing of ERR_PTR
  HID: input: Fix NULL pointer dereference when power_supply_register fails
  power: constify of_device_id array
  power/reset/rmobile-reset.c: Fix !HAS_IOMEM build
  power_supply: 88pm860x_charger: Fix possible NULL pointer dereference and use of initialized variable
  arm: mach-pxa: Decrement the power supply's device reference counter
  mfd: ab8500: Decrement the power supply's device reference counter
  power_supply: bq2415x_charger: Decrement the power supply's device reference counter
  power_supply: 88pm860x_charger: Decrement the power supply's device reference counter
  x86/olpc/xo15/sci: Use newly added power_supply_put API
  x86/olpc/xo1/sci: Use newly added power_supply_put API
  power_supply: charger-manager: Decrement the power supply's device reference counter
  power_supply: Increment power supply use counter when obtaining references
  ...

6 files changed, 121 insertions, 97 deletions

diff --git a/drivers/hid/hid-input.c b/drivers/hid/hid-input.c
index 052869d0ab78..32c2da49bd5b 100644
--- a/drivers/hid/hid-input.c
+++ b/drivers/hid/hid-input.c
@@ -339,7 +339,7 @@ static int hidinput_get_battery_property(struct power_supply *psy,
                                          enum power_supply_property prop,
                                          union power_supply_propval *val)
 {
-        struct hid_device *dev = container_of(psy, struct hid_device, battery);
+        struct hid_device *dev = power_supply_get_drvdata(psy);
         int ret = 0;
         __u8 *buf;
 
@@ -397,26 +397,32 @@ static int hidinput_get_battery_property(struct power_supply *psy,
 
 static bool hidinput_setup_battery(struct hid_device *dev, unsigned report_type, struct hid_field *field)
 {
-        struct power_supply *battery = &dev->battery;
-        int ret;
+        struct power_supply_desc *psy_desc = NULL;
+        struct power_supply_config psy_cfg = { .drv_data = dev, };
         unsigned quirks;
         s32 min, max;
 
         if (field->usage->hid != HID_DC_BATTERYSTRENGTH)
                 return false;   /* no match */
 
-        if (battery->name != NULL)
+        if (dev->battery != NULL)
                 goto out;       /* already initialized? */
 
-        battery->name = kasprintf(GFP_KERNEL, "hid-%s-battery", dev->uniq);
-        if (battery->name == NULL)
+        psy_desc = kzalloc(sizeof(*psy_desc), GFP_KERNEL);
+        if (psy_desc == NULL)
                 goto out;
 
-        battery->type = POWER_SUPPLY_TYPE_BATTERY;
-        battery->properties = hidinput_battery_props;
-        battery->num_properties = ARRAY_SIZE(hidinput_battery_props);
-        battery->use_for_apm = 0;
-        battery->get_property = hidinput_get_battery_property;
+        psy_desc->name = kasprintf(GFP_KERNEL, "hid-%s-battery", dev->uniq);
+        if (psy_desc->name == NULL) {
+                kfree(psy_desc);
+                goto out;
+        }
+
+        psy_desc->type = POWER_SUPPLY_TYPE_BATTERY;
+        psy_desc->properties = hidinput_battery_props;
+        psy_desc->num_properties = ARRAY_SIZE(hidinput_battery_props);
+        psy_desc->use_for_apm = 0;
+        psy_desc->get_property = hidinput_get_battery_property;
 
         quirks = find_battery_quirk(dev);
 
@@ -439,27 +445,30 @@ static bool hidinput_setup_battery(struct hid_device *dev, unsigned report_type,
         dev->battery_report_type = report_type;
         dev->battery_report_id = field->report->id;
 
-        ret = power_supply_register(&dev->dev, battery);
-        if (ret != 0) {
-                hid_warn(dev, "can't register power supply: %d\n", ret);
-                kfree(battery->name);
-                battery->name = NULL;
+        dev->battery = power_supply_register(&dev->dev, psy_desc, &psy_cfg);
+        if (IS_ERR(dev->battery)) {
+                hid_warn(dev, "can't register power supply: %ld\n",
+                                PTR_ERR(dev->battery));
+                kfree(psy_desc->name);
+                kfree(psy_desc);
+                dev->battery = NULL;
+        } else {
+                power_supply_powers(dev->battery, &dev->dev);
         }
 
-        power_supply_powers(battery, &dev->dev);
-
 out:
         return true;
 }
 
 static void hidinput_cleanup_battery(struct hid_device *dev)
 {
-        if (!dev->battery.name)
+        if (!dev->battery)
                 return;
 
-        power_supply_unregister(&dev->battery);
-        kfree(dev->battery.name);
-        dev->battery.name = NULL;
+        power_supply_unregister(dev->battery);
+        kfree(dev->battery->desc->name);
+        kfree(dev->battery->desc);
+        dev->battery = NULL;
 }
 #else  /* !CONFIG_HID_BATTERY_STRENGTH */
 static bool hidinput_setup_battery(struct hid_device *dev, unsigned report_type,
diff --git a/drivers/hid/hid-sony.c b/drivers/hid/hid-sony.c
index 1896c019e302..c906300cf667 100644
--- a/drivers/hid/hid-sony.c
+++ b/drivers/hid/hid-sony.c
@@ -815,7 +815,8 @@ struct sony_sc {
         struct led_classdev *leds[MAX_LEDS];
         unsigned long quirks;
         struct work_struct state_worker;
-        struct power_supply battery;
+        struct power_supply *battery;
+        struct power_supply_desc battery_desc;
         int device_id;
         __u8 *output_report_dmabuf;
 
@@ -1660,7 +1661,7 @@ static int sony_battery_get_property(struct power_supply *psy,
                                      enum power_supply_property psp,
                                      union power_supply_propval *val)
 {
-        struct sony_sc *sc = container_of(psy, struct sony_sc, battery);
+        struct sony_sc *sc = power_supply_get_drvdata(psy);
         unsigned long flags;
         int ret = 0;
         u8 battery_charging, battery_capacity, cable_state;
@@ -1699,6 +1700,7 @@ static int sony_battery_get_property(struct power_supply *psy,
 
 static int sony_battery_probe(struct sony_sc *sc)
 {
+        struct power_supply_config psy_cfg = { .drv_data = sc, };
         struct hid_device *hdev = sc->hdev;
         int ret;
 
@@ -1708,39 +1710,42 @@ static int sony_battery_probe(struct sony_sc *sc)
          */
         sc->battery_capacity = 100;
 
-        sc->battery.properties = sony_battery_props;
-        sc->battery.num_properties = ARRAY_SIZE(sony_battery_props);
-        sc->battery.get_property = sony_battery_get_property;
-        sc->battery.type = POWER_SUPPLY_TYPE_BATTERY;
-        sc->battery.use_for_apm = 0;
-        sc->battery.name = kasprintf(GFP_KERNEL, "sony_controller_battery_%pMR",
-                                     sc->mac_address);
-        if (!sc->battery.name)
+        sc->battery_desc.properties = sony_battery_props;
+        sc->battery_desc.num_properties = ARRAY_SIZE(sony_battery_props);
+        sc->battery_desc.get_property = sony_battery_get_property;
+        sc->battery_desc.type = POWER_SUPPLY_TYPE_BATTERY;
+        sc->battery_desc.use_for_apm = 0;
+        sc->battery_desc.name = kasprintf(GFP_KERNEL,
+                                          "sony_controller_battery_%pMR",
+                                          sc->mac_address);
+        if (!sc->battery_desc.name)
                 return -ENOMEM;
 
-        ret = power_supply_register(&hdev->dev, &sc->battery);
-        if (ret) {
+        sc->battery = power_supply_register(&hdev->dev, &sc->battery_desc,
+                                            &psy_cfg);
+        if (IS_ERR(sc->battery)) {
+                ret = PTR_ERR(sc->battery);
                 hid_err(hdev, "Unable to register battery device\n");
                 goto err_free;
         }
 
-        power_supply_powers(&sc->battery, &hdev->dev);
+        power_supply_powers(sc->battery, &hdev->dev);
         return 0;
 
 err_free:
-        kfree(sc->battery.name);
-        sc->battery.name = NULL;
+        kfree(sc->battery_desc.name);
+        sc->battery_desc.name = NULL;
         return ret;
 }
 
 static void sony_battery_remove(struct sony_sc *sc)
 {
-        if (!sc->battery.name)
+        if (!sc->battery_desc.name)
                 return;
 
-        power_supply_unregister(&sc->battery);
-        kfree(sc->battery.name);
-        sc->battery.name = NULL;
+        power_supply_unregister(sc->battery);
+        kfree(sc->battery_desc.name);
+        sc->battery_desc.name = NULL;
 }
 
 /*
diff --git a/drivers/hid/hid-wiimote-modules.c b/drivers/hid/hid-wiimote-modules.c
index 6b61f01e01e7..05e23c417d50 100644
--- a/drivers/hid/hid-wiimote-modules.c
+++ b/drivers/hid/hid-wiimote-modules.c
@@ -203,8 +203,7 @@ static int wiimod_battery_get_property(struct power_supply *psy,
                                        enum power_supply_property psp,
                                        union power_supply_propval *val)
 {
-        struct wiimote_data *wdata = container_of(psy, struct wiimote_data,
-                                                  battery);
+        struct wiimote_data *wdata = power_supply_get_drvdata(psy);
         int ret = 0, state;
         unsigned long flags;
 
@@ -238,42 +237,46 @@ static int wiimod_battery_get_property(struct power_supply *psy,
 static int wiimod_battery_probe(const struct wiimod_ops *ops,
                                 struct wiimote_data *wdata)
 {
+        struct power_supply_config psy_cfg = { .drv_data = wdata, };
         int ret;
 
-        wdata->battery.properties = wiimod_battery_props;
-        wdata->battery.num_properties = ARRAY_SIZE(wiimod_battery_props);
-        wdata->battery.get_property = wiimod_battery_get_property;
-        wdata->battery.type = POWER_SUPPLY_TYPE_BATTERY;
-        wdata->battery.use_for_apm = 0;
-        wdata->battery.name = kasprintf(GFP_KERNEL, "wiimote_battery_%s",
-                                        wdata->hdev->uniq);
-        if (!wdata->battery.name)
+        wdata->battery_desc.properties = wiimod_battery_props;
+        wdata->battery_desc.num_properties = ARRAY_SIZE(wiimod_battery_props);
+        wdata->battery_desc.get_property = wiimod_battery_get_property;
+        wdata->battery_desc.type = POWER_SUPPLY_TYPE_BATTERY;
+        wdata->battery_desc.use_for_apm = 0;
+        wdata->battery_desc.name = kasprintf(GFP_KERNEL, "wiimote_battery_%s",
+                                             wdata->hdev->uniq);
+        if (!wdata->battery_desc.name)
                 return -ENOMEM;
 
-        ret = power_supply_register(&wdata->hdev->dev, &wdata->battery);
-        if (ret) {
+        wdata->battery = power_supply_register(&wdata->hdev->dev,
+                                               &wdata->battery_desc,
+                                               &psy_cfg);
+        if (IS_ERR(wdata->battery)) {
                 hid_err(wdata->hdev, "cannot register battery device\n");
+                ret = PTR_ERR(wdata->battery);
                 goto err_free;
         }
 
-        power_supply_powers(&wdata->battery, &wdata->hdev->dev);
+        power_supply_powers(wdata->battery, &wdata->hdev->dev);
         return 0;
 
 err_free:
-        kfree(wdata->battery.name);
-        wdata->battery.name = NULL;
+        kfree(wdata->battery_desc.name);
+        wdata->battery_desc.name = NULL;
         return ret;
 }
 
 static void wiimod_battery_remove(const struct wiimod_ops *ops,
                                   struct wiimote_data *wdata)
 {
-        if (!wdata->battery.name)
+        if (!wdata->battery_desc.name)
                 return;
 
-        power_supply_unregister(&wdata->battery);
-        kfree(wdata->battery.name);
-        wdata->battery.name = NULL;
+        power_supply_unregister(wdata->battery);
+        kfree(wdata->battery_desc.name);
+        wdata->battery_desc.name = NULL;
 }
 
 static const struct wiimod_ops wiimod_battery = {
diff --git a/drivers/hid/hid-wiimote.h b/drivers/hid/hid-wiimote.h
index 10934aa129fb..875694d43e4d 100644
--- a/drivers/hid/hid-wiimote.h
+++ b/drivers/hid/hid-wiimote.h
@@ -147,7 +147,8 @@ struct wiimote_data {
         struct led_classdev *leds[4];
         struct input_dev *accel;
         struct input_dev *ir;
-        struct power_supply battery;
+        struct power_supply *battery;
+        struct power_supply_desc battery_desc;
         struct input_dev *mp;
         struct timer_list timer;
         struct wiimote_debug *debug;
diff --git a/drivers/hid/wacom.h b/drivers/hid/wacom.h
index 7db432809e9e..0d0d0dd89d17 100644
--- a/drivers/hid/wacom.h
+++ b/drivers/hid/wacom.h
@@ -119,8 +119,10 @@ struct wacom {
                 u8 img_lum;   /* OLED matrix display brightness */
         } led;
         bool led_initialized;
-        struct power_supply battery;
-        struct power_supply ac;
+        struct power_supply *battery;
+        struct power_supply *ac;
+        struct power_supply_desc battery_desc;
+        struct power_supply_desc ac_desc;
 };
 
 static inline void wacom_schedule_work(struct wacom_wac *wacom_wac)
@@ -133,7 +135,7 @@ static inline void wacom_notify_battery(struct wacom_wac *wacom_wac)
 {
         struct wacom *wacom = container_of(wacom_wac, struct wacom, wacom_wac);
 
-        power_supply_changed(&wacom->battery);
+        power_supply_changed(wacom->battery);
 }
 
 extern const struct hid_device_id wacom_ids[];
diff --git a/drivers/hid/wacom_sys.c b/drivers/hid/wacom_sys.c
index f0568a7e6de9..ba9af470bea0 100644
--- a/drivers/hid/wacom_sys.c
+++ b/drivers/hid/wacom_sys.c
@@ -944,7 +944,7 @@ static int wacom_battery_get_property(struct power_supply *psy,
                                       enum power_supply_property psp,
                                       union power_supply_propval *val)
 {
-        struct wacom *wacom = container_of(psy, struct wacom, battery);
+        struct wacom *wacom = power_supply_get_drvdata(psy);
         int ret = 0;
 
         switch (psp) {
@@ -976,7 +976,7 @@ static int wacom_ac_get_property(struct power_supply *psy,
                                 enum power_supply_property psp,
                                 union power_supply_propval *val)
 {
-        struct wacom *wacom = container_of(psy, struct wacom, ac);
+        struct wacom *wacom = power_supply_get_drvdata(psy);
         int ret = 0;
 
         switch (psp) {
@@ -998,42 +998,46 @@ static int wacom_ac_get_property(struct power_supply *psy,
 static int wacom_initialize_battery(struct wacom *wacom)
 {
         static atomic_t battery_no = ATOMIC_INIT(0);
-        int error;
+        struct power_supply_config psy_cfg = { .drv_data = wacom, };
         unsigned long n;
 
         if (wacom->wacom_wac.features.quirks & WACOM_QUIRK_BATTERY) {
+                struct power_supply_desc *bat_desc = &wacom->battery_desc;
+                struct power_supply_desc *ac_desc = &wacom->ac_desc;
                 n = atomic_inc_return(&battery_no) - 1;
 
-                wacom->battery.properties = wacom_battery_props;
-                wacom->battery.num_properties = ARRAY_SIZE(wacom_battery_props);
-                wacom->battery.get_property = wacom_battery_get_property;
+                bat_desc->properties = wacom_battery_props;
+                bat_desc->num_properties = ARRAY_SIZE(wacom_battery_props);
+                bat_desc->get_property = wacom_battery_get_property;
                 sprintf(wacom->wacom_wac.bat_name, "wacom_battery_%ld", n);
-                wacom->battery.name = wacom->wacom_wac.bat_name;
-                wacom->battery.type = POWER_SUPPLY_TYPE_BATTERY;
-                wacom->battery.use_for_apm = 0;
+                bat_desc->name = wacom->wacom_wac.bat_name;
+                bat_desc->type = POWER_SUPPLY_TYPE_BATTERY;
+                bat_desc->use_for_apm = 0;
 
-                wacom->ac.properties = wacom_ac_props;
-                wacom->ac.num_properties = ARRAY_SIZE(wacom_ac_props);
-                wacom->ac.get_property = wacom_ac_get_property;
+                ac_desc->properties = wacom_ac_props;
+                ac_desc->num_properties = ARRAY_SIZE(wacom_ac_props);
+                ac_desc->get_property = wacom_ac_get_property;
                 sprintf(wacom->wacom_wac.ac_name, "wacom_ac_%ld", n);
-                wacom->ac.name = wacom->wacom_wac.ac_name;
-                wacom->ac.type = POWER_SUPPLY_TYPE_MAINS;
-                wacom->ac.use_for_apm = 0;
-
-                error = power_supply_register(&wacom->hdev->dev,
-                                              &wacom->battery);
-                if (error)
-                        return error;
-
-                power_supply_powers(&wacom->battery, &wacom->hdev->dev);
-
-                error = power_supply_register(&wacom->hdev->dev, &wacom->ac);
-                if (error) {
-                        power_supply_unregister(&wacom->battery);
-                        return error;
+                ac_desc->name = wacom->wacom_wac.ac_name;
+                ac_desc->type = POWER_SUPPLY_TYPE_MAINS;
+                ac_desc->use_for_apm = 0;
+
+                wacom->battery = power_supply_register(&wacom->hdev->dev,
+                                              &wacom->battery_desc, &psy_cfg);
+                if (IS_ERR(wacom->battery))
+                        return PTR_ERR(wacom->battery);
+
+                power_supply_powers(wacom->battery, &wacom->hdev->dev);
+
+                wacom->ac = power_supply_register(&wacom->hdev->dev,
+                                                  &wacom->ac_desc,
+                                                  &psy_cfg);
+                if (IS_ERR(wacom->ac)) {
+                        power_supply_unregister(wacom->battery);
+                        return PTR_ERR(wacom->ac);
                 }
 
-                power_supply_powers(&wacom->ac, &wacom->hdev->dev);
+                power_supply_powers(wacom->ac, &wacom->hdev->dev);
         }
 
         return 0;
@@ -1042,11 +1046,11 @@ static int wacom_initialize_battery(struct wacom *wacom)
 static void wacom_destroy_battery(struct wacom *wacom)
 {
         if ((wacom->wacom_wac.features.quirks & WACOM_QUIRK_BATTERY) &&
-             wacom->battery.dev) {
-                power_supply_unregister(&wacom->battery);
-                wacom->battery.dev = NULL;
-                power_supply_unregister(&wacom->ac);
-                wacom->ac.dev = NULL;
+             wacom->battery) {
+                power_supply_unregister(wacom->battery);
+                wacom->battery = NULL;
+                power_supply_unregister(wacom->ac);
+                wacom->ac = NULL;
         }
 }