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