microsoft
/
WSL2-Linux-Kernel
зеркало из https://github.com/microsoft/WSL2-Linux-Kernel.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

staging:iio: tsl2563 abi fixes and interrupt handling 

Signed-off-by: Jonathan Cameron <jic23@cam.ac.uk>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
This commit is contained in:
Jonathan Cameron 2010-06-26 12:54:21 +01:00 коммит произвёл Greg Kroah-Hartman
Родитель 3bbb49aa3f
Коммит 388be48839
2 изменённых файлов: 299 добавлений и 95 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

7
drivers/staging/iio/light/light.h
Просмотреть файл

@ -2,11 +2,6 @@
/* Light to digital sensor attributes */ /* Light to digital sensor attributes */
#define IIO_DEV_ATTR_LIGHT_INFRARED(_num, _show, _addr) \ #define IIO_EVENT_CODE_LIGHT_THRESH IIO_EVENT_CODE_LIGHT_BASE
IIO_DEVICE_ATTR(light_infrared##_num, S_IRUGO, _show, NULL, _addr)
#define IIO_DEV_ATTR_LIGHT_BROAD(_num, _show, _addr) \
IIO_DEVICE_ATTR(light_broadspectrum##_num, S_IRUGO, _show, NULL, _addr)
#define IIO_DEV_ATTR_LIGHT_VISIBLE(_num, _show, _addr) \
IIO_DEVICE_ATTR(light_visible##_num, S_IRUGO, _show, NULL, _addr)

387
drivers/staging/iio/light/tsl2563.c
Просмотреть файл

@ -27,6 +27,7 @@
#include <linux/module.h> #include <linux/module.h>
#include <linux/i2c.h> #include <linux/i2c.h>
#include <linux/interrupt.h> #include <linux/interrupt.h>
#include <linux/irq.h>
#include <linux/sched.h> #include <linux/sched.h>
#include <linux/mutex.h> #include <linux/mutex.h>
#include <linux/delay.h> #include <linux/delay.h>
@ -117,15 +118,17 @@ struct tsl2563_chip {
struct iio_dev *indio_dev; struct iio_dev *indio_dev;
struct delayed_work poweroff_work; struct delayed_work poweroff_work;
struct work_struct work_thresh;
s64 event_timestamp;
/* Remember state for suspend and resume functions */ /* Remember state for suspend and resume functions */
pm_message_t state; pm_message_t state;
struct tsl2563_gainlevel_coeff *gainlevel; struct tsl2563_gainlevel_coeff *gainlevel;
/* Thresholds are in lux */
u16 low_thres; u16 low_thres;
u16 high_thres; u16 high_thres;
u8 intr; u8 intr;
bool int_enabled;
/* Calibration coefficients */ /* Calibration coefficients */
u32 calib0; u32 calib0;
@ -189,17 +192,29 @@ static int tsl2563_get_power(struct tsl2563_chip *chip)
static int tsl2563_configure(struct tsl2563_chip *chip) static int tsl2563_configure(struct tsl2563_chip *chip)
{ {
struct i2c_client *client = chip->client;
int ret; int ret;
ret = tsl2563_write(client, TSL2563_REG_TIMING, ret = tsl2563_write(chip->client, TSL2563_REG_TIMING,
chip->gainlevel->gaintime); chip->gainlevel->gaintime);
if (ret) if (ret)
goto out; goto error_ret;
ret = tsl2563_write(chip->client, TSL2563_REG_HIGHLOW,
ret = tsl2563_write(client, TSL2563_REG_INT, chip->intr); chip->high_thres & 0xFF);
if (ret)
out: goto error_ret;
ret = tsl2563_write(chip->client, TSL2563_REG_HIGHHIGH,
(chip->high_thres >> 8) & 0xFF);
if (ret)
goto error_ret;
ret = tsl2563_write(chip->client, TSL2563_REG_LOWLOW,
chip->low_thres & 0xFF);
if (ret)
goto error_ret;
ret = tsl2563_write(chip->client, TSL2563_REG_LOWHIGH,
(chip->low_thres >> 8) & 0xFF);
/* Interrupt register is automatically written anyway if it is relevant
so is not here */
error_ret:
return ret; return ret;
} }
@ -323,21 +338,23 @@ static int tsl2563_get_adc(struct tsl2563_chip *chip)
if (chip->state.event != PM_EVENT_ON) if (chip->state.event != PM_EVENT_ON)
goto out; goto out;
cancel_delayed_work(&chip->poweroff_work); if (!chip->int_enabled) {
cancel_delayed_work(&chip->poweroff_work);
if (!tsl2563_get_power(chip)) { if (!tsl2563_get_power(chip)) {
ret = tsl2563_set_power(chip, 1); ret = tsl2563_set_power(chip, 1);
if (ret) if (ret)
goto out; goto out;
ret = tsl2563_configure(chip); ret = tsl2563_configure(chip);
if (ret) if (ret)
goto out; goto out;
tsl2563_wait_adc(chip); tsl2563_wait_adc(chip);
}
} }
while (retry) { while (retry) {
ret = tsl2563_read(client, ret = tsl2563_read(client,
TSL2563_REG_DATA0LOW | TSL2563_CLEARINT, TSL2563_REG_DATA0LOW,
buf0, sizeof(buf0)); buf0, sizeof(buf0));
if (ret != sizeof(buf0)) if (ret != sizeof(buf0))
goto out; goto out;
@ -356,7 +373,8 @@ static int tsl2563_get_adc(struct tsl2563_chip *chip)
chip->data0 = normalize_adc(adc0, chip->gainlevel->gaintime); chip->data0 = normalize_adc(adc0, chip->gainlevel->gaintime);
chip->data1 = normalize_adc(adc1, chip->gainlevel->gaintime); chip->data1 = normalize_adc(adc1, chip->gainlevel->gaintime);
schedule_delayed_work(&chip->poweroff_work, 5 * HZ); if (!chip->int_enabled)
schedule_delayed_work(&chip->poweroff_work, 5 * HZ);
ret = 0; ret = 0;
out: out:
@ -449,11 +467,12 @@ static unsigned int adc_to_lux(u32 adc0, u32 adc1)
/* Sysfs interface */ /* Sysfs interface */
/*--------------------------------------------------------------*/ /*--------------------------------------------------------------*/
static ssize_t tsl2563_adc0_show(struct device *dev, static ssize_t tsl2563_adc_show(struct device *dev,
struct device_attribute *attr, char *buf) struct device_attribute *attr, char *buf)
{ {
struct iio_dev *indio_dev = dev_get_drvdata(dev); struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct tsl2563_chip *chip = indio_dev->dev_data; struct tsl2563_chip *chip = indio_dev->dev_data;
struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
int ret; int ret;
mutex_lock(&chip->lock); mutex_lock(&chip->lock);
@ -462,26 +481,14 @@ static ssize_t tsl2563_adc0_show(struct device *dev,
if (ret) if (ret)
goto out; goto out;
ret = snprintf(buf, PAGE_SIZE, "%d\n", chip->data0); switch (this_attr->address) {
out: case 0:
mutex_unlock(&chip->lock); ret = snprintf(buf, PAGE_SIZE, "%d\n", chip->data0);
return ret; break;
} case 1:
ret = snprintf(buf, PAGE_SIZE, "%d\n", chip->data1);
static ssize_t tsl2563_adc1_show(struct device *dev, break;
struct device_attribute *attr, char *buf) }
{
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct tsl2563_chip *chip = indio_dev->dev_data;
int ret;
mutex_lock(&chip->lock);
ret = tsl2563_get_adc(chip);
if (ret)
goto out;
ret = snprintf(buf, PAGE_SIZE, "%d\n", chip->data1);
out: out:
mutex_unlock(&chip->lock); mutex_unlock(&chip->lock);
return ret; return ret;
@ -527,37 +534,36 @@ static ssize_t format_calib(char *buf, int len, u32 calib)
return snprintf(buf, PAGE_SIZE, "%d\n", calib_to_sysfs(calib)); return snprintf(buf, PAGE_SIZE, "%d\n", calib_to_sysfs(calib));
} }
static ssize_t tsl2563_calib0_show(struct device *dev, static ssize_t tsl2563_calib_show(struct device *dev,
struct device_attribute *attr, char *buf) struct device_attribute *attr, char *buf)
{ {
struct iio_dev *indio_dev = dev_get_drvdata(dev); struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct tsl2563_chip *chip = indio_dev->dev_data; struct tsl2563_chip *chip = indio_dev->dev_data;
struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
int ret; int ret;
mutex_lock(&chip->lock); mutex_lock(&chip->lock);
ret = format_calib(buf, PAGE_SIZE, chip->calib0); switch (this_attr->address) {
case 0:
ret = format_calib(buf, PAGE_SIZE, chip->calib0);
break;
case 1:
ret = format_calib(buf, PAGE_SIZE, chip->calib1);
break;
default:
ret = -ENODEV;
}
mutex_unlock(&chip->lock); mutex_unlock(&chip->lock);
return ret; return ret;
} }
static ssize_t tsl2563_calib1_show(struct device *dev, static ssize_t tsl2563_calib_store(struct device *dev,
struct device_attribute *attr, char *buf) struct device_attribute *attr,
{ const char *buf, size_t len)
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct tsl2563_chip *chip = indio_dev->dev_data;
int ret;
mutex_lock(&chip->lock);
ret = format_calib(buf, PAGE_SIZE, chip->calib1);
mutex_unlock(&chip->lock);
return ret;
}
static int do_calib_store(struct device *dev, const char *buf, size_t len,
int ch)
{ {
struct iio_dev *indio_dev = dev_get_drvdata(dev); struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct tsl2563_chip *chip = indio_dev->dev_data; struct tsl2563_chip *chip = indio_dev->dev_data;
struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
int value; int value;
u32 calib; u32 calib;
@ -566,37 +572,27 @@ static int do_calib_store(struct device *dev, const char *buf, size_t len,
calib = calib_from_sysfs(value); calib = calib_from_sysfs(value);
if (ch) switch (this_attr->address) {
chip->calib1 = calib; case 0:
else
chip->calib0 = calib; chip->calib0 = calib;
break;
case 1:
chip->calib1 = calib;
break;
}
return len; return len;
} }
static ssize_t tsl2563_calib0_store(struct device *dev, static IIO_DEVICE_ATTR(intensity_both_raw, S_IRUGO,
struct device_attribute *attr, tsl2563_adc_show, NULL, 0);
const char *buf, size_t len) static IIO_DEVICE_ATTR(intensity_ir_raw, S_IRUGO,
{ tsl2563_adc_show, NULL, 1);
return do_calib_store(dev, buf, len, 0);
}
static ssize_t tsl2563_calib1_store(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t len)
{
return do_calib_store(dev, buf, len, 1);
}
/* AmitXXXX: Convert to IIO_DEV_ATTR_LIGHT* as in tsl2561
* once I understand what they mean */
static DEVICE_ATTR(adc0, S_IRUGO, tsl2563_adc0_show, NULL);
static DEVICE_ATTR(adc1, S_IRUGO, tsl2563_adc1_show, NULL);
static DEVICE_ATTR(illuminance0_input, S_IRUGO, tsl2563_lux_show, NULL); static DEVICE_ATTR(illuminance0_input, S_IRUGO, tsl2563_lux_show, NULL);
static DEVICE_ATTR(calib0, S_IRUGO | S_IWUSR, static IIO_DEVICE_ATTR(intensity_both_calibgain, S_IRUGO | S_IWUSR,
tsl2563_calib0_show, tsl2563_calib0_store); tsl2563_calib_show, tsl2563_calib_store, 0);
static DEVICE_ATTR(calib1, S_IRUGO | S_IWUSR, static IIO_DEVICE_ATTR(intensity_ir_calibgain, S_IRUGO | S_IWUSR,
tsl2563_calib1_show, tsl2563_calib1_store); tsl2563_calib_show, tsl2563_calib_store, 1);
static ssize_t tsl2563_show_name(struct device *dev, static ssize_t tsl2563_show_name(struct device *dev,
struct device_attribute *attr, struct device_attribute *attr,
@ -610,11 +606,11 @@ static ssize_t tsl2563_show_name(struct device *dev,
static DEVICE_ATTR(name, S_IRUGO, tsl2563_show_name, NULL); static DEVICE_ATTR(name, S_IRUGO, tsl2563_show_name, NULL);
static struct attribute *tsl2563_attributes[] = { static struct attribute *tsl2563_attributes[] = {
&dev_attr_adc0.attr, &iio_dev_attr_intensity_both_raw.dev_attr.attr,
&dev_attr_adc1.attr, &iio_dev_attr_intensity_ir_raw.dev_attr.attr,
&dev_attr_illuminance0_input.attr, &dev_attr_illuminance0_input.attr,
&dev_attr_calib0.attr, &iio_dev_attr_intensity_both_calibgain.dev_attr.attr,
&dev_attr_calib1.attr, &iio_dev_attr_intensity_ir_calibgain.dev_attr.attr,
&dev_attr_name.attr, &dev_attr_name.attr,
NULL NULL
}; };
@ -623,6 +619,192 @@ static const struct attribute_group tsl2563_group = {
.attrs = tsl2563_attributes, .attrs = tsl2563_attributes,
}; };
static ssize_t tsl2563_read_thresh(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct tsl2563_chip *chip = indio_dev->dev_data;
struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
u16 val = 0;
switch (this_attr->address) {
case TSL2563_REG_HIGHLOW:
val = chip->high_thres;
break;
case TSL2563_REG_LOWLOW:
val = chip->low_thres;
break;
}
return snprintf(buf, PAGE_SIZE, "%d\n", val);
}
static ssize_t tsl2563_write_thresh(struct device *dev,
struct device_attribute *attr,
const char *buf,
size_t len)
{
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct tsl2563_chip *chip = indio_dev->dev_data;
struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
unsigned long val;
int ret;
ret = strict_strtoul(buf, 10, &val);
if (ret)
return ret;
mutex_lock(&chip->lock);
ret = tsl2563_write(chip->client, this_attr->address, val & 0xFF);
if (ret)
goto error_ret;
ret = tsl2563_write(chip->client, this_attr->address + 1,
(val >> 8) & 0xFF);
switch (this_attr->address) {
case TSL2563_REG_HIGHLOW:
chip->high_thres = val;
break;
case TSL2563_REG_LOWLOW:
chip->low_thres = val;
break;
}
error_ret:
mutex_unlock(&chip->lock);
return ret < 0 ? ret : len;
}
static IIO_DEVICE_ATTR(intensity_both_thresh_high_value,
S_IRUGO | S_IWUSR,
tsl2563_read_thresh,
tsl2563_write_thresh,
TSL2563_REG_HIGHLOW);
static IIO_DEVICE_ATTR(intensity_both_thresh_low_value,
S_IRUGO | S_IWUSR,
tsl2563_read_thresh,
tsl2563_write_thresh,
TSL2563_REG_LOWLOW);
static int tsl2563_int_th(struct iio_dev *dev_info,
int index,
s64 timestamp,
int not_test)
{
struct tsl2563_chip *chip = dev_info->dev_data;
chip->event_timestamp = timestamp;
schedule_work(&chip->work_thresh);
return 0;
}
static void tsl2563_int_bh(struct work_struct *work_s)
{
struct tsl2563_chip *chip
= container_of(work_s,
struct tsl2563_chip, work_thresh);
u8 cmd = TSL2563_CMD | TSL2563_CLEARINT;
iio_push_event(chip->indio_dev, 0,
IIO_EVENT_CODE_LIGHT_BASE,
chip->event_timestamp);
/* reenable_irq */
enable_irq(chip->client->irq);
/* clear the interrupt and push the event */
i2c_master_send(chip->client, &cmd, sizeof(cmd));
}
static ssize_t tsl2563_write_interrupt_config(struct device *dev,
struct device_attribute *attr,
const char *buf,
size_t len)
{
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct tsl2563_chip *chip = indio_dev->dev_data;
struct iio_event_attr *this_attr = to_iio_event_attr(attr);
int input, ret = 0;
ret = sscanf(buf, "%d", &input);
if (ret != 1)
return -EINVAL;
mutex_lock(&chip->lock);
if (input && !(chip->intr & 0x30)) {
iio_add_event_to_list(this_attr->listel,
&indio_dev->interrupts[0]->ev_list);
chip->intr &= ~0x30;
chip->intr |= 0x10;
/* ensure the chip is actually on */
cancel_delayed_work(&chip->poweroff_work);
if (!tsl2563_get_power(chip)) {
ret = tsl2563_set_power(chip, 1);
if (ret)
goto out;
ret = tsl2563_configure(chip);
if (ret)
goto out;
}
ret = tsl2563_write(chip->client, TSL2563_REG_INT, chip->intr);
chip->int_enabled = true;
}
if (!input && (chip->intr & 0x30)) {
chip->intr |= ~0x30;
ret = tsl2563_write(chip->client, TSL2563_REG_INT, chip->intr);
iio_remove_event_from_list(this_attr->listel,
&indio_dev->interrupts[0]->ev_list);
chip->int_enabled = false;
/* now the interrupt is not enabled, we can go to sleep */
schedule_delayed_work(&chip->poweroff_work, 5 * HZ);
}
out:
mutex_unlock(&chip->lock);
return (ret < 0) ? ret : len;
}
static ssize_t tsl2563_read_interrupt_config(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct tsl2563_chip *chip = indio_dev->dev_data;
int ret;
u8 rxbuf;
ssize_t len;
mutex_lock(&chip->lock);
ret = tsl2563_read(chip->client,
TSL2563_REG_INT,
&rxbuf,
sizeof(rxbuf));
mutex_unlock(&chip->lock);
if (ret < 0)
goto error_ret;
len = snprintf(buf, PAGE_SIZE, "%d\n", !!(rxbuf & 0x30));
error_ret:
return (ret < 0) ? ret : len;
}
IIO_EVENT_ATTR(intensity_both_thresh_both_en,
tsl2563_read_interrupt_config,
tsl2563_write_interrupt_config,
0,
tsl2563_int_th);
static struct attribute *tsl2563_event_attributes[] = {
&iio_event_attr_intensity_both_thresh_both_en.dev_attr.attr,
&iio_dev_attr_intensity_both_thresh_high_value.dev_attr.attr,
&iio_dev_attr_intensity_both_thresh_low_value.dev_attr.attr,
NULL,
};
static struct attribute_group tsl2563_event_attribute_group = {
.attrs = tsl2563_event_attributes,
};
/*--------------------------------------------------------------*/ /*--------------------------------------------------------------*/
/* Probe, Attach, Remove */ /* Probe, Attach, Remove */
/*--------------------------------------------------------------*/ /*--------------------------------------------------------------*/
@ -641,6 +823,7 @@ static int __devinit tsl2563_probe(struct i2c_client *client,
if (!chip) if (!chip)
return -ENOMEM; return -ENOMEM;
INIT_WORK(&chip->work_thresh, tsl2563_int_bh);
i2c_set_clientdata(client, chip); i2c_set_clientdata(client, chip);
chip->client = client; chip->client = client;
@ -679,18 +862,36 @@ static int __devinit tsl2563_probe(struct i2c_client *client,
chip->indio_dev->dev_data = (void *)(chip); chip->indio_dev->dev_data = (void *)(chip);
chip->indio_dev->driver_module = THIS_MODULE; chip->indio_dev->driver_module = THIS_MODULE;
chip->indio_dev->modes = INDIO_DIRECT_MODE; chip->indio_dev->modes = INDIO_DIRECT_MODE;
if (client->irq) {
chip->indio_dev->num_interrupt_lines = 1;
chip->indio_dev->event_attrs
= &tsl2563_event_attribute_group;
}
ret = iio_device_register(chip->indio_dev); ret = iio_device_register(chip->indio_dev);
if (ret) if (ret)
goto fail1; goto fail1;
if (client->irq) {
ret = iio_register_interrupt_line(client->irq,
chip->indio_dev,
0,
IRQF_TRIGGER_RISING,
client->name);
if (ret)
goto fail2;
}
err = tsl2563_configure(chip); err = tsl2563_configure(chip);
if (err) if (err)
goto fail2; goto fail3;
INIT_DELAYED_WORK(&chip->poweroff_work, tsl2563_poweroff_work); INIT_DELAYED_WORK(&chip->poweroff_work, tsl2563_poweroff_work);
/* The interrupt cannot yet be enabled so this is fine without lock */
schedule_delayed_work(&chip->poweroff_work, 5 * HZ); schedule_delayed_work(&chip->poweroff_work, 5 * HZ);
return 0; return 0;
fail3:
if (client->irq)
iio_unregister_interrupt_line(chip->indio_dev, 0);
fail2: fail2:
iio_device_unregister(chip->indio_dev); iio_device_unregister(chip->indio_dev);
fail1: fail1:
@ -701,7 +902,15 @@ fail1:
static int tsl2563_remove(struct i2c_client *client) static int tsl2563_remove(struct i2c_client *client)
{ {
struct tsl2563_chip *chip = i2c_get_clientdata(client); struct tsl2563_chip *chip = i2c_get_clientdata(client);
if (!chip->int_enabled)
cancel_delayed_work(&chip->poweroff_work);
/* Ensure that interrupts are disabled - then flush any bottom halves */
chip->intr |= ~0x30;
tsl2563_write(chip->client, TSL2563_REG_INT, chip->intr);
flush_scheduled_work();
tsl2563_set_power(chip, 0);
if (client->irq)
iio_unregister_interrupt_line(chip->indio_dev, 0);
iio_device_unregister(chip->indio_dev); iio_device_unregister(chip->indio_dev);
kfree(chip); kfree(chip);