sound/pci/echoaudio/layla20_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
  32 static int read_dsp(struct echoaudio *chip, u32 *data);
  33 static int set_professional_spdif(struct echoaudio *chip, char prof);
  34 static int load_asic_generic(struct echoaudio *chip, u32 cmd,
  35                              const struct firmware *asic);
  36 static int check_asic_status(struct echoaudio *chip);
  37 static int update_flags(struct echoaudio *chip);
  38
  39
  40 static int init_hw(struct echoaudio *chip, u16 device_id, u16 subdevice_id)
  41 {
  42         int err;
  43
  44         DE_INIT(("init_hw() - Layla20\n"));
  45         snd_assert((subdevice_id & 0xfff0) == LAYLA20, return -ENODEV);
  46
  47         if ((err = init_dsp_comm_page(chip))) {
  48                 DE_INIT(("init_hw - could not initialize DSP comm page\n"));
  49                 return err;
  50         }
  51
  52         chip->device_id = device_id;
  53         chip->subdevice_id = subdevice_id;
  54         chip->bad_board = TRUE;
  55         chip->has_midi = TRUE;
  56         chip->dsp_code_to_load = &card_fw[FW_LAYLA20_DSP];
  57         chip->input_clock_types =
  58                 ECHO_CLOCK_BIT_INTERNAL | ECHO_CLOCK_BIT_SPDIF |
  59                 ECHO_CLOCK_BIT_WORD | ECHO_CLOCK_BIT_SUPER;
  60         chip->output_clock_types =
  61                 ECHO_CLOCK_BIT_WORD | ECHO_CLOCK_BIT_SUPER;
  62
  63         if ((err = load_firmware(chip)) < 0)
  64                 return err;
  65         chip->bad_board = FALSE;
  66
  67         if ((err = init_line_levels(chip)) < 0)
  68                 return err;
  69
  70         err = set_professional_spdif(chip, TRUE);
  71
  72         DE_INIT(("init_hw done\n"));
  73         return err;
  74 }
  75
  76
  77
  78 static u32 detect_input_clocks(const struct echoaudio *chip)
  79 {
  80         u32 clocks_from_dsp, clock_bits;
  81
  82         /* Map the DSP clock detect bits to the generic driver clock detect bits */
  83         clocks_from_dsp = le32_to_cpu(chip->comm_page->status_clocks);
  84
  85         clock_bits = ECHO_CLOCK_BIT_INTERNAL;
  86
  87         if (clocks_from_dsp & GLDM_CLOCK_DETECT_BIT_SPDIF)
  88                 clock_bits |= ECHO_CLOCK_BIT_SPDIF;
  89
  90         if (clocks_from_dsp & GLDM_CLOCK_DETECT_BIT_WORD) {
  91                 if (clocks_from_dsp & GLDM_CLOCK_DETECT_BIT_SUPER)
  92                         clock_bits |= ECHO_CLOCK_BIT_SUPER;
  93                 else
  94                         clock_bits |= ECHO_CLOCK_BIT_WORD;
  95         }
  96
  97         return clock_bits;
  98 }
  99
 100
 101
 102 /* ASIC status check - some cards have one or two ASICs that need to be
 103 loaded.  Once that load is complete, this function is called to see if
 104 the load was successful.
 105 If this load fails, it does not necessarily mean that the hardware is
 106 defective - the external box may be disconnected or turned off.
 107 This routine sometimes fails for Layla20; for Layla20, the loop runs
 108 5 times and succeeds if it wins on three of the loops. */
 109 static int check_asic_status(struct echoaudio *chip)
 110 {
 111         u32 asic_status;
 112         int goodcnt, i;
 113
 114         chip->asic_loaded = FALSE;
 115         for (i = goodcnt = 0; i < 5; i++) {
 116                 send_vector(chip, DSP_VC_TEST_ASIC);
 117
 118                 /* The DSP will return a value to indicate whether or not
 119                    the ASIC is currently loaded */
 120                 if (read_dsp(chip, &asic_status) < 0) {
 121                         DE_ACT(("check_asic_status: failed on read_dsp\n"));
 122                         return -EIO;
 123                 }
 124
 125                 if (asic_status == ASIC_ALREADY_LOADED) {
 126                         if (++goodcnt == 3) {
 127                                 chip->asic_loaded = TRUE;
 128                                 return 0;
 129                         }
 130                 }
 131         }
 132         return -EIO;
 133 }
 134
 135
 136
 137 /* Layla20 has an ASIC in the external box */
 138 static int load_asic(struct echoaudio *chip)
 139 {
 140         int err;
 141
 142         if (chip->asic_loaded)
 143                 return 0;
 144
 145         err = load_asic_generic(chip, DSP_FNC_LOAD_LAYLA_ASIC,
 146                                 &card_fw[FW_LAYLA20_ASIC]);
 147         if (err < 0)
 148                 return err;
 149
 150         /* Check if ASIC is alive and well. */
 151         return check_asic_status(chip);
 152 }
 153
 154
 155
 156 static int set_sample_rate(struct echoaudio *chip, u32 rate)
 157 {
 158         snd_assert(rate >= 8000 && rate <= 50000, return -EINVAL);
 159
 160         /* Only set the clock for internal mode. Do not return failure,
 161            simply treat it as a non-event. */
 162         if (chip->input_clock != ECHO_CLOCK_INTERNAL) {
 163                 DE_ACT(("set_sample_rate: Cannot set sample rate - "
 164                         "clock not set to CLK_CLOCKININTERNAL\n"));
 165                 chip->comm_page->sample_rate = cpu_to_le32(rate);
 166                 chip->sample_rate = rate;
 167                 return 0;
 168         }
 169
 170         if (wait_handshake(chip))
 171                 return -EIO;
 172
 173         DE_ACT(("set_sample_rate(%d)\n", rate));
 174         chip->sample_rate = rate;
 175         chip->comm_page->sample_rate = cpu_to_le32(rate);
 176         clear_handshake(chip);
 177         return send_vector(chip, DSP_VC_SET_LAYLA_SAMPLE_RATE);
 178 }
 179
 180
 181
 182 static int set_input_clock(struct echoaudio *chip, u16 clock_source)
 183 {
 184         u16 clock;
 185         u32 rate;
 186
 187         DE_ACT(("set_input_clock:\n"));
 188         rate = 0;
 189         switch (clock_source) {
 190         case ECHO_CLOCK_INTERNAL:
 191                 DE_ACT(("Set Layla20 clock to INTERNAL\n"));
 192                 rate = chip->sample_rate;
 193                 clock = LAYLA20_CLOCK_INTERNAL;
 194                 break;
 195         case ECHO_CLOCK_SPDIF:
 196                 DE_ACT(("Set Layla20 clock to SPDIF\n"));
 197                 clock = LAYLA20_CLOCK_SPDIF;
 198                 break;
 199         case ECHO_CLOCK_WORD:
 200                 DE_ACT(("Set Layla20 clock to WORD\n"));
 201                 clock = LAYLA20_CLOCK_WORD;
 202                 break;
 203         case ECHO_CLOCK_SUPER:
 204                 DE_ACT(("Set Layla20 clock to SUPER\n"));
 205                 clock = LAYLA20_CLOCK_SUPER;
 206                 break;
 207         default:
 208                 DE_ACT(("Input clock 0x%x not supported for Layla24\n",
 209                         clock_source));
 210                 return -EINVAL;
 211         }
 212         chip->input_clock = clock_source;
 213
 214         chip->comm_page->input_clock = cpu_to_le16(clock);
 215         clear_handshake(chip);
 216         send_vector(chip, DSP_VC_UPDATE_CLOCKS);
 217
 218         if (rate)
 219                 set_sample_rate(chip, rate);
 220
 221         return 0;
 222 }
 223
 224
 225
 226 static int set_output_clock(struct echoaudio *chip, u16 clock)
 227 {
 228         DE_ACT(("set_output_clock: %d\n", clock));
 229         switch (clock) {
 230         case ECHO_CLOCK_SUPER:
 231                 clock = LAYLA20_OUTPUT_CLOCK_SUPER;
 232                 break;
 233         case ECHO_CLOCK_WORD:
 234                 clock = LAYLA20_OUTPUT_CLOCK_WORD;
 235                 break;
 236         default:
 237                 DE_ACT(("set_output_clock wrong clock\n"));
 238                 return -EINVAL;
 239         }
 240
 241         if (wait_handshake(chip))
 242                 return -EIO;
 243
 244         chip->comm_page->output_clock = cpu_to_le16(clock);
 245         chip->output_clock = clock;
 246         clear_handshake(chip);
 247         return send_vector(chip, DSP_VC_UPDATE_CLOCKS);
 248 }
 249
 250
 251
 252 /* Set input bus gain (one unit is 0.5dB !) */
 253 static int set_input_gain(struct echoaudio *chip, u16 input, int gain)
 254 {
 255         snd_assert(input < num_busses_in(chip), return -EINVAL);
 256
 257         if (wait_handshake(chip))
 258                 return -EIO;
 259
 260         chip->input_gain[input] = gain;
 261         gain += GL20_INPUT_GAIN_MAGIC_NUMBER;
 262         chip->comm_page->line_in_level[input] = gain;
 263         return 0;
 264 }
 265
 266
 267
 268 /* Tell the DSP to reread the flags from the comm page */
 269 static int update_flags(struct echoaudio *chip)
 270 {
 271         if (wait_handshake(chip))
 272                 return -EIO;
 273         clear_handshake(chip);
 274         return send_vector(chip, DSP_VC_UPDATE_FLAGS);
 275 }
 276
 277
 278
 279 static int set_professional_spdif(struct echoaudio *chip, char prof)
 280 {
 281         DE_ACT(("set_professional_spdif %d\n", prof));
 282         if (prof)
 283                 chip->comm_page->flags |=
 284                         __constant_cpu_to_le32(DSP_FLAG_PROFESSIONAL_SPDIF);
 285         else
 286                 chip->comm_page->flags &=
 287                         ~__constant_cpu_to_le32(DSP_FLAG_PROFESSIONAL_SPDIF);
 288         chip->professional_spdif = prof;
 289         return update_flags(chip);
 290 }