mirror of
https://github.com/torvalds/linux.git
synced 2024-11-26 22:21:42 +00:00
First set of new drivers, cleanups and functionality for IIO in the 4.1 cycle.
New drivers
* CM3323 color sensor.
* MS5611 pressure and temperature sensor.
New functionality
* mup6050 - create mux clients for devices described via ACPI. The reasoning
and approach taken in this patch are complex. Basically there is no
otherway of finding out what is there than by some esoteric look ups in
the ACPI data.
* cm3232 - PM support
* itg3200 - suspend/resume support
* mcp320x - add more ADCs to the kconfig to reflect what the driver supports
(this patch and the bindings got left behind when the support was added
a while back).
Docs / utils
* ti-adc128s052 - DT bindings.
* mcp3422 - DT bindings.
* mcp320x - DT bindings
* ABI docs for event threshold scale attributes, in_magn_offset, proximity
scan_element and thresh falling/rising values for accelerometers. All
elements long in use that have slipped by being explicitly documented.
* Tidy up the tools previously in drivers/staging/iio/Documentation and move
them out to /tools/iio. Yet another move that should have happened long ago.
This time Roberta Dobrescu did the leg work. Thanks!
Core Cleanups
* Export userspace IIO headers. We should have done the appropriate header
splitting a long time ago. Thanks to Daniel for sorting this out.
* Refactor the registring of attributes for buffers to move all non-custom
ones to a vector allowing easier additions to the current set in the future.
Driver Cleanups
* gpiod related cleanups. Make use of the additional parameter to specify
initial direciton to avoid extra code.
* bmc150 - Various refactorings to reduce code repitition and prepare for
hardware buffer support. Some of these cleanups are good even
without the new functionality.
* kmx61 - direct use of index to an array avoiding a structure element which
was always the index to an element in an array of that structure.
* vf610 - avoid incorrect type for return from wait_for_completion_timeout.
* gp2ap020a00f - use put_unaligned_le32 for slight code simplification.
* ade7754 - improve error handling including suppressing some build warnings.
* ade7759 - improve error handling including suppressing some build warnings.
* hmc5843 - Long line and indentation fixes. Also some constifying of various
constant data.
* ade7854 - 80+ character line splitting.
* ad2s1210 - fix wrong printf format string.
* mxs-lradc - fix wrong printf format string.
* ade7954-i2c - code alignment fixes and other trivial but worthwhile bits.
* periodic rtc trigger - make the frequency type an unsigned int as it
is always treated as such.
* jsa1212 - constify struct regmap_config as it is constant.
* ad7793 - typo in the MODULE_DESCRIPTION
* mma9551 - check gpiod_to_irq errors. Note that this doesn't actually cause
any trouble but is worth tidying up as obviously incorrect.
* mlx90614 - refactor the register symbols to make it clear which reads are to
RAM not PROM.
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v2
iQIcBAABCAAGBQJVBe4zAAoJEFSFNJnE9BaISXAP+wcVdU9PyiLdpjh7D73qbbV0
KnKJHdO+aKe4hCv6Xl0fWIbJcsxTn8ALPHkkxHnu06hd2Q9zANgdJ5dER5XB34fX
vw+EjsIdiyCDmoOVGzP5SsmbSoO3gNoR5GdWmjKFKjr0eSxinh3AmAesTVSC2T9Y
vHkjgDj3KaqN735brd2GneeG/s3jY8ZZaiTZ0jFotCtSmBAiPi8uYwIwMLmVpsVu
M3tcUPWKithRoyKBmO4tiDg2Qwnj0IhN8zyIYiUBftxCIIY7tSlQkYgRzDmrxGG2
HCITf33Ss87UH0IF1BOm5PXjQ3ClI3idtCwqCeXscAo6IXmoe/+BsXR/m2JqUTdp
EOrORyzsHc0WkJK8dnp1h1XfiBR4UQpiwce5xGFbni2ycfNBw1/J0l7QTi45D6Z7
SdGXTgt1AWd8MoWxcxMhWMPQlHsxK/XMPh10O5wD5icxo5EHvnPP0ObZ15Ax6T/V
kcO+NEJCEHH2Q/kna2M6h4FdUVBxvzjjwhdZVs8PGGfJNDij2cVwspT81lKMauwf
07S0KHEjhqbRSM0TvsMyf2li1Xwv5eu+G2FTkopESJ4a2zyaLobt/QgTu9dzg4Gh
QDJFx4xdmNv4OQ+psZuoDznjM/EV+eQR+swH7P6UDyef0jghLwVkqHxM/HYChiyP
OvZCCnHDB4EiC8jx+c43
=BmiY
-----END PGP SIGNATURE-----
Merge tag 'iio-for-4.1a' of git://git.kernel.org/pub/scm/linux/kernel/git/jic23/iio into staging-next
Jonathan writes:
First set of new drivers, cleanups and functionality for IIO in the 4.1 cycle.
New drivers
* CM3323 color sensor.
* MS5611 pressure and temperature sensor.
New functionality
* mup6050 - create mux clients for devices described via ACPI. The reasoning
and approach taken in this patch are complex. Basically there is no
otherway of finding out what is there than by some esoteric look ups in
the ACPI data.
* cm3232 - PM support
* itg3200 - suspend/resume support
* mcp320x - add more ADCs to the kconfig to reflect what the driver supports
(this patch and the bindings got left behind when the support was added
a while back).
Docs / utils
* ti-adc128s052 - DT bindings.
* mcp3422 - DT bindings.
* mcp320x - DT bindings
* ABI docs for event threshold scale attributes, in_magn_offset, proximity
scan_element and thresh falling/rising values for accelerometers. All
elements long in use that have slipped by being explicitly documented.
* Tidy up the tools previously in drivers/staging/iio/Documentation and move
them out to /tools/iio. Yet another move that should have happened long ago.
This time Roberta Dobrescu did the leg work. Thanks!
Core Cleanups
* Export userspace IIO headers. We should have done the appropriate header
splitting a long time ago. Thanks to Daniel for sorting this out.
* Refactor the registring of attributes for buffers to move all non-custom
ones to a vector allowing easier additions to the current set in the future.
Driver Cleanups
* gpiod related cleanups. Make use of the additional parameter to specify
initial direciton to avoid extra code.
* bmc150 - Various refactorings to reduce code repitition and prepare for
hardware buffer support. Some of these cleanups are good even
without the new functionality.
* kmx61 - direct use of index to an array avoiding a structure element which
was always the index to an element in an array of that structure.
* vf610 - avoid incorrect type for return from wait_for_completion_timeout.
* gp2ap020a00f - use put_unaligned_le32 for slight code simplification.
* ade7754 - improve error handling including suppressing some build warnings.
* ade7759 - improve error handling including suppressing some build warnings.
* hmc5843 - Long line and indentation fixes. Also some constifying of various
constant data.
* ade7854 - 80+ character line splitting.
* ad2s1210 - fix wrong printf format string.
* mxs-lradc - fix wrong printf format string.
* ade7954-i2c - code alignment fixes and other trivial but worthwhile bits.
* periodic rtc trigger - make the frequency type an unsigned int as it
is always treated as such.
* jsa1212 - constify struct regmap_config as it is constant.
* ad7793 - typo in the MODULE_DESCRIPTION
* mma9551 - check gpiod_to_irq errors. Note that this doesn't actually cause
any trouble but is worth tidying up as obviously incorrect.
* mlx90614 - refactor the register symbols to make it clear which reads are to
RAM not PROM.
This commit is contained in:
Greg Kroah-Hartman
commit
dc5f2c5f6a
@ -253,6 +253,7 @@ What: /sys/bus/iio/devices/iio:deviceX/in_temp_offset
|
||||
What: /sys/bus/iio/devices/iio:deviceX/in_pressureY_offset
|
||||
What: /sys/bus/iio/devices/iio:deviceX/in_pressure_offset
|
||||
What: /sys/bus/iio/devices/iio:deviceX/in_humidityrelative_offset
|
||||
What: /sys/bus/iio/devices/iio:deviceX/in_magn_offset
|
||||
KernelVersion: 2.6.35
|
||||
Contact: linux-iio@vger.kernel.org
|
||||
Description:
|
||||
@ -612,6 +613,8 @@ Description:
|
||||
a given event type is enabled a future point (and not those for
|
||||
whatever event was previously enabled).
|
||||
|
||||
What: /sys/.../events/in_accel_thresh_rising_value
|
||||
What: /sys/.../events/in_accel_thresh_falling_value
|
||||
What: /sys/.../events/in_accel_x_raw_thresh_rising_value
|
||||
What: /sys/.../events/in_accel_x_raw_thresh_falling_value
|
||||
What: /sys/.../events/in_accel_y_raw_thresh_rising_value
|
||||
@ -661,6 +664,24 @@ Description:
|
||||
value is in raw device units or in processed units (as _raw
|
||||
and _input do on sysfs direct channel read attributes).
|
||||
|
||||
What: /sys/.../events/in_accel_scale
|
||||
What: /sys/.../events/in_accel_peak_scale
|
||||
What: /sys/.../events/in_anglvel_scale
|
||||
What: /sys/.../events/in_magn_scale
|
||||
What: /sys/.../events/in_rot_from_north_magnetic_scale
|
||||
What: /sys/.../events/in_rot_from_north_true_scale
|
||||
What: /sys/.../events/in_voltage_scale
|
||||
What: /sys/.../events/in_voltage_supply_scale
|
||||
What: /sys/.../events/in_temp_scale
|
||||
What: /sys/.../events/in_illuminance_scale
|
||||
What: /sys/.../events/in_proximity_scale
|
||||
KernelVersion: 3.21
|
||||
Contact: linux-iio@vger.kernel.org
|
||||
Description:
|
||||
Specifies the conversion factor from the standard units
|
||||
to device specific units used to set the event trigger
|
||||
threshold.
|
||||
|
||||
What: /sys/.../events/in_accel_x_thresh_rising_hysteresis
|
||||
What: /sys/.../events/in_accel_x_thresh_falling_hysteresis
|
||||
What: /sys/.../events/in_accel_x_thresh_either_hysteresis
|
||||
@ -997,6 +1018,7 @@ What: /sys/.../iio:deviceX/scan_elements/in_incli_y_en
|
||||
What: /sys/.../iio:deviceX/scan_elements/in_pressureY_en
|
||||
What: /sys/.../iio:deviceX/scan_elements/in_pressure_en
|
||||
What: /sys/.../iio:deviceX/scan_elements/in_rot_quaternion_en
|
||||
What: /sys/.../iio:deviceX/scan_elements/in_proximity_en
|
||||
KernelVersion: 2.6.37
|
||||
Contact: linux-iio@vger.kernel.org
|
||||
Description:
|
||||
@ -1013,6 +1035,7 @@ What: /sys/.../iio:deviceX/scan_elements/in_timestamp_type
|
||||
What: /sys/.../iio:deviceX/scan_elements/in_pressureY_type
|
||||
What: /sys/.../iio:deviceX/scan_elements/in_pressure_type
|
||||
What: /sys/.../iio:deviceX/scan_elements/in_rot_quaternion_type
|
||||
What: /sys/.../iio:deviceX/scan_elements/in_proximity_type
|
||||
KernelVersion: 2.6.37
|
||||
Contact: linux-iio@vger.kernel.org
|
||||
Description:
|
||||
@ -1064,6 +1087,7 @@ What: /sys/.../iio:deviceX/scan_elements/in_timestamp_index
|
||||
What: /sys/.../iio:deviceX/scan_elements/in_pressureY_index
|
||||
What: /sys/.../iio:deviceX/scan_elements/in_pressure_index
|
||||
What: /sys/.../iio:deviceX/scan_elements/in_rot_quaternion_index
|
||||
What: /sys/.../iio:deviceX/scan_elements/in_proximity_index
|
||||
KernelVersion: 2.6.37
|
||||
Contact: linux-iio@vger.kernel.org
|
||||
Description:
|
||||
|
||||
30
Documentation/devicetree/bindings/iio/adc/mcp320x.txt
Normal file
30
Documentation/devicetree/bindings/iio/adc/mcp320x.txt
Normal file
@ -0,0 +1,30 @@
|
||||
* Microchip Analog to Digital Converter (ADC)
|
||||
|
||||
The node for this driver must be a child node of a SPI controller, hence
|
||||
all mandatory properties described in
|
||||
|
||||
Documentation/devicetree/bindings/spi/spi-bus.txt
|
||||
|
||||
must be specified.
|
||||
|
||||
Required properties:
|
||||
- compatible: Must be one of the following, depending on the
|
||||
model:
|
||||
"mcp3001"
|
||||
"mcp3002"
|
||||
"mcp3004"
|
||||
"mcp3008"
|
||||
"mcp3201"
|
||||
"mcp3202"
|
||||
"mcp3204"
|
||||
"mcp3208"
|
||||
|
||||
|
||||
Examples:
|
||||
spi_controller {
|
||||
mcp3x0x@0 {
|
||||
compatible = "mcp3002";
|
||||
reg = <0>;
|
||||
spi-max-frequency = <1000000>;
|
||||
};
|
||||
};
|
||||
17
Documentation/devicetree/bindings/iio/adc/mcp3422.txt
Normal file
17
Documentation/devicetree/bindings/iio/adc/mcp3422.txt
Normal file
@ -0,0 +1,17 @@
|
||||
* Microchip mcp3422/3/4/6/7/8 chip family (ADC)
|
||||
|
||||
Required properties:
|
||||
- compatible: Should be
|
||||
"microchip,mcp3422" or
|
||||
"microchip,mcp3423" or
|
||||
"microchip,mcp3424" or
|
||||
"microchip,mcp3426" or
|
||||
"microchip,mcp3427" or
|
||||
"microchip,mcp3428"
|
||||
- reg: I2C address for the device
|
||||
|
||||
Example:
|
||||
adc@0 {
|
||||
compatible = "microchip,mcp3424";
|
||||
reg = <0x68>;
|
||||
};
|
||||
18
Documentation/devicetree/bindings/iio/adc/ti-adc128s052.txt
Normal file
18
Documentation/devicetree/bindings/iio/adc/ti-adc128s052.txt
Normal file
@ -0,0 +1,18 @@
|
||||
* Texas Instruments' ADC128S052 ADC chip
|
||||
|
||||
Required properties:
|
||||
- compatible: Should be "ti,adc128s052"
|
||||
- reg: spi chip select number for the device
|
||||
- vref-supply: The regulator supply for ADC reference voltage
|
||||
|
||||
Recommended properties:
|
||||
- spi-max-frequency: Definition as per
|
||||
Documentation/devicetree/bindings/spi/spi-bus.txt
|
||||
|
||||
Example:
|
||||
adc@0 {
|
||||
compatible = "ti,adc128s052";
|
||||
reg = <0>;
|
||||
vref-supply = <&vdd_supply>;
|
||||
spi-max-frequency = <1000000>;
|
||||
};
|
||||
@ -4947,6 +4947,7 @@ S: Maintained
|
||||
F: drivers/iio/
|
||||
F: drivers/staging/iio/
|
||||
F: include/linux/iio/
|
||||
F: tools/iio/
|
||||
|
||||
IKANOS/ADI EAGLE ADSL USB DRIVER
|
||||
M: Matthieu Castet <castet.matthieu@free.fr>
|
||||
|
||||
@ -147,10 +147,37 @@ struct bmc150_accel_chip_info {
|
||||
const struct bmc150_scale_info scale_table[4];
|
||||
};
|
||||
|
||||
struct bmc150_accel_interrupt {
|
||||
const struct bmc150_accel_interrupt_info *info;
|
||||
atomic_t users;
|
||||
};
|
||||
|
||||
struct bmc150_accel_trigger {
|
||||
struct bmc150_accel_data *data;
|
||||
struct iio_trigger *indio_trig;
|
||||
int (*setup)(struct bmc150_accel_trigger *t, bool state);
|
||||
int intr;
|
||||
bool enabled;
|
||||
};
|
||||
|
||||
enum bmc150_accel_interrupt_id {
|
||||
BMC150_ACCEL_INT_DATA_READY,
|
||||
BMC150_ACCEL_INT_ANY_MOTION,
|
||||
BMC150_ACCEL_INT_WATERMARK,
|
||||
BMC150_ACCEL_INTERRUPTS,
|
||||
};
|
||||
|
||||
enum bmc150_accel_trigger_id {
|
||||
BMC150_ACCEL_TRIGGER_DATA_READY,
|
||||
BMC150_ACCEL_TRIGGER_ANY_MOTION,
|
||||
BMC150_ACCEL_TRIGGERS,
|
||||
};
|
||||
|
||||
struct bmc150_accel_data {
|
||||
struct i2c_client *client;
|
||||
struct iio_trigger *dready_trig;
|
||||
struct iio_trigger *motion_trig;
|
||||
struct bmc150_accel_interrupt interrupts[BMC150_ACCEL_INTERRUPTS];
|
||||
atomic_t active_intr;
|
||||
struct bmc150_accel_trigger triggers[BMC150_ACCEL_TRIGGERS];
|
||||
struct mutex mutex;
|
||||
s16 buffer[8];
|
||||
u8 bw_bits;
|
||||
@ -158,8 +185,6 @@ struct bmc150_accel_data {
|
||||
u32 slope_thres;
|
||||
u32 range;
|
||||
int ev_enable_state;
|
||||
bool dready_trigger_on;
|
||||
bool motion_trigger_on;
|
||||
int64_t timestamp;
|
||||
const struct bmc150_accel_chip_info *chip_info;
|
||||
};
|
||||
@ -269,6 +294,46 @@ static int bmc150_accel_set_bw(struct bmc150_accel_data *data, int val,
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
static int bmc150_accel_update_slope(struct bmc150_accel_data *data)
|
||||
{
|
||||
int ret, val;
|
||||
|
||||
ret = i2c_smbus_write_byte_data(data->client, BMC150_ACCEL_REG_INT_6,
|
||||
data->slope_thres);
|
||||
if (ret < 0) {
|
||||
dev_err(&data->client->dev, "Error writing reg_int_6\n");
|
||||
return ret;
|
||||
}
|
||||
|
||||
ret = i2c_smbus_read_byte_data(data->client, BMC150_ACCEL_REG_INT_5);
|
||||
if (ret < 0) {
|
||||
dev_err(&data->client->dev, "Error reading reg_int_5\n");
|
||||
return ret;
|
||||
}
|
||||
|
||||
val = (ret & ~BMC150_ACCEL_SLOPE_DUR_MASK) | data->slope_dur;
|
||||
ret = i2c_smbus_write_byte_data(data->client, BMC150_ACCEL_REG_INT_5,
|
||||
val);
|
||||
if (ret < 0) {
|
||||
dev_err(&data->client->dev, "Error write reg_int_5\n");
|
||||
return ret;
|
||||
}
|
||||
|
||||
dev_dbg(&data->client->dev, "%s: %x %x\n", __func__, data->slope_thres,
|
||||
data->slope_dur);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int bmc150_accel_any_motion_setup(struct bmc150_accel_trigger *t,
|
||||
bool state)
|
||||
{
|
||||
if (state)
|
||||
return bmc150_accel_update_slope(t->data);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int bmc150_accel_chip_init(struct bmc150_accel_data *data)
|
||||
{
|
||||
int ret;
|
||||
@ -307,32 +372,12 @@ static int bmc150_accel_chip_init(struct bmc150_accel_data *data)
|
||||
|
||||
data->range = BMC150_ACCEL_DEF_RANGE_4G;
|
||||
|
||||
/* Set default slope duration */
|
||||
ret = i2c_smbus_read_byte_data(data->client, BMC150_ACCEL_REG_INT_5);
|
||||
if (ret < 0) {
|
||||
dev_err(&data->client->dev, "Error reading reg_int_5\n");
|
||||
return ret;
|
||||
}
|
||||
data->slope_dur |= BMC150_ACCEL_DEF_SLOPE_DURATION;
|
||||
ret = i2c_smbus_write_byte_data(data->client,
|
||||
BMC150_ACCEL_REG_INT_5,
|
||||
data->slope_dur);
|
||||
if (ret < 0) {
|
||||
dev_err(&data->client->dev, "Error writing reg_int_5\n");
|
||||
return ret;
|
||||
}
|
||||
dev_dbg(&data->client->dev, "slope_dur %x\n", data->slope_dur);
|
||||
|
||||
/* Set default slope thresholds */
|
||||
ret = i2c_smbus_write_byte_data(data->client,
|
||||
BMC150_ACCEL_REG_INT_6,
|
||||
BMC150_ACCEL_DEF_SLOPE_THRESHOLD);
|
||||
if (ret < 0) {
|
||||
dev_err(&data->client->dev, "Error writing reg_int_6\n");
|
||||
return ret;
|
||||
}
|
||||
/* Set default slope duration and thresholds */
|
||||
data->slope_thres = BMC150_ACCEL_DEF_SLOPE_THRESHOLD;
|
||||
dev_dbg(&data->client->dev, "slope_thres %x\n", data->slope_thres);
|
||||
data->slope_dur = BMC150_ACCEL_DEF_SLOPE_DURATION;
|
||||
ret = bmc150_accel_update_slope(data);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
|
||||
/* Set default as latched interrupts */
|
||||
ret = i2c_smbus_write_byte_data(data->client,
|
||||
@ -348,155 +393,6 @@ static int bmc150_accel_chip_init(struct bmc150_accel_data *data)
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int bmc150_accel_setup_any_motion_interrupt(
|
||||
struct bmc150_accel_data *data,
|
||||
bool status)
|
||||
{
|
||||
int ret;
|
||||
|
||||
/* Enable/Disable INT1 mapping */
|
||||
ret = i2c_smbus_read_byte_data(data->client,
|
||||
BMC150_ACCEL_REG_INT_MAP_0);
|
||||
if (ret < 0) {
|
||||
dev_err(&data->client->dev, "Error reading reg_int_map_0\n");
|
||||
return ret;
|
||||
}
|
||||
if (status)
|
||||
ret |= BMC150_ACCEL_INT_MAP_0_BIT_SLOPE;
|
||||
else
|
||||
ret &= ~BMC150_ACCEL_INT_MAP_0_BIT_SLOPE;
|
||||
|
||||
ret = i2c_smbus_write_byte_data(data->client,
|
||||
BMC150_ACCEL_REG_INT_MAP_0,
|
||||
ret);
|
||||
if (ret < 0) {
|
||||
dev_err(&data->client->dev, "Error writing reg_int_map_0\n");
|
||||
return ret;
|
||||
}
|
||||
|
||||
if (status) {
|
||||
/* Set slope duration (no of samples) */
|
||||
ret = i2c_smbus_write_byte_data(data->client,
|
||||
BMC150_ACCEL_REG_INT_5,
|
||||
data->slope_dur);
|
||||
if (ret < 0) {
|
||||
dev_err(&data->client->dev, "Error write reg_int_5\n");
|
||||
return ret;
|
||||
}
|
||||
|
||||
/* Set slope thresholds */
|
||||
ret = i2c_smbus_write_byte_data(data->client,
|
||||
BMC150_ACCEL_REG_INT_6,
|
||||
data->slope_thres);
|
||||
if (ret < 0) {
|
||||
dev_err(&data->client->dev, "Error write reg_int_6\n");
|
||||
return ret;
|
||||
}
|
||||
|
||||
/*
|
||||
* New data interrupt is always non-latched,
|
||||
* which will have higher priority, so no need
|
||||
* to set latched mode, we will be flooded anyway with INTR
|
||||
*/
|
||||
if (!data->dready_trigger_on) {
|
||||
ret = i2c_smbus_write_byte_data(data->client,
|
||||
BMC150_ACCEL_REG_INT_RST_LATCH,
|
||||
BMC150_ACCEL_INT_MODE_LATCH_INT |
|
||||
BMC150_ACCEL_INT_MODE_LATCH_RESET);
|
||||
if (ret < 0) {
|
||||
dev_err(&data->client->dev,
|
||||
"Error writing reg_int_rst_latch\n");
|
||||
return ret;
|
||||
}
|
||||
}
|
||||
|
||||
ret = i2c_smbus_write_byte_data(data->client,
|
||||
BMC150_ACCEL_REG_INT_EN_0,
|
||||
BMC150_ACCEL_INT_EN_BIT_SLP_X |
|
||||
BMC150_ACCEL_INT_EN_BIT_SLP_Y |
|
||||
BMC150_ACCEL_INT_EN_BIT_SLP_Z);
|
||||
} else
|
||||
ret = i2c_smbus_write_byte_data(data->client,
|
||||
BMC150_ACCEL_REG_INT_EN_0,
|
||||
0);
|
||||
|
||||
if (ret < 0) {
|
||||
dev_err(&data->client->dev, "Error writing reg_int_en_0\n");
|
||||
return ret;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int bmc150_accel_setup_new_data_interrupt(struct bmc150_accel_data *data,
|
||||
bool status)
|
||||
{
|
||||
int ret;
|
||||
|
||||
/* Enable/Disable INT1 mapping */
|
||||
ret = i2c_smbus_read_byte_data(data->client,
|
||||
BMC150_ACCEL_REG_INT_MAP_1);
|
||||
if (ret < 0) {
|
||||
dev_err(&data->client->dev, "Error reading reg_int_map_1\n");
|
||||
return ret;
|
||||
}
|
||||
if (status)
|
||||
ret |= BMC150_ACCEL_INT_MAP_1_BIT_DATA;
|
||||
else
|
||||
ret &= ~BMC150_ACCEL_INT_MAP_1_BIT_DATA;
|
||||
|
||||
ret = i2c_smbus_write_byte_data(data->client,
|
||||
BMC150_ACCEL_REG_INT_MAP_1,
|
||||
ret);
|
||||
if (ret < 0) {
|
||||
dev_err(&data->client->dev, "Error writing reg_int_map_1\n");
|
||||
return ret;
|
||||
}
|
||||
|
||||
if (status) {
|
||||
/*
|
||||
* Set non latched mode interrupt and clear any latched
|
||||
* interrupt
|
||||
*/
|
||||
ret = i2c_smbus_write_byte_data(data->client,
|
||||
BMC150_ACCEL_REG_INT_RST_LATCH,
|
||||
BMC150_ACCEL_INT_MODE_NON_LATCH_INT |
|
||||
BMC150_ACCEL_INT_MODE_LATCH_RESET);
|
||||
if (ret < 0) {
|
||||
dev_err(&data->client->dev,
|
||||
"Error writing reg_int_rst_latch\n");
|
||||
return ret;
|
||||
}
|
||||
|
||||
ret = i2c_smbus_write_byte_data(data->client,
|
||||
BMC150_ACCEL_REG_INT_EN_1,
|
||||
BMC150_ACCEL_INT_EN_BIT_DATA_EN);
|
||||
|
||||
} else {
|
||||
/* Restore default interrupt mode */
|
||||
ret = i2c_smbus_write_byte_data(data->client,
|
||||
BMC150_ACCEL_REG_INT_RST_LATCH,
|
||||
BMC150_ACCEL_INT_MODE_LATCH_INT |
|
||||
BMC150_ACCEL_INT_MODE_LATCH_RESET);
|
||||
if (ret < 0) {
|
||||
dev_err(&data->client->dev,
|
||||
"Error writing reg_int_rst_latch\n");
|
||||
return ret;
|
||||
}
|
||||
|
||||
ret = i2c_smbus_write_byte_data(data->client,
|
||||
BMC150_ACCEL_REG_INT_EN_1,
|
||||
0);
|
||||
}
|
||||
|
||||
if (ret < 0) {
|
||||
dev_err(&data->client->dev, "Error writing reg_int_en_1\n");
|
||||
return ret;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int bmc150_accel_get_bw(struct bmc150_accel_data *data, int *val,
|
||||
int *val2)
|
||||
{
|
||||
@ -554,6 +450,114 @@ static int bmc150_accel_set_power_state(struct bmc150_accel_data *data, bool on)
|
||||
}
|
||||
#endif
|
||||
|
||||
static const struct bmc150_accel_interrupt_info {
|
||||
u8 map_reg;
|
||||
u8 map_bitmask;
|
||||
u8 en_reg;
|
||||
u8 en_bitmask;
|
||||
} bmc150_accel_interrupts[BMC150_ACCEL_INTERRUPTS] = {
|
||||
{ /* data ready interrupt */
|
||||
.map_reg = BMC150_ACCEL_REG_INT_MAP_1,
|
||||
.map_bitmask = BMC150_ACCEL_INT_MAP_1_BIT_DATA,
|
||||
.en_reg = BMC150_ACCEL_REG_INT_EN_1,
|
||||
.en_bitmask = BMC150_ACCEL_INT_EN_BIT_DATA_EN,
|
||||
},
|
||||
{ /* motion interrupt */
|
||||
.map_reg = BMC150_ACCEL_REG_INT_MAP_0,
|
||||
.map_bitmask = BMC150_ACCEL_INT_MAP_0_BIT_SLOPE,
|
||||
.en_reg = BMC150_ACCEL_REG_INT_EN_0,
|
||||
.en_bitmask = BMC150_ACCEL_INT_EN_BIT_SLP_X |
|
||||
BMC150_ACCEL_INT_EN_BIT_SLP_Y |
|
||||
BMC150_ACCEL_INT_EN_BIT_SLP_Z
|
||||
},
|
||||
};
|
||||
|
||||
static void bmc150_accel_interrupts_setup(struct iio_dev *indio_dev,
|
||||
struct bmc150_accel_data *data)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < BMC150_ACCEL_INTERRUPTS; i++)
|
||||
data->interrupts[i].info = &bmc150_accel_interrupts[i];
|
||||
}
|
||||
|
||||
static int bmc150_accel_set_interrupt(struct bmc150_accel_data *data, int i,
|
||||
bool state)
|
||||
{
|
||||
struct bmc150_accel_interrupt *intr = &data->interrupts[i];
|
||||
const struct bmc150_accel_interrupt_info *info = intr->info;
|
||||
int ret;
|
||||
|
||||
if (state) {
|
||||
if (atomic_inc_return(&intr->users) > 1)
|
||||
return 0;
|
||||
} else {
|
||||
if (atomic_dec_return(&intr->users) > 0)
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* We will expect the enable and disable to do operation in
|
||||
* in reverse order. This will happen here anyway as our
|
||||
* resume operation uses sync mode runtime pm calls, the
|
||||
* suspend operation will be delayed by autosuspend delay
|
||||
* So the disable operation will still happen in reverse of
|
||||
* enable operation. When runtime pm is disabled the mode
|
||||
* is always on so sequence doesn't matter
|
||||
*/
|
||||
ret = bmc150_accel_set_power_state(data, state);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
|
||||
/* map the interrupt to the appropriate pins */
|
||||
ret = i2c_smbus_read_byte_data(data->client, info->map_reg);
|
||||
if (ret < 0) {
|
||||
dev_err(&data->client->dev, "Error reading reg_int_map\n");
|
||||
goto out_fix_power_state;
|
||||
}
|
||||
if (state)
|
||||
ret |= info->map_bitmask;
|
||||
else
|
||||
ret &= ~info->map_bitmask;
|
||||
|
||||
ret = i2c_smbus_write_byte_data(data->client, info->map_reg,
|
||||
ret);
|
||||
if (ret < 0) {
|
||||
dev_err(&data->client->dev, "Error writing reg_int_map\n");
|
||||
goto out_fix_power_state;
|
||||
}
|
||||
|
||||
/* enable/disable the interrupt */
|
||||
ret = i2c_smbus_read_byte_data(data->client, info->en_reg);
|
||||
if (ret < 0) {
|
||||
dev_err(&data->client->dev, "Error reading reg_int_en\n");
|
||||
goto out_fix_power_state;
|
||||
}
|
||||
|
||||
if (state)
|
||||
ret |= info->en_bitmask;
|
||||
else
|
||||
ret &= ~info->en_bitmask;
|
||||
|
||||
ret = i2c_smbus_write_byte_data(data->client, info->en_reg, ret);
|
||||
if (ret < 0) {
|
||||
dev_err(&data->client->dev, "Error writing reg_int_en\n");
|
||||
goto out_fix_power_state;
|
||||
}
|
||||
|
||||
if (state)
|
||||
atomic_inc(&data->active_intr);
|
||||
else
|
||||
atomic_dec(&data->active_intr);
|
||||
|
||||
return 0;
|
||||
|
||||
out_fix_power_state:
|
||||
bmc150_accel_set_power_state(data, false);
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
||||
static int bmc150_accel_set_scale(struct bmc150_accel_data *data, int val)
|
||||
{
|
||||
int ret, i;
|
||||
@ -732,7 +736,7 @@ static int bmc150_accel_read_event(struct iio_dev *indio_dev,
|
||||
*val = data->slope_thres;
|
||||
break;
|
||||
case IIO_EV_INFO_PERIOD:
|
||||
*val = data->slope_dur & BMC150_ACCEL_SLOPE_DUR_MASK;
|
||||
*val = data->slope_dur;
|
||||
break;
|
||||
default:
|
||||
return -EINVAL;
|
||||
@ -755,11 +759,10 @@ static int bmc150_accel_write_event(struct iio_dev *indio_dev,
|
||||
|
||||
switch (info) {
|
||||
case IIO_EV_INFO_VALUE:
|
||||
data->slope_thres = val;
|
||||
data->slope_thres = val & 0xFF;
|
||||
break;
|
||||
case IIO_EV_INFO_PERIOD:
|
||||
data->slope_dur &= ~BMC150_ACCEL_SLOPE_DUR_MASK;
|
||||
data->slope_dur |= val & BMC150_ACCEL_SLOPE_DUR_MASK;
|
||||
data->slope_dur = val & BMC150_ACCEL_SLOPE_DUR_MASK;
|
||||
break;
|
||||
default:
|
||||
return -EINVAL;
|
||||
@ -788,40 +791,18 @@ static int bmc150_accel_write_event_config(struct iio_dev *indio_dev,
|
||||
struct bmc150_accel_data *data = iio_priv(indio_dev);
|
||||
int ret;
|
||||
|
||||
if (state && data->ev_enable_state)
|
||||
if (state == data->ev_enable_state)
|
||||
return 0;
|
||||
|
||||
mutex_lock(&data->mutex);
|
||||
|
||||
if (!state && data->motion_trigger_on) {
|
||||
data->ev_enable_state = 0;
|
||||
mutex_unlock(&data->mutex);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* We will expect the enable and disable to do operation in
|
||||
* in reverse order. This will happen here anyway as our
|
||||
* resume operation uses sync mode runtime pm calls, the
|
||||
* suspend operation will be delayed by autosuspend delay
|
||||
* So the disable operation will still happen in reverse of
|
||||
* enable operation. When runtime pm is disabled the mode
|
||||
* is always on so sequence doesn't matter
|
||||
*/
|
||||
|
||||
ret = bmc150_accel_set_power_state(data, state);
|
||||
ret = bmc150_accel_set_interrupt(data, BMC150_ACCEL_INT_ANY_MOTION,
|
||||
state);
|
||||
if (ret < 0) {
|
||||
mutex_unlock(&data->mutex);
|
||||
return ret;
|
||||
}
|
||||
|
||||
ret = bmc150_accel_setup_any_motion_interrupt(data, state);
|
||||
if (ret < 0) {
|
||||
bmc150_accel_set_power_state(data, false);
|
||||
mutex_unlock(&data->mutex);
|
||||
return ret;
|
||||
}
|
||||
|
||||
data->ev_enable_state = state;
|
||||
mutex_unlock(&data->mutex);
|
||||
|
||||
@ -832,11 +813,14 @@ static int bmc150_accel_validate_trigger(struct iio_dev *indio_dev,
|
||||
struct iio_trigger *trig)
|
||||
{
|
||||
struct bmc150_accel_data *data = iio_priv(indio_dev);
|
||||
int i;
|
||||
|
||||
if (data->dready_trig != trig && data->motion_trig != trig)
|
||||
return -EINVAL;
|
||||
for (i = 0; i < BMC150_ACCEL_TRIGGERS; i++) {
|
||||
if (data->triggers[i].indio_trig == trig)
|
||||
return 0;
|
||||
}
|
||||
|
||||
return 0;
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
static IIO_CONST_ATTR_SAMP_FREQ_AVAIL(
|
||||
@ -1008,12 +992,12 @@ err_read:
|
||||
|
||||
static int bmc150_accel_trig_try_reen(struct iio_trigger *trig)
|
||||
{
|
||||
struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig);
|
||||
struct bmc150_accel_data *data = iio_priv(indio_dev);
|
||||
struct bmc150_accel_trigger *t = iio_trigger_get_drvdata(trig);
|
||||
struct bmc150_accel_data *data = t->data;
|
||||
int ret;
|
||||
|
||||
/* new data interrupts don't need ack */
|
||||
if (data->dready_trigger_on)
|
||||
if (t == &t->data->triggers[BMC150_ACCEL_TRIGGER_DATA_READY])
|
||||
return 0;
|
||||
|
||||
mutex_lock(&data->mutex);
|
||||
@ -1032,43 +1016,35 @@ static int bmc150_accel_trig_try_reen(struct iio_trigger *trig)
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int bmc150_accel_data_rdy_trigger_set_state(struct iio_trigger *trig,
|
||||
static int bmc150_accel_trigger_set_state(struct iio_trigger *trig,
|
||||
bool state)
|
||||
{
|
||||
struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig);
|
||||
struct bmc150_accel_data *data = iio_priv(indio_dev);
|
||||
struct bmc150_accel_trigger *t = iio_trigger_get_drvdata(trig);
|
||||
struct bmc150_accel_data *data = t->data;
|
||||
int ret;
|
||||
|
||||
mutex_lock(&data->mutex);
|
||||
|
||||
if (!state && data->ev_enable_state && data->motion_trigger_on) {
|
||||
data->motion_trigger_on = false;
|
||||
if (t->enabled == state) {
|
||||
mutex_unlock(&data->mutex);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* Refer to comment in bmc150_accel_write_event_config for
|
||||
* enable/disable operation order
|
||||
*/
|
||||
ret = bmc150_accel_set_power_state(data, state);
|
||||
if (t->setup) {
|
||||
ret = t->setup(t, state);
|
||||
if (ret < 0) {
|
||||
mutex_unlock(&data->mutex);
|
||||
return ret;
|
||||
}
|
||||
}
|
||||
|
||||
ret = bmc150_accel_set_interrupt(data, t->intr, state);
|
||||
if (ret < 0) {
|
||||
mutex_unlock(&data->mutex);
|
||||
return ret;
|
||||
}
|
||||
if (data->motion_trig == trig)
|
||||
ret = bmc150_accel_setup_any_motion_interrupt(data, state);
|
||||
else
|
||||
ret = bmc150_accel_setup_new_data_interrupt(data, state);
|
||||
if (ret < 0) {
|
||||
bmc150_accel_set_power_state(data, false);
|
||||
mutex_unlock(&data->mutex);
|
||||
return ret;
|
||||
}
|
||||
if (data->motion_trig == trig)
|
||||
data->motion_trigger_on = state;
|
||||
else
|
||||
data->dready_trigger_on = state;
|
||||
|
||||
t->enabled = state;
|
||||
|
||||
mutex_unlock(&data->mutex);
|
||||
|
||||
@ -1076,7 +1052,7 @@ static int bmc150_accel_data_rdy_trigger_set_state(struct iio_trigger *trig,
|
||||
}
|
||||
|
||||
static const struct iio_trigger_ops bmc150_accel_trigger_ops = {
|
||||
.set_trigger_state = bmc150_accel_data_rdy_trigger_set_state,
|
||||
.set_trigger_state = bmc150_accel_trigger_set_state,
|
||||
.try_reenable = bmc150_accel_trig_try_reen,
|
||||
.owner = THIS_MODULE,
|
||||
};
|
||||
@ -1122,7 +1098,7 @@ static irqreturn_t bmc150_accel_event_handler(int irq, void *private)
|
||||
dir),
|
||||
data->timestamp);
|
||||
ack_intr_status:
|
||||
if (!data->dready_trigger_on)
|
||||
if (!data->triggers[BMC150_ACCEL_TRIGGER_DATA_READY].enabled)
|
||||
ret = i2c_smbus_write_byte_data(data->client,
|
||||
BMC150_ACCEL_REG_INT_RST_LATCH,
|
||||
BMC150_ACCEL_INT_MODE_LATCH_INT |
|
||||
@ -1135,13 +1111,16 @@ static irqreturn_t bmc150_accel_data_rdy_trig_poll(int irq, void *private)
|
||||
{
|
||||
struct iio_dev *indio_dev = private;
|
||||
struct bmc150_accel_data *data = iio_priv(indio_dev);
|
||||
int i;
|
||||
|
||||
data->timestamp = iio_get_time_ns();
|
||||
|
||||
if (data->dready_trigger_on)
|
||||
iio_trigger_poll(data->dready_trig);
|
||||
else if (data->motion_trigger_on)
|
||||
iio_trigger_poll(data->motion_trig);
|
||||
for (i = 0; i < BMC150_ACCEL_TRIGGERS; i++) {
|
||||
if (data->triggers[i].enabled) {
|
||||
iio_trigger_poll(data->triggers[i].indio_trig);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (data->ev_enable_state)
|
||||
return IRQ_WAKE_THREAD;
|
||||
@ -1176,16 +1155,12 @@ static int bmc150_accel_gpio_probe(struct i2c_client *client,
|
||||
dev = &client->dev;
|
||||
|
||||
/* data ready gpio interrupt pin */
|
||||
gpio = devm_gpiod_get_index(dev, BMC150_ACCEL_GPIO_NAME, 0);
|
||||
gpio = devm_gpiod_get_index(dev, BMC150_ACCEL_GPIO_NAME, 0, GPIOD_IN);
|
||||
if (IS_ERR(gpio)) {
|
||||
dev_err(dev, "Failed: gpio get index\n");
|
||||
return PTR_ERR(gpio);
|
||||
}
|
||||
|
||||
ret = gpiod_direction_input(gpio);
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
ret = gpiod_to_irq(gpio);
|
||||
|
||||
dev_dbg(dev, "GPIO resource, no:%d irq:%d\n", desc_to_gpio(gpio), ret);
|
||||
@ -1193,6 +1168,70 @@ static int bmc150_accel_gpio_probe(struct i2c_client *client,
|
||||
return ret;
|
||||
}
|
||||
|
||||
static const struct {
|
||||
int intr;
|
||||
const char *name;
|
||||
int (*setup)(struct bmc150_accel_trigger *t, bool state);
|
||||
} bmc150_accel_triggers[BMC150_ACCEL_TRIGGERS] = {
|
||||
{
|
||||
.intr = 0,
|
||||
.name = "%s-dev%d",
|
||||
},
|
||||
{
|
||||
.intr = 1,
|
||||
.name = "%s-any-motion-dev%d",
|
||||
.setup = bmc150_accel_any_motion_setup,
|
||||
},
|
||||
};
|
||||
|
||||
static void bmc150_accel_unregister_triggers(struct bmc150_accel_data *data,
|
||||
int from)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = from; i >= 0; i++) {
|
||||
if (data->triggers[i].indio_trig) {
|
||||
iio_trigger_unregister(data->triggers[i].indio_trig);
|
||||
data->triggers[i].indio_trig = NULL;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static int bmc150_accel_triggers_setup(struct iio_dev *indio_dev,
|
||||
struct bmc150_accel_data *data)
|
||||
{
|
||||
int i, ret;
|
||||
|
||||
for (i = 0; i < BMC150_ACCEL_TRIGGERS; i++) {
|
||||
struct bmc150_accel_trigger *t = &data->triggers[i];
|
||||
|
||||
t->indio_trig = devm_iio_trigger_alloc(&data->client->dev,
|
||||
bmc150_accel_triggers[i].name,
|
||||
indio_dev->name,
|
||||
indio_dev->id);
|
||||
if (!t->indio_trig) {
|
||||
ret = -ENOMEM;
|
||||
break;
|
||||
}
|
||||
|
||||
t->indio_trig->dev.parent = &data->client->dev;
|
||||
t->indio_trig->ops = &bmc150_accel_trigger_ops;
|
||||
t->intr = bmc150_accel_triggers[i].intr;
|
||||
t->data = data;
|
||||
t->setup = bmc150_accel_triggers[i].setup;
|
||||
iio_trigger_set_drvdata(t->indio_trig, t);
|
||||
|
||||
ret = iio_trigger_register(t->indio_trig);
|
||||
if (ret)
|
||||
break;
|
||||
}
|
||||
|
||||
if (ret)
|
||||
bmc150_accel_unregister_triggers(data, i - 1);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int bmc150_accel_probe(struct i2c_client *client,
|
||||
const struct i2c_device_id *id)
|
||||
{
|
||||
@ -1247,36 +1286,26 @@ static int bmc150_accel_probe(struct i2c_client *client,
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
data->dready_trig = devm_iio_trigger_alloc(&client->dev,
|
||||
"%s-dev%d",
|
||||
indio_dev->name,
|
||||
indio_dev->id);
|
||||
if (!data->dready_trig)
|
||||
return -ENOMEM;
|
||||
/*
|
||||
* Set latched mode interrupt. While certain interrupts are
|
||||
* non-latched regardless of this settings (e.g. new data) we
|
||||
* want to use latch mode when we can to prevent interrupt
|
||||
* flooding.
|
||||
*/
|
||||
ret = i2c_smbus_write_byte_data(data->client,
|
||||
BMC150_ACCEL_REG_INT_RST_LATCH,
|
||||
BMC150_ACCEL_INT_MODE_LATCH_RESET);
|
||||
if (ret < 0) {
|
||||
dev_err(&data->client->dev, "Error writing reg_int_rst_latch\n");
|
||||
return ret;
|
||||
}
|
||||
|
||||
data->motion_trig = devm_iio_trigger_alloc(&client->dev,
|
||||
"%s-any-motion-dev%d",
|
||||
indio_dev->name,
|
||||
indio_dev->id);
|
||||
if (!data->motion_trig)
|
||||
return -ENOMEM;
|
||||
bmc150_accel_interrupts_setup(indio_dev, data);
|
||||
|
||||
data->dready_trig->dev.parent = &client->dev;
|
||||
data->dready_trig->ops = &bmc150_accel_trigger_ops;
|
||||
iio_trigger_set_drvdata(data->dready_trig, indio_dev);
|
||||
ret = iio_trigger_register(data->dready_trig);
|
||||
ret = bmc150_accel_triggers_setup(indio_dev, data);
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
data->motion_trig->dev.parent = &client->dev;
|
||||
data->motion_trig->ops = &bmc150_accel_trigger_ops;
|
||||
iio_trigger_set_drvdata(data->motion_trig, indio_dev);
|
||||
ret = iio_trigger_register(data->motion_trig);
|
||||
if (ret) {
|
||||
data->motion_trig = NULL;
|
||||
goto err_trigger_unregister;
|
||||
}
|
||||
|
||||
ret = iio_triggered_buffer_setup(indio_dev,
|
||||
&iio_pollfunc_store_time,
|
||||
bmc150_accel_trigger_handler,
|
||||
@ -1308,13 +1337,10 @@ static int bmc150_accel_probe(struct i2c_client *client,
|
||||
err_iio_unregister:
|
||||
iio_device_unregister(indio_dev);
|
||||
err_buffer_cleanup:
|
||||
if (data->dready_trig)
|
||||
if (indio_dev->pollfunc)
|
||||
iio_triggered_buffer_cleanup(indio_dev);
|
||||
err_trigger_unregister:
|
||||
if (data->dready_trig)
|
||||
iio_trigger_unregister(data->dready_trig);
|
||||
if (data->motion_trig)
|
||||
iio_trigger_unregister(data->motion_trig);
|
||||
bmc150_accel_unregister_triggers(data, BMC150_ACCEL_TRIGGERS - 1);
|
||||
|
||||
return ret;
|
||||
}
|
||||
@ -1330,11 +1356,7 @@ static int bmc150_accel_remove(struct i2c_client *client)
|
||||
|
||||
iio_device_unregister(indio_dev);
|
||||
|
||||
if (data->dready_trig) {
|
||||
iio_triggered_buffer_cleanup(indio_dev);
|
||||
iio_trigger_unregister(data->dready_trig);
|
||||
iio_trigger_unregister(data->motion_trig);
|
||||
}
|
||||
bmc150_accel_unregister_triggers(data, BMC150_ACCEL_TRIGGERS - 1);
|
||||
|
||||
mutex_lock(&data->mutex);
|
||||
bmc150_accel_set_mode(data, BMC150_ACCEL_SLEEP_MODE_DEEP_SUSPEND, 0);
|
||||
@ -1362,8 +1384,7 @@ static int bmc150_accel_resume(struct device *dev)
|
||||
struct bmc150_accel_data *data = iio_priv(indio_dev);
|
||||
|
||||
mutex_lock(&data->mutex);
|
||||
if (data->dready_trigger_on || data->motion_trigger_on ||
|
||||
data->ev_enable_state)
|
||||
if (atomic_read(&data->active_intr))
|
||||
bmc150_accel_set_mode(data, BMC150_ACCEL_SLEEP_MODE_NORMAL, 0);
|
||||
mutex_unlock(&data->mutex);
|
||||
|
||||
|
||||
@ -1169,16 +1169,12 @@ static int kxcjk1013_gpio_probe(struct i2c_client *client,
|
||||
dev = &client->dev;
|
||||
|
||||
/* data ready gpio interrupt pin */
|
||||
gpio = devm_gpiod_get_index(dev, "kxcjk1013_int", 0);
|
||||
gpio = devm_gpiod_get_index(dev, "kxcjk1013_int", 0, GPIOD_IN);
|
||||
if (IS_ERR(gpio)) {
|
||||
dev_err(dev, "acpi gpio get index failed\n");
|
||||
return PTR_ERR(gpio);
|
||||
}
|
||||
|
||||
ret = gpiod_direction_input(gpio);
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
ret = gpiod_to_irq(gpio);
|
||||
|
||||
dev_dbg(dev, "GPIO resource, no:%d irq:%d\n", desc_to_gpio(gpio), ret);
|
||||
|
||||
@ -418,17 +418,18 @@ static int mma9551_gpio_probe(struct iio_dev *indio_dev)
|
||||
struct device *dev = &data->client->dev;
|
||||
|
||||
for (i = 0; i < MMA9551_GPIO_COUNT; i++) {
|
||||
gpio = devm_gpiod_get_index(dev, MMA9551_GPIO_NAME, i);
|
||||
gpio = devm_gpiod_get_index(dev, MMA9551_GPIO_NAME, i,
|
||||
GPIOD_IN);
|
||||
if (IS_ERR(gpio)) {
|
||||
dev_err(dev, "acpi gpio get index failed\n");
|
||||
return PTR_ERR(gpio);
|
||||
}
|
||||
|
||||
ret = gpiod_direction_input(gpio);
|
||||
if (ret)
|
||||
ret = gpiod_to_irq(gpio);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
|
||||
data->irqs[i] = gpiod_to_irq(gpio);
|
||||
data->irqs[i] = ret;
|
||||
ret = devm_request_threaded_irq(dev, data->irqs[i],
|
||||
NULL, mma9551_event_handler,
|
||||
IRQF_TRIGGER_RISING | IRQF_ONESHOT,
|
||||
|
||||
@ -1109,16 +1109,12 @@ static int mma9553_gpio_probe(struct i2c_client *client)
|
||||
dev = &client->dev;
|
||||
|
||||
/* data ready gpio interrupt pin */
|
||||
gpio = devm_gpiod_get_index(dev, MMA9553_GPIO_NAME, 0);
|
||||
gpio = devm_gpiod_get_index(dev, MMA9553_GPIO_NAME, 0, GPIOD_IN);
|
||||
if (IS_ERR(gpio)) {
|
||||
dev_err(dev, "acpi gpio get index failed\n");
|
||||
return PTR_ERR(gpio);
|
||||
}
|
||||
|
||||
ret = gpiod_direction_input(gpio);
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
ret = gpiod_to_irq(gpio);
|
||||
|
||||
dev_dbg(dev, "gpio resource, no:%d irq:%d\n", desc_to_gpio(gpio), ret);
|
||||
|
||||
@ -186,10 +186,11 @@ config MAX1363
|
||||
data via the iio dev interface.
|
||||
|
||||
config MCP320X
|
||||
tristate "Microchip Technology MCP3204/08"
|
||||
tristate "Microchip Technology MCP3x01/02/04/08"
|
||||
depends on SPI
|
||||
help
|
||||
Say yes here to build support for Microchip Technology's MCP3204 or
|
||||
Say yes here to build support for Microchip Technology's
|
||||
MCP3001, MCP3002, MCP3004, MCP3008, MCP3201, MCP3202, MCP3204 or
|
||||
MCP3208 analog to digital converter.
|
||||
|
||||
This driver can also be built as a module. If so, the module will be
|
||||
|
||||
@ -861,5 +861,5 @@ static struct spi_driver ad7793_driver = {
|
||||
module_spi_driver(ad7793_driver);
|
||||
|
||||
MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
|
||||
MODULE_DESCRIPTION("Analog Devices AD7793 and simialr ADCs");
|
||||
MODULE_DESCRIPTION("Analog Devices AD7793 and similar ADCs");
|
||||
MODULE_LICENSE("GPL v2");
|
||||
|
||||
@ -259,7 +259,6 @@ static void vf610_adc_cfg_post_set(struct vf610_adc *info)
|
||||
static void vf610_adc_calibration(struct vf610_adc *info)
|
||||
{
|
||||
int adc_gc, hc_cfg;
|
||||
int timeout;
|
||||
|
||||
if (!info->adc_feature.calibration)
|
||||
return;
|
||||
@ -271,9 +270,7 @@ static void vf610_adc_calibration(struct vf610_adc *info)
|
||||
adc_gc = readl(info->regs + VF610_REG_ADC_GC);
|
||||
writel(adc_gc | VF610_ADC_CAL, info->regs + VF610_REG_ADC_GC);
|
||||
|
||||
timeout = wait_for_completion_timeout
|
||||
(&info->completion, VF610_ADC_TIMEOUT);
|
||||
if (timeout == 0)
|
||||
if (!wait_for_completion_timeout(&info->completion, VF610_ADC_TIMEOUT))
|
||||
dev_err(info->dev, "Timeout for adc calibration\n");
|
||||
|
||||
adc_gc = readl(info->regs + VF610_REG_ADC_GS);
|
||||
|
||||
@ -1001,16 +1001,12 @@ static int bmg160_gpio_probe(struct i2c_client *client,
|
||||
dev = &client->dev;
|
||||
|
||||
/* data ready gpio interrupt pin */
|
||||
gpio = devm_gpiod_get_index(dev, BMG160_GPIO_NAME, 0);
|
||||
gpio = devm_gpiod_get_index(dev, BMG160_GPIO_NAME, 0, GPIOD_IN);
|
||||
if (IS_ERR(gpio)) {
|
||||
dev_err(dev, "acpi gpio get index failed\n");
|
||||
return PTR_ERR(gpio);
|
||||
}
|
||||
|
||||
ret = gpiod_direction_input(gpio);
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
ret = gpiod_to_irq(gpio);
|
||||
|
||||
dev_dbg(dev, "GPIO resource, no:%d irq:%d\n", desc_to_gpio(gpio), ret);
|
||||
|
||||
@ -223,6 +223,10 @@ static int itg3200_initial_setup(struct iio_dev *indio_dev)
|
||||
int ret;
|
||||
u8 val;
|
||||
|
||||
ret = itg3200_reset(indio_dev);
|
||||
if (ret)
|
||||
goto err_ret;
|
||||
|
||||
ret = itg3200_read_reg_8(indio_dev, ITG3200_REG_ADDRESS, &val);
|
||||
if (ret)
|
||||
goto err_ret;
|
||||
@ -233,10 +237,6 @@ static int itg3200_initial_setup(struct iio_dev *indio_dev)
|
||||
goto err_ret;
|
||||
}
|
||||
|
||||
ret = itg3200_reset(indio_dev);
|
||||
if (ret)
|
||||
goto err_ret;
|
||||
|
||||
ret = itg3200_enable_full_scale(indio_dev);
|
||||
err_ret:
|
||||
return ret;
|
||||
@ -351,6 +351,26 @@ static int itg3200_remove(struct i2c_client *client)
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int __maybe_unused itg3200_suspend(struct device *dev)
|
||||
{
|
||||
struct iio_dev *indio_dev = dev_get_drvdata(dev);
|
||||
struct itg3200 *st = iio_priv(indio_dev);
|
||||
|
||||
dev_dbg(&st->i2c->dev, "suspend device");
|
||||
|
||||
return itg3200_write_reg_8(indio_dev, ITG3200_REG_POWER_MANAGEMENT,
|
||||
ITG3200_SLEEP);
|
||||
}
|
||||
|
||||
static int __maybe_unused itg3200_resume(struct device *dev)
|
||||
{
|
||||
struct iio_dev *indio_dev = dev_get_drvdata(dev);
|
||||
|
||||
return itg3200_initial_setup(indio_dev);
|
||||
}
|
||||
|
||||
static SIMPLE_DEV_PM_OPS(itg3200_pm_ops, itg3200_suspend, itg3200_resume);
|
||||
|
||||
static const struct i2c_device_id itg3200_id[] = {
|
||||
{ "itg3200", 0 },
|
||||
{ }
|
||||
@ -361,6 +381,7 @@ static struct i2c_driver itg3200_driver = {
|
||||
.driver = {
|
||||
.owner = THIS_MODULE,
|
||||
.name = "itg3200",
|
||||
.pm = &itg3200_pm_ops,
|
||||
},
|
||||
.id_table = itg3200_id,
|
||||
.probe = itg3200_probe,
|
||||
|
||||
@ -3,4 +3,4 @@
|
||||
#
|
||||
|
||||
obj-$(CONFIG_INV_MPU6050_IIO) += inv-mpu6050.o
|
||||
inv-mpu6050-objs := inv_mpu_core.o inv_mpu_ring.o inv_mpu_trigger.o
|
||||
inv-mpu6050-objs := inv_mpu_core.o inv_mpu_ring.o inv_mpu_trigger.o inv_mpu_acpi.o
|
||||
|
||||
211
drivers/iio/imu/inv_mpu6050/inv_mpu_acpi.c
Normal file
211
drivers/iio/imu/inv_mpu6050/inv_mpu_acpi.c
Normal file
@ -0,0 +1,211 @@
|
||||
/*
|
||||
* inv_mpu_acpi: ACPI processing for creating client devices
|
||||
* Copyright (c) 2015, Intel Corporation.
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify it
|
||||
* under the terms and conditions of the GNU General Public License,
|
||||
* version 2, as published by the Free Software Foundation.
|
||||
*
|
||||
* This program is distributed in the hope it will be useful, but WITHOUT
|
||||
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
|
||||
* more details.
|
||||
*/
|
||||
|
||||
#ifdef CONFIG_ACPI
|
||||
|
||||
#include <linux/kernel.h>
|
||||
#include <linux/i2c.h>
|
||||
#include <linux/dmi.h>
|
||||
#include <linux/acpi.h>
|
||||
#include "inv_mpu_iio.h"
|
||||
|
||||
enum inv_mpu_product_name {
|
||||
INV_MPU_NOT_MATCHED,
|
||||
INV_MPU_ASUS_T100TA,
|
||||
};
|
||||
|
||||
static enum inv_mpu_product_name matched_product_name;
|
||||
|
||||
static int __init asus_t100_matched(const struct dmi_system_id *d)
|
||||
{
|
||||
matched_product_name = INV_MPU_ASUS_T100TA;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static const struct dmi_system_id inv_mpu_dev_list[] = {
|
||||
{
|
||||
.callback = asus_t100_matched,
|
||||
.ident = "Asus Transformer Book T100",
|
||||
.matches = {
|
||||
DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC"),
|
||||
DMI_MATCH(DMI_PRODUCT_NAME, "T100TA"),
|
||||
DMI_MATCH(DMI_PRODUCT_VERSION, "1.0"),
|
||||
},
|
||||
},
|
||||
/* Add more matching tables here..*/
|
||||
{}
|
||||
};
|
||||
|
||||
static int asus_acpi_get_sensor_info(struct acpi_device *adev,
|
||||
struct i2c_client *client,
|
||||
struct i2c_board_info *info)
|
||||
{
|
||||
struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER, NULL};
|
||||
int i;
|
||||
acpi_status status;
|
||||
union acpi_object *cpm;
|
||||
|
||||
status = acpi_evaluate_object(adev->handle, "CNF0", NULL, &buffer);
|
||||
if (ACPI_FAILURE(status))
|
||||
return -ENODEV;
|
||||
|
||||
cpm = buffer.pointer;
|
||||
for (i = 0; i < cpm->package.count; ++i) {
|
||||
union acpi_object *elem;
|
||||
int j;
|
||||
|
||||
elem = &(cpm->package.elements[i]);
|
||||
for (j = 0; j < elem->package.count; ++j) {
|
||||
union acpi_object *sub_elem;
|
||||
|
||||
sub_elem = &(elem->package.elements[j]);
|
||||
if (sub_elem->type == ACPI_TYPE_STRING)
|
||||
strlcpy(info->type, sub_elem->string.pointer,
|
||||
sizeof(info->type));
|
||||
else if (sub_elem->type == ACPI_TYPE_INTEGER) {
|
||||
if (sub_elem->integer.value != client->addr) {
|
||||
info->addr = sub_elem->integer.value;
|
||||
break; /* Not a MPU6500 primary */
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
kfree(buffer.pointer);
|
||||
|
||||
return cpm->package.count;
|
||||
}
|
||||
|
||||
static int acpi_i2c_check_resource(struct acpi_resource *ares, void *data)
|
||||
{
|
||||
u32 *addr = data;
|
||||
|
||||
if (ares->type == ACPI_RESOURCE_TYPE_SERIAL_BUS) {
|
||||
struct acpi_resource_i2c_serialbus *sb;
|
||||
|
||||
sb = &ares->data.i2c_serial_bus;
|
||||
if (sb->type == ACPI_RESOURCE_SERIAL_TYPE_I2C) {
|
||||
if (*addr)
|
||||
*addr |= (sb->slave_address << 16);
|
||||
else
|
||||
*addr = sb->slave_address;
|
||||
}
|
||||
}
|
||||
|
||||
/* Tell the ACPI core that we already copied this address */
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int inv_mpu_process_acpi_config(struct i2c_client *client,
|
||||
unsigned short *primary_addr,
|
||||
unsigned short *secondary_addr)
|
||||
{
|
||||
const struct acpi_device_id *id;
|
||||
struct acpi_device *adev;
|
||||
u32 i2c_addr = 0;
|
||||
LIST_HEAD(resources);
|
||||
int ret;
|
||||
|
||||
id = acpi_match_device(client->dev.driver->acpi_match_table,
|
||||
&client->dev);
|
||||
if (!id)
|
||||
return -ENODEV;
|
||||
|
||||
adev = ACPI_COMPANION(&client->dev);
|
||||
if (!adev)
|
||||
return -ENODEV;
|
||||
|
||||
ret = acpi_dev_get_resources(adev, &resources,
|
||||
acpi_i2c_check_resource, &i2c_addr);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
|
||||
acpi_dev_free_resource_list(&resources);
|
||||
*primary_addr = i2c_addr & 0x0000ffff;
|
||||
*secondary_addr = (i2c_addr & 0xffff0000) >> 16;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int inv_mpu_acpi_create_mux_client(struct inv_mpu6050_state *st)
|
||||
{
|
||||
|
||||
st->mux_client = NULL;
|
||||
if (ACPI_HANDLE(&st->client->dev)) {
|
||||
struct i2c_board_info info;
|
||||
struct acpi_device *adev;
|
||||
int ret = -1;
|
||||
|
||||
adev = ACPI_COMPANION(&st->client->dev);
|
||||
memset(&info, 0, sizeof(info));
|
||||
|
||||
dmi_check_system(inv_mpu_dev_list);
|
||||
switch (matched_product_name) {
|
||||
case INV_MPU_ASUS_T100TA:
|
||||
ret = asus_acpi_get_sensor_info(adev, st->client,
|
||||
&info);
|
||||
break;
|
||||
/* Add more matched product processing here */
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
if (ret < 0) {
|
||||
/* No matching DMI, so create device on INV6XX type */
|
||||
unsigned short primary, secondary;
|
||||
|
||||
ret = inv_mpu_process_acpi_config(st->client, &primary,
|
||||
&secondary);
|
||||
if (!ret && secondary) {
|
||||
char *name;
|
||||
|
||||
info.addr = secondary;
|
||||
strlcpy(info.type, dev_name(&adev->dev),
|
||||
sizeof(info.type));
|
||||
name = strchr(info.type, ':');
|
||||
if (name)
|
||||
*name = '\0';
|
||||
strlcat(info.type, "-client",
|
||||
sizeof(info.type));
|
||||
} else
|
||||
return 0; /* no secondary addr, which is OK */
|
||||
}
|
||||
st->mux_client = i2c_new_device(st->mux_adapter, &info);
|
||||
if (!st->mux_client)
|
||||
return -ENODEV;
|
||||
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
void inv_mpu_acpi_delete_mux_client(struct inv_mpu6050_state *st)
|
||||
{
|
||||
if (st->mux_client)
|
||||
i2c_unregister_device(st->mux_client);
|
||||
}
|
||||
#else
|
||||
|
||||
#include "inv_mpu_iio.h"
|
||||
|
||||
int inv_mpu_acpi_create_mux_client(struct inv_mpu6050_state *st)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
void inv_mpu_acpi_delete_mux_client(struct inv_mpu6050_state *st)
|
||||
{
|
||||
}
|
||||
#endif
|
||||
@ -825,8 +825,14 @@ static int inv_mpu_probe(struct i2c_client *client,
|
||||
goto out_unreg_device;
|
||||
}
|
||||
|
||||
result = inv_mpu_acpi_create_mux_client(st);
|
||||
if (result)
|
||||
goto out_del_mux;
|
||||
|
||||
return 0;
|
||||
|
||||
out_del_mux:
|
||||
i2c_del_mux_adapter(st->mux_adapter);
|
||||
out_unreg_device:
|
||||
iio_device_unregister(indio_dev);
|
||||
out_remove_trigger:
|
||||
@ -841,6 +847,7 @@ static int inv_mpu_remove(struct i2c_client *client)
|
||||
struct iio_dev *indio_dev = i2c_get_clientdata(client);
|
||||
struct inv_mpu6050_state *st = iio_priv(indio_dev);
|
||||
|
||||
inv_mpu_acpi_delete_mux_client(st);
|
||||
i2c_del_mux_adapter(st->mux_adapter);
|
||||
iio_device_unregister(indio_dev);
|
||||
inv_mpu6050_remove_trigger(st);
|
||||
|
||||
@ -121,6 +121,7 @@ struct inv_mpu6050_state {
|
||||
spinlock_t time_stamp_lock;
|
||||
struct i2c_client *client;
|
||||
struct i2c_adapter *mux_adapter;
|
||||
struct i2c_client *mux_client;
|
||||
unsigned int powerup_count;
|
||||
struct inv_mpu6050_platform_data plat_data;
|
||||
DECLARE_KFIFO(timestamps, long long, TIMESTAMP_FIFO_SIZE);
|
||||
@ -251,3 +252,5 @@ int inv_reset_fifo(struct iio_dev *indio_dev);
|
||||
int inv_mpu6050_switch_engine(struct inv_mpu6050_state *st, bool en, u32 mask);
|
||||
int inv_mpu6050_write_reg(struct inv_mpu6050_state *st, int reg, u8 val);
|
||||
int inv_mpu6050_set_power_itg(struct inv_mpu6050_state *st, bool power_on);
|
||||
int inv_mpu_acpi_create_mux_client(struct inv_mpu6050_state *st);
|
||||
void inv_mpu_acpi_delete_mux_client(struct inv_mpu6050_state *st);
|
||||
|
||||
@ -169,19 +169,18 @@ static const u16 kmx61_uscale_table[] = {9582, 19163, 38326};
|
||||
static const struct {
|
||||
int val;
|
||||
int val2;
|
||||
u8 odr_bits;
|
||||
} kmx61_samp_freq_table[] = { {12, 500000, 0x00},
|
||||
{25, 0, 0x01},
|
||||
{50, 0, 0x02},
|
||||
{100, 0, 0x03},
|
||||
{200, 0, 0x04},
|
||||
{400, 0, 0x05},
|
||||
{800, 0, 0x06},
|
||||
{1600, 0, 0x07},
|
||||
{0, 781000, 0x08},
|
||||
{1, 563000, 0x09},
|
||||
{3, 125000, 0x0A},
|
||||
{6, 250000, 0x0B} };
|
||||
} kmx61_samp_freq_table[] = { {12, 500000},
|
||||
{25, 0},
|
||||
{50, 0},
|
||||
{100, 0},
|
||||
{200, 0},
|
||||
{400, 0},
|
||||
{800, 0},
|
||||
{1600, 0},
|
||||
{0, 781000},
|
||||
{1, 563000},
|
||||
{3, 125000},
|
||||
{6, 250000} };
|
||||
|
||||
static const struct {
|
||||
int val;
|
||||
@ -302,24 +301,10 @@ static int kmx61_convert_freq_to_bit(int val, int val2)
|
||||
for (i = 0; i < ARRAY_SIZE(kmx61_samp_freq_table); i++)
|
||||
if (val == kmx61_samp_freq_table[i].val &&
|
||||
val2 == kmx61_samp_freq_table[i].val2)
|
||||
return kmx61_samp_freq_table[i].odr_bits;
|
||||
return i;
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
static int kmx61_convert_bit_to_freq(u8 odr_bits, int *val, int *val2)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < ARRAY_SIZE(kmx61_samp_freq_table); i++)
|
||||
if (odr_bits == kmx61_samp_freq_table[i].odr_bits) {
|
||||
*val = kmx61_samp_freq_table[i].val;
|
||||
*val2 = kmx61_samp_freq_table[i].val2;
|
||||
return 0;
|
||||
}
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
|
||||
static int kmx61_convert_wake_up_odr_to_bit(int val, int val2)
|
||||
{
|
||||
int i;
|
||||
@ -478,7 +463,7 @@ static int kmx61_set_odr(struct kmx61_data *data, int val, int val2, u8 device)
|
||||
|
||||
static int kmx61_get_odr(struct kmx61_data *data, int *val, int *val2,
|
||||
u8 device)
|
||||
{ int i;
|
||||
{
|
||||
u8 lodr_bits;
|
||||
|
||||
if (device & KMX61_ACC)
|
||||
@ -490,13 +475,13 @@ static int kmx61_get_odr(struct kmx61_data *data, int *val, int *val2,
|
||||
else
|
||||
return -EINVAL;
|
||||
|
||||
for (i = 0; i < ARRAY_SIZE(kmx61_samp_freq_table); i++)
|
||||
if (lodr_bits == kmx61_samp_freq_table[i].odr_bits) {
|
||||
*val = kmx61_samp_freq_table[i].val;
|
||||
*val2 = kmx61_samp_freq_table[i].val2;
|
||||
return 0;
|
||||
}
|
||||
return -EINVAL;
|
||||
if (lodr_bits >= ARRAY_SIZE(kmx61_samp_freq_table))
|
||||
return -EINVAL;
|
||||
|
||||
*val = kmx61_samp_freq_table[lodr_bits].val;
|
||||
*val2 = kmx61_samp_freq_table[lodr_bits].val2;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int kmx61_set_range(struct kmx61_data *data, u8 range)
|
||||
@ -580,8 +565,11 @@ static int kmx61_chip_init(struct kmx61_data *data)
|
||||
}
|
||||
data->odr_bits = ret;
|
||||
|
||||
/* set output data rate for wake up (motion detection) function */
|
||||
ret = kmx61_convert_bit_to_freq(data->odr_bits, &val, &val2);
|
||||
/*
|
||||
* set output data rate for wake up (motion detection) function
|
||||
* to match data rate for accelerometer sampling
|
||||
*/
|
||||
ret = kmx61_get_odr(data, &val, &val2, KMX61_ACC);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
|
||||
@ -1267,16 +1255,12 @@ static int kmx61_gpio_probe(struct i2c_client *client, struct kmx61_data *data)
|
||||
dev = &client->dev;
|
||||
|
||||
/* data ready gpio interrupt pin */
|
||||
gpio = devm_gpiod_get_index(dev, KMX61_GPIO_NAME, 0);
|
||||
gpio = devm_gpiod_get_index(dev, KMX61_GPIO_NAME, 0, GPIOD_IN);
|
||||
if (IS_ERR(gpio)) {
|
||||
dev_err(dev, "acpi gpio get index failed\n");
|
||||
return PTR_ERR(gpio);
|
||||
}
|
||||
|
||||
ret = gpiod_direction_input(gpio);
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
ret = gpiod_to_irq(gpio);
|
||||
|
||||
dev_dbg(dev, "GPIO resource, no:%d irq:%d\n", desc_to_gpio(gpio), ret);
|
||||
|
||||
@ -761,6 +761,11 @@ static struct device_attribute dev_attr_length_ro = __ATTR(length,
|
||||
static DEVICE_ATTR(enable, S_IRUGO | S_IWUSR,
|
||||
iio_buffer_show_enable, iio_buffer_store_enable);
|
||||
|
||||
static struct attribute *iio_buffer_attrs[] = {
|
||||
&dev_attr_length.attr,
|
||||
&dev_attr_enable.attr,
|
||||
};
|
||||
|
||||
int iio_buffer_alloc_sysfs_and_mask(struct iio_dev *indio_dev)
|
||||
{
|
||||
struct iio_dev_attr *p;
|
||||
@ -778,21 +783,23 @@ int iio_buffer_alloc_sysfs_and_mask(struct iio_dev *indio_dev)
|
||||
attrcount++;
|
||||
}
|
||||
|
||||
buffer->buffer_group.name = "buffer";
|
||||
buffer->buffer_group.attrs = kcalloc(attrcount + 3,
|
||||
sizeof(*buffer->buffer_group.attrs), GFP_KERNEL);
|
||||
if (!buffer->buffer_group.attrs)
|
||||
attr = kcalloc(attrcount + ARRAY_SIZE(iio_buffer_attrs) + 1,
|
||||
sizeof(struct attribute *), GFP_KERNEL);
|
||||
if (!attr)
|
||||
return -ENOMEM;
|
||||
|
||||
if (buffer->access->set_length)
|
||||
buffer->buffer_group.attrs[0] = &dev_attr_length.attr;
|
||||
else
|
||||
buffer->buffer_group.attrs[0] = &dev_attr_length_ro.attr;
|
||||
buffer->buffer_group.attrs[1] = &dev_attr_enable.attr;
|
||||
memcpy(attr, iio_buffer_attrs, sizeof(iio_buffer_attrs));
|
||||
if (!buffer->access->set_length)
|
||||
attr[0] = &dev_attr_length_ro.attr;
|
||||
|
||||
if (buffer->attrs)
|
||||
memcpy(&buffer->buffer_group.attrs[2], buffer->attrs,
|
||||
sizeof(*&buffer->buffer_group.attrs) * attrcount);
|
||||
buffer->buffer_group.attrs[attrcount+2] = NULL;
|
||||
memcpy(&attr[ARRAY_SIZE(iio_buffer_attrs)], buffer->attrs,
|
||||
sizeof(struct attribute *) * attrcount);
|
||||
|
||||
attr[attrcount + ARRAY_SIZE(iio_buffer_attrs)] = NULL;
|
||||
|
||||
buffer->buffer_group.name = "buffer";
|
||||
buffer->buffer_group.attrs = attr;
|
||||
|
||||
indio_dev->groups[indio_dev->groupcounter++] = &buffer->buffer_group;
|
||||
|
||||
|
||||
@ -59,6 +59,16 @@ config CM3232
|
||||
To compile this driver as a module, choose M here:
|
||||
the module will be called cm3232.
|
||||
|
||||
config CM3323
|
||||
depends on I2C
|
||||
tristate "Capella CM3323 color light sensor"
|
||||
help
|
||||
Say Y here if you want to build a driver for Capela CM3323
|
||||
color sensor.
|
||||
|
||||
To compile this driver as a module, choose M here: the module will
|
||||
be called cm3323.
|
||||
|
||||
config CM36651
|
||||
depends on I2C
|
||||
tristate "CM36651 driver"
|
||||
|
||||
@ -8,6 +8,7 @@ obj-$(CONFIG_AL3320A) += al3320a.o
|
||||
obj-$(CONFIG_APDS9300) += apds9300.o
|
||||
obj-$(CONFIG_CM32181) += cm32181.o
|
||||
obj-$(CONFIG_CM3232) += cm3232.o
|
||||
obj-$(CONFIG_CM3323) += cm3323.o
|
||||
obj-$(CONFIG_CM36651) += cm36651.o
|
||||
obj-$(CONFIG_GP2AP020A00F) += gp2ap020a00f.o
|
||||
obj-$(CONFIG_HID_SENSOR_ALS) += hid-sensor-als.o
|
||||
|
||||
@ -378,6 +378,39 @@ static const struct i2c_device_id cm3232_id[] = {
|
||||
{}
|
||||
};
|
||||
|
||||
#ifdef CONFIG_PM_SLEEP
|
||||
static int cm3232_suspend(struct device *dev)
|
||||
{
|
||||
struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
|
||||
struct cm3232_chip *chip = iio_priv(indio_dev);
|
||||
struct i2c_client *client = chip->client;
|
||||
int ret;
|
||||
|
||||
chip->regs_cmd |= CM3232_CMD_ALS_DISABLE;
|
||||
ret = i2c_smbus_write_byte_data(client, CM3232_REG_ADDR_CMD,
|
||||
chip->regs_cmd);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int cm3232_resume(struct device *dev)
|
||||
{
|
||||
struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
|
||||
struct cm3232_chip *chip = iio_priv(indio_dev);
|
||||
struct i2c_client *client = chip->client;
|
||||
int ret;
|
||||
|
||||
chip->regs_cmd &= ~CM3232_CMD_ALS_DISABLE;
|
||||
ret = i2c_smbus_write_byte_data(client, CM3232_REG_ADDR_CMD,
|
||||
chip->regs_cmd | CM3232_CMD_ALS_RESET);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static const struct dev_pm_ops cm3232_pm_ops = {
|
||||
SET_SYSTEM_SLEEP_PM_OPS(cm3232_suspend, cm3232_resume)};
|
||||
#endif
|
||||
|
||||
MODULE_DEVICE_TABLE(i2c, cm3232_id);
|
||||
|
||||
static const struct of_device_id cm3232_of_match[] = {
|
||||
@ -390,6 +423,9 @@ static struct i2c_driver cm3232_driver = {
|
||||
.name = "cm3232",
|
||||
.owner = THIS_MODULE,
|
||||
.of_match_table = of_match_ptr(cm3232_of_match),
|
||||
#ifdef CONFIG_PM_SLEEP
|
||||
.pm = &cm3232_pm_ops,
|
||||
#endif
|
||||
},
|
||||
.id_table = cm3232_id,
|
||||
.probe = cm3232_probe,
|
||||
|
||||
286
drivers/iio/light/cm3323.c
Normal file
286
drivers/iio/light/cm3323.c
Normal file
@ -0,0 +1,286 @@
|
||||
/*
|
||||
* CM3323 - Capella Color Light Sensor
|
||||
*
|
||||
* Copyright (c) 2015, Intel Corporation.
|
||||
*
|
||||
* This file is subject to the terms and conditions of version 2 of
|
||||
* the GNU General Public License. See the file COPYING in the main
|
||||
* directory of this archive for more details.
|
||||
*
|
||||
* IIO driver for CM3323 (7-bit I2C slave address 0x10)
|
||||
*
|
||||
* TODO: calibscale to correct the lens factor
|
||||
*/
|
||||
#include <linux/module.h>
|
||||
#include <linux/init.h>
|
||||
#include <linux/i2c.h>
|
||||
#include <linux/mutex.h>
|
||||
|
||||
#include <linux/iio/iio.h>
|
||||
#include <linux/iio/sysfs.h>
|
||||
|
||||
#define CM3323_DRV_NAME "cm3323"
|
||||
|
||||
#define CM3323_CMD_CONF 0x00
|
||||
#define CM3323_CMD_RED_DATA 0x08
|
||||
#define CM3323_CMD_GREEN_DATA 0x09
|
||||
#define CM3323_CMD_BLUE_DATA 0x0A
|
||||
#define CM3323_CMD_CLEAR_DATA 0x0B
|
||||
|
||||
#define CM3323_CONF_SD_BIT BIT(0) /* sensor disable */
|
||||
#define CM3323_CONF_AF_BIT BIT(1) /* auto/manual force mode */
|
||||
#define CM3323_CONF_IT_MASK (BIT(4) | BIT(5) | BIT(6))
|
||||
#define CM3323_CONF_IT_SHIFT 4
|
||||
|
||||
#define CM3323_INT_TIME_AVAILABLE "0.04 0.08 0.16 0.32 0.64 1.28"
|
||||
|
||||
static const struct {
|
||||
int val;
|
||||
int val2;
|
||||
} cm3323_int_time[] = {
|
||||
{0, 40000}, /* 40 ms */
|
||||
{0, 80000}, /* 80 ms */
|
||||
{0, 160000}, /* 160 ms */
|
||||
{0, 320000}, /* 320 ms */
|
||||
{0, 640000}, /* 640 ms */
|
||||
{1, 280000}, /* 1280 ms */
|
||||
};
|
||||
|
||||
struct cm3323_data {
|
||||
struct i2c_client *client;
|
||||
u16 reg_conf;
|
||||
struct mutex mutex;
|
||||
};
|
||||
|
||||
#define CM3323_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 cm3323_channels[] = {
|
||||
CM3323_COLOR_CHANNEL(RED, CM3323_CMD_RED_DATA),
|
||||
CM3323_COLOR_CHANNEL(GREEN, CM3323_CMD_GREEN_DATA),
|
||||
CM3323_COLOR_CHANNEL(BLUE, CM3323_CMD_BLUE_DATA),
|
||||
CM3323_COLOR_CHANNEL(CLEAR, CM3323_CMD_CLEAR_DATA),
|
||||
};
|
||||
|
||||
static IIO_CONST_ATTR_INT_TIME_AVAIL(CM3323_INT_TIME_AVAILABLE);
|
||||
|
||||
static struct attribute *cm3323_attributes[] = {
|
||||
&iio_const_attr_integration_time_available.dev_attr.attr,
|
||||
NULL
|
||||
};
|
||||
|
||||
static const struct attribute_group cm3323_attribute_group = {
|
||||
.attrs = cm3323_attributes,
|
||||
};
|
||||
|
||||
static int cm3323_init(struct iio_dev *indio_dev)
|
||||
{
|
||||
int ret;
|
||||
struct cm3323_data *data = iio_priv(indio_dev);
|
||||
|
||||
ret = i2c_smbus_read_word_data(data->client, CM3323_CMD_CONF);
|
||||
if (ret < 0) {
|
||||
dev_err(&data->client->dev, "Error reading reg_conf\n");
|
||||
return ret;
|
||||
}
|
||||
|
||||
/* enable sensor and set auto force mode */
|
||||
ret &= ~(CM3323_CONF_SD_BIT | CM3323_CONF_AF_BIT);
|
||||
|
||||
ret = i2c_smbus_write_word_data(data->client, CM3323_CMD_CONF, ret);
|
||||
if (ret < 0) {
|
||||
dev_err(&data->client->dev, "Error writing reg_conf\n");
|
||||
return ret;
|
||||
}
|
||||
|
||||
data->reg_conf = ret;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void cm3323_disable(struct iio_dev *indio_dev)
|
||||
{
|
||||
int ret;
|
||||
struct cm3323_data *data = iio_priv(indio_dev);
|
||||
|
||||
ret = i2c_smbus_write_word_data(data->client, CM3323_CMD_CONF,
|
||||
CM3323_CONF_SD_BIT);
|
||||
if (ret < 0)
|
||||
dev_err(&data->client->dev, "Error writing reg_conf\n");
|
||||
}
|
||||
|
||||
static int cm3323_set_it_bits(struct cm3323_data *data, int val, int val2)
|
||||
{
|
||||
int i, ret;
|
||||
u16 reg_conf;
|
||||
|
||||
for (i = 0; i < ARRAY_SIZE(cm3323_int_time); i++) {
|
||||
if (val == cm3323_int_time[i].val &&
|
||||
val2 == cm3323_int_time[i].val2) {
|
||||
reg_conf = data->reg_conf;
|
||||
reg_conf |= i << CM3323_CONF_IT_SHIFT;
|
||||
|
||||
ret = i2c_smbus_write_word_data(data->client,
|
||||
CM3323_CMD_CONF,
|
||||
reg_conf);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
|
||||
data->reg_conf = reg_conf;
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
static int cm3323_get_it_bits(struct cm3323_data *data)
|
||||
{
|
||||
int bits;
|
||||
|
||||
bits = (data->reg_conf & CM3323_CONF_IT_MASK) >>
|
||||
CM3323_CONF_IT_SHIFT;
|
||||
|
||||
if (bits >= ARRAY_SIZE(cm3323_int_time))
|
||||
return -EINVAL;
|
||||
return bits;
|
||||
}
|
||||
|
||||
static int cm3323_read_raw(struct iio_dev *indio_dev,
|
||||
struct iio_chan_spec const *chan, int *val,
|
||||
int *val2, long mask)
|
||||
{
|
||||
int i, ret;
|
||||
struct cm3323_data *data = iio_priv(indio_dev);
|
||||
|
||||
switch (mask) {
|
||||
case IIO_CHAN_INFO_RAW:
|
||||
mutex_lock(&data->mutex);
|
||||
ret = i2c_smbus_read_word_data(data->client, chan->address);
|
||||
if (ret < 0) {
|
||||
mutex_unlock(&data->mutex);
|
||||
return ret;
|
||||
}
|
||||
*val = ret;
|
||||
mutex_unlock(&data->mutex);
|
||||
|
||||
return IIO_VAL_INT;
|
||||
case IIO_CHAN_INFO_INT_TIME:
|
||||
mutex_lock(&data->mutex);
|
||||
i = cm3323_get_it_bits(data);
|
||||
if (i < 0) {
|
||||
mutex_unlock(&data->mutex);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
*val = cm3323_int_time[i].val;
|
||||
*val2 = cm3323_int_time[i].val2;
|
||||
mutex_unlock(&data->mutex);
|
||||
|
||||
return IIO_VAL_INT_PLUS_MICRO;
|
||||
default:
|
||||
return -EINVAL;
|
||||
}
|
||||
}
|
||||
|
||||
static int cm3323_write_raw(struct iio_dev *indio_dev,
|
||||
struct iio_chan_spec const *chan, int val,
|
||||
int val2, long mask)
|
||||
{
|
||||
struct cm3323_data *data = iio_priv(indio_dev);
|
||||
int ret;
|
||||
|
||||
switch (mask) {
|
||||
case IIO_CHAN_INFO_INT_TIME:
|
||||
mutex_lock(&data->mutex);
|
||||
ret = cm3323_set_it_bits(data, val, val2);
|
||||
mutex_unlock(&data->mutex);
|
||||
|
||||
return ret;
|
||||
default:
|
||||
return -EINVAL;
|
||||
}
|
||||
}
|
||||
|
||||
static const struct iio_info cm3323_info = {
|
||||
.driver_module = THIS_MODULE,
|
||||
.read_raw = cm3323_read_raw,
|
||||
.write_raw = cm3323_write_raw,
|
||||
.attrs = &cm3323_attribute_group,
|
||||
};
|
||||
|
||||
static int cm3323_probe(struct i2c_client *client,
|
||||
const struct i2c_device_id *id)
|
||||
{
|
||||
struct cm3323_data *data;
|
||||
struct iio_dev *indio_dev;
|
||||
int ret;
|
||||
|
||||
indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
|
||||
if (!indio_dev)
|
||||
return -ENOMEM;
|
||||
|
||||
data = iio_priv(indio_dev);
|
||||
i2c_set_clientdata(client, indio_dev);
|
||||
data->client = client;
|
||||
|
||||
mutex_init(&data->mutex);
|
||||
|
||||
indio_dev->dev.parent = &client->dev;
|
||||
indio_dev->info = &cm3323_info;
|
||||
indio_dev->name = CM3323_DRV_NAME;
|
||||
indio_dev->channels = cm3323_channels;
|
||||
indio_dev->num_channels = ARRAY_SIZE(cm3323_channels);
|
||||
indio_dev->modes = INDIO_DIRECT_MODE;
|
||||
|
||||
ret = cm3323_init(indio_dev);
|
||||
if (ret < 0) {
|
||||
dev_err(&client->dev, "cm3323 chip init failed\n");
|
||||
return ret;
|
||||
}
|
||||
ret = iio_device_register(indio_dev);
|
||||
if (ret < 0) {
|
||||
dev_err(&client->dev, "failed to register iio dev\n");
|
||||
goto err_init;
|
||||
}
|
||||
return 0;
|
||||
err_init:
|
||||
cm3323_disable(indio_dev);
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int cm3323_remove(struct i2c_client *client)
|
||||
{
|
||||
struct iio_dev *indio_dev = i2c_get_clientdata(client);
|
||||
|
||||
iio_device_unregister(indio_dev);
|
||||
cm3323_disable(indio_dev);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static const struct i2c_device_id cm3323_id[] = {
|
||||
{"cm3323", 0},
|
||||
{}
|
||||
};
|
||||
MODULE_DEVICE_TABLE(i2c, cm3323_id);
|
||||
|
||||
static struct i2c_driver cm3323_driver = {
|
||||
.driver = {
|
||||
.name = CM3323_DRV_NAME,
|
||||
},
|
||||
.probe = cm3323_probe,
|
||||
.remove = cm3323_remove,
|
||||
.id_table = cm3323_id,
|
||||
};
|
||||
|
||||
module_i2c_driver(cm3323_driver);
|
||||
|
||||
MODULE_AUTHOR("Daniel Baluta <daniel.baluta@intel.com>");
|
||||
MODULE_DESCRIPTION("Capella CM3323 Color Light Sensor driver");
|
||||
MODULE_LICENSE("GPL v2");
|
||||
@ -46,6 +46,7 @@
|
||||
#include <linux/regmap.h>
|
||||
#include <linux/regulator/consumer.h>
|
||||
#include <linux/slab.h>
|
||||
#include <asm/unaligned.h>
|
||||
#include <linux/iio/buffer.h>
|
||||
#include <linux/iio/events.h>
|
||||
#include <linux/iio/iio.h>
|
||||
@ -966,7 +967,6 @@ static irqreturn_t gp2ap020a00f_trigger_handler(int irq, void *data)
|
||||
struct iio_dev *indio_dev = pf->indio_dev;
|
||||
struct gp2ap020a00f_data *priv = iio_priv(indio_dev);
|
||||
size_t d_size = 0;
|
||||
__le32 light_lux;
|
||||
int i, out_val, ret;
|
||||
|
||||
for_each_set_bit(i, indio_dev->active_scan_mask,
|
||||
@ -981,8 +981,8 @@ static irqreturn_t gp2ap020a00f_trigger_handler(int irq, void *data)
|
||||
i == GP2AP020A00F_SCAN_MODE_LIGHT_IR) {
|
||||
out_val = le16_to_cpup((__le16 *)&priv->buffer[d_size]);
|
||||
gp2ap020a00f_output_to_lux(priv, &out_val);
|
||||
light_lux = cpu_to_le32(out_val);
|
||||
memcpy(&priv->buffer[d_size], (u8 *)&light_lux, 4);
|
||||
|
||||
put_unaligned_le32(out_val, &priv->buffer[d_size]);
|
||||
d_size += 4;
|
||||
} else {
|
||||
d_size += 2;
|
||||
|
||||
@ -308,7 +308,7 @@ static bool jsa1212_is_volatile_reg(struct device *dev, unsigned int reg)
|
||||
}
|
||||
}
|
||||
|
||||
static struct regmap_config jsa1212_regmap_config = {
|
||||
static const struct regmap_config jsa1212_regmap_config = {
|
||||
.name = JSA1212_REGMAP_NAME,
|
||||
.reg_bits = 8,
|
||||
.val_bits = 8,
|
||||
|
||||
@ -52,6 +52,33 @@ config MPL3115
|
||||
To compile this driver as a module, choose M here: the module
|
||||
will be called mpl3115.
|
||||
|
||||
config MS5611
|
||||
tristate "Measurement Specialities MS5611 pressure sensor driver"
|
||||
help
|
||||
Say Y here to build support for the Measurement Specialities
|
||||
MS5611 pressure and temperature sensor.
|
||||
|
||||
To compile this driver as a module, choose M here: the module will
|
||||
be called ms5611_core.
|
||||
|
||||
config MS5611_I2C
|
||||
tristate "support I2C bus connection"
|
||||
depends on I2C && MS5611
|
||||
help
|
||||
Say Y here to build I2C bus support for MS5611.
|
||||
|
||||
To compile this driver as a module, choose M here: the module will
|
||||
be called ms5611_i2c.
|
||||
|
||||
config MS5611_SPI
|
||||
tristate "support SPI bus connection"
|
||||
depends on SPI_MASTER && MS5611
|
||||
help
|
||||
Say Y here to build SPI bus support for MS5611.
|
||||
|
||||
To compile this driver as a module, choose M here: the module will
|
||||
be called ms5611_spi.
|
||||
|
||||
config IIO_ST_PRESS
|
||||
tristate "STMicroelectronics pressure sensor Driver"
|
||||
depends on (I2C || SPI_MASTER) && SYSFS
|
||||
|
||||
@ -7,6 +7,9 @@ obj-$(CONFIG_BMP280) += bmp280.o
|
||||
obj-$(CONFIG_HID_SENSOR_PRESS) += hid-sensor-press.o
|
||||
obj-$(CONFIG_MPL115) += mpl115.o
|
||||
obj-$(CONFIG_MPL3115) += mpl3115.o
|
||||
obj-$(CONFIG_MS5611) += ms5611_core.o
|
||||
obj-$(CONFIG_MS5611_I2C) += ms5611_i2c.o
|
||||
obj-$(CONFIG_MS5611_SPI) += ms5611_spi.o
|
||||
obj-$(CONFIG_IIO_ST_PRESS) += st_pressure.o
|
||||
st_pressure-y := st_pressure_core.o
|
||||
st_pressure-$(CONFIG_IIO_BUFFER) += st_pressure_buffer.o
|
||||
|
||||
44
drivers/iio/pressure/ms5611.h
Normal file
44
drivers/iio/pressure/ms5611.h
Normal file
@ -0,0 +1,44 @@
|
||||
/*
|
||||
* MS5611 pressure and temperature sensor driver
|
||||
*
|
||||
* Copyright (c) Tomasz Duszynski <tduszyns@gmail.com>
|
||||
*
|
||||
* 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.
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef _MS5611_H
|
||||
#define _MS5611_H
|
||||
|
||||
#include <linux/device.h>
|
||||
#include <linux/iio/iio.h>
|
||||
#include <linux/mutex.h>
|
||||
|
||||
#define MS5611_RESET 0x1e
|
||||
#define MS5611_READ_ADC 0x00
|
||||
#define MS5611_READ_PROM_WORD 0xA0
|
||||
#define MS5611_START_TEMP_CONV 0x58
|
||||
#define MS5611_START_PRESSURE_CONV 0x48
|
||||
|
||||
#define MS5611_CONV_TIME_MIN 9040
|
||||
#define MS5611_CONV_TIME_MAX 10000
|
||||
|
||||
#define MS5611_PROM_WORDS_NB 8
|
||||
|
||||
struct ms5611_state {
|
||||
void *client;
|
||||
struct mutex lock;
|
||||
|
||||
int (*reset)(struct device *dev);
|
||||
int (*read_prom_word)(struct device *dev, int index, u16 *word);
|
||||
int (*read_adc_temp_and_pressure)(struct device *dev,
|
||||
s32 *temp, s32 *pressure);
|
||||
|
||||
u16 prom[MS5611_PROM_WORDS_NB];
|
||||
};
|
||||
|
||||
int ms5611_probe(struct iio_dev *indio_dev, struct device *dev);
|
||||
|
||||
#endif /* _MS5611_H */
|
||||
215
drivers/iio/pressure/ms5611_core.c
Normal file
215
drivers/iio/pressure/ms5611_core.c
Normal file
@ -0,0 +1,215 @@
|
||||
/*
|
||||
* MS5611 pressure and temperature sensor driver
|
||||
*
|
||||
* Copyright (c) Tomasz Duszynski <tduszyns@gmail.com>
|
||||
*
|
||||
* 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.
|
||||
*
|
||||
* Data sheet:
|
||||
* http://www.meas-spec.com/downloads/MS5611-01BA03.pdf
|
||||
*
|
||||
*/
|
||||
|
||||
#include <linux/module.h>
|
||||
#include <linux/iio/iio.h>
|
||||
#include <linux/delay.h>
|
||||
|
||||
#include "ms5611.h"
|
||||
|
||||
static bool ms5611_prom_is_valid(u16 *prom, size_t len)
|
||||
{
|
||||
int i, j;
|
||||
uint16_t crc = 0, crc_orig = prom[7] & 0x000F;
|
||||
|
||||
prom[7] &= 0xFF00;
|
||||
|
||||
for (i = 0; i < len * 2; i++) {
|
||||
if (i % 2 == 1)
|
||||
crc ^= prom[i >> 1] & 0x00FF;
|
||||
else
|
||||
crc ^= prom[i >> 1] >> 8;
|
||||
|
||||
for (j = 0; j < 8; j++) {
|
||||
if (crc & 0x8000)
|
||||
crc = (crc << 1) ^ 0x3000;
|
||||
else
|
||||
crc <<= 1;
|
||||
}
|
||||
}
|
||||
|
||||
crc = (crc >> 12) & 0x000F;
|
||||
|
||||
return crc_orig != 0x0000 && crc == crc_orig;
|
||||
}
|
||||
|
||||
static int ms5611_read_prom(struct iio_dev *indio_dev)
|
||||
{
|
||||
int ret, i;
|
||||
struct ms5611_state *st = iio_priv(indio_dev);
|
||||
|
||||
for (i = 0; i < MS5611_PROM_WORDS_NB; i++) {
|
||||
ret = st->read_prom_word(&indio_dev->dev, i, &st->prom[i]);
|
||||
if (ret < 0) {
|
||||
dev_err(&indio_dev->dev,
|
||||
"failed to read prom at %d\n", i);
|
||||
return ret;
|
||||
}
|
||||
}
|
||||
|
||||
if (!ms5611_prom_is_valid(st->prom, MS5611_PROM_WORDS_NB)) {
|
||||
dev_err(&indio_dev->dev, "PROM integrity check failed\n");
|
||||
return -ENODEV;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int ms5611_read_temp_and_pressure(struct iio_dev *indio_dev,
|
||||
s32 *temp, s32 *pressure)
|
||||
{
|
||||
int ret;
|
||||
s32 t, p;
|
||||
s64 off, sens, dt;
|
||||
struct ms5611_state *st = iio_priv(indio_dev);
|
||||
|
||||
ret = st->read_adc_temp_and_pressure(&indio_dev->dev, &t, &p);
|
||||
if (ret < 0) {
|
||||
dev_err(&indio_dev->dev,
|
||||
"failed to read temperature and pressure\n");
|
||||
return ret;
|
||||
}
|
||||
|
||||
dt = t - (st->prom[5] << 8);
|
||||
off = ((s64)st->prom[2] << 16) + ((st->prom[4] * dt) >> 7);
|
||||
sens = ((s64)st->prom[1] << 15) + ((st->prom[3] * dt) >> 8);
|
||||
|
||||
t = 2000 + ((st->prom[6] * dt) >> 23);
|
||||
if (t < 2000) {
|
||||
s64 off2, sens2, t2;
|
||||
|
||||
t2 = (dt * dt) >> 31;
|
||||
off2 = (5 * (t - 2000) * (t - 2000)) >> 1;
|
||||
sens2 = off2 >> 1;
|
||||
|
||||
if (t < -1500) {
|
||||
s64 tmp = (t + 1500) * (t + 1500);
|
||||
|
||||
off2 += 7 * tmp;
|
||||
sens2 += (11 * tmp) >> 1;
|
||||
}
|
||||
|
||||
t -= t2;
|
||||
off -= off2;
|
||||
sens -= sens2;
|
||||
}
|
||||
|
||||
*temp = t;
|
||||
*pressure = (((p * sens) >> 21) - off) >> 15;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int ms5611_reset(struct iio_dev *indio_dev)
|
||||
{
|
||||
int ret;
|
||||
struct ms5611_state *st = iio_priv(indio_dev);
|
||||
|
||||
ret = st->reset(&indio_dev->dev);
|
||||
if (ret < 0) {
|
||||
dev_err(&indio_dev->dev, "failed to reset device\n");
|
||||
return ret;
|
||||
}
|
||||
|
||||
usleep_range(3000, 4000);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int ms5611_read_raw(struct iio_dev *indio_dev,
|
||||
struct iio_chan_spec const *chan,
|
||||
int *val, int *val2, long mask)
|
||||
{
|
||||
int ret;
|
||||
s32 temp, pressure;
|
||||
struct ms5611_state *st = iio_priv(indio_dev);
|
||||
|
||||
switch (mask) {
|
||||
case IIO_CHAN_INFO_PROCESSED:
|
||||
mutex_lock(&st->lock);
|
||||
ret = ms5611_read_temp_and_pressure(indio_dev,
|
||||
&temp, &pressure);
|
||||
mutex_unlock(&st->lock);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
|
||||
switch (chan->type) {
|
||||
case IIO_TEMP:
|
||||
*val = temp * 10;
|
||||
return IIO_VAL_INT;
|
||||
case IIO_PRESSURE:
|
||||
*val = pressure / 1000;
|
||||
*val2 = (pressure % 1000) * 1000;
|
||||
return IIO_VAL_INT_PLUS_MICRO;
|
||||
default:
|
||||
return -EINVAL;
|
||||
}
|
||||
}
|
||||
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
static const struct iio_chan_spec ms5611_channels[] = {
|
||||
{
|
||||
.type = IIO_PRESSURE,
|
||||
.info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED) |
|
||||
BIT(IIO_CHAN_INFO_SCALE)
|
||||
},
|
||||
{
|
||||
.type = IIO_TEMP,
|
||||
.info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED) |
|
||||
BIT(IIO_CHAN_INFO_SCALE)
|
||||
}
|
||||
};
|
||||
|
||||
static const struct iio_info ms5611_info = {
|
||||
.read_raw = &ms5611_read_raw,
|
||||
.driver_module = THIS_MODULE,
|
||||
};
|
||||
|
||||
static int ms5611_init(struct iio_dev *indio_dev)
|
||||
{
|
||||
int ret;
|
||||
|
||||
ret = ms5611_reset(indio_dev);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
|
||||
return ms5611_read_prom(indio_dev);
|
||||
}
|
||||
|
||||
int ms5611_probe(struct iio_dev *indio_dev, struct device *dev)
|
||||
{
|
||||
int ret;
|
||||
struct ms5611_state *st = iio_priv(indio_dev);
|
||||
|
||||
mutex_init(&st->lock);
|
||||
indio_dev->dev.parent = dev;
|
||||
indio_dev->name = dev->driver->name;
|
||||
indio_dev->info = &ms5611_info;
|
||||
indio_dev->channels = ms5611_channels;
|
||||
indio_dev->num_channels = ARRAY_SIZE(ms5611_channels);
|
||||
indio_dev->modes = INDIO_DIRECT_MODE;
|
||||
|
||||
ret = ms5611_init(indio_dev);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
|
||||
return devm_iio_device_register(dev, indio_dev);
|
||||
}
|
||||
EXPORT_SYMBOL(ms5611_probe);
|
||||
|
||||
MODULE_AUTHOR("Tomasz Duszynski <tduszyns@gmail.com>");
|
||||
MODULE_DESCRIPTION("MS5611 core driver");
|
||||
MODULE_LICENSE("GPL v2");
|
||||
128
drivers/iio/pressure/ms5611_i2c.c
Normal file
128
drivers/iio/pressure/ms5611_i2c.c
Normal file
@ -0,0 +1,128 @@
|
||||
/*
|
||||
* MS5611 pressure and temperature sensor driver (I2C bus)
|
||||
*
|
||||
* Copyright (c) Tomasz Duszynski <tduszyns@gmail.com>
|
||||
*
|
||||
* 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.
|
||||
*
|
||||
* 7-bit I2C slave addresses:
|
||||
*
|
||||
* 0x77 (CSB pin low)
|
||||
* 0x76 (CSB pin high)
|
||||
*
|
||||
*/
|
||||
|
||||
#include <linux/delay.h>
|
||||
#include <linux/i2c.h>
|
||||
#include <linux/module.h>
|
||||
|
||||
#include "ms5611.h"
|
||||
|
||||
static int ms5611_i2c_reset(struct device *dev)
|
||||
{
|
||||
struct ms5611_state *st = iio_priv(dev_to_iio_dev(dev));
|
||||
|
||||
return i2c_smbus_write_byte(st->client, MS5611_RESET);
|
||||
}
|
||||
|
||||
static int ms5611_i2c_read_prom_word(struct device *dev, int index, u16 *word)
|
||||
{
|
||||
int ret;
|
||||
struct ms5611_state *st = iio_priv(dev_to_iio_dev(dev));
|
||||
|
||||
ret = i2c_smbus_read_word_swapped(st->client,
|
||||
MS5611_READ_PROM_WORD + (index << 1));
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
|
||||
*word = ret;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int ms5611_i2c_read_adc(struct ms5611_state *st, s32 *val)
|
||||
{
|
||||
int ret;
|
||||
u8 buf[3];
|
||||
|
||||
ret = i2c_smbus_read_i2c_block_data(st->client, MS5611_READ_ADC,
|
||||
3, buf);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
|
||||
*val = (buf[0] << 16) | (buf[1] << 8) | buf[2];
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int ms5611_i2c_read_adc_temp_and_pressure(struct device *dev,
|
||||
s32 *temp, s32 *pressure)
|
||||
{
|
||||
int ret;
|
||||
struct ms5611_state *st = iio_priv(dev_to_iio_dev(dev));
|
||||
|
||||
ret = i2c_smbus_write_byte(st->client, MS5611_START_TEMP_CONV);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
|
||||
usleep_range(MS5611_CONV_TIME_MIN, MS5611_CONV_TIME_MAX);
|
||||
|
||||
ret = ms5611_i2c_read_adc(st, temp);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
|
||||
ret = i2c_smbus_write_byte(st->client, MS5611_START_PRESSURE_CONV);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
|
||||
usleep_range(MS5611_CONV_TIME_MIN, MS5611_CONV_TIME_MAX);
|
||||
|
||||
return ms5611_i2c_read_adc(st, pressure);
|
||||
}
|
||||
|
||||
static int ms5611_i2c_probe(struct i2c_client *client,
|
||||
const struct i2c_device_id *id)
|
||||
{
|
||||
struct ms5611_state *st;
|
||||
struct iio_dev *indio_dev;
|
||||
|
||||
if (!i2c_check_functionality(client->adapter,
|
||||
I2C_FUNC_SMBUS_WRITE_BYTE |
|
||||
I2C_FUNC_SMBUS_READ_WORD_DATA |
|
||||
I2C_FUNC_SMBUS_READ_I2C_BLOCK))
|
||||
return -ENODEV;
|
||||
|
||||
indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*st));
|
||||
if (!indio_dev)
|
||||
return -ENOMEM;
|
||||
|
||||
st = iio_priv(indio_dev);
|
||||
st->reset = ms5611_i2c_reset;
|
||||
st->read_prom_word = ms5611_i2c_read_prom_word;
|
||||
st->read_adc_temp_and_pressure = ms5611_i2c_read_adc_temp_and_pressure;
|
||||
st->client = client;
|
||||
|
||||
return ms5611_probe(indio_dev, &client->dev);
|
||||
}
|
||||
|
||||
static const struct i2c_device_id ms5611_id[] = {
|
||||
{ "ms5611", 0 },
|
||||
{ }
|
||||
};
|
||||
MODULE_DEVICE_TABLE(i2c, ms5611_id);
|
||||
|
||||
static struct i2c_driver ms5611_driver = {
|
||||
.driver = {
|
||||
.name = "ms5611",
|
||||
.owner = THIS_MODULE,
|
||||
},
|
||||
.id_table = ms5611_id,
|
||||
.probe = ms5611_i2c_probe,
|
||||
};
|
||||
module_i2c_driver(ms5611_driver);
|
||||
|
||||
MODULE_AUTHOR("Tomasz Duszynski <tduszyns@gmail.com>");
|
||||
MODULE_DESCRIPTION("MS5611 i2c driver");
|
||||
MODULE_LICENSE("GPL v2");
|
||||
127
drivers/iio/pressure/ms5611_spi.c
Normal file
127
drivers/iio/pressure/ms5611_spi.c
Normal file
@ -0,0 +1,127 @@
|
||||
/*
|
||||
* MS5611 pressure and temperature sensor driver (SPI bus)
|
||||
*
|
||||
* Copyright (c) Tomasz Duszynski <tduszyns@gmail.com>
|
||||
*
|
||||
* 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/delay.h>
|
||||
#include <linux/module.h>
|
||||
#include <linux/spi/spi.h>
|
||||
|
||||
#include "ms5611.h"
|
||||
|
||||
static int ms5611_spi_reset(struct device *dev)
|
||||
{
|
||||
u8 cmd = MS5611_RESET;
|
||||
struct ms5611_state *st = iio_priv(dev_to_iio_dev(dev));
|
||||
|
||||
return spi_write_then_read(st->client, &cmd, 1, NULL, 0);
|
||||
}
|
||||
|
||||
static int ms5611_spi_read_prom_word(struct device *dev, int index, u16 *word)
|
||||
{
|
||||
int ret;
|
||||
struct ms5611_state *st = iio_priv(dev_to_iio_dev(dev));
|
||||
|
||||
ret = spi_w8r16be(st->client, MS5611_READ_PROM_WORD + (index << 1));
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
|
||||
*word = ret;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int ms5611_spi_read_adc(struct device *dev, s32 *val)
|
||||
{
|
||||
int ret;
|
||||
u8 buf[3] = { MS5611_READ_ADC };
|
||||
struct ms5611_state *st = iio_priv(dev_to_iio_dev(dev));
|
||||
|
||||
ret = spi_write_then_read(st->client, buf, 1, buf, 3);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
|
||||
*val = (buf[0] << 16) | (buf[1] << 8) | buf[2];
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int ms5611_spi_read_adc_temp_and_pressure(struct device *dev,
|
||||
s32 *temp, s32 *pressure)
|
||||
{
|
||||
u8 cmd;
|
||||
int ret;
|
||||
struct ms5611_state *st = iio_priv(dev_to_iio_dev(dev));
|
||||
|
||||
cmd = MS5611_START_TEMP_CONV;
|
||||
ret = spi_write_then_read(st->client, &cmd, 1, NULL, 0);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
|
||||
usleep_range(MS5611_CONV_TIME_MIN, MS5611_CONV_TIME_MAX);
|
||||
|
||||
ret = ms5611_spi_read_adc(dev, temp);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
|
||||
cmd = MS5611_START_PRESSURE_CONV;
|
||||
ret = spi_write_then_read(st->client, &cmd, 1, NULL, 0);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
|
||||
usleep_range(MS5611_CONV_TIME_MIN, MS5611_CONV_TIME_MAX);
|
||||
|
||||
return ms5611_spi_read_adc(dev, pressure);
|
||||
}
|
||||
|
||||
static int ms5611_spi_probe(struct spi_device *spi)
|
||||
{
|
||||
int ret;
|
||||
struct ms5611_state *st;
|
||||
struct iio_dev *indio_dev;
|
||||
|
||||
indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*st));
|
||||
if (!indio_dev)
|
||||
return -ENOMEM;
|
||||
|
||||
spi->mode = SPI_MODE_0;
|
||||
spi->max_speed_hz = 20000000;
|
||||
spi->bits_per_word = 8;
|
||||
ret = spi_setup(spi);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
|
||||
st = iio_priv(indio_dev);
|
||||
st->reset = ms5611_spi_reset;
|
||||
st->read_prom_word = ms5611_spi_read_prom_word;
|
||||
st->read_adc_temp_and_pressure = ms5611_spi_read_adc_temp_and_pressure;
|
||||
st->client = spi;
|
||||
|
||||
return ms5611_probe(indio_dev, &spi->dev);
|
||||
}
|
||||
|
||||
static const struct spi_device_id ms5611_id[] = {
|
||||
{ "ms5611", 0 },
|
||||
{ }
|
||||
};
|
||||
MODULE_DEVICE_TABLE(spi, ms5611_id);
|
||||
|
||||
static struct spi_driver ms5611_driver = {
|
||||
.driver = {
|
||||
.name = "ms5611",
|
||||
.owner = THIS_MODULE,
|
||||
},
|
||||
.id_table = ms5611_id,
|
||||
.probe = ms5611_spi_probe,
|
||||
};
|
||||
module_spi_driver(ms5611_driver);
|
||||
|
||||
MODULE_AUTHOR("Tomasz Duszynski <tduszyns@gmail.com>");
|
||||
MODULE_DESCRIPTION("MS5611 spi driver");
|
||||
MODULE_LICENSE("GPL v2");
|
||||
@ -618,16 +618,12 @@ static int sx9500_gpio_probe(struct i2c_client *client,
|
||||
dev = &client->dev;
|
||||
|
||||
/* data ready gpio interrupt pin */
|
||||
gpio = devm_gpiod_get_index(dev, SX9500_GPIO_NAME, 0);
|
||||
gpio = devm_gpiod_get_index(dev, SX9500_GPIO_NAME, 0, GPIOD_IN);
|
||||
if (IS_ERR(gpio)) {
|
||||
dev_err(dev, "acpi gpio get index failed\n");
|
||||
return PTR_ERR(gpio);
|
||||
}
|
||||
|
||||
ret = gpiod_direction_input(gpio);
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
ret = gpiod_to_irq(gpio);
|
||||
|
||||
dev_dbg(dev, "GPIO resource, no:%d irq:%d\n", desc_to_gpio(gpio), ret);
|
||||
|
||||
@ -23,8 +23,8 @@
|
||||
#define MLX90614_OP_RAM 0x00
|
||||
|
||||
/* RAM offsets with 16-bit data, MSB first */
|
||||
#define MLX90614_TA 0x06 /* ambient temperature */
|
||||
#define MLX90614_TOBJ1 0x07 /* object temperature */
|
||||
#define MLX90614_TA (MLX90614_OP_RAM | 0x06) /* ambient temperature */
|
||||
#define MLX90614_TOBJ1 (MLX90614_OP_RAM | 0x07) /* object 1 temperature */
|
||||
|
||||
struct mlx90614_data {
|
||||
struct i2c_client *client;
|
||||
@ -42,13 +42,13 @@ static int mlx90614_read_raw(struct iio_dev *indio_dev,
|
||||
switch (channel->channel2) {
|
||||
case IIO_MOD_TEMP_AMBIENT:
|
||||
ret = i2c_smbus_read_word_data(data->client,
|
||||
MLX90614_OP_RAM | MLX90614_TA);
|
||||
MLX90614_TA);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
break;
|
||||
case IIO_MOD_TEMP_OBJECT:
|
||||
ret = i2c_smbus_read_word_data(data->client,
|
||||
MLX90614_OP_RAM | MLX90614_TOBJ1);
|
||||
MLX90614_TOBJ1);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
break;
|
||||
|
||||
@ -993,7 +993,7 @@ static ssize_t mxs_lradc_show_scale_available_ch(struct device *dev,
|
||||
int i, len = 0;
|
||||
|
||||
for (i = 0; i < ARRAY_SIZE(lradc->scale_avail[ch]); i++)
|
||||
len += sprintf(buf + len, "%d.%09u ",
|
||||
len += sprintf(buf + len, "%u.%09u ",
|
||||
lradc->scale_avail[ch][i].integer,
|
||||
lradc->scale_avail[ch][i].nano);
|
||||
|
||||
|
||||
@ -19,41 +19,41 @@
|
||||
#include "hmc5843.h"
|
||||
|
||||
static const struct regmap_range hmc5843_readable_ranges[] = {
|
||||
regmap_reg_range(0, HMC5843_ID_END),
|
||||
regmap_reg_range(0, HMC5843_ID_END),
|
||||
};
|
||||
|
||||
static struct regmap_access_table hmc5843_readable_table = {
|
||||
.yes_ranges = hmc5843_readable_ranges,
|
||||
.n_yes_ranges = ARRAY_SIZE(hmc5843_readable_ranges),
|
||||
static const struct regmap_access_table hmc5843_readable_table = {
|
||||
.yes_ranges = hmc5843_readable_ranges,
|
||||
.n_yes_ranges = ARRAY_SIZE(hmc5843_readable_ranges),
|
||||
};
|
||||
|
||||
static const struct regmap_range hmc5843_writable_ranges[] = {
|
||||
regmap_reg_range(0, HMC5843_MODE_REG),
|
||||
regmap_reg_range(0, HMC5843_MODE_REG),
|
||||
};
|
||||
|
||||
static struct regmap_access_table hmc5843_writable_table = {
|
||||
.yes_ranges = hmc5843_writable_ranges,
|
||||
.n_yes_ranges = ARRAY_SIZE(hmc5843_writable_ranges),
|
||||
static const struct regmap_access_table hmc5843_writable_table = {
|
||||
.yes_ranges = hmc5843_writable_ranges,
|
||||
.n_yes_ranges = ARRAY_SIZE(hmc5843_writable_ranges),
|
||||
};
|
||||
|
||||
static const struct regmap_range hmc5843_volatile_ranges[] = {
|
||||
regmap_reg_range(HMC5843_DATA_OUT_MSB_REGS, HMC5843_STATUS_REG),
|
||||
regmap_reg_range(HMC5843_DATA_OUT_MSB_REGS, HMC5843_STATUS_REG),
|
||||
};
|
||||
|
||||
static struct regmap_access_table hmc5843_volatile_table = {
|
||||
.yes_ranges = hmc5843_volatile_ranges,
|
||||
.n_yes_ranges = ARRAY_SIZE(hmc5843_volatile_ranges),
|
||||
static const struct regmap_access_table hmc5843_volatile_table = {
|
||||
.yes_ranges = hmc5843_volatile_ranges,
|
||||
.n_yes_ranges = ARRAY_SIZE(hmc5843_volatile_ranges),
|
||||
};
|
||||
|
||||
static struct regmap_config hmc5843_i2c_regmap_config = {
|
||||
.reg_bits = 8,
|
||||
.val_bits = 8,
|
||||
static const struct regmap_config hmc5843_i2c_regmap_config = {
|
||||
.reg_bits = 8,
|
||||
.val_bits = 8,
|
||||
|
||||
.rd_table = &hmc5843_readable_table,
|
||||
.wr_table = &hmc5843_writable_table,
|
||||
.volatile_table = &hmc5843_volatile_table,
|
||||
.rd_table = &hmc5843_readable_table,
|
||||
.wr_table = &hmc5843_writable_table,
|
||||
.volatile_table = &hmc5843_volatile_table,
|
||||
|
||||
.cache_type = REGCACHE_RBTREE,
|
||||
.cache_type = REGCACHE_RBTREE,
|
||||
};
|
||||
|
||||
static int hmc5843_i2c_probe(struct i2c_client *cli,
|
||||
|
||||
@ -19,7 +19,7 @@ static const struct regmap_range hmc5843_readable_ranges[] = {
|
||||
regmap_reg_range(0, HMC5843_ID_END),
|
||||
};
|
||||
|
||||
static struct regmap_access_table hmc5843_readable_table = {
|
||||
static const struct regmap_access_table hmc5843_readable_table = {
|
||||
.yes_ranges = hmc5843_readable_ranges,
|
||||
.n_yes_ranges = ARRAY_SIZE(hmc5843_readable_ranges),
|
||||
};
|
||||
@ -28,7 +28,7 @@ static const struct regmap_range hmc5843_writable_ranges[] = {
|
||||
regmap_reg_range(0, HMC5843_MODE_REG),
|
||||
};
|
||||
|
||||
static struct regmap_access_table hmc5843_writable_table = {
|
||||
static const struct regmap_access_table hmc5843_writable_table = {
|
||||
.yes_ranges = hmc5843_writable_ranges,
|
||||
.n_yes_ranges = ARRAY_SIZE(hmc5843_writable_ranges),
|
||||
};
|
||||
@ -37,12 +37,12 @@ static const struct regmap_range hmc5843_volatile_ranges[] = {
|
||||
regmap_reg_range(HMC5843_DATA_OUT_MSB_REGS, HMC5843_STATUS_REG),
|
||||
};
|
||||
|
||||
static struct regmap_access_table hmc5843_volatile_table = {
|
||||
static const struct regmap_access_table hmc5843_volatile_table = {
|
||||
.yes_ranges = hmc5843_volatile_ranges,
|
||||
.n_yes_ranges = ARRAY_SIZE(hmc5843_volatile_ranges),
|
||||
};
|
||||
|
||||
static struct regmap_config hmc5843_spi_regmap_config = {
|
||||
static const struct regmap_config hmc5843_spi_regmap_config = {
|
||||
.reg_bits = 8,
|
||||
.val_bits = 8,
|
||||
|
||||
|
||||
@ -216,9 +216,13 @@ error_ret:
|
||||
|
||||
static int ade7754_reset(struct device *dev)
|
||||
{
|
||||
int ret;
|
||||
u8 val;
|
||||
|
||||
ade7754_spi_read_reg_8(dev, ADE7754_OPMODE, &val);
|
||||
ret = ade7754_spi_read_reg_8(dev, ADE7754_OPMODE, &val);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
|
||||
val |= 1 << 6; /* Software Chip Reset */
|
||||
return ade7754_spi_write_reg_8(dev, ADE7754_OPMODE, val);
|
||||
}
|
||||
@ -362,9 +366,16 @@ error_ret:
|
||||
/* Power down the device */
|
||||
static int ade7754_stop_device(struct device *dev)
|
||||
{
|
||||
int ret;
|
||||
u8 val;
|
||||
|
||||
ade7754_spi_read_reg_8(dev, ADE7754_OPMODE, &val);
|
||||
ret = ade7754_spi_read_reg_8(dev, ADE7754_OPMODE, &val);
|
||||
if (ret < 0) {
|
||||
dev_err(dev, "unable to power down the device, error: %d",
|
||||
ret);
|
||||
return ret;
|
||||
}
|
||||
|
||||
val |= 7 << 3; /* ADE7754 powered down */
|
||||
return ade7754_spi_write_reg_8(dev, ADE7754_OPMODE, val);
|
||||
}
|
||||
|
||||
@ -215,11 +215,15 @@ error_ret:
|
||||
|
||||
static int ade7759_reset(struct device *dev)
|
||||
{
|
||||
int ret;
|
||||
u16 val;
|
||||
|
||||
ade7759_spi_read_reg_16(dev,
|
||||
ret = ade7759_spi_read_reg_16(dev,
|
||||
ADE7759_MODE,
|
||||
&val);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
|
||||
val |= 1 << 6; /* Software Chip Reset */
|
||||
return ade7759_spi_write_reg_16(dev,
|
||||
ADE7759_MODE,
|
||||
@ -298,11 +302,18 @@ error_ret:
|
||||
/* Power down the device */
|
||||
static int ade7759_stop_device(struct device *dev)
|
||||
{
|
||||
int ret;
|
||||
u16 val;
|
||||
|
||||
ade7759_spi_read_reg_16(dev,
|
||||
ret = ade7759_spi_read_reg_16(dev,
|
||||
ADE7759_MODE,
|
||||
&val);
|
||||
if (ret < 0) {
|
||||
dev_err(dev, "unable to power down the device, error: %d\n",
|
||||
ret);
|
||||
return ret;
|
||||
}
|
||||
|
||||
val |= 1 << 4; /* AD converters can be turned off */
|
||||
|
||||
return ade7759_spi_write_reg_16(dev, ADE7759_MODE, val);
|
||||
|
||||
@ -198,7 +198,7 @@ static ssize_t ad2s1210_show_fclkin(struct device *dev,
|
||||
{
|
||||
struct ad2s1210_state *st = iio_priv(dev_to_iio_dev(dev));
|
||||
|
||||
return sprintf(buf, "%d\n", st->fclkin);
|
||||
return sprintf(buf, "%u\n", st->fclkin);
|
||||
}
|
||||
|
||||
static ssize_t ad2s1210_store_fclkin(struct device *dev,
|
||||
@ -237,7 +237,7 @@ static ssize_t ad2s1210_show_fexcit(struct device *dev,
|
||||
{
|
||||
struct ad2s1210_state *st = iio_priv(dev_to_iio_dev(dev));
|
||||
|
||||
return sprintf(buf, "%d\n", st->fexcit);
|
||||
return sprintf(buf, "%u\n", st->fexcit);
|
||||
}
|
||||
|
||||
static ssize_t ad2s1210_store_fexcit(struct device *dev,
|
||||
|
||||
@ -24,7 +24,7 @@ static DEFINE_MUTEX(iio_prtc_trigger_list_lock);
|
||||
|
||||
struct iio_prtc_trigger_info {
|
||||
struct rtc_device *rtc;
|
||||
int frequency;
|
||||
unsigned int frequency;
|
||||
struct rtc_task task;
|
||||
bool state;
|
||||
};
|
||||
@ -36,7 +36,7 @@ static int iio_trig_periodic_rtc_set_state(struct iio_trigger *trig, bool state)
|
||||
|
||||
if (trig_info->frequency == 0 && state)
|
||||
return -EINVAL;
|
||||
dev_dbg(&trig_info->rtc->dev, "trigger frequency is %d\n",
|
||||
dev_dbg(&trig_info->rtc->dev, "trigger frequency is %u\n",
|
||||
trig_info->frequency);
|
||||
ret = rtc_irq_set_state(trig_info->rtc, &trig_info->task, state);
|
||||
if (ret == 0)
|
||||
@ -62,10 +62,10 @@ static ssize_t iio_trig_periodic_write_freq(struct device *dev,
|
||||
{
|
||||
struct iio_trigger *trig = to_iio_trigger(dev);
|
||||
struct iio_prtc_trigger_info *trig_info = iio_trigger_get_drvdata(trig);
|
||||
int val;
|
||||
unsigned int val;
|
||||
int ret;
|
||||
|
||||
ret = kstrtoint(buf, 10, &val);
|
||||
ret = kstrtouint(buf, 10, &val);
|
||||
if (ret)
|
||||
goto error_ret;
|
||||
|
||||
@ -74,10 +74,8 @@ static ssize_t iio_trig_periodic_write_freq(struct device *dev,
|
||||
if (ret == 0 && trig_info->state && trig_info->frequency == 0)
|
||||
ret = rtc_irq_set_state(trig_info->rtc,
|
||||
&trig_info->task, 1);
|
||||
} else if (val == 0) {
|
||||
ret = rtc_irq_set_state(trig_info->rtc, &trig_info->task, 0);
|
||||
} else
|
||||
ret = -EINVAL;
|
||||
ret = rtc_irq_set_state(trig_info->rtc, &trig_info->task, 0);
|
||||
if (ret)
|
||||
goto error_ret;
|
||||
|
||||
|
||||
@ -9,22 +9,8 @@
|
||||
#ifndef _IIO_EVENTS_H_
|
||||
#define _IIO_EVENTS_H_
|
||||
|
||||
#include <linux/ioctl.h>
|
||||
#include <linux/types.h>
|
||||
#include <linux/iio/types.h>
|
||||
|
||||
/**
|
||||
* struct iio_event_data - The actual event being pushed to userspace
|
||||
* @id: event identifier
|
||||
* @timestamp: best estimate of time of event occurrence (often from
|
||||
* the interrupt handler)
|
||||
*/
|
||||
struct iio_event_data {
|
||||
__u64 id;
|
||||
__s64 timestamp;
|
||||
};
|
||||
|
||||
#define IIO_GET_EVENT_FD_IOCTL _IOR('i', 0x90, int)
|
||||
#include <uapi/linux/iio/events.h>
|
||||
|
||||
/**
|
||||
* IIO_EVENT_CODE() - create event identifier
|
||||
@ -70,18 +56,4 @@ struct iio_event_data {
|
||||
#define IIO_UNMOD_EVENT_CODE(chan_type, number, type, direction) \
|
||||
IIO_EVENT_CODE(chan_type, 0, 0, direction, type, number, 0, 0)
|
||||
|
||||
#define IIO_EVENT_CODE_EXTRACT_TYPE(mask) ((mask >> 56) & 0xFF)
|
||||
|
||||
#define IIO_EVENT_CODE_EXTRACT_DIR(mask) ((mask >> 48) & 0x7F)
|
||||
|
||||
#define IIO_EVENT_CODE_EXTRACT_CHAN_TYPE(mask) ((mask >> 32) & 0xFF)
|
||||
|
||||
/* Event code number extraction depends on which type of event we have.
|
||||
* Perhaps review this function in the future*/
|
||||
#define IIO_EVENT_CODE_EXTRACT_CHAN(mask) ((__s16)(mask & 0xFFFF))
|
||||
#define IIO_EVENT_CODE_EXTRACT_CHAN2(mask) ((__s16)(((mask) >> 16) & 0xFFFF))
|
||||
|
||||
#define IIO_EVENT_CODE_EXTRACT_MODIFIER(mask) ((mask >> 40) & 0xFF)
|
||||
#define IIO_EVENT_CODE_EXTRACT_DIFF(mask) (((mask) >> 55) & 0x1)
|
||||
|
||||
#endif
|
||||
|
||||
@ -10,76 +10,7 @@
|
||||
#ifndef _IIO_TYPES_H_
|
||||
#define _IIO_TYPES_H_
|
||||
|
||||
enum iio_chan_type {
|
||||
IIO_VOLTAGE,
|
||||
IIO_CURRENT,
|
||||
IIO_POWER,
|
||||
IIO_ACCEL,
|
||||
IIO_ANGL_VEL,
|
||||
IIO_MAGN,
|
||||
IIO_LIGHT,
|
||||
IIO_INTENSITY,
|
||||
IIO_PROXIMITY,
|
||||
IIO_TEMP,
|
||||
IIO_INCLI,
|
||||
IIO_ROT,
|
||||
IIO_ANGL,
|
||||
IIO_TIMESTAMP,
|
||||
IIO_CAPACITANCE,
|
||||
IIO_ALTVOLTAGE,
|
||||
IIO_CCT,
|
||||
IIO_PRESSURE,
|
||||
IIO_HUMIDITYRELATIVE,
|
||||
IIO_ACTIVITY,
|
||||
IIO_STEPS,
|
||||
IIO_ENERGY,
|
||||
IIO_DISTANCE,
|
||||
IIO_VELOCITY,
|
||||
};
|
||||
|
||||
enum iio_modifier {
|
||||
IIO_NO_MOD,
|
||||
IIO_MOD_X,
|
||||
IIO_MOD_Y,
|
||||
IIO_MOD_Z,
|
||||
IIO_MOD_X_AND_Y,
|
||||
IIO_MOD_X_AND_Z,
|
||||
IIO_MOD_Y_AND_Z,
|
||||
IIO_MOD_X_AND_Y_AND_Z,
|
||||
IIO_MOD_X_OR_Y,
|
||||
IIO_MOD_X_OR_Z,
|
||||
IIO_MOD_Y_OR_Z,
|
||||
IIO_MOD_X_OR_Y_OR_Z,
|
||||
IIO_MOD_LIGHT_BOTH,
|
||||
IIO_MOD_LIGHT_IR,
|
||||
IIO_MOD_ROOT_SUM_SQUARED_X_Y,
|
||||
IIO_MOD_SUM_SQUARED_X_Y_Z,
|
||||
IIO_MOD_LIGHT_CLEAR,
|
||||
IIO_MOD_LIGHT_RED,
|
||||
IIO_MOD_LIGHT_GREEN,
|
||||
IIO_MOD_LIGHT_BLUE,
|
||||
IIO_MOD_QUATERNION,
|
||||
IIO_MOD_TEMP_AMBIENT,
|
||||
IIO_MOD_TEMP_OBJECT,
|
||||
IIO_MOD_NORTH_MAGN,
|
||||
IIO_MOD_NORTH_TRUE,
|
||||
IIO_MOD_NORTH_MAGN_TILT_COMP,
|
||||
IIO_MOD_NORTH_TRUE_TILT_COMP,
|
||||
IIO_MOD_RUNNING,
|
||||
IIO_MOD_JOGGING,
|
||||
IIO_MOD_WALKING,
|
||||
IIO_MOD_STILL,
|
||||
IIO_MOD_ROOT_SUM_SQUARED_X_Y_Z,
|
||||
};
|
||||
|
||||
enum iio_event_type {
|
||||
IIO_EV_TYPE_THRESH,
|
||||
IIO_EV_TYPE_MAG,
|
||||
IIO_EV_TYPE_ROC,
|
||||
IIO_EV_TYPE_THRESH_ADAPTIVE,
|
||||
IIO_EV_TYPE_MAG_ADAPTIVE,
|
||||
IIO_EV_TYPE_CHANGE,
|
||||
};
|
||||
#include <uapi/linux/iio/types.h>
|
||||
|
||||
enum iio_event_info {
|
||||
IIO_EV_INFO_ENABLE,
|
||||
@ -88,13 +19,6 @@ enum iio_event_info {
|
||||
IIO_EV_INFO_PERIOD,
|
||||
};
|
||||
|
||||
enum iio_event_direction {
|
||||
IIO_EV_DIR_EITHER,
|
||||
IIO_EV_DIR_RISING,
|
||||
IIO_EV_DIR_FALLING,
|
||||
IIO_EV_DIR_NONE,
|
||||
};
|
||||
|
||||
#define IIO_VAL_INT 1
|
||||
#define IIO_VAL_INT_PLUS_MICRO 2
|
||||
#define IIO_VAL_INT_PLUS_NANO 3
|
||||
|
||||
@ -6,6 +6,7 @@ header-y += caif/
|
||||
header-y += dvb/
|
||||
header-y += hdlc/
|
||||
header-y += hsi/
|
||||
header-y += iio/
|
||||
header-y += isdn/
|
||||
header-y += mmc/
|
||||
header-y += nfsd/
|
||||
|
||||
3
include/uapi/linux/iio/Kbuild
Normal file
3
include/uapi/linux/iio/Kbuild
Normal file
@ -0,0 +1,3 @@
|
||||
# UAPI Header export list
|
||||
header-y += events.h
|
||||
header-y += types.h
|
||||
42
include/uapi/linux/iio/events.h
Normal file
42
include/uapi/linux/iio/events.h
Normal file
@ -0,0 +1,42 @@
|
||||
/* The industrial I/O - event passing to userspace
|
||||
*
|
||||
* Copyright (c) 2008-2011 Jonathan Cameron
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
#ifndef _UAPI_IIO_EVENTS_H_
|
||||
#define _UAPI_IIO_EVENTS_H_
|
||||
|
||||
#include <linux/ioctl.h>
|
||||
#include <linux/types.h>
|
||||
|
||||
/**
|
||||
* struct iio_event_data - The actual event being pushed to userspace
|
||||
* @id: event identifier
|
||||
* @timestamp: best estimate of time of event occurrence (often from
|
||||
* the interrupt handler)
|
||||
*/
|
||||
struct iio_event_data {
|
||||
__u64 id;
|
||||
__s64 timestamp;
|
||||
};
|
||||
|
||||
#define IIO_GET_EVENT_FD_IOCTL _IOR('i', 0x90, int)
|
||||
|
||||
#define IIO_EVENT_CODE_EXTRACT_TYPE(mask) ((mask >> 56) & 0xFF)
|
||||
|
||||
#define IIO_EVENT_CODE_EXTRACT_DIR(mask) ((mask >> 48) & 0x7F)
|
||||
|
||||
#define IIO_EVENT_CODE_EXTRACT_CHAN_TYPE(mask) ((mask >> 32) & 0xFF)
|
||||
|
||||
/* Event code number extraction depends on which type of event we have.
|
||||
* Perhaps review this function in the future*/
|
||||
#define IIO_EVENT_CODE_EXTRACT_CHAN(mask) ((__s16)(mask & 0xFFFF))
|
||||
#define IIO_EVENT_CODE_EXTRACT_CHAN2(mask) ((__s16)(((mask) >> 16) & 0xFFFF))
|
||||
|
||||
#define IIO_EVENT_CODE_EXTRACT_MODIFIER(mask) ((mask >> 40) & 0xFF)
|
||||
#define IIO_EVENT_CODE_EXTRACT_DIFF(mask) (((mask) >> 55) & 0x1)
|
||||
|
||||
#endif /* _UAPI_IIO_EVENTS_H_ */
|
||||
92
include/uapi/linux/iio/types.h
Normal file
92
include/uapi/linux/iio/types.h
Normal file
@ -0,0 +1,92 @@
|
||||
/* industrial I/O data types needed both in and out of kernel
|
||||
*
|
||||
* Copyright (c) 2008 Jonathan Cameron
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
#ifndef _UAPI_IIO_TYPES_H_
|
||||
#define _UAPI_IIO_TYPES_H_
|
||||
|
||||
enum iio_chan_type {
|
||||
IIO_VOLTAGE,
|
||||
IIO_CURRENT,
|
||||
IIO_POWER,
|
||||
IIO_ACCEL,
|
||||
IIO_ANGL_VEL,
|
||||
IIO_MAGN,
|
||||
IIO_LIGHT,
|
||||
IIO_INTENSITY,
|
||||
IIO_PROXIMITY,
|
||||
IIO_TEMP,
|
||||
IIO_INCLI,
|
||||
IIO_ROT,
|
||||
IIO_ANGL,
|
||||
IIO_TIMESTAMP,
|
||||
IIO_CAPACITANCE,
|
||||
IIO_ALTVOLTAGE,
|
||||
IIO_CCT,
|
||||
IIO_PRESSURE,
|
||||
IIO_HUMIDITYRELATIVE,
|
||||
IIO_ACTIVITY,
|
||||
IIO_STEPS,
|
||||
IIO_ENERGY,
|
||||
IIO_DISTANCE,
|
||||
IIO_VELOCITY,
|
||||
};
|
||||
|
||||
enum iio_modifier {
|
||||
IIO_NO_MOD,
|
||||
IIO_MOD_X,
|
||||
IIO_MOD_Y,
|
||||
IIO_MOD_Z,
|
||||
IIO_MOD_X_AND_Y,
|
||||
IIO_MOD_X_AND_Z,
|
||||
IIO_MOD_Y_AND_Z,
|
||||
IIO_MOD_X_AND_Y_AND_Z,
|
||||
IIO_MOD_X_OR_Y,
|
||||
IIO_MOD_X_OR_Z,
|
||||
IIO_MOD_Y_OR_Z,
|
||||
IIO_MOD_X_OR_Y_OR_Z,
|
||||
IIO_MOD_LIGHT_BOTH,
|
||||
IIO_MOD_LIGHT_IR,
|
||||
IIO_MOD_ROOT_SUM_SQUARED_X_Y,
|
||||
IIO_MOD_SUM_SQUARED_X_Y_Z,
|
||||
IIO_MOD_LIGHT_CLEAR,
|
||||
IIO_MOD_LIGHT_RED,
|
||||
IIO_MOD_LIGHT_GREEN,
|
||||
IIO_MOD_LIGHT_BLUE,
|
||||
IIO_MOD_QUATERNION,
|
||||
IIO_MOD_TEMP_AMBIENT,
|
||||
IIO_MOD_TEMP_OBJECT,
|
||||
IIO_MOD_NORTH_MAGN,
|
||||
IIO_MOD_NORTH_TRUE,
|
||||
IIO_MOD_NORTH_MAGN_TILT_COMP,
|
||||
IIO_MOD_NORTH_TRUE_TILT_COMP,
|
||||
IIO_MOD_RUNNING,
|
||||
IIO_MOD_JOGGING,
|
||||
IIO_MOD_WALKING,
|
||||
IIO_MOD_STILL,
|
||||
IIO_MOD_ROOT_SUM_SQUARED_X_Y_Z,
|
||||
};
|
||||
|
||||
enum iio_event_type {
|
||||
IIO_EV_TYPE_THRESH,
|
||||
IIO_EV_TYPE_MAG,
|
||||
IIO_EV_TYPE_ROC,
|
||||
IIO_EV_TYPE_THRESH_ADAPTIVE,
|
||||
IIO_EV_TYPE_MAG_ADAPTIVE,
|
||||
IIO_EV_TYPE_CHANGE,
|
||||
};
|
||||
|
||||
enum iio_event_direction {
|
||||
IIO_EV_DIR_EITHER,
|
||||
IIO_EV_DIR_RISING,
|
||||
IIO_EV_DIR_FALLING,
|
||||
IIO_EV_DIR_NONE,
|
||||
};
|
||||
|
||||
#endif /* _UAPI_IIO_TYPES_H_ */
|
||||
|
||||
16
tools/iio/Makefile
Normal file
16
tools/iio/Makefile
Normal file
@ -0,0 +1,16 @@
|
||||
CC = gcc
|
||||
CFLAGS = -Wall -g -D_GNU_SOURCE
|
||||
|
||||
all: iio_event_monitor lsiio generic_buffer
|
||||
|
||||
iio_event_monitor: iio_event_monitor.o iio_utils.o
|
||||
|
||||
lsiio: lsiio.o iio_utils.o
|
||||
|
||||
generic_buffer: generic_buffer.o iio_utils.o
|
||||
|
||||
%.o: %.c iio_utils.h
|
||||
|
||||
.PHONY: clean
|
||||
clean:
|
||||
rm -f *.o iio_event_monitor lsiio generic_buffer
|
||||
@ -18,9 +18,8 @@
|
||||
*
|
||||
*/
|
||||
|
||||
#define _GNU_SOURCE
|
||||
|
||||
#include <unistd.h>
|
||||
#include <stdlib.h>
|
||||
#include <dirent.h>
|
||||
#include <fcntl.h>
|
||||
#include <stdio.h>
|
||||
@ -16,9 +16,8 @@
|
||||
*
|
||||
*/
|
||||
|
||||
#define _GNU_SOURCE
|
||||
|
||||
#include <unistd.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdbool.h>
|
||||
#include <stdio.h>
|
||||
#include <errno.h>
|
||||
@ -28,6 +27,7 @@
|
||||
#include <sys/ioctl.h>
|
||||
#include "iio_utils.h"
|
||||
#include <linux/iio/events.h>
|
||||
#include <linux/iio/types.h>
|
||||
|
||||
static const char * const iio_chan_type_name_spec[] = {
|
||||
[IIO_VOLTAGE] = "voltage",
|
||||
@ -11,17 +11,12 @@
|
||||
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
#include <ctype.h>
|
||||
#include <stdio.h>
|
||||
#include <stdint.h>
|
||||
#include <dirent.h>
|
||||
#include <errno.h>
|
||||
|
||||
/* Made up value to limit allocation sizes */
|
||||
#define IIO_MAX_NAME_LENGTH 30
|
||||
|
||||
#define FORMAT_SCAN_ELEMENTS_DIR "%s/scan_elements"
|
||||
#define FORMAT_TYPE_FILE "%s_type"
|
||||
#include <ctype.h>
|
||||
#include "iio_utils.h"
|
||||
|
||||
const char *iio_dir = "/sys/bus/iio/devices/";
|
||||
|
||||
@ -30,7 +25,7 @@ const char *iio_dir = "/sys/bus/iio/devices/";
|
||||
* @full_name: the full channel name
|
||||
* @generic_name: the output generic channel name
|
||||
**/
|
||||
inline int iioutils_break_up_name(const char *full_name,
|
||||
int iioutils_break_up_name(const char *full_name,
|
||||
char **generic_name)
|
||||
{
|
||||
char *current;
|
||||
@ -56,33 +51,6 @@ inline int iioutils_break_up_name(const char *full_name,
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* struct iio_channel_info - information about a given channel
|
||||
* @name: channel name
|
||||
* @generic_name: general name for channel type
|
||||
* @scale: scale factor to be applied for conversion to si units
|
||||
* @offset: offset to be applied for conversion to si units
|
||||
* @index: the channel index in the buffer output
|
||||
* @bytes: number of bytes occupied in buffer output
|
||||
* @mask: a bit mask for the raw output
|
||||
* @is_signed: is the raw value stored signed
|
||||
* @enabled: is this channel enabled
|
||||
**/
|
||||
struct iio_channel_info {
|
||||
char *name;
|
||||
char *generic_name;
|
||||
float scale;
|
||||
float offset;
|
||||
unsigned index;
|
||||
unsigned bytes;
|
||||
unsigned bits_used;
|
||||
unsigned shift;
|
||||
uint64_t mask;
|
||||
unsigned be;
|
||||
unsigned is_signed;
|
||||
unsigned location;
|
||||
};
|
||||
|
||||
/**
|
||||
* iioutils_get_type() - find and process _type attribute data
|
||||
* @is_signed: output whether channel is signed
|
||||
@ -93,7 +61,7 @@ struct iio_channel_info {
|
||||
* @name: the channel name
|
||||
* @generic_name: the channel type name
|
||||
**/
|
||||
inline int iioutils_get_type(unsigned *is_signed,
|
||||
int iioutils_get_type(unsigned *is_signed,
|
||||
unsigned *bytes,
|
||||
unsigned *bits_used,
|
||||
unsigned *shift,
|
||||
@ -197,7 +165,7 @@ error_ret:
|
||||
return ret;
|
||||
}
|
||||
|
||||
inline int iioutils_get_param_float(float *output,
|
||||
int iioutils_get_param_float(float *output,
|
||||
const char *param_name,
|
||||
const char *device_dir,
|
||||
const char *name,
|
||||
@ -261,7 +229,7 @@ error_ret:
|
||||
*
|
||||
**/
|
||||
|
||||
inline void bsort_channel_array_by_index(struct iio_channel_info **ci_array,
|
||||
void bsort_channel_array_by_index(struct iio_channel_info **ci_array,
|
||||
int cnt)
|
||||
{
|
||||
|
||||
@ -282,7 +250,7 @@ inline void bsort_channel_array_by_index(struct iio_channel_info **ci_array,
|
||||
* @device_dir: the IIO device directory in sysfs
|
||||
* @
|
||||
**/
|
||||
inline int build_channel_array(const char *device_dir,
|
||||
int build_channel_array(const char *device_dir,
|
||||
struct iio_channel_info **ci_array,
|
||||
int *counter)
|
||||
{
|
||||
@ -445,7 +413,7 @@ error_ret:
|
||||
*
|
||||
* Typical types this is used for are device and trigger.
|
||||
**/
|
||||
inline int find_type_by_name(const char *name, const char *type)
|
||||
int find_type_by_name(const char *name, const char *type)
|
||||
{
|
||||
const struct dirent *ent;
|
||||
int number, numstrlen;
|
||||
@ -504,7 +472,7 @@ inline int find_type_by_name(const char *name, const char *type)
|
||||
return -ENODEV;
|
||||
}
|
||||
|
||||
inline int _write_sysfs_int(char *filename, char *basedir, int val, int verify)
|
||||
int _write_sysfs_int(char *filename, char *basedir, int val, int verify)
|
||||
{
|
||||
int ret = 0;
|
||||
FILE *sysfsfp;
|
||||
71
tools/iio/iio_utils.h
Normal file
71
tools/iio/iio_utils.h
Normal file
@ -0,0 +1,71 @@
|
||||
#ifndef _IIO_UTILS_H_
|
||||
#define _IIO_UTILS_H_
|
||||
|
||||
/* IIO - useful set of util functionality
|
||||
*
|
||||
* Copyright (c) 2008 Jonathan Cameron
|
||||
*
|
||||
* 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 <stdint.h>
|
||||
|
||||
/* Made up value to limit allocation sizes */
|
||||
#define IIO_MAX_NAME_LENGTH 30
|
||||
|
||||
#define FORMAT_SCAN_ELEMENTS_DIR "%s/scan_elements"
|
||||
#define FORMAT_TYPE_FILE "%s_type"
|
||||
|
||||
extern const char *iio_dir;
|
||||
|
||||
/**
|
||||
* struct iio_channel_info - information about a given channel
|
||||
* @name: channel name
|
||||
* @generic_name: general name for channel type
|
||||
* @scale: scale factor to be applied for conversion to si units
|
||||
* @offset: offset to be applied for conversion to si units
|
||||
* @index: the channel index in the buffer output
|
||||
* @bytes: number of bytes occupied in buffer output
|
||||
* @mask: a bit mask for the raw output
|
||||
* @is_signed: is the raw value stored signed
|
||||
* @enabled: is this channel enabled
|
||||
**/
|
||||
struct iio_channel_info {
|
||||
char *name;
|
||||
char *generic_name;
|
||||
float scale;
|
||||
float offset;
|
||||
unsigned index;
|
||||
unsigned bytes;
|
||||
unsigned bits_used;
|
||||
unsigned shift;
|
||||
uint64_t mask;
|
||||
unsigned be;
|
||||
unsigned is_signed;
|
||||
unsigned location;
|
||||
};
|
||||
|
||||
int iioutils_break_up_name(const char *full_name, char **generic_name);
|
||||
int iioutils_get_type(unsigned *is_signed, unsigned *bytes,
|
||||
unsigned *bits_used, unsigned *shift,
|
||||
uint64_t *mask, unsigned *be,
|
||||
const char *device_dir, const char *name,
|
||||
const char *generic_name);
|
||||
int iioutils_get_param_float(float *output, const char *param_name,
|
||||
const char *device_dir, const char *name,
|
||||
const char *generic_name);
|
||||
void bsort_channel_array_by_index(struct iio_channel_info **ci_array, int cnt);
|
||||
int build_channel_array(const char *device_dir,
|
||||
struct iio_channel_info **ci_array, int *counter);
|
||||
int find_type_by_name(const char *name, const char *type);
|
||||
int write_sysfs_int(char *filename, char *basedir, int val);
|
||||
int write_sysfs_int_and_verify(char *filename, char *basedir, int val);
|
||||
int write_sysfs_string_and_verify(char *filename, char *basedir, char *val);
|
||||
int write_sysfs_string(char *filename, char *basedir, char *val);
|
||||
int read_sysfs_posint(char *filename, char *basedir);
|
||||
int read_sysfs_float(char *filename, char *basedir, float *val);
|
||||
int read_sysfs_string(const char *filename, const char *basedir, char *str);
|
||||
|
||||
#endif /* _IIO_UTILS_H_ */
|
||||
@ -95,12 +95,7 @@ static int dump_one_trigger(const char *dev_dir_name)
|
||||
static void dump_devices(void)
|
||||
{
|
||||
const struct dirent *ent;
|
||||
int number, numstrlen;
|
||||
|
||||
FILE *nameFile;
|
||||
DIR *dp;
|
||||
char thisname[IIO_MAX_NAME_LENGTH];
|
||||
char *filename;
|
||||
|
||||
dp = opendir(iio_dir);
|
||||
if (dp == NULL) {
|
||||
Loading…
Reference in New Issue
Block a user