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/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_TX | 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"); 430