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

TOMOYO Linux Cross Reference
Linux/sound/pci/mixart/mixart_hwdep.c

Version: ~ [ linux-5.6-rc7 ] ~ [ linux-5.5.11 ] ~ [ linux-5.4.27 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.112 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.174 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.217 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.217 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.82 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * Driver for Digigram miXart soundcards
  3  *
  4  * DSP firmware management
  5  *
  6  * Copyright (c) 2003 by Digigram <alsa@digigram.com>
  7  *
  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.
 12  *
 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.
 17  *
 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
 21  */
 22 
 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>
 29 #include <linux/io.h>
 30 #include <sound/core.h>
 31 #include "mixart.h"
 32 #include "mixart_mixer.h"
 33 #include "mixart_core.h"
 34 #include "mixart_hwdep.h"
 35 
 36 
 37 /**
 38  * wait for a value on a peudo register, exit with a timeout
 39  *
 40  * @mgr: pointer to miXart manager structure
 41  * @offset: unsigned pseudo_register base + offset of value
 42  * @is_egal: wait for the equal value
 43  * @value: value
 44  * @timeout: timeout in centisenconds
 45  */
 46 static int mixart_wait_nice_for_register_value(struct mixart_mgr *mgr,
 47                                                u32 offset, int is_egal,
 48                                                u32 value, unsigned long timeout)
 49 {
 50         unsigned long end_time = jiffies + (timeout * HZ / 100);
 51         u32 read;
 52 
 53         do {    /* we may take too long time in this loop.
 54                  * so give controls back to kernel if needed.
 55                  */
 56                 cond_resched();
 57 
 58                 read = readl_be( MIXART_MEM( mgr, offset ));
 59                 if(is_egal) {
 60                         if(read == value) return 0;
 61                 }
 62                 else { /* wait for different value */
 63                         if(read != value) return 0;
 64                 }
 65         } while ( time_after_eq(end_time, jiffies) );
 66 
 67         return -EBUSY;
 68 }
 69 
 70 
 71 /*
 72   structures needed to upload elf code packets 
 73  */
 74 struct snd_mixart_elf32_ehdr {
 75         u8      e_ident[16];
 76         __be16  e_type;
 77         __be16  e_machine;
 78         __be32  e_version;
 79         __be32  e_entry;
 80         __be32  e_phoff;
 81         __be32  e_shoff;
 82         __be32  e_flags;
 83         __be16  e_ehsize;
 84         __be16  e_phentsize;
 85         __be16  e_phnum;
 86         __be16  e_shentsize;
 87         __be16  e_shnum;
 88         __be16  e_shstrndx;
 89 };
 90 
 91 struct snd_mixart_elf32_phdr {
 92         __be32  p_type;
 93         __be32  p_offset;
 94         __be32  p_vaddr;
 95         __be32  p_paddr;
 96         __be32  p_filesz;
 97         __be32  p_memsz;
 98         __be32  p_flags;
 99         __be32  p_align;
100 };
101 
102 static int mixart_load_elf(struct mixart_mgr *mgr, const struct firmware *dsp )
103 {
104         char                    elf32_magic_number[4] = {0x7f,'E','L','F'};
105         struct snd_mixart_elf32_ehdr *elf_header;
106         int                     i;
107 
108         elf_header = (struct snd_mixart_elf32_ehdr *)dsp->data;
109         for( i=0; i<4; i++ )
110                 if ( elf32_magic_number[i] != elf_header->e_ident[i] )
111                         return -EINVAL;
112 
113         if( elf_header->e_phoff != 0 ) {
114                 struct snd_mixart_elf32_phdr     elf_programheader;
115 
116                 for( i=0; i < be16_to_cpu(elf_header->e_phnum); i++ ) {
117                         u32 pos = be32_to_cpu(elf_header->e_phoff) + (u32)(i * be16_to_cpu(elf_header->e_phentsize));
118 
119                         memcpy( &elf_programheader, dsp->data + pos, sizeof(elf_programheader) );
120 
121                         if(elf_programheader.p_type != 0) {
122                                 if( elf_programheader.p_filesz != 0 ) {
123                                         memcpy_toio( MIXART_MEM( mgr, be32_to_cpu(elf_programheader.p_vaddr)),
124                                                      dsp->data + be32_to_cpu( elf_programheader.p_offset ),
125                                                      be32_to_cpu( elf_programheader.p_filesz ));
126                                 }
127                         }
128                 }
129         }
130         return 0;
131 }
132 
133 /*
134  * get basic information and init miXart
135  */
136 
137 /* audio IDs for request to the board */
138 #define MIXART_FIRST_ANA_AUDIO_ID       0
139 #define MIXART_FIRST_DIG_AUDIO_ID       8
140 
141 static int mixart_enum_connectors(struct mixart_mgr *mgr)
142 {
143         u32 k;
144         int err;
145         struct mixart_msg request;
146         struct mixart_enum_connector_resp *connector;
147         struct mixart_audio_info_req  *audio_info_req;
148         struct mixart_audio_info_resp *audio_info;
149 
150         connector = kmalloc(sizeof(*connector), GFP_KERNEL);
151         audio_info_req = kmalloc(sizeof(*audio_info_req), GFP_KERNEL);
152         audio_info = kmalloc(sizeof(*audio_info), GFP_KERNEL);
153         if (! connector || ! audio_info_req || ! audio_info) {
154                 err = -ENOMEM;
155                 goto __error;
156         }
157 
158         audio_info_req->line_max_level = MIXART_FLOAT_P_22_0_TO_HEX;
159         audio_info_req->micro_max_level = MIXART_FLOAT_M_20_0_TO_HEX;
160         audio_info_req->cd_max_level = MIXART_FLOAT____0_0_TO_HEX;
161 
162         request.message_id = MSG_SYSTEM_ENUM_PLAY_CONNECTOR;
163         request.uid = (struct mixart_uid){0,0};  /* board num = 0 */
164         request.data = NULL;
165         request.size = 0;
166 
167         err = snd_mixart_send_msg(mgr, &request, sizeof(*connector), connector);
168         if((err < 0) || (connector->error_code) || (connector->uid_count > MIXART_MAX_PHYS_CONNECTORS)) {
169                 dev_err(&mgr->pci->dev,
170                         "error MSG_SYSTEM_ENUM_PLAY_CONNECTOR\n");
171                 err = -EINVAL;
172                 goto __error;
173         }
174 
175         for(k=0; k < connector->uid_count; k++) {
176                 struct mixart_pipe *pipe;
177 
178                 if(k < MIXART_FIRST_DIG_AUDIO_ID) {
179                         pipe = &mgr->chip[k/2]->pipe_out_ana;
180                 } else {
181                         pipe = &mgr->chip[(k-MIXART_FIRST_DIG_AUDIO_ID)/2]->pipe_out_dig;
182                 }
183                 if(k & 1) {
184                         pipe->uid_right_connector = connector->uid[k];   /* odd */
185                 } else {
186                         pipe->uid_left_connector = connector->uid[k];    /* even */
187                 }
188 
189                 /* dev_dbg(&mgr->pci->dev, "playback connector[%d].object_id = %x\n", k, connector->uid[k].object_id); */
190 
191                 /* TODO: really need send_msg MSG_CONNECTOR_GET_AUDIO_INFO for each connector ? perhaps for analog level caps ? */
192                 request.message_id = MSG_CONNECTOR_GET_AUDIO_INFO;
193                 request.uid = connector->uid[k];
194                 request.data = audio_info_req;
195                 request.size = sizeof(*audio_info_req);
196 
197                 err = snd_mixart_send_msg(mgr, &request, sizeof(*audio_info), audio_info);
198                 if( err < 0 ) {
199                         dev_err(&mgr->pci->dev,
200                                 "error MSG_CONNECTOR_GET_AUDIO_INFO\n");
201                         goto __error;
202                 }
203                 /*dev_dbg(&mgr->pci->dev, "play  analog_info.analog_level_present = %x\n", audio_info->info.analog_info.analog_level_present);*/
204         }
205 
206         request.message_id = MSG_SYSTEM_ENUM_RECORD_CONNECTOR;
207         request.uid = (struct mixart_uid){0,0};  /* board num = 0 */
208         request.data = NULL;
209         request.size = 0;
210 
211         err = snd_mixart_send_msg(mgr, &request, sizeof(*connector), connector);
212         if((err < 0) || (connector->error_code) || (connector->uid_count > MIXART_MAX_PHYS_CONNECTORS)) {
213                 dev_err(&mgr->pci->dev,
214                         "error MSG_SYSTEM_ENUM_RECORD_CONNECTOR\n");
215                 err = -EINVAL;
216                 goto __error;
217         }
218 
219         for(k=0; k < connector->uid_count; k++) {
220                 struct mixart_pipe *pipe;
221 
222                 if(k < MIXART_FIRST_DIG_AUDIO_ID) {
223                         pipe = &mgr->chip[k/2]->pipe_in_ana;
224                 } else {
225                         pipe = &mgr->chip[(k-MIXART_FIRST_DIG_AUDIO_ID)/2]->pipe_in_dig;
226                 }
227                 if(k & 1) {
228                         pipe->uid_right_connector = connector->uid[k];   /* odd */
229                 } else {
230                         pipe->uid_left_connector = connector->uid[k];    /* even */
231                 }
232 
233                 /* dev_dbg(&mgr->pci->dev, "capture connector[%d].object_id = %x\n", k, connector->uid[k].object_id); */
234 
235                 /* TODO: really need send_msg MSG_CONNECTOR_GET_AUDIO_INFO for each connector ? perhaps for analog level caps ? */
236                 request.message_id = MSG_CONNECTOR_GET_AUDIO_INFO;
237                 request.uid = connector->uid[k];
238                 request.data = audio_info_req;
239                 request.size = sizeof(*audio_info_req);
240 
241                 err = snd_mixart_send_msg(mgr, &request, sizeof(*audio_info), audio_info);
242                 if( err < 0 ) {
243                         dev_err(&mgr->pci->dev,
244                                 "error MSG_CONNECTOR_GET_AUDIO_INFO\n");
245                         goto __error;
246                 }
247                 /*dev_dbg(&mgr->pci->dev, "rec  analog_info.analog_level_present = %x\n", audio_info->info.analog_info.analog_level_present);*/
248         }
249         err = 0;
250 
251  __error:
252         kfree(connector);
253         kfree(audio_info_req);
254         kfree(audio_info);
255 
256         return err;
257 }
258 
259 static int mixart_enum_physio(struct mixart_mgr *mgr)
260 {
261         u32 k;
262         int err;
263         struct mixart_msg request;
264         struct mixart_uid get_console_mgr;
265         struct mixart_return_uid console_mgr;
266         struct mixart_uid_enumeration phys_io;
267 
268         /* get the uid for the console manager */
269         get_console_mgr.object_id = 0;
270         get_console_mgr.desc = MSG_CONSOLE_MANAGER | 0; /* cardindex = 0 */
271 
272         request.message_id = MSG_CONSOLE_GET_CLOCK_UID;
273         request.uid = get_console_mgr;
274         request.data = &get_console_mgr;
275         request.size = sizeof(get_console_mgr);
276 
277         err = snd_mixart_send_msg(mgr, &request, sizeof(console_mgr), &console_mgr);
278 
279         if( (err < 0) || (console_mgr.error_code != 0) ) {
280                 dev_dbg(&mgr->pci->dev,
281                         "error MSG_CONSOLE_GET_CLOCK_UID : err=%x\n",
282                         console_mgr.error_code);
283                 return -EINVAL;
284         }
285 
286         /* used later for clock issues ! */
287         mgr->uid_console_manager = console_mgr.uid;
288 
289         request.message_id = MSG_SYSTEM_ENUM_PHYSICAL_IO;
290         request.uid = (struct mixart_uid){0,0};
291         request.data = &console_mgr.uid;
292         request.size = sizeof(console_mgr.uid);
293 
294         err = snd_mixart_send_msg(mgr, &request, sizeof(phys_io), &phys_io);
295         if( (err < 0) || ( phys_io.error_code != 0 ) ) {
296                 dev_err(&mgr->pci->dev,
297                         "error MSG_SYSTEM_ENUM_PHYSICAL_IO err(%x) error_code(%x)\n",
298                         err, phys_io.error_code);
299                 return -EINVAL;
300         }
301 
302         /* min 2 phys io per card (analog in + analog out) */
303         if (phys_io.nb_uid < MIXART_MAX_CARDS * 2)
304                 return -EINVAL;
305 
306         for(k=0; k<mgr->num_cards; k++) {
307                 mgr->chip[k]->uid_in_analog_physio = phys_io.uid[k];
308                 mgr->chip[k]->uid_out_analog_physio = phys_io.uid[phys_io.nb_uid/2 + k]; 
309         }
310 
311         return 0;
312 }
313 
314 
315 static int mixart_first_init(struct mixart_mgr *mgr)
316 {
317         u32 k;
318         int err;
319         struct mixart_msg request;
320 
321         if((err = mixart_enum_connectors(mgr)) < 0) return err;
322 
323         if((err = mixart_enum_physio(mgr)) < 0) return err;
324 
325         /* send a synchro command to card (necessary to do this before first MSG_STREAM_START_STREAM_GRP_PACKET) */
326         /* though why not here */
327         request.message_id = MSG_SYSTEM_SEND_SYNCHRO_CMD;
328         request.uid = (struct mixart_uid){0,0};
329         request.data = NULL;
330         request.size = 0;
331         /* this command has no data. response is a 32 bit status */
332         err = snd_mixart_send_msg(mgr, &request, sizeof(k), &k);
333         if( (err < 0) || (k != 0) ) {
334                 dev_err(&mgr->pci->dev, "error MSG_SYSTEM_SEND_SYNCHRO_CMD\n");
335                 return err == 0 ? -EINVAL : err;
336         }
337 
338         return 0;
339 }
340 
341 
342 /* firmware base addresses (when hard coded) */
343 #define MIXART_MOTHERBOARD_XLX_BASE_ADDRESS   0x00600000
344 
345 static int mixart_dsp_load(struct mixart_mgr* mgr, int index, const struct firmware *dsp)
346 {
347         int           err, card_index;
348         u32           status_xilinx, status_elf, status_daught;
349         u32           val;
350 
351         /* read motherboard xilinx status */
352         status_xilinx = readl_be( MIXART_MEM( mgr,MIXART_PSEUDOREG_MXLX_STATUS_OFFSET ));
353         /* read elf status */
354         status_elf = readl_be( MIXART_MEM( mgr,MIXART_PSEUDOREG_ELF_STATUS_OFFSET ));
355         /* read daughterboard xilinx status */
356         status_daught = readl_be( MIXART_MEM( mgr,MIXART_PSEUDOREG_DXLX_STATUS_OFFSET ));
357 
358         /* motherboard xilinx status 5 will say that the board is performing a reset */
359         if (status_xilinx == 5) {
360                 dev_err(&mgr->pci->dev, "miXart is resetting !\n");
361                 return -EAGAIN; /* try again later */
362         }
363 
364         switch (index)   {
365         case MIXART_MOTHERBOARD_XLX_INDEX:
366 
367                 /* xilinx already loaded ? */ 
368                 if (status_xilinx == 4) {
369                         dev_dbg(&mgr->pci->dev, "xilinx is already loaded !\n");
370                         return 0;
371                 }
372                 /* the status should be 0 == "idle" */
373                 if (status_xilinx != 0) {
374                         dev_err(&mgr->pci->dev,
375                                 "xilinx load error ! status = %d\n",
376                                    status_xilinx);
377                         return -EIO; /* modprob -r may help ? */
378                 }
379 
380                 /* check xilinx validity */
381                 if (((u32*)(dsp->data))[0] == 0xffffffff)
382                         return -EINVAL;
383                 if (dsp->size % 4)
384                         return -EINVAL;
385 
386                 /* set xilinx status to copying */
387                 writel_be( 1, MIXART_MEM( mgr, MIXART_PSEUDOREG_MXLX_STATUS_OFFSET ));
388 
389                 /* setup xilinx base address */
390                 writel_be( MIXART_MOTHERBOARD_XLX_BASE_ADDRESS, MIXART_MEM( mgr,MIXART_PSEUDOREG_MXLX_BASE_ADDR_OFFSET ));
391                 /* setup code size for xilinx file */
392                 writel_be( dsp->size, MIXART_MEM( mgr, MIXART_PSEUDOREG_MXLX_SIZE_OFFSET ));
393 
394                 /* copy xilinx code */
395                 memcpy_toio(  MIXART_MEM( mgr, MIXART_MOTHERBOARD_XLX_BASE_ADDRESS),  dsp->data,  dsp->size);
396     
397                 /* set xilinx status to copy finished */
398                 writel_be( 2, MIXART_MEM( mgr, MIXART_PSEUDOREG_MXLX_STATUS_OFFSET ));
399 
400                 /* return, because no further processing needed */
401                 return 0;
402 
403         case MIXART_MOTHERBOARD_ELF_INDEX:
404 
405                 if (status_elf == 4) {
406                         dev_dbg(&mgr->pci->dev, "elf file already loaded !\n");
407                         return 0;
408                 }
409 
410                 /* the status should be 0 == "idle" */
411                 if (status_elf != 0) {
412                         dev_err(&mgr->pci->dev,
413                                 "elf load error ! status = %d\n",
414                                    status_elf);
415                         return -EIO; /* modprob -r may help ? */
416                 }
417 
418                 /* wait for xilinx status == 4 */
419                 err = mixart_wait_nice_for_register_value( mgr, MIXART_PSEUDOREG_MXLX_STATUS_OFFSET, 1, 4, 500); /* 5sec */
420                 if (err < 0) {
421                         dev_err(&mgr->pci->dev, "xilinx was not loaded or "
422                                    "could not be started\n");
423                         return err;
424                 }
425 
426                 /* init some data on the card */
427                 writel_be( 0, MIXART_MEM( mgr, MIXART_PSEUDOREG_BOARDNUMBER ) ); /* set miXart boardnumber to 0 */
428                 writel_be( 0, MIXART_MEM( mgr, MIXART_FLOWTABLE_PTR ) );         /* reset pointer to flow table on miXart */
429 
430                 /* set elf status to copying */
431                 writel_be( 1, MIXART_MEM( mgr, MIXART_PSEUDOREG_ELF_STATUS_OFFSET ));
432 
433                 /* process the copying of the elf packets */
434                 err = mixart_load_elf( mgr, dsp );
435                 if (err < 0) return err;
436 
437                 /* set elf status to copy finished */
438                 writel_be( 2, MIXART_MEM( mgr, MIXART_PSEUDOREG_ELF_STATUS_OFFSET ));
439 
440                 /* wait for elf status == 4 */
441                 err = mixart_wait_nice_for_register_value( mgr, MIXART_PSEUDOREG_ELF_STATUS_OFFSET, 1, 4, 300); /* 3sec */
442                 if (err < 0) {
443                         dev_err(&mgr->pci->dev, "elf could not be started\n");
444                         return err;
445                 }
446 
447                 /* miXart waits at this point on the pointer to the flow table */
448                 writel_be( (u32)mgr->flowinfo.addr, MIXART_MEM( mgr, MIXART_FLOWTABLE_PTR ) ); /* give pointer of flow table to miXart */
449 
450                 return 0;  /* return, another xilinx file has to be loaded before */
451 
452         case MIXART_AESEBUBOARD_XLX_INDEX:
453         default:
454 
455                 /* elf and xilinx should be loaded */
456                 if (status_elf != 4 || status_xilinx != 4) {
457                         dev_err(&mgr->pci->dev, "xilinx or elf not "
458                                "successfully loaded\n");
459                         return -EIO; /* modprob -r may help ? */
460                 }
461 
462                 /* wait for daughter detection != 0 */
463                 err = mixart_wait_nice_for_register_value( mgr, MIXART_PSEUDOREG_DBRD_PRESENCE_OFFSET, 0, 0, 30); /* 300msec */
464                 if (err < 0) {
465                         dev_err(&mgr->pci->dev, "error starting elf file\n");
466                         return err;
467                 }
468 
469                 /* the board type can now be retrieved */
470                 mgr->board_type = (DAUGHTER_TYPE_MASK & readl_be( MIXART_MEM( mgr, MIXART_PSEUDOREG_DBRD_TYPE_OFFSET)));
471 
472                 if (mgr->board_type == MIXART_DAUGHTER_TYPE_NONE)
473                         break;  /* no daughter board; the file does not have to be loaded, continue after the switch */
474 
475                 /* only if aesebu daughter board presence (elf code must run)  */ 
476                 if (mgr->board_type != MIXART_DAUGHTER_TYPE_AES )
477                         return -EINVAL;
478 
479                 /* daughter should be idle */
480                 if (status_daught != 0) {
481                         dev_err(&mgr->pci->dev,
482                                 "daughter load error ! status = %d\n",
483                                status_daught);
484                         return -EIO; /* modprob -r may help ? */
485                 }
486  
487                 /* check daughterboard xilinx validity */
488                 if (((u32*)(dsp->data))[0] == 0xffffffff)
489                         return -EINVAL;
490                 if (dsp->size % 4)
491                         return -EINVAL;
492 
493                 /* inform mixart about the size of the file */
494                 writel_be( dsp->size, MIXART_MEM( mgr, MIXART_PSEUDOREG_DXLX_SIZE_OFFSET ));
495 
496                 /* set daughterboard status to 1 */
497                 writel_be( 1, MIXART_MEM( mgr, MIXART_PSEUDOREG_DXLX_STATUS_OFFSET ));
498 
499                 /* wait for status == 2 */
500                 err = mixart_wait_nice_for_register_value( mgr, MIXART_PSEUDOREG_DXLX_STATUS_OFFSET, 1, 2, 30); /* 300msec */
501                 if (err < 0) {
502                         dev_err(&mgr->pci->dev, "daughter board load error\n");
503                         return err;
504                 }
505 
506                 /* get the address where to write the file */
507                 val = readl_be( MIXART_MEM( mgr, MIXART_PSEUDOREG_DXLX_BASE_ADDR_OFFSET ));
508                 if (!val)
509                         return -EINVAL;
510 
511                 /* copy daughterboard xilinx code */
512                 memcpy_toio(  MIXART_MEM( mgr, val),  dsp->data,  dsp->size);
513 
514                 /* set daughterboard status to 4 */
515                 writel_be( 4, MIXART_MEM( mgr, MIXART_PSEUDOREG_DXLX_STATUS_OFFSET ));
516 
517                 /* continue with init */
518                 break;
519         } /* end of switch file index*/
520 
521         /* wait for daughter status == 3 */
522         err = mixart_wait_nice_for_register_value( mgr, MIXART_PSEUDOREG_DXLX_STATUS_OFFSET, 1, 3, 300); /* 3sec */
523         if (err < 0) {
524                 dev_err(&mgr->pci->dev,
525                            "daughter board could not be initialised\n");
526                 return err;
527         }
528 
529         /* init mailbox (communication with embedded) */
530         snd_mixart_init_mailbox(mgr);
531 
532         /* first communication with embedded */
533         err = mixart_first_init(mgr);
534         if (err < 0) {
535                 dev_err(&mgr->pci->dev, "miXart could not be set up\n");
536                 return err;
537         }
538 
539         /* create devices and mixer in accordance with HW options*/
540         for (card_index = 0; card_index < mgr->num_cards; card_index++) {
541                 struct snd_mixart *chip = mgr->chip[card_index];
542 
543                 if ((err = snd_mixart_create_pcm(chip)) < 0)
544                         return err;
545 
546                 if (card_index == 0) {
547                         if ((err = snd_mixart_create_mixer(chip->mgr)) < 0)
548                                 return err;
549                 }
550 
551                 if ((err = snd_card_register(chip->card)) < 0)
552                         return err;
553         }
554 
555         dev_dbg(&mgr->pci->dev,
556                 "miXart firmware downloaded and successfully set up\n");
557 
558         return 0;
559 }
560 
561 
562 int snd_mixart_setup_firmware(struct mixart_mgr *mgr)
563 {
564         static char *fw_files[3] = {
565                 "miXart8.xlx", "miXart8.elf", "miXart8AES.xlx"
566         };
567         char path[32];
568 
569         const struct firmware *fw_entry;
570         int i, err;
571 
572         for (i = 0; i < 3; i++) {
573                 sprintf(path, "mixart/%s", fw_files[i]);
574                 if (request_firmware(&fw_entry, path, &mgr->pci->dev)) {
575                         dev_err(&mgr->pci->dev,
576                                 "miXart: can't load firmware %s\n", path);
577                         return -ENOENT;
578                 }
579                 /* fake hwdep dsp record */
580                 err = mixart_dsp_load(mgr, i, fw_entry);
581                 release_firmware(fw_entry);
582                 if (err < 0)
583                         return err;
584                 mgr->dsp_loaded |= 1 << i;
585         }
586         return 0;
587 }
588 
589 MODULE_FIRMWARE("mixart/miXart8.xlx");
590 MODULE_FIRMWARE("mixart/miXart8.elf");
591 MODULE_FIRMWARE("mixart/miXart8AES.xlx");
592 

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

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

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

osdn.jp