Commit b49a81d0 authored by Ikjoon Jang's avatar Ikjoon Jang Committed by Sebastian Reichel
Browse files

power: supply: sbs-battery: cache constant string properties 



Currently sbs-battery supports three string properties -
manufacturer, model_name, and chemistry. Buffers for those
properties are currently defined as global variables.

This patch moves those global variables into struct sbs_info
and cache/reuse them as they are all constant values.

Signed-off-by: default avatarIkjoon Jang <ikjn@chromium.org>
Tested-by: default avatarHsin-Yi Wang <hsinyi@chromium.org>
Signed-off-by: default avatarSebastian Reichel <sebastian.reichel@collabora.com>
parent 20a3c8b5

drivers/power/supply/sbs-battery.c

+95 −58
Original line number Diff line number Diff line
@@ -189,6 +189,14 @@ static const enum power_supply_property sbs_properties[] = { 
/* Supports special manufacturer commands from TI BQ20Z65 and BQ20Z75 IC. */

#define SBS_FLAGS_TI_BQ20ZX5		BIT(0)



static const enum power_supply_property string_properties[] = {

	POWER_SUPPLY_PROP_TECHNOLOGY,

	POWER_SUPPLY_PROP_MANUFACTURER,

	POWER_SUPPLY_PROP_MODEL_NAME,

};



#define NR_STRING_BUFFERS	ARRAY_SIZE(string_properties)



struct sbs_info {

	struct i2c_client		*client;

	struct power_supply		*power_supply;
@@ -202,11 +210,32 @@ struct sbs_info { 
	struct delayed_work		work;

	struct mutex			mode_lock;

	u32				flags;

	int				technology;

	char				strings[NR_STRING_BUFFERS][I2C_SMBUS_BLOCK_MAX + 1];

};



static char model_name[I2C_SMBUS_BLOCK_MAX + 1];

static char manufacturer[I2C_SMBUS_BLOCK_MAX + 1];

static char chemistry[I2C_SMBUS_BLOCK_MAX + 1];

static char *sbs_get_string_buf(struct sbs_info *chip,

				enum power_supply_property psp)

{

	int i = 0;



	for (i = 0; i < NR_STRING_BUFFERS; i++)

		if (string_properties[i] == psp)

			return chip->strings[i];



	return ERR_PTR(-EINVAL);

}



static void sbs_invalidate_cached_props(struct sbs_info *chip)

{

	int i = 0;



	chip->technology = -1;



	for (i = 0; i < NR_STRING_BUFFERS; i++)

		chip->strings[i][0] = 0;

}



static bool force_load;



static int sbs_read_word_data(struct i2c_client *client, u8 address);
@@ -244,6 +273,7 @@ static int sbs_update_presence(struct sbs_info *chip, bool is_present) 
		chip->is_present = false;

		/* Disable PEC when no device is present */

		client->flags &= ~I2C_CLIENT_PEC;

		sbs_invalidate_cached_props(chip);

		return 0;

	}
@@ -640,17 +670,45 @@ static int sbs_get_battery_property(struct i2c_client *client, 
	return 0;

}



static int sbs_get_battery_string_property(struct i2c_client *client,

	int reg_offset, enum power_supply_property psp, char *val)

static int sbs_get_property_index(struct i2c_client *client,

	enum power_supply_property psp)

{

	s32 ret;

	int count;



	for (count = 0; count < ARRAY_SIZE(sbs_data); count++)

		if (psp == sbs_data[count].psp)

			return count;



	dev_warn(&client->dev,

		"%s: Invalid Property - %d\n", __func__, psp);



	return -EINVAL;

}



	ret = sbs_read_string_data(client, sbs_data[reg_offset].addr, val);

static const char *sbs_get_constant_string(struct sbs_info *chip,

			enum power_supply_property psp)

{

	int ret;

	char *buf;

	u8 addr;



	buf = sbs_get_string_buf(chip, psp);

	if (IS_ERR(buf))

		return buf;



	if (!buf[0]) {

		ret = sbs_get_property_index(chip->client, psp);

		if (ret < 0)

		return ret;

			return ERR_PTR(ret);



	return 0;

		addr = sbs_data[ret].addr;



		ret = sbs_read_string_data(chip->client, addr, buf);

		if (ret < 0)

			return ERR_PTR(ret);

	}



	return buf;

}



static void  sbs_unit_adjustment(struct i2c_client *client,
@@ -773,48 +831,36 @@ static int sbs_get_battery_serial_number(struct i2c_client *client, 
	return 0;

}



static int sbs_get_property_index(struct i2c_client *client,

	enum power_supply_property psp)

static int sbs_get_chemistry(struct sbs_info *chip,

		union power_supply_propval *val)

{

	int count;

	for (count = 0; count < ARRAY_SIZE(sbs_data); count++)

		if (psp == sbs_data[count].psp)

			return count;

	const char *chemistry;



	dev_warn(&client->dev,

		"%s: Invalid Property - %d\n", __func__, psp);



	return -EINVAL;

	if (chip->technology != -1) {

		val->intval = chip->technology;

		return 0;

	}



static int sbs_get_chemistry(struct i2c_client *client,

		union power_supply_propval *val)

{

	enum power_supply_property psp = POWER_SUPPLY_PROP_TECHNOLOGY;

	int ret;

	chemistry = sbs_get_constant_string(chip, POWER_SUPPLY_PROP_TECHNOLOGY);



	ret = sbs_get_property_index(client, psp);

	if (ret < 0)

		return ret;



	ret = sbs_get_battery_string_property(client, ret, psp,

					      chemistry);

	if (ret < 0)

		return ret;

	if (IS_ERR(chemistry))

		return PTR_ERR(chemistry);



	if (!strncasecmp(chemistry, "LION", 4))

		val->intval = POWER_SUPPLY_TECHNOLOGY_LION;

		chip->technology = POWER_SUPPLY_TECHNOLOGY_LION;

	else if (!strncasecmp(chemistry, "LiP", 3))

		val->intval = POWER_SUPPLY_TECHNOLOGY_LIPO;

		chip->technology = POWER_SUPPLY_TECHNOLOGY_LIPO;

	else if (!strncasecmp(chemistry, "NiCd", 4))

		val->intval = POWER_SUPPLY_TECHNOLOGY_NiCd;

		chip->technology = POWER_SUPPLY_TECHNOLOGY_NiCd;

	else if (!strncasecmp(chemistry, "NiMH", 4))

		val->intval = POWER_SUPPLY_TECHNOLOGY_NiMH;

		chip->technology = POWER_SUPPLY_TECHNOLOGY_NiMH;

	else

		val->intval = POWER_SUPPLY_TECHNOLOGY_UNKNOWN;

		chip->technology = POWER_SUPPLY_TECHNOLOGY_UNKNOWN;



	if (chip->technology == POWER_SUPPLY_TECHNOLOGY_UNKNOWN)

		dev_warn(&chip->client->dev, "Unknown chemistry: %s\n", chemistry);



	if (val->intval == POWER_SUPPLY_TECHNOLOGY_UNKNOWN)

		dev_warn(&client->dev, "Unknown chemistry: %s\n", chemistry);

	val->intval = chip->technology;



	return 0;

}
@@ -858,6 +904,7 @@ static int sbs_get_property(struct power_supply *psy, 
	int ret = 0;

	struct sbs_info *chip = power_supply_get_drvdata(psy);

	struct i2c_client *client = chip->client;

	const char *str;



	if (chip->gpio_detect) {

		ret = gpiod_get_value_cansleep(chip->gpio_detect);
@@ -883,7 +930,7 @@ static int sbs_get_property(struct power_supply *psy, 
		break;



	case POWER_SUPPLY_PROP_TECHNOLOGY:

		ret = sbs_get_chemistry(client, val);

		ret = sbs_get_chemistry(chip, val);

		if (ret < 0)

			break;
@@ -935,23 +982,12 @@ static int sbs_get_property(struct power_supply *psy, 
		break;



	case POWER_SUPPLY_PROP_MODEL_NAME:

		ret = sbs_get_property_index(client, psp);

		if (ret < 0)

			break;



		ret = sbs_get_battery_string_property(client, ret, psp,

						      model_name);

		val->strval = model_name;

		break;



	case POWER_SUPPLY_PROP_MANUFACTURER:

		ret = sbs_get_property_index(client, psp);

		if (ret < 0)

			break;



		ret = sbs_get_battery_string_property(client, ret, psp,

						      manufacturer);

		val->strval = manufacturer;

		str = sbs_get_constant_string(chip, psp);

		if (IS_ERR(str))

			ret = PTR_ERR(str);

		else

			val->strval = str;

		break;



	case POWER_SUPPLY_PROP_MANUFACTURE_YEAR:
@@ -1098,6 +1134,7 @@ static int sbs_probe(struct i2c_client *client) 
	psy_cfg.of_node = client->dev.of_node;

	psy_cfg.drv_data = chip;

	chip->last_state = POWER_SUPPLY_STATUS_UNKNOWN;

	sbs_invalidate_cached_props(chip);

	mutex_init(&chip->mode_lock);



	/* use pdata if available, fall back to DT properties,