~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/sound/aoa/soundbus/i2sbus/pcm.c

Version: ~ [ linux-5.2 ] ~ [ linux-5.1.16 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.57 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.132 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.184 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.184 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.69 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.39.4 ] ~ [ linux-2.6.38.8 ] ~ [ linux-2.6.37.6 ] ~ [ linux-2.6.36.4 ] ~ [ linux-2.6.35.14 ] ~ [ linux-2.6.34.15 ] ~ [ linux-2.6.33.20 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp