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_get_chipselect(spi, 0)); 55 if (ret) 56 return ret; 57 58 if (priv->current_cs == spi_get_chipselect(spi, 0)) 59 return 0; 60 61 dev_dbg(&priv->spi->dev, "setting up the mux for cs %d\n", 62 spi_get_chipselect(spi, 0)); 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_get_chipselect(spi, 0); 70 71 spi_setup(priv->spi); 72 73 return 0; 74 } 75 76 static int spi_mux_setup(struct spi_device *spi) 77 { 78 struct spi_mux_priv *priv = spi_controller_get_devdata(spi->controller); 79 80 /* 81 * can be called multiple times, won't do a valid setup now but we will 82 * change the settings when we do a transfer (necessary because we 83 * can't predict from which device it will be anyway) 84 */ 85 return spi_setup(priv->spi); 86 } 87 88 static void spi_mux_complete_cb(void *context) 89 { 90 struct spi_mux_priv *priv = (struct spi_mux_priv *)context; 91 struct spi_controller *ctlr = spi_get_drvdata(priv->spi); 92 struct spi_message *m = ctlr->cur_msg; 93 94 m->complete = priv->child_msg_complete; 95 m->context = priv->child_msg_context; 96 m->spi = priv->child_msg_dev; 97 spi_finalize_current_message(ctlr); 98 mux_control_deselect(priv->mux); 99 } 100 101 static int spi_mux_transfer_one_message(struct spi_controller *ctlr, 102 struct spi_message *m) 103 { 104 struct spi_mux_priv *priv = spi_controller_get_devdata(ctlr); 105 struct spi_device *spi = m->spi; 106 int ret; 107 108 ret = spi_mux_select(spi); 109 if (ret) 110 return ret; 111 112 /* 113 * Replace the complete callback, context and spi_device with our own 114 * pointers. Save originals 115 */ 116 priv->child_msg_complete = m->complete; 117 priv->child_msg_context = m->context; 118 priv->child_msg_dev = m->spi; 119 120 m->complete = spi_mux_complete_cb; 121 m->context = priv; 122 m->spi = priv->spi; 123 124 /* do the transfer */ 125 return spi_async(priv->spi, m); 126 } 127 128 static int spi_mux_probe(struct spi_device *spi) 129 { 130 struct spi_controller *ctlr; 131 struct spi_mux_priv *priv; 132 int ret; 133 134 ctlr = spi_alloc_host(&spi->dev, sizeof(*priv)); 135 if (!ctlr) 136 return -ENOMEM; 137 138 spi_set_drvdata(spi, ctlr); 139 priv = spi_controller_get_devdata(ctlr); 140 priv->spi = spi; 141 142 /* 143 * Increase lockdep class as these lock are taken while the parent bus 144 * already holds their instance's lock. 145 */ 146 lockdep_set_subclass(&ctlr->io_mutex, 1); 147 lockdep_set_subclass(&ctlr->add_lock, 1); 148 149 priv->mux = devm_mux_control_get(&spi->dev, NULL); 150 if (IS_ERR(priv->mux)) { 151 ret = dev_err_probe(&spi->dev, PTR_ERR(priv->mux), 152 "failed to get control-mux\n"); 153 goto err_put_ctlr; 154 } 155 156 priv->current_cs = SPI_MUX_NO_CS; 157 158 /* supported modes are the same as our parent's */ 159 ctlr->mode_bits = spi->controller->mode_bits; 160 ctlr->flags = spi->controller->flags; 161 ctlr->transfer_one_message = spi_mux_transfer_one_message; 162 ctlr->setup = spi_mux_setup; 163 ctlr->num_chipselect = mux_control_states(priv->mux); 164 ctlr->bus_num = -1; 165 ctlr->dev.of_node = spi->dev.of_node; 166 ctlr->must_async = true; 167 168 ret = devm_spi_register_controller(&spi->dev, ctlr); 169 if (ret) 170 goto err_put_ctlr; 171 172 return 0; 173 174 err_put_ctlr: 175 spi_controller_put(ctlr); 176 177 return ret; 178 } 179 180 static const struct spi_device_id spi_mux_id[] = { 181 { "spi-mux" }, 182 { } 183 }; 184 MODULE_DEVICE_TABLE(spi, spi_mux_id); 185 186 static const struct of_device_id spi_mux_of_match[] = { 187 { .compatible = "spi-mux" }, 188 { } 189 }; 190 MODULE_DEVICE_TABLE(of, spi_mux_of_match); 191 192 static struct spi_driver spi_mux_driver = { 193 .probe = spi_mux_probe, 194 .driver = { 195 .name = "spi-mux", 196 .of_match_table = spi_mux_of_match, 197 }, 198 .id_table = spi_mux_id, 199 }; 200 201 module_spi_driver(spi_mux_driver); 202 203 MODULE_DESCRIPTION("SPI multiplexer"); 204 MODULE_LICENSE("GPL"); 205