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