aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/spi/spi.c
diff options
context:
space:
mode:
authorDavid Brownell <david-b@pacbell.net>2006-01-08 16:34:19 -0500
committerGreg Kroah-Hartman <gregkh@suse.de>2006-01-13 19:29:54 -0500
commit8ae12a0d85987dc138f8c944cb78a92bf466cea0 (patch)
treeca032f25bb26f88cc35d68c6f8065143ce64a6a8 /drivers/spi/spi.c
parent67daf5f11f06b9b15f8320de1d237ccc2e74fe43 (diff)
[PATCH] spi: simple SPI framework
This is the core of a small SPI framework, implementing the model of a queue of messages which complete asynchronously (with thin synchronous wrappers on top). - It's still less than 2KB of ".text" (ARM). If there's got to be a mid-layer for something so simple, that's the right size budget. :) - The guts use board-specific SPI device tables to build the driver model tree. (Hardware probing is rarely an option.) - This version of Kconfig includes no drivers. At this writing there are two known master controller drivers (PXA/SSP, OMAP MicroWire) and three protocol drivers (CS8415a, ADS7846, DataFlash) with LKML mentions of other drivers in development. - No userspace API. There are several implementations to compare. Implement them like any other driver, and bind them with sysfs. The changes from last version posted to LKML (on 11-Nov-2005) are minor, and include: - One bugfix (removes a FIXME), with the visible effect of making device names be "spiB.C" where B is the bus number and C is the chipselect. - The "caller provides DMA mappings" mechanism now has kerneldoc, for DMA drivers that want to be fancy. - Hey, the framework init can be subsys_init. Even though board init logic fires earlier, at arch_init ... since the framework init is for driver support, and the board init support uses static init. - Various additional spec/doc clarifications based on discussions with other folk. It adds a brief "thank you" at the end, for folk who've helped nudge this framework into existence. As I've said before, I think that "protocol tweaking" is the main support that this driver framework will need to evolve. From: Mark Underwood <basicmark@yahoo.com> Update the SPI framework to remove a potential priority inversion case by reverting to kmalloc if the pre-allocated DMA-safe buffer isn't available. Signed-off-by: David Brownell <dbrownell@users.sourceforge.net> Signed-off-by: Andrew Morton <akpm@osdl.org> Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
Diffstat (limited to 'drivers/spi/spi.c')
-rw-r--r--drivers/spi/spi.c568
1 files changed, 568 insertions, 0 deletions
diff --git a/drivers/spi/spi.c b/drivers/spi/spi.c
new file mode 100644
index 000000000000..7cd356b17644
--- /dev/null
+++ b/drivers/spi/spi.c
@@ -0,0 +1,568 @@
1/*
2 * spi.c - SPI init/core code
3 *
4 * Copyright (C) 2005 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
21#include <linux/autoconf.h>
22#include <linux/kernel.h>
23#include <linux/device.h>
24#include <linux/init.h>
25#include <linux/cache.h>
26#include <linux/spi/spi.h>
27
28
29/* SPI bustype and spi_master class are registered during early boot,
30 * usually before board init code provides the SPI device tables, and
31 * are available later when driver init code needs them.
32 *
33 * Drivers for SPI devices started out like those for platform bus
34 * devices. But both have changed in 2.6.15; maybe this should get
35 * an "spi_driver" structure at some point (not currently needed)
36 */
37static void spidev_release(struct device *dev)
38{
39 const struct spi_device *spi = to_spi_device(dev);
40
41 /* spi masters may cleanup for released devices */
42 if (spi->master->cleanup)
43 spi->master->cleanup(spi);
44
45 class_device_put(&spi->master->cdev);
46 kfree(dev);
47}
48
49static ssize_t
50modalias_show(struct device *dev, struct device_attribute *a, char *buf)
51{
52 const struct spi_device *spi = to_spi_device(dev);
53
54 return snprintf(buf, BUS_ID_SIZE + 1, "%s\n", spi->modalias);
55}
56
57static struct device_attribute spi_dev_attrs[] = {
58 __ATTR_RO(modalias),
59 __ATTR_NULL,
60};
61
62/* modalias support makes "modprobe $MODALIAS" new-style hotplug work,
63 * and the sysfs version makes coldplug work too.
64 */
65
66static int spi_match_device(struct device *dev, struct device_driver *drv)
67{
68 const struct spi_device *spi = to_spi_device(dev);
69
70 return strncmp(spi->modalias, drv->name, BUS_ID_SIZE) == 0;
71}
72
73static int spi_uevent(struct device *dev, char **envp, int num_envp,
74 char *buffer, int buffer_size)
75{
76 const struct spi_device *spi = to_spi_device(dev);
77
78 envp[0] = buffer;
79 snprintf(buffer, buffer_size, "MODALIAS=%s", spi->modalias);
80 envp[1] = NULL;
81 return 0;
82}
83
84#ifdef CONFIG_PM
85
86/* Suspend/resume in "struct device_driver" don't really need that
87 * strange third parameter, so we just make it a constant and expect
88 * SPI drivers to ignore it just like most platform drivers do.
89 *
90 * NOTE: the suspend() method for an spi_master controller driver
91 * should verify that all its child devices are marked as suspended;
92 * suspend requests delivered through sysfs power/state files don't
93 * enforce such constraints.
94 */
95static int spi_suspend(struct device *dev, pm_message_t message)
96{
97 int value;
98
99 if (!dev->driver || !dev->driver->suspend)
100 return 0;
101
102 /* suspend will stop irqs and dma; no more i/o */
103 value = dev->driver->suspend(dev, message);
104 if (value == 0)
105 dev->power.power_state = message;
106 return value;
107}
108
109static int spi_resume(struct device *dev)
110{
111 int value;
112
113 if (!dev->driver || !dev->driver->resume)
114 return 0;
115
116 /* resume may restart the i/o queue */
117 value = dev->driver->resume(dev);
118 if (value == 0)
119 dev->power.power_state = PMSG_ON;
120 return value;
121}
122
123#else
124#define spi_suspend NULL
125#define spi_resume NULL
126#endif
127
128struct bus_type spi_bus_type = {
129 .name = "spi",
130 .dev_attrs = spi_dev_attrs,
131 .match = spi_match_device,
132 .uevent = spi_uevent,
133 .suspend = spi_suspend,
134 .resume = spi_resume,
135};
136EXPORT_SYMBOL_GPL(spi_bus_type);
137
138/*-------------------------------------------------------------------------*/
139
140/* SPI devices should normally not be created by SPI device drivers; that
141 * would make them board-specific. Similarly with SPI master drivers.
142 * Device registration normally goes into like arch/.../mach.../board-YYY.c
143 * with other readonly (flashable) information about mainboard devices.
144 */
145
146struct boardinfo {
147 struct list_head list;
148 unsigned n_board_info;
149 struct spi_board_info board_info[0];
150};
151
152static LIST_HEAD(board_list);
153static DECLARE_MUTEX(board_lock);
154
155
156/* On typical mainboards, this is purely internal; and it's not needed
157 * after board init creates the hard-wired devices. Some development
158 * platforms may not be able to use spi_register_board_info though, and
159 * this is exported so that for example a USB or parport based adapter
160 * driver could add devices (which it would learn about out-of-band).
161 */
162struct spi_device *__init_or_module
163spi_new_device(struct spi_master *master, struct spi_board_info *chip)
164{
165 struct spi_device *proxy;
166 struct device *dev = master->cdev.dev;
167 int status;
168
169 /* NOTE: caller did any chip->bus_num checks necessary */
170
171 if (!class_device_get(&master->cdev))
172 return NULL;
173
174 proxy = kzalloc(sizeof *proxy, GFP_KERNEL);
175 if (!proxy) {
176 dev_err(dev, "can't alloc dev for cs%d\n",
177 chip->chip_select);
178 goto fail;
179 }
180 proxy->master = master;
181 proxy->chip_select = chip->chip_select;
182 proxy->max_speed_hz = chip->max_speed_hz;
183 proxy->irq = chip->irq;
184 proxy->modalias = chip->modalias;
185
186 snprintf(proxy->dev.bus_id, sizeof proxy->dev.bus_id,
187 "%s.%u", master->cdev.class_id,
188 chip->chip_select);
189 proxy->dev.parent = dev;
190 proxy->dev.bus = &spi_bus_type;
191 proxy->dev.platform_data = (void *) chip->platform_data;
192 proxy->controller_data = chip->controller_data;
193 proxy->controller_state = NULL;
194 proxy->dev.release = spidev_release;
195
196 /* drivers may modify this default i/o setup */
197 status = master->setup(proxy);
198 if (status < 0) {
199 dev_dbg(dev, "can't %s %s, status %d\n",
200 "setup", proxy->dev.bus_id, status);
201 goto fail;
202 }
203
204 /* driver core catches callers that misbehave by defining
205 * devices that already exist.
206 */
207 status = device_register(&proxy->dev);
208 if (status < 0) {
209 dev_dbg(dev, "can't %s %s, status %d\n",
210 "add", proxy->dev.bus_id, status);
211fail:
212 class_device_put(&master->cdev);
213 kfree(proxy);
214 return NULL;
215 }
216 dev_dbg(dev, "registered child %s\n", proxy->dev.bus_id);
217 return proxy;
218}
219EXPORT_SYMBOL_GPL(spi_new_device);
220
221/*
222 * Board-specific early init code calls this (probably during arch_initcall)
223 * with segments of the SPI device table. Any device nodes are created later,
224 * after the relevant parent SPI controller (bus_num) is defined. We keep
225 * this table of devices forever, so that reloading a controller driver will
226 * not make Linux forget about these hard-wired devices.
227 *
228 * Other code can also call this, e.g. a particular add-on board might provide
229 * SPI devices through its expansion connector, so code initializing that board
230 * would naturally declare its SPI devices.
231 *
232 * The board info passed can safely be __initdata ... but be careful of
233 * any embedded pointers (platform_data, etc), they're copied as-is.
234 */
235int __init
236spi_register_board_info(struct spi_board_info const *info, unsigned n)
237{
238 struct boardinfo *bi;
239
240 bi = kmalloc (sizeof (*bi) + n * sizeof (*info), GFP_KERNEL);
241 if (!bi)
242 return -ENOMEM;
243 bi->n_board_info = n;
244 memcpy(bi->board_info, info, n * sizeof (*info));
245
246 down(&board_lock);
247 list_add_tail(&bi->list, &board_list);
248 up(&board_lock);
249 return 0;
250}
251EXPORT_SYMBOL_GPL(spi_register_board_info);
252
253/* FIXME someone should add support for a __setup("spi", ...) that
254 * creates board info from kernel command lines
255 */
256
257static void __init_or_module
258scan_boardinfo(struct spi_master *master)
259{
260 struct boardinfo *bi;
261 struct device *dev = master->cdev.dev;
262
263 down(&board_lock);
264 list_for_each_entry(bi, &board_list, list) {
265 struct spi_board_info *chip = bi->board_info;
266 unsigned n;
267
268 for (n = bi->n_board_info; n > 0; n--, chip++) {
269 if (chip->bus_num != master->bus_num)
270 continue;
271 /* some controllers only have one chip, so they
272 * might not use chipselects. otherwise, the
273 * chipselects are numbered 0..max.
274 */
275 if (chip->chip_select >= master->num_chipselect
276 && master->num_chipselect) {
277 dev_dbg(dev, "cs%d > max %d\n",
278 chip->chip_select,
279 master->num_chipselect);
280 continue;
281 }
282 (void) spi_new_device(master, chip);
283 }
284 }
285 up(&board_lock);
286}
287
288/*-------------------------------------------------------------------------*/
289
290static void spi_master_release(struct class_device *cdev)
291{
292 struct spi_master *master;
293
294 master = container_of(cdev, struct spi_master, cdev);
295 put_device(master->cdev.dev);
296 master->cdev.dev = NULL;
297 kfree(master);
298}
299
300static struct class spi_master_class = {
301 .name = "spi_master",
302 .owner = THIS_MODULE,
303 .release = spi_master_release,
304};
305
306
307/**
308 * spi_alloc_master - allocate SPI master controller
309 * @dev: the controller, possibly using the platform_bus
310 * @size: how much driver-private data to preallocate; a pointer to this
311 * memory in the class_data field of the returned class_device
312 *
313 * This call is used only by SPI master controller drivers, which are the
314 * only ones directly touching chip registers. It's how they allocate
315 * an spi_master structure, prior to calling spi_add_master().
316 *
317 * This must be called from context that can sleep. It returns the SPI
318 * master structure on success, else NULL.
319 *
320 * The caller is responsible for assigning the bus number and initializing
321 * the master's methods before calling spi_add_master(), or else (on error)
322 * calling class_device_put() to prevent a memory leak.
323 */
324struct spi_master * __init_or_module
325spi_alloc_master(struct device *dev, unsigned size)
326{
327 struct spi_master *master;
328
329 master = kzalloc(size + sizeof *master, SLAB_KERNEL);
330 if (!master)
331 return NULL;
332
333 master->cdev.class = &spi_master_class;
334 master->cdev.dev = get_device(dev);
335 class_set_devdata(&master->cdev, &master[1]);
336
337 return master;
338}
339EXPORT_SYMBOL_GPL(spi_alloc_master);
340
341/**
342 * spi_register_master - register SPI master controller
343 * @master: initialized master, originally from spi_alloc_master()
344 *
345 * SPI master controllers connect to their drivers using some non-SPI bus,
346 * such as the platform bus. The final stage of probe() in that code
347 * includes calling spi_register_master() to hook up to this SPI bus glue.
348 *
349 * SPI controllers use board specific (often SOC specific) bus numbers,
350 * and board-specific addressing for SPI devices combines those numbers
351 * with chip select numbers. Since SPI does not directly support dynamic
352 * device identification, boards need configuration tables telling which
353 * chip is at which address.
354 *
355 * This must be called from context that can sleep. It returns zero on
356 * success, else a negative error code (dropping the master's refcount).
357 */
358int __init_or_module
359spi_register_master(struct spi_master *master)
360{
361 static atomic_t dyn_bus_id = ATOMIC_INIT(0);
362 struct device *dev = master->cdev.dev;
363 int status = -ENODEV;
364 int dynamic = 0;
365
366 /* convention: dynamically assigned bus IDs count down from the max */
367 if (master->bus_num == 0) {
368 master->bus_num = atomic_dec_return(&dyn_bus_id);
369 dynamic = 0;
370 }
371
372 /* register the device, then userspace will see it.
373 * registration fails if the bus ID is in use.
374 */
375 snprintf(master->cdev.class_id, sizeof master->cdev.class_id,
376 "spi%u", master->bus_num);
377 status = class_device_register(&master->cdev);
378 if (status < 0) {
379 class_device_put(&master->cdev);
380 goto done;
381 }
382 dev_dbg(dev, "registered master %s%s\n", master->cdev.class_id,
383 dynamic ? " (dynamic)" : "");
384
385 /* populate children from any spi device tables */
386 scan_boardinfo(master);
387 status = 0;
388done:
389 return status;
390}
391EXPORT_SYMBOL_GPL(spi_register_master);
392
393
394static int __unregister(struct device *dev, void *unused)
395{
396 /* note: before about 2.6.14-rc1 this would corrupt memory: */
397 device_unregister(dev);
398 return 0;
399}
400
401/**
402 * spi_unregister_master - unregister SPI master controller
403 * @master: the master being unregistered
404 *
405 * This call is used only by SPI master controller drivers, which are the
406 * only ones directly touching chip registers.
407 *
408 * This must be called from context that can sleep.
409 */
410void spi_unregister_master(struct spi_master *master)
411{
412 class_device_unregister(&master->cdev);
413 (void) device_for_each_child(master->cdev.dev, NULL, __unregister);
414}
415EXPORT_SYMBOL_GPL(spi_unregister_master);
416
417/**
418 * spi_busnum_to_master - look up master associated with bus_num
419 * @bus_num: the master's bus number
420 *
421 * This call may be used with devices that are registered after
422 * arch init time. It returns a refcounted pointer to the relevant
423 * spi_master (which the caller must release), or NULL if there is
424 * no such master registered.
425 */
426struct spi_master *spi_busnum_to_master(u16 bus_num)
427{
428 if (bus_num) {
429 char name[8];
430 struct kobject *bus;
431
432 snprintf(name, sizeof name, "spi%u", bus_num);
433 bus = kset_find_obj(&spi_master_class.subsys.kset, name);
434 if (bus)
435 return container_of(bus, struct spi_master, cdev.kobj);
436 }
437 return NULL;
438}
439EXPORT_SYMBOL_GPL(spi_busnum_to_master);
440
441
442/*-------------------------------------------------------------------------*/
443
444/**
445 * spi_sync - blocking/synchronous SPI data transfers
446 * @spi: device with which data will be exchanged
447 * @message: describes the data transfers
448 *
449 * This call may only be used from a context that may sleep. The sleep
450 * is non-interruptible, and has no timeout. Low-overhead controller
451 * drivers may DMA directly into and out of the message buffers.
452 *
453 * Note that the SPI device's chip select is active during the message,
454 * and then is normally disabled between messages. Drivers for some
455 * frequently-used devices may want to minimize costs of selecting a chip,
456 * by leaving it selected in anticipation that the next message will go
457 * to the same chip. (That may increase power usage.)
458 *
459 * The return value is a negative error code if the message could not be
460 * submitted, else zero. When the value is zero, then message->status is
461 * also defined: it's the completion code for the transfer, either zero
462 * or a negative error code from the controller driver.
463 */
464int spi_sync(struct spi_device *spi, struct spi_message *message)
465{
466 DECLARE_COMPLETION(done);
467 int status;
468
469 message->complete = (void (*)(void *)) complete;
470 message->context = &done;
471 status = spi_async(spi, message);
472 if (status == 0)
473 wait_for_completion(&done);
474 message->context = NULL;
475 return status;
476}
477EXPORT_SYMBOL_GPL(spi_sync);
478
479#define SPI_BUFSIZ (SMP_CACHE_BYTES)
480
481static u8 *buf;
482
483/**
484 * spi_write_then_read - SPI synchronous write followed by read
485 * @spi: device with which data will be exchanged
486 * @txbuf: data to be written (need not be dma-safe)
487 * @n_tx: size of txbuf, in bytes
488 * @rxbuf: buffer into which data will be read
489 * @n_rx: size of rxbuf, in bytes (need not be dma-safe)
490 *
491 * This performs a half duplex MicroWire style transaction with the
492 * device, sending txbuf and then reading rxbuf. The return value
493 * is zero for success, else a negative errno status code.
494 *
495 * Parameters to this routine are always copied using a small buffer,
496 * large transfers should use use spi_{async,sync}() calls with
497 * dma-safe buffers.
498 */
499int spi_write_then_read(struct spi_device *spi,
500 const u8 *txbuf, unsigned n_tx,
501 u8 *rxbuf, unsigned n_rx)
502{
503 static DECLARE_MUTEX(lock);
504
505 int status;
506 struct spi_message message;
507 struct spi_transfer x[2];
508 u8 *local_buf;
509
510 /* Use preallocated DMA-safe buffer. We can't avoid copying here,
511 * (as a pure convenience thing), but we can keep heap costs
512 * out of the hot path ...
513 */
514 if ((n_tx + n_rx) > SPI_BUFSIZ)
515 return -EINVAL;
516
517 /* ... unless someone else is using the pre-allocated buffer */
518 if (down_trylock(&lock)) {
519 local_buf = kmalloc(SPI_BUFSIZ, GFP_KERNEL);
520 if (!local_buf)
521 return -ENOMEM;
522 } else
523 local_buf = buf;
524
525 memset(x, 0, sizeof x);
526
527 memcpy(local_buf, txbuf, n_tx);
528 x[0].tx_buf = local_buf;
529 x[0].len = n_tx;
530
531 x[1].rx_buf = local_buf + n_tx;
532 x[1].len = n_rx;
533
534 /* do the i/o */
535 message.transfers = x;
536 message.n_transfer = ARRAY_SIZE(x);
537 status = spi_sync(spi, &message);
538 if (status == 0) {
539 memcpy(rxbuf, x[1].rx_buf, n_rx);
540 status = message.status;
541 }
542
543 if (x[0].tx_buf == buf)
544 up(&lock);
545 else
546 kfree(local_buf);
547
548 return status;
549}
550EXPORT_SYMBOL_GPL(spi_write_then_read);
551
552/*-------------------------------------------------------------------------*/
553
554static int __init spi_init(void)
555{
556 buf = kmalloc(SPI_BUFSIZ, SLAB_KERNEL);
557 if (!buf)
558 return -ENOMEM;
559
560 bus_register(&spi_bus_type);
561 class_register(&spi_master_class);
562 return 0;
563}
564/* board_info is normally registered in arch_initcall(),
565 * but even essential drivers wait till later
566 */
567subsys_initcall(spi_init);
568