jsa1212.c

  1// SPDX-License-Identifier: GPL-2.0-only
  2/*
  3 * JSA1212 Ambient Light & Proximity Sensor Driver
  4 *
  5 * Copyright (c) 2014, Intel Corporation.
  6 *
  7 * JSA1212 I2C slave address: 0x44(ADDR tied to GND), 0x45(ADDR tied to VDD)
  8 *
  9 * TODO: Interrupt support, thresholds, range support.
 10 */
 11
 12#include <linux/kernel.h>
 13#include <linux/slab.h>
 14#include <linux/module.h>
 15#include <linux/mod_devicetable.h>
 16#include <linux/delay.h>
 17#include <linux/i2c.h>
 18#include <linux/mutex.h>
 19#include <linux/regmap.h>
 20#include <linux/iio/iio.h>
 21#include <linux/iio/sysfs.h>
 22
 23/* JSA1212 reg address */
 24#define JSA1212_CONF_REG		0x01
 25#define JSA1212_INT_REG			0x02
 26#define JSA1212_PXS_LT_REG		0x03
 27#define JSA1212_PXS_HT_REG		0x04
 28#define JSA1212_ALS_TH1_REG		0x05
 29#define JSA1212_ALS_TH2_REG		0x06
 30#define JSA1212_ALS_TH3_REG		0x07
 31#define JSA1212_PXS_DATA_REG		0x08
 32#define JSA1212_ALS_DT1_REG		0x09
 33#define JSA1212_ALS_DT2_REG		0x0A
 34#define JSA1212_ALS_RNG_REG		0x0B
 35#define JSA1212_MAX_REG			0x0C
 36
 37/* JSA1212 reg masks */
 38#define JSA1212_CONF_MASK		0xFF
 39#define JSA1212_INT_MASK		0xFF
 40#define JSA1212_PXS_LT_MASK		0xFF
 41#define JSA1212_PXS_HT_MASK		0xFF
 42#define JSA1212_ALS_TH1_MASK		0xFF
 43#define JSA1212_ALS_TH2_LT_MASK		0x0F
 44#define JSA1212_ALS_TH2_HT_MASK		0xF0
 45#define JSA1212_ALS_TH3_MASK		0xFF
 46#define JSA1212_PXS_DATA_MASK		0xFF
 47#define JSA1212_ALS_DATA_MASK		0x0FFF
 48#define JSA1212_ALS_DT1_MASK		0xFF
 49#define JSA1212_ALS_DT2_MASK		0x0F
 50#define JSA1212_ALS_RNG_MASK		0x07
 51
 52/* JSA1212 CONF REG bits */
 53#define JSA1212_CONF_PXS_MASK		0x80
 54#define JSA1212_CONF_PXS_ENABLE		0x80
 55#define JSA1212_CONF_PXS_DISABLE	0x00
 56#define JSA1212_CONF_ALS_MASK		0x04
 57#define JSA1212_CONF_ALS_ENABLE		0x04
 58#define JSA1212_CONF_ALS_DISABLE	0x00
 59#define JSA1212_CONF_IRDR_MASK		0x08
 60/* Proxmity sensing IRDR current sink settings */
 61#define JSA1212_CONF_IRDR_200MA		0x08
 62#define JSA1212_CONF_IRDR_100MA		0x00
 63#define JSA1212_CONF_PXS_SLP_MASK	0x70
 64#define JSA1212_CONF_PXS_SLP_0MS	0x70
 65#define JSA1212_CONF_PXS_SLP_12MS	0x60
 66#define JSA1212_CONF_PXS_SLP_50MS	0x50
 67#define JSA1212_CONF_PXS_SLP_75MS	0x40
 68#define JSA1212_CONF_PXS_SLP_100MS	0x30
 69#define JSA1212_CONF_PXS_SLP_200MS	0x20
 70#define JSA1212_CONF_PXS_SLP_400MS	0x10
 71#define JSA1212_CONF_PXS_SLP_800MS	0x00
 72
 73/* JSA1212 INT REG bits */
 74#define JSA1212_INT_CTRL_MASK		0x01
 75#define JSA1212_INT_CTRL_EITHER		0x00
 76#define JSA1212_INT_CTRL_BOTH		0x01
 77#define JSA1212_INT_ALS_PRST_MASK	0x06
 78#define JSA1212_INT_ALS_PRST_1CONV	0x00
 79#define JSA1212_INT_ALS_PRST_4CONV	0x02
 80#define JSA1212_INT_ALS_PRST_8CONV	0x04
 81#define JSA1212_INT_ALS_PRST_16CONV	0x06
 82#define JSA1212_INT_ALS_FLAG_MASK	0x08
 83#define JSA1212_INT_ALS_FLAG_CLR	0x00
 84#define JSA1212_INT_PXS_PRST_MASK	0x60
 85#define JSA1212_INT_PXS_PRST_1CONV	0x00
 86#define JSA1212_INT_PXS_PRST_4CONV	0x20
 87#define JSA1212_INT_PXS_PRST_8CONV	0x40
 88#define JSA1212_INT_PXS_PRST_16CONV	0x60
 89#define JSA1212_INT_PXS_FLAG_MASK	0x80
 90#define JSA1212_INT_PXS_FLAG_CLR	0x00
 91
 92/* JSA1212 ALS RNG REG bits */
 93#define JSA1212_ALS_RNG_0_2048		0x00
 94#define JSA1212_ALS_RNG_0_1024		0x01
 95#define JSA1212_ALS_RNG_0_512		0x02
 96#define JSA1212_ALS_RNG_0_256		0x03
 97#define JSA1212_ALS_RNG_0_128		0x04
 98
 99/* JSA1212 INT threshold range */
100#define JSA1212_ALS_TH_MIN	0x0000
101#define JSA1212_ALS_TH_MAX	0x0FFF
102#define JSA1212_PXS_TH_MIN	0x00
103#define JSA1212_PXS_TH_MAX	0xFF
104
105#define JSA1212_ALS_DELAY_MS	200
106#define JSA1212_PXS_DELAY_MS	100
107
108#define JSA1212_DRIVER_NAME	"jsa1212"
109
110enum jsa1212_op_mode {
111	JSA1212_OPMODE_ALS_EN,
112	JSA1212_OPMODE_PXS_EN,
113};
114
115struct jsa1212_data {
116	struct i2c_client *client;
117	struct mutex lock;
118	u8 als_rng_idx;
119	bool als_en; /* ALS enable status */
120	bool pxs_en; /* proximity enable status */
121	struct regmap *regmap;
122};
123
124/* ALS range idx to val mapping */
125static const int jsa1212_als_range_val[] = {2048, 1024, 512, 256, 128,
126						128, 128, 128};
127
128/* Enables or disables ALS function based on status */
129static int jsa1212_als_enable(struct jsa1212_data *data, u8 status)
130{
131	int ret;
132
133	ret = regmap_update_bits(data->regmap, JSA1212_CONF_REG,
134				JSA1212_CONF_ALS_MASK,
135				status);
136	if (ret < 0)
137		return ret;
138
139	data->als_en = !!status;
140
141	return 0;
142}
143
144/* Enables or disables PXS function based on status */
145static int jsa1212_pxs_enable(struct jsa1212_data *data, u8 status)
146{
147	int ret;
148
149	ret = regmap_update_bits(data->regmap, JSA1212_CONF_REG,
150				JSA1212_CONF_PXS_MASK,
151				status);
152	if (ret < 0)
153		return ret;
154
155	data->pxs_en = !!status;
156
157	return 0;
158}
159
160static int jsa1212_read_als_data(struct jsa1212_data *data,
161				unsigned int *val)
162{
163	int ret;
164	__le16 als_data;
165
166	ret = jsa1212_als_enable(data, JSA1212_CONF_ALS_ENABLE);
167	if (ret < 0)
168		return ret;
169
170	/* Delay for data output */
171	msleep(JSA1212_ALS_DELAY_MS);
172
173	/* Read 12 bit data */
174	ret = regmap_bulk_read(data->regmap, JSA1212_ALS_DT1_REG, &als_data, 2);
175	if (ret < 0) {
176		dev_err(&data->client->dev, "als data read err\n");
177		goto als_data_read_err;
178	}
179
180	*val = le16_to_cpu(als_data);
181
182als_data_read_err:
183	return jsa1212_als_enable(data, JSA1212_CONF_ALS_DISABLE);
184}
185
186static int jsa1212_read_pxs_data(struct jsa1212_data *data,
187				unsigned int *val)
188{
189	int ret;
190	unsigned int pxs_data;
191
192	ret = jsa1212_pxs_enable(data, JSA1212_CONF_PXS_ENABLE);
193	if (ret < 0)
194		return ret;
195
196	/* Delay for data output */
197	msleep(JSA1212_PXS_DELAY_MS);
198
199	/* Read out all data */
200	ret = regmap_read(data->regmap, JSA1212_PXS_DATA_REG, &pxs_data);
201	if (ret < 0) {
202		dev_err(&data->client->dev, "pxs data read err\n");
203		goto pxs_data_read_err;
204	}
205
206	*val = pxs_data & JSA1212_PXS_DATA_MASK;
207
208pxs_data_read_err:
209	return jsa1212_pxs_enable(data, JSA1212_CONF_PXS_DISABLE);
210}
211
212static int jsa1212_read_raw(struct iio_dev *indio_dev,
213				struct iio_chan_spec const *chan,
214				int *val, int *val2, long mask)
215{
216	int ret;
217	struct jsa1212_data *data = iio_priv(indio_dev);
218
219	switch (mask) {
220	case IIO_CHAN_INFO_RAW:
221		mutex_lock(&data->lock);
222		switch (chan->type) {
223		case IIO_LIGHT:
224			ret = jsa1212_read_als_data(data, val);
225			break;
226		case IIO_PROXIMITY:
227			ret = jsa1212_read_pxs_data(data, val);
228			break;
229		default:
230			ret = -EINVAL;
231			break;
232		}
233		mutex_unlock(&data->lock);
234		return ret < 0 ? ret : IIO_VAL_INT;
235	case IIO_CHAN_INFO_SCALE:
236		switch (chan->type) {
237		case IIO_LIGHT:
238			*val = jsa1212_als_range_val[data->als_rng_idx];
239			*val2 = BIT(12); /* Max 12 bit value */
240			return IIO_VAL_FRACTIONAL;
241		default:
242			break;
243		}
244		break;
245	default:
246		break;
247	}
248
249	return -EINVAL;
250}
251
252static const struct iio_chan_spec jsa1212_channels[] = {
253	{
254		.type = IIO_LIGHT,
255		.info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
256			BIT(IIO_CHAN_INFO_SCALE),
257	},
258	{
259		.type = IIO_PROXIMITY,
260		.info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
261	}
262};
263
264static const struct iio_info jsa1212_info = {
265	.read_raw		= &jsa1212_read_raw,
266};
267
268static int jsa1212_chip_init(struct jsa1212_data *data)
269{
270	int ret;
271
272	ret = regmap_write(data->regmap, JSA1212_CONF_REG,
273				(JSA1212_CONF_PXS_SLP_50MS |
274				JSA1212_CONF_IRDR_200MA));
275	if (ret < 0)
276		return ret;
277
278	ret = regmap_write(data->regmap, JSA1212_INT_REG,
279				JSA1212_INT_ALS_PRST_4CONV);
280	if (ret < 0)
281		return ret;
282
283	data->als_rng_idx = JSA1212_ALS_RNG_0_2048;
284
285	return 0;
286}
287
288static bool jsa1212_is_volatile_reg(struct device *dev, unsigned int reg)
289{
290	switch (reg) {
291	case JSA1212_PXS_DATA_REG:
292	case JSA1212_ALS_DT1_REG:
293	case JSA1212_ALS_DT2_REG:
294	case JSA1212_INT_REG:
295		return true;
296	default:
297		return false;
298	}
299}
300
301static const struct regmap_config jsa1212_regmap_config = {
302	.name = "jsa1212_regmap",
303	.reg_bits = 8,
304	.val_bits = 8,
305	.max_register = JSA1212_MAX_REG,
306	.cache_type = REGCACHE_RBTREE,
307	.volatile_reg = jsa1212_is_volatile_reg,
308};
309
310static int jsa1212_probe(struct i2c_client *client)
311{
312	struct jsa1212_data *data;
313	struct iio_dev *indio_dev;
314	struct regmap *regmap;
315	int ret;
316
317	indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
318	if (!indio_dev)
319		return -ENOMEM;
320
321	regmap = devm_regmap_init_i2c(client, &jsa1212_regmap_config);
322	if (IS_ERR(regmap)) {
323		dev_err(&client->dev, "Regmap initialization failed.\n");
324		return PTR_ERR(regmap);
325	}
326
327	data = iio_priv(indio_dev);
328
329	i2c_set_clientdata(client, indio_dev);
330	data->client = client;
331	data->regmap = regmap;
332
333	mutex_init(&data->lock);
334
335	ret = jsa1212_chip_init(data);
336	if (ret < 0)
337		return ret;
338
339	indio_dev->channels = jsa1212_channels;
340	indio_dev->num_channels = ARRAY_SIZE(jsa1212_channels);
341	indio_dev->name = JSA1212_DRIVER_NAME;
342	indio_dev->modes = INDIO_DIRECT_MODE;
343
344	indio_dev->info = &jsa1212_info;
345
346	ret = iio_device_register(indio_dev);
347	if (ret < 0)
348		dev_err(&client->dev, "%s: register device failed\n", __func__);
349
350	return ret;
351}
352
353 /* power off the device */
354static int jsa1212_power_off(struct jsa1212_data *data)
355{
356	int ret;
357
358	mutex_lock(&data->lock);
359
360	ret = regmap_update_bits(data->regmap, JSA1212_CONF_REG,
361				JSA1212_CONF_ALS_MASK |
362				JSA1212_CONF_PXS_MASK,
363				JSA1212_CONF_ALS_DISABLE |
364				JSA1212_CONF_PXS_DISABLE);
365
366	if (ret < 0)
367		dev_err(&data->client->dev, "power off cmd failed\n");
368
369	mutex_unlock(&data->lock);
370
371	return ret;
372}
373
374static void jsa1212_remove(struct i2c_client *client)
375{
376	struct iio_dev *indio_dev = i2c_get_clientdata(client);
377	struct jsa1212_data *data = iio_priv(indio_dev);
378
379	iio_device_unregister(indio_dev);
380
381	jsa1212_power_off(data);
382}
383
384static int jsa1212_suspend(struct device *dev)
385{
386	struct jsa1212_data *data;
387
388	data = iio_priv(i2c_get_clientdata(to_i2c_client(dev)));
389
390	return jsa1212_power_off(data);
391}
392
393static int jsa1212_resume(struct device *dev)
394{
395	int ret = 0;
396	struct jsa1212_data *data;
397
398	data = iio_priv(i2c_get_clientdata(to_i2c_client(dev)));
399
400	mutex_lock(&data->lock);
401
402	if (data->als_en) {
403		ret = jsa1212_als_enable(data, JSA1212_CONF_ALS_ENABLE);
404		if (ret < 0) {
405			dev_err(dev, "als resume failed\n");
406			goto unlock_and_ret;
407		}
408	}
409
410	if (data->pxs_en) {
411		ret = jsa1212_pxs_enable(data, JSA1212_CONF_PXS_ENABLE);
412		if (ret < 0)
413			dev_err(dev, "pxs resume failed\n");
414	}
415
416unlock_and_ret:
417	mutex_unlock(&data->lock);
418	return ret;
419}
420
421static DEFINE_SIMPLE_DEV_PM_OPS(jsa1212_pm_ops, jsa1212_suspend,
422				jsa1212_resume);
423
424static const struct acpi_device_id jsa1212_acpi_match[] = {
425	{"JSA1212", 0},
426	{ }
427};
428MODULE_DEVICE_TABLE(acpi, jsa1212_acpi_match);
429
430static const struct i2c_device_id jsa1212_id[] = {
431	{ JSA1212_DRIVER_NAME },
432	{ }
433};
434MODULE_DEVICE_TABLE(i2c, jsa1212_id);
435
436static struct i2c_driver jsa1212_driver = {
437	.driver = {
438		.name	= JSA1212_DRIVER_NAME,
439		.pm	= pm_sleep_ptr(&jsa1212_pm_ops),
440		.acpi_match_table = jsa1212_acpi_match,
441	},
442	.probe		= jsa1212_probe,
443	.remove		= jsa1212_remove,
444	.id_table	= jsa1212_id,
445};
446module_i2c_driver(jsa1212_driver);
447
448MODULE_AUTHOR("Sathya Kuppuswamy <sathyanarayanan.kuppuswamy@linux.intel.com>");
449MODULE_DESCRIPTION("JSA1212 proximity/ambient light sensor driver");
450MODULE_LICENSE("GPL v2");