This source file includes following definitions.
- spi_to_spi_gpio
- setsck
- setmosi
- getmiso
- spi_gpio_txrx_word_mode0
- spi_gpio_txrx_word_mode1
- spi_gpio_txrx_word_mode2
- spi_gpio_txrx_word_mode3
- spi_gpio_spec_txrx_word_mode0
- spi_gpio_spec_txrx_word_mode1
- spi_gpio_spec_txrx_word_mode2
- spi_gpio_spec_txrx_word_mode3
- spi_gpio_chipselect
- spi_gpio_setup
- spi_gpio_set_direction
- spi_gpio_cleanup
- spi_gpio_request
- spi_gpio_probe_dt
- spi_gpio_probe_dt
- spi_gpio_probe_pdata
- spi_gpio_put
- spi_gpio_probe
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
33 struct 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
75 static inline struct spi_gpio *__pure
76 spi_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
87 static 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
94 static 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
101 static 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
135 static 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
141 static 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
147 static 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
153 static 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
169 static 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
176 static 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
183 static 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
190 static 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
199 static 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
216 static 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
239 static 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
267 static 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
282 static 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
297 static const struct of_device_id spi_gpio_dt_ids[] = {
298 { .compatible = "spi-gpio" },
299 {}
300 };
301 MODULE_DEVICE_TABLE(of, spi_gpio_dt_ids);
302
303 static 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
312 static inline int spi_gpio_probe_dt(struct platform_device *pdev,
313 struct spi_master *master)
314 {
315 return 0;
316 }
317 #endif
318
319 static 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
353 static void spi_gpio_put(void *data)
354 {
355 spi_master_put(data);
356 }
357
358 static int spi_gpio_probe(struct platform_device *pdev)
359 {
360 int status;
361 struct spi_master *master;
362 struct spi_gpio *spi_gpio;
363 struct device *dev = &pdev->dev;
364 struct spi_bitbang *bb;
365 const struct of_device_id *of_id;
366
367 of_id = of_match_device(spi_gpio_dt_ids, &pdev->dev);
368
369 master = spi_alloc_master(dev, sizeof(*spi_gpio));
370 if (!master)
371 return -ENOMEM;
372
373 status = devm_add_action_or_reset(&pdev->dev, spi_gpio_put, master);
374 if (status) {
375 spi_master_put(master);
376 return status;
377 }
378
379 if (of_id)
380 status = spi_gpio_probe_dt(pdev, master);
381 else
382 status = spi_gpio_probe_pdata(pdev, master);
383
384 if (status)
385 return status;
386
387 spi_gpio = spi_master_get_devdata(master);
388
389 status = spi_gpio_request(dev, spi_gpio);
390 if (status)
391 return status;
392
393 master->bits_per_word_mask = SPI_BPW_RANGE_MASK(1, 32);
394 master->mode_bits = SPI_3WIRE | SPI_3WIRE_HIZ | SPI_CPHA | SPI_CPOL |
395 SPI_CS_HIGH;
396 if (!spi_gpio->mosi) {
397
398
399
400
401
402
403 master->flags = SPI_MASTER_NO_TX;
404 }
405
406 master->bus_num = pdev->id;
407 master->setup = spi_gpio_setup;
408 master->cleanup = spi_gpio_cleanup;
409
410 bb = &spi_gpio->bitbang;
411 bb->master = master;
412
413
414
415
416
417 master->flags |= SPI_MASTER_GPIO_SS;
418 bb->chipselect = spi_gpio_chipselect;
419 bb->set_line_direction = spi_gpio_set_direction;
420
421 if (master->flags & SPI_MASTER_NO_TX) {
422 bb->txrx_word[SPI_MODE_0] = spi_gpio_spec_txrx_word_mode0;
423 bb->txrx_word[SPI_MODE_1] = spi_gpio_spec_txrx_word_mode1;
424 bb->txrx_word[SPI_MODE_2] = spi_gpio_spec_txrx_word_mode2;
425 bb->txrx_word[SPI_MODE_3] = spi_gpio_spec_txrx_word_mode3;
426 } else {
427 bb->txrx_word[SPI_MODE_0] = spi_gpio_txrx_word_mode0;
428 bb->txrx_word[SPI_MODE_1] = spi_gpio_txrx_word_mode1;
429 bb->txrx_word[SPI_MODE_2] = spi_gpio_txrx_word_mode2;
430 bb->txrx_word[SPI_MODE_3] = spi_gpio_txrx_word_mode3;
431 }
432 bb->setup_transfer = spi_bitbang_setup_transfer;
433
434 status = spi_bitbang_init(&spi_gpio->bitbang);
435 if (status)
436 return status;
437
438 return devm_spi_register_master(&pdev->dev, spi_master_get(master));
439 }
440
441 MODULE_ALIAS("platform:" DRIVER_NAME);
442
443 static struct platform_driver spi_gpio_driver = {
444 .driver = {
445 .name = DRIVER_NAME,
446 .of_match_table = of_match_ptr(spi_gpio_dt_ids),
447 },
448 .probe = spi_gpio_probe,
449 };
450 module_platform_driver(spi_gpio_driver);
451
452 MODULE_DESCRIPTION("SPI master driver using generic bitbanged GPIO ");
453 MODULE_AUTHOR("David Brownell");
454 MODULE_LICENSE("GPL");