OpenE2K
/
linux
6
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Third set of new device support, cleanups and features for IIO in the 4.15 cycle 

New device support
 * ti-dac082s085 dac
   - new driver supporting 8, 10 and 12 bit TI DACs with 2 and 4 channels:
     DAC082S085, DAC102S085, DAC122S085, DAC104s085 and DAC124S085.
 
 Minor features and cleanps
 * adc12138
   - make array ch_to_mux static for small object code size reduction.
 * sun4i-gpadc
   - use of_device_get_match_data rather than opencoding it.
 * stm32 trigger
   - add tim15 tigger on STM32H7
   - check clock rate to avoid potential division by zero
 * tsl2x7x staging cleanups.
   - move *_thresh_period to being created by IIO core.
   - remove unused tsl2x7x_parse_result structure.
   - sort includes
   - drop a repeat iio_dev forward definition
   - fix some code alignment of defines.
   - use IIO_CONST_ATTR for constant string attribute
   - drop some unnecessary parentheses
   - fix various alignment with parenthese
   - rename power defines for readability reasons
   - fix a missaligned break statement
   - Tidy up function definitions so they fit on a single line.
 -----BEGIN PGP SIGNATURE-----
 
 iQJFBAABCAAvFiEEbilms4eEBlKRJoGxVIU0mcT0FogFAlnyJXQRHGppYzIzQGtl
 cm5lbC5vcmcACgkQVIU0mcT0FogSMw/9Hv7euztsUr7lq+6pN+lXZVBCTveIxqf8
 JSKoUt7unA0OqlZAyQv2oR2Vd6/d0Oy6WuAgpBg/mXEjBYC5/yy2NdXKLFvG0HVX
 5JdaKg+ZVTzGceWk75fEFbQ+6bzonXGwkWGMEqV+tb3MPQPD1ffP222pjj6Q8nqZ
 9c72WsScZhU5FxvJsyD31pAx0BxPUTKQKU/ShFF5o1jtQPo/rtoLKQDB4tysaJ9g
 SK5CKvoZMZScMffUnhGUTCOQEXUiew3jgSEHWOpl5JYAO/tTwDkR6EpLAbkbkNFr
 wvwPErfuxoY/PAXuJDQaBX3/wrGqd4UBj0w+w+l3CbkkX8xvmdfVVr+ri501QHUO
 pZYxdvQ5u+lBn6bkTjzf7A2IbT7Y1rdJJvTSIcRieFGmJ3nTOjrWNEo5QnxR5IME
 xR4qHgABqwFJ6dZSgofJ2yWH/t9zjz66guY1IkH3+yzeOjnSAGlrXY3+bJrCJpL8
 vgvNnTwHAWdKYx+1luPTN5vWqB/2ylWcgP2LK/cxslSP1l1jT+JmqmfQ9ydk8NgG
 CT4DuoH0ECSHmWpvPgv6Lu6wJ60hZH5y5u1O7gr2MndYOPGg3L0a7aFWUtzzHgGj
 9GVolsgFHoKGq2hr5FZ5fFJk88FRZP2U7Vus07r34XWuxZItn1aYqHqRTLgaa2hU
 Z9TMNvh4RS4=
 =IXO+
 -----END PGP SIGNATURE-----

Merge tag 'iio-for-4.15c' of git://git.kernel.org/pub/scm/linux/kernel/git/jic23/iio into staging-next

Jonathan writes:

Third set of new device support, cleanups and features for IIO in the 4.15 cycle

New device support
* ti-dac082s085 dac
  - new driver supporting 8, 10 and 12 bit TI DACs with 2 and 4 channels:
    DAC082S085, DAC102S085, DAC122S085, DAC104s085 and DAC124S085.

Minor features and cleanps
* adc12138
  - make array ch_to_mux static for small object code size reduction.
* sun4i-gpadc
  - use of_device_get_match_data rather than opencoding it.
* stm32 trigger
  - add tim15 tigger on STM32H7
  - check clock rate to avoid potential division by zero
* tsl2x7x staging cleanups.
  - move *_thresh_period to being created by IIO core.
  - remove unused tsl2x7x_parse_result structure.
  - sort includes
  - drop a repeat iio_dev forward definition
  - fix some code alignment of defines.
  - use IIO_CONST_ATTR for constant string attribute
  - drop some unnecessary parentheses
  - fix various alignment with parenthese
  - rename power defines for readability reasons
  - fix a missaligned break statement
  - Tidy up function definitions so they fit on a single line.
This commit is contained in:
Greg Kroah-Hartman 2017-10-27 11:13:08 +02:00
parent 7706abf5a0 f98677cf31
commit 85078fd095
11 changed files with 598 additions and 280 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
Documentation/ABI/testing/sysfs-bus-iio
View File

@ -522,6 +522,7 @@ Description:
Specifies the output powerdown mode.
DAC output stage is disconnected from the amplifier and
1kohm_to_gnd: connected to ground via an 1kOhm resistor,
2.5kohm_to_gnd: connected to ground via a 2.5kOhm resistor,
6kohm_to_gnd: connected to ground via a 6kOhm resistor,
20kohm_to_gnd: connected to ground via a 20kOhm resistor,
90kohm_to_gnd: connected to ground via a 90kOhm resistor,

34
Documentation/devicetree/bindings/iio/dac/ti-dac082s085.txt Normal file
View File

@ -0,0 +1,34 @@
Texas Instruments 8/10/12-bit 2/4-channel DAC driver
Required properties:
- compatible: Must be one of:
"ti,dac082s085"
"ti,dac102s085"
"ti,dac122s085"
"ti,dac084s085"
"ti,dac104s085"
"ti,dac124s085"
- reg: Chip select number.
- spi-cpha, spi-cpol: SPI mode (0,1) or (1,0) must be used, so specify
either spi-cpha or spi-cpol (but not both).
- vref-supply: Phandle to the external reference voltage supply.
For other required and optional properties of SPI slave nodes please refer to
../../spi/spi-bus.txt.
Example:
vref_2v5_reg: regulator-vref {
compatible = "regulator-fixed";
regulator-name = "2v5";
regulator-min-microvolt = <2500000>;
regulator-max-microvolt = <2500000>;
regulator-always-on;
};
dac@0 {
compatible = "ti,dac082s085";
reg = <0>;
spi-max-frequency = <40000000>;
spi-cpol;
vref-supply = <&vref_2v5_reg>;
};

13
drivers/iio/adc/stm32-adc-core.c
View File

@ -139,6 +139,11 @@ static int stm32f4_adc_clk_sel(struct platform_device *pdev,
}
rate = clk_get_rate(priv->aclk);
if (!rate) {
dev_err(&pdev->dev, "Invalid clock rate: 0\n");
return -EINVAL;
}
for (i = 0; i < ARRAY_SIZE(stm32f4_pclk_div); i++) {
if ((rate / stm32f4_pclk_div[i]) <= STM32F4_ADC_MAX_CLK_RATE)
break;
@ -216,6 +221,10 @@ static int stm32h7_adc_clk_sel(struct platform_device *pdev,
* From spec: PLL output musn't exceed max rate
*/
rate = clk_get_rate(priv->aclk);
if (!rate) {
dev_err(&pdev->dev, "Invalid adc clock rate: 0\n");
return -EINVAL;
}
for (i = 0; i < ARRAY_SIZE(stm32h7_adc_ckmodes_spec); i++) {
ckmode = stm32h7_adc_ckmodes_spec[i].ckmode;
@ -232,6 +241,10 @@ static int stm32h7_adc_clk_sel(struct platform_device *pdev,
/* Synchronous clock modes (e.g. ckmode is 1, 2 or 3) */
rate = clk_get_rate(priv->bclk);
if (!rate) {
dev_err(&pdev->dev, "Invalid bus clock rate: 0\n");
return -EINVAL;
}
for (i = 0; i < ARRAY_SIZE(stm32h7_adc_ckmodes_spec); i++) {
ckmode = stm32h7_adc_ckmodes_spec[i].ckmode;

1
drivers/iio/adc/stm32-adc.c
View File

@ -531,6 +531,7 @@ static struct stm32_adc_trig_info stm32h7_adc_trigs[] = {
{ TIM2_TRGO, STM32_EXT11 },
{ TIM4_TRGO, STM32_EXT12 },
{ TIM6_TRGO, STM32_EXT13 },
{ TIM15_TRGO, STM32_EXT14 },
{ TIM3_CH4, STM32_EXT15 },
{ LPTIM1_OUT, STM32_EXT18 },
{ LPTIM2_OUT, STM32_EXT19 },

6
drivers/iio/adc/sun4i-gpadc-iio.c
View File

@ -501,17 +501,15 @@ static int sun4i_gpadc_probe_dt(struct platform_device *pdev,
struct iio_dev *indio_dev)
{
struct sun4i_gpadc_iio *info = iio_priv(indio_dev);
const struct of_device_id *of_dev;
struct resource *mem;
void __iomem *base;
int ret;
of_dev = of_match_device(sun4i_gpadc_of_id, &pdev->dev);
if (!of_dev)
info->data = of_device_get_match_data(&pdev->dev);
if (!info->data)
return -ENODEV;
info->no_irq = true;
info->data = (struct gpadc_data *)of_dev->data;
indio_dev->num_channels = ARRAY_SIZE(sun8i_a33_gpadc_channels);
indio_dev->channels = sun8i_a33_gpadc_channels;

2
drivers/iio/adc/ti-adc12138.c
View File

@ -164,7 +164,7 @@ static int __adc12138_start_conv(struct adc12138 *adc,
void *data, int len)
{
const u8 ch_to_mux[] = { 0, 4, 1, 5, 2, 6, 3, 7 };
static const u8 ch_to_mux[] = { 0, 4, 1, 5, 2, 6, 3, 7 };
u8 mode = (ch_to_mux[channel->channel] << 4) |
(channel->differential ? 0 : 0x80);

10
drivers/iio/dac/Kconfig
View File

@ -310,6 +310,16 @@ config STM32_DAC
config STM32_DAC_CORE
tristate
config TI_DAC082S085
tristate "Texas Instruments 8/10/12-bit 2/4-channel DAC driver"
depends on SPI_MASTER
help
Driver for the Texas Instruments (formerly National Semiconductor)
DAC082S085, DAC102S085, DAC122S085, DAC084S085, DAC104S085 and
DAC124S085.
If compiled as a module, it will be called ti-dac082s085.
config VF610_DAC
tristate "Vybrid vf610 DAC driver"
depends on OF

1
drivers/iio/dac/Makefile
View File

@ -33,4 +33,5 @@ obj-$(CONFIG_MCP4725) += mcp4725.o
obj-$(CONFIG_MCP4922) += mcp4922.o
obj-$(CONFIG_STM32_DAC_CORE) += stm32-dac-core.o
obj-$(CONFIG_STM32_DAC) += stm32-dac.o
obj-$(CONFIG_TI_DAC082S085) += ti-dac082s085.o
obj-$(CONFIG_VF610_DAC) += vf610_dac.o

368
drivers/iio/dac/ti-dac082s085.c Normal file
View File

@ -0,0 +1,368 @@
/*
* ti-dac082s085.c - Texas Instruments 8/10/12-bit 2/4-channel DAC driver
*
* Copyright (C) 2017 KUNBUS GmbH
*
* http://www.ti.com/lit/ds/symlink/dac082s085.pdf
* http://www.ti.com/lit/ds/symlink/dac102s085.pdf
* http://www.ti.com/lit/ds/symlink/dac122s085.pdf
* http://www.ti.com/lit/ds/symlink/dac084s085.pdf
* http://www.ti.com/lit/ds/symlink/dac104s085.pdf
* http://www.ti.com/lit/ds/symlink/dac124s085.pdf
*
* 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.
*/
#include <linux/iio/iio.h>
#include <linux/module.h>
#include <linux/regulator/consumer.h>
#include <linux/spi/spi.h>
enum { dual_8bit, dual_10bit, dual_12bit, quad_8bit, quad_10bit, quad_12bit };
struct ti_dac_spec {
u8 num_channels;
u8 resolution;
};
static const struct ti_dac_spec ti_dac_spec[] = {
[dual_8bit] = { .num_channels = 2, .resolution = 8 },
[dual_10bit] = { .num_channels = 2, .resolution = 10 },
[dual_12bit] = { .num_channels = 2, .resolution = 12 },
[quad_8bit] = { .num_channels = 4, .resolution = 8 },
[quad_10bit] = { .num_channels = 4, .resolution = 10 },
[quad_12bit] = { .num_channels = 4, .resolution = 12 },
};
/**
* struct ti_dac_chip - TI DAC chip
* @lock: protects write sequences
* @vref: regulator generating Vref
* @mesg: SPI message to perform a write
* @xfer: SPI transfer used by @mesg
* @val: cached value of each output
* @powerdown: whether the chip is powered down
* @powerdown_mode: selected by the user
* @resolution: resolution of the chip
* @buf: buffer for @xfer
*/
struct ti_dac_chip {
struct mutex lock;
struct regulator *vref;
struct spi_message mesg;
struct spi_transfer xfer;
u16 val[4];
bool powerdown;
u8 powerdown_mode;
u8 resolution;
u8 buf[2] ____cacheline_aligned;
};
#define WRITE_NOT_UPDATE(chan) (0x00 | (chan) << 6)
#define WRITE_AND_UPDATE(chan) (0x10 | (chan) << 6)
#define WRITE_ALL_UPDATE 0x20
#define POWERDOWN(mode) (0x30 | ((mode) + 1) << 6)
static int ti_dac_cmd(struct ti_dac_chip *ti_dac, u8 cmd, u16 val)
{
u8 shift = 12 - ti_dac->resolution;
ti_dac->buf[0] = cmd | (val >> (8 - shift));
ti_dac->buf[1] = (val << shift) & 0xff;
return spi_sync(ti_dac->mesg.spi, &ti_dac->mesg);
}
static const char * const ti_dac_powerdown_modes[] = {
"2.5kohm_to_gnd", "100kohm_to_gnd", "three_state",
};
static int ti_dac_get_powerdown_mode(struct iio_dev *indio_dev,
const struct iio_chan_spec *chan)
{
struct ti_dac_chip *ti_dac = iio_priv(indio_dev);
return ti_dac->powerdown_mode;
}
static int ti_dac_set_powerdown_mode(struct iio_dev *indio_dev,
const struct iio_chan_spec *chan,
unsigned int mode)
{
struct ti_dac_chip *ti_dac = iio_priv(indio_dev);
int ret = 0;
if (ti_dac->powerdown_mode == mode)
return 0;
mutex_lock(&ti_dac->lock);
if (ti_dac->powerdown) {
ret = ti_dac_cmd(ti_dac, POWERDOWN(mode), 0);
if (ret)
goto out;
}
ti_dac->powerdown_mode = mode;
out:
mutex_unlock(&ti_dac->lock);
return ret;
}
static const struct iio_enum ti_dac_powerdown_mode = {
.items = ti_dac_powerdown_modes,
.num_items = ARRAY_SIZE(ti_dac_powerdown_modes),
.get = ti_dac_get_powerdown_mode,
.set = ti_dac_set_powerdown_mode,
};
static ssize_t ti_dac_read_powerdown(struct iio_dev *indio_dev,
uintptr_t private,
const struct iio_chan_spec *chan,
char *buf)
{
struct ti_dac_chip *ti_dac = iio_priv(indio_dev);
return sprintf(buf, "%d\n", ti_dac->powerdown);
}
static ssize_t ti_dac_write_powerdown(struct iio_dev *indio_dev,
uintptr_t private,
const struct iio_chan_spec *chan,
const char *buf, size_t len)
{
struct ti_dac_chip *ti_dac = iio_priv(indio_dev);
bool powerdown;
int ret;
ret = strtobool(buf, &powerdown);
if (ret)
return ret;
if (ti_dac->powerdown == powerdown)
return len;
mutex_lock(&ti_dac->lock);
if (powerdown)
ret = ti_dac_cmd(ti_dac, POWERDOWN(ti_dac->powerdown_mode), 0);
else
ret = ti_dac_cmd(ti_dac, WRITE_AND_UPDATE(0), ti_dac->val[0]);
if (!ret)
ti_dac->powerdown = powerdown;
mutex_unlock(&ti_dac->lock);
return ret ? ret : len;
}
static const struct iio_chan_spec_ext_info ti_dac_ext_info[] = {
{
.name = "powerdown",
.read = ti_dac_read_powerdown,
.write = ti_dac_write_powerdown,
.shared = IIO_SHARED_BY_TYPE,
},
IIO_ENUM("powerdown_mode", IIO_SHARED_BY_TYPE, &ti_dac_powerdown_mode),
IIO_ENUM_AVAILABLE("powerdown_mode", &ti_dac_powerdown_mode),
{ },
};
#define TI_DAC_CHANNEL(chan) { \
.type = IIO_VOLTAGE, \
.channel = (chan), \
.address = (chan), \
.indexed = true, \
.output = true, \
.datasheet_name = (const char[]){ 'A' + (chan), 0 }, \
.info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
.info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), \
.ext_info = ti_dac_ext_info, \
}
static const struct iio_chan_spec ti_dac_channels[] = {
TI_DAC_CHANNEL(0),
TI_DAC_CHANNEL(1),
TI_DAC_CHANNEL(2),
TI_DAC_CHANNEL(3),
};
static int ti_dac_read_raw(struct iio_dev *indio_dev,
struct iio_chan_spec const *chan,
int *val, int *val2, long mask)
{
struct ti_dac_chip *ti_dac = iio_priv(indio_dev);
int ret;
switch (mask) {
case IIO_CHAN_INFO_RAW:
*val = ti_dac->val[chan->channel];
ret = IIO_VAL_INT;
break;
case IIO_CHAN_INFO_SCALE:
ret = regulator_get_voltage(ti_dac->vref);
if (ret < 0)
return ret;
*val = ret / 1000;
*val2 = ti_dac->resolution;
ret = IIO_VAL_FRACTIONAL_LOG2;
break;
default:
ret = -EINVAL;
}
return ret;
}
static int ti_dac_write_raw(struct iio_dev *indio_dev,
struct iio_chan_spec const *chan,
int val, int val2, long mask)
{
struct ti_dac_chip *ti_dac = iio_priv(indio_dev);
int ret;
switch (mask) {
case IIO_CHAN_INFO_RAW:
if (ti_dac->val[chan->channel] == val)
return 0;
if (val >= (1 << ti_dac->resolution) || val < 0)
return -EINVAL;
if (ti_dac->powerdown)
return -EBUSY;
mutex_lock(&ti_dac->lock);
ret = ti_dac_cmd(ti_dac, WRITE_AND_UPDATE(chan->channel), val);
if (!ret)
ti_dac->val[chan->channel] = val;
mutex_unlock(&ti_dac->lock);
break;
default:
ret = -EINVAL;
}
return ret;
}
static int ti_dac_write_raw_get_fmt(struct iio_dev *indio_dev,
struct iio_chan_spec const *chan, long mask)
{
return IIO_VAL_INT;
}
static const struct iio_info ti_dac_info = {
.read_raw = ti_dac_read_raw,
.write_raw = ti_dac_write_raw,
.write_raw_get_fmt = ti_dac_write_raw_get_fmt,
};
static int ti_dac_probe(struct spi_device *spi)
{
struct device *dev = &spi->dev;
const struct ti_dac_spec *spec;
struct ti_dac_chip *ti_dac;
struct iio_dev *indio_dev;
int ret;
indio_dev = devm_iio_device_alloc(dev, sizeof(*ti_dac));
if (!indio_dev)
return -ENOMEM;
indio_dev->dev.parent = dev;
indio_dev->info = &ti_dac_info;
indio_dev->name = spi->modalias;
indio_dev->modes = INDIO_DIRECT_MODE;
indio_dev->channels = ti_dac_channels;
spi_set_drvdata(spi, indio_dev);
ti_dac = iio_priv(indio_dev);
ti_dac->xfer.tx_buf = &ti_dac->buf;
ti_dac->xfer.len = sizeof(ti_dac->buf);
spi_message_init_with_transfers(&ti_dac->mesg, &ti_dac->xfer, 1);
ti_dac->mesg.spi = spi;
spec = &ti_dac_spec[spi_get_device_id(spi)->driver_data];
indio_dev->num_channels = spec->num_channels;
ti_dac->resolution = spec->resolution;
ti_dac->vref = devm_regulator_get(dev, "vref");
if (IS_ERR(ti_dac->vref))
return PTR_ERR(ti_dac->vref);
ret = regulator_enable(ti_dac->vref);
if (ret < 0)
return ret;
mutex_init(&ti_dac->lock);
ret = ti_dac_cmd(ti_dac, WRITE_ALL_UPDATE, 0);
if (ret) {
dev_err(dev, "failed to initialize outputs to 0\n");
goto err;
}
ret = iio_device_register(indio_dev);
if (ret)
goto err;
return 0;
err:
mutex_destroy(&ti_dac->lock);
regulator_disable(ti_dac->vref);
return ret;
}
static int ti_dac_remove(struct spi_device *spi)
{
struct iio_dev *indio_dev = spi_get_drvdata(spi);
struct ti_dac_chip *ti_dac = iio_priv(indio_dev);
iio_device_unregister(indio_dev);
mutex_destroy(&ti_dac->lock);
regulator_disable(ti_dac->vref);
return 0;
}
#ifdef CONFIG_OF
static const struct of_device_id ti_dac_of_id[] = {
{ .compatible = "ti,dac082s085" },
{ .compatible = "ti,dac102s085" },
{ .compatible = "ti,dac122s085" },
{ .compatible = "ti,dac084s085" },
{ .compatible = "ti,dac104s085" },
{ .compatible = "ti,dac124s085" },
{ }
};
MODULE_DEVICE_TABLE(of, ti_dac_of_id);
#endif
static const struct spi_device_id ti_dac_spi_id[] = {
{ "dac082s085", dual_8bit },
{ "dac102s085", dual_10bit },
{ "dac122s085", dual_12bit },
{ "dac084s085", quad_8bit },
{ "dac104s085", quad_10bit },
{ "dac124s085", quad_12bit },
{ }
};
MODULE_DEVICE_TABLE(spi, ti_dac_spi_id);
static struct spi_driver ti_dac_driver = {
.driver = {
.name = "ti-dac082s085",
.of_match_table = of_match_ptr(ti_dac_of_id),
},
.probe = ti_dac_probe,
.remove = ti_dac_remove,
.id_table = ti_dac_spi_id,
};
module_spi_driver(ti_dac_driver);
MODULE_AUTHOR("Lukas Wunner <lukas@wunner.de>");
MODULE_DESCRIPTION("Texas Instruments 8/10/12-bit 2/4-channel DAC driver");
MODULE_LICENSE("GPL v2");

440
drivers/staging/iio/light/tsl2x7x.c
View File

@ -15,112 +15,112 @@
* more details.
*/
#include <linux/kernel.h>
#include <linux/i2c.h>
#include <linux/errno.h>
#include <linux/delay.h>
#include <linux/mutex.h>
#include <linux/errno.h>
#include <linux/i2c.h>
#include <linux/interrupt.h>
#include <linux/slab.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/mutex.h>
#include <linux/slab.h>
#include <linux/iio/events.h>
#include <linux/iio/iio.h>
#include <linux/iio/sysfs.h>
#include "tsl2x7x.h"
/* Cal defs*/
#define PROX_STAT_CAL 0
#define PROX_STAT_SAMP 1
#define MAX_SAMPLES_CAL 200
#define PROX_STAT_CAL 0
#define PROX_STAT_SAMP 1
#define MAX_SAMPLES_CAL 200
/* TSL2X7X Device ID */
#define TRITON_ID 0x00
#define SWORDFISH_ID 0x30
#define HALIBUT_ID 0x20
#define TRITON_ID 0x00
#define SWORDFISH_ID 0x30
#define HALIBUT_ID 0x20
/* Lux calculation constants */
#define TSL2X7X_LUX_CALC_OVER_FLOW 65535
#define TSL2X7X_LUX_CALC_OVER_FLOW 65535
/* TAOS Register definitions - note:
* depending on device, some of these register are not used and the
* register address is benign.
*/
/* 2X7X register offsets */
#define TSL2X7X_MAX_CONFIG_REG 16
#define TSL2X7X_MAX_CONFIG_REG 16
/* Device Registers and Masks */
#define TSL2X7X_CNTRL 0x00
#define TSL2X7X_ALS_TIME 0X01
#define TSL2X7X_PRX_TIME 0x02
#define TSL2X7X_WAIT_TIME 0x03
#define TSL2X7X_ALS_MINTHRESHLO 0X04
#define TSL2X7X_ALS_MINTHRESHHI 0X05
#define TSL2X7X_ALS_MAXTHRESHLO 0X06
#define TSL2X7X_ALS_MAXTHRESHHI 0X07
#define TSL2X7X_PRX_MINTHRESHLO 0X08
#define TSL2X7X_PRX_MINTHRESHHI 0X09
#define TSL2X7X_PRX_MAXTHRESHLO 0X0A
#define TSL2X7X_PRX_MAXTHRESHHI 0X0B
#define TSL2X7X_PERSISTENCE 0x0C
#define TSL2X7X_PRX_CONFIG 0x0D
#define TSL2X7X_PRX_COUNT 0x0E
#define TSL2X7X_GAIN 0x0F
#define TSL2X7X_NOTUSED 0x10
#define TSL2X7X_REVID 0x11
#define TSL2X7X_CHIPID 0x12
#define TSL2X7X_STATUS 0x13
#define TSL2X7X_ALS_CHAN0LO 0x14
#define TSL2X7X_ALS_CHAN0HI 0x15
#define TSL2X7X_ALS_CHAN1LO 0x16
#define TSL2X7X_ALS_CHAN1HI 0x17
#define TSL2X7X_PRX_LO 0x18
#define TSL2X7X_PRX_HI 0x19
#define TSL2X7X_CNTRL 0x00
#define TSL2X7X_ALS_TIME 0X01
#define TSL2X7X_PRX_TIME 0x02
#define TSL2X7X_WAIT_TIME 0x03
#define TSL2X7X_ALS_MINTHRESHLO 0X04
#define TSL2X7X_ALS_MINTHRESHHI 0X05
#define TSL2X7X_ALS_MAXTHRESHLO 0X06
#define TSL2X7X_ALS_MAXTHRESHHI 0X07
#define TSL2X7X_PRX_MINTHRESHLO 0X08
#define TSL2X7X_PRX_MINTHRESHHI 0X09
#define TSL2X7X_PRX_MAXTHRESHLO 0X0A
#define TSL2X7X_PRX_MAXTHRESHHI 0X0B
#define TSL2X7X_PERSISTENCE 0x0C
#define TSL2X7X_PRX_CONFIG 0x0D
#define TSL2X7X_PRX_COUNT 0x0E
#define TSL2X7X_GAIN 0x0F
#define TSL2X7X_NOTUSED 0x10
#define TSL2X7X_REVID 0x11
#define TSL2X7X_CHIPID 0x12
#define TSL2X7X_STATUS 0x13
#define TSL2X7X_ALS_CHAN0LO 0x14
#define TSL2X7X_ALS_CHAN0HI 0x15
#define TSL2X7X_ALS_CHAN1LO 0x16
#define TSL2X7X_ALS_CHAN1HI 0x17
#define TSL2X7X_PRX_LO 0x18
#define TSL2X7X_PRX_HI 0x19
/* tsl2X7X cmd reg masks */
#define TSL2X7X_CMD_REG 0x80
#define TSL2X7X_CMD_SPL_FN 0x60
#define TSL2X7X_CMD_REG 0x80
#define TSL2X7X_CMD_SPL_FN 0x60
#define TSL2X7X_CMD_PROX_INT_CLR 0X05
#define TSL2X7X_CMD_ALS_INT_CLR 0x06
#define TSL2X7X_CMD_PROXALS_INT_CLR 0X07
#define TSL2X7X_CMD_PROX_INT_CLR 0X05
#define TSL2X7X_CMD_ALS_INT_CLR 0x06
#define TSL2X7X_CMD_PROXALS_INT_CLR 0X07
/* tsl2X7X cntrl reg masks */
#define TSL2X7X_CNTL_ADC_ENBL 0x02
#define TSL2X7X_CNTL_PWR_ON 0x01
#define TSL2X7X_CNTL_ADC_ENBL 0x02
#define TSL2X7X_CNTL_PWR_ON 0x01
/* tsl2X7X status reg masks */
#define TSL2X7X_STA_ADC_VALID 0x01
#define TSL2X7X_STA_PRX_VALID 0x02
#define TSL2X7X_STA_ADC_PRX_VALID (TSL2X7X_STA_ADC_VALID |\
TSL2X7X_STA_PRX_VALID)
#define TSL2X7X_STA_ALS_INTR 0x10
#define TSL2X7X_STA_PRX_INTR 0x20
#define TSL2X7X_STA_ADC_VALID 0x01
#define TSL2X7X_STA_PRX_VALID 0x02
#define TSL2X7X_STA_ADC_PRX_VALID (TSL2X7X_STA_ADC_VALID | \
TSL2X7X_STA_PRX_VALID)
#define TSL2X7X_STA_ALS_INTR 0x10
#define TSL2X7X_STA_PRX_INTR 0x20
/* tsl2X7X cntrl reg masks */
#define TSL2X7X_CNTL_REG_CLEAR 0x00
#define TSL2X7X_CNTL_PROX_INT_ENBL 0X20
#define TSL2X7X_CNTL_ALS_INT_ENBL 0X10
#define TSL2X7X_CNTL_WAIT_TMR_ENBL 0X08
#define TSL2X7X_CNTL_PROX_DET_ENBL 0X04
#define TSL2X7X_CNTL_PWRON 0x01
#define TSL2X7X_CNTL_ALSPON_ENBL 0x03
#define TSL2X7X_CNTL_INTALSPON_ENBL 0x13
#define TSL2X7X_CNTL_PROXPON_ENBL 0x0F
#define TSL2X7X_CNTL_INTPROXPON_ENBL 0x2F
#define TSL2X7X_CNTL_REG_CLEAR 0x00
#define TSL2X7X_CNTL_PROX_INT_ENBL 0X20
#define TSL2X7X_CNTL_ALS_INT_ENBL 0X10
#define TSL2X7X_CNTL_WAIT_TMR_ENBL 0X08
#define TSL2X7X_CNTL_PROX_DET_ENBL 0X04
#define TSL2X7X_CNTL_PWRON 0x01
#define TSL2X7X_CNTL_ALSPON_ENBL 0x03
#define TSL2X7X_CNTL_INTALSPON_ENBL 0x13
#define TSL2X7X_CNTL_PROXPON_ENBL 0x0F
#define TSL2X7X_CNTL_INTPROXPON_ENBL 0x2F
/*Prox diode to use */
#define TSL2X7X_DIODE0 0x10
#define TSL2X7X_DIODE1 0x20
#define TSL2X7X_DIODE_BOTH 0x30
#define TSL2X7X_DIODE0 0x10
#define TSL2X7X_DIODE1 0x20
#define TSL2X7X_DIODE_BOTH 0x30
/* LED Power */
#define TSL2X7X_mA100 0x00
#define TSL2X7X_mA50 0x40
#define TSL2X7X_mA25 0x80
#define TSL2X7X_mA13 0xD0
#define TSL2X7X_MAX_TIMER_CNT (0xFF)
#define TSL2X7X_100_mA 0x00
#define TSL2X7X_50_mA 0x40
#define TSL2X7X_25_mA 0x80
#define TSL2X7X_13_mA 0xD0
#define TSL2X7X_MAX_TIMER_CNT 0xFF
#define TSL2X7X_MIN_ITIME 3
#define TSL2X7X_MIN_ITIME 3
/* TAOS txx2x7x Device family members */
enum {
@ -142,11 +142,6 @@ enum {
TSL2X7X_CHIP_SUSPENDED = 2
};
struct tsl2x7x_parse_result {
int integer;
int fract;
};
/* Per-device data */
struct tsl2x7x_als_info {
u16 als_ch0;
@ -248,14 +243,14 @@ static const struct tsl2x7x_settings tsl2x7x_default_settings = {
.prox_pulse_count = 8
};
static const s16 tsl2X7X_als_gainadj[] = {
static const s16 tsl2x7x_als_gain[] = {
1,
8,
16,
120
};
static const s16 tsl2X7X_prx_gainadj[] = {
static const s16 tsl2x7x_prx_gain[] = {
1,
2,
4,
@ -353,9 +348,9 @@ static int tsl2x7x_get_lux(struct iio_dev *indio_dev)
/* clear any existing interrupt status */
ret = i2c_smbus_write_byte(chip->client,
(TSL2X7X_CMD_REG |
TSL2X7X_CMD_REG |
TSL2X7X_CMD_SPL_FN |
TSL2X7X_CMD_ALS_INT_CLR));
TSL2X7X_CMD_ALS_INT_CLR);
if (ret < 0) {
dev_err(&chip->client->dev,
"i2c_write_command failed - err = %d\n", ret);
@ -369,7 +364,7 @@ static int tsl2x7x_get_lux(struct iio_dev *indio_dev)
chip->als_cur_info.als_ch0 = ch0;
chip->als_cur_info.als_ch1 = ch1;
if ((ch0 >= chip->als_saturation) || (ch1 >= chip->als_saturation)) {
if (ch0 >= chip->als_saturation || ch1 >= chip->als_saturation) {
lux = TSL2X7X_LUX_CALC_OVER_FLOW;
goto return_max;
}
@ -389,11 +384,10 @@ static int tsl2x7x_get_lux(struct iio_dev *indio_dev)
if (p->ratio == 0) {
lux = 0;
} else {
ch0lux = DIV_ROUND_UP(ch0 * p->ch0,
tsl2X7X_als_gainadj[chip->settings.als_gain]);
ch1lux = DIV_ROUND_UP(ch1 * p->ch1,
tsl2X7X_als_gainadj[chip->settings.als_gain]);
lux = ch0lux - ch1lux;
lux = DIV_ROUND_UP(ch0 * p->ch0,
tsl2x7x_als_gain[chip->settings.als_gain]) -
DIV_ROUND_UP(ch1 * p->ch1,
tsl2x7x_als_gain[chip->settings.als_gain]);
}
/* note: lux is 31 bit max at this point */
@ -472,7 +466,7 @@ static int tsl2x7x_get_prox(struct iio_dev *indio_dev)
case tmd2771:
if (!(ret & TSL2X7X_STA_ADC_VALID))
goto prox_poll_err;
break;
break;
case tsl2572:
case tsl2672:
case tmd2672:
@ -480,7 +474,7 @@ static int tsl2x7x_get_prox(struct iio_dev *indio_dev)
case tmd2772:
if (!(ret & TSL2X7X_STA_PRX_VALID))
goto prox_poll_err;
break;
break;
}
for (i = 0; i < 2; i++) {
@ -527,8 +521,8 @@ static void tsl2x7x_defaults(struct tsl2X7X_chip *chip)
sizeof(chip->pdata->platform_lux_table));
else
memcpy(chip->tsl2x7x_device_lux,
(struct tsl2x7x_lux *)tsl2x7x_default_lux_table_group[chip->id],
TSL2X7X_DEFAULT_TABLE_BYTES);
tsl2x7x_default_lux_table_group[chip->id],
TSL2X7X_DEFAULT_TABLE_BYTES);
}
/**
@ -642,7 +636,7 @@ static int tsl2x7x_chip_on(struct iio_dev *indio_dev)
/* Set the gain based on tsl2x7x_settings struct */
chip->tsl2x7x_config[TSL2X7X_GAIN] =
chip->settings.als_gain |
(TSL2X7X_mA100 | TSL2X7X_DIODE1) |
(TSL2X7X_100_mA | TSL2X7X_DIODE1) |
(chip->settings.prox_gain << 2);
/* set chip struct re scaling and saturation */
@ -702,14 +696,14 @@ static int tsl2x7x_chip_on(struct iio_dev *indio_dev)
dev_info(&chip->client->dev, "Setting Up Interrupt(s)\n");
reg_val = TSL2X7X_CNTL_PWR_ON | TSL2X7X_CNTL_ADC_ENBL;
if ((chip->settings.interrupts_en == 0x20) ||
(chip->settings.interrupts_en == 0x30))
if (chip->settings.interrupts_en == 0x20 ||
chip->settings.interrupts_en == 0x30)
reg_val |= TSL2X7X_CNTL_PROX_DET_ENBL;
reg_val |= chip->settings.interrupts_en;
ret = i2c_smbus_write_byte_data(chip->client,
(TSL2X7X_CMD_REG |
TSL2X7X_CNTRL), reg_val);
TSL2X7X_CMD_REG | TSL2X7X_CNTRL,
reg_val);
if (ret < 0)
dev_err(&chip->client->dev,
"%s: failed in tsl2x7x_IOCTL_INT_SET.\n",
@ -758,8 +752,7 @@ static int tsl2x7x_chip_off(struct iio_dev *indio_dev)
* put device back into proper state, and unlock
* resource.
*/
static
int tsl2x7x_invoke_change(struct iio_dev *indio_dev)
static int tsl2x7x_invoke_change(struct iio_dev *indio_dev)
{
struct tsl2X7X_chip *chip = iio_priv(indio_dev);
int device_status = chip->tsl2x7x_chip_status;
@ -783,9 +776,8 @@ unlock:
return ret;
}
static
void tsl2x7x_prox_calculate(int *data, int length,
struct tsl2x7x_prox_stat *statP)
static void tsl2x7x_prox_calculate(int *data, int length,
struct tsl2x7x_prox_stat *statP)
{
int i;
int sample_sum;
@ -873,9 +865,10 @@ static void tsl2x7x_prox_cal(struct iio_dev *indio_dev)
tsl2x7x_chip_on(indio_dev);
}
static ssize_t in_illuminance0_calibscale_available_show(struct device *dev,
struct device_attribute *attr,
char *buf)
static ssize_t
in_illuminance0_calibscale_available_show(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct tsl2X7X_chip *chip = iio_priv(dev_to_iio_dev(dev));
@ -891,19 +884,14 @@ static ssize_t in_illuminance0_calibscale_available_show(struct device *dev,
return snprintf(buf, PAGE_SIZE, "%s\n", "1 8 16 120");
}
static ssize_t in_proximity0_calibscale_available_show(struct device *dev,
struct device_attribute *attr,
char *buf)
{
return snprintf(buf, PAGE_SIZE, "%s\n", "1 2 4 8");
}
static IIO_CONST_ATTR(in_proximity0_calibscale_available, "1 2 4 8");
static IIO_CONST_ATTR(in_illuminance0_integration_time_available,
".00272 - .696");
static ssize_t in_illuminance0_target_input_show(struct device *dev,
struct device_attribute *attr,
char *buf)
struct device_attribute *attr,
char *buf)
{
struct tsl2X7X_chip *chip = iio_priv(dev_to_iio_dev(dev));
@ -911,8 +899,8 @@ static ssize_t in_illuminance0_target_input_show(struct device *dev,
}
static ssize_t in_illuminance0_target_input_store(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t len)
struct device_attribute *attr,
const char *buf, size_t len)
{
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct tsl2X7X_chip *chip = iio_priv(indio_dev);
@ -932,111 +920,9 @@ static ssize_t in_illuminance0_target_input_store(struct device *dev,
return len;
}
/* persistence settings */
static ssize_t in_intensity0_thresh_period_show(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct tsl2X7X_chip *chip = iio_priv(dev_to_iio_dev(dev));
int y, z, filter_delay;
/* Determine integration time */
y = (TSL2X7X_MAX_TIMER_CNT - (u8)chip->settings.als_time) + 1;
z = y * TSL2X7X_MIN_ITIME;
filter_delay = z * (chip->settings.persistence & 0x0F);
y = filter_delay / 1000;
z = filter_delay % 1000;
return snprintf(buf, PAGE_SIZE, "%d.%03d\n", y, z);
}
static ssize_t in_intensity0_thresh_period_store(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t len)
{
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct tsl2X7X_chip *chip = iio_priv(indio_dev);
struct tsl2x7x_parse_result result;
int y, z, filter_delay;
int ret;
ret = iio_str_to_fixpoint(buf, 100, &result.integer, &result.fract);
if (ret)
return ret;
y = (TSL2X7X_MAX_TIMER_CNT - (u8)chip->settings.als_time) + 1;
z = y * TSL2X7X_MIN_ITIME;
filter_delay =
DIV_ROUND_UP((result.integer * 1000) + result.fract, z);
chip->settings.persistence &= 0xF0;
chip->settings.persistence |= (filter_delay & 0x0F);
dev_info(&chip->client->dev, "%s: als persistence = %d",
__func__, filter_delay);
ret = tsl2x7x_invoke_change(indio_dev);
if (ret < 0)
return ret;
return IIO_VAL_INT_PLUS_MICRO;
}
static ssize_t in_proximity0_thresh_period_show(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct tsl2X7X_chip *chip = iio_priv(dev_to_iio_dev(dev));
int y, z, filter_delay;
/* Determine integration time */
y = (TSL2X7X_MAX_TIMER_CNT - (u8)chip->settings.prx_time) + 1;
z = y * TSL2X7X_MIN_ITIME;
filter_delay = z * ((chip->settings.persistence & 0xF0) >> 4);
y = filter_delay / 1000;
z = filter_delay % 1000;
return snprintf(buf, PAGE_SIZE, "%d.%03d\n", y, z);
}
static ssize_t in_proximity0_thresh_period_store(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t len)
{
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct tsl2X7X_chip *chip = iio_priv(indio_dev);
struct tsl2x7x_parse_result result;
int y, z, filter_delay;
int ret;
ret = iio_str_to_fixpoint(buf, 100, &result.integer, &result.fract);
if (ret)
return ret;
y = (TSL2X7X_MAX_TIMER_CNT - (u8)chip->settings.prx_time) + 1;
z = y * TSL2X7X_MIN_ITIME;
filter_delay =
DIV_ROUND_UP((result.integer * 1000) + result.fract, z);
chip->settings.persistence &= 0x0F;
chip->settings.persistence |= ((filter_delay << 4) & 0xF0);
dev_info(&chip->client->dev, "%s: prox persistence = %d",
__func__, filter_delay);
ret = tsl2x7x_invoke_change(indio_dev);
if (ret < 0)
return ret;
return IIO_VAL_INT_PLUS_MICRO;
}
static ssize_t in_illuminance0_calibrate_store(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t len)
struct device_attribute *attr,
const char *buf, size_t len)
{
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
bool value;
@ -1056,8 +942,8 @@ static ssize_t in_illuminance0_calibrate_store(struct device *dev,
}
static ssize_t in_illuminance0_lux_table_show(struct device *dev,
struct device_attribute *attr,
char *buf)
struct device_attribute *attr,
char *buf)
{
struct tsl2X7X_chip *chip = iio_priv(dev_to_iio_dev(dev));
int i = 0;
@ -1084,8 +970,8 @@ static ssize_t in_illuminance0_lux_table_show(struct device *dev,
}
static ssize_t in_illuminance0_lux_table_store(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t len)
struct device_attribute *attr,
const char *buf, size_t len)
{
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct tsl2X7X_chip *chip = iio_priv(indio_dev);
@ -1126,8 +1012,8 @@ static ssize_t in_illuminance0_lux_table_store(struct device *dev,
}
static ssize_t in_proximity0_calibrate_store(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t len)
struct device_attribute *attr,
const char *buf, size_t len)
{
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
bool value;
@ -1198,7 +1084,8 @@ static int tsl2x7x_write_event_value(struct iio_dev *indio_dev,
int val, int val2)
{
struct tsl2X7X_chip *chip = iio_priv(indio_dev);
int ret = -EINVAL;
int ret = -EINVAL, y, z, filter_delay;
u8 time;
switch (info) {
case IIO_EV_INFO_VALUE:
@ -1230,6 +1117,33 @@ static int tsl2x7x_write_event_value(struct iio_dev *indio_dev,
}
}
break;
case IIO_EV_INFO_PERIOD:
if (chan->type == IIO_INTENSITY)
time = chip->settings.als_time;
else
time = chip->settings.prx_time;
y = (TSL2X7X_MAX_TIMER_CNT - time) + 1;
z = y * TSL2X7X_MIN_ITIME;
filter_delay = DIV_ROUND_UP((val * 1000) + val2, z);
if (chan->type == IIO_INTENSITY) {
chip->settings.persistence &= 0xF0;
chip->settings.persistence |=
(filter_delay & 0x0F);
dev_info(&chip->client->dev, "%s: ALS persistence = %d",
__func__, filter_delay);
} else {
chip->settings.persistence &= 0x0F;
chip->settings.persistence |=
((filter_delay << 4) & 0xF0);
dev_info(&chip->client->dev,
"%s: Proximity persistence = %d",
__func__, filter_delay);
}
ret = 0;
break;
default:
break;
}
@ -1248,7 +1162,8 @@ static int tsl2x7x_read_event_value(struct iio_dev *indio_dev,
int *val, int *val2)
{
struct tsl2X7X_chip *chip = iio_priv(indio_dev);
int ret = -EINVAL;
int ret = -EINVAL, filter_delay, mult;
u8 time;
switch (info) {
case IIO_EV_INFO_VALUE:
@ -1280,6 +1195,23 @@ static int tsl2x7x_read_event_value(struct iio_dev *indio_dev,
}
}
break;
case IIO_EV_INFO_PERIOD:
if (chan->type == IIO_INTENSITY) {
time = chip->settings.als_time;
mult = chip->settings.persistence & 0x0F;
} else {
time = chip->settings.prx_time;
mult = (chip->settings.persistence & 0xF0) >> 4;
}
/* Determine integration time */
*val = (TSL2X7X_MAX_TIMER_CNT - time) + 1;
*val2 = *val * TSL2X7X_MIN_ITIME;
filter_delay = *val2 * mult;
*val = filter_delay / 1000;
*val2 = filter_delay % 1000;
ret = IIO_VAL_INT_PLUS_MICRO;
break;
default:
break;
}
@ -1329,9 +1261,9 @@ static int tsl2x7x_read_raw(struct iio_dev *indio_dev,
break;
case IIO_CHAN_INFO_CALIBSCALE:
if (chan->type == IIO_LIGHT)
*val = tsl2X7X_als_gainadj[chip->settings.als_gain];
*val = tsl2x7x_als_gain[chip->settings.als_gain];
else
*val = tsl2X7X_prx_gainadj[chip->settings.prox_gain];
*val = tsl2x7x_prx_gain[chip->settings.prox_gain];
ret = IIO_VAL_INT;
break;
case IIO_CHAN_INFO_CALIBBIAS:
@ -1432,8 +1364,6 @@ static int tsl2x7x_write_raw(struct iio_dev *indio_dev,
return tsl2x7x_invoke_change(indio_dev);
}
static DEVICE_ATTR_RO(in_proximity0_calibscale_available);
static DEVICE_ATTR_RO(in_illuminance0_calibscale_available);
static DEVICE_ATTR_RW(in_illuminance0_target_input);
@ -1444,10 +1374,6 @@ static DEVICE_ATTR_WO(in_proximity0_calibrate);
static DEVICE_ATTR_RW(in_illuminance0_lux_table);
static DEVICE_ATTR_RW(in_intensity0_thresh_period);
static DEVICE_ATTR_RW(in_proximity0_thresh_period);
/* Use the default register values to identify the Taos device */
static int tsl2x7x_device_id(int *id, int target)
{
@ -1533,13 +1459,13 @@ static struct attribute *tsl2x7x_ALSPRX_device_attrs[] = {
&dev_attr_in_illuminance0_target_input.attr,
&dev_attr_in_illuminance0_calibrate.attr,
&dev_attr_in_illuminance0_lux_table.attr,
&dev_attr_in_proximity0_calibrate.attr,
&iio_const_attr_in_proximity0_calibscale_available.dev_attr.attr,
NULL
};
static struct attribute *tsl2x7x_PRX2_device_attrs[] = {
&dev_attr_in_proximity0_calibrate.attr,
&dev_attr_in_proximity0_calibscale_available.attr,
&iio_const_attr_in_proximity0_calibscale_available.dev_attr.attr,
NULL
};
@ -1550,26 +1476,10 @@ static struct attribute *tsl2x7x_ALSPRX2_device_attrs[] = {
&dev_attr_in_illuminance0_calibrate.attr,
&dev_attr_in_illuminance0_lux_table.attr,
&dev_attr_in_proximity0_calibrate.attr,
&dev_attr_in_proximity0_calibscale_available.attr,
&iio_const_attr_in_proximity0_calibscale_available.dev_attr.attr,
NULL
};
static struct attribute *tsl2X7X_ALS_event_attrs[] = {
&dev_attr_in_intensity0_thresh_period.attr,
NULL,
};
static struct attribute *tsl2X7X_PRX_event_attrs[] = {
&dev_attr_in_proximity0_thresh_period.attr,
NULL,
};
static struct attribute *tsl2X7X_ALSPRX_event_attrs[] = {
&dev_attr_in_intensity0_thresh_period.attr,
&dev_attr_in_proximity0_thresh_period.attr,
NULL,
};
static const struct attribute_group tsl2X7X_device_attr_group_tbl[] = {
[ALS] = {
.attrs = tsl2x7x_ALS_device_attrs,
@ -1588,25 +1498,9 @@ static const struct attribute_group tsl2X7X_device_attr_group_tbl[] = {
},
};
static const struct attribute_group tsl2X7X_event_attr_group_tbl[] = {
[ALS] = {
.attrs = tsl2X7X_ALS_event_attrs,
.name = "events",
},
[PRX] = {
.attrs = tsl2X7X_PRX_event_attrs,
.name = "events",
},
[ALSPRX] = {
.attrs = tsl2X7X_ALSPRX_event_attrs,
.name = "events",
},
};
static const struct iio_info tsl2X7X_device_info[] = {
[ALS] = {
.attrs = &tsl2X7X_device_attr_group_tbl[ALS],
.event_attrs = &tsl2X7X_event_attr_group_tbl[ALS],
.read_raw = &tsl2x7x_read_raw,
.write_raw = &tsl2x7x_write_raw,
.read_event_value = &tsl2x7x_read_event_value,
@ -1616,7 +1510,6 @@ static const struct iio_info tsl2X7X_device_info[] = {
},
[PRX] = {
.attrs = &tsl2X7X_device_attr_group_tbl[PRX],
.event_attrs = &tsl2X7X_event_attr_group_tbl[PRX],
.read_raw = &tsl2x7x_read_raw,
.write_raw = &tsl2x7x_write_raw,
.read_event_value = &tsl2x7x_read_event_value,
@ -1626,7 +1519,6 @@ static const struct iio_info tsl2X7X_device_info[] = {
},
[ALSPRX] = {
.attrs = &tsl2X7X_device_attr_group_tbl[ALSPRX],
.event_attrs = &tsl2X7X_event_attr_group_tbl[ALSPRX],
.read_raw = &tsl2x7x_read_raw,
.write_raw = &tsl2x7x_write_raw,
.read_event_value = &tsl2x7x_read_event_value,
@ -1636,7 +1528,6 @@ static const struct iio_info tsl2X7X_device_info[] = {
},
[PRX2] = {
.attrs = &tsl2X7X_device_attr_group_tbl[PRX2],
.event_attrs = &tsl2X7X_event_attr_group_tbl[PRX],
.read_raw = &tsl2x7x_read_raw,
.write_raw = &tsl2x7x_write_raw,
.read_event_value = &tsl2x7x_read_event_value,
@ -1646,7 +1537,6 @@ static const struct iio_info tsl2X7X_device_info[] = {
},
[ALSPRX2] = {
.attrs = &tsl2X7X_device_attr_group_tbl[ALSPRX2],
.event_attrs = &tsl2X7X_event_attr_group_tbl[ALSPRX],
.read_raw = &tsl2x7x_read_raw,
.write_raw = &tsl2x7x_write_raw,
.read_event_value = &tsl2x7x_read_event_value,
@ -1667,6 +1557,10 @@ static const struct iio_event_spec tsl2x7x_events[] = {
.dir = IIO_EV_DIR_FALLING,
.mask_separate = BIT(IIO_EV_INFO_VALUE) |
BIT(IIO_EV_INFO_ENABLE),
}, {
.type = IIO_EV_TYPE_THRESH,
.dir = IIO_EV_DIR_EITHER,
.mask_separate = BIT(IIO_EV_INFO_PERIOD),
},
};
@ -1825,7 +1719,7 @@ static int tsl2x7x_probe(struct i2c_client *clientp,
return -EINVAL;
}
ret = i2c_smbus_write_byte(clientp, (TSL2X7X_CMD_REG | TSL2X7X_CNTRL));
ret = i2c_smbus_write_byte(clientp, TSL2X7X_CMD_REG | TSL2X7X_CNTRL);
if (ret < 0) {
dev_err(&clientp->dev, "write to cmd reg failed. err = %d\n",
ret);

2
drivers/staging/iio/light/tsl2x7x.h
View File

@ -23,8 +23,6 @@
#define __TSL2X7X_H
#include <linux/pm.h>
struct iio_dev;
struct tsl2x7x_lux {
unsigned int ratio;
unsigned int ch0;