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