* [chrome-os:chromeos-6.1 41/43] drivers/misc/nxp-sr1xx.c:387:50: sparse: sparse: incorrect type in argument 2 (different address spaces)
@ 2023-09-26 0:18 kernel test robot
0 siblings, 0 replies; only message in thread
From: kernel test robot @ 2023-09-26 0:18 UTC (permalink / raw)
To: cros-kernel-buildreports, Guenter Roeck; +Cc: oe-kbuild-all
tree: https://chromium.googlesource.com/chromiumos/third_party/kernel chromeos-6.1
head: 1a5dca9ba41093d8076be63e613b5d8547708b30
commit: 30dee752600323ee56b4ba0c9504475fa7ab6849 [41/43] CHROMIUM: FROMLIST: misc: nxp-sr1xx: UWB driver for sr1xx
config: i386-randconfig-061-20230926 (https://download.01.org/0day-ci/archive/20230926/202309260858.slOKw7dZ-lkp@intel.com/config)
compiler: gcc-12 (Debian 12.2.0-14) 12.2.0
reproduce (this is a W=1 build): (https://download.01.org/0day-ci/archive/20230926/202309260858.slOKw7dZ-lkp@intel.com/reproduce)
If you fix the issue in a separate patch/commit (i.e. not just a new version of
the same patch/commit), kindly add following tags
| Reported-by: kernel test robot <lkp@intel.com>
| Closes: https://lore.kernel.org/oe-kbuild-all/202309260858.slOKw7dZ-lkp@intel.com/
sparse warnings: (new ones prefixed by >>)
>> drivers/misc/nxp-sr1xx.c:387:50: sparse: sparse: incorrect type in argument 2 (different address spaces) @@ expected void const [noderef] __user *from @@ got char const *buf @@
drivers/misc/nxp-sr1xx.c:387:50: sparse: expected void const [noderef] __user *from
drivers/misc/nxp-sr1xx.c:387:50: sparse: got char const *buf
>> drivers/misc/nxp-sr1xx.c:451:26: sparse: sparse: incorrect type in argument 1 (different address spaces) @@ expected void [noderef] __user *to @@ got char *buf @@
drivers/misc/nxp-sr1xx.c:451:26: sparse: expected void [noderef] __user *to
drivers/misc/nxp-sr1xx.c:451:26: sparse: got char *buf
drivers/misc/nxp-sr1xx.c:508:34: sparse: sparse: incorrect type in argument 1 (different address spaces) @@ expected void [noderef] __user *to @@ got char *buf @@
drivers/misc/nxp-sr1xx.c:508:34: sparse: expected void [noderef] __user *to
drivers/misc/nxp-sr1xx.c:508:34: sparse: got char *buf
>> drivers/misc/nxp-sr1xx.c:541:17: sparse: sparse: incorrect type in initializer (incompatible argument 2 (different address spaces)) @@ expected int ( *read )( ... ) @@ got int ( * )( ... ) @@
drivers/misc/nxp-sr1xx.c:541:17: sparse: expected int ( *read )( ... )
drivers/misc/nxp-sr1xx.c:541:17: sparse: got int ( * )( ... )
>> drivers/misc/nxp-sr1xx.c:542:18: sparse: sparse: incorrect type in initializer (incompatible argument 2 (different address spaces)) @@ expected int ( *write )( ... ) @@ got int ( * )( ... ) @@
drivers/misc/nxp-sr1xx.c:542:18: sparse: expected int ( *write )( ... )
drivers/misc/nxp-sr1xx.c:542:18: sparse: got int ( * )( ... )
>> drivers/misc/nxp-sr1xx.c:584:21: sparse: sparse: incorrect type in assignment (different base types) @@ expected int [assigned] ret @@ got struct gpio_desc *[assigned] gpiod_irq @@
drivers/misc/nxp-sr1xx.c:584:21: sparse: expected int [assigned] ret
drivers/misc/nxp-sr1xx.c:584:21: sparse: got struct gpio_desc *[assigned] gpiod_irq
>> drivers/misc/nxp-sr1xx.c:593:21: sparse: sparse: incorrect type in assignment (different base types) @@ expected int [assigned] ret @@ got struct gpio_desc *[assigned] gpiod_ce @@
drivers/misc/nxp-sr1xx.c:593:21: sparse: expected int [assigned] ret
drivers/misc/nxp-sr1xx.c:593:21: sparse: got struct gpio_desc *[assigned] gpiod_ce
>> drivers/misc/nxp-sr1xx.c:602:21: sparse: sparse: incorrect type in assignment (different base types) @@ expected int [assigned] ret @@ got struct gpio_desc *[assigned] gpiod_ri @@
drivers/misc/nxp-sr1xx.c:602:21: sparse: expected int [assigned] ret
drivers/misc/nxp-sr1xx.c:602:21: sparse: got struct gpio_desc *[assigned] gpiod_ri
>> drivers/misc/nxp-sr1xx.c:695:5: sparse: sparse: symbol 'sr1xx_dev_suspend' was not declared. Should it be static?
>> drivers/misc/nxp-sr1xx.c:710:5: sparse: sparse: symbol 'sr1xx_dev_resume' was not declared. Should it be static?
vim +387 drivers/misc/nxp-sr1xx.c
373
374 static ssize_t sr1xx_dev_write(struct file *filp, const char *buf, size_t count,
375 loff_t *offset)
376 {
377 int ret;
378 struct sr1xx_dev *sr1xx_dev;
379
380 sr1xx_dev = filp->private_data;
381 if (count > SR1XX_MAX_TX_BUF_SIZE || count > SR1XX_TXBUF_SIZE) {
382 dev_err(&sr1xx_dev->spi->dev, "%s : Write Size Exceeds\n",
383 __func__);
384 ret = -ENOBUFS;
385 goto write_end;
386 }
> 387 if (copy_from_user(sr1xx_dev->tx_buffer, buf, count)) {
388 dev_err(&sr1xx_dev->spi->dev,
389 "%s : failed to copy from user space\n", __func__);
390 return -EFAULT;
391 }
392 if (sr1xx_dev->is_fw_dwnld_enabled)
393 ret = sr1xx_hbci_write(sr1xx_dev, count);
394 else
395 ret = sr1xx_dev_transceive(sr1xx_dev, SR1XX_WRITE_MODE, count);
396 if (ret == TRANSCEIVE_SUCCESS)
397 ret = sr1xx_dev->write_count;
398 else
399 dev_err(&sr1xx_dev->spi->dev, "write failed......");
400 write_end:
401 return ret;
402 }
403
404 /**
405 * sr1xx_hbci_read
406 *
407 * Function used to read data from sr1xx on SPI line
408 * as part of firmware download sequence.
409 *
410 * Returns: Number of bytes read if read is success else
411 * indicate each error code
412 */
413 static ssize_t sr1xx_hbci_read(struct sr1xx_dev *sr1xx_dev, char *buf,
414 size_t count)
415 {
416 int ret = -EIO;
417
418 if (count > SR1XX_RXBUF_SIZE) {
419 dev_err(&sr1xx_dev->spi->dev, "count(%zu) out of range(0-%d)\n",
420 count, SR1XX_RXBUF_SIZE);
421 ret = -EINVAL;
422 goto hbci_fail;
423 }
424 /* Wait for inetrrupt upto 500ms */
425 ret = wait_event_interruptible_timeout(sr1xx_dev->read_wq,
426 sr1xx_dev->irq_received,
427 sr1xx_dev->timeout_in_ms);
428 if (ret == 0) {
429 dev_err(&sr1xx_dev->spi->dev,
430 "hbci wait_event_interruptible timeout() : Failed.\n");
431 ret = -EIO;
432 goto hbci_fail;
433 }
434 if (sr1xx_dev->read_abort_requested) {
435 sr1xx_dev->read_abort_requested = false;
436 dev_err(&sr1xx_dev->spi->dev, "HBCI Abort Read pending......");
437 return ret;
438 }
439 if (!gpio_get_value(sr1xx_dev->irq_gpio)) {
440 dev_err(&sr1xx_dev->spi->dev,
441 "IRQ is low during firmware download");
442 goto hbci_fail;
443 }
444 ret = spi_read(sr1xx_dev->spi, (void *)sr1xx_dev->rx_buffer, count);
445 if (ret < 0) {
446 dev_err(&sr1xx_dev->spi->dev,
447 "sr1xx_dev_read: spi read error %d\n ", ret);
448 goto hbci_fail;
449 }
450 ret = count;
> 451 if (copy_to_user(buf, sr1xx_dev->rx_buffer, count)) {
452 dev_err(&sr1xx_dev->spi->dev,
453 "sr1xx_dev_read: copy to user failed\n");
454 ret = -EFAULT;
455 }
456 return ret;
457 hbci_fail:
458 dev_err(&sr1xx_dev->spi->dev, "Error sr1xx_fw_download ret %d Exit\n",
459 ret);
460 return ret;
461 }
462
463 static ssize_t sr1xx_dev_read(struct file *filp, char *buf, size_t count,
464 loff_t *offset)
465 {
466 struct sr1xx_dev *sr1xx_dev = filp->private_data;
467 int ret = -EIO;
468
469 /* 500ms timeout in jiffies */
470 sr1xx_dev->timeout_in_ms = ((500 * HZ) / 1000);
471 memset(sr1xx_dev->rx_buffer, 0x00, SR1XX_RXBUF_SIZE);
472 if (!gpio_get_value(sr1xx_dev->irq_gpio)) {
473 if (filp->f_flags & O_NONBLOCK) {
474 ret = -EAGAIN;
475 goto read_end;
476 }
477 }
478 /* HBCI packet read */
479 if (sr1xx_dev->is_fw_dwnld_enabled) {
480 ret = sr1xx_hbci_read(sr1xx_dev, buf, count);
481 goto read_end;
482 }
483 /* UCI packet read */
484 do {
485 sr1xx_enable_irq(sr1xx_dev);
486 if (!sr1xx_dev->read_abort_requested) {
487 ret = wait_event_interruptible(sr1xx_dev->read_wq,
488 sr1xx_dev->irq_received);
489 if (ret) {
490 dev_err(&sr1xx_dev->spi->dev,
491 "wait_event_interruptible() : Failed.\n");
492 goto read_end;
493 }
494 }
495 if (sr1xx_dev->read_abort_requested) {
496 sr1xx_dev->read_abort_requested = false;
497 dev_err(&sr1xx_dev->spi->dev,
498 "Abort Read pending......");
499 goto read_end;
500 }
501 ret = sr1xx_dev_transceive(sr1xx_dev, SR1XX_READ_MODE, count);
502 if (ret == IRQ_WAIT_REQUEST) {
503 dev_err(&sr1xx_dev->spi->dev,
504 "Irg is low due to write hence irq is requested again...");
505 }
506 } while (ret == IRQ_WAIT_REQUEST);
507 if (ret == TRANSCEIVE_SUCCESS) {
508 if (copy_to_user(buf, sr1xx_dev->rx_buffer,
509 sr1xx_dev->read_count)) {
510 dev_err(&sr1xx_dev->spi->dev,
511 "%s: copy to user failed\n", __func__);
512 ret = -EFAULT;
513 goto read_end;
514 }
515 ret = sr1xx_dev->read_count;
516 } else if (ret == IRQ_WAIT_TIMEOUT) {
517 dev_err(&sr1xx_dev->spi->dev,
518 "Second irq is not received..Time out...");
519 ret = -ETIME;
520 } else {
521 dev_err(&sr1xx_dev->spi->dev, "spi read failed...%d", ret);
522 ret = -EIO;
523 }
524 read_end:
525 return ret;
526 }
527
528 static inline void sr1xx_set_data(struct spi_device *spi, void *data)
529 {
530 dev_set_drvdata(&spi->dev, data);
531 }
532
533 static inline void *sr1xx_get_data(const struct spi_device *spi)
534 {
535 return dev_get_drvdata(&spi->dev);
536 }
537
538 /* Possible fops on the sr1xx device */
539 static const struct file_operations sr1xx_dev_fops = {
540 .owner = THIS_MODULE,
> 541 .read = sr1xx_dev_read,
> 542 .write = sr1xx_dev_write,
543 .open = sr1xx_dev_open,
544 .unlocked_ioctl = sr1xx_dev_ioctl,
545 .compat_ioctl = sr1xx_dev_ioctl,
546 };
547
548 static int sr1xx_probe(struct spi_device *spi)
549 {
550 int ret;
551 struct sr1xx_dev *sr1xx_dev = NULL;
552 unsigned int irq_flags;
553 struct gpio_desc *gpiod_irq;
554 struct gpio_desc *gpiod_ce;
555 struct gpio_desc *gpiod_ri;
556
557 dev_info(&spi->dev, "%s chip select : %d , bus number = %d\n", __func__,
558 spi->chip_select, spi->master->bus_num);
559
560 sr1xx_dev = kzalloc(sizeof(*sr1xx_dev), GFP_KERNEL);
561 if (!sr1xx_dev) {
562 ret = -ENOMEM;
563 goto err_exit;
564 }
565
566 spi->bits_per_word = 8;
567 spi->mode = SPI_MODE_0;
568 spi->max_speed_hz = SR1XX_SPI_CLOCK;
569 ret = spi_setup(spi);
570 if (ret < 0) {
571 dev_err(&spi->dev, "failed to do spi_setup()\n");
572 goto err_setup;
573 }
574
575 sr1xx_dev->spi = spi;
576 sr1xx_dev->sr1xx_device.minor = MISC_DYNAMIC_MINOR;
577 sr1xx_dev->sr1xx_device.name = "sr1xx";
578 sr1xx_dev->sr1xx_device.fops = &sr1xx_dev_fops;
579 sr1xx_dev->sr1xx_device.parent = &spi->dev;
580
581 gpiod_irq = devm_gpiod_get(&spi->dev, "nxp,sr1xx-irq", GPIOD_IN);
582 if (IS_ERR(gpiod_irq)) {
583 dev_err(&spi->dev, "failed to do fetch irq gpio desc\n");
> 584 ret = gpiod_irq;
585 goto err_setup;
586 } else {
587 sr1xx_dev->irq_gpio = desc_to_gpio(gpiod_irq);
588 }
589
590 gpiod_ce = devm_gpiod_get(&spi->dev, "nxp,sr1xx-ce", GPIOD_OUT_LOW);
591 if (IS_ERR(gpiod_ce)) {
592 dev_err(&spi->dev, "failed to do fetch ce gpio desc\n");
593 ret = gpiod_ce;
594 goto err_setup;
595 } else {
596 sr1xx_dev->ce_gpio = desc_to_gpio(gpiod_ce);
597 }
598
599 gpiod_ri = devm_gpiod_get(&spi->dev, "nxp,sr1xx-ri", GPIOD_OUT_LOW);
600 if (IS_ERR(gpiod_ri)) {
601 dev_err(&spi->dev, "failed to do fetch ri gpio desc\n");
602 ret = gpiod_ri;
603 goto err_setup;
604 } else {
605 sr1xx_dev->spi_handshake_gpio = desc_to_gpio(gpiod_ri);
606 }
607
608 dev_set_drvdata(&spi->dev, sr1xx_dev);
609
610 /* init mutex and queues */
611 init_waitqueue_head(&sr1xx_dev->read_wq);
612 mutex_init(&sr1xx_dev->sr1xx_access_lock);
613
614 spin_lock_init(&sr1xx_dev->irq_enabled_lock);
615
616 ret = misc_register(&sr1xx_dev->sr1xx_device);
617 if (ret < 0) {
618 dev_err(&spi->dev, "misc_register failed! %d\n", ret);
619 goto err_setup;
620 }
621
622 sr1xx_dev->tx_buffer = kzalloc(SR1XX_TXBUF_SIZE, GFP_KERNEL);
623 sr1xx_dev->rx_buffer = kzalloc(SR1XX_RXBUF_SIZE, GFP_KERNEL);
624 if (!sr1xx_dev->tx_buffer) {
625 ret = -ENOMEM;
626 goto err_exit;
627 }
628 if (!sr1xx_dev->rx_buffer) {
629 ret = -ENOMEM;
630 goto err_exit;
631 }
632
633 sr1xx_dev->spi->irq = gpio_to_irq(sr1xx_dev->irq_gpio);
634 if (sr1xx_dev->spi->irq < 0) {
635 dev_err(&spi->dev, "gpio_to_irq request failed gpio = 0x%x\n",
636 sr1xx_dev->irq_gpio);
637 goto err_exit;
638 }
639 /* request irq. The irq is set whenever the chip has data available
640 * for reading. It is cleared when all data has been read.
641 */
642 irq_flags = IRQ_TYPE_LEVEL_HIGH;
643 sr1xx_dev->irq_enabled = true;
644 sr1xx_dev->irq_received = false;
645
646 ret = request_irq(sr1xx_dev->spi->irq, sr1xx_dev_irq_handler, irq_flags,
647 sr1xx_dev->sr1xx_device.name, sr1xx_dev);
648 if (ret) {
649 dev_err(&spi->dev, "request_irq failed\n");
650 goto err_exit;
651 }
652 sr1xx_disable_irq(sr1xx_dev);
653 return 0;
654 err_exit:
655 if (sr1xx_dev) {
656 kfree(sr1xx_dev->tx_buffer);
657 kfree(sr1xx_dev->rx_buffer);
658 misc_deregister(&sr1xx_dev->sr1xx_device);
659 }
660 err_setup:
661 if (sr1xx_dev)
662 mutex_destroy(&sr1xx_dev->sr1xx_access_lock);
663 kfree(sr1xx_dev);
664 dev_err(&spi->dev, "ERROR: Exit : %s ret %d\n", __func__, ret);
665 return ret;
666 }
667
--
0-DAY CI Kernel Test Service
https://github.com/intel/lkp-tests/wiki
^ permalink raw reply [flat|nested] only message in thread
only message in thread, other threads:[~2023-09-26 0:19 UTC | newest]
Thread overview: (only message) (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2023-09-26 0:18 [chrome-os:chromeos-6.1 41/43] drivers/misc/nxp-sr1xx.c:387:50: sparse: sparse: incorrect type in argument 2 (different address spaces) kernel test robot
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.