3 * ALSA driver for the digigram lx6464es interface
5 * Copyright (c) 2008, 2009 Tim Blechmann <tim@klingt.org>
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; see the file COPYING. If not, write to
20 * the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
21 * Boston, MA 02111-1307, USA.
25 #include <linux/module.h>
26 #include <linux/init.h>
27 #include <linux/pci.h>
28 #include <linux/delay.h>
29 #include <linux/slab.h>
31 #include <sound/initval.h>
32 #include <sound/control.h>
33 #include <sound/info.h>
37 MODULE_AUTHOR("Tim Blechmann");
38 MODULE_LICENSE("GPL");
39 MODULE_DESCRIPTION("digigram lx6464es");
40 MODULE_SUPPORTED_DEVICE("{digigram lx6464es{}}");
43 static int index
[SNDRV_CARDS
] = SNDRV_DEFAULT_IDX
;
44 static char *id
[SNDRV_CARDS
] = SNDRV_DEFAULT_STR
;
45 static int enable
[SNDRV_CARDS
] = SNDRV_DEFAULT_ENABLE_PNP
;
47 module_param_array(index
, int, NULL
, 0444);
48 MODULE_PARM_DESC(index
, "Index value for Digigram LX6464ES interface.");
49 module_param_array(id
, charp
, NULL
, 0444);
50 MODULE_PARM_DESC(id
, "ID string for Digigram LX6464ES interface.");
51 module_param_array(enable
, bool, NULL
, 0444);
52 MODULE_PARM_DESC(enable
, "Enable/disable specific Digigram LX6464ES soundcards.");
54 static const char card_name
[] = "LX6464ES";
57 #define PCI_DEVICE_ID_PLX_LX6464ES PCI_DEVICE_ID_PLX_9056
59 static DEFINE_PCI_DEVICE_TABLE(snd_lx6464es_ids
) = {
60 { PCI_DEVICE(PCI_VENDOR_ID_PLX
, PCI_DEVICE_ID_PLX_LX6464ES
),
61 .subvendor
= PCI_VENDOR_ID_DIGIGRAM
,
62 .subdevice
= PCI_SUBDEVICE_ID_DIGIGRAM_LX6464ES_SERIAL_SUBSYSTEM
64 { PCI_DEVICE(PCI_VENDOR_ID_PLX
, PCI_DEVICE_ID_PLX_LX6464ES
),
65 .subvendor
= PCI_VENDOR_ID_DIGIGRAM
,
66 .subdevice
= PCI_SUBDEVICE_ID_DIGIGRAM_LX6464ES_CAE_SERIAL_SUBSYSTEM
71 MODULE_DEVICE_TABLE(pci
, snd_lx6464es_ids
);
75 /* PGO pour USERo dans le registre pci_0x06/loc_0xEC */
76 #define CHIPSC_RESET_XILINX (1L<<16)
80 static struct snd_pcm_hardware lx_caps
= {
81 .info
= (SNDRV_PCM_INFO_MMAP
|
82 SNDRV_PCM_INFO_INTERLEAVED
|
83 SNDRV_PCM_INFO_MMAP_VALID
|
84 SNDRV_PCM_INFO_SYNC_START
),
85 .formats
= (SNDRV_PCM_FMTBIT_S16_LE
|
86 SNDRV_PCM_FMTBIT_S16_BE
|
87 SNDRV_PCM_FMTBIT_S24_3LE
|
88 SNDRV_PCM_FMTBIT_S24_3BE
),
89 .rates
= (SNDRV_PCM_RATE_CONTINUOUS
|
90 SNDRV_PCM_RATE_8000_192000
),
95 .buffer_bytes_max
= 64*2*3*MICROBLAZE_IBL_MAX
*MAX_STREAM_BUFFER
,
96 .period_bytes_min
= (2*2*MICROBLAZE_IBL_MIN
*2),
97 .period_bytes_max
= (4*64*MICROBLAZE_IBL_MAX
*MAX_STREAM_BUFFER
),
99 .periods_max
= MAX_STREAM_BUFFER
,
102 static int lx_set_granularity(struct lx6464es
*chip
, u32 gran
);
105 static int lx_hardware_open(struct lx6464es
*chip
,
106 struct snd_pcm_substream
*substream
)
109 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
110 int channels
= runtime
->channels
;
111 int is_capture
= (substream
->stream
== SNDRV_PCM_STREAM_CAPTURE
);
113 snd_pcm_uframes_t period_size
= runtime
->period_size
;
115 snd_printd(LXP
"allocating pipe for %d channels\n", channels
);
116 err
= lx_pipe_allocate(chip
, 0, is_capture
, channels
);
118 snd_printk(KERN_ERR LXP
"allocating pipe failed\n");
122 err
= lx_set_granularity(chip
, period_size
);
124 snd_printk(KERN_ERR LXP
"setting granularity to %ld failed\n",
132 static int lx_hardware_start(struct lx6464es
*chip
,
133 struct snd_pcm_substream
*substream
)
136 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
137 int is_capture
= (substream
->stream
== SNDRV_PCM_STREAM_CAPTURE
);
139 snd_printd(LXP
"setting stream format\n");
140 err
= lx_stream_set_format(chip
, runtime
, 0, is_capture
);
142 snd_printk(KERN_ERR LXP
"setting stream format failed\n");
146 snd_printd(LXP
"starting pipe\n");
147 err
= lx_pipe_start(chip
, 0, is_capture
);
149 snd_printk(KERN_ERR LXP
"starting pipe failed\n");
153 snd_printd(LXP
"waiting for pipe to start\n");
154 err
= lx_pipe_wait_for_start(chip
, 0, is_capture
);
156 snd_printk(KERN_ERR LXP
"waiting for pipe failed\n");
164 static int lx_hardware_stop(struct lx6464es
*chip
,
165 struct snd_pcm_substream
*substream
)
168 int is_capture
= (substream
->stream
== SNDRV_PCM_STREAM_CAPTURE
);
170 snd_printd(LXP
"pausing pipe\n");
171 err
= lx_pipe_pause(chip
, 0, is_capture
);
173 snd_printk(KERN_ERR LXP
"pausing pipe failed\n");
177 snd_printd(LXP
"waiting for pipe to become idle\n");
178 err
= lx_pipe_wait_for_idle(chip
, 0, is_capture
);
180 snd_printk(KERN_ERR LXP
"waiting for pipe failed\n");
184 snd_printd(LXP
"stopping pipe\n");
185 err
= lx_pipe_stop(chip
, 0, is_capture
);
187 snd_printk(LXP
"stopping pipe failed\n");
195 static int lx_hardware_close(struct lx6464es
*chip
,
196 struct snd_pcm_substream
*substream
)
199 int is_capture
= (substream
->stream
== SNDRV_PCM_STREAM_CAPTURE
);
201 snd_printd(LXP
"releasing pipe\n");
202 err
= lx_pipe_release(chip
, 0, is_capture
);
204 snd_printk(LXP
"releasing pipe failed\n");
212 static int lx_pcm_open(struct snd_pcm_substream
*substream
)
214 struct lx6464es
*chip
= snd_pcm_substream_chip(substream
);
215 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
219 snd_printdd("->lx_pcm_open\n");
220 mutex_lock(&chip
->setup_mutex
);
222 /* copy the struct snd_pcm_hardware struct */
223 runtime
->hw
= lx_caps
;
226 /* the clock rate cannot be changed */
227 board_rate
= chip
->board_sample_rate
;
228 err
= snd_pcm_hw_constraint_minmax(runtime
, SNDRV_PCM_HW_PARAM_RATE
,
229 board_rate
, board_rate
);
232 snd_printk(KERN_WARNING LXP
"could not constrain periods\n");
236 /* constrain period size */
237 err
= snd_pcm_hw_constraint_minmax(runtime
,
238 SNDRV_PCM_HW_PARAM_PERIOD_SIZE
,
242 snd_printk(KERN_WARNING LXP
243 "could not constrain period size\n");
247 snd_pcm_hw_constraint_step(runtime
, 0,
248 SNDRV_PCM_HW_PARAM_BUFFER_SIZE
, 32);
250 snd_pcm_set_sync(substream
);
254 runtime
->private_data
= chip
;
256 mutex_unlock(&chip
->setup_mutex
);
257 snd_printdd("<-lx_pcm_open, %d\n", err
);
261 static int lx_pcm_close(struct snd_pcm_substream
*substream
)
264 snd_printdd("->lx_pcm_close\n");
268 static snd_pcm_uframes_t
lx_pcm_stream_pointer(struct snd_pcm_substream
271 struct lx6464es
*chip
= snd_pcm_substream_chip(substream
);
272 snd_pcm_uframes_t pos
;
274 int is_capture
= (substream
->stream
== SNDRV_PCM_STREAM_CAPTURE
);
276 struct lx_stream
*lx_stream
= is_capture
? &chip
->capture_stream
:
277 &chip
->playback_stream
;
279 snd_printdd("->lx_pcm_stream_pointer\n");
281 spin_lock_irqsave(&chip
->lock
, flags
);
282 pos
= lx_stream
->frame_pos
* substream
->runtime
->period_size
;
283 spin_unlock_irqrestore(&chip
->lock
, flags
);
285 snd_printdd(LXP
"stream_pointer at %ld\n", pos
);
289 static int lx_pcm_prepare(struct snd_pcm_substream
*substream
)
291 struct lx6464es
*chip
= snd_pcm_substream_chip(substream
);
293 const int is_capture
= (substream
->stream
== SNDRV_PCM_STREAM_CAPTURE
);
295 snd_printdd("->lx_pcm_prepare\n");
297 mutex_lock(&chip
->setup_mutex
);
299 if (chip
->hardware_running
[is_capture
]) {
300 err
= lx_hardware_stop(chip
, substream
);
302 snd_printk(KERN_ERR LXP
"failed to stop hardware. "
303 "Error code %d\n", err
);
307 err
= lx_hardware_close(chip
, substream
);
309 snd_printk(KERN_ERR LXP
"failed to close hardware. "
310 "Error code %d\n", err
);
315 snd_printd(LXP
"opening hardware\n");
316 err
= lx_hardware_open(chip
, substream
);
318 snd_printk(KERN_ERR LXP
"failed to open hardware. "
319 "Error code %d\n", err
);
323 err
= lx_hardware_start(chip
, substream
);
325 snd_printk(KERN_ERR LXP
"failed to start hardware. "
326 "Error code %d\n", err
);
330 chip
->hardware_running
[is_capture
] = 1;
332 if (chip
->board_sample_rate
!= substream
->runtime
->rate
) {
334 chip
->board_sample_rate
= substream
->runtime
->rate
;
338 mutex_unlock(&chip
->setup_mutex
);
342 static int lx_pcm_hw_params(struct snd_pcm_substream
*substream
,
343 struct snd_pcm_hw_params
*hw_params
, int is_capture
)
345 struct lx6464es
*chip
= snd_pcm_substream_chip(substream
);
348 snd_printdd("->lx_pcm_hw_params\n");
350 mutex_lock(&chip
->setup_mutex
);
353 err
= snd_pcm_lib_malloc_pages(substream
,
354 params_buffer_bytes(hw_params
));
357 chip
->capture_stream
.stream
= substream
;
359 chip
->playback_stream
.stream
= substream
;
361 mutex_unlock(&chip
->setup_mutex
);
365 static int lx_pcm_hw_params_playback(struct snd_pcm_substream
*substream
,
366 struct snd_pcm_hw_params
*hw_params
)
368 return lx_pcm_hw_params(substream
, hw_params
, 0);
371 static int lx_pcm_hw_params_capture(struct snd_pcm_substream
*substream
,
372 struct snd_pcm_hw_params
*hw_params
)
374 return lx_pcm_hw_params(substream
, hw_params
, 1);
377 static int lx_pcm_hw_free(struct snd_pcm_substream
*substream
)
379 struct lx6464es
*chip
= snd_pcm_substream_chip(substream
);
381 int is_capture
= (substream
->stream
== SNDRV_PCM_STREAM_CAPTURE
);
383 snd_printdd("->lx_pcm_hw_free\n");
384 mutex_lock(&chip
->setup_mutex
);
386 if (chip
->hardware_running
[is_capture
]) {
387 err
= lx_hardware_stop(chip
, substream
);
389 snd_printk(KERN_ERR LXP
"failed to stop hardware. "
390 "Error code %d\n", err
);
394 err
= lx_hardware_close(chip
, substream
);
396 snd_printk(KERN_ERR LXP
"failed to close hardware. "
397 "Error code %d\n", err
);
401 chip
->hardware_running
[is_capture
] = 0;
404 err
= snd_pcm_lib_free_pages(substream
);
407 chip
->capture_stream
.stream
= 0;
409 chip
->playback_stream
.stream
= 0;
412 mutex_unlock(&chip
->setup_mutex
);
416 static void lx_trigger_start(struct lx6464es
*chip
, struct lx_stream
*lx_stream
)
418 struct snd_pcm_substream
*substream
= lx_stream
->stream
;
419 const int is_capture
= lx_stream
->is_capture
;
423 const u32 channels
= substream
->runtime
->channels
;
424 const u32 bytes_per_frame
= channels
* 3;
425 const u32 period_size
= substream
->runtime
->period_size
;
426 const u32 periods
= substream
->runtime
->periods
;
427 const u32 period_bytes
= period_size
* bytes_per_frame
;
429 dma_addr_t buf
= substream
->dma_buffer
.addr
;
435 for (i
= 0; i
!= periods
; ++i
) {
436 u32 buffer_index
= 0;
438 err
= lx_buffer_ask(chip
, 0, is_capture
, &needed
, &freed
,
440 snd_printdd(LXP
"starting: needed %d, freed %d\n",
443 err
= lx_buffer_give(chip
, 0, is_capture
, period_bytes
,
444 lower_32_bits(buf
), upper_32_bits(buf
),
447 snd_printdd(LXP
"starting: buffer index %x on %p (%d bytes)\n",
448 buffer_index
, (void *)buf
, period_bytes
);
452 err
= lx_buffer_ask(chip
, 0, is_capture
, &needed
, &freed
, size_array
);
453 snd_printdd(LXP
"starting: needed %d, freed %d\n", needed
, freed
);
455 snd_printd(LXP
"starting: starting stream\n");
456 err
= lx_stream_start(chip
, 0, is_capture
);
458 snd_printk(KERN_ERR LXP
"couldn't start stream\n");
460 lx_stream
->status
= LX_STREAM_STATUS_RUNNING
;
462 lx_stream
->frame_pos
= 0;
465 static void lx_trigger_stop(struct lx6464es
*chip
, struct lx_stream
*lx_stream
)
467 const int is_capture
= lx_stream
->is_capture
;
470 snd_printd(LXP
"stopping: stopping stream\n");
471 err
= lx_stream_stop(chip
, 0, is_capture
);
473 snd_printk(KERN_ERR LXP
"couldn't stop stream\n");
475 lx_stream
->status
= LX_STREAM_STATUS_FREE
;
479 static void lx_trigger_tasklet_dispatch_stream(struct lx6464es
*chip
,
480 struct lx_stream
*lx_stream
)
482 switch (lx_stream
->status
) {
483 case LX_STREAM_STATUS_SCHEDULE_RUN
:
484 lx_trigger_start(chip
, lx_stream
);
487 case LX_STREAM_STATUS_SCHEDULE_STOP
:
488 lx_trigger_stop(chip
, lx_stream
);
496 static void lx_trigger_tasklet(unsigned long data
)
498 struct lx6464es
*chip
= (struct lx6464es
*)data
;
501 snd_printdd("->lx_trigger_tasklet\n");
503 spin_lock_irqsave(&chip
->lock
, flags
);
504 lx_trigger_tasklet_dispatch_stream(chip
, &chip
->capture_stream
);
505 lx_trigger_tasklet_dispatch_stream(chip
, &chip
->playback_stream
);
506 spin_unlock_irqrestore(&chip
->lock
, flags
);
509 static int lx_pcm_trigger_dispatch(struct lx6464es
*chip
,
510 struct lx_stream
*lx_stream
, int cmd
)
515 case SNDRV_PCM_TRIGGER_START
:
516 lx_stream
->status
= LX_STREAM_STATUS_SCHEDULE_RUN
;
519 case SNDRV_PCM_TRIGGER_STOP
:
520 lx_stream
->status
= LX_STREAM_STATUS_SCHEDULE_STOP
;
527 tasklet_schedule(&chip
->trigger_tasklet
);
534 static int lx_pcm_trigger(struct snd_pcm_substream
*substream
, int cmd
)
536 struct lx6464es
*chip
= snd_pcm_substream_chip(substream
);
537 const int is_capture
= (substream
->stream
== SNDRV_PCM_STREAM_CAPTURE
);
538 struct lx_stream
*stream
= is_capture
? &chip
->capture_stream
:
539 &chip
->playback_stream
;
541 snd_printdd("->lx_pcm_trigger\n");
543 return lx_pcm_trigger_dispatch(chip
, stream
, cmd
);
546 static int snd_lx6464es_free(struct lx6464es
*chip
)
548 snd_printdd("->snd_lx6464es_free\n");
550 lx_irq_disable(chip
);
553 free_irq(chip
->irq
, chip
);
555 iounmap(chip
->port_dsp_bar
);
556 ioport_unmap(chip
->port_plx_remapped
);
558 pci_release_regions(chip
->pci
);
559 pci_disable_device(chip
->pci
);
566 static int snd_lx6464es_dev_free(struct snd_device
*device
)
568 return snd_lx6464es_free(device
->device_data
);
571 /* reset the dsp during initialization */
572 static int __devinit
lx_init_xilinx_reset(struct lx6464es
*chip
)
575 u32 plx_reg
= lx_plx_reg_read(chip
, ePLX_CHIPSC
);
577 snd_printdd("->lx_init_xilinx_reset\n");
579 /* activate reset of xilinx */
580 plx_reg
&= ~CHIPSC_RESET_XILINX
;
582 lx_plx_reg_write(chip
, ePLX_CHIPSC
, plx_reg
);
585 lx_plx_reg_write(chip
, ePLX_MBOX3
, 0);
588 plx_reg
|= CHIPSC_RESET_XILINX
;
589 lx_plx_reg_write(chip
, ePLX_CHIPSC
, plx_reg
);
591 /* deactivate reset of xilinx */
592 for (i
= 0; i
!= 100; ++i
) {
595 reg_mbox3
= lx_plx_reg_read(chip
, ePLX_MBOX3
);
597 snd_printd(LXP
"xilinx reset done\n");
598 snd_printdd(LXP
"xilinx took %d loops\n", i
);
603 /* todo: add some error handling? */
606 lx_dsp_reg_write(chip
, eReg_CSM
, 0);
608 /* le xilinx ES peut ne pas etre encore pret, on attend. */
614 static int __devinit
lx_init_xilinx_test(struct lx6464es
*chip
)
618 snd_printdd("->lx_init_xilinx_test\n");
620 /* TEST if we have access to Xilinx/MicroBlaze */
621 lx_dsp_reg_write(chip
, eReg_CSM
, 0);
623 reg
= lx_dsp_reg_read(chip
, eReg_CSM
);
626 snd_printk(KERN_ERR LXP
"Problem: Reg_CSM %x.\n", reg
);
628 /* PCI9056_SPACE0_REMAP */
629 lx_plx_reg_write(chip
, ePLX_PCICR
, 1);
631 reg
= lx_dsp_reg_read(chip
, eReg_CSM
);
633 snd_printk(KERN_ERR LXP
"Error: Reg_CSM %x.\n", reg
);
634 return -EAGAIN
; /* seems to be appropriate */
638 snd_printd(LXP
"Xilinx/MicroBlaze access test successful\n");
643 /* initialize ethersound */
644 static int __devinit
lx_init_ethersound_config(struct lx6464es
*chip
)
647 u32 orig_conf_es
= lx_dsp_reg_read(chip
, eReg_CONFES
);
649 /* configure 64 io channels */
650 u32 conf_es
= (orig_conf_es
& CONFES_READ_PART_MASK
) |
651 (64 << IOCR_INPUTS_OFFSET
) |
652 (64 << IOCR_OUTPUTS_OFFSET
) |
653 (FREQ_RATIO_SINGLE_MODE
<< FREQ_RATIO_OFFSET
);
655 snd_printdd("->lx_init_ethersound\n");
657 chip
->freq_ratio
= FREQ_RATIO_SINGLE_MODE
;
660 * write it to the card !
661 * this actually kicks the ES xilinx, the first time since poweron.
662 * the MAC address in the Reg_ADMACESMSB Reg_ADMACESLSB registers
663 * is not ready before this is done, and the bit 2 in Reg_CSES is set.
665 lx_dsp_reg_write(chip
, eReg_CONFES
, conf_es
);
667 for (i
= 0; i
!= 1000; ++i
) {
668 if (lx_dsp_reg_read(chip
, eReg_CSES
) & 4) {
669 snd_printd(LXP
"ethersound initialized after %dms\n",
671 goto ethersound_initialized
;
675 snd_printk(KERN_WARNING LXP
676 "ethersound could not be initialized after %dms\n", i
);
679 ethersound_initialized
:
680 snd_printd(LXP
"ethersound initialized\n");
684 static int __devinit
lx_init_get_version_features(struct lx6464es
*chip
)
690 snd_printdd("->lx_init_get_version_features\n");
692 err
= lx_dsp_get_version(chip
, &dsp_version
);
697 snd_printk(LXP
"DSP version: V%02d.%02d #%d\n",
698 (dsp_version
>>16) & 0xff, (dsp_version
>>8) & 0xff,
701 /* later: what firmware version do we expect? */
703 /* retrieve Play/Rec features */
704 /* done here because we may have to handle alternate
708 /* init the EtherSound sample rate */
709 err
= lx_dsp_get_clock_frequency(chip
, &freq
);
711 chip
->board_sample_rate
= freq
;
712 snd_printd(LXP
"actual clock frequency %d\n", freq
);
714 snd_printk(KERN_ERR LXP
"DSP corrupted \n");
721 static int lx_set_granularity(struct lx6464es
*chip
, u32 gran
)
724 u32 snapped_gran
= MICROBLAZE_IBL_MIN
;
726 snd_printdd("->lx_set_granularity\n");
728 /* blocksize is a power of 2 */
729 while ((snapped_gran
< gran
) &&
730 (snapped_gran
< MICROBLAZE_IBL_MAX
)) {
734 if (snapped_gran
== chip
->pcm_granularity
)
737 err
= lx_dsp_set_granularity(chip
, snapped_gran
);
739 snd_printk(KERN_WARNING LXP
"could not set granularity\n");
743 if (snapped_gran
!= gran
)
744 snd_printk(LXP
"snapped blocksize to %d\n", snapped_gran
);
746 snd_printd(LXP
"set blocksize on board %d\n", snapped_gran
);
747 chip
->pcm_granularity
= snapped_gran
;
752 /* initialize and test the xilinx dsp chip */
753 static int __devinit
lx_init_dsp(struct lx6464es
*chip
)
759 snd_printdd("->lx_init_dsp\n");
761 snd_printd(LXP
"initialize board\n");
762 err
= lx_init_xilinx_reset(chip
);
766 snd_printd(LXP
"testing board\n");
767 err
= lx_init_xilinx_test(chip
);
771 snd_printd(LXP
"initialize ethersound configuration\n");
772 err
= lx_init_ethersound_config(chip
);
778 /** \todo the mac address should be ready by not, but it isn't,
779 * so we wait for it */
780 for (i
= 0; i
!= 1000; ++i
) {
781 err
= lx_dsp_get_mac(chip
, mac_address
);
784 if (mac_address
[0] || mac_address
[1] || mac_address
[2] ||
785 mac_address
[3] || mac_address
[4] || mac_address
[5])
792 snd_printd(LXP
"mac address ready read after: %dms\n", i
);
793 snd_printk(LXP
"mac address: %02X.%02X.%02X.%02X.%02X.%02X\n",
794 mac_address
[0], mac_address
[1], mac_address
[2],
795 mac_address
[3], mac_address
[4], mac_address
[5]);
797 err
= lx_init_get_version_features(chip
);
801 lx_set_granularity(chip
, MICROBLAZE_IBL_DEFAULT
);
803 chip
->playback_mute
= 0;
808 static struct snd_pcm_ops lx_ops_playback
= {
810 .close
= lx_pcm_close
,
811 .ioctl
= snd_pcm_lib_ioctl
,
812 .prepare
= lx_pcm_prepare
,
813 .hw_params
= lx_pcm_hw_params_playback
,
814 .hw_free
= lx_pcm_hw_free
,
815 .trigger
= lx_pcm_trigger
,
816 .pointer
= lx_pcm_stream_pointer
,
819 static struct snd_pcm_ops lx_ops_capture
= {
821 .close
= lx_pcm_close
,
822 .ioctl
= snd_pcm_lib_ioctl
,
823 .prepare
= lx_pcm_prepare
,
824 .hw_params
= lx_pcm_hw_params_capture
,
825 .hw_free
= lx_pcm_hw_free
,
826 .trigger
= lx_pcm_trigger
,
827 .pointer
= lx_pcm_stream_pointer
,
830 static int __devinit
lx_pcm_create(struct lx6464es
*chip
)
835 u32 size
= 64 * /* channels */
836 3 * /* 24 bit samples */
837 MAX_STREAM_BUFFER
* /* periods */
838 MICROBLAZE_IBL_MAX
* /* frames per period */
841 size
= PAGE_ALIGN(size
);
843 /* hardcoded device name & channel count */
844 err
= snd_pcm_new(chip
->card
, (char *)card_name
, 0,
847 pcm
->private_data
= chip
;
849 snd_pcm_set_ops(pcm
, SNDRV_PCM_STREAM_PLAYBACK
, &lx_ops_playback
);
850 snd_pcm_set_ops(pcm
, SNDRV_PCM_STREAM_CAPTURE
, &lx_ops_capture
);
853 strcpy(pcm
->name
, card_name
);
855 err
= snd_pcm_lib_preallocate_pages_for_all(pcm
, SNDRV_DMA_TYPE_DEV
,
856 snd_dma_pci_data(chip
->pci
),
862 chip
->capture_stream
.is_capture
= 1;
867 static int lx_control_playback_info(struct snd_kcontrol
*kcontrol
,
868 struct snd_ctl_elem_info
*uinfo
)
870 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_BOOLEAN
;
872 uinfo
->value
.integer
.min
= 0;
873 uinfo
->value
.integer
.max
= 1;
877 static int lx_control_playback_get(struct snd_kcontrol
*kcontrol
,
878 struct snd_ctl_elem_value
*ucontrol
)
880 struct lx6464es
*chip
= snd_kcontrol_chip(kcontrol
);
881 ucontrol
->value
.integer
.value
[0] = chip
->playback_mute
;
885 static int lx_control_playback_put(struct snd_kcontrol
*kcontrol
,
886 struct snd_ctl_elem_value
*ucontrol
)
888 struct lx6464es
*chip
= snd_kcontrol_chip(kcontrol
);
890 int current_value
= chip
->playback_mute
;
892 if (current_value
!= ucontrol
->value
.integer
.value
[0]) {
893 lx_level_unmute(chip
, 0, !current_value
);
894 chip
->playback_mute
= !current_value
;
900 static struct snd_kcontrol_new lx_control_playback_switch __devinitdata
= {
901 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
902 .name
= "PCM Playback Switch",
904 .access
= SNDRV_CTL_ELEM_ACCESS_READWRITE
,
906 .info
= lx_control_playback_info
,
907 .get
= lx_control_playback_get
,
908 .put
= lx_control_playback_put
913 static void lx_proc_levels_read(struct snd_info_entry
*entry
,
914 struct snd_info_buffer
*buffer
)
919 struct lx6464es
*chip
= entry
->private_data
;
921 snd_iprintf(buffer
, "capture levels:\n");
922 err
= lx_level_peaks(chip
, 1, 64, levels
);
926 for (i
= 0; i
!= 8; ++i
) {
927 for (j
= 0; j
!= 8; ++j
)
928 snd_iprintf(buffer
, "%08x ", levels
[i
*8+j
]);
929 snd_iprintf(buffer
, "\n");
932 snd_iprintf(buffer
, "\nplayback levels:\n");
934 err
= lx_level_peaks(chip
, 0, 64, levels
);
938 for (i
= 0; i
!= 8; ++i
) {
939 for (j
= 0; j
!= 8; ++j
)
940 snd_iprintf(buffer
, "%08x ", levels
[i
*8+j
]);
941 snd_iprintf(buffer
, "\n");
944 snd_iprintf(buffer
, "\n");
947 static int __devinit
lx_proc_create(struct snd_card
*card
, struct lx6464es
*chip
)
949 struct snd_info_entry
*entry
;
950 int err
= snd_card_proc_new(card
, "levels", &entry
);
954 snd_info_set_text_ops(entry
, chip
, lx_proc_levels_read
);
959 static int __devinit
snd_lx6464es_create(struct snd_card
*card
,
961 struct lx6464es
**rchip
)
963 struct lx6464es
*chip
;
966 static struct snd_device_ops ops
= {
967 .dev_free
= snd_lx6464es_dev_free
,
970 snd_printdd("->snd_lx6464es_create\n");
974 /* enable PCI device */
975 err
= pci_enable_device(pci
);
981 /* check if we can restrict PCI DMA transfers to 32 bits */
982 err
= pci_set_dma_mask(pci
, DMA_BIT_MASK(32));
984 snd_printk(KERN_ERR
"architecture does not support "
985 "32bit PCI busmaster DMA\n");
986 pci_disable_device(pci
);
990 chip
= kzalloc(sizeof(*chip
), GFP_KERNEL
);
1000 /* initialize synchronization structs */
1001 spin_lock_init(&chip
->lock
);
1002 spin_lock_init(&chip
->msg_lock
);
1003 mutex_init(&chip
->setup_mutex
);
1004 tasklet_init(&chip
->trigger_tasklet
, lx_trigger_tasklet
,
1005 (unsigned long)chip
);
1006 tasklet_init(&chip
->tasklet_capture
, lx_tasklet_capture
,
1007 (unsigned long)chip
);
1008 tasklet_init(&chip
->tasklet_playback
, lx_tasklet_playback
,
1009 (unsigned long)chip
);
1011 /* request resources */
1012 err
= pci_request_regions(pci
, card_name
);
1014 goto request_regions_failed
;
1017 chip
->port_plx
= pci_resource_start(pci
, 1);
1018 chip
->port_plx_remapped
= ioport_map(chip
->port_plx
,
1019 pci_resource_len(pci
, 1));
1022 chip
->port_dsp_bar
= pci_ioremap_bar(pci
, 2);
1024 err
= request_irq(pci
->irq
, lx_interrupt
, IRQF_SHARED
,
1027 snd_printk(KERN_ERR LXP
"unable to grab IRQ %d\n", pci
->irq
);
1028 goto request_irq_failed
;
1030 chip
->irq
= pci
->irq
;
1032 err
= snd_device_new(card
, SNDRV_DEV_LOWLEVEL
, chip
, &ops
);
1034 goto device_new_failed
;
1036 err
= lx_init_dsp(chip
);
1038 snd_printk(KERN_ERR LXP
"error during DSP initialization\n");
1042 err
= lx_pcm_create(chip
);
1046 err
= lx_proc_create(card
, chip
);
1050 err
= snd_ctl_add(card
, snd_ctl_new1(&lx_control_playback_switch
,
1055 snd_card_set_dev(card
, &pci
->dev
);
1061 free_irq(pci
->irq
, chip
);
1064 pci_release_regions(pci
);
1066 request_regions_failed
:
1070 pci_disable_device(pci
);
1075 static int __devinit
snd_lx6464es_probe(struct pci_dev
*pci
,
1076 const struct pci_device_id
*pci_id
)
1079 struct snd_card
*card
;
1080 struct lx6464es
*chip
;
1083 snd_printdd("->snd_lx6464es_probe\n");
1085 if (dev
>= SNDRV_CARDS
)
1092 err
= snd_card_create(index
[dev
], id
[dev
], THIS_MODULE
, 0, &card
);
1096 err
= snd_lx6464es_create(card
, pci
, &chip
);
1098 snd_printk(KERN_ERR LXP
"error during snd_lx6464es_create\n");
1102 strcpy(card
->driver
, "lx6464es");
1103 strcpy(card
->shortname
, "Digigram LX6464ES");
1104 sprintf(card
->longname
, "%s at 0x%lx, 0x%p, irq %i",
1105 card
->shortname
, chip
->port_plx
,
1106 chip
->port_dsp_bar
, chip
->irq
);
1108 err
= snd_card_register(card
);
1112 snd_printdd(LXP
"initialization successful\n");
1113 pci_set_drvdata(pci
, card
);
1118 snd_card_free(card
);
1123 static void __devexit
snd_lx6464es_remove(struct pci_dev
*pci
)
1125 snd_card_free(pci_get_drvdata(pci
));
1126 pci_set_drvdata(pci
, NULL
);
1130 static struct pci_driver driver
= {
1131 .name
= "Digigram LX6464ES",
1132 .id_table
= snd_lx6464es_ids
,
1133 .probe
= snd_lx6464es_probe
,
1134 .remove
= __devexit_p(snd_lx6464es_remove
),
1138 /* module initialization */
1139 static int __init
mod_init(void)
1141 return pci_register_driver(&driver
);
1144 static void __exit
mod_exit(void)
1146 pci_unregister_driver(&driver
);
1149 module_init(mod_init
);
1150 module_exit(mod_exit
);