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 int i, m, n; 639 640 m = 0; 641 n = 0; 642 for (i = 0; i < num_busses_out(chip); i++, m++) { 643 meters[n++] = chip->comm_page->vu_meter[m]; 644 meters[n++] = chip->comm_page->peak_meter[m]; 645 } 646 for (; n < 32; n++) 647 meters[n] = 0; 648 649 #ifdef ECHOCARD_ECHO3G 650 m = E3G_MAX_OUTPUTS; /* Skip unused meters */ 651 #endif 652 653 for (i = 0; i < num_busses_in(chip); i++, m++) { 654 meters[n++] = chip->comm_page->vu_meter[m]; 655 meters[n++] = chip->comm_page->peak_meter[m]; 656 } 657 for (; n < 64; n++) 658 meters[n] = 0; 659 660 #ifdef ECHOCARD_HAS_VMIXER 661 for (i = 0; i < num_pipes_out(chip); i++, m++) { 662 meters[n++] = chip->comm_page->vu_meter[m]; 663 meters[n++] = chip->comm_page->peak_meter[m]; 664 } 665 #endif 666 for (; n < 96; n++) 667 meters[n] = 0; 668 } 669 670 671 672 static int restore_dsp_rettings(struct echoaudio *chip) 673 { 674 int i, o, err; 675 676 if ((err = check_asic_status(chip)) < 0) 677 return err; 678 679 /* Gina20/Darla20 only. Should be harmless for other cards. */ 680 chip->comm_page->gd_clock_state = GD_CLOCK_UNDEF; 681 chip->comm_page->gd_spdif_status = GD_SPDIF_STATUS_UNDEF; 682 chip->comm_page->handshake = 0xffffffff; 683 684 /* Restore output busses */ 685 for (i = 0; i < num_busses_out(chip); i++) { 686 err = set_output_gain(chip, i, chip->output_gain[i]); 687 if (err < 0) 688 return err; 689 } 690 691 #ifdef ECHOCARD_HAS_VMIXER 692 for (i = 0; i < num_pipes_out(chip); i++) 693 for (o = 0; o < num_busses_out(chip); o++) { 694 err = set_vmixer_gain(chip, o, i, 695 chip->vmixer_gain[o][i]); 696 if (err < 0) 697 return err; 698 } 699 if (update_vmixer_level(chip) < 0) 700 return -EIO; 701 #endif /* ECHOCARD_HAS_VMIXER */ 702 703 #ifdef ECHOCARD_HAS_MONITOR 704 for (o = 0; o < num_busses_out(chip); o++) 705 for (i = 0; i < num_busses_in(chip); i++) { 706 err = set_monitor_gain(chip, o, i, 707 chip->monitor_gain[o][i]); 708 if (err < 0) 709 return err; 710 } 711 #endif /* ECHOCARD_HAS_MONITOR */ 712 713 #ifdef ECHOCARD_HAS_INPUT_GAIN 714 for (i = 0; i < num_busses_in(chip); i++) { 715 err = set_input_gain(chip, i, chip->input_gain[i]); 716 if (err < 0) 717 return err; 718 } 719 #endif /* ECHOCARD_HAS_INPUT_GAIN */ 720 721 err = update_output_line_level(chip); 722 if (err < 0) 723 return err; 724 725 err = update_input_line_level(chip); 726 if (err < 0) 727 return err; 728 729 err = set_sample_rate(chip, chip->sample_rate); 730 if (err < 0) 731 return err; 732 733 if (chip->meters_enabled) { 734 err = send_vector(chip, DSP_VC_METERS_ON); 735 if (err < 0) 736 return err; 737 } 738 739 #ifdef ECHOCARD_HAS_DIGITAL_MODE_SWITCH 740 if (set_digital_mode(chip, chip->digital_mode) < 0) 741 return -EIO; 742 #endif 743 744 #ifdef ECHOCARD_HAS_DIGITAL_IO 745 if (set_professional_spdif(chip, chip->professional_spdif) < 0) 746 return -EIO; 747 #endif 748 749 #ifdef ECHOCARD_HAS_PHANTOM_POWER 750 if (set_phantom_power(chip, chip->phantom_power) < 0) 751 return -EIO; 752 #endif 753 754 #ifdef ECHOCARD_HAS_EXTERNAL_CLOCK 755 /* set_input_clock() also restores automute setting */ 756 if (set_input_clock(chip, chip->input_clock) < 0) 757 return -EIO; 758 #endif 759 760 #ifdef ECHOCARD_HAS_OUTPUT_CLOCK_SWITCH 761 if (set_output_clock(chip, chip->output_clock) < 0) 762 return -EIO; 763 #endif 764 765 if (wait_handshake(chip) < 0) 766 return -EIO; 767 clear_handshake(chip); 768 if (send_vector(chip, DSP_VC_UPDATE_FLAGS) < 0) 769 return -EIO; 770 771 return 0; 772 } 773 774 775 776 /**************************************************************************** 777 Transport functions 778 ****************************************************************************/ 779 780 /* set_audio_format() sets the format of the audio data in host memory for 781 this pipe. Note that _MS_ (mono-to-stereo) playback modes are not used by ALSA 782 but they are here because they are just mono while capturing */ 783 static void set_audio_format(struct echoaudio *chip, u16 pipe_index, 784 const struct audioformat *format) 785 { 786 u16 dsp_format; 787 788 dsp_format = DSP_AUDIOFORM_SS_16LE; 789 790 /* Look for super-interleave (no big-endian and 8 bits) */ 791 if (format->interleave > 2) { 792 switch (format->bits_per_sample) { 793 case 16: 794 dsp_format = DSP_AUDIOFORM_SUPER_INTERLEAVE_16LE; 795 break; 796 case 24: 797 dsp_format = DSP_AUDIOFORM_SUPER_INTERLEAVE_24LE; 798 break; 799 case 32: 800 dsp_format = DSP_AUDIOFORM_SUPER_INTERLEAVE_32LE; 801 break; 802 } 803 dsp_format |= format->interleave; 804 } else if (format->data_are_bigendian) { 805 /* For big-endian data, only 32 bit samples are supported */ 806 switch (format->interleave) { 807 case 1: 808 dsp_format = DSP_AUDIOFORM_MM_32BE; 809 break; 810 #ifdef ECHOCARD_HAS_STEREO_BIG_ENDIAN32 811 case 2: 812 dsp_format = DSP_AUDIOFORM_SS_32BE; 813 break; 814 #endif 815 } 816 } else if (format->interleave == 1 && 817 format->bits_per_sample == 32 && !format->mono_to_stereo) { 818 /* 32 bit little-endian mono->mono case */ 819 dsp_format = DSP_AUDIOFORM_MM_32LE; 820 } else { 821 /* Handle the other little-endian formats */ 822 switch (format->bits_per_sample) { 823 case 8: 824 if (format->interleave == 2) 825 dsp_format = DSP_AUDIOFORM_SS_8; 826 else 827 dsp_format = DSP_AUDIOFORM_MS_8; 828 break; 829 default: 830 case 16: 831 if (format->interleave == 2) 832 dsp_format = DSP_AUDIOFORM_SS_16LE; 833 else 834 dsp_format = DSP_AUDIOFORM_MS_16LE; 835 break; 836 case 24: 837 if (format->interleave == 2) 838 dsp_format = DSP_AUDIOFORM_SS_24LE; 839 else 840 dsp_format = DSP_AUDIOFORM_MS_24LE; 841 break; 842 case 32: 843 if (format->interleave == 2) 844 dsp_format = DSP_AUDIOFORM_SS_32LE; 845 else 846 dsp_format = DSP_AUDIOFORM_MS_32LE; 847 break; 848 } 849 } 850 dev_dbg(chip->card->dev, 851 "set_audio_format[%d] = %x\n", pipe_index, dsp_format); 852 chip->comm_page->audio_format[pipe_index] = cpu_to_le16(dsp_format); 853 } 854 855 856 857 /* start_transport starts transport for a set of pipes. 858 The bits 1 in channel_mask specify what pipes to start. Only the bit of the 859 first channel must be set, regardless its interleave. 860 Same thing for pause_ and stop_ -trasport below. */ 861 static int start_transport(struct echoaudio *chip, u32 channel_mask, 862 u32 cyclic_mask) 863 { 864 865 if (wait_handshake(chip)) 866 return -EIO; 867 868 chip->comm_page->cmd_start |= cpu_to_le32(channel_mask); 869 870 if (chip->comm_page->cmd_start) { 871 clear_handshake(chip); 872 send_vector(chip, DSP_VC_START_TRANSFER); 873 if (wait_handshake(chip)) 874 return -EIO; 875 /* Keep track of which pipes are transporting */ 876 chip->active_mask |= channel_mask; 877 chip->comm_page->cmd_start = 0; 878 return 0; 879 } 880 881 dev_err(chip->card->dev, "start_transport: No pipes to start!\n"); 882 return -EINVAL; 883 } 884 885 886 887 static int pause_transport(struct echoaudio *chip, u32 channel_mask) 888 { 889 890 if (wait_handshake(chip)) 891 return -EIO; 892 893 chip->comm_page->cmd_stop |= cpu_to_le32(channel_mask); 894 chip->comm_page->cmd_reset = 0; 895 if (chip->comm_page->cmd_stop) { 896 clear_handshake(chip); 897 send_vector(chip, DSP_VC_STOP_TRANSFER); 898 if (wait_handshake(chip)) 899 return -EIO; 900 /* Keep track of which pipes are transporting */ 901 chip->active_mask &= ~channel_mask; 902 chip->comm_page->cmd_stop = 0; 903 chip->comm_page->cmd_reset = 0; 904 return 0; 905 } 906 907 dev_warn(chip->card->dev, "pause_transport: No pipes to stop!\n"); 908 return 0; 909 } 910 911 912 913 static int stop_transport(struct echoaudio *chip, u32 channel_mask) 914 { 915 916 if (wait_handshake(chip)) 917 return -EIO; 918 919 chip->comm_page->cmd_stop |= cpu_to_le32(channel_mask); 920 chip->comm_page->cmd_reset |= cpu_to_le32(channel_mask); 921 if (chip->comm_page->cmd_reset) { 922 clear_handshake(chip); 923 send_vector(chip, DSP_VC_STOP_TRANSFER); 924 if (wait_handshake(chip)) 925 return -EIO; 926 /* Keep track of which pipes are transporting */ 927 chip->active_mask &= ~channel_mask; 928 chip->comm_page->cmd_stop = 0; 929 chip->comm_page->cmd_reset = 0; 930 return 0; 931 } 932 933 dev_warn(chip->card->dev, "stop_transport: No pipes to stop!\n"); 934 return 0; 935 } 936 937 938 939 static inline int is_pipe_allocated(struct echoaudio *chip, u16 pipe_index) 940 { 941 return (chip->pipe_alloc_mask & (1 << pipe_index)); 942 } 943 944 945 946 /* Stops everything and turns off the DSP. All pipes should be already 947 stopped and unallocated. */ 948 static int rest_in_peace(struct echoaudio *chip) 949 { 950 951 /* Stops all active pipes (just to be sure) */ 952 stop_transport(chip, chip->active_mask); 953 954 set_meters_on(chip, false); 955 956 #ifdef ECHOCARD_HAS_MIDI 957 enable_midi_input(chip, false); 958 #endif 959 960 /* Go to sleep */ 961 if (chip->dsp_code) { 962 /* Make load_firmware do a complete reload */ 963 chip->dsp_code = NULL; 964 /* Put the DSP to sleep */ 965 return send_vector(chip, DSP_VC_GO_COMATOSE); 966 } 967 return 0; 968 } 969 970 971 972 /* Fills the comm page with default values */ 973 static int init_dsp_comm_page(struct echoaudio *chip) 974 { 975 /* Check if the compiler added extra padding inside the structure */ 976 if (offsetof(struct comm_page, midi_output) != 0xbe0) { 977 dev_err(chip->card->dev, 978 "init_dsp_comm_page() - Invalid struct comm_page structure\n"); 979 return -EPERM; 980 } 981 982 /* Init all the basic stuff */ 983 chip->card_name = ECHOCARD_NAME; 984 chip->bad_board = true; /* Set true until DSP loaded */ 985 chip->dsp_code = NULL; /* Current DSP code not loaded */ 986 chip->asic_loaded = false; 987 memset(chip->comm_page, 0, sizeof(struct comm_page)); 988 989 /* Init the comm page */ 990 chip->comm_page->comm_size = 991 cpu_to_le32(sizeof(struct comm_page)); 992 chip->comm_page->handshake = 0xffffffff; 993 chip->comm_page->midi_out_free_count = 994 cpu_to_le32(DSP_MIDI_OUT_FIFO_SIZE); 995 chip->comm_page->sample_rate = cpu_to_le32(44100); 996 997 /* Set line levels so we don't blast any inputs on startup */ 998 memset(chip->comm_page->monitors, ECHOGAIN_MUTED, MONITOR_ARRAY_SIZE); 999 memset(chip->comm_page->vmixer, ECHOGAIN_MUTED, VMIXER_ARRAY_SIZE); 1000 1001 return 0; 1002 } 1003 1004 1005 1006 /* This function initializes the chip structure with default values, ie. all 1007 * muted and internal clock source. Then it copies the settings to the DSP. 1008 * This MUST be called after the DSP is up and running ! 1009 */ 1010 static int init_line_levels(struct echoaudio *chip) 1011 { 1012 memset(chip->output_gain, ECHOGAIN_MUTED, sizeof(chip->output_gain)); 1013 memset(chip->input_gain, ECHOGAIN_MUTED, sizeof(chip->input_gain)); 1014 memset(chip->monitor_gain, ECHOGAIN_MUTED, sizeof(chip->monitor_gain)); 1015 memset(chip->vmixer_gain, ECHOGAIN_MUTED, sizeof(chip->vmixer_gain)); 1016 chip->input_clock = ECHO_CLOCK_INTERNAL; 1017 chip->output_clock = ECHO_CLOCK_WORD; 1018 chip->sample_rate = 44100; 1019 return restore_dsp_rettings(chip); 1020 } 1021 1022 1023 1024 /* This is low level part of the interrupt handler. 1025 It returns -1 if the IRQ is not ours, or N>=0 if it is, where N is the number 1026 of midi data in the input queue. */ 1027 static int service_irq(struct echoaudio *chip) 1028 { 1029 int st; 1030 1031 /* Read the DSP status register and see if this DSP generated this interrupt */ 1032 if (get_dsp_register(chip, CHI32_STATUS_REG) & CHI32_STATUS_IRQ) { 1033 st = 0; 1034 #ifdef ECHOCARD_HAS_MIDI 1035 /* Get and parse midi data if present */ 1036 if (chip->comm_page->midi_input[0]) /* The count is at index 0 */ 1037 st = midi_service_irq(chip); /* Returns how many midi bytes we received */ 1038 #endif 1039 /* Clear the hardware interrupt */ 1040 chip->comm_page->midi_input[0] = 0; 1041 send_vector(chip, DSP_VC_ACK_INT); 1042 return st; 1043 } 1044 return -1; 1045 } 1046 1047 1048 1049 1050 /****************************************************************************** 1051 Functions for opening and closing pipes 1052 ******************************************************************************/ 1053 1054 /* allocate_pipes is used to reserve audio pipes for your exclusive use. 1055 The call will fail if some pipes are already allocated. */ 1056 static int allocate_pipes(struct echoaudio *chip, struct audiopipe *pipe, 1057 int pipe_index, int interleave) 1058 { 1059 int i; 1060 u32 channel_mask; 1061 char is_cyclic; 1062 1063 dev_dbg(chip->card->dev, 1064 "allocate_pipes: ch=%d int=%d\n", pipe_index, interleave); 1065 1066 if (chip->bad_board) 1067 return -EIO; 1068 1069 is_cyclic = 1; /* This driver uses cyclic buffers only */ 1070 1071 for (channel_mask = i = 0; i < interleave; i++) 1072 channel_mask |= 1 << (pipe_index + i); 1073 if (chip->pipe_alloc_mask & channel_mask) { 1074 dev_err(chip->card->dev, 1075 "allocate_pipes: channel already open\n"); 1076 return -EAGAIN; 1077 } 1078 1079 chip->comm_page->position[pipe_index] = 0; 1080 chip->pipe_alloc_mask |= channel_mask; 1081 if (is_cyclic) 1082 chip->pipe_cyclic_mask |= channel_mask; 1083 pipe->index = pipe_index; 1084 pipe->interleave = interleave; 1085 pipe->state = PIPE_STATE_STOPPED; 1086 1087 /* The counter register is where the DSP writes the 32 bit DMA 1088 position for a pipe. The DSP is constantly updating this value as 1089 it moves data. The DMA counter is in units of bytes, not samples. */ 1090 pipe->dma_counter = &chip->comm_page->position[pipe_index]; 1091 *pipe->dma_counter = 0; 1092 return pipe_index; 1093 } 1094 1095 1096 1097 static int free_pipes(struct echoaudio *chip, struct audiopipe *pipe) 1098 { 1099 u32 channel_mask; 1100 int i; 1101 1102 if (snd_BUG_ON(!is_pipe_allocated(chip, pipe->index))) 1103 return -EINVAL; 1104 if (snd_BUG_ON(pipe->state != PIPE_STATE_STOPPED)) 1105 return -EINVAL; 1106 1107 for (channel_mask = i = 0; i < pipe->interleave; i++) 1108 channel_mask |= 1 << (pipe->index + i); 1109 1110 chip->pipe_alloc_mask &= ~channel_mask; 1111 chip->pipe_cyclic_mask &= ~channel_mask; 1112 return 0; 1113 } 1114 1115 1116 1117 /****************************************************************************** 1118 Functions for managing the scatter-gather list 1119 ******************************************************************************/ 1120 1121 static int sglist_init(struct echoaudio *chip, struct audiopipe *pipe) 1122 { 1123 pipe->sglist_head = 0; 1124 memset(pipe->sgpage.area, 0, PAGE_SIZE); 1125 chip->comm_page->sglist_addr[pipe->index].addr = 1126 cpu_to_le32(pipe->sgpage.addr); 1127 return 0; 1128 } 1129 1130 1131 1132 static int sglist_add_mapping(struct echoaudio *chip, struct audiopipe *pipe, 1133 dma_addr_t address, size_t length) 1134 { 1135 int head = pipe->sglist_head; 1136 struct sg_entry *list = (struct sg_entry *)pipe->sgpage.area; 1137 1138 if (head < MAX_SGLIST_ENTRIES - 1) { 1139 list[head].addr = cpu_to_le32(address); 1140 list[head].size = cpu_to_le32(length); 1141 pipe->sglist_head++; 1142 } else { 1143 dev_err(chip->card->dev, "SGlist: too many fragments\n"); 1144 return -ENOMEM; 1145 } 1146 return 0; 1147 } 1148 1149 1150 1151 static inline int sglist_add_irq(struct echoaudio *chip, struct audiopipe *pipe) 1152 { 1153 return sglist_add_mapping(chip, pipe, 0, 0); 1154 } 1155 1156 1157 1158 static inline int sglist_wrap(struct echoaudio *chip, struct audiopipe *pipe) 1159 { 1160 return sglist_add_mapping(chip, pipe, pipe->sgpage.addr, 0); 1161 } 1162