2 * This program is free software; you can redistribute it and/or modify
3 * it under the terms of the GNU General Public License as published by
4 * the Free Software Foundation; either version 2 of the License, or
5 * (at your option) any later version.
7 * This program is distributed in the hope that it will be useful,
8 * but WITHOUT ANY WARRANTY; without even the implied warranty of
9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10 * GNU General Public License for more details.
12 * You should have received a copy of the GNU General Public License
13 * along with this program; if not, write to the Free Software
14 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 * 2002-07 Benny Sjostrand benny@hostmobility.com
23 #include <sound/driver.h>
25 #include <linux/delay.h>
26 #include <linux/pci.h>
28 #include <linux/init.h>
29 #include <linux/slab.h>
30 #include <linux/vmalloc.h>
31 #include <sound/core.h>
32 #include <sound/control.h>
33 #include <sound/info.h>
34 #include <sound/asoundef.h>
35 #include <sound/cs46xx.h>
37 #include "cs46xx_lib.h"
40 static wide_opcode_t wide_opcodes
[] = {
45 WIDE_TBEQ_COND_GOTO_ADDR
,
46 WIDE_TBEQ_COND_CALL_ADDR
,
47 WIDE_TBEQ_NCOND_GOTO_ADDR
,
48 WIDE_TBEQ_NCOND_CALL_ADDR
,
49 WIDE_TBEQ_COND_GOTO1_ADDR
,
50 WIDE_TBEQ_COND_CALL1_ADDR
,
51 WIDE_TBEQ_NCOND_GOTOI_ADDR
,
52 WIDE_TBEQ_NCOND_CALL1_ADDR
55 static int shadow_and_reallocate_code (cs46xx_t
* chip
,u32
* data
,u32 size
, u32 overlay_begin_address
)
57 unsigned int i
= 0, j
, nreallocated
= 0;
58 u32 hival
,loval
,address
;
59 u32 mop_operands
,mop_type
,wide_op
;
60 dsp_spos_instance_t
* ins
= chip
->dsp_spos_instance
;
62 snd_assert( ((size
% 2) == 0), return -EINVAL
);
68 if (ins
->code
.offset
> 0) {
69 mop_operands
= (hival
>> 6) & 0x03fff;
70 mop_type
= mop_operands
>> 10;
72 /* check for wide type instruction */
74 (mop_operands
& WIDE_LADD_INSTR_MASK
) == 0 &&
75 (mop_operands
& WIDE_INSTR_MASK
) != 0) {
76 wide_op
= loval
& 0x7f;
77 for (j
= 0;j
< ARRAY_SIZE(wide_opcodes
); ++j
) {
78 if (wide_opcodes
[j
] == wide_op
) {
79 /* need to reallocate instruction */
80 address
= (hival
& 0x00FFF) << 5;
81 address
|= loval
>> 15;
83 snd_printdd("handle_wideop[1]: %05x:%05x addr %04x\n",hival
,loval
,address
);
85 if ( !(address
& 0x8000) ) {
86 address
+= (ins
->code
.offset
/ 2) - overlay_begin_address
;
88 snd_printdd("handle_wideop[1]: ROM symbol not reallocated\n");
94 hival
|= ( (address
>> 5) & 0x00FFF);
95 loval
|= ( (address
<< 15) & 0xF8000);
97 address
= (hival
& 0x00FFF) << 5;
98 address
|= loval
>> 15;
100 snd_printdd("handle_wideop:[2] %05x:%05x addr %04x\n",hival
,loval
,address
);
102 } /* wide_opcodes[j] == wide_op */
104 } /* mod_type == 0 ... */
105 } /* ins->code.offset > 0 */
107 ins
->code
.data
[ins
->code
.size
++] = loval
;
108 ins
->code
.data
[ins
->code
.size
++] = hival
;
111 snd_printdd("dsp_spos: %d instructions reallocated\n",nreallocated
);
115 static segment_desc_t
* get_segment_desc (dsp_module_desc_t
* module
, int seg_type
)
118 for (i
= 0;i
< module
->nsegments
; ++i
) {
119 if (module
->segments
[i
].segment_type
== seg_type
) {
120 return (module
->segments
+ i
);
127 static int find_free_symbol_index (dsp_spos_instance_t
* ins
)
129 int index
= ins
->symbol_table
.nsymbols
,i
;
131 for (i
= ins
->symbol_table
.highest_frag_index
; i
< ins
->symbol_table
.nsymbols
; ++i
) {
132 if (ins
->symbol_table
.symbols
[i
].deleted
) {
141 static int add_symbols (cs46xx_t
* chip
, dsp_module_desc_t
* module
)
144 dsp_spos_instance_t
* ins
= chip
->dsp_spos_instance
;
146 if (module
->symbol_table
.nsymbols
> 0) {
147 if (!strcmp(module
->symbol_table
.symbols
[0].symbol_name
, "OVERLAYBEGINADDRESS") &&
148 module
->symbol_table
.symbols
[0].symbol_type
== SYMBOL_CONSTANT
) {
149 module
->overlay_begin_address
= module
->symbol_table
.symbols
[0].address
;
153 for (i
= 0;i
< module
->symbol_table
.nsymbols
; ++i
) {
154 if (ins
->symbol_table
.nsymbols
== (DSP_MAX_SYMBOLS
- 1)) {
155 snd_printk(KERN_ERR
"dsp_spos: symbol table is full\n");
160 if (cs46xx_dsp_lookup_symbol(chip
,
161 module
->symbol_table
.symbols
[i
].symbol_name
,
162 module
->symbol_table
.symbols
[i
].symbol_type
) == NULL
) {
164 ins
->symbol_table
.symbols
[ins
->symbol_table
.nsymbols
] = module
->symbol_table
.symbols
[i
];
165 ins
->symbol_table
.symbols
[ins
->symbol_table
.nsymbols
].address
+= ((ins
->code
.offset
/ 2) - module
->overlay_begin_address
);
166 ins
->symbol_table
.symbols
[ins
->symbol_table
.nsymbols
].module
= module
;
167 ins
->symbol_table
.symbols
[ins
->symbol_table
.nsymbols
].deleted
= 0;
169 if (ins
->symbol_table
.nsymbols
> ins
->symbol_table
.highest_frag_index
)
170 ins
->symbol_table
.highest_frag_index
= ins
->symbol_table
.nsymbols
;
172 ins
->symbol_table
.nsymbols
++;
174 /* if (0) printk ("dsp_spos: symbol <%s> duplicated, probably nothing wrong with that (Cirrus?)\n",
175 module->symbol_table.symbols[i].symbol_name); */
182 static symbol_entry_t
* add_symbol (cs46xx_t
* chip
, char * symbol_name
, u32 address
, int type
)
184 dsp_spos_instance_t
* ins
= chip
->dsp_spos_instance
;
185 symbol_entry_t
* symbol
= NULL
;
188 if (ins
->symbol_table
.nsymbols
== (DSP_MAX_SYMBOLS
- 1)) {
189 snd_printk(KERN_ERR
"dsp_spos: symbol table is full\n");
193 if (cs46xx_dsp_lookup_symbol(chip
,
196 snd_printk(KERN_ERR
"dsp_spos: symbol <%s> duplicated\n", symbol_name
);
200 index
= find_free_symbol_index (ins
);
202 strcpy (ins
->symbol_table
.symbols
[index
].symbol_name
, symbol_name
);
203 ins
->symbol_table
.symbols
[index
].address
= address
;
204 ins
->symbol_table
.symbols
[index
].symbol_type
= type
;
205 ins
->symbol_table
.symbols
[index
].module
= NULL
;
206 ins
->symbol_table
.symbols
[index
].deleted
= 0;
207 symbol
= (ins
->symbol_table
.symbols
+ index
);
209 if (index
> ins
->symbol_table
.highest_frag_index
)
210 ins
->symbol_table
.highest_frag_index
= index
;
212 if (index
== ins
->symbol_table
.nsymbols
)
213 ins
->symbol_table
.nsymbols
++; /* no frag. in list */
218 dsp_spos_instance_t
* cs46xx_dsp_spos_create (cs46xx_t
* chip
)
220 dsp_spos_instance_t
* ins
= kmalloc(sizeof(dsp_spos_instance_t
), GFP_KERNEL
);
224 memset(ins
, 0, sizeof(*ins
));
226 /* better to use vmalloc for this big table */
227 ins
->symbol_table
.nsymbols
= 0;
228 ins
->symbol_table
.symbols
= vmalloc(sizeof(symbol_entry_t
) * DSP_MAX_SYMBOLS
);
229 ins
->symbol_table
.highest_frag_index
= 0;
231 if (ins
->symbol_table
.symbols
== NULL
) {
232 cs46xx_dsp_spos_destroy(chip
);
236 ins
->code
.offset
= 0;
238 ins
->code
.data
= kmalloc(DSP_CODE_BYTE_SIZE
, GFP_KERNEL
);
240 if (ins
->code
.data
== NULL
) {
241 cs46xx_dsp_spos_destroy(chip
);
249 ins
->modules
= kmalloc(sizeof(dsp_module_desc_t
) * DSP_MAX_MODULES
, GFP_KERNEL
);
251 if (ins
->modules
== NULL
) {
252 cs46xx_dsp_spos_destroy(chip
);
256 /* default SPDIF input sample rate
258 ins
->spdif_in_sample_rate
= 48000;
260 /* maximize volume */
261 ins
->dac_volume_right
= 0x8000;
262 ins
->dac_volume_left
= 0x8000;
263 ins
->spdif_input_volume_right
= 0x8000;
264 ins
->spdif_input_volume_left
= 0x8000;
266 /* set left and right validity bits and
267 default channel status */
268 ins
->spdif_csuv_default
=
269 ins
->spdif_csuv_stream
=
270 /* byte 0 */ ((unsigned int)_wrap_all_bits( (SNDRV_PCM_DEFAULT_CON_SPDIF
& 0xff)) << 24) |
271 /* byte 1 */ ((unsigned int)_wrap_all_bits( ((SNDRV_PCM_DEFAULT_CON_SPDIF
>> 8) & 0xff)) << 16) |
272 /* byte 3 */ (unsigned int)_wrap_all_bits( (SNDRV_PCM_DEFAULT_CON_SPDIF
>> 24) & 0xff) |
273 /* left and right validity bits */ (1 << 13) | (1 << 12);
278 void cs46xx_dsp_spos_destroy (cs46xx_t
* chip
)
281 dsp_spos_instance_t
* ins
= chip
->dsp_spos_instance
;
283 snd_assert(ins
!= NULL
, return);
285 down(&chip
->spos_mutex
);
286 for (i
= 0; i
< ins
->nscb
; ++i
) {
287 if (ins
->scbs
[i
].deleted
) continue;
289 cs46xx_dsp_proc_free_scb_desc ( (ins
->scbs
+ i
) );
293 kfree(ins
->code
.data
);
295 if (ins
->symbol_table
.symbols
)
296 vfree(ins
->symbol_table
.symbols
);
302 up(&chip
->spos_mutex
);
305 int cs46xx_dsp_load_module (cs46xx_t
* chip
, dsp_module_desc_t
* module
)
307 dsp_spos_instance_t
* ins
= chip
->dsp_spos_instance
;
308 segment_desc_t
* code
= get_segment_desc (module
,SEGTYPE_SP_PROGRAM
);
309 segment_desc_t
* parameter
= get_segment_desc (module
,SEGTYPE_SP_PARAMETER
);
310 segment_desc_t
* sample
= get_segment_desc (module
,SEGTYPE_SP_SAMPLE
);
313 if (ins
->nmodules
== DSP_MAX_MODULES
- 1) {
314 snd_printk(KERN_ERR
"dsp_spos: to many modules loaded into DSP\n");
318 snd_printdd("dsp_spos: loading module %s into DSP\n", module
->module_name
);
320 if (ins
->nmodules
== 0) {
321 snd_printdd("dsp_spos: clearing parameter area\n");
322 snd_cs46xx_clear_BA1(chip
, DSP_PARAMETER_BYTE_OFFSET
, DSP_PARAMETER_BYTE_SIZE
);
325 if (parameter
== NULL
) {
326 snd_printdd("dsp_spos: module got no parameter segment\n");
328 if (ins
->nmodules
> 0) {
329 snd_printk(KERN_WARNING
"dsp_spos: WARNING current parameter data may be overwriten!\n");
332 doffset
= (parameter
->offset
* 4 + DSP_PARAMETER_BYTE_OFFSET
);
333 dsize
= parameter
->size
* 4;
335 snd_printdd("dsp_spos: downloading parameter data to chip (%08x-%08x)\n",
336 doffset
,doffset
+ dsize
);
338 if (snd_cs46xx_download (chip
, parameter
->data
, doffset
, dsize
)) {
339 snd_printk(KERN_ERR
"dsp_spos: failed to download parameter data to DSP\n");
344 if (ins
->nmodules
== 0) {
345 snd_printdd("dsp_spos: clearing sample area\n");
346 snd_cs46xx_clear_BA1(chip
, DSP_SAMPLE_BYTE_OFFSET
, DSP_SAMPLE_BYTE_SIZE
);
349 if (sample
== NULL
) {
350 snd_printdd("dsp_spos: module got no sample segment\n");
352 if (ins
->nmodules
> 0) {
353 snd_printk(KERN_WARNING
"dsp_spos: WARNING current sample data may be overwriten\n");
356 doffset
= (sample
->offset
* 4 + DSP_SAMPLE_BYTE_OFFSET
);
357 dsize
= sample
->size
* 4;
359 snd_printdd("dsp_spos: downloading sample data to chip (%08x-%08x)\n",
360 doffset
,doffset
+ dsize
);
362 if (snd_cs46xx_download (chip
,sample
->data
,doffset
,dsize
)) {
363 snd_printk(KERN_ERR
"dsp_spos: failed to sample data to DSP\n");
369 if (ins
->nmodules
== 0) {
370 snd_printdd("dsp_spos: clearing code area\n");
371 snd_cs46xx_clear_BA1(chip
, DSP_CODE_BYTE_OFFSET
, DSP_CODE_BYTE_SIZE
);
375 snd_printdd("dsp_spos: module got no code segment\n");
377 if (ins
->code
.offset
+ code
->size
> DSP_CODE_BYTE_SIZE
) {
378 snd_printk(KERN_ERR
"dsp_spos: no space available in DSP\n");
382 module
->load_address
= ins
->code
.offset
;
383 module
->overlay_begin_address
= 0x000;
385 /* if module has a code segment it must have
387 snd_assert(module
->symbol_table
.symbols
!= NULL
,return -ENOMEM
);
388 if (add_symbols(chip
,module
)) {
389 snd_printk(KERN_ERR
"dsp_spos: failed to load symbol table\n");
393 doffset
= (code
->offset
* 4 + ins
->code
.offset
* 4 + DSP_CODE_BYTE_OFFSET
);
394 dsize
= code
->size
* 4;
395 snd_printdd("dsp_spos: downloading code to chip (%08x-%08x)\n",
396 doffset
,doffset
+ dsize
);
398 module
->nfixups
= shadow_and_reallocate_code(chip
,code
->data
,code
->size
,module
->overlay_begin_address
);
400 if (snd_cs46xx_download (chip
,(ins
->code
.data
+ ins
->code
.offset
),doffset
,dsize
)) {
401 snd_printk(KERN_ERR
"dsp_spos: failed to download code to DSP\n");
405 ins
->code
.offset
+= code
->size
;
408 /* NOTE: module segments and symbol table must be
409 statically allocated. Case that module data is
410 not generated by the ospparser */
411 ins
->modules
[ins
->nmodules
] = *module
;
417 symbol_entry_t
* cs46xx_dsp_lookup_symbol (cs46xx_t
* chip
, char * symbol_name
, int symbol_type
)
420 dsp_spos_instance_t
* ins
= chip
->dsp_spos_instance
;
422 for ( i
= 0; i
< ins
->symbol_table
.nsymbols
; ++i
) {
424 if (ins
->symbol_table
.symbols
[i
].deleted
)
427 if (!strcmp(ins
->symbol_table
.symbols
[i
].symbol_name
,symbol_name
) &&
428 ins
->symbol_table
.symbols
[i
].symbol_type
== symbol_type
) {
429 return (ins
->symbol_table
.symbols
+ i
);
434 printk ("dsp_spos: symbol <%s> type %02x not found\n",
435 symbol_name
,symbol_type
);
442 symbol_entry_t
* cs46xx_dsp_lookup_symbol_addr (cs46xx_t
* chip
, u32 address
, int symbol_type
)
445 dsp_spos_instance_t
* ins
= chip
->dsp_spos_instance
;
447 for ( i
= 0; i
< ins
->symbol_table
.nsymbols
; ++i
) {
449 if (ins
->symbol_table
.symbols
[i
].deleted
)
452 if (ins
->symbol_table
.symbols
[i
].address
== address
&&
453 ins
->symbol_table
.symbols
[i
].symbol_type
== symbol_type
) {
454 return (ins
->symbol_table
.symbols
+ i
);
463 static void cs46xx_dsp_proc_symbol_table_read (snd_info_entry_t
*entry
, snd_info_buffer_t
* buffer
)
465 cs46xx_t
*chip
= entry
->private_data
;
466 dsp_spos_instance_t
* ins
= chip
->dsp_spos_instance
;
469 snd_iprintf(buffer
, "SYMBOLS:\n");
470 for ( i
= 0; i
< ins
->symbol_table
.nsymbols
; ++i
) {
471 char *module_str
= "system";
473 if (ins
->symbol_table
.symbols
[i
].deleted
)
476 if (ins
->symbol_table
.symbols
[i
].module
!= NULL
) {
477 module_str
= ins
->symbol_table
.symbols
[i
].module
->module_name
;
481 snd_iprintf(buffer
, "%04X <%02X> %s [%s]\n",
482 ins
->symbol_table
.symbols
[i
].address
,
483 ins
->symbol_table
.symbols
[i
].symbol_type
,
484 ins
->symbol_table
.symbols
[i
].symbol_name
,
490 static void cs46xx_dsp_proc_modules_read (snd_info_entry_t
*entry
, snd_info_buffer_t
* buffer
)
492 cs46xx_t
*chip
= entry
->private_data
;
493 dsp_spos_instance_t
* ins
= chip
->dsp_spos_instance
;
496 down(&chip
->spos_mutex
);
497 snd_iprintf(buffer
, "MODULES:\n");
498 for ( i
= 0; i
< ins
->nmodules
; ++i
) {
499 snd_iprintf(buffer
, "\n%s:\n", ins
->modules
[i
].module_name
);
500 snd_iprintf(buffer
, " %d symbols\n", ins
->modules
[i
].symbol_table
.nsymbols
);
501 snd_iprintf(buffer
, " %d fixups\n", ins
->modules
[i
].nfixups
);
503 for (j
= 0; j
< ins
->modules
[i
].nsegments
; ++ j
) {
504 segment_desc_t
* desc
= (ins
->modules
[i
].segments
+ j
);
505 snd_iprintf(buffer
, " segment %02x offset %08x size %08x\n",
506 desc
->segment_type
,desc
->offset
, desc
->size
);
509 up(&chip
->spos_mutex
);
512 static void cs46xx_dsp_proc_task_tree_read (snd_info_entry_t
*entry
, snd_info_buffer_t
* buffer
)
514 cs46xx_t
*chip
= entry
->private_data
;
515 dsp_spos_instance_t
* ins
= chip
->dsp_spos_instance
;
517 unsigned long dst
= chip
->region
.idx
[1].remap_addr
+ DSP_PARAMETER_BYTE_OFFSET
;
519 down(&chip
->spos_mutex
);
520 snd_iprintf(buffer
, "TASK TREES:\n");
521 for ( i
= 0; i
< ins
->ntask
; ++i
) {
522 snd_iprintf(buffer
,"\n%04x %s:\n",ins
->tasks
[i
].address
,ins
->tasks
[i
].task_name
);
524 for (col
= 0,j
= 0;j
< ins
->tasks
[i
].size
; j
++,col
++) {
527 snd_iprintf(buffer
,"\n");
530 val
= readl(dst
+ (ins
->tasks
[i
].address
+ j
) * sizeof(u32
));
531 snd_iprintf(buffer
,"%08x ",val
);
535 snd_iprintf(buffer
,"\n");
536 up(&chip
->spos_mutex
);
539 static void cs46xx_dsp_proc_scb_read (snd_info_entry_t
*entry
, snd_info_buffer_t
* buffer
)
541 cs46xx_t
*chip
= entry
->private_data
;
542 dsp_spos_instance_t
* ins
= chip
->dsp_spos_instance
;
545 down(&chip
->spos_mutex
);
546 snd_iprintf(buffer
, "SCB's:\n");
547 for ( i
= 0; i
< ins
->nscb
; ++i
) {
548 if (ins
->scbs
[i
].deleted
)
550 snd_iprintf(buffer
,"\n%04x %s:\n\n",ins
->scbs
[i
].address
,ins
->scbs
[i
].scb_name
);
552 if (ins
->scbs
[i
].parent_scb_ptr
!= NULL
) {
553 snd_iprintf(buffer
,"parent [%s:%04x] ",
554 ins
->scbs
[i
].parent_scb_ptr
->scb_name
,
555 ins
->scbs
[i
].parent_scb_ptr
->address
);
556 } else snd_iprintf(buffer
,"parent [none] ");
558 snd_iprintf(buffer
,"sub_list_ptr [%s:%04x]\nnext_scb_ptr [%s:%04x] task_entry [%s:%04x]\n",
559 ins
->scbs
[i
].sub_list_ptr
->scb_name
,
560 ins
->scbs
[i
].sub_list_ptr
->address
,
561 ins
->scbs
[i
].next_scb_ptr
->scb_name
,
562 ins
->scbs
[i
].next_scb_ptr
->address
,
563 ins
->scbs
[i
].task_entry
->symbol_name
,
564 ins
->scbs
[i
].task_entry
->address
);
567 snd_iprintf(buffer
,"\n");
568 up(&chip
->spos_mutex
);
571 static void cs46xx_dsp_proc_parameter_dump_read (snd_info_entry_t
*entry
, snd_info_buffer_t
* buffer
)
573 cs46xx_t
*chip
= entry
->private_data
;
574 /*dsp_spos_instance_t * ins = chip->dsp_spos_instance; */
575 unsigned int i
,col
= 0;
576 unsigned long dst
= chip
->region
.idx
[1].remap_addr
+ DSP_PARAMETER_BYTE_OFFSET
;
577 symbol_entry_t
* symbol
;
579 for (i
= 0;i
< DSP_PARAMETER_BYTE_SIZE
; i
+= sizeof(u32
),col
++) {
581 snd_iprintf(buffer
,"\n");
585 if ( (symbol
= cs46xx_dsp_lookup_symbol_addr (chip
,i
/ sizeof(u32
), SYMBOL_PARAMETER
)) != NULL
) {
587 snd_iprintf (buffer
,"\n%s:\n",symbol
->symbol_name
);
591 snd_iprintf(buffer
, "%04X ", i
/ (unsigned int)sizeof(u32
));
594 snd_iprintf(buffer
,"%08X ",readl(dst
+ i
));
598 static void cs46xx_dsp_proc_sample_dump_read (snd_info_entry_t
*entry
, snd_info_buffer_t
* buffer
)
600 cs46xx_t
*chip
= entry
->private_data
;
602 unsigned long dst
= chip
->region
.idx
[2].remap_addr
;
604 snd_iprintf(buffer
,"PCMREADER:\n");
605 for (i
= PCM_READER_BUF1
;i
< PCM_READER_BUF1
+ 0x30; i
+= sizeof(u32
),col
++) {
607 snd_iprintf(buffer
,"\n");
612 snd_iprintf(buffer
, "%04X ",i
);
615 snd_iprintf(buffer
,"%08X ",readl(dst
+ i
));
618 snd_iprintf(buffer
,"\nMIX_SAMPLE_BUF1:\n");
621 for (i
= MIX_SAMPLE_BUF1
;i
< MIX_SAMPLE_BUF1
+ 0x40; i
+= sizeof(u32
),col
++) {
623 snd_iprintf(buffer
,"\n");
628 snd_iprintf(buffer
, "%04X ",i
);
631 snd_iprintf(buffer
,"%08X ",readl(dst
+ i
));
634 snd_iprintf(buffer
,"\nSRC_TASK_SCB1:\n");
636 for (i
= 0x2480 ; i
< 0x2480 + 0x40 ; i
+= sizeof(u32
),col
++) {
638 snd_iprintf(buffer
,"\n");
643 snd_iprintf(buffer
, "%04X ",i
);
646 snd_iprintf(buffer
,"%08X ",readl(dst
+ i
));
650 snd_iprintf(buffer
,"\nSPDIFO_BUFFER:\n");
652 for (i
= SPDIFO_IP_OUTPUT_BUFFER1
;i
< SPDIFO_IP_OUTPUT_BUFFER1
+ 0x30; i
+= sizeof(u32
),col
++) {
654 snd_iprintf(buffer
,"\n");
659 snd_iprintf(buffer
, "%04X ",i
);
662 snd_iprintf(buffer
,"%08X ",readl(dst
+ i
));
665 snd_iprintf(buffer
,"\n...\n");
668 for (i
= SPDIFO_IP_OUTPUT_BUFFER1
+0xD0;i
< SPDIFO_IP_OUTPUT_BUFFER1
+ 0x110; i
+= sizeof(u32
),col
++) {
670 snd_iprintf(buffer
,"\n");
675 snd_iprintf(buffer
, "%04X ",i
);
678 snd_iprintf(buffer
,"%08X ",readl(dst
+ i
));
682 snd_iprintf(buffer
,"\nOUTPUT_SNOOP:\n");
684 for (i
= OUTPUT_SNOOP_BUFFER
;i
< OUTPUT_SNOOP_BUFFER
+ 0x40; i
+= sizeof(u32
),col
++) {
686 snd_iprintf(buffer
,"\n");
691 snd_iprintf(buffer
, "%04X ",i
);
694 snd_iprintf(buffer
,"%08X ",readl(dst
+ i
));
697 snd_iprintf(buffer
,"\nCODEC_INPUT_BUF1: \n");
699 for (i
= CODEC_INPUT_BUF1
;i
< CODEC_INPUT_BUF1
+ 0x40; i
+= sizeof(u32
),col
++) {
701 snd_iprintf(buffer
,"\n");
706 snd_iprintf(buffer
, "%04X ",i
);
709 snd_iprintf(buffer
,"%08X ",readl(dst
+ i
));
712 snd_iprintf(buffer
,"\nWRITE_BACK_BUF1: \n");
714 for (i
= WRITE_BACK_BUF1
;i
< WRITE_BACK_BUF1
+ 0x40; i
+= sizeof(u32
),col
++) {
716 snd_iprintf(buffer
,"\n");
721 snd_iprintf(buffer
, "%04X ",i
);
724 snd_iprintf(buffer
,"%08X ",readl(dst
+ i
));
728 snd_iprintf(buffer
,"\nSPDIFI_IP_OUTPUT_BUFFER1: \n");
730 for (i
= SPDIFI_IP_OUTPUT_BUFFER1
;i
< SPDIFI_IP_OUTPUT_BUFFER1
+ 0x80; i
+= sizeof(u32
),col
++) {
732 snd_iprintf(buffer
,"\n");
737 snd_iprintf(buffer
, "%04X ",i
);
740 snd_iprintf(buffer
,"%08X ",readl(dst
+ i
));
742 snd_iprintf(buffer
,"\n");
745 int cs46xx_dsp_proc_init (snd_card_t
* card
, cs46xx_t
*chip
)
747 snd_info_entry_t
*entry
;
748 dsp_spos_instance_t
* ins
= chip
->dsp_spos_instance
;
751 ins
->snd_card
= card
;
753 if ((entry
= snd_info_create_card_entry(card
, "dsp", card
->proc_root
)) != NULL
) {
754 entry
->content
= SNDRV_INFO_CONTENT_TEXT
;
755 entry
->mode
= S_IFDIR
| S_IRUGO
| S_IXUGO
;
756 entry
->c
.text
.read_size
= 512;
758 if (snd_info_register(entry
) < 0) {
759 snd_info_free_entry(entry
);
764 ins
->proc_dsp_dir
= entry
;
766 if (!ins
->proc_dsp_dir
)
769 if ((entry
= snd_info_create_card_entry(card
, "spos_symbols", ins
->proc_dsp_dir
)) != NULL
) {
770 entry
->content
= SNDRV_INFO_CONTENT_TEXT
;
771 entry
->private_data
= chip
;
772 entry
->mode
= S_IFREG
| S_IRUGO
| S_IWUSR
;
773 entry
->c
.text
.read_size
= 512;
774 entry
->c
.text
.read
= cs46xx_dsp_proc_symbol_table_read
;
775 if (snd_info_register(entry
) < 0) {
776 snd_info_free_entry(entry
);
780 ins
->proc_sym_info_entry
= entry
;
782 if ((entry
= snd_info_create_card_entry(card
, "spos_modules", ins
->proc_dsp_dir
)) != NULL
) {
783 entry
->content
= SNDRV_INFO_CONTENT_TEXT
;
784 entry
->private_data
= chip
;
785 entry
->mode
= S_IFREG
| S_IRUGO
| S_IWUSR
;
786 entry
->c
.text
.read_size
= 512;
787 entry
->c
.text
.read
= cs46xx_dsp_proc_modules_read
;
788 if (snd_info_register(entry
) < 0) {
789 snd_info_free_entry(entry
);
793 ins
->proc_modules_info_entry
= entry
;
795 if ((entry
= snd_info_create_card_entry(card
, "parameter", ins
->proc_dsp_dir
)) != NULL
) {
796 entry
->content
= SNDRV_INFO_CONTENT_TEXT
;
797 entry
->private_data
= chip
;
798 entry
->mode
= S_IFREG
| S_IRUGO
| S_IWUSR
;
799 entry
->c
.text
.read_size
= 512;
800 entry
->c
.text
.read
= cs46xx_dsp_proc_parameter_dump_read
;
801 if (snd_info_register(entry
) < 0) {
802 snd_info_free_entry(entry
);
806 ins
->proc_parameter_dump_info_entry
= entry
;
808 if ((entry
= snd_info_create_card_entry(card
, "sample", ins
->proc_dsp_dir
)) != NULL
) {
809 entry
->content
= SNDRV_INFO_CONTENT_TEXT
;
810 entry
->private_data
= chip
;
811 entry
->mode
= S_IFREG
| S_IRUGO
| S_IWUSR
;
812 entry
->c
.text
.read_size
= 512;
813 entry
->c
.text
.read
= cs46xx_dsp_proc_sample_dump_read
;
814 if (snd_info_register(entry
) < 0) {
815 snd_info_free_entry(entry
);
819 ins
->proc_sample_dump_info_entry
= entry
;
821 if ((entry
= snd_info_create_card_entry(card
, "task_tree", ins
->proc_dsp_dir
)) != NULL
) {
822 entry
->content
= SNDRV_INFO_CONTENT_TEXT
;
823 entry
->private_data
= chip
;
824 entry
->mode
= S_IFREG
| S_IRUGO
| S_IWUSR
;
825 entry
->c
.text
.read_size
= 512;
826 entry
->c
.text
.read
= cs46xx_dsp_proc_task_tree_read
;
827 if (snd_info_register(entry
) < 0) {
828 snd_info_free_entry(entry
);
832 ins
->proc_task_info_entry
= entry
;
834 if ((entry
= snd_info_create_card_entry(card
, "scb_info", ins
->proc_dsp_dir
)) != NULL
) {
835 entry
->content
= SNDRV_INFO_CONTENT_TEXT
;
836 entry
->private_data
= chip
;
837 entry
->mode
= S_IFREG
| S_IRUGO
| S_IWUSR
;
838 entry
->c
.text
.read_size
= 1024;
839 entry
->c
.text
.read
= cs46xx_dsp_proc_scb_read
;
840 if (snd_info_register(entry
) < 0) {
841 snd_info_free_entry(entry
);
845 ins
->proc_scb_info_entry
= entry
;
847 down(&chip
->spos_mutex
);
848 /* register/update SCB's entries on proc */
849 for (i
= 0; i
< ins
->nscb
; ++i
) {
850 if (ins
->scbs
[i
].deleted
) continue;
852 cs46xx_dsp_proc_register_scb_desc (chip
, (ins
->scbs
+ i
));
854 up(&chip
->spos_mutex
);
859 int cs46xx_dsp_proc_done (cs46xx_t
*chip
)
861 dsp_spos_instance_t
* ins
= chip
->dsp_spos_instance
;
864 if (ins
->proc_sym_info_entry
) {
865 snd_info_unregister(ins
->proc_sym_info_entry
);
866 ins
->proc_sym_info_entry
= NULL
;
869 if (ins
->proc_modules_info_entry
) {
870 snd_info_unregister(ins
->proc_modules_info_entry
);
871 ins
->proc_modules_info_entry
= NULL
;
874 if (ins
->proc_parameter_dump_info_entry
) {
875 snd_info_unregister(ins
->proc_parameter_dump_info_entry
);
876 ins
->proc_parameter_dump_info_entry
= NULL
;
879 if (ins
->proc_sample_dump_info_entry
) {
880 snd_info_unregister(ins
->proc_sample_dump_info_entry
);
881 ins
->proc_sample_dump_info_entry
= NULL
;
884 if (ins
->proc_scb_info_entry
) {
885 snd_info_unregister(ins
->proc_scb_info_entry
);
886 ins
->proc_scb_info_entry
= NULL
;
889 if (ins
->proc_task_info_entry
) {
890 snd_info_unregister(ins
->proc_task_info_entry
);
891 ins
->proc_task_info_entry
= NULL
;
894 down(&chip
->spos_mutex
);
895 for (i
= 0; i
< ins
->nscb
; ++i
) {
896 if (ins
->scbs
[i
].deleted
) continue;
897 cs46xx_dsp_proc_free_scb_desc ( (ins
->scbs
+ i
) );
899 up(&chip
->spos_mutex
);
901 if (ins
->proc_dsp_dir
) {
902 snd_info_unregister (ins
->proc_dsp_dir
);
903 ins
->proc_dsp_dir
= NULL
;
909 static int debug_tree
;
910 static void _dsp_create_task_tree (cs46xx_t
*chip
,u32
* task_data
, u32 dest
, int size
)
912 unsigned long spdst
= chip
->region
.idx
[1].remap_addr
+
913 DSP_PARAMETER_BYTE_OFFSET
+ dest
* sizeof(u32
);
916 for (i
= 0; i
< size
; ++i
) {
917 if (debug_tree
) printk ("addr %08x, val %08x\n",(int)spdst
,task_data
[i
]);
918 writel(task_data
[i
],spdst
);
919 spdst
+= sizeof(u32
);
923 static int debug_scb
;
924 static void _dsp_create_scb (cs46xx_t
*chip
,u32
* scb_data
, u32 dest
)
926 unsigned long spdst
= chip
->region
.idx
[1].remap_addr
+
927 DSP_PARAMETER_BYTE_OFFSET
+ dest
* sizeof(u32
);
930 for (i
= 0; i
< 0x10; ++i
) {
931 if (debug_scb
) printk ("addr %08x, val %08x\n",(int)spdst
,scb_data
[i
]);
932 writel(scb_data
[i
],spdst
);
933 spdst
+= sizeof(u32
);
937 static int find_free_scb_index (dsp_spos_instance_t
* ins
)
939 int index
= ins
->nscb
, i
;
941 for (i
= ins
->scb_highest_frag_index
; i
< ins
->nscb
; ++i
) {
942 if (ins
->scbs
[i
].deleted
) {
951 static dsp_scb_descriptor_t
* _map_scb (cs46xx_t
*chip
,char * name
,u32 dest
)
953 dsp_spos_instance_t
* ins
= chip
->dsp_spos_instance
;
954 dsp_scb_descriptor_t
* desc
= NULL
;
957 if (ins
->nscb
== DSP_MAX_SCB_DESC
- 1) {
958 snd_printk(KERN_ERR
"dsp_spos: got no place for other SCB\n");
962 index
= find_free_scb_index (ins
);
964 strcpy(ins
->scbs
[index
].scb_name
, name
);
965 ins
->scbs
[index
].address
= dest
;
966 ins
->scbs
[index
].index
= index
;
967 ins
->scbs
[index
].proc_info
= NULL
;
968 ins
->scbs
[index
].ref_count
= 1;
969 ins
->scbs
[index
].deleted
= 0;
970 spin_lock_init(&ins
->scbs
[index
].lock
);
972 desc
= (ins
->scbs
+ index
);
973 ins
->scbs
[index
].scb_symbol
= add_symbol (chip
, name
, dest
, SYMBOL_PARAMETER
);
975 if (index
> ins
->scb_highest_frag_index
)
976 ins
->scb_highest_frag_index
= index
;
978 if (index
== ins
->nscb
)
984 static dsp_task_descriptor_t
* _map_task_tree (cs46xx_t
*chip
,char * name
,u32 dest
,u32 size
)
986 dsp_spos_instance_t
* ins
= chip
->dsp_spos_instance
;
987 dsp_task_descriptor_t
* desc
= NULL
;
989 if (ins
->ntask
== DSP_MAX_TASK_DESC
- 1) {
990 snd_printk(KERN_ERR
"dsp_spos: got no place for other TASK\n");
994 strcpy(ins
->tasks
[ins
->ntask
].task_name
,name
);
995 ins
->tasks
[ins
->ntask
].address
= dest
;
996 ins
->tasks
[ins
->ntask
].size
= size
;
998 /* quick find in list */
999 ins
->tasks
[ins
->ntask
].index
= ins
->ntask
;
1000 desc
= (ins
->tasks
+ ins
->ntask
);
1003 add_symbol (chip
,name
,dest
,SYMBOL_PARAMETER
);
1007 dsp_scb_descriptor_t
* cs46xx_dsp_create_scb (cs46xx_t
*chip
,char * name
, u32
* scb_data
,u32 dest
)
1009 dsp_scb_descriptor_t
* desc
;
1011 desc
= _map_scb (chip
,name
,dest
);
1013 _dsp_create_scb(chip
,scb_data
,dest
);
1015 snd_printk(KERN_ERR
"dsp_spos: failed to map SCB\n");
1022 dsp_task_descriptor_t
* cs46xx_dsp_create_task_tree (cs46xx_t
*chip
,char * name
, u32
* task_data
,u32 dest
,int size
)
1024 dsp_task_descriptor_t
* desc
;
1026 desc
= _map_task_tree (chip
,name
,dest
,size
);
1028 _dsp_create_task_tree(chip
,task_data
,dest
,size
);
1030 snd_printk(KERN_ERR
"dsp_spos: failed to map TASK\n");
1036 int cs46xx_dsp_scb_and_task_init (cs46xx_t
*chip
)
1038 dsp_spos_instance_t
* ins
= chip
->dsp_spos_instance
;
1039 symbol_entry_t
* fg_task_tree_header_code
;
1040 symbol_entry_t
* task_tree_header_code
;
1041 symbol_entry_t
* task_tree_thread
;
1042 symbol_entry_t
* null_algorithm
;
1043 symbol_entry_t
* magic_snoop_task
;
1045 dsp_scb_descriptor_t
* timing_master_scb
;
1046 dsp_scb_descriptor_t
* codec_out_scb
;
1047 dsp_scb_descriptor_t
* codec_in_scb
;
1048 dsp_scb_descriptor_t
* src_task_scb
;
1049 dsp_scb_descriptor_t
* master_mix_scb
;
1050 dsp_scb_descriptor_t
* rear_mix_scb
;
1051 dsp_scb_descriptor_t
* record_mix_scb
;
1052 dsp_scb_descriptor_t
* write_back_scb
;
1053 dsp_scb_descriptor_t
* vari_decimate_scb
;
1054 dsp_scb_descriptor_t
* rear_codec_out_scb
;
1055 dsp_scb_descriptor_t
* clfe_codec_out_scb
;
1056 dsp_scb_descriptor_t
* magic_snoop_scb
;
1058 int fifo_addr
,fifo_span
,valid_slots
;
1060 static spos_control_block_t sposcb
= {
1061 /* 0 */ HFG_TREE_SCB
,HFG_STACK
,
1062 /* 1 */ SPOSCB_ADDR
,BG_TREE_SCB_ADDR
,
1063 /* 2 */ DSP_SPOS_DC
,0,
1064 /* 3 */ DSP_SPOS_DC
,DSP_SPOS_DC
,
1066 /* 5 */ DSP_SPOS_UU
,0,
1067 /* 6 */ FG_TASK_HEADER_ADDR
,0,
1069 /* 8 */ DSP_SPOS_UU
,DSP_SPOS_DC
,
1071 /* A */ 0,HFG_FIRST_EXECUTE_MODE
,
1072 /* B */ DSP_SPOS_UU
,DSP_SPOS_UU
,
1073 /* C */ DSP_SPOS_DC_DC
,
1074 /* D */ DSP_SPOS_DC_DC
,
1075 /* E */ DSP_SPOS_DC_DC
,
1076 /* F */ DSP_SPOS_DC_DC
1079 cs46xx_dsp_create_task_tree(chip
, "sposCB", (u32
*)&sposcb
, SPOSCB_ADDR
, 0x10);
1081 null_algorithm
= cs46xx_dsp_lookup_symbol(chip
, "NULLALGORITHM", SYMBOL_CODE
);
1082 if (null_algorithm
== NULL
) {
1083 snd_printk(KERN_ERR
"dsp_spos: symbol NULLALGORITHM not found\n");
1087 fg_task_tree_header_code
= cs46xx_dsp_lookup_symbol(chip
, "FGTASKTREEHEADERCODE", SYMBOL_CODE
);
1088 if (fg_task_tree_header_code
== NULL
) {
1089 snd_printk(KERN_ERR
"dsp_spos: symbol FGTASKTREEHEADERCODE not found\n");
1093 task_tree_header_code
= cs46xx_dsp_lookup_symbol(chip
, "TASKTREEHEADERCODE", SYMBOL_CODE
);
1094 if (task_tree_header_code
== NULL
) {
1095 snd_printk(KERN_ERR
"dsp_spos: symbol TASKTREEHEADERCODE not found\n");
1099 task_tree_thread
= cs46xx_dsp_lookup_symbol(chip
, "TASKTREETHREAD", SYMBOL_CODE
);
1100 if (task_tree_thread
== NULL
) {
1101 snd_printk(KERN_ERR
"dsp_spos: symbol TASKTREETHREAD not found\n");
1105 magic_snoop_task
= cs46xx_dsp_lookup_symbol(chip
, "MAGICSNOOPTASK", SYMBOL_CODE
);
1106 if (magic_snoop_task
== NULL
) {
1107 snd_printk(KERN_ERR
"dsp_spos: symbol MAGICSNOOPTASK not found\n");
1112 /* create the null SCB */
1113 static generic_scb_t null_scb
= {
1116 NULL_SCB_ADDR
, NULL_SCB_ADDR
,
1124 null_scb
.entry_point
= null_algorithm
->address
;
1125 ins
->the_null_scb
= cs46xx_dsp_create_scb(chip
, "nullSCB", (u32
*)&null_scb
, NULL_SCB_ADDR
);
1126 ins
->the_null_scb
->task_entry
= null_algorithm
;
1127 ins
->the_null_scb
->sub_list_ptr
= ins
->the_null_scb
;
1128 ins
->the_null_scb
->next_scb_ptr
= ins
->the_null_scb
;
1129 ins
->the_null_scb
->parent_scb_ptr
= NULL
;
1130 cs46xx_dsp_proc_register_scb_desc (chip
,ins
->the_null_scb
);
1134 /* setup foreground task tree */
1135 static task_tree_control_block_t fg_task_tree_hdr
= {
1136 { FG_TASK_HEADER_ADDR
| (DSP_SPOS_DC
<< 0x10),
1140 DSP_SPOS_DC
, DSP_SPOS_DC
,
1144 DSP_SPOS_DC
,DSP_SPOS_DC
},
1147 BG_TREE_SCB_ADDR
,TIMINGMASTER_SCB_ADDR
,
1149 FG_TASK_HEADER_ADDR
+ TCBData
,
1155 2,SPOSCB_ADDR
+ HFGFlags
,
1157 FG_TASK_HEADER_ADDR
+ TCBContextBlk
,FG_STACK
1162 DSP_SPOS_DC
,DSP_SPOS_DC
,
1163 DSP_SPOS_DC
,DSP_SPOS_DC
,
1164 DSP_SPOS_DC
,DSP_SPOS_DC
,
1165 DSP_SPOS_DC
,DSP_SPOS_DC
,
1198 FG_INTERVAL_TIMER_PERIOD
,DSP_SPOS_UU
,
1203 fg_task_tree_hdr
.links
.entry_point
= fg_task_tree_header_code
->address
;
1204 fg_task_tree_hdr
.context_blk
.stack0
= task_tree_thread
->address
;
1205 cs46xx_dsp_create_task_tree(chip
,"FGtaskTreeHdr",(u32
*)&fg_task_tree_hdr
,FG_TASK_HEADER_ADDR
,0x35);
1210 /* setup foreground task tree */
1211 static task_tree_control_block_t bg_task_tree_hdr
= {
1215 DSP_SPOS_DC
, DSP_SPOS_DC
,
1216 DSP_SPOS_DC
, DSP_SPOS_DC
,
1220 DSP_SPOS_DC
,DSP_SPOS_DC
},
1223 NULL_SCB_ADDR
,NULL_SCB_ADDR
, /* Set up the background to do nothing */
1225 BG_TREE_SCB_ADDR
+ TCBData
,
1231 0,SPOSCB_ADDR
+ HFGFlags
,
1233 BG_TREE_SCB_ADDR
+ TCBContextBlk
,BG_STACK
1238 DSP_SPOS_DC
,DSP_SPOS_DC
,
1239 DSP_SPOS_DC
,DSP_SPOS_DC
,
1240 DSP_SPOS_DC
,DSP_SPOS_DC
,
1241 DSP_SPOS_DC
,DSP_SPOS_DC
,
1274 BG_INTERVAL_TIMER_PERIOD
,DSP_SPOS_UU
,
1279 bg_task_tree_hdr
.links
.entry_point
= task_tree_header_code
->address
;
1280 bg_task_tree_hdr
.context_blk
.stack0
= task_tree_thread
->address
;
1281 cs46xx_dsp_create_task_tree(chip
,"BGtaskTreeHdr",(u32
*)&bg_task_tree_hdr
,BG_TREE_SCB_ADDR
,0x35);
1284 /* create timing master SCB */
1285 timing_master_scb
= cs46xx_dsp_create_timing_master_scb(chip
);
1287 /* create the CODEC output task */
1288 codec_out_scb
= cs46xx_dsp_create_codec_out_scb(chip
,"CodecOutSCB_I",0x0010,0x0000,
1290 CODECOUT_SCB_ADDR
,timing_master_scb
,
1291 SCB_ON_PARENT_SUBLIST_SCB
);
1293 if (!codec_out_scb
) goto _fail_end
;
1294 /* create the master mix SCB */
1295 master_mix_scb
= cs46xx_dsp_create_mix_only_scb(chip
,"MasterMixSCB",
1296 MIX_SAMPLE_BUF1
,MASTERMIX_SCB_ADDR
,
1298 SCB_ON_PARENT_SUBLIST_SCB
);
1299 ins
->master_mix_scb
= master_mix_scb
;
1301 if (!master_mix_scb
) goto _fail_end
;
1303 /* create codec in */
1304 codec_in_scb
= cs46xx_dsp_create_codec_in_scb(chip
,"CodecInSCB",0x0010,0x00A0,
1306 CODECIN_SCB_ADDR
,codec_out_scb
,
1307 SCB_ON_PARENT_NEXT_SCB
);
1308 if (!codec_in_scb
) goto _fail_end
;
1309 ins
->codec_in_scb
= codec_in_scb
;
1311 /* create write back scb */
1312 write_back_scb
= cs46xx_dsp_create_mix_to_ostream_scb(chip
,"WriteBackSCB",
1313 WRITE_BACK_BUF1
,WRITE_BACK_SPB
,
1316 SCB_ON_PARENT_NEXT_SCB
);
1317 if (!write_back_scb
) goto _fail_end
;
1320 static mix2_ostream_spb_t mix2_ostream_spb
= {
1325 /* dirty hack ... */
1326 _dsp_create_task_tree (chip
,(u32
*)&mix2_ostream_spb
,WRITE_BACK_SPB
,2);
1329 /* input sample converter */
1330 vari_decimate_scb
= cs46xx_dsp_create_vari_decimate_scb(chip
,"VariDecimateSCB",
1333 VARIDECIMATE_SCB_ADDR
,
1335 SCB_ON_PARENT_SUBLIST_SCB
);
1336 if (!vari_decimate_scb
) goto _fail_end
;
1338 /* create the record mixer SCB */
1339 record_mix_scb
= cs46xx_dsp_create_mix_only_scb(chip
,"RecordMixerSCB",
1341 RECORD_MIXER_SCB_ADDR
,
1343 SCB_ON_PARENT_SUBLIST_SCB
);
1344 ins
->record_mixer_scb
= record_mix_scb
;
1346 if (!record_mix_scb
) goto _fail_end
;
1348 valid_slots
= snd_cs46xx_peekBA0(chip
, BA0_ACOSV
);
1350 snd_assert (chip
->nr_ac97_codecs
== 1 || chip
->nr_ac97_codecs
== 2);
1352 if (chip
->nr_ac97_codecs
== 1) {
1353 /* output on slot 5 and 11
1358 /* enable slot 5 and 11 */
1359 valid_slots
|= ACOSV_SLV5
| ACOSV_SLV11
;
1361 /* output on slot 7 and 8
1362 on secondary CODEC */
1366 /* enable slot 7 and 8 */
1367 valid_slots
|= ACOSV_SLV7
| ACOSV_SLV8
;
1369 /* create CODEC tasklet for rear speakers output*/
1370 rear_codec_out_scb
= cs46xx_dsp_create_codec_out_scb(chip
,"CodecOutSCB_Rear",fifo_span
,fifo_addr
,
1371 REAR_MIXER_SCB_ADDR
,
1372 REAR_CODECOUT_SCB_ADDR
,codec_in_scb
,
1373 SCB_ON_PARENT_NEXT_SCB
);
1374 if (!rear_codec_out_scb
) goto _fail_end
;
1377 /* create the rear PCM channel mixer SCB */
1378 rear_mix_scb
= cs46xx_dsp_create_mix_only_scb(chip
,"RearMixerSCB",
1380 REAR_MIXER_SCB_ADDR
,
1382 SCB_ON_PARENT_SUBLIST_SCB
);
1383 ins
->rear_mix_scb
= rear_mix_scb
;
1384 if (!rear_mix_scb
) goto _fail_end
;
1386 if (chip
->nr_ac97_codecs
== 2) {
1387 /* create CODEC tasklet for rear Center/LFE output
1388 slot 6 and 9 on seconadry CODEC */
1389 clfe_codec_out_scb
= cs46xx_dsp_create_codec_out_scb(chip
,"CodecOutSCB_CLFE",0x0030,0x0030,
1390 CLFE_MIXER_SCB_ADDR
,
1391 CLFE_CODEC_SCB_ADDR
,
1393 SCB_ON_PARENT_NEXT_SCB
);
1394 if (!clfe_codec_out_scb
) goto _fail_end
;
1397 /* create the rear PCM channel mixer SCB */
1398 ins
->center_lfe_mix_scb
= cs46xx_dsp_create_mix_only_scb(chip
,"CLFEMixerSCB",
1400 CLFE_MIXER_SCB_ADDR
,
1402 SCB_ON_PARENT_SUBLIST_SCB
);
1403 if (!ins
->center_lfe_mix_scb
) goto _fail_end
;
1405 /* enable slot 6 and 9 */
1406 valid_slots
|= ACOSV_SLV6
| ACOSV_SLV9
;
1408 clfe_codec_out_scb
= rear_codec_out_scb
;
1409 ins
->center_lfe_mix_scb
= rear_mix_scb
;
1412 /* enable slots depending on CODEC configuration */
1413 snd_cs46xx_pokeBA0(chip
, BA0_ACOSV
, valid_slots
);
1415 /* the magic snooper */
1416 magic_snoop_scb
= cs46xx_dsp_create_magic_snoop_scb (chip
,"MagicSnoopSCB_I",OUTPUTSNOOP_SCB_ADDR
,
1417 OUTPUT_SNOOP_BUFFER
,
1420 SCB_ON_PARENT_NEXT_SCB
);
1423 if (!magic_snoop_scb
) goto _fail_end
;
1424 ins
->ref_snoop_scb
= magic_snoop_scb
;
1427 if (!cs46xx_dsp_create_spio_write_scb(chip
,"SPIOWriteSCB",SPIOWRITE_SCB_ADDR
,
1429 SCB_ON_PARENT_NEXT_SCB
))
1432 /* SPDIF input sampel rate converter */
1433 src_task_scb
= cs46xx_dsp_create_src_task_scb(chip
,"SrcTaskSCB_SPDIFI",
1434 ins
->spdif_in_sample_rate
,
1436 SRC_DELAY_BUF1
,SRCTASK_SCB_ADDR
,
1438 SCB_ON_PARENT_SUBLIST_SCB
,1);
1440 if (!src_task_scb
) goto _fail_end
;
1441 cs46xx_src_unlink(chip
,src_task_scb
);
1443 /* NOTE: when we now how to detect the SPDIF input
1444 sample rate we will use this SRC to adjust it */
1445 ins
->spdif_in_src
= src_task_scb
;
1447 cs46xx_dsp_async_init(chip
,timing_master_scb
);
1451 snd_printk(KERN_ERR
"dsp_spos: failed to setup SCB's in DSP\n");
1455 int cs46xx_dsp_async_init (cs46xx_t
*chip
, dsp_scb_descriptor_t
* fg_entry
)
1457 dsp_spos_instance_t
* ins
= chip
->dsp_spos_instance
;
1458 symbol_entry_t
* s16_async_codec_input_task
;
1459 symbol_entry_t
* spdifo_task
;
1460 symbol_entry_t
* spdifi_task
;
1461 dsp_scb_descriptor_t
* spdifi_scb_desc
,* spdifo_scb_desc
,* async_codec_scb_desc
;
1463 s16_async_codec_input_task
= cs46xx_dsp_lookup_symbol(chip
, "S16_ASYNCCODECINPUTTASK", SYMBOL_CODE
);
1464 if (s16_async_codec_input_task
== NULL
) {
1465 snd_printk(KERN_ERR
"dsp_spos: symbol S16_ASYNCCODECINPUTTASK not found\n");
1468 spdifo_task
= cs46xx_dsp_lookup_symbol(chip
, "SPDIFOTASK", SYMBOL_CODE
);
1469 if (spdifo_task
== NULL
) {
1470 snd_printk(KERN_ERR
"dsp_spos: symbol SPDIFOTASK not found\n");
1474 spdifi_task
= cs46xx_dsp_lookup_symbol(chip
, "SPDIFITASK", SYMBOL_CODE
);
1475 if (spdifi_task
== NULL
) {
1476 snd_printk(KERN_ERR
"dsp_spos: symbol SPDIFITASK not found\n");
1482 spdifoscb_t spdifo_scb
= {
1483 /* 0 */ DSP_SPOS_UUUU
,
1490 /* NOTE: the SPDIF output task read samples in mono
1491 format, the AsynchFGTxSCB task writes to buffer
1494 /* 5 */ RSCONFIG_SAMPLE_16MONO
+ RSCONFIG_MODULO_256
,
1495 /* 6 */ ( SPDIFO_IP_OUTPUT_BUFFER1
<< 0x10 ) | 0xFFFC,
1498 /* 9 */ FG_TASK_HEADER_ADDR
, NULL_SCB_ADDR
,
1499 /* A */ spdifo_task
->address
,
1500 SPDIFO_SCB_INST
+ SPDIFOFIFOPointer
,
1502 /* B */ 0x0040, /*DSP_SPOS_UUUU,*/
1503 /* C */ 0x20ff, /*DSP_SPOS_UUUU,*/
1505 /* D */ 0x804c,0, /* SPDIFOFIFOPointer:SPDIFOStatRegAddr; */
1506 /* E */ 0x0108,0x0001, /* SPDIFOStMoFormat:SPDIFOFIFOBaseAddr; */
1507 /* F */ DSP_SPOS_UUUU
/* SPDIFOFree; */
1511 spdifiscb_t spdifi_scb
= {
1512 /* 0 */ DSP_SPOS_UULO
,DSP_SPOS_UUHI
,
1515 /* 3 */ 1,4000, /* SPDIFICountLimit SPDIFICount */
1516 /* 4 */ DSP_SPOS_UUUU
, /* SPDIFIStatusData */
1517 /* 5 */ 0,DSP_SPOS_UUHI
, /* StatusData, Free4 */
1518 /* 6 */ DSP_SPOS_UUUU
, /* Free3 */
1519 /* 7 */ DSP_SPOS_UU
,DSP_SPOS_DC
, /* Free2 BitCount*/
1520 /* 8 */ DSP_SPOS_UUUU
, /* TempStatus */
1521 /* 9 */ SPDIFO_SCB_INST
, NULL_SCB_ADDR
,
1522 /* A */ spdifi_task
->address
,
1523 SPDIFI_SCB_INST
+ SPDIFIFIFOPointer
,
1524 /* NOTE: The SPDIF input task write the sample in mono
1525 format from the HW FIFO, the AsynchFGRxSCB task reads
1528 /* B */ RSCONFIG_SAMPLE_16MONO
+ RSCONFIG_MODULO_128
,
1529 /* C */ (SPDIFI_IP_OUTPUT_BUFFER1
<< 0x10) | 0xFFFC,
1531 /* E */ 0x01f0,0x0001,
1532 /* F */ DSP_SPOS_UUUU
/* SPDIN_STATUS monitor */
1536 async_codec_input_scb_t async_codec_input_scb
= {
1537 /* 0 */ DSP_SPOS_UUUU
,
1541 /* 4 */ 0x0118,0x0001,
1542 /* 5 */ RSCONFIG_SAMPLE_16MONO
+ RSCONFIG_MODULO_64
,
1543 /* 6 */ (ASYNC_IP_OUTPUT_BUFFER1
<< 0x10) | 0xFFFC,
1544 /* 7 */ DSP_SPOS_UU
,0x3,
1545 /* 8 */ DSP_SPOS_UUUU
,
1546 /* 9 */ SPDIFI_SCB_INST
,NULL_SCB_ADDR
,
1547 /* A */ s16_async_codec_input_task
->address
,
1548 HFG_TREE_SCB
+ AsyncCIOFIFOPointer
,
1550 /* B */ RSCONFIG_SAMPLE_16STEREO
+ RSCONFIG_MODULO_64
,
1551 /* C */ (ASYNC_IP_OUTPUT_BUFFER1
<< 0x10), /*(ASYNC_IP_OUTPUT_BUFFER1 << 0x10) | 0xFFFC,*/
1553 #ifdef UseASER1Input
1554 /* short AsyncCIFIFOPointer:AsyncCIStatRegAddr;
1555 Init. 0000:8042: for ASER1
1556 0000:8044: for ASER2 */
1559 /* short AsyncCIStMoFormat:AsyncCIFIFOBaseAddr;
1560 Init 1 stero:8050 ASER1
1561 Init 0 mono:8070 ASER2
1562 Init 1 Stereo : 0100 ASER1 (Set by script) */
1563 /* E */ 0x0100,0x0001,
1567 #ifdef UseASER2Input
1568 /* short AsyncCIFIFOPointer:AsyncCIStatRegAddr;
1569 Init. 0000:8042: for ASER1
1570 0000:8044: for ASER2 */
1573 /* short AsyncCIStMoFormat:AsyncCIFIFOBaseAddr;
1574 Init 1 stero:8050 ASER1
1575 Init 0 mono:8070 ASER2
1576 Init 1 Stereo : 0100 ASER1 (Set by script) */
1577 /* E */ 0x0110,0x0001,
1581 /* short AsyncCIOutputBufModulo:AsyncCIFree;
1582 AsyncCIOutputBufModulo: The modulo size for
1583 the output buffer of this task */
1584 /* F */ 0, /* DSP_SPOS_UUUU */
1587 spdifo_scb_desc
= cs46xx_dsp_create_scb(chip
,"SPDIFOSCB",(u32
*)&spdifo_scb
,SPDIFO_SCB_INST
);
1589 snd_assert(spdifo_scb_desc
, return -EIO
);
1590 spdifi_scb_desc
= cs46xx_dsp_create_scb(chip
,"SPDIFISCB",(u32
*)&spdifi_scb
,SPDIFI_SCB_INST
);
1591 snd_assert(spdifi_scb_desc
, return -EIO
);
1592 async_codec_scb_desc
= cs46xx_dsp_create_scb(chip
,"AsynCodecInputSCB",(u32
*)&async_codec_input_scb
, HFG_TREE_SCB
);
1593 snd_assert(async_codec_scb_desc
, return -EIO
);
1595 async_codec_scb_desc
->parent_scb_ptr
= NULL
;
1596 async_codec_scb_desc
->next_scb_ptr
= spdifi_scb_desc
;
1597 async_codec_scb_desc
->sub_list_ptr
= ins
->the_null_scb
;
1598 async_codec_scb_desc
->task_entry
= s16_async_codec_input_task
;
1600 spdifi_scb_desc
->parent_scb_ptr
= async_codec_scb_desc
;
1601 spdifi_scb_desc
->next_scb_ptr
= spdifo_scb_desc
;
1602 spdifi_scb_desc
->sub_list_ptr
= ins
->the_null_scb
;
1603 spdifi_scb_desc
->task_entry
= spdifi_task
;
1605 spdifo_scb_desc
->parent_scb_ptr
= spdifi_scb_desc
;
1606 spdifo_scb_desc
->next_scb_ptr
= fg_entry
;
1607 spdifo_scb_desc
->sub_list_ptr
= ins
->the_null_scb
;
1608 spdifo_scb_desc
->task_entry
= spdifo_task
;
1610 /* this one is faked, as the parnet of SPDIFO task
1611 is the FG task tree */
1612 fg_entry
->parent_scb_ptr
= spdifo_scb_desc
;
1615 cs46xx_dsp_proc_register_scb_desc (chip
,spdifo_scb_desc
);
1616 cs46xx_dsp_proc_register_scb_desc (chip
,spdifi_scb_desc
);
1617 cs46xx_dsp_proc_register_scb_desc (chip
,async_codec_scb_desc
);
1619 /* Async MASTER ENABLE, affects both SPDIF input and output */
1620 snd_cs46xx_pokeBA0(chip
, BA0_ASER_MASTER
, 0x1 );
1627 static void cs46xx_dsp_disable_spdif_hw (cs46xx_t
*chip
)
1629 dsp_spos_instance_t
* ins
= chip
->dsp_spos_instance
;
1631 /* set SPDIF output FIFO slot */
1632 snd_cs46xx_pokeBA0(chip
, BA0_ASER_FADDR
, 0);
1634 /* SPDIF output MASTER ENABLE */
1635 cs46xx_poke_via_dsp (chip
,SP_SPDOUT_CONTROL
, 0);
1637 /* right and left validate bit */
1638 /*cs46xx_poke_via_dsp (chip,SP_SPDOUT_CSUV, ins->spdif_csuv_default);*/
1639 cs46xx_poke_via_dsp (chip
,SP_SPDOUT_CSUV
, 0x0);
1641 /* clear fifo pointer */
1642 cs46xx_poke_via_dsp (chip
,SP_SPDIN_FIFOPTR
, 0x0);
1645 ins
->spdif_status_out
&= ~DSP_SPDIF_STATUS_HW_ENABLED
;
1648 int cs46xx_dsp_enable_spdif_hw (cs46xx_t
*chip
)
1650 dsp_spos_instance_t
* ins
= chip
->dsp_spos_instance
;
1652 /* if hw-ctrl already enabled, turn off to reset logic ... */
1653 cs46xx_dsp_disable_spdif_hw (chip
);
1656 /* set SPDIF output FIFO slot */
1657 snd_cs46xx_pokeBA0(chip
, BA0_ASER_FADDR
, ( 0x8000 | ((SP_SPDOUT_FIFO
>> 4) << 4) ));
1659 /* SPDIF output MASTER ENABLE */
1660 cs46xx_poke_via_dsp (chip
,SP_SPDOUT_CONTROL
, 0x80000000);
1662 /* right and left validate bit */
1663 cs46xx_poke_via_dsp (chip
,SP_SPDOUT_CSUV
, ins
->spdif_csuv_default
);
1666 ins
->spdif_status_out
|= DSP_SPDIF_STATUS_HW_ENABLED
;
1671 int cs46xx_dsp_enable_spdif_in (cs46xx_t
*chip
)
1673 dsp_spos_instance_t
* ins
= chip
->dsp_spos_instance
;
1675 /* turn on amplifier */
1676 chip
->active_ctrl(chip
, 1);
1677 chip
->amplifier_ctrl(chip
, 1);
1679 snd_assert (ins
->asynch_rx_scb
== NULL
,return -EINVAL
);
1680 snd_assert (ins
->spdif_in_src
!= NULL
,return -EINVAL
);
1682 down(&chip
->spos_mutex
);
1684 if ( ! (ins
->spdif_status_out
& DSP_SPDIF_STATUS_INPUT_CTRL_ENABLED
) ) {
1685 /* time countdown enable */
1686 cs46xx_poke_via_dsp (chip
,SP_ASER_COUNTDOWN
, 0x80000005);
1687 /* NOTE: 80000005 value is just magic. With all values
1688 that I've tested this one seem to give the best result.
1689 Got no explication why. (Benny) */
1691 /* SPDIF input MASTER ENABLE */
1692 cs46xx_poke_via_dsp (chip
,SP_SPDIN_CONTROL
, 0x800003ff);
1694 ins
->spdif_status_out
|= DSP_SPDIF_STATUS_INPUT_CTRL_ENABLED
;
1697 /* create and start the asynchronous receiver SCB */
1698 ins
->asynch_rx_scb
= cs46xx_dsp_create_asynch_fg_rx_scb(chip
,"AsynchFGRxSCB",
1701 SPDIFI_IP_OUTPUT_BUFFER1
,
1703 SCB_ON_PARENT_SUBLIST_SCB
);
1705 spin_lock_irq(&chip
->reg_lock
);
1707 /* reset SPDIF input sample buffer pointer */
1708 /*snd_cs46xx_poke (chip, (SPDIFI_SCB_INST + 0x0c) << 2,
1709 (SPDIFI_IP_OUTPUT_BUFFER1 << 0x10) | 0xFFFC);*/
1711 /* reset FIFO ptr */
1712 /*cs46xx_poke_via_dsp (chip,SP_SPDIN_FIFOPTR, 0x0);*/
1713 cs46xx_src_link(chip
,ins
->spdif_in_src
);
1715 /* unmute SRC volume */
1716 cs46xx_dsp_scb_set_volume (chip
,ins
->spdif_in_src
,0x7fff,0x7fff);
1718 spin_unlock_irq(&chip
->reg_lock
);
1720 /* set SPDIF input sample rate and unmute
1721 NOTE: only 48khz support for SPDIF input this time */
1722 /* cs46xx_dsp_set_src_sample_rate(chip,ins->spdif_in_src,48000); */
1725 ins
->spdif_status_in
= 1;
1726 up(&chip
->spos_mutex
);
1731 int cs46xx_dsp_disable_spdif_in (cs46xx_t
*chip
)
1733 dsp_spos_instance_t
* ins
= chip
->dsp_spos_instance
;
1735 snd_assert (ins
->asynch_rx_scb
!= NULL
, return -EINVAL
);
1736 snd_assert (ins
->spdif_in_src
!= NULL
,return -EINVAL
);
1738 down(&chip
->spos_mutex
);
1740 /* Remove the asynchronous receiver SCB */
1741 cs46xx_dsp_remove_scb (chip
,ins
->asynch_rx_scb
);
1742 ins
->asynch_rx_scb
= NULL
;
1744 cs46xx_src_unlink(chip
,ins
->spdif_in_src
);
1747 ins
->spdif_status_in
= 0;
1748 up(&chip
->spos_mutex
);
1750 /* restore amplifier */
1751 chip
->active_ctrl(chip
, -1);
1752 chip
->amplifier_ctrl(chip
, -1);
1757 int cs46xx_dsp_enable_pcm_capture (cs46xx_t
*chip
)
1759 dsp_spos_instance_t
* ins
= chip
->dsp_spos_instance
;
1761 snd_assert (ins
->pcm_input
== NULL
,return -EINVAL
);
1762 snd_assert (ins
->ref_snoop_scb
!= NULL
,return -EINVAL
);
1764 down(&chip
->spos_mutex
);
1765 ins
->pcm_input
= cs46xx_add_record_source(chip
,ins
->ref_snoop_scb
,PCMSERIALIN_PCM_SCB_ADDR
,
1766 "PCMSerialInput_Wave");
1767 up(&chip
->spos_mutex
);
1772 int cs46xx_dsp_disable_pcm_capture (cs46xx_t
*chip
)
1774 dsp_spos_instance_t
* ins
= chip
->dsp_spos_instance
;
1776 snd_assert (ins
->pcm_input
!= NULL
,return -EINVAL
);
1778 down(&chip
->spos_mutex
);
1779 cs46xx_dsp_remove_scb (chip
,ins
->pcm_input
);
1780 ins
->pcm_input
= NULL
;
1781 up(&chip
->spos_mutex
);
1786 int cs46xx_dsp_enable_adc_capture (cs46xx_t
*chip
)
1788 dsp_spos_instance_t
* ins
= chip
->dsp_spos_instance
;
1790 snd_assert (ins
->adc_input
== NULL
,return -EINVAL
);
1791 snd_assert (ins
->codec_in_scb
!= NULL
,return -EINVAL
);
1793 down(&chip
->spos_mutex
);
1794 ins
->adc_input
= cs46xx_add_record_source(chip
,ins
->codec_in_scb
,PCMSERIALIN_SCB_ADDR
,
1795 "PCMSerialInput_ADC");
1796 up(&chip
->spos_mutex
);
1801 int cs46xx_dsp_disable_adc_capture (cs46xx_t
*chip
)
1803 dsp_spos_instance_t
* ins
= chip
->dsp_spos_instance
;
1805 snd_assert (ins
->adc_input
!= NULL
,return -EINVAL
);
1807 down(&chip
->spos_mutex
);
1808 cs46xx_dsp_remove_scb (chip
,ins
->adc_input
);
1809 ins
->adc_input
= NULL
;
1810 up(&chip
->spos_mutex
);
1815 int cs46xx_poke_via_dsp (cs46xx_t
*chip
,u32 address
,u32 data
)
1820 /* santiy check the parameters. (These numbers are not 100% correct. They are
1821 a rough guess from looking at the controller spec.) */
1822 if (address
< 0x8000 || address
>= 0x9000)
1825 /* initialize the SP_IO_WRITE SCB with the data. */
1826 temp
= ( address
<< 16 ) | ( address
& 0x0000FFFF); /* offset 0 <-- address2 : address1 */
1828 snd_cs46xx_poke(chip
,( SPIOWRITE_SCB_ADDR
<< 2), temp
);
1829 snd_cs46xx_poke(chip
,((SPIOWRITE_SCB_ADDR
+ 1) << 2), data
); /* offset 1 <-- data1 */
1830 snd_cs46xx_poke(chip
,((SPIOWRITE_SCB_ADDR
+ 2) << 2), data
); /* offset 1 <-- data2 */
1832 /* Poke this location to tell the task to start */
1833 snd_cs46xx_poke(chip
,((SPIOWRITE_SCB_ADDR
+ 6) << 2), SPIOWRITE_SCB_ADDR
<< 0x10);
1835 /* Verify that the task ran */
1836 for (i
=0; i
<25; i
++) {
1839 temp
= snd_cs46xx_peek(chip
,((SPIOWRITE_SCB_ADDR
+ 6) << 2));
1840 if (temp
== 0x00000000)
1845 snd_printk(KERN_ERR
"dsp_spos: SPIOWriteTask not responding\n");
1852 int cs46xx_dsp_set_dac_volume (cs46xx_t
* chip
,u16 left
,u16 right
)
1854 dsp_spos_instance_t
* ins
= chip
->dsp_spos_instance
;
1855 dsp_scb_descriptor_t
* scb
;
1857 down(&chip
->spos_mutex
);
1860 scb
= ins
->master_mix_scb
->sub_list_ptr
;
1861 while (scb
!= ins
->the_null_scb
) {
1862 cs46xx_dsp_scb_set_volume (chip
,scb
,left
,right
);
1863 scb
= scb
->next_scb_ptr
;
1867 scb
= ins
->rear_mix_scb
->sub_list_ptr
;
1868 while (scb
!= ins
->the_null_scb
) {
1869 cs46xx_dsp_scb_set_volume (chip
,scb
,left
,right
);
1870 scb
= scb
->next_scb_ptr
;
1873 ins
->dac_volume_left
= left
;
1874 ins
->dac_volume_right
= right
;
1876 up(&chip
->spos_mutex
);
1881 int cs46xx_dsp_set_iec958_volume (cs46xx_t
* chip
,u16 left
,u16 right
) {
1882 dsp_spos_instance_t
* ins
= chip
->dsp_spos_instance
;
1884 down(&chip
->spos_mutex
);
1886 if (ins
->asynch_rx_scb
!= NULL
)
1887 cs46xx_dsp_scb_set_volume (chip
,ins
->asynch_rx_scb
,
1890 ins
->spdif_input_volume_left
= left
;
1891 ins
->spdif_input_volume_right
= right
;
1893 up(&chip
->spos_mutex
);