[ALSA] Remove sound/driver.h
[linux-2.6.git] / sound / aoa / soundbus / i2sbus / i2sbus-pcm.c
1 /*
2  * i2sbus driver -- pcm routines
3  *
4  * Copyright 2006 Johannes Berg <johannes@sipsolutions.net>
5  *
6  * GPL v2, can be found in COPYING.
7  */
8
9 #include <asm/io.h>
10 #include <linux/delay.h>
11 #include <sound/core.h>
12 #include <asm/macio.h>
13 #include <linux/pci.h>
14 #include "../soundbus.h"
15 #include "i2sbus.h"
16
17 static inline void get_pcm_info(struct i2sbus_dev *i2sdev, int in,
18                                 struct pcm_info **pi, struct pcm_info **other)
19 {
20         if (in) {
21                 if (pi)
22                         *pi = &i2sdev->in;
23                 if (other)
24                         *other = &i2sdev->out;
25         } else {
26                 if (pi)
27                         *pi = &i2sdev->out;
28                 if (other)
29                         *other = &i2sdev->in;
30         }
31 }
32
33 static int clock_and_divisors(int mclk, int sclk, int rate, int *out)
34 {
35         /* sclk must be derived from mclk! */
36         if (mclk % sclk)
37                 return -1;
38         /* derive sclk register value */
39         if (i2s_sf_sclkdiv(mclk / sclk, out))
40                 return -1;
41
42         if (I2S_CLOCK_SPEED_18MHz % (rate * mclk) == 0) {
43                 if (!i2s_sf_mclkdiv(I2S_CLOCK_SPEED_18MHz / (rate * mclk), out)) {
44                         *out |= I2S_SF_CLOCK_SOURCE_18MHz;
45                         return 0;
46                 }
47         }
48         if (I2S_CLOCK_SPEED_45MHz % (rate * mclk) == 0) {
49                 if (!i2s_sf_mclkdiv(I2S_CLOCK_SPEED_45MHz / (rate * mclk), out)) {
50                         *out |= I2S_SF_CLOCK_SOURCE_45MHz;
51                         return 0;
52                 }
53         }
54         if (I2S_CLOCK_SPEED_49MHz % (rate * mclk) == 0) {
55                 if (!i2s_sf_mclkdiv(I2S_CLOCK_SPEED_49MHz / (rate * mclk), out)) {
56                         *out |= I2S_SF_CLOCK_SOURCE_49MHz;
57                         return 0;
58                 }
59         }
60         return -1;
61 }
62
63 #define CHECK_RATE(rate)                                                \
64         do { if (rates & SNDRV_PCM_RATE_ ##rate) {                      \
65                 int dummy;                                              \
66                 if (clock_and_divisors(sysclock_factor,                 \
67                                        bus_factor, rate, &dummy))       \
68                         rates &= ~SNDRV_PCM_RATE_ ##rate;               \
69         } } while (0)
70
71 static int i2sbus_pcm_open(struct i2sbus_dev *i2sdev, int in)
72 {
73         struct pcm_info *pi, *other;
74         struct soundbus_dev *sdev;
75         int masks_inited = 0, err;
76         struct codec_info_item *cii, *rev;
77         struct snd_pcm_hardware *hw;
78         u64 formats = 0;
79         unsigned int rates = 0;
80         struct transfer_info v;
81         int result = 0;
82         int bus_factor = 0, sysclock_factor = 0;
83         int found_this;
84
85         mutex_lock(&i2sdev->lock);
86
87         get_pcm_info(i2sdev, in, &pi, &other);
88
89         hw = &pi->substream->runtime->hw;
90         sdev = &i2sdev->sound;
91
92         if (pi->active) {
93                 /* alsa messed up */
94                 result = -EBUSY;
95                 goto out_unlock;
96         }
97
98         /* we now need to assign the hw */
99         list_for_each_entry(cii, &sdev->codec_list, list) {
100                 struct transfer_info *ti = cii->codec->transfers;
101                 bus_factor = cii->codec->bus_factor;
102                 sysclock_factor = cii->codec->sysclock_factor;
103                 while (ti->formats && ti->rates) {
104                         v = *ti;
105                         if (ti->transfer_in == in
106                             && cii->codec->usable(cii, ti, &v)) {
107                                 if (masks_inited) {
108                                         formats &= v.formats;
109                                         rates &= v.rates;
110                                 } else {
111                                         formats = v.formats;
112                                         rates = v.rates;
113                                         masks_inited = 1;
114                                 }
115                         }
116                         ti++;
117                 }
118         }
119         if (!masks_inited || !bus_factor || !sysclock_factor) {
120                 result = -ENODEV;
121                 goto out_unlock;
122         }
123         /* bus dependent stuff */
124         hw->info = SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_MMAP_VALID |
125                    SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_RESUME |
126                    SNDRV_PCM_INFO_JOINT_DUPLEX;
127
128         CHECK_RATE(5512);
129         CHECK_RATE(8000);
130         CHECK_RATE(11025);
131         CHECK_RATE(16000);
132         CHECK_RATE(22050);
133         CHECK_RATE(32000);
134         CHECK_RATE(44100);
135         CHECK_RATE(48000);
136         CHECK_RATE(64000);
137         CHECK_RATE(88200);
138         CHECK_RATE(96000);
139         CHECK_RATE(176400);
140         CHECK_RATE(192000);
141         hw->rates = rates;
142
143         /* well. the codec might want 24 bits only, and we'll
144          * ever only transfer 24 bits, but they are top-aligned!
145          * So for alsa, we claim that we're doing full 32 bit
146          * while in reality we'll ignore the lower 8 bits of
147          * that when doing playback (they're transferred as 0
148          * as far as I know, no codecs we have are 32-bit capable
149          * so I can't really test) and when doing recording we'll
150          * always have those lower 8 bits recorded as 0 */
151         if (formats & SNDRV_PCM_FMTBIT_S24_BE)
152                 formats |= SNDRV_PCM_FMTBIT_S32_BE;
153         if (formats & SNDRV_PCM_FMTBIT_U24_BE)
154                 formats |= SNDRV_PCM_FMTBIT_U32_BE;
155         /* now mask off what we can support. I suppose we could
156          * also support S24_3LE and some similar formats, but I
157          * doubt there's a codec that would be able to use that,
158          * so we don't support it here. */
159         hw->formats = formats & (SNDRV_PCM_FMTBIT_S16_BE |
160                                  SNDRV_PCM_FMTBIT_U16_BE |
161                                  SNDRV_PCM_FMTBIT_S32_BE |
162                                  SNDRV_PCM_FMTBIT_U32_BE);
163
164         /* we need to set the highest and lowest rate possible.
165          * These are the highest and lowest rates alsa can
166          * support properly in its bitfield.
167          * Below, we'll use that to restrict to the rate
168          * currently in use (if any). */
169         hw->rate_min = 5512;
170         hw->rate_max = 192000;
171         /* if the other stream is active, then we can only
172          * support what it is currently using.
173          * FIXME: I lied. This comment is wrong. We can support
174          * anything that works with the same serial format, ie.
175          * when recording 24 bit sound we can well play 16 bit
176          * sound at the same time iff using the same transfer mode.
177          */
178         if (other->active) {
179                 /* FIXME: is this guaranteed by the alsa api? */
180                 hw->formats &= (1ULL << i2sdev->format);
181                 /* see above, restrict rates to the one we already have */
182                 hw->rate_min = i2sdev->rate;
183                 hw->rate_max = i2sdev->rate;
184         }
185
186         hw->channels_min = 2;
187         hw->channels_max = 2;
188         /* these are somewhat arbitrary */
189         hw->buffer_bytes_max = 131072;
190         hw->period_bytes_min = 256;
191         hw->period_bytes_max = 16384;
192         hw->periods_min = 3;
193         hw->periods_max = MAX_DBDMA_COMMANDS;
194         err = snd_pcm_hw_constraint_integer(pi->substream->runtime,
195                                             SNDRV_PCM_HW_PARAM_PERIODS);
196         if (err < 0) {
197                 result = err;
198                 goto out_unlock;
199         }
200         list_for_each_entry(cii, &sdev->codec_list, list) {
201                 if (cii->codec->open) {
202                         err = cii->codec->open(cii, pi->substream);
203                         if (err) {
204                                 result = err;
205                                 /* unwind */
206                                 found_this = 0;
207                                 list_for_each_entry_reverse(rev,
208                                     &sdev->codec_list, list) {
209                                         if (found_this && rev->codec->close) {
210                                                 rev->codec->close(rev,
211                                                                 pi->substream);
212                                         }
213                                         if (rev == cii)
214                                                 found_this = 1;
215                                 }
216                                 goto out_unlock;
217                         }
218                 }
219         }
220
221  out_unlock:
222         mutex_unlock(&i2sdev->lock);
223         return result;
224 }
225
226 #undef CHECK_RATE
227
228 static int i2sbus_pcm_close(struct i2sbus_dev *i2sdev, int in)
229 {
230         struct codec_info_item *cii;
231         struct pcm_info *pi;
232         int err = 0, tmp;
233
234         mutex_lock(&i2sdev->lock);
235
236         get_pcm_info(i2sdev, in, &pi, NULL);
237
238         list_for_each_entry(cii, &i2sdev->sound.codec_list, list) {
239                 if (cii->codec->close) {
240                         tmp = cii->codec->close(cii, pi->substream);
241                         if (tmp)
242                                 err = tmp;
243                 }
244         }
245
246         pi->substream = NULL;
247         pi->active = 0;
248         mutex_unlock(&i2sdev->lock);
249         return err;
250 }
251
252 static void i2sbus_wait_for_stop(struct i2sbus_dev *i2sdev,
253                                  struct pcm_info *pi)
254 {
255         unsigned long flags;
256         struct completion done;
257         long timeout;
258
259         spin_lock_irqsave(&i2sdev->low_lock, flags);
260         if (pi->dbdma_ring.stopping) {
261                 init_completion(&done);
262                 pi->stop_completion = &done;
263                 spin_unlock_irqrestore(&i2sdev->low_lock, flags);
264                 timeout = wait_for_completion_timeout(&done, HZ);
265                 spin_lock_irqsave(&i2sdev->low_lock, flags);
266                 pi->stop_completion = NULL;
267                 if (timeout == 0) {
268                         /* timeout expired, stop dbdma forcefully */
269                         printk(KERN_ERR "i2sbus_wait_for_stop: timed out\n");
270                         /* make sure RUN, PAUSE and S0 bits are cleared */
271                         out_le32(&pi->dbdma->control, (RUN | PAUSE | 1) << 16);
272                         pi->dbdma_ring.stopping = 0;
273                         timeout = 10;
274                         while (in_le32(&pi->dbdma->status) & ACTIVE) {
275                                 if (--timeout <= 0)
276                                         break;
277                                 udelay(1);
278                         }
279                 }
280         }
281         spin_unlock_irqrestore(&i2sdev->low_lock, flags);
282 }
283
284 #ifdef CONFIG_PM
285 void i2sbus_wait_for_stop_both(struct i2sbus_dev *i2sdev)
286 {
287         struct pcm_info *pi;
288
289         get_pcm_info(i2sdev, 0, &pi, NULL);
290         i2sbus_wait_for_stop(i2sdev, pi);
291         get_pcm_info(i2sdev, 1, &pi, NULL);
292         i2sbus_wait_for_stop(i2sdev, pi);
293 }
294 #endif
295
296 static int i2sbus_hw_params(struct snd_pcm_substream *substream,
297                             struct snd_pcm_hw_params *params)
298 {
299         return snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(params));
300 }
301
302 static inline int i2sbus_hw_free(struct snd_pcm_substream *substream, int in)
303 {
304         struct i2sbus_dev *i2sdev = snd_pcm_substream_chip(substream);
305         struct pcm_info *pi;
306
307         get_pcm_info(i2sdev, in, &pi, NULL);
308         if (pi->dbdma_ring.stopping)
309                 i2sbus_wait_for_stop(i2sdev, pi);
310         snd_pcm_lib_free_pages(substream);
311         return 0;
312 }
313
314 static int i2sbus_playback_hw_free(struct snd_pcm_substream *substream)
315 {
316         return i2sbus_hw_free(substream, 0);
317 }
318
319 static int i2sbus_record_hw_free(struct snd_pcm_substream *substream)
320 {
321         return i2sbus_hw_free(substream, 1);
322 }
323
324 static int i2sbus_pcm_prepare(struct i2sbus_dev *i2sdev, int in)
325 {
326         /* whee. Hard work now. The user has selected a bitrate
327          * and bit format, so now we have to program our
328          * I2S controller appropriately. */
329         struct snd_pcm_runtime *runtime;
330         struct dbdma_cmd *command;
331         int i, periodsize, nperiods;
332         dma_addr_t offset;
333         struct bus_info bi;
334         struct codec_info_item *cii;
335         int sfr = 0;            /* serial format register */
336         int dws = 0;            /* data word sizes reg */
337         int input_16bit;
338         struct pcm_info *pi, *other;
339         int cnt;
340         int result = 0;
341         unsigned int cmd, stopaddr;
342
343         mutex_lock(&i2sdev->lock);
344
345         get_pcm_info(i2sdev, in, &pi, &other);
346
347         if (pi->dbdma_ring.running) {
348                 result = -EBUSY;
349                 goto out_unlock;
350         }
351         if (pi->dbdma_ring.stopping)
352                 i2sbus_wait_for_stop(i2sdev, pi);
353
354         if (!pi->substream || !pi->substream->runtime) {
355                 result = -EINVAL;
356                 goto out_unlock;
357         }
358
359         runtime = pi->substream->runtime;
360         pi->active = 1;
361         if (other->active &&
362             ((i2sdev->format != runtime->format)
363              || (i2sdev->rate != runtime->rate))) {
364                 result = -EINVAL;
365                 goto out_unlock;
366         }
367
368         i2sdev->format = runtime->format;
369         i2sdev->rate = runtime->rate;
370
371         periodsize = snd_pcm_lib_period_bytes(pi->substream);
372         nperiods = pi->substream->runtime->periods;
373         pi->current_period = 0;
374
375         /* generate dbdma command ring first */
376         command = pi->dbdma_ring.cmds;
377         memset(command, 0, (nperiods + 2) * sizeof(struct dbdma_cmd));
378
379         /* commands to DMA to/from the ring */
380         /*
381          * For input, we need to do a graceful stop; if we abort
382          * the DMA, we end up with leftover bytes that corrupt
383          * the next recording.  To do this we set the S0 status
384          * bit and wait for the DMA controller to stop.  Each
385          * command has a branch condition to
386          * make it branch to a stop command if S0 is set.
387          * On input we also need to wait for the S7 bit to be
388          * set before turning off the DMA controller.
389          * In fact we do the graceful stop for output as well.
390          */
391         offset = runtime->dma_addr;
392         cmd = (in? INPUT_MORE: OUTPUT_MORE) | BR_IFSET | INTR_ALWAYS;
393         stopaddr = pi->dbdma_ring.bus_cmd_start +
394                 (nperiods + 1) * sizeof(struct dbdma_cmd);
395         for (i = 0; i < nperiods; i++, command++, offset += periodsize) {
396                 command->command = cpu_to_le16(cmd);
397                 command->cmd_dep = cpu_to_le32(stopaddr);
398                 command->phy_addr = cpu_to_le32(offset);
399                 command->req_count = cpu_to_le16(periodsize);
400         }
401
402         /* branch back to beginning of ring */
403         command->command = cpu_to_le16(DBDMA_NOP | BR_ALWAYS);
404         command->cmd_dep = cpu_to_le32(pi->dbdma_ring.bus_cmd_start);
405         command++;
406
407         /* set stop command */
408         command->command = cpu_to_le16(DBDMA_STOP);
409
410         /* ok, let's set the serial format and stuff */
411         switch (runtime->format) {
412         /* 16 bit formats */
413         case SNDRV_PCM_FORMAT_S16_BE:
414         case SNDRV_PCM_FORMAT_U16_BE:
415                 /* FIXME: if we add different bus factors we need to
416                  * do more here!! */
417                 bi.bus_factor = 0;
418                 list_for_each_entry(cii, &i2sdev->sound.codec_list, list) {
419                         bi.bus_factor = cii->codec->bus_factor;
420                         break;
421                 }
422                 if (!bi.bus_factor) {
423                         result = -ENODEV;
424                         goto out_unlock;
425                 }
426                 input_16bit = 1;
427                 break;
428         case SNDRV_PCM_FORMAT_S32_BE:
429         case SNDRV_PCM_FORMAT_U32_BE:
430                 /* force 64x bus speed, otherwise the data cannot be
431                  * transferred quickly enough! */
432                 bi.bus_factor = 64;
433                 input_16bit = 0;
434                 break;
435         default:
436                 result = -EINVAL;
437                 goto out_unlock;
438         }
439         /* we assume all sysclocks are the same! */
440         list_for_each_entry(cii, &i2sdev->sound.codec_list, list) {
441                 bi.sysclock_factor = cii->codec->sysclock_factor;
442                 break;
443         }
444
445         if (clock_and_divisors(bi.sysclock_factor,
446                                bi.bus_factor,
447                                runtime->rate,
448                                &sfr) < 0) {
449                 result = -EINVAL;
450                 goto out_unlock;
451         }
452         switch (bi.bus_factor) {
453         case 32:
454                 sfr |= I2S_SF_SERIAL_FORMAT_I2S_32X;
455                 break;
456         case 64:
457                 sfr |= I2S_SF_SERIAL_FORMAT_I2S_64X;
458                 break;
459         }
460         /* FIXME: THIS ASSUMES MASTER ALL THE TIME */
461         sfr |= I2S_SF_SCLK_MASTER;
462
463         list_for_each_entry(cii, &i2sdev->sound.codec_list, list) {
464                 int err = 0;
465                 if (cii->codec->prepare)
466                         err = cii->codec->prepare(cii, &bi, pi->substream);
467                 if (err) {
468                         result = err;
469                         goto out_unlock;
470                 }
471         }
472         /* codecs are fine with it, so set our clocks */
473         if (input_16bit)
474                 dws =   (2 << I2S_DWS_NUM_CHANNELS_IN_SHIFT) |
475                         (2 << I2S_DWS_NUM_CHANNELS_OUT_SHIFT) |
476                         I2S_DWS_DATA_IN_16BIT | I2S_DWS_DATA_OUT_16BIT;
477         else
478                 dws =   (2 << I2S_DWS_NUM_CHANNELS_IN_SHIFT) |
479                         (2 << I2S_DWS_NUM_CHANNELS_OUT_SHIFT) |
480                         I2S_DWS_DATA_IN_24BIT | I2S_DWS_DATA_OUT_24BIT;
481
482         /* early exit if already programmed correctly */
483         /* not locking these is fine since we touch them only in this function */
484         if (in_le32(&i2sdev->intfregs->serial_format) == sfr
485          && in_le32(&i2sdev->intfregs->data_word_sizes) == dws)
486                 goto out_unlock;
487
488         /* let's notify the codecs about clocks going away.
489          * For now we only do mastering on the i2s cell... */
490         list_for_each_entry(cii, &i2sdev->sound.codec_list, list)
491                 if (cii->codec->switch_clock)
492                         cii->codec->switch_clock(cii, CLOCK_SWITCH_PREPARE_SLAVE);
493
494         i2sbus_control_enable(i2sdev->control, i2sdev);
495         i2sbus_control_cell(i2sdev->control, i2sdev, 1);
496
497         out_le32(&i2sdev->intfregs->intr_ctl, I2S_PENDING_CLOCKS_STOPPED);
498
499         i2sbus_control_clock(i2sdev->control, i2sdev, 0);
500
501         msleep(1);
502
503         /* wait for clock stopped. This can apparently take a while... */
504         cnt = 100;
505         while (cnt-- &&
506             !(in_le32(&i2sdev->intfregs->intr_ctl) & I2S_PENDING_CLOCKS_STOPPED)) {
507                 msleep(5);
508         }
509         out_le32(&i2sdev->intfregs->intr_ctl, I2S_PENDING_CLOCKS_STOPPED);
510
511         /* not locking these is fine since we touch them only in this function */
512         out_le32(&i2sdev->intfregs->serial_format, sfr);
513         out_le32(&i2sdev->intfregs->data_word_sizes, dws);
514
515         i2sbus_control_enable(i2sdev->control, i2sdev);
516         i2sbus_control_cell(i2sdev->control, i2sdev, 1);
517         i2sbus_control_clock(i2sdev->control, i2sdev, 1);
518         msleep(1);
519
520         list_for_each_entry(cii, &i2sdev->sound.codec_list, list)
521                 if (cii->codec->switch_clock)
522                         cii->codec->switch_clock(cii, CLOCK_SWITCH_SLAVE);
523
524  out_unlock:
525         mutex_unlock(&i2sdev->lock);
526         return result;
527 }
528
529 #ifdef CONFIG_PM
530 void i2sbus_pcm_prepare_both(struct i2sbus_dev *i2sdev)
531 {
532         i2sbus_pcm_prepare(i2sdev, 0);
533         i2sbus_pcm_prepare(i2sdev, 1);
534 }
535 #endif
536
537 static int i2sbus_pcm_trigger(struct i2sbus_dev *i2sdev, int in, int cmd)
538 {
539         struct codec_info_item *cii;
540         struct pcm_info *pi;
541         int result = 0;
542         unsigned long flags;
543
544         spin_lock_irqsave(&i2sdev->low_lock, flags);
545
546         get_pcm_info(i2sdev, in, &pi, NULL);
547
548         switch (cmd) {
549         case SNDRV_PCM_TRIGGER_START:
550         case SNDRV_PCM_TRIGGER_RESUME:
551                 if (pi->dbdma_ring.running) {
552                         result = -EALREADY;
553                         goto out_unlock;
554                 }
555                 list_for_each_entry(cii, &i2sdev->sound.codec_list, list)
556                         if (cii->codec->start)
557                                 cii->codec->start(cii, pi->substream);
558                 pi->dbdma_ring.running = 1;
559
560                 if (pi->dbdma_ring.stopping) {
561                         /* Clear the S0 bit, then see if we stopped yet */
562                         out_le32(&pi->dbdma->control, 1 << 16);
563                         if (in_le32(&pi->dbdma->status) & ACTIVE) {
564                                 /* possible race here? */
565                                 udelay(10);
566                                 if (in_le32(&pi->dbdma->status) & ACTIVE) {
567                                         pi->dbdma_ring.stopping = 0;
568                                         goto out_unlock; /* keep running */
569                                 }
570                         }
571                 }
572
573                 /* make sure RUN, PAUSE and S0 bits are cleared */
574                 out_le32(&pi->dbdma->control, (RUN | PAUSE | 1) << 16);
575
576                 /* set branch condition select register */
577                 out_le32(&pi->dbdma->br_sel, (1 << 16) | 1);
578
579                 /* write dma command buffer address to the dbdma chip */
580                 out_le32(&pi->dbdma->cmdptr, pi->dbdma_ring.bus_cmd_start);
581
582                 /* initialize the frame count and current period */
583                 pi->current_period = 0;
584                 pi->frame_count = in_le32(&i2sdev->intfregs->frame_count);
585
586                 /* set the DMA controller running */
587                 out_le32(&pi->dbdma->control, (RUN << 16) | RUN);
588
589                 /* off you go! */
590                 break;
591
592         case SNDRV_PCM_TRIGGER_STOP:
593         case SNDRV_PCM_TRIGGER_SUSPEND:
594                 if (!pi->dbdma_ring.running) {
595                         result = -EALREADY;
596                         goto out_unlock;
597                 }
598                 pi->dbdma_ring.running = 0;
599
600                 /* Set the S0 bit to make the DMA branch to the stop cmd */
601                 out_le32(&pi->dbdma->control, (1 << 16) | 1);
602                 pi->dbdma_ring.stopping = 1;
603
604                 list_for_each_entry(cii, &i2sdev->sound.codec_list, list)
605                         if (cii->codec->stop)
606                                 cii->codec->stop(cii, pi->substream);
607                 break;
608         default:
609                 result = -EINVAL;
610                 goto out_unlock;
611         }
612
613  out_unlock:
614         spin_unlock_irqrestore(&i2sdev->low_lock, flags);
615         return result;
616 }
617
618 static snd_pcm_uframes_t i2sbus_pcm_pointer(struct i2sbus_dev *i2sdev, int in)
619 {
620         struct pcm_info *pi;
621         u32 fc;
622
623         get_pcm_info(i2sdev, in, &pi, NULL);
624
625         fc = in_le32(&i2sdev->intfregs->frame_count);
626         fc = fc - pi->frame_count;
627
628         if (fc >= pi->substream->runtime->buffer_size)
629                 fc %= pi->substream->runtime->buffer_size;
630         return fc;
631 }
632
633 static inline void handle_interrupt(struct i2sbus_dev *i2sdev, int in)
634 {
635         struct pcm_info *pi;
636         u32 fc, nframes;
637         u32 status;
638         int timeout, i;
639         int dma_stopped = 0;
640         struct snd_pcm_runtime *runtime;
641
642         spin_lock(&i2sdev->low_lock);
643         get_pcm_info(i2sdev, in, &pi, NULL);
644         if (!pi->dbdma_ring.running && !pi->dbdma_ring.stopping)
645                 goto out_unlock;
646
647         i = pi->current_period;
648         runtime = pi->substream->runtime;
649         while (pi->dbdma_ring.cmds[i].xfer_status) {
650                 if (le16_to_cpu(pi->dbdma_ring.cmds[i].xfer_status) & BT)
651                         /*
652                          * BT is the branch taken bit.  If it took a branch
653                          * it is because we set the S0 bit to make it
654                          * branch to the stop command.
655                          */
656                         dma_stopped = 1;
657                 pi->dbdma_ring.cmds[i].xfer_status = 0;
658
659                 if (++i >= runtime->periods) {
660                         i = 0;
661                         pi->frame_count += runtime->buffer_size;
662                 }
663                 pi->current_period = i;
664
665                 /*
666                  * Check the frame count.  The DMA tends to get a bit
667                  * ahead of the frame counter, which confuses the core.
668                  */
669                 fc = in_le32(&i2sdev->intfregs->frame_count);
670                 nframes = i * runtime->period_size;
671                 if (fc < pi->frame_count + nframes)
672                         pi->frame_count = fc - nframes;
673         }
674
675         if (dma_stopped) {
676                 timeout = 1000;
677                 for (;;) {
678                         status = in_le32(&pi->dbdma->status);
679                         if (!(status & ACTIVE) && (!in || (status & 0x80)))
680                                 break;
681                         if (--timeout <= 0) {
682                                 printk(KERN_ERR "i2sbus: timed out "
683                                        "waiting for DMA to stop!\n");
684                                 break;
685                         }
686                         udelay(1);
687                 }
688
689                 /* Turn off DMA controller, clear S0 bit */
690                 out_le32(&pi->dbdma->control, (RUN | PAUSE | 1) << 16);
691
692                 pi->dbdma_ring.stopping = 0;
693                 if (pi->stop_completion)
694                         complete(pi->stop_completion);
695         }
696
697         if (!pi->dbdma_ring.running)
698                 goto out_unlock;
699         spin_unlock(&i2sdev->low_lock);
700         /* may call _trigger again, hence needs to be unlocked */
701         snd_pcm_period_elapsed(pi->substream);
702         return;
703
704  out_unlock:
705         spin_unlock(&i2sdev->low_lock);
706 }
707
708 irqreturn_t i2sbus_tx_intr(int irq, void *devid)
709 {
710         handle_interrupt((struct i2sbus_dev *)devid, 0);
711         return IRQ_HANDLED;
712 }
713
714 irqreturn_t i2sbus_rx_intr(int irq, void *devid)
715 {
716         handle_interrupt((struct i2sbus_dev *)devid, 1);
717         return IRQ_HANDLED;
718 }
719
720 static int i2sbus_playback_open(struct snd_pcm_substream *substream)
721 {
722         struct i2sbus_dev *i2sdev = snd_pcm_substream_chip(substream);
723
724         if (!i2sdev)
725                 return -EINVAL;
726         i2sdev->out.substream = substream;
727         return i2sbus_pcm_open(i2sdev, 0);
728 }
729
730 static int i2sbus_playback_close(struct snd_pcm_substream *substream)
731 {
732         struct i2sbus_dev *i2sdev = snd_pcm_substream_chip(substream);
733         int err;
734
735         if (!i2sdev)
736                 return -EINVAL;
737         if (i2sdev->out.substream != substream)
738                 return -EINVAL;
739         err = i2sbus_pcm_close(i2sdev, 0);
740         if (!err)
741                 i2sdev->out.substream = NULL;
742         return err;
743 }
744
745 static int i2sbus_playback_prepare(struct snd_pcm_substream *substream)
746 {
747         struct i2sbus_dev *i2sdev = snd_pcm_substream_chip(substream);
748
749         if (!i2sdev)
750                 return -EINVAL;
751         if (i2sdev->out.substream != substream)
752                 return -EINVAL;
753         return i2sbus_pcm_prepare(i2sdev, 0);
754 }
755
756 static int i2sbus_playback_trigger(struct snd_pcm_substream *substream, int cmd)
757 {
758         struct i2sbus_dev *i2sdev = snd_pcm_substream_chip(substream);
759
760         if (!i2sdev)
761                 return -EINVAL;
762         if (i2sdev->out.substream != substream)
763                 return -EINVAL;
764         return i2sbus_pcm_trigger(i2sdev, 0, cmd);
765 }
766
767 static snd_pcm_uframes_t i2sbus_playback_pointer(struct snd_pcm_substream
768                                                  *substream)
769 {
770         struct i2sbus_dev *i2sdev = snd_pcm_substream_chip(substream);
771
772         if (!i2sdev)
773                 return -EINVAL;
774         if (i2sdev->out.substream != substream)
775                 return 0;
776         return i2sbus_pcm_pointer(i2sdev, 0);
777 }
778
779 static struct snd_pcm_ops i2sbus_playback_ops = {
780         .open =         i2sbus_playback_open,
781         .close =        i2sbus_playback_close,
782         .ioctl =        snd_pcm_lib_ioctl,
783         .hw_params =    i2sbus_hw_params,
784         .hw_free =      i2sbus_playback_hw_free,
785         .prepare =      i2sbus_playback_prepare,
786         .trigger =      i2sbus_playback_trigger,
787         .pointer =      i2sbus_playback_pointer,
788 };
789
790 static int i2sbus_record_open(struct snd_pcm_substream *substream)
791 {
792         struct i2sbus_dev *i2sdev = snd_pcm_substream_chip(substream);
793
794         if (!i2sdev)
795                 return -EINVAL;
796         i2sdev->in.substream = substream;
797         return i2sbus_pcm_open(i2sdev, 1);
798 }
799
800 static int i2sbus_record_close(struct snd_pcm_substream *substream)
801 {
802         struct i2sbus_dev *i2sdev = snd_pcm_substream_chip(substream);
803         int err;
804
805         if (!i2sdev)
806                 return -EINVAL;
807         if (i2sdev->in.substream != substream)
808                 return -EINVAL;
809         err = i2sbus_pcm_close(i2sdev, 1);
810         if (!err)
811                 i2sdev->in.substream = NULL;
812         return err;
813 }
814
815 static int i2sbus_record_prepare(struct snd_pcm_substream *substream)
816 {
817         struct i2sbus_dev *i2sdev = snd_pcm_substream_chip(substream);
818
819         if (!i2sdev)
820                 return -EINVAL;
821         if (i2sdev->in.substream != substream)
822                 return -EINVAL;
823         return i2sbus_pcm_prepare(i2sdev, 1);
824 }
825
826 static int i2sbus_record_trigger(struct snd_pcm_substream *substream, int cmd)
827 {
828         struct i2sbus_dev *i2sdev = snd_pcm_substream_chip(substream);
829
830         if (!i2sdev)
831                 return -EINVAL;
832         if (i2sdev->in.substream != substream)
833                 return -EINVAL;
834         return i2sbus_pcm_trigger(i2sdev, 1, cmd);
835 }
836
837 static snd_pcm_uframes_t i2sbus_record_pointer(struct snd_pcm_substream
838                                                *substream)
839 {
840         struct i2sbus_dev *i2sdev = snd_pcm_substream_chip(substream);
841
842         if (!i2sdev)
843                 return -EINVAL;
844         if (i2sdev->in.substream != substream)
845                 return 0;
846         return i2sbus_pcm_pointer(i2sdev, 1);
847 }
848
849 static struct snd_pcm_ops i2sbus_record_ops = {
850         .open =         i2sbus_record_open,
851         .close =        i2sbus_record_close,
852         .ioctl =        snd_pcm_lib_ioctl,
853         .hw_params =    i2sbus_hw_params,
854         .hw_free =      i2sbus_record_hw_free,
855         .prepare =      i2sbus_record_prepare,
856         .trigger =      i2sbus_record_trigger,
857         .pointer =      i2sbus_record_pointer,
858 };
859
860 static void i2sbus_private_free(struct snd_pcm *pcm)
861 {
862         struct i2sbus_dev *i2sdev = snd_pcm_chip(pcm);
863         struct codec_info_item *p, *tmp;
864
865         i2sdev->sound.pcm = NULL;
866         i2sdev->out.created = 0;
867         i2sdev->in.created = 0;
868         list_for_each_entry_safe(p, tmp, &i2sdev->sound.codec_list, list) {
869                 printk(KERN_ERR "i2sbus: a codec didn't unregister!\n");
870                 list_del(&p->list);
871                 module_put(p->codec->owner);
872                 kfree(p);
873         }
874         soundbus_dev_put(&i2sdev->sound);
875         module_put(THIS_MODULE);
876 }
877
878 int
879 i2sbus_attach_codec(struct soundbus_dev *dev, struct snd_card *card,
880                     struct codec_info *ci, void *data)
881 {
882         int err, in = 0, out = 0;
883         struct transfer_info *tmp;
884         struct i2sbus_dev *i2sdev = soundbus_dev_to_i2sbus_dev(dev);
885         struct codec_info_item *cii;
886
887         if (!dev->pcmname || dev->pcmid == -1) {
888                 printk(KERN_ERR "i2sbus: pcm name and id must be set!\n");
889                 return -EINVAL;
890         }
891
892         list_for_each_entry(cii, &dev->codec_list, list) {
893                 if (cii->codec_data == data)
894                         return -EALREADY;
895         }
896
897         if (!ci->transfers || !ci->transfers->formats
898             || !ci->transfers->rates || !ci->usable)
899                 return -EINVAL;
900
901         /* we currently code the i2s transfer on the clock, and support only
902          * 32 and 64 */
903         if (ci->bus_factor != 32 && ci->bus_factor != 64)
904                 return -EINVAL;
905
906         /* If you want to fix this, you need to keep track of what transport infos
907          * are to be used, which codecs they belong to, and then fix all the
908          * sysclock/busclock stuff above to depend on which is usable */
909         list_for_each_entry(cii, &dev->codec_list, list) {
910                 if (cii->codec->sysclock_factor != ci->sysclock_factor) {
911                         printk(KERN_DEBUG
912                                "cannot yet handle multiple different sysclocks!\n");
913                         return -EINVAL;
914                 }
915                 if (cii->codec->bus_factor != ci->bus_factor) {
916                         printk(KERN_DEBUG
917                                "cannot yet handle multiple different bus clocks!\n");
918                         return -EINVAL;
919                 }
920         }
921
922         tmp = ci->transfers;
923         while (tmp->formats && tmp->rates) {
924                 if (tmp->transfer_in)
925                         in = 1;
926                 else
927                         out = 1;
928                 tmp++;
929         }
930
931         cii = kzalloc(sizeof(struct codec_info_item), GFP_KERNEL);
932         if (!cii) {
933                 printk(KERN_DEBUG "i2sbus: failed to allocate cii\n");
934                 return -ENOMEM;
935         }
936
937         /* use the private data to point to the codec info */
938         cii->sdev = soundbus_dev_get(dev);
939         cii->codec = ci;
940         cii->codec_data = data;
941
942         if (!cii->sdev) {
943                 printk(KERN_DEBUG
944                        "i2sbus: failed to get soundbus dev reference\n");
945                 err = -ENODEV;
946                 goto out_free_cii;
947         }
948
949         if (!try_module_get(THIS_MODULE)) {
950                 printk(KERN_DEBUG "i2sbus: failed to get module reference!\n");
951                 err = -EBUSY;
952                 goto out_put_sdev;
953         }
954
955         if (!try_module_get(ci->owner)) {
956                 printk(KERN_DEBUG
957                        "i2sbus: failed to get module reference to codec owner!\n");
958                 err = -EBUSY;
959                 goto out_put_this_module;
960         }
961
962         if (!dev->pcm) {
963                 err = snd_pcm_new(card, dev->pcmname, dev->pcmid, 0, 0,
964                                   &dev->pcm);
965                 if (err) {
966                         printk(KERN_DEBUG "i2sbus: failed to create pcm\n");
967                         goto out_put_ci_module;
968                 }
969                 dev->pcm->dev = &dev->ofdev.dev;
970         }
971
972         /* ALSA yet again sucks.
973          * If it is ever fixed, remove this line. See below. */
974         out = in = 1;
975
976         if (!i2sdev->out.created && out) {
977                 if (dev->pcm->card != card) {
978                         /* eh? */
979                         printk(KERN_ERR
980                                "Can't attach same bus to different cards!\n");
981                         err = -EINVAL;
982                         goto out_put_ci_module;
983                 }
984                 err = snd_pcm_new_stream(dev->pcm, SNDRV_PCM_STREAM_PLAYBACK, 1);
985                 if (err)
986                         goto out_put_ci_module;
987                 snd_pcm_set_ops(dev->pcm, SNDRV_PCM_STREAM_PLAYBACK,
988                                 &i2sbus_playback_ops);
989                 i2sdev->out.created = 1;
990         }
991
992         if (!i2sdev->in.created && in) {
993                 if (dev->pcm->card != card) {
994                         printk(KERN_ERR
995                                "Can't attach same bus to different cards!\n");
996                         err = -EINVAL;
997                         goto out_put_ci_module;
998                 }
999                 err = snd_pcm_new_stream(dev->pcm, SNDRV_PCM_STREAM_CAPTURE, 1);
1000                 if (err)
1001                         goto out_put_ci_module;
1002                 snd_pcm_set_ops(dev->pcm, SNDRV_PCM_STREAM_CAPTURE,
1003                                 &i2sbus_record_ops);
1004                 i2sdev->in.created = 1;
1005         }
1006
1007         /* so we have to register the pcm after adding any substream
1008          * to it because alsa doesn't create the devices for the
1009          * substreams when we add them later.
1010          * Therefore, force in and out on both busses (above) and
1011          * register the pcm now instead of just after creating it.
1012          */
1013         err = snd_device_register(card, dev->pcm);
1014         if (err) {
1015                 printk(KERN_ERR "i2sbus: error registering new pcm\n");
1016                 goto out_put_ci_module;
1017         }
1018         /* no errors any more, so let's add this to our list */
1019         list_add(&cii->list, &dev->codec_list);
1020
1021         dev->pcm->private_data = i2sdev;
1022         dev->pcm->private_free = i2sbus_private_free;
1023
1024         /* well, we really should support scatter/gather DMA */
1025         snd_pcm_lib_preallocate_pages_for_all(
1026                 dev->pcm, SNDRV_DMA_TYPE_DEV,
1027                 snd_dma_pci_data(macio_get_pci_dev(i2sdev->macio)),
1028                 64 * 1024, 64 * 1024);
1029
1030         return 0;
1031  out_put_ci_module:
1032         module_put(ci->owner);
1033  out_put_this_module:
1034         module_put(THIS_MODULE);
1035  out_put_sdev:
1036         soundbus_dev_put(dev);
1037  out_free_cii:
1038         kfree(cii);
1039         return err;
1040 }
1041
1042 void i2sbus_detach_codec(struct soundbus_dev *dev, void *data)
1043 {
1044         struct codec_info_item *cii = NULL, *i;
1045
1046         list_for_each_entry(i, &dev->codec_list, list) {
1047                 if (i->codec_data == data) {
1048                         cii = i;
1049                         break;
1050                 }
1051         }
1052         if (cii) {
1053                 list_del(&cii->list);
1054                 module_put(cii->codec->owner);
1055                 kfree(cii);
1056         }
1057         /* no more codecs, but still a pcm? */
1058         if (list_empty(&dev->codec_list) && dev->pcm) {
1059                 /* the actual cleanup is done by the callback above! */
1060                 snd_device_free(dev->pcm->card, dev->pcm);
1061         }
1062 }