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(chip, &rmh); 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(chip, &rmh); 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(chip, &rmh); 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(chip, &rmh); 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(chip, &rmh); 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(chip, &rmh); 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(chip, &rmh); 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 /* 524 * vx_pcm_playback_open - open callback for playback 525 */ 526 static int vx_pcm_playback_open(struct snd_pcm_substream *subs) 527 { 528 struct snd_pcm_runtime *runtime = subs->runtime; 529 struct vx_core *chip = snd_pcm_substream_chip(subs); 530 struct vx_pipe *pipe = NULL; 531 unsigned int audio; 532 int err; 533 534 if (chip->chip_status & VX_STAT_IS_STALE) 535 return -EBUSY; 536 537 audio = subs->pcm->device * 2; 538 if (snd_BUG_ON(audio >= chip->audio_outs)) 539 return -EINVAL; 540 541 /* playback pipe may have been already allocated for monitoring */ 542 pipe = chip->playback_pipes[audio]; 543 if (! pipe) { 544 /* not allocated yet */ 545 err = vx_alloc_pipe(chip, 0, audio, 2, &pipe); /* stereo playback */ 546 if (err < 0) 547 return err; 548 chip->playback_pipes[audio] = pipe; 549 } 550 /* open for playback */ 551 pipe->references++; 552 553 pipe->substream = subs; 554 chip->playback_pipes[audio] = pipe; 555 556 runtime->hw = vx_pcm_playback_hw; 557 runtime->hw.period_bytes_min = chip->ibl.size; 558 runtime->private_data = pipe; 559 560 /* align to 4 bytes (otherwise will be problematic when 24bit is used) */ 561 snd_pcm_hw_constraint_step(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, 4); 562 snd_pcm_hw_constraint_step(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_BYTES, 4); 563 564 return 0; 565 } 566 567 /* 568 * vx_pcm_playback_close - close callback for playback 569 */ 570 static int vx_pcm_playback_close(struct snd_pcm_substream *subs) 571 { 572 struct vx_core *chip = snd_pcm_substream_chip(subs); 573 struct vx_pipe *pipe; 574 575 if (! subs->runtime->private_data) 576 return -EINVAL; 577 578 pipe = subs->runtime->private_data; 579 580 if (--pipe->references == 0) { 581 chip->playback_pipes[pipe->number] = NULL; 582 vx_free_pipe(chip, pipe); 583 } 584 585 return 0; 586 587 } 588 589 590 /* 591 * vx_notify_end_of_buffer - send "end-of-buffer" notifier at the given pipe 592 * @pipe: the pipe to notify 593 * 594 * NB: call with a certain lock. 595 */ 596 static int vx_notify_end_of_buffer(struct vx_core *chip, struct vx_pipe *pipe) 597 { 598 int err; 599 struct vx_rmh rmh; /* use a temporary rmh here */ 600 601 /* Toggle Dsp Host Interface into Message mode */ 602 vx_send_rih_nolock(chip, IRQ_PAUSE_START_CONNECT); 603 vx_init_rmh(&rmh, CMD_NOTIFY_END_OF_BUFFER); 604 vx_set_stream_cmd_params(&rmh, 0, pipe->number); 605 err = vx_send_msg_nolock(chip, &rmh); 606 if (err < 0) 607 return err; 608 /* Toggle Dsp Host Interface back to sound transfer mode */ 609 vx_send_rih_nolock(chip, IRQ_PAUSE_START_CONNECT); 610 return 0; 611 } 612 613 /* 614 * vx_pcm_playback_transfer_chunk - transfer a single chunk 615 * @subs: substream 616 * @pipe: the pipe to transfer 617 * @size: chunk size in bytes 618 * 619 * transfer a single buffer chunk. EOB notificaton is added after that. 620 * called from the interrupt handler, too. 621 * 622 * return 0 if ok. 623 */ 624 static int vx_pcm_playback_transfer_chunk(struct vx_core *chip, 625 struct snd_pcm_runtime *runtime, 626 struct vx_pipe *pipe, int size) 627 { 628 int space, err = 0; 629 630 space = vx_query_hbuffer_size(chip, pipe); 631 if (space < 0) { 632 /* disconnect the host, SIZE_HBUF command always switches to the stream mode */ 633 vx_send_rih(chip, IRQ_CONNECT_STREAM_NEXT); 634 snd_printd("error hbuffer\n"); 635 return space; 636 } 637 if (space < size) { 638 vx_send_rih(chip, IRQ_CONNECT_STREAM_NEXT); 639 snd_printd("no enough hbuffer space %d\n", space); 640 return -EIO; /* XRUN */ 641 } 642 643 /* we don't need irqsave here, because this function 644 * is called from either trigger callback or irq handler 645 */ 646 mutex_lock(&chip->lock); 647 vx_pseudo_dma_write(chip, runtime, pipe, size); 648 err = vx_notify_end_of_buffer(chip, pipe); 649 /* disconnect the host, SIZE_HBUF command always switches to the stream mode */ 650 vx_send_rih_nolock(chip, IRQ_CONNECT_STREAM_NEXT); 651 mutex_unlock(&chip->lock); 652 return err; 653 } 654 655 /* 656 * update the position of the given pipe. 657 * pipe->position is updated and wrapped within the buffer size. 658 * pipe->transferred is updated, too, but the size is not wrapped, 659 * so that the caller can check the total transferred size later 660 * (to call snd_pcm_period_elapsed). 661 */ 662 static int vx_update_pipe_position(struct vx_core *chip, 663 struct snd_pcm_runtime *runtime, 664 struct vx_pipe *pipe) 665 { 666 struct vx_rmh rmh; 667 int err, update; 668 u64 count; 669 670 vx_init_rmh(&rmh, CMD_STREAM_SAMPLE_COUNT); 671 vx_set_pipe_cmd_params(&rmh, pipe->is_capture, pipe->number, 0); 672 err = vx_send_msg(chip, &rmh); 673 if (err < 0) 674 return err; 675 676 count = ((u64)(rmh.Stat[0] & 0xfffff) << 24) | (u64)rmh.Stat[1]; 677 update = (int)(count - pipe->cur_count); 678 pipe->cur_count = count; 679 pipe->position += update; 680 if (pipe->position >= (int)runtime->buffer_size) 681 pipe->position %= runtime->buffer_size; 682 pipe->transferred += update; 683 return 0; 684 } 685 686 /* 687 * transfer the pending playback buffer data to DSP 688 * called from interrupt handler 689 */ 690 static void vx_pcm_playback_transfer(struct vx_core *chip, 691 struct snd_pcm_substream *subs, 692 struct vx_pipe *pipe, int nchunks) 693 { 694 int i, err; 695 struct snd_pcm_runtime *runtime = subs->runtime; 696 697 if (! pipe->prepared || (chip->chip_status & VX_STAT_IS_STALE)) 698 return; 699 for (i = 0; i < nchunks; i++) { 700 if ((err = vx_pcm_playback_transfer_chunk(chip, runtime, pipe, 701 chip->ibl.size)) < 0) 702 return; 703 } 704 } 705 706 /* 707 * update the playback position and call snd_pcm_period_elapsed() if necessary 708 * called from interrupt handler 709 */ 710 static void vx_pcm_playback_update(struct vx_core *chip, 711 struct snd_pcm_substream *subs, 712 struct vx_pipe *pipe) 713 { 714 int err; 715 struct snd_pcm_runtime *runtime = subs->runtime; 716 717 if (pipe->running && ! (chip->chip_status & VX_STAT_IS_STALE)) { 718 if ((err = vx_update_pipe_position(chip, runtime, pipe)) < 0) 719 return; 720 if (pipe->transferred >= (int)runtime->period_size) { 721 pipe->transferred %= runtime->period_size; 722 snd_pcm_period_elapsed(subs); 723 } 724 } 725 } 726 727 /* 728 * vx_pcm_playback_trigger - trigger callback for playback 729 */ 730 static int vx_pcm_trigger(struct snd_pcm_substream *subs, int cmd) 731 { 732 struct vx_core *chip = snd_pcm_substream_chip(subs); 733 struct vx_pipe *pipe = subs->runtime->private_data; 734 int err; 735 736 if (chip->chip_status & VX_STAT_IS_STALE) 737 return -EBUSY; 738 739 switch (cmd) { 740 case SNDRV_PCM_TRIGGER_START: 741 case SNDRV_PCM_TRIGGER_RESUME: 742 if (! pipe->is_capture) 743 vx_pcm_playback_transfer(chip, subs, pipe, 2); 744 err = vx_start_stream(chip, pipe); 745 if (err < 0) { 746 pr_debug("vx: cannot start stream\n"); 747 return err; 748 } 749 err = vx_toggle_pipe(chip, pipe, 1); 750 if (err < 0) { 751 pr_debug("vx: cannot start pipe\n"); 752 vx_stop_stream(chip, pipe); 753 return err; 754 } 755 chip->pcm_running++; 756 pipe->running = 1; 757 break; 758 case SNDRV_PCM_TRIGGER_STOP: 759 case SNDRV_PCM_TRIGGER_SUSPEND: 760 vx_toggle_pipe(chip, pipe, 0); 761 vx_stop_pipe(chip, pipe); 762 vx_stop_stream(chip, pipe); 763 chip->pcm_running--; 764 pipe->running = 0; 765 break; 766 case SNDRV_PCM_TRIGGER_PAUSE_PUSH: 767 if ((err = vx_toggle_pipe(chip, pipe, 0)) < 0) 768 return err; 769 break; 770 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: 771 if ((err = vx_toggle_pipe(chip, pipe, 1)) < 0) 772 return err; 773 break; 774 default: 775 return -EINVAL; 776 } 777 return 0; 778 } 779 780 /* 781 * vx_pcm_playback_pointer - pointer callback for playback 782 */ 783 static snd_pcm_uframes_t vx_pcm_playback_pointer(struct snd_pcm_substream *subs) 784 { 785 struct snd_pcm_runtime *runtime = subs->runtime; 786 struct vx_pipe *pipe = runtime->private_data; 787 return pipe->position; 788 } 789 790 /* 791 * vx_pcm_hw_params - hw_params callback for playback and capture 792 */ 793 static int vx_pcm_hw_params(struct snd_pcm_substream *subs, 794 struct snd_pcm_hw_params *hw_params) 795 { 796 return snd_pcm_lib_alloc_vmalloc_32_buffer 797 (subs, params_buffer_bytes(hw_params)); 798 } 799 800 /* 801 * vx_pcm_hw_free - hw_free callback for playback and capture 802 */ 803 static int vx_pcm_hw_free(struct snd_pcm_substream *subs) 804 { 805 return snd_pcm_lib_free_vmalloc_buffer(subs); 806 } 807 808 /* 809 * vx_pcm_prepare - prepare callback for playback and capture 810 */ 811 static int vx_pcm_prepare(struct snd_pcm_substream *subs) 812 { 813 struct vx_core *chip = snd_pcm_substream_chip(subs); 814 struct snd_pcm_runtime *runtime = subs->runtime; 815 struct vx_pipe *pipe = runtime->private_data; 816 int err, data_mode; 817 // int max_size, nchunks; 818 819 if (chip->chip_status & VX_STAT_IS_STALE) 820 return -EBUSY; 821 822 data_mode = (chip->uer_bits & IEC958_AES0_NONAUDIO) != 0; 823 if (data_mode != pipe->data_mode && ! pipe->is_capture) { 824 /* IEC958 status (raw-mode) was changed */ 825 /* we reopen the pipe */ 826 struct vx_rmh rmh; 827 snd_printdd(KERN_DEBUG "reopen the pipe with data_mode = %d\n", data_mode); 828 vx_init_rmh(&rmh, CMD_FREE_PIPE); 829 vx_set_pipe_cmd_params(&rmh, 0, pipe->number, 0); 830 if ((err = vx_send_msg(chip, &rmh)) < 0) 831 return err; 832 vx_init_rmh(&rmh, CMD_RES_PIPE); 833 vx_set_pipe_cmd_params(&rmh, 0, pipe->number, pipe->channels); 834 if (data_mode) 835 rmh.Cmd[0] |= BIT_DATA_MODE; 836 if ((err = vx_send_msg(chip, &rmh)) < 0) 837 return err; 838 pipe->data_mode = data_mode; 839 } 840 841 if (chip->pcm_running && chip->freq != runtime->rate) { 842 snd_printk(KERN_ERR "vx: cannot set different clock %d " 843 "from the current %d\n", runtime->rate, chip->freq); 844 return -EINVAL; 845 } 846 vx_set_clock(chip, runtime->rate); 847 848 if ((err = vx_set_format(chip, pipe, runtime)) < 0) 849 return err; 850 851 if (vx_is_pcmcia(chip)) { 852 pipe->align = 2; /* 16bit word */ 853 } else { 854 pipe->align = 4; /* 32bit word */ 855 } 856 857 pipe->buffer_bytes = frames_to_bytes(runtime, runtime->buffer_size); 858 pipe->period_bytes = frames_to_bytes(runtime, runtime->period_size); 859 pipe->hw_ptr = 0; 860 861 /* set the timestamp */ 862 vx_update_pipe_position(chip, runtime, pipe); 863 /* clear again */ 864 pipe->transferred = 0; 865 pipe->position = 0; 866 867 pipe->prepared = 1; 868 869 return 0; 870 } 871 872 873 /* 874 * operators for PCM playback 875 */ 876 static struct snd_pcm_ops vx_pcm_playback_ops = { 877 .open = vx_pcm_playback_open, 878 .close = vx_pcm_playback_close, 879 .ioctl = snd_pcm_lib_ioctl, 880 .hw_params = vx_pcm_hw_params, 881 .hw_free = vx_pcm_hw_free, 882 .prepare = vx_pcm_prepare, 883 .trigger = vx_pcm_trigger, 884 .pointer = vx_pcm_playback_pointer, 885 .page = snd_pcm_lib_get_vmalloc_page, 886 .mmap = snd_pcm_lib_mmap_vmalloc, 887 }; 888 889 890 /* 891 * playback hw information 892 */ 893 894 static struct snd_pcm_hardware vx_pcm_capture_hw = { 895 .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | 896 SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_MMAP_VALID /*|*/ 897 /*SNDRV_PCM_INFO_RESUME*/), 898 .formats = (/*SNDRV_PCM_FMTBIT_U8 |*/ 899 SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S24_3LE), 900 .rates = SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_48000, 901 .rate_min = 5000, 902 .rate_max = 48000, 903 .channels_min = 1, 904 .channels_max = 2, 905 .buffer_bytes_max = (128*1024), 906 .period_bytes_min = 126, 907 .period_bytes_max = (128*1024), 908 .periods_min = 2, 909 .periods_max = VX_MAX_PERIODS, 910 .fifo_size = 126, 911 }; 912 913 914 /* 915 * vx_pcm_capture_open - open callback for capture 916 */ 917 static int vx_pcm_capture_open(struct snd_pcm_substream *subs) 918 { 919 struct snd_pcm_runtime *runtime = subs->runtime; 920 struct vx_core *chip = snd_pcm_substream_chip(subs); 921 struct vx_pipe *pipe; 922 struct vx_pipe *pipe_out_monitoring = NULL; 923 unsigned int audio; 924 int err; 925 926 if (chip->chip_status & VX_STAT_IS_STALE) 927 return -EBUSY; 928 929 audio = subs->pcm->device * 2; 930 if (snd_BUG_ON(audio >= chip->audio_ins)) 931 return -EINVAL; 932 err = vx_alloc_pipe(chip, 1, audio, 2, &pipe); 933 if (err < 0) 934 return err; 935 pipe->substream = subs; 936 chip->capture_pipes[audio] = pipe; 937 938 /* check if monitoring is needed */ 939 if (chip->audio_monitor_active[audio]) { 940 pipe_out_monitoring = chip->playback_pipes[audio]; 941 if (! pipe_out_monitoring) { 942 /* allocate a pipe */ 943 err = vx_alloc_pipe(chip, 0, audio, 2, &pipe_out_monitoring); 944 if (err < 0) 945 return err; 946 chip->playback_pipes[audio] = pipe_out_monitoring; 947 } 948 pipe_out_monitoring->references++; 949 /* 950 if an output pipe is available, it's audios still may need to be 951 unmuted. hence we'll have to call a mixer entry point. 952 */ 953 vx_set_monitor_level(chip, audio, chip->audio_monitor[audio], 954 chip->audio_monitor_active[audio]); 955 /* assuming stereo */ 956 vx_set_monitor_level(chip, audio+1, chip->audio_monitor[audio+1], 957 chip->audio_monitor_active[audio+1]); 958 } 959 960 pipe->monitoring_pipe = pipe_out_monitoring; /* default value NULL */ 961 962 runtime->hw = vx_pcm_capture_hw; 963 runtime->hw.period_bytes_min = chip->ibl.size; 964 runtime->private_data = pipe; 965 966 /* align to 4 bytes (otherwise will be problematic when 24bit is used) */ 967 snd_pcm_hw_constraint_step(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, 4); 968 snd_pcm_hw_constraint_step(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_BYTES, 4); 969 970 return 0; 971 } 972 973 /* 974 * vx_pcm_capture_close - close callback for capture 975 */ 976 static int vx_pcm_capture_close(struct snd_pcm_substream *subs) 977 { 978 struct vx_core *chip = snd_pcm_substream_chip(subs); 979 struct vx_pipe *pipe; 980 struct vx_pipe *pipe_out_monitoring; 981 982 if (! subs->runtime->private_data) 983 return -EINVAL; 984 pipe = subs->runtime->private_data; 985 chip->capture_pipes[pipe->number] = NULL; 986 987 pipe_out_monitoring = pipe->monitoring_pipe; 988 989 /* 990 if an output pipe is attached to this input, 991 check if it needs to be released. 992 */ 993 if (pipe_out_monitoring) { 994 if (--pipe_out_monitoring->references == 0) { 995 vx_free_pipe(chip, pipe_out_monitoring); 996 chip->playback_pipes[pipe->number] = NULL; 997 pipe->monitoring_pipe = NULL; 998 } 999 } 1000 1001 vx_free_pipe(chip, pipe); 1002 return 0; 1003 } 1004 1005 1006 1007 #define DMA_READ_ALIGN 6 /* hardware alignment for read */ 1008 1009 /* 1010 * vx_pcm_capture_update - update the capture buffer 1011 */ 1012 static void vx_pcm_capture_update(struct vx_core *chip, struct snd_pcm_substream *subs, 1013 struct vx_pipe *pipe) 1014 { 1015 int size, space, count; 1016 struct snd_pcm_runtime *runtime = subs->runtime; 1017 1018 if (! pipe->prepared || (chip->chip_status & VX_STAT_IS_STALE)) 1019 return; 1020 1021 size = runtime->buffer_size - snd_pcm_capture_avail(runtime); 1022 if (! size) 1023 return; 1024 size = frames_to_bytes(runtime, size); 1025 space = vx_query_hbuffer_size(chip, pipe); 1026 if (space < 0) 1027 goto _error; 1028 if (size > space) 1029 size = space; 1030 size = (size / 3) * 3; /* align to 3 bytes */ 1031 if (size < DMA_READ_ALIGN) 1032 goto _error; 1033 1034 /* keep the last 6 bytes, they will be read after disconnection */ 1035 count = size - DMA_READ_ALIGN; 1036 /* read bytes until the current pointer reaches to the aligned position 1037 * for word-transfer 1038 */ 1039 while (count > 0) { 1040 if ((pipe->hw_ptr % pipe->align) == 0) 1041 break; 1042 if (vx_wait_for_rx_full(chip) < 0) 1043 goto _error; 1044 vx_pcm_read_per_bytes(chip, runtime, pipe); 1045 count -= 3; 1046 } 1047 if (count > 0) { 1048 /* ok, let's accelerate! */ 1049 int align = pipe->align * 3; 1050 space = (count / align) * align; 1051 vx_pseudo_dma_read(chip, runtime, pipe, space); 1052 count -= space; 1053 } 1054 /* read the rest of bytes */ 1055 while (count > 0) { 1056 if (vx_wait_for_rx_full(chip) < 0) 1057 goto _error; 1058 vx_pcm_read_per_bytes(chip, runtime, pipe); 1059 count -= 3; 1060 } 1061 /* disconnect the host, SIZE_HBUF command always switches to the stream mode */ 1062 vx_send_rih(chip, IRQ_CONNECT_STREAM_NEXT); 1063 /* read the last pending 6 bytes */ 1064 count = DMA_READ_ALIGN; 1065 while (count > 0) { 1066 vx_pcm_read_per_bytes(chip, runtime, pipe); 1067 count -= 3; 1068 } 1069 /* update the position */ 1070 pipe->transferred += size; 1071 if (pipe->transferred >= pipe->period_bytes) { 1072 pipe->transferred %= pipe->period_bytes; 1073 snd_pcm_period_elapsed(subs); 1074 } 1075 return; 1076 1077 _error: 1078 /* disconnect the host, SIZE_HBUF command always switches to the stream mode */ 1079 vx_send_rih(chip, IRQ_CONNECT_STREAM_NEXT); 1080 return; 1081 } 1082 1083 /* 1084 * vx_pcm_capture_pointer - pointer callback for capture 1085 */ 1086 static snd_pcm_uframes_t vx_pcm_capture_pointer(struct snd_pcm_substream *subs) 1087 { 1088 struct snd_pcm_runtime *runtime = subs->runtime; 1089 struct vx_pipe *pipe = runtime->private_data; 1090 return bytes_to_frames(runtime, pipe->hw_ptr); 1091 } 1092 1093 /* 1094 * operators for PCM capture 1095 */ 1096 static struct snd_pcm_ops vx_pcm_capture_ops = { 1097 .open = vx_pcm_capture_open, 1098 .close = vx_pcm_capture_close, 1099 .ioctl = snd_pcm_lib_ioctl, 1100 .hw_params = vx_pcm_hw_params, 1101 .hw_free = vx_pcm_hw_free, 1102 .prepare = vx_pcm_prepare, 1103 .trigger = vx_pcm_trigger, 1104 .pointer = vx_pcm_capture_pointer, 1105 .page = snd_pcm_lib_get_vmalloc_page, 1106 .mmap = snd_pcm_lib_mmap_vmalloc, 1107 }; 1108 1109 1110 /* 1111 * interrupt handler for pcm streams 1112 */ 1113 void vx_pcm_update_intr(struct vx_core *chip, unsigned int events) 1114 { 1115 unsigned int i; 1116 struct vx_pipe *pipe; 1117 1118 #define EVENT_MASK (END_OF_BUFFER_EVENTS_PENDING|ASYNC_EVENTS_PENDING) 1119 1120 if (events & EVENT_MASK) { 1121 vx_init_rmh(&chip->irq_rmh, CMD_ASYNC); 1122 if (events & ASYNC_EVENTS_PENDING) 1123 chip->irq_rmh.Cmd[0] |= 0x00000001; /* SEL_ASYNC_EVENTS */ 1124 if (events & END_OF_BUFFER_EVENTS_PENDING) 1125 chip->irq_rmh.Cmd[0] |= 0x00000002; /* SEL_END_OF_BUF_EVENTS */ 1126 1127 if (vx_send_msg(chip, &chip->irq_rmh) < 0) { 1128 snd_printdd(KERN_ERR "msg send error!!\n"); 1129 return; 1130 } 1131 1132 i = 1; 1133 while (i < chip->irq_rmh.LgStat) { 1134 int p, buf, capture, eob; 1135 p = chip->irq_rmh.Stat[i] & MASK_FIRST_FIELD; 1136 capture = (chip->irq_rmh.Stat[i] & 0x400000) ? 1 : 0; 1137 eob = (chip->irq_rmh.Stat[i] & 0x800000) ? 1 : 0; 1138 i++; 1139 if (events & ASYNC_EVENTS_PENDING) 1140 i++; 1141 buf = 1; /* force to transfer */ 1142 if (events & END_OF_BUFFER_EVENTS_PENDING) { 1143 if (eob) 1144 buf = chip->irq_rmh.Stat[i]; 1145 i++; 1146 } 1147 if (capture) 1148 continue; 1149 if (snd_BUG_ON(p < 0 || p >= chip->audio_outs)) 1150 continue; 1151 pipe = chip->playback_pipes[p]; 1152 if (pipe && pipe->substream) { 1153 vx_pcm_playback_update(chip, pipe->substream, pipe); 1154 vx_pcm_playback_transfer(chip, pipe->substream, pipe, buf); 1155 } 1156 } 1157 } 1158 1159 /* update the capture pcm pointers as frequently as possible */ 1160 for (i = 0; i < chip->audio_ins; i++) { 1161 pipe = chip->capture_pipes[i]; 1162 if (pipe && pipe->substream) 1163 vx_pcm_capture_update(chip, pipe->substream, pipe); 1164 } 1165 } 1166 1167 1168 /* 1169 * vx_init_audio_io - check the available audio i/o and allocate pipe arrays 1170 */ 1171 static int vx_init_audio_io(struct vx_core *chip) 1172 { 1173 struct vx_rmh rmh; 1174 int preferred; 1175 1176 vx_init_rmh(&rmh, CMD_SUPPORTED); 1177 if (vx_send_msg(chip, &rmh) < 0) { 1178 snd_printk(KERN_ERR "vx: cannot get the supported audio data\n"); 1179 return -ENXIO; 1180 } 1181 1182 chip->audio_outs = rmh.Stat[0] & MASK_FIRST_FIELD; 1183 chip->audio_ins = (rmh.Stat[0] >> (FIELD_SIZE*2)) & MASK_FIRST_FIELD; 1184 chip->audio_info = rmh.Stat[1]; 1185 1186 /* allocate pipes */ 1187 chip->playback_pipes = kcalloc(chip->audio_outs, sizeof(struct vx_pipe *), GFP_KERNEL); 1188 if (!chip->playback_pipes) 1189 return -ENOMEM; 1190 chip->capture_pipes = kcalloc(chip->audio_ins, sizeof(struct vx_pipe *), GFP_KERNEL); 1191 if (!chip->capture_pipes) { 1192 kfree(chip->playback_pipes); 1193 return -ENOMEM; 1194 } 1195 1196 preferred = chip->ibl.size; 1197 chip->ibl.size = 0; 1198 vx_set_ibl(chip, &chip->ibl); /* query the info */ 1199 if (preferred > 0) { 1200 chip->ibl.size = ((preferred + chip->ibl.granularity - 1) / 1201 chip->ibl.granularity) * chip->ibl.granularity; 1202 if (chip->ibl.size > chip->ibl.max_size) 1203 chip->ibl.size = chip->ibl.max_size; 1204 } else 1205 chip->ibl.size = chip->ibl.min_size; /* set to the minimum */ 1206 vx_set_ibl(chip, &chip->ibl); 1207 1208 return 0; 1209 } 1210 1211 1212 /* 1213 * free callback for pcm 1214 */ 1215 static void snd_vx_pcm_free(struct snd_pcm *pcm) 1216 { 1217 struct vx_core *chip = pcm->private_data; 1218 chip->pcm[pcm->device] = NULL; 1219 kfree(chip->playback_pipes); 1220 chip->playback_pipes = NULL; 1221 kfree(chip->capture_pipes); 1222 chip->capture_pipes = NULL; 1223 } 1224 1225 /* 1226 * snd_vx_pcm_new - create and initialize a pcm 1227 */ 1228 int snd_vx_pcm_new(struct vx_core *chip) 1229 { 1230 struct snd_pcm *pcm; 1231 unsigned int i; 1232 int err; 1233 1234 if ((err = vx_init_audio_io(chip)) < 0) 1235 return err; 1236 1237 for (i = 0; i < chip->hw->num_codecs; i++) { 1238 unsigned int outs, ins; 1239 outs = chip->audio_outs > i * 2 ? 1 : 0; 1240 ins = chip->audio_ins > i * 2 ? 1 : 0; 1241 if (! outs && ! ins) 1242 break; 1243 err = snd_pcm_new(chip->card, "VX PCM", i, 1244 outs, ins, &pcm); 1245 if (err < 0) 1246 return err; 1247 if (outs) 1248 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &vx_pcm_playback_ops); 1249 if (ins) 1250 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &vx_pcm_capture_ops); 1251 1252 pcm->private_data = chip; 1253 pcm->private_free = snd_vx_pcm_free; 1254 pcm->info_flags = 0; 1255 pcm->nonatomic = true; 1256 strcpy(pcm->name, chip->card->shortname); 1257 chip->pcm[i] = pcm; 1258 } 1259 1260 return 0; 1261 } 1262