drivers/spi/spi_gpio.c

   1 /*
   2  * spi_gpio.c - 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/init.h>
  22 #include <linux/platform_device.h>
  23 #include <linux/gpio.h>
  24
  25 #include <linux/spi/spi.h>
  26 #include <linux/spi/spi_bitbang.h>
  27 #include <linux/spi/spi_gpio.h>
  28
  29
  30 /*
  31  * This bitbanging SPI master driver should help make systems usable
  32  * when a native hardware SPI engine is not available, perhaps because
  33  * its driver isn't yet working or because the I/O pins it requires
  34  * are used for other purposes.
  35  *
  36  * platform_device->driver_data ... points to spi_gpio
  37  *
  38  * spi->controller_state ... reserved for bitbang framework code
  39  * spi->controller_data ... holds chipselect GPIO
  40  *
  41  * spi->master->dev.driver_data ... points to spi_gpio->bitbang
  42  */
  43
  44 struct spi_gpio {
  45         struct spi_bitbang              bitbang;
  46         struct spi_gpio_platform_data   pdata;
  47         struct platform_device          *pdev;
  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 const struct spi_gpio_platform_data * __pure
  92 spi_to_pdata(const struct spi_device *spi)
  93 {
  94         const struct spi_bitbang        *bang;
  95         const 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->pdata;
 100 }
 101
 102 /* this is #defined to avoid unused-variable warnings when inlining */
 103 #define pdata           spi_to_pdata(spi)
 104
 105 static inline void setsck(const struct spi_device *spi, int is_on)
 106 {
 107         gpio_set_value(SPI_SCK_GPIO, is_on);
 108 }
 109
 110 static inline void setmosi(const struct spi_device *spi, int is_on)
 111 {
 112         gpio_set_value(SPI_MOSI_GPIO, is_on);
 113 }
 114
 115 static inline int getmiso(const struct spi_device *spi)
 116 {
 117         return !!gpio_get_value(SPI_MISO_GPIO);
 118 }
 119
 120 #undef pdata
 121
 122 /*
 123  * NOTE:  this clocks "as fast as we can".  It "should" be a function of the
 124  * requested device clock.  Software overhead means we usually have trouble
 125  * reaching even one Mbit/sec (except when we can inline bitops), so for now
 126  * we'll just assume we never need additional per-bit slowdowns.
 127  */
 128 #define spidelay(nsecs) do {} while (0)
 129
 130 #include "spi_bitbang_txrx.h"
 131
 132 /*
 133  * These functions can leverage inline expansion of GPIO calls to shrink
 134  * costs for a txrx bit, often by factors of around ten (by instruction
 135  * count).  That is particularly visible for larger word sizes, but helps
 136  * even with default 8-bit words.
 137  *
 138  * REVISIT overheads calling these functions for each word also have
 139  * significant performance costs.  Having txrx_bufs() calls that inline
 140  * the txrx_word() logic would help performance, e.g. on larger blocks
 141  * used with flash storage or MMC/SD.  There should also be ways to make
 142  * GCC be less stupid about reloading registers inside the I/O loops,
 143  * even without inlined GPIO calls; __attribute__((hot)) on GCC 4.3?
 144  */
 145
 146 static u32 spi_gpio_txrx_word_mode0(struct spi_device *spi,
 147                 unsigned nsecs, u32 word, u8 bits)
 148 {
 149         return bitbang_txrx_be_cpha0(spi, nsecs, 0, 0, word, bits);
 150 }
 151
 152 static u32 spi_gpio_txrx_word_mode1(struct spi_device *spi,
 153                 unsigned nsecs, u32 word, u8 bits)
 154 {
 155         return bitbang_txrx_be_cpha1(spi, nsecs, 0, 0, word, bits);
 156 }
 157
 158 static u32 spi_gpio_txrx_word_mode2(struct spi_device *spi,
 159                 unsigned nsecs, u32 word, u8 bits)
 160 {
 161         return bitbang_txrx_be_cpha0(spi, nsecs, 1, 0, word, bits);
 162 }
 163
 164 static u32 spi_gpio_txrx_word_mode3(struct spi_device *spi,
 165                 unsigned nsecs, u32 word, u8 bits)
 166 {
 167         return bitbang_txrx_be_cpha1(spi, nsecs, 1, 0, word, bits);
 168 }
 169
 170 /*
 171  * These functions do not call setmosi or getmiso if respective flag
 172  * (SPI_MASTER_NO_RX or SPI_MASTER_NO_TX) is set, so they are safe to
 173  * call when such pin is not present or defined in the controller.
 174  * A separate set of callbacks is defined to get highest possible
 175  * speed in the generic case (when both MISO and MOSI lines are
 176  * available), as optimiser will remove the checks when argument is
 177  * constant.
 178  */
 179
 180 static u32 spi_gpio_spec_txrx_word_mode0(struct spi_device *spi,
 181                 unsigned nsecs, u32 word, u8 bits)
 182 {
 183         unsigned flags = spi->master->flags;
 184         return bitbang_txrx_be_cpha0(spi, nsecs, 0, flags, word, bits);
 185 }
 186
 187 static u32 spi_gpio_spec_txrx_word_mode1(struct spi_device *spi,
 188                 unsigned nsecs, u32 word, u8 bits)
 189 {
 190         unsigned flags = spi->master->flags;
 191         return bitbang_txrx_be_cpha1(spi, nsecs, 0, flags, word, bits);
 192 }
 193
 194 static u32 spi_gpio_spec_txrx_word_mode2(struct spi_device *spi,
 195                 unsigned nsecs, u32 word, u8 bits)
 196 {
 197         unsigned flags = spi->master->flags;
 198         return bitbang_txrx_be_cpha0(spi, nsecs, 1, flags, word, bits);
 199 }
 200
 201 static u32 spi_gpio_spec_txrx_word_mode3(struct spi_device *spi,
 202                 unsigned nsecs, u32 word, u8 bits)
 203 {
 204         unsigned flags = spi->master->flags;
 205         return bitbang_txrx_be_cpha1(spi, nsecs, 1, flags, word, bits);
 206 }
 207
 208 /*----------------------------------------------------------------------*/
 209
 210 static void spi_gpio_chipselect(struct spi_device *spi, int is_active)
 211 {
 212         unsigned long cs = (unsigned long) spi->controller_data;
 213
 214         /* set initial clock polarity */
 215         if (is_active)
 216                 setsck(spi, spi->mode & SPI_CPOL);
 217
 218         if (cs != SPI_GPIO_NO_CHIPSELECT) {
 219                 /* SPI is normally active-low */
 220                 gpio_set_value(cs, (spi->mode & SPI_CS_HIGH) ? is_active : !is_active);
 221         }
 222 }
 223
 224 static int spi_gpio_setup(struct spi_device *spi)
 225 {
 226         unsigned long   cs = (unsigned long) spi->controller_data;
 227         int             status = 0;
 228
 229         if (spi->bits_per_word > 32)
 230                 return -EINVAL;
 231
 232         if (!spi->controller_state) {
 233                 if (cs != SPI_GPIO_NO_CHIPSELECT) {
 234                         status = gpio_request(cs, dev_name(&spi->dev));
 235                         if (status)
 236                                 return status;
 237                         status = gpio_direction_output(cs, spi->mode & SPI_CS_HIGH);
 238                 }
 239         }
 240         if (!status)
 241                 status = spi_bitbang_setup(spi);
 242         if (status) {
 243                 if (!spi->controller_state && cs != SPI_GPIO_NO_CHIPSELECT)
 244                         gpio_free(cs);
 245         }
 246         return status;
 247 }
 248
 249 static void spi_gpio_cleanup(struct spi_device *spi)
 250 {
 251         unsigned long   cs = (unsigned long) spi->controller_data;
 252
 253         if (cs != SPI_GPIO_NO_CHIPSELECT)
 254                 gpio_free(cs);
 255         spi_bitbang_cleanup(spi);
 256 }
 257
 258 static int __init spi_gpio_alloc(unsigned pin, const char *label, bool is_in)
 259 {
 260         int value;
 261
 262         value = gpio_request(pin, label);
 263         if (value == 0) {
 264                 if (is_in)
 265                         value = gpio_direction_input(pin);
 266                 else
 267                         value = gpio_direction_output(pin, 0);
 268         }
 269         return value;
 270 }
 271
 272 static int __init
 273 spi_gpio_request(struct spi_gpio_platform_data *pdata, const char *label,
 274         u16 *res_flags)
 275 {
 276         int value;
 277
 278         /* NOTE:  SPI_*_GPIO symbols may reference "pdata" */
 279
 280         if (SPI_MOSI_GPIO != SPI_GPIO_NO_MOSI) {
 281                 value = spi_gpio_alloc(SPI_MOSI_GPIO, label, false);
 282                 if (value)
 283                         goto done;
 284         } else {
 285                 /* HW configuration without MOSI pin */
 286                 *res_flags |= SPI_MASTER_NO_TX;
 287         }
 288
 289         if (SPI_MISO_GPIO != SPI_GPIO_NO_MISO) {
 290                 value = spi_gpio_alloc(SPI_MISO_GPIO, label, true);
 291                 if (value)
 292                         goto free_mosi;
 293         } else {
 294                 /* HW configuration without MISO pin */
 295                 *res_flags |= SPI_MASTER_NO_RX;
 296         }
 297
 298         value = spi_gpio_alloc(SPI_SCK_GPIO, label, false);
 299         if (value)
 300                 goto free_miso;
 301
 302         goto done;
 303
 304 free_miso:
 305         if (SPI_MISO_GPIO != SPI_GPIO_NO_MISO)
 306                 gpio_free(SPI_MISO_GPIO);
 307 free_mosi:
 308         if (SPI_MOSI_GPIO != SPI_GPIO_NO_MOSI)
 309                 gpio_free(SPI_MOSI_GPIO);
 310 done:
 311         return value;
 312 }
 313
 314 static int __init spi_gpio_probe(struct platform_device *pdev)
 315 {
 316         int                             status;
 317         struct spi_master               *master;
 318         struct spi_gpio                 *spi_gpio;
 319         struct spi_gpio_platform_data   *pdata;
 320         u16 master_flags = 0;
 321
 322         pdata = pdev->dev.platform_data;
 323 #ifdef GENERIC_BITBANG
 324         if (!pdata || !pdata->num_chipselect)
 325                 return -ENODEV;
 326 #endif
 327
 328         status = spi_gpio_request(pdata, dev_name(&pdev->dev), &master_flags);
 329         if (status < 0)
 330                 return status;
 331
 332         master = spi_alloc_master(&pdev->dev, sizeof *spi_gpio);
 333         if (!master) {
 334                 status = -ENOMEM;
 335                 goto gpio_free;
 336         }
 337         spi_gpio = spi_master_get_devdata(master);
 338         platform_set_drvdata(pdev, spi_gpio);
 339
 340         spi_gpio->pdev = pdev;
 341         if (pdata)
 342                 spi_gpio->pdata = *pdata;
 343
 344         master->flags = master_flags;
 345         master->bus_num = pdev->id;
 346         master->num_chipselect = SPI_N_CHIPSEL;
 347         master->setup = spi_gpio_setup;
 348         master->cleanup = spi_gpio_cleanup;
 349
 350         spi_gpio->bitbang.master = spi_master_get(master);
 351         spi_gpio->bitbang.chipselect = spi_gpio_chipselect;
 352
 353         if ((master_flags & (SPI_MASTER_NO_RX | SPI_MASTER_NO_RX)) == 0) {
 354                 spi_gpio->bitbang.txrx_word[SPI_MODE_0] = spi_gpio_txrx_word_mode0;
 355                 spi_gpio->bitbang.txrx_word[SPI_MODE_1] = spi_gpio_txrx_word_mode1;
 356                 spi_gpio->bitbang.txrx_word[SPI_MODE_2] = spi_gpio_txrx_word_mode2;
 357                 spi_gpio->bitbang.txrx_word[SPI_MODE_3] = spi_gpio_txrx_word_mode3;
 358         } else {
 359                 spi_gpio->bitbang.txrx_word[SPI_MODE_0] = spi_gpio_spec_txrx_word_mode0;
 360                 spi_gpio->bitbang.txrx_word[SPI_MODE_1] = spi_gpio_spec_txrx_word_mode1;
 361                 spi_gpio->bitbang.txrx_word[SPI_MODE_2] = spi_gpio_spec_txrx_word_mode2;
 362                 spi_gpio->bitbang.txrx_word[SPI_MODE_3] = spi_gpio_spec_txrx_word_mode3;
 363         }
 364         spi_gpio->bitbang.setup_transfer = spi_bitbang_setup_transfer;
 365         spi_gpio->bitbang.flags = SPI_CS_HIGH;
 366
 367         status = spi_bitbang_start(&spi_gpio->bitbang);
 368         if (status < 0) {
 369                 spi_master_put(spi_gpio->bitbang.master);
 370 gpio_free:
 371                 if (SPI_MISO_GPIO != SPI_GPIO_NO_MISO)
 372                         gpio_free(SPI_MISO_GPIO);
 373                 if (SPI_MOSI_GPIO != SPI_GPIO_NO_MOSI)
 374                         gpio_free(SPI_MOSI_GPIO);
 375                 gpio_free(SPI_SCK_GPIO);
 376                 spi_master_put(master);
 377         }
 378
 379         return status;
 380 }
 381
 382 static int __exit spi_gpio_remove(struct platform_device *pdev)
 383 {
 384         struct spi_gpio                 *spi_gpio;
 385         struct spi_gpio_platform_data   *pdata;
 386         int                             status;
 387
 388         spi_gpio = platform_get_drvdata(pdev);
 389         pdata = pdev->dev.platform_data;
 390
 391         /* stop() unregisters child devices too */
 392         status = spi_bitbang_stop(&spi_gpio->bitbang);
 393         spi_master_put(spi_gpio->bitbang.master);
 394
 395         platform_set_drvdata(pdev, NULL);
 396
 397         if (SPI_MISO_GPIO != SPI_GPIO_NO_MISO)
 398                 gpio_free(SPI_MISO_GPIO);
 399         if (SPI_MOSI_GPIO != SPI_GPIO_NO_MOSI)
 400                 gpio_free(SPI_MOSI_GPIO);
 401         gpio_free(SPI_SCK_GPIO);
 402
 403         return status;
 404 }
 405
 406 MODULE_ALIAS("platform:" DRIVER_NAME);
 407
 408 static struct platform_driver spi_gpio_driver = {
 409         .driver.name    = DRIVER_NAME,
 410         .driver.owner   = THIS_MODULE,
 411         .remove         = __exit_p(spi_gpio_remove),
 412 };
 413
 414 static int __init spi_gpio_init(void)
 415 {
 416         return platform_driver_probe(&spi_gpio_driver, spi_gpio_probe);
 417 }
 418 module_init(spi_gpio_init);
 419
 420 static void __exit spi_gpio_exit(void)
 421 {
 422         platform_driver_unregister(&spi_gpio_driver);
 423 }
 424 module_exit(spi_gpio_exit);
 425
 426
 427 MODULE_DESCRIPTION("SPI master driver using generic bitbanged GPIO ");
 428 MODULE_AUTHOR("David Brownell");
 429 MODULE_LICENSE("GPL");