git.oblomov.eu Git - linux-2.6/blob - 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 }