Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 2724be03 authored by Rui Miguel Silva's avatar Rui Miguel Silva Committed by Greg Kroah-Hartman
Browse files

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: default avatarRui Miguel Silva <rui.silva@linaro.org>
Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@google.com>
parent 46488841

drivers/staging/greybus/greybus_manifest.h

+2 −2
Original line number Diff line number Diff line
@@ -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,

drivers/staging/greybus/greybus_protocols.h

+39 −39
Original line number Diff line number Diff line
@@ -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;

drivers/staging/greybus/power_supply.c

+79 −76
Original line number Diff line number Diff line 
/*

 * 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");