Lines Matching defs:spi
34 #include <linux/spi/spi.h>
35 #include <linux/spi/spi-mem.h>
39 #include <trace/events/spi.h>
49 struct spi_device *spi = to_spi_device(dev);
51 spi_controller_put(spi->controller);
52 kfree(spi->driver_override);
53 free_percpu(spi->pcpu_statistics);
54 kfree(spi);
60 const struct spi_device *spi = to_spi_device(dev);
67 return sysfs_emit(buf, "%s%s\n", SPI_MODULE_PREFIX, spi->modalias);
75 struct spi_device *spi = to_spi_device(dev);
78 ret = driver_set_override(dev, &spi->driver_override, buf, count);
88 const struct spi_device *spi = to_spi_device(dev);
92 len = sysfs_emit(buf, "%s\n", spi->driver_override ? : "");
160 struct spi_device *spi = to_spi_device(dev); \
161 return spi_statistics_##field##_show(spi->pcpu_statistics, buf); \
378 const struct spi_device *spi = to_spi_device(dev);
382 if (spi->driver_override)
383 return strcmp(spi->driver_override, drv->name) == 0;
394 return !!spi_match_id(sdrv->id_table, spi->modalias);
396 return strcmp(spi->modalias, drv->name) == 0;
401 const struct spi_device *spi = to_spi_device(dev);
408 return add_uevent_var(env, "MODALIAS=%s%s", SPI_MODULE_PREFIX, spi->modalias);
414 struct spi_device *spi = to_spi_device(dev);
422 spi->irq = of_irq_get(dev->of_node, 0);
423 if (spi->irq == -EPROBE_DEFER)
425 if (spi->irq < 0)
426 spi->irq = 0;
434 ret = sdrv->probe(spi);
463 .name = "spi",
487 * For Really Good Reasons we use spi: modaliases not of:
569 struct spi_device *spi;
574 spi = kzalloc(sizeof(*spi), GFP_KERNEL);
575 if (!spi) {
580 spi->pcpu_statistics = spi_alloc_pcpu_stats(NULL);
581 if (!spi->pcpu_statistics) {
582 kfree(spi);
587 spi->master = spi->controller = ctlr;
588 spi->dev.parent = &ctlr->dev;
589 spi->dev.bus = &spi_bus_type;
590 spi->dev.release = spidev_release;
591 spi->mode = ctlr->buswidth_override_bits;
593 device_initialize(&spi->dev);
594 return spi;
598 static void spi_dev_set_name(struct spi_device *spi)
600 struct acpi_device *adev = ACPI_COMPANION(&spi->dev);
603 dev_set_name(&spi->dev, "spi-%s", acpi_dev_name(adev));
607 dev_set_name(&spi->dev, "%s.%u", dev_name(&spi->controller->dev),
608 spi_get_chipselect(spi, 0));
613 struct spi_device *spi = to_spi_device(dev);
616 if (spi->controller == new_spi->controller &&
617 spi_get_chipselect(spi, 0) == spi_get_chipselect(new_spi, 0))
622 static void spi_cleanup(struct spi_device *spi)
624 if (spi->controller->cleanup)
625 spi->controller->cleanup(spi);
628 static int __spi_add_device(struct spi_device *spi)
630 struct spi_controller *ctlr = spi->controller;
635 if (spi_get_chipselect(spi, 0) >= ctlr->num_chipselect) {
636 dev_err(dev, "cs%d >= max %d\n", spi_get_chipselect(spi, 0),
642 spi_dev_set_name(spi);
649 status = bus_for_each_dev(&spi_bus_type, NULL, spi, spi_dev_check);
652 spi_get_chipselect(spi, 0));
663 spi_set_csgpiod(spi, 0, ctlr->cs_gpiods[spi_get_chipselect(spi, 0)]);
670 status = spi_setup(spi);
673 dev_name(&spi->dev), status);
678 status = device_add(&spi->dev);
681 dev_name(&spi->dev), status);
682 spi_cleanup(spi);
684 dev_dbg(dev, "registered child %s\n", dev_name(&spi->dev));
692 * @spi: spi_device to register
699 int spi_add_device(struct spi_device *spi)
701 struct spi_controller *ctlr = spi->controller;
705 status = __spi_add_device(spi);
778 * @spi: spi_device to unregister
783 void spi_unregister_device(struct spi_device *spi)
785 if (!spi)
788 if (spi->dev.of_node) {
789 of_node_clear_flag(spi->dev.of_node, OF_POPULATED);
790 of_node_put(spi->dev.of_node);
792 if (ACPI_COMPANION(&spi->dev))
793 acpi_device_clear_enumerated(ACPI_COMPANION(&spi->dev));
794 device_remove_software_node(&spi->dev);
795 device_del(&spi->dev);
796 spi_cleanup(spi);
797 put_device(&spi->dev);
869 * spi_res_alloc - allocate a spi resource that is life-cycle managed
872 * @spi: the SPI device for which we allocate memory
882 static void *spi_res_alloc(struct spi_device *spi, spi_res_release_t release,
946 static void spi_set_cs(struct spi_device *spi, bool enable, bool force)
954 if (!force && ((enable && spi->controller->last_cs == spi_get_chipselect(spi, 0)) ||
955 (!enable && spi->controller->last_cs != spi_get_chipselect(spi, 0))) &&
956 (spi->controller->last_cs_mode_high == (spi->mode & SPI_CS_HIGH)))
959 trace_spi_set_cs(spi, activate);
961 spi->controller->last_cs = enable ? spi_get_chipselect(spi, 0) : -1;
962 spi->controller->last_cs_mode_high = spi->mode & SPI_CS_HIGH;
964 if ((spi_get_csgpiod(spi, 0) || !spi->controller->set_cs_timing) && !activate)
965 spi_delay_exec(&spi->cs_hold, NULL);
967 if (spi->mode & SPI_CS_HIGH)
970 if (spi_get_csgpiod(spi, 0)) {
971 if (!(spi->mode & SPI_NO_CS)) {
982 if (has_acpi_companion(&spi->dev))
983 gpiod_set_value_cansleep(spi_get_csgpiod(spi, 0), !enable);
986 gpiod_set_value_cansleep(spi_get_csgpiod(spi, 0), activate);
989 if ((spi->controller->flags & SPI_CONTROLLER_GPIO_SS) &&
990 spi->controller->set_cs)
991 spi->controller->set_cs(spi, !enable);
992 } else if (spi->controller->set_cs) {
993 spi->controller->set_cs(spi, !enable);
996 if (spi_get_csgpiod(spi, 0) || !spi->controller->set_cs_timing) {
998 spi_delay_exec(&spi->cs_setup, NULL);
1000 spi_delay_exec(&spi->cs_inactive, NULL);
1135 if (!ctlr->can_dma(ctlr, msg->spi, xfer))
1181 if (!ctlr->can_dma(ctlr, msg->spi, xfer))
1274 && !(msg->spi->mode & SPI_3WIRE)) {
1324 struct spi_statistics __percpu *stats = msg->spi->pcpu_statistics;
1330 dev_dbg(&msg->spi->dev, "SPI transfer interrupted\n");
1360 dev_err(&msg->spi->dev,
1460 dev_err_once(&msg->spi->dev,
1488 struct spi_statistics __percpu *stats = msg->spi->pcpu_statistics;
1491 spi_set_cs(msg->spi, !xfer->cs_off, false);
1512 ret = ctlr->transfer_one(ctlr, msg->spi, xfer);
1528 dev_err(&msg->spi->dev,
1542 dev_err(&msg->spi->dev,
1565 spi_set_cs(msg->spi, false, false);
1568 spi_set_cs(msg->spi, true, false);
1572 spi_set_cs(msg->spi, xfer->cs_off, false);
1580 spi_set_cs(msg->spi, false, false);
1658 spi_max_transfer_size(msg->spi),
1824 * spi_pump_messages - kthread work function which processes spi message queue
2129 static int __spi_queued_transfer(struct spi_device *spi,
2133 struct spi_controller *ctlr = spi->controller;
2156 * @spi: SPI device which is requesting transfer
2161 static int spi_queued_transfer(struct spi_device *spi, struct spi_message *msg)
2163 return __spi_queued_transfer(spi, msg, true);
2201 * sent before doing something. Is used by the spi-mem code to make sure SPI
2203 * before the spi-mem operation.
2230 static int of_spi_parse_dt(struct spi_controller *ctlr, struct spi_device *spi,
2237 if (of_property_read_bool(nc, "spi-cpha"))
2238 spi->mode |= SPI_CPHA;
2239 if (of_property_read_bool(nc, "spi-cpol"))
2240 spi->mode |= SPI_CPOL;
2241 if (of_property_read_bool(nc, "spi-3wire"))
2242 spi->mode |= SPI_3WIRE;
2243 if (of_property_read_bool(nc, "spi-lsb-first"))
2244 spi->mode |= SPI_LSB_FIRST;
2245 if (of_property_read_bool(nc, "spi-cs-high"))
2246 spi->mode |= SPI_CS_HIGH;
2249 if (!of_property_read_u32(nc, "spi-tx-bus-width", &value)) {
2252 spi->mode |= SPI_NO_TX;
2257 spi->mode |= SPI_TX_DUAL;
2260 spi->mode |= SPI_TX_QUAD;
2263 spi->mode |= SPI_TX_OCTAL;
2267 "spi-tx-bus-width %d not supported\n",
2273 if (!of_property_read_u32(nc, "spi-rx-bus-width", &value)) {
2276 spi->mode |= SPI_NO_RX;
2281 spi->mode |= SPI_RX_DUAL;
2284 spi->mode |= SPI_RX_QUAD;
2287 spi->mode |= SPI_RX_OCTAL;
2291 "spi-rx-bus-width %d not supported\n",
2313 spi_set_chipselect(spi, 0, value);
2316 if (!of_property_read_u32(nc, "spi-max-frequency", &value))
2317 spi->max_speed_hz = value;
2320 of_spi_parse_dt_cs_delay(nc, &spi->cs_setup, "spi-cs-setup-delay-ns");
2321 of_spi_parse_dt_cs_delay(nc, &spi->cs_hold, "spi-cs-hold-delay-ns");
2322 of_spi_parse_dt_cs_delay(nc, &spi->cs_inactive, "spi-cs-inactive-delay-ns");
2330 struct spi_device *spi;
2334 spi = spi_alloc_device(ctlr);
2335 if (!spi) {
2342 rc = of_alias_from_compatible(nc, spi->modalias,
2343 sizeof(spi->modalias));
2349 rc = of_spi_parse_dt(ctlr, spi, nc);
2356 device_set_node(&spi->dev, of_fwnode_handle(nc));
2359 rc = spi_add_device(spi);
2365 return spi;
2370 spi_dev_put(spi);
2383 struct spi_device *spi;
2389 spi = of_register_spi_device(ctlr, nc);
2390 if (IS_ERR(spi)) {
2403 * @spi: Pointer to the main SPI device registering the ancillary device
2413 struct spi_device *spi_new_ancillary_device(struct spi_device *spi,
2416 struct spi_controller *ctlr = spi->controller;
2433 ancillary->max_speed_hz = spi->max_speed_hz;
2434 ancillary->mode = spi->mode;
2441 dev_err(&spi->dev, "failed to register ancillary device\n");
2615 * acpi_spi_device_alloc - Allocate a spi device, and fill it in with ACPI information
2616 * @ctlr: controller to which the spi device belongs
2617 * @adev: ACPI Device for the spi device
2618 * @index: Index of the spi resource inside the ACPI Node
2637 struct spi_device *spi;
2667 spi = spi_alloc_device(lookup.ctlr);
2668 if (!spi) {
2674 ACPI_COMPANION_SET(&spi->dev, adev);
2675 spi->max_speed_hz = lookup.max_speed_hz;
2676 spi->mode |= lookup.mode;
2677 spi->irq = lookup.irq;
2678 spi->bits_per_word = lookup.bits_per_word;
2679 spi_set_chipselect(spi, 0, lookup.chip_select);
2681 return spi;
2688 struct spi_device *spi;
2694 spi = acpi_spi_device_alloc(ctlr, adev, -1);
2695 if (IS_ERR(spi)) {
2696 if (PTR_ERR(spi) == -ENOMEM)
2702 acpi_set_modalias(adev, acpi_device_hid(adev), spi->modalias,
2703 sizeof(spi->modalias));
2705 if (spi->irq < 0)
2706 spi->irq = acpi_dev_gpio_irq_get(adev, 0);
2711 if (spi_add_device(spi)) {
2715 spi_dev_put(spi);
2772 * @spi: device used for the current transfer
2774 int spi_slave_abort(struct spi_device *spi)
2776 struct spi_controller *ctlr = spi->controller;
2785 int spi_target_abort(struct spi_device *spi)
2787 struct spi_controller *ctlr = spi->controller;
2812 struct spi_device *spi;
2830 spi = spi_alloc_device(ctlr);
2831 if (!spi)
2834 strscpy(spi->modalias, name, sizeof(spi->modalias));
2836 rc = spi_add_device(spi);
2838 spi_dev_put(spi);
3126 ctlr->bus_num = of_alias_get_id(ctlr->dev.of_node, "spi");
3134 first_dynamic = of_alias_get_highest_id("spi");
3154 dev_set_name(&ctlr->dev, "spi%u", ctlr->bus_num);
3432 rxfer = spi_res_alloc(msg->spi, __spi_replace_transfers_release,
3464 dev_err(&msg->spi->dev,
3577 SPI_STATISTICS_INCREMENT_FIELD(msg->spi->pcpu_statistics,
3584 * spi_split_transfers_maxsize - split spi transfers into multiple transfers
3688 * @spi: the device that requires specific CS timing configuration
3692 static int spi_set_cs_timing(struct spi_device *spi)
3694 struct device *parent = spi->controller->dev.parent;
3697 if (spi->controller->set_cs_timing && !spi_get_csgpiod(spi, 0)) {
3698 if (spi->controller->auto_runtime_pm) {
3702 dev_err(&spi->controller->dev, "Failed to power device: %d\n",
3707 status = spi->controller->set_cs_timing(spi);
3711 status = spi->controller->set_cs_timing(spi);
3719 * @spi: the device whose settings are being modified
3737 int spi_setup(struct spi_device *spi)
3746 if ((hweight_long(spi->mode &
3748 (hweight_long(spi->mode &
3750 dev_err(&spi->dev,
3755 if ((spi->mode & SPI_3WIRE) && (spi->mode &
3765 bad_bits = spi->mode & ~(spi->controller->mode_bits | SPI_CS_WORD |
3771 dev_warn(&spi->dev,
3774 spi->mode &= ~ugly_bits;
3778 dev_err(&spi->dev, "setup: unsupported mode bits %x\n",
3783 if (!spi->bits_per_word) {
3784 spi->bits_per_word = 8;
3790 status = __spi_validate_bits_per_word(spi->controller,
3791 spi->bits_per_word);
3796 if (spi->controller->max_speed_hz &&
3797 (!spi->max_speed_hz ||
3798 spi->max_speed_hz > spi->controller->max_speed_hz))
3799 spi->max_speed_hz = spi->controller->max_speed_hz;
3801 mutex_lock(&spi->controller->io_mutex);
3803 if (spi->controller->setup) {
3804 status = spi->controller->setup(spi);
3806 mutex_unlock(&spi->controller->io_mutex);
3807 dev_err(&spi->controller->dev, "Failed to setup device: %d\n",
3813 status = spi_set_cs_timing(spi);
3815 mutex_unlock(&spi->controller->io_mutex);
3819 if (spi->controller->auto_runtime_pm && spi->controller->set_cs) {
3820 status = pm_runtime_resume_and_get(spi->controller->dev.parent);
3822 mutex_unlock(&spi->controller->io_mutex);
3823 dev_err(&spi->controller->dev, "Failed to power device: %d\n",
3836 spi_set_cs(spi, false, true);
3837 pm_runtime_mark_last_busy(spi->controller->dev.parent);
3838 pm_runtime_put_autosuspend(spi->controller->dev.parent);
3840 spi_set_cs(spi, false, true);
3843 mutex_unlock(&spi->controller->io_mutex);
3845 if (spi->rt && !spi->controller->rt) {
3846 spi->controller->rt = true;
3847 spi_set_thread_rt(spi->controller);
3850 trace_spi_setup(spi, status);
3852 dev_dbg(&spi->dev, "setup mode %lu, %s%s%s%s%u bits/w, %u Hz max --> %d\n",
3853 spi->mode & SPI_MODE_X_MASK,
3854 (spi->mode & SPI_CS_HIGH) ? "cs_high, " : "",
3855 (spi->mode & SPI_LSB_FIRST) ? "lsb, " : "",
3856 (spi->mode & SPI_3WIRE) ? "3wire, " : "",
3857 (spi->mode & SPI_LOOP) ? "loopback, " : "",
3858 spi->bits_per_word, spi->max_speed_hz,
3866 struct spi_device *spi)
3874 delay2 = spi_delay_to_ns(&spi->word_delay, xfer);
3879 memcpy(&xfer->word_delay, &spi->word_delay,
3885 static int __spi_validate(struct spi_device *spi, struct spi_message *message)
3887 struct spi_controller *ctlr = spi->controller;
3901 if ((spi->mode & SPI_CS_WORD) && (!(ctlr->mode_bits & SPI_CS_WORD) ||
3902 spi_get_csgpiod(spi, 0))) {
3903 size_t maxsize = BITS_TO_BYTES(spi->bits_per_word);
3906 /* spi_split_transfers_maxsize() requires message->spi */
3907 message->spi = spi;
3929 (spi->mode & SPI_3WIRE)) {
3943 * Set transfer bits_per_word and max speed as spi device default if
3955 xfer->bits_per_word = spi->bits_per_word;
3958 xfer->speed_hz = spi->max_speed_hz;
3995 if (spi->mode & SPI_NO_TX)
4002 !(spi->mode & (SPI_TX_DUAL | SPI_TX_QUAD)))
4005 !(spi->mode & SPI_TX_QUAD))
4010 if (spi->mode & SPI_NO_RX)
4017 !(spi->mode & (SPI_RX_DUAL | SPI_RX_QUAD)))
4020 !(spi->mode & SPI_RX_QUAD))
4024 if (_spi_xfer_word_delay_update(xfer, spi))
4033 static int __spi_async(struct spi_device *spi, struct spi_message *message)
4035 struct spi_controller *ctlr = spi->controller;
4045 message->spi = spi;
4048 SPI_STATISTICS_INCREMENT_FIELD(spi->pcpu_statistics, spi_async);
4059 return ctlr->transfer(spi, message);
4064 * @spi: device with which data will be exchanged
4093 int spi_async(struct spi_device *spi, struct spi_message *message)
4095 struct spi_controller *ctlr = spi->controller;
4099 ret = __spi_validate(spi, message);
4108 ret = __spi_async(spi, message);
4118 * @spi: device with which data will be exchanged
4147 static int spi_async_locked(struct spi_device *spi, struct spi_message *message)
4149 struct spi_controller *ctlr = spi->controller;
4153 ret = __spi_validate(spi, message);
4159 ret = __spi_async(spi, message);
4211 static int __spi_sync(struct spi_device *spi, struct spi_message *message)
4215 struct spi_controller *ctlr = spi->controller;
4218 dev_warn_once(&spi->dev, "Attempted to sync while suspend\n");
4222 status = __spi_validate(spi, message);
4226 message->spi = spi;
4229 SPI_STATISTICS_INCREMENT_FIELD(spi->pcpu_statistics, spi_sync);
4244 SPI_STATISTICS_INCREMENT_FIELD(spi->pcpu_statistics, spi_sync_immediate);
4259 status = spi_async_locked(spi, message);
4271 * @spi: device with which data will be exchanged
4290 int spi_sync(struct spi_device *spi, struct spi_message *message)
4294 mutex_lock(&spi->controller->bus_lock_mutex);
4295 ret = __spi_sync(spi, message);
4296 mutex_unlock(&spi->controller->bus_lock_mutex);
4304 * @spi: device with which data will be exchanged
4318 int spi_sync_locked(struct spi_device *spi, struct spi_message *message)
4320 return __spi_sync(spi, message);
4385 * @spi: device with which data will be exchanged
4403 int spi_write_then_read(struct spi_device *spi,
4445 status = spi_sync(spi, &message);
4469 /* The spi controllers are not using spi_bus, so we find it with another way */
4489 struct spi_device *spi;
4507 spi = of_register_spi_device(ctlr, rd->dn);
4510 if (IS_ERR(spi)) {
4514 return notifier_from_errno(PTR_ERR(spi));
4524 spi = of_find_spi_device_by_node(rd->dn);
4525 if (spi == NULL)
4529 spi_unregister_device(spi);
4532 put_device(&spi->dev);
4580 struct spi_device *spi;
4595 spi = acpi_spi_find_device_by_adev(adev);
4596 if (!spi)
4599 spi_unregister_device(spi);
4600 put_device(&spi->dev);