2 * Driver for Digigram pcxhr compatible soundcards
4 * main file with alsa callbacks
6 * Copyright (c) 2004 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
24 #include <sound/driver.h>
25 #include <linux/init.h>
26 #include <linux/interrupt.h>
27 #include <linux/slab.h>
28 #include <linux/pci.h>
29 #include <linux/delay.h>
30 #include <linux/moduleparam.h>
31 #include <sound/core.h>
32 #include <sound/initval.h>
33 #include <sound/info.h>
34 #include <sound/control.h>
35 #include <sound/pcm.h>
36 #include <sound/pcm_params.h>
38 #include "pcxhr_mixer.h"
39 #include "pcxhr_hwdep.h"
40 #include "pcxhr_core.h"
42 #define DRIVER_NAME "pcxhr"
44 MODULE_AUTHOR("Markus Bollinger <bollinger@digigram.com>");
45 MODULE_DESCRIPTION("Digigram " DRIVER_NAME
" " PCXHR_DRIVER_VERSION_STRING
);
46 MODULE_LICENSE("GPL");
47 MODULE_SUPPORTED_DEVICE("{{Digigram," DRIVER_NAME
"}}");
49 static int index
[SNDRV_CARDS
] = SNDRV_DEFAULT_IDX
; /* Index 0-MAX */
50 static char *id
[SNDRV_CARDS
] = SNDRV_DEFAULT_STR
; /* ID for this card */
51 static int enable
[SNDRV_CARDS
] = SNDRV_DEFAULT_ENABLE_PNP
; /* Enable this card */
52 static int mono
[SNDRV_CARDS
]; /* capture in mono only */
54 module_param_array(index
, int, NULL
, 0444);
55 MODULE_PARM_DESC(index
, "Index value for Digigram " DRIVER_NAME
" soundcard");
56 module_param_array(id
, charp
, NULL
, 0444);
57 MODULE_PARM_DESC(id
, "ID string for Digigram " DRIVER_NAME
" soundcard");
58 module_param_array(enable
, bool, NULL
, 0444);
59 MODULE_PARM_DESC(enable
, "Enable Digigram " DRIVER_NAME
" soundcard");
60 module_param_array(mono
, bool, NULL
, 0444);
61 MODULE_PARM_DESC(mono
, "Mono capture mode (default is stereo)");
73 static struct pci_device_id pcxhr_ids
[] = {
74 { 0x10b5, 0x9656, 0x1369, 0xb001, 0, 0, PCI_ID_VX882HR
, }, /* VX882HR */
75 { 0x10b5, 0x9656, 0x1369, 0xb101, 0, 0, PCI_ID_PCX882HR
, }, /* PCX882HR */
76 { 0x10b5, 0x9656, 0x1369, 0xb201, 0, 0, PCI_ID_VX881HR
, }, /* VX881HR */
77 { 0x10b5, 0x9656, 0x1369, 0xb301, 0, 0, PCI_ID_PCX881HR
, }, /* PCX881HR */
78 { 0x10b5, 0x9656, 0x1369, 0xb501, 0, 0, PCI_ID_PCX1222HR
, }, /* PCX1222HR */
79 { 0x10b5, 0x9656, 0x1369, 0xb701, 0, 0, PCI_ID_PCX1221HR
, }, /* PCX1221HR */
83 MODULE_DEVICE_TABLE(pci
, pcxhr_ids
);
85 struct board_parameters
{
91 static struct board_parameters pcxhr_board_params
[] = {
92 [PCI_ID_VX882HR
] = { "VX882HR", 4, 4, 41, },
93 [PCI_ID_PCX882HR
] = { "PCX882HR", 4, 4, 41, },
94 [PCI_ID_VX881HR
] = { "VX881HR", 4, 4, 41, },
95 [PCI_ID_PCX881HR
] = { "PCX881HR", 4, 4, 41, },
96 [PCI_ID_PCX1222HR
] = { "PCX1222HR", 6, 1, 42, },
97 [PCI_ID_PCX1221HR
] = { "PCX1221HR", 6, 1, 42, },
101 static int pcxhr_pll_freq_register(unsigned int freq
, unsigned int* pllreg
,
102 unsigned int* realfreq
)
106 if (freq
< 6900 || freq
> 110250)
108 reg
= (28224000 * 10) / freq
;
109 reg
= (reg
+ 5) / 10;
111 *pllreg
= reg
+ 0x800;
112 else if (reg
< 0x400)
113 *pllreg
= reg
& 0x1ff;
114 else if (reg
< 0x800) {
115 *pllreg
= ((reg
>> 1) & 0x1ff) + 0x200;
118 *pllreg
= ((reg
>> 2) & 0x1ff) + 0x400;
122 *realfreq
= ((28224000 * 10) / reg
+ 5) / 10;
127 #define PCXHR_FREQ_REG_MASK 0x1f
128 #define PCXHR_FREQ_QUARTZ_48000 0x00
129 #define PCXHR_FREQ_QUARTZ_24000 0x01
130 #define PCXHR_FREQ_QUARTZ_12000 0x09
131 #define PCXHR_FREQ_QUARTZ_32000 0x08
132 #define PCXHR_FREQ_QUARTZ_16000 0x04
133 #define PCXHR_FREQ_QUARTZ_8000 0x0c
134 #define PCXHR_FREQ_QUARTZ_44100 0x02
135 #define PCXHR_FREQ_QUARTZ_22050 0x0a
136 #define PCXHR_FREQ_QUARTZ_11025 0x06
137 #define PCXHR_FREQ_PLL 0x05
138 #define PCXHR_FREQ_QUARTZ_192000 0x10
139 #define PCXHR_FREQ_QUARTZ_96000 0x18
140 #define PCXHR_FREQ_QUARTZ_176400 0x14
141 #define PCXHR_FREQ_QUARTZ_88200 0x1c
142 #define PCXHR_FREQ_QUARTZ_128000 0x12
143 #define PCXHR_FREQ_QUARTZ_64000 0x1a
145 #define PCXHR_FREQ_WORD_CLOCK 0x0f
146 #define PCXHR_FREQ_SYNC_AES 0x0e
147 #define PCXHR_FREQ_AES_1 0x07
148 #define PCXHR_FREQ_AES_2 0x0b
149 #define PCXHR_FREQ_AES_3 0x03
150 #define PCXHR_FREQ_AES_4 0x0d
152 #define PCXHR_MODIFY_CLOCK_S_BIT 0x04
154 #define PCXHR_IRQ_TIMER_FREQ 92000
155 #define PCXHR_IRQ_TIMER_PERIOD 48
157 static int pcxhr_get_clock_reg(struct pcxhr_mgr
*mgr
, unsigned int rate
,
158 unsigned int *reg
, unsigned int *freq
)
160 unsigned int val
, realfreq
, pllreg
;
161 struct pcxhr_rmh rmh
;
165 switch (mgr
->use_clock_type
) {
166 case PCXHR_CLOCK_TYPE_INTERNAL
: /* clock by quartz or pll */
168 case 48000 : val
= PCXHR_FREQ_QUARTZ_48000
; break;
169 case 24000 : val
= PCXHR_FREQ_QUARTZ_24000
; break;
170 case 12000 : val
= PCXHR_FREQ_QUARTZ_12000
; break;
171 case 32000 : val
= PCXHR_FREQ_QUARTZ_32000
; break;
172 case 16000 : val
= PCXHR_FREQ_QUARTZ_16000
; break;
173 case 8000 : val
= PCXHR_FREQ_QUARTZ_8000
; break;
174 case 44100 : val
= PCXHR_FREQ_QUARTZ_44100
; break;
175 case 22050 : val
= PCXHR_FREQ_QUARTZ_22050
; break;
176 case 11025 : val
= PCXHR_FREQ_QUARTZ_11025
; break;
177 case 192000 : val
= PCXHR_FREQ_QUARTZ_192000
; break;
178 case 96000 : val
= PCXHR_FREQ_QUARTZ_96000
; break;
179 case 176400 : val
= PCXHR_FREQ_QUARTZ_176400
; break;
180 case 88200 : val
= PCXHR_FREQ_QUARTZ_88200
; break;
181 case 128000 : val
= PCXHR_FREQ_QUARTZ_128000
; break;
182 case 64000 : val
= PCXHR_FREQ_QUARTZ_64000
; break;
184 val
= PCXHR_FREQ_PLL
;
185 /* get the value for the pll register */
186 err
= pcxhr_pll_freq_register(rate
, &pllreg
, &realfreq
);
189 pcxhr_init_rmh(&rmh
, CMD_ACCESS_IO_WRITE
);
190 rmh
.cmd
[0] |= IO_NUM_REG_GENCLK
;
191 rmh
.cmd
[1] = pllreg
& MASK_DSP_WORD
;
192 rmh
.cmd
[2] = pllreg
>> 24;
194 err
= pcxhr_send_msg(mgr
, &rmh
);
197 "error CMD_ACCESS_IO_WRITE for PLL register : %x!\n",
203 case PCXHR_CLOCK_TYPE_WORD_CLOCK
: val
= PCXHR_FREQ_WORD_CLOCK
; break;
204 case PCXHR_CLOCK_TYPE_AES_SYNC
: val
= PCXHR_FREQ_SYNC_AES
; break;
205 case PCXHR_CLOCK_TYPE_AES_1
: val
= PCXHR_FREQ_AES_1
; break;
206 case PCXHR_CLOCK_TYPE_AES_2
: val
= PCXHR_FREQ_AES_2
; break;
207 case PCXHR_CLOCK_TYPE_AES_3
: val
= PCXHR_FREQ_AES_3
; break;
208 case PCXHR_CLOCK_TYPE_AES_4
: val
= PCXHR_FREQ_AES_4
; break;
209 default : return -EINVAL
;
217 int pcxhr_set_clock(struct pcxhr_mgr
*mgr
, unsigned int rate
)
219 unsigned int val
, realfreq
, speed
;
220 struct pcxhr_rmh rmh
;
224 return 0; /* nothing to do */
226 err
= pcxhr_get_clock_reg(mgr
, rate
, &val
, &realfreq
);
230 /* codec speed modes */
232 speed
= 0; /* single speed */
233 else if (rate
< 100000)
234 speed
= 1; /* dual speed */
236 speed
= 2; /* quad speed */
237 if (mgr
->codec_speed
!= speed
) {
238 pcxhr_init_rmh(&rmh
, CMD_ACCESS_IO_WRITE
); /* mute outputs */
239 rmh
.cmd
[0] |= IO_NUM_REG_MUTE_OUT
;
240 err
= pcxhr_send_msg(mgr
, &rmh
);
244 pcxhr_init_rmh(&rmh
, CMD_ACCESS_IO_WRITE
); /* set speed ratio */
245 rmh
.cmd
[0] |= IO_NUM_SPEED_RATIO
;
248 err
= pcxhr_send_msg(mgr
, &rmh
);
252 /* set the new frequency */
253 snd_printdd("clock register : set %x\n", val
);
254 err
= pcxhr_write_io_num_reg_cont(mgr
, PCXHR_FREQ_REG_MASK
, val
, &changed
);
257 mgr
->sample_rate_real
= realfreq
;
258 mgr
->cur_clock_type
= mgr
->use_clock_type
;
260 /* unmute after codec speed modes */
261 if (mgr
->codec_speed
!= speed
) {
262 pcxhr_init_rmh(&rmh
, CMD_ACCESS_IO_READ
); /* unmute outputs */
263 rmh
.cmd
[0] |= IO_NUM_REG_MUTE_OUT
;
264 err
= pcxhr_send_msg(mgr
, &rmh
);
267 mgr
->codec_speed
= speed
; /* save new codec speed */
271 pcxhr_init_rmh(&rmh
, CMD_MODIFY_CLOCK
);
272 rmh
.cmd
[0] |= PCXHR_MODIFY_CLOCK_S_BIT
; /* resync fifos */
273 if (rate
< PCXHR_IRQ_TIMER_FREQ
)
274 rmh
.cmd
[1] = PCXHR_IRQ_TIMER_PERIOD
;
276 rmh
.cmd
[1] = PCXHR_IRQ_TIMER_PERIOD
* 2;
279 err
= pcxhr_send_msg(mgr
, &rmh
);
283 snd_printdd("pcxhr_set_clock to %dHz (realfreq=%d)\n", rate
, realfreq
);
288 int pcxhr_get_external_clock(struct pcxhr_mgr
*mgr
, enum pcxhr_clock_type clock_type
,
291 struct pcxhr_rmh rmh
;
295 switch (clock_type
) {
296 case PCXHR_CLOCK_TYPE_WORD_CLOCK
: reg
= REG_STATUS_WORD_CLOCK
; break;
297 case PCXHR_CLOCK_TYPE_AES_SYNC
: reg
= REG_STATUS_AES_SYNC
; break;
298 case PCXHR_CLOCK_TYPE_AES_1
: reg
= REG_STATUS_AES_1
; break;
299 case PCXHR_CLOCK_TYPE_AES_2
: reg
= REG_STATUS_AES_2
; break;
300 case PCXHR_CLOCK_TYPE_AES_3
: reg
= REG_STATUS_AES_3
; break;
301 case PCXHR_CLOCK_TYPE_AES_4
: reg
= REG_STATUS_AES_4
; break;
302 default : return -EINVAL
;
304 pcxhr_init_rmh(&rmh
, CMD_ACCESS_IO_READ
);
306 rmh
.cmd
[0] |= IO_NUM_REG_STATUS
;
307 if (mgr
->last_reg_stat
!= reg
) {
309 err
= pcxhr_send_msg(mgr
, &rmh
);
312 udelay(100); /* wait minimum 2 sample_frames at 32kHz ! */
313 mgr
->last_reg_stat
= reg
;
315 rmh
.cmd
[1] = REG_STATUS_CURRENT
;
316 err
= pcxhr_send_msg(mgr
, &rmh
);
319 switch (rmh
.stat
[1] & 0x0f) {
320 case REG_STATUS_SYNC_32000
: rate
= 32000; break;
321 case REG_STATUS_SYNC_44100
: rate
= 44100; break;
322 case REG_STATUS_SYNC_48000
: rate
= 48000; break;
323 case REG_STATUS_SYNC_64000
: rate
= 64000; break;
324 case REG_STATUS_SYNC_88200
: rate
= 88200; break;
325 case REG_STATUS_SYNC_96000
: rate
= 96000; break;
326 case REG_STATUS_SYNC_128000
: rate
= 128000; break;
327 case REG_STATUS_SYNC_176400
: rate
= 176400; break;
328 case REG_STATUS_SYNC_192000
: rate
= 192000; break;
331 snd_printdd("External clock is at %d Hz\n", rate
);
338 * start or stop playback/capture substream
340 static int pcxhr_set_stream_state(struct pcxhr_stream
*stream
)
343 struct snd_pcxhr
*chip
;
344 struct pcxhr_rmh rmh
;
345 int stream_mask
, start
;
347 if (stream
->status
== PCXHR_STREAM_STATUS_SCHEDULE_RUN
)
350 if (stream
->status
!= PCXHR_STREAM_STATUS_SCHEDULE_STOP
) {
351 snd_printk(KERN_ERR
"ERROR pcxhr_set_stream_state CANNOT be stopped\n");
356 if (!stream
->substream
)
359 stream
->timer_abs_periods
= 0;
360 stream
->timer_period_frag
= 0; /* reset theoretical stream pos */
361 stream
->timer_buf_periods
= 0;
362 stream
->timer_is_synced
= 0;
364 stream_mask
= stream
->pipe
->is_capture
? 1 : 1<<stream
->substream
->number
;
366 pcxhr_init_rmh(&rmh
, start
? CMD_START_STREAM
: CMD_STOP_STREAM
);
367 pcxhr_set_pipe_cmd_params(&rmh
, stream
->pipe
->is_capture
,
368 stream
->pipe
->first_audio
, 0, stream_mask
);
370 chip
= snd_pcm_substream_chip(stream
->substream
);
372 err
= pcxhr_send_msg(chip
->mgr
, &rmh
);
374 snd_printk(KERN_ERR
"ERROR pcxhr_set_stream_state err=%x;\n", err
);
375 stream
->status
= start
? PCXHR_STREAM_STATUS_STARTED
: PCXHR_STREAM_STATUS_STOPPED
;
379 #define HEADER_FMT_BASE_LIN 0xfed00000
380 #define HEADER_FMT_BASE_FLOAT 0xfad00000
381 #define HEADER_FMT_INTEL 0x00008000
382 #define HEADER_FMT_24BITS 0x00004000
383 #define HEADER_FMT_16BITS 0x00002000
384 #define HEADER_FMT_UPTO11 0x00000200
385 #define HEADER_FMT_UPTO32 0x00000100
386 #define HEADER_FMT_MONO 0x00000080
388 static int pcxhr_set_format(struct pcxhr_stream
*stream
)
390 int err
, is_capture
, sample_rate
, stream_num
;
391 struct snd_pcxhr
*chip
;
392 struct pcxhr_rmh rmh
;
395 switch (stream
->format
) {
396 case SNDRV_PCM_FORMAT_U8
:
397 header
= HEADER_FMT_BASE_LIN
;
399 case SNDRV_PCM_FORMAT_S16_LE
:
400 header
= HEADER_FMT_BASE_LIN
| HEADER_FMT_16BITS
| HEADER_FMT_INTEL
;
402 case SNDRV_PCM_FORMAT_S16_BE
:
403 header
= HEADER_FMT_BASE_LIN
| HEADER_FMT_16BITS
;
405 case SNDRV_PCM_FORMAT_S24_3LE
:
406 header
= HEADER_FMT_BASE_LIN
| HEADER_FMT_24BITS
| HEADER_FMT_INTEL
;
408 case SNDRV_PCM_FORMAT_S24_3BE
:
409 header
= HEADER_FMT_BASE_LIN
| HEADER_FMT_24BITS
;
411 case SNDRV_PCM_FORMAT_FLOAT_LE
:
412 header
= HEADER_FMT_BASE_FLOAT
| HEADER_FMT_INTEL
;
415 snd_printk(KERN_ERR
"error pcxhr_set_format() : unknown format\n");
418 chip
= snd_pcm_substream_chip(stream
->substream
);
420 sample_rate
= chip
->mgr
->sample_rate
;
421 if (sample_rate
<= 32000 && sample_rate
!=0) {
422 if (sample_rate
<= 11025)
423 header
|= HEADER_FMT_UPTO11
;
425 header
|= HEADER_FMT_UPTO32
;
427 if (stream
->channels
== 1)
428 header
|= HEADER_FMT_MONO
;
430 is_capture
= stream
->pipe
->is_capture
;
431 stream_num
= is_capture
? 0 : stream
->substream
->number
;
433 pcxhr_init_rmh(&rmh
, is_capture
? CMD_FORMAT_STREAM_IN
: CMD_FORMAT_STREAM_OUT
);
434 pcxhr_set_pipe_cmd_params(&rmh
, is_capture
, stream
->pipe
->first_audio
, stream_num
, 0);
438 rmh
.cmd
[2] = header
>> 8;
439 rmh
.cmd
[3] = (header
& 0xff) << 16;
441 err
= pcxhr_send_msg(chip
->mgr
, &rmh
);
443 snd_printk(KERN_ERR
"ERROR pcxhr_set_format err=%x;\n", err
);
447 static int pcxhr_update_r_buffer(struct pcxhr_stream
*stream
)
449 int err
, is_capture
, stream_num
;
450 struct pcxhr_rmh rmh
;
451 struct snd_pcm_substream
*subs
= stream
->substream
;
452 struct snd_pcxhr
*chip
= snd_pcm_substream_chip(subs
);
454 is_capture
= (subs
->stream
== SNDRV_PCM_STREAM_CAPTURE
);
455 stream_num
= is_capture
? 0 : subs
->number
;
457 snd_printdd("pcxhr_update_r_buffer(pcm%c%d) : addr(%p) bytes(%x) subs(%d)\n",
458 is_capture
? 'c' : 'p',
459 chip
->chip_idx
, (void*)subs
->runtime
->dma_addr
,
460 subs
->runtime
->dma_bytes
, subs
->number
);
462 pcxhr_init_rmh(&rmh
, CMD_UPDATE_R_BUFFERS
);
463 pcxhr_set_pipe_cmd_params(&rmh
, is_capture
, stream
->pipe
->first_audio
, stream_num
, 0);
465 snd_assert(subs
->runtime
->dma_bytes
< 0x200000); /* max buffer size is 2 MByte */
466 rmh
.cmd
[1] = subs
->runtime
->dma_bytes
* 8; /* size in bits */
467 rmh
.cmd
[2] = subs
->runtime
->dma_addr
>> 24; /* most significant byte */
468 rmh
.cmd
[2] |= 1<<19; /* this is a circular buffer */
469 rmh
.cmd
[3] = subs
->runtime
->dma_addr
& MASK_DSP_WORD
; /* least 3 significant bytes */
471 err
= pcxhr_send_msg(chip
->mgr
, &rmh
);
473 snd_printk(KERN_ERR
"ERROR CMD_UPDATE_R_BUFFERS err=%x;\n", err
);
479 static int pcxhr_pipe_sample_count(struct pcxhr_stream
*stream
, snd_pcm_uframes_t
*sample_count
)
481 struct pcxhr_rmh rmh
;
483 pcxhr_t
*chip
= snd_pcm_substream_chip(stream
->substream
);
484 pcxhr_init_rmh(&rmh
, CMD_PIPE_SAMPLE_COUNT
);
485 pcxhr_set_pipe_cmd_params(&rmh
, stream
->pipe
->is_capture
, 0, 0,
486 1<<stream
->pipe
->first_audio
);
487 err
= pcxhr_send_msg(chip
->mgr
, &rmh
);
489 *sample_count
= ((snd_pcm_uframes_t
)rmh
.stat
[0]) << 24;
490 *sample_count
+= (snd_pcm_uframes_t
)rmh
.stat
[1];
492 snd_printdd("PIPE_SAMPLE_COUNT = %lx\n", *sample_count
);
497 static inline int pcxhr_stream_scheduled_get_pipe(struct pcxhr_stream
*stream
,
498 struct pcxhr_pipe
**pipe
)
500 if (stream
->status
== PCXHR_STREAM_STATUS_SCHEDULE_RUN
) {
501 *pipe
= stream
->pipe
;
507 static void pcxhr_trigger_tasklet(unsigned long arg
)
511 struct pcxhr_pipe
*pipe
;
512 struct snd_pcxhr
*chip
;
513 struct pcxhr_mgr
*mgr
= (struct pcxhr_mgr
*)(arg
);
514 int capture_mask
= 0;
515 int playback_mask
= 0;
517 #ifdef CONFIG_SND_DEBUG_DETECT
518 struct timeval my_tv1
, my_tv2
;
519 do_gettimeofday(&my_tv1
);
521 down(&mgr
->setup_mutex
);
523 /* check the pipes concerned and build pipe_array */
524 for (i
= 0; i
< mgr
->num_cards
; i
++) {
526 for (j
= 0; j
< chip
->nb_streams_capt
; j
++) {
527 if (pcxhr_stream_scheduled_get_pipe(&chip
->capture_stream
[j
], &pipe
))
528 capture_mask
|= (1 << pipe
->first_audio
);
530 for (j
= 0; j
< chip
->nb_streams_play
; j
++) {
531 if (pcxhr_stream_scheduled_get_pipe(&chip
->playback_stream
[j
], &pipe
)) {
532 playback_mask
|= (1 << pipe
->first_audio
);
533 break; /* add only once, as all playback streams of
534 * one chip use the same pipe
539 if (capture_mask
== 0 && playback_mask
== 0) {
540 up(&mgr
->setup_mutex
);
541 snd_printk(KERN_ERR
"pcxhr_trigger_tasklet : no pipes\n");
545 snd_printdd("pcxhr_trigger_tasklet : playback_mask=%x capture_mask=%x\n",
546 playback_mask
, capture_mask
);
548 /* synchronous stop of all the pipes concerned */
549 err
= pcxhr_set_pipe_state(mgr
, playback_mask
, capture_mask
, 0);
551 up(&mgr
->setup_mutex
);
552 snd_printk(KERN_ERR
"pcxhr_trigger_tasklet : error stop pipes (P%x C%x)\n",
553 playback_mask
, capture_mask
);
557 /* unfortunately the dsp lost format and buffer info with the stop pipe */
558 for (i
= 0; i
< mgr
->num_cards
; i
++) {
559 struct pcxhr_stream
*stream
;
561 for (j
= 0; j
< chip
->nb_streams_capt
; j
++) {
562 stream
= &chip
->capture_stream
[j
];
563 if (pcxhr_stream_scheduled_get_pipe(stream
, &pipe
)) {
564 err
= pcxhr_set_format(stream
);
565 err
= pcxhr_update_r_buffer(stream
);
568 for (j
= 0; j
< chip
->nb_streams_play
; j
++) {
569 stream
= &chip
->playback_stream
[j
];
570 if (pcxhr_stream_scheduled_get_pipe(stream
, &pipe
)) {
571 err
= pcxhr_set_format(stream
);
572 err
= pcxhr_update_r_buffer(stream
);
576 /* start all the streams */
577 for (i
= 0; i
< mgr
->num_cards
; i
++) {
578 struct pcxhr_stream
*stream
;
580 for (j
= 0; j
< chip
->nb_streams_capt
; j
++) {
581 stream
= &chip
->capture_stream
[j
];
582 if (pcxhr_stream_scheduled_get_pipe(stream
, &pipe
))
583 err
= pcxhr_set_stream_state(stream
);
585 for (j
= 0; j
< chip
->nb_streams_play
; j
++) {
586 stream
= &chip
->playback_stream
[j
];
587 if (pcxhr_stream_scheduled_get_pipe(stream
, &pipe
))
588 err
= pcxhr_set_stream_state(stream
);
592 /* synchronous start of all the pipes concerned */
593 err
= pcxhr_set_pipe_state(mgr
, playback_mask
, capture_mask
, 1);
595 up(&mgr
->setup_mutex
);
596 snd_printk(KERN_ERR
"pcxhr_trigger_tasklet : error start pipes (P%x C%x)\n",
597 playback_mask
, capture_mask
);
601 /* put the streams into the running state now (increment pointer by interrupt) */
602 spin_lock_irqsave(&mgr
->lock
, flags
);
603 for ( i
=0; i
< mgr
->num_cards
; i
++) {
604 struct pcxhr_stream
*stream
;
606 for(j
= 0; j
< chip
->nb_streams_capt
; j
++) {
607 stream
= &chip
->capture_stream
[j
];
608 if(stream
->status
== PCXHR_STREAM_STATUS_STARTED
)
609 stream
->status
= PCXHR_STREAM_STATUS_RUNNING
;
611 for (j
= 0; j
< chip
->nb_streams_play
; j
++) {
612 stream
= &chip
->playback_stream
[j
];
613 if (stream
->status
== PCXHR_STREAM_STATUS_STARTED
) {
614 /* playback will already have advanced ! */
615 stream
->timer_period_frag
+= PCXHR_GRANULARITY
;
616 stream
->status
= PCXHR_STREAM_STATUS_RUNNING
;
620 spin_unlock_irqrestore(&mgr
->lock
, flags
);
622 up(&mgr
->setup_mutex
);
624 #ifdef CONFIG_SND_DEBUG_DETECT
625 do_gettimeofday(&my_tv2
);
626 snd_printdd("***TRIGGER TASKLET*** TIME = %ld (err = %x)\n",
627 my_tv2
.tv_usec
- my_tv1
.tv_usec
, err
);
635 static int pcxhr_trigger(struct snd_pcm_substream
*subs
, int cmd
)
637 struct pcxhr_stream
*stream
;
638 struct list_head
*pos
;
639 struct snd_pcm_substream
*s
;
643 case SNDRV_PCM_TRIGGER_START
:
644 snd_printdd("SNDRV_PCM_TRIGGER_START\n");
646 snd_pcm_group_for_each(pos
, subs
) {
647 s
= snd_pcm_group_substream_entry(pos
);
648 stream
= s
->runtime
->private_data
;
649 stream
->status
= PCXHR_STREAM_STATUS_SCHEDULE_RUN
;
650 snd_pcm_trigger_done(s
, subs
);
654 snd_printdd("Only one Substream %c %d\n",
655 stream
->pipe
->is_capture
? 'C' : 'P',
656 stream
->pipe
->first_audio
);
657 if (pcxhr_set_format(stream
))
659 if (pcxhr_update_r_buffer(stream
))
662 if (pcxhr_set_stream_state(stream
))
664 stream
->status
= PCXHR_STREAM_STATUS_RUNNING
;
666 struct snd_pcxhr
*chip
= snd_pcm_substream_chip(subs
);
667 tasklet_hi_schedule(&chip
->mgr
->trigger_taskq
);
670 case SNDRV_PCM_TRIGGER_STOP
:
671 snd_printdd("SNDRV_PCM_TRIGGER_STOP\n");
672 snd_pcm_group_for_each(pos
, subs
) {
673 s
= snd_pcm_group_substream_entry(pos
);
674 stream
= s
->runtime
->private_data
;
675 stream
->status
= PCXHR_STREAM_STATUS_SCHEDULE_STOP
;
676 if (pcxhr_set_stream_state(stream
))
678 snd_pcm_trigger_done(s
, subs
);
681 case SNDRV_PCM_TRIGGER_PAUSE_PUSH
:
682 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE
:
691 static int pcxhr_hardware_timer(struct pcxhr_mgr
*mgr
, int start
)
693 struct pcxhr_rmh rmh
;
696 pcxhr_init_rmh(&rmh
, CMD_SET_TIMER_INTERRUPT
);
698 mgr
->dsp_time_last
= PCXHR_DSP_TIME_INVALID
; /* last dsp time invalid */
699 rmh
.cmd
[0] |= PCXHR_GRANULARITY
;
701 err
= pcxhr_send_msg(mgr
, &rmh
);
703 snd_printk(KERN_ERR
"error pcxhr_hardware_timer err(%x)\n", err
);
708 * prepare callback for all pcms
710 static int pcxhr_prepare(struct snd_pcm_substream
*subs
)
712 struct snd_pcxhr
*chip
= snd_pcm_substream_chip(subs
);
713 struct pcxhr_mgr
*mgr
= chip
->mgr
;
715 struct pcxhr_stream *stream = (pcxhr_stream_t*)subs->runtime->private_data;
719 snd_printdd("pcxhr_prepare : period_size(%lx) periods(%x) buffer_size(%lx)\n",
720 subs
->runtime
->period_size
, subs
->runtime
->periods
,
721 subs
->runtime
->buffer_size
);
724 if(subs->runtime->period_size <= PCXHR_GRANULARITY) {
725 snd_printk(KERN_ERR "pcxhr_prepare : error period_size too small (%x)\n",
726 (unsigned int)subs->runtime->period_size);
731 down(&mgr
->setup_mutex
);
734 /* if the stream was stopped before, format and buffer were reset */
736 if(stream->status == PCXHR_STREAM_STATUS_STOPPED) {
737 err = pcxhr_set_format(stream);
739 err = pcxhr_update_r_buffer(stream);
744 /* only the first stream can choose the sample rate */
745 /* the further opened streams will be limited to its frequency (see open) */
746 /* set the clock only once (first stream) */
747 if (mgr
->sample_rate
== 0) {
748 err
= pcxhr_set_clock(mgr
, subs
->runtime
->rate
);
751 mgr
->sample_rate
= subs
->runtime
->rate
;
753 err
= pcxhr_hardware_timer(mgr
, 1); /* start the DSP-timer */
755 } while(0); /* do only once (so we can use break instead of goto) */
757 up(&mgr
->setup_mutex
);
764 * HW_PARAMS callback for all pcms
766 static int pcxhr_hw_params(struct snd_pcm_substream
*subs
,
767 struct snd_pcm_hw_params
*hw
)
769 struct snd_pcxhr
*chip
= snd_pcm_substream_chip(subs
);
770 struct pcxhr_mgr
*mgr
= chip
->mgr
;
771 struct pcxhr_stream
*stream
= subs
->runtime
->private_data
;
772 snd_pcm_format_t format
;
776 /* set up channels */
777 channels
= params_channels(hw
);
779 /* set up format for the stream */
780 format
= params_format(hw
);
782 down(&mgr
->setup_mutex
);
784 stream
->channels
= channels
;
785 stream
->format
= format
;
787 /* set the format to the board */
789 err = pcxhr_set_format(stream);
791 up(&mgr->setup_mutex);
795 /* allocate buffer */
796 err
= snd_pcm_lib_malloc_pages(subs
, params_buffer_bytes(hw
));
800 err = pcxhr_update_r_buffer(stream);
803 up(&mgr
->setup_mutex
);
808 static int pcxhr_hw_free(struct snd_pcm_substream
*subs
)
810 snd_pcm_lib_free_pages(subs
);
816 * CONFIGURATION SPACE for all pcms, mono pcm must update channels_max
818 static struct snd_pcm_hardware pcxhr_caps
=
820 .info
= ( SNDRV_PCM_INFO_MMAP
| SNDRV_PCM_INFO_INTERLEAVED
|
821 SNDRV_PCM_INFO_MMAP_VALID
| SNDRV_PCM_INFO_SYNC_START
|
822 0 /*SNDRV_PCM_INFO_PAUSE*/),
823 .formats
= ( SNDRV_PCM_FMTBIT_U8
|
824 SNDRV_PCM_FMTBIT_S16_LE
| SNDRV_PCM_FMTBIT_S16_BE
|
825 SNDRV_PCM_FMTBIT_S24_3LE
| SNDRV_PCM_FMTBIT_S24_3BE
|
826 SNDRV_PCM_FMTBIT_FLOAT_LE
),
827 .rates
= SNDRV_PCM_RATE_CONTINUOUS
| SNDRV_PCM_RATE_8000_192000
,
832 .buffer_bytes_max
= (32*1024),
833 /* 1 byte == 1 frame U8 mono (PCXHR_GRANULARITY is frames!) */
834 .period_bytes_min
= (2*PCXHR_GRANULARITY
),
835 .period_bytes_max
= (16*1024),
837 .periods_max
= (32*1024/PCXHR_GRANULARITY
),
841 static int pcxhr_open(struct snd_pcm_substream
*subs
)
843 struct snd_pcxhr
*chip
= snd_pcm_substream_chip(subs
);
844 struct pcxhr_mgr
*mgr
= chip
->mgr
;
845 struct snd_pcm_runtime
*runtime
= subs
->runtime
;
846 struct pcxhr_stream
*stream
;
849 down(&mgr
->setup_mutex
);
851 /* copy the struct snd_pcm_hardware struct */
852 runtime
->hw
= pcxhr_caps
;
854 if( subs
->stream
== SNDRV_PCM_STREAM_PLAYBACK
) {
855 snd_printdd("pcxhr_open playback chip%d subs%d\n",
856 chip
->chip_idx
, subs
->number
);
858 stream
= &chip
->playback_stream
[subs
->number
];
860 snd_printdd("pcxhr_open capture chip%d subs%d\n",
861 chip
->chip_idx
, subs
->number
);
863 if (mgr
->mono_capture
)
864 runtime
->hw
.channels_max
= 1;
866 runtime
->hw
.channels_min
= 2;
867 stream
= &chip
->capture_stream
[subs
->number
];
869 if (stream
->status
!= PCXHR_STREAM_STATUS_FREE
){
871 snd_printk(KERN_ERR
"pcxhr_open chip%d subs%d in use\n",
872 chip
->chip_idx
, subs
->number
);
873 up(&mgr
->setup_mutex
);
877 /* if a sample rate is already used or fixed by external clock,
878 * the stream cannot change
880 if (mgr
->sample_rate
)
881 runtime
->hw
.rate_min
= runtime
->hw
.rate_max
= mgr
->sample_rate
;
883 if (mgr
->use_clock_type
!= PCXHR_CLOCK_TYPE_INTERNAL
) {
885 if (pcxhr_get_external_clock(mgr
, mgr
->use_clock_type
,
887 external_rate
== 0) {
888 /* cannot detect the external clock rate */
889 up(&mgr
->setup_mutex
);
892 runtime
->hw
.rate_min
= runtime
->hw
.rate_max
= external_rate
;
896 stream
->status
= PCXHR_STREAM_STATUS_OPEN
;
897 stream
->substream
= subs
;
898 stream
->channels
= 0; /* not configured yet */
900 runtime
->private_data
= stream
;
902 snd_pcm_hw_constraint_step(runtime
, 0, SNDRV_PCM_HW_PARAM_BUFFER_BYTES
, 4);
903 snd_pcm_hw_constraint_step(runtime
, 0, SNDRV_PCM_HW_PARAM_PERIOD_BYTES
, 4);
905 mgr
->ref_count_rate
++;
907 up(&mgr
->setup_mutex
);
912 static int pcxhr_close(struct snd_pcm_substream
*subs
)
914 struct snd_pcxhr
*chip
= snd_pcm_substream_chip(subs
);
915 struct pcxhr_mgr
*mgr
= chip
->mgr
;
916 struct pcxhr_stream
*stream
= subs
->runtime
->private_data
;
918 down(&mgr
->setup_mutex
);
920 snd_printdd("pcxhr_close chip%d subs%d\n", chip
->chip_idx
, subs
->number
);
922 /* sample rate released */
923 if (--mgr
->ref_count_rate
== 0) {
924 mgr
->sample_rate
= 0; /* the sample rate is no more locked */
925 pcxhr_hardware_timer(mgr
, 0); /* stop the DSP-timer */
928 stream
->status
= PCXHR_STREAM_STATUS_FREE
;
929 stream
->substream
= NULL
;
931 up(&mgr
->setup_mutex
);
937 static snd_pcm_uframes_t
pcxhr_stream_pointer(struct snd_pcm_substream
*subs
)
940 u_int32_t timer_period_frag
;
941 int timer_buf_periods
;
942 struct snd_pcxhr
*chip
= snd_pcm_substream_chip(subs
);
943 struct snd_pcm_runtime
*runtime
= subs
->runtime
;
944 struct pcxhr_stream
*stream
= runtime
->private_data
;
946 spin_lock_irqsave(&chip
->mgr
->lock
, flags
);
948 /* get the period fragment and the nb of periods in the buffer */
949 timer_period_frag
= stream
->timer_period_frag
;
950 timer_buf_periods
= stream
->timer_buf_periods
;
952 spin_unlock_irqrestore(&chip
->mgr
->lock
, flags
);
954 return (snd_pcm_uframes_t
)((timer_buf_periods
* runtime
->period_size
) +
959 static struct snd_pcm_ops pcxhr_ops
= {
961 .close
= pcxhr_close
,
962 .ioctl
= snd_pcm_lib_ioctl
,
963 .prepare
= pcxhr_prepare
,
964 .hw_params
= pcxhr_hw_params
,
965 .hw_free
= pcxhr_hw_free
,
966 .trigger
= pcxhr_trigger
,
967 .pointer
= pcxhr_stream_pointer
,
972 int pcxhr_create_pcm(struct snd_pcxhr
*chip
)
978 sprintf(name
, "pcxhr %d", chip
->chip_idx
);
979 if ((err
= snd_pcm_new(chip
->card
, name
, 0,
980 chip
->nb_streams_play
,
981 chip
->nb_streams_capt
, &pcm
)) < 0) {
982 snd_printk(KERN_ERR
"cannot create pcm %s\n", name
);
985 pcm
->private_data
= chip
;
987 if (chip
->nb_streams_play
)
988 snd_pcm_set_ops(pcm
, SNDRV_PCM_STREAM_PLAYBACK
, &pcxhr_ops
);
989 if (chip
->nb_streams_capt
)
990 snd_pcm_set_ops(pcm
, SNDRV_PCM_STREAM_CAPTURE
, &pcxhr_ops
);
993 strcpy(pcm
->name
, name
);
995 snd_pcm_lib_preallocate_pages_for_all(pcm
, SNDRV_DMA_TYPE_DEV
,
996 snd_dma_pci_data(chip
->mgr
->pci
),
1002 static int pcxhr_chip_free(struct snd_pcxhr
*chip
)
1008 static int pcxhr_chip_dev_free(struct snd_device
*device
)
1010 struct snd_pcxhr
*chip
= device
->device_data
;
1011 return pcxhr_chip_free(chip
);
1017 static int __devinit
pcxhr_create(struct pcxhr_mgr
*mgr
, struct snd_card
*card
, int idx
)
1020 struct snd_pcxhr
*chip
;
1021 static struct snd_device_ops ops
= {
1022 .dev_free
= pcxhr_chip_dev_free
,
1025 mgr
->chip
[idx
] = chip
= kzalloc(sizeof(*chip
), GFP_KERNEL
);
1027 snd_printk(KERN_ERR
"cannot allocate chip\n");
1032 chip
->chip_idx
= idx
;
1035 if (idx
< mgr
->playback_chips
)
1036 /* stereo or mono streams */
1037 chip
->nb_streams_play
= PCXHR_PLAYBACK_STREAMS
;
1039 if (idx
< mgr
->capture_chips
) {
1040 if (mgr
->mono_capture
)
1041 chip
->nb_streams_capt
= 2; /* 2 mono streams (left+right) */
1043 chip
->nb_streams_capt
= 1; /* or 1 stereo stream */
1046 if ((err
= snd_device_new(card
, SNDRV_DEV_LOWLEVEL
, chip
, &ops
)) < 0) {
1047 pcxhr_chip_free(chip
);
1051 snd_card_set_dev(card
, &mgr
->pci
->dev
);
1056 /* proc interface */
1057 static void pcxhr_proc_info(struct snd_info_entry
*entry
, struct snd_info_buffer
*buffer
)
1059 struct snd_pcxhr
*chip
= entry
->private_data
;
1060 struct pcxhr_mgr
*mgr
= chip
->mgr
;
1062 snd_iprintf(buffer
, "\n%s\n", mgr
->longname
);
1064 /* stats available when embedded DSP is running */
1065 if (mgr
->dsp_loaded
& (1 << PCXHR_FIRMWARE_DSP_MAIN_INDEX
)) {
1066 struct pcxhr_rmh rmh
;
1067 short ver_maj
= (mgr
->dsp_version
>> 16) & 0xff;
1068 short ver_min
= (mgr
->dsp_version
>> 8) & 0xff;
1069 short ver_build
= mgr
->dsp_version
& 0xff;
1070 snd_iprintf(buffer
, "module version %s\n", PCXHR_DRIVER_VERSION_STRING
);
1071 snd_iprintf(buffer
, "dsp version %d.%d.%d\n", ver_maj
, ver_min
, ver_build
);
1072 if (mgr
->board_has_analog
)
1073 snd_iprintf(buffer
, "analog io available\n");
1075 snd_iprintf(buffer
, "digital only board\n");
1077 /* calc cpu load of the dsp */
1078 pcxhr_init_rmh(&rmh
, CMD_GET_DSP_RESOURCES
);
1079 if( ! pcxhr_send_msg(mgr
, &rmh
) ) {
1080 int cur
= rmh
.stat
[0];
1081 int ref
= rmh
.stat
[1];
1083 if (mgr
->sample_rate_real
!= 0 &&
1084 mgr
->sample_rate_real
!= 48000) {
1085 ref
= (ref
* 48000) / mgr
->sample_rate_real
;
1086 if (mgr
->sample_rate_real
>= PCXHR_IRQ_TIMER_FREQ
)
1089 cur
= 100 - (100 * cur
) / ref
;
1090 snd_iprintf(buffer
, "cpu load %d%%\n", cur
);
1091 snd_iprintf(buffer
, "buffer pool %d/%d kWords\n",
1092 rmh
.stat
[2], rmh
.stat
[3]);
1095 snd_iprintf(buffer
, "dma granularity : %d\n", PCXHR_GRANULARITY
);
1096 snd_iprintf(buffer
, "dsp time errors : %d\n", mgr
->dsp_time_err
);
1097 snd_iprintf(buffer
, "dsp async pipe xrun errors : %d\n",
1098 mgr
->async_err_pipe_xrun
);
1099 snd_iprintf(buffer
, "dsp async stream xrun errors : %d\n",
1100 mgr
->async_err_stream_xrun
);
1101 snd_iprintf(buffer
, "dsp async last other error : %x\n",
1102 mgr
->async_err_other_last
);
1103 /* debug zone dsp */
1104 rmh
.cmd
[0] = 0x4200 + PCXHR_SIZE_MAX_STATUS
;
1106 rmh
.stat_len
= PCXHR_SIZE_MAX_STATUS
;
1108 rmh
.cmd_idx
= CMD_LAST_INDEX
;
1109 if( ! pcxhr_send_msg(mgr
, &rmh
) ) {
1111 for (i
= 0; i
< rmh
.stat_len
; i
++)
1112 snd_iprintf(buffer
, "debug[%02d] = %06x\n", i
, rmh
.stat
[i
]);
1115 snd_iprintf(buffer
, "no firmware loaded\n");
1116 snd_iprintf(buffer
, "\n");
1118 static void pcxhr_proc_sync(struct snd_info_entry
*entry
, struct snd_info_buffer
*buffer
)
1120 struct snd_pcxhr
*chip
= entry
->private_data
;
1121 struct pcxhr_mgr
*mgr
= chip
->mgr
;
1122 static char *texts
[7] = {
1123 "Internal", "Word", "AES Sync", "AES 1", "AES 2", "AES 3", "AES 4"
1126 snd_iprintf(buffer
, "\n%s\n", mgr
->longname
);
1127 snd_iprintf(buffer
, "Current Sample Clock\t: %s\n", texts
[mgr
->cur_clock_type
]);
1128 snd_iprintf(buffer
, "Current Sample Rate\t= %d\n", mgr
->sample_rate_real
);
1130 /* commands available when embedded DSP is running */
1131 if (mgr
->dsp_loaded
& (1 << PCXHR_FIRMWARE_DSP_MAIN_INDEX
)) {
1132 int i
, err
, sample_rate
;
1133 for (i
= PCXHR_CLOCK_TYPE_WORD_CLOCK
; i
< (3 + mgr
->capture_chips
); i
++) {
1134 err
= pcxhr_get_external_clock(mgr
, i
, &sample_rate
);
1137 snd_iprintf(buffer
, "%s Clock\t\t= %d\n", texts
[i
], sample_rate
);
1140 snd_iprintf(buffer
, "no firmware loaded\n");
1141 snd_iprintf(buffer
, "\n");
1144 static void __devinit
pcxhr_proc_init(struct snd_pcxhr
*chip
)
1146 struct snd_info_entry
*entry
;
1148 if (! snd_card_proc_new(chip
->card
, "info", &entry
))
1149 snd_info_set_text_ops(entry
, chip
, 1024, pcxhr_proc_info
);
1150 if (! snd_card_proc_new(chip
->card
, "sync", &entry
))
1151 snd_info_set_text_ops(entry
, chip
, 1024, pcxhr_proc_sync
);
1153 /* end of proc interface */
1156 * release all the cards assigned to a manager instance
1158 static int pcxhr_free(struct pcxhr_mgr
*mgr
)
1162 for (i
= 0; i
< mgr
->num_cards
; i
++) {
1164 snd_card_free(mgr
->chip
[i
]->card
);
1167 /* reset board if some firmware was loaded */
1168 if(mgr
->dsp_loaded
) {
1169 pcxhr_reset_board(mgr
);
1170 snd_printdd("reset pcxhr !\n");
1175 free_irq(mgr
->irq
, mgr
);
1177 pci_release_regions(mgr
->pci
);
1179 /* free hostport purgebuffer */
1180 if (mgr
->hostport
.area
) {
1181 snd_dma_free_pages(&mgr
->hostport
);
1182 mgr
->hostport
.area
= NULL
;
1187 pci_disable_device(mgr
->pci
);
1193 * probe function - creates the card manager
1195 static int __devinit
pcxhr_probe(struct pci_dev
*pci
, const struct pci_device_id
*pci_id
)
1198 struct pcxhr_mgr
*mgr
;
1204 if (dev
>= SNDRV_CARDS
)
1206 if (! enable
[dev
]) {
1211 /* enable PCI device */
1212 if ((err
= pci_enable_device(pci
)) < 0)
1214 pci_set_master(pci
);
1216 /* check if we can restrict PCI DMA transfers to 32 bits */
1217 if (pci_set_dma_mask(pci
, 0xffffffff) < 0) {
1218 snd_printk(KERN_ERR
"architecture does not support 32bit PCI busmaster DMA\n");
1219 pci_disable_device(pci
);
1223 /* alloc card manager */
1224 mgr
= kzalloc(sizeof(*mgr
), GFP_KERNEL
);
1226 pci_disable_device(pci
);
1230 snd_assert(pci_id
->driver_data
< PCI_ID_LAST
, return -ENODEV
);
1231 card_name
= pcxhr_board_params
[pci_id
->driver_data
].board_name
;
1232 mgr
->playback_chips
= pcxhr_board_params
[pci_id
->driver_data
].playback_chips
;
1233 mgr
->capture_chips
= pcxhr_board_params
[pci_id
->driver_data
].capture_chips
;
1234 mgr
->firmware_num
= pcxhr_board_params
[pci_id
->driver_data
].firmware_num
;
1235 mgr
->mono_capture
= mono
[dev
];
1237 /* resource assignment */
1238 if ((err
= pci_request_regions(pci
, card_name
)) < 0) {
1240 pci_disable_device(pci
);
1243 for (i
= 0; i
< 3; i
++)
1244 mgr
->port
[i
] = pci_resource_start(pci
, i
);
1249 if (request_irq(pci
->irq
, pcxhr_interrupt
, SA_INTERRUPT
|SA_SHIRQ
,
1251 snd_printk(KERN_ERR
"unable to grab IRQ %d\n", pci
->irq
);
1255 mgr
->irq
= pci
->irq
;
1257 sprintf(mgr
->shortname
, "Digigram %s", card_name
);
1258 sprintf(mgr
->longname
, "%s at 0x%lx & 0x%lx, 0x%lx irq %i", mgr
->shortname
,
1259 mgr
->port
[0], mgr
->port
[1], mgr
->port
[2], mgr
->irq
);
1262 spin_lock_init(&mgr
->lock
);
1263 spin_lock_init(&mgr
->msg_lock
);
1265 /* init setup mutex*/
1266 init_MUTEX(&mgr
->setup_mutex
);
1269 tasklet_init(&mgr
->msg_taskq
, pcxhr_msg_tasklet
, (unsigned long) mgr
);
1270 tasklet_init(&mgr
->trigger_taskq
, pcxhr_trigger_tasklet
, (unsigned long) mgr
);
1271 mgr
->prmh
= kmalloc(sizeof(*mgr
->prmh
) +
1272 sizeof(u32
) * (PCXHR_SIZE_MAX_LONG_STATUS
- PCXHR_SIZE_MAX_STATUS
),
1279 for (i
=0; i
< PCXHR_MAX_CARDS
; i
++) {
1280 struct snd_card
*card
;
1284 if (i
>= max(mgr
->playback_chips
, mgr
->capture_chips
))
1291 idx
= index
[dev
] + i
;
1293 snprintf(tmpid
, sizeof(tmpid
), "%s-%d", id
[dev
] ? id
[dev
] : card_name
, i
);
1294 card
= snd_card_new(idx
, tmpid
, THIS_MODULE
, 0);
1297 snd_printk(KERN_ERR
"cannot allocate the card %d\n", i
);
1302 strcpy(card
->driver
, DRIVER_NAME
);
1303 sprintf(card
->shortname
, "%s [PCM #%d]", mgr
->shortname
, i
);
1304 sprintf(card
->longname
, "%s [PCM #%d]", mgr
->longname
, i
);
1306 if ((err
= pcxhr_create(mgr
, card
, i
)) < 0) {
1312 /* init proc interface only for chip0 */
1313 pcxhr_proc_init(mgr
->chip
[i
]);
1315 if ((err
= snd_card_register(card
)) < 0) {
1321 /* create hostport purgebuffer */
1322 size
= PAGE_ALIGN(sizeof(struct pcxhr_hostport
));
1323 if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV
, snd_dma_pci_data(pci
),
1324 size
, &mgr
->hostport
) < 0) {
1328 /* init purgebuffer */
1329 memset(mgr
->hostport
.area
, 0, size
);
1331 /* create a DSP loader */
1332 err
= pcxhr_setup_firmware(mgr
);
1338 pci_set_drvdata(pci
, mgr
);
1343 static void __devexit
pcxhr_remove(struct pci_dev
*pci
)
1345 pcxhr_free(pci_get_drvdata(pci
));
1346 pci_set_drvdata(pci
, NULL
);
1349 static struct pci_driver driver
= {
1350 .name
= "Digigram pcxhr",
1351 .id_table
= pcxhr_ids
,
1352 .probe
= pcxhr_probe
,
1353 .remove
= __devexit_p(pcxhr_remove
),
1356 static int __init
pcxhr_module_init(void)
1358 return pci_register_driver(&driver
);
1361 static void __exit
pcxhr_module_exit(void)
1363 pci_unregister_driver(&driver
);
1366 module_init(pcxhr_module_init
)
1367 module_exit(pcxhr_module_exit
)