11a59d1b8SThomas Gleixner // SPDX-License-Identifier: GPL-2.0-or-later
21da177e4SLinus Torvalds /*
31da177e4SLinus Torvalds * Driver for Digigram miXart soundcards
41da177e4SLinus Torvalds *
51da177e4SLinus Torvalds * DSP firmware management
61da177e4SLinus Torvalds *
71da177e4SLinus Torvalds * Copyright (c) 2003 by Digigram <alsa@digigram.com>
81da177e4SLinus Torvalds */
91da177e4SLinus Torvalds
101da177e4SLinus Torvalds #include <linux/interrupt.h>
111da177e4SLinus Torvalds #include <linux/pci.h>
121da177e4SLinus Torvalds #include <linux/firmware.h>
1344052e0dSFrank Lichtenheld #include <linux/vmalloc.h>
145a0e3ad6STejun Heo #include <linux/slab.h>
15da155d5bSPaul Gortmaker #include <linux/module.h>
166cbbfe1cSTakashi Iwai #include <linux/io.h>
171da177e4SLinus Torvalds #include <sound/core.h>
181da177e4SLinus Torvalds #include "mixart.h"
191da177e4SLinus Torvalds #include "mixart_mixer.h"
201da177e4SLinus Torvalds #include "mixart_core.h"
211da177e4SLinus Torvalds #include "mixart_hwdep.h"
221da177e4SLinus Torvalds
231da177e4SLinus Torvalds
241da177e4SLinus Torvalds /**
2506495facSPierre-Louis Bossart * mixart_wait_nice_for_register_value - wait for a value on a peudo register,
2606495facSPierre-Louis Bossart * exit with a timeout
271da177e4SLinus Torvalds *
283f60c87dSTakashi Iwai * @mgr: pointer to miXart manager structure
293f60c87dSTakashi Iwai * @offset: unsigned pseudo_register base + offset of value
303f60c87dSTakashi Iwai * @is_egal: wait for the equal value
313f60c87dSTakashi Iwai * @value: value
323f60c87dSTakashi Iwai * @timeout: timeout in centisenconds
331da177e4SLinus Torvalds */
mixart_wait_nice_for_register_value(struct mixart_mgr * mgr,u32 offset,int is_egal,u32 value,unsigned long timeout)3467b48b88STakashi Iwai static int mixart_wait_nice_for_register_value(struct mixart_mgr *mgr,
3567b48b88STakashi Iwai u32 offset, int is_egal,
3667b48b88STakashi Iwai u32 value, unsigned long timeout)
371da177e4SLinus Torvalds {
381da177e4SLinus Torvalds unsigned long end_time = jiffies + (timeout * HZ / 100);
391da177e4SLinus Torvalds u32 read;
401da177e4SLinus Torvalds
411da177e4SLinus Torvalds do { /* we may take too long time in this loop.
421da177e4SLinus Torvalds * so give controls back to kernel if needed.
431da177e4SLinus Torvalds */
441da177e4SLinus Torvalds cond_resched();
451da177e4SLinus Torvalds
461da177e4SLinus Torvalds read = readl_be( MIXART_MEM( mgr, offset ));
471da177e4SLinus Torvalds if(is_egal) {
481da177e4SLinus Torvalds if(read == value) return 0;
491da177e4SLinus Torvalds }
501da177e4SLinus Torvalds else { /* wait for different value */
511da177e4SLinus Torvalds if(read != value) return 0;
521da177e4SLinus Torvalds }
531da177e4SLinus Torvalds } while ( time_after_eq(end_time, jiffies) );
541da177e4SLinus Torvalds
551da177e4SLinus Torvalds return -EBUSY;
561da177e4SLinus Torvalds }
571da177e4SLinus Torvalds
581da177e4SLinus Torvalds
591da177e4SLinus Torvalds /*
601da177e4SLinus Torvalds structures needed to upload elf code packets
611da177e4SLinus Torvalds */
621da177e4SLinus Torvalds struct snd_mixart_elf32_ehdr {
631da177e4SLinus Torvalds u8 e_ident[16];
640e7ca66aSTakashi Iwai __be16 e_type;
650e7ca66aSTakashi Iwai __be16 e_machine;
660e7ca66aSTakashi Iwai __be32 e_version;
670e7ca66aSTakashi Iwai __be32 e_entry;
680e7ca66aSTakashi Iwai __be32 e_phoff;
690e7ca66aSTakashi Iwai __be32 e_shoff;
700e7ca66aSTakashi Iwai __be32 e_flags;
710e7ca66aSTakashi Iwai __be16 e_ehsize;
720e7ca66aSTakashi Iwai __be16 e_phentsize;
730e7ca66aSTakashi Iwai __be16 e_phnum;
740e7ca66aSTakashi Iwai __be16 e_shentsize;
750e7ca66aSTakashi Iwai __be16 e_shnum;
760e7ca66aSTakashi Iwai __be16 e_shstrndx;
771da177e4SLinus Torvalds };
781da177e4SLinus Torvalds
791da177e4SLinus Torvalds struct snd_mixart_elf32_phdr {
800e7ca66aSTakashi Iwai __be32 p_type;
810e7ca66aSTakashi Iwai __be32 p_offset;
820e7ca66aSTakashi Iwai __be32 p_vaddr;
830e7ca66aSTakashi Iwai __be32 p_paddr;
840e7ca66aSTakashi Iwai __be32 p_filesz;
850e7ca66aSTakashi Iwai __be32 p_memsz;
860e7ca66aSTakashi Iwai __be32 p_flags;
870e7ca66aSTakashi Iwai __be32 p_align;
881da177e4SLinus Torvalds };
891da177e4SLinus Torvalds
mixart_load_elf(struct mixart_mgr * mgr,const struct firmware * dsp)9067b48b88STakashi Iwai static int mixart_load_elf(struct mixart_mgr *mgr, const struct firmware *dsp )
911da177e4SLinus Torvalds {
921da177e4SLinus Torvalds char elf32_magic_number[4] = {0x7f,'E','L','F'};
9367b48b88STakashi Iwai struct snd_mixart_elf32_ehdr *elf_header;
941da177e4SLinus Torvalds int i;
951da177e4SLinus Torvalds
9667b48b88STakashi Iwai elf_header = (struct snd_mixart_elf32_ehdr *)dsp->data;
971da177e4SLinus Torvalds for( i=0; i<4; i++ )
981da177e4SLinus Torvalds if ( elf32_magic_number[i] != elf_header->e_ident[i] )
991da177e4SLinus Torvalds return -EINVAL;
1001da177e4SLinus Torvalds
1011da177e4SLinus Torvalds if( elf_header->e_phoff != 0 ) {
10267b48b88STakashi Iwai struct snd_mixart_elf32_phdr elf_programheader;
1031da177e4SLinus Torvalds
1041da177e4SLinus Torvalds for( i=0; i < be16_to_cpu(elf_header->e_phnum); i++ ) {
1051da177e4SLinus Torvalds u32 pos = be32_to_cpu(elf_header->e_phoff) + (u32)(i * be16_to_cpu(elf_header->e_phentsize));
1061da177e4SLinus Torvalds
1071da177e4SLinus Torvalds memcpy( &elf_programheader, dsp->data + pos, sizeof(elf_programheader) );
1081da177e4SLinus Torvalds
1091da177e4SLinus Torvalds if(elf_programheader.p_type != 0) {
1101da177e4SLinus Torvalds if( elf_programheader.p_filesz != 0 ) {
1111da177e4SLinus Torvalds memcpy_toio( MIXART_MEM( mgr, be32_to_cpu(elf_programheader.p_vaddr)),
1121da177e4SLinus Torvalds dsp->data + be32_to_cpu( elf_programheader.p_offset ),
1131da177e4SLinus Torvalds be32_to_cpu( elf_programheader.p_filesz ));
1141da177e4SLinus Torvalds }
1151da177e4SLinus Torvalds }
1161da177e4SLinus Torvalds }
1171da177e4SLinus Torvalds }
1181da177e4SLinus Torvalds return 0;
1191da177e4SLinus Torvalds }
1201da177e4SLinus Torvalds
1211da177e4SLinus Torvalds /*
1221da177e4SLinus Torvalds * get basic information and init miXart
1231da177e4SLinus Torvalds */
1241da177e4SLinus Torvalds
1251da177e4SLinus Torvalds /* audio IDs for request to the board */
1261da177e4SLinus Torvalds #define MIXART_FIRST_ANA_AUDIO_ID 0
1271da177e4SLinus Torvalds #define MIXART_FIRST_DIG_AUDIO_ID 8
1281da177e4SLinus Torvalds
mixart_enum_connectors(struct mixart_mgr * mgr)12967b48b88STakashi Iwai static int mixart_enum_connectors(struct mixart_mgr *mgr)
1301da177e4SLinus Torvalds {
1311da177e4SLinus Torvalds u32 k;
1321da177e4SLinus Torvalds int err;
13367b48b88STakashi Iwai struct mixart_msg request;
13467b48b88STakashi Iwai struct mixart_enum_connector_resp *connector;
13567b48b88STakashi Iwai struct mixart_audio_info_req *audio_info_req;
13667b48b88STakashi Iwai struct mixart_audio_info_resp *audio_info;
1371da177e4SLinus Torvalds
1381da177e4SLinus Torvalds connector = kmalloc(sizeof(*connector), GFP_KERNEL);
1391da177e4SLinus Torvalds audio_info_req = kmalloc(sizeof(*audio_info_req), GFP_KERNEL);
1401da177e4SLinus Torvalds audio_info = kmalloc(sizeof(*audio_info), GFP_KERNEL);
1411da177e4SLinus Torvalds if (! connector || ! audio_info_req || ! audio_info) {
1421da177e4SLinus Torvalds err = -ENOMEM;
1431da177e4SLinus Torvalds goto __error;
1441da177e4SLinus Torvalds }
1451da177e4SLinus Torvalds
1461da177e4SLinus Torvalds audio_info_req->line_max_level = MIXART_FLOAT_P_22_0_TO_HEX;
1471da177e4SLinus Torvalds audio_info_req->micro_max_level = MIXART_FLOAT_M_20_0_TO_HEX;
1481da177e4SLinus Torvalds audio_info_req->cd_max_level = MIXART_FLOAT____0_0_TO_HEX;
1491da177e4SLinus Torvalds
1501da177e4SLinus Torvalds request.message_id = MSG_SYSTEM_ENUM_PLAY_CONNECTOR;
15167b48b88STakashi Iwai request.uid = (struct mixart_uid){0,0}; /* board num = 0 */
1521da177e4SLinus Torvalds request.data = NULL;
1531da177e4SLinus Torvalds request.size = 0;
1541da177e4SLinus Torvalds
1551da177e4SLinus Torvalds err = snd_mixart_send_msg(mgr, &request, sizeof(*connector), connector);
1561da177e4SLinus Torvalds if((err < 0) || (connector->error_code) || (connector->uid_count > MIXART_MAX_PHYS_CONNECTORS)) {
1576414e35dSTakashi Iwai dev_err(&mgr->pci->dev,
1586414e35dSTakashi Iwai "error MSG_SYSTEM_ENUM_PLAY_CONNECTOR\n");
1591da177e4SLinus Torvalds err = -EINVAL;
1601da177e4SLinus Torvalds goto __error;
1611da177e4SLinus Torvalds }
1621da177e4SLinus Torvalds
1631da177e4SLinus Torvalds for(k=0; k < connector->uid_count; k++) {
16467b48b88STakashi Iwai struct mixart_pipe *pipe;
1651da177e4SLinus Torvalds
1661da177e4SLinus Torvalds if(k < MIXART_FIRST_DIG_AUDIO_ID) {
1671da177e4SLinus Torvalds pipe = &mgr->chip[k/2]->pipe_out_ana;
1681da177e4SLinus Torvalds } else {
1691da177e4SLinus Torvalds pipe = &mgr->chip[(k-MIXART_FIRST_DIG_AUDIO_ID)/2]->pipe_out_dig;
1701da177e4SLinus Torvalds }
1711da177e4SLinus Torvalds if(k & 1) {
1721da177e4SLinus Torvalds pipe->uid_right_connector = connector->uid[k]; /* odd */
1731da177e4SLinus Torvalds } else {
1741da177e4SLinus Torvalds pipe->uid_left_connector = connector->uid[k]; /* even */
1751da177e4SLinus Torvalds }
1761da177e4SLinus Torvalds
1776414e35dSTakashi Iwai /* dev_dbg(&mgr->pci->dev, "playback connector[%d].object_id = %x\n", k, connector->uid[k].object_id); */
1781da177e4SLinus Torvalds
1791da177e4SLinus Torvalds /* TODO: really need send_msg MSG_CONNECTOR_GET_AUDIO_INFO for each connector ? perhaps for analog level caps ? */
1801da177e4SLinus Torvalds request.message_id = MSG_CONNECTOR_GET_AUDIO_INFO;
1811da177e4SLinus Torvalds request.uid = connector->uid[k];
1821da177e4SLinus Torvalds request.data = audio_info_req;
1831da177e4SLinus Torvalds request.size = sizeof(*audio_info_req);
1841da177e4SLinus Torvalds
1851da177e4SLinus Torvalds err = snd_mixart_send_msg(mgr, &request, sizeof(*audio_info), audio_info);
1861da177e4SLinus Torvalds if( err < 0 ) {
1876414e35dSTakashi Iwai dev_err(&mgr->pci->dev,
1886414e35dSTakashi Iwai "error MSG_CONNECTOR_GET_AUDIO_INFO\n");
1891da177e4SLinus Torvalds goto __error;
1901da177e4SLinus Torvalds }
1916414e35dSTakashi Iwai /*dev_dbg(&mgr->pci->dev, "play analog_info.analog_level_present = %x\n", audio_info->info.analog_info.analog_level_present);*/
1921da177e4SLinus Torvalds }
1931da177e4SLinus Torvalds
1941da177e4SLinus Torvalds request.message_id = MSG_SYSTEM_ENUM_RECORD_CONNECTOR;
19567b48b88STakashi Iwai request.uid = (struct mixart_uid){0,0}; /* board num = 0 */
1961da177e4SLinus Torvalds request.data = NULL;
1971da177e4SLinus Torvalds request.size = 0;
1981da177e4SLinus Torvalds
1991da177e4SLinus Torvalds err = snd_mixart_send_msg(mgr, &request, sizeof(*connector), connector);
2001da177e4SLinus Torvalds if((err < 0) || (connector->error_code) || (connector->uid_count > MIXART_MAX_PHYS_CONNECTORS)) {
2016414e35dSTakashi Iwai dev_err(&mgr->pci->dev,
2026414e35dSTakashi Iwai "error MSG_SYSTEM_ENUM_RECORD_CONNECTOR\n");
2031da177e4SLinus Torvalds err = -EINVAL;
2041da177e4SLinus Torvalds goto __error;
2051da177e4SLinus Torvalds }
2061da177e4SLinus Torvalds
2071da177e4SLinus Torvalds for(k=0; k < connector->uid_count; k++) {
20867b48b88STakashi Iwai struct mixart_pipe *pipe;
2091da177e4SLinus Torvalds
2101da177e4SLinus Torvalds if(k < MIXART_FIRST_DIG_AUDIO_ID) {
2111da177e4SLinus Torvalds pipe = &mgr->chip[k/2]->pipe_in_ana;
2121da177e4SLinus Torvalds } else {
2131da177e4SLinus Torvalds pipe = &mgr->chip[(k-MIXART_FIRST_DIG_AUDIO_ID)/2]->pipe_in_dig;
2141da177e4SLinus Torvalds }
2151da177e4SLinus Torvalds if(k & 1) {
2161da177e4SLinus Torvalds pipe->uid_right_connector = connector->uid[k]; /* odd */
2171da177e4SLinus Torvalds } else {
2181da177e4SLinus Torvalds pipe->uid_left_connector = connector->uid[k]; /* even */
2191da177e4SLinus Torvalds }
2201da177e4SLinus Torvalds
2216414e35dSTakashi Iwai /* dev_dbg(&mgr->pci->dev, "capture connector[%d].object_id = %x\n", k, connector->uid[k].object_id); */
2221da177e4SLinus Torvalds
2231da177e4SLinus Torvalds /* TODO: really need send_msg MSG_CONNECTOR_GET_AUDIO_INFO for each connector ? perhaps for analog level caps ? */
2241da177e4SLinus Torvalds request.message_id = MSG_CONNECTOR_GET_AUDIO_INFO;
2251da177e4SLinus Torvalds request.uid = connector->uid[k];
2261da177e4SLinus Torvalds request.data = audio_info_req;
2271da177e4SLinus Torvalds request.size = sizeof(*audio_info_req);
2281da177e4SLinus Torvalds
2291da177e4SLinus Torvalds err = snd_mixart_send_msg(mgr, &request, sizeof(*audio_info), audio_info);
2301da177e4SLinus Torvalds if( err < 0 ) {
2316414e35dSTakashi Iwai dev_err(&mgr->pci->dev,
2326414e35dSTakashi Iwai "error MSG_CONNECTOR_GET_AUDIO_INFO\n");
2331da177e4SLinus Torvalds goto __error;
2341da177e4SLinus Torvalds }
2356414e35dSTakashi Iwai /*dev_dbg(&mgr->pci->dev, "rec analog_info.analog_level_present = %x\n", audio_info->info.analog_info.analog_level_present);*/
2361da177e4SLinus Torvalds }
2371da177e4SLinus Torvalds err = 0;
2381da177e4SLinus Torvalds
2391da177e4SLinus Torvalds __error:
2401da177e4SLinus Torvalds kfree(connector);
2411da177e4SLinus Torvalds kfree(audio_info_req);
2421da177e4SLinus Torvalds kfree(audio_info);
2431da177e4SLinus Torvalds
2441da177e4SLinus Torvalds return err;
2451da177e4SLinus Torvalds }
2461da177e4SLinus Torvalds
mixart_enum_physio(struct mixart_mgr * mgr)24767b48b88STakashi Iwai static int mixart_enum_physio(struct mixart_mgr *mgr)
2481da177e4SLinus Torvalds {
2491da177e4SLinus Torvalds u32 k;
2501da177e4SLinus Torvalds int err;
25167b48b88STakashi Iwai struct mixart_msg request;
25267b48b88STakashi Iwai struct mixart_uid get_console_mgr;
25367b48b88STakashi Iwai struct mixart_return_uid console_mgr;
25467b48b88STakashi Iwai struct mixart_uid_enumeration phys_io;
2551da177e4SLinus Torvalds
2561da177e4SLinus Torvalds /* get the uid for the console manager */
2571da177e4SLinus Torvalds get_console_mgr.object_id = 0;
2581da177e4SLinus Torvalds get_console_mgr.desc = MSG_CONSOLE_MANAGER | 0; /* cardindex = 0 */
2591da177e4SLinus Torvalds
2601da177e4SLinus Torvalds request.message_id = MSG_CONSOLE_GET_CLOCK_UID;
2611da177e4SLinus Torvalds request.uid = get_console_mgr;
2621da177e4SLinus Torvalds request.data = &get_console_mgr;
2631da177e4SLinus Torvalds request.size = sizeof(get_console_mgr);
2641da177e4SLinus Torvalds
2651da177e4SLinus Torvalds err = snd_mixart_send_msg(mgr, &request, sizeof(console_mgr), &console_mgr);
2661da177e4SLinus Torvalds
2671da177e4SLinus Torvalds if( (err < 0) || (console_mgr.error_code != 0) ) {
2686414e35dSTakashi Iwai dev_dbg(&mgr->pci->dev,
2696414e35dSTakashi Iwai "error MSG_CONSOLE_GET_CLOCK_UID : err=%x\n",
2706414e35dSTakashi Iwai console_mgr.error_code);
2711da177e4SLinus Torvalds return -EINVAL;
2721da177e4SLinus Torvalds }
2731da177e4SLinus Torvalds
2741da177e4SLinus Torvalds /* used later for clock issues ! */
2751da177e4SLinus Torvalds mgr->uid_console_manager = console_mgr.uid;
2761da177e4SLinus Torvalds
2771da177e4SLinus Torvalds request.message_id = MSG_SYSTEM_ENUM_PHYSICAL_IO;
27867b48b88STakashi Iwai request.uid = (struct mixart_uid){0,0};
2791da177e4SLinus Torvalds request.data = &console_mgr.uid;
2801da177e4SLinus Torvalds request.size = sizeof(console_mgr.uid);
2811da177e4SLinus Torvalds
2821da177e4SLinus Torvalds err = snd_mixart_send_msg(mgr, &request, sizeof(phys_io), &phys_io);
2831da177e4SLinus Torvalds if( (err < 0) || ( phys_io.error_code != 0 ) ) {
2846414e35dSTakashi Iwai dev_err(&mgr->pci->dev,
2856414e35dSTakashi Iwai "error MSG_SYSTEM_ENUM_PHYSICAL_IO err(%x) error_code(%x)\n",
2866414e35dSTakashi Iwai err, phys_io.error_code);
2871da177e4SLinus Torvalds return -EINVAL;
2881da177e4SLinus Torvalds }
2891da177e4SLinus Torvalds
290da3cec35STakashi Iwai /* min 2 phys io per card (analog in + analog out) */
291da3cec35STakashi Iwai if (phys_io.nb_uid < MIXART_MAX_CARDS * 2)
292da3cec35STakashi Iwai return -EINVAL;
2931da177e4SLinus Torvalds
2941da177e4SLinus Torvalds for(k=0; k<mgr->num_cards; k++) {
2951da177e4SLinus Torvalds mgr->chip[k]->uid_in_analog_physio = phys_io.uid[k];
2961da177e4SLinus Torvalds mgr->chip[k]->uid_out_analog_physio = phys_io.uid[phys_io.nb_uid/2 + k];
2971da177e4SLinus Torvalds }
2981da177e4SLinus Torvalds
2991da177e4SLinus Torvalds return 0;
3001da177e4SLinus Torvalds }
3011da177e4SLinus Torvalds
3021da177e4SLinus Torvalds
mixart_first_init(struct mixart_mgr * mgr)30367b48b88STakashi Iwai static int mixart_first_init(struct mixart_mgr *mgr)
3041da177e4SLinus Torvalds {
3051da177e4SLinus Torvalds u32 k;
3061da177e4SLinus Torvalds int err;
30767b48b88STakashi Iwai struct mixart_msg request;
3081da177e4SLinus Torvalds
309*73debecfSTakashi Iwai err = mixart_enum_connectors(mgr);
310*73debecfSTakashi Iwai if (err < 0)
311*73debecfSTakashi Iwai return err;
3121da177e4SLinus Torvalds
313*73debecfSTakashi Iwai err = mixart_enum_physio(mgr);
314*73debecfSTakashi Iwai if (err < 0)
315*73debecfSTakashi Iwai return err;
3161da177e4SLinus Torvalds
3171da177e4SLinus Torvalds /* send a synchro command to card (necessary to do this before first MSG_STREAM_START_STREAM_GRP_PACKET) */
3181da177e4SLinus Torvalds /* though why not here */
3191da177e4SLinus Torvalds request.message_id = MSG_SYSTEM_SEND_SYNCHRO_CMD;
32067b48b88STakashi Iwai request.uid = (struct mixart_uid){0,0};
3211da177e4SLinus Torvalds request.data = NULL;
3221da177e4SLinus Torvalds request.size = 0;
3231da177e4SLinus Torvalds /* this command has no data. response is a 32 bit status */
3241da177e4SLinus Torvalds err = snd_mixart_send_msg(mgr, &request, sizeof(k), &k);
3251da177e4SLinus Torvalds if( (err < 0) || (k != 0) ) {
3266414e35dSTakashi Iwai dev_err(&mgr->pci->dev, "error MSG_SYSTEM_SEND_SYNCHRO_CMD\n");
3271da177e4SLinus Torvalds return err == 0 ? -EINVAL : err;
3281da177e4SLinus Torvalds }
3291da177e4SLinus Torvalds
3301da177e4SLinus Torvalds return 0;
3311da177e4SLinus Torvalds }
3321da177e4SLinus Torvalds
3331da177e4SLinus Torvalds
3341da177e4SLinus Torvalds /* firmware base addresses (when hard coded) */
3351da177e4SLinus Torvalds #define MIXART_MOTHERBOARD_XLX_BASE_ADDRESS 0x00600000
3361da177e4SLinus Torvalds
mixart_dsp_load(struct mixart_mgr * mgr,int index,const struct firmware * dsp)33767b48b88STakashi Iwai static int mixart_dsp_load(struct mixart_mgr* mgr, int index, const struct firmware *dsp)
3381da177e4SLinus Torvalds {
3391da177e4SLinus Torvalds int err, card_index;
3401da177e4SLinus Torvalds u32 status_xilinx, status_elf, status_daught;
3411da177e4SLinus Torvalds u32 val;
3421da177e4SLinus Torvalds
3431da177e4SLinus Torvalds /* read motherboard xilinx status */
3441da177e4SLinus Torvalds status_xilinx = readl_be( MIXART_MEM( mgr,MIXART_PSEUDOREG_MXLX_STATUS_OFFSET ));
3451da177e4SLinus Torvalds /* read elf status */
3461da177e4SLinus Torvalds status_elf = readl_be( MIXART_MEM( mgr,MIXART_PSEUDOREG_ELF_STATUS_OFFSET ));
3471da177e4SLinus Torvalds /* read daughterboard xilinx status */
3481da177e4SLinus Torvalds status_daught = readl_be( MIXART_MEM( mgr,MIXART_PSEUDOREG_DXLX_STATUS_OFFSET ));
3491da177e4SLinus Torvalds
3501da177e4SLinus Torvalds /* motherboard xilinx status 5 will say that the board is performing a reset */
3511da177e4SLinus Torvalds if (status_xilinx == 5) {
3526414e35dSTakashi Iwai dev_err(&mgr->pci->dev, "miXart is resetting !\n");
3531da177e4SLinus Torvalds return -EAGAIN; /* try again later */
3541da177e4SLinus Torvalds }
3551da177e4SLinus Torvalds
3561da177e4SLinus Torvalds switch (index) {
3571da177e4SLinus Torvalds case MIXART_MOTHERBOARD_XLX_INDEX:
3581da177e4SLinus Torvalds
3591da177e4SLinus Torvalds /* xilinx already loaded ? */
3601da177e4SLinus Torvalds if (status_xilinx == 4) {
3616414e35dSTakashi Iwai dev_dbg(&mgr->pci->dev, "xilinx is already loaded !\n");
3621da177e4SLinus Torvalds return 0;
3631da177e4SLinus Torvalds }
3641da177e4SLinus Torvalds /* the status should be 0 == "idle" */
3651da177e4SLinus Torvalds if (status_xilinx != 0) {
3666414e35dSTakashi Iwai dev_err(&mgr->pci->dev,
3676414e35dSTakashi Iwai "xilinx load error ! status = %d\n",
368ee419653STakashi Iwai status_xilinx);
3691da177e4SLinus Torvalds return -EIO; /* modprob -r may help ? */
3701da177e4SLinus Torvalds }
3711da177e4SLinus Torvalds
3721da177e4SLinus Torvalds /* check xilinx validity */
373da3cec35STakashi Iwai if (((u32*)(dsp->data))[0] == 0xffffffff)
374da3cec35STakashi Iwai return -EINVAL;
375da3cec35STakashi Iwai if (dsp->size % 4)
376da3cec35STakashi Iwai return -EINVAL;
3771da177e4SLinus Torvalds
3781da177e4SLinus Torvalds /* set xilinx status to copying */
3791da177e4SLinus Torvalds writel_be( 1, MIXART_MEM( mgr, MIXART_PSEUDOREG_MXLX_STATUS_OFFSET ));
3801da177e4SLinus Torvalds
3811da177e4SLinus Torvalds /* setup xilinx base address */
3821da177e4SLinus Torvalds writel_be( MIXART_MOTHERBOARD_XLX_BASE_ADDRESS, MIXART_MEM( mgr,MIXART_PSEUDOREG_MXLX_BASE_ADDR_OFFSET ));
3831da177e4SLinus Torvalds /* setup code size for xilinx file */
3841da177e4SLinus Torvalds writel_be( dsp->size, MIXART_MEM( mgr, MIXART_PSEUDOREG_MXLX_SIZE_OFFSET ));
3851da177e4SLinus Torvalds
3861da177e4SLinus Torvalds /* copy xilinx code */
3871da177e4SLinus Torvalds memcpy_toio( MIXART_MEM( mgr, MIXART_MOTHERBOARD_XLX_BASE_ADDRESS), dsp->data, dsp->size);
3881da177e4SLinus Torvalds
3891da177e4SLinus Torvalds /* set xilinx status to copy finished */
3901da177e4SLinus Torvalds writel_be( 2, MIXART_MEM( mgr, MIXART_PSEUDOREG_MXLX_STATUS_OFFSET ));
3911da177e4SLinus Torvalds
3921da177e4SLinus Torvalds /* return, because no further processing needed */
3931da177e4SLinus Torvalds return 0;
3941da177e4SLinus Torvalds
3951da177e4SLinus Torvalds case MIXART_MOTHERBOARD_ELF_INDEX:
3961da177e4SLinus Torvalds
3971da177e4SLinus Torvalds if (status_elf == 4) {
3986414e35dSTakashi Iwai dev_dbg(&mgr->pci->dev, "elf file already loaded !\n");
3991da177e4SLinus Torvalds return 0;
4001da177e4SLinus Torvalds }
4011da177e4SLinus Torvalds
4021da177e4SLinus Torvalds /* the status should be 0 == "idle" */
4031da177e4SLinus Torvalds if (status_elf != 0) {
4046414e35dSTakashi Iwai dev_err(&mgr->pci->dev,
4056414e35dSTakashi Iwai "elf load error ! status = %d\n",
406ee419653STakashi Iwai status_elf);
4071da177e4SLinus Torvalds return -EIO; /* modprob -r may help ? */
4081da177e4SLinus Torvalds }
4091da177e4SLinus Torvalds
4101da177e4SLinus Torvalds /* wait for xilinx status == 4 */
4111da177e4SLinus Torvalds err = mixart_wait_nice_for_register_value( mgr, MIXART_PSEUDOREG_MXLX_STATUS_OFFSET, 1, 4, 500); /* 5sec */
4121da177e4SLinus Torvalds if (err < 0) {
4136414e35dSTakashi Iwai dev_err(&mgr->pci->dev, "xilinx was not loaded or "
414ee419653STakashi Iwai "could not be started\n");
4151da177e4SLinus Torvalds return err;
4161da177e4SLinus Torvalds }
4171da177e4SLinus Torvalds
4181da177e4SLinus Torvalds /* init some data on the card */
4191da177e4SLinus Torvalds writel_be( 0, MIXART_MEM( mgr, MIXART_PSEUDOREG_BOARDNUMBER ) ); /* set miXart boardnumber to 0 */
4201da177e4SLinus Torvalds writel_be( 0, MIXART_MEM( mgr, MIXART_FLOWTABLE_PTR ) ); /* reset pointer to flow table on miXart */
4211da177e4SLinus Torvalds
4221da177e4SLinus Torvalds /* set elf status to copying */
4231da177e4SLinus Torvalds writel_be( 1, MIXART_MEM( mgr, MIXART_PSEUDOREG_ELF_STATUS_OFFSET ));
4241da177e4SLinus Torvalds
4251da177e4SLinus Torvalds /* process the copying of the elf packets */
4261da177e4SLinus Torvalds err = mixart_load_elf( mgr, dsp );
4271da177e4SLinus Torvalds if (err < 0) return err;
4281da177e4SLinus Torvalds
4291da177e4SLinus Torvalds /* set elf status to copy finished */
4301da177e4SLinus Torvalds writel_be( 2, MIXART_MEM( mgr, MIXART_PSEUDOREG_ELF_STATUS_OFFSET ));
4311da177e4SLinus Torvalds
4321da177e4SLinus Torvalds /* wait for elf status == 4 */
4331da177e4SLinus Torvalds err = mixart_wait_nice_for_register_value( mgr, MIXART_PSEUDOREG_ELF_STATUS_OFFSET, 1, 4, 300); /* 3sec */
4341da177e4SLinus Torvalds if (err < 0) {
4356414e35dSTakashi Iwai dev_err(&mgr->pci->dev, "elf could not be started\n");
4361da177e4SLinus Torvalds return err;
4371da177e4SLinus Torvalds }
4381da177e4SLinus Torvalds
4391da177e4SLinus Torvalds /* miXart waits at this point on the pointer to the flow table */
4401da177e4SLinus Torvalds writel_be( (u32)mgr->flowinfo.addr, MIXART_MEM( mgr, MIXART_FLOWTABLE_PTR ) ); /* give pointer of flow table to miXart */
4411da177e4SLinus Torvalds
4421da177e4SLinus Torvalds return 0; /* return, another xilinx file has to be loaded before */
4431da177e4SLinus Torvalds
4441da177e4SLinus Torvalds case MIXART_AESEBUBOARD_XLX_INDEX:
4451da177e4SLinus Torvalds default:
4461da177e4SLinus Torvalds
4471da177e4SLinus Torvalds /* elf and xilinx should be loaded */
448ee419653STakashi Iwai if (status_elf != 4 || status_xilinx != 4) {
4496414e35dSTakashi Iwai dev_err(&mgr->pci->dev, "xilinx or elf not "
450ee419653STakashi Iwai "successfully loaded\n");
4511da177e4SLinus Torvalds return -EIO; /* modprob -r may help ? */
4521da177e4SLinus Torvalds }
4531da177e4SLinus Torvalds
4541da177e4SLinus Torvalds /* wait for daughter detection != 0 */
4551da177e4SLinus Torvalds err = mixart_wait_nice_for_register_value( mgr, MIXART_PSEUDOREG_DBRD_PRESENCE_OFFSET, 0, 0, 30); /* 300msec */
4561da177e4SLinus Torvalds if (err < 0) {
4576414e35dSTakashi Iwai dev_err(&mgr->pci->dev, "error starting elf file\n");
4581da177e4SLinus Torvalds return err;
4591da177e4SLinus Torvalds }
4601da177e4SLinus Torvalds
4611da177e4SLinus Torvalds /* the board type can now be retrieved */
4621da177e4SLinus Torvalds mgr->board_type = (DAUGHTER_TYPE_MASK & readl_be( MIXART_MEM( mgr, MIXART_PSEUDOREG_DBRD_TYPE_OFFSET)));
4631da177e4SLinus Torvalds
4641da177e4SLinus Torvalds if (mgr->board_type == MIXART_DAUGHTER_TYPE_NONE)
4651da177e4SLinus Torvalds break; /* no daughter board; the file does not have to be loaded, continue after the switch */
4661da177e4SLinus Torvalds
4671da177e4SLinus Torvalds /* only if aesebu daughter board presence (elf code must run) */
4681da177e4SLinus Torvalds if (mgr->board_type != MIXART_DAUGHTER_TYPE_AES )
4691da177e4SLinus Torvalds return -EINVAL;
4701da177e4SLinus Torvalds
4711da177e4SLinus Torvalds /* daughter should be idle */
4721da177e4SLinus Torvalds if (status_daught != 0) {
4736414e35dSTakashi Iwai dev_err(&mgr->pci->dev,
4746414e35dSTakashi Iwai "daughter load error ! status = %d\n",
475ee419653STakashi Iwai status_daught);
4761da177e4SLinus Torvalds return -EIO; /* modprob -r may help ? */
4771da177e4SLinus Torvalds }
4781da177e4SLinus Torvalds
4791da177e4SLinus Torvalds /* check daughterboard xilinx validity */
480da3cec35STakashi Iwai if (((u32*)(dsp->data))[0] == 0xffffffff)
481da3cec35STakashi Iwai return -EINVAL;
482da3cec35STakashi Iwai if (dsp->size % 4)
483da3cec35STakashi Iwai return -EINVAL;
4841da177e4SLinus Torvalds
4851da177e4SLinus Torvalds /* inform mixart about the size of the file */
4861da177e4SLinus Torvalds writel_be( dsp->size, MIXART_MEM( mgr, MIXART_PSEUDOREG_DXLX_SIZE_OFFSET ));
4871da177e4SLinus Torvalds
4881da177e4SLinus Torvalds /* set daughterboard status to 1 */
4891da177e4SLinus Torvalds writel_be( 1, MIXART_MEM( mgr, MIXART_PSEUDOREG_DXLX_STATUS_OFFSET ));
4901da177e4SLinus Torvalds
4911da177e4SLinus Torvalds /* wait for status == 2 */
4921da177e4SLinus Torvalds err = mixart_wait_nice_for_register_value( mgr, MIXART_PSEUDOREG_DXLX_STATUS_OFFSET, 1, 2, 30); /* 300msec */
4931da177e4SLinus Torvalds if (err < 0) {
4946414e35dSTakashi Iwai dev_err(&mgr->pci->dev, "daughter board load error\n");
4951da177e4SLinus Torvalds return err;
4961da177e4SLinus Torvalds }
4971da177e4SLinus Torvalds
4981da177e4SLinus Torvalds /* get the address where to write the file */
4991da177e4SLinus Torvalds val = readl_be( MIXART_MEM( mgr, MIXART_PSEUDOREG_DXLX_BASE_ADDR_OFFSET ));
500da3cec35STakashi Iwai if (!val)
501da3cec35STakashi Iwai return -EINVAL;
5021da177e4SLinus Torvalds
5031da177e4SLinus Torvalds /* copy daughterboard xilinx code */
5041da177e4SLinus Torvalds memcpy_toio( MIXART_MEM( mgr, val), dsp->data, dsp->size);
5051da177e4SLinus Torvalds
5061da177e4SLinus Torvalds /* set daughterboard status to 4 */
5071da177e4SLinus Torvalds writel_be( 4, MIXART_MEM( mgr, MIXART_PSEUDOREG_DXLX_STATUS_OFFSET ));
5081da177e4SLinus Torvalds
5091da177e4SLinus Torvalds /* continue with init */
5101da177e4SLinus Torvalds break;
5111da177e4SLinus Torvalds } /* end of switch file index*/
5121da177e4SLinus Torvalds
5131da177e4SLinus Torvalds /* wait for daughter status == 3 */
5141da177e4SLinus Torvalds err = mixart_wait_nice_for_register_value( mgr, MIXART_PSEUDOREG_DXLX_STATUS_OFFSET, 1, 3, 300); /* 3sec */
5151da177e4SLinus Torvalds if (err < 0) {
5166414e35dSTakashi Iwai dev_err(&mgr->pci->dev,
517ee419653STakashi Iwai "daughter board could not be initialised\n");
5181da177e4SLinus Torvalds return err;
5191da177e4SLinus Torvalds }
5201da177e4SLinus Torvalds
5211da177e4SLinus Torvalds /* init mailbox (communication with embedded) */
5221da177e4SLinus Torvalds snd_mixart_init_mailbox(mgr);
5231da177e4SLinus Torvalds
5241da177e4SLinus Torvalds /* first communication with embedded */
5251da177e4SLinus Torvalds err = mixart_first_init(mgr);
5261da177e4SLinus Torvalds if (err < 0) {
5276414e35dSTakashi Iwai dev_err(&mgr->pci->dev, "miXart could not be set up\n");
5281da177e4SLinus Torvalds return err;
5291da177e4SLinus Torvalds }
5301da177e4SLinus Torvalds
5311da177e4SLinus Torvalds /* create devices and mixer in accordance with HW options*/
5321da177e4SLinus Torvalds for (card_index = 0; card_index < mgr->num_cards; card_index++) {
53367b48b88STakashi Iwai struct snd_mixart *chip = mgr->chip[card_index];
5341da177e4SLinus Torvalds
535*73debecfSTakashi Iwai err = snd_mixart_create_pcm(chip);
536*73debecfSTakashi Iwai if (err < 0)
5371da177e4SLinus Torvalds return err;
5381da177e4SLinus Torvalds
5391da177e4SLinus Torvalds if (card_index == 0) {
540*73debecfSTakashi Iwai err = snd_mixart_create_mixer(chip->mgr);
541*73debecfSTakashi Iwai if (err < 0)
5421da177e4SLinus Torvalds return err;
5431da177e4SLinus Torvalds }
5441da177e4SLinus Torvalds
545*73debecfSTakashi Iwai err = snd_card_register(chip->card);
546*73debecfSTakashi Iwai if (err < 0)
5471da177e4SLinus Torvalds return err;
548395d9dd5SPeter Senna Tschudin }
5491da177e4SLinus Torvalds
5506414e35dSTakashi Iwai dev_dbg(&mgr->pci->dev,
5516414e35dSTakashi Iwai "miXart firmware downloaded and successfully set up\n");
5521da177e4SLinus Torvalds
5531da177e4SLinus Torvalds return 0;
5541da177e4SLinus Torvalds }
5551da177e4SLinus Torvalds
5561da177e4SLinus Torvalds
snd_mixart_setup_firmware(struct mixart_mgr * mgr)55767b48b88STakashi Iwai int snd_mixart_setup_firmware(struct mixart_mgr *mgr)
5581da177e4SLinus Torvalds {
5593cfe54b9STakashi Iwai static const char * const fw_files[3] = {
5601da177e4SLinus Torvalds "miXart8.xlx", "miXart8.elf", "miXart8AES.xlx"
5611da177e4SLinus Torvalds };
5621da177e4SLinus Torvalds char path[32];
5631da177e4SLinus Torvalds
5641da177e4SLinus Torvalds const struct firmware *fw_entry;
5651da177e4SLinus Torvalds int i, err;
5661da177e4SLinus Torvalds
5671da177e4SLinus Torvalds for (i = 0; i < 3; i++) {
5681da177e4SLinus Torvalds sprintf(path, "mixart/%s", fw_files[i]);
5691da177e4SLinus Torvalds if (request_firmware(&fw_entry, path, &mgr->pci->dev)) {
5706414e35dSTakashi Iwai dev_err(&mgr->pci->dev,
5716414e35dSTakashi Iwai "miXart: can't load firmware %s\n", path);
5721da177e4SLinus Torvalds return -ENOENT;
5731da177e4SLinus Torvalds }
5741da177e4SLinus Torvalds /* fake hwdep dsp record */
5751da177e4SLinus Torvalds err = mixart_dsp_load(mgr, i, fw_entry);
5761da177e4SLinus Torvalds release_firmware(fw_entry);
5771da177e4SLinus Torvalds if (err < 0)
5781da177e4SLinus Torvalds return err;
5791da177e4SLinus Torvalds mgr->dsp_loaded |= 1 << i;
5801da177e4SLinus Torvalds }
5811da177e4SLinus Torvalds return 0;
5821da177e4SLinus Torvalds }
5831da177e4SLinus Torvalds
5847e0af29dSClemens Ladisch MODULE_FIRMWARE("mixart/miXart8.xlx");
5857e0af29dSClemens Ladisch MODULE_FIRMWARE("mixart/miXart8.elf");
5867e0af29dSClemens Ladisch MODULE_FIRMWARE("mixart/miXart8AES.xlx");
587