+2 -4

Documentation/ABI/testing/sysfs-bus-iio

reviewed

··· 1234 1234 object is near the sensor, usually be observing 1235 1235 reflectivity of infrared or ultrasound emitted. 1236 1236 Often these sensors are unit less and as such conversion 1237 1237 - to SI units is not possible. Where it is, the units should 1238 1238 - be meters. If such a conversion is not possible, the reported 1239 1239 - values should behave in the same way as a distance, i.e. lower 1240 1240 - values indicate something is closer to the sensor. 1237 1237 + to SI units is not possible. Higher proximity measurements 1238 1238 + indicate closer objects, and vice versa. 1241 1239 1242 1240 What: /sys/.../iio:deviceX/in_illuminance_input 1243 1241 What: /sys/.../iio:deviceX/in_illuminance_raw

+1 -1

drivers/iio/accel/bmc150-accel.c

reviewed

··· 1464 1464 { 1465 1465 int i; 1466 1466 1467 1467 - for (i = from; i >= 0; i++) { 1467 1467 + for (i = from; i >= 0; i--) { 1468 1468 if (data->triggers[i].indio_trig) { 1469 1469 iio_trigger_unregister(data->triggers[i].indio_trig); 1470 1470 data->triggers[i].indio_trig = NULL;

+1 -2

drivers/iio/adc/Kconfig

reviewed

··· 153 153 154 154 config CC10001_ADC 155 155 tristate "Cosmic Circuits 10001 ADC driver" 156 156 - depends on HAVE_CLK || REGULATOR 157 157 - depends on HAS_IOMEM 156 156 + depends on HAS_IOMEM && HAVE_CLK && REGULATOR 158 157 select IIO_BUFFER 159 158 select IIO_TRIGGERED_BUFFER 160 159 help

+4 -4

drivers/iio/adc/at91_adc.c

reviewed

··· 182 182 u8 ts_pen_detect_sensitivity; 183 183 184 184 /* startup time calculate function */ 185 185 - u32 (*calc_startup_ticks)(u8 startup_time, u32 adc_clk_khz); 185 185 + u32 (*calc_startup_ticks)(u32 startup_time, u32 adc_clk_khz); 186 186 187 187 u8 num_channels; 188 188 struct at91_adc_reg_desc registers; ··· 201 201 u8 num_channels; 202 202 void __iomem *reg_base; 203 203 struct at91_adc_reg_desc *registers; 204 204 - u8 startup_time; 204 204 + u32 startup_time; 205 205 u8 sample_hold_time; 206 206 bool sleep_mode; 207 207 struct iio_trigger **trig; ··· 779 779 return ret; 780 780 } 781 781 782 782 - static u32 calc_startup_ticks_9260(u8 startup_time, u32 adc_clk_khz) 782 782 + static u32 calc_startup_ticks_9260(u32 startup_time, u32 adc_clk_khz) 783 783 { 784 784 /* 785 785 * Number of ticks needed to cover the startup time of the ADC ··· 790 790 return round_up((startup_time * adc_clk_khz / 1000) - 1, 8) / 8; 791 791 } 792 792 793 793 - static u32 calc_startup_ticks_9x5(u8 startup_time, u32 adc_clk_khz) 793 793 + static u32 calc_startup_ticks_9x5(u32 startup_time, u32 adc_clk_khz) 794 794 { 795 795 /* 796 796 * For sama5d3x and at91sam9x5, the formula changes to:

+4

drivers/iio/adc/rockchip_saradc.c

reviewed

··· 349 349 }; 350 350 351 351 module_platform_driver(rockchip_saradc_driver); 352 352 + 353 353 + MODULE_AUTHOR("Heiko Stuebner <heiko@sntech.de>"); 354 354 + MODULE_DESCRIPTION("Rockchip SARADC driver"); 355 355 + MODULE_LICENSE("GPL v2");

+2 -1

drivers/iio/adc/twl4030-madc.c

reviewed

··· 833 833 irq = platform_get_irq(pdev, 0); 834 834 ret = devm_request_threaded_irq(&pdev->dev, irq, NULL, 835 835 twl4030_madc_threaded_irq_handler, 836 836 - IRQF_TRIGGER_RISING, "twl4030_madc", madc); 836 836 + IRQF_TRIGGER_RISING | IRQF_ONESHOT, 837 837 + "twl4030_madc", madc); 837 838 if (ret) { 838 839 dev_err(&pdev->dev, "could not request irq\n"); 839 840 goto err_i2c;

+10 -1

drivers/iio/common/hid-sensors/hid-sensor-trigger.c

reviewed

··· 36 36 s32 poll_value = 0; 37 37 38 38 if (state) { 39 39 + if (!atomic_read(&st->user_requested_state)) 40 40 + return 0; 39 41 if (sensor_hub_device_open(st->hsdev)) 40 42 return -EIO; 41 43 ··· 54 52 55 53 poll_value = hid_sensor_read_poll_value(st); 56 54 } else { 57 57 - if (!atomic_dec_and_test(&st->data_ready)) 55 55 + int val; 56 56 + 57 57 + val = atomic_dec_if_positive(&st->data_ready); 58 58 + if (val < 0) 58 59 return 0; 60 60 + 59 61 sensor_hub_device_close(st->hsdev); 60 62 state_val = hid_sensor_get_usage_index(st->hsdev, 61 63 st->power_state.report_id, ··· 98 92 99 93 int hid_sensor_power_state(struct hid_sensor_common *st, bool state) 100 94 { 95 95 + 101 96 #ifdef CONFIG_PM 102 97 int ret; 103 98 99 99 + atomic_set(&st->user_requested_state, state); 104 100 if (state) 105 101 ret = pm_runtime_get_sync(&st->pdev->dev); 106 102 else { ··· 117 109 118 110 return 0; 119 111 #else 112 112 + atomic_set(&st->user_requested_state, state); 120 113 return _hid_sensor_power_state(st, state); 121 114 #endif 122 115 }

+2 -2

drivers/iio/dac/ad5624r_spi.c

reviewed

··· 22 22 #include "ad5624r.h" 23 23 24 24 static int ad5624r_spi_write(struct spi_device *spi, 25 25 - u8 cmd, u8 addr, u16 val, u8 len) 25 25 + u8 cmd, u8 addr, u16 val, u8 shift) 26 26 { 27 27 u32 data; 28 28 u8 msg[3]; ··· 35 35 * 14-, 12-bit input code followed by 0, 2, or 4 don't care bits, 36 36 * for the AD5664R, AD5644R, and AD5624R, respectively. 37 37 */ 38 38 - data = (0 << 22) | (cmd << 19) | (addr << 16) | (val << (16 - len)); 38 38 + data = (0 << 22) | (cmd << 19) | (addr << 16) | (val << shift); 39 39 msg[0] = data >> 16; 40 40 msg[1] = data >> 8; 41 41 msg[2] = data;

+18

drivers/iio/imu/inv_mpu6050/inv_mpu_core.c

reviewed

··· 431 431 return -EINVAL; 432 432 } 433 433 434 434 + static int inv_write_raw_get_fmt(struct iio_dev *indio_dev, 435 435 + struct iio_chan_spec const *chan, long mask) 436 436 + { 437 437 + switch (mask) { 438 438 + case IIO_CHAN_INFO_SCALE: 439 439 + switch (chan->type) { 440 440 + case IIO_ANGL_VEL: 441 441 + return IIO_VAL_INT_PLUS_NANO; 442 442 + default: 443 443 + return IIO_VAL_INT_PLUS_MICRO; 444 444 + } 445 445 + default: 446 446 + return IIO_VAL_INT_PLUS_MICRO; 447 447 + } 448 448 + 449 449 + return -EINVAL; 450 450 + } 434 451 static int inv_mpu6050_write_accel_scale(struct inv_mpu6050_state *st, int val) 435 452 { 436 453 int result, i; ··· 713 696 .driver_module = THIS_MODULE, 714 697 .read_raw = &inv_mpu6050_read_raw, 715 698 .write_raw = &inv_mpu6050_write_raw, 699 699 + .write_raw_get_fmt = &inv_write_raw_get_fmt, 716 700 .attrs = &inv_attribute_group, 717 701 .validate_trigger = inv_mpu6050_validate_trigger, 718 702 };

+2

drivers/iio/light/Kconfig

reviewed

··· 188 188 config LTR501 189 189 tristate "LTR-501ALS-01 light sensor" 190 190 depends on I2C 191 191 + select REGMAP_I2C 191 192 select IIO_BUFFER 192 193 select IIO_TRIGGERED_BUFFER 193 194 help ··· 202 201 config STK3310 203 202 tristate "STK3310 ALS and proximity sensor" 204 203 depends on I2C 204 204 + select REGMAP_I2C 205 205 help 206 206 Say yes here to get support for the Sensortek STK3310 ambient light 207 207 and proximity sensor. The STK3311 model is also supported by this

+1 -1

drivers/iio/light/cm3323.c

reviewed

··· 123 123 for (i = 0; i < ARRAY_SIZE(cm3323_int_time); i++) { 124 124 if (val == cm3323_int_time[i].val && 125 125 val2 == cm3323_int_time[i].val2) { 126 126 - reg_conf = data->reg_conf; 126 126 + reg_conf = data->reg_conf & ~CM3323_CONF_IT_MASK; 127 127 reg_conf |= i << CM3323_CONF_IT_SHIFT; 128 128 129 129 ret = i2c_smbus_write_word_data(data->client,

+1 -1

drivers/iio/light/ltr501.c

reviewed

··· 1302 1302 if (ret < 0) 1303 1303 return ret; 1304 1304 1305 1305 - data->als_contr = ret | data->chip_info->als_mode_active; 1305 1305 + data->als_contr = status | data->chip_info->als_mode_active; 1306 1306 1307 1307 ret = regmap_read(data->regmap, LTR501_PS_CONTR, &status); 1308 1308 if (ret < 0)

+17 -36

drivers/iio/light/stk3310.c

reviewed

··· 43 43 #define STK3311_CHIP_ID_VAL 0x1D 44 44 #define STK3310_PSINT_EN 0x01 45 45 #define STK3310_PS_MAX_VAL 0xFFFF 46 46 - #define STK3310_THRESH_MAX 0xFFFF 47 46 48 47 #define STK3310_DRIVER_NAME "stk3310" 49 48 #define STK3310_REGMAP_NAME "stk3310_regmap" ··· 83 84 REG_FIELD(STK3310_REG_FLAG, 4, 4); 84 85 static const struct reg_field stk3310_reg_field_flag_nf = 85 86 REG_FIELD(STK3310_REG_FLAG, 0, 0); 86 86 - /* 87 87 - * Maximum PS values with regard to scale. Used to export the 'inverse' 88 88 - * PS value (high values for far objects, low values for near objects). 89 89 - */ 87 87 + 88 88 + /* Estimate maximum proximity values with regard to measurement scale. */ 90 89 static const int stk3310_ps_max[4] = { 91 91 - STK3310_PS_MAX_VAL / 64, 92 92 - STK3310_PS_MAX_VAL / 16, 93 93 - STK3310_PS_MAX_VAL / 4, 94 94 - STK3310_PS_MAX_VAL, 90 90 + STK3310_PS_MAX_VAL / 640, 91 91 + STK3310_PS_MAX_VAL / 160, 92 92 + STK3310_PS_MAX_VAL / 40, 93 93 + STK3310_PS_MAX_VAL / 10 95 94 }; 96 95 97 96 static const int stk3310_scale_table[][2] = { ··· 125 128 /* Proximity event */ 126 129 { 127 130 .type = IIO_EV_TYPE_THRESH, 128 128 - .dir = IIO_EV_DIR_FALLING, 131 131 + .dir = IIO_EV_DIR_RISING, 129 132 .mask_separate = BIT(IIO_EV_INFO_VALUE) | 130 133 BIT(IIO_EV_INFO_ENABLE), 131 134 }, 132 135 /* Out-of-proximity event */ 133 136 { 134 137 .type = IIO_EV_TYPE_THRESH, 135 135 - .dir = IIO_EV_DIR_RISING, 138 138 + .dir = IIO_EV_DIR_FALLING, 136 139 .mask_separate = BIT(IIO_EV_INFO_VALUE) | 137 140 BIT(IIO_EV_INFO_ENABLE), 138 141 }, ··· 202 205 u8 reg; 203 206 u16 buf; 204 207 int ret; 205 205 - unsigned int index; 206 208 struct stk3310_data *data = iio_priv(indio_dev); 207 209 208 210 if (info != IIO_EV_INFO_VALUE) 209 211 return -EINVAL; 210 212 211 211 - /* 212 212 - * Only proximity interrupts are implemented at the moment. 213 213 - * Since we're inverting proximity values, the sensor's 'high' 214 214 - * threshold will become our 'low' threshold, associated with 215 215 - * 'near' events. Similarly, the sensor's 'low' threshold will 216 216 - * be our 'high' threshold, associated with 'far' events. 217 217 - */ 213 213 + /* Only proximity interrupts are implemented at the moment. */ 218 214 if (dir == IIO_EV_DIR_RISING) 219 219 - reg = STK3310_REG_THDL_PS; 220 220 - else if (dir == IIO_EV_DIR_FALLING) 221 215 reg = STK3310_REG_THDH_PS; 216 216 + else if (dir == IIO_EV_DIR_FALLING) 217 217 + reg = STK3310_REG_THDL_PS; 222 218 else 223 219 return -EINVAL; 224 220 ··· 222 232 dev_err(&data->client->dev, "register read failed\n"); 223 233 return ret; 224 234 } 225 225 - regmap_field_read(data->reg_ps_gain, &index); 226 226 - *val = swab16(stk3310_ps_max[index] - buf); 235 235 + *val = swab16(buf); 227 236 228 237 return IIO_VAL_INT; 229 238 } ··· 246 257 return -EINVAL; 247 258 248 259 if (dir == IIO_EV_DIR_RISING) 249 249 - reg = STK3310_REG_THDL_PS; 250 250 - else if (dir == IIO_EV_DIR_FALLING) 251 260 reg = STK3310_REG_THDH_PS; 261 261 + else if (dir == IIO_EV_DIR_FALLING) 262 262 + reg = STK3310_REG_THDL_PS; 252 263 else 253 264 return -EINVAL; 254 265 255 255 - buf = swab16(stk3310_ps_max[index] - val); 266 266 + buf = swab16(val); 256 267 ret = regmap_bulk_write(data->regmap, reg, &buf, 2); 257 268 if (ret < 0) 258 269 dev_err(&client->dev, "failed to set PS threshold!\n"); ··· 323 334 return ret; 324 335 } 325 336 *val = swab16(buf); 326 326 - if (chan->type == IIO_PROXIMITY) { 327 327 - /* 328 328 - * Invert the proximity data so we return low values 329 329 - * for close objects and high values for far ones. 330 330 - */ 331 331 - regmap_field_read(data->reg_ps_gain, &index); 332 332 - *val = stk3310_ps_max[index] - *val; 333 333 - } 334 337 mutex_unlock(&data->lock); 335 338 return IIO_VAL_INT; 336 339 case IIO_CHAN_INFO_INT_TIME: ··· 562 581 } 563 582 event = IIO_UNMOD_EVENT_CODE(IIO_PROXIMITY, 1, 564 583 IIO_EV_TYPE_THRESH, 565 565 - (dir ? IIO_EV_DIR_RISING : 566 566 - IIO_EV_DIR_FALLING)); 584 584 + (dir ? IIO_EV_DIR_FALLING : 585 585 + IIO_EV_DIR_RISING)); 567 586 iio_push_event(indio_dev, event, data->timestamp); 568 587 569 588 /* Reset the interrupt flag */

+1 -1

drivers/iio/light/tcs3414.c

reviewed

··· 185 185 if (val != 0) 186 186 return -EINVAL; 187 187 for (i = 0; i < ARRAY_SIZE(tcs3414_times); i++) { 188 188 - if (val == tcs3414_times[i] * 1000) { 188 188 + if (val2 == tcs3414_times[i] * 1000) { 189 189 data->timing &= ~TCS3414_INTEG_MASK; 190 190 data->timing |= i; 191 191 return i2c_smbus_write_byte_data(

+21 -14

drivers/iio/magnetometer/mmc35240.c

reviewed

··· 84 84 #define MMC35240_OTP_START_ADDR 0x1B 85 85 86 86 enum mmc35240_resolution { 87 87 - MMC35240_16_BITS_SLOW = 0, /* 100 Hz */ 88 88 - MMC35240_16_BITS_FAST, /* 200 Hz */ 89 89 - MMC35240_14_BITS, /* 333 Hz */ 90 90 - MMC35240_12_BITS, /* 666 Hz */ 87 87 + MMC35240_16_BITS_SLOW = 0, /* 7.92 ms */ 88 88 + MMC35240_16_BITS_FAST, /* 4.08 ms */ 89 89 + MMC35240_14_BITS, /* 2.16 ms */ 90 90 + MMC35240_12_BITS, /* 1.20 ms */ 91 91 }; 92 92 93 93 enum mmc35240_axis { ··· 100 100 int sens[3]; /* sensitivity per X, Y, Z axis */ 101 101 int nfo; /* null field output */ 102 102 } mmc35240_props_table[] = { 103 103 - /* 16 bits, 100Hz ODR */ 103 103 + /* 16 bits, 125Hz ODR */ 104 104 { 105 105 {1024, 1024, 1024}, 106 106 32768, 107 107 }, 108 108 - /* 16 bits, 200Hz ODR */ 108 108 + /* 16 bits, 250Hz ODR */ 109 109 { 110 110 {1024, 1024, 770}, 111 111 32768, 112 112 }, 113 113 - /* 14 bits, 333Hz ODR */ 113 113 + /* 14 bits, 450Hz ODR */ 114 114 { 115 115 {256, 256, 193}, 116 116 8192, 117 117 }, 118 118 - /* 12 bits, 666Hz ODR */ 118 118 + /* 12 bits, 800Hz ODR */ 119 119 { 120 120 {64, 64, 48}, 121 121 2048, ··· 133 133 int axis_scale[3]; 134 134 }; 135 135 136 136 - static const int mmc35240_samp_freq[] = {100, 200, 333, 666}; 136 136 + static const struct { 137 137 + int val; 138 138 + int val2; 139 139 + } mmc35240_samp_freq[] = { {1, 500000}, 140 140 + {13, 0}, 141 141 + {25, 0}, 142 142 + {50, 0} }; 137 143 138 138 - static IIO_CONST_ATTR_SAMP_FREQ_AVAIL("100 200 333 666"); 144 144 + static IIO_CONST_ATTR_SAMP_FREQ_AVAIL("1.5 13 25 50"); 139 145 140 146 #define MMC35240_CHANNEL(_axis) { \ 141 147 .type = IIO_MAGN, \ ··· 174 168 int i; 175 169 176 170 for (i = 0; i < ARRAY_SIZE(mmc35240_samp_freq); i++) 177 177 - if (mmc35240_samp_freq[i] == val) 171 171 + if (mmc35240_samp_freq[i].val == val && 172 172 + mmc35240_samp_freq[i].val2 == val2) 178 173 return i; 179 174 return -EINVAL; 180 175 } ··· 385 378 if (i < 0 || i >= ARRAY_SIZE(mmc35240_samp_freq)) 386 379 return -EINVAL; 387 380 388 388 - *val = mmc35240_samp_freq[i]; 389 389 - *val2 = 0; 390 390 - return IIO_VAL_INT; 381 381 + *val = mmc35240_samp_freq[i].val; 382 382 + *val2 = mmc35240_samp_freq[i].val2; 383 383 + return IIO_VAL_INT_PLUS_MICRO; 391 384 default: 392 385 return -EINVAL; 393 386 }

+16 -14

drivers/iio/proximity/sx9500.c

reviewed

··· 80 80 #define SX9500_COMPSTAT_MASK GENMASK(3, 0) 81 81 82 82 #define SX9500_NUM_CHANNELS 4 83 83 + #define SX9500_CHAN_MASK GENMASK(SX9500_NUM_CHANNELS - 1, 0) 83 84 84 85 struct sx9500_data { 85 86 struct mutex mutex; ··· 282 281 if (ret < 0) 283 282 return ret; 284 283 285 285 - *val = 32767 - (s16)be16_to_cpu(regval); 284 284 + *val = be16_to_cpu(regval); 286 285 287 286 return IIO_VAL_INT; 288 287 } ··· 330 329 else 331 330 ret = sx9500_wait_for_sample(data); 332 331 333 333 - if (ret < 0) 334 334 - return ret; 335 335 - 336 332 mutex_lock(&data->mutex); 333 333 + 334 334 + if (ret < 0) 335 335 + goto out_dec_data_rdy; 337 336 338 337 ret = sx9500_read_prox_data(data, chan, val); 339 338 if (ret < 0) 340 340 - goto out; 341 341 - 342 342 - ret = sx9500_dec_chan_users(data, chan->channel); 343 343 - if (ret < 0) 344 344 - goto out; 339 339 + goto out_dec_data_rdy; 345 340 346 341 ret = sx9500_dec_data_rdy_users(data); 342 342 + if (ret < 0) 343 343 + goto out_dec_chan; 344 344 + 345 345 + ret = sx9500_dec_chan_users(data, chan->channel); 347 346 if (ret < 0) 348 347 goto out; 349 348 ··· 351 350 352 351 goto out; 353 352 353 353 + out_dec_data_rdy: 354 354 + sx9500_dec_data_rdy_users(data); 354 355 out_dec_chan: 355 356 sx9500_dec_chan_users(data, chan->channel); 356 357 out: ··· 682 679 static int sx9500_buffer_preenable(struct iio_dev *indio_dev) 683 680 { 684 681 struct sx9500_data *data = iio_priv(indio_dev); 685 685 - int ret, i; 682 682 + int ret = 0, i; 686 683 687 684 mutex_lock(&data->mutex); 688 685 ··· 706 703 static int sx9500_buffer_predisable(struct iio_dev *indio_dev) 707 704 { 708 705 struct sx9500_data *data = iio_priv(indio_dev); 709 709 - int ret, i; 706 706 + int ret = 0, i; 710 707 711 708 iio_triggered_buffer_predisable(indio_dev); 712 709 ··· 803 800 unsigned int val; 804 801 805 802 ret = regmap_update_bits(data->regmap, SX9500_REG_PROX_CTRL0, 806 806 - GENMASK(SX9500_NUM_CHANNELS, 0), 807 807 - GENMASK(SX9500_NUM_CHANNELS, 0)); 803 803 + SX9500_CHAN_MASK, SX9500_CHAN_MASK); 808 804 if (ret < 0) 809 805 return ret; 810 806 ··· 823 821 824 822 out: 825 823 regmap_update_bits(data->regmap, SX9500_REG_PROX_CTRL0, 826 826 - GENMASK(SX9500_NUM_CHANNELS, 0), 0); 824 824 + SX9500_CHAN_MASK, 0); 827 825 return ret; 828 826 } 829 827

+3

drivers/iio/temperature/tmp006.c

reviewed

··· 132 132 struct tmp006_data *data = iio_priv(indio_dev); 133 133 int i; 134 134 135 135 + if (mask != IIO_CHAN_INFO_SAMP_FREQ) 136 136 + return -EINVAL; 137 137 + 135 138 for (i = 0; i < ARRAY_SIZE(tmp006_freqs); i++) 136 139 if ((val == tmp006_freqs[i][0]) && 137 140 (val2 == tmp006_freqs[i][1])) {

+1 -1

drivers/staging/board/Kconfig

reviewed

··· 1 1 config STAGING_BOARD 2 2 bool "Staging Board Support" 3 3 - depends on OF_ADDRESS 3 3 + depends on OF_ADDRESS && OF_IRQ && CLKDEV_LOOKUP 4 4 help 5 5 Select to enable per-board staging support code. 6 6

-1

drivers/staging/lustre/lnet/klnds/socklnd/socklnd.h

reviewed

··· 31 31 #define DEBUG_PORTAL_ALLOC 32 32 #define DEBUG_SUBSYSTEM S_LND 33 33 34 34 - #include <asm/irq.h> 35 34 #include <linux/crc32.h> 36 35 #include <linux/errno.h> 37 36 #include <linux/if.h>

+1 -1

drivers/staging/vt6655/device_main.c

reviewed

··· 1418 1418 1419 1419 priv->current_aid = conf->aid; 1420 1420 1421 1421 - if (changed & BSS_CHANGED_BSSID) { 1421 1421 + if (changed & BSS_CHANGED_BSSID && conf->bssid) { 1422 1422 unsigned long flags; 1423 1423 1424 1424 spin_lock_irqsave(&priv->lock, flags);

+1 -1

drivers/staging/vt6656/main_usb.c

reviewed

··· 701 701 702 702 priv->current_aid = conf->aid; 703 703 704 704 - if (changed & BSS_CHANGED_BSSID) 704 704 + if (changed & BSS_CHANGED_BSSID && conf->bssid) 705 705 vnt_mac_set_bssid_addr(priv, (u8 *)conf->bssid); 706 706 707 707

+1

include/linux/hid-sensor-hub.h

reviewed

··· 230 230 struct platform_device *pdev; 231 231 unsigned usage_id; 232 232 atomic_t data_ready; 233 233 + atomic_t user_requested_state; 233 234 struct iio_trigger *trigger; 234 235 struct hid_sensor_hub_attribute_info poll; 235 236 struct hid_sensor_hub_attribute_info report_state;