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