[IA64] remove obsolete no_irq_type
[linux-2.6/verdex.git] / drivers / spi / spi.c
blob8eba98c8ed1e0727bb200f58be39d3831ab30b26
1 /*
2 * spi.c - SPI init/core code
4 * Copyright (C) 2005 David Brownell
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.
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.
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.
21 #include <linux/kernel.h>
22 #include <linux/device.h>
23 #include <linux/init.h>
24 #include <linux/cache.h>
25 #include <linux/mutex.h>
26 #include <linux/spi/spi.h>
29 /* SPI bustype and spi_master class are registered after board init code
30 * provides the SPI device tables, ensuring that both are present by the
31 * time controller driver registration causes spi_devices to "enumerate".
33 static void spidev_release(struct device *dev)
35 struct spi_device *spi = to_spi_device(dev);
37 /* spi masters may cleanup for released devices */
38 if (spi->master->cleanup)
39 spi->master->cleanup(spi);
41 spi_master_put(spi->master);
42 kfree(dev);
45 static ssize_t
46 modalias_show(struct device *dev, struct device_attribute *a, char *buf)
48 const struct spi_device *spi = to_spi_device(dev);
50 return sprintf(buf, "%s\n", spi->modalias);
53 static struct device_attribute spi_dev_attrs[] = {
54 __ATTR_RO(modalias),
55 __ATTR_NULL,
58 /* modalias support makes "modprobe $MODALIAS" new-style hotplug work,
59 * and the sysfs version makes coldplug work too.
62 static int spi_match_device(struct device *dev, struct device_driver *drv)
64 const struct spi_device *spi = to_spi_device(dev);
66 return strcmp(spi->modalias, drv->name) == 0;
69 static int spi_uevent(struct device *dev, struct kobj_uevent_env *env)
71 const struct spi_device *spi = to_spi_device(dev);
73 add_uevent_var(env, "MODALIAS=%s", spi->modalias);
74 return 0;
77 #ifdef CONFIG_PM
79 static int spi_suspend(struct device *dev, pm_message_t message)
81 int value = 0;
82 struct spi_driver *drv = to_spi_driver(dev->driver);
84 /* suspend will stop irqs and dma; no more i/o */
85 if (drv) {
86 if (drv->suspend)
87 value = drv->suspend(to_spi_device(dev), message);
88 else
89 dev_dbg(dev, "... can't suspend\n");
91 return value;
94 static int spi_resume(struct device *dev)
96 int value = 0;
97 struct spi_driver *drv = to_spi_driver(dev->driver);
99 /* resume may restart the i/o queue */
100 if (drv) {
101 if (drv->resume)
102 value = drv->resume(to_spi_device(dev));
103 else
104 dev_dbg(dev, "... can't resume\n");
106 return value;
109 #else
110 #define spi_suspend NULL
111 #define spi_resume NULL
112 #endif
114 struct bus_type spi_bus_type = {
115 .name = "spi",
116 .dev_attrs = spi_dev_attrs,
117 .match = spi_match_device,
118 .uevent = spi_uevent,
119 .suspend = spi_suspend,
120 .resume = spi_resume,
122 EXPORT_SYMBOL_GPL(spi_bus_type);
125 static int spi_drv_probe(struct device *dev)
127 const struct spi_driver *sdrv = to_spi_driver(dev->driver);
129 return sdrv->probe(to_spi_device(dev));
132 static int spi_drv_remove(struct device *dev)
134 const struct spi_driver *sdrv = to_spi_driver(dev->driver);
136 return sdrv->remove(to_spi_device(dev));
139 static void spi_drv_shutdown(struct device *dev)
141 const struct spi_driver *sdrv = to_spi_driver(dev->driver);
143 sdrv->shutdown(to_spi_device(dev));
147 * spi_register_driver - register a SPI driver
148 * @sdrv: the driver to register
149 * Context: can sleep
151 int spi_register_driver(struct spi_driver *sdrv)
153 sdrv->driver.bus = &spi_bus_type;
154 if (sdrv->probe)
155 sdrv->driver.probe = spi_drv_probe;
156 if (sdrv->remove)
157 sdrv->driver.remove = spi_drv_remove;
158 if (sdrv->shutdown)
159 sdrv->driver.shutdown = spi_drv_shutdown;
160 return driver_register(&sdrv->driver);
162 EXPORT_SYMBOL_GPL(spi_register_driver);
164 /*-------------------------------------------------------------------------*/
166 /* SPI devices should normally not be created by SPI device drivers; that
167 * would make them board-specific. Similarly with SPI master drivers.
168 * Device registration normally goes into like arch/.../mach.../board-YYY.c
169 * with other readonly (flashable) information about mainboard devices.
172 struct boardinfo {
173 struct list_head list;
174 unsigned n_board_info;
175 struct spi_board_info board_info[0];
178 static LIST_HEAD(board_list);
179 static DEFINE_MUTEX(board_lock);
182 * spi_alloc_device - Allocate a new SPI device
183 * @master: Controller to which device is connected
184 * Context: can sleep
186 * Allows a driver to allocate and initialize a spi_device without
187 * registering it immediately. This allows a driver to directly
188 * fill the spi_device with device parameters before calling
189 * spi_add_device() on it.
191 * Caller is responsible to call spi_add_device() on the returned
192 * spi_device structure to add it to the SPI master. If the caller
193 * needs to discard the spi_device without adding it, then it should
194 * call spi_dev_put() on it.
196 * Returns a pointer to the new device, or NULL.
198 struct spi_device *spi_alloc_device(struct spi_master *master)
200 struct spi_device *spi;
201 struct device *dev = master->dev.parent;
203 if (!spi_master_get(master))
204 return NULL;
206 spi = kzalloc(sizeof *spi, GFP_KERNEL);
207 if (!spi) {
208 dev_err(dev, "cannot alloc spi_device\n");
209 spi_master_put(master);
210 return NULL;
213 spi->master = master;
214 spi->dev.parent = dev;
215 spi->dev.bus = &spi_bus_type;
216 spi->dev.release = spidev_release;
217 device_initialize(&spi->dev);
218 return spi;
220 EXPORT_SYMBOL_GPL(spi_alloc_device);
223 * spi_add_device - Add spi_device allocated with spi_alloc_device
224 * @spi: spi_device to register
226 * Companion function to spi_alloc_device. Devices allocated with
227 * spi_alloc_device can be added onto the spi bus with this function.
229 * Returns 0 on success; negative errno on failure
231 int spi_add_device(struct spi_device *spi)
233 static DEFINE_MUTEX(spi_add_lock);
234 struct device *dev = spi->master->dev.parent;
235 int status;
237 /* Chipselects are numbered 0..max; validate. */
238 if (spi->chip_select >= spi->master->num_chipselect) {
239 dev_err(dev, "cs%d >= max %d\n",
240 spi->chip_select,
241 spi->master->num_chipselect);
242 return -EINVAL;
245 /* Set the bus ID string */
246 dev_set_name(&spi->dev, "%s.%u", dev_name(&spi->master->dev),
247 spi->chip_select);
250 /* We need to make sure there's no other device with this
251 * chipselect **BEFORE** we call setup(), else we'll trash
252 * its configuration. Lock against concurrent add() calls.
254 mutex_lock(&spi_add_lock);
256 if (bus_find_device_by_name(&spi_bus_type, NULL, dev_name(&spi->dev))
257 != NULL) {
258 dev_err(dev, "chipselect %d already in use\n",
259 spi->chip_select);
260 status = -EBUSY;
261 goto done;
264 /* Drivers may modify this initial i/o setup, but will
265 * normally rely on the device being setup. Devices
266 * using SPI_CS_HIGH can't coexist well otherwise...
268 status = spi->master->setup(spi);
269 if (status < 0) {
270 dev_err(dev, "can't %s %s, status %d\n",
271 "setup", dev_name(&spi->dev), status);
272 goto done;
275 /* Device may be bound to an active driver when this returns */
276 status = device_add(&spi->dev);
277 if (status < 0)
278 dev_err(dev, "can't %s %s, status %d\n",
279 "add", dev_name(&spi->dev), status);
280 else
281 dev_dbg(dev, "registered child %s\n", dev_name(&spi->dev));
283 done:
284 mutex_unlock(&spi_add_lock);
285 return status;
287 EXPORT_SYMBOL_GPL(spi_add_device);
290 * spi_new_device - instantiate one new SPI device
291 * @master: Controller to which device is connected
292 * @chip: Describes the SPI device
293 * Context: can sleep
295 * On typical mainboards, this is purely internal; and it's not needed
296 * after board init creates the hard-wired devices. Some development
297 * platforms may not be able to use spi_register_board_info though, and
298 * this is exported so that for example a USB or parport based adapter
299 * driver could add devices (which it would learn about out-of-band).
301 * Returns the new device, or NULL.
303 struct spi_device *spi_new_device(struct spi_master *master,
304 struct spi_board_info *chip)
306 struct spi_device *proxy;
307 int status;
309 /* NOTE: caller did any chip->bus_num checks necessary.
311 * Also, unless we change the return value convention to use
312 * error-or-pointer (not NULL-or-pointer), troubleshootability
313 * suggests syslogged diagnostics are best here (ugh).
316 proxy = spi_alloc_device(master);
317 if (!proxy)
318 return NULL;
320 WARN_ON(strlen(chip->modalias) >= sizeof(proxy->modalias));
322 proxy->chip_select = chip->chip_select;
323 proxy->max_speed_hz = chip->max_speed_hz;
324 proxy->mode = chip->mode;
325 proxy->irq = chip->irq;
326 strlcpy(proxy->modalias, chip->modalias, sizeof(proxy->modalias));
327 proxy->dev.platform_data = (void *) chip->platform_data;
328 proxy->controller_data = chip->controller_data;
329 proxy->controller_state = NULL;
331 status = spi_add_device(proxy);
332 if (status < 0) {
333 spi_dev_put(proxy);
334 return NULL;
337 return proxy;
339 EXPORT_SYMBOL_GPL(spi_new_device);
342 * spi_register_board_info - register SPI devices for a given board
343 * @info: array of chip descriptors
344 * @n: how many descriptors are provided
345 * Context: can sleep
347 * Board-specific early init code calls this (probably during arch_initcall)
348 * with segments of the SPI device table. Any device nodes are created later,
349 * after the relevant parent SPI controller (bus_num) is defined. We keep
350 * this table of devices forever, so that reloading a controller driver will
351 * not make Linux forget about these hard-wired devices.
353 * Other code can also call this, e.g. a particular add-on board might provide
354 * SPI devices through its expansion connector, so code initializing that board
355 * would naturally declare its SPI devices.
357 * The board info passed can safely be __initdata ... but be careful of
358 * any embedded pointers (platform_data, etc), they're copied as-is.
360 int __init
361 spi_register_board_info(struct spi_board_info const *info, unsigned n)
363 struct boardinfo *bi;
365 bi = kmalloc(sizeof(*bi) + n * sizeof *info, GFP_KERNEL);
366 if (!bi)
367 return -ENOMEM;
368 bi->n_board_info = n;
369 memcpy(bi->board_info, info, n * sizeof *info);
371 mutex_lock(&board_lock);
372 list_add_tail(&bi->list, &board_list);
373 mutex_unlock(&board_lock);
374 return 0;
377 /* FIXME someone should add support for a __setup("spi", ...) that
378 * creates board info from kernel command lines
381 static void scan_boardinfo(struct spi_master *master)
383 struct boardinfo *bi;
385 mutex_lock(&board_lock);
386 list_for_each_entry(bi, &board_list, list) {
387 struct spi_board_info *chip = bi->board_info;
388 unsigned n;
390 for (n = bi->n_board_info; n > 0; n--, chip++) {
391 if (chip->bus_num != master->bus_num)
392 continue;
393 /* NOTE: this relies on spi_new_device to
394 * issue diagnostics when given bogus inputs
396 (void) spi_new_device(master, chip);
399 mutex_unlock(&board_lock);
402 /*-------------------------------------------------------------------------*/
404 static void spi_master_release(struct device *dev)
406 struct spi_master *master;
408 master = container_of(dev, struct spi_master, dev);
409 kfree(master);
412 static struct class spi_master_class = {
413 .name = "spi_master",
414 .owner = THIS_MODULE,
415 .dev_release = spi_master_release,
420 * spi_alloc_master - allocate SPI master controller
421 * @dev: the controller, possibly using the platform_bus
422 * @size: how much zeroed driver-private data to allocate; the pointer to this
423 * memory is in the driver_data field of the returned device,
424 * accessible with spi_master_get_devdata().
425 * Context: can sleep
427 * This call is used only by SPI master controller drivers, which are the
428 * only ones directly touching chip registers. It's how they allocate
429 * an spi_master structure, prior to calling spi_register_master().
431 * This must be called from context that can sleep. It returns the SPI
432 * master structure on success, else NULL.
434 * The caller is responsible for assigning the bus number and initializing
435 * the master's methods before calling spi_register_master(); and (after errors
436 * adding the device) calling spi_master_put() to prevent a memory leak.
438 struct spi_master *spi_alloc_master(struct device *dev, unsigned size)
440 struct spi_master *master;
442 if (!dev)
443 return NULL;
445 master = kzalloc(size + sizeof *master, GFP_KERNEL);
446 if (!master)
447 return NULL;
449 device_initialize(&master->dev);
450 master->dev.class = &spi_master_class;
451 master->dev.parent = get_device(dev);
452 spi_master_set_devdata(master, &master[1]);
454 return master;
456 EXPORT_SYMBOL_GPL(spi_alloc_master);
459 * spi_register_master - register SPI master controller
460 * @master: initialized master, originally from spi_alloc_master()
461 * Context: can sleep
463 * SPI master controllers connect to their drivers using some non-SPI bus,
464 * such as the platform bus. The final stage of probe() in that code
465 * includes calling spi_register_master() to hook up to this SPI bus glue.
467 * SPI controllers use board specific (often SOC specific) bus numbers,
468 * and board-specific addressing for SPI devices combines those numbers
469 * with chip select numbers. Since SPI does not directly support dynamic
470 * device identification, boards need configuration tables telling which
471 * chip is at which address.
473 * This must be called from context that can sleep. It returns zero on
474 * success, else a negative error code (dropping the master's refcount).
475 * After a successful return, the caller is responsible for calling
476 * spi_unregister_master().
478 int spi_register_master(struct spi_master *master)
480 static atomic_t dyn_bus_id = ATOMIC_INIT((1<<15) - 1);
481 struct device *dev = master->dev.parent;
482 int status = -ENODEV;
483 int dynamic = 0;
485 if (!dev)
486 return -ENODEV;
488 /* even if it's just one always-selected device, there must
489 * be at least one chipselect
491 if (master->num_chipselect == 0)
492 return -EINVAL;
494 /* convention: dynamically assigned bus IDs count down from the max */
495 if (master->bus_num < 0) {
496 /* FIXME switch to an IDR based scheme, something like
497 * I2C now uses, so we can't run out of "dynamic" IDs
499 master->bus_num = atomic_dec_return(&dyn_bus_id);
500 dynamic = 1;
503 /* register the device, then userspace will see it.
504 * registration fails if the bus ID is in use.
506 dev_set_name(&master->dev, "spi%u", master->bus_num);
507 status = device_add(&master->dev);
508 if (status < 0)
509 goto done;
510 dev_dbg(dev, "registered master %s%s\n", dev_name(&master->dev),
511 dynamic ? " (dynamic)" : "");
513 /* populate children from any spi device tables */
514 scan_boardinfo(master);
515 status = 0;
516 done:
517 return status;
519 EXPORT_SYMBOL_GPL(spi_register_master);
522 static int __unregister(struct device *dev, void *master_dev)
524 /* note: before about 2.6.14-rc1 this would corrupt memory: */
525 if (dev != master_dev)
526 spi_unregister_device(to_spi_device(dev));
527 return 0;
531 * spi_unregister_master - unregister SPI master controller
532 * @master: the master being unregistered
533 * Context: can sleep
535 * This call is used only by SPI master controller drivers, which are the
536 * only ones directly touching chip registers.
538 * This must be called from context that can sleep.
540 void spi_unregister_master(struct spi_master *master)
542 int dummy;
544 dummy = device_for_each_child(master->dev.parent, &master->dev,
545 __unregister);
546 device_unregister(&master->dev);
548 EXPORT_SYMBOL_GPL(spi_unregister_master);
550 static int __spi_master_match(struct device *dev, void *data)
552 struct spi_master *m;
553 u16 *bus_num = data;
555 m = container_of(dev, struct spi_master, dev);
556 return m->bus_num == *bus_num;
560 * spi_busnum_to_master - look up master associated with bus_num
561 * @bus_num: the master's bus number
562 * Context: can sleep
564 * This call may be used with devices that are registered after
565 * arch init time. It returns a refcounted pointer to the relevant
566 * spi_master (which the caller must release), or NULL if there is
567 * no such master registered.
569 struct spi_master *spi_busnum_to_master(u16 bus_num)
571 struct device *dev;
572 struct spi_master *master = NULL;
574 dev = class_find_device(&spi_master_class, NULL, &bus_num,
575 __spi_master_match);
576 if (dev)
577 master = container_of(dev, struct spi_master, dev);
578 /* reference got in class_find_device */
579 return master;
581 EXPORT_SYMBOL_GPL(spi_busnum_to_master);
584 /*-------------------------------------------------------------------------*/
586 static void spi_complete(void *arg)
588 complete(arg);
592 * spi_sync - blocking/synchronous SPI data transfers
593 * @spi: device with which data will be exchanged
594 * @message: describes the data transfers
595 * Context: can sleep
597 * This call may only be used from a context that may sleep. The sleep
598 * is non-interruptible, and has no timeout. Low-overhead controller
599 * drivers may DMA directly into and out of the message buffers.
601 * Note that the SPI device's chip select is active during the message,
602 * and then is normally disabled between messages. Drivers for some
603 * frequently-used devices may want to minimize costs of selecting a chip,
604 * by leaving it selected in anticipation that the next message will go
605 * to the same chip. (That may increase power usage.)
607 * Also, the caller is guaranteeing that the memory associated with the
608 * message will not be freed before this call returns.
610 * It returns zero on success, else a negative error code.
612 int spi_sync(struct spi_device *spi, struct spi_message *message)
614 DECLARE_COMPLETION_ONSTACK(done);
615 int status;
617 message->complete = spi_complete;
618 message->context = &done;
619 status = spi_async(spi, message);
620 if (status == 0) {
621 wait_for_completion(&done);
622 status = message->status;
624 message->context = NULL;
625 return status;
627 EXPORT_SYMBOL_GPL(spi_sync);
629 /* portable code must never pass more than 32 bytes */
630 #define SPI_BUFSIZ max(32,SMP_CACHE_BYTES)
632 static u8 *buf;
635 * spi_write_then_read - SPI synchronous write followed by read
636 * @spi: device with which data will be exchanged
637 * @txbuf: data to be written (need not be dma-safe)
638 * @n_tx: size of txbuf, in bytes
639 * @rxbuf: buffer into which data will be read
640 * @n_rx: size of rxbuf, in bytes (need not be dma-safe)
641 * Context: can sleep
643 * This performs a half duplex MicroWire style transaction with the
644 * device, sending txbuf and then reading rxbuf. The return value
645 * is zero for success, else a negative errno status code.
646 * This call may only be used from a context that may sleep.
648 * Parameters to this routine are always copied using a small buffer;
649 * portable code should never use this for more than 32 bytes.
650 * Performance-sensitive or bulk transfer code should instead use
651 * spi_{async,sync}() calls with dma-safe buffers.
653 int spi_write_then_read(struct spi_device *spi,
654 const u8 *txbuf, unsigned n_tx,
655 u8 *rxbuf, unsigned n_rx)
657 static DEFINE_MUTEX(lock);
659 int status;
660 struct spi_message message;
661 struct spi_transfer x[2];
662 u8 *local_buf;
664 /* Use preallocated DMA-safe buffer. We can't avoid copying here,
665 * (as a pure convenience thing), but we can keep heap costs
666 * out of the hot path ...
668 if ((n_tx + n_rx) > SPI_BUFSIZ)
669 return -EINVAL;
671 spi_message_init(&message);
672 memset(x, 0, sizeof x);
673 if (n_tx) {
674 x[0].len = n_tx;
675 spi_message_add_tail(&x[0], &message);
677 if (n_rx) {
678 x[1].len = n_rx;
679 spi_message_add_tail(&x[1], &message);
682 /* ... unless someone else is using the pre-allocated buffer */
683 if (!mutex_trylock(&lock)) {
684 local_buf = kmalloc(SPI_BUFSIZ, GFP_KERNEL);
685 if (!local_buf)
686 return -ENOMEM;
687 } else
688 local_buf = buf;
690 memcpy(local_buf, txbuf, n_tx);
691 x[0].tx_buf = local_buf;
692 x[1].rx_buf = local_buf + n_tx;
694 /* do the i/o */
695 status = spi_sync(spi, &message);
696 if (status == 0)
697 memcpy(rxbuf, x[1].rx_buf, n_rx);
699 if (x[0].tx_buf == buf)
700 mutex_unlock(&lock);
701 else
702 kfree(local_buf);
704 return status;
706 EXPORT_SYMBOL_GPL(spi_write_then_read);
708 /*-------------------------------------------------------------------------*/
710 static int __init spi_init(void)
712 int status;
714 buf = kmalloc(SPI_BUFSIZ, GFP_KERNEL);
715 if (!buf) {
716 status = -ENOMEM;
717 goto err0;
720 status = bus_register(&spi_bus_type);
721 if (status < 0)
722 goto err1;
724 status = class_register(&spi_master_class);
725 if (status < 0)
726 goto err2;
727 return 0;
729 err2:
730 bus_unregister(&spi_bus_type);
731 err1:
732 kfree(buf);
733 buf = NULL;
734 err0:
735 return status;
738 /* board_info is normally registered in arch_initcall(),
739 * but even essential drivers wait till later
741 * REVISIT only boardinfo really needs static linking. the rest (device and
742 * driver registration) _could_ be dynamically linked (modular) ... costs
743 * include needing to have boardinfo data structures be much more public.
745 postcore_initcall(spi_init);