[ALSA] snd-aoa: add snd-aoa
[linux-2.6.git] / sound / aoa / soundbus / i2sbus / i2sbus-core.c
1 /*
2  * i2sbus driver
3  *
4  * Copyright 2006 Johannes Berg <johannes@sipsolutions.net>
5  *
6  * GPL v2, can be found in COPYING.
7  */
8
9 #include <linux/module.h>
10 #include <asm/macio.h>
11 #include <asm/dbdma.h>
12 #include <linux/pci.h>
13 #include <linux/interrupt.h>
14 #include <sound/driver.h>
15 #include <sound/core.h>
16 #include <linux/dma-mapping.h>
17 #include "../soundbus.h"
18 #include "i2sbus.h"
19
20 MODULE_LICENSE("GPL");
21 MODULE_AUTHOR("Johannes Berg <johannes@sipsolutions.net>");
22 MODULE_DESCRIPTION("Apple Soundbus: I2S support");
23 /* for auto-loading, declare that we handle this weird
24  * string that macio puts into the relevant device */
25 MODULE_ALIAS("of:Ni2sTi2sC");
26
27 static struct of_device_id i2sbus_match[] = {
28         { .name = "i2s" },
29         { }
30 };
31
32 static int alloc_dbdma_descriptor_ring(struct i2sbus_dev *i2sdev,
33                                        struct dbdma_command_mem *r,
34                                        int numcmds)
35 {
36         /* one more for rounding */
37         r->size = (numcmds+1) * sizeof(struct dbdma_cmd);
38         /* We use the PCI APIs for now until the generic one gets fixed
39          * enough or until we get some macio-specific versions
40          */
41         r->space = dma_alloc_coherent(
42                         &macio_get_pci_dev(i2sdev->macio)->dev,
43                         r->size,
44                         &r->bus_addr,
45                         GFP_KERNEL);
46
47         if (!r->space) return -ENOMEM;
48
49         memset(r->space, 0, r->size);
50         r->cmds = (void*)DBDMA_ALIGN(r->space);
51         r->bus_cmd_start = r->bus_addr +
52                            (dma_addr_t)((char*)r->cmds - (char*)r->space);
53
54         return 0;
55 }
56
57 static void free_dbdma_descriptor_ring(struct i2sbus_dev *i2sdev,
58                                        struct dbdma_command_mem *r)
59 {
60         if (!r->space) return;
61         
62         dma_free_coherent(&macio_get_pci_dev(i2sdev->macio)->dev,
63                             r->size, r->space, r->bus_addr);
64 }
65
66 static void i2sbus_release_dev(struct device *dev)
67 {
68         struct i2sbus_dev *i2sdev;
69         int i;
70
71         i2sdev = container_of(dev, struct i2sbus_dev, sound.ofdev.dev);
72
73         if (i2sdev->intfregs) iounmap(i2sdev->intfregs);
74         if (i2sdev->out.dbdma) iounmap(i2sdev->out.dbdma);
75         if (i2sdev->in.dbdma) iounmap(i2sdev->in.dbdma);
76         for (i=0;i<3;i++)
77                 if (i2sdev->allocated_resource[i])
78                         release_and_free_resource(i2sdev->allocated_resource[i]);
79         free_dbdma_descriptor_ring(i2sdev, &i2sdev->out.dbdma_ring);
80         free_dbdma_descriptor_ring(i2sdev, &i2sdev->in.dbdma_ring);
81         for (i=0;i<3;i++)
82                 free_irq(i2sdev->interrupts[i], i2sdev);
83         i2sbus_control_remove_dev(i2sdev->control, i2sdev);
84         mutex_destroy(&i2sdev->lock);
85         kfree(i2sdev);
86 }
87
88 static irqreturn_t i2sbus_bus_intr(int irq, void *devid, struct pt_regs *regs)
89 {
90         struct i2sbus_dev *dev = devid;
91         u32 intreg;
92
93         spin_lock(&dev->low_lock);
94         intreg = in_le32(&dev->intfregs->intr_ctl);
95
96         /* acknowledge interrupt reasons */
97         out_le32(&dev->intfregs->intr_ctl, intreg);
98
99         spin_unlock(&dev->low_lock);
100
101         return IRQ_HANDLED;
102 }
103
104 static int force;
105 module_param(force, int, 0444);
106 MODULE_PARM_DESC(force, "Force loading i2sbus even when"
107                         " no layout-id property is present");
108
109 /* FIXME: look at device node refcounting */
110 static int i2sbus_add_dev(struct macio_dev *macio,
111                           struct i2sbus_control *control,
112                           struct device_node *np)
113 {
114         struct i2sbus_dev *dev;
115         struct device_node *child = NULL, *sound = NULL;
116         int i;
117         static const char *rnames[] = { "i2sbus: %s (control)",
118                                         "i2sbus: %s (tx)",
119                                         "i2sbus: %s (rx)" };
120         static irqreturn_t (*ints[])(int irq, void *devid,
121                                      struct pt_regs *regs) = {
122                 i2sbus_bus_intr,
123                 i2sbus_tx_intr,
124                 i2sbus_rx_intr
125         };
126
127         if (strlen(np->name) != 5)
128                 return 0;
129         if (strncmp(np->name, "i2s-", 4))
130                 return 0;
131
132         if (np->n_intrs != 3)
133                 return 0;
134
135         dev = kzalloc(sizeof(struct i2sbus_dev), GFP_KERNEL);
136         if (!dev)
137                 return 0;
138
139         i = 0;
140         while ((child = of_get_next_child(np, child))) {
141                 if (strcmp(child->name, "sound") == 0) {
142                         i++;
143                         sound = child;
144                 }
145         }
146         if (i == 1) {
147                 u32 *layout_id;
148                 layout_id = (u32*) get_property(sound, "layout-id", NULL);
149                 if (layout_id) {
150                         snprintf(dev->sound.modalias, 32,
151                                  "sound-layout-%d", *layout_id);
152                         force = 1;
153                 }
154         }
155         /* for the time being, until we can handle non-layout-id
156          * things in some fabric, refuse to attach if there is no
157          * layout-id property or we haven't been forced to attach.
158          * When there are two i2s busses and only one has a layout-id,
159          * then this depends on the order, but that isn't important
160          * either as the second one in that case is just a modem. */
161         if (!force) {
162                 kfree(dev);
163                 return -ENODEV;
164         }
165
166         mutex_init(&dev->lock);
167         spin_lock_init(&dev->low_lock);
168         dev->sound.ofdev.node = np;
169         dev->sound.ofdev.dma_mask = macio->ofdev.dma_mask;
170         dev->sound.ofdev.dev.dma_mask = &dev->sound.ofdev.dma_mask;
171         dev->sound.ofdev.dev.parent = &macio->ofdev.dev;
172         dev->sound.ofdev.dev.release = i2sbus_release_dev;
173         dev->sound.attach_codec = i2sbus_attach_codec;
174         dev->sound.detach_codec = i2sbus_detach_codec;
175         dev->sound.pcmid = -1;
176         dev->macio = macio;
177         dev->control = control;
178         dev->bus_number = np->name[4] - 'a';
179         INIT_LIST_HEAD(&dev->sound.codec_list);
180
181         for (i=0;i<3;i++) {
182                 dev->interrupts[i] = -1;
183                 snprintf(dev->rnames[i], sizeof(dev->rnames[i]), rnames[i], np->name);
184         }
185         for (i=0;i<3;i++) {
186                 if (request_irq(np->intrs[i].line, ints[i], 0, dev->rnames[i], dev))
187                         goto err;
188                 dev->interrupts[i] = np->intrs[i].line;
189         }
190
191         for (i=0;i<3;i++) {
192                 if (of_address_to_resource(np, i, &dev->resources[i]))
193                         goto err;
194                 /* if only we could use our resource dev->resources[i]...
195                  * but request_resource doesn't know about parents and
196                  * contained resources... */
197                 dev->allocated_resource[i] = 
198                         request_mem_region(dev->resources[i].start,
199                                            dev->resources[i].end -
200                                            dev->resources[i].start + 1,
201                                            dev->rnames[i]);
202                 if (!dev->allocated_resource[i]) {
203                         printk(KERN_ERR "i2sbus: failed to claim resource %d!\n", i);
204                         goto err;
205                 }
206         }
207         /* should do sanity checking here about length of them */
208         dev->intfregs = ioremap(dev->resources[0].start,
209                                 dev->resources[0].end-dev->resources[0].start+1);
210         dev->out.dbdma = ioremap(dev->resources[1].start,
211                                  dev->resources[1].end-dev->resources[1].start+1);
212         dev->in.dbdma = ioremap(dev->resources[2].start,
213                                 dev->resources[2].end-dev->resources[2].start+1);
214         if (!dev->intfregs || !dev->out.dbdma || !dev->in.dbdma)
215                 goto err;
216
217         if (alloc_dbdma_descriptor_ring(dev, &dev->out.dbdma_ring,
218                                         MAX_DBDMA_COMMANDS))
219                 goto err;
220         if (alloc_dbdma_descriptor_ring(dev, &dev->in.dbdma_ring,
221                                         MAX_DBDMA_COMMANDS))
222                 goto err;
223
224         if (i2sbus_control_add_dev(dev->control, dev)) {
225                 printk(KERN_ERR "i2sbus: control layer didn't like bus\n");
226                 goto err;
227         }
228
229         if (soundbus_add_one(&dev->sound)) {
230                 printk(KERN_DEBUG "i2sbus: device registration error!\n");
231                 goto err;
232         }
233
234         /* enable this cell */
235         i2sbus_control_cell(dev->control, dev, 1);
236         i2sbus_control_enable(dev->control, dev);
237         i2sbus_control_clock(dev->control, dev, 1);
238
239         return 1;
240  err:
241         for (i=0;i<3;i++)
242                 if (dev->interrupts[i] != -1)
243                         free_irq(dev->interrupts[i], dev);
244         free_dbdma_descriptor_ring(dev, &dev->out.dbdma_ring);
245         free_dbdma_descriptor_ring(dev, &dev->in.dbdma_ring);
246         if (dev->intfregs) iounmap(dev->intfregs);
247         if (dev->out.dbdma) iounmap(dev->out.dbdma);
248         if (dev->in.dbdma) iounmap(dev->in.dbdma);
249         for (i=0;i<3;i++)
250                 if (dev->allocated_resource[i])
251                         release_and_free_resource(dev->allocated_resource[i]);
252         mutex_destroy(&dev->lock);
253         kfree(dev);
254         return 0;
255 }
256
257 static int i2sbus_probe(struct macio_dev* dev, const struct of_device_id *match)
258 {
259         struct device_node *np = NULL;
260         int got = 0, err;
261         struct i2sbus_control *control = NULL;
262
263         err = i2sbus_control_init(dev, &control);
264         if (err)
265                 return err;
266         if (!control) {
267                 printk(KERN_ERR "i2sbus_control_init API breakage\n");
268                 return -ENODEV;
269         }
270
271         while ((np = of_get_next_child(dev->ofdev.node, np))) {
272                 if (device_is_compatible(np, "i2sbus") ||
273                     device_is_compatible(np, "i2s-modem")) {
274                         got += i2sbus_add_dev(dev, control, np);
275                 }
276         }
277
278         if (!got) {
279                 /* found none, clean up */
280                 i2sbus_control_destroy(control);
281                 return -ENODEV;
282         }
283
284         dev->ofdev.dev.driver_data = control;
285
286         return 0;
287 }
288
289 static int i2sbus_remove(struct macio_dev* dev)
290 {
291         struct i2sbus_control *control = dev->ofdev.dev.driver_data;
292         struct i2sbus_dev *i2sdev, *tmp;
293
294         list_for_each_entry_safe(i2sdev, tmp, &control->list, item)
295                 soundbus_remove_one(&i2sdev->sound);
296
297         return 0;
298 }
299
300 #ifdef CONFIG_PM
301 static int i2sbus_suspend(struct macio_dev* dev, pm_message_t state)
302 {
303         struct i2sbus_control *control = dev->ofdev.dev.driver_data;
304         struct codec_info_item *cii;
305         struct i2sbus_dev* i2sdev;
306         int err, ret = 0;
307
308         list_for_each_entry(i2sdev, &control->list, item) {
309                 /* Notify Alsa */
310                 if (i2sdev->sound.pcm) {
311                         /* Suspend PCM streams */
312                         snd_pcm_suspend_all(i2sdev->sound.pcm);
313                         /* Probably useless as we handle
314                          * power transitions ourselves */
315                         snd_power_change_state(i2sdev->sound.pcm->card,
316                                                SNDRV_CTL_POWER_D3hot);
317                 }
318                 /* Notify codecs */
319                 list_for_each_entry(cii, &i2sdev->sound.codec_list, list) {
320                         err = 0;
321                         if (cii->codec->suspend)
322                                 err = cii->codec->suspend(cii, state);
323                         if (err)
324                                 ret = err;
325                 }
326         }
327         return ret;
328 }
329
330 static int i2sbus_resume(struct macio_dev* dev)
331 {
332         struct i2sbus_control *control = dev->ofdev.dev.driver_data;
333         struct codec_info_item *cii;
334         struct i2sbus_dev* i2sdev;
335         int err, ret = 0;
336
337         list_for_each_entry(i2sdev, &control->list, item) {
338                 /* Notify codecs so they can re-initialize */
339                 list_for_each_entry(cii, &i2sdev->sound.codec_list, list) {
340                         err = 0;
341                         if (cii->codec->resume)
342                                 err = cii->codec->resume(cii);
343                         if (err)
344                                 ret = err;
345                 }
346                 /* Notify Alsa */
347                 if (i2sdev->sound.pcm) {
348                         /* Same comment as above, probably useless */
349                         snd_power_change_state(i2sdev->sound.pcm->card,
350                                                SNDRV_CTL_POWER_D0);
351                 }
352         }
353
354         return ret;
355 }
356 #endif /* CONFIG_PM */
357
358 static int i2sbus_shutdown(struct macio_dev* dev)
359 {
360         return 0;
361 }
362
363 static struct macio_driver i2sbus_drv = {
364         .name = "soundbus-i2s",
365         .owner = THIS_MODULE,
366         .match_table = i2sbus_match,
367         .probe = i2sbus_probe,
368         .remove = i2sbus_remove,
369 #ifdef CONFIG_PM
370         .suspend = i2sbus_suspend,
371         .resume = i2sbus_resume,
372 #endif
373         .shutdown = i2sbus_shutdown,
374 };
375
376 static int __init soundbus_i2sbus_init(void)
377 {
378         return macio_register_driver(&i2sbus_drv);
379 }
380
381 static void __exit soundbus_i2sbus_exit(void)
382 {
383         macio_unregister_driver(&i2sbus_drv);
384 }
385
386 module_init(soundbus_i2sbus_init);
387 module_exit(soundbus_i2sbus_exit);