tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
fork atom

Merge tag 'staging-4.0-rc3' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/staging

Pull staging driver fixes from Greg KH:
"Here are some IIO and staging driver fixes for 4.0-rc3.

Details are in the shortlog, nothing major, mostly IIO fixes for
reported issues.

All have been in linux-next successfully"

* tag 'staging-4.0-rc3' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/staging: (23 commits)
staging: comedi: adv_pci1710: fix AI INSN_READ for non-zero channel
staging: comedi: vmk80xx: remove "firmware version" kernel messages
staging: comedi: comedi_isadma: fix "stalled" detect in comedi_isadma_disable_on_sample()
iio: ak8975: fix AK09911 dependencies
iio: common: ssp_sensors: Protect PM-only functions to kill warning
IIO: si7020: Allocate correct amount of memory in devm_iio_device_alloc
Revert "iio:humidity:si7020: fix pointer to i2c client"
iio: light: gp2ap020a00f: Select REGMAP_I2C
iio: light: jsa1212: Select REGMAP_I2C
iio: ad5686: fix optional reference voltage declaration
iio:adc:mcp3422 Fix incorrect scales table
iio: mxs-lradc: fix iio channel map regression
iio: imu: adis16400: Fix sign extension
staging: iio: ad2s1200: Fix sign extension
iio: mxs-lradc: only update the buffer when its conversions have finished
iio: mxs-lradc: make ADC reads not unschedule touchscreen conversions
iio: mxs-lradc: make ADC reads not disable touchscreen interrupts
iio: mxs-lradc: separate touchscreen and buffer virtual channels
iio: imu: inv_mpu6050: Prevent dereferencing NULL
iio: iadc: wait_for_completion_timeout time in jiffies
...

Linus Torvalds 47df986b 29191c7f

options
unified split
Changed files
+176 -227
drivers
iio
adc
mcp3422.c
qcom-spmi-iadc.c
common
ssp_sensors
ssp_dev.c
dac
ad5686.c
humidity
dht11.c
si7020.c
imu
adis16400_core.c
inv_mpu6050
inv_mpu_core.c
light
Kconfig
magnetometer
Kconfig
staging
comedi
drivers
adv_pci1710.c
comedi_isadma.c
vmk80xx.c
iio
adc
mxs-lradc.c
resolver
ad2s1200.c
+4 -13
drivers/iio/adc/mcp3422.c
··· 58 58 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SAMP_FREQ), \ 59 59 } 60 60 61 - /* LSB is in nV to eliminate floating point */ 62 - static const u32 rates_to_lsb[] = {1000000, 250000, 62500, 15625}; 63 - 64 - /* 65 - * scales calculated as: 66 - * rates_to_lsb[sample_rate] / (1 << pga); 67 - * pga is 1 for 0, 2 68 - */ 69 - 70 61 static const int mcp3422_scales[4][4] = { 71 - { 1000000, 250000, 62500, 15625 }, 72 - { 500000 , 125000, 31250, 7812 }, 73 - { 250000 , 62500 , 15625, 3906 }, 74 - { 125000 , 31250 , 7812 , 1953 } }; 62 + { 1000000, 500000, 250000, 125000 }, 63 + { 250000 , 125000, 62500 , 31250 }, 64 + { 62500 , 31250 , 15625 , 7812 }, 65 + { 15625 , 7812 , 3906 , 1953 } }; 75 66 76 67 /* Constant msleep times for data acquisitions */ 77 68 static const int mcp3422_read_times[4] = {
+2 -1
drivers/iio/adc/qcom-spmi-iadc.c
··· 296 296 if (iadc->poll_eoc) { 297 297 ret = iadc_poll_wait_eoc(iadc, wait); 298 298 } else { 299 - ret = wait_for_completion_timeout(&iadc->complete, wait); 299 + ret = wait_for_completion_timeout(&iadc->complete, 300 + usecs_to_jiffies(wait)); 300 301 if (!ret) 301 302 ret = -ETIMEDOUT; 302 303 else
+2
drivers/iio/common/ssp_sensors/ssp_dev.c
··· 640 640 return 0; 641 641 } 642 642 643 + #ifdef CONFIG_PM_SLEEP 643 644 static int ssp_suspend(struct device *dev) 644 645 { 645 646 int ret; ··· 689 688 690 689 return 0; 691 690 } 691 + #endif /* CONFIG_PM_SLEEP */ 692 692 693 693 static const struct dev_pm_ops ssp_pm_ops = { 694 694 SET_SYSTEM_SLEEP_PM_OPS(ssp_suspend, ssp_resume)
+1 -1
drivers/iio/dac/ad5686.c
··· 322 322 st = iio_priv(indio_dev); 323 323 spi_set_drvdata(spi, indio_dev); 324 324 325 - st->reg = devm_regulator_get(&spi->dev, "vcc"); 325 + st->reg = devm_regulator_get_optional(&spi->dev, "vcc"); 326 326 if (!IS_ERR(st->reg)) { 327 327 ret = regulator_enable(st->reg); 328 328 if (ret)
+41 -28
drivers/iio/humidity/dht11.c
··· 29 29 #include <linux/wait.h> 30 30 #include <linux/bitops.h> 31 31 #include <linux/completion.h> 32 + #include <linux/mutex.h> 32 33 #include <linux/delay.h> 33 34 #include <linux/gpio.h> 34 35 #include <linux/of_gpio.h> ··· 40 39 41 40 #define DHT11_DATA_VALID_TIME 2000000000 /* 2s in ns */ 42 41 43 - #define DHT11_EDGES_PREAMBLE 4 42 + #define DHT11_EDGES_PREAMBLE 2 44 43 #define DHT11_BITS_PER_READ 40 44 + /* 45 + * Note that when reading the sensor actually 84 edges are detected, but 46 + * since the last edge is not significant, we only store 83: 47 + */ 45 48 #define DHT11_EDGES_PER_READ (2*DHT11_BITS_PER_READ + DHT11_EDGES_PREAMBLE + 1) 46 49 47 50 /* Data transmission timing (nano seconds) */ ··· 62 57 int irq; 63 58 64 59 struct completion completion; 60 + struct mutex lock; 65 61 66 62 s64 timestamp; 67 63 int temperature; ··· 94 88 unsigned char temp_int, temp_dec, hum_int, hum_dec, checksum; 95 89 96 90 /* Calculate timestamp resolution */ 97 - for (i = 0; i < dht11->num_edges; ++i) { 91 + for (i = 1; i < dht11->num_edges; ++i) { 98 92 t = dht11->edges[i].ts - dht11->edges[i-1].ts; 99 93 if (t > 0 && t < timeres) 100 94 timeres = t; ··· 144 138 return 0; 145 139 } 146 140 141 + /* 142 + * IRQ handler called on GPIO edges 143 + */ 144 + static irqreturn_t dht11_handle_irq(int irq, void *data) 145 + { 146 + struct iio_dev *iio = data; 147 + struct dht11 *dht11 = iio_priv(iio); 148 + 149 + /* TODO: Consider making the handler safe for IRQ sharing */ 150 + if (dht11->num_edges < DHT11_EDGES_PER_READ && dht11->num_edges >= 0) { 151 + dht11->edges[dht11->num_edges].ts = iio_get_time_ns(); 152 + dht11->edges[dht11->num_edges++].value = 153 + gpio_get_value(dht11->gpio); 154 + 155 + if (dht11->num_edges >= DHT11_EDGES_PER_READ) 156 + complete(&dht11->completion); 157 + } 158 + 159 + return IRQ_HANDLED; 160 + } 161 + 147 162 static int dht11_read_raw(struct iio_dev *iio_dev, 148 163 const struct iio_chan_spec *chan, 149 164 int *val, int *val2, long m) ··· 172 145 struct dht11 *dht11 = iio_priv(iio_dev); 173 146 int ret; 174 147 148 + mutex_lock(&dht11->lock); 175 149 if (dht11->timestamp + DHT11_DATA_VALID_TIME < iio_get_time_ns()) { 176 150 reinit_completion(&dht11->completion); 177 151 ··· 185 157 if (ret) 186 158 goto err; 187 159 160 + ret = request_irq(dht11->irq, dht11_handle_irq, 161 + IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, 162 + iio_dev->name, iio_dev); 163 + if (ret) 164 + goto err; 165 + 188 166 ret = wait_for_completion_killable_timeout(&dht11->completion, 189 167 HZ); 168 + 169 + free_irq(dht11->irq, iio_dev); 170 + 190 171 if (ret == 0 && dht11->num_edges < DHT11_EDGES_PER_READ - 1) { 191 172 dev_err(&iio_dev->dev, 192 173 "Only %d signal edges detected\n", ··· 222 185 ret = -EINVAL; 223 186 err: 224 187 dht11->num_edges = -1; 188 + mutex_unlock(&dht11->lock); 225 189 return ret; 226 190 } 227 191 ··· 230 192 .driver_module = THIS_MODULE, 231 193 .read_raw = dht11_read_raw, 232 194 }; 233 - 234 - /* 235 - * IRQ handler called on GPIO edges 236 - */ 237 - static irqreturn_t dht11_handle_irq(int irq, void *data) 238 - { 239 - struct iio_dev *iio = data; 240 - struct dht11 *dht11 = iio_priv(iio); 241 - 242 - /* TODO: Consider making the handler safe for IRQ sharing */ 243 - if (dht11->num_edges < DHT11_EDGES_PER_READ && dht11->num_edges >= 0) { 244 - dht11->edges[dht11->num_edges].ts = iio_get_time_ns(); 245 - dht11->edges[dht11->num_edges++].value = 246 - gpio_get_value(dht11->gpio); 247 - 248 - if (dht11->num_edges >= DHT11_EDGES_PER_READ) 249 - complete(&dht11->completion); 250 - } 251 - 252 - return IRQ_HANDLED; 253 - } 254 195 255 196 static const struct iio_chan_spec dht11_chan_spec[] = { 256 197 { .type = IIO_TEMP, ··· 273 256 dev_err(dev, "GPIO %d has no interrupt\n", dht11->gpio); 274 257 return -EINVAL; 275 258 } 276 - ret = devm_request_irq(dev, dht11->irq, dht11_handle_irq, 277 - IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, 278 - pdev->name, iio); 279 - if (ret) 280 - return ret; 281 259 282 260 dht11->timestamp = iio_get_time_ns() - DHT11_DATA_VALID_TIME - 1; 283 261 dht11->num_edges = -1; ··· 280 268 platform_set_drvdata(pdev, iio); 281 269 282 270 init_completion(&dht11->completion); 271 + mutex_init(&dht11->lock); 283 272 iio->name = pdev->name; 284 273 iio->dev.parent = &pdev->dev; 285 274 iio->info = &dht11_iio_info;
+3 -3
drivers/iio/humidity/si7020.c
··· 45 45 struct iio_chan_spec const *chan, int *val, 46 46 int *val2, long mask) 47 47 { 48 - struct i2c_client *client = iio_priv(indio_dev); 48 + struct i2c_client **client = iio_priv(indio_dev); 49 49 int ret; 50 50 51 51 switch (mask) { 52 52 case IIO_CHAN_INFO_RAW: 53 - ret = i2c_smbus_read_word_data(client, 53 + ret = i2c_smbus_read_word_data(*client, 54 54 chan->type == IIO_TEMP ? 55 55 SI7020CMD_TEMP_HOLD : 56 56 SI7020CMD_RH_HOLD); ··· 126 126 /* Wait the maximum power-up time after software reset. */ 127 127 msleep(15); 128 128 129 - indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*client)); 129 + indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data)); 130 130 if (!indio_dev) 131 131 return -ENOMEM; 132 132
+2 -1
drivers/iio/imu/adis16400_core.c
··· 26 26 #include <linux/list.h> 27 27 #include <linux/module.h> 28 28 #include <linux/debugfs.h> 29 + #include <linux/bitops.h> 29 30 30 31 #include <linux/iio/iio.h> 31 32 #include <linux/iio/sysfs.h> ··· 415 414 mutex_unlock(&indio_dev->mlock); 416 415 if (ret) 417 416 return ret; 418 - val16 = ((val16 & 0xFFF) << 4) >> 4; 417 + val16 = sign_extend32(val16, 11); 419 418 *val = val16; 420 419 return IIO_VAL_INT; 421 420 case IIO_CHAN_INFO_OFFSET:
+5 -1
drivers/iio/imu/inv_mpu6050/inv_mpu_core.c
··· 780 780 781 781 i2c_set_clientdata(client, indio_dev); 782 782 indio_dev->dev.parent = &client->dev; 783 - indio_dev->name = id->name; 783 + /* id will be NULL when enumerated via ACPI */ 784 + if (id) 785 + indio_dev->name = (char *)id->name; 786 + else 787 + indio_dev->name = (char *)dev_name(&client->dev); 784 788 indio_dev->channels = inv_mpu_channels; 785 789 indio_dev->num_channels = ARRAY_SIZE(inv_mpu_channels); 786 790
+2
drivers/iio/light/Kconfig
··· 73 73 config GP2AP020A00F 74 74 tristate "Sharp GP2AP020A00F Proximity/ALS sensor" 75 75 depends on I2C 76 + select REGMAP_I2C 76 77 select IIO_BUFFER 77 78 select IIO_TRIGGERED_BUFFER 78 79 select IRQ_WORK ··· 127 126 config JSA1212 128 127 tristate "JSA1212 ALS and proximity sensor driver" 129 128 depends on I2C 129 + select REGMAP_I2C 130 130 help 131 131 Say Y here if you want to build a IIO driver for JSA1212 132 132 proximity & ALS sensor device.
+2
drivers/iio/magnetometer/Kconfig
··· 18 18 19 19 config AK09911 20 20 tristate "Asahi Kasei AK09911 3-axis Compass" 21 + depends on I2C 22 + depends on GPIOLIB 21 23 select AK8975 22 24 help 23 25 Deprecated: AK09911 is now supported by AK8975 driver.
+1 -2
drivers/staging/comedi/drivers/adv_pci1710.c
··· 426 426 unsigned int *data) 427 427 { 428 428 struct pci1710_private *devpriv = dev->private; 429 - unsigned int chan = CR_CHAN(insn->chanspec); 430 429 int ret = 0; 431 430 int i; 432 431 ··· 446 447 if (ret) 447 448 break; 448 449 449 - ret = pci171x_ai_read_sample(dev, s, chan, &val); 450 + ret = pci171x_ai_read_sample(dev, s, 0, &val); 450 451 if (ret) 451 452 break; 452 453
+3 -2
drivers/staging/comedi/drivers/comedi_isadma.c
··· 91 91 stalled++; 92 92 if (stalled > 10) 93 93 break; 94 + } else { 95 + residue = new_residue; 96 + stalled = 0; 94 97 } 95 - residue = new_residue; 96 - stalled = 0; 97 98 } 98 99 return residue; 99 100 }
-71
drivers/staging/comedi/drivers/vmk80xx.c
··· 103 103 VMK8061_MODEL 104 104 }; 105 105 106 - struct firmware_version { 107 - unsigned char ic3_vers[32]; /* USB-Controller */ 108 - unsigned char ic6_vers[32]; /* CPU */ 109 - }; 110 - 111 106 static const struct comedi_lrange vmk8061_range = { 112 107 2, { 113 108 UNI_RANGE(5), ··· 151 156 struct vmk80xx_private { 152 157 struct usb_endpoint_descriptor *ep_rx; 153 158 struct usb_endpoint_descriptor *ep_tx; 154 - struct firmware_version fw; 155 159 struct semaphore limit_sem; 156 160 unsigned char *usb_rx_buf; 157 161 unsigned char *usb_tx_buf; 158 162 enum vmk80xx_model model; 159 163 }; 160 - 161 - static int vmk80xx_check_data_link(struct comedi_device *dev) 162 - { 163 - struct vmk80xx_private *devpriv = dev->private; 164 - struct usb_device *usb = comedi_to_usb_dev(dev); 165 - unsigned int tx_pipe; 166 - unsigned int rx_pipe; 167 - unsigned char tx[1]; 168 - unsigned char rx[2]; 169 - 170 - tx_pipe = usb_sndbulkpipe(usb, 0x01); 171 - rx_pipe = usb_rcvbulkpipe(usb, 0x81); 172 - 173 - tx[0] = VMK8061_CMD_RD_PWR_STAT; 174 - 175 - /* 176 - * Check that IC6 (PIC16F871) is powered and 177 - * running and the data link between IC3 and 178 - * IC6 is working properly 179 - */ 180 - usb_bulk_msg(usb, tx_pipe, tx, 1, NULL, devpriv->ep_tx->bInterval); 181 - usb_bulk_msg(usb, rx_pipe, rx, 2, NULL, HZ * 10); 182 - 183 - return (int)rx[1]; 184 - } 185 - 186 - static void vmk80xx_read_eeprom(struct comedi_device *dev, int flag) 187 - { 188 - struct vmk80xx_private *devpriv = dev->private; 189 - struct usb_device *usb = comedi_to_usb_dev(dev); 190 - unsigned int tx_pipe; 191 - unsigned int rx_pipe; 192 - unsigned char tx[1]; 193 - unsigned char rx[64]; 194 - int cnt; 195 - 196 - tx_pipe = usb_sndbulkpipe(usb, 0x01); 197 - rx_pipe = usb_rcvbulkpipe(usb, 0x81); 198 - 199 - tx[0] = VMK8061_CMD_RD_VERSION; 200 - 201 - /* 202 - * Read the firmware version info of IC3 and 203 - * IC6 from the internal EEPROM of the IC 204 - */ 205 - usb_bulk_msg(usb, tx_pipe, tx, 1, NULL, devpriv->ep_tx->bInterval); 206 - usb_bulk_msg(usb, rx_pipe, rx, 64, &cnt, HZ * 10); 207 - 208 - rx[cnt] = '\0'; 209 - 210 - if (flag & IC3_VERSION) 211 - strncpy(devpriv->fw.ic3_vers, rx + 1, 24); 212 - else /* IC6_VERSION */ 213 - strncpy(devpriv->fw.ic6_vers, rx + 25, 24); 214 - } 215 164 216 165 static void vmk80xx_do_bulk_msg(struct comedi_device *dev) 217 166 { ··· 816 877 sema_init(&devpriv->limit_sem, 8); 817 878 818 879 usb_set_intfdata(intf, devpriv); 819 - 820 - if (devpriv->model == VMK8061_MODEL) { 821 - vmk80xx_read_eeprom(dev, IC3_VERSION); 822 - dev_info(&intf->dev, "%s\n", devpriv->fw.ic3_vers); 823 - 824 - if (vmk80xx_check_data_link(dev)) { 825 - vmk80xx_read_eeprom(dev, IC6_VERSION); 826 - dev_info(&intf->dev, "%s\n", devpriv->fw.ic6_vers); 827 - } 828 - } 829 880 830 881 if (devpriv->model == VMK8055_MODEL) 831 882 vmk80xx_reset_device(dev);
+106 -103
drivers/staging/iio/adc/mxs-lradc.c
··· 214 214 unsigned long is_divided; 215 215 216 216 /* 217 - * Touchscreen LRADC channels receives a private slot in the CTRL4 218 - * register, the slot #7. Therefore only 7 slots instead of 8 in the 219 - * CTRL4 register can be mapped to LRADC channels when using the 220 - * touchscreen. 221 - * 217 + * When the touchscreen is enabled, we give it two private virtual 218 + * channels: #6 and #7. This means that only 6 virtual channels (instead 219 + * of 8) will be available for buffered capture. 220 + */ 221 + #define TOUCHSCREEN_VCHANNEL1 7 222 + #define TOUCHSCREEN_VCHANNEL2 6 223 + #define BUFFER_VCHANS_LIMITED 0x3f 224 + #define BUFFER_VCHANS_ALL 0xff 225 + u8 buffer_vchans; 226 + 227 + /* 222 228 * Furthermore, certain LRADC channels are shared between touchscreen 223 229 * and/or touch-buttons and generic LRADC block. Therefore when using 224 230 * either of these, these channels are not available for the regular ··· 348 342 #define LRADC_CTRL4 0x140 349 343 #define LRADC_CTRL4_LRADCSELECT_MASK(n) (0xf << ((n) * 4)) 350 344 #define LRADC_CTRL4_LRADCSELECT_OFFSET(n) ((n) * 4) 345 + #define LRADC_CTRL4_LRADCSELECT(n, x) \ 346 + (((x) << LRADC_CTRL4_LRADCSELECT_OFFSET(n)) & \ 347 + LRADC_CTRL4_LRADCSELECT_MASK(n)) 351 348 352 349 #define LRADC_RESOLUTION 12 353 350 #define LRADC_SINGLE_SAMPLE_MASK ((1 << LRADC_RESOLUTION) - 1) ··· 425 416 LRADC_STATUS_TOUCH_DETECT_RAW); 426 417 } 427 418 419 + static void mxs_lradc_map_channel(struct mxs_lradc *lradc, unsigned vch, 420 + unsigned ch) 421 + { 422 + mxs_lradc_reg_clear(lradc, LRADC_CTRL4_LRADCSELECT_MASK(vch), 423 + LRADC_CTRL4); 424 + mxs_lradc_reg_set(lradc, LRADC_CTRL4_LRADCSELECT(vch, ch), LRADC_CTRL4); 425 + } 426 + 428 427 static void mxs_lradc_setup_ts_channel(struct mxs_lradc *lradc, unsigned ch) 429 428 { 430 429 /* ··· 467 450 LRADC_DELAY_DELAY(lradc->over_sample_delay - 1), 468 451 LRADC_DELAY(3)); 469 452 470 - mxs_lradc_reg_clear(lradc, LRADC_CTRL1_LRADC_IRQ(2) | 471 - LRADC_CTRL1_LRADC_IRQ(3) | LRADC_CTRL1_LRADC_IRQ(4) | 472 - LRADC_CTRL1_LRADC_IRQ(5), LRADC_CTRL1); 453 + mxs_lradc_reg_clear(lradc, LRADC_CTRL1_LRADC_IRQ(ch), LRADC_CTRL1); 473 454 474 - /* wake us again, when the complete conversion is done */ 475 - mxs_lradc_reg_set(lradc, LRADC_CTRL1_LRADC_IRQ_EN(ch), LRADC_CTRL1); 476 455 /* 477 456 * after changing the touchscreen plates setting 478 457 * the signals need some initial time to settle. Start the ··· 522 509 LRADC_DELAY_DELAY(lradc->over_sample_delay - 1), 523 510 LRADC_DELAY(3)); 524 511 525 - mxs_lradc_reg_clear(lradc, LRADC_CTRL1_LRADC_IRQ(2) | 526 - LRADC_CTRL1_LRADC_IRQ(3) | LRADC_CTRL1_LRADC_IRQ(4) | 527 - LRADC_CTRL1_LRADC_IRQ(5), LRADC_CTRL1); 512 + mxs_lradc_reg_clear(lradc, LRADC_CTRL1_LRADC_IRQ(ch2), LRADC_CTRL1); 528 513 529 - /* wake us again, when the conversions are done */ 530 - mxs_lradc_reg_set(lradc, LRADC_CTRL1_LRADC_IRQ_EN(ch2), LRADC_CTRL1); 531 514 /* 532 515 * after changing the touchscreen plates setting 533 516 * the signals need some initial time to settle. Start the ··· 589 580 #define TS_CH_XM 4 590 581 #define TS_CH_YM 5 591 582 592 - static int mxs_lradc_read_ts_channel(struct mxs_lradc *lradc) 593 - { 594 - u32 reg; 595 - int val; 596 - 597 - reg = readl(lradc->base + LRADC_CTRL1); 598 - 599 - /* only channels 3 to 5 are of interest here */ 600 - if (reg & LRADC_CTRL1_LRADC_IRQ(TS_CH_YP)) { 601 - mxs_lradc_reg_clear(lradc, LRADC_CTRL1_LRADC_IRQ_EN(TS_CH_YP) | 602 - LRADC_CTRL1_LRADC_IRQ(TS_CH_YP), LRADC_CTRL1); 603 - val = mxs_lradc_read_raw_channel(lradc, TS_CH_YP); 604 - } else if (reg & LRADC_CTRL1_LRADC_IRQ(TS_CH_XM)) { 605 - mxs_lradc_reg_clear(lradc, LRADC_CTRL1_LRADC_IRQ_EN(TS_CH_XM) | 606 - LRADC_CTRL1_LRADC_IRQ(TS_CH_XM), LRADC_CTRL1); 607 - val = mxs_lradc_read_raw_channel(lradc, TS_CH_XM); 608 - } else if (reg & LRADC_CTRL1_LRADC_IRQ(TS_CH_YM)) { 609 - mxs_lradc_reg_clear(lradc, LRADC_CTRL1_LRADC_IRQ_EN(TS_CH_YM) | 610 - LRADC_CTRL1_LRADC_IRQ(TS_CH_YM), LRADC_CTRL1); 611 - val = mxs_lradc_read_raw_channel(lradc, TS_CH_YM); 612 - } else { 613 - return -EIO; 614 - } 615 - 616 - mxs_lradc_reg_wrt(lradc, 0, LRADC_DELAY(2)); 617 - mxs_lradc_reg_wrt(lradc, 0, LRADC_DELAY(3)); 618 - 619 - return val; 620 - } 621 - 622 583 /* 623 584 * YP(open)--+-------------+ 624 585 * | |--+ ··· 632 653 mxs_lradc_reg_set(lradc, mxs_lradc_drive_x_plate(lradc), LRADC_CTRL0); 633 654 634 655 lradc->cur_plate = LRADC_SAMPLE_X; 635 - mxs_lradc_setup_ts_channel(lradc, TS_CH_YP); 656 + mxs_lradc_map_channel(lradc, TOUCHSCREEN_VCHANNEL1, TS_CH_YP); 657 + mxs_lradc_setup_ts_channel(lradc, TOUCHSCREEN_VCHANNEL1); 636 658 } 637 659 638 660 /* ··· 654 674 mxs_lradc_reg_set(lradc, mxs_lradc_drive_y_plate(lradc), LRADC_CTRL0); 655 675 656 676 lradc->cur_plate = LRADC_SAMPLE_Y; 657 - mxs_lradc_setup_ts_channel(lradc, TS_CH_XM); 677 + mxs_lradc_map_channel(lradc, TOUCHSCREEN_VCHANNEL1, TS_CH_XM); 678 + mxs_lradc_setup_ts_channel(lradc, TOUCHSCREEN_VCHANNEL1); 658 679 } 659 680 660 681 /* ··· 676 695 mxs_lradc_reg_set(lradc, mxs_lradc_drive_pressure(lradc), LRADC_CTRL0); 677 696 678 697 lradc->cur_plate = LRADC_SAMPLE_PRESSURE; 679 - mxs_lradc_setup_ts_pressure(lradc, TS_CH_XP, TS_CH_YM); 698 + mxs_lradc_map_channel(lradc, TOUCHSCREEN_VCHANNEL1, TS_CH_YM); 699 + mxs_lradc_map_channel(lradc, TOUCHSCREEN_VCHANNEL2, TS_CH_XP); 700 + mxs_lradc_setup_ts_pressure(lradc, TOUCHSCREEN_VCHANNEL2, 701 + TOUCHSCREEN_VCHANNEL1); 680 702 } 681 703 682 704 static void mxs_lradc_enable_touch_detection(struct mxs_lradc *lradc) ··· 690 706 mxs_lradc_reg_clear(lradc, LRADC_CTRL1_TOUCH_DETECT_IRQ | 691 707 LRADC_CTRL1_TOUCH_DETECT_IRQ_EN, LRADC_CTRL1); 692 708 mxs_lradc_reg_set(lradc, LRADC_CTRL1_TOUCH_DETECT_IRQ_EN, LRADC_CTRL1); 709 + } 710 + 711 + static void mxs_lradc_start_touch_event(struct mxs_lradc *lradc) 712 + { 713 + mxs_lradc_reg_clear(lradc, LRADC_CTRL1_TOUCH_DETECT_IRQ_EN, 714 + LRADC_CTRL1); 715 + mxs_lradc_reg_set(lradc, 716 + LRADC_CTRL1_LRADC_IRQ_EN(TOUCHSCREEN_VCHANNEL1), LRADC_CTRL1); 717 + /* 718 + * start with the Y-pos, because it uses nearly the same plate 719 + * settings like the touch detection 720 + */ 721 + mxs_lradc_prepare_y_pos(lradc); 693 722 } 694 723 695 724 static void mxs_lradc_report_ts_event(struct mxs_lradc *lradc) ··· 722 725 * start a dummy conversion to burn time to settle the signals 723 726 * note: we are not interested in the conversion's value 724 727 */ 725 - mxs_lradc_reg_wrt(lradc, 0, LRADC_CH(5)); 726 - mxs_lradc_reg_clear(lradc, LRADC_CTRL1_LRADC_IRQ(5), LRADC_CTRL1); 727 - mxs_lradc_reg_set(lradc, LRADC_CTRL1_LRADC_IRQ_EN(5), LRADC_CTRL1); 728 - mxs_lradc_reg_wrt(lradc, LRADC_DELAY_TRIGGER(1 << 5) | 728 + mxs_lradc_reg_wrt(lradc, 0, LRADC_CH(TOUCHSCREEN_VCHANNEL1)); 729 + mxs_lradc_reg_clear(lradc, 730 + LRADC_CTRL1_LRADC_IRQ(TOUCHSCREEN_VCHANNEL1) | 731 + LRADC_CTRL1_LRADC_IRQ(TOUCHSCREEN_VCHANNEL2), LRADC_CTRL1); 732 + mxs_lradc_reg_wrt(lradc, 733 + LRADC_DELAY_TRIGGER(1 << TOUCHSCREEN_VCHANNEL1) | 729 734 LRADC_DELAY_KICK | LRADC_DELAY_DELAY(10), /* waste 5 ms */ 730 735 LRADC_DELAY(2)); 731 736 } ··· 759 760 760 761 /* if it is released, wait for the next touch via IRQ */ 761 762 lradc->cur_plate = LRADC_TOUCH; 762 - mxs_lradc_reg_clear(lradc, LRADC_CTRL1_TOUCH_DETECT_IRQ, LRADC_CTRL1); 763 + mxs_lradc_reg_wrt(lradc, 0, LRADC_DELAY(2)); 764 + mxs_lradc_reg_wrt(lradc, 0, LRADC_DELAY(3)); 765 + mxs_lradc_reg_clear(lradc, LRADC_CTRL1_TOUCH_DETECT_IRQ | 766 + LRADC_CTRL1_LRADC_IRQ_EN(TOUCHSCREEN_VCHANNEL1) | 767 + LRADC_CTRL1_LRADC_IRQ(TOUCHSCREEN_VCHANNEL1), LRADC_CTRL1); 763 768 mxs_lradc_reg_set(lradc, LRADC_CTRL1_TOUCH_DETECT_IRQ_EN, LRADC_CTRL1); 764 769 } 765 770 766 771 /* touchscreen's state machine */ 767 772 static void mxs_lradc_handle_touch(struct mxs_lradc *lradc) 768 773 { 769 - int val; 770 - 771 774 switch (lradc->cur_plate) { 772 775 case LRADC_TOUCH: 773 - /* 774 - * start with the Y-pos, because it uses nearly the same plate 775 - * settings like the touch detection 776 - */ 777 - if (mxs_lradc_check_touch_event(lradc)) { 778 - mxs_lradc_reg_clear(lradc, 779 - LRADC_CTRL1_TOUCH_DETECT_IRQ_EN, 780 - LRADC_CTRL1); 781 - mxs_lradc_prepare_y_pos(lradc); 782 - } 776 + if (mxs_lradc_check_touch_event(lradc)) 777 + mxs_lradc_start_touch_event(lradc); 783 778 mxs_lradc_reg_clear(lradc, LRADC_CTRL1_TOUCH_DETECT_IRQ, 784 779 LRADC_CTRL1); 785 780 return; 786 781 787 782 case LRADC_SAMPLE_Y: 788 - val = mxs_lradc_read_ts_channel(lradc); 789 - if (val < 0) { 790 - mxs_lradc_enable_touch_detection(lradc); /* re-start */ 791 - return; 792 - } 793 - lradc->ts_y_pos = val; 783 + lradc->ts_y_pos = mxs_lradc_read_raw_channel(lradc, 784 + TOUCHSCREEN_VCHANNEL1); 794 785 mxs_lradc_prepare_x_pos(lradc); 795 786 return; 796 787 797 788 case LRADC_SAMPLE_X: 798 - val = mxs_lradc_read_ts_channel(lradc); 799 - if (val < 0) { 800 - mxs_lradc_enable_touch_detection(lradc); /* re-start */ 801 - return; 802 - } 803 - lradc->ts_x_pos = val; 789 + lradc->ts_x_pos = mxs_lradc_read_raw_channel(lradc, 790 + TOUCHSCREEN_VCHANNEL1); 804 791 mxs_lradc_prepare_pressure(lradc); 805 792 return; 806 793 807 794 case LRADC_SAMPLE_PRESSURE: 808 - lradc->ts_pressure = 809 - mxs_lradc_read_ts_pressure(lradc, TS_CH_XP, TS_CH_YM); 795 + lradc->ts_pressure = mxs_lradc_read_ts_pressure(lradc, 796 + TOUCHSCREEN_VCHANNEL2, 797 + TOUCHSCREEN_VCHANNEL1); 810 798 mxs_lradc_complete_touch_event(lradc); 811 799 return; 812 800 813 801 case LRADC_SAMPLE_VALID: 814 - val = mxs_lradc_read_ts_channel(lradc); /* ignore the value */ 815 802 mxs_lradc_finish_touch_event(lradc, 1); 816 803 break; 817 804 } ··· 829 844 * used if doing raw sampling. 830 845 */ 831 846 if (lradc->soc == IMX28_LRADC) 832 - mxs_lradc_reg_clear(lradc, LRADC_CTRL1_MX28_LRADC_IRQ_EN_MASK, 847 + mxs_lradc_reg_clear(lradc, LRADC_CTRL1_LRADC_IRQ_EN(0), 833 848 LRADC_CTRL1); 834 - mxs_lradc_reg_clear(lradc, 0xff, LRADC_CTRL0); 849 + mxs_lradc_reg_clear(lradc, 0x1, LRADC_CTRL0); 835 850 836 851 /* Enable / disable the divider per requirement */ 837 852 if (test_bit(chan, &lradc->is_divided)) ··· 1075 1090 { 1076 1091 /* stop all interrupts from firing */ 1077 1092 mxs_lradc_reg_clear(lradc, LRADC_CTRL1_TOUCH_DETECT_IRQ_EN | 1078 - LRADC_CTRL1_LRADC_IRQ_EN(2) | LRADC_CTRL1_LRADC_IRQ_EN(3) | 1079 - LRADC_CTRL1_LRADC_IRQ_EN(4) | LRADC_CTRL1_LRADC_IRQ_EN(5), 1080 - LRADC_CTRL1); 1093 + LRADC_CTRL1_LRADC_IRQ_EN(TOUCHSCREEN_VCHANNEL1) | 1094 + LRADC_CTRL1_LRADC_IRQ_EN(TOUCHSCREEN_VCHANNEL2), LRADC_CTRL1); 1081 1095 1082 1096 /* Power-down touchscreen touch-detect circuitry. */ 1083 1097 mxs_lradc_reg_clear(lradc, mxs_lradc_plate_mask(lradc), LRADC_CTRL0); ··· 1142 1158 struct iio_dev *iio = data; 1143 1159 struct mxs_lradc *lradc = iio_priv(iio); 1144 1160 unsigned long reg = readl(lradc->base + LRADC_CTRL1); 1161 + uint32_t clr_irq = mxs_lradc_irq_mask(lradc); 1145 1162 const uint32_t ts_irq_mask = 1146 1163 LRADC_CTRL1_TOUCH_DETECT_IRQ | 1147 - LRADC_CTRL1_LRADC_IRQ(2) | 1148 - LRADC_CTRL1_LRADC_IRQ(3) | 1149 - LRADC_CTRL1_LRADC_IRQ(4) | 1150 - LRADC_CTRL1_LRADC_IRQ(5); 1164 + LRADC_CTRL1_LRADC_IRQ(TOUCHSCREEN_VCHANNEL1) | 1165 + LRADC_CTRL1_LRADC_IRQ(TOUCHSCREEN_VCHANNEL2); 1151 1166 1152 1167 if (!(reg & mxs_lradc_irq_mask(lradc))) 1153 1168 return IRQ_NONE; 1154 1169 1155 - if (lradc->use_touchscreen && (reg & ts_irq_mask)) 1170 + if (lradc->use_touchscreen && (reg & ts_irq_mask)) { 1156 1171 mxs_lradc_handle_touch(lradc); 1157 1172 1158 - if (iio_buffer_enabled(iio)) 1159 - iio_trigger_poll(iio->trig); 1160 - else if (reg & LRADC_CTRL1_LRADC_IRQ(0)) 1161 - complete(&lradc->completion); 1173 + /* Make sure we don't clear the next conversion's interrupt. */ 1174 + clr_irq &= ~(LRADC_CTRL1_LRADC_IRQ(TOUCHSCREEN_VCHANNEL1) | 1175 + LRADC_CTRL1_LRADC_IRQ(TOUCHSCREEN_VCHANNEL2)); 1176 + } 1162 1177 1163 - mxs_lradc_reg_clear(lradc, reg & mxs_lradc_irq_mask(lradc), 1164 - LRADC_CTRL1); 1178 + if (iio_buffer_enabled(iio)) { 1179 + if (reg & lradc->buffer_vchans) 1180 + iio_trigger_poll(iio->trig); 1181 + } else if (reg & LRADC_CTRL1_LRADC_IRQ(0)) { 1182 + complete(&lradc->completion); 1183 + } 1184 + 1185 + mxs_lradc_reg_clear(lradc, reg & clr_irq, LRADC_CTRL1); 1165 1186 1166 1187 return IRQ_HANDLED; 1167 1188 } ··· 1278 1289 } 1279 1290 1280 1291 if (lradc->soc == IMX28_LRADC) 1281 - mxs_lradc_reg_clear(lradc, LRADC_CTRL1_MX28_LRADC_IRQ_EN_MASK, 1282 - LRADC_CTRL1); 1283 - mxs_lradc_reg_clear(lradc, 0xff, LRADC_CTRL0); 1292 + mxs_lradc_reg_clear(lradc, 1293 + lradc->buffer_vchans << LRADC_CTRL1_LRADC_IRQ_EN_OFFSET, 1294 + LRADC_CTRL1); 1295 + mxs_lradc_reg_clear(lradc, lradc->buffer_vchans, LRADC_CTRL0); 1284 1296 1285 1297 for_each_set_bit(chan, iio->active_scan_mask, LRADC_MAX_TOTAL_CHANS) { 1286 1298 ctrl4_set |= chan << LRADC_CTRL4_LRADCSELECT_OFFSET(ofs); ··· 1314 1324 mxs_lradc_reg_clear(lradc, LRADC_DELAY_TRIGGER_LRADCS_MASK | 1315 1325 LRADC_DELAY_KICK, LRADC_DELAY(0)); 1316 1326 1317 - mxs_lradc_reg_clear(lradc, 0xff, LRADC_CTRL0); 1327 + mxs_lradc_reg_clear(lradc, lradc->buffer_vchans, LRADC_CTRL0); 1318 1328 if (lradc->soc == IMX28_LRADC) 1319 - mxs_lradc_reg_clear(lradc, LRADC_CTRL1_MX28_LRADC_IRQ_EN_MASK, 1320 - LRADC_CTRL1); 1329 + mxs_lradc_reg_clear(lradc, 1330 + lradc->buffer_vchans << LRADC_CTRL1_LRADC_IRQ_EN_OFFSET, 1331 + LRADC_CTRL1); 1321 1332 1322 1333 kfree(lradc->buffer); 1323 1334 mutex_unlock(&lradc->lock); ··· 1344 1353 if (lradc->use_touchbutton) 1345 1354 rsvd_chans++; 1346 1355 if (lradc->use_touchscreen) 1347 - rsvd_chans++; 1356 + rsvd_chans += 2; 1348 1357 1349 1358 /* Test for attempts to map channels with special mode of operation. */ 1350 1359 if (bitmap_intersects(mask, &rsvd_mask, LRADC_MAX_TOTAL_CHANS)) ··· 1403 1412 BIT(IIO_CHAN_INFO_SCALE), 1404 1413 .channel = 8, 1405 1414 .scan_type = {.sign = 'u', .realbits = 18, .storagebits = 32,}, 1415 + }, 1416 + /* Hidden channel to keep indexes */ 1417 + { 1418 + .type = IIO_TEMP, 1419 + .indexed = 1, 1420 + .scan_index = -1, 1421 + .channel = 9, 1406 1422 }, 1407 1423 MXS_ADC_CHAN(10, IIO_VOLTAGE), /* VDDIO */ 1408 1424 MXS_ADC_CHAN(11, IIO_VOLTAGE), /* VTH */ ··· 1580 1582 } 1581 1583 1582 1584 touch_ret = mxs_lradc_probe_touchscreen(lradc, node); 1585 + 1586 + if (touch_ret == 0) 1587 + lradc->buffer_vchans = BUFFER_VCHANS_LIMITED; 1588 + else 1589 + lradc->buffer_vchans = BUFFER_VCHANS_ALL; 1583 1590 1584 1591 /* Grab all IRQ sources */ 1585 1592 for (i = 0; i < of_cfg->irq_count; i++) {
+2 -1
drivers/staging/iio/resolver/ad2s1200.c
··· 18 18 #include <linux/delay.h> 19 19 #include <linux/gpio.h> 20 20 #include <linux/module.h> 21 + #include <linux/bitops.h> 21 22 22 23 #include <linux/iio/iio.h> 23 24 #include <linux/iio/sysfs.h> ··· 69 68 break; 70 69 case IIO_ANGL_VEL: 71 70 vel = (((s16)(st->rx[0])) << 4) | ((st->rx[1] & 0xF0) >> 4); 72 - vel = (vel << 4) >> 4; 71 + vel = sign_extend32(vel, 11); 73 72 *val = vel; 74 73 break; 75 74 default: