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

Configure Feed

Select the types of activity you want to include in your feed.

Merge tag 'char-misc-6.16-rc7' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/char-misc

Pull char / misc / IIO fixes from Greg KH:
"Here are some char/misc/iio and other driver fixes for 6.16-rc7.
Included in here are:

- IIO driver fixes for reported problems

- Interconnect driver fixes for reported problems

- nvmem driver fixes

- bunch of comedi driver fixes for long-term bugs

- Kconfig dependancy fixes for mux drivers

- other small driver fixes for reported problems.

All of these have been in linux-next for a while with no reported
problems"

* tag 'char-misc-6.16-rc7' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/char-misc: (35 commits)
nvmem: layouts: u-boot-env: remove crc32 endianness conversion
misc: amd-sbi: Explicitly clear in/out arg "mb_in_out"
misc: amd-sbi: Address copy_to/from_user() warning reported in smatch
misc: amd-sbi: Address potential integer overflow issue reported in smatch
comedi: comedi_test: Fix possible deletion of uninitialized timers
comedi: Fix initialization of data for instructions that write to subdevice
comedi: Fix use of uninitialized data in insn_rw_emulate_bits()
comedi: das6402: Fix bit shift out of bounds
comedi: aio_iiro_16: Fix bit shift out of bounds
comedi: pcl812: Fix bit shift out of bounds
comedi: das16m1: Fix bit shift out of bounds
comedi: Fix some signed shift left operations
comedi: Fail COMEDI_INSNLIST ioctl if n_insns is too large
nvmem: imx-ocotp: fix MAC address byte length
MAINTAINERS: add miscdevice Rust abstractions
mux: mmio: Fix missing CONFIG_REGMAP_MMIO
iio: dac: ad3530r: Fix incorrect masking for channels 4-7 in powerdown mode
iio: adc: ad7380: fix adi,gain-milli property parsing
iio: adc: ad7949: use spi_is_bpw_supported()
iio: accel: fxls8962af: Fix use after free in fxls8962af_fifo_flush
...

Linus Torvalds ecf11d31 990b11a5

+213 -112
-6
Documentation/devicetree/bindings/iio/adc/adi,ad7606.yaml
··· 223 223 - required: 224 224 - pwms 225 225 226 - - oneOf: 227 - - required: 228 - - interrupts 229 - - required: 230 - - io-backends 231 - 232 226 - if: 233 227 properties: 234 228 compatible:
+1 -1
Documentation/devicetree/bindings/iio/gyroscope/invensense,mpu3050.yaml
··· 21 21 vlogic-supply: true 22 22 23 23 interrupts: 24 - minItems: 1 24 + maxItems: 1 25 25 description: 26 26 Interrupt mapping for the trigger interrupt from the internal oscillator. 27 27
+1
MAINTAINERS
··· 5570 5570 F: drivers/char/ 5571 5571 F: drivers/misc/ 5572 5572 F: include/linux/miscdevice.h 5573 + F: rust/kernel/miscdevice.rs 5573 5574 F: samples/rust/rust_misc_device.rs 5574 5575 X: drivers/char/agp/ 5575 5576 X: drivers/char/hw_random/
+28 -2
drivers/comedi/comedi_fops.c
··· 1556 1556 } 1557 1557 1558 1558 for (i = 0; i < n_insns; ++i) { 1559 + unsigned int n = insns[i].n; 1560 + 1559 1561 if (insns[i].insn & INSN_MASK_WRITE) { 1560 1562 if (copy_from_user(data, insns[i].data, 1561 - insns[i].n * sizeof(unsigned int))) { 1563 + n * sizeof(unsigned int))) { 1562 1564 dev_dbg(dev->class_dev, 1563 1565 "copy_from_user failed\n"); 1564 1566 ret = -EFAULT; 1565 1567 goto error; 1568 + } 1569 + if (n < MIN_SAMPLES) { 1570 + memset(&data[n], 0, (MIN_SAMPLES - n) * 1571 + sizeof(unsigned int)); 1566 1572 } 1567 1573 } 1568 1574 ret = parse_insn(dev, insns + i, data, file); ··· 1576 1570 goto error; 1577 1571 if (insns[i].insn & INSN_MASK_READ) { 1578 1572 if (copy_to_user(insns[i].data, data, 1579 - insns[i].n * sizeof(unsigned int))) { 1573 + n * sizeof(unsigned int))) { 1580 1574 dev_dbg(dev->class_dev, 1581 1575 "copy_to_user failed\n"); 1582 1576 ret = -EFAULT; ··· 1593 1587 if (ret < 0) 1594 1588 return ret; 1595 1589 return i; 1590 + } 1591 + 1592 + #define MAX_INSNS MAX_SAMPLES 1593 + static int check_insnlist_len(struct comedi_device *dev, unsigned int n_insns) 1594 + { 1595 + if (n_insns > MAX_INSNS) { 1596 + dev_dbg(dev->class_dev, "insnlist length too large\n"); 1597 + return -EINVAL; 1598 + } 1599 + return 0; 1596 1600 } 1597 1601 1598 1602 /* ··· 1648 1632 insn->n * sizeof(unsigned int))) { 1649 1633 ret = -EFAULT; 1650 1634 goto error; 1635 + } 1636 + if (insn->n < MIN_SAMPLES) { 1637 + memset(&data[insn->n], 0, 1638 + (MIN_SAMPLES - insn->n) * sizeof(unsigned int)); 1651 1639 } 1652 1640 } 1653 1641 ret = parse_insn(dev, insn, data, file); ··· 2259 2239 rc = -EFAULT; 2260 2240 break; 2261 2241 } 2242 + rc = check_insnlist_len(dev, insnlist.n_insns); 2243 + if (rc) 2244 + break; 2262 2245 insns = kcalloc(insnlist.n_insns, sizeof(*insns), GFP_KERNEL); 2263 2246 if (!insns) { 2264 2247 rc = -ENOMEM; ··· 3165 3142 if (copy_from_user(&insnlist32, compat_ptr(arg), sizeof(insnlist32))) 3166 3143 return -EFAULT; 3167 3144 3145 + rc = check_insnlist_len(dev, insnlist32.n_insns); 3146 + if (rc) 3147 + return rc; 3168 3148 insns = kcalloc(insnlist32.n_insns, sizeof(*insns), GFP_KERNEL); 3169 3149 if (!insns) 3170 3150 return -ENOMEM;
+10 -7
drivers/comedi/drivers.c
··· 339 339 unsigned int *data, 340 340 unsigned int mask) 341 341 { 342 - unsigned int chan_mask = 1 << CR_CHAN(insn->chanspec); 342 + unsigned int chan = CR_CHAN(insn->chanspec); 343 343 344 - if (!mask) 345 - mask = chan_mask; 344 + if (!mask && chan < 32) 345 + mask = 1U << chan; 346 346 347 347 switch (data[0]) { 348 348 case INSN_CONFIG_DIO_INPUT: ··· 382 382 unsigned int comedi_dio_update_state(struct comedi_subdevice *s, 383 383 unsigned int *data) 384 384 { 385 - unsigned int chanmask = (s->n_chan < 32) ? ((1 << s->n_chan) - 1) 385 + unsigned int chanmask = (s->n_chan < 32) ? ((1U << s->n_chan) - 1) 386 386 : 0xffffffff; 387 387 unsigned int mask = data[0] & chanmask; 388 388 unsigned int bits = data[1]; ··· 615 615 unsigned int _data[2]; 616 616 int ret; 617 617 618 + if (insn->n == 0) 619 + return 0; 620 + 618 621 memset(_data, 0, sizeof(_data)); 619 622 memset(&_insn, 0, sizeof(_insn)); 620 623 _insn.insn = INSN_BITS; ··· 628 625 if (insn->insn == INSN_WRITE) { 629 626 if (!(s->subdev_flags & SDF_WRITABLE)) 630 627 return -EINVAL; 631 - _data[0] = 1 << (chan - base_chan); /* mask */ 632 - _data[1] = data[0] ? (1 << (chan - base_chan)) : 0; /* bits */ 628 + _data[0] = 1U << (chan - base_chan); /* mask */ 629 + _data[1] = data[0] ? (1U << (chan - base_chan)) : 0; /* bits */ 633 630 } 634 631 635 632 ret = s->insn_bits(dev, s, &_insn, _data); ··· 712 709 713 710 if (s->type == COMEDI_SUBD_DO) { 714 711 if (s->n_chan < 32) 715 - s->io_bits = (1 << s->n_chan) - 1; 712 + s->io_bits = (1U << s->n_chan) - 1; 716 713 else 717 714 s->io_bits = 0xffffffff; 718 715 }
+2 -1
drivers/comedi/drivers/aio_iiro_16.c
··· 177 177 * Digital input change of state interrupts are optionally supported 178 178 * using IRQ 2-7, 10-12, 14, or 15. 179 179 */ 180 - if ((1 << it->options[1]) & 0xdcfc) { 180 + if (it->options[1] > 0 && it->options[1] < 16 && 181 + (1 << it->options[1]) & 0xdcfc) { 181 182 ret = request_irq(it->options[1], aio_iiro_16_cos, 0, 182 183 dev->board_name, dev); 183 184 if (ret == 0)
+1 -1
drivers/comedi/drivers/comedi_test.c
··· 792 792 { 793 793 struct waveform_private *devpriv = dev->private; 794 794 795 - if (devpriv) { 795 + if (devpriv && dev->n_subdevices) { 796 796 timer_delete_sync(&devpriv->ai_timer); 797 797 timer_delete_sync(&devpriv->ao_timer); 798 798 }
+2 -1
drivers/comedi/drivers/das16m1.c
··· 522 522 devpriv->extra_iobase = dev->iobase + DAS16M1_8255_IOBASE; 523 523 524 524 /* only irqs 2, 3, 4, 5, 6, 7, 10, 11, 12, 14, and 15 are valid */ 525 - if ((1 << it->options[1]) & 0xdcfc) { 525 + if (it->options[1] >= 2 && it->options[1] <= 15 && 526 + (1 << it->options[1]) & 0xdcfc) { 526 527 ret = request_irq(it->options[1], das16m1_interrupt, 0, 527 528 dev->board_name, dev); 528 529 if (ret == 0)
+2 -1
drivers/comedi/drivers/das6402.c
··· 567 567 das6402_reset(dev); 568 568 569 569 /* IRQs 2,3,5,6,7, 10,11,15 are valid for "enhanced" mode */ 570 - if ((1 << it->options[1]) & 0x8cec) { 570 + if (it->options[1] > 0 && it->options[1] < 16 && 571 + (1 << it->options[1]) & 0x8cec) { 571 572 ret = request_irq(it->options[1], das6402_interrupt, 0, 572 573 dev->board_name, dev); 573 574 if (ret == 0) {
+2 -1
drivers/comedi/drivers/pcl812.c
··· 1149 1149 if (IS_ERR(dev->pacer)) 1150 1150 return PTR_ERR(dev->pacer); 1151 1151 1152 - if ((1 << it->options[1]) & board->irq_bits) { 1152 + if (it->options[1] > 0 && it->options[1] < 16 && 1153 + (1 << it->options[1]) & board->irq_bits) { 1153 1154 ret = request_irq(it->options[1], pcl812_interrupt, 0, 1154 1155 dev->board_name, dev); 1155 1156 if (ret == 0)
+2
drivers/iio/accel/fxls8962af-core.c
··· 877 877 if (ret) 878 878 return ret; 879 879 880 + synchronize_irq(data->irq); 881 + 880 882 ret = __fxls8962af_fifo_set_mode(data, false); 881 883 882 884 if (data->enable_event)
+5 -5
drivers/iio/accel/st_accel_core.c
··· 1353 1353 union acpi_object *ont; 1354 1354 union acpi_object *elements; 1355 1355 acpi_status status; 1356 + struct device *parent = indio_dev->dev.parent; 1356 1357 int ret = -EINVAL; 1357 1358 unsigned int val; 1358 1359 int i, j; ··· 1372 1371 }; 1373 1372 1374 1373 1375 - adev = ACPI_COMPANION(indio_dev->dev.parent); 1374 + adev = ACPI_COMPANION(parent); 1376 1375 if (!adev) 1377 1376 return -ENXIO; 1378 1377 ··· 1381 1380 if (status == AE_NOT_FOUND) { 1382 1381 return -ENXIO; 1383 1382 } else if (ACPI_FAILURE(status)) { 1384 - dev_warn(&indio_dev->dev, "failed to execute _ONT: %d\n", 1385 - status); 1383 + dev_warn(parent, "failed to execute _ONT: %d\n", status); 1386 1384 return status; 1387 1385 } 1388 1386 ··· 1457 1457 } 1458 1458 1459 1459 ret = 0; 1460 - dev_info(&indio_dev->dev, "computed mount matrix from ACPI\n"); 1460 + dev_info(parent, "computed mount matrix from ACPI\n"); 1461 1461 1462 1462 out: 1463 1463 kfree(buffer.pointer); 1464 1464 if (ret) 1465 - dev_dbg(&indio_dev->dev, 1465 + dev_dbg(parent, 1466 1466 "failed to apply ACPI orientation data: %d\n", ret); 1467 1467 1468 1468 return ret;
+3 -2
drivers/iio/adc/ad7380.c
··· 1953 1953 1954 1954 if (st->chip_info->has_hardware_gain) { 1955 1955 device_for_each_child_node_scoped(dev, node) { 1956 - unsigned int channel, gain; 1956 + unsigned int channel; 1957 1957 int gain_idx; 1958 + u16 gain; 1958 1959 1959 1960 ret = fwnode_property_read_u32(node, "reg", &channel); 1960 1961 if (ret) ··· 1967 1966 "Invalid channel number %i\n", 1968 1967 channel); 1969 1968 1970 - ret = fwnode_property_read_u32(node, "adi,gain-milli", 1969 + ret = fwnode_property_read_u16(node, "adi,gain-milli", 1971 1970 &gain); 1972 1971 if (ret && ret != -EINVAL) 1973 1972 return dev_err_probe(dev, ret,
+3 -4
drivers/iio/adc/ad7949.c
··· 308 308 309 309 static int ad7949_spi_probe(struct spi_device *spi) 310 310 { 311 - u32 spi_ctrl_mask = spi->controller->bits_per_word_mask; 312 311 struct device *dev = &spi->dev; 313 312 const struct ad7949_adc_spec *spec; 314 313 struct ad7949_adc_chip *ad7949_adc; ··· 336 337 ad7949_adc->resolution = spec->resolution; 337 338 338 339 /* Set SPI bits per word */ 339 - if (spi_ctrl_mask & SPI_BPW_MASK(ad7949_adc->resolution)) { 340 + if (spi_is_bpw_supported(spi, ad7949_adc->resolution)) { 340 341 spi->bits_per_word = ad7949_adc->resolution; 341 - } else if (spi_ctrl_mask == SPI_BPW_MASK(16)) { 342 + } else if (spi_is_bpw_supported(spi, 16)) { 342 343 spi->bits_per_word = 16; 343 - } else if (spi_ctrl_mask == SPI_BPW_MASK(8)) { 344 + } else if (spi_is_bpw_supported(spi, 8)) { 344 345 spi->bits_per_word = 8; 345 346 } else { 346 347 dev_err(dev, "unable to find common BPW with spi controller\n");
+4 -2
drivers/iio/adc/adi-axi-adc.c
··· 445 445 static int ad7606_bus_reg_read(struct iio_backend *back, u32 reg, u32 *val) 446 446 { 447 447 struct adi_axi_adc_state *st = iio_backend_get_priv(back); 448 - int addr; 448 + u32 addr, reg_val; 449 449 450 450 guard(mutex)(&st->lock); 451 451 ··· 455 455 */ 456 456 addr = FIELD_PREP(ADI_AXI_REG_ADDRESS_MASK, reg) | ADI_AXI_REG_READ_BIT; 457 457 axi_adc_raw_write(back, addr); 458 - axi_adc_raw_read(back, val); 458 + axi_adc_raw_read(back, &reg_val); 459 + 460 + *val = FIELD_GET(ADI_AXI_REG_VALUE_MASK, reg_val); 459 461 460 462 /* Write 0x0 on the bus to get back to ADC mode */ 461 463 axi_adc_raw_write(back, 0);
+1
drivers/iio/adc/axp20x_adc.c
··· 187 187 .consumer_channel = "batt_chrg_i", 188 188 .adc_channel_label = "batt_chrg_i", 189 189 }, 190 + { } 190 191 }; 191 192 192 193 /*
+21 -22
drivers/iio/adc/max1363.c
··· 511 511 MAX1363_CHAN_U(1, _s1, 1, bits, ev_spec, num_ev_spec), \ 512 512 MAX1363_CHAN_U(2, _s2, 2, bits, ev_spec, num_ev_spec), \ 513 513 MAX1363_CHAN_U(3, _s3, 3, bits, ev_spec, num_ev_spec), \ 514 - MAX1363_CHAN_B(0, 1, d0m1, 4, bits, ev_spec, num_ev_spec), \ 515 - MAX1363_CHAN_B(2, 3, d2m3, 5, bits, ev_spec, num_ev_spec), \ 516 - MAX1363_CHAN_B(1, 0, d1m0, 6, bits, ev_spec, num_ev_spec), \ 517 - MAX1363_CHAN_B(3, 2, d3m2, 7, bits, ev_spec, num_ev_spec), \ 514 + MAX1363_CHAN_B(0, 1, d0m1, 12, bits, ev_spec, num_ev_spec), \ 515 + MAX1363_CHAN_B(2, 3, d2m3, 13, bits, ev_spec, num_ev_spec), \ 516 + MAX1363_CHAN_B(1, 0, d1m0, 18, bits, ev_spec, num_ev_spec), \ 517 + MAX1363_CHAN_B(3, 2, d3m2, 19, bits, ev_spec, num_ev_spec), \ 518 518 IIO_CHAN_SOFT_TIMESTAMP(8) \ 519 519 } 520 520 ··· 532 532 /* Applies to max1236, max1237 */ 533 533 static const enum max1363_modes max1236_mode_list[] = { 534 534 _s0, _s1, _s2, _s3, 535 - s0to1, s0to2, s0to3, 535 + s0to1, s0to2, s2to3, s0to3, 536 536 d0m1, d2m3, d1m0, d3m2, 537 537 d0m1to2m3, d1m0to3m2, 538 - s2to3, 539 538 }; 540 539 541 540 /* Applies to max1238, max1239 */ 542 541 static const enum max1363_modes max1238_mode_list[] = { 543 542 _s0, _s1, _s2, _s3, _s4, _s5, _s6, _s7, _s8, _s9, _s10, _s11, 544 543 s0to1, s0to2, s0to3, s0to4, s0to5, s0to6, 544 + s6to7, s6to8, s6to9, s6to10, s6to11, 545 545 s0to7, s0to8, s0to9, s0to10, s0to11, 546 546 d0m1, d2m3, d4m5, d6m7, d8m9, d10m11, 547 547 d1m0, d3m2, d5m4, d7m6, d9m8, d11m10, 548 - d0m1to2m3, d0m1to4m5, d0m1to6m7, d0m1to8m9, d0m1to10m11, 549 - d1m0to3m2, d1m0to5m4, d1m0to7m6, d1m0to9m8, d1m0to11m10, 550 - s6to7, s6to8, s6to9, s6to10, s6to11, 551 - d6m7to8m9, d6m7to10m11, d7m6to9m8, d7m6to11m10, 548 + d0m1to2m3, d0m1to4m5, d0m1to6m7, d6m7to8m9, 549 + d0m1to8m9, d6m7to10m11, d0m1to10m11, d1m0to3m2, 550 + d1m0to5m4, d1m0to7m6, d7m6to9m8, d1m0to9m8, 551 + d7m6to11m10, d1m0to11m10, 552 552 }; 553 553 554 554 #define MAX1363_12X_CHANS(bits) { \ ··· 584 584 585 585 static const enum max1363_modes max11607_mode_list[] = { 586 586 _s0, _s1, _s2, _s3, 587 - s0to1, s0to2, s0to3, 588 - s2to3, 587 + s0to1, s0to2, s2to3, 588 + s0to3, 589 589 d0m1, d2m3, d1m0, d3m2, 590 590 d0m1to2m3, d1m0to3m2, 591 591 }; 592 592 593 593 static const enum max1363_modes max11608_mode_list[] = { 594 594 _s0, _s1, _s2, _s3, _s4, _s5, _s6, _s7, 595 - s0to1, s0to2, s0to3, s0to4, s0to5, s0to6, s0to7, 596 - s6to7, 595 + s0to1, s0to2, s0to3, s0to4, s0to5, s0to6, s6to7, s0to7, 597 596 d0m1, d2m3, d4m5, d6m7, 598 597 d1m0, d3m2, d5m4, d7m6, 599 598 d0m1to2m3, d0m1to4m5, d0m1to6m7, ··· 608 609 MAX1363_CHAN_U(5, _s5, 5, bits, NULL, 0), \ 609 610 MAX1363_CHAN_U(6, _s6, 6, bits, NULL, 0), \ 610 611 MAX1363_CHAN_U(7, _s7, 7, bits, NULL, 0), \ 611 - MAX1363_CHAN_B(0, 1, d0m1, 8, bits, NULL, 0), \ 612 - MAX1363_CHAN_B(2, 3, d2m3, 9, bits, NULL, 0), \ 613 - MAX1363_CHAN_B(4, 5, d4m5, 10, bits, NULL, 0), \ 614 - MAX1363_CHAN_B(6, 7, d6m7, 11, bits, NULL, 0), \ 615 - MAX1363_CHAN_B(1, 0, d1m0, 12, bits, NULL, 0), \ 616 - MAX1363_CHAN_B(3, 2, d3m2, 13, bits, NULL, 0), \ 617 - MAX1363_CHAN_B(5, 4, d5m4, 14, bits, NULL, 0), \ 618 - MAX1363_CHAN_B(7, 6, d7m6, 15, bits, NULL, 0), \ 612 + MAX1363_CHAN_B(0, 1, d0m1, 12, bits, NULL, 0), \ 613 + MAX1363_CHAN_B(2, 3, d2m3, 13, bits, NULL, 0), \ 614 + MAX1363_CHAN_B(4, 5, d4m5, 14, bits, NULL, 0), \ 615 + MAX1363_CHAN_B(6, 7, d6m7, 15, bits, NULL, 0), \ 616 + MAX1363_CHAN_B(1, 0, d1m0, 18, bits, NULL, 0), \ 617 + MAX1363_CHAN_B(3, 2, d3m2, 19, bits, NULL, 0), \ 618 + MAX1363_CHAN_B(5, 4, d5m4, 20, bits, NULL, 0), \ 619 + MAX1363_CHAN_B(7, 6, d7m6, 21, bits, NULL, 0), \ 619 620 IIO_CHAN_SOFT_TIMESTAMP(16) \ 620 621 } 621 622 static const struct iio_chan_spec max11602_channels[] = MAX1363_8X_CHANS(8);
+3 -4
drivers/iio/adc/stm32-adc-core.c
··· 430 430 return -ENOMEM; 431 431 } 432 432 433 - for (i = 0; i < priv->cfg->num_irqs; i++) { 434 - irq_set_chained_handler(priv->irq[i], stm32_adc_irq_handler); 435 - irq_set_handler_data(priv->irq[i], priv); 436 - } 433 + for (i = 0; i < priv->cfg->num_irqs; i++) 434 + irq_set_chained_handler_and_data(priv->irq[i], 435 + stm32_adc_irq_handler, priv); 437 436 438 437 return 0; 439 438 }
+17 -19
drivers/iio/common/st_sensors/st_sensors_core.c
··· 154 154 return err; 155 155 156 156 st_accel_set_fullscale_error: 157 - dev_err(&indio_dev->dev, "failed to set new fullscale.\n"); 157 + dev_err(indio_dev->dev.parent, "failed to set new fullscale.\n"); 158 158 return err; 159 159 } 160 160 ··· 231 231 ARRAY_SIZE(regulator_names), 232 232 regulator_names); 233 233 if (err) 234 - return dev_err_probe(&indio_dev->dev, err, 235 - "unable to enable supplies\n"); 234 + return dev_err_probe(parent, err, "unable to enable supplies\n"); 236 235 237 236 return 0; 238 237 } ··· 240 241 static int st_sensors_set_drdy_int_pin(struct iio_dev *indio_dev, 241 242 struct st_sensors_platform_data *pdata) 242 243 { 244 + struct device *parent = indio_dev->dev.parent; 243 245 struct st_sensor_data *sdata = iio_priv(indio_dev); 244 246 245 247 /* Sensor does not support interrupts */ 246 248 if (!sdata->sensor_settings->drdy_irq.int1.addr && 247 249 !sdata->sensor_settings->drdy_irq.int2.addr) { 248 250 if (pdata->drdy_int_pin) 249 - dev_info(&indio_dev->dev, 251 + dev_info(parent, 250 252 "DRDY on pin INT%d specified, but sensor does not support interrupts\n", 251 253 pdata->drdy_int_pin); 252 254 return 0; ··· 256 256 switch (pdata->drdy_int_pin) { 257 257 case 1: 258 258 if (!sdata->sensor_settings->drdy_irq.int1.mask) { 259 - dev_err(&indio_dev->dev, 260 - "DRDY on INT1 not available.\n"); 259 + dev_err(parent, "DRDY on INT1 not available.\n"); 261 260 return -EINVAL; 262 261 } 263 262 sdata->drdy_int_pin = 1; 264 263 break; 265 264 case 2: 266 265 if (!sdata->sensor_settings->drdy_irq.int2.mask) { 267 - dev_err(&indio_dev->dev, 268 - "DRDY on INT2 not available.\n"); 266 + dev_err(parent, "DRDY on INT2 not available.\n"); 269 267 return -EINVAL; 270 268 } 271 269 sdata->drdy_int_pin = 2; 272 270 break; 273 271 default: 274 - dev_err(&indio_dev->dev, "DRDY on pdata not valid.\n"); 272 + dev_err(parent, "DRDY on pdata not valid.\n"); 275 273 return -EINVAL; 276 274 } 277 275 278 276 if (pdata->open_drain) { 279 277 if (!sdata->sensor_settings->drdy_irq.int1.addr_od && 280 278 !sdata->sensor_settings->drdy_irq.int2.addr_od) 281 - dev_err(&indio_dev->dev, 279 + dev_err(parent, 282 280 "open drain requested but unsupported.\n"); 283 281 else 284 282 sdata->int_pin_open_drain = true; ··· 334 336 int st_sensors_init_sensor(struct iio_dev *indio_dev, 335 337 struct st_sensors_platform_data *pdata) 336 338 { 339 + struct device *parent = indio_dev->dev.parent; 337 340 struct st_sensor_data *sdata = iio_priv(indio_dev); 338 341 struct st_sensors_platform_data *of_pdata; 339 342 int err = 0; ··· 342 343 mutex_init(&sdata->odr_lock); 343 344 344 345 /* If OF/DT pdata exists, it will take precedence of anything else */ 345 - of_pdata = st_sensors_dev_probe(indio_dev->dev.parent, pdata); 346 + of_pdata = st_sensors_dev_probe(parent, pdata); 346 347 if (IS_ERR(of_pdata)) 347 348 return PTR_ERR(of_pdata); 348 349 if (of_pdata) ··· 369 370 if (err < 0) 370 371 return err; 371 372 } else 372 - dev_info(&indio_dev->dev, "Full-scale not possible\n"); 373 + dev_info(parent, "Full-scale not possible\n"); 373 374 374 375 err = st_sensors_set_odr(indio_dev, sdata->odr); 375 376 if (err < 0) ··· 404 405 mask = sdata->sensor_settings->drdy_irq.int2.mask_od; 405 406 } 406 407 407 - dev_info(&indio_dev->dev, 408 + dev_info(parent, 408 409 "set interrupt line to open drain mode on pin %d\n", 409 410 sdata->drdy_int_pin); 410 411 err = st_sensors_write_data_with_mask(indio_dev, addr, ··· 592 593 int st_sensors_verify_id(struct iio_dev *indio_dev) 593 594 { 594 595 struct st_sensor_data *sdata = iio_priv(indio_dev); 596 + struct device *parent = indio_dev->dev.parent; 595 597 int wai, err; 596 598 597 599 if (sdata->sensor_settings->wai_addr) { 598 600 err = regmap_read(sdata->regmap, 599 601 sdata->sensor_settings->wai_addr, &wai); 600 602 if (err < 0) { 601 - dev_err(&indio_dev->dev, 602 - "failed to read Who-Am-I register.\n"); 603 - return err; 603 + return dev_err_probe(parent, err, 604 + "failed to read Who-Am-I register.\n"); 604 605 } 605 606 606 607 if (sdata->sensor_settings->wai != wai) { 607 - dev_warn(&indio_dev->dev, 608 - "%s: WhoAmI mismatch (0x%x).\n", 609 - indio_dev->name, wai); 608 + dev_warn(parent, "%s: WhoAmI mismatch (0x%x).\n", 609 + indio_dev->name, wai); 610 610 } 611 611 } 612 612
+9 -11
drivers/iio/common/st_sensors/st_sensors_trigger.c
··· 127 127 sdata->trig = devm_iio_trigger_alloc(parent, "%s-trigger", 128 128 indio_dev->name); 129 129 if (sdata->trig == NULL) { 130 - dev_err(&indio_dev->dev, "failed to allocate iio trigger.\n"); 130 + dev_err(parent, "failed to allocate iio trigger.\n"); 131 131 return -ENOMEM; 132 132 } 133 133 ··· 143 143 case IRQF_TRIGGER_FALLING: 144 144 case IRQF_TRIGGER_LOW: 145 145 if (!sdata->sensor_settings->drdy_irq.addr_ihl) { 146 - dev_err(&indio_dev->dev, 146 + dev_err(parent, 147 147 "falling/low specified for IRQ but hardware supports only rising/high: will request rising/high\n"); 148 148 if (irq_trig == IRQF_TRIGGER_FALLING) 149 149 irq_trig = IRQF_TRIGGER_RISING; ··· 156 156 sdata->sensor_settings->drdy_irq.mask_ihl, 1); 157 157 if (err < 0) 158 158 return err; 159 - dev_info(&indio_dev->dev, 159 + dev_info(parent, 160 160 "interrupts on the falling edge or active low level\n"); 161 161 } 162 162 break; 163 163 case IRQF_TRIGGER_RISING: 164 - dev_info(&indio_dev->dev, 165 - "interrupts on the rising edge\n"); 164 + dev_info(parent, "interrupts on the rising edge\n"); 166 165 break; 167 166 case IRQF_TRIGGER_HIGH: 168 - dev_info(&indio_dev->dev, 169 - "interrupts active high level\n"); 167 + dev_info(parent, "interrupts active high level\n"); 170 168 break; 171 169 default: 172 170 /* This is the most preferred mode, if possible */ 173 - dev_err(&indio_dev->dev, 171 + dev_err(parent, 174 172 "unsupported IRQ trigger specified (%lx), enforce rising edge\n", irq_trig); 175 173 irq_trig = IRQF_TRIGGER_RISING; 176 174 } ··· 177 179 if (irq_trig == IRQF_TRIGGER_FALLING || 178 180 irq_trig == IRQF_TRIGGER_RISING) { 179 181 if (!sdata->sensor_settings->drdy_irq.stat_drdy.addr) { 180 - dev_err(&indio_dev->dev, 182 + dev_err(parent, 181 183 "edge IRQ not supported w/o stat register.\n"); 182 184 return -EOPNOTSUPP; 183 185 } ··· 212 214 sdata->trig->name, 213 215 sdata->trig); 214 216 if (err) { 215 - dev_err(&indio_dev->dev, "failed to request trigger IRQ.\n"); 217 + dev_err(parent, "failed to request trigger IRQ.\n"); 216 218 return err; 217 219 } 218 220 219 221 err = devm_iio_trigger_register(parent, sdata->trig); 220 222 if (err < 0) { 221 - dev_err(&indio_dev->dev, "failed to register iio trigger.\n"); 223 + dev_err(parent, "failed to register iio trigger.\n"); 222 224 return err; 223 225 } 224 226 indio_dev->trig = iio_trigger_get(sdata->trig);
+3 -1
drivers/iio/dac/ad3530r.c
··· 166 166 AD3530R_OUTPUT_OPERATING_MODE_0 : 167 167 AD3530R_OUTPUT_OPERATING_MODE_1; 168 168 pdmode = powerdown ? st->chan[chan->channel].powerdown_mode : 0; 169 - mask = AD3530R_OP_MODE_CHAN_MSK(chan->channel); 169 + mask = chan->channel < AD3531R_MAX_CHANNELS ? 170 + AD3530R_OP_MODE_CHAN_MSK(chan->channel) : 171 + AD3530R_OP_MODE_CHAN_MSK(chan->channel - 4); 170 172 val = field_prep(mask, pdmode); 171 173 172 174 ret = regmap_update_bits(st->regmap, reg, mask, val);
+4 -1
drivers/iio/industrialio-backend.c
··· 155 155 ssize_t rc; 156 156 int ret; 157 157 158 + if (count >= sizeof(buf)) 159 + return -ENOSPC; 160 + 158 161 rc = simple_write_to_buffer(buf, sizeof(buf) - 1, ppos, userbuf, count); 159 162 if (rc < 0) 160 163 return rc; 161 164 162 - buf[count] = '\0'; 165 + buf[rc] = '\0'; 163 166 164 167 ret = sscanf(buf, "%i %i", &back->cached_reg_addr, &val); 165 168
+4 -1
drivers/iio/industrialio-core.c
··· 411 411 char buf[80]; 412 412 int ret; 413 413 414 + if (count >= sizeof(buf)) 415 + return -EINVAL; 416 + 414 417 ret = simple_write_to_buffer(buf, sizeof(buf) - 1, ppos, userbuf, 415 418 count); 416 419 if (ret < 0) 417 420 return ret; 418 421 419 - buf[count] = '\0'; 422 + buf[ret] = '\0'; 420 423 421 424 ret = sscanf(buf, "%i %i", &reg, &val); 422 425
+29 -5
drivers/interconnect/core.c
··· 20 20 21 21 #include "internal.h" 22 22 23 - #define ICC_DYN_ID_START 10000 23 + #define ICC_DYN_ID_START 100000 24 24 25 25 #define CREATE_TRACE_POINTS 26 26 #include "trace.h" ··· 819 819 { 820 820 struct icc_node *node; 821 821 822 + if (id >= ICC_DYN_ID_START) 823 + return ERR_PTR(-EINVAL); 824 + 822 825 /* check if node already exists */ 823 826 node = node_find(id); 824 827 if (node) ··· 909 906 return; 910 907 911 908 kfree(node->links); 909 + if (node->id >= ICC_DYN_ID_START) 910 + kfree(node->name); 912 911 kfree(node); 913 912 } 914 913 EXPORT_SYMBOL_GPL(icc_node_destroy); 914 + 915 + /** 916 + * icc_node_set_name() - set node name 917 + * @node: node 918 + * @provider: node provider 919 + * @name: node name 920 + * 921 + * Return: 0 on success, or -ENOMEM on allocation failure 922 + */ 923 + int icc_node_set_name(struct icc_node *node, const struct icc_provider *provider, const char *name) 924 + { 925 + if (node->id >= ICC_DYN_ID_START) { 926 + node->name = kasprintf(GFP_KERNEL, "%s@%s", name, 927 + dev_name(provider->dev)); 928 + if (!node->name) 929 + return -ENOMEM; 930 + } else { 931 + node->name = name; 932 + } 933 + 934 + return 0; 935 + } 936 + EXPORT_SYMBOL_GPL(icc_node_set_name); 915 937 916 938 /** 917 939 * icc_link_nodes() - create link between two nodes ··· 1065 1037 } 1066 1038 node->avg_bw = node->init_avg; 1067 1039 node->peak_bw = node->init_peak; 1068 - 1069 - if (node->id >= ICC_DYN_ID_START) 1070 - node->name = devm_kasprintf(provider->dev, GFP_KERNEL, "%s@%s", 1071 - node->name, dev_name(provider->dev)); 1072 1040 1073 1041 if (node->avg_bw || node->peak_bw) { 1074 1042 if (provider->pre_aggregate)
+2
drivers/interconnect/icc-clk.c
··· 117 117 118 118 node->name = devm_kasprintf(dev, GFP_KERNEL, "%s_master", data[i].name); 119 119 if (!node->name) { 120 + icc_node_destroy(node->id); 120 121 ret = -ENOMEM; 121 122 goto err; 122 123 } ··· 136 135 137 136 node->name = devm_kasprintf(dev, GFP_KERNEL, "%s_slave", data[i].name); 138 137 if (!node->name) { 138 + icc_node_destroy(node->id); 139 139 ret = -ENOMEM; 140 140 goto err; 141 141 }
+6 -1
drivers/interconnect/qcom/icc-rpmh.c
··· 293 293 goto err_remove_nodes; 294 294 } 295 295 296 - node->name = qn->name; 296 + ret = icc_node_set_name(node, provider, qn->name); 297 + if (ret) { 298 + icc_node_destroy(node->id); 299 + goto err_remove_nodes; 300 + } 301 + 297 302 node->data = qn; 298 303 icc_node_add(node, provider); 299 304
+6 -1
drivers/interconnect/qcom/osm-l3.c
··· 236 236 goto err; 237 237 } 238 238 239 - node->name = qnodes[i]->name; 239 + ret = icc_node_set_name(node, provider, qnodes[i]->name); 240 + if (ret) { 241 + icc_node_destroy(node->id); 242 + goto err; 243 + } 244 + 240 245 /* Cast away const and add it back in qcom_osm_l3_set() */ 241 246 node->data = (void *)qnodes[i]; 242 247 icc_node_add(node, provider);
+1
drivers/interconnect/qcom/sc7280.c
··· 238 238 .id = SC7280_MASTER_PCIE_1, 239 239 .channels = 1, 240 240 .buswidth = 8, 241 + .num_links = 1, 241 242 .links = { SC7280_SLAVE_ANOC_PCIE_GEM_NOC }, 242 243 }; 243 244
+5
drivers/interconnect/samsung/exynos.c
··· 134 134 priv->node = icc_node; 135 135 icc_node->name = devm_kasprintf(&pdev->dev, GFP_KERNEL, "%pOFn", 136 136 bus_dev->of_node); 137 + if (!icc_node->name) { 138 + icc_node_destroy(pdev->id); 139 + return -ENOMEM; 140 + } 141 + 137 142 if (of_property_read_u32(bus_dev->of_node, "samsung,data-clock-ratio", 138 143 &priv->bus_clk_ratio)) 139 144 priv->bus_clk_ratio = EXYNOS_ICC_DEFAULT_BUS_CLK_RATIO;
+17 -7
drivers/misc/amd-sbi/rmi-core.c
··· 42 42 #define RD_MCA_CMD 0x86 43 43 44 44 /* CPUID MCAMSR mask & index */ 45 - #define CPUID_MCA_THRD_MASK GENMASK(15, 0) 46 45 #define CPUID_MCA_THRD_INDEX 32 47 46 #define CPUID_MCA_FUNC_MASK GENMASK(31, 0) 48 47 #define CPUID_EXT_FUNC_INDEX 56 ··· 128 129 goto exit_unlock; 129 130 } 130 131 131 - thread = msg->cpu_in_out << CPUID_MCA_THRD_INDEX & CPUID_MCA_THRD_MASK; 132 + thread = msg->cpu_in_out >> CPUID_MCA_THRD_INDEX; 132 133 133 134 /* Thread > 127, Thread128 CS register, 1'b1 needs to be set to 1 */ 134 135 if (thread > 127) { ··· 209 210 goto exit_unlock; 210 211 } 211 212 212 - thread = msg->mcamsr_in_out << CPUID_MCA_THRD_INDEX & CPUID_MCA_THRD_MASK; 213 + thread = msg->mcamsr_in_out >> CPUID_MCA_THRD_INDEX; 213 214 214 215 /* Thread > 127, Thread128 CS register, 1'b1 needs to be set to 1 */ 215 216 if (thread > 127) { ··· 320 321 ret = regmap_read(data->regmap, SBRMI_OUTBNDMSG7, &ec); 321 322 if (ret || ec) 322 323 goto exit_clear_alert; 324 + 325 + /* Clear the input value before updating the output data */ 326 + msg->mb_in_out = 0; 327 + 323 328 /* 324 329 * For a read operation, the initiator (BMC) reads the firmware 325 330 * response Command Data Out[31:0] from SBRMI::OutBndMsg_inst[4:1] ··· 376 373 mutex_unlock(&data->lock); 377 374 378 375 if (msg.rflag && !ret) 379 - return copy_to_user(arg, &msg, sizeof(struct apml_reg_xfer_msg)); 376 + if (copy_to_user(arg, &msg, sizeof(struct apml_reg_xfer_msg))) 377 + return -EFAULT; 380 378 return ret; 381 379 } 382 380 ··· 395 391 if (ret && ret != -EPROTOTYPE) 396 392 return ret; 397 393 398 - return copy_to_user(arg, &msg, sizeof(struct apml_mbox_msg)); 394 + if (copy_to_user(arg, &msg, sizeof(struct apml_mbox_msg))) 395 + return -EFAULT; 396 + return ret; 399 397 } 400 398 401 399 static int apml_cpuid_xfer(struct sbrmi_data *data, struct apml_cpuid_msg __user *arg) ··· 414 408 if (ret && ret != -EPROTOTYPE) 415 409 return ret; 416 410 417 - return copy_to_user(arg, &msg, sizeof(struct apml_cpuid_msg)); 411 + if (copy_to_user(arg, &msg, sizeof(struct apml_cpuid_msg))) 412 + return -EFAULT; 413 + return ret; 418 414 } 419 415 420 416 static int apml_mcamsr_xfer(struct sbrmi_data *data, struct apml_mcamsr_msg __user *arg) ··· 433 425 if (ret && ret != -EPROTOTYPE) 434 426 return ret; 435 427 436 - return copy_to_user(arg, &msg, sizeof(struct apml_mcamsr_msg)); 428 + if (copy_to_user(arg, &msg, sizeof(struct apml_mcamsr_msg))) 429 + return -EFAULT; 430 + return ret; 437 431 } 438 432 439 433 static long sbrmi_ioctl(struct file *fp, unsigned int cmd, unsigned long arg)
+1
drivers/mux/Kconfig
··· 48 48 config MUX_MMIO 49 49 tristate "MMIO/Regmap register bitfield-controlled Multiplexer" 50 50 depends on OF 51 + select REGMAP_MMIO 51 52 help 52 53 MMIO/Regmap register bitfield-controlled Multiplexer controller. 53 54
+4 -1
drivers/nvmem/imx-ocotp-ele.c
··· 12 12 #include <linux/of.h> 13 13 #include <linux/platform_device.h> 14 14 #include <linux/slab.h> 15 + #include <linux/if_ether.h> /* ETH_ALEN */ 15 16 16 17 enum fuse_type { 17 18 FUSE_FSB = BIT(0), ··· 119 118 int i; 120 119 121 120 /* Deal with some post processing of nvmem cell data */ 122 - if (id && !strcmp(id, "mac-address")) 121 + if (id && !strcmp(id, "mac-address")) { 122 + bytes = min(bytes, ETH_ALEN); 123 123 for (i = 0; i < bytes / 2; i++) 124 124 swap(buf[i], buf[bytes - i - 1]); 125 + } 125 126 126 127 return 0; 127 128 }
+4 -1
drivers/nvmem/imx-ocotp.c
··· 23 23 #include <linux/platform_device.h> 24 24 #include <linux/slab.h> 25 25 #include <linux/delay.h> 26 + #include <linux/if_ether.h> /* ETH_ALEN */ 26 27 27 28 #define IMX_OCOTP_OFFSET_B0W0 0x400 /* Offset from base address of the 28 29 * OTP Bank0 Word0 ··· 228 227 int i; 229 228 230 229 /* Deal with some post processing of nvmem cell data */ 231 - if (id && !strcmp(id, "mac-address")) 230 + if (id && !strcmp(id, "mac-address")) { 231 + bytes = min(bytes, ETH_ALEN); 232 232 for (i = 0; i < bytes / 2; i++) 233 233 swap(buf[i], buf[bytes - i - 1]); 234 + } 234 235 235 236 return 0; 236 237 }
+3 -3
drivers/nvmem/layouts/u-boot-env.c
··· 92 92 size_t crc32_data_offset; 93 93 size_t crc32_data_len; 94 94 size_t crc32_offset; 95 - __le32 *crc32_addr; 95 + uint32_t *crc32_addr; 96 96 size_t data_offset; 97 97 size_t data_len; 98 98 size_t dev_size; ··· 143 143 goto err_kfree; 144 144 } 145 145 146 - crc32_addr = (__le32 *)(buf + crc32_offset); 147 - crc32 = le32_to_cpu(*crc32_addr); 146 + crc32_addr = (uint32_t *)(buf + crc32_offset); 147 + crc32 = *crc32_addr; 148 148 crc32_data_len = dev_size - crc32_data_offset; 149 149 data_len = dev_size - data_offset; 150 150
+7
include/linux/interconnect-provider.h
··· 119 119 struct icc_node *icc_node_create_dyn(void); 120 120 struct icc_node *icc_node_create(int id); 121 121 void icc_node_destroy(int id); 122 + int icc_node_set_name(struct icc_node *node, const struct icc_provider *provider, const char *name); 122 123 int icc_link_nodes(struct icc_node *src_node, struct icc_node **dst_node); 123 124 int icc_link_create(struct icc_node *node, const int dst_id); 124 125 void icc_node_add(struct icc_node *node, struct icc_provider *provider); ··· 151 150 152 151 static inline void icc_node_destroy(int id) 153 152 { 153 + } 154 + 155 + static inline int icc_node_set_name(struct icc_node *node, const struct icc_provider *provider, 156 + const char *name) 157 + { 158 + return -EOPNOTSUPP; 154 159 } 155 160 156 161 static inline int icc_link_nodes(struct icc_node *src_node, struct icc_node **dst_node)