GNU Linux-libre 5.10.219-gnu1
[releases.git] / drivers / spi / spi-mux.c
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 spi_device_id spi_mux_id[] = {
171         { "spi-mux" },
172         { }
173 };
174 MODULE_DEVICE_TABLE(spi, spi_mux_id);
175
176 static const struct of_device_id spi_mux_of_match[] = {
177         { .compatible = "spi-mux" },
178         { }
179 };
180 MODULE_DEVICE_TABLE(of, spi_mux_of_match);
181
182 static struct spi_driver spi_mux_driver = {
183         .probe  = spi_mux_probe,
184         .driver = {
185                 .name   = "spi-mux",
186                 .of_match_table = spi_mux_of_match,
187         },
188         .id_table = spi_mux_id,
189 };
190
191 module_spi_driver(spi_mux_driver);
192
193 MODULE_DESCRIPTION("SPI multiplexer");
194 MODULE_LICENSE("GPL");