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 */
spi_mux_select(struct spi_device * spi)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
spi_mux_setup(struct spi_device * spi)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
spi_mux_complete_cb(void * context)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
spi_mux_transfer_one_message(struct spi_controller * ctlr,struct spi_message * m)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
spi_mux_probe(struct spi_device * spi)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->bits_per_word_mask = spi->controller->bits_per_word_mask;
162 ctlr->transfer_one_message = spi_mux_transfer_one_message;
163 ctlr->setup = spi_mux_setup;
164 ctlr->num_chipselect = mux_control_states(priv->mux);
165 ctlr->bus_num = -1;
166 ctlr->dev.of_node = spi->dev.of_node;
167 ctlr->must_async = true;
168 ctlr->defer_optimize_message = true;
169
170 ret = devm_spi_register_controller(&spi->dev, ctlr);
171 if (ret)
172 goto err_put_ctlr;
173
174 return 0;
175
176 err_put_ctlr:
177 spi_controller_put(ctlr);
178
179 return ret;
180 }
181
182 static const struct spi_device_id spi_mux_id[] = {
183 { "spi-mux" },
184 { }
185 };
186 MODULE_DEVICE_TABLE(spi, spi_mux_id);
187
188 static const struct of_device_id spi_mux_of_match[] = {
189 { .compatible = "spi-mux" },
190 { }
191 };
192 MODULE_DEVICE_TABLE(of, spi_mux_of_match);
193
194 static struct spi_driver spi_mux_driver = {
195 .probe = spi_mux_probe,
196 .driver = {
197 .name = "spi-mux",
198 .of_match_table = spi_mux_of_match,
199 },
200 .id_table = spi_mux_id,
201 };
202
203 module_spi_driver(spi_mux_driver);
204
205 MODULE_DESCRIPTION("SPI multiplexer");
206 MODULE_LICENSE("GPL");
207