1 // SPDX-License-Identifier: GPL-2.0 2 // 3 // General Purpose SPI multiplexer 4 5 #include <linux/err.h> 6 #include <linux/kernel.h> 7 #include <linux/module.h> 8 #include <linux/mux/consumer.h> 9 #include <linux/slab.h> 10 #include <linux/spi/spi.h> 11 12 #define SPI_MUX_NO_CS ((unsigned int)-1) 13 14 /** 15 * DOC: Driver description 16 * 17 * This driver supports a MUX on an SPI bus. This can be useful when you need 18 * more chip selects than the hardware peripherals support, or than are 19 * available in a particular board setup. 20 * 21 * The driver will create an additional SPI controller. Devices added under the 22 * mux will be handled as 'chip selects' on this controller. 23 */ 24 25 /** 26 * struct spi_mux_priv - the basic spi_mux structure 27 * @spi: pointer to the device struct attached to the parent 28 * spi controller 29 * @current_cs: The current chip select set in the mux 30 * @child_msg_complete: The mux replaces the complete callback in the child's 31 * message to its own callback; this field is used by the 32 * driver to store the child's callback during a transfer 33 * @child_msg_context: Used to store the child's context to the callback 34 * @child_msg_dev: Used to store the spi_device pointer to the child 35 * @mux: mux_control structure used to provide chip selects for 36 * downstream spi devices 37 */ 38 struct spi_mux_priv { 39 struct spi_device *spi; 40 unsigned int current_cs; 41 42 void (*child_msg_complete)(void *context); 43 void *child_msg_context; 44 struct spi_device *child_msg_dev; 45 struct mux_control *mux; 46 }; 47 48 /* should not get called when the parent controller is doing a transfer */ 49 static int spi_mux_select(struct spi_device *spi) 50 { 51 struct spi_mux_priv *priv = spi_controller_get_devdata(spi->controller); 52 int ret; 53 54 ret = mux_control_select(priv->mux, spi->chip_select); 55 if (ret) 56 return ret; 57 58 if (priv->current_cs == spi->chip_select) 59 return 0; 60 61 dev_dbg(&priv->spi->dev, "setting up the mux for cs %d\n", 62 spi->chip_select); 63 64 /* copy the child device's settings except for the cs */ 65 priv->spi->max_speed_hz = spi->max_speed_hz; 66 priv->spi->mode = spi->mode; 67 priv->spi->bits_per_word = spi->bits_per_word; 68 69 priv->current_cs = spi->chip_select; 70 71 return 0; 72 } 73 74 static int spi_mux_setup(struct spi_device *spi) 75 { 76 struct spi_mux_priv *priv = spi_controller_get_devdata(spi->controller); 77 78 /* 79 * can be called multiple times, won't do a valid setup now but we will 80 * change the settings when we do a transfer (necessary because we 81 * can't predict from which device it will be anyway) 82 */ 83 return spi_setup(priv->spi); 84 } 85 86 static void spi_mux_complete_cb(void *context) 87 { 88 struct spi_mux_priv *priv = (struct spi_mux_priv *)context; 89 struct spi_controller *ctlr = spi_get_drvdata(priv->spi); 90 struct spi_message *m = ctlr->cur_msg; 91 92 m->complete = priv->child_msg_complete; 93 m->context = priv->child_msg_context; 94 m->spi = priv->child_msg_dev; 95 spi_finalize_current_message(ctlr); 96 mux_control_deselect(priv->mux); 97 } 98 99 static int spi_mux_transfer_one_message(struct spi_controller *ctlr, 100 struct spi_message *m) 101 { 102 struct spi_mux_priv *priv = spi_controller_get_devdata(ctlr); 103 struct spi_device *spi = m->spi; 104 int ret; 105 106 ret = spi_mux_select(spi); 107 if (ret) 108 return ret; 109 110 /* 111 * Replace the complete callback, context and spi_device with our own 112 * pointers. Save originals 113 */ 114 priv->child_msg_complete = m->complete; 115 priv->child_msg_context = m->context; 116 priv->child_msg_dev = m->spi; 117 118 m->complete = spi_mux_complete_cb; 119 m->context = priv; 120 m->spi = priv->spi; 121 122 /* do the transfer */ 123 return spi_async(priv->spi, m); 124 } 125 126 static int spi_mux_probe(struct spi_device *spi) 127 { 128 struct spi_controller *ctlr; 129 struct spi_mux_priv *priv; 130 int ret; 131 132 ctlr = spi_alloc_master(&spi->dev, sizeof(*priv)); 133 if (!ctlr) 134 return -ENOMEM; 135 136 spi_set_drvdata(spi, ctlr); 137 priv = spi_controller_get_devdata(ctlr); 138 priv->spi = spi; 139 140 priv->mux = devm_mux_control_get(&spi->dev, NULL); 141 if (IS_ERR(priv->mux)) { 142 ret = dev_err_probe(&spi->dev, PTR_ERR(priv->mux), 143 "failed to get control-mux\n"); 144 goto err_put_ctlr; 145 } 146 147 priv->current_cs = SPI_MUX_NO_CS; 148 149 /* supported modes are the same as our parent's */ 150 ctlr->mode_bits = spi->controller->mode_bits; 151 ctlr->flags = spi->controller->flags; 152 ctlr->transfer_one_message = spi_mux_transfer_one_message; 153 ctlr->setup = spi_mux_setup; 154 ctlr->num_chipselect = mux_control_states(priv->mux); 155 ctlr->bus_num = -1; 156 ctlr->dev.of_node = spi->dev.of_node; 157 158 ret = devm_spi_register_controller(&spi->dev, ctlr); 159 if (ret) 160 goto err_put_ctlr; 161 162 return 0; 163 164 err_put_ctlr: 165 spi_controller_put(ctlr); 166 167 return ret; 168 } 169 170 static const struct of_device_id spi_mux_of_match[] = { 171 { .compatible = "spi-mux" }, 172 { } 173 }; 174 175 static struct spi_driver spi_mux_driver = { 176 .probe = spi_mux_probe, 177 .driver = { 178 .name = "spi-mux", 179 .of_match_table = spi_mux_of_match, 180 }, 181 }; 182 183 module_spi_driver(spi_mux_driver); 184 185 MODULE_DESCRIPTION("SPI multiplexer"); 186 MODULE_LICENSE("GPL"); 187