sound/pci/echoaudio/echoaudio_dsp.c

   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 }