Lines Matching refs: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); \
376 const struct spi_device *spi = to_spi_device(dev);
380 if (spi->driver_override)
381 return strcmp(spi->driver_override, drv->name) == 0;
392 return !!spi_match_id(sdrv->id_table, spi->modalias);
394 return strcmp(spi->modalias, drv->name) == 0;
399 const struct spi_device *spi = to_spi_device(dev);
406 return add_uevent_var(env, "MODALIAS=%s%s", SPI_MODULE_PREFIX, spi->modalias);
412 struct spi_device *spi = to_spi_device(dev);
421 spi->irq = of_irq_get(dev->of_node, 0);
422 else if (is_acpi_device_node(fwnode) && spi->irq < 0)
423 spi->irq = acpi_dev_gpio_irq_get(to_acpi_device_node(fwnode), 0);
424 if (spi->irq == -EPROBE_DEFER)
425 return dev_err_probe(dev, spi->irq, "Failed to get irq\n");
426 if (spi->irq < 0)
427 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->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 device *dev = &spi->dev;
604 dev_set_name(dev, "spi-%s", acpi_dev_name(to_acpi_device_node(fwnode)));
609 dev_set_name(dev, "spi-%pfwP", fwnode);
613 dev_set_name(&spi->dev, "%s.%u", dev_name(&spi->controller->dev),
614 spi_get_chipselect(spi, 0));
619 * logical CS in the spi->chip_select[]. If all the physical CS
634 struct spi_device *spi, u8 idx,
640 cs = spi_get_chipselect(spi, idx);
653 struct spi_device *spi = to_spi_device(dev);
657 if (spi->controller == new_spi->controller) {
659 status = spi_dev_check_cs(dev, spi, idx, new_spi, 0);
667 static void spi_cleanup(struct spi_device *spi)
669 if (spi->controller->cleanup)
670 spi->controller->cleanup(spi);
673 static int __spi_add_device(struct spi_device *spi)
675 struct spi_controller *ctlr = spi->controller;
682 cs = spi_get_chipselect(spi, idx);
684 dev_err(dev, "cs%d >= max %d\n", spi_get_chipselect(spi, idx),
692 * For example, spi->chip_select[0] != spi->chip_select[1] and so on.
696 status = spi_dev_check_cs(dev, spi, idx, spi, idx + 1);
703 spi_dev_set_name(spi);
710 status = bus_for_each_dev(&spi_bus_type, NULL, spi, spi_dev_check);
724 cs = spi_get_chipselect(spi, idx);
726 spi_set_csgpiod(spi, idx, ctlr->cs_gpiods[cs]);
735 status = spi_setup(spi);
738 dev_name(&spi->dev), status);
743 status = device_add(&spi->dev);
746 dev_name(&spi->dev), status);
747 spi_cleanup(spi);
749 dev_dbg(dev, "registered child %s\n", dev_name(&spi->dev));
757 * @spi: spi_device to register
764 int spi_add_device(struct spi_device *spi)
766 struct spi_controller *ctlr = spi->controller;
770 spi_dev_set_name(spi);
773 status = __spi_add_device(spi);
779 static void spi_set_all_cs_unused(struct spi_device *spi)
784 spi_set_chipselect(spi, idx, SPI_INVALID_CS);
833 * By default spi->chip_select[0] will hold the physical CS number,
834 * so set bit 0 in spi->cs_index_mask.
862 * @spi: spi_device to unregister
867 void spi_unregister_device(struct spi_device *spi)
871 if (!spi)
874 fwnode = dev_fwnode(&spi->dev);
881 device_remove_software_node(&spi->dev);
882 device_del(&spi->dev);
883 spi_cleanup(spi);
884 put_device(&spi->dev);
956 * spi_res_alloc - allocate a spi resource that is life-cycle managed
959 * @spi: the SPI device for which we allocate memory
969 static void *spi_res_alloc(struct spi_device *spi, spi_res_release_t release,
1029 #define spi_for_each_valid_cs(spi, idx) \
1031 if (!(spi->cs_index_mask & BIT(idx))) {} else
1033 static inline bool spi_is_last_cs(struct spi_device *spi)
1038 spi_for_each_valid_cs(spi, idx) {
1039 if (spi->controller->last_cs[idx] == spi_get_chipselect(spi, idx))
1045 static void spi_toggle_csgpiod(struct spi_device *spi, u8 idx, bool enable, bool activate)
1057 if (is_acpi_device_node(dev_fwnode(&spi->dev)))
1058 gpiod_set_value_cansleep(spi_get_csgpiod(spi, idx), !enable);
1061 gpiod_set_value_cansleep(spi_get_csgpiod(spi, idx), activate);
1064 spi_delay_exec(&spi->cs_setup, NULL);
1066 spi_delay_exec(&spi->cs_inactive, NULL);
1069 static void spi_set_cs(struct spi_device *spi, bool enable, bool force)
1078 if (!force && ((enable && spi->controller->last_cs_index_mask == spi->cs_index_mask &&
1079 spi_is_last_cs(spi)) ||
1080 (!enable && spi->controller->last_cs_index_mask == spi->cs_index_mask &&
1081 !spi_is_last_cs(spi))) &&
1082 (spi->controller->last_cs_mode_high == (spi->mode & SPI_CS_HIGH)))
1085 trace_spi_set_cs(spi, activate);
1087 spi->controller->last_cs_index_mask = spi->cs_index_mask;
1089 spi->controller->last_cs[idx] = enable ? spi_get_chipselect(spi, 0) : SPI_INVALID_CS;
1090 spi->controller->last_cs_mode_high = spi->mode & SPI_CS_HIGH;
1092 if (spi->mode & SPI_CS_HIGH)
1099 if ((spi_is_csgpiod(spi) || !spi->controller->set_cs_timing) && !activate)
1100 spi_delay_exec(&spi->cs_hold, NULL);
1102 if (spi_is_csgpiod(spi)) {
1103 if (!(spi->mode & SPI_NO_CS)) {
1104 spi_for_each_valid_cs(spi, idx) {
1105 if (spi_get_csgpiod(spi, idx))
1106 spi_toggle_csgpiod(spi, idx, enable, activate);
1110 if ((spi->controller->flags & SPI_CONTROLLER_GPIO_SS) &&
1111 spi->controller->set_cs)
1112 spi->controller->set_cs(spi, !enable);
1113 } else if (spi->controller->set_cs) {
1114 spi->controller->set_cs(spi, !enable);
1117 if (spi_is_csgpiod(spi) || !spi->controller->set_cs_timing) {
1119 spi_delay_exec(&spi->cs_setup, NULL);
1121 spi_delay_exec(&spi->cs_inactive, NULL);
1255 if (!ctlr->can_dma(ctlr, msg->spi, xfer))
1391 && !(msg->spi->mode & SPI_3WIRE)) {
1441 struct spi_statistics __percpu *stats = msg->spi->pcpu_statistics;
1447 dev_dbg(&msg->spi->dev, "SPI transfer interrupted\n");
1477 dev_err(&msg->spi->dev,
1580 dev_err_once(&msg->spi->dev,
1608 struct spi_statistics __percpu *stats = msg->spi->pcpu_statistics;
1611 spi_set_cs(msg->spi, !xfer->cs_off, false);
1632 ret = ctlr->transfer_one(ctlr, msg->spi, xfer);
1648 dev_err(&msg->spi->dev,
1662 dev_err(&msg->spi->dev,
1685 spi_set_cs(msg->spi, false, false);
1688 spi_set_cs(msg->spi, true, false);
1692 spi_set_cs(msg->spi, xfer->cs_off, false);
1700 spi_set_cs(msg->spi, false, false);
1935 * spi_pump_messages - kthread work function which processes spi message queue
2117 struct spi_controller *ctlr = msg->spi->controller;
2138 !msg->spi->controller->defer_optimize_message)
2262 static int __spi_queued_transfer(struct spi_device *spi,
2266 struct spi_controller *ctlr = spi->controller;
2289 * @spi: SPI device which is requesting transfer
2294 static int spi_queued_transfer(struct spi_device *spi, struct spi_message *msg)
2296 return __spi_queued_transfer(spi, msg, true);
2334 * sent before doing something. Is used by the spi-mem code to make sure SPI
2336 * before the spi-mem operation.
2363 static int of_spi_parse_dt(struct spi_controller *ctlr, struct spi_device *spi,
2370 if (of_property_read_bool(nc, "spi-cpha"))
2371 spi->mode |= SPI_CPHA;
2372 if (of_property_read_bool(nc, "spi-cpol"))
2373 spi->mode |= SPI_CPOL;
2374 if (of_property_read_bool(nc, "spi-3wire"))
2375 spi->mode |= SPI_3WIRE;
2376 if (of_property_read_bool(nc, "spi-lsb-first"))
2377 spi->mode |= SPI_LSB_FIRST;
2378 if (of_property_read_bool(nc, "spi-cs-high"))
2379 spi->mode |= SPI_CS_HIGH;
2382 if (!of_property_read_u32(nc, "spi-tx-bus-width", &value)) {
2385 spi->mode |= SPI_NO_TX;
2390 spi->mode |= SPI_TX_DUAL;
2393 spi->mode |= SPI_TX_QUAD;
2396 spi->mode |= SPI_TX_OCTAL;
2400 "spi-tx-bus-width %d not supported\n",
2406 if (!of_property_read_u32(nc, "spi-rx-bus-width", &value)) {
2409 spi->mode |= SPI_NO_RX;
2414 spi->mode |= SPI_RX_DUAL;
2417 spi->mode |= SPI_RX_QUAD;
2420 spi->mode |= SPI_RX_OCTAL;
2424 "spi-rx-bus-width %d not supported\n",
2444 spi_set_all_cs_unused(spi);
2465 spi_set_chipselect(spi, idx, cs[idx]);
2468 * By default spi->chip_select[0] will hold the physical CS number,
2469 * so set bit 0 in spi->cs_index_mask.
2471 spi->cs_index_mask = BIT(0);
2474 if (!of_property_read_u32(nc, "spi-max-frequency", &value))
2475 spi->max_speed_hz = value;
2478 of_spi_parse_dt_cs_delay(nc, &spi->cs_setup, "spi-cs-setup-delay-ns");
2479 of_spi_parse_dt_cs_delay(nc, &spi->cs_hold, "spi-cs-hold-delay-ns");
2480 of_spi_parse_dt_cs_delay(nc, &spi->cs_inactive, "spi-cs-inactive-delay-ns");
2488 struct spi_device *spi;
2492 spi = spi_alloc_device(ctlr);
2493 if (!spi) {
2500 rc = of_alias_from_compatible(nc, spi->modalias,
2501 sizeof(spi->modalias));
2507 rc = of_spi_parse_dt(ctlr, spi, nc);
2514 device_set_node(&spi->dev, of_fwnode_handle(nc));
2517 rc = spi_add_device(spi);
2523 return spi;
2528 spi_dev_put(spi);
2541 struct spi_device *spi;
2547 spi = of_register_spi_device(ctlr, nc);
2548 if (IS_ERR(spi)) {
2561 * @spi: Pointer to the main SPI device registering the ancillary device
2571 struct spi_device *spi_new_ancillary_device(struct spi_device *spi,
2574 struct spi_controller *ctlr = spi->controller;
2592 ancillary->max_speed_hz = spi->max_speed_hz;
2593 ancillary->mode = spi->mode;
2595 * By default spi->chip_select[0] will hold the physical CS number,
2596 * so set bit 0 in spi->cs_index_mask.
2605 dev_err(&spi->dev, "failed to register ancillary device\n");
2777 * acpi_spi_device_alloc - Allocate a spi device, and fill it in with ACPI information
2778 * @ctlr: controller to which the spi device belongs
2779 * @adev: ACPI Device for the spi device
2780 * @index: Index of the spi resource inside the ACPI Node
2799 struct spi_device *spi;
2829 spi = spi_alloc_device(lookup.ctlr);
2830 if (!spi) {
2836 spi_set_all_cs_unused(spi);
2837 spi_set_chipselect(spi, 0, lookup.chip_select);
2839 ACPI_COMPANION_SET(&spi->dev, adev);
2840 spi->max_speed_hz = lookup.max_speed_hz;
2841 spi->mode |= lookup.mode;
2842 spi->irq = lookup.irq;
2843 spi->bits_per_word = lookup.bits_per_word;
2845 * By default spi->chip_select[0] will hold the physical CS number,
2846 * so set bit 0 in spi->cs_index_mask.
2848 spi->cs_index_mask = BIT(0);
2850 return spi;
2857 struct spi_device *spi;
2863 spi = acpi_spi_device_alloc(ctlr, adev, -1);
2864 if (IS_ERR(spi)) {
2865 if (PTR_ERR(spi) == -ENOMEM)
2871 acpi_set_modalias(adev, acpi_device_hid(adev), spi->modalias,
2872 sizeof(spi->modalias));
2877 if (spi_add_device(spi)) {
2881 spi_dev_put(spi);
2938 * @spi: device used for the current transfer
2940 int spi_target_abort(struct spi_device *spi)
2942 struct spi_controller *ctlr = spi->controller;
2967 struct spi_device *spi;
2985 spi = spi_alloc_device(ctlr);
2986 if (!spi)
2989 strscpy(spi->modalias, name, sizeof(spi->modalias));
2991 rc = spi_add_device(spi);
2993 spi_dev_put(spi);
3282 ctlr->bus_num = of_alias_get_id(ctlr->dev.of_node, "spi");
3290 first_dynamic = of_alias_get_highest_id("spi");
3310 dev_set_name(&ctlr->dev, "spi%u", ctlr->bus_num);
3589 rxfer = spi_res_alloc(msg->spi, __spi_replace_transfers_release,
3621 dev_err(&msg->spi->dev,
3726 SPI_STATISTICS_INCREMENT_FIELD(msg->spi->pcpu_statistics,
3733 * spi_split_transfers_maxsize - split spi transfers into multiple transfers
3741 * spi message unoptimize phase so this function should only be called from
3783 * spi message unoptimize phase so this function should only be called from
3841 * @spi: the device that requires specific CS timing configuration
3845 static int spi_set_cs_timing(struct spi_device *spi)
3847 struct device *parent = spi->controller->dev.parent;
3850 if (spi->controller->set_cs_timing && !spi_get_csgpiod(spi, 0)) {
3851 if (spi->controller->auto_runtime_pm) {
3855 dev_err(&spi->controller->dev, "Failed to power device: %d\n",
3860 status = spi->controller->set_cs_timing(spi);
3864 status = spi->controller->set_cs_timing(spi);
3872 * @spi: the device whose settings are being modified
3890 int spi_setup(struct spi_device *spi)
3899 if ((hweight_long(spi->mode &
3901 (hweight_long(spi->mode &
3903 dev_err(&spi->dev,
3908 if ((spi->mode & SPI_3WIRE) && (spi->mode &
3913 if ((spi->mode & SPI_MOSI_IDLE_LOW) && (spi->mode & SPI_MOSI_IDLE_HIGH)) {
3914 dev_err(&spi->dev,
3924 bad_bits = spi->mode & ~(spi->controller->mode_bits | SPI_CS_WORD |
3930 dev_warn(&spi->dev,
3933 spi->mode &= ~ugly_bits;
3937 dev_err(&spi->dev, "setup: unsupported mode bits %x\n",
3942 if (!spi->bits_per_word) {
3943 spi->bits_per_word = 8;
3949 status = __spi_validate_bits_per_word(spi->controller,
3950 spi->bits_per_word);
3955 if (spi->controller->max_speed_hz &&
3956 (!spi->max_speed_hz ||
3957 spi->max_speed_hz > spi->controller->max_speed_hz))
3958 spi->max_speed_hz = spi->controller->max_speed_hz;
3960 mutex_lock(&spi->controller->io_mutex);
3962 if (spi->controller->setup) {
3963 status = spi->controller->setup(spi);
3965 mutex_unlock(&spi->controller->io_mutex);
3966 dev_err(&spi->controller->dev, "Failed to setup device: %d\n",
3972 status = spi_set_cs_timing(spi);
3974 mutex_unlock(&spi->controller->io_mutex);
3978 if (spi->controller->auto_runtime_pm && spi->controller->set_cs) {
3979 status = pm_runtime_resume_and_get(spi->controller->dev.parent);
3981 mutex_unlock(&spi->controller->io_mutex);
3982 dev_err(&spi->controller->dev, "Failed to power device: %d\n",
3995 spi_set_cs(spi, false, true);
3996 pm_runtime_mark_last_busy(spi->controller->dev.parent);
3997 pm_runtime_put_autosuspend(spi->controller->dev.parent);
3999 spi_set_cs(spi, false, true);
4002 mutex_unlock(&spi->controller->io_mutex);
4004 if (spi->rt && !spi->controller->rt) {
4005 spi->controller->rt = true;
4006 spi_set_thread_rt(spi->controller);
4009 trace_spi_setup(spi, status);
4011 dev_dbg(&spi->dev, "setup mode %lu, %s%s%s%s%u bits/w, %u Hz max --> %d\n",
4012 spi->mode & SPI_MODE_X_MASK,
4013 (spi->mode & SPI_CS_HIGH) ? "cs_high, " : "",
4014 (spi->mode & SPI_LSB_FIRST) ? "lsb, " : "",
4015 (spi->mode & SPI_3WIRE) ? "3wire, " : "",
4016 (spi->mode & SPI_LOOP) ? "loopback, " : "",
4017 spi->bits_per_word, spi->max_speed_hz,
4025 struct spi_device *spi)
4033 delay2 = spi_delay_to_ns(&spi->word_delay, xfer);
4038 memcpy(&xfer->word_delay, &spi->word_delay,
4044 static int __spi_validate(struct spi_device *spi, struct spi_message *message)
4046 struct spi_controller *ctlr = spi->controller;
4053 message->spi = spi;
4062 (spi->mode & SPI_3WIRE)) {
4076 * Set transfer bits_per_word and max speed as spi device default if
4088 xfer->bits_per_word = spi->bits_per_word;
4091 xfer->speed_hz = spi->max_speed_hz;
4128 if (spi->mode & SPI_NO_TX)
4136 !(spi->mode & (SPI_TX_DUAL | SPI_TX_QUAD)))
4139 !(spi->mode & SPI_TX_QUAD))
4144 if (spi->mode & SPI_NO_RX)
4152 !(spi->mode & (SPI_RX_DUAL | SPI_RX_QUAD)))
4155 !(spi->mode & SPI_RX_QUAD))
4159 if (_spi_xfer_word_delay_update(xfer, spi))
4185 struct spi_controller *ctlr = msg->spi->controller;
4196 if ((msg->spi->mode & SPI_CS_WORD) &&
4197 (!(ctlr->mode_bits & SPI_CS_WORD) || spi_is_csgpiod(msg->spi))) {
4211 spi_max_transfer_size(msg->spi));
4222 * @spi: the device that will be used for the message
4225 * Peripheral drivers will call spi_optimize_message() and the spi core will
4232 static int __spi_optimize_message(struct spi_device *spi,
4235 struct spi_controller *ctlr = spi->controller;
4238 ret = __spi_validate(spi, msg);
4261 * @spi: the device that will be used for the message
4265 static int spi_maybe_optimize_message(struct spi_device *spi,
4268 if (spi->controller->defer_optimize_message) {
4269 msg->spi = spi;
4276 return __spi_optimize_message(spi, msg);
4281 * @spi: the device that will be used for the message
4299 int spi_optimize_message(struct spi_device *spi, struct spi_message *msg)
4305 * when using spi-mux.
4307 if (spi->controller->defer_optimize_message)
4310 ret = __spi_optimize_message(spi, msg);
4336 if (msg->spi->controller->defer_optimize_message)
4344 static int __spi_async(struct spi_device *spi, struct spi_message *message)
4346 struct spi_controller *ctlr = spi->controller;
4357 SPI_STATISTICS_INCREMENT_FIELD(spi->pcpu_statistics, spi_async);
4368 return ctlr->transfer(spi, message);
4378 * @dev: the device that manages @msg (usually @spi->dev)
4379 * @spi: the device that will be used for the message
4386 int devm_spi_optimize_message(struct device *dev, struct spi_device *spi,
4391 ret = spi_optimize_message(spi, msg);
4401 * @spi: device with which data will be exchanged
4430 int spi_async(struct spi_device *spi, struct spi_message *message)
4432 struct spi_controller *ctlr = spi->controller;
4436 ret = spi_maybe_optimize_message(spi, message);
4445 ret = __spi_async(spi, message);
4497 static int __spi_sync(struct spi_device *spi, struct spi_message *message)
4502 struct spi_controller *ctlr = spi->controller;
4505 dev_warn_once(&spi->dev, "Attempted to sync while suspend\n");
4509 status = spi_maybe_optimize_message(spi, message);
4514 SPI_STATISTICS_INCREMENT_FIELD(spi->pcpu_statistics, spi_sync);
4529 SPI_STATISTICS_INCREMENT_FIELD(spi->pcpu_statistics, spi_sync_immediate);
4546 status = __spi_async(spi, message);
4561 * @spi: device with which data will be exchanged
4580 int spi_sync(struct spi_device *spi, struct spi_message *message)
4584 mutex_lock(&spi->controller->bus_lock_mutex);
4585 ret = __spi_sync(spi, message);
4586 mutex_unlock(&spi->controller->bus_lock_mutex);
4594 * @spi: device with which data will be exchanged
4608 int spi_sync_locked(struct spi_device *spi, struct spi_message *message)
4610 return __spi_sync(spi, message);
4675 * @spi: device with which data will be exchanged
4693 int spi_write_then_read(struct spi_device *spi,
4735 status = spi_sync(spi, &message);
4759 /* The spi controllers are not using spi_bus, so we find it with another way */
4779 struct spi_device *spi;
4797 spi = of_register_spi_device(ctlr, rd->dn);
4800 if (IS_ERR(spi)) {
4804 return notifier_from_errno(PTR_ERR(spi));
4814 spi = of_find_spi_device_by_node(rd->dn);
4815 if (spi == NULL)
4819 spi_unregister_device(spi);
4822 put_device(&spi->dev);
4871 struct spi_device *spi;
4886 spi = acpi_spi_find_device_by_adev(adev);
4887 if (!spi)
4890 spi_unregister_device(spi);
4891 put_device(&spi->dev);