2 * Driver for Digigram miXart soundcards
4 * DSP firmware management
6 * Copyright (c) 2003 by Digigram <alsa@digigram.com>
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23 #include <linux/interrupt.h>
24 #include <linux/pci.h>
25 #include <linux/firmware.h>
26 #include <linux/vmalloc.h>
27 #include <linux/slab.h>
28 #include <linux/module.h>
30 #include <sound/core.h>
32 #include "mixart_mixer.h"
33 #include "mixart_core.h"
34 #include "mixart_hwdep.h"
38 * wait for a value on a peudo register, exit with a timeout
40 * @param mgr pointer to miXart manager structure
41 * @param offset unsigned pseudo_register base + offset of value
43 * @param timeout timeout in centisenconds
45 static int mixart_wait_nice_for_register_value(struct mixart_mgr
*mgr
,
46 u32 offset
, int is_egal
,
47 u32 value
, unsigned long timeout
)
49 unsigned long end_time
= jiffies
+ (timeout
* HZ
/ 100);
52 do { /* we may take too long time in this loop.
53 * so give controls back to kernel if needed.
57 read
= readl_be( MIXART_MEM( mgr
, offset
));
59 if(read
== value
) return 0;
61 else { /* wait for different value */
62 if(read
!= value
) return 0;
64 } while ( time_after_eq(end_time
, jiffies
) );
71 structures needed to upload elf code packets
73 struct snd_mixart_elf32_ehdr
{
90 struct snd_mixart_elf32_phdr
{
101 static int mixart_load_elf(struct mixart_mgr
*mgr
, const struct firmware
*dsp
)
103 char elf32_magic_number
[4] = {0x7f,'E','L','F'};
104 struct snd_mixart_elf32_ehdr
*elf_header
;
107 elf_header
= (struct snd_mixart_elf32_ehdr
*)dsp
->data
;
109 if ( elf32_magic_number
[i
] != elf_header
->e_ident
[i
] )
112 if( elf_header
->e_phoff
!= 0 ) {
113 struct snd_mixart_elf32_phdr elf_programheader
;
115 for( i
=0; i
< be16_to_cpu(elf_header
->e_phnum
); i
++ ) {
116 u32 pos
= be32_to_cpu(elf_header
->e_phoff
) + (u32
)(i
* be16_to_cpu(elf_header
->e_phentsize
));
118 memcpy( &elf_programheader
, dsp
->data
+ pos
, sizeof(elf_programheader
) );
120 if(elf_programheader
.p_type
!= 0) {
121 if( elf_programheader
.p_filesz
!= 0 ) {
122 memcpy_toio( MIXART_MEM( mgr
, be32_to_cpu(elf_programheader
.p_vaddr
)),
123 dsp
->data
+ be32_to_cpu( elf_programheader
.p_offset
),
124 be32_to_cpu( elf_programheader
.p_filesz
));
133 * get basic information and init miXart
136 /* audio IDs for request to the board */
137 #define MIXART_FIRST_ANA_AUDIO_ID 0
138 #define MIXART_FIRST_DIG_AUDIO_ID 8
140 static int mixart_enum_connectors(struct mixart_mgr
*mgr
)
144 struct mixart_msg request
;
145 struct mixart_enum_connector_resp
*connector
;
146 struct mixart_audio_info_req
*audio_info_req
;
147 struct mixart_audio_info_resp
*audio_info
;
149 connector
= kmalloc(sizeof(*connector
), GFP_KERNEL
);
150 audio_info_req
= kmalloc(sizeof(*audio_info_req
), GFP_KERNEL
);
151 audio_info
= kmalloc(sizeof(*audio_info
), GFP_KERNEL
);
152 if (! connector
|| ! audio_info_req
|| ! audio_info
) {
157 audio_info_req
->line_max_level
= MIXART_FLOAT_P_22_0_TO_HEX
;
158 audio_info_req
->micro_max_level
= MIXART_FLOAT_M_20_0_TO_HEX
;
159 audio_info_req
->cd_max_level
= MIXART_FLOAT____0_0_TO_HEX
;
161 request
.message_id
= MSG_SYSTEM_ENUM_PLAY_CONNECTOR
;
162 request
.uid
= (struct mixart_uid
){0,0}; /* board num = 0 */
166 err
= snd_mixart_send_msg(mgr
, &request
, sizeof(*connector
), connector
);
167 if((err
< 0) || (connector
->error_code
) || (connector
->uid_count
> MIXART_MAX_PHYS_CONNECTORS
)) {
168 snd_printk(KERN_ERR
"error MSG_SYSTEM_ENUM_PLAY_CONNECTOR\n");
173 for(k
=0; k
< connector
->uid_count
; k
++) {
174 struct mixart_pipe
*pipe
;
176 if(k
< MIXART_FIRST_DIG_AUDIO_ID
) {
177 pipe
= &mgr
->chip
[k
/2]->pipe_out_ana
;
179 pipe
= &mgr
->chip
[(k
-MIXART_FIRST_DIG_AUDIO_ID
)/2]->pipe_out_dig
;
182 pipe
->uid_right_connector
= connector
->uid
[k
]; /* odd */
184 pipe
->uid_left_connector
= connector
->uid
[k
]; /* even */
187 /* snd_printk(KERN_DEBUG "playback connector[%d].object_id = %x\n", k, connector->uid[k].object_id); */
189 /* TODO: really need send_msg MSG_CONNECTOR_GET_AUDIO_INFO for each connector ? perhaps for analog level caps ? */
190 request
.message_id
= MSG_CONNECTOR_GET_AUDIO_INFO
;
191 request
.uid
= connector
->uid
[k
];
192 request
.data
= audio_info_req
;
193 request
.size
= sizeof(*audio_info_req
);
195 err
= snd_mixart_send_msg(mgr
, &request
, sizeof(*audio_info
), audio_info
);
197 snd_printk(KERN_ERR
"error MSG_CONNECTOR_GET_AUDIO_INFO\n");
200 /*snd_printk(KERN_DEBUG "play analog_info.analog_level_present = %x\n", audio_info->info.analog_info.analog_level_present);*/
203 request
.message_id
= MSG_SYSTEM_ENUM_RECORD_CONNECTOR
;
204 request
.uid
= (struct mixart_uid
){0,0}; /* board num = 0 */
208 err
= snd_mixart_send_msg(mgr
, &request
, sizeof(*connector
), connector
);
209 if((err
< 0) || (connector
->error_code
) || (connector
->uid_count
> MIXART_MAX_PHYS_CONNECTORS
)) {
210 snd_printk(KERN_ERR
"error MSG_SYSTEM_ENUM_RECORD_CONNECTOR\n");
215 for(k
=0; k
< connector
->uid_count
; k
++) {
216 struct mixart_pipe
*pipe
;
218 if(k
< MIXART_FIRST_DIG_AUDIO_ID
) {
219 pipe
= &mgr
->chip
[k
/2]->pipe_in_ana
;
221 pipe
= &mgr
->chip
[(k
-MIXART_FIRST_DIG_AUDIO_ID
)/2]->pipe_in_dig
;
224 pipe
->uid_right_connector
= connector
->uid
[k
]; /* odd */
226 pipe
->uid_left_connector
= connector
->uid
[k
]; /* even */
229 /* snd_printk(KERN_DEBUG "capture connector[%d].object_id = %x\n", k, connector->uid[k].object_id); */
231 /* TODO: really need send_msg MSG_CONNECTOR_GET_AUDIO_INFO for each connector ? perhaps for analog level caps ? */
232 request
.message_id
= MSG_CONNECTOR_GET_AUDIO_INFO
;
233 request
.uid
= connector
->uid
[k
];
234 request
.data
= audio_info_req
;
235 request
.size
= sizeof(*audio_info_req
);
237 err
= snd_mixart_send_msg(mgr
, &request
, sizeof(*audio_info
), audio_info
);
239 snd_printk(KERN_ERR
"error MSG_CONNECTOR_GET_AUDIO_INFO\n");
242 /*snd_printk(KERN_DEBUG "rec analog_info.analog_level_present = %x\n", audio_info->info.analog_info.analog_level_present);*/
248 kfree(audio_info_req
);
254 static int mixart_enum_physio(struct mixart_mgr
*mgr
)
258 struct mixart_msg request
;
259 struct mixart_uid get_console_mgr
;
260 struct mixart_return_uid console_mgr
;
261 struct mixart_uid_enumeration phys_io
;
263 /* get the uid for the console manager */
264 get_console_mgr
.object_id
= 0;
265 get_console_mgr
.desc
= MSG_CONSOLE_MANAGER
| 0; /* cardindex = 0 */
267 request
.message_id
= MSG_CONSOLE_GET_CLOCK_UID
;
268 request
.uid
= get_console_mgr
;
269 request
.data
= &get_console_mgr
;
270 request
.size
= sizeof(get_console_mgr
);
272 err
= snd_mixart_send_msg(mgr
, &request
, sizeof(console_mgr
), &console_mgr
);
274 if( (err
< 0) || (console_mgr
.error_code
!= 0) ) {
275 snd_printk(KERN_DEBUG
"error MSG_CONSOLE_GET_CLOCK_UID : err=%x\n", console_mgr
.error_code
);
279 /* used later for clock issues ! */
280 mgr
->uid_console_manager
= console_mgr
.uid
;
282 request
.message_id
= MSG_SYSTEM_ENUM_PHYSICAL_IO
;
283 request
.uid
= (struct mixart_uid
){0,0};
284 request
.data
= &console_mgr
.uid
;
285 request
.size
= sizeof(console_mgr
.uid
);
287 err
= snd_mixart_send_msg(mgr
, &request
, sizeof(phys_io
), &phys_io
);
288 if( (err
< 0) || ( phys_io
.error_code
!= 0 ) ) {
289 snd_printk(KERN_ERR
"error MSG_SYSTEM_ENUM_PHYSICAL_IO err(%x) error_code(%x)\n", err
, phys_io
.error_code
);
293 /* min 2 phys io per card (analog in + analog out) */
294 if (phys_io
.nb_uid
< MIXART_MAX_CARDS
* 2)
297 for(k
=0; k
<mgr
->num_cards
; k
++) {
298 mgr
->chip
[k
]->uid_in_analog_physio
= phys_io
.uid
[k
];
299 mgr
->chip
[k
]->uid_out_analog_physio
= phys_io
.uid
[phys_io
.nb_uid
/2 + k
];
306 static int mixart_first_init(struct mixart_mgr
*mgr
)
310 struct mixart_msg request
;
312 if((err
= mixart_enum_connectors(mgr
)) < 0) return err
;
314 if((err
= mixart_enum_physio(mgr
)) < 0) return err
;
316 /* send a synchro command to card (necessary to do this before first MSG_STREAM_START_STREAM_GRP_PACKET) */
317 /* though why not here */
318 request
.message_id
= MSG_SYSTEM_SEND_SYNCHRO_CMD
;
319 request
.uid
= (struct mixart_uid
){0,0};
322 /* this command has no data. response is a 32 bit status */
323 err
= snd_mixart_send_msg(mgr
, &request
, sizeof(k
), &k
);
324 if( (err
< 0) || (k
!= 0) ) {
325 snd_printk(KERN_ERR
"error MSG_SYSTEM_SEND_SYNCHRO_CMD\n");
326 return err
== 0 ? -EINVAL
: err
;
333 /* firmware base addresses (when hard coded) */
334 #define MIXART_MOTHERBOARD_XLX_BASE_ADDRESS 0x00600000
336 static int mixart_dsp_load(struct mixart_mgr
* mgr
, int index
, const struct firmware
*dsp
)
339 u32 status_xilinx
, status_elf
, status_daught
;
342 /* read motherboard xilinx status */
343 status_xilinx
= readl_be( MIXART_MEM( mgr
,MIXART_PSEUDOREG_MXLX_STATUS_OFFSET
));
344 /* read elf status */
345 status_elf
= readl_be( MIXART_MEM( mgr
,MIXART_PSEUDOREG_ELF_STATUS_OFFSET
));
346 /* read daughterboard xilinx status */
347 status_daught
= readl_be( MIXART_MEM( mgr
,MIXART_PSEUDOREG_DXLX_STATUS_OFFSET
));
349 /* motherboard xilinx status 5 will say that the board is performing a reset */
350 if (status_xilinx
== 5) {
351 snd_printk(KERN_ERR
"miXart is resetting !\n");
352 return -EAGAIN
; /* try again later */
356 case MIXART_MOTHERBOARD_XLX_INDEX
:
358 /* xilinx already loaded ? */
359 if (status_xilinx
== 4) {
360 snd_printk(KERN_DEBUG
"xilinx is already loaded !\n");
363 /* the status should be 0 == "idle" */
364 if (status_xilinx
!= 0) {
365 snd_printk(KERN_ERR
"xilinx load error ! status = %d\n",
367 return -EIO
; /* modprob -r may help ? */
370 /* check xilinx validity */
371 if (((u32
*)(dsp
->data
))[0] == 0xffffffff)
376 /* set xilinx status to copying */
377 writel_be( 1, MIXART_MEM( mgr
, MIXART_PSEUDOREG_MXLX_STATUS_OFFSET
));
379 /* setup xilinx base address */
380 writel_be( MIXART_MOTHERBOARD_XLX_BASE_ADDRESS
, MIXART_MEM( mgr
,MIXART_PSEUDOREG_MXLX_BASE_ADDR_OFFSET
));
381 /* setup code size for xilinx file */
382 writel_be( dsp
->size
, MIXART_MEM( mgr
, MIXART_PSEUDOREG_MXLX_SIZE_OFFSET
));
384 /* copy xilinx code */
385 memcpy_toio( MIXART_MEM( mgr
, MIXART_MOTHERBOARD_XLX_BASE_ADDRESS
), dsp
->data
, dsp
->size
);
387 /* set xilinx status to copy finished */
388 writel_be( 2, MIXART_MEM( mgr
, MIXART_PSEUDOREG_MXLX_STATUS_OFFSET
));
390 /* return, because no further processing needed */
393 case MIXART_MOTHERBOARD_ELF_INDEX
:
395 if (status_elf
== 4) {
396 snd_printk(KERN_DEBUG
"elf file already loaded !\n");
400 /* the status should be 0 == "idle" */
401 if (status_elf
!= 0) {
402 snd_printk(KERN_ERR
"elf load error ! status = %d\n",
404 return -EIO
; /* modprob -r may help ? */
407 /* wait for xilinx status == 4 */
408 err
= mixart_wait_nice_for_register_value( mgr
, MIXART_PSEUDOREG_MXLX_STATUS_OFFSET
, 1, 4, 500); /* 5sec */
410 snd_printk(KERN_ERR
"xilinx was not loaded or "
411 "could not be started\n");
415 /* init some data on the card */
416 writel_be( 0, MIXART_MEM( mgr
, MIXART_PSEUDOREG_BOARDNUMBER
) ); /* set miXart boardnumber to 0 */
417 writel_be( 0, MIXART_MEM( mgr
, MIXART_FLOWTABLE_PTR
) ); /* reset pointer to flow table on miXart */
419 /* set elf status to copying */
420 writel_be( 1, MIXART_MEM( mgr
, MIXART_PSEUDOREG_ELF_STATUS_OFFSET
));
422 /* process the copying of the elf packets */
423 err
= mixart_load_elf( mgr
, dsp
);
424 if (err
< 0) return err
;
426 /* set elf status to copy finished */
427 writel_be( 2, MIXART_MEM( mgr
, MIXART_PSEUDOREG_ELF_STATUS_OFFSET
));
429 /* wait for elf status == 4 */
430 err
= mixart_wait_nice_for_register_value( mgr
, MIXART_PSEUDOREG_ELF_STATUS_OFFSET
, 1, 4, 300); /* 3sec */
432 snd_printk(KERN_ERR
"elf could not be started\n");
436 /* miXart waits at this point on the pointer to the flow table */
437 writel_be( (u32
)mgr
->flowinfo
.addr
, MIXART_MEM( mgr
, MIXART_FLOWTABLE_PTR
) ); /* give pointer of flow table to miXart */
439 return 0; /* return, another xilinx file has to be loaded before */
441 case MIXART_AESEBUBOARD_XLX_INDEX
:
444 /* elf and xilinx should be loaded */
445 if (status_elf
!= 4 || status_xilinx
!= 4) {
446 printk(KERN_ERR
"xilinx or elf not "
447 "successfully loaded\n");
448 return -EIO
; /* modprob -r may help ? */
451 /* wait for daughter detection != 0 */
452 err
= mixart_wait_nice_for_register_value( mgr
, MIXART_PSEUDOREG_DBRD_PRESENCE_OFFSET
, 0, 0, 30); /* 300msec */
454 snd_printk(KERN_ERR
"error starting elf file\n");
458 /* the board type can now be retrieved */
459 mgr
->board_type
= (DAUGHTER_TYPE_MASK
& readl_be( MIXART_MEM( mgr
, MIXART_PSEUDOREG_DBRD_TYPE_OFFSET
)));
461 if (mgr
->board_type
== MIXART_DAUGHTER_TYPE_NONE
)
462 break; /* no daughter board; the file does not have to be loaded, continue after the switch */
464 /* only if aesebu daughter board presence (elf code must run) */
465 if (mgr
->board_type
!= MIXART_DAUGHTER_TYPE_AES
)
468 /* daughter should be idle */
469 if (status_daught
!= 0) {
470 printk(KERN_ERR
"daughter load error ! status = %d\n",
472 return -EIO
; /* modprob -r may help ? */
475 /* check daughterboard xilinx validity */
476 if (((u32
*)(dsp
->data
))[0] == 0xffffffff)
481 /* inform mixart about the size of the file */
482 writel_be( dsp
->size
, MIXART_MEM( mgr
, MIXART_PSEUDOREG_DXLX_SIZE_OFFSET
));
484 /* set daughterboard status to 1 */
485 writel_be( 1, MIXART_MEM( mgr
, MIXART_PSEUDOREG_DXLX_STATUS_OFFSET
));
487 /* wait for status == 2 */
488 err
= mixart_wait_nice_for_register_value( mgr
, MIXART_PSEUDOREG_DXLX_STATUS_OFFSET
, 1, 2, 30); /* 300msec */
490 snd_printk(KERN_ERR
"daughter board load error\n");
494 /* get the address where to write the file */
495 val
= readl_be( MIXART_MEM( mgr
, MIXART_PSEUDOREG_DXLX_BASE_ADDR_OFFSET
));
499 /* copy daughterboard xilinx code */
500 memcpy_toio( MIXART_MEM( mgr
, val
), dsp
->data
, dsp
->size
);
502 /* set daughterboard status to 4 */
503 writel_be( 4, MIXART_MEM( mgr
, MIXART_PSEUDOREG_DXLX_STATUS_OFFSET
));
505 /* continue with init */
507 } /* end of switch file index*/
509 /* wait for daughter status == 3 */
510 err
= mixart_wait_nice_for_register_value( mgr
, MIXART_PSEUDOREG_DXLX_STATUS_OFFSET
, 1, 3, 300); /* 3sec */
513 "daughter board could not be initialised\n");
517 /* init mailbox (communication with embedded) */
518 snd_mixart_init_mailbox(mgr
);
520 /* first communication with embedded */
521 err
= mixart_first_init(mgr
);
523 snd_printk(KERN_ERR
"miXart could not be set up\n");
527 /* create devices and mixer in accordance with HW options*/
528 for (card_index
= 0; card_index
< mgr
->num_cards
; card_index
++) {
529 struct snd_mixart
*chip
= mgr
->chip
[card_index
];
531 if ((err
= snd_mixart_create_pcm(chip
)) < 0)
534 if (card_index
== 0) {
535 if ((err
= snd_mixart_create_mixer(chip
->mgr
)) < 0)
539 if ((err
= snd_card_register(chip
->card
)) < 0)
543 snd_printdd("miXart firmware downloaded and successfully set up\n");
549 #if defined(CONFIG_FW_LOADER) || defined(CONFIG_FW_LOADER_MODULE)
550 #if !defined(CONFIG_USE_MIXARTLOADER) && !defined(CONFIG_SND_MIXART) /* built-in kernel */
551 #define SND_MIXART_FW_LOADER /* use the standard firmware loader */
555 #ifdef SND_MIXART_FW_LOADER
557 int snd_mixart_setup_firmware(struct mixart_mgr
*mgr
)
559 static char *fw_files
[3] = {
560 "miXart8.xlx", "miXart8.elf", "miXart8AES.xlx"
564 const struct firmware
*fw_entry
;
567 for (i
= 0; i
< 3; i
++) {
568 sprintf(path
, "mixart/%s", fw_files
[i
]);
569 if (request_firmware(&fw_entry
, path
, &mgr
->pci
->dev
)) {
570 snd_printk(KERN_ERR
"miXart: can't load firmware %s\n", path
);
573 /* fake hwdep dsp record */
574 err
= mixart_dsp_load(mgr
, i
, fw_entry
);
575 release_firmware(fw_entry
);
578 mgr
->dsp_loaded
|= 1 << i
;
583 MODULE_FIRMWARE("mixart/miXart8.xlx");
584 MODULE_FIRMWARE("mixart/miXart8.elf");
585 MODULE_FIRMWARE("mixart/miXart8AES.xlx");
587 #else /* old style firmware loading */
589 /* miXart hwdep interface id string */
590 #define SND_MIXART_HWDEP_ID "miXart Loader"
592 static int mixart_hwdep_dsp_status(struct snd_hwdep
*hw
,
593 struct snd_hwdep_dsp_status
*info
)
595 struct mixart_mgr
*mgr
= hw
->private_data
;
597 strcpy(info
->id
, "miXart");
598 info
->num_dsps
= MIXART_HARDW_FILES_MAX_INDEX
;
600 if (mgr
->dsp_loaded
& (1 << MIXART_MOTHERBOARD_ELF_INDEX
))
601 info
->chip_ready
= 1;
603 info
->version
= MIXART_DRIVER_VERSION
;
607 static int mixart_hwdep_dsp_load(struct snd_hwdep
*hw
,
608 struct snd_hwdep_dsp_image
*dsp
)
610 struct mixart_mgr
* mgr
= hw
->private_data
;
614 fw
.size
= dsp
->length
;
615 fw
.data
= vmalloc(dsp
->length
);
617 snd_printk(KERN_ERR
"miXart: cannot allocate image size %d\n",
621 if (copy_from_user((void *) fw
.data
, dsp
->image
, dsp
->length
)) {
625 err
= mixart_dsp_load(mgr
, dsp
->index
, &fw
);
629 mgr
->dsp_loaded
|= 1 << dsp
->index
;
633 int snd_mixart_setup_firmware(struct mixart_mgr
*mgr
)
636 struct snd_hwdep
*hw
;
638 /* only create hwdep interface for first cardX (see "index" module parameter)*/
639 if ((err
= snd_hwdep_new(mgr
->chip
[0]->card
, SND_MIXART_HWDEP_ID
, 0, &hw
)) < 0)
642 hw
->iface
= SNDRV_HWDEP_IFACE_MIXART
;
643 hw
->private_data
= mgr
;
644 hw
->ops
.dsp_status
= mixart_hwdep_dsp_status
;
645 hw
->ops
.dsp_load
= mixart_hwdep_dsp_load
;
647 sprintf(hw
->name
, SND_MIXART_HWDEP_ID
);
650 return snd_card_register(mgr
->chip
[0]->card
);
653 #endif /* SND_MIXART_FW_LOADER */