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

+4 -5

drivers/iio/common/st_sensors/st_sensors_core.c

··· 62 62 int st_sensors_set_odr(struct iio_dev *indio_dev, unsigned int odr) 63 63 { 64 64 int err; 65 - struct st_sensor_odr_avl odr_out; 65 + struct st_sensor_odr_avl odr_out = {0, 0}; 66 66 struct st_sensor_data *sdata = iio_priv(indio_dev); 67 67 68 68 err = st_sensors_match_odr(sdata->sensor, odr, &odr_out); ··· 114 114 115 115 static int st_sensors_set_fullscale(struct iio_dev *indio_dev, unsigned int fs) 116 116 { 117 - int err, i; 117 + int err, i = 0; 118 118 struct st_sensor_data *sdata = iio_priv(indio_dev); 119 119 120 120 err = st_sensors_match_fs(sdata->sensor, fs, &i); ··· 139 139 140 140 int st_sensors_set_enable(struct iio_dev *indio_dev, bool enable) 141 141 { 142 - bool found; 143 142 u8 tmp_value; 144 143 int err = -EINVAL; 145 - struct st_sensor_odr_avl odr_out; 144 + bool found = false; 145 + struct st_sensor_odr_avl odr_out = {0, 0}; 146 146 struct st_sensor_data *sdata = iio_priv(indio_dev); 147 147 148 148 if (enable) { 149 - found = false; 150 149 tmp_value = sdata->sensor->pw.value_on; 151 150 if ((sdata->sensor->odr.addr == sdata->sensor->pw.addr) && 152 151 (sdata->sensor->odr.mask == sdata->sensor->pw.mask)) {

+38 -26

drivers/iio/dac/ad5064.c

··· 27 27 #define AD5064_ADDR(x) ((x) << 20) 28 28 #define AD5064_CMD(x) ((x) << 24) 29 29 30 - #define AD5064_ADDR_DAC(chan) (chan) 31 30 #define AD5064_ADDR_ALL_DAC 0xF 32 31 33 32 #define AD5064_CMD_WRITE_INPUT_N 0x0 ··· 130 131 } 131 132 132 133 static int ad5064_sync_powerdown_mode(struct ad5064_state *st, 133 - unsigned int channel) 134 + const struct iio_chan_spec *chan) 134 135 { 135 136 unsigned int val; 136 137 int ret; 137 138 138 - val = (0x1 << channel); 139 + val = (0x1 << chan->address); 139 140 140 - if (st->pwr_down[channel]) 141 - val |= st->pwr_down_mode[channel] << 8; 141 + if (st->pwr_down[chan->channel]) 142 + val |= st->pwr_down_mode[chan->channel] << 8; 142 143 143 144 ret = ad5064_write(st, AD5064_CMD_POWERDOWN_DAC, 0, val, 0); 144 145 ··· 168 169 mutex_lock(&indio_dev->mlock); 169 170 st->pwr_down_mode[chan->channel] = mode + 1; 170 171 171 - ret = ad5064_sync_powerdown_mode(st, chan->channel); 172 + ret = ad5064_sync_powerdown_mode(st, chan); 172 173 mutex_unlock(&indio_dev->mlock); 173 174 174 175 return ret; ··· 204 205 mutex_lock(&indio_dev->mlock); 205 206 st->pwr_down[chan->channel] = pwr_down; 206 207 207 - ret = ad5064_sync_powerdown_mode(st, chan->channel); 208 + ret = ad5064_sync_powerdown_mode(st, chan); 208 209 mutex_unlock(&indio_dev->mlock); 209 210 return ret ? ret : len; 210 211 } ··· 257 258 258 259 switch (mask) { 259 260 case IIO_CHAN_INFO_RAW: 260 - if (val > (1 << chan->scan_type.realbits) || val < 0) 261 + if (val >= (1 << chan->scan_type.realbits) || val < 0) 261 262 return -EINVAL; 262 263 263 264 mutex_lock(&indio_dev->mlock); ··· 291 292 { }, 292 293 }; 293 294 294 - #define AD5064_CHANNEL(chan, bits) { \ 295 + #define AD5064_CHANNEL(chan, addr, bits) { \ 295 296 .type = IIO_VOLTAGE, \ 296 297 .indexed = 1, \ 297 298 .output = 1, \ 298 299 .channel = (chan), \ 299 300 .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT | \ 300 301 IIO_CHAN_INFO_SCALE_SEPARATE_BIT, \ 301 - .address = AD5064_ADDR_DAC(chan), \ 302 + .address = addr, \ 302 303 .scan_type = IIO_ST('u', (bits), 16, 20 - (bits)), \ 303 304 .ext_info = ad5064_ext_info, \ 304 305 } 305 306 306 307 #define DECLARE_AD5064_CHANNELS(name, bits) \ 307 308 const struct iio_chan_spec name[] = { \ 308 - AD5064_CHANNEL(0, bits), \ 309 - AD5064_CHANNEL(1, bits), \ 310 - AD5064_CHANNEL(2, bits), \ 311 - AD5064_CHANNEL(3, bits), \ 312 - AD5064_CHANNEL(4, bits), \ 313 - AD5064_CHANNEL(5, bits), \ 314 - AD5064_CHANNEL(6, bits), \ 315 - AD5064_CHANNEL(7, bits), \ 309 + AD5064_CHANNEL(0, 0, bits), \ 310 + AD5064_CHANNEL(1, 1, bits), \ 311 + AD5064_CHANNEL(2, 2, bits), \ 312 + AD5064_CHANNEL(3, 3, bits), \ 313 + AD5064_CHANNEL(4, 4, bits), \ 314 + AD5064_CHANNEL(5, 5, bits), \ 315 + AD5064_CHANNEL(6, 6, bits), \ 316 + AD5064_CHANNEL(7, 7, bits), \ 317 + } 318 + 319 + #define DECLARE_AD5065_CHANNELS(name, bits) \ 320 + const struct iio_chan_spec name[] = { \ 321 + AD5064_CHANNEL(0, 0, bits), \ 322 + AD5064_CHANNEL(1, 3, bits), \ 316 323 } 317 324 318 325 static DECLARE_AD5064_CHANNELS(ad5024_channels, 12); 319 326 static DECLARE_AD5064_CHANNELS(ad5044_channels, 14); 320 327 static DECLARE_AD5064_CHANNELS(ad5064_channels, 16); 328 + 329 + static DECLARE_AD5065_CHANNELS(ad5025_channels, 12); 330 + static DECLARE_AD5065_CHANNELS(ad5045_channels, 14); 331 + static DECLARE_AD5065_CHANNELS(ad5065_channels, 16); 321 332 322 333 static const struct ad5064_chip_info ad5064_chip_info_tbl[] = { 323 334 [ID_AD5024] = { ··· 337 328 }, 338 329 [ID_AD5025] = { 339 330 .shared_vref = false, 340 - .channels = ad5024_channels, 331 + .channels = ad5025_channels, 341 332 .num_channels = 2, 342 333 }, 343 334 [ID_AD5044] = { ··· 347 338 }, 348 339 [ID_AD5045] = { 349 340 .shared_vref = false, 350 - .channels = ad5044_channels, 341 + .channels = ad5045_channels, 351 342 .num_channels = 2, 352 343 }, 353 344 [ID_AD5064] = { ··· 362 353 }, 363 354 [ID_AD5065] = { 364 355 .shared_vref = false, 365 - .channels = ad5064_channels, 356 + .channels = ad5065_channels, 366 357 .num_channels = 2, 367 358 }, 368 359 [ID_AD5628_1] = { ··· 438 429 { 439 430 struct iio_dev *indio_dev; 440 431 struct ad5064_state *st; 432 + unsigned int midscale; 441 433 unsigned int i; 442 434 int ret; 443 435 ··· 475 465 goto error_free_reg; 476 466 } 477 467 478 - for (i = 0; i < st->chip_info->num_channels; ++i) { 479 - st->pwr_down_mode[i] = AD5064_LDAC_PWRDN_1K; 480 - st->dac_cache[i] = 0x8000; 481 - } 482 - 483 468 indio_dev->dev.parent = dev; 484 469 indio_dev->name = name; 485 470 indio_dev->info = &ad5064_info; 486 471 indio_dev->modes = INDIO_DIRECT_MODE; 487 472 indio_dev->channels = st->chip_info->channels; 488 473 indio_dev->num_channels = st->chip_info->num_channels; 474 + 475 + midscale = (1 << indio_dev->channels[0].scan_type.realbits) / 2; 476 + 477 + for (i = 0; i < st->chip_info->num_channels; ++i) { 478 + st->pwr_down_mode[i] = AD5064_LDAC_PWRDN_1K; 479 + st->dac_cache[i] = midscale; 480 + } 489 481 490 482 ret = iio_device_register(indio_dev); 491 483 if (ret)

+1

drivers/iio/imu/inv_mpu6050/Kconfig

··· 5 5 config INV_MPU6050_IIO 6 6 tristate "Invensense MPU6050 devices" 7 7 depends on I2C && SYSFS 8 + select IIO_BUFFER 8 9 select IIO_TRIGGERED_BUFFER 9 10 help 10 11 This driver supports the Invensense MPU6050 devices.

+10 -6

drivers/staging/comedi/drivers/dt9812.c

··· 947 947 unsigned int *data) 948 948 { 949 949 struct comedi_dt9812 *devpriv = dev->private; 950 + unsigned int channel = CR_CHAN(insn->chanspec); 950 951 int n; 951 952 u8 bits = 0; 952 953 953 954 dt9812_digital_in(devpriv->slot, &bits); 954 955 for (n = 0; n < insn->n; n++) 955 - data[n] = ((1 << insn->chanspec) & bits) != 0; 956 + data[n] = ((1 << channel) & bits) != 0; 956 957 return n; 957 958 } 958 959 ··· 962 961 unsigned int *data) 963 962 { 964 963 struct comedi_dt9812 *devpriv = dev->private; 964 + unsigned int channel = CR_CHAN(insn->chanspec); 965 965 int n; 966 966 u8 bits = 0; 967 967 968 968 dt9812_digital_out_shadow(devpriv->slot, &bits); 969 969 for (n = 0; n < insn->n; n++) { 970 - u8 mask = 1 << insn->chanspec; 970 + u8 mask = 1 << channel; 971 971 972 972 bits &= ~mask; 973 973 if (data[n]) ··· 983 981 unsigned int *data) 984 982 { 985 983 struct comedi_dt9812 *devpriv = dev->private; 984 + unsigned int channel = CR_CHAN(insn->chanspec); 986 985 int n; 987 986 988 987 for (n = 0; n < insn->n; n++) { 989 988 u16 value = 0; 990 989 991 - dt9812_analog_in(devpriv->slot, insn->chanspec, &value, 992 - DT9812_GAIN_1); 990 + dt9812_analog_in(devpriv->slot, channel, &value, DT9812_GAIN_1); 993 991 data[n] = value; 994 992 } 995 993 return n; ··· 1000 998 unsigned int *data) 1001 999 { 1002 1000 struct comedi_dt9812 *devpriv = dev->private; 1001 + unsigned int channel = CR_CHAN(insn->chanspec); 1003 1002 int n; 1004 1003 u16 value; 1005 1004 1006 1005 for (n = 0; n < insn->n; n++) { 1007 1006 value = 0; 1008 - dt9812_analog_out_shadow(devpriv->slot, insn->chanspec, &value); 1007 + dt9812_analog_out_shadow(devpriv->slot, channel, &value); 1009 1008 data[n] = value; 1010 1009 } 1011 1010 return n; ··· 1017 1014 unsigned int *data) 1018 1015 { 1019 1016 struct comedi_dt9812 *devpriv = dev->private; 1017 + unsigned int channel = CR_CHAN(insn->chanspec); 1020 1018 int n; 1021 1019 1022 1020 for (n = 0; n < insn->n; n++) 1023 - dt9812_analog_out(devpriv->slot, insn->chanspec, data[n]); 1021 + dt9812_analog_out(devpriv->slot, channel, data[n]); 1024 1022 return n; 1025 1023 } 1026 1024

+19 -12

drivers/staging/comedi/drivers/usbdux.c

··· 730 730 static int usbduxsub_start(struct usbduxsub *usbduxsub) 731 731 { 732 732 int errcode = 0; 733 - uint8_t local_transfer_buffer[16]; 733 + uint8_t *local_transfer_buffer; 734 + 735 + local_transfer_buffer = kmalloc(1, GFP_KERNEL); 736 + if (!local_transfer_buffer) 737 + return -ENOMEM; 734 738 735 739 /* 7f92 to zero */ 736 - local_transfer_buffer[0] = 0; 740 + *local_transfer_buffer = 0; 737 741 errcode = usb_control_msg(usbduxsub->usbdev, 738 742 /* create a pipe for a control transfer */ 739 743 usb_sndctrlpipe(usbduxsub->usbdev, 0), ··· 755 751 1, 756 752 /* Timeout */ 757 753 BULK_TIMEOUT); 758 - if (errcode < 0) { 754 + if (errcode < 0) 759 755 dev_err(&usbduxsub->interface->dev, 760 756 "comedi_: control msg failed (start)\n"); 761 - return errcode; 762 - } 763 - return 0; 757 + 758 + kfree(local_transfer_buffer); 759 + return errcode; 764 760 } 765 761 766 762 static int usbduxsub_stop(struct usbduxsub *usbduxsub) 767 763 { 768 764 int errcode = 0; 765 + uint8_t *local_transfer_buffer; 769 766 770 - uint8_t local_transfer_buffer[16]; 767 + local_transfer_buffer = kmalloc(1, GFP_KERNEL); 768 + if (!local_transfer_buffer) 769 + return -ENOMEM; 771 770 772 771 /* 7f92 to one */ 773 - local_transfer_buffer[0] = 1; 772 + *local_transfer_buffer = 1; 774 773 errcode = usb_control_msg(usbduxsub->usbdev, 775 774 usb_sndctrlpipe(usbduxsub->usbdev, 0), 776 775 /* bRequest, "Firmware" */ ··· 788 781 1, 789 782 /* Timeout */ 790 783 BULK_TIMEOUT); 791 - if (errcode < 0) { 784 + if (errcode < 0) 792 785 dev_err(&usbduxsub->interface->dev, 793 786 "comedi_: control msg failed (stop)\n"); 794 - return errcode; 795 - } 796 - return 0; 787 + 788 + kfree(local_transfer_buffer); 789 + return errcode; 797 790 } 798 791 799 792 static int usbduxsub_upload(struct usbduxsub *usbduxsub,

+18 -12

drivers/staging/comedi/drivers/usbduxfast.c

··· 436 436 static int usbduxfastsub_start(struct usbduxfastsub_s *udfs) 437 437 { 438 438 int ret; 439 - unsigned char local_transfer_buffer[16]; 439 + unsigned char *local_transfer_buffer; 440 + 441 + local_transfer_buffer = kmalloc(1, GFP_KERNEL); 442 + if (!local_transfer_buffer) 443 + return -ENOMEM; 440 444 441 445 /* 7f92 to zero */ 442 - local_transfer_buffer[0] = 0; 446 + *local_transfer_buffer = 0; 443 447 /* bRequest, "Firmware" */ 444 448 ret = usb_control_msg(udfs->usbdev, usb_sndctrlpipe(udfs->usbdev, 0), 445 449 USBDUXFASTSUB_FIRMWARE, ··· 454 450 local_transfer_buffer, 455 451 1, /* Length */ 456 452 EZTIMEOUT); /* Timeout */ 457 - if (ret < 0) { 453 + if (ret < 0) 458 454 dev_err(&udfs->interface->dev, 459 455 "control msg failed (start)\n"); 460 - return ret; 461 - } 462 456 463 - return 0; 457 + kfree(local_transfer_buffer); 458 + return ret; 464 459 } 465 460 466 461 static int usbduxfastsub_stop(struct usbduxfastsub_s *udfs) 467 462 { 468 463 int ret; 469 - unsigned char local_transfer_buffer[16]; 464 + unsigned char *local_transfer_buffer; 465 + 466 + local_transfer_buffer = kmalloc(1, GFP_KERNEL); 467 + if (!local_transfer_buffer) 468 + return -ENOMEM; 470 469 471 470 /* 7f92 to one */ 472 - local_transfer_buffer[0] = 1; 471 + *local_transfer_buffer = 1; 473 472 /* bRequest, "Firmware" */ 474 473 ret = usb_control_msg(udfs->usbdev, usb_sndctrlpipe(udfs->usbdev, 0), 475 474 USBDUXFASTSUB_FIRMWARE, ··· 481 474 0x0000, /* Index */ 482 475 local_transfer_buffer, 1, /* Length */ 483 476 EZTIMEOUT); /* Timeout */ 484 - if (ret < 0) { 477 + if (ret < 0) 485 478 dev_err(&udfs->interface->dev, 486 479 "control msg failed (stop)\n"); 487 - return ret; 488 - } 489 480 490 - return 0; 481 + kfree(local_transfer_buffer); 482 + return ret; 491 483 } 492 484 493 485 static int usbduxfastsub_upload(struct usbduxfastsub_s *udfs,

+17 -10

drivers/staging/comedi/drivers/usbduxsigma.c

··· 681 681 static int usbduxsub_start(struct usbduxsub *usbduxsub) 682 682 { 683 683 int errcode = 0; 684 - uint8_t local_transfer_buffer[16]; 684 + uint8_t *local_transfer_buffer; 685 + 686 + local_transfer_buffer = kmalloc(16, GFP_KERNEL); 687 + if (!local_transfer_buffer) 688 + return -ENOMEM; 685 689 686 690 /* 7f92 to zero */ 687 691 local_transfer_buffer[0] = 0; ··· 706 702 1, 707 703 /* Timeout */ 708 704 BULK_TIMEOUT); 709 - if (errcode < 0) { 705 + if (errcode < 0) 710 706 dev_err(&usbduxsub->interface->dev, 711 707 "comedi_: control msg failed (start)\n"); 712 - return errcode; 713 - } 714 - return 0; 708 + 709 + kfree(local_transfer_buffer); 710 + return errcode; 715 711 } 716 712 717 713 static int usbduxsub_stop(struct usbduxsub *usbduxsub) 718 714 { 719 715 int errcode = 0; 716 + uint8_t *local_transfer_buffer; 720 717 721 - uint8_t local_transfer_buffer[16]; 718 + local_transfer_buffer = kmalloc(16, GFP_KERNEL); 719 + if (!local_transfer_buffer) 720 + return -ENOMEM; 722 721 723 722 /* 7f92 to one */ 724 723 local_transfer_buffer[0] = 1; ··· 739 732 1, 740 733 /* Timeout */ 741 734 BULK_TIMEOUT); 742 - if (errcode < 0) { 735 + if (errcode < 0) 743 736 dev_err(&usbduxsub->interface->dev, 744 737 "comedi_: control msg failed (stop)\n"); 745 - return errcode; 746 - } 747 - return 0; 738 + 739 + kfree(local_transfer_buffer); 740 + return errcode; 748 741 } 749 742 750 743 static int usbduxsub_upload(struct usbduxsub *usbduxsub,

+12 -11

drivers/staging/imx-drm/ipuv3-crtc.c

··· 483 483 goto err_out; 484 484 } 485 485 486 - ipu_crtc->irq = ipu_idmac_channel_irq(ipu, ipu_crtc->ipu_ch, 487 - IPU_IRQ_EOF); 488 - ret = devm_request_irq(ipu_crtc->dev, ipu_crtc->irq, ipu_irq_handler, 0, 489 - "imx_drm", ipu_crtc); 490 - if (ret < 0) { 491 - dev_err(ipu_crtc->dev, "irq request failed with %d.\n", ret); 492 - goto err_out; 493 - } 494 - 495 - disable_irq(ipu_crtc->irq); 496 - 497 486 return 0; 498 487 err_out: 499 488 ipu_put_resources(ipu_crtc); ··· 493 504 static int ipu_crtc_init(struct ipu_crtc *ipu_crtc, 494 505 struct ipu_client_platformdata *pdata) 495 506 { 507 + struct ipu_soc *ipu = dev_get_drvdata(ipu_crtc->dev->parent); 496 508 int ret; 497 509 498 510 ret = ipu_get_resources(ipu_crtc, pdata); ··· 511 521 dev_err(ipu_crtc->dev, "adding crtc failed with %d.\n", ret); 512 522 goto err_put_resources; 513 523 } 524 + 525 + ipu_crtc->irq = ipu_idmac_channel_irq(ipu, ipu_crtc->ipu_ch, 526 + IPU_IRQ_EOF); 527 + ret = devm_request_irq(ipu_crtc->dev, ipu_crtc->irq, ipu_irq_handler, 0, 528 + "imx_drm", ipu_crtc); 529 + if (ret < 0) { 530 + dev_err(ipu_crtc->dev, "irq request failed with %d.\n", ret); 531 + goto err_put_resources; 532 + } 533 + 534 + disable_irq(ipu_crtc->irq); 514 535 515 536 return 0; 516 537

+1 -1

drivers/staging/vt6656/card.c

··· 790 790 if ((~uLowNextTBTT) < uLowRemain) 791 791 qwTSF = ((qwTSF >> 32) + 1) << 32; 792 792 793 - qwTSF = (qwTSF & 0xffffffff00000000UL) | 793 + qwTSF = (qwTSF & 0xffffffff00000000ULL) | 794 794 (u64)(uLowNextTBTT + uLowRemain); 795 795 796 796 return (qwTSF);

-4

drivers/staging/vt6656/main_usb.c

··· 669 669 if (device->flags & DEVICE_FLAGS_OPENED) 670 670 device_close(device->dev); 671 671 672 - usb_put_dev(interface_to_usbdev(intf)); 673 - 674 672 return 0; 675 673 } 676 674 ··· 678 680 679 681 if (!device || !device->dev) 680 682 return -ENODEV; 681 - 682 - usb_get_dev(interface_to_usbdev(intf)); 683 683 684 684 if (!(device->flags & DEVICE_FLAGS_OPENED)) 685 685 device_open(device->dev);

+6 -3

include/linux/iio/common/st_sensors.h

··· 227 227 }; 228 228 229 229 #ifdef CONFIG_IIO_BUFFER 230 + irqreturn_t st_sensors_trigger_handler(int irq, void *p); 231 + 232 + int st_sensors_get_buffer_element(struct iio_dev *indio_dev, u8 *buf); 233 + #endif 234 + 235 + #ifdef CONFIG_IIO_TRIGGER 230 236 int st_sensors_allocate_trigger(struct iio_dev *indio_dev, 231 237 const struct iio_trigger_ops *trigger_ops); 232 238 233 239 void st_sensors_deallocate_trigger(struct iio_dev *indio_dev); 234 240 235 - irqreturn_t st_sensors_trigger_handler(int irq, void *p); 236 - 237 - int st_sensors_get_buffer_element(struct iio_dev *indio_dev, u8 *buf); 238 241 #else 239 242 static inline int st_sensors_allocate_trigger(struct iio_dev *indio_dev, 240 243 const struct iio_trigger_ops *trigger_ops)

Configure Feed

Configure Feed