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 bool 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 const struct pci_device_id snd_lx6464es_ids
[] = {
60 { PCI_DEVICE_SUB(PCI_VENDOR_ID_PLX
, PCI_DEVICE_ID_PLX_LX6464ES
,
61 PCI_VENDOR_ID_DIGIGRAM
,
62 PCI_SUBDEVICE_ID_DIGIGRAM_LX6464ES_SERIAL_SUBSYSTEM
),
64 { PCI_DEVICE_SUB(PCI_VENDOR_ID_PLX
, PCI_DEVICE_ID_PLX_LX6464ES
,
65 PCI_VENDOR_ID_DIGIGRAM
,
66 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 const 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 dev_dbg(chip
->card
->dev
, "allocating pipe for %d channels\n", channels
);
116 err
= lx_pipe_allocate(chip
, 0, is_capture
, channels
);
118 dev_err(chip
->card
->dev
, LXP
"allocating pipe failed\n");
122 err
= lx_set_granularity(chip
, period_size
);
124 dev_err(chip
->card
->dev
, "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 dev_dbg(chip
->card
->dev
, "setting stream format\n");
140 err
= lx_stream_set_format(chip
, runtime
, 0, is_capture
);
142 dev_err(chip
->card
->dev
, "setting stream format failed\n");
146 dev_dbg(chip
->card
->dev
, "starting pipe\n");
147 err
= lx_pipe_start(chip
, 0, is_capture
);
149 dev_err(chip
->card
->dev
, "starting pipe failed\n");
153 dev_dbg(chip
->card
->dev
, "waiting for pipe to start\n");
154 err
= lx_pipe_wait_for_start(chip
, 0, is_capture
);
156 dev_err(chip
->card
->dev
, "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 dev_dbg(chip
->card
->dev
, "pausing pipe\n");
171 err
= lx_pipe_pause(chip
, 0, is_capture
);
173 dev_err(chip
->card
->dev
, "pausing pipe failed\n");
177 dev_dbg(chip
->card
->dev
, "waiting for pipe to become idle\n");
178 err
= lx_pipe_wait_for_idle(chip
, 0, is_capture
);
180 dev_err(chip
->card
->dev
, "waiting for pipe failed\n");
184 dev_dbg(chip
->card
->dev
, "stopping pipe\n");
185 err
= lx_pipe_stop(chip
, 0, is_capture
);
187 dev_err(chip
->card
->dev
, "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 dev_dbg(chip
->card
->dev
, "releasing pipe\n");
202 err
= lx_pipe_release(chip
, 0, is_capture
);
204 dev_err(chip
->card
->dev
, "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 dev_dbg(chip
->card
->dev
, "->lx_pcm_open\n");
220 mutex_lock(&chip
->setup_mutex
);
222 /* copy the struct snd_pcm_hardware struct */
223 runtime
->hw
= lx_caps
;
226 /* buffer-size should better be multiple of period-size */
227 err
= snd_pcm_hw_constraint_integer(runtime
,
228 SNDRV_PCM_HW_PARAM_PERIODS
);
230 dev_warn(chip
->card
->dev
, "could not constrain periods\n");
235 /* the clock rate cannot be changed */
236 board_rate
= chip
->board_sample_rate
;
237 err
= snd_pcm_hw_constraint_single(runtime
, SNDRV_PCM_HW_PARAM_RATE
,
241 dev_warn(chip
->card
->dev
, "could not constrain periods\n");
245 /* constrain period size */
246 err
= snd_pcm_hw_constraint_minmax(runtime
,
247 SNDRV_PCM_HW_PARAM_PERIOD_SIZE
,
251 dev_warn(chip
->card
->dev
,
252 "could not constrain period size\n");
256 snd_pcm_hw_constraint_step(runtime
, 0,
257 SNDRV_PCM_HW_PARAM_BUFFER_SIZE
, 32);
259 snd_pcm_set_sync(substream
);
263 runtime
->private_data
= chip
;
265 mutex_unlock(&chip
->setup_mutex
);
266 dev_dbg(chip
->card
->dev
, "<-lx_pcm_open, %d\n", err
);
270 static int lx_pcm_close(struct snd_pcm_substream
*substream
)
273 dev_dbg(substream
->pcm
->card
->dev
, "->lx_pcm_close\n");
277 static snd_pcm_uframes_t
lx_pcm_stream_pointer(struct snd_pcm_substream
280 struct lx6464es
*chip
= snd_pcm_substream_chip(substream
);
281 snd_pcm_uframes_t pos
;
282 int is_capture
= (substream
->stream
== SNDRV_PCM_STREAM_CAPTURE
);
284 struct lx_stream
*lx_stream
= is_capture
? &chip
->capture_stream
:
285 &chip
->playback_stream
;
287 dev_dbg(chip
->card
->dev
, "->lx_pcm_stream_pointer\n");
289 mutex_lock(&chip
->lock
);
290 pos
= lx_stream
->frame_pos
* substream
->runtime
->period_size
;
291 mutex_unlock(&chip
->lock
);
293 dev_dbg(chip
->card
->dev
, "stream_pointer at %ld\n", pos
);
297 static int lx_pcm_prepare(struct snd_pcm_substream
*substream
)
299 struct lx6464es
*chip
= snd_pcm_substream_chip(substream
);
301 const int is_capture
= (substream
->stream
== SNDRV_PCM_STREAM_CAPTURE
);
303 dev_dbg(chip
->card
->dev
, "->lx_pcm_prepare\n");
305 mutex_lock(&chip
->setup_mutex
);
307 if (chip
->hardware_running
[is_capture
]) {
308 err
= lx_hardware_stop(chip
, substream
);
310 dev_err(chip
->card
->dev
, "failed to stop hardware. "
311 "Error code %d\n", err
);
315 err
= lx_hardware_close(chip
, substream
);
317 dev_err(chip
->card
->dev
, "failed to close hardware. "
318 "Error code %d\n", err
);
323 dev_dbg(chip
->card
->dev
, "opening hardware\n");
324 err
= lx_hardware_open(chip
, substream
);
326 dev_err(chip
->card
->dev
, "failed to open hardware. "
327 "Error code %d\n", err
);
331 err
= lx_hardware_start(chip
, substream
);
333 dev_err(chip
->card
->dev
, "failed to start hardware. "
334 "Error code %d\n", err
);
338 chip
->hardware_running
[is_capture
] = 1;
340 if (chip
->board_sample_rate
!= substream
->runtime
->rate
) {
342 chip
->board_sample_rate
= substream
->runtime
->rate
;
346 mutex_unlock(&chip
->setup_mutex
);
350 static int lx_pcm_hw_params(struct snd_pcm_substream
*substream
,
351 struct snd_pcm_hw_params
*hw_params
, int is_capture
)
353 struct lx6464es
*chip
= snd_pcm_substream_chip(substream
);
356 dev_dbg(chip
->card
->dev
, "->lx_pcm_hw_params\n");
358 mutex_lock(&chip
->setup_mutex
);
361 err
= snd_pcm_lib_malloc_pages(substream
,
362 params_buffer_bytes(hw_params
));
365 chip
->capture_stream
.stream
= substream
;
367 chip
->playback_stream
.stream
= substream
;
369 mutex_unlock(&chip
->setup_mutex
);
373 static int lx_pcm_hw_params_playback(struct snd_pcm_substream
*substream
,
374 struct snd_pcm_hw_params
*hw_params
)
376 return lx_pcm_hw_params(substream
, hw_params
, 0);
379 static int lx_pcm_hw_params_capture(struct snd_pcm_substream
*substream
,
380 struct snd_pcm_hw_params
*hw_params
)
382 return lx_pcm_hw_params(substream
, hw_params
, 1);
385 static int lx_pcm_hw_free(struct snd_pcm_substream
*substream
)
387 struct lx6464es
*chip
= snd_pcm_substream_chip(substream
);
389 int is_capture
= (substream
->stream
== SNDRV_PCM_STREAM_CAPTURE
);
391 dev_dbg(chip
->card
->dev
, "->lx_pcm_hw_free\n");
392 mutex_lock(&chip
->setup_mutex
);
394 if (chip
->hardware_running
[is_capture
]) {
395 err
= lx_hardware_stop(chip
, substream
);
397 dev_err(chip
->card
->dev
, "failed to stop hardware. "
398 "Error code %d\n", err
);
402 err
= lx_hardware_close(chip
, substream
);
404 dev_err(chip
->card
->dev
, "failed to close hardware. "
405 "Error code %d\n", err
);
409 chip
->hardware_running
[is_capture
] = 0;
412 err
= snd_pcm_lib_free_pages(substream
);
415 chip
->capture_stream
.stream
= NULL
;
417 chip
->playback_stream
.stream
= NULL
;
420 mutex_unlock(&chip
->setup_mutex
);
424 static void lx_trigger_start(struct lx6464es
*chip
, struct lx_stream
*lx_stream
)
426 struct snd_pcm_substream
*substream
= lx_stream
->stream
;
427 const unsigned int is_capture
= lx_stream
->is_capture
;
431 const u32 channels
= substream
->runtime
->channels
;
432 const u32 bytes_per_frame
= channels
* 3;
433 const u32 period_size
= substream
->runtime
->period_size
;
434 const u32 periods
= substream
->runtime
->periods
;
435 const u32 period_bytes
= period_size
* bytes_per_frame
;
437 dma_addr_t buf
= substream
->dma_buffer
.addr
;
443 for (i
= 0; i
!= periods
; ++i
) {
444 u32 buffer_index
= 0;
446 err
= lx_buffer_ask(chip
, 0, is_capture
, &needed
, &freed
,
448 dev_dbg(chip
->card
->dev
, "starting: needed %d, freed %d\n",
451 err
= lx_buffer_give(chip
, 0, is_capture
, period_bytes
,
452 lower_32_bits(buf
), upper_32_bits(buf
),
455 dev_dbg(chip
->card
->dev
, "starting: buffer index %x on 0x%lx (%d bytes)\n",
456 buffer_index
, (unsigned long)buf
, period_bytes
);
460 err
= lx_buffer_ask(chip
, 0, is_capture
, &needed
, &freed
, size_array
);
461 dev_dbg(chip
->card
->dev
, "starting: needed %d, freed %d\n", needed
, freed
);
463 dev_dbg(chip
->card
->dev
, "starting: starting stream\n");
464 err
= lx_stream_start(chip
, 0, is_capture
);
466 dev_err(chip
->card
->dev
, "couldn't start stream\n");
468 lx_stream
->status
= LX_STREAM_STATUS_RUNNING
;
470 lx_stream
->frame_pos
= 0;
473 static void lx_trigger_stop(struct lx6464es
*chip
, struct lx_stream
*lx_stream
)
475 const unsigned int is_capture
= lx_stream
->is_capture
;
478 dev_dbg(chip
->card
->dev
, "stopping: stopping stream\n");
479 err
= lx_stream_stop(chip
, 0, is_capture
);
481 dev_err(chip
->card
->dev
, "couldn't stop stream\n");
483 lx_stream
->status
= LX_STREAM_STATUS_FREE
;
487 static void lx_trigger_dispatch_stream(struct lx6464es
*chip
,
488 struct lx_stream
*lx_stream
)
490 switch (lx_stream
->status
) {
491 case LX_STREAM_STATUS_SCHEDULE_RUN
:
492 lx_trigger_start(chip
, lx_stream
);
495 case LX_STREAM_STATUS_SCHEDULE_STOP
:
496 lx_trigger_stop(chip
, lx_stream
);
504 static int lx_pcm_trigger_dispatch(struct lx6464es
*chip
,
505 struct lx_stream
*lx_stream
, int cmd
)
509 mutex_lock(&chip
->lock
);
511 case SNDRV_PCM_TRIGGER_START
:
512 lx_stream
->status
= LX_STREAM_STATUS_SCHEDULE_RUN
;
515 case SNDRV_PCM_TRIGGER_STOP
:
516 lx_stream
->status
= LX_STREAM_STATUS_SCHEDULE_STOP
;
524 lx_trigger_dispatch_stream(chip
, &chip
->capture_stream
);
525 lx_trigger_dispatch_stream(chip
, &chip
->playback_stream
);
528 mutex_unlock(&chip
->lock
);
533 static int lx_pcm_trigger(struct snd_pcm_substream
*substream
, int cmd
)
535 struct lx6464es
*chip
= snd_pcm_substream_chip(substream
);
536 const int is_capture
= (substream
->stream
== SNDRV_PCM_STREAM_CAPTURE
);
537 struct lx_stream
*stream
= is_capture
? &chip
->capture_stream
:
538 &chip
->playback_stream
;
540 dev_dbg(chip
->card
->dev
, "->lx_pcm_trigger\n");
542 return lx_pcm_trigger_dispatch(chip
, stream
, cmd
);
545 static int snd_lx6464es_free(struct lx6464es
*chip
)
547 dev_dbg(chip
->card
->dev
, "->snd_lx6464es_free\n");
549 lx_irq_disable(chip
);
552 free_irq(chip
->irq
, chip
);
554 iounmap(chip
->port_dsp_bar
);
555 ioport_unmap(chip
->port_plx_remapped
);
557 pci_release_regions(chip
->pci
);
558 pci_disable_device(chip
->pci
);
565 static int snd_lx6464es_dev_free(struct snd_device
*device
)
567 return snd_lx6464es_free(device
->device_data
);
570 /* reset the dsp during initialization */
571 static int lx_init_xilinx_reset(struct lx6464es
*chip
)
574 u32 plx_reg
= lx_plx_reg_read(chip
, ePLX_CHIPSC
);
576 dev_dbg(chip
->card
->dev
, "->lx_init_xilinx_reset\n");
578 /* activate reset of xilinx */
579 plx_reg
&= ~CHIPSC_RESET_XILINX
;
581 lx_plx_reg_write(chip
, ePLX_CHIPSC
, plx_reg
);
584 lx_plx_reg_write(chip
, ePLX_MBOX3
, 0);
587 plx_reg
|= CHIPSC_RESET_XILINX
;
588 lx_plx_reg_write(chip
, ePLX_CHIPSC
, plx_reg
);
590 /* deactivate reset of xilinx */
591 for (i
= 0; i
!= 100; ++i
) {
594 reg_mbox3
= lx_plx_reg_read(chip
, ePLX_MBOX3
);
596 dev_dbg(chip
->card
->dev
, "xilinx reset done\n");
597 dev_dbg(chip
->card
->dev
, "xilinx took %d loops\n", i
);
602 /* todo: add some error handling? */
605 lx_dsp_reg_write(chip
, eReg_CSM
, 0);
607 /* le xilinx ES peut ne pas etre encore pret, on attend. */
613 static int lx_init_xilinx_test(struct lx6464es
*chip
)
617 dev_dbg(chip
->card
->dev
, "->lx_init_xilinx_test\n");
619 /* TEST if we have access to Xilinx/MicroBlaze */
620 lx_dsp_reg_write(chip
, eReg_CSM
, 0);
622 reg
= lx_dsp_reg_read(chip
, eReg_CSM
);
625 dev_err(chip
->card
->dev
, "Problem: Reg_CSM %x.\n", reg
);
627 /* PCI9056_SPACE0_REMAP */
628 lx_plx_reg_write(chip
, ePLX_PCICR
, 1);
630 reg
= lx_dsp_reg_read(chip
, eReg_CSM
);
632 dev_err(chip
->card
->dev
, "Error: Reg_CSM %x.\n", reg
);
633 return -EAGAIN
; /* seems to be appropriate */
637 dev_dbg(chip
->card
->dev
, "Xilinx/MicroBlaze access test successful\n");
642 /* initialize ethersound */
643 static int lx_init_ethersound_config(struct lx6464es
*chip
)
646 u32 orig_conf_es
= lx_dsp_reg_read(chip
, eReg_CONFES
);
648 /* configure 64 io channels */
649 u32 conf_es
= (orig_conf_es
& CONFES_READ_PART_MASK
) |
650 (64 << IOCR_INPUTS_OFFSET
) |
651 (64 << IOCR_OUTPUTS_OFFSET
) |
652 (FREQ_RATIO_SINGLE_MODE
<< FREQ_RATIO_OFFSET
);
654 dev_dbg(chip
->card
->dev
, "->lx_init_ethersound\n");
656 chip
->freq_ratio
= FREQ_RATIO_SINGLE_MODE
;
659 * write it to the card !
660 * this actually kicks the ES xilinx, the first time since poweron.
661 * the MAC address in the Reg_ADMACESMSB Reg_ADMACESLSB registers
662 * is not ready before this is done, and the bit 2 in Reg_CSES is set.
664 lx_dsp_reg_write(chip
, eReg_CONFES
, conf_es
);
666 for (i
= 0; i
!= 1000; ++i
) {
667 if (lx_dsp_reg_read(chip
, eReg_CSES
) & 4) {
668 dev_dbg(chip
->card
->dev
, "ethersound initialized after %dms\n",
670 goto ethersound_initialized
;
674 dev_warn(chip
->card
->dev
,
675 "ethersound could not be initialized after %dms\n", i
);
678 ethersound_initialized
:
679 dev_dbg(chip
->card
->dev
, "ethersound initialized\n");
683 static int lx_init_get_version_features(struct lx6464es
*chip
)
689 dev_dbg(chip
->card
->dev
, "->lx_init_get_version_features\n");
691 err
= lx_dsp_get_version(chip
, &dsp_version
);
696 dev_info(chip
->card
->dev
, "DSP version: V%02d.%02d #%d\n",
697 (dsp_version
>>16) & 0xff, (dsp_version
>>8) & 0xff,
700 /* later: what firmware version do we expect? */
702 /* retrieve Play/Rec features */
703 /* done here because we may have to handle alternate
707 /* init the EtherSound sample rate */
708 err
= lx_dsp_get_clock_frequency(chip
, &freq
);
710 chip
->board_sample_rate
= freq
;
711 dev_dbg(chip
->card
->dev
, "actual clock frequency %d\n", freq
);
713 dev_err(chip
->card
->dev
, "DSP corrupted \n");
720 static int lx_set_granularity(struct lx6464es
*chip
, u32 gran
)
723 u32 snapped_gran
= MICROBLAZE_IBL_MIN
;
725 dev_dbg(chip
->card
->dev
, "->lx_set_granularity\n");
727 /* blocksize is a power of 2 */
728 while ((snapped_gran
< gran
) &&
729 (snapped_gran
< MICROBLAZE_IBL_MAX
)) {
733 if (snapped_gran
== chip
->pcm_granularity
)
736 err
= lx_dsp_set_granularity(chip
, snapped_gran
);
738 dev_warn(chip
->card
->dev
, "could not set granularity\n");
742 if (snapped_gran
!= gran
)
743 dev_err(chip
->card
->dev
, "snapped blocksize to %d\n", snapped_gran
);
745 dev_dbg(chip
->card
->dev
, "set blocksize on board %d\n", snapped_gran
);
746 chip
->pcm_granularity
= snapped_gran
;
751 /* initialize and test the xilinx dsp chip */
752 static int lx_init_dsp(struct lx6464es
*chip
)
757 dev_dbg(chip
->card
->dev
, "->lx_init_dsp\n");
759 dev_dbg(chip
->card
->dev
, "initialize board\n");
760 err
= lx_init_xilinx_reset(chip
);
764 dev_dbg(chip
->card
->dev
, "testing board\n");
765 err
= lx_init_xilinx_test(chip
);
769 dev_dbg(chip
->card
->dev
, "initialize ethersound configuration\n");
770 err
= lx_init_ethersound_config(chip
);
776 /** \todo the mac address should be ready by not, but it isn't,
777 * so we wait for it */
778 for (i
= 0; i
!= 1000; ++i
) {
779 err
= lx_dsp_get_mac(chip
);
782 if (chip
->mac_address
[0] || chip
->mac_address
[1] || chip
->mac_address
[2] ||
783 chip
->mac_address
[3] || chip
->mac_address
[4] || chip
->mac_address
[5])
790 dev_dbg(chip
->card
->dev
, "mac address ready read after: %dms\n", i
);
791 dev_info(chip
->card
->dev
,
792 "mac address: %02X.%02X.%02X.%02X.%02X.%02X\n",
793 chip
->mac_address
[0], chip
->mac_address
[1], chip
->mac_address
[2],
794 chip
->mac_address
[3], chip
->mac_address
[4], chip
->mac_address
[5]);
796 err
= lx_init_get_version_features(chip
);
800 lx_set_granularity(chip
, MICROBLAZE_IBL_DEFAULT
);
802 chip
->playback_mute
= 0;
807 static const struct snd_pcm_ops lx_ops_playback
= {
809 .close
= lx_pcm_close
,
810 .ioctl
= snd_pcm_lib_ioctl
,
811 .prepare
= lx_pcm_prepare
,
812 .hw_params
= lx_pcm_hw_params_playback
,
813 .hw_free
= lx_pcm_hw_free
,
814 .trigger
= lx_pcm_trigger
,
815 .pointer
= lx_pcm_stream_pointer
,
818 static const struct snd_pcm_ops lx_ops_capture
= {
820 .close
= lx_pcm_close
,
821 .ioctl
= snd_pcm_lib_ioctl
,
822 .prepare
= lx_pcm_prepare
,
823 .hw_params
= lx_pcm_hw_params_capture
,
824 .hw_free
= lx_pcm_hw_free
,
825 .trigger
= lx_pcm_trigger
,
826 .pointer
= lx_pcm_stream_pointer
,
829 static int lx_pcm_create(struct lx6464es
*chip
)
834 u32 size
= 64 * /* channels */
835 3 * /* 24 bit samples */
836 MAX_STREAM_BUFFER
* /* periods */
837 MICROBLAZE_IBL_MAX
* /* frames per period */
840 size
= PAGE_ALIGN(size
);
842 /* hardcoded device name & channel count */
843 err
= snd_pcm_new(chip
->card
, (char *)card_name
, 0,
848 pcm
->private_data
= chip
;
850 snd_pcm_set_ops(pcm
, SNDRV_PCM_STREAM_PLAYBACK
, &lx_ops_playback
);
851 snd_pcm_set_ops(pcm
, SNDRV_PCM_STREAM_CAPTURE
, &lx_ops_capture
);
854 pcm
->nonatomic
= true;
855 strcpy(pcm
->name
, card_name
);
857 err
= snd_pcm_lib_preallocate_pages_for_all(pcm
, SNDRV_DMA_TYPE_DEV
,
858 snd_dma_pci_data(chip
->pci
),
864 chip
->capture_stream
.is_capture
= 1;
869 static int lx_control_playback_info(struct snd_kcontrol
*kcontrol
,
870 struct snd_ctl_elem_info
*uinfo
)
872 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_BOOLEAN
;
874 uinfo
->value
.integer
.min
= 0;
875 uinfo
->value
.integer
.max
= 1;
879 static int lx_control_playback_get(struct snd_kcontrol
*kcontrol
,
880 struct snd_ctl_elem_value
*ucontrol
)
882 struct lx6464es
*chip
= snd_kcontrol_chip(kcontrol
);
883 ucontrol
->value
.integer
.value
[0] = chip
->playback_mute
;
887 static int lx_control_playback_put(struct snd_kcontrol
*kcontrol
,
888 struct snd_ctl_elem_value
*ucontrol
)
890 struct lx6464es
*chip
= snd_kcontrol_chip(kcontrol
);
892 int current_value
= chip
->playback_mute
;
894 if (current_value
!= ucontrol
->value
.integer
.value
[0]) {
895 lx_level_unmute(chip
, 0, !current_value
);
896 chip
->playback_mute
= !current_value
;
902 static const struct snd_kcontrol_new lx_control_playback_switch
= {
903 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
904 .name
= "PCM Playback Switch",
906 .access
= SNDRV_CTL_ELEM_ACCESS_READWRITE
,
908 .info
= lx_control_playback_info
,
909 .get
= lx_control_playback_get
,
910 .put
= lx_control_playback_put
915 static void lx_proc_levels_read(struct snd_info_entry
*entry
,
916 struct snd_info_buffer
*buffer
)
921 struct lx6464es
*chip
= entry
->private_data
;
923 snd_iprintf(buffer
, "capture levels:\n");
924 err
= lx_level_peaks(chip
, 1, 64, levels
);
928 for (i
= 0; i
!= 8; ++i
) {
929 for (j
= 0; j
!= 8; ++j
)
930 snd_iprintf(buffer
, "%08x ", levels
[i
*8+j
]);
931 snd_iprintf(buffer
, "\n");
934 snd_iprintf(buffer
, "\nplayback levels:\n");
936 err
= lx_level_peaks(chip
, 0, 64, levels
);
940 for (i
= 0; i
!= 8; ++i
) {
941 for (j
= 0; j
!= 8; ++j
)
942 snd_iprintf(buffer
, "%08x ", levels
[i
*8+j
]);
943 snd_iprintf(buffer
, "\n");
946 snd_iprintf(buffer
, "\n");
949 static int lx_proc_create(struct snd_card
*card
, struct lx6464es
*chip
)
951 struct snd_info_entry
*entry
;
952 int err
= snd_card_proc_new(card
, "levels", &entry
);
956 snd_info_set_text_ops(entry
, chip
, lx_proc_levels_read
);
961 static int snd_lx6464es_create(struct snd_card
*card
,
963 struct lx6464es
**rchip
)
965 struct lx6464es
*chip
;
968 static struct snd_device_ops ops
= {
969 .dev_free
= snd_lx6464es_dev_free
,
972 dev_dbg(card
->dev
, "->snd_lx6464es_create\n");
976 /* enable PCI device */
977 err
= pci_enable_device(pci
);
983 /* check if we can restrict PCI DMA transfers to 32 bits */
984 err
= dma_set_mask(&pci
->dev
, DMA_BIT_MASK(32));
987 "architecture does not support 32bit PCI busmaster DMA\n");
988 pci_disable_device(pci
);
992 chip
= kzalloc(sizeof(*chip
), GFP_KERNEL
);
1002 /* initialize synchronization structs */
1003 mutex_init(&chip
->lock
);
1004 mutex_init(&chip
->msg_lock
);
1005 mutex_init(&chip
->setup_mutex
);
1007 /* request resources */
1008 err
= pci_request_regions(pci
, card_name
);
1010 goto request_regions_failed
;
1013 chip
->port_plx
= pci_resource_start(pci
, 1);
1014 chip
->port_plx_remapped
= ioport_map(chip
->port_plx
,
1015 pci_resource_len(pci
, 1));
1018 chip
->port_dsp_bar
= pci_ioremap_bar(pci
, 2);
1020 err
= request_threaded_irq(pci
->irq
, lx_interrupt
, lx_threaded_irq
,
1021 IRQF_SHARED
, KBUILD_MODNAME
, chip
);
1023 dev_err(card
->dev
, "unable to grab IRQ %d\n", pci
->irq
);
1024 goto request_irq_failed
;
1026 chip
->irq
= pci
->irq
;
1028 err
= snd_device_new(card
, SNDRV_DEV_LOWLEVEL
, chip
, &ops
);
1030 goto device_new_failed
;
1032 err
= lx_init_dsp(chip
);
1034 dev_err(card
->dev
, "error during DSP initialization\n");
1038 err
= lx_pcm_create(chip
);
1042 err
= lx_proc_create(card
, chip
);
1046 err
= snd_ctl_add(card
, snd_ctl_new1(&lx_control_playback_switch
,
1055 free_irq(pci
->irq
, chip
);
1058 pci_release_regions(pci
);
1060 request_regions_failed
:
1064 pci_disable_device(pci
);
1069 static int snd_lx6464es_probe(struct pci_dev
*pci
,
1070 const struct pci_device_id
*pci_id
)
1073 struct snd_card
*card
;
1074 struct lx6464es
*chip
;
1077 dev_dbg(&pci
->dev
, "->snd_lx6464es_probe\n");
1079 if (dev
>= SNDRV_CARDS
)
1086 err
= snd_card_new(&pci
->dev
, index
[dev
], id
[dev
], THIS_MODULE
,
1091 err
= snd_lx6464es_create(card
, pci
, &chip
);
1093 dev_err(card
->dev
, "error during snd_lx6464es_create\n");
1097 strcpy(card
->driver
, "LX6464ES");
1098 sprintf(card
->id
, "LX6464ES_%02X%02X%02X",
1099 chip
->mac_address
[3], chip
->mac_address
[4], chip
->mac_address
[5]);
1101 sprintf(card
->shortname
, "LX6464ES %02X.%02X.%02X.%02X.%02X.%02X",
1102 chip
->mac_address
[0], chip
->mac_address
[1], chip
->mac_address
[2],
1103 chip
->mac_address
[3], chip
->mac_address
[4], chip
->mac_address
[5]);
1105 sprintf(card
->longname
, "%s at 0x%lx, 0x%p, irq %i",
1106 card
->shortname
, chip
->port_plx
,
1107 chip
->port_dsp_bar
, chip
->irq
);
1109 err
= snd_card_register(card
);
1113 dev_dbg(chip
->card
->dev
, "initialization successful\n");
1114 pci_set_drvdata(pci
, card
);
1119 snd_card_free(card
);
1124 static void snd_lx6464es_remove(struct pci_dev
*pci
)
1126 snd_card_free(pci_get_drvdata(pci
));
1130 static struct pci_driver lx6464es_driver
= {
1131 .name
= KBUILD_MODNAME
,
1132 .id_table
= snd_lx6464es_ids
,
1133 .probe
= snd_lx6464es_probe
,
1134 .remove
= snd_lx6464es_remove
,
1137 module_pci_driver(lx6464es_driver
);