1
2
3
4
5
6
7
8#include <linux/kernel.h>
9#include <linux/module.h>
10#include <linux/platform_device.h>
11#include <linux/gpio/consumer.h>
12#include <linux/of.h>
13#include <linux/of_device.h>
14
15#include <linux/spi/spi.h>
16#include <linux/spi/spi_bitbang.h>
17#include <linux/spi/spi_gpio.h>
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33struct spi_gpio {
34 struct spi_bitbang bitbang;
35 struct gpio_desc *sck;
36 struct gpio_desc *miso;
37 struct gpio_desc *mosi;
38 struct gpio_desc **cs_gpios;
39};
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66#ifndef DRIVER_NAME
67#define DRIVER_NAME "spi_gpio"
68
69#define GENERIC_BITBANG
70
71#endif
72
73
74
75static inline struct spi_gpio *__pure
76spi_to_spi_gpio(const struct spi_device *spi)
77{
78 const struct spi_bitbang *bang;
79 struct spi_gpio *spi_gpio;
80
81 bang = spi_master_get_devdata(spi->master);
82 spi_gpio = container_of(bang, struct spi_gpio, bitbang);
83 return spi_gpio;
84}
85
86
87static inline void setsck(const struct spi_device *spi, int is_on)
88{
89 struct spi_gpio *spi_gpio = spi_to_spi_gpio(spi);
90
91 gpiod_set_value_cansleep(spi_gpio->sck, is_on);
92}
93
94static inline void setmosi(const struct spi_device *spi, int is_on)
95{
96 struct spi_gpio *spi_gpio = spi_to_spi_gpio(spi);
97
98 gpiod_set_value_cansleep(spi_gpio->mosi, is_on);
99}
100
101static inline int getmiso(const struct spi_device *spi)
102{
103 struct spi_gpio *spi_gpio = spi_to_spi_gpio(spi);
104
105 if (spi->mode & SPI_3WIRE)
106 return !!gpiod_get_value_cansleep(spi_gpio->mosi);
107 else
108 return !!gpiod_get_value_cansleep(spi_gpio->miso);
109}
110
111
112
113
114
115
116
117#define spidelay(nsecs) do {} while (0)
118
119#include "spi-bitbang-txrx.h"
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135static u32 spi_gpio_txrx_word_mode0(struct spi_device *spi,
136 unsigned nsecs, u32 word, u8 bits, unsigned flags)
137{
138 return bitbang_txrx_be_cpha0(spi, nsecs, 0, flags, word, bits);
139}
140
141static u32 spi_gpio_txrx_word_mode1(struct spi_device *spi,
142 unsigned nsecs, u32 word, u8 bits, unsigned flags)
143{
144 return bitbang_txrx_be_cpha1(spi, nsecs, 0, flags, word, bits);
145}
146
147static u32 spi_gpio_txrx_word_mode2(struct spi_device *spi,
148 unsigned nsecs, u32 word, u8 bits, unsigned flags)
149{
150 return bitbang_txrx_be_cpha0(spi, nsecs, 1, flags, word, bits);
151}
152
153static u32 spi_gpio_txrx_word_mode3(struct spi_device *spi,
154 unsigned nsecs, u32 word, u8 bits, unsigned flags)
155{
156 return bitbang_txrx_be_cpha1(spi, nsecs, 1, flags, word, bits);
157}
158
159
160
161
162
163
164
165
166
167
168
169static u32 spi_gpio_spec_txrx_word_mode0(struct spi_device *spi,
170 unsigned nsecs, u32 word, u8 bits, unsigned flags)
171{
172 flags = spi->master->flags;
173 return bitbang_txrx_be_cpha0(spi, nsecs, 0, flags, word, bits);
174}
175
176static u32 spi_gpio_spec_txrx_word_mode1(struct spi_device *spi,
177 unsigned nsecs, u32 word, u8 bits, unsigned flags)
178{
179 flags = spi->master->flags;
180 return bitbang_txrx_be_cpha1(spi, nsecs, 0, flags, word, bits);
181}
182
183static u32 spi_gpio_spec_txrx_word_mode2(struct spi_device *spi,
184 unsigned nsecs, u32 word, u8 bits, unsigned flags)
185{
186 flags = spi->master->flags;
187 return bitbang_txrx_be_cpha0(spi, nsecs, 1, flags, word, bits);
188}
189
190static u32 spi_gpio_spec_txrx_word_mode3(struct spi_device *spi,
191 unsigned nsecs, u32 word, u8 bits, unsigned flags)
192{
193 flags = spi->master->flags;
194 return bitbang_txrx_be_cpha1(spi, nsecs, 1, flags, word, bits);
195}
196
197
198
199static void spi_gpio_chipselect(struct spi_device *spi, int is_active)
200{
201 struct spi_gpio *spi_gpio = spi_to_spi_gpio(spi);
202
203
204 if (is_active)
205 gpiod_set_value_cansleep(spi_gpio->sck, spi->mode & SPI_CPOL);
206
207
208 if (spi_gpio->cs_gpios) {
209 struct gpio_desc *cs = spi_gpio->cs_gpios[spi->chip_select];
210
211
212 gpiod_set_value_cansleep(cs, (spi->mode & SPI_CS_HIGH) ? is_active : !is_active);
213 }
214}
215
216static int spi_gpio_setup(struct spi_device *spi)
217{
218 struct gpio_desc *cs;
219 int status = 0;
220 struct spi_gpio *spi_gpio = spi_to_spi_gpio(spi);
221
222
223
224
225
226 if (spi_gpio->cs_gpios) {
227 cs = spi_gpio->cs_gpios[spi->chip_select];
228 if (!spi->controller_state && cs)
229 status = gpiod_direction_output(cs,
230 !(spi->mode & SPI_CS_HIGH));
231 }
232
233 if (!status)
234 status = spi_bitbang_setup(spi);
235
236 return status;
237}
238
239static int spi_gpio_set_direction(struct spi_device *spi, bool output)
240{
241 struct spi_gpio *spi_gpio = spi_to_spi_gpio(spi);
242 int ret;
243
244 if (output)
245 return gpiod_direction_output(spi_gpio->mosi, 1);
246
247 ret = gpiod_direction_input(spi_gpio->mosi);
248 if (ret)
249 return ret;
250
251
252
253
254
255
256
257
258 if (spi->mode & SPI_3WIRE_HIZ) {
259 gpiod_set_value_cansleep(spi_gpio->sck,
260 !(spi->mode & SPI_CPOL));
261 gpiod_set_value_cansleep(spi_gpio->sck,
262 !!(spi->mode & SPI_CPOL));
263 }
264 return 0;
265}
266
267static void spi_gpio_cleanup(struct spi_device *spi)
268{
269 spi_bitbang_cleanup(spi);
270}
271
272
273
274
275
276
277
278
279
280
281
282static int spi_gpio_request(struct device *dev, struct spi_gpio *spi_gpio)
283{
284 spi_gpio->mosi = devm_gpiod_get_optional(dev, "mosi", GPIOD_OUT_LOW);
285 if (IS_ERR(spi_gpio->mosi))
286 return PTR_ERR(spi_gpio->mosi);
287
288 spi_gpio->miso = devm_gpiod_get_optional(dev, "miso", GPIOD_IN);
289 if (IS_ERR(spi_gpio->miso))
290 return PTR_ERR(spi_gpio->miso);
291
292 spi_gpio->sck = devm_gpiod_get(dev, "sck", GPIOD_OUT_LOW);
293 return PTR_ERR_OR_ZERO(spi_gpio->sck);
294}
295
296#ifdef CONFIG_OF
297static const struct of_device_id spi_gpio_dt_ids[] = {
298 { .compatible = "spi-gpio" },
299 {}
300};
301MODULE_DEVICE_TABLE(of, spi_gpio_dt_ids);
302
303static int spi_gpio_probe_dt(struct platform_device *pdev,
304 struct spi_master *master)
305{
306 master->dev.of_node = pdev->dev.of_node;
307 master->use_gpio_descriptors = true;
308
309 return 0;
310}
311#else
312static inline int spi_gpio_probe_dt(struct platform_device *pdev,
313 struct spi_master *master)
314{
315 return 0;
316}
317#endif
318
319static int spi_gpio_probe_pdata(struct platform_device *pdev,
320 struct spi_master *master)
321{
322 struct device *dev = &pdev->dev;
323 struct spi_gpio_platform_data *pdata = dev_get_platdata(dev);
324 struct spi_gpio *spi_gpio = spi_master_get_devdata(master);
325 int i;
326
327#ifdef GENERIC_BITBANG
328 if (!pdata || !pdata->num_chipselect)
329 return -ENODEV;
330#endif
331
332
333
334
335 master->num_chipselect = pdata->num_chipselect ?: 1;
336
337 spi_gpio->cs_gpios = devm_kcalloc(dev, master->num_chipselect,
338 sizeof(*spi_gpio->cs_gpios),
339 GFP_KERNEL);
340 if (!spi_gpio->cs_gpios)
341 return -ENOMEM;
342
343 for (i = 0; i < master->num_chipselect; i++) {
344 spi_gpio->cs_gpios[i] = devm_gpiod_get_index(dev, "cs", i,
345 GPIOD_OUT_HIGH);
346 if (IS_ERR(spi_gpio->cs_gpios[i]))
347 return PTR_ERR(spi_gpio->cs_gpios[i]);
348 }
349
350 return 0;
351}
352
353static int spi_gpio_probe(struct platform_device *pdev)
354{
355 int status;
356 struct spi_master *master;
357 struct spi_gpio *spi_gpio;
358 struct device *dev = &pdev->dev;
359 struct spi_bitbang *bb;
360
361 master = devm_spi_alloc_master(dev, sizeof(*spi_gpio));
362 if (!master)
363 return -ENOMEM;
364
365 if (pdev->dev.of_node)
366 status = spi_gpio_probe_dt(pdev, master);
367 else
368 status = spi_gpio_probe_pdata(pdev, master);
369
370 if (status)
371 return status;
372
373 spi_gpio = spi_master_get_devdata(master);
374
375 status = spi_gpio_request(dev, spi_gpio);
376 if (status)
377 return status;
378
379 master->bits_per_word_mask = SPI_BPW_RANGE_MASK(1, 32);
380 master->mode_bits = SPI_3WIRE | SPI_3WIRE_HIZ | SPI_CPHA | SPI_CPOL |
381 SPI_CS_HIGH;
382 if (!spi_gpio->mosi) {
383
384
385
386
387
388
389 master->flags = SPI_MASTER_NO_TX;
390 }
391
392 master->bus_num = pdev->id;
393 master->setup = spi_gpio_setup;
394 master->cleanup = spi_gpio_cleanup;
395
396 bb = &spi_gpio->bitbang;
397 bb->master = master;
398
399
400
401
402
403 master->flags |= SPI_MASTER_GPIO_SS;
404 bb->chipselect = spi_gpio_chipselect;
405 bb->set_line_direction = spi_gpio_set_direction;
406
407 if (master->flags & SPI_MASTER_NO_TX) {
408 bb->txrx_word[SPI_MODE_0] = spi_gpio_spec_txrx_word_mode0;
409 bb->txrx_word[SPI_MODE_1] = spi_gpio_spec_txrx_word_mode1;
410 bb->txrx_word[SPI_MODE_2] = spi_gpio_spec_txrx_word_mode2;
411 bb->txrx_word[SPI_MODE_3] = spi_gpio_spec_txrx_word_mode3;
412 } else {
413 bb->txrx_word[SPI_MODE_0] = spi_gpio_txrx_word_mode0;
414 bb->txrx_word[SPI_MODE_1] = spi_gpio_txrx_word_mode1;
415 bb->txrx_word[SPI_MODE_2] = spi_gpio_txrx_word_mode2;
416 bb->txrx_word[SPI_MODE_3] = spi_gpio_txrx_word_mode3;
417 }
418 bb->setup_transfer = spi_bitbang_setup_transfer;
419
420 status = spi_bitbang_init(&spi_gpio->bitbang);
421 if (status)
422 return status;
423
424 return devm_spi_register_master(&pdev->dev, master);
425}
426
427MODULE_ALIAS("platform:" DRIVER_NAME);
428
429static struct platform_driver spi_gpio_driver = {
430 .driver = {
431 .name = DRIVER_NAME,
432 .of_match_table = of_match_ptr(spi_gpio_dt_ids),
433 },
434 .probe = spi_gpio_probe,
435};
436module_platform_driver(spi_gpio_driver);
437
438MODULE_DESCRIPTION("SPI master driver using generic bitbanged GPIO ");
439MODULE_AUTHOR("David Brownell");
440MODULE_LICENSE("GPL");
441