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