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 __init 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 __init 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"); 420