leds-lp5523: use generic firmware interface (db6eaf83) · Commits · e / devices / android_kernel_xiaomi_markw

drivers/leds/leds-lp5523.c

+157 −346

Original line number	Diff line number	Diff line
		@@ -35,6 +35,7 @@
		#include <linux/workqueue.h>
		#include <linux/slab.h>
		#include <linux/platform_data/leds-lp55xx.h>
		#include <linux/firmware.h>

		#include "leds-lp55xx-common.h"

		@@ -108,20 +109,39 @@
		#define LED_ACTIVE(mux, led) (!!(mux & (0x0001 << led)))
		#define SHIFT_MASK(id) (((id) - 1) * 2)

		/* Memory Page Selection */
		#define LP5523_PAGE_ENG1 0
		#define LP5523_PAGE_ENG2 1
		#define LP5523_PAGE_ENG3 2

		/* Program Memory Operations */
		#define LP5523_MODE_ENG1_M 0x30 /* Operation Mode Register */
		#define LP5523_MODE_ENG2_M 0x0C
		#define LP5523_MODE_ENG3_M 0x03
		#define LP5523_LOAD_ENG1 0x10
		#define LP5523_LOAD_ENG2 0x04
		#define LP5523_LOAD_ENG3 0x01

		#define LP5523_ENG1_IS_LOADING(mode) \
		((mode & LP5523_MODE_ENG1_M) == LP5523_LOAD_ENG1)
		#define LP5523_ENG2_IS_LOADING(mode) \
		((mode & LP5523_MODE_ENG2_M) == LP5523_LOAD_ENG2)
		#define LP5523_ENG3_IS_LOADING(mode) \
		((mode & LP5523_MODE_ENG3_M) == LP5523_LOAD_ENG3)

		#define LP5523_EXEC_ENG1_M 0x30 /* Enable Register */
		#define LP5523_EXEC_ENG2_M 0x0C
		#define LP5523_EXEC_ENG3_M 0x03
		#define LP5523_EXEC_M 0x3F
		#define LP5523_RUN_ENG1 0x20
		#define LP5523_RUN_ENG2 0x08
		#define LP5523_RUN_ENG3 0x02

		enum lp5523_chip_id {
		LP5523,
		LP55231,
		};

		struct lp5523_engine {
		int id;
		u8 mode;
		u8 prog_page;
		u8 mux_page;
		u16 led_mux;
		u8 engine_mask;
		};

		struct lp5523_led {
		int id;
		u8 chan_nr;
		@@ -135,13 +155,17 @@ struct lp5523_led {
		struct lp5523_chip {
		struct mutex lock; /* Serialize control */
		struct i2c_client *client;
		struct lp5523_engine engines[LP5523_ENGINES];
		struct lp5523_led leds[LP5523_MAX_LEDS];
		struct lp5523_platform_data *pdata;
		u8 num_channels;
		u8 num_leds;
		};

		static inline void lp5523_wait_opmode_done(void)
		{
		usleep_range(1000, 2000);
		}

		static void lp5523_set_led_current(struct lp55xx_led *led, u8 led_current)
		{
		led->led_current = led_current;
		@@ -149,27 +173,6 @@ static void lp5523_set_led_current(struct lp55xx_led *led, u8 led_current)
		led_current);
		}

		static inline struct lp5523_led cdev_to_led(struct led_classdev cdev)
		{
		return container_of(cdev, struct lp5523_led, cdev);
		}

		static inline struct lp5523_chip engine_to_lp5523(struct lp5523_engine engine)
		{
		return container_of(engine, struct lp5523_chip,
		engines[engine->id - 1]);
		}

		static inline struct lp5523_chip led_to_lp5523(struct lp5523_led led)
		{
		return container_of(led, struct lp5523_chip,
		leds[led->id]);
		}

		static void lp5523_set_mode(struct lp5523_engine *engine, u8 mode);
		static int lp5523_set_engine_mode(struct lp5523_engine *engine, u8 mode);
		static int lp5523_load_program(struct lp5523_engine engine, const u8 pattern);

		static int lp5523_write(struct i2c_client *client, u8 reg, u8 value)
		{
		return i2c_smbus_write_byte_data(client, reg, value);
		@@ -212,177 +215,162 @@ static int lp5523_post_init_device(struct lp55xx_chip *chip)
		return lp55xx_write(chip, LP5523_REG_ENABLE_LEDS_LSB, 0xff);
		}

		static int lp5523_set_engine_mode(struct lp5523_engine *engine, u8 mode)
		static void lp5523_load_engine(struct lp55xx_chip *chip)
		{
		struct lp5523_chip *chip = engine_to_lp5523(engine);
		struct i2c_client *client = chip->client;
		int ret;
		u8 engine_state;
		enum lp55xx_engine_index idx = chip->engine_idx;
		u8 mask[] = {
		[LP55XX_ENGINE_1] = LP5523_MODE_ENG1_M,
		[LP55XX_ENGINE_2] = LP5523_MODE_ENG2_M,
		[LP55XX_ENGINE_3] = LP5523_MODE_ENG3_M,
		};

		ret = lp5523_read(client, LP5523_REG_OP_MODE, &engine_state);
		if (ret)
		goto fail;
		u8 val[] = {
		[LP55XX_ENGINE_1] = LP5523_LOAD_ENG1,
		[LP55XX_ENGINE_2] = LP5523_LOAD_ENG2,
		[LP55XX_ENGINE_3] = LP5523_LOAD_ENG3,
		};

		engine_state &= ~(engine->engine_mask);
		u8 page_sel[] = {
		[LP55XX_ENGINE_1] = LP5523_PAGE_ENG1,
		[LP55XX_ENGINE_2] = LP5523_PAGE_ENG2,
		[LP55XX_ENGINE_3] = LP5523_PAGE_ENG3,
		};

		/* set mode only for this engine */
		mode &= engine->engine_mask;
		lp55xx_update_bits(chip, LP5523_REG_OP_MODE, mask[idx], val[idx]);

		engine_state \|= mode;
		lp5523_wait_opmode_done();

		ret \|= lp5523_write(client, LP5523_REG_OP_MODE, engine_state);
		fail:
		return ret;
		lp55xx_write(chip, LP5523_REG_PROG_PAGE_SEL, page_sel[idx]);
		}

		static int lp5523_load_mux(struct lp5523_engine *engine, u16 mux)
		static void lp5523_stop_engine(struct lp55xx_chip *chip)
		{
		struct lp5523_chip *chip = engine_to_lp5523(engine);
		struct i2c_client *client = chip->client;
		int ret = 0;

		ret \|= lp5523_set_engine_mode(engine, LP5523_CMD_LOAD);

		ret \|= lp5523_write(client, LP5523_REG_PROG_PAGE_SEL, engine->mux_page);
		ret \|= lp5523_write(client, LP5523_REG_PROG_MEM,
		(u8)(mux >> 8));
		ret \|= lp5523_write(client, LP5523_REG_PROG_MEM + 1, (u8)(mux));
		engine->led_mux = mux;

		return ret;
		lp55xx_write(chip, LP5523_REG_OP_MODE, 0);
		lp5523_wait_opmode_done();
		}

		static int lp5523_load_program(struct lp5523_engine engine, const u8 pattern)
		static void lp5523_turn_off_channels(struct lp55xx_chip *chip)
		{
		struct lp5523_chip *chip = engine_to_lp5523(engine);
		struct i2c_client *client = chip->client;

		int ret = 0;

		ret \|= lp5523_set_engine_mode(engine, LP5523_CMD_LOAD);

		ret \|= lp5523_write(client, LP5523_REG_PROG_PAGE_SEL,
		engine->prog_page);
		ret \|= i2c_smbus_write_i2c_block_data(client, LP5523_REG_PROG_MEM,
		LP5523_PROGRAM_LENGTH, pattern);
		int i;

		return ret;
		for (i = 0; i < LP5523_MAX_LEDS; i++)
		lp55xx_write(chip, LP5523_REG_LED_PWM_BASE + i, 0);
		}

		static int lp5523_run_program(struct lp5523_engine *engine)
		static void lp5523_run_engine(struct lp55xx_chip *chip, bool start)
		{
		struct lp5523_chip *chip = engine_to_lp5523(engine);
		struct i2c_client *client = chip->client;
		int ret;
		u8 mode;
		u8 exec;

		/* stop engine */
		if (!start) {
		lp5523_stop_engine(chip);
		lp5523_turn_off_channels(chip);
		return;
		}

		ret = lp5523_write(client, LP5523_REG_ENABLE,
		LP5523_CMD_RUN \| LP5523_ENABLE);
		/*
		* To run the engine,
		* operation mode and enable register should updated at the same time
		*/

		ret = lp55xx_read(chip, LP5523_REG_OP_MODE, &mode);
		if (ret)
		goto fail;
		return;

		ret = lp5523_set_engine_mode(engine, LP5523_CMD_RUN);
		fail:
		return ret;
		}
		ret = lp55xx_read(chip, LP5523_REG_ENABLE, &exec);
		if (ret)
		return;

		static int lp5523_mux_parse(const char buf, u16 mux, size_t len)
		{
		int i;
		u16 tmp_mux = 0;

		len = min_t(int, len, LP5523_MAX_LEDS);
		for (i = 0; i < len; i++) {
		switch (buf[i]) {
		case '1':
		tmp_mux \|= (1 << i);
		break;
		case '0':
		break;
		case '\n':
		i = len;
		break;
		default:
		return -1;
		/* change operation mode to RUN only when each engine is loading */
		if (LP5523_ENG1_IS_LOADING(mode)) {
		mode = (mode & ~LP5523_MODE_ENG1_M) \| LP5523_RUN_ENG1;
		exec = (exec & ~LP5523_EXEC_ENG1_M) \| LP5523_RUN_ENG1;
		}

		if (LP5523_ENG2_IS_LOADING(mode)) {
		mode = (mode & ~LP5523_MODE_ENG2_M) \| LP5523_RUN_ENG2;
		exec = (exec & ~LP5523_EXEC_ENG2_M) \| LP5523_RUN_ENG2;
		}
		*mux = tmp_mux;

		return 0;
		if (LP5523_ENG3_IS_LOADING(mode)) {
		mode = (mode & ~LP5523_MODE_ENG3_M) \| LP5523_RUN_ENG3;
		exec = (exec & ~LP5523_EXEC_ENG3_M) \| LP5523_RUN_ENG3;
		}

		static void lp5523_mux_to_array(u16 led_mux, char *array)
		{
		int i, pos = 0;
		for (i = 0; i < LP5523_MAX_LEDS; i++)
		pos += sprintf(array + pos, "%x", LED_ACTIVE(led_mux, i));
		lp55xx_write(chip, LP5523_REG_OP_MODE, mode);
		lp5523_wait_opmode_done();

		array[pos] = '\0';
		lp55xx_update_bits(chip, LP5523_REG_ENABLE, LP5523_EXEC_M, exec);
		}

		/--------------------------------------------------------------/
		/* Sysfs interface */
		/--------------------------------------------------------------/

		static ssize_t show_engine_leds(struct device *dev,
		struct device_attribute *attr,
		char *buf, int nr)
		static int lp5523_update_program_memory(struct lp55xx_chip *chip,
		const u8 *data, size_t size)
		{
		struct i2c_client *client = to_i2c_client(dev);
		struct lp5523_chip *chip = i2c_get_clientdata(client);
		char mux[LP5523_MAX_LEDS + 1];
		u8 pattern[LP5523_PROGRAM_LENGTH] = {0};
		unsigned cmd;
		char c[3];
		int update_size;
		int nrchars;
		int offset = 0;
		int ret;
		int i;

		lp5523_mux_to_array(chip->engines[nr - 1].led_mux, mux);
		/* clear program memory before updating */
		for (i = 0; i < LP5523_PROGRAM_LENGTH; i++)
		lp55xx_write(chip, LP5523_REG_PROG_MEM + i, 0);

		return sprintf(buf, "%s\n", mux);
		}
		i = 0;
		while ((offset < size - 1) && (i < LP5523_PROGRAM_LENGTH)) {
		/* separate sscanfs because length is working only for %s */
		ret = sscanf(data + offset, "%2s%n ", c, &nrchars);
		if (ret != 1)
		goto err;

		ret = sscanf(c, "%2x", &cmd);
		if (ret != 1)
		goto err;

		#define show_leds(nr) \
		static ssize_t show_engine##nr##_leds(struct device *dev, \
		struct device_attribute *attr, \
		char *buf) \
		{ \
		return show_engine_leds(dev, attr, buf, nr); \
		pattern[i] = (u8)cmd;
		offset += nrchars;
		i++;
		}
		show_leds(1)
		show_leds(2)
		show_leds(3)

		static ssize_t store_engine_leds(struct device *dev,
		struct device_attribute *attr,
		const char *buf, size_t len, int nr)
		{
		struct i2c_client *client = to_i2c_client(dev);
		struct lp5523_chip *chip = i2c_get_clientdata(client);
		u16 mux = 0;
		ssize_t ret;
		/* Each instruction is 16bit long. Check that length is even */
		if (i % 2)
		goto err;

		if (lp5523_mux_parse(buf, &mux, len))
		return -EINVAL;
		update_size = i;
		for (i = 0; i < update_size; i++)
		lp55xx_write(chip, LP5523_REG_PROG_MEM + i, pattern[i]);

		mutex_lock(&chip->lock);
		ret = -EINVAL;
		if (chip->engines[nr - 1].mode != LP5523_CMD_LOAD)
		goto leave;
		return 0;

		if (lp5523_load_mux(&chip->engines[nr - 1], mux))
		goto leave;
		err:
		dev_err(&chip->cl->dev, "wrong pattern format\n");
		return -EINVAL;
		}

		ret = len;
		leave:
		mutex_unlock(&chip->lock);
		return ret;
		static void lp5523_firmware_loaded(struct lp55xx_chip *chip)
		{
		const struct firmware *fw = chip->fw;

		if (fw->size > LP5523_PROGRAM_LENGTH) {
		dev_err(&chip->cl->dev, "firmware data size overflow: %zu\n",
		fw->size);
		return;
		}

		#define store_leds(nr) \
		static ssize_t store_engine##nr##_leds(struct device *dev, \
		struct device_attribute *attr, \
		const char *buf, size_t len) \
		{ \
		return store_engine_leds(dev, attr, buf, len, nr); \
		/*
		* Program momery sequence
		* 1) set engine mode to "LOAD"
		* 2) write firmware data into program memory
		*/

		lp5523_load_engine(chip);
		lp5523_update_program_memory(chip, fw->data, fw->size);
		}
		store_leds(1)
		store_leds(2)
		store_leds(3)

		static ssize_t lp5523_selftest(struct device *dev,
		struct device_attribute *attr,
		@@ -485,159 +473,10 @@ static void lp5523_led_brightness_work(struct work_struct *work)
		mutex_unlock(&chip->lock);
		}

		static int lp5523_do_store_load(struct lp5523_engine *engine,
		const char *buf, size_t len)
		{
		struct lp5523_chip *chip = engine_to_lp5523(engine);
		struct i2c_client *client = chip->client;
		int ret, nrchars, offset = 0, i = 0;
		char c[3];
		unsigned cmd;
		u8 pattern[LP5523_PROGRAM_LENGTH] = {0};

		if (engine->mode != LP5523_CMD_LOAD)
		return -EINVAL;

		while ((offset < len - 1) && (i < LP5523_PROGRAM_LENGTH)) {
		/* separate sscanfs because length is working only for %s */
		ret = sscanf(buf + offset, "%2s%n ", c, &nrchars);
		ret = sscanf(c, "%2x", &cmd);
		if (ret != 1)
		goto fail;
		pattern[i] = (u8)cmd;

		offset += nrchars;
		i++;
		}

		/* Each instruction is 16bit long. Check that length is even */
		if (i % 2)
		goto fail;

		mutex_lock(&chip->lock);
		ret = lp5523_load_program(engine, pattern);
		mutex_unlock(&chip->lock);

		if (ret) {
		dev_err(&client->dev, "failed loading pattern\n");
		return ret;
		}

		return len;
		fail:
		dev_err(&client->dev, "wrong pattern format\n");
		return -EINVAL;
		}

		static ssize_t store_engine_load(struct device *dev,
		struct device_attribute *attr,
		const char *buf, size_t len, int nr)
		{
		struct i2c_client *client = to_i2c_client(dev);
		struct lp5523_chip *chip = i2c_get_clientdata(client);
		return lp5523_do_store_load(&chip->engines[nr - 1], buf, len);
		}

		#define store_load(nr) \
		static ssize_t store_engine##nr##_load(struct device *dev, \
		struct device_attribute *attr, \
		const char *buf, size_t len) \
		{ \
		return store_engine_load(dev, attr, buf, len, nr); \
		}
		store_load(1)
		store_load(2)
		store_load(3)

		static ssize_t show_engine_mode(struct device *dev,
		struct device_attribute *attr,
		char *buf, int nr)
		{
		struct i2c_client *client = to_i2c_client(dev);
		struct lp5523_chip *chip = i2c_get_clientdata(client);
		switch (chip->engines[nr - 1].mode) {
		case LP5523_CMD_RUN:
		return sprintf(buf, "run\n");
		case LP5523_CMD_LOAD:
		return sprintf(buf, "load\n");
		case LP5523_CMD_DISABLED:
		return sprintf(buf, "disabled\n");
		default:
		return sprintf(buf, "disabled\n");
		}
		}

		#define show_mode(nr) \
		static ssize_t show_engine##nr##_mode(struct device *dev, \
		struct device_attribute *attr, \
		char *buf) \
		{ \
		return show_engine_mode(dev, attr, buf, nr); \
		}
		show_mode(1)
		show_mode(2)
		show_mode(3)

		static ssize_t store_engine_mode(struct device *dev,
		struct device_attribute *attr,
		const char *buf, size_t len, int nr)
		{
		struct i2c_client *client = to_i2c_client(dev);
		struct lp5523_chip *chip = i2c_get_clientdata(client);
		struct lp5523_engine *engine = &chip->engines[nr - 1];
		mutex_lock(&chip->lock);

		if (!strncmp(buf, "run", 3))
		lp5523_set_mode(engine, LP5523_CMD_RUN);
		else if (!strncmp(buf, "load", 4))
		lp5523_set_mode(engine, LP5523_CMD_LOAD);
		else if (!strncmp(buf, "disabled", 8))
		lp5523_set_mode(engine, LP5523_CMD_DISABLED);

		mutex_unlock(&chip->lock);
		return len;
		}

		#define store_mode(nr) \
		static ssize_t store_engine##nr##_mode(struct device *dev, \
		struct device_attribute *attr, \
		const char *buf, size_t len) \
		{ \
		return store_engine_mode(dev, attr, buf, len, nr); \
		}
		store_mode(1)
		store_mode(2)
		store_mode(3)

		/* device attributes */
		static DEVICE_ATTR(engine1_mode, S_IRUGO \| S_IWUSR,
		show_engine1_mode, store_engine1_mode);
		static DEVICE_ATTR(engine2_mode, S_IRUGO \| S_IWUSR,
		show_engine2_mode, store_engine2_mode);
		static DEVICE_ATTR(engine3_mode, S_IRUGO \| S_IWUSR,
		show_engine3_mode, store_engine3_mode);
		static DEVICE_ATTR(engine1_leds, S_IRUGO \| S_IWUSR,
		show_engine1_leds, store_engine1_leds);
		static DEVICE_ATTR(engine2_leds, S_IRUGO \| S_IWUSR,
		show_engine2_leds, store_engine2_leds);
		static DEVICE_ATTR(engine3_leds, S_IRUGO \| S_IWUSR,
		show_engine3_leds, store_engine3_leds);
		static DEVICE_ATTR(engine1_load, S_IWUSR, NULL, store_engine1_load);
		static DEVICE_ATTR(engine2_load, S_IWUSR, NULL, store_engine2_load);
		static DEVICE_ATTR(engine3_load, S_IWUSR, NULL, store_engine3_load);
		static DEVICE_ATTR(selftest, S_IRUGO, lp5523_selftest, NULL);

		static struct attribute *lp5523_attributes[] = {
		&dev_attr_engine1_mode.attr,
		&dev_attr_engine2_mode.attr,
		&dev_attr_engine3_mode.attr,
		&dev_attr_selftest.attr,
		&dev_attr_engine1_load.attr,
		&dev_attr_engine1_leds.attr,
		&dev_attr_engine2_load.attr,
		&dev_attr_engine2_leds.attr,
		&dev_attr_engine3_load.attr,
		&dev_attr_engine3_leds.attr,
		NULL,
		};

		@@ -664,36 +503,6 @@ static void lp5523_unregister_sysfs(struct i2c_client *client)
		sysfs_remove_group(&dev->kobj, &lp5523_group);
		}

		/--------------------------------------------------------------/
		/* Set chip operating mode */
		/--------------------------------------------------------------/
		static void lp5523_set_mode(struct lp5523_engine *engine, u8 mode)
		{
		/* if in that mode already do nothing, except for run */
		if (mode == engine->mode && mode != LP5523_CMD_RUN)
		return;

		switch (mode) {
		case LP5523_CMD_RUN:
		lp5523_run_program(engine);
		break;
		case LP5523_CMD_LOAD:
		lp5523_set_engine_mode(engine, LP5523_CMD_DISABLED);
		lp5523_set_engine_mode(engine, LP5523_CMD_LOAD);
		break;
		case LP5523_CMD_DISABLED:
		lp5523_set_engine_mode(engine, LP5523_CMD_DISABLED);
		break;
		default:
		return;
		}

		engine->mode = mode;
		}

		/--------------------------------------------------------------/
		/* Probe, Attach, Remove */
		/--------------------------------------------------------------/
		/* Chip specific configurations */
		static struct lp55xx_device_config lp5523_cfg = {
		.reset = {
		@@ -708,6 +517,8 @@ static struct lp55xx_device_config lp5523_cfg = {
		.post_init_device = lp5523_post_init_device,
		.brightness_work_fn = lp5523_led_brightness_work,
		.set_led_current = lp5523_set_led_current,
		.firmware_cb = lp5523_firmware_loaded,
		.run_engine = lp5523_run_engine,
		};

		static int lp5523_probe(struct i2c_client *client,