diff options
Diffstat (limited to 'drivers')
| -rw-r--r-- | drivers/iio/light/Kconfig | 25 | ||||
| -rw-r--r-- | drivers/iio/light/Makefile | 2 | ||||
| -rw-r--r-- | drivers/iio/light/cm3391.c | 784 |
3 files changed, 811 insertions, 0 deletions
diff --git a/drivers/iio/light/Kconfig b/drivers/iio/light/Kconfig index 5ef1a396e0c..e86ccb49d9d 100644 --- a/drivers/iio/light/Kconfig +++ b/drivers/iio/light/Kconfig @@ -32,6 +32,31 @@ config SENSORS_LM3533 changes. The ALS-control output values can be set per zone for the three current output channels. +config CM32181 + tristate "CM32181 driver" + depends on I2C + help + Say Y here if you use cm32181. + + This option enables ambient light sensor using + Capella cm32181 device driver. + + To compile this driver as a module, choose M here: + the module will be called cm32181. + +config CM3391 + tristate "CM3391 driver" + depends on I2C + help + Say Y here if you use cm3391. + + This option enables ambient light sensor using + Capella cm3391 device driver. + + To compile this driver as a module, choose M here: + the module will be called cm3391. + + config SENSORS_TSL2563 tristate "TAOS TSL2560, TSL2561, TSL2562 and TSL2563 ambient light sensors" depends on I2C diff --git a/drivers/iio/light/Makefile b/drivers/iio/light/Makefile index 040d9c75f8e..fdf3b87e1f1 100644 --- a/drivers/iio/light/Makefile +++ b/drivers/iio/light/Makefile @@ -7,3 +7,5 @@ obj-$(CONFIG_SENSORS_LM3533) += lm3533-als.o obj-$(CONFIG_SENSORS_TSL2563) += tsl2563.o obj-$(CONFIG_VCNL4000) += vcnl4000.o obj-$(CONFIG_HID_SENSOR_ALS) += hid-sensor-als.o +obj-$(CONFIG_CM32181) += cm32181.o +obj-$(CONFIG_CM3391) += cm3391.o
\ No newline at end of file diff --git a/drivers/iio/light/cm3391.c b/drivers/iio/light/cm3391.c new file mode 100644 index 00000000000..ed2d84a61fe --- /dev/null +++ b/drivers/iio/light/cm3391.c @@ -0,0 +1,784 @@ +/* + * Copyright (C) 2014-2015 Capella Microsystems Inc. + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2, as published + * by the Free Software Foundation. + * + * Special thanks Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com> + * help to add ACPI support. + * + */ + +#include <linux/delay.h> +#include <linux/err.h> +#include <linux/i2c.h> +#include <linux/mutex.h> +#include <linux/module.h> +#include <linux/interrupt.h> +#include <linux/regulator/consumer.h> +#include <linux/iio/iio.h> +#include <linux/iio/sysfs.h> +#include <linux/iio/events.h> + +#include <linux/init.h> + +#ifdef CONFIG_ACPI +#include <linux/acpi.h> +#endif /* CONFIG_ACPI */ + +#define OLDAPI + +/* Registers Address */ +#define CM3391_REG_ADDR_CMD 0x00 +#define CM3391_REG_ADDR_TEST 0x01 +#define CM3391_REG_ADDR_WH 0x02 +#define CM3391_REG_ADDR_WL 0x03 +#define CM3391_REG_ADDR_RED 0x08 +#define CM3391_REG_ADDR_ALS 0x09 +#define CM3391_REG_ADDR_BLUE 0x0A +#define CM3391_REG_ADDR_CLEAR 0x0B +#define CM3391_REG_ADDR_ID 0x0C +#define CM3391_REG_ADDR_STATUS 0x0D + +/* Number of Configurable Registers */ +#define CM3391_CONF_REG_NUM 16 + +/* CMD register */ +#define CM3391_CMD_CS_DISABLE BIT(0) +#define CM3391_CMD_CS_INT_EN BIT(8) + +#define CM3391_CMD_CS_PERS_SHIFT 10 +#define CM3391_CMD_CS_PERS_MASK (0x03 << CM3391_CMD_CS_PERS_SHIFT) +#define CM3391_CMD_CS_PERS_DEFAULT (0x01 << CM3391_CMD_CS_PERS_SHIFT) + +#define CM3391_CMD_CS_IT_SHIFT 4 +#define CM3391_CMD_CS_IT_MASK (0x07 << CM3391_CMD_CS_IT_SHIFT) +#define CM3391_CMD_CS_IT_DEFAULT (0x01 << CM3391_CMD_CS_IT_SHIFT) + +#define CM3391_CMD_CS_HS_SHIFT 3 +#define CM3391_CMD_CS_HS_MASK (0x01 << CM3391_CMD_CS_HS_SHIFT) +#define CM3391_CMD_CS_HS_DEFAULT (0x00 << CM3391_CMD_CS_HS_SHIFT) + +#define CM3391_CMD_DEFAULT (\ + CM3391_CMD_CS_PERS_DEFAULT |\ + CM3391_CMD_CS_IT_DEFAULT |\ + CM3391_CMD_CS_HS_DEFAULT) + +#define CM3391_WH_DEFAULT 0xFFFF +#define CM3391_WL_DEFAULT 0x0000 + +#define CM3391_CALIBSCALE_DEFAULT 100000 +#define CM3391_CALIBSCALE_RESOLUTION 100000 +#define CM3391_MLUX_PER_LUX 1000 +#define CM3391_THRESHOLD_PERCENT 10 /* 10 percent */ + +#define CM3391_MLUX_PER_BIT_DEFAULT 550 +#define CM3391_MLUX_PER_BIT_BASE_IT 100000 +static const int CM3391_cs_it_bits[] = { 0, 1, 2, 3, 4}; +static const int CM3391_cs_it_values[] = { + 50000, 100000, 200000, 400000, 800000}; + +struct cm3391_cs_info { + u32 id; + int regs_bmp; + int calibscale; + int mlux_per_bit; + int mlux_per_bit_base_it; + const int *cs_it_bits; + const int *cs_it_values; + const int num_cs_it; + int als_raw; +}; + +static struct cm3391_cs_info cm3391_cs_info_default = { + .id = 3391, + .regs_bmp = 0x0F, + .calibscale = CM3391_CALIBSCALE_DEFAULT, + .mlux_per_bit = CM3391_MLUX_PER_BIT_DEFAULT, + .mlux_per_bit_base_it = CM3391_MLUX_PER_BIT_BASE_IT, + .cs_it_bits = CM3391_cs_it_bits, + .cs_it_values = CM3391_cs_it_values, + .num_cs_it = ARRAY_SIZE(CM3391_cs_it_bits), +}; + +struct cm3391_chip { + struct i2c_client *client; + struct mutex lock; + u16 conf_regs[CM3391_CONF_REG_NUM]; + struct cm3391_cs_info *cs_info; +}; + +static int cm3391_get_lux(struct cm3391_chip *chip); +static int cm3391_threshold_update(struct cm3391_chip *chip, int percent); +static int cm3391_read_cs_it(struct cm3391_chip *chip, int *val2); + +/** + * cm3391_interrupt_config() - Enable/Disable CM3391 interrupt + * @chip: pointer of struct cm3391. + * @enable: 0 to disable; otherwise to enable + * + * Config CM3391 interrupt control bit. + * + * Return: 0 for success; otherwise for error code. + */ +static int cm3391_interrupt_config(struct cm3391_chip *chip, int enable) +{ + struct i2c_client *client = chip->client; + struct cm3391_cs_info *cs_info = chip->cs_info; + int status; + + if (!cs_info) + return -ENODEV; + + /* Force to clean interrupt */ + status = i2c_smbus_read_word_data(client, + CM3391_REG_ADDR_STATUS); + if (status < 0) + return -ENODEV; + + if (enable) + chip->conf_regs[CM3391_REG_ADDR_CMD] |= + CM3391_CMD_CS_INT_EN; + else + chip->conf_regs[CM3391_REG_ADDR_CMD] &= + ~CM3391_CMD_CS_INT_EN; + + status = i2c_smbus_write_word_data(client, CM3391_REG_ADDR_CMD, + chip->conf_regs[CM3391_REG_ADDR_CMD]); + + if (status < 0) + return -ENODEV; + + return status; +} + +#ifdef CONFIG_ACPI +/** + * cm3391_acpi_get_cpm_info() - Get CPM object from ACPI + * @client pointer of struct i2c_client. + * @obj_name pointer of ACPI object name. + * @count maximum size of return array. + * @vals pointer of array for return elements. + * + * Convert ACPI CPM table to array. Special thanks Srinivas Pandruvada's + * help to implement this routine. + * + * Return: -ENODEV for fail. Otherwise is number of elements. + */ +static int cm3391_acpi_get_cpm_info(struct i2c_client *client, char *obj_name, + int count, u64 *vals) +{ + acpi_handle handle; + struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER, NULL}; + int i; + acpi_status status; + union acpi_object *cpm; + + handle = ACPI_HANDLE(&client->dev); + if (!handle) + return -ENODEV; + + status = acpi_evaluate_object(handle, obj_name, NULL, &buffer); + if (ACPI_FAILURE(status)) { + dev_err(&client->dev, "object %s not found\n", obj_name); + return -ENODEV; + } + + cpm = buffer.pointer; + for (i = 0; i < cpm->package.count && i < count; ++i) { + union acpi_object *elem; + elem = &(cpm->package.elements[i]); + vals[i] = elem->integer.value; + } + + kfree(buffer.pointer); + + return cpm->package.count; +} +#endif /* CONFIG_ACPI */ + +/** + * cm3391_reg_init() - Initialize CM3391 registers + * @chip: pointer of struct cm3391. + * + * Initialize CM3391 color sensor register to default values. + * + Return: 0 for success; otherwise for error code. + */ +static int cm3391_reg_init(struct cm3391_chip *chip) +{ + struct i2c_client *client = chip->client; + int i; + s32 ret; + struct cm3391_cs_info *cs_info; +#ifdef CONFIG_ACPI + int cpm_elem_count; + u64 cpm_elems[20]; +#endif /* CONFIG_ACPI */ + + + /* Default device */ + cs_info = chip->cs_info = &cm3391_cs_info_default; + chip->conf_regs[CM3391_REG_ADDR_CMD] = CM3391_CMD_DEFAULT; + chip->conf_regs[CM3391_REG_ADDR_WH] = CM3391_WH_DEFAULT; + chip->conf_regs[CM3391_REG_ADDR_WL] = CM3391_WL_DEFAULT; + + /* Disable interrupt */ + cm3391_interrupt_config(chip, 0); + + /* Disable Test Mode */ + i2c_smbus_write_word_data(client, CM3391_REG_ADDR_TEST, 0x0000); + + /* Disable device */ + i2c_smbus_write_word_data(client, CM3391_REG_ADDR_CMD, + CM3391_CMD_CS_DISABLE); + + /* Identify device */ + ret = i2c_smbus_read_word_data(client, CM3391_REG_ADDR_ID); + if (ret < 0) + return ret; + + if ((ret & 0xFF) != 0x91) + return -ENODEV; + +#ifdef CONFIG_ACPI +#error ACPI is enabled, strange! OLIO MFJ + + if (ACPI_HANDLE(&client->dev)) { + /* Load from ACPI */ + cpm_elem_count = cm3391_acpi_get_cpm_info(client, "CPM0", + ARRAY_SIZE(cpm_elems), + cpm_elems); + if (cpm_elem_count > 0) { + int header_num = 3; + int reg_num = cpm_elem_count - header_num; + + cs_info->id = cpm_elems[0]; + cs_info->regs_bmp = cpm_elems[2]; + for (i = 0; i < reg_num; i++) + if (cs_info->regs_bmp & (1<<i)) + chip->conf_regs[i] = + cpm_elems[header_num+i]; + } + + cpm_elem_count = cm3391_acpi_get_cpm_info(client, "CPM1", + ARRAY_SIZE(cpm_elems), + cpm_elems); + if (cpm_elem_count > 0) { + cs_info->mlux_per_bit = (int)cpm_elems[0] / 100; + cs_info->calibscale = (int)cpm_elems[1]; + } + } +#endif /* CONFIG_ACPI */ + + /* Force to disable interrupt */ + chip->conf_regs[CM3391_REG_ADDR_CMD] &= ~CM3391_CMD_CS_INT_EN; + + /* Initialize registers */ + for (i = 0; i < CM3391_CONF_REG_NUM; i++) { + if (cs_info->regs_bmp & (1<<i)) { + ret = i2c_smbus_write_word_data(client, i, + chip->conf_regs[i]); + if (ret < 0) + return ret; + } + } + + return 0; +} + +/** + * cm3391_read_cs_it() - Get sensor integration time (ms) + * @chip: pointer of struct cm3391 + * @val2: pointer of int to load the cs_it value. + * + * Report the current integration time in milliseconds. + * + * Return: IIO_VAL_INT_PLUS_MICRO for success, otherwise -EINVAL. + */ +static int cm3391_read_cs_it(struct cm3391_chip *chip, int *val2) +{ + struct cm3391_cs_info *cs_info = chip->cs_info; + u16 cs_it; + int i; + + cs_it = chip->conf_regs[CM3391_REG_ADDR_CMD]; + cs_it &= CM3391_CMD_CS_IT_MASK; + cs_it >>= CM3391_CMD_CS_IT_SHIFT; + for (i = 0; i < cs_info->num_cs_it; i++) { + if (cs_it == cs_info->cs_it_bits[i]) { + *val2 = cs_info->cs_it_values[i]; + return IIO_VAL_INT_PLUS_MICRO; + } + } + + return -EINVAL; +} + +#ifndef OLDAPI +/** + * cm3391_write_cs_it() - Write sensor integration time + * @chip: pointer of struct cm3391. + * @val: integration time in milliseconds. + * + * Convert integration time (ms) to sensor value. + * + * Return: i2c_smbus_write_word_data command return value. + */ +static int cm3391_write_cs_it(struct cm3391_chip *chip, int val) +{ + struct i2c_client *client = chip->client; + struct cm3391_cs_info *cs_info = chip->cs_info; + u16 cs_it; + int ret, i; + + for (i = 0; i < cs_info->num_cs_it; i++) + if (val <= cs_info->cs_it_values[i]) + break; + if (i >= cs_info->num_cs_it) + i = cs_info->num_cs_it - 1; + + cs_it = cs_info->cs_it_bits[i]; + cs_it <<= CM3391_CMD_CS_IT_SHIFT; + + mutex_lock(&chip->lock); + chip->conf_regs[CM3391_REG_ADDR_CMD] &= + ~CM3391_CMD_CS_IT_MASK; + chip->conf_regs[CM3391_REG_ADDR_CMD] |= + cs_it; + ret = i2c_smbus_write_word_data(client, CM3391_REG_ADDR_CMD, + chip->conf_regs[CM3391_REG_ADDR_CMD]); + mutex_unlock(&chip->lock); + + return ret; +} +#endif /* !OLDAPI */ + +/** + * cm3391_get_lux() - report current lux value + * @chip: pointer of struct cm3391. + * + * Convert sensor raw data to lux. It depends on integration + * time and calibscale variable. + * + * Return: Positive value is lux, otherwise is error code. + */ +static int cm3391_get_lux(struct cm3391_chip *chip) +{ + struct i2c_client *client = chip->client; + struct cm3391_cs_info *cs_info = chip->cs_info; + int ret; + int cs_it; + u64 tmp; + + /* Calculate mlux per bit based on cs_it */ + ret = cm3391_read_cs_it(chip, &cs_it); + if (ret < 0) + return -EINVAL; + tmp = (__force u64)cs_info->mlux_per_bit; + tmp *= cs_info->mlux_per_bit_base_it; + tmp = div_u64(tmp, cs_it); + + /* Get als_raw */ + if (!(chip->conf_regs[CM3391_REG_ADDR_CMD] & CM3391_CMD_CS_INT_EN)) + cs_info->als_raw = i2c_smbus_read_word_data( + client, + CM3391_REG_ADDR_ALS); + if (cs_info->als_raw < 0) + return cs_info->als_raw; + + tmp *= cs_info->als_raw; + tmp *= cs_info->calibscale; + tmp = div_u64(tmp, CM3391_CALIBSCALE_RESOLUTION); + tmp = div_u64(tmp, CM3391_MLUX_PER_LUX); + + if (tmp > 0xFFFF) + tmp = 0xFFFF; + + return (int)tmp; +} + +static int cm3391_read_raw(struct iio_dev *indio_dev, + struct iio_chan_spec const *chan, + int *val, int *val2, long mask) +{ + struct cm3391_chip *chip = iio_priv(indio_dev); + struct cm3391_cs_info *cs_info = chip->cs_info; + int ret; + + switch (mask) { + case IIO_CHAN_INFO_RAW: + ret = i2c_smbus_read_word_data(chip->client, chan->address); + if (ret < 0) { + return ret; + } + *val = ret; + return IIO_VAL_INT; + case IIO_CHAN_INFO_PROCESSED: + ret = cm3391_get_lux(chip); + if (ret < 0) + return ret; + *val = ret; + return IIO_VAL_INT; + case IIO_CHAN_INFO_CALIBSCALE: + *val = cs_info->calibscale; + return IIO_VAL_INT; +#ifndef OLDAPI + case IIO_CHAN_INFO_INT_TIME: + *val = 0; + ret = cm3391_read_cs_it(chip, val2); + return ret; +#endif /* !OLDAPI */ + } + + return -EINVAL; +} + +static int cm3391_write_raw(struct iio_dev *indio_dev, + struct iio_chan_spec const *chan, + int val, int val2, long mask) +{ + struct cm3391_chip *chip = iio_priv(indio_dev); + struct cm3391_cs_info *cs_info = chip->cs_info; +#ifndef OLDAPI + long ms; +#endif /* !OLDAPI */ + + switch (mask) { + case IIO_CHAN_INFO_CALIBSCALE: + cs_info->calibscale = val; + return val; +#ifndef OLDAPI + case IIO_CHAN_INFO_INT_TIME: + ms = val * 1000000 + val2; + return cm3391_write_cs_it(chip, (int)ms); +#endif /* !OLDAPI */ + } + + return -EINVAL; +} + +/** + * cm3391_get_it_available() - Get available IT value + * @dev: pointer of struct device. + * @attr: pointer of struct device_attribute. + * @buf: pointer of return string buffer. + * + * Display the available integration time in milliseconds. + * + * Return: string length. + */ +static ssize_t cm3391_get_it_available(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct cm3391_chip *chip = iio_priv(dev_to_iio_dev(dev)); + struct cm3391_cs_info *cs_info = chip->cs_info; + int i, len; + + for (i = 0, len = 0; i < cs_info->num_cs_it; i++) + len += scnprintf(buf + len, PAGE_SIZE - len, "%u.%06u ", + cs_info->cs_it_values[i]/1000000, + cs_info->cs_it_values[i]%1000000); + return len + scnprintf(buf + len, PAGE_SIZE - len, "\n"); +} + +/** + * cm3391_threshold_update() - Update the threshold registers. + * @chip: pointer of struct cm3391_chip. + * @percent: +/- percent. + * + * Based on the current ALS value, update the hi and low threshold registers. + * + * Return: 0 for success; otherwise for error code. + */ +static int cm3391_threshold_update(struct cm3391_chip *chip, int percent) +{ + struct i2c_client *client = chip->client; + struct cm3391_cs_info *cs_info = chip->cs_info; + int ret; + int wh, wl; + + ret = cs_info->als_raw = i2c_smbus_read_word_data(client, + CM3391_REG_ADDR_ALS); + if (ret < 0) + return ret; + + wh = wl = ret; + ret *= percent; + ret /= 100; + if (ret < 1) + ret = 1; + wh += ret; + wl -= ret; + if (wh > 65535) + wh = 65535; + if (wl < 0) + wl = 0; + + chip->conf_regs[CM3391_REG_ADDR_WH] = wh; + ret = i2c_smbus_write_word_data( + client, + CM3391_REG_ADDR_WH, + chip->conf_regs[CM3391_REG_ADDR_WH]); + if (ret < 0) + return ret; + + chip->conf_regs[CM3391_REG_ADDR_WL] = wl; + ret = i2c_smbus_write_word_data( + client, + CM3391_REG_ADDR_WL, + chip->conf_regs[CM3391_REG_ADDR_WL]); + + return ret; +} + +/** + * cm3391_event_handler() - Interrupt handling routine. + * @irq: irq number. + * @private: pointer of void. + * + * Clean interrupt and reset threshold registers. + * + * Return: IRQ_HANDLED. + */ +static irqreturn_t cm3391_event_handler(int irq, void *private) +{ + struct iio_dev *dev_info = private; + struct cm3391_chip *chip = iio_priv(dev_info); + int ret; + + mutex_lock(&chip->lock); + + /* Disable interrupt */ + ret = cm3391_interrupt_config(chip, 0); + if (ret < 0) + goto error_handler_unlock; + + /* Update Hi/Lo windows */ + ret = cm3391_threshold_update(chip, CM3391_THRESHOLD_PERCENT); + if (ret < 0) + goto error_handler_unlock; + + /* Enable interrupt */ + cm3391_interrupt_config(chip, 1); + +error_handler_unlock: + mutex_unlock(&chip->lock); + return IRQ_HANDLED; +} + +#ifdef OLDAPI +#define CM3391_COLOR_CHANNEL(_color, _addr) { \ + .type = IIO_INTENSITY, \ + .modified = 1, \ + .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \ + .channel2 = IIO_MOD_LIGHT_##_color, \ + .address = _addr, \ +} + +static const struct iio_chan_spec cm3391_channels[] = { + { + .type = IIO_LIGHT, + .info_mask_separate = + BIT(IIO_CHAN_INFO_PROCESSED) | + BIT(IIO_CHAN_INFO_CALIBSCALE) + }, + CM3391_COLOR_CHANNEL(RED, CM3391_REG_ADDR_RED), + CM3391_COLOR_CHANNEL(GREEN, CM3391_REG_ADDR_ALS), + CM3391_COLOR_CHANNEL(BLUE, CM3391_REG_ADDR_BLUE), + CM3391_COLOR_CHANNEL(CLEAR, CM3391_REG_ADDR_CLEAR), +}; + +#else +#define CM3391_COLOR_CHANNEL(_color, _addr) { \ + .type = IIO_INTENSITY, \ + .modified = 1, \ + .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \ + .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_INT_TIME), \ + .channel2 = IIO_MOD_LIGHT_##_color, \ + .address = _addr, \ +} + +static const struct iio_chan_spec cm3391_channels[] = { + { + .type = IIO_LIGHT, + .info_mask_separate = + BIT(IIO_CHAN_INFO_PROCESSED) | + BIT(IIO_CHAN_INFO_CALIBSCALE) | + BIT(IIO_CHAN_INFO_INT_TIME), + }, + CM3391_COLOR_CHANNEL(RED, CM3391_REG_ADDR_RED), + CM3391_COLOR_CHANNEL(GREEN, CM3391_REG_ADDR_ALS), + CM3391_COLOR_CHANNEL(BLUE, CM3391_REG_ADDR_BLUE), + CM3391_COLOR_CHANNEL(CLEAR, CM3391_REG_ADDR_CLEAR), +}; +#endif /* !OLDAPI */ + +static IIO_DEVICE_ATTR(in_illuminance_integration_time_available, + S_IRUGO, cm3391_get_it_available, NULL, 0); + +static struct attribute *cm3391_attributes[] = { + &iio_dev_attr_in_illuminance_integration_time_available.dev_attr.attr, + NULL, +}; + +static const struct attribute_group cm3391_attribute_group = { + .attrs = cm3391_attributes +}; + +static const struct iio_info cm3391_info = { + .driver_module = THIS_MODULE, + .read_raw = &cm3391_read_raw, + .write_raw = &cm3391_write_raw, + .attrs = &cm3391_attribute_group, +}; + +static int cm3391_probe(struct i2c_client *client, + const struct i2c_device_id *id) +{ + struct cm3391_chip *chip; + struct iio_dev *indio_dev; + int ret; + +#ifdef OLDAPI + indio_dev = iio_device_alloc(sizeof(*chip)); + if (!indio_dev) { + dev_err(&client->dev, "iio_device_alloc fails\n"); + return -ENOMEM; + } +#else + indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*chip)); + if (!indio_dev) { + dev_err(&client->dev, "devm_iio_device_alloc failed\n"); + return -ENOMEM; + } +#endif /* OLDAPI */ + + chip = iio_priv(indio_dev); + i2c_set_clientdata(client, indio_dev); + chip->client = client; + + mutex_init(&chip->lock); + indio_dev->dev.parent = &client->dev; + indio_dev->channels = cm3391_channels; + indio_dev->num_channels = ARRAY_SIZE(cm3391_channels); + indio_dev->info = &cm3391_info; + if (id && id->name) + indio_dev->name = id->name; + else + indio_dev->name = (char *)dev_name(&client->dev); + indio_dev->channels = cm3391_channels; + indio_dev->num_channels = ARRAY_SIZE(cm3391_channels); + indio_dev->modes = INDIO_DIRECT_MODE; + + ret = cm3391_reg_init(chip); + if (ret) { + dev_err(&client->dev, + "%s: register init failed\n", + __func__); + return ret; + } + + if (client->irq) { + ret = request_threaded_irq(client->irq, + NULL, + cm3391_event_handler, + IRQF_TRIGGER_FALLING | IRQF_ONESHOT, + "cm3391_event", + indio_dev); + + if (ret < 0) { + dev_err(&client->dev, "irq request error %d\n", + -ret); + goto error_disable_int; + } + } + + ret = iio_device_register(indio_dev); + if (ret < 0) { + dev_err(&client->dev, + "%s: regist device failed\n", + __func__); + goto error_free_irq; + } + + if (client->irq) { + ret = cm3391_threshold_update(chip, CM3391_THRESHOLD_PERCENT); + if (ret < 0) + goto error_free_irq; + + ret = cm3391_interrupt_config(chip, 1); + if (ret < 0) + goto error_free_irq; + } + + return 0; + +error_free_irq: + if (client->irq) + free_irq(client->irq, indio_dev); +#ifdef OLDAPI + iio_device_free(indio_dev); +#endif /* OLDAPI */ +error_disable_int: + cm3391_interrupt_config(chip, 0); + + return ret; +} + +static int cm3391_remove(struct i2c_client *client) +{ + struct iio_dev *indio_dev = i2c_get_clientdata(client); + struct cm3391_chip *chip = iio_priv(indio_dev); + + cm3391_interrupt_config(chip, 0); + if (client->irq) + free_irq(client->irq, indio_dev); + iio_device_unregister(indio_dev); +#ifdef OLDAPI + iio_device_free(indio_dev); +#endif /* OLDAPI */ + return 0; +} + +static const struct i2c_device_id cm3391_id[] = { + { "cm3391", 0}, + { } +}; + +MODULE_DEVICE_TABLE(i2c, cm3391_id); + +static const struct of_device_id cm3391_of_match[] = { + { .compatible = "capella,cm3391" }, + { } +}; + +#ifdef CONFIG_ACPI +static const struct acpi_device_id cm3391_acpi_match[] = { + { "CPLM3391", 0}, + {}, +}; + +MODULE_DEVICE_TABLE(acpi, cm3391_acpi_match); +#endif /* CONFIG_ACPI */ + +static struct i2c_driver cm3391_driver = { + .driver = { + .name = "cm3391", +#ifdef CONFIG_ACPI + .acpi_match_table = ACPI_PTR(cm3391_acpi_match), +#endif /* CONFIG_ACPI */ + .of_match_table = of_match_ptr(cm3391_of_match), + .owner = THIS_MODULE, + }, + .id_table = cm3391_id, + .probe = cm3391_probe, + .remove = cm3391_remove, +}; + +module_i2c_driver(cm3391_driver); + +MODULE_AUTHOR("Kevin Tsai <ktsai@capellamicro.com>"); +MODULE_DESCRIPTION("CM3391 color sensor driver"); +MODULE_LICENSE("GPL"); |