1// SPDX-License-Identifier: GPL-2.0-only
   2/*
   3 * Audio support for PS3
   4 * Copyright (C) 2007 Sony Computer Entertainment Inc.
   5 * All rights reserved.
   6 * Copyright 2006, 2007 Sony Corporation
   7 */
   8
   9#include <linux/dma-mapping.h>
  10#include <linux/dmapool.h>
  11#include <linux/gfp.h>
  12#include <linux/init.h>
  13#include <linux/interrupt.h>
  14#include <linux/io.h>
  15#include <linux/module.h>
  16
  17#include <sound/asound.h>
  18#include <sound/control.h>
  19#include <sound/core.h>
  20#include <sound/initval.h>
  21#include <sound/memalloc.h>
  22#include <sound/pcm.h>
  23#include <sound/pcm_params.h>
  24
  25#include <asm/dma.h>
  26#include <asm/firmware.h>
  27#include <asm/lv1call.h>
  28#include <asm/ps3.h>
  29#include <asm/ps3av.h>
  30
  31#include "snd_ps3.h"
  32#include "snd_ps3_reg.h"
  33
  34
  35/*
  36 * global
  37 */
  38static struct snd_ps3_card_info the_card;
  39
  40static int snd_ps3_start_delay = CONFIG_SND_PS3_DEFAULT_START_DELAY;
  41
  42module_param_named(start_delay, snd_ps3_start_delay, uint, 0644);
  43MODULE_PARM_DESC(start_delay, "time to insert silent data in ms");
  44
  45static int index = SNDRV_DEFAULT_IDX1;
  46static char *id = SNDRV_DEFAULT_STR1;
  47
  48module_param(index, int, 0444);
  49MODULE_PARM_DESC(index, "Index value for PS3 soundchip.");
  50module_param(id, charp, 0444);
  51MODULE_PARM_DESC(id, "ID string for PS3 soundchip.");
  52
  53
  54/*
  55 * PS3 audio register access
  56 */
  57static inline u32 read_reg(unsigned int reg)
  58{
  59	return in_be32(the_card.mapped_mmio_vaddr + reg);
  60}
  61static inline void write_reg(unsigned int reg, u32 val)
  62{
  63	out_be32(the_card.mapped_mmio_vaddr + reg, val);
  64}
  65static inline void update_reg(unsigned int reg, u32 or_val)
  66{
  67	u32 newval = read_reg(reg) | or_val;
  68	write_reg(reg, newval);
  69}
  70static inline void update_mask_reg(unsigned int reg, u32 mask, u32 or_val)
  71{
  72	u32 newval = (read_reg(reg) & mask) | or_val;
  73	write_reg(reg, newval);
  74}
  75
  76/*
  77 * ALSA defs
  78 */
  79static const struct snd_pcm_hardware snd_ps3_pcm_hw = {
  80	.info = (SNDRV_PCM_INFO_MMAP |
  81		 SNDRV_PCM_INFO_NONINTERLEAVED |
  82		 SNDRV_PCM_INFO_MMAP_VALID),
  83	.formats = (SNDRV_PCM_FMTBIT_S16_BE |
  84		    SNDRV_PCM_FMTBIT_S24_BE),
  85	.rates = (SNDRV_PCM_RATE_44100 |
  86		  SNDRV_PCM_RATE_48000 |
  87		  SNDRV_PCM_RATE_88200 |
  88		  SNDRV_PCM_RATE_96000),
  89	.rate_min = 44100,
  90	.rate_max = 96000,
  91
  92	.channels_min = 2, /* stereo only */
  93	.channels_max = 2,
  94
  95	.buffer_bytes_max = PS3_AUDIO_FIFO_SIZE * 64,
  96
  97	/* interrupt by four stages */
  98	.period_bytes_min = PS3_AUDIO_FIFO_STAGE_SIZE * 4,
  99	.period_bytes_max = PS3_AUDIO_FIFO_STAGE_SIZE * 4,
 100
 101	.periods_min = 16,
 102	.periods_max = 32, /* buffer_size_max/ period_bytes_max */
 103
 104	.fifo_size = PS3_AUDIO_FIFO_SIZE
 105};
 106
 107static int snd_ps3_verify_dma_stop(struct snd_ps3_card_info *card,
 108				   int count, int force_stop)
 109{
 110	int dma_ch, done, retries, stop_forced = 0;
 111	uint32_t status;
 112
 113	for (dma_ch = 0; dma_ch < 8; dma_ch++) {
 114		retries = count;
 115		do {
 116			status = read_reg(PS3_AUDIO_KICK(dma_ch)) &
 117				PS3_AUDIO_KICK_STATUS_MASK;
 118			switch (status) {
 119			case PS3_AUDIO_KICK_STATUS_DONE:
 120			case PS3_AUDIO_KICK_STATUS_NOTIFY:
 121			case PS3_AUDIO_KICK_STATUS_CLEAR:
 122			case PS3_AUDIO_KICK_STATUS_ERROR:
 123				done = 1;
 124				break;
 125			default:
 126				done = 0;
 127				udelay(10);
 128			}
 129		} while (!done && --retries);
 130		if (!retries && force_stop) {
 131			pr_info("%s: DMA ch %d is not stopped.",
 132				__func__, dma_ch);
 133			/* last resort. force to stop dma.
 134			 *  NOTE: this cause DMA done interrupts
 135			 */
 136			update_reg(PS3_AUDIO_CONFIG, PS3_AUDIO_CONFIG_CLEAR);
 137			stop_forced = 1;
 138		}
 139	}
 140	return stop_forced;
 141}
 142
 143/*
 144 * wait for all dma is done.
 145 * NOTE: caller should reset card->running before call.
 146 *       If not, the interrupt handler will re-start DMA,
 147 *       then DMA is never stopped.
 148 */
 149static void snd_ps3_wait_for_dma_stop(struct snd_ps3_card_info *card)
 150{
 151	int stop_forced;
 152	/*
 153	 * wait for the last dma is done
 154	 */
 155
 156	/*
 157	 * expected maximum DMA done time is 5.7ms + something (DMA itself).
 158	 * 5.7ms is from 16bit/sample 2ch 44.1Khz; the time next
 159	 * DMA kick event would occur.
 160	 */
 161	stop_forced = snd_ps3_verify_dma_stop(card, 700, 1);
 162
 163	/*
 164	 * clear outstanding interrupts.
 165	 */
 166	update_reg(PS3_AUDIO_INTR_0, 0);
 167	update_reg(PS3_AUDIO_AX_IS, 0);
 168
 169	/*
 170	 *revert CLEAR bit since it will not reset automatically after DMA stop
 171	 */
 172	if (stop_forced)
 173		update_mask_reg(PS3_AUDIO_CONFIG, ~PS3_AUDIO_CONFIG_CLEAR, 0);
 174	/* ensure the hardware sees changes */
 175	wmb();
 176}
 177
 178static void snd_ps3_kick_dma(struct snd_ps3_card_info *card)
 179{
 180
 181	update_reg(PS3_AUDIO_KICK(0), PS3_AUDIO_KICK_REQUEST);
 182	/* ensure the hardware sees the change */
 183	wmb();
 184}
 185
 186/*
 187 * convert virtual addr to ioif bus addr.
 188 */
 189static dma_addr_t v_to_bus(struct snd_ps3_card_info *card, void *paddr, int ch)
 190{
 191	return card->dma_start_bus_addr[ch] +
 192		(paddr - card->dma_start_vaddr[ch]);
 193};
 194
 195
 196/*
 197 * increment ring buffer pointer.
 198 * NOTE: caller must hold write spinlock
 199 */
 200static void snd_ps3_bump_buffer(struct snd_ps3_card_info *card,
 201				enum snd_ps3_ch ch, size_t byte_count,
 202				int stage)
 203{
 204	if (!stage)
 205		card->dma_last_transfer_vaddr[ch] =
 206			card->dma_next_transfer_vaddr[ch];
 207	card->dma_next_transfer_vaddr[ch] += byte_count;
 208	if ((card->dma_start_vaddr[ch] + (card->dma_buffer_size / 2)) <=
 209	    card->dma_next_transfer_vaddr[ch]) {
 210		card->dma_next_transfer_vaddr[ch] = card->dma_start_vaddr[ch];
 211	}
 212}
 213/*
 214 * setup dmac to send data to audio and attenuate samples on the ring buffer
 215 */
 216static int snd_ps3_program_dma(struct snd_ps3_card_info *card,
 217			       enum snd_ps3_dma_filltype filltype)
 218{
 219	/* this dmac does not support over 4G */
 220	uint32_t dma_addr;
 221	int fill_stages, dma_ch, stage;
 222	enum snd_ps3_ch ch;
 223	uint32_t ch0_kick_event = 0; /* initialize to mute gcc */
 224	unsigned long irqsave;
 225	int silent = 0;
 226
 227	switch (filltype) {
 228	case SND_PS3_DMA_FILLTYPE_SILENT_FIRSTFILL:
 229		silent = 1;
 230		fallthrough;
 231	case SND_PS3_DMA_FILLTYPE_FIRSTFILL:
 232		ch0_kick_event = PS3_AUDIO_KICK_EVENT_ALWAYS;
 233		break;
 234
 235	case SND_PS3_DMA_FILLTYPE_SILENT_RUNNING:
 236		silent = 1;
 237		fallthrough;
 238	case SND_PS3_DMA_FILLTYPE_RUNNING:
 239		ch0_kick_event = PS3_AUDIO_KICK_EVENT_SERIALOUT0_EMPTY;
 240		break;
 241	}
 242
 243	snd_ps3_verify_dma_stop(card, 700, 0);
 244	fill_stages = 4;
 245	spin_lock_irqsave(&card->dma_lock, irqsave);
 246	for (ch = 0; ch < 2; ch++) {
 247		for (stage = 0; stage < fill_stages; stage++) {
 248			dma_ch = stage * 2 + ch;
 249			if (silent)
 250				dma_addr = card->null_buffer_start_dma_addr;
 251			else
 252				dma_addr =
 253				v_to_bus(card,
 254					 card->dma_next_transfer_vaddr[ch],
 255					 ch);
 256
 257			write_reg(PS3_AUDIO_SOURCE(dma_ch),
 258				  (PS3_AUDIO_SOURCE_TARGET_SYSTEM_MEMORY |
 259				   dma_addr));
 260
 261			/* dst: fixed to 3wire#0 */
 262			if (ch == 0)
 263				write_reg(PS3_AUDIO_DEST(dma_ch),
 264					  (PS3_AUDIO_DEST_TARGET_AUDIOFIFO |
 265					   PS3_AUDIO_AO_3W_LDATA(0)));
 266			else
 267				write_reg(PS3_AUDIO_DEST(dma_ch),
 268					  (PS3_AUDIO_DEST_TARGET_AUDIOFIFO |
 269					   PS3_AUDIO_AO_3W_RDATA(0)));
 270
 271			/* count always 1 DMA block (1/2 stage = 128 bytes) */
 272			write_reg(PS3_AUDIO_DMASIZE(dma_ch), 0);
 273			/* bump pointer if needed */
 274			if (!silent)
 275				snd_ps3_bump_buffer(card, ch,
 276						    PS3_AUDIO_DMAC_BLOCK_SIZE,
 277						    stage);
 278
 279			/* kick event  */
 280			if (dma_ch == 0)
 281				write_reg(PS3_AUDIO_KICK(dma_ch),
 282					  ch0_kick_event);
 283			else
 284				write_reg(PS3_AUDIO_KICK(dma_ch),
 285					  PS3_AUDIO_KICK_EVENT_AUDIO_DMA(dma_ch
 286									 - 1) |
 287					  PS3_AUDIO_KICK_REQUEST);
 288		}
 289	}
 290	/* ensure the hardware sees the change */
 291	wmb();
 292	spin_unlock_irqrestore(&card->dma_lock, irqsave);
 293
 294	return 0;
 295}
 296
 297/*
 298 * Interrupt handler
 299 */
 300static irqreturn_t snd_ps3_interrupt(int irq, void *dev_id)
 301{
 302
 303	uint32_t port_intr;
 304	int underflow_occured = 0;
 305	struct snd_ps3_card_info *card = dev_id;
 306
 307	if (!card->running) {
 308		update_reg(PS3_AUDIO_AX_IS, 0);
 309		update_reg(PS3_AUDIO_INTR_0, 0);
 310		return IRQ_HANDLED;
 311	}
 312
 313	port_intr = read_reg(PS3_AUDIO_AX_IS);
 314	/*
 315	 *serial buffer empty detected (every 4 times),
 316	 *program next dma and kick it
 317	 */
 318	if (port_intr & PS3_AUDIO_AX_IE_ASOBEIE(0)) {
 319		write_reg(PS3_AUDIO_AX_IS, PS3_AUDIO_AX_IE_ASOBEIE(0));
 320		if (port_intr & PS3_AUDIO_AX_IE_ASOBUIE(0)) {
 321			write_reg(PS3_AUDIO_AX_IS, port_intr);
 322			underflow_occured = 1;
 323		}
 324		if (card->silent) {
 325			/* we are still in silent time */
 326			snd_ps3_program_dma(card,
 327				(underflow_occured) ?
 328				SND_PS3_DMA_FILLTYPE_SILENT_FIRSTFILL :
 329				SND_PS3_DMA_FILLTYPE_SILENT_RUNNING);
 330			snd_ps3_kick_dma(card);
 331			card->silent--;
 332		} else {
 333			snd_ps3_program_dma(card,
 334				(underflow_occured) ?
 335				SND_PS3_DMA_FILLTYPE_FIRSTFILL :
 336				SND_PS3_DMA_FILLTYPE_RUNNING);
 337			snd_ps3_kick_dma(card);
 338			snd_pcm_period_elapsed(card->substream);
 339		}
 340	} else if (port_intr & PS3_AUDIO_AX_IE_ASOBUIE(0)) {
 341		write_reg(PS3_AUDIO_AX_IS, PS3_AUDIO_AX_IE_ASOBUIE(0));
 342		/*
 343		 * serial out underflow, but buffer empty not detected.
 344		 * in this case, fill fifo with 0 to recover.  After
 345		 * filling dummy data, serial automatically start to
 346		 * consume them and then will generate normal buffer
 347		 * empty interrupts.
 348		 * If both buffer underflow and buffer empty are occurred,
 349		 * it is better to do nomal data transfer than empty one
 350		 */
 351		snd_ps3_program_dma(card,
 352				    SND_PS3_DMA_FILLTYPE_SILENT_FIRSTFILL);
 353		snd_ps3_kick_dma(card);
 354		snd_ps3_program_dma(card,
 355				    SND_PS3_DMA_FILLTYPE_SILENT_FIRSTFILL);
 356		snd_ps3_kick_dma(card);
 357	}
 358	/* clear interrupt cause */
 359	return IRQ_HANDLED;
 360};
 361
 362/*
 363 * audio mute on/off
 364 * mute_on : 0 output enabled
 365 *           1 mute
 366 */
 367static int snd_ps3_mute(int mute_on)
 368{
 369	return ps3av_audio_mute(mute_on);
 370}
 371
 372/*
 373 * av setting
 374 * NOTE: calling this function may generate audio interrupt.
 375 */
 376static int snd_ps3_change_avsetting(struct snd_ps3_card_info *card)
 377{
 378	int ret, retries, i;
 379	pr_debug("%s: start\n", __func__);
 380
 381	ret = ps3av_set_audio_mode(card->avs.avs_audio_ch,
 382				  card->avs.avs_audio_rate,
 383				  card->avs.avs_audio_width,
 384				  card->avs.avs_audio_format,
 385				  card->avs.avs_audio_source);
 386	/*
 387	 * Reset the following unwanted settings:
 388	 */
 389
 390	/* disable all 3wire buffers */
 391	update_mask_reg(PS3_AUDIO_AO_3WMCTRL,
 392			~(PS3_AUDIO_AO_3WMCTRL_ASOEN(0) |
 393			  PS3_AUDIO_AO_3WMCTRL_ASOEN(1) |
 394			  PS3_AUDIO_AO_3WMCTRL_ASOEN(2) |
 395			  PS3_AUDIO_AO_3WMCTRL_ASOEN(3)),
 396			0);
 397	wmb();	/* ensure the hardware sees the change */
 398	/* wait for actually stopped */
 399	retries = 1000;
 400	while ((read_reg(PS3_AUDIO_AO_3WMCTRL) &
 401		(PS3_AUDIO_AO_3WMCTRL_ASORUN(0) |
 402		 PS3_AUDIO_AO_3WMCTRL_ASORUN(1) |
 403		 PS3_AUDIO_AO_3WMCTRL_ASORUN(2) |
 404		 PS3_AUDIO_AO_3WMCTRL_ASORUN(3))) &&
 405	       --retries) {
 406		udelay(1);
 407	}
 408
 409	/* reset buffer pointer */
 410	for (i = 0; i < 4; i++) {
 411		update_reg(PS3_AUDIO_AO_3WCTRL(i),
 412			   PS3_AUDIO_AO_3WCTRL_ASOBRST_RESET);
 413		udelay(10);
 414	}
 415	wmb(); /* ensure the hardware actually start resetting */
 416
 417	/* enable 3wire#0 buffer */
 418	update_reg(PS3_AUDIO_AO_3WMCTRL, PS3_AUDIO_AO_3WMCTRL_ASOEN(0));
 419
 420
 421	/* In 24bit mode,ALSA inserts a zero byte at first byte of per sample */
 422	update_mask_reg(PS3_AUDIO_AO_3WCTRL(0),
 423			~PS3_AUDIO_AO_3WCTRL_ASODF,
 424			PS3_AUDIO_AO_3WCTRL_ASODF_LSB);
 425	update_mask_reg(PS3_AUDIO_AO_SPDCTRL(0),
 426			~PS3_AUDIO_AO_SPDCTRL_SPODF,
 427			PS3_AUDIO_AO_SPDCTRL_SPODF_LSB);
 428	/* ensure all the setting above is written back to register */
 429	wmb();
 430	/* avsetting driver altered AX_IE, caller must reset it if you want */
 431	pr_debug("%s: end\n", __func__);
 432	return ret;
 433}
 434
 435/*
 436 *  set sampling rate according to the substream
 437 */
 438static int snd_ps3_set_avsetting(struct snd_pcm_substream *substream)
 439{
 440	struct snd_ps3_card_info *card = snd_pcm_substream_chip(substream);
 441	struct snd_ps3_avsetting_info avs;
 442	int ret;
 443
 444	avs = card->avs;
 445
 446	pr_debug("%s: called freq=%d width=%d\n", __func__,
 447		 substream->runtime->rate,
 448		 snd_pcm_format_width(substream->runtime->format));
 449
 450	pr_debug("%s: before freq=%d width=%d\n", __func__,
 451		 card->avs.avs_audio_rate, card->avs.avs_audio_width);
 452
 453	/* sample rate */
 454	switch (substream->runtime->rate) {
 455	case 44100:
 456		avs.avs_audio_rate = PS3AV_CMD_AUDIO_FS_44K;
 457		break;
 458	case 48000:
 459		avs.avs_audio_rate = PS3AV_CMD_AUDIO_FS_48K;
 460		break;
 461	case 88200:
 462		avs.avs_audio_rate = PS3AV_CMD_AUDIO_FS_88K;
 463		break;
 464	case 96000:
 465		avs.avs_audio_rate = PS3AV_CMD_AUDIO_FS_96K;
 466		break;
 467	default:
 468		pr_info("%s: invalid rate %d\n", __func__,
 469			substream->runtime->rate);
 470		return 1;
 471	}
 472
 473	/* width */
 474	switch (snd_pcm_format_width(substream->runtime->format)) {
 475	case 16:
 476		avs.avs_audio_width = PS3AV_CMD_AUDIO_WORD_BITS_16;
 477		break;
 478	case 24:
 479		avs.avs_audio_width = PS3AV_CMD_AUDIO_WORD_BITS_24;
 480		break;
 481	default:
 482		pr_info("%s: invalid width %d\n", __func__,
 483			snd_pcm_format_width(substream->runtime->format));
 484		return 1;
 485	}
 486
 487	memcpy(avs.avs_cs_info, ps3av_mode_cs_info, 8);
 488
 489	if (memcmp(&card->avs, &avs, sizeof(avs))) {
 490		pr_debug("%s: after freq=%d width=%d\n", __func__,
 491			 card->avs.avs_audio_rate, card->avs.avs_audio_width);
 492
 493		card->avs = avs;
 494		snd_ps3_change_avsetting(card);
 495		ret = 0;
 496	} else
 497		ret = 1;
 498
 499	/* check CS non-audio bit and mute accordingly */
 500	if (avs.avs_cs_info[0] & 0x02)
 501		ps3av_audio_mute_analog(1); /* mute if non-audio */
 502	else
 503		ps3av_audio_mute_analog(0);
 504
 505	return ret;
 506}
 507
 508/*
 509 * PCM operators
 510 */
 511static int snd_ps3_pcm_open(struct snd_pcm_substream *substream)
 512{
 513	struct snd_pcm_runtime *runtime = substream->runtime;
 514	struct snd_ps3_card_info *card = snd_pcm_substream_chip(substream);
 515
 516	/* to retrieve substream/runtime in interrupt handler */
 517	card->substream = substream;
 518
 519	runtime->hw = snd_ps3_pcm_hw;
 520
 521	card->start_delay = snd_ps3_start_delay;
 522
 523	/* mute off */
 524	snd_ps3_mute(0); /* this function sleep */
 525
 526	snd_pcm_hw_constraint_step(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_BYTES,
 527				   PS3_AUDIO_FIFO_STAGE_SIZE * 4 * 2);
 528	return 0;
 529};
 530
 531static int snd_ps3_pcm_close(struct snd_pcm_substream *substream)
 532{
 533	/* mute on */
 534	snd_ps3_mute(1);
 535	return 0;
 536};
 537
 538static int snd_ps3_delay_to_bytes(struct snd_pcm_substream *substream,
 539				  unsigned int delay_ms)
 540{
 541	int ret;
 542	int rate ;
 543
 544	rate = substream->runtime->rate;
 545	ret = snd_pcm_format_size(substream->runtime->format,
 546				  rate * delay_ms / 1000)
 547		* substream->runtime->channels;
 548
 549	pr_debug("%s: time=%d rate=%d bytes=%ld, frames=%d, ret=%d\n",
 550		 __func__,
 551		 delay_ms,
 552		 rate,
 553		 snd_pcm_format_size(substream->runtime->format, rate),
 554		 rate * delay_ms / 1000,
 555		 ret);
 556
 557	return ret;
 558};
 559
 560static int snd_ps3_pcm_prepare(struct snd_pcm_substream *substream)
 561{
 562	struct snd_pcm_runtime *runtime = substream->runtime;
 563	struct snd_ps3_card_info *card = snd_pcm_substream_chip(substream);
 564	unsigned long irqsave;
 565
 566	if (!snd_ps3_set_avsetting(substream)) {
 567		/* some parameter changed */
 568		write_reg(PS3_AUDIO_AX_IE,
 569			  PS3_AUDIO_AX_IE_ASOBEIE(0) |
 570			  PS3_AUDIO_AX_IE_ASOBUIE(0));
 571		/*
 572		 * let SPDIF device re-lock with SPDIF signal,
 573		 * start with some silence
 574		 */
 575		card->silent = snd_ps3_delay_to_bytes(substream,
 576						      card->start_delay) /
 577			(PS3_AUDIO_FIFO_STAGE_SIZE * 4); /* every 4 times */
 578	}
 579
 580	/* restart ring buffer pointer */
 581	spin_lock_irqsave(&card->dma_lock, irqsave);
 582	{
 583		card->dma_buffer_size = runtime->dma_bytes;
 584
 585		card->dma_last_transfer_vaddr[SND_PS3_CH_L] =
 586			card->dma_next_transfer_vaddr[SND_PS3_CH_L] =
 587			card->dma_start_vaddr[SND_PS3_CH_L] =
 588			runtime->dma_area;
 589		card->dma_start_bus_addr[SND_PS3_CH_L] = runtime->dma_addr;
 590
 591		card->dma_last_transfer_vaddr[SND_PS3_CH_R] =
 592			card->dma_next_transfer_vaddr[SND_PS3_CH_R] =
 593			card->dma_start_vaddr[SND_PS3_CH_R] =
 594			runtime->dma_area + (runtime->dma_bytes / 2);
 595		card->dma_start_bus_addr[SND_PS3_CH_R] =
 596			runtime->dma_addr + (runtime->dma_bytes / 2);
 597
 598		pr_debug("%s: vaddr=%p bus=%#llx\n", __func__,
 599			 card->dma_start_vaddr[SND_PS3_CH_L],
 600			 card->dma_start_bus_addr[SND_PS3_CH_L]);
 601
 602	}
 603	spin_unlock_irqrestore(&card->dma_lock, irqsave);
 604
 605	/* ensure the hardware sees the change */
 606	mb();
 607
 608	return 0;
 609};
 610
 611static int snd_ps3_pcm_trigger(struct snd_pcm_substream *substream,
 612			       int cmd)
 613{
 614	struct snd_ps3_card_info *card = snd_pcm_substream_chip(substream);
 615
 616	switch (cmd) {
 617	case SNDRV_PCM_TRIGGER_START:
 618		/* clear outstanding interrupts  */
 619		update_reg(PS3_AUDIO_AX_IS, 0);
 620
 621		spin_lock(&card->dma_lock);
 622		{
 623			card->running = 1;
 624		}
 625		spin_unlock(&card->dma_lock);
 626
 627		snd_ps3_program_dma(card,
 628				    SND_PS3_DMA_FILLTYPE_SILENT_FIRSTFILL);
 629		snd_ps3_kick_dma(card);
 630		while (read_reg(PS3_AUDIO_KICK(7)) &
 631		       PS3_AUDIO_KICK_STATUS_MASK) {
 632			udelay(1);
 633		}
 634		snd_ps3_program_dma(card, SND_PS3_DMA_FILLTYPE_SILENT_RUNNING);
 635		snd_ps3_kick_dma(card);
 636		break;
 637
 638	case SNDRV_PCM_TRIGGER_STOP:
 639		spin_lock(&card->dma_lock);
 640		{
 641			card->running = 0;
 642		}
 643		spin_unlock(&card->dma_lock);
 644		snd_ps3_wait_for_dma_stop(card);
 645		break;
 646	default:
 647		break;
 648
 649	}
 650
 651	return 0;
 652};
 653
 654/*
 655 * report current pointer
 656 */
 657static snd_pcm_uframes_t snd_ps3_pcm_pointer(
 658	struct snd_pcm_substream *substream)
 659{
 660	struct snd_ps3_card_info *card = snd_pcm_substream_chip(substream);
 661	size_t bytes;
 662	snd_pcm_uframes_t ret;
 663
 664	spin_lock(&card->dma_lock);
 665	{
 666		bytes = (size_t)(card->dma_last_transfer_vaddr[SND_PS3_CH_L] -
 667				 card->dma_start_vaddr[SND_PS3_CH_L]);
 668	}
 669	spin_unlock(&card->dma_lock);
 670
 671	ret = bytes_to_frames(substream->runtime, bytes * 2);
 672
 673	return ret;
 674};
 675
 676/*
 677 * SPDIF status bits controls
 678 */
 679static int snd_ps3_spdif_mask_info(struct snd_kcontrol *kcontrol,
 680				   struct snd_ctl_elem_info *uinfo)
 681{
 682	uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
 683	uinfo->count = 1;
 684	return 0;
 685}
 686
 687/* FIXME: ps3av_set_audio_mode() assumes only consumer mode */
 688static int snd_ps3_spdif_cmask_get(struct snd_kcontrol *kcontrol,
 689				   struct snd_ctl_elem_value *ucontrol)
 690{
 691	memset(ucontrol->value.iec958.status, 0xff, 8);
 692	return 0;
 693}
 694
 695static int snd_ps3_spdif_pmask_get(struct snd_kcontrol *kcontrol,
 696				   struct snd_ctl_elem_value *ucontrol)
 697{
 698	return 0;
 699}
 700
 701static int snd_ps3_spdif_default_get(struct snd_kcontrol *kcontrol,
 702				     struct snd_ctl_elem_value *ucontrol)
 703{
 704	memcpy(ucontrol->value.iec958.status, ps3av_mode_cs_info, 8);
 705	return 0;
 706}
 707
 708static int snd_ps3_spdif_default_put(struct snd_kcontrol *kcontrol,
 709				     struct snd_ctl_elem_value *ucontrol)
 710{
 711	if (memcmp(ps3av_mode_cs_info, ucontrol->value.iec958.status, 8)) {
 712		memcpy(ps3av_mode_cs_info, ucontrol->value.iec958.status, 8);
 713		return 1;
 714	}
 715	return 0;
 716}
 717
 718static const struct snd_kcontrol_new spdif_ctls[] = {
 719	{
 720		.access = SNDRV_CTL_ELEM_ACCESS_READ,
 721		.iface = SNDRV_CTL_ELEM_IFACE_PCM,
 722		.name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, CON_MASK),
 723		.info = snd_ps3_spdif_mask_info,
 724		.get = snd_ps3_spdif_cmask_get,
 725	},
 726	{
 727		.access = SNDRV_CTL_ELEM_ACCESS_READ,
 728		.iface = SNDRV_CTL_ELEM_IFACE_PCM,
 729		.name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, PRO_MASK),
 730		.info = snd_ps3_spdif_mask_info,
 731		.get = snd_ps3_spdif_pmask_get,
 732	},
 733	{
 734		.iface = SNDRV_CTL_ELEM_IFACE_PCM,
 735		.name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, DEFAULT),
 736		.info = snd_ps3_spdif_mask_info,
 737		.get = snd_ps3_spdif_default_get,
 738		.put = snd_ps3_spdif_default_put,
 739	},
 740};
 741
 742static const struct snd_pcm_ops snd_ps3_pcm_spdif_ops = {
 743	.open = snd_ps3_pcm_open,
 744	.close = snd_ps3_pcm_close,
 745	.prepare = snd_ps3_pcm_prepare,
 746	.trigger = snd_ps3_pcm_trigger,
 747	.pointer = snd_ps3_pcm_pointer,
 748};
 749
 750
 751static int snd_ps3_map_mmio(void)
 752{
 753	the_card.mapped_mmio_vaddr =
 754		ioremap(the_card.ps3_dev->m_region->bus_addr,
 755			the_card.ps3_dev->m_region->len);
 756
 757	if (!the_card.mapped_mmio_vaddr) {
 758		pr_info("%s: ioremap 0 failed p=%#lx l=%#lx \n",
 759		       __func__, the_card.ps3_dev->m_region->lpar_addr,
 760		       the_card.ps3_dev->m_region->len);
 761		return -ENXIO;
 762	}
 763
 764	return 0;
 765};
 766
 767static void snd_ps3_unmap_mmio(void)
 768{
 769	iounmap(the_card.mapped_mmio_vaddr);
 770	the_card.mapped_mmio_vaddr = NULL;
 771}
 772
 773static int snd_ps3_allocate_irq(void)
 774{
 775	int ret;
 776	u64 lpar_addr, lpar_size;
 777	u64 __iomem *mapped;
 778
 779	/* FIXME: move this to device_init (H/W probe) */
 780
 781	/* get irq outlet */
 782	ret = lv1_gpu_device_map(1, &lpar_addr, &lpar_size);
 783	if (ret) {
 784		pr_info("%s: device map 1 failed %d\n", __func__,
 785			ret);
 786		return -ENXIO;
 787	}
 788
 789	mapped = ioremap(lpar_addr, lpar_size);
 790	if (!mapped) {
 791		pr_info("%s: ioremap 1 failed \n", __func__);
 792		return -ENXIO;
 793	}
 794
 795	the_card.audio_irq_outlet = in_be64(mapped);
 796
 797	iounmap(mapped);
 798	ret = lv1_gpu_device_unmap(1);
 799	if (ret)
 800		pr_info("%s: unmap 1 failed\n", __func__);
 801
 802	/* irq */
 803	ret = ps3_irq_plug_setup(PS3_BINDING_CPU_ANY,
 804				 the_card.audio_irq_outlet,
 805				 &the_card.irq_no);
 806	if (ret) {
 807		pr_info("%s:ps3_alloc_irq failed (%d)\n", __func__, ret);
 808		return ret;
 809	}
 810
 811	ret = request_irq(the_card.irq_no, snd_ps3_interrupt, 0,
 812			  SND_PS3_DRIVER_NAME, &the_card);
 813	if (ret) {
 814		pr_info("%s: request_irq failed (%d)\n", __func__, ret);
 815		goto cleanup_irq;
 816	}
 817
 818	return 0;
 819
 820 cleanup_irq:
 821	ps3_irq_plug_destroy(the_card.irq_no);
 822	return ret;
 823};
 824
 825static void snd_ps3_free_irq(void)
 826{
 827	free_irq(the_card.irq_no, &the_card);
 828	ps3_irq_plug_destroy(the_card.irq_no);
 829}
 830
 831static void snd_ps3_audio_set_base_addr(uint64_t ioaddr_start)
 832{
 833	uint64_t val;
 834	int ret;
 835
 836	val = (ioaddr_start & (0x0fUL << 32)) >> (32 - 20) |
 837		(0x03UL << 24) |
 838		(0x0fUL << 12) |
 839		(PS3_AUDIO_IOID);
 840
 841	ret = lv1_gpu_attribute(0x100, 0x007, val);
 842	if (ret)
 843		pr_info("%s: gpu_attribute failed %d\n", __func__,
 844			ret);
 845}
 846
 847static void snd_ps3_audio_fixup(struct snd_ps3_card_info *card)
 848{
 849	/*
 850	 * avsetting driver seems to never change the following
 851	 * so, init them here once
 852	 */
 853
 854	/* no dma interrupt needed */
 855	write_reg(PS3_AUDIO_INTR_EN_0, 0);
 856
 857	/* use every 4 buffer empty interrupt */
 858	update_mask_reg(PS3_AUDIO_AX_IC,
 859			PS3_AUDIO_AX_IC_AASOIMD_MASK,
 860			PS3_AUDIO_AX_IC_AASOIMD_EVERY4);
 861
 862	/* enable 3wire clocks */
 863	update_mask_reg(PS3_AUDIO_AO_3WMCTRL,
 864			~(PS3_AUDIO_AO_3WMCTRL_ASOBCLKD_DISABLED |
 865			  PS3_AUDIO_AO_3WMCTRL_ASOLRCKD_DISABLED),
 866			0);
 867	update_reg(PS3_AUDIO_AO_3WMCTRL,
 868		   PS3_AUDIO_AO_3WMCTRL_ASOPLRCK_DEFAULT);
 869}
 870
 871static int snd_ps3_init_avsetting(struct snd_ps3_card_info *card)
 872{
 873	int ret;
 874	pr_debug("%s: start\n", __func__);
 875	card->avs.avs_audio_ch = PS3AV_CMD_AUDIO_NUM_OF_CH_2;
 876	card->avs.avs_audio_rate = PS3AV_CMD_AUDIO_FS_48K;
 877	card->avs.avs_audio_width = PS3AV_CMD_AUDIO_WORD_BITS_16;
 878	card->avs.avs_audio_format = PS3AV_CMD_AUDIO_FORMAT_PCM;
 879	card->avs.avs_audio_source = PS3AV_CMD_AUDIO_SOURCE_SERIAL;
 880	memcpy(card->avs.avs_cs_info, ps3av_mode_cs_info, 8);
 881
 882	ret = snd_ps3_change_avsetting(card);
 883
 884	snd_ps3_audio_fixup(card);
 885
 886	/* to start to generate SPDIF signal, fill data */
 887	snd_ps3_program_dma(card, SND_PS3_DMA_FILLTYPE_SILENT_FIRSTFILL);
 888	snd_ps3_kick_dma(card);
 889	pr_debug("%s: end\n", __func__);
 890	return ret;
 891}
 892
 893static int snd_ps3_driver_probe(struct ps3_system_bus_device *dev)
 894{
 895	int i, ret;
 896	u64 lpar_addr, lpar_size;
 897	static u64 dummy_mask;
 898
 899	the_card.ps3_dev = dev;
 900
 901	ret = ps3_open_hv_device(dev);
 902
 903	if (ret)
 904		return -ENXIO;
 905
 906	/* setup MMIO */
 907	ret = lv1_gpu_device_map(2, &lpar_addr, &lpar_size);
 908	if (ret) {
 909		pr_info("%s: device map 2 failed %d\n", __func__, ret);
 910		goto clean_open;
 911	}
 912	ps3_mmio_region_init(dev, dev->m_region, lpar_addr, lpar_size,
 913		PAGE_SHIFT);
 914
 915	ret = snd_ps3_map_mmio();
 916	if (ret)
 917		goto clean_dev_map;
 918
 919	/* setup DMA area */
 920	ps3_dma_region_init(dev, dev->d_region,
 921			    PAGE_SHIFT, /* use system page size */
 922			    0, /* dma type; not used */
 923			    NULL,
 924			    ALIGN(SND_PS3_DMA_REGION_SIZE, PAGE_SIZE));
 925	dev->d_region->ioid = PS3_AUDIO_IOID;
 926
 927	ret = ps3_dma_region_create(dev->d_region);
 928	if (ret) {
 929		pr_info("%s: region_create\n", __func__);
 930		goto clean_mmio;
 931	}
 932
 933	dummy_mask = DMA_BIT_MASK(32);
 934	dev->core.dma_mask = &dummy_mask;
 935	dma_set_coherent_mask(&dev->core, dummy_mask);
 936
 937	snd_ps3_audio_set_base_addr(dev->d_region->bus_addr);
 938
 939	/* CONFIG_SND_PS3_DEFAULT_START_DELAY */
 940	the_card.start_delay = snd_ps3_start_delay;
 941
 942	/* irq */
 943	if (snd_ps3_allocate_irq()) {
 944		ret = -ENXIO;
 945		goto clean_dma_region;
 946	}
 947
 948	/* create card instance */
 949	ret = snd_card_new(&dev->core, index, id, THIS_MODULE,
 950			   0, &the_card.card);
 951	if (ret < 0)
 952		goto clean_irq;
 953
 954	strcpy(the_card.card->driver, "PS3");
 955	strcpy(the_card.card->shortname, "PS3");
 956	strcpy(the_card.card->longname, "PS3 sound");
 957
 958	/* create control elements */
 959	for (i = 0; i < ARRAY_SIZE(spdif_ctls); i++) {
 960		ret = snd_ctl_add(the_card.card,
 961				  snd_ctl_new1(&spdif_ctls[i], &the_card));
 962		if (ret < 0)
 963			goto clean_card;
 964	}
 965
 966	/* create PCM devices instance */
 967	/* NOTE:this driver works assuming pcm:substream = 1:1 */
 968	ret = snd_pcm_new(the_card.card,
 969			  "SPDIF",
 970			  0, /* instance index, will be stored pcm.device*/
 971			  1, /* output substream */
 972			  0, /* input substream */
 973			  &(the_card.pcm));
 974	if (ret)
 975		goto clean_card;
 976
 977	the_card.pcm->private_data = &the_card;
 978	strcpy(the_card.pcm->name, "SPDIF");
 979
 980	/* set pcm ops */
 981	snd_pcm_set_ops(the_card.pcm, SNDRV_PCM_STREAM_PLAYBACK,
 982			&snd_ps3_pcm_spdif_ops);
 983
 984	the_card.pcm->info_flags = SNDRV_PCM_INFO_NONINTERLEAVED;
 985	/* pre-alloc PCM DMA buffer*/
 986	snd_pcm_set_managed_buffer_all(the_card.pcm,
 987				       SNDRV_DMA_TYPE_DEV,
 988				       &dev->core,
 989				       SND_PS3_PCM_PREALLOC_SIZE,
 990				       SND_PS3_PCM_PREALLOC_SIZE);
 991
 992	/*
 993	 * allocate null buffer
 994	 * its size should be lager than PS3_AUDIO_FIFO_STAGE_SIZE * 2
 995	 * PAGE_SIZE is enogh
 996	 */
 997	the_card.null_buffer_start_vaddr =
 998		dma_alloc_coherent(&the_card.ps3_dev->core,
 999				   PAGE_SIZE,
1000				   &the_card.null_buffer_start_dma_addr,
1001				   GFP_KERNEL);
1002	if (!the_card.null_buffer_start_vaddr) {
1003		pr_info("%s: nullbuffer alloc failed\n", __func__);
1004		ret = -ENOMEM;
1005		goto clean_card;
1006	}
1007	pr_debug("%s: null vaddr=%p dma=%#llx\n", __func__,
1008		 the_card.null_buffer_start_vaddr,
1009		 the_card.null_buffer_start_dma_addr);
1010	/* set default sample rate/word width */
1011	snd_ps3_init_avsetting(&the_card);
1012
1013	/* register the card */
1014	ret = snd_card_register(the_card.card);
1015	if (ret < 0)
1016		goto clean_dma_map;
1017
1018	pr_info("%s started. start_delay=%dms\n",
1019		the_card.card->longname, the_card.start_delay);
1020	return 0;
1021
1022clean_dma_map:
1023	dma_free_coherent(&the_card.ps3_dev->core,
1024			  PAGE_SIZE,
1025			  the_card.null_buffer_start_vaddr,
1026			  the_card.null_buffer_start_dma_addr);
1027clean_card:
1028	snd_card_free(the_card.card);
1029clean_irq:
1030	snd_ps3_free_irq();
1031clean_dma_region:
1032	ps3_dma_region_free(dev->d_region);
1033clean_mmio:
1034	snd_ps3_unmap_mmio();
1035clean_dev_map:
1036	lv1_gpu_device_unmap(2);
1037clean_open:
1038	ps3_close_hv_device(dev);
1039	/*
1040	 * there is no destructor function to pcm.
1041	 * midlayer automatically releases if the card removed
1042	 */
1043	return ret;
1044}; /* snd_ps3_probe */
1045
1046/* called when module removal */
1047static void snd_ps3_driver_remove(struct ps3_system_bus_device *dev)
1048{
1049	pr_info("%s:start id=%d\n", __func__,  dev->match_id);
1050
1051	/*
1052	 * ctl and preallocate buffer will be freed in
1053	 * snd_card_free
1054	 */
1055	snd_card_free(the_card.card);
1056
1057	dma_free_coherent(&dev->core,
1058			  PAGE_SIZE,
1059			  the_card.null_buffer_start_vaddr,
1060			  the_card.null_buffer_start_dma_addr);
1061
1062	ps3_dma_region_free(dev->d_region);
1063
1064	snd_ps3_free_irq();
1065	snd_ps3_unmap_mmio();
1066
1067	lv1_gpu_device_unmap(2);
1068	ps3_close_hv_device(dev);
1069	pr_info("%s:end id=%d\n", __func__, dev->match_id);
1070} /* snd_ps3_remove */
1071
1072static struct ps3_system_bus_driver snd_ps3_bus_driver_info = {
1073	.match_id = PS3_MATCH_ID_SOUND,
1074	.probe = snd_ps3_driver_probe,
1075	.remove = snd_ps3_driver_remove,
1076	.shutdown = snd_ps3_driver_remove,
1077	.core = {
1078		.name = SND_PS3_DRIVER_NAME,
1079		.owner = THIS_MODULE,
1080	},
1081};
1082
1083
1084/*
1085 * module/subsystem initialize/terminate
1086 */
1087static int __init snd_ps3_init(void)
1088{
1089	int ret;
1090
1091	if (!firmware_has_feature(FW_FEATURE_PS3_LV1))
1092		return -ENXIO;
1093
1094	memset(&the_card, 0, sizeof(the_card));
1095	spin_lock_init(&the_card.dma_lock);
1096
1097	/* register systembus DRIVER, this calls our probe() func */
1098	ret = ps3_system_bus_driver_register(&snd_ps3_bus_driver_info);
1099
1100	return ret;
1101}
1102module_init(snd_ps3_init);
1103
1104static void __exit snd_ps3_exit(void)
1105{
1106	ps3_system_bus_driver_unregister(&snd_ps3_bus_driver_info);
1107}
1108module_exit(snd_ps3_exit);
1109
1110MODULE_LICENSE("GPL v2");
1111MODULE_DESCRIPTION("PS3 sound driver");
1112MODULE_AUTHOR("Sony Computer Entertainment Inc.");
1113MODULE_ALIAS(PS3_MODULE_ALIAS_SOUND);