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

TOMOYO Linux Cross Reference
Linux/sound/drivers/vx/vx_pcm.c

Version: ~ [ linux-5.3-rc5 ] ~ [ linux-5.2.9 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.67 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.139 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.189 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.189 ] ~ [ 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.72 ] ~ [ 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.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  * Driver for Digigram VX soundcards
  3  *
  4  * PCM part
  5  *
  6  * Copyright (c) 2002,2003 by Takashi Iwai <tiwai@suse.de>
  7  *
  8  *   This program is free software; you can redistribute it and/or modify
  9  *   it under the terms of the GNU General Public License as published by
 10  *   the Free Software Foundation; either version 2 of the License, or
 11  *   (at your option) any later version.
 12  *
 13  *   This program is distributed in the hope that it will be useful,
 14  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 15  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 16  *   GNU General Public License for more details.
 17  *
 18  *   You should have received a copy of the GNU General Public License
 19  *   along with this program; if not, write to the Free Software
 20  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 21  *
 22  *
 23  * STRATEGY
 24  *  for playback, we send series of "chunks", which size is equal with the
 25  *  IBL size, typically 126 samples.  at each end of chunk, the end-of-buffer
 26  *  interrupt is notified, and the interrupt handler will feed the next chunk.
 27  *
 28  *  the current position is calculated from the sample count RMH.
 29  *  pipe->transferred is the counter of data which has been already transferred.
 30  *  if this counter reaches to the period size, snd_pcm_period_elapsed() will
 31  *  be issued.
 32  *
 33  *  for capture, the situation is much easier.
 34  *  to get a low latency response, we'll check the capture streams at each
 35  *  interrupt (capture stream has no EOB notification).  if the pending
 36  *  data is accumulated to the period size, snd_pcm_period_elapsed() is
 37  *  called and the pointer is updated.
 38  *
 39  *  the current point of read buffer is kept in pipe->hw_ptr.  note that
 40  *  this is in bytes.
 41  *
 42  *
 43  * TODO
 44  *  - linked trigger for full-duplex mode.
 45  *  - scheduled action on the stream.
 46  */
 47 
 48 #include <linux/slab.h>
 49 #include <linux/delay.h>
 50 #include <sound/core.h>
 51 #include <sound/asoundef.h>
 52 #include <sound/pcm.h>
 53 #include <sound/vx_core.h>
 54 #include "vx_cmd.h"
 55 
 56 
 57 /*
 58  * read three pending pcm bytes via inb()
 59  */
 60 static void vx_pcm_read_per_bytes(struct vx_core *chip, struct snd_pcm_runtime *runtime,
 61                                   struct vx_pipe *pipe)
 62 {
 63         int offset = pipe->hw_ptr;
 64         unsigned char *buf = (unsigned char *)(runtime->dma_area + offset);
 65         *buf++ = vx_inb(chip, RXH);
 66         if (++offset >= pipe->buffer_bytes) {
 67                 offset = 0;
 68                 buf = (unsigned char *)runtime->dma_area;
 69         }
 70         *buf++ = vx_inb(chip, RXM);
 71         if (++offset >= pipe->buffer_bytes) {
 72                 offset = 0;
 73                 buf = (unsigned char *)runtime->dma_area;
 74         }
 75         *buf++ = vx_inb(chip, RXL);
 76         if (++offset >= pipe->buffer_bytes) {
 77                 offset = 0;
 78                 buf = (unsigned char *)runtime->dma_area;
 79         }
 80         pipe->hw_ptr = offset;
 81 }
 82 
 83 /*
 84  * vx_set_pcx_time - convert from the PC time to the RMH status time.
 85  * @pc_time: the pointer for the PC-time to set
 86  * @dsp_time: the pointer for RMH status time array
 87  */
 88 static void vx_set_pcx_time(struct vx_core *chip, pcx_time_t *pc_time,
 89                             unsigned int *dsp_time)
 90 {
 91         dsp_time[0] = (unsigned int)((*pc_time) >> 24) & PCX_TIME_HI_MASK;
 92         dsp_time[1] = (unsigned int)(*pc_time) &  MASK_DSP_WORD;
 93 }
 94 
 95 /*
 96  * vx_set_differed_time - set the differed time if specified
 97  * @rmh: the rmh record to modify
 98  * @pipe: the pipe to be checked
 99  *
100  * if the pipe is programmed with the differed time, set the DSP time
101  * on the rmh and changes its command length.
102  *
103  * returns the increase of the command length.
104  */
105 static int vx_set_differed_time(struct vx_core *chip, struct vx_rmh *rmh,
106                                 struct vx_pipe *pipe)
107 {
108         /* Update The length added to the RMH command by the timestamp */
109         if (! (pipe->differed_type & DC_DIFFERED_DELAY))
110                 return 0;
111                 
112         /* Set the T bit */
113         rmh->Cmd[0] |= DSP_DIFFERED_COMMAND_MASK;
114 
115         /* Time stamp is the 1st following parameter */
116         vx_set_pcx_time(chip, &pipe->pcx_time, &rmh->Cmd[1]);
117 
118         /* Add the flags to a notified differed command */
119         if (pipe->differed_type & DC_NOTIFY_DELAY)
120                 rmh->Cmd[1] |= NOTIFY_MASK_TIME_HIGH ;
121 
122         /* Add the flags to a multiple differed command */
123         if (pipe->differed_type & DC_MULTIPLE_DELAY)
124                 rmh->Cmd[1] |= MULTIPLE_MASK_TIME_HIGH;
125 
126         /* Add the flags to a stream-time differed command */
127         if (pipe->differed_type & DC_STREAM_TIME_DELAY)
128                 rmh->Cmd[1] |= STREAM_MASK_TIME_HIGH;
129                 
130         rmh->LgCmd += 2;
131         return 2;
132 }
133 
134 /*
135  * vx_set_stream_format - send the stream format command
136  * @pipe: the affected pipe
137  * @data: format bitmask
138  */
139 static int vx_set_stream_format(struct vx_core *chip, struct vx_pipe *pipe,
140                                 unsigned int data)
141 {
142         struct vx_rmh rmh;
143 
144         vx_init_rmh(&rmh, pipe->is_capture ?
145                     CMD_FORMAT_STREAM_IN : CMD_FORMAT_STREAM_OUT);
146         rmh.Cmd[0] |= pipe->number << FIELD_SIZE;
147 
148         /* Command might be longer since we may have to add a timestamp */
149         vx_set_differed_time(chip, &rmh, pipe);
150 
151         rmh.Cmd[rmh.LgCmd] = (data & 0xFFFFFF00) >> 8;
152         rmh.Cmd[rmh.LgCmd + 1] = (data & 0xFF) << 16 /*| (datal & 0xFFFF00) >> 8*/;
153         rmh.LgCmd += 2;
154     
155         return vx_send_msg(chip, &rmh);
156 }
157 
158 
159 /*
160  * vx_set_format - set the format of a pipe
161  * @pipe: the affected pipe
162  * @runtime: pcm runtime instance to be referred
163  *
164  * returns 0 if successful, or a negative error code.
165  */
166 static int vx_set_format(struct vx_core *chip, struct vx_pipe *pipe,
167                          struct snd_pcm_runtime *runtime)
168 {
169         unsigned int header = HEADER_FMT_BASE;
170 
171         if (runtime->channels == 1)
172                 header |= HEADER_FMT_MONO;
173         if (snd_pcm_format_little_endian(runtime->format))
174                 header |= HEADER_FMT_INTEL;
175         if (runtime->rate < 32000 && runtime->rate > 11025)
176                 header |= HEADER_FMT_UPTO32;
177         else if (runtime->rate <= 11025)
178                 header |= HEADER_FMT_UPTO11;
179 
180         switch (snd_pcm_format_physical_width(runtime->format)) {
181         // case 8: break;
182         case 16: header |= HEADER_FMT_16BITS; break;
183         case 24: header |= HEADER_FMT_24BITS; break;
184         default : 
185                 snd_BUG();
186                 return -EINVAL;
187         }
188 
189         return vx_set_stream_format(chip, pipe, header);
190 }
191 
192 /*
193  * set / query the IBL size
194  */
195 static int vx_set_ibl(struct vx_core *chip, struct vx_ibl_info *info)
196 {
197         int err;
198         struct vx_rmh rmh;
199 
200         vx_init_rmh(&rmh, CMD_IBL);
201         rmh.Cmd[0] |= info->size & 0x03ffff;
202         err = vx_send_msg(chip, &rmh);
203         if (err < 0)
204                 return err;
205         info->size = rmh.Stat[0];
206         info->max_size = rmh.Stat[1];
207         info->min_size = rmh.Stat[2];
208         info->granularity = rmh.Stat[3];
209         snd_printdd(KERN_DEBUG "vx_set_ibl: size = %d, max = %d, min = %d, gran = %d\n",
210                    info->size, info->max_size, info->min_size, info->granularity);
211         return 0;
212 }
213 
214 
215 /*
216  * vx_get_pipe_state - get the state of a pipe
217  * @pipe: the pipe to be checked
218  * @state: the pointer for the returned state
219  *
220  * checks the state of a given pipe, and stores the state (1 = running,
221  * 0 = paused) on the given pointer.
222  *
223  * called from trigger callback only
224  */
225 static int vx_get_pipe_state(struct vx_core *chip, struct vx_pipe *pipe, int *state)
226 {
227         int err;
228         struct vx_rmh rmh;
229 
230         vx_init_rmh(&rmh, CMD_PIPE_STATE);
231         vx_set_pipe_cmd_params(&rmh, pipe->is_capture, pipe->number, 0);
232         err = vx_send_msg_nolock(chip, &rmh); /* no lock needed for trigger */ 
233         if (! err)
234                 *state = (rmh.Stat[0] & (1 << pipe->number)) ? 1 : 0;
235         return err;
236 }
237 
238 
239 /*
240  * vx_query_hbuffer_size - query available h-buffer size in bytes
241  * @pipe: the pipe to be checked
242  *
243  * return the available size on h-buffer in bytes,
244  * or a negative error code.
245  *
246  * NOTE: calling this function always switches to the stream mode.
247  *       you'll need to disconnect the host to get back to the
248  *       normal mode.
249  */
250 static int vx_query_hbuffer_size(struct vx_core *chip, struct vx_pipe *pipe)
251 {
252         int result;
253         struct vx_rmh rmh;
254 
255         vx_init_rmh(&rmh, CMD_SIZE_HBUFFER);
256         vx_set_pipe_cmd_params(&rmh, pipe->is_capture, pipe->number, 0);
257         if (pipe->is_capture)
258                 rmh.Cmd[0] |= 0x00000001;
259         result = vx_send_msg(chip, &rmh);
260         if (! result)
261                 result = rmh.Stat[0] & 0xffff;
262         return result;
263 }
264 
265 
266 /*
267  * vx_pipe_can_start - query whether a pipe is ready for start
268  * @pipe: the pipe to be checked
269  *
270  * return 1 if ready, 0 if not ready, and negative value on error.
271  *
272  * called from trigger callback only
273  */
274 static int vx_pipe_can_start(struct vx_core *chip, struct vx_pipe *pipe)
275 {
276         int err;
277         struct vx_rmh rmh;
278         
279         vx_init_rmh(&rmh, CMD_CAN_START_PIPE);
280         vx_set_pipe_cmd_params(&rmh, pipe->is_capture, pipe->number, 0);
281         rmh.Cmd[0] |= 1;
282 
283         err = vx_send_msg_nolock(chip, &rmh); /* no lock needed for trigger */ 
284         if (! err) {
285                 if (rmh.Stat[0])
286                         err = 1;
287         }
288         return err;
289 }
290 
291 /*
292  * vx_conf_pipe - tell the pipe to stand by and wait for IRQA.
293  * @pipe: the pipe to be configured
294  */
295 static int vx_conf_pipe(struct vx_core *chip, struct vx_pipe *pipe)
296 {
297         struct vx_rmh rmh;
298 
299         vx_init_rmh(&rmh, CMD_CONF_PIPE);
300         if (pipe->is_capture)
301                 rmh.Cmd[0] |= COMMAND_RECORD_MASK;
302         rmh.Cmd[1] = 1 << pipe->number;
303         return vx_send_msg_nolock(chip, &rmh); /* no lock needed for trigger */
304 }
305 
306 /*
307  * vx_send_irqa - trigger IRQA
308  */
309 static int vx_send_irqa(struct vx_core *chip)
310 {
311         struct vx_rmh rmh;
312 
313         vx_init_rmh(&rmh, CMD_SEND_IRQA);
314         return vx_send_msg_nolock(chip, &rmh); /* no lock needed for trigger */ 
315 }
316 
317 
318 #define MAX_WAIT_FOR_DSP        250
319 /*
320  * vx boards do not support inter-card sync, besides
321  * only 126 samples require to be prepared before a pipe can start
322  */
323 #define CAN_START_DELAY         2       /* wait 2ms only before asking if the pipe is ready*/
324 #define WAIT_STATE_DELAY        2       /* wait 2ms after irqA was requested and check if the pipe state toggled*/
325 
326 /*
327  * vx_toggle_pipe - start / pause a pipe
328  * @pipe: the pipe to be triggered
329  * @state: start = 1, pause = 0
330  *
331  * called from trigger callback only
332  *
333  */
334 static int vx_toggle_pipe(struct vx_core *chip, struct vx_pipe *pipe, int state)
335 {
336         int err, i, cur_state;
337 
338         /* Check the pipe is not already in the requested state */
339         if (vx_get_pipe_state(chip, pipe, &cur_state) < 0)
340                 return -EBADFD;
341         if (state == cur_state)
342                 return 0;
343 
344         /* If a start is requested, ask the DSP to get prepared
345          * and wait for a positive acknowledge (when there are
346          * enough sound buffer for this pipe)
347          */
348         if (state) {
349                 for (i = 0 ; i < MAX_WAIT_FOR_DSP; i++) {
350                         err = vx_pipe_can_start(chip, pipe);
351                         if (err > 0)
352                                 break;
353                         /* Wait for a few, before asking again
354                          * to avoid flooding the DSP with our requests
355                          */
356                         mdelay(1);
357                 }
358         }
359     
360         if ((err = vx_conf_pipe(chip, pipe)) < 0)
361                 return err;
362 
363         if ((err = vx_send_irqa(chip)) < 0)
364                 return err;
365     
366         /* If it completes successfully, wait for the pipes
367          * reaching the expected state before returning
368          * Check one pipe only (since they are synchronous)
369          */
370         for (i = 0; i < MAX_WAIT_FOR_DSP; i++) {
371                 err = vx_get_pipe_state(chip, pipe, &cur_state);
372                 if (err < 0 || cur_state == state)
373                         break;
374                 err = -EIO;
375                 mdelay(1);
376         }
377         return err < 0 ? -EIO : 0;
378 }
379 
380     
381 /*
382  * vx_stop_pipe - stop a pipe
383  * @pipe: the pipe to be stopped
384  *
385  * called from trigger callback only
386  */
387 static int vx_stop_pipe(struct vx_core *chip, struct vx_pipe *pipe)
388 {
389         struct vx_rmh rmh;
390         vx_init_rmh(&rmh, CMD_STOP_PIPE);
391         vx_set_pipe_cmd_params(&rmh, pipe->is_capture, pipe->number, 0);
392         return vx_send_msg_nolock(chip, &rmh); /* no lock needed for trigger */ 
393 }
394 
395 
396 /*
397  * vx_alloc_pipe - allocate a pipe and initialize the pipe instance
398  * @capture: 0 = playback, 1 = capture operation
399  * @audioid: the audio id to be assigned
400  * @num_audio: number of audio channels
401  * @pipep: the returned pipe instance
402  *
403  * return 0 on success, or a negative error code.
404  */
405 static int vx_alloc_pipe(struct vx_core *chip, int capture,
406                          int audioid, int num_audio,
407                          struct vx_pipe **pipep)
408 {
409         int err;
410         struct vx_pipe *pipe;
411         struct vx_rmh rmh;
412         int data_mode;
413 
414         *pipep = NULL;
415         vx_init_rmh(&rmh, CMD_RES_PIPE);
416         vx_set_pipe_cmd_params(&rmh, capture, audioid, num_audio);
417 #if 0   // NYI
418         if (underrun_skip_sound)
419                 rmh.Cmd[0] |= BIT_SKIP_SOUND;
420 #endif  // NYI
421         data_mode = (chip->uer_bits & IEC958_AES0_NONAUDIO) != 0;
422         if (! capture && data_mode)
423                 rmh.Cmd[0] |= BIT_DATA_MODE;
424         err = vx_send_msg(chip, &rmh);
425         if (err < 0)
426                 return err;
427 
428         /* initialize the pipe record */
429         pipe = kzalloc(sizeof(*pipe), GFP_KERNEL);
430         if (! pipe) {
431                 /* release the pipe */
432                 vx_init_rmh(&rmh, CMD_FREE_PIPE);
433                 vx_set_pipe_cmd_params(&rmh, capture, audioid, 0);
434                 vx_send_msg(chip, &rmh);
435                 return -ENOMEM;
436         }
437 
438         /* the pipe index should be identical with the audio index */
439         pipe->number = audioid;
440         pipe->is_capture = capture;
441         pipe->channels = num_audio;
442         pipe->differed_type = 0;
443         pipe->pcx_time = 0;
444         pipe->data_mode = data_mode;
445         *pipep = pipe;
446 
447         return 0;
448 }
449 
450 
451 /*
452  * vx_free_pipe - release a pipe
453  * @pipe: pipe to be released
454  */
455 static int vx_free_pipe(struct vx_core *chip, struct vx_pipe *pipe)
456 {
457         struct vx_rmh rmh;
458 
459         vx_init_rmh(&rmh, CMD_FREE_PIPE);
460         vx_set_pipe_cmd_params(&rmh, pipe->is_capture, pipe->number, 0);
461         vx_send_msg(chip, &rmh);
462 
463         kfree(pipe);
464         return 0;
465 }
466 
467 
468 /*
469  * vx_start_stream - start the stream
470  *
471  * called from trigger callback only
472  */
473 static int vx_start_stream(struct vx_core *chip, struct vx_pipe *pipe)
474 {
475         struct vx_rmh rmh;
476 
477         vx_init_rmh(&rmh, CMD_START_ONE_STREAM);
478         vx_set_stream_cmd_params(&rmh, pipe->is_capture, pipe->number);
479         vx_set_differed_time(chip, &rmh, pipe);
480         return vx_send_msg_nolock(chip, &rmh); /* no lock needed for trigger */ 
481 }
482 
483 
484 /*
485  * vx_stop_stream - stop the stream
486  *
487  * called from trigger callback only
488  */
489 static int vx_stop_stream(struct vx_core *chip, struct vx_pipe *pipe)
490 {
491         struct vx_rmh rmh;
492 
493         vx_init_rmh(&rmh, CMD_STOP_STREAM);
494         vx_set_stream_cmd_params(&rmh, pipe->is_capture, pipe->number);
495         return vx_send_msg_nolock(chip, &rmh); /* no lock needed for trigger */ 
496 }
497 
498 
499 /*
500  * playback hw information
501  */
502 
503 static struct snd_pcm_hardware vx_pcm_playback_hw = {
504         .info =                 (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
505                                  SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_MMAP_VALID /*|*/
506                                  /*SNDRV_PCM_INFO_RESUME*/),
507         .formats =              (/*SNDRV_PCM_FMTBIT_U8 |*/
508                                  SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S24_3LE),
509         .rates =                SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_48000,
510         .rate_min =             5000,
511         .rate_max =             48000,
512         .channels_min =         1,
513         .channels_max =         2,
514         .buffer_bytes_max =     (128*1024),
515         .period_bytes_min =     126,
516         .period_bytes_max =     (128*1024),
517         .periods_min =          2,
518         .periods_max =          VX_MAX_PERIODS,
519         .fifo_size =            126,
520 };
521 
522 
523 static void vx_pcm_delayed_start(unsigned long arg);
524 
525 /*
526  * vx_pcm_playback_open - open callback for playback
527  */
528 static int vx_pcm_playback_open(struct snd_pcm_substream *subs)
529 {
530         struct snd_pcm_runtime *runtime = subs->runtime;
531         struct vx_core *chip = snd_pcm_substream_chip(subs);
532         struct vx_pipe *pipe = NULL;
533         unsigned int audio;
534         int err;
535 
536         if (chip->chip_status & VX_STAT_IS_STALE)
537                 return -EBUSY;
538 
539         audio = subs->pcm->device * 2;
540         if (snd_BUG_ON(audio >= chip->audio_outs))
541                 return -EINVAL;
542         
543         /* playback pipe may have been already allocated for monitoring */
544         pipe = chip->playback_pipes[audio];
545         if (! pipe) {
546                 /* not allocated yet */
547                 err = vx_alloc_pipe(chip, 0, audio, 2, &pipe); /* stereo playback */
548                 if (err < 0)
549                         return err;
550                 chip->playback_pipes[audio] = pipe;
551         }
552         /* open for playback */
553         pipe->references++;
554 
555         pipe->substream = subs;
556         tasklet_init(&pipe->start_tq, vx_pcm_delayed_start, (unsigned long)subs);
557         chip->playback_pipes[audio] = pipe;
558 
559         runtime->hw = vx_pcm_playback_hw;
560         runtime->hw.period_bytes_min = chip->ibl.size;
561         runtime->private_data = pipe;
562 
563         /* align to 4 bytes (otherwise will be problematic when 24bit is used) */ 
564         snd_pcm_hw_constraint_step(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, 4);
565         snd_pcm_hw_constraint_step(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_BYTES, 4);
566 
567         return 0;
568 }
569 
570 /*
571  * vx_pcm_playback_close - close callback for playback
572  */
573 static int vx_pcm_playback_close(struct snd_pcm_substream *subs)
574 {
575         struct vx_core *chip = snd_pcm_substream_chip(subs);
576         struct vx_pipe *pipe;
577 
578         if (! subs->runtime->private_data)
579                 return -EINVAL;
580 
581         pipe = subs->runtime->private_data;
582 
583         if (--pipe->references == 0) {
584                 chip->playback_pipes[pipe->number] = NULL;
585                 vx_free_pipe(chip, pipe);
586         }
587 
588         return 0;
589 
590 }
591 
592 
593 /*
594  * vx_notify_end_of_buffer - send "end-of-buffer" notifier at the given pipe
595  * @pipe: the pipe to notify
596  *
597  * NB: call with a certain lock.
598  */
599 static int vx_notify_end_of_buffer(struct vx_core *chip, struct vx_pipe *pipe)
600 {
601         int err;
602         struct vx_rmh rmh;  /* use a temporary rmh here */
603 
604         /* Toggle Dsp Host Interface into Message mode */
605         vx_send_rih_nolock(chip, IRQ_PAUSE_START_CONNECT);
606         vx_init_rmh(&rmh, CMD_NOTIFY_END_OF_BUFFER);
607         vx_set_stream_cmd_params(&rmh, 0, pipe->number);
608         err = vx_send_msg_nolock(chip, &rmh);
609         if (err < 0)
610                 return err;
611         /* Toggle Dsp Host Interface back to sound transfer mode */
612         vx_send_rih_nolock(chip, IRQ_PAUSE_START_CONNECT);
613         return 0;
614 }
615 
616 /*
617  * vx_pcm_playback_transfer_chunk - transfer a single chunk
618  * @subs: substream
619  * @pipe: the pipe to transfer
620  * @size: chunk size in bytes
621  *
622  * transfer a single buffer chunk.  EOB notificaton is added after that.
623  * called from the interrupt handler, too.
624  *
625  * return 0 if ok.
626  */
627 static int vx_pcm_playback_transfer_chunk(struct vx_core *chip,
628                                           struct snd_pcm_runtime *runtime,
629                                           struct vx_pipe *pipe, int size)
630 {
631         int space, err = 0;
632 
633         space = vx_query_hbuffer_size(chip, pipe);
634         if (space < 0) {
635                 /* disconnect the host, SIZE_HBUF command always switches to the stream mode */
636                 vx_send_rih(chip, IRQ_CONNECT_STREAM_NEXT);
637                 snd_printd("error hbuffer\n");
638                 return space;
639         }
640         if (space < size) {
641                 vx_send_rih(chip, IRQ_CONNECT_STREAM_NEXT);
642                 snd_printd("no enough hbuffer space %d\n", space);
643                 return -EIO; /* XRUN */
644         }
645                 
646         /* we don't need irqsave here, because this function
647          * is called from either trigger callback or irq handler
648          */
649         spin_lock(&chip->lock); 
650         vx_pseudo_dma_write(chip, runtime, pipe, size);
651         err = vx_notify_end_of_buffer(chip, pipe);
652         /* disconnect the host, SIZE_HBUF command always switches to the stream mode */
653         vx_send_rih_nolock(chip, IRQ_CONNECT_STREAM_NEXT);
654         spin_unlock(&chip->lock);
655         return err;
656 }
657 
658 /*
659  * update the position of the given pipe.
660  * pipe->position is updated and wrapped within the buffer size.
661  * pipe->transferred is updated, too, but the size is not wrapped,
662  * so that the caller can check the total transferred size later
663  * (to call snd_pcm_period_elapsed).
664  */
665 static int vx_update_pipe_position(struct vx_core *chip,
666                                    struct snd_pcm_runtime *runtime,
667                                    struct vx_pipe *pipe)
668 {
669         struct vx_rmh rmh;
670         int err, update;
671         u64 count;
672 
673         vx_init_rmh(&rmh, CMD_STREAM_SAMPLE_COUNT);
674         vx_set_pipe_cmd_params(&rmh, pipe->is_capture, pipe->number, 0);
675         err = vx_send_msg(chip, &rmh);
676         if (err < 0)
677                 return err;
678 
679         count = ((u64)(rmh.Stat[0] & 0xfffff) << 24) | (u64)rmh.Stat[1];
680         update = (int)(count - pipe->cur_count);
681         pipe->cur_count = count;
682         pipe->position += update;
683         if (pipe->position >= (int)runtime->buffer_size)
684                 pipe->position %= runtime->buffer_size;
685         pipe->transferred += update;
686         return 0;
687 }
688 
689 /*
690  * transfer the pending playback buffer data to DSP
691  * called from interrupt handler
692  */
693 static void vx_pcm_playback_transfer(struct vx_core *chip,
694                                      struct snd_pcm_substream *subs,
695                                      struct vx_pipe *pipe, int nchunks)
696 {
697         int i, err;
698         struct snd_pcm_runtime *runtime = subs->runtime;
699 
700         if (! pipe->prepared || (chip->chip_status & VX_STAT_IS_STALE))
701                 return;
702         for (i = 0; i < nchunks; i++) {
703                 if ((err = vx_pcm_playback_transfer_chunk(chip, runtime, pipe,
704                                                           chip->ibl.size)) < 0)
705                         return;
706         }
707 }
708 
709 /*
710  * update the playback position and call snd_pcm_period_elapsed() if necessary
711  * called from interrupt handler
712  */
713 static void vx_pcm_playback_update(struct vx_core *chip,
714                                    struct snd_pcm_substream *subs,
715                                    struct vx_pipe *pipe)
716 {
717         int err;
718         struct snd_pcm_runtime *runtime = subs->runtime;
719 
720         if (pipe->running && ! (chip->chip_status & VX_STAT_IS_STALE)) {
721                 if ((err = vx_update_pipe_position(chip, runtime, pipe)) < 0)
722                         return;
723                 if (pipe->transferred >= (int)runtime->period_size) {
724                         pipe->transferred %= runtime->period_size;
725                         snd_pcm_period_elapsed(subs);
726                 }
727         }
728 }
729 
730 /*
731  * start the stream and pipe.
732  * this function is called from tasklet, which is invoked by the trigger
733  * START callback.
734  */
735 static void vx_pcm_delayed_start(unsigned long arg)
736 {
737         struct snd_pcm_substream *subs = (struct snd_pcm_substream *)arg;
738         struct vx_core *chip = subs->pcm->private_data;
739         struct vx_pipe *pipe = subs->runtime->private_data;
740         int err;
741 
742         /*  printk( KERN_DEBUG "DDDD tasklet delayed start jiffies = %ld\n", jiffies);*/
743 
744         if ((err = vx_start_stream(chip, pipe)) < 0) {
745                 snd_printk(KERN_ERR "vx: cannot start stream\n");
746                 return;
747         }
748         if ((err = vx_toggle_pipe(chip, pipe, 1)) < 0) {
749                 snd_printk(KERN_ERR "vx: cannot start pipe\n");
750                 return;
751         }
752         /*   printk( KERN_DEBUG "dddd tasklet delayed start jiffies = %ld \n", jiffies);*/
753 }
754 
755 /*
756  * vx_pcm_playback_trigger - trigger callback for playback
757  */
758 static int vx_pcm_trigger(struct snd_pcm_substream *subs, int cmd)
759 {
760         struct vx_core *chip = snd_pcm_substream_chip(subs);
761         struct vx_pipe *pipe = subs->runtime->private_data;
762         int err;
763 
764         if (chip->chip_status & VX_STAT_IS_STALE)
765                 return -EBUSY;
766                 
767         switch (cmd) {
768         case SNDRV_PCM_TRIGGER_START:
769         case SNDRV_PCM_TRIGGER_RESUME:
770                 if (! pipe->is_capture)
771                         vx_pcm_playback_transfer(chip, subs, pipe, 2);
772                 /* FIXME:
773                  * we trigger the pipe using tasklet, so that the interrupts are
774                  * issued surely after the trigger is completed.
775                  */ 
776                 tasklet_schedule(&pipe->start_tq);
777                 chip->pcm_running++;
778                 pipe->running = 1;
779                 break;
780         case SNDRV_PCM_TRIGGER_STOP:
781         case SNDRV_PCM_TRIGGER_SUSPEND:
782                 vx_toggle_pipe(chip, pipe, 0);
783                 vx_stop_pipe(chip, pipe);
784                 vx_stop_stream(chip, pipe);
785                 chip->pcm_running--;
786                 pipe->running = 0;
787                 break;
788         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
789                 if ((err = vx_toggle_pipe(chip, pipe, 0)) < 0)
790                         return err;
791                 break;
792         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
793                 if ((err = vx_toggle_pipe(chip, pipe, 1)) < 0)
794                         return err;
795                 break;
796         default:
797                 return -EINVAL;
798         }
799         return 0;
800 }
801 
802 /*
803  * vx_pcm_playback_pointer - pointer callback for playback
804  */
805 static snd_pcm_uframes_t vx_pcm_playback_pointer(struct snd_pcm_substream *subs)
806 {
807         struct snd_pcm_runtime *runtime = subs->runtime;
808         struct vx_pipe *pipe = runtime->private_data;
809         return pipe->position;
810 }
811 
812 /*
813  * vx_pcm_hw_params - hw_params callback for playback and capture
814  */
815 static int vx_pcm_hw_params(struct snd_pcm_substream *subs,
816                                      struct snd_pcm_hw_params *hw_params)
817 {
818         return snd_pcm_lib_alloc_vmalloc_32_buffer
819                                         (subs, params_buffer_bytes(hw_params));
820 }
821 
822 /*
823  * vx_pcm_hw_free - hw_free callback for playback and capture
824  */
825 static int vx_pcm_hw_free(struct snd_pcm_substream *subs)
826 {
827         return snd_pcm_lib_free_vmalloc_buffer(subs);
828 }
829 
830 /*
831  * vx_pcm_prepare - prepare callback for playback and capture
832  */
833 static int vx_pcm_prepare(struct snd_pcm_substream *subs)
834 {
835         struct vx_core *chip = snd_pcm_substream_chip(subs);
836         struct snd_pcm_runtime *runtime = subs->runtime;
837         struct vx_pipe *pipe = runtime->private_data;
838         int err, data_mode;
839         // int max_size, nchunks;
840 
841         if (chip->chip_status & VX_STAT_IS_STALE)
842                 return -EBUSY;
843 
844         data_mode = (chip->uer_bits & IEC958_AES0_NONAUDIO) != 0;
845         if (data_mode != pipe->data_mode && ! pipe->is_capture) {
846                 /* IEC958 status (raw-mode) was changed */
847                 /* we reopen the pipe */
848                 struct vx_rmh rmh;
849                 snd_printdd(KERN_DEBUG "reopen the pipe with data_mode = %d\n", data_mode);
850                 vx_init_rmh(&rmh, CMD_FREE_PIPE);
851                 vx_set_pipe_cmd_params(&rmh, 0, pipe->number, 0);
852                 if ((err = vx_send_msg(chip, &rmh)) < 0)
853                         return err;
854                 vx_init_rmh(&rmh, CMD_RES_PIPE);
855                 vx_set_pipe_cmd_params(&rmh, 0, pipe->number, pipe->channels);
856                 if (data_mode)
857                         rmh.Cmd[0] |= BIT_DATA_MODE;
858                 if ((err = vx_send_msg(chip, &rmh)) < 0)
859                         return err;
860                 pipe->data_mode = data_mode;
861         }
862 
863         if (chip->pcm_running && chip->freq != runtime->rate) {
864                 snd_printk(KERN_ERR "vx: cannot set different clock %d "
865                            "from the current %d\n", runtime->rate, chip->freq);
866                 return -EINVAL;
867         }
868         vx_set_clock(chip, runtime->rate);
869 
870         if ((err = vx_set_format(chip, pipe, runtime)) < 0)
871                 return err;
872 
873         if (vx_is_pcmcia(chip)) {
874                 pipe->align = 2; /* 16bit word */
875         } else {
876                 pipe->align = 4; /* 32bit word */
877         }
878 
879         pipe->buffer_bytes = frames_to_bytes(runtime, runtime->buffer_size);
880         pipe->period_bytes = frames_to_bytes(runtime, runtime->period_size);
881         pipe->hw_ptr = 0;
882 
883         /* set the timestamp */
884         vx_update_pipe_position(chip, runtime, pipe);
885         /* clear again */
886         pipe->transferred = 0;
887         pipe->position = 0;
888 
889         pipe->prepared = 1;
890 
891         return 0;
892 }
893 
894 
895 /*
896  * operators for PCM playback
897  */
898 static struct snd_pcm_ops vx_pcm_playback_ops = {
899         .open =         vx_pcm_playback_open,
900         .close =        vx_pcm_playback_close,
901         .ioctl =        snd_pcm_lib_ioctl,
902         .hw_params =    vx_pcm_hw_params,
903         .hw_free =      vx_pcm_hw_free,
904         .prepare =      vx_pcm_prepare,
905         .trigger =      vx_pcm_trigger,
906         .pointer =      vx_pcm_playback_pointer,
907         .page =         snd_pcm_lib_get_vmalloc_page,
908         .mmap =         snd_pcm_lib_mmap_vmalloc,
909 };
910 
911 
912 /*
913  * playback hw information
914  */
915 
916 static struct snd_pcm_hardware vx_pcm_capture_hw = {
917         .info =                 (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
918                                  SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_MMAP_VALID /*|*/
919                                  /*SNDRV_PCM_INFO_RESUME*/),
920         .formats =              (/*SNDRV_PCM_FMTBIT_U8 |*/
921                                  SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S24_3LE),
922         .rates =                SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_48000,
923         .rate_min =             5000,
924         .rate_max =             48000,
925         .channels_min =         1,
926         .channels_max =         2,
927         .buffer_bytes_max =     (128*1024),
928         .period_bytes_min =     126,
929         .period_bytes_max =     (128*1024),
930         .periods_min =          2,
931         .periods_max =          VX_MAX_PERIODS,
932         .fifo_size =            126,
933 };
934 
935 
936 /*
937  * vx_pcm_capture_open - open callback for capture
938  */
939 static int vx_pcm_capture_open(struct snd_pcm_substream *subs)
940 {
941         struct snd_pcm_runtime *runtime = subs->runtime;
942         struct vx_core *chip = snd_pcm_substream_chip(subs);
943         struct vx_pipe *pipe;
944         struct vx_pipe *pipe_out_monitoring = NULL;
945         unsigned int audio;
946         int err;
947 
948         if (chip->chip_status & VX_STAT_IS_STALE)
949                 return -EBUSY;
950 
951         audio = subs->pcm->device * 2;
952         if (snd_BUG_ON(audio >= chip->audio_ins))
953                 return -EINVAL;
954         err = vx_alloc_pipe(chip, 1, audio, 2, &pipe);
955         if (err < 0)
956                 return err;
957         pipe->substream = subs;
958         tasklet_init(&pipe->start_tq, vx_pcm_delayed_start, (unsigned long)subs);
959         chip->capture_pipes[audio] = pipe;
960 
961         /* check if monitoring is needed */
962         if (chip->audio_monitor_active[audio]) {
963                 pipe_out_monitoring = chip->playback_pipes[audio];
964                 if (! pipe_out_monitoring) {
965                         /* allocate a pipe */
966                         err = vx_alloc_pipe(chip, 0, audio, 2, &pipe_out_monitoring);
967                         if (err < 0)
968                                 return err;
969                         chip->playback_pipes[audio] = pipe_out_monitoring;
970                 }
971                 pipe_out_monitoring->references++;
972                 /* 
973                    if an output pipe is available, it's audios still may need to be 
974                    unmuted. hence we'll have to call a mixer entry point.
975                 */
976                 vx_set_monitor_level(chip, audio, chip->audio_monitor[audio],
977                                      chip->audio_monitor_active[audio]);
978                 /* assuming stereo */
979                 vx_set_monitor_level(chip, audio+1, chip->audio_monitor[audio+1],
980                                      chip->audio_monitor_active[audio+1]); 
981         }
982 
983         pipe->monitoring_pipe = pipe_out_monitoring; /* default value NULL */
984 
985         runtime->hw = vx_pcm_capture_hw;
986         runtime->hw.period_bytes_min = chip->ibl.size;
987         runtime->private_data = pipe;
988 
989         /* align to 4 bytes (otherwise will be problematic when 24bit is used) */ 
990         snd_pcm_hw_constraint_step(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, 4);
991         snd_pcm_hw_constraint_step(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_BYTES, 4);
992 
993         return 0;
994 }
995 
996 /*
997  * vx_pcm_capture_close - close callback for capture
998  */
999 static int vx_pcm_capture_close(struct snd_pcm_substream *subs)
1000 {
1001         struct vx_core *chip = snd_pcm_substream_chip(subs);
1002         struct vx_pipe *pipe;
1003         struct vx_pipe *pipe_out_monitoring;
1004         
1005         if (! subs->runtime->private_data)
1006                 return -EINVAL;
1007         pipe = subs->runtime->private_data;
1008         chip->capture_pipes[pipe->number] = NULL;
1009 
1010         pipe_out_monitoring = pipe->monitoring_pipe;
1011 
1012         /*
1013           if an output pipe is attached to this input, 
1014           check if it needs to be released.
1015         */
1016         if (pipe_out_monitoring) {
1017                 if (--pipe_out_monitoring->references == 0) {
1018                         vx_free_pipe(chip, pipe_out_monitoring);
1019                         chip->playback_pipes[pipe->number] = NULL;
1020                         pipe->monitoring_pipe = NULL;
1021                 }
1022         }
1023         
1024         vx_free_pipe(chip, pipe);
1025         return 0;
1026 }
1027 
1028 
1029 
1030 #define DMA_READ_ALIGN  6       /* hardware alignment for read */
1031 
1032 /*
1033  * vx_pcm_capture_update - update the capture buffer
1034  */
1035 static void vx_pcm_capture_update(struct vx_core *chip, struct snd_pcm_substream *subs,
1036                                   struct vx_pipe *pipe)
1037 {
1038         int size, space, count;
1039         struct snd_pcm_runtime *runtime = subs->runtime;
1040 
1041         if (! pipe->prepared || (chip->chip_status & VX_STAT_IS_STALE))
1042                 return;
1043 
1044         size = runtime->buffer_size - snd_pcm_capture_avail(runtime);
1045         if (! size)
1046                 return;
1047         size = frames_to_bytes(runtime, size);
1048         space = vx_query_hbuffer_size(chip, pipe);
1049         if (space < 0)
1050                 goto _error;
1051         if (size > space)
1052                 size = space;
1053         size = (size / 3) * 3; /* align to 3 bytes */
1054         if (size < DMA_READ_ALIGN)
1055                 goto _error;
1056 
1057         /* keep the last 6 bytes, they will be read after disconnection */
1058         count = size - DMA_READ_ALIGN;
1059         /* read bytes until the current pointer reaches to the aligned position
1060          * for word-transfer
1061          */
1062         while (count > 0) {
1063                 if ((pipe->hw_ptr % pipe->align) == 0)
1064                         break;
1065                 if (vx_wait_for_rx_full(chip) < 0)
1066                         goto _error;
1067                 vx_pcm_read_per_bytes(chip, runtime, pipe);
1068                 count -= 3;
1069         }
1070         if (count > 0) {
1071                 /* ok, let's accelerate! */
1072                 int align = pipe->align * 3;
1073                 space = (count / align) * align;
1074                 vx_pseudo_dma_read(chip, runtime, pipe, space);
1075                 count -= space;
1076         }
1077         /* read the rest of bytes */
1078         while (count > 0) {
1079                 if (vx_wait_for_rx_full(chip) < 0)
1080                         goto _error;
1081                 vx_pcm_read_per_bytes(chip, runtime, pipe);
1082                 count -= 3;
1083         }
1084         /* disconnect the host, SIZE_HBUF command always switches to the stream mode */
1085         vx_send_rih_nolock(chip, IRQ_CONNECT_STREAM_NEXT);
1086         /* read the last pending 6 bytes */
1087         count = DMA_READ_ALIGN;
1088         while (count > 0) {
1089                 vx_pcm_read_per_bytes(chip, runtime, pipe);
1090                 count -= 3;
1091         }
1092         /* update the position */
1093         pipe->transferred += size;
1094         if (pipe->transferred >= pipe->period_bytes) {
1095                 pipe->transferred %= pipe->period_bytes;
1096                 snd_pcm_period_elapsed(subs);
1097         }
1098         return;
1099 
1100  _error:
1101         /* disconnect the host, SIZE_HBUF command always switches to the stream mode */
1102         vx_send_rih_nolock(chip, IRQ_CONNECT_STREAM_NEXT);
1103         return;
1104 }
1105 
1106 /*
1107  * vx_pcm_capture_pointer - pointer callback for capture
1108  */
1109 static snd_pcm_uframes_t vx_pcm_capture_pointer(struct snd_pcm_substream *subs)
1110 {
1111         struct snd_pcm_runtime *runtime = subs->runtime;
1112         struct vx_pipe *pipe = runtime->private_data;
1113         return bytes_to_frames(runtime, pipe->hw_ptr);
1114 }
1115 
1116 /*
1117  * operators for PCM capture
1118  */
1119 static struct snd_pcm_ops vx_pcm_capture_ops = {
1120         .open =         vx_pcm_capture_open,
1121         .close =        vx_pcm_capture_close,
1122         .ioctl =        snd_pcm_lib_ioctl,
1123         .hw_params =    vx_pcm_hw_params,
1124         .hw_free =      vx_pcm_hw_free,
1125         .prepare =      vx_pcm_prepare,
1126         .trigger =      vx_pcm_trigger,
1127         .pointer =      vx_pcm_capture_pointer,
1128         .page =         snd_pcm_lib_get_vmalloc_page,
1129         .mmap =         snd_pcm_lib_mmap_vmalloc,
1130 };
1131 
1132 
1133 /*
1134  * interrupt handler for pcm streams
1135  */
1136 void vx_pcm_update_intr(struct vx_core *chip, unsigned int events)
1137 {
1138         unsigned int i;
1139         struct vx_pipe *pipe;
1140 
1141 #define EVENT_MASK      (END_OF_BUFFER_EVENTS_PENDING|ASYNC_EVENTS_PENDING)
1142 
1143         if (events & EVENT_MASK) {
1144                 vx_init_rmh(&chip->irq_rmh, CMD_ASYNC);
1145                 if (events & ASYNC_EVENTS_PENDING)
1146                         chip->irq_rmh.Cmd[0] |= 0x00000001;     /* SEL_ASYNC_EVENTS */
1147                 if (events & END_OF_BUFFER_EVENTS_PENDING)
1148                         chip->irq_rmh.Cmd[0] |= 0x00000002;     /* SEL_END_OF_BUF_EVENTS */
1149 
1150                 if (vx_send_msg(chip, &chip->irq_rmh) < 0) {
1151                         snd_printdd(KERN_ERR "msg send error!!\n");
1152                         return;
1153                 }
1154 
1155                 i = 1;
1156                 while (i < chip->irq_rmh.LgStat) {
1157                         int p, buf, capture, eob;
1158                         p = chip->irq_rmh.Stat[i] & MASK_FIRST_FIELD;
1159                         capture = (chip->irq_rmh.Stat[i] & 0x400000) ? 1 : 0;
1160                         eob = (chip->irq_rmh.Stat[i] & 0x800000) ? 1 : 0;
1161                         i++;
1162                         if (events & ASYNC_EVENTS_PENDING)
1163                                 i++;
1164                         buf = 1; /* force to transfer */
1165                         if (events & END_OF_BUFFER_EVENTS_PENDING) {
1166                                 if (eob)
1167                                         buf = chip->irq_rmh.Stat[i];
1168                                 i++;
1169                         }
1170                         if (capture)
1171                                 continue;
1172                         if (snd_BUG_ON(p < 0 || p >= chip->audio_outs))
1173                                 continue;
1174                         pipe = chip->playback_pipes[p];
1175                         if (pipe && pipe->substream) {
1176                                 vx_pcm_playback_update(chip, pipe->substream, pipe);
1177                                 vx_pcm_playback_transfer(chip, pipe->substream, pipe, buf);
1178                         }
1179                 }
1180         }
1181 
1182         /* update the capture pcm pointers as frequently as possible */
1183         for (i = 0; i < chip->audio_ins; i++) {
1184                 pipe = chip->capture_pipes[i];
1185                 if (pipe && pipe->substream)
1186                         vx_pcm_capture_update(chip, pipe->substream, pipe);
1187         }
1188 }
1189 
1190 
1191 /*
1192  * vx_init_audio_io - check the available audio i/o and allocate pipe arrays
1193  */
1194 static int vx_init_audio_io(struct vx_core *chip)
1195 {
1196         struct vx_rmh rmh;
1197         int preferred;
1198 
1199         vx_init_rmh(&rmh, CMD_SUPPORTED);
1200         if (vx_send_msg(chip, &rmh) < 0) {
1201                 snd_printk(KERN_ERR "vx: cannot get the supported audio data\n");
1202                 return -ENXIO;
1203         }
1204 
1205         chip->audio_outs = rmh.Stat[0] & MASK_FIRST_FIELD;
1206         chip->audio_ins = (rmh.Stat[0] >> (FIELD_SIZE*2)) & MASK_FIRST_FIELD;
1207         chip->audio_info = rmh.Stat[1];
1208 
1209         /* allocate pipes */
1210         chip->playback_pipes = kcalloc(chip->audio_outs, sizeof(struct vx_pipe *), GFP_KERNEL);
1211         if (!chip->playback_pipes)
1212                 return -ENOMEM;
1213         chip->capture_pipes = kcalloc(chip->audio_ins, sizeof(struct vx_pipe *), GFP_KERNEL);
1214         if (!chip->capture_pipes) {
1215                 kfree(chip->playback_pipes);
1216                 return -ENOMEM;
1217         }
1218 
1219         preferred = chip->ibl.size;
1220         chip->ibl.size = 0;
1221         vx_set_ibl(chip, &chip->ibl); /* query the info */
1222         if (preferred > 0) {
1223                 chip->ibl.size = ((preferred + chip->ibl.granularity - 1) /
1224                                   chip->ibl.granularity) * chip->ibl.granularity;
1225                 if (chip->ibl.size > chip->ibl.max_size)
1226                         chip->ibl.size = chip->ibl.max_size;
1227         } else
1228                 chip->ibl.size = chip->ibl.min_size; /* set to the minimum */
1229         vx_set_ibl(chip, &chip->ibl);
1230 
1231         return 0;
1232 }
1233 
1234 
1235 /*
1236  * free callback for pcm
1237  */
1238 static void snd_vx_pcm_free(struct snd_pcm *pcm)
1239 {
1240         struct vx_core *chip = pcm->private_data;
1241         chip->pcm[pcm->device] = NULL;
1242         kfree(chip->playback_pipes);
1243         chip->playback_pipes = NULL;
1244         kfree(chip->capture_pipes);
1245         chip->capture_pipes = NULL;
1246 }
1247 
1248 /*
1249  * snd_vx_pcm_new - create and initialize a pcm
1250  */
1251 int snd_vx_pcm_new(struct vx_core *chip)
1252 {
1253         struct snd_pcm *pcm;
1254         unsigned int i;
1255         int err;
1256 
1257         if ((err = vx_init_audio_io(chip)) < 0)
1258                 return err;
1259 
1260         for (i = 0; i < chip->hw->num_codecs; i++) {
1261                 unsigned int outs, ins;
1262                 outs = chip->audio_outs > i * 2 ? 1 : 0;
1263                 ins = chip->audio_ins > i * 2 ? 1 : 0;
1264                 if (! outs && ! ins)
1265                         break;
1266                 err = snd_pcm_new(chip->card, "VX PCM", i,
1267                                   outs, ins, &pcm);
1268                 if (err < 0)
1269                         return err;
1270                 if (outs)
1271                         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &vx_pcm_playback_ops);
1272                 if (ins)
1273                         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &vx_pcm_capture_ops);
1274 
1275                 pcm->private_data = chip;
1276                 pcm->private_free = snd_vx_pcm_free;
1277                 pcm->info_flags = 0;
1278                 strcpy(pcm->name, chip->card->shortname);
1279                 chip->pcm[i] = pcm;
1280         }
1281 
1282         return 0;
1283 }
1284 

~ [ 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