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 35 static int restore_dsp_rettings(struct echoaudio *chip); 36 37 38 /* Some vector commands involve the DSP reading or writing data to and from the 39 comm page; if you send one of these commands to the DSP, it will complete the 40 command and then write a non-zero value to the Handshake field in the 41 comm page. This function waits for the handshake to show up. */ 42 static int wait_handshake(struct echoaudio *chip) 43 { 44 int i; 45 46 /* Wait up to 20ms for the handshake from the DSP */ 47 for (i = 0; i < HANDSHAKE_TIMEOUT; i++) { 48 /* Look for the handshake value */ 49 barrier(); 50 if (chip->comm_page->handshake) { 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 63 commands; send_vector writes a vector command to the DSP. Typically, this 64 causes the DSP to read or write fields in the comm page. 65 PCI posting is not required thanks to the handshake logic. */ 66 static 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 90 exclusively for loading the DSP. */ 91 static 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 114 exclusively for loading the DSP and checking the status of the ASIC. */ 115 static 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; 141 this is triggered by the SET_COMMPAGE_ADDR command. 142 Only some early Echogals products have serial numbers in the ROM; 143 the serial number is not used, but you still need to do this as 144 part of the DSP load process. */ 145 static 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 */ 165 static 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 */ 178 static int load_asic_generic(struct echoaudio *chip, u32 cmd, short asic) 179 { 180 const struct firmware *fw; 181 int err; 182 u32 i, size; 183 u8 *code; 184 185 err = get_firmware(&fw, chip, asic); 186 if (err < 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 211 la_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 224 the EPROM on the board for 56301 DSP. The resident loader is a tiny little 225 program that is used to load the real DSP code. */ 226 static 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 i = get_firmware(&fw, chip, FW_361_LOADER); 249 if (i < 0) { 250 snd_printk(KERN_WARNING "Firmware not found !\n"); 251 return i; 252 } 253 254 /* The DSP code is an array of 16 bit words. The array is divided up 255 into sections. The first word of each section is the size in words, 256 followed by the section type. 257 Since DSP addresses and data are 24 bits wide, they each take up two 258 16 bit words in the array. 259 This is a lot like the other loader loop, but it's not a loop, you 260 don't write the memory type, and you don't write a zero at the end. */ 261 262 /* Set DSP format bits for 24 bit mode */ 263 set_dsp_register(chip, CHI32_CONTROL_REG, 264 get_dsp_register(chip, CHI32_CONTROL_REG) | 0x900); 265 266 code = (u16 *)fw->data; 267 268 /* Skip the header section; the first word in the array is the size 269 of the first section, so the first real section of code is pointed 270 to by Code[0]. */ 271 index = code[0]; 272 273 /* Skip the section size, LRS block type, and DSP memory type */ 274 index += 3; 275 276 /* Get the number of DSP words to write */ 277 words = code[index++]; 278 279 /* Get the DSP address for this block; 24 bits, so build from two words */ 280 address = ((u32)code[index] << 16) + code[index + 1]; 281 index += 2; 282 283 /* Write the count to the DSP */ 284 if (write_dsp(chip, words)) { 285 DE_INIT(("install_resident_loader: Failed to write word count!\n")); 286 goto irl_error; 287 } 288 /* Write the DSP address */ 289 if (write_dsp(chip, address)) { 290 DE_INIT(("install_resident_loader: Failed to write DSP address!\n")); 291 goto irl_error; 292 } 293 /* Write out this block of code to the DSP */ 294 for (i = 0; i < words; i++) { 295 u32 data; 296 297 data = ((u32)code[index] << 16) + code[index + 1]; 298 if (write_dsp(chip, data)) { 299 DE_INIT(("install_resident_loader: Failed to write DSP code\n")); 300 goto irl_error; 301 } 302 index += 2; 303 } 304 305 /* Wait for flag 5 to come up */ 306 for (i = 0; i < 200; i++) { /* Timeout is 50us * 200 = 10ms */ 307 udelay(50); 308 status = get_dsp_register(chip, CHI32_STATUS_REG); 309 if (status & CHI32_STATUS_REG_HF5) 310 break; 311 } 312 313 if (i == 200) { 314 DE_INIT(("Resident loader failed to set HF5\n")); 315 goto irl_error; 316 } 317 318 DE_INIT(("Resident loader successfully installed\n")); 319 free_firmware(fw); 320 return 0; 321 322 irl_error: 323 free_firmware(fw); 324 return -EIO; 325 } 326 327 #endif /* DSP_56361 */ 328 329 330 static int load_dsp(struct echoaudio *chip, u16 *code) 331 { 332 u32 address, data; 333 int index, words, i; 334 335 if (chip->dsp_code == code) { 336 DE_INIT(("DSP is already loaded!\n")); 337 return 0; 338 } 339 chip->bad_board = TRUE; /* Set TRUE until DSP loaded */ 340 chip->dsp_code = NULL; /* Current DSP code not loaded */ 341 chip->asic_loaded = FALSE; /* Loading the DSP code will reset the ASIC */ 342 343 DE_INIT(("load_dsp: Set bad_board to TRUE\n")); 344 345 /* If this board requires a resident loader, install it. */ 346 #ifdef DSP_56361 347 if ((i = install_resident_loader(chip)) < 0) 348 return i; 349 #endif 350 351 /* Send software reset command */ 352 if (send_vector(chip, DSP_VC_RESET) < 0) { 353 DE_INIT(("LoadDsp: send_vector DSP_VC_RESET failed, Critical Failure\n")); 354 return -EIO; 355 } 356 /* Delay 10us */ 357 udelay(10); 358 359 /* Wait 10ms for HF3 to indicate that software reset is complete */ 360 for (i = 0; i < 1000; i++) { /* Timeout is 10us * 1000 = 10ms */ 361 if (get_dsp_register(chip, CHI32_STATUS_REG) & 362 CHI32_STATUS_REG_HF3) 363 break; 364 udelay(10); 365 } 366 367 if (i == 1000) { 368 DE_INIT(("load_dsp: Timeout waiting for CHI32_STATUS_REG_HF3\n")); 369 return -EIO; 370 } 371 372 /* Set DSP format bits for 24 bit mode now that soft reset is done */ 373 set_dsp_register(chip, CHI32_CONTROL_REG, 374 get_dsp_register(chip, CHI32_CONTROL_REG) | 0x900); 375 376 /* Main loader loop */ 377 378 index = code[0]; 379 for (;;) { 380 int block_type, mem_type; 381 382 /* Total Block Size */ 383 index++; 384 385 /* Block Type */ 386 block_type = code[index]; 387 if (block_type == 4) /* We're finished */ 388 break; 389 390 index++; 391 392 /* Memory Type P=0,X=1,Y=2 */ 393 mem_type = code[index++]; 394 395 /* Block Code Size */ 396 words = code[index++]; 397 if (words == 0) /* We're finished */ 398 break; 399 400 /* Start Address */ 401 address = ((u32)code[index] << 16) + code[index + 1]; 402 index += 2; 403 404 if (write_dsp(chip, words) < 0) { 405 DE_INIT(("load_dsp: failed to write number of DSP words\n")); 406 return -EIO; 407 } 408 if (write_dsp(chip, address) < 0) { 409 DE_INIT(("load_dsp: failed to write DSP address\n")); 410 return -EIO; 411 } 412 if (write_dsp(chip, mem_type) < 0) { 413 DE_INIT(("load_dsp: failed to write DSP memory type\n")); 414 return -EIO; 415 } 416 /* Code */ 417 for (i = 0; i < words; i++, index+=2) { 418 data = ((u32)code[index] << 16) + code[index + 1]; 419 if (write_dsp(chip, data) < 0) { 420 DE_INIT(("load_dsp: failed to write DSP data\n")); 421 return -EIO; 422 } 423 } 424 } 425 426 if (write_dsp(chip, 0) < 0) { /* We're done!!! */ 427 DE_INIT(("load_dsp: Failed to write final zero\n")); 428 return -EIO; 429 } 430 udelay(10); 431 432 for (i = 0; i < 5000; i++) { /* Timeout is 100us * 5000 = 500ms */ 433 /* Wait for flag 4 - indicates that the DSP loaded OK */ 434 if (get_dsp_register(chip, CHI32_STATUS_REG) & 435 CHI32_STATUS_REG_HF4) { 436 set_dsp_register(chip, CHI32_CONTROL_REG, 437 get_dsp_register(chip, CHI32_CONTROL_REG) & ~0x1b00); 438 439 if (write_dsp(chip, DSP_FNC_SET_COMMPAGE_ADDR) < 0) { 440 DE_INIT(("load_dsp: Failed to write DSP_FNC_SET_COMMPAGE_ADDR\n")); 441 return -EIO; 442 } 443 444 if (write_dsp(chip, chip->comm_page_phys) < 0) { 445 DE_INIT(("load_dsp: Failed to write comm page address\n")); 446 return -EIO; 447 } 448 449 /* Get the serial number via slave mode. 450 This is triggered by the SET_COMMPAGE_ADDR command. 451 We don't actually use the serial number but we have to 452 get it as part of the DSP init voodoo. */ 453 if (read_sn(chip) < 0) { 454 DE_INIT(("load_dsp: Failed to read serial number\n")); 455 return -EIO; 456 } 457 458 chip->dsp_code = code; /* Show which DSP code loaded */ 459 chip->bad_board = FALSE; /* DSP OK */ 460 DE_INIT(("load_dsp: OK!\n")); 461 return 0; 462 } 463 udelay(100); 464 } 465 466 DE_INIT(("load_dsp: DSP load timed out waiting for HF4\n")); 467 return -EIO; 468 } 469 470 471 472 /* load_firmware takes care of loading the DSP and any ASIC code. */ 473 static int load_firmware(struct echoaudio *chip) 474 { 475 const struct firmware *fw; 476 int box_type, err; 477 478 if (snd_BUG_ON(!chip->comm_page)) 479 return -EPERM; 480 481 /* See if the ASIC is present and working - only if the DSP is already loaded */ 482 if (chip->dsp_code) { 483 if ((box_type = check_asic_status(chip)) >= 0) 484 return box_type; 485 /* ASIC check failed; force the DSP to reload */ 486 chip->dsp_code = NULL; 487 } 488 489 err = get_firmware(&fw, chip, chip->dsp_code_to_load); 490 if (err < 0) 491 return err; 492 err = load_dsp(chip, (u16 *)fw->data); 493 free_firmware(fw); 494 if (err < 0) 495 return err; 496 497 if ((box_type = load_asic(chip)) < 0) 498 return box_type; /* error */ 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) */ 513 static int set_nominal_level(struct echoaudio *chip, u16 index, char consumer) 514 { 515 if (snd_BUG_ON(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). */ 537 static int set_output_gain(struct echoaudio *chip, u16 channel, s8 gain) 538 { 539 if (snd_BUG_ON(channel >= num_busses_out(chip))) 540 return -EINVAL; 541 542 if (wait_handshake(chip)) 543 return -EIO; 544 545 /* Save the new value */ 546 chip->output_gain[channel] = gain; 547 chip->comm_page->line_out_level[channel] = gain; 548 return 0; 549 } 550 551 552 553 #ifdef ECHOCARD_HAS_MONITOR 554 /* Set the monitor level from an input bus to an output bus. */ 555 static int set_monitor_gain(struct echoaudio *chip, u16 output, u16 input, 556 s8 gain) 557 { 558 if (snd_BUG_ON(output >= num_busses_out(chip) || 559 input >= num_busses_in(chip))) 560 return -EINVAL; 561 562 if (wait_handshake(chip)) 563 return -EIO; 564 565 chip->monitor_gain[output][input] = gain; 566 chip->comm_page->monitors[monitor_index(chip, output, input)] = gain; 567 return 0; 568 } 569 #endif /* ECHOCARD_HAS_MONITOR */ 570 571 572 /* Tell the DSP to read and update output, nominal & monitor levels in comm page. */ 573 static int update_output_line_level(struct echoaudio *chip) 574 { 575 if (wait_handshake(chip)) 576 return -EIO; 577 clear_handshake(chip); 578 return send_vector(chip, DSP_VC_UPDATE_OUTVOL); 579 } 580 581 582 583 /* Tell the DSP to read and update input levels in comm page */ 584 static int update_input_line_level(struct echoaudio *chip) 585 { 586 if (wait_handshake(chip)) 587 return -EIO; 588 clear_handshake(chip); 589 return send_vector(chip, DSP_VC_UPDATE_INGAIN); 590 } 591 592 593 594 /* set_meters_on turns the meters on or off. If meters are turned on, the DSP 595 will write the meter and clock detect values to the comm page at about 30Hz */ 596 static void set_meters_on(struct echoaudio *chip, char on) 597 { 598 if (on && !chip->meters_enabled) { 599 send_vector(chip, DSP_VC_METERS_ON); 600 chip->meters_enabled = 1; 601 } else if (!on && chip->meters_enabled) { 602 send_vector(chip, DSP_VC_METERS_OFF); 603 chip->meters_enabled = 0; 604 memset((s8 *)chip->comm_page->vu_meter, ECHOGAIN_MUTED, 605 DSP_MAXPIPES); 606 memset((s8 *)chip->comm_page->peak_meter, ECHOGAIN_MUTED, 607 DSP_MAXPIPES); 608 } 609 } 610 611 612 613 /* Fill out an the given array using the current values in the comm page. 614 Meters are written in the comm page by the DSP in this order: 615 Output busses 616 Input busses 617 Output pipes (vmixer cards only) 618 619 This function assumes there are no more than 16 in/out busses or pipes 620 Meters is an array [3][16][2] of long. */ 621 static void get_audio_meters(struct echoaudio *chip, long *meters) 622 { 623 int i, m, n; 624 625 m = 0; 626 n = 0; 627 for (i = 0; i < num_busses_out(chip); i++, m++) { 628 meters[n++] = chip->comm_page->vu_meter[m]; 629 meters[n++] = chip->comm_page->peak_meter[m]; 630 } 631 for (; n < 32; n++) 632 meters[n] = 0; 633 634 #ifdef ECHOCARD_ECHO3G 635 m = E3G_MAX_OUTPUTS; /* Skip unused meters */ 636 #endif 637 638 for (i = 0; i < num_busses_in(chip); i++, m++) { 639 meters[n++] = chip->comm_page->vu_meter[m]; 640 meters[n++] = chip->comm_page->peak_meter[m]; 641 } 642 for (; n < 64; n++) 643 meters[n] = 0; 644 645 #ifdef ECHOCARD_HAS_VMIXER 646 for (i = 0; i < num_pipes_out(chip); i++, m++) { 647 meters[n++] = chip->comm_page->vu_meter[m]; 648 meters[n++] = chip->comm_page->peak_meter[m]; 649 } 650 #endif 651 for (; n < 96; n++) 652 meters[n] = 0; 653 } 654 655 656 657 static int restore_dsp_rettings(struct echoaudio *chip) 658 { 659 int i, o, err; 660 DE_INIT(("restore_dsp_settings\n")); 661 662 if ((err = check_asic_status(chip)) < 0) 663 return err; 664 665 /* Gina20/Darla20 only. Should be harmless for other cards. */ 666 chip->comm_page->gd_clock_state = GD_CLOCK_UNDEF; 667 chip->comm_page->gd_spdif_status = GD_SPDIF_STATUS_UNDEF; 668 chip->comm_page->handshake = 0xffffffff; 669 670 /* Restore output busses */ 671 for (i = 0; i < num_busses_out(chip); i++) { 672 err = set_output_gain(chip, i, chip->output_gain[i]); 673 if (err < 0) 674 return err; 675 } 676 677 #ifdef ECHOCARD_HAS_VMIXER 678 for (i = 0; i < num_pipes_out(chip); i++) 679 for (o = 0; o < num_busses_out(chip); o++) { 680 err = set_vmixer_gain(chip, o, i, 681 chip->vmixer_gain[o][i]); 682 if (err < 0) 683 return err; 684 } 685 if (update_vmixer_level(chip) < 0) 686 return -EIO; 687 #endif /* ECHOCARD_HAS_VMIXER */ 688 689 #ifdef ECHOCARD_HAS_MONITOR 690 for (o = 0; o < num_busses_out(chip); o++) 691 for (i = 0; i < num_busses_in(chip); i++) { 692 err = set_monitor_gain(chip, o, i, 693 chip->monitor_gain[o][i]); 694 if (err < 0) 695 return err; 696 } 697 #endif /* ECHOCARD_HAS_MONITOR */ 698 699 #ifdef ECHOCARD_HAS_INPUT_GAIN 700 for (i = 0; i < num_busses_in(chip); i++) { 701 err = set_input_gain(chip, i, chip->input_gain[i]); 702 if (err < 0) 703 return err; 704 } 705 #endif /* ECHOCARD_HAS_INPUT_GAIN */ 706 707 err = update_output_line_level(chip); 708 if (err < 0) 709 return err; 710 711 err = update_input_line_level(chip); 712 if (err < 0) 713 return err; 714 715 err = set_sample_rate(chip, chip->sample_rate); 716 if (err < 0) 717 return err; 718 719 if (chip->meters_enabled) { 720 err = send_vector(chip, DSP_VC_METERS_ON); 721 if (err < 0) 722 return err; 723 } 724 725 #ifdef ECHOCARD_HAS_DIGITAL_MODE_SWITCH 726 if (set_digital_mode(chip, chip->digital_mode) < 0) 727 return -EIO; 728 #endif 729 730 #ifdef ECHOCARD_HAS_DIGITAL_IO 731 if (set_professional_spdif(chip, chip->professional_spdif) < 0) 732 return -EIO; 733 #endif 734 735 #ifdef ECHOCARD_HAS_PHANTOM_POWER 736 if (set_phantom_power(chip, chip->phantom_power) < 0) 737 return -EIO; 738 #endif 739 740 #ifdef ECHOCARD_HAS_EXTERNAL_CLOCK 741 /* set_input_clock() also restores automute setting */ 742 if (set_input_clock(chip, chip->input_clock) < 0) 743 return -EIO; 744 #endif 745 746 #ifdef ECHOCARD_HAS_OUTPUT_CLOCK_SWITCH 747 if (set_output_clock(chip, chip->output_clock) < 0) 748 return -EIO; 749 #endif 750 751 if (wait_handshake(chip) < 0) 752 return -EIO; 753 clear_handshake(chip); 754 if (send_vector(chip, DSP_VC_UPDATE_FLAGS) < 0) 755 return -EIO; 756 757 DE_INIT(("restore_dsp_rettings done\n")); 758 return 0; 759 } 760 761 762 763 /**************************************************************************** 764 Transport functions 765 ****************************************************************************/ 766 767 /* set_audio_format() sets the format of the audio data in host memory for 768 this pipe. Note that _MS_ (mono-to-stereo) playback modes are not used by ALSA 769 but they are here because they are just mono while capturing */ 770 static void set_audio_format(struct echoaudio *chip, u16 pipe_index, 771 const struct audioformat *format) 772 { 773 u16 dsp_format; 774 775 dsp_format = DSP_AUDIOFORM_SS_16LE; 776 777 /* Look for super-interleave (no big-endian and 8 bits) */ 778 if (format->interleave > 2) { 779 switch (format->bits_per_sample) { 780 case 16: 781 dsp_format = DSP_AUDIOFORM_SUPER_INTERLEAVE_16LE; 782 break; 783 case 24: 784 dsp_format = DSP_AUDIOFORM_SUPER_INTERLEAVE_24LE; 785 break; 786 case 32: 787 dsp_format = DSP_AUDIOFORM_SUPER_INTERLEAVE_32LE; 788 break; 789 } 790 dsp_format |= format->interleave; 791 } else if (format->data_are_bigendian) { 792 /* For big-endian data, only 32 bit samples are supported */ 793 switch (format->interleave) { 794 case 1: 795 dsp_format = DSP_AUDIOFORM_MM_32BE; 796 break; 797 #ifdef ECHOCARD_HAS_STEREO_BIG_ENDIAN32 798 case 2: 799 dsp_format = DSP_AUDIOFORM_SS_32BE; 800 break; 801 #endif 802 } 803 } else if (format->interleave == 1 && 804 format->bits_per_sample == 32 && !format->mono_to_stereo) { 805 /* 32 bit little-endian mono->mono case */ 806 dsp_format = DSP_AUDIOFORM_MM_32LE; 807 } else { 808 /* Handle the other little-endian formats */ 809 switch (format->bits_per_sample) { 810 case 8: 811 if (format->interleave == 2) 812 dsp_format = DSP_AUDIOFORM_SS_8; 813 else 814 dsp_format = DSP_AUDIOFORM_MS_8; 815 break; 816 default: 817 case 16: 818 if (format->interleave == 2) 819 dsp_format = DSP_AUDIOFORM_SS_16LE; 820 else 821 dsp_format = DSP_AUDIOFORM_MS_16LE; 822 break; 823 case 24: 824 if (format->interleave == 2) 825 dsp_format = DSP_AUDIOFORM_SS_24LE; 826 else 827 dsp_format = DSP_AUDIOFORM_MS_24LE; 828 break; 829 case 32: 830 if (format->interleave == 2) 831 dsp_format = DSP_AUDIOFORM_SS_32LE; 832 else 833 dsp_format = DSP_AUDIOFORM_MS_32LE; 834 break; 835 } 836 } 837 DE_ACT(("set_audio_format[%d] = %x\n", pipe_index, dsp_format)); 838 chip->comm_page->audio_format[pipe_index] = cpu_to_le16(dsp_format); 839 } 840 841 842 843 /* start_transport starts transport for a set of pipes. 844 The bits 1 in channel_mask specify what pipes to start. Only the bit of the 845 first channel must be set, regardless its interleave. 846 Same thing for pause_ and stop_ -trasport below. */ 847 static int start_transport(struct echoaudio *chip, u32 channel_mask, 848 u32 cyclic_mask) 849 { 850 DE_ACT(("start_transport %x\n", channel_mask)); 851 852 if (wait_handshake(chip)) 853 return -EIO; 854 855 chip->comm_page->cmd_start |= cpu_to_le32(channel_mask); 856 857 if (chip->comm_page->cmd_start) { 858 clear_handshake(chip); 859 send_vector(chip, DSP_VC_START_TRANSFER); 860 if (wait_handshake(chip)) 861 return -EIO; 862 /* Keep track of which pipes are transporting */ 863 chip->active_mask |= channel_mask; 864 chip->comm_page->cmd_start = 0; 865 return 0; 866 } 867 868 DE_ACT(("start_transport: No pipes to start!\n")); 869 return -EINVAL; 870 } 871 872 873 874 static int pause_transport(struct echoaudio *chip, u32 channel_mask) 875 { 876 DE_ACT(("pause_transport %x\n", channel_mask)); 877 878 if (wait_handshake(chip)) 879 return -EIO; 880 881 chip->comm_page->cmd_stop |= cpu_to_le32(channel_mask); 882 chip->comm_page->cmd_reset = 0; 883 if (chip->comm_page->cmd_stop) { 884 clear_handshake(chip); 885 send_vector(chip, DSP_VC_STOP_TRANSFER); 886 if (wait_handshake(chip)) 887 return -EIO; 888 /* Keep track of which pipes are transporting */ 889 chip->active_mask &= ~channel_mask; 890 chip->comm_page->cmd_stop = 0; 891 chip->comm_page->cmd_reset = 0; 892 return 0; 893 } 894 895 DE_ACT(("pause_transport: No pipes to stop!\n")); 896 return 0; 897 } 898 899 900 901 static int stop_transport(struct echoaudio *chip, u32 channel_mask) 902 { 903 DE_ACT(("stop_transport %x\n", channel_mask)); 904 905 if (wait_handshake(chip)) 906 return -EIO; 907 908 chip->comm_page->cmd_stop |= cpu_to_le32(channel_mask); 909 chip->comm_page->cmd_reset |= cpu_to_le32(channel_mask); 910 if (chip->comm_page->cmd_reset) { 911 clear_handshake(chip); 912 send_vector(chip, DSP_VC_STOP_TRANSFER); 913 if (wait_handshake(chip)) 914 return -EIO; 915 /* Keep track of which pipes are transporting */ 916 chip->active_mask &= ~channel_mask; 917 chip->comm_page->cmd_stop = 0; 918 chip->comm_page->cmd_reset = 0; 919 return 0; 920 } 921 922 DE_ACT(("stop_transport: No pipes to stop!\n")); 923 return 0; 924 } 925 926 927 928 static inline int is_pipe_allocated(struct echoaudio *chip, u16 pipe_index) 929 { 930 return (chip->pipe_alloc_mask & (1 << pipe_index)); 931 } 932 933 934 935 /* Stops everything and turns off the DSP. All pipes should be already 936 stopped and unallocated. */ 937 static int rest_in_peace(struct echoaudio *chip) 938 { 939 DE_ACT(("rest_in_peace() open=%x\n", chip->pipe_alloc_mask)); 940 941 /* Stops all active pipes (just to be sure) */ 942 stop_transport(chip, chip->active_mask); 943 944 set_meters_on(chip, FALSE); 945 946 #ifdef ECHOCARD_HAS_MIDI 947 enable_midi_input(chip, FALSE); 948 #endif 949 950 /* Go to sleep */ 951 if (chip->dsp_code) { 952 /* Make load_firmware do a complete reload */ 953 chip->dsp_code = NULL; 954 /* Put the DSP to sleep */ 955 return send_vector(chip, DSP_VC_GO_COMATOSE); 956 } 957 return 0; 958 } 959 960 961 962 /* Fills the comm page with default values */ 963 static int init_dsp_comm_page(struct echoaudio *chip) 964 { 965 /* Check if the compiler added extra padding inside the structure */ 966 if (offsetof(struct comm_page, midi_output) != 0xbe0) { 967 DE_INIT(("init_dsp_comm_page() - Invalid struct comm_page structure\n")); 968 return -EPERM; 969 } 970 971 /* Init all the basic stuff */ 972 chip->card_name = ECHOCARD_NAME; 973 chip->bad_board = TRUE; /* Set TRUE until DSP loaded */ 974 chip->dsp_code = NULL; /* Current DSP code not loaded */ 975 chip->asic_loaded = FALSE; 976 memset(chip->comm_page, 0, sizeof(struct comm_page)); 977 978 /* Init the comm page */ 979 chip->comm_page->comm_size = 980 cpu_to_le32(sizeof(struct comm_page)); 981 chip->comm_page->handshake = 0xffffffff; 982 chip->comm_page->midi_out_free_count = 983 cpu_to_le32(DSP_MIDI_OUT_FIFO_SIZE); 984 chip->comm_page->sample_rate = cpu_to_le32(44100); 985 986 /* Set line levels so we don't blast any inputs on startup */ 987 memset(chip->comm_page->monitors, ECHOGAIN_MUTED, MONITOR_ARRAY_SIZE); 988 memset(chip->comm_page->vmixer, ECHOGAIN_MUTED, VMIXER_ARRAY_SIZE); 989 990 return 0; 991 } 992 993 994 995 /* This function initializes the chip structure with default values, ie. all 996 * muted and internal clock source. Then it copies the settings to the DSP. 997 * This MUST be called after the DSP is up and running ! 998 */ 999 static int init_line_levels(struct echoaudio *chip) 1000 { 1001 DE_INIT(("init_line_levels\n")); 1002 memset(chip->output_gain, ECHOGAIN_MUTED, sizeof(chip->output_gain)); 1003 memset(chip->input_gain, ECHOGAIN_MUTED, sizeof(chip->input_gain)); 1004 memset(chip->monitor_gain, ECHOGAIN_MUTED, sizeof(chip->monitor_gain)); 1005 memset(chip->vmixer_gain, ECHOGAIN_MUTED, sizeof(chip->vmixer_gain)); 1006 chip->input_clock = ECHO_CLOCK_INTERNAL; 1007 chip->output_clock = ECHO_CLOCK_WORD; 1008 chip->sample_rate = 44100; 1009 return restore_dsp_rettings(chip); 1010 } 1011 1012 1013 1014 /* This is low level part of the interrupt handler. 1015 It returns -1 if the IRQ is not ours, or N>=0 if it is, where N is the number 1016 of midi data in the input queue. */ 1017 static int service_irq(struct echoaudio *chip) 1018 { 1019 int st; 1020 1021 /* Read the DSP status register and see if this DSP generated this interrupt */ 1022 if (get_dsp_register(chip, CHI32_STATUS_REG) & CHI32_STATUS_IRQ) { 1023 st = 0; 1024 #ifdef ECHOCARD_HAS_MIDI 1025 /* Get and parse midi data if present */ 1026 if (chip->comm_page->midi_input[0]) /* The count is at index 0 */ 1027 st = midi_service_irq(chip); /* Returns how many midi bytes we received */ 1028 #endif 1029 /* Clear the hardware interrupt */ 1030 chip->comm_page->midi_input[0] = 0; 1031 send_vector(chip, DSP_VC_ACK_INT); 1032 return st; 1033 } 1034 return -1; 1035 } 1036 1037 1038 1039 1040 /****************************************************************************** 1041 Functions for opening and closing pipes 1042 ******************************************************************************/ 1043 1044 /* allocate_pipes is used to reserve audio pipes for your exclusive use. 1045 The call will fail if some pipes are already allocated. */ 1046 static int allocate_pipes(struct echoaudio *chip, struct audiopipe *pipe, 1047 int pipe_index, int interleave) 1048 { 1049 int i; 1050 u32 channel_mask; 1051 char is_cyclic; 1052 1053 DE_ACT(("allocate_pipes: ch=%d int=%d\n", pipe_index, interleave)); 1054 1055 if (chip->bad_board) 1056 return -EIO; 1057 1058 is_cyclic = 1; /* This driver uses cyclic buffers only */ 1059 1060 for (channel_mask = i = 0; i < interleave; i++) 1061 channel_mask |= 1 << (pipe_index + i); 1062 if (chip->pipe_alloc_mask & channel_mask) { 1063 DE_ACT(("allocate_pipes: channel already open\n")); 1064 return -EAGAIN; 1065 } 1066 1067 chip->comm_page->position[pipe_index] = 0; 1068 chip->pipe_alloc_mask |= channel_mask; 1069 if (is_cyclic) 1070 chip->pipe_cyclic_mask |= channel_mask; 1071 pipe->index = pipe_index; 1072 pipe->interleave = interleave; 1073 pipe->state = PIPE_STATE_STOPPED; 1074 1075 /* The counter register is where the DSP writes the 32 bit DMA 1076 position for a pipe. The DSP is constantly updating this value as 1077 it moves data. The DMA counter is in units of bytes, not samples. */ 1078 pipe->dma_counter = &chip->comm_page->position[pipe_index]; 1079 *pipe->dma_counter = 0; 1080 DE_ACT(("allocate_pipes: ok\n")); 1081 return pipe_index; 1082 } 1083 1084 1085 1086 static int free_pipes(struct echoaudio *chip, struct audiopipe *pipe) 1087 { 1088 u32 channel_mask; 1089 int i; 1090 1091 DE_ACT(("free_pipes: Pipe %d\n", pipe->index)); 1092 if (snd_BUG_ON(!is_pipe_allocated(chip, pipe->index))) 1093 return -EINVAL; 1094 if (snd_BUG_ON(pipe->state != PIPE_STATE_STOPPED)) 1095 return -EINVAL; 1096 1097 for (channel_mask = i = 0; i < pipe->interleave; i++) 1098 channel_mask |= 1 << (pipe->index + i); 1099 1100 chip->pipe_alloc_mask &= ~channel_mask; 1101 chip->pipe_cyclic_mask &= ~channel_mask; 1102 return 0; 1103 } 1104 1105 1106 1107 /****************************************************************************** 1108 Functions for managing the scatter-gather list 1109 ******************************************************************************/ 1110 1111 static int sglist_init(struct echoaudio *chip, struct audiopipe *pipe) 1112 { 1113 pipe->sglist_head = 0; 1114 memset(pipe->sgpage.area, 0, PAGE_SIZE); 1115 chip->comm_page->sglist_addr[pipe->index].addr = 1116 cpu_to_le32(pipe->sgpage.addr); 1117 return 0; 1118 } 1119 1120 1121 1122 static int sglist_add_mapping(struct echoaudio *chip, struct audiopipe *pipe, 1123 dma_addr_t address, size_t length) 1124 { 1125 int head = pipe->sglist_head; 1126 struct sg_entry *list = (struct sg_entry *)pipe->sgpage.area; 1127 1128 if (head < MAX_SGLIST_ENTRIES - 1) { 1129 list[head].addr = cpu_to_le32(address); 1130 list[head].size = cpu_to_le32(length); 1131 pipe->sglist_head++; 1132 } else { 1133 DE_ACT(("SGlist: too many fragments\n")); 1134 return -ENOMEM; 1135 } 1136 return 0; 1137 } 1138 1139 1140 1141 static inline int sglist_add_irq(struct echoaudio *chip, struct audiopipe *pipe) 1142 { 1143 return sglist_add_mapping(chip, pipe, 0, 0); 1144 } 1145 1146 1147 1148 static inline int sglist_wrap(struct echoaudio *chip, struct audiopipe *pipe) 1149 { 1150 return sglist_add_mapping(chip, pipe, pipe->sgpage.addr, 0); 1151 } 1152