2 * Audio support for PS3
3 * Copyright (C) 2007 Sony Computer Entertainment Inc.
5 * Copyright 2006, 2007 Sony Corporation
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License
9 * as published by the Free Software Foundation; version 2 of the Licence.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 #include <linux/dma-mapping.h>
22 #include <linux/dmapool.h>
23 #include <linux/gfp.h>
24 #include <linux/init.h>
25 #include <linux/interrupt.h>
27 #include <linux/module.h>
29 #include <sound/asound.h>
30 #include <sound/control.h>
31 #include <sound/core.h>
32 #include <sound/initval.h>
33 #include <sound/memalloc.h>
34 #include <sound/pcm.h>
35 #include <sound/pcm_params.h>
38 #include <asm/firmware.h>
39 #include <asm/lv1call.h>
41 #include <asm/ps3av.h>
44 #include "snd_ps3_reg.h"
50 static struct snd_ps3_card_info the_card
;
52 static int snd_ps3_start_delay
= CONFIG_SND_PS3_DEFAULT_START_DELAY
;
54 module_param_named(start_delay
, snd_ps3_start_delay
, uint
, 0644);
55 MODULE_PARM_DESC(start_delay
, "time to insert silent data in ms");
57 static int index
= SNDRV_DEFAULT_IDX1
;
58 static char *id
= SNDRV_DEFAULT_STR1
;
60 module_param(index
, int, 0444);
61 MODULE_PARM_DESC(index
, "Index value for PS3 soundchip.");
62 module_param(id
, charp
, 0444);
63 MODULE_PARM_DESC(id
, "ID string for PS3 soundchip.");
67 * PS3 audio register access
69 static inline u32
read_reg(unsigned int reg
)
71 return in_be32(the_card
.mapped_mmio_vaddr
+ reg
);
73 static inline void write_reg(unsigned int reg
, u32 val
)
75 out_be32(the_card
.mapped_mmio_vaddr
+ reg
, val
);
77 static inline void update_reg(unsigned int reg
, u32 or_val
)
79 u32 newval
= read_reg(reg
) | or_val
;
80 write_reg(reg
, newval
);
82 static inline void update_mask_reg(unsigned int reg
, u32 mask
, u32 or_val
)
84 u32 newval
= (read_reg(reg
) & mask
) | or_val
;
85 write_reg(reg
, newval
);
91 static const struct snd_pcm_hardware snd_ps3_pcm_hw
= {
92 .info
= (SNDRV_PCM_INFO_MMAP
|
93 SNDRV_PCM_INFO_NONINTERLEAVED
|
94 SNDRV_PCM_INFO_MMAP_VALID
),
95 .formats
= (SNDRV_PCM_FMTBIT_S16_BE
|
96 SNDRV_PCM_FMTBIT_S24_BE
),
97 .rates
= (SNDRV_PCM_RATE_44100
|
98 SNDRV_PCM_RATE_48000
|
99 SNDRV_PCM_RATE_88200
|
100 SNDRV_PCM_RATE_96000
),
104 .channels_min
= 2, /* stereo only */
107 .buffer_bytes_max
= PS3_AUDIO_FIFO_SIZE
* 64,
109 /* interrupt by four stages */
110 .period_bytes_min
= PS3_AUDIO_FIFO_STAGE_SIZE
* 4,
111 .period_bytes_max
= PS3_AUDIO_FIFO_STAGE_SIZE
* 4,
114 .periods_max
= 32, /* buffer_size_max/ period_bytes_max */
116 .fifo_size
= PS3_AUDIO_FIFO_SIZE
119 static int snd_ps3_verify_dma_stop(struct snd_ps3_card_info
*card
,
120 int count
, int force_stop
)
122 int dma_ch
, done
, retries
, stop_forced
= 0;
125 for (dma_ch
= 0; dma_ch
< 8; dma_ch
++) {
128 status
= read_reg(PS3_AUDIO_KICK(dma_ch
)) &
129 PS3_AUDIO_KICK_STATUS_MASK
;
131 case PS3_AUDIO_KICK_STATUS_DONE
:
132 case PS3_AUDIO_KICK_STATUS_NOTIFY
:
133 case PS3_AUDIO_KICK_STATUS_CLEAR
:
134 case PS3_AUDIO_KICK_STATUS_ERROR
:
141 } while (!done
&& --retries
);
142 if (!retries
&& force_stop
) {
143 pr_info("%s: DMA ch %d is not stopped.",
145 /* last resort. force to stop dma.
146 * NOTE: this cause DMA done interrupts
148 update_reg(PS3_AUDIO_CONFIG
, PS3_AUDIO_CONFIG_CLEAR
);
156 * wait for all dma is done.
157 * NOTE: caller should reset card->running before call.
158 * If not, the interrupt handler will re-start DMA,
159 * then DMA is never stopped.
161 static void snd_ps3_wait_for_dma_stop(struct snd_ps3_card_info
*card
)
165 * wait for the last dma is done
169 * expected maximum DMA done time is 5.7ms + something (DMA itself).
170 * 5.7ms is from 16bit/sample 2ch 44.1Khz; the time next
171 * DMA kick event would occur.
173 stop_forced
= snd_ps3_verify_dma_stop(card
, 700, 1);
176 * clear outstanding interrupts.
178 update_reg(PS3_AUDIO_INTR_0
, 0);
179 update_reg(PS3_AUDIO_AX_IS
, 0);
182 *revert CLEAR bit since it will not reset automatically after DMA stop
185 update_mask_reg(PS3_AUDIO_CONFIG
, ~PS3_AUDIO_CONFIG_CLEAR
, 0);
186 /* ensure the hardware sees changes */
190 static void snd_ps3_kick_dma(struct snd_ps3_card_info
*card
)
193 update_reg(PS3_AUDIO_KICK(0), PS3_AUDIO_KICK_REQUEST
);
194 /* ensure the hardware sees the change */
199 * convert virtual addr to ioif bus addr.
201 static dma_addr_t
v_to_bus(struct snd_ps3_card_info
*card
, void *paddr
, int ch
)
203 return card
->dma_start_bus_addr
[ch
] +
204 (paddr
- card
->dma_start_vaddr
[ch
]);
209 * increment ring buffer pointer.
210 * NOTE: caller must hold write spinlock
212 static void snd_ps3_bump_buffer(struct snd_ps3_card_info
*card
,
213 enum snd_ps3_ch ch
, size_t byte_count
,
217 card
->dma_last_transfer_vaddr
[ch
] =
218 card
->dma_next_transfer_vaddr
[ch
];
219 card
->dma_next_transfer_vaddr
[ch
] += byte_count
;
220 if ((card
->dma_start_vaddr
[ch
] + (card
->dma_buffer_size
/ 2)) <=
221 card
->dma_next_transfer_vaddr
[ch
]) {
222 card
->dma_next_transfer_vaddr
[ch
] = card
->dma_start_vaddr
[ch
];
226 * setup dmac to send data to audio and attenuate samples on the ring buffer
228 static int snd_ps3_program_dma(struct snd_ps3_card_info
*card
,
229 enum snd_ps3_dma_filltype filltype
)
231 /* this dmac does not support over 4G */
233 int fill_stages
, dma_ch
, stage
;
235 uint32_t ch0_kick_event
= 0; /* initialize to mute gcc */
237 unsigned long irqsave
;
241 case SND_PS3_DMA_FILLTYPE_SILENT_FIRSTFILL
:
243 /* intentionally fall thru */
244 case SND_PS3_DMA_FILLTYPE_FIRSTFILL
:
245 ch0_kick_event
= PS3_AUDIO_KICK_EVENT_ALWAYS
;
248 case SND_PS3_DMA_FILLTYPE_SILENT_RUNNING
:
250 /* intentionally fall thru */
251 case SND_PS3_DMA_FILLTYPE_RUNNING
:
252 ch0_kick_event
= PS3_AUDIO_KICK_EVENT_SERIALOUT0_EMPTY
;
256 snd_ps3_verify_dma_stop(card
, 700, 0);
258 spin_lock_irqsave(&card
->dma_lock
, irqsave
);
259 for (ch
= 0; ch
< 2; ch
++) {
260 start_vaddr
= card
->dma_next_transfer_vaddr
[0];
261 for (stage
= 0; stage
< fill_stages
; stage
++) {
262 dma_ch
= stage
* 2 + ch
;
264 dma_addr
= card
->null_buffer_start_dma_addr
;
268 card
->dma_next_transfer_vaddr
[ch
],
271 write_reg(PS3_AUDIO_SOURCE(dma_ch
),
272 (PS3_AUDIO_SOURCE_TARGET_SYSTEM_MEMORY
|
275 /* dst: fixed to 3wire#0 */
277 write_reg(PS3_AUDIO_DEST(dma_ch
),
278 (PS3_AUDIO_DEST_TARGET_AUDIOFIFO
|
279 PS3_AUDIO_AO_3W_LDATA(0)));
281 write_reg(PS3_AUDIO_DEST(dma_ch
),
282 (PS3_AUDIO_DEST_TARGET_AUDIOFIFO
|
283 PS3_AUDIO_AO_3W_RDATA(0)));
285 /* count always 1 DMA block (1/2 stage = 128 bytes) */
286 write_reg(PS3_AUDIO_DMASIZE(dma_ch
), 0);
287 /* bump pointer if needed */
289 snd_ps3_bump_buffer(card
, ch
,
290 PS3_AUDIO_DMAC_BLOCK_SIZE
,
295 write_reg(PS3_AUDIO_KICK(dma_ch
),
298 write_reg(PS3_AUDIO_KICK(dma_ch
),
299 PS3_AUDIO_KICK_EVENT_AUDIO_DMA(dma_ch
301 PS3_AUDIO_KICK_REQUEST
);
304 /* ensure the hardware sees the change */
306 spin_unlock_irqrestore(&card
->dma_lock
, irqsave
);
314 static irqreturn_t
snd_ps3_interrupt(int irq
, void *dev_id
)
318 int underflow_occured
= 0;
319 struct snd_ps3_card_info
*card
= dev_id
;
321 if (!card
->running
) {
322 update_reg(PS3_AUDIO_AX_IS
, 0);
323 update_reg(PS3_AUDIO_INTR_0
, 0);
327 port_intr
= read_reg(PS3_AUDIO_AX_IS
);
329 *serial buffer empty detected (every 4 times),
330 *program next dma and kick it
332 if (port_intr
& PS3_AUDIO_AX_IE_ASOBEIE(0)) {
333 write_reg(PS3_AUDIO_AX_IS
, PS3_AUDIO_AX_IE_ASOBEIE(0));
334 if (port_intr
& PS3_AUDIO_AX_IE_ASOBUIE(0)) {
335 write_reg(PS3_AUDIO_AX_IS
, port_intr
);
336 underflow_occured
= 1;
339 /* we are still in silent time */
340 snd_ps3_program_dma(card
,
341 (underflow_occured
) ?
342 SND_PS3_DMA_FILLTYPE_SILENT_FIRSTFILL
:
343 SND_PS3_DMA_FILLTYPE_SILENT_RUNNING
);
344 snd_ps3_kick_dma(card
);
347 snd_ps3_program_dma(card
,
348 (underflow_occured
) ?
349 SND_PS3_DMA_FILLTYPE_FIRSTFILL
:
350 SND_PS3_DMA_FILLTYPE_RUNNING
);
351 snd_ps3_kick_dma(card
);
352 snd_pcm_period_elapsed(card
->substream
);
354 } else if (port_intr
& PS3_AUDIO_AX_IE_ASOBUIE(0)) {
355 write_reg(PS3_AUDIO_AX_IS
, PS3_AUDIO_AX_IE_ASOBUIE(0));
357 * serial out underflow, but buffer empty not detected.
358 * in this case, fill fifo with 0 to recover. After
359 * filling dummy data, serial automatically start to
360 * consume them and then will generate normal buffer
362 * If both buffer underflow and buffer empty are occurred,
363 * it is better to do nomal data transfer than empty one
365 snd_ps3_program_dma(card
,
366 SND_PS3_DMA_FILLTYPE_SILENT_FIRSTFILL
);
367 snd_ps3_kick_dma(card
);
368 snd_ps3_program_dma(card
,
369 SND_PS3_DMA_FILLTYPE_SILENT_FIRSTFILL
);
370 snd_ps3_kick_dma(card
);
372 /* clear interrupt cause */
378 * mute_on : 0 output enabled
381 static int snd_ps3_mute(int mute_on
)
383 return ps3av_audio_mute(mute_on
);
388 * NOTE: calling this function may generate audio interrupt.
390 static int snd_ps3_change_avsetting(struct snd_ps3_card_info
*card
)
393 pr_debug("%s: start\n", __func__
);
395 ret
= ps3av_set_audio_mode(card
->avs
.avs_audio_ch
,
396 card
->avs
.avs_audio_rate
,
397 card
->avs
.avs_audio_width
,
398 card
->avs
.avs_audio_format
,
399 card
->avs
.avs_audio_source
);
401 * Reset the following unwanted settings:
404 /* disable all 3wire buffers */
405 update_mask_reg(PS3_AUDIO_AO_3WMCTRL
,
406 ~(PS3_AUDIO_AO_3WMCTRL_ASOEN(0) |
407 PS3_AUDIO_AO_3WMCTRL_ASOEN(1) |
408 PS3_AUDIO_AO_3WMCTRL_ASOEN(2) |
409 PS3_AUDIO_AO_3WMCTRL_ASOEN(3)),
411 wmb(); /* ensure the hardware sees the change */
412 /* wait for actually stopped */
414 while ((read_reg(PS3_AUDIO_AO_3WMCTRL
) &
415 (PS3_AUDIO_AO_3WMCTRL_ASORUN(0) |
416 PS3_AUDIO_AO_3WMCTRL_ASORUN(1) |
417 PS3_AUDIO_AO_3WMCTRL_ASORUN(2) |
418 PS3_AUDIO_AO_3WMCTRL_ASORUN(3))) &&
423 /* reset buffer pointer */
424 for (i
= 0; i
< 4; i
++) {
425 update_reg(PS3_AUDIO_AO_3WCTRL(i
),
426 PS3_AUDIO_AO_3WCTRL_ASOBRST_RESET
);
429 wmb(); /* ensure the hardware actually start resetting */
431 /* enable 3wire#0 buffer */
432 update_reg(PS3_AUDIO_AO_3WMCTRL
, PS3_AUDIO_AO_3WMCTRL_ASOEN(0));
435 /* In 24bit mode,ALSA inserts a zero byte at first byte of per sample */
436 update_mask_reg(PS3_AUDIO_AO_3WCTRL(0),
437 ~PS3_AUDIO_AO_3WCTRL_ASODF
,
438 PS3_AUDIO_AO_3WCTRL_ASODF_LSB
);
439 update_mask_reg(PS3_AUDIO_AO_SPDCTRL(0),
440 ~PS3_AUDIO_AO_SPDCTRL_SPODF
,
441 PS3_AUDIO_AO_SPDCTRL_SPODF_LSB
);
442 /* ensure all the setting above is written back to register */
444 /* avsetting driver altered AX_IE, caller must reset it if you want */
445 pr_debug("%s: end\n", __func__
);
450 * set sampling rate according to the substream
452 static int snd_ps3_set_avsetting(struct snd_pcm_substream
*substream
)
454 struct snd_ps3_card_info
*card
= snd_pcm_substream_chip(substream
);
455 struct snd_ps3_avsetting_info avs
;
460 pr_debug("%s: called freq=%d width=%d\n", __func__
,
461 substream
->runtime
->rate
,
462 snd_pcm_format_width(substream
->runtime
->format
));
464 pr_debug("%s: before freq=%d width=%d\n", __func__
,
465 card
->avs
.avs_audio_rate
, card
->avs
.avs_audio_width
);
468 switch (substream
->runtime
->rate
) {
470 avs
.avs_audio_rate
= PS3AV_CMD_AUDIO_FS_44K
;
473 avs
.avs_audio_rate
= PS3AV_CMD_AUDIO_FS_48K
;
476 avs
.avs_audio_rate
= PS3AV_CMD_AUDIO_FS_88K
;
479 avs
.avs_audio_rate
= PS3AV_CMD_AUDIO_FS_96K
;
482 pr_info("%s: invalid rate %d\n", __func__
,
483 substream
->runtime
->rate
);
488 switch (snd_pcm_format_width(substream
->runtime
->format
)) {
490 avs
.avs_audio_width
= PS3AV_CMD_AUDIO_WORD_BITS_16
;
493 avs
.avs_audio_width
= PS3AV_CMD_AUDIO_WORD_BITS_24
;
496 pr_info("%s: invalid width %d\n", __func__
,
497 snd_pcm_format_width(substream
->runtime
->format
));
501 memcpy(avs
.avs_cs_info
, ps3av_mode_cs_info
, 8);
503 if (memcmp(&card
->avs
, &avs
, sizeof(avs
))) {
504 pr_debug("%s: after freq=%d width=%d\n", __func__
,
505 card
->avs
.avs_audio_rate
, card
->avs
.avs_audio_width
);
508 snd_ps3_change_avsetting(card
);
513 /* check CS non-audio bit and mute accordingly */
514 if (avs
.avs_cs_info
[0] & 0x02)
515 ps3av_audio_mute_analog(1); /* mute if non-audio */
517 ps3av_audio_mute_analog(0);
525 static int snd_ps3_pcm_open(struct snd_pcm_substream
*substream
)
527 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
528 struct snd_ps3_card_info
*card
= snd_pcm_substream_chip(substream
);
531 pcm_index
= substream
->pcm
->device
;
532 /* to retrieve substream/runtime in interrupt handler */
533 card
->substream
= substream
;
535 runtime
->hw
= snd_ps3_pcm_hw
;
537 card
->start_delay
= snd_ps3_start_delay
;
540 snd_ps3_mute(0); /* this function sleep */
542 snd_pcm_hw_constraint_step(runtime
, 0, SNDRV_PCM_HW_PARAM_BUFFER_BYTES
,
543 PS3_AUDIO_FIFO_STAGE_SIZE
* 4 * 2);
547 static int snd_ps3_pcm_close(struct snd_pcm_substream
*substream
)
554 static int snd_ps3_pcm_hw_params(struct snd_pcm_substream
*substream
,
555 struct snd_pcm_hw_params
*hw_params
)
559 /* alloc transport buffer */
560 size
= params_buffer_bytes(hw_params
);
561 snd_pcm_lib_malloc_pages(substream
, size
);
565 static int snd_ps3_pcm_hw_free(struct snd_pcm_substream
*substream
)
567 return snd_pcm_lib_free_pages(substream
);
570 static int snd_ps3_delay_to_bytes(struct snd_pcm_substream
*substream
,
571 unsigned int delay_ms
)
576 rate
= substream
->runtime
->rate
;
577 ret
= snd_pcm_format_size(substream
->runtime
->format
,
578 rate
* delay_ms
/ 1000)
579 * substream
->runtime
->channels
;
581 pr_debug("%s: time=%d rate=%d bytes=%ld, frames=%d, ret=%d\n",
585 snd_pcm_format_size(substream
->runtime
->format
, rate
),
586 rate
* delay_ms
/ 1000,
592 static int snd_ps3_pcm_prepare(struct snd_pcm_substream
*substream
)
594 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
595 struct snd_ps3_card_info
*card
= snd_pcm_substream_chip(substream
);
596 unsigned long irqsave
;
598 if (!snd_ps3_set_avsetting(substream
)) {
599 /* some parameter changed */
600 write_reg(PS3_AUDIO_AX_IE
,
601 PS3_AUDIO_AX_IE_ASOBEIE(0) |
602 PS3_AUDIO_AX_IE_ASOBUIE(0));
604 * let SPDIF device re-lock with SPDIF signal,
605 * start with some silence
607 card
->silent
= snd_ps3_delay_to_bytes(substream
,
609 (PS3_AUDIO_FIFO_STAGE_SIZE
* 4); /* every 4 times */
612 /* restart ring buffer pointer */
613 spin_lock_irqsave(&card
->dma_lock
, irqsave
);
615 card
->dma_buffer_size
= runtime
->dma_bytes
;
617 card
->dma_last_transfer_vaddr
[SND_PS3_CH_L
] =
618 card
->dma_next_transfer_vaddr
[SND_PS3_CH_L
] =
619 card
->dma_start_vaddr
[SND_PS3_CH_L
] =
621 card
->dma_start_bus_addr
[SND_PS3_CH_L
] = runtime
->dma_addr
;
623 card
->dma_last_transfer_vaddr
[SND_PS3_CH_R
] =
624 card
->dma_next_transfer_vaddr
[SND_PS3_CH_R
] =
625 card
->dma_start_vaddr
[SND_PS3_CH_R
] =
626 runtime
->dma_area
+ (runtime
->dma_bytes
/ 2);
627 card
->dma_start_bus_addr
[SND_PS3_CH_R
] =
628 runtime
->dma_addr
+ (runtime
->dma_bytes
/ 2);
630 pr_debug("%s: vaddr=%p bus=%#llx\n", __func__
,
631 card
->dma_start_vaddr
[SND_PS3_CH_L
],
632 card
->dma_start_bus_addr
[SND_PS3_CH_L
]);
635 spin_unlock_irqrestore(&card
->dma_lock
, irqsave
);
637 /* ensure the hardware sees the change */
643 static int snd_ps3_pcm_trigger(struct snd_pcm_substream
*substream
,
646 struct snd_ps3_card_info
*card
= snd_pcm_substream_chip(substream
);
650 case SNDRV_PCM_TRIGGER_START
:
651 /* clear outstanding interrupts */
652 update_reg(PS3_AUDIO_AX_IS
, 0);
654 spin_lock(&card
->dma_lock
);
658 spin_unlock(&card
->dma_lock
);
660 snd_ps3_program_dma(card
,
661 SND_PS3_DMA_FILLTYPE_SILENT_FIRSTFILL
);
662 snd_ps3_kick_dma(card
);
663 while (read_reg(PS3_AUDIO_KICK(7)) &
664 PS3_AUDIO_KICK_STATUS_MASK
) {
667 snd_ps3_program_dma(card
, SND_PS3_DMA_FILLTYPE_SILENT_RUNNING
);
668 snd_ps3_kick_dma(card
);
671 case SNDRV_PCM_TRIGGER_STOP
:
672 spin_lock(&card
->dma_lock
);
676 spin_unlock(&card
->dma_lock
);
677 snd_ps3_wait_for_dma_stop(card
);
688 * report current pointer
690 static snd_pcm_uframes_t
snd_ps3_pcm_pointer(
691 struct snd_pcm_substream
*substream
)
693 struct snd_ps3_card_info
*card
= snd_pcm_substream_chip(substream
);
695 snd_pcm_uframes_t ret
;
697 spin_lock(&card
->dma_lock
);
699 bytes
= (size_t)(card
->dma_last_transfer_vaddr
[SND_PS3_CH_L
] -
700 card
->dma_start_vaddr
[SND_PS3_CH_L
]);
702 spin_unlock(&card
->dma_lock
);
704 ret
= bytes_to_frames(substream
->runtime
, bytes
* 2);
710 * SPDIF status bits controls
712 static int snd_ps3_spdif_mask_info(struct snd_kcontrol
*kcontrol
,
713 struct snd_ctl_elem_info
*uinfo
)
715 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_IEC958
;
720 /* FIXME: ps3av_set_audio_mode() assumes only consumer mode */
721 static int snd_ps3_spdif_cmask_get(struct snd_kcontrol
*kcontrol
,
722 struct snd_ctl_elem_value
*ucontrol
)
724 memset(ucontrol
->value
.iec958
.status
, 0xff, 8);
728 static int snd_ps3_spdif_pmask_get(struct snd_kcontrol
*kcontrol
,
729 struct snd_ctl_elem_value
*ucontrol
)
734 static int snd_ps3_spdif_default_get(struct snd_kcontrol
*kcontrol
,
735 struct snd_ctl_elem_value
*ucontrol
)
737 memcpy(ucontrol
->value
.iec958
.status
, ps3av_mode_cs_info
, 8);
741 static int snd_ps3_spdif_default_put(struct snd_kcontrol
*kcontrol
,
742 struct snd_ctl_elem_value
*ucontrol
)
744 if (memcmp(ps3av_mode_cs_info
, ucontrol
->value
.iec958
.status
, 8)) {
745 memcpy(ps3av_mode_cs_info
, ucontrol
->value
.iec958
.status
, 8);
751 static struct snd_kcontrol_new spdif_ctls
[] = {
753 .access
= SNDRV_CTL_ELEM_ACCESS_READ
,
754 .iface
= SNDRV_CTL_ELEM_IFACE_PCM
,
755 .name
= SNDRV_CTL_NAME_IEC958("", PLAYBACK
, CON_MASK
),
756 .info
= snd_ps3_spdif_mask_info
,
757 .get
= snd_ps3_spdif_cmask_get
,
760 .access
= SNDRV_CTL_ELEM_ACCESS_READ
,
761 .iface
= SNDRV_CTL_ELEM_IFACE_PCM
,
762 .name
= SNDRV_CTL_NAME_IEC958("", PLAYBACK
, PRO_MASK
),
763 .info
= snd_ps3_spdif_mask_info
,
764 .get
= snd_ps3_spdif_pmask_get
,
767 .iface
= SNDRV_CTL_ELEM_IFACE_PCM
,
768 .name
= SNDRV_CTL_NAME_IEC958("", PLAYBACK
, DEFAULT
),
769 .info
= snd_ps3_spdif_mask_info
,
770 .get
= snd_ps3_spdif_default_get
,
771 .put
= snd_ps3_spdif_default_put
,
775 static const struct snd_pcm_ops snd_ps3_pcm_spdif_ops
= {
776 .open
= snd_ps3_pcm_open
,
777 .close
= snd_ps3_pcm_close
,
778 .ioctl
= snd_pcm_lib_ioctl
,
779 .hw_params
= snd_ps3_pcm_hw_params
,
780 .hw_free
= snd_ps3_pcm_hw_free
,
781 .prepare
= snd_ps3_pcm_prepare
,
782 .trigger
= snd_ps3_pcm_trigger
,
783 .pointer
= snd_ps3_pcm_pointer
,
787 static int snd_ps3_map_mmio(void)
789 the_card
.mapped_mmio_vaddr
=
790 ioremap(the_card
.ps3_dev
->m_region
->bus_addr
,
791 the_card
.ps3_dev
->m_region
->len
);
793 if (!the_card
.mapped_mmio_vaddr
) {
794 pr_info("%s: ioremap 0 failed p=%#lx l=%#lx \n",
795 __func__
, the_card
.ps3_dev
->m_region
->lpar_addr
,
796 the_card
.ps3_dev
->m_region
->len
);
803 static void snd_ps3_unmap_mmio(void)
805 iounmap(the_card
.mapped_mmio_vaddr
);
806 the_card
.mapped_mmio_vaddr
= NULL
;
809 static int snd_ps3_allocate_irq(void)
812 u64 lpar_addr
, lpar_size
;
815 /* FIXME: move this to device_init (H/W probe) */
818 ret
= lv1_gpu_device_map(1, &lpar_addr
, &lpar_size
);
820 pr_info("%s: device map 1 failed %d\n", __func__
,
825 mapped
= ioremap(lpar_addr
, lpar_size
);
827 pr_info("%s: ioremap 1 failed \n", __func__
);
831 the_card
.audio_irq_outlet
= in_be64(mapped
);
834 ret
= lv1_gpu_device_unmap(1);
836 pr_info("%s: unmap 1 failed\n", __func__
);
839 ret
= ps3_irq_plug_setup(PS3_BINDING_CPU_ANY
,
840 the_card
.audio_irq_outlet
,
843 pr_info("%s:ps3_alloc_irq failed (%d)\n", __func__
, ret
);
847 ret
= request_irq(the_card
.irq_no
, snd_ps3_interrupt
, 0,
848 SND_PS3_DRIVER_NAME
, &the_card
);
850 pr_info("%s: request_irq failed (%d)\n", __func__
, ret
);
857 ps3_irq_plug_destroy(the_card
.irq_no
);
861 static void snd_ps3_free_irq(void)
863 free_irq(the_card
.irq_no
, &the_card
);
864 ps3_irq_plug_destroy(the_card
.irq_no
);
867 static void snd_ps3_audio_set_base_addr(uint64_t ioaddr_start
)
872 val
= (ioaddr_start
& (0x0fUL
<< 32)) >> (32 - 20) |
877 ret
= lv1_gpu_attribute(0x100, 0x007, val
);
879 pr_info("%s: gpu_attribute failed %d\n", __func__
,
883 static void snd_ps3_audio_fixup(struct snd_ps3_card_info
*card
)
886 * avsetting driver seems to never change the following
887 * so, init them here once
890 /* no dma interrupt needed */
891 write_reg(PS3_AUDIO_INTR_EN_0
, 0);
893 /* use every 4 buffer empty interrupt */
894 update_mask_reg(PS3_AUDIO_AX_IC
,
895 PS3_AUDIO_AX_IC_AASOIMD_MASK
,
896 PS3_AUDIO_AX_IC_AASOIMD_EVERY4
);
898 /* enable 3wire clocks */
899 update_mask_reg(PS3_AUDIO_AO_3WMCTRL
,
900 ~(PS3_AUDIO_AO_3WMCTRL_ASOBCLKD_DISABLED
|
901 PS3_AUDIO_AO_3WMCTRL_ASOLRCKD_DISABLED
),
903 update_reg(PS3_AUDIO_AO_3WMCTRL
,
904 PS3_AUDIO_AO_3WMCTRL_ASOPLRCK_DEFAULT
);
907 static int snd_ps3_init_avsetting(struct snd_ps3_card_info
*card
)
910 pr_debug("%s: start\n", __func__
);
911 card
->avs
.avs_audio_ch
= PS3AV_CMD_AUDIO_NUM_OF_CH_2
;
912 card
->avs
.avs_audio_rate
= PS3AV_CMD_AUDIO_FS_48K
;
913 card
->avs
.avs_audio_width
= PS3AV_CMD_AUDIO_WORD_BITS_16
;
914 card
->avs
.avs_audio_format
= PS3AV_CMD_AUDIO_FORMAT_PCM
;
915 card
->avs
.avs_audio_source
= PS3AV_CMD_AUDIO_SOURCE_SERIAL
;
916 memcpy(card
->avs
.avs_cs_info
, ps3av_mode_cs_info
, 8);
918 ret
= snd_ps3_change_avsetting(card
);
920 snd_ps3_audio_fixup(card
);
922 /* to start to generate SPDIF signal, fill data */
923 snd_ps3_program_dma(card
, SND_PS3_DMA_FILLTYPE_SILENT_FIRSTFILL
);
924 snd_ps3_kick_dma(card
);
925 pr_debug("%s: end\n", __func__
);
929 static int snd_ps3_driver_probe(struct ps3_system_bus_device
*dev
)
932 u64 lpar_addr
, lpar_size
;
934 if (WARN_ON(!firmware_has_feature(FW_FEATURE_PS3_LV1
)))
936 if (WARN_ON(dev
->match_id
!= PS3_MATCH_ID_SOUND
))
939 the_card
.ps3_dev
= dev
;
941 ret
= ps3_open_hv_device(dev
);
947 ret
= lv1_gpu_device_map(2, &lpar_addr
, &lpar_size
);
949 pr_info("%s: device map 2 failed %d\n", __func__
, ret
);
952 ps3_mmio_region_init(dev
, dev
->m_region
, lpar_addr
, lpar_size
,
955 ret
= snd_ps3_map_mmio();
960 ps3_dma_region_init(dev
, dev
->d_region
,
961 PAGE_SHIFT
, /* use system page size */
962 0, /* dma type; not used */
964 _ALIGN_UP(SND_PS3_DMA_REGION_SIZE
, PAGE_SIZE
));
965 dev
->d_region
->ioid
= PS3_AUDIO_IOID
;
967 ret
= ps3_dma_region_create(dev
->d_region
);
969 pr_info("%s: region_create\n", __func__
);
973 snd_ps3_audio_set_base_addr(dev
->d_region
->bus_addr
);
975 /* CONFIG_SND_PS3_DEFAULT_START_DELAY */
976 the_card
.start_delay
= snd_ps3_start_delay
;
979 if (snd_ps3_allocate_irq()) {
981 goto clean_dma_region
;
984 /* create card instance */
985 ret
= snd_card_new(&dev
->core
, index
, id
, THIS_MODULE
,
990 strcpy(the_card
.card
->driver
, "PS3");
991 strcpy(the_card
.card
->shortname
, "PS3");
992 strcpy(the_card
.card
->longname
, "PS3 sound");
994 /* create control elements */
995 for (i
= 0; i
< ARRAY_SIZE(spdif_ctls
); i
++) {
996 ret
= snd_ctl_add(the_card
.card
,
997 snd_ctl_new1(&spdif_ctls
[i
], &the_card
));
1002 /* create PCM devices instance */
1003 /* NOTE:this driver works assuming pcm:substream = 1:1 */
1004 ret
= snd_pcm_new(the_card
.card
,
1006 0, /* instance index, will be stored pcm.device*/
1007 1, /* output substream */
1008 0, /* input substream */
1013 the_card
.pcm
->private_data
= &the_card
;
1014 strcpy(the_card
.pcm
->name
, "SPDIF");
1017 snd_pcm_set_ops(the_card
.pcm
, SNDRV_PCM_STREAM_PLAYBACK
,
1018 &snd_ps3_pcm_spdif_ops
);
1020 the_card
.pcm
->info_flags
= SNDRV_PCM_INFO_NONINTERLEAVED
;
1021 /* pre-alloc PCM DMA buffer*/
1022 ret
= snd_pcm_lib_preallocate_pages_for_all(the_card
.pcm
,
1025 SND_PS3_PCM_PREALLOC_SIZE
,
1026 SND_PS3_PCM_PREALLOC_SIZE
);
1028 pr_info("%s: prealloc failed\n", __func__
);
1033 * allocate null buffer
1034 * its size should be lager than PS3_AUDIO_FIFO_STAGE_SIZE * 2
1035 * PAGE_SIZE is enogh
1037 the_card
.null_buffer_start_vaddr
=
1038 dma_alloc_coherent(&the_card
.ps3_dev
->core
,
1040 &the_card
.null_buffer_start_dma_addr
,
1042 if (!the_card
.null_buffer_start_vaddr
) {
1043 pr_info("%s: nullbuffer alloc failed\n", __func__
);
1047 pr_debug("%s: null vaddr=%p dma=%#llx\n", __func__
,
1048 the_card
.null_buffer_start_vaddr
,
1049 the_card
.null_buffer_start_dma_addr
);
1050 /* set default sample rate/word width */
1051 snd_ps3_init_avsetting(&the_card
);
1053 /* register the card */
1054 ret
= snd_card_register(the_card
.card
);
1058 pr_info("%s started. start_delay=%dms\n",
1059 the_card
.card
->longname
, the_card
.start_delay
);
1063 dma_free_coherent(&the_card
.ps3_dev
->core
,
1065 the_card
.null_buffer_start_vaddr
,
1066 the_card
.null_buffer_start_dma_addr
);
1068 snd_card_free(the_card
.card
);
1072 ps3_dma_region_free(dev
->d_region
);
1074 snd_ps3_unmap_mmio();
1076 lv1_gpu_device_unmap(2);
1078 ps3_close_hv_device(dev
);
1080 * there is no destructor function to pcm.
1081 * midlayer automatically releases if the card removed
1084 }; /* snd_ps3_probe */
1086 /* called when module removal */
1087 static int snd_ps3_driver_remove(struct ps3_system_bus_device
*dev
)
1090 pr_info("%s:start id=%d\n", __func__
, dev
->match_id
);
1091 if (dev
->match_id
!= PS3_MATCH_ID_SOUND
)
1095 * ctl and preallocate buffer will be freed in
1098 ret
= snd_card_free(the_card
.card
);
1100 pr_info("%s: ctl freecard=%d\n", __func__
, ret
);
1102 dma_free_coherent(&dev
->core
,
1104 the_card
.null_buffer_start_vaddr
,
1105 the_card
.null_buffer_start_dma_addr
);
1107 ps3_dma_region_free(dev
->d_region
);
1110 snd_ps3_unmap_mmio();
1112 lv1_gpu_device_unmap(2);
1113 ps3_close_hv_device(dev
);
1114 pr_info("%s:end id=%d\n", __func__
, dev
->match_id
);
1116 } /* snd_ps3_remove */
1118 static struct ps3_system_bus_driver snd_ps3_bus_driver_info
= {
1119 .match_id
= PS3_MATCH_ID_SOUND
,
1120 .probe
= snd_ps3_driver_probe
,
1121 .remove
= snd_ps3_driver_remove
,
1122 .shutdown
= snd_ps3_driver_remove
,
1124 .name
= SND_PS3_DRIVER_NAME
,
1125 .owner
= THIS_MODULE
,
1131 * module/subsystem initialize/terminate
1133 static int __init
snd_ps3_init(void)
1137 if (!firmware_has_feature(FW_FEATURE_PS3_LV1
))
1140 memset(&the_card
, 0, sizeof(the_card
));
1141 spin_lock_init(&the_card
.dma_lock
);
1143 /* register systembus DRIVER, this calls our probe() func */
1144 ret
= ps3_system_bus_driver_register(&snd_ps3_bus_driver_info
);
1148 module_init(snd_ps3_init
);
1150 static void __exit
snd_ps3_exit(void)
1152 ps3_system_bus_driver_unregister(&snd_ps3_bus_driver_info
);
1154 module_exit(snd_ps3_exit
);
1156 MODULE_LICENSE("GPL v2");
1157 MODULE_DESCRIPTION("PS3 sound driver");
1158 MODULE_AUTHOR("Sony Computer Entertainment Inc.");
1159 MODULE_ALIAS(PS3_MODULE_ALIAS_SOUND
);