diff --git a/drivers/staging/greybus/greybus_manifest.h b/drivers/staging/greybus/greybus_manifest.h index f29f470909c9..c36c4d1d30f9 100644 --- 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 1142b2094901..b2380403edc6 100644 --- 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 */ +/* Power Supply */ -/* Version of the Greybus battery protocol we support */ -#define GB_BATTERY_VERSION_MAJOR 0x00 -#define GB_BATTERY_VERSION_MINOR 0x01 +/* Version of the Greybus power supply protocol we support */ +#define GB_POWER_SUPPLY_VERSION_MAJOR 0x00 +#define GB_POWER_SUPPLY_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 +/* 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 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 +/* 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_battery_technology_response { +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 e119775fb19b..d7797a24e00d 100644 --- 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 #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");