Lines Matching refs:spidev

26 #include <linux/spi/spidev.h>

87 static ssize_t spidev_sync(struct spidev_data *spidev, struct spi_message *message)

92     spin_lock_irq(&spidev->spi_lock);

93     spi = spidev->spi;

94     spin_unlock_irq(&spidev->spi_lock);

109 static inline ssize_t spidev_sync_write(struct spidev_data *spidev, size_t len)

112         .tx_buf = spidev->tx_buffer,

114         .speed_hz = spidev->speed_hz,

120     return spidev_sync(spidev, &m);

123 static inline ssize_t spidev_sync_read(struct spidev_data *spidev, size_t len)

126         .rx_buf = spidev->rx_buffer,

128         .speed_hz = spidev->speed_hz,

134     return spidev_sync(spidev, &m);

142     struct spidev_data *spidev;

150     spidev = filp->private_data;

152     mutex_lock(&spidev->buf_lock);

153     status = spidev_sync_read(spidev, count);

157         missing = copy_to_user(buf, spidev->rx_buffer, status);

164     mutex_unlock(&spidev->buf_lock);

172     struct spidev_data *spidev;

181     spidev = filp->private_data;

183     mutex_lock(&spidev->buf_lock);

184     missing = copy_from_user(spidev->tx_buffer, buf, count);

186         status = spidev_sync_write(spidev, count);

190     mutex_unlock(&spidev->buf_lock);

195 static int spidev_message(struct spidev_data *spidev, struct spi_ioc_transfer *u_xfers, unsigned n_xfers)

215     tx_buf = spidev->tx_buffer;

216     rx_buf = spidev->rx_buffer;

273             k_tmp->speed_hz = spidev->speed_hz;

276         dev_dbg(&spidev->spi->dev, "  xfer len %u %s%s%s%dbits %u usec %u usec %uHz\n", k_tmp->len,

278                 k_tmp->bits_per_word ?: spidev->spi->bits_per_word, k_tmp->delay.value, k_tmp->word_delay.value,

279                 k_tmp->speed_hz ?: spidev->spi->max_speed_hz);

284     status = spidev_sync(spidev, &msg);

331     struct spidev_data *spidev;

345     spidev = filp->private_data;

346     spin_lock_irq(&spidev->spi_lock);

347     spi = spi_dev_get(spidev->spi);

348     spin_unlock_irq(&spidev->spi_lock);

360     mutex_lock(&spidev->buf_lock);

377             retval = put_user(spidev->speed_hz, (__u32 __user *)arg);

451                     spidev->speed_hz = tmp;

452                     dev_dbg(&spi->dev, "%d Hz (max)\n", spidev->speed_hz);

471             retval = spidev_message(spidev, ioc, n_ioc);

476     mutex_unlock(&spidev->buf_lock);

486     struct spidev_data *spidev;

496     spidev = filp->private_data;

497     spin_lock_irq(&spidev->spi_lock);

498     spi = spi_dev_get(spidev->spi);

499     spin_unlock_irq(&spidev->spi_lock);

506     mutex_lock(&spidev->buf_lock);

525     retval = spidev_message(spidev, ioc, n_ioc);

529     mutex_unlock(&spidev->buf_lock);

548     struct spidev_data *spidev;

553     list_for_each_entry(spidev, &device_list, device_entry)

555         if (spidev->devt == inode->i_rdev) {

562         pr_debug("spidev: nothing for minor %d\n", iminor(inode));

566     if (!spidev->tx_buffer) {

567         spidev->tx_buffer = kmalloc(bufsiz, GFP_KERNEL);

568         if (!spidev->tx_buffer) {

569             dev_dbg(&spidev->spi->dev, "open/ENOMEM\n");

575     if (!spidev->rx_buffer) {

576         spidev->rx_buffer = kmalloc(bufsiz, GFP_KERNEL);

577         if (!spidev->rx_buffer) {

578             dev_dbg(&spidev->spi->dev, "open/ENOMEM\n");

584     spidev->users++;

585     filp->private_data = spidev;

592     kfree(spidev->tx_buffer);

593     spidev->tx_buffer = NULL;

601     struct spidev_data *spidev;

605     spidev = filp->private_data;

608     spin_lock_irq(&spidev->spi_lock);

610     dofree = (spidev->spi == NULL);

611     spin_unlock_irq(&spidev->spi_lock);

614     spidev->users--;

615     if (!spidev->users) {

616         kfree(spidev->tx_buffer);

617         spidev->tx_buffer = NULL;

619         kfree(spidev->rx_buffer);

620         spidev->rx_buffer = NULL;

623             kfree(spidev);

625             spidev->speed_hz = spidev->spi->max_speed_hz;

630         spi_slave_abort(spidev->spi);

671     {.compatible = "rockchip,spidev"},

723     struct spidev_data *spidev;

728      * spidev should never be referenced in DT without a specific

732     WARN(spi->dev.of_node && of_device_is_compatible(spi->dev.of_node, "spidev"),

733          "%pOF: buggy DT: spidev listed directly in DT\n", spi->dev.of_node);

738     spidev = kzalloc(sizeof(*spidev), GFP_KERNEL);

739     if (!spidev) {

744     spidev->spi = spi;

745     spin_lock_init(&spidev->spi_lock);

746     mutex_init(&spidev->buf_lock);

748     INIT_LIST_HEAD(&spidev->device_entry);

758         spidev->devt = MKDEV(SPIDEV_MAJOR, minor);

759         dev = device_create(spidev_class, &spi->dev, spidev->devt, spidev, "spidev%d.%d", spi->master->bus_num,

768         list_add(&spidev->device_entry, &device_list);

772     spidev->speed_hz = spi->max_speed_hz;

775         spi_set_drvdata(spi, spidev);

777         kfree(spidev);

785     struct spidev_data *spidev = spi_get_drvdata(spi);

790     spin_lock_irq(&spidev->spi_lock);

791     spidev->spi = NULL;

792     spin_unlock_irq(&spidev->spi_lock);

794     list_del(&spidev->device_entry);

795     device_destroy(spidev_class, spidev->devt);

796     clear_bit(MINOR(spidev->devt), minors);

797     if (spidev->users == 0) {

798         kfree(spidev);

808             .name = "spidev",

838     spidev_class = class_create(THIS_MODULE, "spidev");

864 MODULE_ALIAS("spi:spidev");