greybus: battery: move implementation to power_supply

Rename protocol to POWER_SUPPLY and implementation details from battery
to power_supply.

Also fix some tabs between define and macro name.

Signed-off-by: Rui Miguel Silva <rui.silva@linaro.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@google.com>

diff --git a/drivers/staging/greybus/greybus_manifest.h b/drivers/staging/greybus/greybus_manifest.h
index f29f470909c91a7602dca14da3414fb3fd85cde6..c36c4d1d30f9fe3803dafa5ffa4c93dfe39f5695 100644 (file)
--- a/drivers/staging/greybus/greybus_manifest.h
+++ b/drivers/staging/greybus/greybus_manifest.h
@@ -30,7 +30,7 @@ enum greybus_protocol {
        GREYBUS_PROTOCOL_HID            = 0x05,
        GREYBUS_PROTOCOL_USB            = 0x06,
        GREYBUS_PROTOCOL_SDIO           = 0x07,
-       GREYBUS_PROTOCOL_BATTERY        = 0x08,
+       GREYBUS_PROTOCOL_POWER_SUPPLY   = 0x08,
        GREYBUS_PROTOCOL_PWM            = 0x09,
        /* 0x0a is unused */
        GREYBUS_PROTOCOL_SPI            = 0x0b,
@@ -58,7 +58,7 @@ enum greybus_class_type {
        GREYBUS_CLASS_HID               = 0x05,
        GREYBUS_CLASS_USB               = 0x06,
        GREYBUS_CLASS_SDIO              = 0x07,
-       GREYBUS_CLASS_BATTERY           = 0x08,
+       GREYBUS_CLASS_POWER_SUPPLY      = 0x08,
        GREYBUS_CLASS_PWM               = 0x09,
        /* 0x0a is unused */
        GREYBUS_CLASS_SPI               = 0x0b,

diff --git a/drivers/staging/greybus/greybus_protocols.h b/drivers/staging/greybus/greybus_protocols.h
index 1142b20949014ffdf0b86fa9bf899b3c227f845f..b2380403edc64cb5ace309895e107cc0cf93c360 100644 (file)
--- a/drivers/staging/greybus/greybus_protocols.h
+++ b/drivers/staging/greybus/greybus_protocols.h
@@ -198,60 +198,60 @@ struct gb_firmware_ready_to_boot_request {
 /* Firmware protocol Ready to boot response has no payload */
 
 
-/* BATTERY */
-
-/* Version of the Greybus battery protocol we support */
-#define        GB_BATTERY_VERSION_MAJOR                0x00
-#define        GB_BATTERY_VERSION_MINOR                0x01
-
-/* Greybus battery request types */
-#define        GB_BATTERY_TYPE_TECHNOLOGY              0x02
-#define        GB_BATTERY_TYPE_STATUS                  0x03
-#define        GB_BATTERY_TYPE_MAX_VOLTAGE             0x04
-#define        GB_BATTERY_TYPE_PERCENT_CAPACITY        0x05
-#define        GB_BATTERY_TYPE_TEMPERATURE             0x06
-#define        GB_BATTERY_TYPE_VOLTAGE                 0x07
-#define        GB_BATTERY_TYPE_CURRENT                 0x08
-#define GB_BATTERY_TYPE_CAPACITY               0x09    // TODO - POWER_SUPPLY_PROP_CURRENT_MAX
-#define GB_BATTERY_TYPE_SHUTDOWN_TEMP          0x0a    // TODO - POWER_SUPPLY_PROP_TEMP_ALERT_MAX
-
-/* Should match up with battery types in linux/power_supply.h */
-#define GB_BATTERY_TECH_UNKNOWN                        0x0000
-#define GB_BATTERY_TECH_NiMH                   0x0001
-#define GB_BATTERY_TECH_LION                   0x0002
-#define GB_BATTERY_TECH_LIPO                   0x0003
-#define GB_BATTERY_TECH_LiFe                   0x0004
-#define GB_BATTERY_TECH_NiCd                   0x0005
-#define GB_BATTERY_TECH_LiMn                   0x0006
-
-struct gb_battery_technology_response {
+/* Power Supply */
+
+/* Version of the Greybus power supply protocol we support */
+#define GB_POWER_SUPPLY_VERSION_MAJOR          0x00
+#define GB_POWER_SUPPLY_VERSION_MINOR          0x01
+
+/* Greybus power supply request types */
+#define GB_POWER_SUPPLY_TYPE_TECHNOLOGY                        0x02
+#define GB_POWER_SUPPLY_TYPE_STATUS                    0x03
+#define GB_POWER_SUPPLY_TYPE_MAX_VOLTAGE               0x04
+#define GB_POWER_SUPPLY_TYPE_PERCENT_CAPACITY          0x05
+#define GB_POWER_SUPPLY_TYPE_TEMPERATURE               0x06
+#define GB_POWER_SUPPLY_TYPE_VOLTAGE                   0x07
+#define GB_POWER_SUPPLY_TYPE_CURRENT                   0x08
+#define GB_POWER_SUPPLY_TYPE_CAPACITY                  0x09    // TODO - POWER_SUPPLY_PROP_CURRENT_MAX
+#define GB_POWER_SUPPLY_TYPE_SHUTDOWN_TEMP             0x0a    // TODO - POWER_SUPPLY_PROP_TEMP_ALERT_MAX
+
+/* Should match up with battery technology types in linux/power_supply.h */
+#define GB_POWER_SUPPLY_TECH_UNKNOWN                   0x0000
+#define GB_POWER_SUPPLY_TECH_NiMH                      0x0001
+#define GB_POWER_SUPPLY_TECH_LION                      0x0002
+#define GB_POWER_SUPPLY_TECH_LIPO                      0x0003
+#define GB_POWER_SUPPLY_TECH_LiFe                      0x0004
+#define GB_POWER_SUPPLY_TECH_NiCd                      0x0005
+#define GB_POWER_SUPPLY_TECH_LiMn                      0x0006
+
+struct gb_power_supply_technology_response {
        __le32  technology;
 } __packed;
 
-/* Should match up with battery status in linux/power_supply.h */
-#define GB_BATTERY_STATUS_UNKNOWN              0x0000
-#define GB_BATTERY_STATUS_CHARGING             0x0001
-#define GB_BATTERY_STATUS_DISCHARGING          0x0002
-#define GB_BATTERY_STATUS_NOT_CHARGING         0x0003
-#define GB_BATTERY_STATUS_FULL                 0x0004
+/* Should match up with power supply status in linux/power_supply.h */
+#define GB_POWER_SUPPLY_STATUS_UNKNOWN                 0x0000
+#define GB_POWER_SUPPLY_STATUS_CHARGING                        0x0001
+#define GB_POWER_SUPPLY_STATUS_DISCHARGING             0x0002
+#define GB_POWER_SUPPLY_STATUS_NOT_CHARGING            0x0003
+#define GB_POWER_SUPPLY_STATUS_FULL                    0x0004
 
-struct gb_battery_status_response {
-       __le16  battery_status;
+struct gb_power_supply_status_response {
+       __le16  psy_status;
 } __packed;
 
-struct gb_battery_max_voltage_response {
+struct gb_power_supply_max_voltage_response {
        __le32  max_voltage;
 } __packed;
 
-struct gb_battery_capacity_response {
+struct gb_power_supply_capacity_response {
        __le32  capacity;
 } __packed;
 
-struct gb_battery_temperature_response {
+struct gb_power_supply_temperature_response {
        __le32  temperature;
 } __packed;
 
-struct gb_battery_voltage_response {
+struct gb_power_supply_voltage_response {
        __le32  voltage;
 } __packed;
 

diff --git a/drivers/staging/greybus/power_supply.c b/drivers/staging/greybus/power_supply.c
index e119775fb19bfb80526854d85623b010730ff566..d7797a24e00dd27bc04da2c3f4b0581abaff15a6 100644 (file)
--- a/drivers/staging/greybus/power_supply.c
+++ b/drivers/staging/greybus/power_supply.c
@@ -1,5 +1,5 @@
 /*
- * Battery driver for a Greybus module.
+ * Power Supply driver for a Greybus module.
  *
  * Copyright 2014 Google Inc.
  * Copyright 2014 Linaro Ltd.
@@ -13,35 +13,36 @@
 #include <linux/power_supply.h>
 #include "greybus.h"
 
-struct gb_battery {
+struct gb_power_supply {
        /*
         * The power supply api changed in 4.1, so handle both the old
         * and new apis in the same driver for now, until this is merged
         * upstream, when all of these version checks can be removed.
         */
 #ifdef DRIVER_OWNS_PSY_STRUCT
-       struct power_supply bat;
-#define to_gb_battery(x) container_of(x, struct gb_battery, bat)
+       struct power_supply psy;
+#define to_gb_power_supply(x) container_of(x, struct gb_power_supply, psy)
 #else
-       struct power_supply *bat;
+       struct power_supply *psy;
        struct power_supply_desc desc;
-#define to_gb_battery(x) power_supply_get_drvdata(x)
+#define to_gb_power_supply(x) power_supply_get_drvdata(x)
 #endif
        // FIXME
-       // we will want to keep the battery stats in here as we will be getting
-       // updates from the SVC "on the fly" so we don't have to always go ask
-       // the battery for some information.  Hopefully...
+       // we will want to keep the power supply stats in here as we will be
+       // getting updates from the SVC "on the fly" so we don't have to always
+       // go ask the power supply for some information. Hopefully...
        struct gb_connection *connection;
 
 };
 
-static int get_tech(struct gb_battery *gb)
+static int get_tech(struct gb_power_supply *gb)
 {
-       struct gb_battery_technology_response tech_response;
+       struct gb_power_supply_technology_response tech_response;
        u32 technology;
        int retval;
 
-       retval = gb_operation_sync(gb->connection, GB_BATTERY_TYPE_TECHNOLOGY,
+       retval = gb_operation_sync(gb->connection,
+                                  GB_POWER_SUPPLY_TYPE_TECHNOLOGY,
                                   NULL, 0,
                                   &tech_response, sizeof(tech_response));
        if (retval)
@@ -54,25 +55,25 @@ static int get_tech(struct gb_battery *gb)
         */
        technology = le32_to_cpu(tech_response.technology);
        switch (technology) {
-       case GB_BATTERY_TECH_NiMH:
+       case GB_POWER_SUPPLY_TECH_NiMH:
                technology = POWER_SUPPLY_TECHNOLOGY_NiMH;
                break;
-       case GB_BATTERY_TECH_LION:
+       case GB_POWER_SUPPLY_TECH_LION:
                technology = POWER_SUPPLY_TECHNOLOGY_LION;
                break;
-       case GB_BATTERY_TECH_LIPO:
+       case GB_POWER_SUPPLY_TECH_LIPO:
                technology = POWER_SUPPLY_TECHNOLOGY_LIPO;
                break;
-       case GB_BATTERY_TECH_LiFe:
+       case GB_POWER_SUPPLY_TECH_LiFe:
                technology = POWER_SUPPLY_TECHNOLOGY_LiFe;
                break;
-       case GB_BATTERY_TECH_NiCd:
+       case GB_POWER_SUPPLY_TECH_NiCd:
                technology = POWER_SUPPLY_TECHNOLOGY_NiCd;
                break;
-       case GB_BATTERY_TECH_LiMn:
+       case GB_POWER_SUPPLY_TECH_LiMn:
                technology = POWER_SUPPLY_TECHNOLOGY_LiMn;
                break;
-       case GB_BATTERY_TECH_UNKNOWN:
+       case GB_POWER_SUPPLY_TECH_UNKNOWN:
        default:
                technology = POWER_SUPPLY_TECHNOLOGY_UNKNOWN;
                break;
@@ -80,13 +81,13 @@ static int get_tech(struct gb_battery *gb)
        return technology;
 }
 
-static int get_status(struct gb_battery *gb)
+static int get_status(struct gb_power_supply *gb)
 {
-       struct gb_battery_status_response status_response;
-       u16 battery_status;
+       struct gb_power_supply_status_response status_response;
+       u16 psy_status;
        int retval;
 
-       retval = gb_operation_sync(gb->connection, GB_BATTERY_TYPE_STATUS,
+       retval = gb_operation_sync(gb->connection, GB_POWER_SUPPLY_TYPE_STATUS,
                                   NULL, 0,
                                   &status_response, sizeof(status_response));
        if (retval)
@@ -97,35 +98,36 @@ static int get_status(struct gb_battery *gb)
         * "identical" which should allow gcc to optimize the code away to
         * nothing.
         */
-       battery_status = le16_to_cpu(status_response.battery_status);
-       switch (battery_status) {
-       case GB_BATTERY_STATUS_CHARGING:
-               battery_status = POWER_SUPPLY_STATUS_CHARGING;
+       psy_status = le16_to_cpu(status_response.psy_status);
+       switch (psy_status) {
+       case GB_POWER_SUPPLY_STATUS_CHARGING:
+               psy_status = POWER_SUPPLY_STATUS_CHARGING;
                break;
-       case GB_BATTERY_STATUS_DISCHARGING:
-               battery_status = POWER_SUPPLY_STATUS_DISCHARGING;
+       case GB_POWER_SUPPLY_STATUS_DISCHARGING:
+               psy_status = POWER_SUPPLY_STATUS_DISCHARGING;
                break;
-       case GB_BATTERY_STATUS_NOT_CHARGING:
-               battery_status = POWER_SUPPLY_STATUS_NOT_CHARGING;
+       case GB_POWER_SUPPLY_STATUS_NOT_CHARGING:
+               psy_status = POWER_SUPPLY_STATUS_NOT_CHARGING;
                break;
-       case GB_BATTERY_STATUS_FULL:
-               battery_status = POWER_SUPPLY_STATUS_FULL;
+       case GB_POWER_SUPPLY_STATUS_FULL:
+               psy_status = POWER_SUPPLY_STATUS_FULL;
                break;
-       case GB_BATTERY_STATUS_UNKNOWN:
+       case GB_POWER_SUPPLY_STATUS_UNKNOWN:
        default:
-               battery_status = POWER_SUPPLY_STATUS_UNKNOWN;
+               psy_status = POWER_SUPPLY_STATUS_UNKNOWN;
                break;
        }
-       return battery_status;
+       return psy_status;
 }
 
-static int get_max_voltage(struct gb_battery *gb)
+static int get_max_voltage(struct gb_power_supply *gb)
 {
-       struct gb_battery_max_voltage_response volt_response;
+       struct gb_power_supply_max_voltage_response volt_response;
        u32 max_voltage;
        int retval;
 
-       retval = gb_operation_sync(gb->connection, GB_BATTERY_TYPE_MAX_VOLTAGE,
+       retval = gb_operation_sync(gb->connection,
+                                  GB_POWER_SUPPLY_TYPE_MAX_VOLTAGE,
                                   NULL, 0,
                                   &volt_response, sizeof(volt_response));
        if (retval)
@@ -135,14 +137,14 @@ static int get_max_voltage(struct gb_battery *gb)
        return max_voltage;
 }
 
-static int get_percent_capacity(struct gb_battery *gb)
+static int get_percent_capacity(struct gb_power_supply *gb)
 {
-       struct gb_battery_capacity_response capacity_response;
+       struct gb_power_supply_capacity_response capacity_response;
        u32 capacity;
        int retval;
 
        retval = gb_operation_sync(gb->connection,
-                                  GB_BATTERY_TYPE_PERCENT_CAPACITY,
+                                  GB_POWER_SUPPLY_TYPE_PERCENT_CAPACITY,
                                   NULL, 0, &capacity_response,
                                   sizeof(capacity_response));
        if (retval)
@@ -152,13 +154,14 @@ static int get_percent_capacity(struct gb_battery *gb)
        return capacity;
 }
 
-static int get_temp(struct gb_battery *gb)
+static int get_temp(struct gb_power_supply *gb)
 {
-       struct gb_battery_temperature_response temp_response;
+       struct gb_power_supply_temperature_response temp_response;
        u32 temperature;
        int retval;
 
-       retval = gb_operation_sync(gb->connection, GB_BATTERY_TYPE_TEMPERATURE,
+       retval = gb_operation_sync(gb->connection,
+                                  GB_POWER_SUPPLY_TYPE_TEMPERATURE,
                                   NULL, 0,
                                   &temp_response, sizeof(temp_response));
        if (retval)
@@ -168,13 +171,13 @@ static int get_temp(struct gb_battery *gb)
        return temperature;
 }
 
-static int get_voltage(struct gb_battery *gb)
+static int get_voltage(struct gb_power_supply *gb)
 {
-       struct gb_battery_voltage_response voltage_response;
+       struct gb_power_supply_voltage_response voltage_response;
        u32 voltage;
        int retval;
 
-       retval = gb_operation_sync(gb->connection, GB_BATTERY_TYPE_VOLTAGE,
+       retval = gb_operation_sync(gb->connection, GB_POWER_SUPPLY_TYPE_VOLTAGE,
                                   NULL, 0,
                                   &voltage_response, sizeof(voltage_response));
        if (retval)
@@ -188,7 +191,7 @@ static int get_property(struct power_supply *b,
                        enum power_supply_property psp,
                        union power_supply_propval *val)
 {
-       struct gb_battery *gb = to_gb_battery(b);
+       struct gb_power_supply *gb = to_gb_power_supply(b);
 
        switch (psp) {
        case POWER_SUPPLY_PROP_TECHNOLOGY:
@@ -223,7 +226,7 @@ static int get_property(struct power_supply *b,
 }
 
 // FIXME - verify this list, odds are some can be removed and others added.
-static enum power_supply_property battery_props[] = {
+static enum power_supply_property psy_props[] = {
        POWER_SUPPLY_PROP_TECHNOLOGY,
        POWER_SUPPLY_PROP_STATUS,
        POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN,
@@ -238,17 +241,17 @@ static int init_and_register(struct gb_connection *connection,
 {
        // FIXME - get a better (i.e. unique) name
        // FIXME - anything else needs to be set?
-       gb->bat.name            = "gb_battery";
-       gb->bat.type            = POWER_SUPPLY_TYPE_BATTERY;
-       gb->bat.properties      = battery_props;
-       gb->bat.num_properties  = ARRAY_SIZE(battery_props);
-       gb->bat.get_property    = get_property;
+       gb->psy.name            = "gb_battery";
+       gb->psy.type            = POWER_SUPPLY_TYPE_BATTERY;
+       gb->psy.properties      = psy_props;
+       gb->psy.num_properties  = ARRAY_SIZE(psy_props);
+       gb->psy.get_property    = get_property;
 
-       return power_supply_register(&connection->bundle->dev, &gb->bat);
+       return power_supply_register(&connection->bundle->dev, &gb->psy);
 }
 #else
 static int init_and_register(struct gb_connection *connection,
-                            struct gb_battery *gb)
+                            struct gb_power_supply *gb)
 {
        struct power_supply_config cfg = {};
 
@@ -258,22 +261,22 @@ static int init_and_register(struct gb_connection *connection,
        // FIXME - anything else needs to be set?
        gb->desc.name           = "gb_battery";
        gb->desc.type           = POWER_SUPPLY_TYPE_BATTERY;
-       gb->desc.properties     = battery_props;
-       gb->desc.num_properties = ARRAY_SIZE(battery_props);
+       gb->desc.properties     = psy_props;
+       gb->desc.num_properties = ARRAY_SIZE(psy_props);
        gb->desc.get_property   = get_property;
 
-       gb->bat = power_supply_register(&connection->bundle->dev,
+       gb->psy = power_supply_register(&connection->bundle->dev,
                                        &gb->desc, &cfg);
-       if (IS_ERR(gb->bat))
-               return PTR_ERR(gb->bat);
+       if (IS_ERR(gb->psy))
+               return PTR_ERR(gb->psy);
 
        return 0;
 }
 #endif
 
-static int gb_battery_connection_init(struct gb_connection *connection)
+static int gb_power_supply_connection_init(struct gb_connection *connection)
 {
-       struct gb_battery *gb;
+       struct gb_power_supply *gb;
        int retval;
 
        gb = kzalloc(sizeof(*gb), GFP_KERNEL);
@@ -290,28 +293,28 @@ static int gb_battery_connection_init(struct gb_connection *connection)
        return retval;
 }
 
-static void gb_battery_connection_exit(struct gb_connection *connection)
+static void gb_power_supply_connection_exit(struct gb_connection *connection)
 {
-       struct gb_battery *gb = connection->private;
+       struct gb_power_supply *gb = connection->private;
 
 #ifdef DRIVER_OWNS_PSY_STRUCT
-       power_supply_unregister(&gb->bat);
+       power_supply_unregister(&gb->psy);
 #else
-       power_supply_unregister(gb->bat);
+       power_supply_unregister(gb->psy);
 #endif
        kfree(gb);
 }
 
-static struct gb_protocol battery_protocol = {
-       .name                   = "battery",
-       .id                     = GREYBUS_PROTOCOL_BATTERY,
-       .major                  = GB_BATTERY_VERSION_MAJOR,
-       .minor                  = GB_BATTERY_VERSION_MINOR,
-       .connection_init        = gb_battery_connection_init,
-       .connection_exit        = gb_battery_connection_exit,
+static struct gb_protocol power_supply_protocol = {
+       .name                   = "power_supply",
+       .id                     = GREYBUS_PROTOCOL_POWER_SUPPLY,
+       .major                  = GB_POWER_SUPPLY_VERSION_MAJOR,
+       .minor                  = GB_POWER_SUPPLY_VERSION_MINOR,
+       .connection_init        = gb_power_supply_connection_init,
+       .connection_exit        = gb_power_supply_connection_exit,
        .request_recv           = NULL, /* no incoming requests */
 };
 
-gb_protocol_driver(&battery_protocol);
+gb_protocol_driver(&power_supply_protocol);
 
 MODULE_LICENSE("GPL v2");