Lines Matching defs:spi
19 #include <linux/spi/spi.h>
20 #include <linux/spi/spi-mem.h>
38 #include <trace/events/spi.h>
48 struct spi_device *spi = to_spi_device(dev);
50 spi_controller_put(spi->controller);
51 kfree(spi->driver_override);
52 kfree(spi);
58 const struct spi_device *spi = to_spi_device(dev);
65 return sprintf(buf, "%s%s\n", SPI_MODULE_PREFIX, spi->modalias);
73 struct spi_device *spi = to_spi_device(dev);
87 old = spi->driver_override;
89 spi->driver_override = driver_override;
92 spi->driver_override = NULL;
104 const struct spi_device *spi = to_spi_device(dev);
108 len = snprintf(buf, PAGE_SIZE, "%s\n", spi->driver_override ? : "");
131 struct spi_device *spi = to_spi_device(dev); \
132 return spi_statistics_##field##_show(&spi->statistics, buf); \
340 const struct spi_device *spi = to_spi_device(dev);
344 if (spi->driver_override)
345 return strcmp(spi->driver_override, drv->name) == 0;
356 return !!spi_match_id(sdrv->id_table, spi);
358 return strcmp(spi->modalias, drv->name) == 0;
363 const struct spi_device *spi = to_spi_device(dev);
370 return add_uevent_var(env, "MODALIAS=%s%s", SPI_MODULE_PREFIX, spi->modalias);
374 .name = "spi",
385 struct spi_device *spi = to_spi_device(dev);
393 spi->irq = of_irq_get(dev->of_node, 0);
394 if (spi->irq == -EPROBE_DEFER)
396 if (spi->irq < 0)
397 spi->irq = 0;
405 ret = sdrv->probe(spi);
494 struct spi_device *spi;
499 spi = kzalloc(sizeof(*spi), GFP_KERNEL);
500 if (!spi) {
505 spi->master = spi->controller = ctlr;
506 spi->dev.parent = &ctlr->dev;
507 spi->dev.bus = &spi_bus_type;
508 spi->dev.release = spidev_release;
509 spi->cs_gpio = -ENOENT;
510 spi->mode = ctlr->buswidth_override_bits;
512 spin_lock_init(&spi->statistics.lock);
514 device_initialize(&spi->dev);
515 return spi;
519 static void spi_dev_set_name(struct spi_device *spi)
521 struct acpi_device *adev = ACPI_COMPANION(&spi->dev);
524 dev_set_name(&spi->dev, "spi-%s", acpi_dev_name(adev));
528 dev_set_name(&spi->dev, "%s.%u", dev_name(&spi->controller->dev),
529 spi->chip_select);
534 struct spi_device *spi = to_spi_device(dev);
537 if (spi->controller == new_spi->controller &&
538 spi->chip_select == new_spi->chip_select)
543 static void spi_cleanup(struct spi_device *spi)
545 if (spi->controller->cleanup)
546 spi->controller->cleanup(spi);
551 * @spi: spi_device to register
554 * spi_alloc_device can be added onto the spi bus with this function.
558 int spi_add_device(struct spi_device *spi)
560 struct spi_controller *ctlr = spi->controller;
565 if (spi->chip_select >= ctlr->num_chipselect) {
566 dev_err(dev, "cs%d >= max %d\n", spi->chip_select,
572 spi_dev_set_name(spi);
580 status = bus_for_each_dev(&spi_bus_type, NULL, spi, spi_dev_check);
583 spi->chip_select);
596 spi->cs_gpiod = ctlr->cs_gpiods[spi->chip_select];
598 spi->cs_gpio = ctlr->cs_gpios[spi->chip_select];
604 status = spi_setup(spi);
607 dev_name(&spi->dev), status);
612 status = device_add(&spi->dev);
615 dev_name(&spi->dev), status);
616 spi_cleanup(spi);
618 dev_dbg(dev, "registered child %s\n", dev_name(&spi->dev));
696 * @spi: spi_device to unregister
701 void spi_unregister_device(struct spi_device *spi)
703 if (!spi)
706 if (spi->dev.of_node) {
707 of_node_clear_flag(spi->dev.of_node, OF_POPULATED);
708 of_node_put(spi->dev.of_node);
710 if (ACPI_COMPANION(&spi->dev))
711 acpi_device_clear_enumerated(ACPI_COMPANION(&spi->dev));
712 device_del(&spi->dev);
713 spi_cleanup(spi);
714 put_device(&spi->dev);
790 static void spi_set_cs(struct spi_device *spi, bool enable, bool force)
798 if (!force && (spi->controller->last_cs_enable == enable) &&
799 (spi->controller->last_cs_mode_high == (spi->mode & SPI_CS_HIGH)))
802 spi->controller->last_cs_enable = enable;
803 spi->controller->last_cs_mode_high = spi->mode & SPI_CS_HIGH;
805 if (!spi->controller->set_cs_timing) {
807 spi_delay_exec(&spi->controller->cs_setup, NULL);
809 spi_delay_exec(&spi->controller->cs_hold, NULL);
812 if (spi->mode & SPI_CS_HIGH)
815 if (spi->cs_gpiod || gpio_is_valid(spi->cs_gpio)) {
816 if (!(spi->mode & SPI_NO_CS)) {
817 if (spi->cs_gpiod) {
828 if (has_acpi_companion(&spi->dev))
829 gpiod_set_value_cansleep(spi->cs_gpiod, !enable);
832 gpiod_set_value_cansleep(spi->cs_gpiod, enable1);
838 gpio_set_value_cansleep(spi->cs_gpio, !enable);
842 if ((spi->controller->flags & SPI_MASTER_GPIO_SS) &&
843 spi->controller->set_cs)
844 spi->controller->set_cs(spi, !enable);
845 } else if (spi->controller->set_cs) {
846 spi->controller->set_cs(spi, !enable);
849 if (!spi->controller->set_cs_timing) {
851 spi_delay_exec(&spi->controller->cs_inactive, NULL);
968 if (!ctlr->can_dma(ctlr, msg->spi, xfer))
1015 if (!ctlr->can_dma(ctlr, msg->spi, xfer))
1066 && !(msg->spi->mode & SPI_3WIRE)) {
1117 struct spi_statistics *stats = &msg->spi->statistics;
1123 dev_dbg(&msg->spi->dev, "SPI transfer interrupted\n");
1143 dev_err(&msg->spi->dev,
1238 dev_err_once(&msg->spi->dev,
1259 struct spi_statistics *stats = &msg->spi->statistics;
1261 spi_set_cs(msg->spi, true, false);
1281 ret = ctlr->transfer_one(ctlr, msg->spi, xfer);
1295 dev_err(&msg->spi->dev,
1307 dev_err(&msg->spi->dev,
1329 spi_set_cs(msg->spi, false, false);
1331 spi_set_cs(msg->spi, true, false);
1340 spi_set_cs(msg->spi, false, false);
1376 * __spi_pump_messages - function which processes spi message queue
1380 * This function checks if there is any spi message in the queue that
1544 * spi_pump_messages - kthread work function which processes spi message queue
1744 /* In the prepare_messages callback the spi bus has the opportunity to
1850 static int __spi_queued_transfer(struct spi_device *spi,
1854 struct spi_controller *ctlr = spi->controller;
1876 * @spi: spi device which is requesting transfer
1877 * @msg: spi message which is to handled is queued to driver queue
1881 static int spi_queued_transfer(struct spi_device *spi, struct spi_message *msg)
1883 return __spi_queued_transfer(spi, msg, true);
1921 * sent before doing something. Is used by the spi-mem code to make sure SPI
1923 * before the spi-mem operation.
1934 static int of_spi_parse_dt(struct spi_controller *ctlr, struct spi_device *spi,
1941 if (of_property_read_bool(nc, "spi-cpha"))
1942 spi->mode |= SPI_CPHA;
1943 if (of_property_read_bool(nc, "spi-cpol"))
1944 spi->mode |= SPI_CPOL;
1945 if (of_property_read_bool(nc, "spi-3wire"))
1946 spi->mode |= SPI_3WIRE;
1947 if (of_property_read_bool(nc, "spi-lsb-first"))
1948 spi->mode |= SPI_LSB_FIRST;
1949 if (of_property_read_bool(nc, "spi-cs-high"))
1950 spi->mode |= SPI_CS_HIGH;
1953 if (!of_property_read_u32(nc, "spi-tx-bus-width", &value)) {
1958 spi->mode |= SPI_TX_DUAL;
1961 spi->mode |= SPI_TX_QUAD;
1964 spi->mode |= SPI_TX_OCTAL;
1968 "spi-tx-bus-width %d not supported\n",
1974 if (!of_property_read_u32(nc, "spi-rx-bus-width", &value)) {
1979 spi->mode |= SPI_RX_DUAL;
1982 spi->mode |= SPI_RX_QUAD;
1985 spi->mode |= SPI_RX_OCTAL;
1989 "spi-rx-bus-width %d not supported\n",
2011 spi->chip_select = value;
2014 if (!of_property_read_u32(nc, "spi-max-frequency", &value))
2015 spi->max_speed_hz = value;
2023 struct spi_device *spi;
2027 spi = spi_alloc_device(ctlr);
2028 if (!spi) {
2035 rc = of_modalias_node(nc, spi->modalias,
2036 sizeof(spi->modalias));
2042 rc = of_spi_parse_dt(ctlr, spi, nc);
2048 spi->dev.of_node = nc;
2049 spi->dev.fwnode = of_fwnode_handle(nc);
2052 rc = spi_add_device(spi);
2058 return spi;
2063 spi_dev_put(spi);
2076 struct spi_device *spi;
2085 spi = of_register_spi_device(ctlr, nc);
2086 if (IS_ERR(spi)) {
2201 struct spi_device *spi;
2230 spi = spi_alloc_device(ctlr);
2231 if (!spi) {
2238 ACPI_COMPANION_SET(&spi->dev, adev);
2239 spi->max_speed_hz = lookup.max_speed_hz;
2240 spi->mode |= lookup.mode;
2241 spi->irq = lookup.irq;
2242 spi->bits_per_word = lookup.bits_per_word;
2243 spi->chip_select = lookup.chip_select;
2245 acpi_set_modalias(adev, acpi_device_hid(adev), spi->modalias,
2246 sizeof(spi->modalias));
2248 if (spi->irq < 0)
2249 spi->irq = acpi_dev_gpio_irq_get(adev, 0);
2254 if (spi_add_device(spi)) {
2258 spi_dev_put(spi);
2316 * @spi: device used for the current transfer
2318 int spi_slave_abort(struct spi_device *spi)
2320 struct spi_controller *ctlr = spi->controller;
2351 struct spi_device *spi;
2369 spi = spi_alloc_device(ctlr);
2370 if (!spi)
2373 strlcpy(spi->modalias, name, sizeof(spi->modalias));
2375 rc = spi_add_device(spi);
2377 spi_dev_put(spi);
2696 id = of_alias_get_id(ctlr->dev.of_node, "spi");
2708 first_dynamic = of_alias_get_highest_id("spi");
2736 dev_set_name(&ctlr->dev, "spi%u", ctlr->bus_num);
2979 * spi_res_alloc - allocate a spi resource that is life-cycle managed
2982 * @spi: the spi device for which we allocate memory
2992 void *spi_res_alloc(struct spi_device *spi,
3010 * spi_res_free - free an spi resource
3028 * @message: the spi message
3041 * spi_res_release - release all spi resources for this message
3112 rxfer = spi_res_alloc(msg->spi, __spi_replace_transfers_release,
3142 dev_err(&msg->spi->dev,
3252 SPI_STATISTICS_INCREMENT_FIELD(&msg->spi->statistics,
3259 * spi_split_tranfers_maxsize - split spi transfers into multiple transfers
3318 * @spi: the device whose settings are being modified
3327 * or from it. When this function returns, the spi device is deselected.
3336 int spi_setup(struct spi_device *spi)
3343 if (((spi->mode & SPI_TX_DUAL) && (spi->mode & SPI_TX_QUAD)) ||
3344 ((spi->mode & SPI_RX_DUAL) && (spi->mode & SPI_RX_QUAD))) {
3345 dev_err(&spi->dev,
3351 if ((spi->mode & SPI_3WIRE) && (spi->mode &
3360 bad_bits = spi->mode & ~(spi->controller->mode_bits | SPI_CS_WORD);
3364 if (gpio_is_valid(spi->cs_gpio))
3370 dev_warn(&spi->dev,
3373 spi->mode &= ~ugly_bits;
3377 dev_err(&spi->dev, "setup: unsupported mode bits %x\n",
3382 if (!spi->bits_per_word)
3383 spi->bits_per_word = 8;
3385 status = __spi_validate_bits_per_word(spi->controller,
3386 spi->bits_per_word);
3390 if (!spi->max_speed_hz)
3391 spi->max_speed_hz = spi->controller->max_speed_hz;
3393 mutex_lock(&spi->controller->io_mutex);
3395 if (spi->controller->setup)
3396 status = spi->controller->setup(spi);
3398 if (spi->controller->auto_runtime_pm && spi->controller->set_cs) {
3399 status = pm_runtime_get_sync(spi->controller->dev.parent);
3401 mutex_unlock(&spi->controller->io_mutex);
3402 pm_runtime_put_noidle(spi->controller->dev.parent);
3403 dev_err(&spi->controller->dev, "Failed to power device: %d\n",
3416 spi_set_cs(spi, false, true);
3417 pm_runtime_mark_last_busy(spi->controller->dev.parent);
3418 pm_runtime_put_autosuspend(spi->controller->dev.parent);
3420 spi_set_cs(spi, false, true);
3423 mutex_unlock(&spi->controller->io_mutex);
3425 if (spi->rt && !spi->controller->rt) {
3426 spi->controller->rt = true;
3427 spi_set_thread_rt(spi->controller);
3430 dev_dbg(&spi->dev, "setup mode %d, %s%s%s%s%u bits/w, %u Hz max --> %d\n",
3431 (int) (spi->mode & (SPI_CPOL | SPI_CPHA)),
3432 (spi->mode & SPI_CS_HIGH) ? "cs_high, " : "",
3433 (spi->mode & SPI_LSB_FIRST) ? "lsb, " : "",
3434 (spi->mode & SPI_3WIRE) ? "3wire, " : "",
3435 (spi->mode & SPI_LOOP) ? "loopback, " : "",
3436 spi->bits_per_word, spi->max_speed_hz,
3445 * @spi: the device that requires specific CS timing configuration
3452 int spi_set_cs_timing(struct spi_device *spi, struct spi_delay *setup,
3457 if (spi->controller->set_cs_timing)
3458 return spi->controller->set_cs_timing(spi, setup, hold,
3464 dev_err(&spi->dev,
3473 memcpy(&spi->controller->cs_setup, setup, len);
3475 memset(&spi->controller->cs_setup, 0, len);
3478 memcpy(&spi->controller->cs_hold, hold, len);
3480 memset(&spi->controller->cs_hold, 0, len);
3483 memcpy(&spi->controller->cs_inactive, inactive, len);
3485 memset(&spi->controller->cs_inactive, 0, len);
3492 struct spi_device *spi)
3500 delay2 = spi_delay_to_ns(&spi->word_delay, xfer);
3505 memcpy(&xfer->word_delay, &spi->word_delay,
3511 static int __spi_validate(struct spi_device *spi, struct spi_message *message)
3513 struct spi_controller *ctlr = spi->controller;
3526 if ((spi->mode & SPI_CS_WORD) && (!(ctlr->mode_bits & SPI_CS_WORD) ||
3527 spi->cs_gpiod ||
3528 gpio_is_valid(spi->cs_gpio))) {
3532 maxsize = (spi->bits_per_word + 7) / 8;
3534 /* spi_split_transfers_maxsize() requires message->spi */
3535 message->spi = spi;
3556 (spi->mode & SPI_3WIRE)) {
3570 * Set transfer bits_per_word and max speed as spi device default if
3582 xfer->bits_per_word = spi->bits_per_word;
3585 xfer->speed_hz = spi->max_speed_hz;
3626 !(spi->mode & (SPI_TX_DUAL | SPI_TX_QUAD)))
3629 !(spi->mode & SPI_TX_QUAD))
3639 !(spi->mode & (SPI_RX_DUAL | SPI_RX_QUAD)))
3642 !(spi->mode & SPI_RX_QUAD))
3646 if (_spi_xfer_word_delay_update(xfer, spi))
3655 static int __spi_async(struct spi_device *spi, struct spi_message *message)
3657 struct spi_controller *ctlr = spi->controller;
3667 message->spi = spi;
3670 SPI_STATISTICS_INCREMENT_FIELD(&spi->statistics, spi_async);
3681 return ctlr->transfer(spi, message);
3686 * @spi: device with which data will be exchanged
3715 int spi_async(struct spi_device *spi, struct spi_message *message)
3717 struct spi_controller *ctlr = spi->controller;
3721 ret = __spi_validate(spi, message);
3730 ret = __spi_async(spi, message);
3740 * @spi: device with which data will be exchanged
3769 int spi_async_locked(struct spi_device *spi, struct spi_message *message)
3771 struct spi_controller *ctlr = spi->controller;
3775 ret = __spi_validate(spi, message);
3781 ret = __spi_async(spi, message);
3802 static int __spi_sync(struct spi_device *spi, struct spi_message *message)
3806 struct spi_controller *ctlr = spi->controller;
3809 status = __spi_validate(spi, message);
3815 message->spi = spi;
3818 SPI_STATISTICS_INCREMENT_FIELD(&spi->statistics, spi_sync);
3830 status = __spi_queued_transfer(spi, message, false);
3834 status = spi_async_locked(spi, message);
3844 SPI_STATISTICS_INCREMENT_FIELD(&spi->statistics,
3858 * @spi: device with which data will be exchanged
3877 int spi_sync(struct spi_device *spi, struct spi_message *message)
3881 mutex_lock(&spi->controller->bus_lock_mutex);
3882 ret = __spi_sync(spi, message);
3883 mutex_unlock(&spi->controller->bus_lock_mutex);
3891 * @spi: device with which data will be exchanged
3905 int spi_sync_locked(struct spi_device *spi, struct spi_message *message)
3907 return __spi_sync(spi, message);
3972 * @spi: device with which data will be exchanged
3990 int spi_write_then_read(struct spi_device *spi,
4031 status = spi_sync(spi, &message);
4058 /* the spi controllers are not using spi_bus, so we find it with another way */
4078 struct spi_device *spi;
4091 spi = of_register_spi_device(ctlr, rd->dn);
4094 if (IS_ERR(spi)) {
4098 return notifier_from_errno(PTR_ERR(spi));
4108 spi = of_find_spi_device_by_node(rd->dn);
4109 if (spi == NULL)
4113 spi_unregister_device(spi);
4116 put_device(&spi->dev);
4164 struct spi_device *spi;
4179 spi = acpi_spi_find_device_by_adev(adev);
4180 if (!spi)
4183 spi_unregister_device(spi);
4184 put_device(&spi->dev);