snd_ps3.c 27 KB

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