1/**************************************************************************** 2 3 Copyright Echo Digital Audio Corporation (c) 1998 - 2004 4 All rights reserved 5 www.echoaudio.com 6 7 This file is part of Echo Digital Audio's generic driver library. 8 9 Echo Digital Audio's generic driver library is free software; 10 you can redistribute it and/or modify it under the terms of 11 the GNU General Public License as published by the Free Software 12 Foundation. 13 14 This program is distributed in the hope that it will be useful, 15 but WITHOUT ANY WARRANTY; without even the implied warranty of 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 GNU General Public License for more details. 18 19 You should have received a copy of the GNU General Public License 20 along with this program; if not, write to the Free Software 21 Foundation, Inc., 59 Temple Place - Suite 330, Boston, 22 MA 02111-1307, USA. 23 24 ************************************************************************* 25 26 Translation from C++ and adaptation for use in ALSA-Driver 27 were made by Giuliano Pochini <pochini@shiny.it> 28 29****************************************************************************/ 30 31#if PAGE_SIZE < 4096 32#error PAGE_SIZE is < 4k 33#endif 34 35static int restore_dsp_rettings(struct echoaudio *chip); 36 37 38/* Some vector commands involve the DSP reading or writing data to and from the 39comm page; if you send one of these commands to the DSP, it will complete the 40command and then write a non-zero value to the Handshake field in the 41comm page. This function waits for the handshake to show up. */ 42static int wait_handshake(struct echoaudio *chip) 43{ 44 int i; 45 46 /* Wait up to 10ms for the handshake from the DSP */ 47 for (i = 0; i < HANDSHAKE_TIMEOUT; i++) { 48 /* Look for the handshake value */ 49 if (chip->comm_page->handshake) { 50 /*if (i) DE_ACT(("Handshake time: %d\n", i));*/ 51 return 0; 52 } 53 udelay(1); 54 } 55 56 snd_printk(KERN_ERR "wait_handshake(): Timeout waiting for DSP\n"); 57 return -EBUSY; 58} 59 60 61 62/* Much of the interaction between the DSP and the driver is done via vector 63commands; send_vector writes a vector command to the DSP. Typically, this 64causes the DSP to read or write fields in the comm page. 65PCI posting is not required thanks to the handshake logic. */ 66static int send_vector(struct echoaudio *chip, u32 command) 67{ 68 int i; 69 70 wmb(); /* Flush all pending writes before sending the command */ 71 72 /* Wait up to 100ms for the "vector busy" bit to be off */ 73 for (i = 0; i < VECTOR_BUSY_TIMEOUT; i++) { 74 if (!(get_dsp_register(chip, CHI32_VECTOR_REG) & 75 CHI32_VECTOR_BUSY)) { 76 set_dsp_register(chip, CHI32_VECTOR_REG, command); 77 /*if (i) DE_ACT(("send_vector time: %d\n", i));*/ 78 return 0; 79 } 80 udelay(1); 81 } 82 83 DE_ACT((KERN_ERR "timeout on send_vector\n")); 84 return -EBUSY; 85} 86 87 88 89/* write_dsp writes a 32-bit value to the DSP; this is used almost 90exclusively for loading the DSP. */ 91static int write_dsp(struct echoaudio *chip, u32 data) 92{ 93 u32 status, i; 94 95 for (i = 0; i < 10000000; i++) { /* timeout = 10s */ 96 status = get_dsp_register(chip, CHI32_STATUS_REG); 97 if ((status & CHI32_STATUS_HOST_WRITE_EMPTY) != 0) { 98 set_dsp_register(chip, CHI32_DATA_REG, data); 99 wmb(); /* write it immediately */ 100 return 0; 101 } 102 udelay(1); 103 cond_resched(); 104 } 105 106 chip->bad_board = TRUE; /* Set TRUE until DSP re-loaded */ 107 DE_ACT((KERN_ERR "write_dsp: Set bad_board to TRUE\n")); 108 return -EIO; 109} 110 111 112 113/* read_dsp reads a 32-bit value from the DSP; this is used almost 114exclusively for loading the DSP and checking the status of the ASIC. */ 115static int read_dsp(struct echoaudio *chip, u32 *data) 116{ 117 u32 status, i; 118 119 for (i = 0; i < READ_DSP_TIMEOUT; i++) { 120 status = get_dsp_register(chip, CHI32_STATUS_REG); 121 if ((status & CHI32_STATUS_HOST_READ_FULL) != 0) { 122 *data = get_dsp_register(chip, CHI32_DATA_REG); 123 return 0; 124 } 125 udelay(1); 126 cond_resched(); 127 } 128 129 chip->bad_board = TRUE; /* Set TRUE until DSP re-loaded */ 130 DE_INIT((KERN_ERR "read_dsp: Set bad_board to TRUE\n")); 131 return -EIO; 132} 133 134 135 136/**************************************************************************** 137 Firmware loading functions 138 ****************************************************************************/ 139 140/* This function is used to read back the serial number from the DSP; 141this is triggered by the SET_COMMPAGE_ADDR command. 142Only some early Echogals products have serial numbers in the ROM; 143the serial number is not used, but you still need to do this as 144part of the DSP load process. */ 145static int read_sn(struct echoaudio *chip) 146{ 147 int i; 148 u32 sn[6]; 149 150 for (i = 0; i < 5; i++) { 151 if (read_dsp(chip, &sn[i])) { 152 snd_printk(KERN_ERR "Failed to read serial number\n"); 153 return -EIO; 154 } 155 } 156 DE_INIT(("Read serial number %08x %08x %08x %08x %08x\n", 157 sn[0], sn[1], sn[2], sn[3], sn[4])); 158 return 0; 159} 160 161 162 163#ifndef ECHOCARD_HAS_ASIC 164/* This card has no ASIC, just return ok */ 165static inline int check_asic_status(struct echoaudio *chip) 166{ 167 chip->asic_loaded = TRUE; 168 return 0; 169} 170 171#endif /* !ECHOCARD_HAS_ASIC */ 172 173 174 175#ifdef ECHOCARD_HAS_ASIC 176 177/* Load ASIC code - done after the DSP is loaded */ 178static int load_asic_generic(struct echoaudio *chip, u32 cmd, 179 const struct firmware *asic) 180{ 181 const struct firmware *fw; 182 int err; 183 u32 i, size; 184 u8 *code; 185 186 if ((err = get_firmware(&fw, asic, chip)) < 0) { 187 snd_printk(KERN_WARNING "Firmware not found !\n"); 188 return err; 189 } 190 191 code = (u8 *)fw->data; 192 size = fw->size; 193 194 /* Send the "Here comes the ASIC" command */ 195 if (write_dsp(chip, cmd) < 0) 196 goto la_error; 197 198 /* Write length of ASIC file in bytes */ 199 if (write_dsp(chip, size) < 0) 200 goto la_error; 201 202 for (i = 0; i < size; i++) { 203 if (write_dsp(chip, code[i]) < 0) 204 goto la_error; 205 } 206 207 DE_INIT(("ASIC loaded\n")); 208 free_firmware(fw); 209 return 0; 210 211la_error: 212 DE_INIT(("failed on write_dsp\n")); 213 free_firmware(fw); 214 return -EIO; 215} 216 217#endif /* ECHOCARD_HAS_ASIC */ 218 219 220 221#ifdef DSP_56361 222 223/* Install the resident loader for 56361 DSPs; The resident loader is on 224the EPROM on the board for 56301 DSP. The resident loader is a tiny little 225program that is used to load the real DSP code. */ 226static int install_resident_loader(struct echoaudio *chip) 227{ 228 u32 address; 229 int index, words, i; 230 u16 *code; 231 u32 status; 232 const struct firmware *fw; 233 234 /* 56361 cards only! This check is required by the old 56301-based 235 Mona and Gina24 */ 236 if (chip->device_id != DEVICE_ID_56361) 237 return 0; 238 239 /* Look to see if the resident loader is present. If the resident 240 loader is already installed, host flag 5 will be on. */ 241 status = get_dsp_register(chip, CHI32_STATUS_REG); 242 if (status & CHI32_STATUS_REG_HF5) { 243 DE_INIT(("Resident loader already installed; status is 0x%x\n", 244 status)); 245 return 0; 246 } 247 248 if ((i = get_firmware(&fw, &card_fw[FW_361_LOADER], chip)) < 0) { 249 snd_printk(KERN_WARNING "Firmware not found !\n"); 250 return i; 251 } 252 253 /* The DSP code is an array of 16 bit words. The array is divided up 254 into sections. The first word of each section is the size in words, 255 followed by the section type. 256 Since DSP addresses and data are 24 bits wide, they each take up two 257 16 bit words in the array. 258 This is a lot like the other loader loop, but it's not a loop, you 259 don't write the memory type, and you don't write a zero at the end. */ 260 261 /* Set DSP format bits for 24 bit mode */ 262 set_dsp_register(chip, CHI32_CONTROL_REG, 263 get_dsp_register(chip, CHI32_CONTROL_REG) | 0x900); 264 265 code = (u16 *)fw->data; 266 267 /* Skip the header section; the first word in the array is the size 268 of the first section, so the first real section of code is pointed 269 to by Code[0]. */ 270 index = code[0]; 271 272 /* Skip the section size, LRS block type, and DSP memory type */ 273 index += 3; 274 275 /* Get the number of DSP words to write */ 276 words = code[index++]; 277 278 /* Get the DSP address for this block; 24 bits, so build from two words */ 279 address = ((u32)code[index] << 16) + code[index + 1]; 280 index += 2; 281 282 /* Write the count to the DSP */ 283 if (write_dsp(chip, words)) { 284 DE_INIT(("install_resident_loader: Failed to write word count!\n")); 285 goto irl_error; 286 } 287 /* Write the DSP address */ 288 if (write_dsp(chip, address)) { 289 DE_INIT(("install_resident_loader: Failed to write DSP address!\n")); 290 goto irl_error; 291 } 292 /* Write out this block of code to the DSP */ 293 for (i = 0; i < words; i++) { 294 u32 data; 295 296 data = ((u32)code[index] << 16) + code[index + 1]; 297 if (write_dsp(chip, data)) { 298 DE_INIT(("install_resident_loader: Failed to write DSP code\n")); 299 goto irl_error; 300 } 301 index += 2; 302 } 303 304 /* Wait for flag 5 to come up */ 305 for (i = 0; i < 200; i++) { /* Timeout is 50us * 200 = 10ms */ 306 udelay(50); 307 status = get_dsp_register(chip, CHI32_STATUS_REG); 308 if (status & CHI32_STATUS_REG_HF5) 309 break; 310 } 311 312 if (i == 200) { 313 DE_INIT(("Resident loader failed to set HF5\n")); 314 goto irl_error; 315 } 316 317 DE_INIT(("Resident loader successfully installed\n")); 318 free_firmware(fw); 319 return 0; 320 321irl_error: 322 free_firmware(fw); 323 return -EIO; 324} 325 326#endif /* DSP_56361 */ 327 328 329static int load_dsp(struct echoaudio *chip, u16 *code) 330{ 331 u32 address, data; 332 int index, words, i; 333 334 if (chip->dsp_code == code) { 335 DE_INIT(("DSP is already loaded!\n")); 336 return 0; 337 } 338 chip->bad_board = TRUE; /* Set TRUE until DSP loaded */ 339 chip->dsp_code = NULL; /* Current DSP code not loaded */ 340 chip->asic_loaded = FALSE; /* Loading the DSP code will reset the ASIC */ 341 342 DE_INIT(("load_dsp: Set bad_board to TRUE\n")); 343 344 /* If this board requires a resident loader, install it. */ 345#ifdef DSP_56361 346 if ((i = install_resident_loader(chip)) < 0) 347 return i; 348#endif 349 350 /* Send software reset command */ 351 if (send_vector(chip, DSP_VC_RESET) < 0) { 352 DE_INIT(("LoadDsp: send_vector DSP_VC_RESET failed, Critical Failure\n")); 353 return -EIO; 354 } 355 /* Delay 10us */ 356 udelay(10); 357 358 /* Wait 10ms for HF3 to indicate that software reset is complete */ 359 for (i = 0; i < 1000; i++) { /* Timeout is 10us * 1000 = 10ms */ 360 if (get_dsp_register(chip, CHI32_STATUS_REG) & 361 CHI32_STATUS_REG_HF3) 362 break; 363 udelay(10); 364 } 365 366 if (i == 1000) { 367 DE_INIT(("load_dsp: Timeout waiting for CHI32_STATUS_REG_HF3\n")); 368 return -EIO; 369 } 370 371 /* Set DSP format bits for 24 bit mode now that soft reset is done */ 372 set_dsp_register(chip, CHI32_CONTROL_REG, 373 get_dsp_register(chip, CHI32_CONTROL_REG) | 0x900); 374 375 /* Main loader loop */ 376 377 index = code[0]; 378 for (;;) { 379 int block_type, mem_type; 380 381 /* Total Block Size */ 382 index++; 383 384 /* Block Type */ 385 block_type = code[index]; 386 if (block_type == 4) /* We're finished */ 387 break; 388 389 index++; 390 391 /* Memory Type P=0,X=1,Y=2 */ 392 mem_type = code[index++]; 393 394 /* Block Code Size */ 395 words = code[index++]; 396 if (words == 0) /* We're finished */ 397 break; 398 399 /* Start Address */ 400 address = ((u32)code[index] << 16) + code[index + 1]; 401 index += 2; 402 403 if (write_dsp(chip, words) < 0) { 404 DE_INIT(("load_dsp: failed to write number of DSP words\n")); 405 return -EIO; 406 } 407 if (write_dsp(chip, address) < 0) { 408 DE_INIT(("load_dsp: failed to write DSP address\n")); 409 return -EIO; 410 } 411 if (write_dsp(chip, mem_type) < 0) { 412 DE_INIT(("load_dsp: failed to write DSP memory type\n")); 413 return -EIO; 414 } 415 /* Code */ 416 for (i = 0; i < words; i++, index+=2) { 417 data = ((u32)code[index] << 16) + code[index + 1]; 418 if (write_dsp(chip, data) < 0) { 419 DE_INIT(("load_dsp: failed to write DSP data\n")); 420 return -EIO; 421 } 422 } 423 } 424 425 if (write_dsp(chip, 0) < 0) { /* We're done!!! */ 426 DE_INIT(("load_dsp: Failed to write final zero\n")); 427 return -EIO; 428 } 429 udelay(10); 430 431 for (i = 0; i < 5000; i++) { /* Timeout is 100us * 5000 = 500ms */ 432 /* Wait for flag 4 - indicates that the DSP loaded OK */ 433 if (get_dsp_register(chip, CHI32_STATUS_REG) & 434 CHI32_STATUS_REG_HF4) { 435 set_dsp_register(chip, CHI32_CONTROL_REG, 436 get_dsp_register(chip, CHI32_CONTROL_REG) & ~0x1b00); 437 438 if (write_dsp(chip, DSP_FNC_SET_COMMPAGE_ADDR) < 0) { 439 DE_INIT(("load_dsp: Failed to write DSP_FNC_SET_COMMPAGE_ADDR\n")); 440 return -EIO; 441 } 442 443 if (write_dsp(chip, chip->comm_page_phys) < 0) { 444 DE_INIT(("load_dsp: Failed to write comm page address\n")); 445 return -EIO; 446 } 447 448 /* Get the serial number via slave mode. 449 This is triggered by the SET_COMMPAGE_ADDR command. 450 We don't actually use the serial number but we have to 451 get it as part of the DSP init voodoo. */ 452 if (read_sn(chip) < 0) { 453 DE_INIT(("load_dsp: Failed to read serial number\n")); 454 return -EIO; 455 } 456 457 chip->dsp_code = code; /* Show which DSP code loaded */ 458 chip->bad_board = FALSE; /* DSP OK */ 459 DE_INIT(("load_dsp: OK!\n")); 460 return 0; 461 } 462 udelay(100); 463 } 464 465 DE_INIT(("load_dsp: DSP load timed out waiting for HF4\n")); 466 return -EIO; 467} 468 469 470 471/* load_firmware takes care of loading the DSP and any ASIC code. */ 472static int load_firmware(struct echoaudio *chip) 473{ 474 const struct firmware *fw; 475 int box_type, err; 476 477 snd_assert(chip->dsp_code_to_load && chip->comm_page, return -EPERM); 478 479 /* See if the ASIC is present and working - only if the DSP is already loaded */ 480 if (chip->dsp_code) { 481 if ((box_type = check_asic_status(chip)) >= 0) 482 return box_type; 483 /* ASIC check failed; force the DSP to reload */ 484 chip->dsp_code = NULL; 485 } 486 487 if ((err = get_firmware(&fw, chip->dsp_code_to_load, chip)) < 0) 488 return err; 489 err = load_dsp(chip, (u16 *)fw->data); 490 free_firmware(fw); 491 if (err < 0) 492 return err; 493 494 if ((box_type = load_asic(chip)) < 0) 495 return box_type; /* error */ 496 497 if ((err = restore_dsp_rettings(chip)) < 0) 498 return err; 499 500 return box_type; 501} 502 503 504 505/**************************************************************************** 506 Mixer functions 507 ****************************************************************************/ 508 509#if defined(ECHOCARD_HAS_INPUT_NOMINAL_LEVEL) || \ 510 defined(ECHOCARD_HAS_OUTPUT_NOMINAL_LEVEL) 511 512/* Set the nominal level for an input or output bus (true = -10dBV, false = +4dBu) */ 513static int set_nominal_level(struct echoaudio *chip, u16 index, char consumer) 514{ 515 snd_assert(index < num_busses_out(chip) + num_busses_in(chip), 516 return -EINVAL); 517 518 /* Wait for the handshake (OK even if ASIC is not loaded) */ 519 if (wait_handshake(chip)) 520 return -EIO; 521 522 chip->nominal_level[index] = consumer; 523 524 if (consumer) 525 chip->comm_page->nominal_level_mask |= cpu_to_le32(1 << index); 526 else 527 chip->comm_page->nominal_level_mask &= ~cpu_to_le32(1 << index); 528 529 return 0; 530} 531 532#endif /* ECHOCARD_HAS_*_NOMINAL_LEVEL */ 533 534 535 536/* Set the gain for a single physical output channel (dB). */ 537static int set_output_gain(struct echoaudio *chip, u16 channel, s8 gain) 538{ 539 snd_assert(channel < num_busses_out(chip), return -EINVAL); 540 541 if (wait_handshake(chip)) 542 return -EIO; 543 544 /* Save the new value */ 545 chip->output_gain[channel] = gain; 546 chip->comm_page->line_out_level[channel] = gain; 547 return 0; 548} 549 550 551 552#ifdef ECHOCARD_HAS_MONITOR 553/* Set the monitor level from an input bus to an output bus. */ 554static int set_monitor_gain(struct echoaudio *chip, u16 output, u16 input, 555 s8 gain) 556{ 557 snd_assert(output < num_busses_out(chip) && 558 input < num_busses_in(chip), return -EINVAL); 559 560 if (wait_handshake(chip)) 561 return -EIO; 562 563 chip->monitor_gain[output][input] = gain; 564 chip->comm_page->monitors[monitor_index(chip, output, input)] = gain; 565 return 0; 566} 567#endif /* ECHOCARD_HAS_MONITOR */ 568 569 570/* Tell the DSP to read and update output, nominal & monitor levels in comm page. */ 571static int update_output_line_level(struct echoaudio *chip) 572{ 573 if (wait_handshake(chip)) 574 return -EIO; 575 clear_handshake(chip); 576 return send_vector(chip, DSP_VC_UPDATE_OUTVOL); 577} 578 579 580 581/* Tell the DSP to read and update input levels in comm page */ 582static int update_input_line_level(struct echoaudio *chip) 583{ 584 if (wait_handshake(chip)) 585 return -EIO; 586 clear_handshake(chip); 587 return send_vector(chip, DSP_VC_UPDATE_INGAIN); 588} 589 590 591 592/* set_meters_on turns the meters on or off. If meters are turned on, the DSP 593will write the meter and clock detect values to the comm page at about 30Hz */ 594static void set_meters_on(struct echoaudio *chip, char on) 595{ 596 if (on && !chip->meters_enabled) { 597 send_vector(chip, DSP_VC_METERS_ON); 598 chip->meters_enabled = 1; 599 } else if (!on && chip->meters_enabled) { 600 send_vector(chip, DSP_VC_METERS_OFF); 601 chip->meters_enabled = 0; 602 memset((s8 *)chip->comm_page->vu_meter, ECHOGAIN_MUTED, 603 DSP_MAXPIPES); 604 memset((s8 *)chip->comm_page->peak_meter, ECHOGAIN_MUTED, 605 DSP_MAXPIPES); 606 } 607} 608 609 610 611/* Fill out an the given array using the current values in the comm page. 612Meters are written in the comm page by the DSP in this order: 613 Output busses 614 Input busses 615 Output pipes (vmixer cards only) 616 617This function assumes there are no more than 16 in/out busses or pipes 618Meters is an array [3][16][2] of long. */ 619static void get_audio_meters(struct echoaudio *chip, long *meters) 620{ 621 int i, m, n; 622 623 m = 0; 624 n = 0; 625 for (i = 0; i < num_busses_out(chip); i++, m++) { 626 meters[n++] = chip->comm_page->vu_meter[m]; 627 meters[n++] = chip->comm_page->peak_meter[m]; 628 } 629 for (; n < 32; n++) 630 meters[n] = 0; 631 632#ifdef ECHOCARD_ECHO3G 633 m = E3G_MAX_OUTPUTS; /* Skip unused meters */ 634#endif 635 636 for (i = 0; i < num_busses_in(chip); i++, m++) { 637 meters[n++] = chip->comm_page->vu_meter[m]; 638 meters[n++] = chip->comm_page->peak_meter[m]; 639 } 640 for (; n < 64; n++) 641 meters[n] = 0; 642 643#ifdef ECHOCARD_HAS_VMIXER 644 for (i = 0; i < num_pipes_out(chip); i++, m++) { 645 meters[n++] = chip->comm_page->vu_meter[m]; 646 meters[n++] = chip->comm_page->peak_meter[m]; 647 } 648#endif 649 for (; n < 96; n++) 650 meters[n] = 0; 651} 652 653 654 655static int restore_dsp_rettings(struct echoaudio *chip) 656{ 657 int err; 658 DE_INIT(("restore_dsp_settings\n")); 659 660 if ((err = check_asic_status(chip)) < 0) 661 return err; 662 663 /* @ Gina20/Darla20 only. Should be harmless for other cards. */ 664 chip->comm_page->gd_clock_state = GD_CLOCK_UNDEF; 665 chip->comm_page->gd_spdif_status = GD_SPDIF_STATUS_UNDEF; 666 chip->comm_page->handshake = 0xffffffff; 667 668 if ((err = set_sample_rate(chip, chip->sample_rate)) < 0) 669 return err; 670 671 if (chip->meters_enabled) 672 if (send_vector(chip, DSP_VC_METERS_ON) < 0) 673 return -EIO; 674 675#ifdef ECHOCARD_HAS_EXTERNAL_CLOCK 676 if (set_input_clock(chip, chip->input_clock) < 0) 677 return -EIO; 678#endif 679 680#ifdef ECHOCARD_HAS_OUTPUT_CLOCK_SWITCH 681 if (set_output_clock(chip, chip->output_clock) < 0) 682 return -EIO; 683#endif 684 685 if (update_output_line_level(chip) < 0) 686 return -EIO; 687 688 if (update_input_line_level(chip) < 0) 689 return -EIO; 690 691#ifdef ECHOCARD_HAS_VMIXER 692 if (update_vmixer_level(chip) < 0) 693 return -EIO; 694#endif 695 696 if (wait_handshake(chip) < 0) 697 return -EIO; 698 clear_handshake(chip); 699 700 DE_INIT(("restore_dsp_rettings done\n")); 701 return send_vector(chip, DSP_VC_UPDATE_FLAGS); 702} 703 704 705 706/**************************************************************************** 707 Transport functions 708 ****************************************************************************/ 709 710/* set_audio_format() sets the format of the audio data in host memory for 711this pipe. Note that _MS_ (mono-to-stereo) playback modes are not used by ALSA 712but they are here because they are just mono while capturing */ 713static void set_audio_format(struct echoaudio *chip, u16 pipe_index, 714 const struct audioformat *format) 715{ 716 u16 dsp_format; 717 718 dsp_format = DSP_AUDIOFORM_SS_16LE; 719 720 /* Look for super-interleave (no big-endian and 8 bits) */ 721 if (format->interleave > 2) { 722 switch (format->bits_per_sample) { 723 case 16: 724 dsp_format = DSP_AUDIOFORM_SUPER_INTERLEAVE_16LE; 725 break; 726 case 24: 727 dsp_format = DSP_AUDIOFORM_SUPER_INTERLEAVE_24LE; 728 break; 729 case 32: 730 dsp_format = DSP_AUDIOFORM_SUPER_INTERLEAVE_32LE; 731 break; 732 } 733 dsp_format |= format->interleave; 734 } else if (format->data_are_bigendian) { 735 /* For big-endian data, only 32 bit samples are supported */ 736 switch (format->interleave) { 737 case 1: 738 dsp_format = DSP_AUDIOFORM_MM_32BE; 739 break; 740#ifdef ECHOCARD_HAS_STEREO_BIG_ENDIAN32 741 case 2: 742 dsp_format = DSP_AUDIOFORM_SS_32BE; 743 break; 744#endif 745 } 746 } else if (format->interleave == 1 && 747 format->bits_per_sample == 32 && !format->mono_to_stereo) { 748 /* 32 bit little-endian mono->mono case */ 749 dsp_format = DSP_AUDIOFORM_MM_32LE; 750 } else { 751 /* Handle the other little-endian formats */ 752 switch (format->bits_per_sample) { 753 case 8: 754 if (format->interleave == 2) 755 dsp_format = DSP_AUDIOFORM_SS_8; 756 else 757 dsp_format = DSP_AUDIOFORM_MS_8; 758 break; 759 default: 760 case 16: 761 if (format->interleave == 2) 762 dsp_format = DSP_AUDIOFORM_SS_16LE; 763 else 764 dsp_format = DSP_AUDIOFORM_MS_16LE; 765 break; 766 case 24: 767 if (format->interleave == 2) 768 dsp_format = DSP_AUDIOFORM_SS_24LE; 769 else 770 dsp_format = DSP_AUDIOFORM_MS_24LE; 771 break; 772 case 32: 773 if (format->interleave == 2) 774 dsp_format = DSP_AUDIOFORM_SS_32LE; 775 else 776 dsp_format = DSP_AUDIOFORM_MS_32LE; 777 break; 778 } 779 } 780 DE_ACT(("set_audio_format[%d] = %x\n", pipe_index, dsp_format)); 781 chip->comm_page->audio_format[pipe_index] = cpu_to_le16(dsp_format); 782} 783 784 785 786/* start_transport starts transport for a set of pipes. 787The bits 1 in channel_mask specify what pipes to start. Only the bit of the 788first channel must be set, regardless its interleave. 789Same thing for pause_ and stop_ -trasport below. */ 790static int start_transport(struct echoaudio *chip, u32 channel_mask, 791 u32 cyclic_mask) 792{ 793 DE_ACT(("start_transport %x\n", channel_mask)); 794 795 if (wait_handshake(chip)) 796 return -EIO; 797 798 chip->comm_page->cmd_start |= cpu_to_le32(channel_mask); 799 800 if (chip->comm_page->cmd_start) { 801 clear_handshake(chip); 802 send_vector(chip, DSP_VC_START_TRANSFER); 803 if (wait_handshake(chip)) 804 return -EIO; 805 /* Keep track of which pipes are transporting */ 806 chip->active_mask |= channel_mask; 807 chip->comm_page->cmd_start = 0; 808 return 0; 809 } 810 811 DE_ACT(("start_transport: No pipes to start!\n")); 812 return -EINVAL; 813} 814 815 816 817static int pause_transport(struct echoaudio *chip, u32 channel_mask) 818{ 819 DE_ACT(("pause_transport %x\n", channel_mask)); 820 821 if (wait_handshake(chip)) 822 return -EIO; 823 824 chip->comm_page->cmd_stop |= cpu_to_le32(channel_mask); 825 chip->comm_page->cmd_reset = 0; 826 if (chip->comm_page->cmd_stop) { 827 clear_handshake(chip); 828 send_vector(chip, DSP_VC_STOP_TRANSFER); 829 if (wait_handshake(chip)) 830 return -EIO; 831 /* Keep track of which pipes are transporting */ 832 chip->active_mask &= ~channel_mask; 833 chip->comm_page->cmd_stop = 0; 834 chip->comm_page->cmd_reset = 0; 835 return 0; 836 } 837 838 DE_ACT(("pause_transport: No pipes to stop!\n")); 839 return 0; 840} 841 842 843 844static int stop_transport(struct echoaudio *chip, u32 channel_mask) 845{ 846 DE_ACT(("stop_transport %x\n", channel_mask)); 847 848 if (wait_handshake(chip)) 849 return -EIO; 850 851 chip->comm_page->cmd_stop |= cpu_to_le32(channel_mask); 852 chip->comm_page->cmd_reset |= cpu_to_le32(channel_mask); 853 if (chip->comm_page->cmd_reset) { 854 clear_handshake(chip); 855 send_vector(chip, DSP_VC_STOP_TRANSFER); 856 if (wait_handshake(chip)) 857 return -EIO; 858 /* Keep track of which pipes are transporting */ 859 chip->active_mask &= ~channel_mask; 860 chip->comm_page->cmd_stop = 0; 861 chip->comm_page->cmd_reset = 0; 862 return 0; 863 } 864 865 DE_ACT(("stop_transport: No pipes to stop!\n")); 866 return 0; 867} 868 869 870 871static inline int is_pipe_allocated(struct echoaudio *chip, u16 pipe_index) 872{ 873 return (chip->pipe_alloc_mask & (1 << pipe_index)); 874} 875 876 877 878/* Stops everything and turns off the DSP. All pipes should be already 879stopped and unallocated. */ 880static int rest_in_peace(struct echoaudio *chip) 881{ 882 DE_ACT(("rest_in_peace() open=%x\n", chip->pipe_alloc_mask)); 883 884 /* Stops all active pipes (just to be sure) */ 885 stop_transport(chip, chip->active_mask); 886 887 set_meters_on(chip, FALSE); 888 889#ifdef ECHOCARD_HAS_MIDI 890 enable_midi_input(chip, FALSE); 891#endif 892 893 /* Go to sleep */ 894 if (chip->dsp_code) { 895 /* Make load_firmware do a complete reload */ 896 chip->dsp_code = NULL; 897 /* Put the DSP to sleep */ 898 return send_vector(chip, DSP_VC_GO_COMATOSE); 899 } 900 return 0; 901} 902 903 904 905/* Fills the comm page with default values */ 906static int init_dsp_comm_page(struct echoaudio *chip) 907{ 908 /* Check if the compiler added extra padding inside the structure */ 909 if (offsetof(struct comm_page, midi_output) != 0xbe0) { 910 DE_INIT(("init_dsp_comm_page() - Invalid struct comm_page structure\n")); 911 return -EPERM; 912 } 913 914 /* Init all the basic stuff */ 915 chip->card_name = ECHOCARD_NAME; 916 chip->bad_board = TRUE; /* Set TRUE until DSP loaded */ 917 chip->dsp_code = NULL; /* Current DSP code not loaded */ 918 chip->digital_mode = DIGITAL_MODE_NONE; 919 chip->input_clock = ECHO_CLOCK_INTERNAL; 920 chip->output_clock = ECHO_CLOCK_WORD; 921 chip->asic_loaded = FALSE; 922 memset(chip->comm_page, 0, sizeof(struct comm_page)); 923 924 /* Init the comm page */ 925 chip->comm_page->comm_size = 926 __constant_cpu_to_le32(sizeof(struct comm_page)); 927 chip->comm_page->handshake = 0xffffffff; 928 chip->comm_page->midi_out_free_count = 929 __constant_cpu_to_le32(DSP_MIDI_OUT_FIFO_SIZE); 930 chip->comm_page->sample_rate = __constant_cpu_to_le32(44100); 931 chip->sample_rate = 44100; 932 933 /* Set line levels so we don't blast any inputs on startup */ 934 memset(chip->comm_page->monitors, ECHOGAIN_MUTED, MONITOR_ARRAY_SIZE); 935 memset(chip->comm_page->vmixer, ECHOGAIN_MUTED, VMIXER_ARRAY_SIZE); 936 937 return 0; 938} 939 940 941 942/* This function initializes the several volume controls for busses and pipes. 943This MUST be called after the DSP is up and running ! */ 944static int init_line_levels(struct echoaudio *chip) 945{ 946 int st, i, o; 947 948 DE_INIT(("init_line_levels\n")); 949 950 /* Mute output busses */ 951 for (i = 0; i < num_busses_out(chip); i++) 952 if ((st = set_output_gain(chip, i, ECHOGAIN_MUTED))) 953 return st; 954 if ((st = update_output_line_level(chip))) 955 return st; 956 957#ifdef ECHOCARD_HAS_VMIXER 958 /* Mute the Vmixer */ 959 for (i = 0; i < num_pipes_out(chip); i++) 960 for (o = 0; o < num_busses_out(chip); o++) 961 if ((st = set_vmixer_gain(chip, o, i, ECHOGAIN_MUTED))) 962 return st; 963 if ((st = update_vmixer_level(chip))) 964 return st; 965#endif /* ECHOCARD_HAS_VMIXER */ 966 967#ifdef ECHOCARD_HAS_MONITOR 968 /* Mute the monitor mixer */ 969 for (o = 0; o < num_busses_out(chip); o++) 970 for (i = 0; i < num_busses_in(chip); i++) 971 if ((st = set_monitor_gain(chip, o, i, ECHOGAIN_MUTED))) 972 return st; 973 if ((st = update_output_line_level(chip))) 974 return st; 975#endif /* ECHOCARD_HAS_MONITOR */ 976 977#ifdef ECHOCARD_HAS_INPUT_GAIN 978 for (i = 0; i < num_busses_in(chip); i++) 979 if ((st = set_input_gain(chip, i, ECHOGAIN_MUTED))) 980 return st; 981 if ((st = update_input_line_level(chip))) 982 return st; 983#endif /* ECHOCARD_HAS_INPUT_GAIN */ 984 985 return 0; 986} 987 988 989 990/* This is low level part of the interrupt handler. 991It returns -1 if the IRQ is not ours, or N>=0 if it is, where N is the number 992of midi data in the input queue. */ 993static int service_irq(struct echoaudio *chip) 994{ 995 int st; 996 997 /* Read the DSP status register and see if this DSP generated this interrupt */ 998 if (get_dsp_register(chip, CHI32_STATUS_REG) & CHI32_STATUS_IRQ) { 999 st = 0; 1000#ifdef ECHOCARD_HAS_MIDI 1001 /* Get and parse midi data if present */ 1002 if (chip->comm_page->midi_input[0]) /* The count is at index 0 */ 1003 st = midi_service_irq(chip); /* Returns how many midi bytes we received */ 1004#endif 1005 /* Clear the hardware interrupt */ 1006 chip->comm_page->midi_input[0] = 0; 1007 send_vector(chip, DSP_VC_ACK_INT); 1008 return st; 1009 } 1010 return -1; 1011} 1012 1013 1014 1015 1016/****************************************************************************** 1017 Functions for opening and closing pipes 1018 ******************************************************************************/ 1019 1020/* allocate_pipes is used to reserve audio pipes for your exclusive use. 1021The call will fail if some pipes are already allocated. */ 1022static int allocate_pipes(struct echoaudio *chip, struct audiopipe *pipe, 1023 int pipe_index, int interleave) 1024{ 1025 int i; 1026 u32 channel_mask; 1027 char is_cyclic; 1028 1029 DE_ACT(("allocate_pipes: ch=%d int=%d\n", pipe_index, interleave)); 1030 1031 if (chip->bad_board) 1032 return -EIO; 1033 1034 is_cyclic = 1; /* This driver uses cyclic buffers only */ 1035 1036 for (channel_mask = i = 0; i < interleave; i++) 1037 channel_mask |= 1 << (pipe_index + i); 1038 if (chip->pipe_alloc_mask & channel_mask) { 1039 DE_ACT(("allocate_pipes: channel already open\n")); 1040 return -EAGAIN; 1041 } 1042 1043 chip->comm_page->position[pipe_index] = 0; 1044 chip->pipe_alloc_mask |= channel_mask; 1045 if (is_cyclic) 1046 chip->pipe_cyclic_mask |= channel_mask; 1047 pipe->index = pipe_index; 1048 pipe->interleave = interleave; 1049 pipe->state = PIPE_STATE_STOPPED; 1050 1051 /* The counter register is where the DSP writes the 32 bit DMA 1052 position for a pipe. The DSP is constantly updating this value as 1053 it moves data. The DMA counter is in units of bytes, not samples. */ 1054 pipe->dma_counter = &chip->comm_page->position[pipe_index]; 1055 *pipe->dma_counter = 0; 1056 DE_ACT(("allocate_pipes: ok\n")); 1057 return pipe_index; 1058} 1059 1060 1061 1062static int free_pipes(struct echoaudio *chip, struct audiopipe *pipe) 1063{ 1064 u32 channel_mask; 1065 int i; 1066 1067 DE_ACT(("free_pipes: Pipe %d\n", pipe->index)); 1068 snd_assert(is_pipe_allocated(chip, pipe->index), return -EINVAL); 1069 snd_assert(pipe->state == PIPE_STATE_STOPPED, return -EINVAL); 1070 1071 for (channel_mask = i = 0; i < pipe->interleave; i++) 1072 channel_mask |= 1 << (pipe->index + i); 1073 1074 chip->pipe_alloc_mask &= ~channel_mask; 1075 chip->pipe_cyclic_mask &= ~channel_mask; 1076 return 0; 1077} 1078 1079 1080 1081/****************************************************************************** 1082 Functions for managing the scatter-gather list 1083******************************************************************************/ 1084 1085static int sglist_init(struct echoaudio *chip, struct audiopipe *pipe) 1086{ 1087 pipe->sglist_head = 0; 1088 memset(pipe->sgpage.area, 0, PAGE_SIZE); 1089 chip->comm_page->sglist_addr[pipe->index].addr = 1090 cpu_to_le32(pipe->sgpage.addr); 1091 return 0; 1092} 1093 1094 1095 1096static int sglist_add_mapping(struct echoaudio *chip, struct audiopipe *pipe, 1097 dma_addr_t address, size_t length) 1098{ 1099 int head = pipe->sglist_head; 1100 struct sg_entry *list = (struct sg_entry *)pipe->sgpage.area; 1101 1102 if (head < MAX_SGLIST_ENTRIES - 1) { 1103 list[head].addr = cpu_to_le32(address); 1104 list[head].size = cpu_to_le32(length); 1105 pipe->sglist_head++; 1106 } else { 1107 DE_ACT(("SGlist: too many fragments\n")); 1108 return -ENOMEM; 1109 } 1110 return 0; 1111} 1112 1113 1114 1115static inline int sglist_add_irq(struct echoaudio *chip, struct audiopipe *pipe) 1116{ 1117 return sglist_add_mapping(chip, pipe, 0, 0); 1118} 1119 1120 1121 1122static inline int sglist_wrap(struct echoaudio *chip, struct audiopipe *pipe) 1123{ 1124 return sglist_add_mapping(chip, pipe, pipe->sgpage.addr, 0); 1125} 1126