drivers/spi/spi.c

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);
420 		spi->irq = of_irq_get(dev->of_node, 0);
421 		if (spi->irq == -EPROBE_DEFER)
423 		if (spi->irq < 0)
424 			spi->irq = 0;
432 		ret = sdrv->probe(spi);
461 	.name		= "spi",
485 	 * For Really Good Reasons we use spi: modaliases not of:
567 	struct spi_device	*spi;
572 	spi = kzalloc(sizeof(*spi), GFP_KERNEL);
573 	if (!spi) {
578 	spi->pcpu_statistics = spi_alloc_pcpu_stats(NULL);
579 	if (!spi->pcpu_statistics) {
580 		kfree(spi);
585 	spi->controller = ctlr;
586 	spi->dev.parent = &ctlr->dev;
587 	spi->dev.bus = &spi_bus_type;
588 	spi->dev.release = spidev_release;
589 	spi->mode = ctlr->buswidth_override_bits;
591 	device_initialize(&spi->dev);
592 	return spi;
596 static void spi_dev_set_name(struct spi_device *spi)
598 	struct device *dev = &spi->dev;
602 		dev_set_name(dev, "spi-%s", acpi_dev_name(to_acpi_device_node(fwnode)));
607 		dev_set_name(dev, "spi-%pfwP", fwnode);
611 	dev_set_name(&spi->dev, "%s.%u", dev_name(&spi->controller->dev),
612 		     spi_get_chipselect(spi, 0));
617  * logical CS in the spi->chip_select[]. If all the physical CS
632 				   struct spi_device *spi, u8 idx,
638 	cs = spi_get_chipselect(spi, idx);
651 	struct spi_device *spi = to_spi_device(dev);
655 	if (spi->controller == new_spi->controller) {
657 			status = spi_dev_check_cs(dev, spi, idx, new_spi, 0);
665 static void spi_cleanup(struct spi_device *spi)
667 	if (spi->controller->cleanup)
668 		spi->controller->cleanup(spi);
671 static int __spi_add_device(struct spi_device *spi)
673 	struct spi_controller *ctlr = spi->controller;
680 		cs = spi_get_chipselect(spi, idx);
682 			dev_err(dev, "cs%d >= max %d\n", spi_get_chipselect(spi, idx),
690 	 * For example, spi->chip_select[0] != spi->chip_select[1] and so on.
693 		status = spi_dev_check_cs(dev, spi, idx, spi, idx + 1);
699 	spi_dev_set_name(spi);
706 	status = bus_for_each_dev(&spi_bus_type, NULL, spi, spi_dev_check);
720 			cs = spi_get_chipselect(spi, idx);
722 				spi_set_csgpiod(spi, idx, ctlr->cs_gpiods[cs]);
731 	status = spi_setup(spi);
734 				dev_name(&spi->dev), status);
739 	status = device_add(&spi->dev);
742 				dev_name(&spi->dev), status);
743 		spi_cleanup(spi);
745 		dev_dbg(dev, "registered child %s\n", dev_name(&spi->dev));
753  * @spi: spi_device to register
760 int spi_add_device(struct spi_device *spi)
762 	struct spi_controller *ctlr = spi->controller;
766 	spi_dev_set_name(spi);
769 	status = __spi_add_device(spi);
775 static void spi_set_all_cs_unused(struct spi_device *spi)
780 		spi_set_chipselect(spi, idx, SPI_INVALID_CS);
829 	 * By default spi->chip_select[0] will hold the physical CS number,
830 	 * so set bit 0 in spi->cs_index_mask.
858  * @spi: spi_device to unregister
863 void spi_unregister_device(struct spi_device *spi)
865 	if (!spi)
868 	if (spi->dev.of_node) {
869 		of_node_clear_flag(spi->dev.of_node, OF_POPULATED);
870 		of_node_put(spi->dev.of_node);
872 	if (ACPI_COMPANION(&spi->dev))
873 		acpi_device_clear_enumerated(ACPI_COMPANION(&spi->dev));
874 	device_remove_software_node(&spi->dev);
875 	device_del(&spi->dev);
876 	spi_cleanup(spi);
877 	put_device(&spi->dev);
949  * spi_res_alloc - allocate a spi resource that is life-cycle managed
952  * @spi:     the SPI device for which we allocate memory
962 static void *spi_res_alloc(struct spi_device *spi, spi_res_release_t release,
1025 #define spi_for_each_valid_cs(spi, idx)				\
1027 		if (!(spi->cs_index_mask & BIT(idx))) {} else
1029 static inline bool spi_is_last_cs(struct spi_device *spi)
1034 	spi_for_each_valid_cs(spi, idx) {
1035 		if (spi->controller->last_cs[idx] == spi_get_chipselect(spi, idx))
1041 static void spi_toggle_csgpiod(struct spi_device *spi, u8 idx, bool enable, bool activate)
1053 	if (has_acpi_companion(&spi->dev))
1054 		gpiod_set_value_cansleep(spi_get_csgpiod(spi, idx), !enable);
1057 		gpiod_set_value_cansleep(spi_get_csgpiod(spi, idx), activate);
1060 		spi_delay_exec(&spi->cs_setup, NULL);
1062 		spi_delay_exec(&spi->cs_inactive, NULL);
1065 static void spi_set_cs(struct spi_device *spi, bool enable, bool force)
1074 	if (!force && ((enable && spi->controller->last_cs_index_mask == spi->cs_index_mask &&
1075 			spi_is_last_cs(spi)) ||
1076 		       (!enable && spi->controller->last_cs_index_mask == spi->cs_index_mask &&
1077 			!spi_is_last_cs(spi))) &&
1078 	    (spi->controller->last_cs_mode_high == (spi->mode & SPI_CS_HIGH)))
1081 	trace_spi_set_cs(spi, activate);
1083 	spi->controller->last_cs_index_mask = spi->cs_index_mask;
1085 		spi->controller->last_cs[idx] = enable ? spi_get_chipselect(spi, 0) : SPI_INVALID_CS;
1086 	spi->controller->last_cs_mode_high = spi->mode & SPI_CS_HIGH;
1088 	if (spi->mode & SPI_CS_HIGH)
1095 	if ((spi_is_csgpiod(spi) || !spi->controller->set_cs_timing) && !activate)
1096 		spi_delay_exec(&spi->cs_hold, NULL);
1098 	if (spi_is_csgpiod(spi)) {
1099 		if (!(spi->mode & SPI_NO_CS)) {
1100 			spi_for_each_valid_cs(spi, idx) {
1101 				if (spi_get_csgpiod(spi, idx))
1102 					spi_toggle_csgpiod(spi, idx, enable, activate);
1106 		if ((spi->controller->flags & SPI_CONTROLLER_GPIO_SS) &&
1107 		    spi->controller->set_cs)
1108 			spi->controller->set_cs(spi, !enable);
1109 	} else if (spi->controller->set_cs) {
1110 		spi->controller->set_cs(spi, !enable);
1113 	if (spi_is_csgpiod(spi) || !spi->controller->set_cs_timing) {
1115 			spi_delay_exec(&spi->cs_setup, NULL);
1117 			spi_delay_exec(&spi->cs_inactive, NULL);
1250 		if (!ctlr->can_dma(ctlr, msg->spi, xfer))
1296 		if (!ctlr->can_dma(ctlr, msg->spi, xfer))
1385 		&& !(msg->spi->mode & SPI_3WIRE)) {
1435 	struct spi_statistics __percpu *stats = msg->spi->pcpu_statistics;
1441 			dev_dbg(&msg->spi->dev, "SPI transfer interrupted\n");
1471 			dev_err(&msg->spi->dev,
1574 		dev_err_once(&msg->spi->dev,
1602 	struct spi_statistics __percpu *stats = msg->spi->pcpu_statistics;
1605 	spi_set_cs(msg->spi, !xfer->cs_off, false);
1626 			ret = ctlr->transfer_one(ctlr, msg->spi, xfer);
1642 				dev_err(&msg->spi->dev,
1656 				dev_err(&msg->spi->dev,
1679 					spi_set_cs(msg->spi, false, false);
1682 					spi_set_cs(msg->spi, true, false);
1686 			spi_set_cs(msg->spi, xfer->cs_off, false);
1694 		spi_set_cs(msg->spi, false, false);
1929  * spi_pump_messages - kthread work function which processes spi message queue
2111 	struct spi_controller *ctlr = msg->spi->controller;
2260 static int __spi_queued_transfer(struct spi_device *spi,
2264 	struct spi_controller *ctlr = spi->controller;
2287  * @spi: SPI device which is requesting transfer
2292 static int spi_queued_transfer(struct spi_device *spi, struct spi_message *msg)
2294 	return __spi_queued_transfer(spi, msg, true);
2332  * sent before doing something. Is used by the spi-mem code to make sure SPI
2334  * before the spi-mem operation.
2361 static int of_spi_parse_dt(struct spi_controller *ctlr, struct spi_device *spi,
2368 	if (of_property_read_bool(nc, "spi-cpha"))
2369 		spi->mode |= SPI_CPHA;
2370 	if (of_property_read_bool(nc, "spi-cpol"))
2371 		spi->mode |= SPI_CPOL;
2372 	if (of_property_read_bool(nc, "spi-3wire"))
2373 		spi->mode |= SPI_3WIRE;
2374 	if (of_property_read_bool(nc, "spi-lsb-first"))
2375 		spi->mode |= SPI_LSB_FIRST;
2376 	if (of_property_read_bool(nc, "spi-cs-high"))
2377 		spi->mode |= SPI_CS_HIGH;
2380 	if (!of_property_read_u32(nc, "spi-tx-bus-width", &value)) {
2383 			spi->mode |= SPI_NO_TX;
2388 			spi->mode |= SPI_TX_DUAL;
2391 			spi->mode |= SPI_TX_QUAD;
2394 			spi->mode |= SPI_TX_OCTAL;
2398 				"spi-tx-bus-width %d not supported\n",
2404 	if (!of_property_read_u32(nc, "spi-rx-bus-width", &value)) {
2407 			spi->mode |= SPI_NO_RX;
2412 			spi->mode |= SPI_RX_DUAL;
2415 			spi->mode |= SPI_RX_QUAD;
2418 			spi->mode |= SPI_RX_OCTAL;
2422 				"spi-rx-bus-width %d not supported\n",
2442 	spi_set_all_cs_unused(spi);
2463 		spi_set_chipselect(spi, idx, cs[idx]);
2466 	 * By default spi->chip_select[0] will hold the physical CS number,
2467 	 * so set bit 0 in spi->cs_index_mask.
2469 	spi->cs_index_mask = BIT(0);
2472 	if (!of_property_read_u32(nc, "spi-max-frequency", &value))
2473 		spi->max_speed_hz = value;
2476 	of_spi_parse_dt_cs_delay(nc, &spi->cs_setup, "spi-cs-setup-delay-ns");
2477 	of_spi_parse_dt_cs_delay(nc, &spi->cs_hold, "spi-cs-hold-delay-ns");
2478 	of_spi_parse_dt_cs_delay(nc, &spi->cs_inactive, "spi-cs-inactive-delay-ns");
2486 	struct spi_device *spi;
2490 	spi = spi_alloc_device(ctlr);
2491 	if (!spi) {
2498 	rc = of_alias_from_compatible(nc, spi->modalias,
2499 				      sizeof(spi->modalias));
2505 	rc = of_spi_parse_dt(ctlr, spi, nc);
2512 	device_set_node(&spi->dev, of_fwnode_handle(nc));
2515 	rc = spi_add_device(spi);
2521 	return spi;
2526 	spi_dev_put(spi);
2539 	struct spi_device *spi;
2545 		spi = of_register_spi_device(ctlr, nc);
2546 		if (IS_ERR(spi)) {
2559  * @spi:         Pointer to the main SPI device registering the ancillary device
2569 struct spi_device *spi_new_ancillary_device(struct spi_device *spi,
2572 	struct spi_controller *ctlr = spi->controller;
2590 	ancillary->max_speed_hz = spi->max_speed_hz;
2591 	ancillary->mode = spi->mode;
2593 	 * By default spi->chip_select[0] will hold the physical CS number,
2594 	 * so set bit 0 in spi->cs_index_mask.
2603 		dev_err(&spi->dev, "failed to register ancillary device\n");
2775  * acpi_spi_device_alloc - Allocate a spi device, and fill it in with ACPI information
2776  * @ctlr: controller to which the spi device belongs
2777  * @adev: ACPI Device for the spi device
2778  * @index: Index of the spi resource inside the ACPI Node
2797 	struct spi_device *spi;
2827 	spi = spi_alloc_device(lookup.ctlr);
2828 	if (!spi) {
2834 	spi_set_all_cs_unused(spi);
2835 	spi_set_chipselect(spi, 0, lookup.chip_select);
2837 	ACPI_COMPANION_SET(&spi->dev, adev);
2838 	spi->max_speed_hz	= lookup.max_speed_hz;
2839 	spi->mode		|= lookup.mode;
2840 	spi->irq		= lookup.irq;
2841 	spi->bits_per_word	= lookup.bits_per_word;
2843 	 * By default spi->chip_select[0] will hold the physical CS number,
2844 	 * so set bit 0 in spi->cs_index_mask.
2846 	spi->cs_index_mask	= BIT(0);
2848 	return spi;
2855 	struct spi_device *spi;
2861 	spi = acpi_spi_device_alloc(ctlr, adev, -1);
2862 	if (IS_ERR(spi)) {
2863 		if (PTR_ERR(spi) == -ENOMEM)
2869 	acpi_set_modalias(adev, acpi_device_hid(adev), spi->modalias,
2870 			  sizeof(spi->modalias));
2872 	if (spi->irq < 0)
2873 		spi->irq = acpi_dev_gpio_irq_get(adev, 0);
2878 	if (spi_add_device(spi)) {
2882 		spi_dev_put(spi);
2939  * @spi: device used for the current transfer
2941 int spi_slave_abort(struct spi_device *spi)
2943 	struct spi_controller *ctlr = spi->controller;
2952 int spi_target_abort(struct spi_device *spi)
2954 	struct spi_controller *ctlr = spi->controller;
2979 	struct spi_device *spi;
2997 		spi = spi_alloc_device(ctlr);
2998 		if (!spi)
3001 		strscpy(spi->modalias, name, sizeof(spi->modalias));
3003 		rc = spi_add_device(spi);
3005 			spi_dev_put(spi);
3294 		ctlr->bus_num = of_alias_get_id(ctlr->dev.of_node, "spi");
3302 		first_dynamic = of_alias_get_highest_id("spi");
3322 	dev_set_name(&ctlr->dev, "spi%u", ctlr->bus_num);
3601 	rxfer = spi_res_alloc(msg->spi, __spi_replace_transfers_release,
3633 			dev_err(&msg->spi->dev,
3738 	SPI_STATISTICS_INCREMENT_FIELD(msg->spi->pcpu_statistics,
3745  * spi_split_transfers_maxsize - split spi transfers into multiple transfers
3753  * spi message unoptimize phase so this function should only be called from
3795  * spi message unoptimize phase so this function should only be called from
3853  * @spi: the device that requires specific CS timing configuration
3857 static int spi_set_cs_timing(struct spi_device *spi)
3859 	struct device *parent = spi->controller->dev.parent;
3862 	if (spi->controller->set_cs_timing && !spi_get_csgpiod(spi, 0)) {
3863 		if (spi->controller->auto_runtime_pm) {
3867 				dev_err(&spi->controller->dev, "Failed to power device: %d\n",
3872 			status = spi->controller->set_cs_timing(spi);
3876 			status = spi->controller->set_cs_timing(spi);
3884  * @spi: the device whose settings are being modified
3902 int spi_setup(struct spi_device *spi)
3911 	if ((hweight_long(spi->mode &
3913 	    (hweight_long(spi->mode &
3915 		dev_err(&spi->dev,
3920 	if ((spi->mode & SPI_3WIRE) && (spi->mode &
3930 	bad_bits = spi->mode & ~(spi->controller->mode_bits | SPI_CS_WORD |
3936 		dev_warn(&spi->dev,
3939 		spi->mode &= ~ugly_bits;
3943 		dev_err(&spi->dev, "setup: unsupported mode bits %x\n",
3948 	if (!spi->bits_per_word) {
3949 		spi->bits_per_word = 8;
3955 		status = __spi_validate_bits_per_word(spi->controller,
3956 						      spi->bits_per_word);
3961 	if (spi->controller->max_speed_hz &&
3962 	    (!spi->max_speed_hz ||
3963 	     spi->max_speed_hz > spi->controller->max_speed_hz))
3964 		spi->max_speed_hz = spi->controller->max_speed_hz;
3966 	mutex_lock(&spi->controller->io_mutex);
3968 	if (spi->controller->setup) {
3969 		status = spi->controller->setup(spi);
3971 			mutex_unlock(&spi->controller->io_mutex);
3972 			dev_err(&spi->controller->dev, "Failed to setup device: %d\n",
3978 	status = spi_set_cs_timing(spi);
3980 		mutex_unlock(&spi->controller->io_mutex);
3984 	if (spi->controller->auto_runtime_pm && spi->controller->set_cs) {
3985 		status = pm_runtime_resume_and_get(spi->controller->dev.parent);
3987 			mutex_unlock(&spi->controller->io_mutex);
3988 			dev_err(&spi->controller->dev, "Failed to power device: %d\n",
4001 		spi_set_cs(spi, false, true);
4002 		pm_runtime_mark_last_busy(spi->controller->dev.parent);
4003 		pm_runtime_put_autosuspend(spi->controller->dev.parent);
4005 		spi_set_cs(spi, false, true);
4008 	mutex_unlock(&spi->controller->io_mutex);
4010 	if (spi->rt && !spi->controller->rt) {
4011 		spi->controller->rt = true;
4012 		spi_set_thread_rt(spi->controller);
4015 	trace_spi_setup(spi, status);
4017 	dev_dbg(&spi->dev, "setup mode %lu, %s%s%s%s%u bits/w, %u Hz max --> %d\n",
4018 			spi->mode & SPI_MODE_X_MASK,
4019 			(spi->mode & SPI_CS_HIGH) ? "cs_high, " : "",
4020 			(spi->mode & SPI_LSB_FIRST) ? "lsb, " : "",
4021 			(spi->mode & SPI_3WIRE) ? "3wire, " : "",
4022 			(spi->mode & SPI_LOOP) ? "loopback, " : "",
4023 			spi->bits_per_word, spi->max_speed_hz,
4031 				       struct spi_device *spi)
4039 	delay2 = spi_delay_to_ns(&spi->word_delay, xfer);
4044 		memcpy(&xfer->word_delay, &spi->word_delay,
4050 static int __spi_validate(struct spi_device *spi, struct spi_message *message)
4052 	struct spi_controller *ctlr = spi->controller;
4059 	message->spi = spi;
4068 	    (spi->mode & SPI_3WIRE)) {
4082 	 * Set transfer bits_per_word and max speed as spi device default if
4094 			xfer->bits_per_word = spi->bits_per_word;
4097 			xfer->speed_hz = spi->max_speed_hz;
4134 			if (spi->mode & SPI_NO_TX)
4141 				!(spi->mode & (SPI_TX_DUAL | SPI_TX_QUAD)))
4144 				!(spi->mode & SPI_TX_QUAD))
4149 			if (spi->mode & SPI_NO_RX)
4156 				!(spi->mode & (SPI_RX_DUAL | SPI_RX_QUAD)))
4159 				!(spi->mode & SPI_RX_QUAD))
4163 		if (_spi_xfer_word_delay_update(xfer, spi))
4189 	struct spi_controller *ctlr = msg->spi->controller;
4200 	if ((msg->spi->mode & SPI_CS_WORD) &&
4201 	    (!(ctlr->mode_bits & SPI_CS_WORD) || spi_is_csgpiod(msg->spi))) {
4215 						  spi_max_transfer_size(msg->spi));
4226  * @spi: the device that will be used for the message
4229  * Peripheral drivers will call spi_optimize_message() and the spi core will
4236 static int __spi_optimize_message(struct spi_device *spi,
4239 	struct spi_controller *ctlr = spi->controller;
4242 	ret = __spi_validate(spi, msg);
4265  * @spi: the device that will be used for the message
4269 static int spi_maybe_optimize_message(struct spi_device *spi,
4275 	return __spi_optimize_message(spi, msg);
4280  * @spi: the device that will be used for the message
4298 int spi_optimize_message(struct spi_device *spi, struct spi_message *msg)
4302 	ret = __spi_optimize_message(spi, msg);
4333 static int __spi_async(struct spi_device *spi, struct spi_message *message)
4335 	struct spi_controller *ctlr = spi->controller;
4346 	SPI_STATISTICS_INCREMENT_FIELD(spi->pcpu_statistics, spi_async);
4357 	return ctlr->transfer(spi, message);
4362  * @spi: device with which data will be exchanged
4391 int spi_async(struct spi_device *spi, struct spi_message *message)
4393 	struct spi_controller *ctlr = spi->controller;
4397 	ret = spi_maybe_optimize_message(spi, message);
4406 		ret = __spi_async(spi, message);
4460 static int __spi_sync(struct spi_device *spi, struct spi_message *message)
4465 	struct spi_controller *ctlr = spi->controller;
4468 		dev_warn_once(&spi->dev, "Attempted to sync while suspend\n");
4472 	status = spi_maybe_optimize_message(spi, message);
4477 	SPI_STATISTICS_INCREMENT_FIELD(spi->pcpu_statistics, spi_sync);
4492 		SPI_STATISTICS_INCREMENT_FIELD(spi->pcpu_statistics, spi_sync_immediate);
4509 	status = __spi_async(spi, message);
4524  * @spi: device with which data will be exchanged
4543 int spi_sync(struct spi_device *spi, struct spi_message *message)
4547 	mutex_lock(&spi->controller->bus_lock_mutex);
4548 	ret = __spi_sync(spi, message);
4549 	mutex_unlock(&spi->controller->bus_lock_mutex);
4557  * @spi: device with which data will be exchanged
4571 int spi_sync_locked(struct spi_device *spi, struct spi_message *message)
4573 	return __spi_sync(spi, message);
4638  * @spi: device with which data will be exchanged
4656 int spi_write_then_read(struct spi_device *spi,
4698 	status = spi_sync(spi, &message);
4722 /* The spi controllers are not using spi_bus, so we find it with another way */
4742 	struct spi_device *spi;
4760 		spi = of_register_spi_device(ctlr, rd->dn);
4763 		if (IS_ERR(spi)) {
4767 			return notifier_from_errno(PTR_ERR(spi));
4777 		spi = of_find_spi_device_by_node(rd->dn);
4778 		if (spi == NULL)
4782 		spi_unregister_device(spi);
4785 		put_device(&spi->dev);
4834 	struct spi_device *spi;
4849 		spi = acpi_spi_find_device_by_adev(adev);
4850 		if (!spi)
4853 		spi_unregister_device(spi);
4854 		put_device(&spi->dev);