kirkwood-i2s.c 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485
  1. /*
  2. * kirkwood-i2s.c
  3. *
  4. * (c) 2010 Arnaud Patard <apatard@mandriva.com>
  5. *
  6. * This program is free software; you can redistribute it and/or modify it
  7. * under the terms of the GNU General Public License as published by the
  8. * Free Software Foundation; either version 2 of the License, or (at your
  9. * option) any later version.
  10. */
  11. #include <linux/init.h>
  12. #include <linux/module.h>
  13. #include <linux/platform_device.h>
  14. #include <linux/io.h>
  15. #include <linux/slab.h>
  16. #include <linux/mbus.h>
  17. #include <linux/delay.h>
  18. #include <sound/pcm.h>
  19. #include <sound/pcm_params.h>
  20. #include <sound/soc.h>
  21. #include <plat/audio.h>
  22. #include "kirkwood-i2s.h"
  23. #include "kirkwood.h"
  24. #define DRV_NAME "kirkwood-i2s"
  25. #define KIRKWOOD_I2S_RATES \
  26. (SNDRV_PCM_RATE_44100 | \
  27. SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_96000)
  28. #define KIRKWOOD_I2S_FORMATS \
  29. (SNDRV_PCM_FMTBIT_S16_LE | \
  30. SNDRV_PCM_FMTBIT_S24_LE | \
  31. SNDRV_PCM_FMTBIT_S32_LE)
  32. struct snd_soc_dai kirkwood_i2s_dai;
  33. static struct kirkwood_dma_data *priv;
  34. static int kirkwood_i2s_set_fmt(struct snd_soc_dai *cpu_dai,
  35. unsigned int fmt)
  36. {
  37. unsigned long mask;
  38. unsigned long value;
  39. switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
  40. case SND_SOC_DAIFMT_RIGHT_J:
  41. mask = KIRKWOOD_I2S_CTL_RJ;
  42. break;
  43. case SND_SOC_DAIFMT_LEFT_J:
  44. mask = KIRKWOOD_I2S_CTL_LJ;
  45. break;
  46. case SND_SOC_DAIFMT_I2S:
  47. mask = KIRKWOOD_I2S_CTL_I2S;
  48. break;
  49. default:
  50. return -EINVAL;
  51. }
  52. /*
  53. * Set same format for playback and record
  54. * This avoids some troubles.
  55. */
  56. value = readl(priv->io+KIRKWOOD_I2S_PLAYCTL);
  57. value &= ~KIRKWOOD_I2S_CTL_JUST_MASK;
  58. value |= mask;
  59. writel(value, priv->io+KIRKWOOD_I2S_PLAYCTL);
  60. value = readl(priv->io+KIRKWOOD_I2S_RECCTL);
  61. value &= ~KIRKWOOD_I2S_CTL_JUST_MASK;
  62. value |= mask;
  63. writel(value, priv->io+KIRKWOOD_I2S_RECCTL);
  64. return 0;
  65. }
  66. static inline void kirkwood_set_dco(void __iomem *io, unsigned long rate)
  67. {
  68. unsigned long value;
  69. value = KIRKWOOD_DCO_CTL_OFFSET_0;
  70. switch (rate) {
  71. default:
  72. case 44100:
  73. value |= KIRKWOOD_DCO_CTL_FREQ_11;
  74. break;
  75. case 48000:
  76. value |= KIRKWOOD_DCO_CTL_FREQ_12;
  77. break;
  78. case 96000:
  79. value |= KIRKWOOD_DCO_CTL_FREQ_24;
  80. break;
  81. }
  82. writel(value, io + KIRKWOOD_DCO_CTL);
  83. /* wait for dco locked */
  84. do {
  85. cpu_relax();
  86. value = readl(io + KIRKWOOD_DCO_SPCR_STATUS);
  87. value &= KIRKWOOD_DCO_SPCR_STATUS;
  88. } while (value == 0);
  89. }
  90. static int kirkwood_i2s_hw_params(struct snd_pcm_substream *substream,
  91. struct snd_pcm_hw_params *params,
  92. struct snd_soc_dai *dai)
  93. {
  94. unsigned int i2s_reg, reg;
  95. unsigned long i2s_value, value;
  96. if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
  97. i2s_reg = KIRKWOOD_I2S_PLAYCTL;
  98. reg = KIRKWOOD_PLAYCTL;
  99. } else {
  100. i2s_reg = KIRKWOOD_I2S_RECCTL;
  101. reg = KIRKWOOD_RECCTL;
  102. }
  103. /* set dco conf */
  104. kirkwood_set_dco(priv->io, params_rate(params));
  105. i2s_value = readl(priv->io+i2s_reg);
  106. i2s_value &= ~KIRKWOOD_I2S_CTL_SIZE_MASK;
  107. value = readl(priv->io+reg);
  108. value &= ~KIRKWOOD_PLAYCTL_SIZE_MASK;
  109. /*
  110. * Size settings in play/rec i2s control regs and play/rec control
  111. * regs must be the same.
  112. */
  113. switch (params_format(params)) {
  114. case SNDRV_PCM_FORMAT_S16_LE:
  115. i2s_value |= KIRKWOOD_I2S_CTL_SIZE_16;
  116. value |= KIRKWOOD_PLAYCTL_SIZE_16_C;
  117. break;
  118. /*
  119. * doesn't work... S20_3LE != kirkwood 20bit format ?
  120. *
  121. case SNDRV_PCM_FORMAT_S20_3LE:
  122. i2s_value |= KIRKWOOD_I2S_CTL_SIZE_20;
  123. value |= KIRKWOOD_PLAYCTL_SIZE_20;
  124. break;
  125. */
  126. case SNDRV_PCM_FORMAT_S24_LE:
  127. i2s_value |= KIRKWOOD_I2S_CTL_SIZE_24;
  128. value |= KIRKWOOD_PLAYCTL_SIZE_24;
  129. break;
  130. case SNDRV_PCM_FORMAT_S32_LE:
  131. i2s_value |= KIRKWOOD_I2S_CTL_SIZE_32;
  132. value |= KIRKWOOD_PLAYCTL_SIZE_32;
  133. break;
  134. default:
  135. return -EINVAL;
  136. }
  137. writel(i2s_value, priv->io+i2s_reg);
  138. writel(value, priv->io+reg);
  139. return 0;
  140. }
  141. static int kirkwood_i2s_play_trigger(struct snd_pcm_substream *substream,
  142. int cmd, struct snd_soc_dai *dai)
  143. {
  144. unsigned long value;
  145. /*
  146. * specs says KIRKWOOD_PLAYCTL must be read 2 times before
  147. * changing it. So read 1 time here and 1 later.
  148. */
  149. value = readl(priv->io + KIRKWOOD_PLAYCTL);
  150. switch (cmd) {
  151. case SNDRV_PCM_TRIGGER_START:
  152. /* stop audio, enable interrupts */
  153. value = readl(priv->io + KIRKWOOD_PLAYCTL);
  154. value |= KIRKWOOD_PLAYCTL_PAUSE;
  155. writel(value, priv->io + KIRKWOOD_PLAYCTL);
  156. value = readl(priv->io + KIRKWOOD_INT_MASK);
  157. value |= KIRKWOOD_INT_CAUSE_PLAY_BYTES;
  158. writel(value, priv->io + KIRKWOOD_INT_MASK);
  159. /* configure audio & enable i2s playback */
  160. value = readl(priv->io + KIRKWOOD_PLAYCTL);
  161. value &= ~KIRKWOOD_PLAYCTL_BURST_MASK;
  162. value &= ~(KIRKWOOD_PLAYCTL_PAUSE|KIRKWOOD_PLAYCTL_SPDIF_EN);
  163. if (priv->burst == 32)
  164. value |= KIRKWOOD_PLAYCTL_BURST_32;
  165. else
  166. value |= KIRKWOOD_PLAYCTL_BURST_128;
  167. value |= KIRKWOOD_PLAYCTL_I2S_EN;
  168. writel(value, priv->io + KIRKWOOD_PLAYCTL);
  169. break;
  170. case SNDRV_PCM_TRIGGER_STOP:
  171. /* stop audio, disable interrupts */
  172. value = readl(priv->io + KIRKWOOD_PLAYCTL);
  173. value |= KIRKWOOD_PLAYCTL_PAUSE;
  174. writel(value, priv->io + KIRKWOOD_PLAYCTL);
  175. value = readl(priv->io + KIRKWOOD_INT_MASK);
  176. value &= ~KIRKWOOD_INT_CAUSE_PLAY_BYTES;
  177. writel(value, priv->io + KIRKWOOD_INT_MASK);
  178. /* disable all playbacks */
  179. value = readl(priv->io + KIRKWOOD_PLAYCTL);
  180. value &= ~(KIRKWOOD_PLAYCTL_I2S_EN | KIRKWOOD_PLAYCTL_SPDIF_EN);
  181. writel(value, priv->io + KIRKWOOD_PLAYCTL);
  182. break;
  183. case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
  184. case SNDRV_PCM_TRIGGER_SUSPEND:
  185. value = readl(priv->io + KIRKWOOD_PLAYCTL);
  186. value |= KIRKWOOD_PLAYCTL_PAUSE;
  187. writel(value, priv->io + KIRKWOOD_PLAYCTL);
  188. break;
  189. case SNDRV_PCM_TRIGGER_RESUME:
  190. case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
  191. value = readl(priv->io + KIRKWOOD_PLAYCTL);
  192. value &= ~KIRKWOOD_PLAYCTL_PAUSE;
  193. writel(value, priv->io + KIRKWOOD_PLAYCTL);
  194. break;
  195. default:
  196. return -EINVAL;
  197. }
  198. return 0;
  199. }
  200. static int kirkwood_i2s_rec_trigger(struct snd_pcm_substream *substream,
  201. int cmd, struct snd_soc_dai *dai)
  202. {
  203. unsigned long value;
  204. value = readl(priv->io + KIRKWOOD_RECCTL);
  205. switch (cmd) {
  206. case SNDRV_PCM_TRIGGER_START:
  207. /* stop audio, enable interrupts */
  208. value = readl(priv->io + KIRKWOOD_RECCTL);
  209. value |= KIRKWOOD_RECCTL_PAUSE;
  210. writel(value, priv->io + KIRKWOOD_RECCTL);
  211. value = readl(priv->io + KIRKWOOD_INT_MASK);
  212. value |= KIRKWOOD_INT_CAUSE_REC_BYTES;
  213. writel(value, priv->io + KIRKWOOD_INT_MASK);
  214. /* configure audio & enable i2s record */
  215. value = readl(priv->io + KIRKWOOD_RECCTL);
  216. value &= ~KIRKWOOD_RECCTL_BURST_MASK;
  217. value &= ~KIRKWOOD_RECCTL_MONO;
  218. value &= ~(KIRKWOOD_RECCTL_PAUSE | KIRKWOOD_RECCTL_SPDIF_EN);
  219. if (priv->burst == 32)
  220. value |= KIRKWOOD_RECCTL_BURST_32;
  221. else
  222. value |= KIRKWOOD_RECCTL_BURST_128;
  223. value |= KIRKWOOD_RECCTL_I2S_EN;
  224. writel(value, priv->io + KIRKWOOD_RECCTL);
  225. break;
  226. case SNDRV_PCM_TRIGGER_STOP:
  227. /* stop audio, disable interrupts */
  228. value = readl(priv->io + KIRKWOOD_RECCTL);
  229. value |= KIRKWOOD_RECCTL_PAUSE;
  230. writel(value, priv->io + KIRKWOOD_RECCTL);
  231. value = readl(priv->io + KIRKWOOD_INT_MASK);
  232. value &= ~KIRKWOOD_INT_CAUSE_REC_BYTES;
  233. writel(value, priv->io + KIRKWOOD_INT_MASK);
  234. /* disable all records */
  235. value = readl(priv->io + KIRKWOOD_RECCTL);
  236. value &= ~(KIRKWOOD_RECCTL_I2S_EN | KIRKWOOD_RECCTL_SPDIF_EN);
  237. writel(value, priv->io + KIRKWOOD_RECCTL);
  238. break;
  239. case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
  240. case SNDRV_PCM_TRIGGER_SUSPEND:
  241. value = readl(priv->io + KIRKWOOD_RECCTL);
  242. value |= KIRKWOOD_RECCTL_PAUSE;
  243. writel(value, priv->io + KIRKWOOD_RECCTL);
  244. break;
  245. case SNDRV_PCM_TRIGGER_RESUME:
  246. case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
  247. value = readl(priv->io + KIRKWOOD_RECCTL);
  248. value &= ~KIRKWOOD_RECCTL_PAUSE;
  249. writel(value, priv->io + KIRKWOOD_RECCTL);
  250. break;
  251. default:
  252. return -EINVAL;
  253. break;
  254. }
  255. return 0;
  256. }
  257. static int kirkwood_i2s_trigger(struct snd_pcm_substream *substream, int cmd,
  258. struct snd_soc_dai *dai)
  259. {
  260. if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
  261. return kirkwood_i2s_play_trigger(substream, cmd, dai);
  262. else
  263. return kirkwood_i2s_rec_trigger(substream, cmd, dai);
  264. return 0;
  265. }
  266. static int kirkwood_i2s_probe(struct platform_device *pdev,
  267. struct snd_soc_dai *dai)
  268. {
  269. unsigned long value;
  270. unsigned int reg_data;
  271. /* put system in a "safe" state : */
  272. /* disable audio interrupts */
  273. writel(0xffffffff, priv->io + KIRKWOOD_INT_CAUSE);
  274. writel(0, priv->io + KIRKWOOD_INT_MASK);
  275. reg_data = readl(priv->io + 0x1200);
  276. reg_data &= (~(0x333FF8));
  277. reg_data |= 0x111D18;
  278. writel(reg_data, priv->io + 0x1200);
  279. msleep(500);
  280. reg_data = readl(priv->io + 0x1200);
  281. reg_data &= (~(0x333FF8));
  282. reg_data |= 0x111D18;
  283. writel(reg_data, priv->io + 0x1200);
  284. /* disable playback/record */
  285. value = readl(priv->io + KIRKWOOD_PLAYCTL);
  286. value &= ~(KIRKWOOD_PLAYCTL_I2S_EN|KIRKWOOD_PLAYCTL_SPDIF_EN);
  287. writel(value, priv->io + KIRKWOOD_PLAYCTL);
  288. value = readl(priv->io + KIRKWOOD_RECCTL);
  289. value &= ~(KIRKWOOD_RECCTL_I2S_EN | KIRKWOOD_RECCTL_SPDIF_EN);
  290. writel(value, priv->io + KIRKWOOD_RECCTL);
  291. return 0;
  292. }
  293. static void kirkwood_i2s_remove(struct platform_device *pdev,
  294. struct snd_soc_dai *dai)
  295. {
  296. }
  297. static struct snd_soc_dai_ops kirkwood_i2s_dai_ops = {
  298. .trigger = kirkwood_i2s_trigger,
  299. .hw_params = kirkwood_i2s_hw_params,
  300. .set_fmt = kirkwood_i2s_set_fmt,
  301. };
  302. struct snd_soc_dai kirkwood_i2s_dai = {
  303. .name = DRV_NAME,
  304. .id = 0,
  305. .probe = kirkwood_i2s_probe,
  306. .remove = kirkwood_i2s_remove,
  307. .playback = {
  308. .channels_min = 1,
  309. .channels_max = 2,
  310. .rates = KIRKWOOD_I2S_RATES,
  311. .formats = KIRKWOOD_I2S_FORMATS,},
  312. .capture = {
  313. .channels_min = 1,
  314. .channels_max = 2,
  315. .rates = KIRKWOOD_I2S_RATES,
  316. .formats = KIRKWOOD_I2S_FORMATS,},
  317. .ops = &kirkwood_i2s_dai_ops,
  318. };
  319. EXPORT_SYMBOL_GPL(kirkwood_i2s_dai);
  320. static __devinit int kirkwood_i2s_dev_probe(struct platform_device *pdev)
  321. {
  322. struct resource *mem;
  323. struct kirkwood_asoc_platform_data *data =
  324. pdev->dev.platform_data;
  325. int err;
  326. priv = kzalloc(sizeof(struct kirkwood_dma_data), GFP_KERNEL);
  327. if (!priv) {
  328. dev_err(&pdev->dev, "allocation failed\n");
  329. err = -ENOMEM;
  330. goto error;
  331. }
  332. mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
  333. if (!mem) {
  334. dev_err(&pdev->dev, "platform_get_resource failed\n");
  335. err = -ENXIO;
  336. goto err_alloc;
  337. }
  338. priv->mem = request_mem_region(mem->start, SZ_16K, DRV_NAME);
  339. if (!priv->mem) {
  340. dev_err(&pdev->dev, "request_mem_region failed\n");
  341. err = -EBUSY;
  342. goto error;
  343. }
  344. priv->io = ioremap(priv->mem->start, SZ_16K);
  345. if (!priv->io) {
  346. dev_err(&pdev->dev, "ioremap failed\n");
  347. err = -ENOMEM;
  348. goto err_iomem;
  349. }
  350. priv->irq = platform_get_irq(pdev, 0);
  351. if (priv->irq <= 0) {
  352. dev_err(&pdev->dev, "platform_get_irq failed\n");
  353. err = -ENXIO;
  354. goto err_ioremap;
  355. }
  356. if (!data || !data->dram) {
  357. dev_err(&pdev->dev, "no platform data ?!\n");
  358. err = -EINVAL;
  359. goto err_ioremap;
  360. }
  361. priv->dram = data->dram;
  362. priv->burst = data->burst;
  363. kirkwood_i2s_dai.capture.dma_data = priv;
  364. kirkwood_i2s_dai.playback.dma_data = priv;
  365. return snd_soc_register_dai(&kirkwood_i2s_dai);
  366. err_ioremap:
  367. iounmap(priv->io);
  368. err_iomem:
  369. release_mem_region(priv->mem->start, SZ_16K);
  370. err_alloc:
  371. kfree(priv);
  372. error:
  373. return err;
  374. }
  375. static __devexit int kirkwood_i2s_dev_remove(struct platform_device *pdev)
  376. {
  377. if (priv) {
  378. iounmap(priv->io);
  379. release_mem_region(priv->mem->start, SZ_16K);
  380. kfree(priv);
  381. }
  382. snd_soc_unregister_dai(&kirkwood_i2s_dai);
  383. return 0;
  384. }
  385. static struct platform_driver kirkwood_i2s_driver = {
  386. .probe = kirkwood_i2s_dev_probe,
  387. .remove = kirkwood_i2s_dev_remove,
  388. .driver = {
  389. .name = DRV_NAME,
  390. .owner = THIS_MODULE,
  391. },
  392. };
  393. static int __init kirkwood_i2s_init(void)
  394. {
  395. return platform_driver_register(&kirkwood_i2s_driver);
  396. }
  397. module_init(kirkwood_i2s_init);
  398. static void __exit kirkwood_i2s_exit(void)
  399. {
  400. platform_driver_unregister(&kirkwood_i2s_driver);
  401. }
  402. module_exit(kirkwood_i2s_exit);
  403. /* Module information */
  404. MODULE_AUTHOR("Arnaud Patard, <apatard@mandriva.com>");
  405. MODULE_DESCRIPTION("Kirkwood I2S SoC Interface");
  406. MODULE_LICENSE("GPL");
  407. MODULE_ALIAS("platform:kirkwood-i2s");