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         snd_assert(chip->dsp_code_to_load && chip->comm_page, return -EPERM);
 478
 479         /* See if the ASIC is present and working - only if the DSP is already loaded */
 480         if (chip->dsp_code) {
 481                 if ((box_type = check_asic_status(chip)) >= 0)
 482                         return box_type;
 483                 /* ASIC check failed; force the DSP to reload */
 484                 chip->dsp_code = NULL;
 485         }
 486
 487         if ((err = get_firmware(&fw, chip->dsp_code_to_load, chip)) < 0)
 488                 return err;
 489         err = load_dsp(chip, (u16 *)fw->data);
 490         free_firmware(fw);
 491         if (err < 0)
 492                 return err;
 493
 494         if ((box_type = load_asic(chip)) < 0)
 495                 return box_type;        /* error */
 496
 497         if ((err = restore_dsp_rettings(chip)) < 0)
 498                 return err;
 499
 500         return box_type;
 501 }
 502
 503
 504
 505 /****************************************************************************
 506         Mixer functions
 507  ****************************************************************************/
 508
 509 #if defined(ECHOCARD_HAS_INPUT_NOMINAL_LEVEL) || \
 510         defined(ECHOCARD_HAS_OUTPUT_NOMINAL_LEVEL)
 511
 512 /* Set the nominal level for an input or output bus (true = -10dBV, false = +4dBu) */
 513 static int set_nominal_level(struct echoaudio *chip, u16 index, char consumer)
 514 {
 515         snd_assert(index < num_busses_out(chip) + num_busses_in(chip),
 516                    return -EINVAL);
 517
 518         /* Wait for the handshake (OK even if ASIC is not loaded) */
 519         if (wait_handshake(chip))
 520                 return -EIO;
 521
 522         chip->nominal_level[index] = consumer;
 523
 524         if (consumer)
 525                 chip->comm_page->nominal_level_mask |= cpu_to_le32(1 << index);
 526         else
 527                 chip->comm_page->nominal_level_mask &= ~cpu_to_le32(1 << index);
 528
 529         return 0;
 530 }
 531
 532 #endif /* ECHOCARD_HAS_*_NOMINAL_LEVEL */
 533
 534
 535
 536 /* Set the gain for a single physical output channel (dB). */
 537 static int set_output_gain(struct echoaudio *chip, u16 channel, s8 gain)
 538 {
 539         snd_assert(channel < num_busses_out(chip), return -EINVAL);
 540
 541         if (wait_handshake(chip))
 542                 return -EIO;
 543
 544         /* Save the new value */
 545         chip->output_gain[channel] = gain;
 546         chip->comm_page->line_out_level[channel] = gain;
 547         return 0;
 548 }
 549
 550
 551
 552 #ifdef ECHOCARD_HAS_MONITOR
 553 /* Set the monitor level from an input bus to an output bus. */
 554 static int set_monitor_gain(struct echoaudio *chip, u16 output, u16 input,
 555                             s8 gain)
 556 {
 557         snd_assert(output < num_busses_out(chip) &&
 558                    input < num_busses_in(chip), return -EINVAL);
 559
 560         if (wait_handshake(chip))
 561                 return -EIO;
 562
 563         chip->monitor_gain[output][input] = gain;
 564         chip->comm_page->monitors[monitor_index(chip, output, input)] = gain;
 565         return 0;
 566 }
 567 #endif /* ECHOCARD_HAS_MONITOR */
 568
 569
 570 /* Tell the DSP to read and update output, nominal & monitor levels in comm page. */
 571 static int update_output_line_level(struct echoaudio *chip)
 572 {
 573         if (wait_handshake(chip))
 574                 return -EIO;
 575         clear_handshake(chip);
 576         return send_vector(chip, DSP_VC_UPDATE_OUTVOL);
 577 }
 578
 579
 580
 581 /* Tell the DSP to read and update input levels in comm page */
 582 static int update_input_line_level(struct echoaudio *chip)
 583 {
 584         if (wait_handshake(chip))
 585                 return -EIO;
 586         clear_handshake(chip);
 587         return send_vector(chip, DSP_VC_UPDATE_INGAIN);
 588 }
 589
 590
 591
 592 /* set_meters_on turns the meters on or off.  If meters are turned on, the DSP
 593 will write the meter and clock detect values to the comm page at about 30Hz */
 594 static void set_meters_on(struct echoaudio *chip, char on)
 595 {
 596         if (on && !chip->meters_enabled) {
 597                 send_vector(chip, DSP_VC_METERS_ON);
 598                 chip->meters_enabled = 1;
 599         } else if (!on && chip->meters_enabled) {
 600                 send_vector(chip, DSP_VC_METERS_OFF);
 601                 chip->meters_enabled = 0;
 602                 memset((s8 *)chip->comm_page->vu_meter, ECHOGAIN_MUTED,
 603                        DSP_MAXPIPES);
 604                 memset((s8 *)chip->comm_page->peak_meter, ECHOGAIN_MUTED,
 605                        DSP_MAXPIPES);
 606         }
 607 }
 608
 609
 610
 611 /* Fill out an the given array using the current values in the comm page.
 612 Meters are written in the comm page by the DSP in this order:
 613  Output busses
 614  Input busses
 615  Output pipes (vmixer cards only)
 616
 617 This function assumes there are no more than 16 in/out busses or pipes
 618 Meters is an array [3][16][2] of long. */
 619 static void get_audio_meters(struct echoaudio *chip, long *meters)
 620 {
 621         int i, m, n;
 622
 623         m = 0;
 624         n = 0;
 625         for (i = 0; i < num_busses_out(chip); i++, m++) {
 626                 meters[n++] = chip->comm_page->vu_meter[m];
 627                 meters[n++] = chip->comm_page->peak_meter[m];
 628         }
 629         for (; n < 32; n++)
 630                 meters[n] = 0;
 631
 632 #ifdef ECHOCARD_ECHO3G
 633         m = E3G_MAX_OUTPUTS;    /* Skip unused meters */
 634 #endif
 635
 636         for (i = 0; i < num_busses_in(chip); i++, m++) {
 637                 meters[n++] = chip->comm_page->vu_meter[m];
 638                 meters[n++] = chip->comm_page->peak_meter[m];
 639         }
 640         for (; n < 64; n++)
 641                 meters[n] = 0;
 642
 643 #ifdef ECHOCARD_HAS_VMIXER
 644         for (i = 0; i < num_pipes_out(chip); i++, m++) {
 645                 meters[n++] = chip->comm_page->vu_meter[m];
 646                 meters[n++] = chip->comm_page->peak_meter[m];
 647         }
 648 #endif
 649         for (; n < 96; n++)
 650                 meters[n] = 0;
 651 }
 652
 653
 654
 655 static int restore_dsp_rettings(struct echoaudio *chip)
 656 {
 657         int err;
 658         DE_INIT(("restore_dsp_settings\n"));
 659
 660         if ((err = check_asic_status(chip)) < 0)
 661                 return err;
 662
 663         /* @ Gina20/Darla20 only. Should be harmless for other cards. */
 664         chip->comm_page->gd_clock_state = GD_CLOCK_UNDEF;
 665         chip->comm_page->gd_spdif_status = GD_SPDIF_STATUS_UNDEF;
 666         chip->comm_page->handshake = 0xffffffff;
 667
 668         if ((err = set_sample_rate(chip, chip->sample_rate)) < 0)
 669                 return err;
 670
 671         if (chip->meters_enabled)
 672                 if (send_vector(chip, DSP_VC_METERS_ON) < 0)
 673                         return -EIO;
 674
 675 #ifdef ECHOCARD_HAS_EXTERNAL_CLOCK
 676         if (set_input_clock(chip, chip->input_clock) < 0)
 677                 return -EIO;
 678 #endif
 679
 680 #ifdef ECHOCARD_HAS_OUTPUT_CLOCK_SWITCH
 681         if (set_output_clock(chip, chip->output_clock) < 0)
 682                 return -EIO;
 683 #endif
 684
 685         if (update_output_line_level(chip) < 0)
 686                 return -EIO;
 687
 688         if (update_input_line_level(chip) < 0)
 689                 return -EIO;
 690
 691 #ifdef ECHOCARD_HAS_VMIXER
 692         if (update_vmixer_level(chip) < 0)
 693                 return -EIO;
 694 #endif
 695
 696         if (wait_handshake(chip) < 0)
 697                 return -EIO;
 698         clear_handshake(chip);
 699
 700         DE_INIT(("restore_dsp_rettings done\n"));
 701         return send_vector(chip, DSP_VC_UPDATE_FLAGS);
 702 }
 703
 704
 705
 706 /****************************************************************************
 707         Transport functions
 708  ****************************************************************************/
 709
 710 /* set_audio_format() sets the format of the audio data in host memory for
 711 this pipe.  Note that _MS_ (mono-to-stereo) playback modes are not used by ALSA
 712 but they are here because they are just mono while capturing */
 713 static void set_audio_format(struct echoaudio *chip, u16 pipe_index,
 714                              const struct audioformat *format)
 715 {
 716         u16 dsp_format;
 717
 718         dsp_format = DSP_AUDIOFORM_SS_16LE;
 719
 720         /* Look for super-interleave (no big-endian and 8 bits) */
 721         if (format->interleave > 2) {
 722                 switch (format->bits_per_sample) {
 723                 case 16:
 724                         dsp_format = DSP_AUDIOFORM_SUPER_INTERLEAVE_16LE;
 725                         break;
 726                 case 24:
 727                         dsp_format = DSP_AUDIOFORM_SUPER_INTERLEAVE_24LE;
 728                         break;
 729                 case 32:
 730                         dsp_format = DSP_AUDIOFORM_SUPER_INTERLEAVE_32LE;
 731                         break;
 732                 }
 733                 dsp_format |= format->interleave;
 734         } else if (format->data_are_bigendian) {
 735                 /* For big-endian data, only 32 bit samples are supported */
 736                 switch (format->interleave) {
 737                 case 1:
 738                         dsp_format = DSP_AUDIOFORM_MM_32BE;
 739                         break;
 740 #ifdef ECHOCARD_HAS_STEREO_BIG_ENDIAN32
 741                 case 2:
 742                         dsp_format = DSP_AUDIOFORM_SS_32BE;
 743                         break;
 744 #endif
 745                 }
 746         } else if (format->interleave == 1 &&
 747                    format->bits_per_sample == 32 && !format->mono_to_stereo) {
 748                 /* 32 bit little-endian mono->mono case */
 749                 dsp_format = DSP_AUDIOFORM_MM_32LE;
 750         } else {
 751                 /* Handle the other little-endian formats */
 752                 switch (format->bits_per_sample) {
 753                 case 8:
 754                         if (format->interleave == 2)
 755                                 dsp_format = DSP_AUDIOFORM_SS_8;
 756                         else
 757                                 dsp_format = DSP_AUDIOFORM_MS_8;
 758                         break;
 759                 default:
 760                 case 16:
 761                         if (format->interleave == 2)
 762                                 dsp_format = DSP_AUDIOFORM_SS_16LE;
 763                         else
 764                                 dsp_format = DSP_AUDIOFORM_MS_16LE;
 765                         break;
 766                 case 24:
 767                         if (format->interleave == 2)
 768                                 dsp_format = DSP_AUDIOFORM_SS_24LE;
 769                         else
 770                                 dsp_format = DSP_AUDIOFORM_MS_24LE;
 771                         break;
 772                 case 32:
 773                         if (format->interleave == 2)
 774                                 dsp_format = DSP_AUDIOFORM_SS_32LE;
 775                         else
 776                                 dsp_format = DSP_AUDIOFORM_MS_32LE;
 777                         break;
 778                 }
 779         }
 780         DE_ACT(("set_audio_format[%d] = %x\n", pipe_index, dsp_format));
 781         chip->comm_page->audio_format[pipe_index] = cpu_to_le16(dsp_format);
 782 }
 783
 784
 785
 786 /* start_transport starts transport for a set of pipes.
 787 The bits 1 in channel_mask specify what pipes to start. Only the bit of the
 788 first channel must be set, regardless its interleave.
 789 Same thing for pause_ and stop_ -trasport below. */
 790 static int start_transport(struct echoaudio *chip, u32 channel_mask,
 791                            u32 cyclic_mask)
 792 {
 793         DE_ACT(("start_transport %x\n", channel_mask));
 794
 795         if (wait_handshake(chip))
 796                 return -EIO;
 797
 798         chip->comm_page->cmd_start |= cpu_to_le32(channel_mask);
 799
 800         if (chip->comm_page->cmd_start) {
 801                 clear_handshake(chip);
 802                 send_vector(chip, DSP_VC_START_TRANSFER);
 803                 if (wait_handshake(chip))
 804                         return -EIO;
 805                 /* Keep track of which pipes are transporting */
 806                 chip->active_mask |= channel_mask;
 807                 chip->comm_page->cmd_start = 0;
 808                 return 0;
 809         }
 810
 811         DE_ACT(("start_transport: No pipes to start!\n"));
 812         return -EINVAL;
 813 }
 814
 815
 816
 817 static int pause_transport(struct echoaudio *chip, u32 channel_mask)
 818 {
 819         DE_ACT(("pause_transport %x\n", channel_mask));
 820
 821         if (wait_handshake(chip))
 822                 return -EIO;
 823
 824         chip->comm_page->cmd_stop |= cpu_to_le32(channel_mask);
 825         chip->comm_page->cmd_reset = 0;
 826         if (chip->comm_page->cmd_stop) {
 827                 clear_handshake(chip);
 828                 send_vector(chip, DSP_VC_STOP_TRANSFER);
 829                 if (wait_handshake(chip))
 830                         return -EIO;
 831                 /* Keep track of which pipes are transporting */
 832                 chip->active_mask &= ~channel_mask;
 833                 chip->comm_page->cmd_stop = 0;
 834                 chip->comm_page->cmd_reset = 0;
 835                 return 0;
 836         }
 837
 838         DE_ACT(("pause_transport: No pipes to stop!\n"));
 839         return 0;
 840 }
 841
 842
 843
 844 static int stop_transport(struct echoaudio *chip, u32 channel_mask)
 845 {
 846         DE_ACT(("stop_transport %x\n", channel_mask));
 847
 848         if (wait_handshake(chip))
 849                 return -EIO;
 850
 851         chip->comm_page->cmd_stop |= cpu_to_le32(channel_mask);
 852         chip->comm_page->cmd_reset |= cpu_to_le32(channel_mask);
 853         if (chip->comm_page->cmd_reset) {
 854                 clear_handshake(chip);
 855                 send_vector(chip, DSP_VC_STOP_TRANSFER);
 856                 if (wait_handshake(chip))
 857                         return -EIO;
 858                 /* Keep track of which pipes are transporting */
 859                 chip->active_mask &= ~channel_mask;
 860                 chip->comm_page->cmd_stop = 0;
 861                 chip->comm_page->cmd_reset = 0;
 862                 return 0;
 863         }
 864
 865         DE_ACT(("stop_transport: No pipes to stop!\n"));
 866         return 0;
 867 }
 868
 869
 870
 871 static inline int is_pipe_allocated(struct echoaudio *chip, u16 pipe_index)
 872 {
 873         return (chip->pipe_alloc_mask & (1 << pipe_index));
 874 }
 875
 876
 877
 878 /* Stops everything and turns off the DSP. All pipes should be already
 879 stopped and unallocated. */
 880 static int rest_in_peace(struct echoaudio *chip)
 881 {
 882         DE_ACT(("rest_in_peace() open=%x\n", chip->pipe_alloc_mask));
 883
 884         /* Stops all active pipes (just to be sure) */
 885         stop_transport(chip, chip->active_mask);
 886
 887         set_meters_on(chip, FALSE);
 888
 889 #ifdef ECHOCARD_HAS_MIDI
 890         enable_midi_input(chip, FALSE);
 891 #endif
 892
 893         /* Go to sleep */
 894         if (chip->dsp_code) {
 895                 /* Make load_firmware do a complete reload */
 896                 chip->dsp_code = NULL;
 897                 /* Put the DSP to sleep */
 898                 return send_vector(chip, DSP_VC_GO_COMATOSE);
 899         }
 900         return 0;
 901 }
 902
 903
 904
 905 /* Fills the comm page with default values */
 906 static int init_dsp_comm_page(struct echoaudio *chip)
 907 {
 908         /* Check if the compiler added extra padding inside the structure */
 909         if (offsetof(struct comm_page, midi_output) != 0xbe0) {
 910                 DE_INIT(("init_dsp_comm_page() - Invalid struct comm_page structure\n"));
 911                 return -EPERM;
 912         }
 913
 914         /* Init all the basic stuff */
 915         chip->card_name = ECHOCARD_NAME;
 916         chip->bad_board = TRUE; /* Set TRUE until DSP loaded */
 917         chip->dsp_code = NULL;  /* Current DSP code not loaded */
 918         chip->digital_mode = DIGITAL_MODE_NONE;
 919         chip->input_clock = ECHO_CLOCK_INTERNAL;
 920         chip->output_clock = ECHO_CLOCK_WORD;
 921         chip->asic_loaded = FALSE;
 922         memset(chip->comm_page, 0, sizeof(struct comm_page));
 923
 924         /* Init the comm page */
 925         chip->comm_page->comm_size =
 926                 __constant_cpu_to_le32(sizeof(struct comm_page));
 927         chip->comm_page->handshake = 0xffffffff;
 928         chip->comm_page->midi_out_free_count =
 929                 __constant_cpu_to_le32(DSP_MIDI_OUT_FIFO_SIZE);
 930         chip->comm_page->sample_rate = __constant_cpu_to_le32(44100);
 931         chip->sample_rate = 44100;
 932
 933         /* Set line levels so we don't blast any inputs on startup */
 934         memset(chip->comm_page->monitors, ECHOGAIN_MUTED, MONITOR_ARRAY_SIZE);
 935         memset(chip->comm_page->vmixer, ECHOGAIN_MUTED, VMIXER_ARRAY_SIZE);
 936
 937         return 0;
 938 }
 939
 940
 941
 942 /* This function initializes the several volume controls for busses and pipes.
 943 This MUST be called after the DSP is up and running ! */
 944 static int init_line_levels(struct echoaudio *chip)
 945 {
 946         int st, i, o;
 947
 948         DE_INIT(("init_line_levels\n"));
 949
 950         /* Mute output busses */
 951         for (i = 0; i < num_busses_out(chip); i++)
 952                 if ((st = set_output_gain(chip, i, ECHOGAIN_MUTED)))
 953                         return st;
 954         if ((st = update_output_line_level(chip)))
 955                 return st;
 956
 957 #ifdef ECHOCARD_HAS_VMIXER
 958         /* Mute the Vmixer */
 959         for (i = 0; i < num_pipes_out(chip); i++)
 960                 for (o = 0; o < num_busses_out(chip); o++)
 961                         if ((st = set_vmixer_gain(chip, o, i, ECHOGAIN_MUTED)))
 962                                 return st;
 963         if ((st = update_vmixer_level(chip)))
 964                 return st;
 965 #endif /* ECHOCARD_HAS_VMIXER */
 966
 967 #ifdef ECHOCARD_HAS_MONITOR
 968         /* Mute the monitor mixer */
 969         for (o = 0; o < num_busses_out(chip); o++)
 970                 for (i = 0; i < num_busses_in(chip); i++)
 971                         if ((st = set_monitor_gain(chip, o, i, ECHOGAIN_MUTED)))
 972                                 return st;
 973         if ((st = update_output_line_level(chip)))
 974                 return st;
 975 #endif /* ECHOCARD_HAS_MONITOR */
 976
 977 #ifdef ECHOCARD_HAS_INPUT_GAIN
 978         for (i = 0; i < num_busses_in(chip); i++)
 979                 if ((st = set_input_gain(chip, i, ECHOGAIN_MUTED)))
 980                         return st;
 981         if ((st = update_input_line_level(chip)))
 982                 return st;
 983 #endif /* ECHOCARD_HAS_INPUT_GAIN */
 984
 985         return 0;
 986 }
 987
 988
 989
 990 /* This is low level part of the interrupt handler.
 991 It returns -1 if the IRQ is not ours, or N>=0 if it is, where N is the number
 992 of midi data in the input queue. */
 993 static int service_irq(struct echoaudio *chip)
 994 {
 995         int st;
 996
 997         /* Read the DSP status register and see if this DSP generated this interrupt */
 998         if (get_dsp_register(chip, CHI32_STATUS_REG) & CHI32_STATUS_IRQ) {
 999                 st = 0;
1000 #ifdef ECHOCARD_HAS_MIDI
1001                 /* Get and parse midi data if present */
1002                 if (chip->comm_page->midi_input[0])     /* The count is at index 0 */
1003                         st = midi_service_irq(chip);    /* Returns how many midi bytes we received */
1004 #endif
1005                 /* Clear the hardware interrupt */
1006                 chip->comm_page->midi_input[0] = 0;
1007                 send_vector(chip, DSP_VC_ACK_INT);
1008                 return st;
1009         }
1010         return -1;
1011 }
1012
1013
1014
1015
1016 /******************************************************************************
1017         Functions for opening and closing pipes
1018  ******************************************************************************/
1019
1020 /* allocate_pipes is used to reserve audio pipes for your exclusive use.
1021 The call will fail if some pipes are already allocated. */
1022 static int allocate_pipes(struct echoaudio *chip, struct audiopipe *pipe,
1023                           int pipe_index, int interleave)
1024 {
1025         int i;
1026         u32 channel_mask;
1027         char is_cyclic;
1028
1029         DE_ACT(("allocate_pipes: ch=%d int=%d\n", pipe_index, interleave));
1030
1031         if (chip->bad_board)
1032                 return -EIO;
1033
1034         is_cyclic = 1;  /* This driver uses cyclic buffers only */
1035
1036         for (channel_mask = i = 0; i < interleave; i++)
1037                 channel_mask |= 1 << (pipe_index + i);
1038         if (chip->pipe_alloc_mask & channel_mask) {
1039                 DE_ACT(("allocate_pipes: channel already open\n"));
1040                 return -EAGAIN;
1041         }
1042
1043         chip->comm_page->position[pipe_index] = 0;
1044         chip->pipe_alloc_mask |= channel_mask;
1045         if (is_cyclic)
1046                 chip->pipe_cyclic_mask |= channel_mask;
1047         pipe->index = pipe_index;
1048         pipe->interleave = interleave;
1049         pipe->state = PIPE_STATE_STOPPED;
1050
1051         /* The counter register is where the DSP writes the 32 bit DMA
1052         position for a pipe.  The DSP is constantly updating this value as
1053         it moves data. The DMA counter is in units of bytes, not samples. */
1054         pipe->dma_counter = &chip->comm_page->position[pipe_index];
1055         *pipe->dma_counter = 0;
1056         DE_ACT(("allocate_pipes: ok\n"));
1057         return pipe_index;
1058 }
1059
1060
1061
1062 static int free_pipes(struct echoaudio *chip, struct audiopipe *pipe)
1063 {
1064         u32 channel_mask;
1065         int i;
1066
1067         DE_ACT(("free_pipes: Pipe %d\n", pipe->index));
1068         snd_assert(is_pipe_allocated(chip, pipe->index), return -EINVAL);
1069         snd_assert(pipe->state == PIPE_STATE_STOPPED, return -EINVAL);
1070
1071         for (channel_mask = i = 0; i < pipe->interleave; i++)
1072                 channel_mask |= 1 << (pipe->index + i);
1073
1074         chip->pipe_alloc_mask &= ~channel_mask;
1075         chip->pipe_cyclic_mask &= ~channel_mask;
1076         return 0;
1077 }
1078
1079
1080
1081 /******************************************************************************
1082         Functions for managing the scatter-gather list
1083 ******************************************************************************/
1084
1085 static int sglist_init(struct echoaudio *chip, struct audiopipe *pipe)
1086 {
1087         pipe->sglist_head = 0;
1088         memset(pipe->sgpage.area, 0, PAGE_SIZE);
1089         chip->comm_page->sglist_addr[pipe->index].addr =
1090                 cpu_to_le32(pipe->sgpage.addr);
1091         return 0;
1092 }
1093
1094
1095
1096 static int sglist_add_mapping(struct echoaudio *chip, struct audiopipe *pipe,
1097                                 dma_addr_t address, size_t length)
1098 {
1099         int head = pipe->sglist_head;
1100         struct sg_entry *list = (struct sg_entry *)pipe->sgpage.area;
1101
1102         if (head < MAX_SGLIST_ENTRIES - 1) {
1103                 list[head].addr = cpu_to_le32(address);
1104                 list[head].size = cpu_to_le32(length);
1105                 pipe->sglist_head++;
1106         } else {
1107                 DE_ACT(("SGlist: too many fragments\n"));
1108                 return -ENOMEM;
1109         }
1110         return 0;
1111 }
1112
1113
1114
1115 static inline int sglist_add_irq(struct echoaudio *chip, struct audiopipe *pipe)
1116 {
1117         return sglist_add_mapping(chip, pipe, 0, 0);
1118 }
1119
1120
1121
1122 static inline int sglist_wrap(struct echoaudio *chip, struct audiopipe *pipe)
1123 {
1124         return sglist_add_mapping(chip, pipe, pipe->sgpage.addr, 0);
1125 }