Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge tag 'staging-4.7-rc4' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/staging
Pull IIO and staging fixes from Greg KH:
"Here are a number of IIO and staging bugfixes for 4.7-rc4.
Nothing huge, the normal amount of iio driver fixes, and some small
staging driver bugfixes for some reported problems (2 are reverts of
patches that went into 4.7-rc1). All have been in linux-next with no
reported issues"
* tag 'staging-4.7-rc4' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/staging: (24 commits)
Revert "Staging: rtl8188eu: rtw_efuse: Use sizeof type *pointer instead of sizeof type."
Revert "Staging: drivers: rtl8188eu: use sizeof(*ptr) instead of sizeof(struct)"
staging: lustre: lnet: Don't access NULL NI on failure path
iio: hudmidity: hdc100x: fix incorrect shifting and scaling
iio: light apds9960: Add the missing dev.parent
iio: Fix error handling in iio_trigger_attach_poll_func
iio: st_sensors: Disable DRDY at init time
iio: st_sensors: Init trigger before irq request
iio: st_sensors: switch to a threaded interrupt
iio: light: bh1780: assign a static name
iio: bh1780: dereference the client properly
iio: humidity: hdc100x: fix IIO_TEMP channel reporting
iio:st_pressure: fix sampling gains (bring inline with ABI)
iio: proximity: as3935: fix buffer stack trashing
iio: proximity: as3935: remove triggered buffer processing
iio: proximity: as3935: correct IIO_CHAN_INFO_RAW output
max44000: Remove scale from proximity
iio: humidity: am2315: Remove a stray unlock
iio: humidity: hdc100x: correct humidity integration time mask
iio: pressure: bmp280: fix error message for wrong chip id
...
+237
-105
+1
-1
Documentation/ABI/testing/sysfs-bus-iio-proximity-as3935
+1
-1
Documentation/ABI/testing/sysfs-bus-iio-proximity-as3935
+1
-1
drivers/iio/accel/st_accel_buffer.c
+1
-1
drivers/iio/accel/st_accel_buffer.c
+1
drivers/iio/accel/st_accel_core.c
+1
drivers/iio/accel/st_accel_core.c
+7
-18
drivers/iio/common/st_sensors/st_sensors_buffer.c
+7
-18
drivers/iio/common/st_sensors/st_sensors_buffer.c
···
57
57
struct iio_poll_func *pf = p;
58
58
struct iio_dev *indio_dev = pf->indio_dev;
59
59
struct st_sensor_data *sdata = iio_priv(indio_dev);
60
+
s64 timestamp;
60
61
61
-
/* If we have a status register, check if this IRQ came from us */
62
-
if (sdata->sensor_settings->drdy_irq.addr_stat_drdy) {
63
-
u8 status;
64
-
65
-
len = sdata->tf->read_byte(&sdata->tb, sdata->dev,
66
-
sdata->sensor_settings->drdy_irq.addr_stat_drdy,
67
-
&status);
68
-
if (len < 0)
69
-
dev_err(sdata->dev, "could not read channel status\n");
70
-
71
-
/*
72
-
* If this was not caused by any channels on this sensor,
73
-
* return IRQ_NONE
74
-
*/
75
-
if (!(status & (u8)indio_dev->active_scan_mask[0]))
76
-
return IRQ_NONE;
77
-
}
62
+
/* If we do timetamping here, do it before reading the values */
63
+
if (sdata->hw_irq_trigger)
64
+
timestamp = sdata->hw_timestamp;
65
+
else
66
+
timestamp = iio_get_time_ns();
78
67
79
68
len = st_sensors_get_buffer_element(indio_dev, sdata->buffer_data);
80
69
if (len < 0)
81
70
goto st_sensors_get_buffer_element_error;
82
71
83
72
iio_push_to_buffers_with_timestamp(indio_dev, sdata->buffer_data,
84
-
pf->timestamp);
73
+
timestamp);
85
74
86
75
st_sensors_get_buffer_element_error:
87
76
iio_trigger_notify_done(indio_dev->trig);
+8
drivers/iio/common/st_sensors/st_sensors_core.c
+8
drivers/iio/common/st_sensors/st_sensors_core.c
···
363
363
if (err < 0)
364
364
return err;
365
365
366
+
/* Disable DRDY, this might be still be enabled after reboot. */
367
+
err = st_sensors_set_dataready_irq(indio_dev, false);
368
+
if (err < 0)
369
+
return err;
370
+
366
371
if (sdata->current_fullscale) {
367
372
err = st_sensors_set_fullscale(indio_dev,
368
373
sdata->current_fullscale->num);
···
428
423
drdy_mask = sdata->sensor_settings->drdy_irq.mask_int1;
429
424
else
430
425
drdy_mask = sdata->sensor_settings->drdy_irq.mask_int2;
426
+
427
+
/* Flag to the poll function that the hardware trigger is in use */
428
+
sdata->hw_irq_trigger = enable;
431
429
432
430
/* Enable/Disable the interrupt generator for data ready. */
433
431
err = st_sensors_write_data_with_mask(indio_dev,
+89
-7
drivers/iio/common/st_sensors/st_sensors_trigger.c
+89
-7
drivers/iio/common/st_sensors/st_sensors_trigger.c
···
17
17
#include <linux/iio/common/st_sensors.h>
18
18
#include "st_sensors_core.h"
19
19
20
+
/**
21
+
* st_sensors_irq_handler() - top half of the IRQ-based triggers
22
+
* @irq: irq number
23
+
* @p: private handler data
24
+
*/
25
+
irqreturn_t st_sensors_irq_handler(int irq, void *p)
26
+
{
27
+
struct iio_trigger *trig = p;
28
+
struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig);
29
+
struct st_sensor_data *sdata = iio_priv(indio_dev);
30
+
31
+
/* Get the time stamp as close in time as possible */
32
+
sdata->hw_timestamp = iio_get_time_ns();
33
+
return IRQ_WAKE_THREAD;
34
+
}
35
+
36
+
/**
37
+
* st_sensors_irq_thread() - bottom half of the IRQ-based triggers
38
+
* @irq: irq number
39
+
* @p: private handler data
40
+
*/
41
+
irqreturn_t st_sensors_irq_thread(int irq, void *p)
42
+
{
43
+
struct iio_trigger *trig = p;
44
+
struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig);
45
+
struct st_sensor_data *sdata = iio_priv(indio_dev);
46
+
int ret;
47
+
48
+
/*
49
+
* If this trigger is backed by a hardware interrupt and we have a
50
+
* status register, check if this IRQ came from us
51
+
*/
52
+
if (sdata->sensor_settings->drdy_irq.addr_stat_drdy) {
53
+
u8 status;
54
+
55
+
ret = sdata->tf->read_byte(&sdata->tb, sdata->dev,
56
+
sdata->sensor_settings->drdy_irq.addr_stat_drdy,
57
+
&status);
58
+
if (ret < 0) {
59
+
dev_err(sdata->dev, "could not read channel status\n");
60
+
goto out_poll;
61
+
}
62
+
/*
63
+
* the lower bits of .active_scan_mask[0] is directly mapped
64
+
* to the channels on the sensor: either bit 0 for
65
+
* one-dimensional sensors, or e.g. x,y,z for accelerometers,
66
+
* gyroscopes or magnetometers. No sensor use more than 3
67
+
* channels, so cut the other status bits here.
68
+
*/
69
+
status &= 0x07;
70
+
71
+
/*
72
+
* If this was not caused by any channels on this sensor,
73
+
* return IRQ_NONE
74
+
*/
75
+
if (!indio_dev->active_scan_mask)
76
+
return IRQ_NONE;
77
+
if (!(status & (u8)indio_dev->active_scan_mask[0]))
78
+
return IRQ_NONE;
79
+
}
80
+
81
+
out_poll:
82
+
/* It's our IRQ: proceed to handle the register polling */
83
+
iio_trigger_poll_chained(p);
84
+
return IRQ_HANDLED;
85
+
}
86
+
20
87
int st_sensors_allocate_trigger(struct iio_dev *indio_dev,
21
88
const struct iio_trigger_ops *trigger_ops)
22
89
{
···
96
29
dev_err(&indio_dev->dev, "failed to allocate iio trigger.\n");
97
30
return -ENOMEM;
98
31
}
32
+
33
+
iio_trigger_set_drvdata(sdata->trig, indio_dev);
34
+
sdata->trig->ops = trigger_ops;
35
+
sdata->trig->dev.parent = sdata->dev;
99
36
100
37
irq = sdata->get_irq_data_ready(indio_dev);
101
38
irq_trig = irqd_get_trigger_type(irq_get_irq_data(irq));
···
148
77
sdata->sensor_settings->drdy_irq.addr_stat_drdy)
149
78
irq_trig |= IRQF_SHARED;
150
79
151
-
err = request_threaded_irq(irq,
152
-
iio_trigger_generic_data_rdy_poll,
153
-
NULL,
80
+
/* Let's create an interrupt thread masking the hard IRQ here */
81
+
irq_trig |= IRQF_ONESHOT;
82
+
83
+
err = request_threaded_irq(sdata->get_irq_data_ready(indio_dev),
84
+
st_sensors_irq_handler,
85
+
st_sensors_irq_thread,
154
86
irq_trig,
155
87
sdata->trig->name,
156
88
sdata->trig);
···
161
87
dev_err(&indio_dev->dev, "failed to request trigger IRQ.\n");
162
88
goto iio_trigger_free;
163
89
}
164
-
165
-
iio_trigger_set_drvdata(sdata->trig, indio_dev);
166
-
sdata->trig->ops = trigger_ops;
167
-
sdata->trig->dev.parent = sdata->dev;
168
90
169
91
err = iio_trigger_register(sdata->trig);
170
92
if (err < 0) {
···
188
118
iio_trigger_free(sdata->trig);
189
119
}
190
120
EXPORT_SYMBOL(st_sensors_deallocate_trigger);
121
+
122
+
int st_sensors_validate_device(struct iio_trigger *trig,
123
+
struct iio_dev *indio_dev)
124
+
{
125
+
struct iio_dev *indio = iio_trigger_get_drvdata(trig);
126
+
127
+
if (indio != indio_dev)
128
+
return -EINVAL;
129
+
130
+
return 0;
131
+
}
132
+
EXPORT_SYMBOL(st_sensors_validate_device);
191
133
192
134
MODULE_AUTHOR("Denis Ciocca <denis.ciocca@st.com>");
193
135
MODULE_DESCRIPTION("STMicroelectronics ST-sensors trigger");
+1
-1
drivers/iio/dac/ad5592r-base.c
+1
-1
drivers/iio/dac/ad5592r-base.c
···
525
525
526
526
device_for_each_child_node(st->dev, child) {
527
527
ret = fwnode_property_read_u32(child, "reg", ®);
528
-
if (ret || reg > ARRAY_SIZE(st->channel_modes))
528
+
if (ret || reg >= ARRAY_SIZE(st->channel_modes))
529
529
continue;
530
530
531
531
ret = fwnode_property_read_u32(child, "adi,mode", &tmp);
+1
-1
drivers/iio/gyro/st_gyro_buffer.c
+1
-1
drivers/iio/gyro/st_gyro_buffer.c
+1
drivers/iio/gyro/st_gyro_core.c
+1
drivers/iio/gyro/st_gyro_core.c
+1
-3
drivers/iio/humidity/am2315.c
+1
-3
drivers/iio/humidity/am2315.c
···
165
165
struct am2315_sensor_data sensor_data;
166
166
167
167
ret = am2315_read_data(data, &sensor_data);
168
-
if (ret < 0) {
169
-
mutex_unlock(&data->lock);
168
+
if (ret < 0)
170
169
goto err;
171
-
}
172
170
173
171
mutex_lock(&data->lock);
174
172
if (*(indio_dev->active_scan_mask) == AM2315_ALL_CHANNEL_MASK) {
+10
-10
drivers/iio/humidity/hdc100x.c
+10
-10
drivers/iio/humidity/hdc100x.c
···
55
55
},
56
56
{ /* IIO_HUMIDITYRELATIVE channel */
57
57
.shift = 8,
58
-
.mask = 2,
58
+
.mask = 3,
59
59
},
60
60
};
61
61
···
164
164
dev_err(&client->dev, "cannot read high byte measurement");
165
165
return ret;
166
166
}
167
-
val = ret << 6;
167
+
val = ret << 8;
168
168
169
169
ret = i2c_smbus_read_byte(client);
170
170
if (ret < 0) {
171
171
dev_err(&client->dev, "cannot read low byte measurement");
172
172
return ret;
173
173
}
174
-
val |= ret >> 2;
174
+
val |= ret;
175
175
176
176
return val;
177
177
}
···
211
211
return IIO_VAL_INT_PLUS_MICRO;
212
212
case IIO_CHAN_INFO_SCALE:
213
213
if (chan->type == IIO_TEMP) {
214
-
*val = 165;
215
-
*val2 = 65536 >> 2;
214
+
*val = 165000;
215
+
*val2 = 65536;
216
216
return IIO_VAL_FRACTIONAL;
217
217
} else {
218
-
*val = 0;
219
-
*val2 = 10000;
220
-
return IIO_VAL_INT_PLUS_MICRO;
218
+
*val = 100;
219
+
*val2 = 65536;
220
+
return IIO_VAL_FRACTIONAL;
221
221
}
222
222
break;
223
223
case IIO_CHAN_INFO_OFFSET:
224
-
*val = -3971;
225
-
*val2 = 879096;
224
+
*val = -15887;
225
+
*val2 = 515151;
226
226
return IIO_VAL_INT_PLUS_MICRO;
227
227
default:
228
228
return -EINVAL;
+8
-8
drivers/iio/imu/bmi160/bmi160_core.c
+8
-8
drivers/iio/imu/bmi160/bmi160_core.c
···
209
209
};
210
210
211
211
static const struct bmi160_odr bmi160_accel_odr[] = {
212
-
{0x01, 0, 78125},
213
-
{0x02, 1, 5625},
214
-
{0x03, 3, 125},
215
-
{0x04, 6, 25},
216
-
{0x05, 12, 5},
212
+
{0x01, 0, 781250},
213
+
{0x02, 1, 562500},
214
+
{0x03, 3, 125000},
215
+
{0x04, 6, 250000},
216
+
{0x05, 12, 500000},
217
217
{0x06, 25, 0},
218
218
{0x07, 50, 0},
219
219
{0x08, 100, 0},
···
229
229
{0x08, 100, 0},
230
230
{0x09, 200, 0},
231
231
{0x0A, 400, 0},
232
-
{0x0B, 8000, 0},
232
+
{0x0B, 800, 0},
233
233
{0x0C, 1600, 0},
234
234
{0x0D, 3200, 0},
235
235
};
···
364
364
365
365
return regmap_update_bits(data->regmap,
366
366
bmi160_regs[t].config,
367
-
bmi160_odr_table[t].tbl[i].bits,
368
-
bmi160_regs[t].config_odr_mask);
367
+
bmi160_regs[t].config_odr_mask,
368
+
bmi160_odr_table[t].tbl[i].bits);
369
369
}
370
370
371
371
static int bmi160_get_odr(struct bmi160_data *data, enum bmi160_sensor_type t,
+18
-5
drivers/iio/industrialio-trigger.c
+18
-5
drivers/iio/industrialio-trigger.c
···
210
210
211
211
/* Prevent the module from being removed whilst attached to a trigger */
212
212
__module_get(pf->indio_dev->info->driver_module);
213
+
214
+
/* Get irq number */
213
215
pf->irq = iio_trigger_get_irq(trig);
216
+
if (pf->irq < 0)
217
+
goto out_put_module;
218
+
219
+
/* Request irq */
214
220
ret = request_threaded_irq(pf->irq, pf->h, pf->thread,
215
221
pf->type, pf->name,
216
222
pf);
217
-
if (ret < 0) {
218
-
module_put(pf->indio_dev->info->driver_module);
219
-
return ret;
220
-
}
223
+
if (ret < 0)
224
+
goto out_put_irq;
221
225
226
+
/* Enable trigger in driver */
222
227
if (trig->ops && trig->ops->set_trigger_state && notinuse) {
223
228
ret = trig->ops->set_trigger_state(trig, true);
224
229
if (ret < 0)
225
-
module_put(pf->indio_dev->info->driver_module);
230
+
goto out_free_irq;
226
231
}
227
232
233
+
return ret;
234
+
235
+
out_free_irq:
236
+
free_irq(pf->irq, pf);
237
+
out_put_irq:
238
+
iio_trigger_put_irq(trig, pf->irq);
239
+
out_put_module:
240
+
module_put(pf->indio_dev->info->driver_module);
228
241
return ret;
229
242
}
230
243
+1
drivers/iio/light/apds9960.c
+1
drivers/iio/light/apds9960.c
+6
-4
drivers/iio/light/bh1780.c
+6
-4
drivers/iio/light/bh1780.c
···
84
84
int ret;
85
85
86
86
if (!readval)
87
-
bh1780_write(bh1780, (u8)reg, (u8)writeval);
87
+
return bh1780_write(bh1780, (u8)reg, (u8)writeval);
88
88
89
89
ret = bh1780_read(bh1780, (u8)reg);
90
90
if (ret < 0)
···
187
187
188
188
indio_dev->dev.parent = &client->dev;
189
189
indio_dev->info = &bh1780_info;
190
-
indio_dev->name = id->name;
190
+
indio_dev->name = "bh1780";
191
191
indio_dev->channels = bh1780_channels;
192
192
indio_dev->num_channels = ARRAY_SIZE(bh1780_channels);
193
193
indio_dev->modes = INDIO_DIRECT_MODE;
···
226
226
static int bh1780_runtime_suspend(struct device *dev)
227
227
{
228
228
struct i2c_client *client = to_i2c_client(dev);
229
-
struct bh1780_data *bh1780 = i2c_get_clientdata(client);
229
+
struct iio_dev *indio_dev = i2c_get_clientdata(client);
230
+
struct bh1780_data *bh1780 = iio_priv(indio_dev);
230
231
int ret;
231
232
232
233
ret = bh1780_write(bh1780, BH1780_REG_CONTROL, BH1780_POFF);
···
242
241
static int bh1780_runtime_resume(struct device *dev)
243
242
{
244
243
struct i2c_client *client = to_i2c_client(dev);
245
-
struct bh1780_data *bh1780 = i2c_get_clientdata(client);
244
+
struct iio_dev *indio_dev = i2c_get_clientdata(client);
245
+
struct bh1780_data *bh1780 = iio_priv(indio_dev);
246
246
int ret;
247
247
248
248
ret = bh1780_write(bh1780, BH1780_REG_CONTROL, BH1780_PON);
-1
drivers/iio/light/max44000.c
-1
drivers/iio/light/max44000.c
+1
-1
drivers/iio/magnetometer/st_magn_buffer.c
+1
-1
drivers/iio/magnetometer/st_magn_buffer.c
+1
drivers/iio/magnetometer/st_magn_core.c
+1
drivers/iio/magnetometer/st_magn_core.c
+2
-2
drivers/iio/pressure/bmp280.c
+2
-2
drivers/iio/pressure/bmp280.c
···
879
879
if (ret < 0)
880
880
return ret;
881
881
if (chip_id != id->driver_data) {
882
-
dev_err(&client->dev, "bad chip id. expected %x got %x\n",
883
-
BMP280_CHIP_ID, chip_id);
882
+
dev_err(&client->dev, "bad chip id. expected %lx got %x\n",
883
+
id->driver_data, chip_id);
884
884
return -EINVAL;
885
885
}
886
886
+1
-1
drivers/iio/pressure/st_pressure_buffer.c
+1
-1
drivers/iio/pressure/st_pressure_buffer.c
+51
-30
drivers/iio/pressure/st_pressure_core.c
+51
-30
drivers/iio/pressure/st_pressure_core.c
···
28
28
#include <linux/iio/common/st_sensors.h>
29
29
#include "st_pressure.h"
30
30
31
+
#define MCELSIUS_PER_CELSIUS 1000
32
+
33
+
/* Default pressure sensitivity */
31
34
#define ST_PRESS_LSB_PER_MBAR 4096UL
32
35
#define ST_PRESS_KPASCAL_NANO_SCALE (100000000UL / \
33
36
ST_PRESS_LSB_PER_MBAR)
37
+
38
+
/* Default temperature sensitivity */
34
39
#define ST_PRESS_LSB_PER_CELSIUS 480UL
35
-
#define ST_PRESS_CELSIUS_NANO_SCALE (1000000000UL / \
36
-
ST_PRESS_LSB_PER_CELSIUS)
40
+
#define ST_PRESS_MILLI_CELSIUS_OFFSET 42500UL
41
+
37
42
#define ST_PRESS_NUMBER_DATA_CHANNELS 1
38
43
39
44
/* FULLSCALE */
45
+
#define ST_PRESS_FS_AVL_1100MB 1100
40
46
#define ST_PRESS_FS_AVL_1260MB 1260
41
47
42
48
#define ST_PRESS_1_OUT_XL_ADDR 0x28
···
60
54
#define ST_PRESS_LPS331AP_PW_MASK 0x80
61
55
#define ST_PRESS_LPS331AP_FS_ADDR 0x23
62
56
#define ST_PRESS_LPS331AP_FS_MASK 0x30
63
-
#define ST_PRESS_LPS331AP_FS_AVL_1260_VAL 0x00
64
-
#define ST_PRESS_LPS331AP_FS_AVL_1260_GAIN ST_PRESS_KPASCAL_NANO_SCALE
65
-
#define ST_PRESS_LPS331AP_FS_AVL_TEMP_GAIN ST_PRESS_CELSIUS_NANO_SCALE
66
57
#define ST_PRESS_LPS331AP_BDU_ADDR 0x20
67
58
#define ST_PRESS_LPS331AP_BDU_MASK 0x04
68
59
#define ST_PRESS_LPS331AP_DRDY_IRQ_ADDR 0x22
···
70
67
#define ST_PRESS_LPS331AP_OD_IRQ_ADDR 0x22
71
68
#define ST_PRESS_LPS331AP_OD_IRQ_MASK 0x40
72
69
#define ST_PRESS_LPS331AP_MULTIREAD_BIT true
73
-
#define ST_PRESS_LPS331AP_TEMP_OFFSET 42500
74
70
75
71
/* CUSTOM VALUES FOR LPS001WP SENSOR */
72
+
73
+
/* LPS001WP pressure resolution */
74
+
#define ST_PRESS_LPS001WP_LSB_PER_MBAR 16UL
75
+
/* LPS001WP temperature resolution */
76
+
#define ST_PRESS_LPS001WP_LSB_PER_CELSIUS 64UL
77
+
76
78
#define ST_PRESS_LPS001WP_WAI_EXP 0xba
77
79
#define ST_PRESS_LPS001WP_ODR_ADDR 0x20
78
80
#define ST_PRESS_LPS001WP_ODR_MASK 0x30
···
86
78
#define ST_PRESS_LPS001WP_ODR_AVL_13HZ_VAL 0x03
87
79
#define ST_PRESS_LPS001WP_PW_ADDR 0x20
88
80
#define ST_PRESS_LPS001WP_PW_MASK 0x40
81
+
#define ST_PRESS_LPS001WP_FS_AVL_PRESS_GAIN \
82
+
(100000000UL / ST_PRESS_LPS001WP_LSB_PER_MBAR)
89
83
#define ST_PRESS_LPS001WP_BDU_ADDR 0x20
90
84
#define ST_PRESS_LPS001WP_BDU_MASK 0x04
91
85
#define ST_PRESS_LPS001WP_MULTIREAD_BIT true
···
104
94
#define ST_PRESS_LPS25H_ODR_AVL_25HZ_VAL 0x04
105
95
#define ST_PRESS_LPS25H_PW_ADDR 0x20
106
96
#define ST_PRESS_LPS25H_PW_MASK 0x80
107
-
#define ST_PRESS_LPS25H_FS_ADDR 0x00
108
-
#define ST_PRESS_LPS25H_FS_MASK 0x00
109
-
#define ST_PRESS_LPS25H_FS_AVL_1260_VAL 0x00
110
-
#define ST_PRESS_LPS25H_FS_AVL_1260_GAIN ST_PRESS_KPASCAL_NANO_SCALE
111
-
#define ST_PRESS_LPS25H_FS_AVL_TEMP_GAIN ST_PRESS_CELSIUS_NANO_SCALE
112
97
#define ST_PRESS_LPS25H_BDU_ADDR 0x20
113
98
#define ST_PRESS_LPS25H_BDU_MASK 0x04
114
99
#define ST_PRESS_LPS25H_DRDY_IRQ_ADDR 0x23
···
114
109
#define ST_PRESS_LPS25H_OD_IRQ_ADDR 0x22
115
110
#define ST_PRESS_LPS25H_OD_IRQ_MASK 0x40
116
111
#define ST_PRESS_LPS25H_MULTIREAD_BIT true
117
-
#define ST_PRESS_LPS25H_TEMP_OFFSET 42500
118
112
#define ST_PRESS_LPS25H_OUT_XL_ADDR 0x28
119
113
#define ST_TEMP_LPS25H_OUT_L_ADDR 0x2b
120
114
···
165
161
.storagebits = 16,
166
162
.endianness = IIO_LE,
167
163
},
168
-
.info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
164
+
.info_mask_separate =
165
+
BIT(IIO_CHAN_INFO_RAW) |
166
+
BIT(IIO_CHAN_INFO_SCALE),
169
167
.modified = 0,
170
168
},
171
169
{
···
183
177
},
184
178
.info_mask_separate =
185
179
BIT(IIO_CHAN_INFO_RAW) |
186
-
BIT(IIO_CHAN_INFO_OFFSET),
180
+
BIT(IIO_CHAN_INFO_SCALE),
187
181
.modified = 0,
188
182
},
189
183
IIO_CHAN_SOFT_TIMESTAMP(1)
···
218
212
.addr = ST_PRESS_LPS331AP_FS_ADDR,
219
213
.mask = ST_PRESS_LPS331AP_FS_MASK,
220
214
.fs_avl = {
215
+
/*
216
+
* Pressure and temperature sensitivity values
217
+
* as defined in table 3 of LPS331AP datasheet.
218
+
*/
221
219
[0] = {
222
220
.num = ST_PRESS_FS_AVL_1260MB,
223
-
.value = ST_PRESS_LPS331AP_FS_AVL_1260_VAL,
224
-
.gain = ST_PRESS_LPS331AP_FS_AVL_1260_GAIN,
225
-
.gain2 = ST_PRESS_LPS331AP_FS_AVL_TEMP_GAIN,
221
+
.gain = ST_PRESS_KPASCAL_NANO_SCALE,
222
+
.gain2 = ST_PRESS_LSB_PER_CELSIUS,
226
223
},
227
224
},
228
225
},
···
270
261
.value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE,
271
262
},
272
263
.fs = {
273
-
.addr = 0,
264
+
.fs_avl = {
265
+
/*
266
+
* Pressure and temperature resolution values
267
+
* as defined in table 3 of LPS001WP datasheet.
268
+
*/
269
+
[0] = {
270
+
.num = ST_PRESS_FS_AVL_1100MB,
271
+
.gain = ST_PRESS_LPS001WP_FS_AVL_PRESS_GAIN,
272
+
.gain2 = ST_PRESS_LPS001WP_LSB_PER_CELSIUS,
273
+
},
274
+
},
274
275
},
275
276
.bdu = {
276
277
.addr = ST_PRESS_LPS001WP_BDU_ADDR,
···
317
298
.value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE,
318
299
},
319
300
.fs = {
320
-
.addr = ST_PRESS_LPS25H_FS_ADDR,
321
-
.mask = ST_PRESS_LPS25H_FS_MASK,
322
301
.fs_avl = {
302
+
/*
303
+
* Pressure and temperature sensitivity values
304
+
* as defined in table 3 of LPS25H datasheet.
305
+
*/
323
306
[0] = {
324
307
.num = ST_PRESS_FS_AVL_1260MB,
325
-
.value = ST_PRESS_LPS25H_FS_AVL_1260_VAL,
326
-
.gain = ST_PRESS_LPS25H_FS_AVL_1260_GAIN,
327
-
.gain2 = ST_PRESS_LPS25H_FS_AVL_TEMP_GAIN,
308
+
.gain = ST_PRESS_KPASCAL_NANO_SCALE,
309
+
.gain2 = ST_PRESS_LSB_PER_CELSIUS,
328
310
},
329
311
},
330
312
},
···
384
364
385
365
return IIO_VAL_INT;
386
366
case IIO_CHAN_INFO_SCALE:
387
-
*val = 0;
388
-
389
367
switch (ch->type) {
390
368
case IIO_PRESSURE:
369
+
*val = 0;
391
370
*val2 = press_data->current_fullscale->gain;
392
-
break;
371
+
return IIO_VAL_INT_PLUS_NANO;
393
372
case IIO_TEMP:
373
+
*val = MCELSIUS_PER_CELSIUS;
394
374
*val2 = press_data->current_fullscale->gain2;
395
-
break;
375
+
return IIO_VAL_FRACTIONAL;
396
376
default:
397
377
err = -EINVAL;
398
378
goto read_error;
399
379
}
400
380
401
-
return IIO_VAL_INT_PLUS_NANO;
402
381
case IIO_CHAN_INFO_OFFSET:
403
382
switch (ch->type) {
404
383
case IIO_TEMP:
405
-
*val = 425;
406
-
*val2 = 10;
384
+
*val = ST_PRESS_MILLI_CELSIUS_OFFSET *
385
+
press_data->current_fullscale->gain2;
386
+
*val2 = MCELSIUS_PER_CELSIUS;
407
387
break;
408
388
default:
409
389
err = -EINVAL;
···
445
425
static const struct iio_trigger_ops st_press_trigger_ops = {
446
426
.owner = THIS_MODULE,
447
427
.set_trigger_state = ST_PRESS_TRIGGER_SET_STATE,
428
+
.validate_device = st_sensors_validate_device,
448
429
};
449
430
#define ST_PRESS_TRIGGER_OPS (&st_press_trigger_ops)
450
431
#else
+12
-5
drivers/iio/proximity/as3935.c
+12
-5
drivers/iio/proximity/as3935.c
···
64
64
struct delayed_work work;
65
65
66
66
u32 tune_cap;
67
+
u8 buffer[16]; /* 8-bit data + 56-bit padding + 64-bit timestamp */
67
68
u8 buf[2] ____cacheline_aligned;
68
69
};
69
70
···
73
72
.type = IIO_PROXIMITY,
74
73
.info_mask_separate =
75
74
BIT(IIO_CHAN_INFO_RAW) |
76
-
BIT(IIO_CHAN_INFO_PROCESSED),
75
+
BIT(IIO_CHAN_INFO_PROCESSED) |
76
+
BIT(IIO_CHAN_INFO_SCALE),
77
77
.scan_index = 0,
78
78
.scan_type = {
79
79
.sign = 'u',
···
183
181
/* storm out of range */
184
182
if (*val == AS3935_DATA_MASK)
185
183
return -EINVAL;
186
-
*val *= 1000;
184
+
185
+
if (m == IIO_CHAN_INFO_PROCESSED)
186
+
*val *= 1000;
187
+
break;
188
+
case IIO_CHAN_INFO_SCALE:
189
+
*val = 1000;
187
190
break;
188
191
default:
189
192
return -EINVAL;
···
213
206
ret = as3935_read(st, AS3935_DATA, &val);
214
207
if (ret)
215
208
goto err_read;
216
-
val &= AS3935_DATA_MASK;
217
-
val *= 1000;
218
209
219
-
iio_push_to_buffers_with_timestamp(indio_dev, &val, pf->timestamp);
210
+
st->buffer[0] = val & AS3935_DATA_MASK;
211
+
iio_push_to_buffers_with_timestamp(indio_dev, &st->buffer,
212
+
pf->timestamp);
220
213
err_read:
221
214
iio_trigger_notify_done(indio_dev->trig);
222
215
+4
-3
drivers/staging/lustre/lnet/klnds/o2iblnd/o2iblnd_cb.c
+4
-3
drivers/staging/lustre/lnet/klnds/o2iblnd/o2iblnd_cb.c
···
2521
2521
return 0;
2522
2522
2523
2523
failed:
2524
-
if (ni)
2524
+
if (ni) {
2525
2525
lnet_ni_decref(ni);
2526
+
rej.ibr_cp.ibcp_queue_depth = kiblnd_msg_queue_size(version, ni);
2527
+
rej.ibr_cp.ibcp_max_frags = kiblnd_rdma_frags(version, ni);
2528
+
}
2526
2529
2527
2530
rej.ibr_version = version;
2528
-
rej.ibr_cp.ibcp_queue_depth = kiblnd_msg_queue_size(version, ni);
2529
-
rej.ibr_cp.ibcp_max_frags = kiblnd_rdma_frags(version, ni);
2530
2531
kiblnd_reject(cmid, &rej);
2531
2532
2532
2533
return -ECONNREFUSED;
+1
-1
drivers/staging/rtl8188eu/core/rtw_efuse.c
+1
-1
drivers/staging/rtl8188eu/core/rtw_efuse.c
···
102
102
if (!efuseTbl)
103
103
return;
104
104
105
-
eFuseWord = (u16 **)rtw_malloc2d(EFUSE_MAX_SECTION_88E, EFUSE_MAX_WORD_UNIT, sizeof(*eFuseWord));
105
+
eFuseWord = (u16 **)rtw_malloc2d(EFUSE_MAX_SECTION_88E, EFUSE_MAX_WORD_UNIT, sizeof(u16));
106
106
if (!eFuseWord) {
107
107
DBG_88E("%s: alloc eFuseWord fail!\n", __func__);
108
108
goto eFuseWord_failed;
+2
-1
drivers/staging/rtl8188eu/hal/usb_halinit.c
+2
-1
drivers/staging/rtl8188eu/hal/usb_halinit.c
···
2072
2072
{
2073
2073
struct hal_ops *halfunc = &adapt->HalFunc;
2074
2074
2075
-
adapt->HalData = kzalloc(sizeof(*adapt->HalData), GFP_KERNEL);
2075
+
2076
+
adapt->HalData = kzalloc(sizeof(struct hal_data_8188e), GFP_KERNEL);
2076
2077
if (!adapt->HalData)
2077
2078
DBG_88E("cant not alloc memory for HAL DATA\n");
2078
2079
+8
-1
include/linux/iio/common/st_sensors.h
+8
-1
include/linux/iio/common/st_sensors.h
···
223
223
* @get_irq_data_ready: Function to get the IRQ used for data ready signal.
224
224
* @tf: Transfer function structure used by I/O operations.
225
225
* @tb: Transfer buffers and mutex used by I/O operations.
226
+
* @hw_irq_trigger: if we're using the hardware interrupt on the sensor.
227
+
* @hw_timestamp: Latest timestamp from the interrupt handler, when in use.
226
228
*/
227
229
struct st_sensor_data {
228
230
struct device *dev;
···
249
247
250
248
const struct st_sensor_transfer_function *tf;
251
249
struct st_sensor_transfer_buffer tb;
250
+
251
+
bool hw_irq_trigger;
252
+
s64 hw_timestamp;
252
253
};
253
254
254
255
#ifdef CONFIG_IIO_BUFFER
···
265
260
const struct iio_trigger_ops *trigger_ops);
266
261
267
262
void st_sensors_deallocate_trigger(struct iio_dev *indio_dev);
268
-
263
+
int st_sensors_validate_device(struct iio_trigger *trig,
264
+
struct iio_dev *indio_dev);
269
265
#else
270
266
static inline int st_sensors_allocate_trigger(struct iio_dev *indio_dev,
271
267
const struct iio_trigger_ops *trigger_ops)
···
277
271
{
278
272
return;
279
273
}
274
+
#define st_sensors_validate_device NULL
280
275
#endif
281
276
282
277
int st_sensors_init_sensor(struct iio_dev *indio_dev,