Version:  2.0.40 2.2.26 2.4.37 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2

Linux/drivers/spi/spi-gpio.c

  1 /*
  2  * SPI master driver using generic bitbanged GPIO
  3  *
  4  * Copyright (C) 2006,2008 David Brownell
  5  *
  6  * This program is free software; you can redistribute it and/or modify
  7  * it under the terms of the GNU General Public License as published by
  8  * the Free Software Foundation; either version 2 of the License, or
  9  * (at your option) any later version.
 10  *
 11  * This program is distributed in the hope that it will be useful,
 12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 14  * GNU General Public License for more details.
 15  */
 16 #include <linux/kernel.h>
 17 #include <linux/module.h>
 18 #include <linux/platform_device.h>
 19 #include <linux/gpio.h>
 20 #include <linux/of.h>
 21 #include <linux/of_device.h>
 22 #include <linux/of_gpio.h>
 23 
 24 #include <linux/spi/spi.h>
 25 #include <linux/spi/spi_bitbang.h>
 26 #include <linux/spi/spi_gpio.h>
 27 
 28 
 29 /*
 30  * This bitbanging SPI master driver should help make systems usable
 31  * when a native hardware SPI engine is not available, perhaps because
 32  * its driver isn't yet working or because the I/O pins it requires
 33  * are used for other purposes.
 34  *
 35  * platform_device->driver_data ... points to spi_gpio
 36  *
 37  * spi->controller_state ... reserved for bitbang framework code
 38  * spi->controller_data ... holds chipselect GPIO
 39  *
 40  * spi->master->dev.driver_data ... points to spi_gpio->bitbang
 41  */
 42 
 43 struct spi_gpio {
 44         struct spi_bitbang              bitbang;
 45         struct spi_gpio_platform_data   pdata;
 46         struct platform_device          *pdev;
 47         unsigned long                   cs_gpios[0];
 48 };
 49 
 50 /*----------------------------------------------------------------------*/
 51 
 52 /*
 53  * Because the overhead of going through four GPIO procedure calls
 54  * per transferred bit can make performance a problem, this code
 55  * is set up so that you can use it in either of two ways:
 56  *
 57  *   - The slow generic way:  set up platform_data to hold the GPIO
 58  *     numbers used for MISO/MOSI/SCK, and issue procedure calls for
 59  *     each of them.  This driver can handle several such busses.
 60  *
 61  *   - The quicker inlined way:  only helps with platform GPIO code
 62  *     that inlines operations for constant GPIOs.  This can give
 63  *     you tight (fast!) inner loops, but each such bus needs a
 64  *     new driver.  You'll define a new C file, with Makefile and
 65  *     Kconfig support; the C code can be a total of six lines:
 66  *
 67  *              #define DRIVER_NAME     "myboard_spi2"
 68  *              #define SPI_MISO_GPIO   119
 69  *              #define SPI_MOSI_GPIO   120
 70  *              #define SPI_SCK_GPIO    121
 71  *              #define SPI_N_CHIPSEL   4
 72  *              #include "spi-gpio.c"
 73  */
 74 
 75 #ifndef DRIVER_NAME
 76 #define DRIVER_NAME     "spi_gpio"
 77 
 78 #define GENERIC_BITBANG /* vs tight inlines */
 79 
 80 /* all functions referencing these symbols must define pdata */
 81 #define SPI_MISO_GPIO   ((pdata)->miso)
 82 #define SPI_MOSI_GPIO   ((pdata)->mosi)
 83 #define SPI_SCK_GPIO    ((pdata)->sck)
 84 
 85 #define SPI_N_CHIPSEL   ((pdata)->num_chipselect)
 86 
 87 #endif
 88 
 89 /*----------------------------------------------------------------------*/
 90 
 91 static inline struct spi_gpio *__pure
 92 spi_to_spi_gpio(const struct spi_device *spi)
 93 {
 94         const struct spi_bitbang        *bang;
 95         struct spi_gpio                 *spi_gpio;
 96 
 97         bang = spi_master_get_devdata(spi->master);
 98         spi_gpio = container_of(bang, struct spi_gpio, bitbang);
 99         return spi_gpio;
100 }
101 
102 static inline struct spi_gpio_platform_data *__pure
103 spi_to_pdata(const struct spi_device *spi)
104 {
105         return &spi_to_spi_gpio(spi)->pdata;
106 }
107 
108 /* this is #defined to avoid unused-variable warnings when inlining */
109 #define pdata           spi_to_pdata(spi)
110 
111 static inline void setsck(const struct spi_device *spi, int is_on)
112 {
113         gpio_set_value_cansleep(SPI_SCK_GPIO, is_on);
114 }
115 
116 static inline void setmosi(const struct spi_device *spi, int is_on)
117 {
118         gpio_set_value_cansleep(SPI_MOSI_GPIO, is_on);
119 }
120 
121 static inline int getmiso(const struct spi_device *spi)
122 {
123         return !!gpio_get_value_cansleep(SPI_MISO_GPIO);
124 }
125 
126 #undef pdata
127 
128 /*
129  * NOTE:  this clocks "as fast as we can".  It "should" be a function of the
130  * requested device clock.  Software overhead means we usually have trouble
131  * reaching even one Mbit/sec (except when we can inline bitops), so for now
132  * we'll just assume we never need additional per-bit slowdowns.
133  */
134 #define spidelay(nsecs) do {} while (0)
135 
136 #include "spi-bitbang-txrx.h"
137 
138 /*
139  * These functions can leverage inline expansion of GPIO calls to shrink
140  * costs for a txrx bit, often by factors of around ten (by instruction
141  * count).  That is particularly visible for larger word sizes, but helps
142  * even with default 8-bit words.
143  *
144  * REVISIT overheads calling these functions for each word also have
145  * significant performance costs.  Having txrx_bufs() calls that inline
146  * the txrx_word() logic would help performance, e.g. on larger blocks
147  * used with flash storage or MMC/SD.  There should also be ways to make
148  * GCC be less stupid about reloading registers inside the I/O loops,
149  * even without inlined GPIO calls; __attribute__((hot)) on GCC 4.3?
150  */
151 
152 static u32 spi_gpio_txrx_word_mode0(struct spi_device *spi,
153                 unsigned nsecs, u32 word, u8 bits)
154 {
155         return bitbang_txrx_be_cpha0(spi, nsecs, 0, 0, word, bits);
156 }
157 
158 static u32 spi_gpio_txrx_word_mode1(struct spi_device *spi,
159                 unsigned nsecs, u32 word, u8 bits)
160 {
161         return bitbang_txrx_be_cpha1(spi, nsecs, 0, 0, word, bits);
162 }
163 
164 static u32 spi_gpio_txrx_word_mode2(struct spi_device *spi,
165                 unsigned nsecs, u32 word, u8 bits)
166 {
167         return bitbang_txrx_be_cpha0(spi, nsecs, 1, 0, word, bits);
168 }
169 
170 static u32 spi_gpio_txrx_word_mode3(struct spi_device *spi,
171                 unsigned nsecs, u32 word, u8 bits)
172 {
173         return bitbang_txrx_be_cpha1(spi, nsecs, 1, 0, word, bits);
174 }
175 
176 /*
177  * These functions do not call setmosi or getmiso if respective flag
178  * (SPI_MASTER_NO_RX or SPI_MASTER_NO_TX) is set, so they are safe to
179  * call when such pin is not present or defined in the controller.
180  * A separate set of callbacks is defined to get highest possible
181  * speed in the generic case (when both MISO and MOSI lines are
182  * available), as optimiser will remove the checks when argument is
183  * constant.
184  */
185 
186 static u32 spi_gpio_spec_txrx_word_mode0(struct spi_device *spi,
187                 unsigned nsecs, u32 word, u8 bits)
188 {
189         unsigned flags = spi->master->flags;
190         return bitbang_txrx_be_cpha0(spi, nsecs, 0, flags, word, bits);
191 }
192 
193 static u32 spi_gpio_spec_txrx_word_mode1(struct spi_device *spi,
194                 unsigned nsecs, u32 word, u8 bits)
195 {
196         unsigned flags = spi->master->flags;
197         return bitbang_txrx_be_cpha1(spi, nsecs, 0, flags, word, bits);
198 }
199 
200 static u32 spi_gpio_spec_txrx_word_mode2(struct spi_device *spi,
201                 unsigned nsecs, u32 word, u8 bits)
202 {
203         unsigned flags = spi->master->flags;
204         return bitbang_txrx_be_cpha0(spi, nsecs, 1, flags, word, bits);
205 }
206 
207 static u32 spi_gpio_spec_txrx_word_mode3(struct spi_device *spi,
208                 unsigned nsecs, u32 word, u8 bits)
209 {
210         unsigned flags = spi->master->flags;
211         return bitbang_txrx_be_cpha1(spi, nsecs, 1, flags, word, bits);
212 }
213 
214 /*----------------------------------------------------------------------*/
215 
216 static void spi_gpio_chipselect(struct spi_device *spi, int is_active)
217 {
218         struct spi_gpio *spi_gpio = spi_to_spi_gpio(spi);
219         unsigned long cs = spi_gpio->cs_gpios[spi->chip_select];
220 
221         /* set initial clock polarity */
222         if (is_active)
223                 setsck(spi, spi->mode & SPI_CPOL);
224 
225         if (cs != SPI_GPIO_NO_CHIPSELECT) {
226                 /* SPI is normally active-low */
227                 gpio_set_value_cansleep(cs, (spi->mode & SPI_CS_HIGH) ? is_active : !is_active);
228         }
229 }
230 
231 static int spi_gpio_setup(struct spi_device *spi)
232 {
233         unsigned long           cs;
234         int                     status = 0;
235         struct spi_gpio         *spi_gpio = spi_to_spi_gpio(spi);
236         struct device_node      *np = spi->master->dev.of_node;
237 
238         if (np) {
239                 /*
240                  * In DT environments, the CS GPIOs have already been
241                  * initialized from the "cs-gpios" property of the node.
242                  */
243                 cs = spi_gpio->cs_gpios[spi->chip_select];
244         } else {
245                 /*
246                  * ... otherwise, take it from spi->controller_data
247                  */
248                 cs = (uintptr_t) spi->controller_data;
249         }
250 
251         if (!spi->controller_state) {
252                 if (cs != SPI_GPIO_NO_CHIPSELECT) {
253                         status = gpio_request(cs, dev_name(&spi->dev));
254                         if (status)
255                                 return status;
256                         status = gpio_direction_output(cs,
257                                         !(spi->mode & SPI_CS_HIGH));
258                 }
259         }
260         if (!status) {
261                 /* in case it was initialized from static board data */
262                 spi_gpio->cs_gpios[spi->chip_select] = cs;
263                 status = spi_bitbang_setup(spi);
264         }
265 
266         if (status) {
267                 if (!spi->controller_state && cs != SPI_GPIO_NO_CHIPSELECT)
268                         gpio_free(cs);
269         }
270         return status;
271 }
272 
273 static void spi_gpio_cleanup(struct spi_device *spi)
274 {
275         struct spi_gpio *spi_gpio = spi_to_spi_gpio(spi);
276         unsigned long cs = spi_gpio->cs_gpios[spi->chip_select];
277 
278         if (cs != SPI_GPIO_NO_CHIPSELECT)
279                 gpio_free(cs);
280         spi_bitbang_cleanup(spi);
281 }
282 
283 static int spi_gpio_alloc(unsigned pin, const char *label, bool is_in)
284 {
285         int value;
286 
287         value = gpio_request(pin, label);
288         if (value == 0) {
289                 if (is_in)
290                         value = gpio_direction_input(pin);
291                 else
292                         value = gpio_direction_output(pin, 0);
293         }
294         return value;
295 }
296 
297 static int spi_gpio_request(struct spi_gpio_platform_data *pdata,
298                             const char *label, u16 *res_flags)
299 {
300         int value;
301 
302         /* NOTE:  SPI_*_GPIO symbols may reference "pdata" */
303 
304         if (SPI_MOSI_GPIO != SPI_GPIO_NO_MOSI) {
305                 value = spi_gpio_alloc(SPI_MOSI_GPIO, label, false);
306                 if (value)
307                         goto done;
308         } else {
309                 /* HW configuration without MOSI pin */
310                 *res_flags |= SPI_MASTER_NO_TX;
311         }
312 
313         if (SPI_MISO_GPIO != SPI_GPIO_NO_MISO) {
314                 value = spi_gpio_alloc(SPI_MISO_GPIO, label, true);
315                 if (value)
316                         goto free_mosi;
317         } else {
318                 /* HW configuration without MISO pin */
319                 *res_flags |= SPI_MASTER_NO_RX;
320         }
321 
322         value = spi_gpio_alloc(SPI_SCK_GPIO, label, false);
323         if (value)
324                 goto free_miso;
325 
326         goto done;
327 
328 free_miso:
329         if (SPI_MISO_GPIO != SPI_GPIO_NO_MISO)
330                 gpio_free(SPI_MISO_GPIO);
331 free_mosi:
332         if (SPI_MOSI_GPIO != SPI_GPIO_NO_MOSI)
333                 gpio_free(SPI_MOSI_GPIO);
334 done:
335         return value;
336 }
337 
338 #ifdef CONFIG_OF
339 static const struct of_device_id spi_gpio_dt_ids[] = {
340         { .compatible = "spi-gpio" },
341         {}
342 };
343 MODULE_DEVICE_TABLE(of, spi_gpio_dt_ids);
344 
345 static int spi_gpio_probe_dt(struct platform_device *pdev)
346 {
347         int ret;
348         u32 tmp;
349         struct spi_gpio_platform_data   *pdata;
350         struct device_node *np = pdev->dev.of_node;
351         const struct of_device_id *of_id =
352                         of_match_device(spi_gpio_dt_ids, &pdev->dev);
353 
354         if (!of_id)
355                 return 0;
356 
357         pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
358         if (!pdata)
359                 return -ENOMEM;
360 
361         ret = of_get_named_gpio(np, "gpio-sck", 0);
362         if (ret < 0) {
363                 dev_err(&pdev->dev, "gpio-sck property not found\n");
364                 goto error_free;
365         }
366         pdata->sck = ret;
367 
368         ret = of_get_named_gpio(np, "gpio-miso", 0);
369         if (ret < 0) {
370                 dev_info(&pdev->dev, "gpio-miso property not found, switching to no-rx mode\n");
371                 pdata->miso = SPI_GPIO_NO_MISO;
372         } else
373                 pdata->miso = ret;
374 
375         ret = of_get_named_gpio(np, "gpio-mosi", 0);
376         if (ret < 0) {
377                 dev_info(&pdev->dev, "gpio-mosi property not found, switching to no-tx mode\n");
378                 pdata->mosi = SPI_GPIO_NO_MOSI;
379         } else
380                 pdata->mosi = ret;
381 
382         ret = of_property_read_u32(np, "num-chipselects", &tmp);
383         if (ret < 0) {
384                 dev_err(&pdev->dev, "num-chipselects property not found\n");
385                 goto error_free;
386         }
387 
388         pdata->num_chipselect = tmp;
389         pdev->dev.platform_data = pdata;
390 
391         return 1;
392 
393 error_free:
394         devm_kfree(&pdev->dev, pdata);
395         return ret;
396 }
397 #else
398 static inline int spi_gpio_probe_dt(struct platform_device *pdev)
399 {
400         return 0;
401 }
402 #endif
403 
404 static int spi_gpio_probe(struct platform_device *pdev)
405 {
406         int                             status;
407         struct spi_master               *master;
408         struct spi_gpio                 *spi_gpio;
409         struct spi_gpio_platform_data   *pdata;
410         u16 master_flags = 0;
411         bool use_of = 0;
412         int num_devices;
413 
414         status = spi_gpio_probe_dt(pdev);
415         if (status < 0)
416                 return status;
417         if (status > 0)
418                 use_of = 1;
419 
420         pdata = dev_get_platdata(&pdev->dev);
421 #ifdef GENERIC_BITBANG
422         if (!pdata || (!use_of && !pdata->num_chipselect))
423                 return -ENODEV;
424 #endif
425 
426         if (use_of && !SPI_N_CHIPSEL)
427                 num_devices = 1;
428         else
429                 num_devices = SPI_N_CHIPSEL;
430 
431         status = spi_gpio_request(pdata, dev_name(&pdev->dev), &master_flags);
432         if (status < 0)
433                 return status;
434 
435         master = spi_alloc_master(&pdev->dev, sizeof(*spi_gpio) +
436                                         (sizeof(unsigned long) * num_devices));
437         if (!master) {
438                 status = -ENOMEM;
439                 goto gpio_free;
440         }
441         spi_gpio = spi_master_get_devdata(master);
442         platform_set_drvdata(pdev, spi_gpio);
443 
444         spi_gpio->pdev = pdev;
445         if (pdata)
446                 spi_gpio->pdata = *pdata;
447 
448         master->bits_per_word_mask = SPI_BPW_RANGE_MASK(1, 32);
449         master->flags = master_flags;
450         master->bus_num = pdev->id;
451         master->num_chipselect = num_devices;
452         master->setup = spi_gpio_setup;
453         master->cleanup = spi_gpio_cleanup;
454 #ifdef CONFIG_OF
455         master->dev.of_node = pdev->dev.of_node;
456 
457         if (use_of) {
458                 int i;
459                 struct device_node *np = pdev->dev.of_node;
460 
461                 /*
462                  * In DT environments, take the CS GPIO from the "cs-gpios"
463                  * property of the node.
464                  */
465 
466                 if (!SPI_N_CHIPSEL)
467                         spi_gpio->cs_gpios[0] = SPI_GPIO_NO_CHIPSELECT;
468                 else
469                         for (i = 0; i < SPI_N_CHIPSEL; i++) {
470                                 status = of_get_named_gpio(np, "cs-gpios", i);
471                                 if (status < 0) {
472                                         dev_err(&pdev->dev,
473                                                 "invalid cs-gpios property\n");
474                                         goto gpio_free;
475                                 }
476                                 spi_gpio->cs_gpios[i] = status;
477                         }
478         }
479 #endif
480 
481         spi_gpio->bitbang.master = master;
482         spi_gpio->bitbang.chipselect = spi_gpio_chipselect;
483 
484         if ((master_flags & (SPI_MASTER_NO_TX | SPI_MASTER_NO_RX)) == 0) {
485                 spi_gpio->bitbang.txrx_word[SPI_MODE_0] = spi_gpio_txrx_word_mode0;
486                 spi_gpio->bitbang.txrx_word[SPI_MODE_1] = spi_gpio_txrx_word_mode1;
487                 spi_gpio->bitbang.txrx_word[SPI_MODE_2] = spi_gpio_txrx_word_mode2;
488                 spi_gpio->bitbang.txrx_word[SPI_MODE_3] = spi_gpio_txrx_word_mode3;
489         } else {
490                 spi_gpio->bitbang.txrx_word[SPI_MODE_0] = spi_gpio_spec_txrx_word_mode0;
491                 spi_gpio->bitbang.txrx_word[SPI_MODE_1] = spi_gpio_spec_txrx_word_mode1;
492                 spi_gpio->bitbang.txrx_word[SPI_MODE_2] = spi_gpio_spec_txrx_word_mode2;
493                 spi_gpio->bitbang.txrx_word[SPI_MODE_3] = spi_gpio_spec_txrx_word_mode3;
494         }
495         spi_gpio->bitbang.setup_transfer = spi_bitbang_setup_transfer;
496         spi_gpio->bitbang.flags = SPI_CS_HIGH;
497 
498         status = spi_bitbang_start(&spi_gpio->bitbang);
499         if (status < 0) {
500 gpio_free:
501                 if (SPI_MISO_GPIO != SPI_GPIO_NO_MISO)
502                         gpio_free(SPI_MISO_GPIO);
503                 if (SPI_MOSI_GPIO != SPI_GPIO_NO_MOSI)
504                         gpio_free(SPI_MOSI_GPIO);
505                 gpio_free(SPI_SCK_GPIO);
506                 spi_master_put(master);
507         }
508 
509         return status;
510 }
511 
512 static int spi_gpio_remove(struct platform_device *pdev)
513 {
514         struct spi_gpio                 *spi_gpio;
515         struct spi_gpio_platform_data   *pdata;
516 
517         spi_gpio = platform_get_drvdata(pdev);
518         pdata = dev_get_platdata(&pdev->dev);
519 
520         /* stop() unregisters child devices too */
521         spi_bitbang_stop(&spi_gpio->bitbang);
522 
523         if (SPI_MISO_GPIO != SPI_GPIO_NO_MISO)
524                 gpio_free(SPI_MISO_GPIO);
525         if (SPI_MOSI_GPIO != SPI_GPIO_NO_MOSI)
526                 gpio_free(SPI_MOSI_GPIO);
527         gpio_free(SPI_SCK_GPIO);
528         spi_master_put(spi_gpio->bitbang.master);
529 
530         return 0;
531 }
532 
533 MODULE_ALIAS("platform:" DRIVER_NAME);
534 
535 static struct platform_driver spi_gpio_driver = {
536         .driver = {
537                 .name   = DRIVER_NAME,
538                 .of_match_table = of_match_ptr(spi_gpio_dt_ids),
539         },
540         .probe          = spi_gpio_probe,
541         .remove         = spi_gpio_remove,
542 };
543 module_platform_driver(spi_gpio_driver);
544 
545 MODULE_DESCRIPTION("SPI master driver using generic bitbanged GPIO ");
546 MODULE_AUTHOR("David Brownell");
547 MODULE_LICENSE("GPL");
548 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us