Version:  2.0.40 2.2.26 2.4.37 3.3 3.4 3.5 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

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

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