cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

tcs3414.c (9764B)


      1// SPDX-License-Identifier: GPL-2.0-only
      2/*
      3 * tcs3414.c - Support for TAOS TCS3414 digital color sensor
      4 *
      5 * Copyright (c) 2014 Peter Meerwald <pmeerw@pmeerw.net>
      6 *
      7 * Digital color sensor with 16-bit channels for red, green, blue, clear);
      8 * 7-bit I2C slave address 0x39 (TCS3414) or 0x29, 0x49, 0x59 (TCS3413,
      9 * TCS3415, TCS3416, resp.)
     10 *
     11 * TODO: sync, interrupt support, thresholds, prescaler
     12 */
     13
     14#include <linux/module.h>
     15#include <linux/i2c.h>
     16#include <linux/delay.h>
     17#include <linux/pm.h>
     18
     19#include <linux/iio/iio.h>
     20#include <linux/iio/sysfs.h>
     21#include <linux/iio/trigger_consumer.h>
     22#include <linux/iio/buffer.h>
     23#include <linux/iio/triggered_buffer.h>
     24
     25#define TCS3414_DRV_NAME "tcs3414"
     26
     27#define TCS3414_COMMAND BIT(7)
     28#define TCS3414_COMMAND_WORD (TCS3414_COMMAND | BIT(5))
     29
     30#define TCS3414_CONTROL (TCS3414_COMMAND | 0x00)
     31#define TCS3414_TIMING (TCS3414_COMMAND | 0x01)
     32#define TCS3414_ID (TCS3414_COMMAND | 0x04)
     33#define TCS3414_GAIN (TCS3414_COMMAND | 0x07)
     34#define TCS3414_DATA_GREEN (TCS3414_COMMAND_WORD | 0x10)
     35#define TCS3414_DATA_RED (TCS3414_COMMAND_WORD | 0x12)
     36#define TCS3414_DATA_BLUE (TCS3414_COMMAND_WORD | 0x14)
     37#define TCS3414_DATA_CLEAR (TCS3414_COMMAND_WORD | 0x16)
     38
     39#define TCS3414_CONTROL_ADC_VALID BIT(4)
     40#define TCS3414_CONTROL_ADC_EN BIT(1)
     41#define TCS3414_CONTROL_POWER BIT(0)
     42
     43#define TCS3414_INTEG_MASK GENMASK(1, 0)
     44#define TCS3414_INTEG_12MS 0x0
     45#define TCS3414_INTEG_100MS 0x1
     46#define TCS3414_INTEG_400MS 0x2
     47
     48#define TCS3414_GAIN_MASK GENMASK(5, 4)
     49#define TCS3414_GAIN_SHIFT 4
     50
     51struct tcs3414_data {
     52	struct i2c_client *client;
     53	u8 control;
     54	u8 gain;
     55	u8 timing;
     56	/* Ensure timestamp is naturally aligned */
     57	struct {
     58		u16 chans[4];
     59		s64 timestamp __aligned(8);
     60	} scan;
     61};
     62
     63#define TCS3414_CHANNEL(_color, _si, _addr) { \
     64	.type = IIO_INTENSITY, \
     65	.modified = 1, \
     66	.info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
     67	.info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) | \
     68		BIT(IIO_CHAN_INFO_INT_TIME), \
     69	.channel2 = IIO_MOD_LIGHT_##_color, \
     70	.address = _addr, \
     71	.scan_index = _si, \
     72	.scan_type = { \
     73		.sign = 'u', \
     74		.realbits = 16, \
     75		.storagebits = 16, \
     76		.endianness = IIO_CPU, \
     77	}, \
     78}
     79
     80/* scale factors: 1/gain */
     81static const int tcs3414_scales[][2] = {
     82	{1, 0}, {0, 250000}, {0, 62500}, {0, 15625}
     83};
     84
     85/* integration time in ms */
     86static const int tcs3414_times[] = { 12, 100, 400 };
     87
     88static const struct iio_chan_spec tcs3414_channels[] = {
     89	TCS3414_CHANNEL(GREEN, 0, TCS3414_DATA_GREEN),
     90	TCS3414_CHANNEL(RED, 1, TCS3414_DATA_RED),
     91	TCS3414_CHANNEL(BLUE, 2, TCS3414_DATA_BLUE),
     92	TCS3414_CHANNEL(CLEAR, 3, TCS3414_DATA_CLEAR),
     93	IIO_CHAN_SOFT_TIMESTAMP(4),
     94};
     95
     96static int tcs3414_req_data(struct tcs3414_data *data)
     97{
     98	int tries = 25;
     99	int ret;
    100
    101	ret = i2c_smbus_write_byte_data(data->client, TCS3414_CONTROL,
    102		data->control | TCS3414_CONTROL_ADC_EN);
    103	if (ret < 0)
    104		return ret;
    105
    106	while (tries--) {
    107		ret = i2c_smbus_read_byte_data(data->client, TCS3414_CONTROL);
    108		if (ret < 0)
    109			return ret;
    110		if (ret & TCS3414_CONTROL_ADC_VALID)
    111			break;
    112		msleep(20);
    113	}
    114
    115	ret = i2c_smbus_write_byte_data(data->client, TCS3414_CONTROL,
    116		data->control);
    117	if (ret < 0)
    118		return ret;
    119
    120	if (tries < 0) {
    121		dev_err(&data->client->dev, "data not ready\n");
    122		return -EIO;
    123	}
    124
    125	return 0;
    126}
    127
    128static int tcs3414_read_raw(struct iio_dev *indio_dev,
    129			   struct iio_chan_spec const *chan,
    130			   int *val, int *val2, long mask)
    131{
    132	struct tcs3414_data *data = iio_priv(indio_dev);
    133	int i, ret;
    134
    135	switch (mask) {
    136	case IIO_CHAN_INFO_RAW:
    137		ret = iio_device_claim_direct_mode(indio_dev);
    138		if (ret)
    139			return ret;
    140		ret = tcs3414_req_data(data);
    141		if (ret < 0) {
    142			iio_device_release_direct_mode(indio_dev);
    143			return ret;
    144		}
    145		ret = i2c_smbus_read_word_data(data->client, chan->address);
    146		iio_device_release_direct_mode(indio_dev);
    147		if (ret < 0)
    148			return ret;
    149		*val = ret;
    150		return IIO_VAL_INT;
    151	case IIO_CHAN_INFO_SCALE:
    152		i = (data->gain & TCS3414_GAIN_MASK) >> TCS3414_GAIN_SHIFT;
    153		*val = tcs3414_scales[i][0];
    154		*val2 = tcs3414_scales[i][1];
    155		return IIO_VAL_INT_PLUS_MICRO;
    156	case IIO_CHAN_INFO_INT_TIME:
    157		*val = 0;
    158		*val2 = tcs3414_times[data->timing & TCS3414_INTEG_MASK] * 1000;
    159		return IIO_VAL_INT_PLUS_MICRO;
    160	}
    161	return -EINVAL;
    162}
    163
    164static int tcs3414_write_raw(struct iio_dev *indio_dev,
    165			       struct iio_chan_spec const *chan,
    166			       int val, int val2, long mask)
    167{
    168	struct tcs3414_data *data = iio_priv(indio_dev);
    169	int i;
    170
    171	switch (mask) {
    172	case IIO_CHAN_INFO_SCALE:
    173		for (i = 0; i < ARRAY_SIZE(tcs3414_scales); i++) {
    174			if (val == tcs3414_scales[i][0] &&
    175				val2 == tcs3414_scales[i][1]) {
    176				data->gain &= ~TCS3414_GAIN_MASK;
    177				data->gain |= i << TCS3414_GAIN_SHIFT;
    178				return i2c_smbus_write_byte_data(
    179					data->client, TCS3414_GAIN,
    180					data->gain);
    181			}
    182		}
    183		return -EINVAL;
    184	case IIO_CHAN_INFO_INT_TIME:
    185		if (val != 0)
    186			return -EINVAL;
    187		for (i = 0; i < ARRAY_SIZE(tcs3414_times); i++) {
    188			if (val2 == tcs3414_times[i] * 1000) {
    189				data->timing &= ~TCS3414_INTEG_MASK;
    190				data->timing |= i;
    191				return i2c_smbus_write_byte_data(
    192					data->client, TCS3414_TIMING,
    193					data->timing);
    194			}
    195		}
    196		return -EINVAL;
    197	default:
    198		return -EINVAL;
    199	}
    200}
    201
    202static irqreturn_t tcs3414_trigger_handler(int irq, void *p)
    203{
    204	struct iio_poll_func *pf = p;
    205	struct iio_dev *indio_dev = pf->indio_dev;
    206	struct tcs3414_data *data = iio_priv(indio_dev);
    207	int i, j = 0;
    208
    209	for_each_set_bit(i, indio_dev->active_scan_mask,
    210		indio_dev->masklength) {
    211		int ret = i2c_smbus_read_word_data(data->client,
    212			TCS3414_DATA_GREEN + 2*i);
    213		if (ret < 0)
    214			goto done;
    215
    216		data->scan.chans[j++] = ret;
    217	}
    218
    219	iio_push_to_buffers_with_timestamp(indio_dev, &data->scan,
    220		iio_get_time_ns(indio_dev));
    221
    222done:
    223	iio_trigger_notify_done(indio_dev->trig);
    224
    225	return IRQ_HANDLED;
    226}
    227
    228static IIO_CONST_ATTR(scale_available, "1 0.25 0.0625 0.015625");
    229static IIO_CONST_ATTR_INT_TIME_AVAIL("0.012 0.1 0.4");
    230
    231static struct attribute *tcs3414_attributes[] = {
    232	&iio_const_attr_scale_available.dev_attr.attr,
    233	&iio_const_attr_integration_time_available.dev_attr.attr,
    234	NULL
    235};
    236
    237static const struct attribute_group tcs3414_attribute_group = {
    238	.attrs = tcs3414_attributes,
    239};
    240
    241static const struct iio_info tcs3414_info = {
    242	.read_raw = tcs3414_read_raw,
    243	.write_raw = tcs3414_write_raw,
    244	.attrs = &tcs3414_attribute_group,
    245};
    246
    247static int tcs3414_buffer_postenable(struct iio_dev *indio_dev)
    248{
    249	struct tcs3414_data *data = iio_priv(indio_dev);
    250
    251	data->control |= TCS3414_CONTROL_ADC_EN;
    252	return i2c_smbus_write_byte_data(data->client, TCS3414_CONTROL,
    253		data->control);
    254}
    255
    256static int tcs3414_buffer_predisable(struct iio_dev *indio_dev)
    257{
    258	struct tcs3414_data *data = iio_priv(indio_dev);
    259
    260	data->control &= ~TCS3414_CONTROL_ADC_EN;
    261	return i2c_smbus_write_byte_data(data->client, TCS3414_CONTROL,
    262		data->control);
    263}
    264
    265static const struct iio_buffer_setup_ops tcs3414_buffer_setup_ops = {
    266	.postenable = tcs3414_buffer_postenable,
    267	.predisable = tcs3414_buffer_predisable,
    268};
    269
    270static int tcs3414_powerdown(struct tcs3414_data *data)
    271{
    272	return i2c_smbus_write_byte_data(data->client, TCS3414_CONTROL,
    273		data->control & ~(TCS3414_CONTROL_POWER |
    274		TCS3414_CONTROL_ADC_EN));
    275}
    276
    277static void tcs3414_powerdown_cleanup(void *data)
    278{
    279	tcs3414_powerdown(data);
    280}
    281
    282static int tcs3414_probe(struct i2c_client *client,
    283			   const struct i2c_device_id *id)
    284{
    285	struct tcs3414_data *data;
    286	struct iio_dev *indio_dev;
    287	int ret;
    288
    289	indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
    290	if (indio_dev == NULL)
    291		return -ENOMEM;
    292
    293	data = iio_priv(indio_dev);
    294	i2c_set_clientdata(client, indio_dev);
    295	data->client = client;
    296
    297	indio_dev->info = &tcs3414_info;
    298	indio_dev->name = TCS3414_DRV_NAME;
    299	indio_dev->channels = tcs3414_channels;
    300	indio_dev->num_channels = ARRAY_SIZE(tcs3414_channels);
    301	indio_dev->modes = INDIO_DIRECT_MODE;
    302
    303	ret = i2c_smbus_read_byte_data(data->client, TCS3414_ID);
    304	if (ret < 0)
    305		return ret;
    306
    307	switch (ret & 0xf0) {
    308	case 0x00:
    309		dev_info(&client->dev, "TCS3404 found\n");
    310		break;
    311	case 0x10:
    312		dev_info(&client->dev, "TCS3413/14/15/16 found\n");
    313		break;
    314	default:
    315		return -ENODEV;
    316	}
    317
    318	data->control = TCS3414_CONTROL_POWER;
    319	ret = i2c_smbus_write_byte_data(data->client, TCS3414_CONTROL,
    320		data->control);
    321	if (ret < 0)
    322		return ret;
    323
    324	ret = devm_add_action_or_reset(&client->dev, tcs3414_powerdown_cleanup,
    325				       data);
    326	if (ret < 0)
    327		return ret;
    328
    329	data->timing = TCS3414_INTEG_12MS; /* free running */
    330	ret = i2c_smbus_write_byte_data(data->client, TCS3414_TIMING,
    331		data->timing);
    332	if (ret < 0)
    333		return ret;
    334
    335	ret = i2c_smbus_read_byte_data(data->client, TCS3414_GAIN);
    336	if (ret < 0)
    337		return ret;
    338	data->gain = ret;
    339
    340	ret = devm_iio_triggered_buffer_setup(&client->dev, indio_dev, NULL,
    341		tcs3414_trigger_handler, &tcs3414_buffer_setup_ops);
    342	if (ret < 0)
    343		return ret;
    344
    345	return devm_iio_device_register(&client->dev, indio_dev);
    346}
    347
    348static int tcs3414_suspend(struct device *dev)
    349{
    350	struct tcs3414_data *data = iio_priv(i2c_get_clientdata(
    351		to_i2c_client(dev)));
    352	return tcs3414_powerdown(data);
    353}
    354
    355static int tcs3414_resume(struct device *dev)
    356{
    357	struct tcs3414_data *data = iio_priv(i2c_get_clientdata(
    358		to_i2c_client(dev)));
    359	return i2c_smbus_write_byte_data(data->client, TCS3414_CONTROL,
    360		data->control);
    361}
    362
    363static DEFINE_SIMPLE_DEV_PM_OPS(tcs3414_pm_ops, tcs3414_suspend,
    364				tcs3414_resume);
    365
    366static const struct i2c_device_id tcs3414_id[] = {
    367	{ "tcs3414", 0 },
    368	{ }
    369};
    370MODULE_DEVICE_TABLE(i2c, tcs3414_id);
    371
    372static struct i2c_driver tcs3414_driver = {
    373	.driver = {
    374		.name	= TCS3414_DRV_NAME,
    375		.pm	= pm_sleep_ptr(&tcs3414_pm_ops),
    376	},
    377	.probe		= tcs3414_probe,
    378	.id_table	= tcs3414_id,
    379};
    380module_i2c_driver(tcs3414_driver);
    381
    382MODULE_AUTHOR("Peter Meerwald <pmeerw@pmeerw.net>");
    383MODULE_DESCRIPTION("TCS3414 digital color sensors driver");
    384MODULE_LICENSE("GPL");