kirkwood-i2s.c 16 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * kirkwood-i2s.c
  4. *
  5. * (c) 2010 Arnaud Patard <apatard@mandriva.com>
  6. * (c) 2010 Arnaud Patard <arnaud.patard@rtp-net.org>
  7. */
  8. #include <linux/init.h>
  9. #include <linux/module.h>
  10. #include <linux/platform_device.h>
  11. #include <linux/io.h>
  12. #include <linux/slab.h>
  13. #include <linux/mbus.h>
  14. #include <linux/delay.h>
  15. #include <linux/clk.h>
  16. #include <sound/pcm.h>
  17. #include <sound/pcm_params.h>
  18. #include <sound/soc.h>
  19. #include <linux/platform_data/asoc-kirkwood.h>
  20. #include <linux/of.h>
  21. #include "kirkwood.h"
  22. #define KIRKWOOD_I2S_FORMATS \
  23. (SNDRV_PCM_FMTBIT_S16_LE | \
  24. SNDRV_PCM_FMTBIT_S24_LE | \
  25. SNDRV_PCM_FMTBIT_S32_LE)
  26. #define KIRKWOOD_SPDIF_FORMATS \
  27. (SNDRV_PCM_FMTBIT_S16_LE | \
  28. SNDRV_PCM_FMTBIT_S24_LE)
  29. static int kirkwood_i2s_set_fmt(struct snd_soc_dai *cpu_dai,
  30. unsigned int fmt)
  31. {
  32. struct kirkwood_dma_data *priv = snd_soc_dai_get_drvdata(cpu_dai);
  33. unsigned long mask;
  34. unsigned long value;
  35. switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
  36. case SND_SOC_DAIFMT_RIGHT_J:
  37. mask = KIRKWOOD_I2S_CTL_RJ;
  38. break;
  39. case SND_SOC_DAIFMT_LEFT_J:
  40. mask = KIRKWOOD_I2S_CTL_LJ;
  41. break;
  42. case SND_SOC_DAIFMT_I2S:
  43. mask = KIRKWOOD_I2S_CTL_I2S;
  44. break;
  45. default:
  46. return -EINVAL;
  47. }
  48. /*
  49. * Set same format for playback and record
  50. * This avoids some troubles.
  51. */
  52. value = readl(priv->io+KIRKWOOD_I2S_PLAYCTL);
  53. value &= ~KIRKWOOD_I2S_CTL_JUST_MASK;
  54. value |= mask;
  55. writel(value, priv->io+KIRKWOOD_I2S_PLAYCTL);
  56. value = readl(priv->io+KIRKWOOD_I2S_RECCTL);
  57. value &= ~KIRKWOOD_I2S_CTL_JUST_MASK;
  58. value |= mask;
  59. writel(value, priv->io+KIRKWOOD_I2S_RECCTL);
  60. return 0;
  61. }
  62. static inline void kirkwood_set_dco(void __iomem *io, unsigned long rate)
  63. {
  64. unsigned long value;
  65. value = KIRKWOOD_DCO_CTL_OFFSET_0;
  66. switch (rate) {
  67. default:
  68. case 44100:
  69. value |= KIRKWOOD_DCO_CTL_FREQ_11;
  70. break;
  71. case 48000:
  72. value |= KIRKWOOD_DCO_CTL_FREQ_12;
  73. break;
  74. case 96000:
  75. value |= KIRKWOOD_DCO_CTL_FREQ_24;
  76. break;
  77. }
  78. writel(value, io + KIRKWOOD_DCO_CTL);
  79. /* wait for dco locked */
  80. do {
  81. cpu_relax();
  82. value = readl(io + KIRKWOOD_DCO_SPCR_STATUS);
  83. value &= KIRKWOOD_DCO_SPCR_STATUS_DCO_LOCK;
  84. } while (value == 0);
  85. }
  86. static void kirkwood_set_rate(struct snd_soc_dai *dai,
  87. struct kirkwood_dma_data *priv, unsigned long rate)
  88. {
  89. uint32_t clks_ctrl;
  90. if (IS_ERR(priv->extclk)) {
  91. /* use internal dco for the supported rates
  92. * defined in kirkwood_i2s_dai */
  93. dev_dbg(dai->dev, "%s: dco set rate = %lu\n",
  94. __func__, rate);
  95. kirkwood_set_dco(priv->io, rate);
  96. clks_ctrl = KIRKWOOD_MCLK_SOURCE_DCO;
  97. } else {
  98. /* use the external clock for the other rates
  99. * defined in kirkwood_i2s_dai_extclk */
  100. dev_dbg(dai->dev, "%s: extclk set rate = %lu -> %lu\n",
  101. __func__, rate, 256 * rate);
  102. clk_set_rate(priv->extclk, 256 * rate);
  103. clks_ctrl = KIRKWOOD_MCLK_SOURCE_EXTCLK;
  104. }
  105. writel(clks_ctrl, priv->io + KIRKWOOD_CLOCKS_CTRL);
  106. }
  107. static int kirkwood_i2s_startup(struct snd_pcm_substream *substream,
  108. struct snd_soc_dai *dai)
  109. {
  110. struct kirkwood_dma_data *priv = snd_soc_dai_get_drvdata(dai);
  111. snd_soc_dai_set_dma_data(dai, substream, priv);
  112. return 0;
  113. }
  114. static int kirkwood_i2s_hw_params(struct snd_pcm_substream *substream,
  115. struct snd_pcm_hw_params *params,
  116. struct snd_soc_dai *dai)
  117. {
  118. struct kirkwood_dma_data *priv = snd_soc_dai_get_drvdata(dai);
  119. uint32_t ctl_play, ctl_rec;
  120. unsigned int i2s_reg;
  121. unsigned long i2s_value;
  122. if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
  123. i2s_reg = KIRKWOOD_I2S_PLAYCTL;
  124. } else {
  125. i2s_reg = KIRKWOOD_I2S_RECCTL;
  126. }
  127. kirkwood_set_rate(dai, priv, params_rate(params));
  128. i2s_value = readl(priv->io+i2s_reg);
  129. i2s_value &= ~KIRKWOOD_I2S_CTL_SIZE_MASK;
  130. /*
  131. * Size settings in play/rec i2s control regs and play/rec control
  132. * regs must be the same.
  133. */
  134. switch (params_format(params)) {
  135. case SNDRV_PCM_FORMAT_S16_LE:
  136. i2s_value |= KIRKWOOD_I2S_CTL_SIZE_16;
  137. ctl_play = KIRKWOOD_PLAYCTL_SIZE_16_C |
  138. KIRKWOOD_PLAYCTL_I2S_EN |
  139. KIRKWOOD_PLAYCTL_SPDIF_EN;
  140. ctl_rec = KIRKWOOD_RECCTL_SIZE_16_C |
  141. KIRKWOOD_RECCTL_I2S_EN |
  142. KIRKWOOD_RECCTL_SPDIF_EN;
  143. break;
  144. /*
  145. * doesn't work... S20_3LE != kirkwood 20bit format ?
  146. *
  147. case SNDRV_PCM_FORMAT_S20_3LE:
  148. i2s_value |= KIRKWOOD_I2S_CTL_SIZE_20;
  149. ctl_play = KIRKWOOD_PLAYCTL_SIZE_20 |
  150. KIRKWOOD_PLAYCTL_I2S_EN;
  151. ctl_rec = KIRKWOOD_RECCTL_SIZE_20 |
  152. KIRKWOOD_RECCTL_I2S_EN;
  153. break;
  154. */
  155. case SNDRV_PCM_FORMAT_S24_LE:
  156. i2s_value |= KIRKWOOD_I2S_CTL_SIZE_24;
  157. ctl_play = KIRKWOOD_PLAYCTL_SIZE_24 |
  158. KIRKWOOD_PLAYCTL_I2S_EN |
  159. KIRKWOOD_PLAYCTL_SPDIF_EN;
  160. ctl_rec = KIRKWOOD_RECCTL_SIZE_24 |
  161. KIRKWOOD_RECCTL_I2S_EN |
  162. KIRKWOOD_RECCTL_SPDIF_EN;
  163. break;
  164. case SNDRV_PCM_FORMAT_S32_LE:
  165. i2s_value |= KIRKWOOD_I2S_CTL_SIZE_32;
  166. ctl_play = KIRKWOOD_PLAYCTL_SIZE_32 |
  167. KIRKWOOD_PLAYCTL_I2S_EN;
  168. ctl_rec = KIRKWOOD_RECCTL_SIZE_32 |
  169. KIRKWOOD_RECCTL_I2S_EN;
  170. break;
  171. default:
  172. return -EINVAL;
  173. }
  174. if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
  175. if (params_channels(params) == 1)
  176. ctl_play |= KIRKWOOD_PLAYCTL_MONO_BOTH;
  177. else
  178. ctl_play |= KIRKWOOD_PLAYCTL_MONO_OFF;
  179. priv->ctl_play &= ~(KIRKWOOD_PLAYCTL_MONO_MASK |
  180. KIRKWOOD_PLAYCTL_ENABLE_MASK |
  181. KIRKWOOD_PLAYCTL_SIZE_MASK);
  182. priv->ctl_play |= ctl_play;
  183. } else {
  184. priv->ctl_rec &= ~(KIRKWOOD_RECCTL_ENABLE_MASK |
  185. KIRKWOOD_RECCTL_SIZE_MASK);
  186. priv->ctl_rec |= ctl_rec;
  187. }
  188. writel(i2s_value, priv->io+i2s_reg);
  189. return 0;
  190. }
  191. static unsigned kirkwood_i2s_play_mute(unsigned ctl)
  192. {
  193. if (!(ctl & KIRKWOOD_PLAYCTL_I2S_EN))
  194. ctl |= KIRKWOOD_PLAYCTL_I2S_MUTE;
  195. if (!(ctl & KIRKWOOD_PLAYCTL_SPDIF_EN))
  196. ctl |= KIRKWOOD_PLAYCTL_SPDIF_MUTE;
  197. return ctl;
  198. }
  199. static int kirkwood_i2s_play_trigger(struct snd_pcm_substream *substream,
  200. int cmd, struct snd_soc_dai *dai)
  201. {
  202. struct snd_pcm_runtime *runtime = substream->runtime;
  203. struct kirkwood_dma_data *priv = snd_soc_dai_get_drvdata(dai);
  204. uint32_t ctl, value;
  205. ctl = readl(priv->io + KIRKWOOD_PLAYCTL);
  206. if ((ctl & KIRKWOOD_PLAYCTL_ENABLE_MASK) == 0) {
  207. unsigned timeout = 5000;
  208. /*
  209. * The Armada510 spec says that if we enter pause mode, the
  210. * busy bit must be read back as clear _twice_. Make sure
  211. * we respect that otherwise we get DMA underruns.
  212. */
  213. do {
  214. value = ctl;
  215. ctl = readl(priv->io + KIRKWOOD_PLAYCTL);
  216. if (!((ctl | value) & KIRKWOOD_PLAYCTL_PLAY_BUSY))
  217. break;
  218. udelay(1);
  219. } while (timeout--);
  220. if ((ctl | value) & KIRKWOOD_PLAYCTL_PLAY_BUSY)
  221. dev_notice(dai->dev, "timed out waiting for busy to deassert: %08x\n",
  222. ctl);
  223. }
  224. switch (cmd) {
  225. case SNDRV_PCM_TRIGGER_START:
  226. /* configure */
  227. ctl = priv->ctl_play;
  228. if (dai->id == 0)
  229. ctl &= ~KIRKWOOD_PLAYCTL_SPDIF_EN; /* i2s */
  230. else
  231. ctl &= ~KIRKWOOD_PLAYCTL_I2S_EN; /* spdif */
  232. ctl = kirkwood_i2s_play_mute(ctl);
  233. value = ctl & ~KIRKWOOD_PLAYCTL_ENABLE_MASK;
  234. writel(value, priv->io + KIRKWOOD_PLAYCTL);
  235. /* enable interrupts */
  236. if (!runtime->no_period_wakeup) {
  237. value = readl(priv->io + KIRKWOOD_INT_MASK);
  238. value |= KIRKWOOD_INT_CAUSE_PLAY_BYTES;
  239. writel(value, priv->io + KIRKWOOD_INT_MASK);
  240. }
  241. /* enable playback */
  242. writel(ctl, priv->io + KIRKWOOD_PLAYCTL);
  243. break;
  244. case SNDRV_PCM_TRIGGER_STOP:
  245. /* stop audio, disable interrupts */
  246. ctl |= KIRKWOOD_PLAYCTL_PAUSE | KIRKWOOD_PLAYCTL_I2S_MUTE |
  247. KIRKWOOD_PLAYCTL_SPDIF_MUTE;
  248. writel(ctl, priv->io + KIRKWOOD_PLAYCTL);
  249. value = readl(priv->io + KIRKWOOD_INT_MASK);
  250. value &= ~KIRKWOOD_INT_CAUSE_PLAY_BYTES;
  251. writel(value, priv->io + KIRKWOOD_INT_MASK);
  252. /* disable all playbacks */
  253. ctl &= ~KIRKWOOD_PLAYCTL_ENABLE_MASK;
  254. writel(ctl, priv->io + KIRKWOOD_PLAYCTL);
  255. break;
  256. case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
  257. case SNDRV_PCM_TRIGGER_SUSPEND:
  258. ctl |= KIRKWOOD_PLAYCTL_PAUSE | KIRKWOOD_PLAYCTL_I2S_MUTE |
  259. KIRKWOOD_PLAYCTL_SPDIF_MUTE;
  260. writel(ctl, priv->io + KIRKWOOD_PLAYCTL);
  261. break;
  262. case SNDRV_PCM_TRIGGER_RESUME:
  263. case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
  264. ctl &= ~(KIRKWOOD_PLAYCTL_PAUSE | KIRKWOOD_PLAYCTL_I2S_MUTE |
  265. KIRKWOOD_PLAYCTL_SPDIF_MUTE);
  266. ctl = kirkwood_i2s_play_mute(ctl);
  267. writel(ctl, priv->io + KIRKWOOD_PLAYCTL);
  268. break;
  269. default:
  270. return -EINVAL;
  271. }
  272. return 0;
  273. }
  274. static int kirkwood_i2s_rec_trigger(struct snd_pcm_substream *substream,
  275. int cmd, struct snd_soc_dai *dai)
  276. {
  277. struct kirkwood_dma_data *priv = snd_soc_dai_get_drvdata(dai);
  278. uint32_t ctl, value;
  279. value = readl(priv->io + KIRKWOOD_RECCTL);
  280. switch (cmd) {
  281. case SNDRV_PCM_TRIGGER_START:
  282. /* configure */
  283. ctl = priv->ctl_rec;
  284. if (dai->id == 0)
  285. ctl &= ~KIRKWOOD_RECCTL_SPDIF_EN; /* i2s */
  286. else
  287. ctl &= ~KIRKWOOD_RECCTL_I2S_EN; /* spdif */
  288. value = ctl & ~KIRKWOOD_RECCTL_ENABLE_MASK;
  289. writel(value, priv->io + KIRKWOOD_RECCTL);
  290. /* enable interrupts */
  291. value = readl(priv->io + KIRKWOOD_INT_MASK);
  292. value |= KIRKWOOD_INT_CAUSE_REC_BYTES;
  293. writel(value, priv->io + KIRKWOOD_INT_MASK);
  294. /* enable record */
  295. writel(ctl, priv->io + KIRKWOOD_RECCTL);
  296. break;
  297. case SNDRV_PCM_TRIGGER_STOP:
  298. /* stop audio, disable interrupts */
  299. value = readl(priv->io + KIRKWOOD_RECCTL);
  300. value |= KIRKWOOD_RECCTL_PAUSE | KIRKWOOD_RECCTL_MUTE;
  301. writel(value, priv->io + KIRKWOOD_RECCTL);
  302. value = readl(priv->io + KIRKWOOD_INT_MASK);
  303. value &= ~KIRKWOOD_INT_CAUSE_REC_BYTES;
  304. writel(value, priv->io + KIRKWOOD_INT_MASK);
  305. /* disable all records */
  306. value = readl(priv->io + KIRKWOOD_RECCTL);
  307. value &= ~KIRKWOOD_RECCTL_ENABLE_MASK;
  308. writel(value, priv->io + KIRKWOOD_RECCTL);
  309. break;
  310. case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
  311. case SNDRV_PCM_TRIGGER_SUSPEND:
  312. value = readl(priv->io + KIRKWOOD_RECCTL);
  313. value |= KIRKWOOD_RECCTL_PAUSE | KIRKWOOD_RECCTL_MUTE;
  314. writel(value, priv->io + KIRKWOOD_RECCTL);
  315. break;
  316. case SNDRV_PCM_TRIGGER_RESUME:
  317. case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
  318. value = readl(priv->io + KIRKWOOD_RECCTL);
  319. value &= ~(KIRKWOOD_RECCTL_PAUSE | KIRKWOOD_RECCTL_MUTE);
  320. writel(value, priv->io + KIRKWOOD_RECCTL);
  321. break;
  322. default:
  323. return -EINVAL;
  324. }
  325. return 0;
  326. }
  327. static int kirkwood_i2s_trigger(struct snd_pcm_substream *substream, int cmd,
  328. struct snd_soc_dai *dai)
  329. {
  330. if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
  331. return kirkwood_i2s_play_trigger(substream, cmd, dai);
  332. else
  333. return kirkwood_i2s_rec_trigger(substream, cmd, dai);
  334. return 0;
  335. }
  336. static int kirkwood_i2s_init(struct kirkwood_dma_data *priv)
  337. {
  338. unsigned long value;
  339. unsigned int reg_data;
  340. /* put system in a "safe" state : */
  341. /* disable audio interrupts */
  342. writel(0xffffffff, priv->io + KIRKWOOD_INT_CAUSE);
  343. writel(0, priv->io + KIRKWOOD_INT_MASK);
  344. reg_data = readl(priv->io + 0x1200);
  345. reg_data &= (~(0x333FF8));
  346. reg_data |= 0x111D18;
  347. writel(reg_data, priv->io + 0x1200);
  348. msleep(500);
  349. reg_data = readl(priv->io + 0x1200);
  350. reg_data &= (~(0x333FF8));
  351. reg_data |= 0x111D18;
  352. writel(reg_data, priv->io + 0x1200);
  353. /* disable playback/record */
  354. value = readl(priv->io + KIRKWOOD_PLAYCTL);
  355. value &= ~KIRKWOOD_PLAYCTL_ENABLE_MASK;
  356. writel(value, priv->io + KIRKWOOD_PLAYCTL);
  357. value = readl(priv->io + KIRKWOOD_RECCTL);
  358. value &= ~KIRKWOOD_RECCTL_ENABLE_MASK;
  359. writel(value, priv->io + KIRKWOOD_RECCTL);
  360. return 0;
  361. }
  362. static const struct snd_soc_dai_ops kirkwood_i2s_dai_ops = {
  363. .startup = kirkwood_i2s_startup,
  364. .trigger = kirkwood_i2s_trigger,
  365. .hw_params = kirkwood_i2s_hw_params,
  366. .set_fmt = kirkwood_i2s_set_fmt,
  367. };
  368. static struct snd_soc_dai_driver kirkwood_i2s_dai[2] = {
  369. {
  370. .name = "i2s",
  371. .id = 0,
  372. .playback = {
  373. .channels_min = 1,
  374. .channels_max = 2,
  375. .rates = SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000 |
  376. SNDRV_PCM_RATE_96000,
  377. .formats = KIRKWOOD_I2S_FORMATS,
  378. },
  379. .capture = {
  380. .channels_min = 1,
  381. .channels_max = 2,
  382. .rates = SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000 |
  383. SNDRV_PCM_RATE_96000,
  384. .formats = KIRKWOOD_I2S_FORMATS,
  385. },
  386. .ops = &kirkwood_i2s_dai_ops,
  387. },
  388. {
  389. .name = "spdif",
  390. .id = 1,
  391. .playback = {
  392. .channels_min = 1,
  393. .channels_max = 2,
  394. .rates = SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000 |
  395. SNDRV_PCM_RATE_96000,
  396. .formats = KIRKWOOD_SPDIF_FORMATS,
  397. },
  398. .capture = {
  399. .channels_min = 1,
  400. .channels_max = 2,
  401. .rates = SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000 |
  402. SNDRV_PCM_RATE_96000,
  403. .formats = KIRKWOOD_SPDIF_FORMATS,
  404. },
  405. .ops = &kirkwood_i2s_dai_ops,
  406. },
  407. };
  408. static struct snd_soc_dai_driver kirkwood_i2s_dai_extclk[2] = {
  409. {
  410. .name = "i2s",
  411. .id = 0,
  412. .playback = {
  413. .channels_min = 1,
  414. .channels_max = 2,
  415. .rates = SNDRV_PCM_RATE_CONTINUOUS,
  416. .rate_min = 5512,
  417. .rate_max = 192000,
  418. .formats = KIRKWOOD_I2S_FORMATS,
  419. },
  420. .capture = {
  421. .channels_min = 1,
  422. .channels_max = 2,
  423. .rates = SNDRV_PCM_RATE_CONTINUOUS,
  424. .rate_min = 5512,
  425. .rate_max = 192000,
  426. .formats = KIRKWOOD_I2S_FORMATS,
  427. },
  428. .ops = &kirkwood_i2s_dai_ops,
  429. },
  430. {
  431. .name = "spdif",
  432. .id = 1,
  433. .playback = {
  434. .channels_min = 1,
  435. .channels_max = 2,
  436. .rates = SNDRV_PCM_RATE_CONTINUOUS,
  437. .rate_min = 5512,
  438. .rate_max = 192000,
  439. .formats = KIRKWOOD_SPDIF_FORMATS,
  440. },
  441. .capture = {
  442. .channels_min = 1,
  443. .channels_max = 2,
  444. .rates = SNDRV_PCM_RATE_CONTINUOUS,
  445. .rate_min = 5512,
  446. .rate_max = 192000,
  447. .formats = KIRKWOOD_SPDIF_FORMATS,
  448. },
  449. .ops = &kirkwood_i2s_dai_ops,
  450. },
  451. };
  452. static int kirkwood_i2s_dev_probe(struct platform_device *pdev)
  453. {
  454. struct kirkwood_asoc_platform_data *data = pdev->dev.platform_data;
  455. struct snd_soc_dai_driver *soc_dai = kirkwood_i2s_dai;
  456. struct kirkwood_dma_data *priv;
  457. struct device_node *np = pdev->dev.of_node;
  458. int err;
  459. priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
  460. if (!priv)
  461. return -ENOMEM;
  462. dev_set_drvdata(&pdev->dev, priv);
  463. priv->io = devm_platform_ioremap_resource(pdev, 0);
  464. if (IS_ERR(priv->io))
  465. return PTR_ERR(priv->io);
  466. priv->irq = platform_get_irq(pdev, 0);
  467. if (priv->irq < 0)
  468. return priv->irq;
  469. if (np) {
  470. priv->burst = 128; /* might be 32 or 128 */
  471. } else if (data) {
  472. priv->burst = data->burst;
  473. } else {
  474. dev_err(&pdev->dev, "no DT nor platform data ?!\n");
  475. return -EINVAL;
  476. }
  477. priv->clk = devm_clk_get(&pdev->dev, np ? "internal" : NULL);
  478. if (IS_ERR(priv->clk)) {
  479. dev_err(&pdev->dev, "no clock\n");
  480. return PTR_ERR(priv->clk);
  481. }
  482. priv->extclk = devm_clk_get(&pdev->dev, "extclk");
  483. if (IS_ERR(priv->extclk)) {
  484. if (PTR_ERR(priv->extclk) == -EPROBE_DEFER)
  485. return -EPROBE_DEFER;
  486. } else {
  487. if (clk_is_match(priv->extclk, priv->clk)) {
  488. devm_clk_put(&pdev->dev, priv->extclk);
  489. priv->extclk = ERR_PTR(-EINVAL);
  490. } else {
  491. dev_info(&pdev->dev, "found external clock\n");
  492. clk_prepare_enable(priv->extclk);
  493. soc_dai = kirkwood_i2s_dai_extclk;
  494. }
  495. }
  496. err = clk_prepare_enable(priv->clk);
  497. if (err < 0)
  498. return err;
  499. /* Some sensible defaults - this reflects the powerup values */
  500. priv->ctl_play = KIRKWOOD_PLAYCTL_SIZE_24;
  501. priv->ctl_rec = KIRKWOOD_RECCTL_SIZE_24;
  502. /* Select the burst size */
  503. if (priv->burst == 32) {
  504. priv->ctl_play |= KIRKWOOD_PLAYCTL_BURST_32;
  505. priv->ctl_rec |= KIRKWOOD_RECCTL_BURST_32;
  506. } else {
  507. priv->ctl_play |= KIRKWOOD_PLAYCTL_BURST_128;
  508. priv->ctl_rec |= KIRKWOOD_RECCTL_BURST_128;
  509. }
  510. err = snd_soc_register_component(&pdev->dev, &kirkwood_soc_component,
  511. soc_dai, 2);
  512. if (err) {
  513. dev_err(&pdev->dev, "snd_soc_register_component failed\n");
  514. goto err_component;
  515. }
  516. kirkwood_i2s_init(priv);
  517. return 0;
  518. err_component:
  519. if (!IS_ERR(priv->extclk))
  520. clk_disable_unprepare(priv->extclk);
  521. clk_disable_unprepare(priv->clk);
  522. return err;
  523. }
  524. static int kirkwood_i2s_dev_remove(struct platform_device *pdev)
  525. {
  526. struct kirkwood_dma_data *priv = dev_get_drvdata(&pdev->dev);
  527. snd_soc_unregister_component(&pdev->dev);
  528. if (!IS_ERR(priv->extclk))
  529. clk_disable_unprepare(priv->extclk);
  530. clk_disable_unprepare(priv->clk);
  531. return 0;
  532. }
  533. #ifdef CONFIG_OF
  534. static const struct of_device_id mvebu_audio_of_match[] = {
  535. { .compatible = "marvell,kirkwood-audio" },
  536. { .compatible = "marvell,dove-audio" },
  537. { .compatible = "marvell,armada370-audio" },
  538. { }
  539. };
  540. MODULE_DEVICE_TABLE(of, mvebu_audio_of_match);
  541. #endif
  542. static struct platform_driver kirkwood_i2s_driver = {
  543. .probe = kirkwood_i2s_dev_probe,
  544. .remove = kirkwood_i2s_dev_remove,
  545. .driver = {
  546. .name = DRV_NAME,
  547. .of_match_table = of_match_ptr(mvebu_audio_of_match),
  548. },
  549. };
  550. module_platform_driver(kirkwood_i2s_driver);
  551. /* Module information */
  552. MODULE_AUTHOR("Arnaud Patard, <arnaud.patard@rtp-net.org>");
  553. MODULE_DESCRIPTION("Kirkwood I2S SoC Interface");
  554. MODULE_LICENSE("GPL");
  555. MODULE_ALIAS("platform:mvebu-audio");