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