some kmalloc/memset ->kzalloc (tree wide)
[linux-2.6.git] / drivers / spi / spi.c
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/mutex.h>
27 #include <linux/spi/spi.h>
28
29
30 /* SPI bustype and spi_master class are registered after board init code
31  * provides the SPI device tables, ensuring that both are present by the
32  * time controller driver registration causes spi_devices to "enumerate".
33  */
34 static void spidev_release(struct device *dev)
35 {
36         struct spi_device       *spi = to_spi_device(dev);
37
38         /* spi masters may cleanup for released devices */
39         if (spi->master->cleanup)
40                 spi->master->cleanup(spi);
41
42         spi_master_put(spi->master);
43         kfree(dev);
44 }
45
46 static ssize_t
47 modalias_show(struct device *dev, struct device_attribute *a, char *buf)
48 {
49         const struct spi_device *spi = to_spi_device(dev);
50
51         return snprintf(buf, BUS_ID_SIZE + 1, "%s\n", spi->modalias);
52 }
53
54 static struct device_attribute spi_dev_attrs[] = {
55         __ATTR_RO(modalias),
56         __ATTR_NULL,
57 };
58
59 /* modalias support makes "modprobe $MODALIAS" new-style hotplug work,
60  * and the sysfs version makes coldplug work too.
61  */
62
63 static int spi_match_device(struct device *dev, struct device_driver *drv)
64 {
65         const struct spi_device *spi = to_spi_device(dev);
66
67         return strncmp(spi->modalias, drv->name, BUS_ID_SIZE) == 0;
68 }
69
70 static int spi_uevent(struct device *dev, char **envp, int num_envp,
71                 char *buffer, int buffer_size)
72 {
73         const struct spi_device         *spi = to_spi_device(dev);
74
75         envp[0] = buffer;
76         snprintf(buffer, buffer_size, "MODALIAS=%s", spi->modalias);
77         envp[1] = NULL;
78         return 0;
79 }
80
81 #ifdef  CONFIG_PM
82
83 /*
84  * NOTE:  the suspend() method for an spi_master controller driver
85  * should verify that all its child devices are marked as suspended;
86  * suspend requests delivered through sysfs power/state files don't
87  * enforce such constraints.
88  */
89 static int spi_suspend(struct device *dev, pm_message_t message)
90 {
91         int                     value;
92         struct spi_driver       *drv = to_spi_driver(dev->driver);
93
94         if (!drv || !drv->suspend)
95                 return 0;
96
97         /* suspend will stop irqs and dma; no more i/o */
98         value = drv->suspend(to_spi_device(dev), message);
99         if (value == 0)
100                 dev->power.power_state = message;
101         return value;
102 }
103
104 static int spi_resume(struct device *dev)
105 {
106         int                     value;
107         struct spi_driver       *drv = to_spi_driver(dev->driver);
108
109         if (!drv || !drv->resume)
110                 return 0;
111
112         /* resume may restart the i/o queue */
113         value = drv->resume(to_spi_device(dev));
114         if (value == 0)
115                 dev->power.power_state = PMSG_ON;
116         return value;
117 }
118
119 #else
120 #define spi_suspend     NULL
121 #define spi_resume      NULL
122 #endif
123
124 struct bus_type spi_bus_type = {
125         .name           = "spi",
126         .dev_attrs      = spi_dev_attrs,
127         .match          = spi_match_device,
128         .uevent         = spi_uevent,
129         .suspend        = spi_suspend,
130         .resume         = spi_resume,
131 };
132 EXPORT_SYMBOL_GPL(spi_bus_type);
133
134
135 static int spi_drv_probe(struct device *dev)
136 {
137         const struct spi_driver         *sdrv = to_spi_driver(dev->driver);
138
139         return sdrv->probe(to_spi_device(dev));
140 }
141
142 static int spi_drv_remove(struct device *dev)
143 {
144         const struct spi_driver         *sdrv = to_spi_driver(dev->driver);
145
146         return sdrv->remove(to_spi_device(dev));
147 }
148
149 static void spi_drv_shutdown(struct device *dev)
150 {
151         const struct spi_driver         *sdrv = to_spi_driver(dev->driver);
152
153         sdrv->shutdown(to_spi_device(dev));
154 }
155
156 /**
157  * spi_register_driver - register a SPI driver
158  * @sdrv: the driver to register
159  * Context: can sleep
160  */
161 int spi_register_driver(struct spi_driver *sdrv)
162 {
163         sdrv->driver.bus = &spi_bus_type;
164         if (sdrv->probe)
165                 sdrv->driver.probe = spi_drv_probe;
166         if (sdrv->remove)
167                 sdrv->driver.remove = spi_drv_remove;
168         if (sdrv->shutdown)
169                 sdrv->driver.shutdown = spi_drv_shutdown;
170         return driver_register(&sdrv->driver);
171 }
172 EXPORT_SYMBOL_GPL(spi_register_driver);
173
174 /*-------------------------------------------------------------------------*/
175
176 /* SPI devices should normally not be created by SPI device drivers; that
177  * would make them board-specific.  Similarly with SPI master drivers.
178  * Device registration normally goes into like arch/.../mach.../board-YYY.c
179  * with other readonly (flashable) information about mainboard devices.
180  */
181
182 struct boardinfo {
183         struct list_head        list;
184         unsigned                n_board_info;
185         struct spi_board_info   board_info[0];
186 };
187
188 static LIST_HEAD(board_list);
189 static DEFINE_MUTEX(board_lock);
190
191
192 /**
193  * spi_new_device - instantiate one new SPI device
194  * @master: Controller to which device is connected
195  * @chip: Describes the SPI device
196  * Context: can sleep
197  *
198  * On typical mainboards, this is purely internal; and it's not needed
199  * after board init creates the hard-wired devices.  Some development
200  * platforms may not be able to use spi_register_board_info though, and
201  * this is exported so that for example a USB or parport based adapter
202  * driver could add devices (which it would learn about out-of-band).
203  */
204 struct spi_device *spi_new_device(struct spi_master *master,
205                                   struct spi_board_info *chip)
206 {
207         struct spi_device       *proxy;
208         struct device           *dev = master->cdev.dev;
209         int                     status;
210
211         /* NOTE:  caller did any chip->bus_num checks necessary */
212
213         if (!spi_master_get(master))
214                 return NULL;
215
216         proxy = kzalloc(sizeof *proxy, GFP_KERNEL);
217         if (!proxy) {
218                 dev_err(dev, "can't alloc dev for cs%d\n",
219                         chip->chip_select);
220                 goto fail;
221         }
222         proxy->master = master;
223         proxy->chip_select = chip->chip_select;
224         proxy->max_speed_hz = chip->max_speed_hz;
225         proxy->mode = chip->mode;
226         proxy->irq = chip->irq;
227         proxy->modalias = chip->modalias;
228
229         snprintf(proxy->dev.bus_id, sizeof proxy->dev.bus_id,
230                         "%s.%u", master->cdev.class_id,
231                         chip->chip_select);
232         proxy->dev.parent = dev;
233         proxy->dev.bus = &spi_bus_type;
234         proxy->dev.platform_data = (void *) chip->platform_data;
235         proxy->controller_data = chip->controller_data;
236         proxy->controller_state = NULL;
237         proxy->dev.release = spidev_release;
238
239         /* drivers may modify this default i/o setup */
240         status = master->setup(proxy);
241         if (status < 0) {
242                 dev_dbg(dev, "can't %s %s, status %d\n",
243                                 "setup", proxy->dev.bus_id, status);
244                 goto fail;
245         }
246
247         /* driver core catches callers that misbehave by defining
248          * devices that already exist.
249          */
250         status = device_register(&proxy->dev);
251         if (status < 0) {
252                 dev_dbg(dev, "can't %s %s, status %d\n",
253                                 "add", proxy->dev.bus_id, status);
254                 goto fail;
255         }
256         dev_dbg(dev, "registered child %s\n", proxy->dev.bus_id);
257         return proxy;
258
259 fail:
260         spi_master_put(master);
261         kfree(proxy);
262         return NULL;
263 }
264 EXPORT_SYMBOL_GPL(spi_new_device);
265
266 /**
267  * spi_register_board_info - register SPI devices for a given board
268  * @info: array of chip descriptors
269  * @n: how many descriptors are provided
270  * Context: can sleep
271  *
272  * Board-specific early init code calls this (probably during arch_initcall)
273  * with segments of the SPI device table.  Any device nodes are created later,
274  * after the relevant parent SPI controller (bus_num) is defined.  We keep
275  * this table of devices forever, so that reloading a controller driver will
276  * not make Linux forget about these hard-wired devices.
277  *
278  * Other code can also call this, e.g. a particular add-on board might provide
279  * SPI devices through its expansion connector, so code initializing that board
280  * would naturally declare its SPI devices.
281  *
282  * The board info passed can safely be __initdata ... but be careful of
283  * any embedded pointers (platform_data, etc), they're copied as-is.
284  */
285 int __init
286 spi_register_board_info(struct spi_board_info const *info, unsigned n)
287 {
288         struct boardinfo        *bi;
289
290         bi = kmalloc(sizeof(*bi) + n * sizeof *info, GFP_KERNEL);
291         if (!bi)
292                 return -ENOMEM;
293         bi->n_board_info = n;
294         memcpy(bi->board_info, info, n * sizeof *info);
295
296         mutex_lock(&board_lock);
297         list_add_tail(&bi->list, &board_list);
298         mutex_unlock(&board_lock);
299         return 0;
300 }
301
302 /* FIXME someone should add support for a __setup("spi", ...) that
303  * creates board info from kernel command lines
304  */
305
306 static void __init_or_module
307 scan_boardinfo(struct spi_master *master)
308 {
309         struct boardinfo        *bi;
310         struct device           *dev = master->cdev.dev;
311
312         mutex_lock(&board_lock);
313         list_for_each_entry(bi, &board_list, list) {
314                 struct spi_board_info   *chip = bi->board_info;
315                 unsigned                n;
316
317                 for (n = bi->n_board_info; n > 0; n--, chip++) {
318                         if (chip->bus_num != master->bus_num)
319                                 continue;
320                         /* some controllers only have one chip, so they
321                          * might not use chipselects.  otherwise, the
322                          * chipselects are numbered 0..max.
323                          */
324                         if (chip->chip_select >= master->num_chipselect
325                                         && master->num_chipselect) {
326                                 dev_dbg(dev, "cs%d > max %d\n",
327                                         chip->chip_select,
328                                         master->num_chipselect);
329                                 continue;
330                         }
331                         (void) spi_new_device(master, chip);
332                 }
333         }
334         mutex_unlock(&board_lock);
335 }
336
337 /*-------------------------------------------------------------------------*/
338
339 static void spi_master_release(struct class_device *cdev)
340 {
341         struct spi_master *master;
342
343         master = container_of(cdev, struct spi_master, cdev);
344         kfree(master);
345 }
346
347 static struct class spi_master_class = {
348         .name           = "spi_master",
349         .owner          = THIS_MODULE,
350         .release        = spi_master_release,
351 };
352
353
354 /**
355  * spi_alloc_master - allocate SPI master controller
356  * @dev: the controller, possibly using the platform_bus
357  * @size: how much zeroed driver-private data to allocate; the pointer to this
358  *      memory is in the class_data field of the returned class_device,
359  *      accessible with spi_master_get_devdata().
360  * Context: can sleep
361  *
362  * This call is used only by SPI master controller drivers, which are the
363  * only ones directly touching chip registers.  It's how they allocate
364  * an spi_master structure, prior to calling spi_register_master().
365  *
366  * This must be called from context that can sleep.  It returns the SPI
367  * master structure on success, else NULL.
368  *
369  * The caller is responsible for assigning the bus number and initializing
370  * the master's methods before calling spi_register_master(); and (after errors
371  * adding the device) calling spi_master_put() to prevent a memory leak.
372  */
373 struct spi_master *spi_alloc_master(struct device *dev, unsigned size)
374 {
375         struct spi_master       *master;
376
377         if (!dev)
378                 return NULL;
379
380         master = kzalloc(size + sizeof *master, GFP_KERNEL);
381         if (!master)
382                 return NULL;
383
384         class_device_initialize(&master->cdev);
385         master->cdev.class = &spi_master_class;
386         master->cdev.dev = get_device(dev);
387         spi_master_set_devdata(master, &master[1]);
388
389         return master;
390 }
391 EXPORT_SYMBOL_GPL(spi_alloc_master);
392
393 /**
394  * spi_register_master - register SPI master controller
395  * @master: initialized master, originally from spi_alloc_master()
396  * Context: can sleep
397  *
398  * SPI master controllers connect to their drivers using some non-SPI bus,
399  * such as the platform bus.  The final stage of probe() in that code
400  * includes calling spi_register_master() to hook up to this SPI bus glue.
401  *
402  * SPI controllers use board specific (often SOC specific) bus numbers,
403  * and board-specific addressing for SPI devices combines those numbers
404  * with chip select numbers.  Since SPI does not directly support dynamic
405  * device identification, boards need configuration tables telling which
406  * chip is at which address.
407  *
408  * This must be called from context that can sleep.  It returns zero on
409  * success, else a negative error code (dropping the master's refcount).
410  * After a successful return, the caller is responsible for calling
411  * spi_unregister_master().
412  */
413 int spi_register_master(struct spi_master *master)
414 {
415         static atomic_t         dyn_bus_id = ATOMIC_INIT((1<<15) - 1);
416         struct device           *dev = master->cdev.dev;
417         int                     status = -ENODEV;
418         int                     dynamic = 0;
419
420         if (!dev)
421                 return -ENODEV;
422
423         /* convention:  dynamically assigned bus IDs count down from the max */
424         if (master->bus_num < 0) {
425                 master->bus_num = atomic_dec_return(&dyn_bus_id);
426                 dynamic = 1;
427         }
428
429         /* register the device, then userspace will see it.
430          * registration fails if the bus ID is in use.
431          */
432         snprintf(master->cdev.class_id, sizeof master->cdev.class_id,
433                 "spi%u", master->bus_num);
434         status = class_device_add(&master->cdev);
435         if (status < 0)
436                 goto done;
437         dev_dbg(dev, "registered master %s%s\n", master->cdev.class_id,
438                         dynamic ? " (dynamic)" : "");
439
440         /* populate children from any spi device tables */
441         scan_boardinfo(master);
442         status = 0;
443 done:
444         return status;
445 }
446 EXPORT_SYMBOL_GPL(spi_register_master);
447
448
449 static int __unregister(struct device *dev, void *unused)
450 {
451         /* note: before about 2.6.14-rc1 this would corrupt memory: */
452         spi_unregister_device(to_spi_device(dev));
453         return 0;
454 }
455
456 /**
457  * spi_unregister_master - unregister SPI master controller
458  * @master: the master being unregistered
459  * Context: can sleep
460  *
461  * This call is used only by SPI master controller drivers, which are the
462  * only ones directly touching chip registers.
463  *
464  * This must be called from context that can sleep.
465  */
466 void spi_unregister_master(struct spi_master *master)
467 {
468         int dummy;
469
470         dummy = device_for_each_child(master->cdev.dev, NULL, __unregister);
471         class_device_unregister(&master->cdev);
472 }
473 EXPORT_SYMBOL_GPL(spi_unregister_master);
474
475 /**
476  * spi_busnum_to_master - look up master associated with bus_num
477  * @bus_num: the master's bus number
478  * Context: can sleep
479  *
480  * This call may be used with devices that are registered after
481  * arch init time.  It returns a refcounted pointer to the relevant
482  * spi_master (which the caller must release), or NULL if there is
483  * no such master registered.
484  */
485 struct spi_master *spi_busnum_to_master(u16 bus_num)
486 {
487         struct class_device     *cdev;
488         struct spi_master       *master = NULL;
489         struct spi_master       *m;
490
491         down(&spi_master_class.sem);
492         list_for_each_entry(cdev, &spi_master_class.children, node) {
493                 m = container_of(cdev, struct spi_master, cdev);
494                 if (m->bus_num == bus_num) {
495                         master = spi_master_get(m);
496                         break;
497                 }
498         }
499         up(&spi_master_class.sem);
500         return master;
501 }
502 EXPORT_SYMBOL_GPL(spi_busnum_to_master);
503
504
505 /*-------------------------------------------------------------------------*/
506
507 static void spi_complete(void *arg)
508 {
509         complete(arg);
510 }
511
512 /**
513  * spi_sync - blocking/synchronous SPI data transfers
514  * @spi: device with which data will be exchanged
515  * @message: describes the data transfers
516  * Context: can sleep
517  *
518  * This call may only be used from a context that may sleep.  The sleep
519  * is non-interruptible, and has no timeout.  Low-overhead controller
520  * drivers may DMA directly into and out of the message buffers.
521  *
522  * Note that the SPI device's chip select is active during the message,
523  * and then is normally disabled between messages.  Drivers for some
524  * frequently-used devices may want to minimize costs of selecting a chip,
525  * by leaving it selected in anticipation that the next message will go
526  * to the same chip.  (That may increase power usage.)
527  *
528  * Also, the caller is guaranteeing that the memory associated with the
529  * message will not be freed before this call returns.
530  *
531  * The return value is a negative error code if the message could not be
532  * submitted, else zero.  When the value is zero, then message->status is
533  * also defined;  it's the completion code for the transfer, either zero
534  * or a negative error code from the controller driver.
535  */
536 int spi_sync(struct spi_device *spi, struct spi_message *message)
537 {
538         DECLARE_COMPLETION_ONSTACK(done);
539         int status;
540
541         message->complete = spi_complete;
542         message->context = &done;
543         status = spi_async(spi, message);
544         if (status == 0)
545                 wait_for_completion(&done);
546         message->context = NULL;
547         return status;
548 }
549 EXPORT_SYMBOL_GPL(spi_sync);
550
551 /* portable code must never pass more than 32 bytes */
552 #define SPI_BUFSIZ      max(32,SMP_CACHE_BYTES)
553
554 static u8       *buf;
555
556 /**
557  * spi_write_then_read - SPI synchronous write followed by read
558  * @spi: device with which data will be exchanged
559  * @txbuf: data to be written (need not be dma-safe)
560  * @n_tx: size of txbuf, in bytes
561  * @rxbuf: buffer into which data will be read
562  * @n_rx: size of rxbuf, in bytes (need not be dma-safe)
563  * Context: can sleep
564  *
565  * This performs a half duplex MicroWire style transaction with the
566  * device, sending txbuf and then reading rxbuf.  The return value
567  * is zero for success, else a negative errno status code.
568  * This call may only be used from a context that may sleep.
569  *
570  * Parameters to this routine are always copied using a small buffer;
571  * portable code should never use this for more than 32 bytes.
572  * Performance-sensitive or bulk transfer code should instead use
573  * spi_{async,sync}() calls with dma-safe buffers.
574  */
575 int spi_write_then_read(struct spi_device *spi,
576                 const u8 *txbuf, unsigned n_tx,
577                 u8 *rxbuf, unsigned n_rx)
578 {
579         static DECLARE_MUTEX(lock);
580
581         int                     status;
582         struct spi_message      message;
583         struct spi_transfer     x[2];
584         u8                      *local_buf;
585
586         /* Use preallocated DMA-safe buffer.  We can't avoid copying here,
587          * (as a pure convenience thing), but we can keep heap costs
588          * out of the hot path ...
589          */
590         if ((n_tx + n_rx) > SPI_BUFSIZ)
591                 return -EINVAL;
592
593         spi_message_init(&message);
594         memset(x, 0, sizeof x);
595         if (n_tx) {
596                 x[0].len = n_tx;
597                 spi_message_add_tail(&x[0], &message);
598         }
599         if (n_rx) {
600                 x[1].len = n_rx;
601                 spi_message_add_tail(&x[1], &message);
602         }
603
604         /* ... unless someone else is using the pre-allocated buffer */
605         if (down_trylock(&lock)) {
606                 local_buf = kmalloc(SPI_BUFSIZ, GFP_KERNEL);
607                 if (!local_buf)
608                         return -ENOMEM;
609         } else
610                 local_buf = buf;
611
612         memcpy(local_buf, txbuf, n_tx);
613         x[0].tx_buf = local_buf;
614         x[1].rx_buf = local_buf + n_tx;
615
616         /* do the i/o */
617         status = spi_sync(spi, &message);
618         if (status == 0) {
619                 memcpy(rxbuf, x[1].rx_buf, n_rx);
620                 status = message.status;
621         }
622
623         if (x[0].tx_buf == buf)
624                 up(&lock);
625         else
626                 kfree(local_buf);
627
628         return status;
629 }
630 EXPORT_SYMBOL_GPL(spi_write_then_read);
631
632 /*-------------------------------------------------------------------------*/
633
634 static int __init spi_init(void)
635 {
636         int     status;
637
638         buf = kmalloc(SPI_BUFSIZ, GFP_KERNEL);
639         if (!buf) {
640                 status = -ENOMEM;
641                 goto err0;
642         }
643
644         status = bus_register(&spi_bus_type);
645         if (status < 0)
646                 goto err1;
647
648         status = class_register(&spi_master_class);
649         if (status < 0)
650                 goto err2;
651         return 0;
652
653 err2:
654         bus_unregister(&spi_bus_type);
655 err1:
656         kfree(buf);
657         buf = NULL;
658 err0:
659         return status;
660 }
661
662 /* board_info is normally registered in arch_initcall(),
663  * but even essential drivers wait till later
664  *
665  * REVISIT only boardinfo really needs static linking. the rest (device and
666  * driver registration) _could_ be dynamically linked (modular) ... costs
667  * include needing to have boardinfo data structures be much more public.
668  */
669 subsys_initcall(spi_init);
670