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