~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/sound/pci/echoaudio/echoaudio_dsp.c

Version: ~ [ linux-5.16-rc3 ] ~ [ linux-5.15.5 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.82 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.162 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.218 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.256 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.291 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.293 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp