Jetpack/kernel/nvidia/drivers/iio/light/nvs_jsa1127.c

/* Copyright (c) 2014-2017, NVIDIA CORPORATION.  All rights reserved.
 *
 * This software is licensed under the terms of the GNU General Public
 * License version 2, as published by the Free Software Foundation, and
 * may be copied, distributed, and modified under those terms.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 */

/* The NVS = NVidia Sensor framework */
/* See nvs_iio.c and nvs.h for documentation */
/* See nvs_light.c and nvs_light.h for documentation */


#include <linux/i2c.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/err.h>
#include <linux/delay.h>
#include <linux/regulator/consumer.h>
#include <linux/workqueue.h>
#include <linux/of.h>
#include <linux/nvs.h>
#include <linux/nvs_light.h>

#define JSA_VENDOR			"SolteamOpto"
#define JSA_NAME			"jsa1127"
#define JSA_LIGHT_VERSION		(3)
#define JSA_LIGHT_MILLIAMP_IVAL		(0)
#define JSA_LIGHT_MILLIAMP_FVAL		(90000)
#define JSA_LIGHT_SCALE_IVAL		(0)
#define JSA_LIGHT_SCALE_MICRO		(10000)
#define JSA_LIGHT_THRESHOLD_LO		(10)
#define JSA_LIGHT_THRESHOLD_HI		(10)
#define JSA_POLL_DLY_MS_MAX		(4000)
#define JSA_HW_DATA_MASK		(0x7FFF)
/* HW registers */
#define JSA_CMD_SHUTDOWN		(0x80)
#define JSA_CMD_EN_CONT			(0x0C)
#define JSA_CMD_EN			(0x04)
#define JSA_CMD_START			(0x08)
#define JSA_CMD_STOP			(0x30)
#define JSA_CMD_MASK			(0x3F)
#define JSA_VAL_VALID			(15)
#define JSA_HW_DELAY_MS			(60)


/* regulator names in order of powering on */
static char *jsa_vregs[] = {
	"vdd",
};

static unsigned short jsa_i2c_addrs[] = {
	0x29,
	0x39,
	0x44,
};

static struct nvs_light_dynamic jsa_nld_tbl[] = {
	{{0, 210000}, {6500,   0}, {0, 90000}, 800, 0},
	{{0, 420000}, {13000,  0}, {0, 90000}, 400, 0},
	{{0, 560000}, {18000,  0}, {0, 90000}, 300, 0},
	{{0, 830000}, {27000,  0}, {0, 90000}, 200, 0},
	{{1, 670000}, {54000,  0}, {0, 90000}, 100, 0},
	{{3, 330000}, {109000, 0}, {0, 90000}, 50,  0}
};

struct jsa_state {
	struct i2c_client *i2c;
	struct nvs_fn_if *nvs;
	void *nvs_st;
	struct sensor_cfg cfg;
	struct workqueue_struct *wq;
	struct work_struct ws;
	struct regulator_bulk_data vreg[ARRAY_SIZE(jsa_vregs)];
	struct nvs_light light;
	struct nvs_light_dynamic hnld[2]; /* hybrid NLD table */
	unsigned int sts;		/* status flags */
	unsigned int errs;		/* error count */
	unsigned int enabled;		/* enable status */
	bool hw_it;			/* HW defined integration time */
	bool hnld_it;			/* hybrid NLD table enable flag */
	u16 i2c_addr;			/* I2C address */
	u8 rc_cmd;			/* store for register dump */
};


static void jsa_err(struct jsa_state *st)
{
	st->errs++;
	if (!st->errs)
		st->errs--;
}

static int jsa_i2c_rd(struct jsa_state *st, u16 *val)
{
	struct i2c_msg msg;
	int ret = 0;

	msg.addr = st->i2c_addr;
	msg.flags = I2C_M_RD;
	msg.len = 2;
	msg.buf = (__u8 *)val;
	if (i2c_transfer(st->i2c->adapter, &msg, 1) == 1) {
		*val = le16_to_cpup(val);
	} else {
		jsa_err(st);
		ret = -EIO;
	}
	return ret;
}

static int jsa_i2c_wr(struct jsa_state *st, u8 val)
{
	struct i2c_msg msg;
	u8 buf[1];
	int ret = 0;

	if (st->i2c_addr) {
		buf[0] = val;
		msg.addr = st->i2c_addr;
		msg.flags = 0;
		msg.len = sizeof(buf);
		msg.buf = buf;
		if (i2c_transfer(st->i2c->adapter, &msg, 1) == 1) {
			st->rc_cmd = val;
		} else {
			jsa_err(st);
			ret = -EIO;
		}
		if (st->sts & NVS_STS_SPEW_MSG)
			dev_info(&st->i2c->dev, "%s=%hhx err=%d\n",
				 __func__, val, ret);
	}
	return ret;
}

static int jsa_pm(struct jsa_state *st, bool enable)
{
	int ret = 0;

	if (enable) {
		ret = nvs_vregs_enable(&st->i2c->dev, st->vreg,
				       ARRAY_SIZE(jsa_vregs));
		if (ret)
			mdelay(JSA_HW_DELAY_MS);
	} else {
		ret = nvs_vregs_sts(st->vreg, ARRAY_SIZE(jsa_vregs));
		if ((ret < 0) || (ret == ARRAY_SIZE(jsa_vregs))) {
			ret = jsa_i2c_wr(st, JSA_CMD_SHUTDOWN);
		} else if (ret > 0) {
			ret = nvs_vregs_enable(&st->i2c->dev, st->vreg,
					       ARRAY_SIZE(jsa_vregs));
			mdelay(JSA_HW_DELAY_MS);
			ret = jsa_i2c_wr(st, JSA_CMD_SHUTDOWN);
		}
		ret |= nvs_vregs_disable(&st->i2c->dev, st->vreg,
					 ARRAY_SIZE(jsa_vregs));
	}
	if (ret > 0)
		ret = 0;
	if (ret) {
		dev_err(&st->i2c->dev, "%s pwr=%x ERR=%d\n",
			__func__, enable, ret);
	} else {
		if (st->sts & NVS_STS_SPEW_MSG)
			dev_info(&st->i2c->dev, "%s pwr=%x\n",
				 __func__, enable);
	}
	return ret;
}

static void jsa_pm_exit(struct jsa_state *st)
{
	jsa_pm(st, false);
	nvs_vregs_exit(&st->i2c->dev, st->vreg, ARRAY_SIZE(jsa_vregs));
}

static int jsa_pm_init(struct jsa_state *st)
{
	int ret;

	st->enabled = 0;
	nvs_vregs_init(&st->i2c->dev,
		       st->vreg, ARRAY_SIZE(jsa_vregs), jsa_vregs);
	ret = jsa_pm(st, true);
	return ret;
}

static int jsa_start(struct jsa_state *st)
{
	int ret;

	if (st->hw_it) {
		ret = jsa_i2c_wr(st, JSA_CMD_EN_CONT);

	} else {
		ret = jsa_i2c_wr(st, JSA_CMD_EN);
		ret |= jsa_i2c_wr(st, JSA_CMD_START);
	}
	return ret;
}

static unsigned int jsa_sleep(struct jsa_state *st)
{
	unsigned int ms;

	if (st->hw_it)
		return st->light.poll_delay_ms;

	ms = st->light.delay_us / 1000;
	if (ms > st->light.poll_delay_ms) {
		jsa_i2c_wr(st, JSA_CMD_SHUTDOWN);
		ms -= st->light.poll_delay_ms;
	} else {
		jsa_start(st);
		ms = st->light.poll_delay_ms;
	}
	return ms;
}

static int jsa_rd(struct jsa_state *st)
{
	s64 ts;
	u16 hw;
	unsigned int i;
	int ret;

	ret = jsa_i2c_rd(st, &hw);
	if (ret)
		return ret;

	if (!(hw & (1 << JSA_VAL_VALID)))
		/* data not ready */
		return -EINVAL;

	hw &= ~(1 << JSA_VAL_VALID);
	ts = nvs_timestamp();
	if (st->sts & NVS_STS_SPEW_DATA)
		dev_info(&st->i2c->dev,
			 "%s hw: %hu %lld diff: %d %lldns nld_i(index)=%u hw_it=%x\n",
			 __func__, hw, ts, hw - st->light.hw,
			 ts - st->light.timestamp, st->light.nld_i, st->hw_it);
	st->light.hw = hw;
	st->light.timestamp = ts;
	nvs_light_read(&st->light);
	if (st->light.nld_i_change && st->hnld_it &&
						   !st->light.calibration_en) {
		/* hybrid mode SW/HW IT switching */
		i = st->light.nld_i;
		if (st->hnld[i].driver_data) {
			st->hw_it = false;
			if (i == 0) {
				/* SW IT is for the low range */
				st->light.hw_mask = st->hnld[i].max_range.ival;
				st->cfg.thresh_lo = 1;
				st->cfg.thresh_hi = 1;
			}
		} else {
			st->hw_it = true;
			st->light.hw_mask = JSA_HW_DATA_MASK;
			st->cfg.thresh_lo = JSA_LIGHT_THRESHOLD_LO;
			st->cfg.thresh_hi = JSA_LIGHT_THRESHOLD_HI;
		}
		jsa_start(st);
	}
	return 0;
}

static void jsa_work(struct work_struct *ws)
{
	struct jsa_state *st = container_of((struct work_struct *)ws,
					    struct jsa_state, ws);
	unsigned int ms;
	int ret;

	ms = st->light.poll_delay_ms;
	while (st->enabled) {
		msleep(ms);
		st->nvs->nvs_mutex_lock(st->nvs_st);
		ms = st->light.poll_delay_ms;
		if (st->hw_it) {
			st->light.nld_i = 1;
			jsa_rd(st);
		} else {
			st->light.nld_i = 0;
			if (st->rc_cmd == JSA_CMD_START) {
				ret = jsa_i2c_wr(st, JSA_CMD_STOP);
				if (!ret) {
					ret = jsa_rd(st);
					if (ret)
						jsa_start(st);
					else
						ms = jsa_sleep(st);
				}
			} else {
				jsa_start(st);
			}
		}
		st->nvs->nvs_mutex_unlock(st->nvs_st);
		if (st->sts & NVS_STS_SPEW_MSG)
			dev_info(&st->i2c->dev,
				 "%s schedule_delayed_work=%ums\n",
				 __func__, ms);
	}
}

static int jsa_disable(struct jsa_state *st)
{
	int ret;

	ret = jsa_pm(st, false);
	if (!ret)
		st->enabled = 0;
	return ret;
}

static int jsa_enable(void *client, int snsr_id, int enable)
{
	struct jsa_state *st = (struct jsa_state *)client;
	int ret;

	dev_info(&st->i2c->dev, "%s\n", __func__);
	if (enable < 0)
		return st->enabled;

	if (enable) {
		ret = jsa_pm(st, true);
		if (!ret) {
			nvs_light_enable(&st->light);
			ret = jsa_start(st);
			if (ret) {
				jsa_disable(st);
			} else {
				st->enabled = enable;
				cancel_work_sync(&st->ws);
				queue_work(st->wq, &st->ws);
			}
		}
	} else {
		ret = jsa_disable(st);
	}
	return ret;
}

static int jsa_batch(void *client, int snsr_id, int flags,
		     unsigned int period_us, unsigned int timeout_us)
{
	struct jsa_state *st = (struct jsa_state *)client;

	if (st->hnld_it && st->light.calibration_en) {
		/* mechanism to test the hybrid SW integration time */
		if (timeout_us) {
			st->hw_it = false;
			if (st->hnld[0].driver_data)
				st->hnld[0].delay_min_ms = timeout_us;
			else
				st->hnld[1].delay_min_ms = timeout_us;
		} else {
			st->hw_it = true;
		}
		jsa_start(st);
	} else if (timeout_us) {
		/* timeout not supported (no HW FIFO) */
		return -EINVAL;
	}

	st->light.delay_us = period_us;
	return 0;
}

static int jsa_thresh_lo(void *client, int snsr_id, int thresh_lo)
{
	struct jsa_state *st = (struct jsa_state *)client;

	nvs_light_threshold_calibrate_lo(&st->light, thresh_lo);
	return 0;
}

static int jsa_thresh_hi(void *client, int snsr_id, int thresh_hi)
{
	struct jsa_state *st = (struct jsa_state *)client;

	nvs_light_threshold_calibrate_hi(&st->light, thresh_hi);
	return 0;
}

static int jsa_regs(void *client, int snsr_id, char *buf)
{
	struct jsa_state *st = (struct jsa_state *)client;
	ssize_t t;
	u16 val;
	int ret;

	t = sprintf(buf, "registers:\n");
	t += sprintf(buf + t, "CMD=%#2x\n", st->rc_cmd);
	ret = jsa_i2c_rd(st, &val);
	t += sprintf(buf + t, "VAL=%#4x  ERR=%d\n", val, ret);
	return t;
}

static int jsa_nvs_write(void *client, int snsr_id, unsigned int nvs)
{
	if (nvs)
		return -EINVAL;

	return 0;
}

static int jsa_nvs_read(void *client, int snsr_id, char *buf)
{
	struct jsa_state *st = (struct jsa_state *)client;

	return nvs_light_dbg(&st->light, buf);
}

static struct nvs_fn_dev jsa_fn_dev = {
	.enable				= jsa_enable,
	.batch				= jsa_batch,
	.thresh_lo			= jsa_thresh_lo,
	.thresh_hi			= jsa_thresh_hi,
	.regs				= jsa_regs,
	.nvs_write			= jsa_nvs_write,
	.nvs_read			= jsa_nvs_read,
};

static int jsa_suspend(struct device *dev)
{
	struct i2c_client *client = to_i2c_client(dev);
	struct jsa_state *st = i2c_get_clientdata(client);
	int ret = 0;

	st->sts |= NVS_STS_SUSPEND;
	if (st->nvs && st->nvs_st)
		ret = st->nvs->suspend(st->nvs_st);
	if (st->sts & NVS_STS_SPEW_MSG)
		dev_info(&client->dev, "%s\n", __func__);
	return ret;
}

static int jsa_resume(struct device *dev)
{
	struct i2c_client *client = to_i2c_client(dev);
	struct jsa_state *st = i2c_get_clientdata(client);
	int ret = 0;

	if (st->nvs && st->nvs_st)
		ret = st->nvs->resume(st->nvs_st);
	st->sts &= ~NVS_STS_SUSPEND;
	if (st->sts & NVS_STS_SPEW_MSG)
		dev_info(&client->dev, "%s\n", __func__);
	return ret;
}

static SIMPLE_DEV_PM_OPS(jsa_pm_ops, jsa_suspend, jsa_resume);

static void jsa_shutdown(struct i2c_client *client)
{
	struct jsa_state *st = i2c_get_clientdata(client);

	st->sts |= NVS_STS_SHUTDOWN;
	if (st->nvs && st->nvs_st)
		st->nvs->shutdown(st->nvs_st);
	if (st->sts & NVS_STS_SPEW_MSG)
		dev_info(&client->dev, "%s\n", __func__);
}

static int jsa_remove(struct i2c_client *client)
{
	struct jsa_state *st = i2c_get_clientdata(client);

	if (st != NULL) {
		jsa_shutdown(client);
		if (st->nvs && st->nvs_st)
			st->nvs->remove(st->nvs_st);
		if (st->wq) {
			destroy_workqueue(st->wq);
			st->wq = NULL;
		}
		jsa_pm_exit(st);
	}
	dev_info(&client->dev, "%s\n", __func__);
	return 0;
}

static int jsa_id_dev(struct jsa_state *st, const char *name)
{
	u16 val;
	int ret = 0;

	if (name == NULL) {
		ret = jsa_i2c_rd(st, &val);
		if (!ret)
			dev_info(&st->i2c->dev, "%s %hx responded\n",
				 __func__, st->i2c_addr);
	}
	return ret;
}

static int jsa_id_i2c(struct jsa_state *st, const char *name)
{
	int i;
	int ret;

	for (i = 0; i < ARRAY_SIZE(jsa_i2c_addrs); i++) {
		if (st->i2c->addr == jsa_i2c_addrs[i])
			break;
	}

	if (i < ARRAY_SIZE(jsa_i2c_addrs)) {
		st->i2c_addr = st->i2c->addr;
		ret = jsa_id_dev(st, name);
	} else {
		name = NULL;
		for (i = 0; i < ARRAY_SIZE(jsa_i2c_addrs); i++) {
			st->i2c_addr = jsa_i2c_addrs[i];
			ret = jsa_id_dev(st, name);
			if (!ret)
				break;
		}
	}
	if (ret)
		st->i2c_addr = 0;
	return ret;
}

static struct sensor_cfg jsa_cfg_dflt = {
	.name			= NVS_LIGHT_STRING,
	.ch_n			= 1,
	.ch_sz			= 4,
	.part			= JSA_NAME,
	.vendor			= JSA_VENDOR,
	.version		= JSA_LIGHT_VERSION,
	.milliamp		= {
		.ival		= JSA_LIGHT_MILLIAMP_IVAL,
		.fval		= JSA_LIGHT_MILLIAMP_FVAL,
	},
	.delay_us_max		= JSA_POLL_DLY_MS_MAX * 1000,
	.flags			= SENSOR_FLAG_ON_CHANGE_MODE,
	.scale			= {
		.ival		= JSA_LIGHT_SCALE_IVAL,
		.fval		= JSA_LIGHT_SCALE_MICRO,
	},
	.thresh_lo		= JSA_LIGHT_THRESHOLD_LO,
	.thresh_hi		= JSA_LIGHT_THRESHOLD_HI,
};

static int jsa_of_dt(struct jsa_state *st, struct device_node *dn)
{
	unsigned int i;
	int ret = 0;
	/* default NVS programmable parameters */
	memcpy(&st->cfg, &jsa_cfg_dflt, sizeof(st->cfg));
	st->light.cfg = &st->cfg;
	st->light.hw_mask = JSA_HW_DATA_MASK;
	st->light.nld_tbl = jsa_nld_tbl;
	/* device tree parameters */
	/* common NVS parameters */
	ret = nvs_of_dt(dn, &st->cfg, NULL);
	if (ret == -ENODEV)
		return -ENODEV;

	/* this device supports these programmable parameters */
	ret = nvs_light_of_dt(&st->light, dn, NULL);
	if (ret) {
		/* default is HW IT */
		st->light.nld_i_lo = 0;
		st->light.nld_i_hi = 0;
	}
	if (st->light.nld_i_lo == st->light.nld_i_hi) {
		/* HW IT is enabled when indexes are the same.
		 * The values used are those in the jsa_nld_tbl pointed to by
		 * the common index (both nld_i_lo and nld_i_hi).
		 */
		st->light.nld_i = st->light.nld_i_lo;
		st->hw_it = true;
		/* disable dynamic resolution */
		st->light.nld_tbl = NULL;

		/* Initialize default dynamic parameter table	*/
		/* Overlay device-specific dynamic parameters, where necessary*/
		if (dn) {
			of_property_read_u32(dn, "light_hwm_maxrange_ival",
					     &jsa_nld_tbl[st->light.nld_i].max_range.ival);
			of_property_read_u32(dn, "light_hwm_maxrange_fval",
					     &jsa_nld_tbl[st->light.nld_i].max_range.fval);
			of_property_read_u32(dn, "light_hwm_resolution_ival",
					     &jsa_nld_tbl[st->light.nld_i].resolution.ival);
			of_property_read_u32(dn, "light_hwm_resolution_fval",
					     &jsa_nld_tbl[st->light.nld_i].resolution.fval);
			of_property_read_u32(dn, "light_hwm_interval",
					     &jsa_nld_tbl[st->light.nld_i].delay_min_ms);
		}

		/* Initialize default hybrid parameter table	*/
		/* memcpy(&st->hnld[0], &jsa_hnld_tbl, sizeof(st->hnld[0]));*/
		/* Overlay device-specific hybrid parameters, where necessary*/
		if (dn) {
			of_property_read_u32(dn, "light_hyb_maxrange_ival",
					     &st->hnld[0].max_range.ival);
			of_property_read_u32(dn, "light_hyb_maxrange_fval",
					     &st->hnld[0].max_range.fval);
			of_property_read_u32(dn, "light_hyb_resolution_ival",
					     &st->hnld[0].resolution.ival);
			of_property_read_u32(dn, "light_hyb_resolution_fval",
					     &st->hnld[0].resolution.fval);
			of_property_read_u32(dn, "light_hyb_interval",
					     &st->hnld[0].delay_min_ms);
		}

	}
	i = st->light.nld_i_lo; /* use lowest resolution */
	st->cfg.resolution.ival = jsa_nld_tbl[i].resolution.ival;
	st->cfg.resolution.fval = jsa_nld_tbl[i].resolution.fval;
	st->cfg.delay_us_min = jsa_nld_tbl[i].delay_min_ms * 1000;
	/* test if hyrbrid mode enabled */
	if (st->hnld[0].max_range.ival || st->hnld[0].max_range.fval) {
		/* Hybrid mode uses a both HW integration time (hw_it = true)
		 * and SW integration time.  It's used to help obtain the low
		 * or high range values of the fixed HW integration time.
		 * HW IT uses values from the fixed indexed jsa_nld_tbl.
		 * SW IT uses a custom entry in the hybrid nvs_light_dynamic
		 * table st->hnld before or after the HW IT entry.
		 * Therefore, this hybrid dynamic resolution/max_range table
		 * has only two entries.
		 */
		st->hnld[0].milliamp.ival = JSA_LIGHT_MILLIAMP_IVAL;
		st->hnld[0].milliamp.fval = JSA_LIGHT_MILLIAMP_FVAL;
		st->hnld[0].driver_data = 1; /* flag the SW entry */
		/* copy SW IT entry to other entry */
		memcpy(&st->hnld[1], &st->hnld[0], sizeof(st->hnld[1]));
		/* copy the HW IT to hybrid nld table in range order */
		if (jsa_nld_tbl[st->light.nld_i].max_range.ival <
						    st->hnld[0].max_range.ival)
			i = 0;
		else
			i = 1;
		memcpy(&st->hnld[i], &jsa_nld_tbl[st->light.nld_i],
		       sizeof(st->hnld[i]));
		st->light.nld_i = i;
		st->light.nld_i_lo = 0;
		st->light.nld_i_hi = 1;
		st->light.nld_tbl = st->hnld;
		st->hnld_it = true;
	}
	i = st->light.nld_i_hi; /* use highest range & delay */
	st->cfg.max_range.ival = jsa_nld_tbl[i].max_range.ival;
	st->cfg.max_range.fval = jsa_nld_tbl[i].max_range.fval;
	return 0;
}

static int jsa_probe(struct i2c_client *client,
		     const struct i2c_device_id *id)
{
	struct jsa_state *st;
	int ret;

	dev_info(&client->dev, "%s\n", __func__);
	st = devm_kzalloc(&client->dev, sizeof(*st), GFP_KERNEL);
	if (st == NULL) {
		dev_err(&client->dev, "%s devm_kzalloc ERR\n", __func__);
		return -ENOMEM;
	}

	i2c_set_clientdata(client, st);
	st->i2c = client;
	ret = jsa_of_dt(st, client->dev.of_node);
	if (ret) {
		if (ret == -ENODEV) {
			dev_info(&client->dev, "%s DT disabled\n", __func__);
		} else {
			dev_err(&client->dev, "%s _of_dt ERR\n", __func__);
			ret = -ENODEV;
		}
		goto jsa_probe_exit;
	}

	jsa_pm_init(st);
	ret = jsa_id_i2c(st, id->name);
	if (ret) {
		dev_err(&client->dev, "%s _id_i2c ERR\n", __func__);
		ret = -ENODEV;
		goto jsa_probe_exit;
	}

	jsa_fn_dev.errs = &st->errs;
	jsa_fn_dev.sts = &st->sts;
	st->nvs = nvs_iio();
	if (st->nvs == NULL) {
		dev_err(&client->dev, "%s nvs_iio ERR\n", __func__);
		ret = -ENODEV;
		goto jsa_probe_exit;
	}

	st->light.handler = st->nvs->handler;
	ret = st->nvs->probe(&st->nvs_st, st, &client->dev,
			     &jsa_fn_dev, &st->cfg);
	if (ret) {
		dev_err(&client->dev, "%s nvs_probe ERR\n", __func__);
		ret = -ENODEV;
		goto jsa_probe_exit;
	}

	st->light.nvs_st = st->nvs_st;
	st->wq = create_workqueue(JSA_NAME);
	if (!st->wq) {
		dev_err(&client->dev, "%s create_workqueue ERR\n", __func__);
		ret = -ENOMEM;
		goto jsa_probe_exit;
	}

	INIT_WORK(&st->ws, jsa_work);
	dev_info(&client->dev, "%s done\n", __func__);
	return 0;

jsa_probe_exit:
	jsa_remove(client);
	return ret;
}

static const struct i2c_device_id jsa_i2c_device_id[] = {
	{ JSA_NAME, 0 },
	{}
};

MODULE_DEVICE_TABLE(i2c, jsa_i2c_device_id);

static const struct of_device_id jsa_of_match[] = {
	{ .compatible = "solteamopto,jsa1127", },
	{},
};

MODULE_DEVICE_TABLE(of, jsa_of_match);

static struct i2c_driver jsa_driver = {
	.class		= I2C_CLASS_HWMON,
	.probe		= jsa_probe,
	.remove		= jsa_remove,
	.shutdown	= jsa_shutdown,
	.driver = {
		.name		= JSA_NAME,
		.owner		= THIS_MODULE,
		.of_match_table	= of_match_ptr(jsa_of_match),
		.pm		= &jsa_pm_ops,
	},
	.id_table	= jsa_i2c_device_id,
};
module_i2c_driver(jsa_driver);

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("JSA1127 driver");
MODULE_AUTHOR("NVIDIA Corporation");