davinci-vcif.c 7.3 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274
  1. /*
  2. * ALSA SoC Voice Codec Interface for TI DAVINCI processor
  3. *
  4. * Copyright (C) 2010 Texas Instruments.
  5. *
  6. * Author: Miguel Aguilar <miguel.aguilar@ridgerun.com>
  7. *
  8. * This program is free software; you can redistribute it and/or modify
  9. * it under the terms of the GNU General Public License as published by
  10. * the Free Software Foundation; either version 2 of the License, or
  11. * (at your option) any later version.
  12. *
  13. * This program is distributed in the hope that it will be useful,
  14. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  16. * GNU General Public License for more details.
  17. *
  18. * You should have received a copy of the GNU General Public License
  19. * along with this program; if not, write to the Free Software
  20. * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  21. */
  22. #include <linux/init.h>
  23. #include <linux/module.h>
  24. #include <linux/device.h>
  25. #include <linux/delay.h>
  26. #include <linux/slab.h>
  27. #include <linux/io.h>
  28. #include <linux/mfd/davinci_voicecodec.h>
  29. #include <sound/core.h>
  30. #include <sound/pcm.h>
  31. #include <sound/pcm_params.h>
  32. #include <sound/initval.h>
  33. #include <sound/soc.h>
  34. #include "davinci-pcm.h"
  35. #include "davinci-i2s.h"
  36. #include "davinci-vcif.h"
  37. #define MOD_REG_BIT(val, mask, set) do { \
  38. if (set) { \
  39. val |= mask; \
  40. } else { \
  41. val &= ~mask; \
  42. } \
  43. } while (0)
  44. struct davinci_vcif_dev {
  45. struct davinci_vc *davinci_vc;
  46. struct davinci_pcm_dma_params dma_params[2];
  47. };
  48. static void davinci_vcif_start(struct snd_pcm_substream *substream)
  49. {
  50. struct snd_soc_pcm_runtime *rtd = substream->private_data;
  51. struct davinci_vcif_dev *davinci_vcif_dev =
  52. rtd->dai->cpu_dai->private_data;
  53. struct davinci_vc *davinci_vc = davinci_vcif_dev->davinci_vc;
  54. u32 w;
  55. /* Start the sample generator and enable transmitter/receiver */
  56. w = readl(davinci_vc->base + DAVINCI_VC_CTRL);
  57. if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
  58. MOD_REG_BIT(w, DAVINCI_VC_CTRL_RSTDAC, 1);
  59. else
  60. MOD_REG_BIT(w, DAVINCI_VC_CTRL_RSTADC, 1);
  61. writel(w, davinci_vc->base + DAVINCI_VC_CTRL);
  62. }
  63. static void davinci_vcif_stop(struct snd_pcm_substream *substream)
  64. {
  65. struct snd_soc_pcm_runtime *rtd = substream->private_data;
  66. struct davinci_vcif_dev *davinci_vcif_dev =
  67. rtd->dai->cpu_dai->private_data;
  68. struct davinci_vc *davinci_vc = davinci_vcif_dev->davinci_vc;
  69. u32 w;
  70. /* Reset transmitter/receiver and sample rate/frame sync generators */
  71. w = readl(davinci_vc->base + DAVINCI_VC_CTRL);
  72. if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
  73. MOD_REG_BIT(w, DAVINCI_VC_CTRL_RSTDAC, 0);
  74. else
  75. MOD_REG_BIT(w, DAVINCI_VC_CTRL_RSTADC, 0);
  76. writel(w, davinci_vc->base + DAVINCI_VC_CTRL);
  77. }
  78. static int davinci_vcif_hw_params(struct snd_pcm_substream *substream,
  79. struct snd_pcm_hw_params *params,
  80. struct snd_soc_dai *dai)
  81. {
  82. struct davinci_vcif_dev *davinci_vcif_dev = dai->private_data;
  83. struct davinci_vc *davinci_vc = davinci_vcif_dev->davinci_vc;
  84. struct davinci_pcm_dma_params *dma_params =
  85. &davinci_vcif_dev->dma_params[substream->stream];
  86. u32 w;
  87. /* Restart the codec before setup */
  88. davinci_vcif_stop(substream);
  89. davinci_vcif_start(substream);
  90. /* General line settings */
  91. writel(DAVINCI_VC_CTRL_MASK, davinci_vc->base + DAVINCI_VC_CTRL);
  92. writel(DAVINCI_VC_INT_MASK, davinci_vc->base + DAVINCI_VC_INTCLR);
  93. writel(DAVINCI_VC_INT_MASK, davinci_vc->base + DAVINCI_VC_INTEN);
  94. w = readl(davinci_vc->base + DAVINCI_VC_CTRL);
  95. /* Determine xfer data type */
  96. switch (params_format(params)) {
  97. case SNDRV_PCM_FORMAT_U8:
  98. dma_params->data_type = 0;
  99. MOD_REG_BIT(w, DAVINCI_VC_CTRL_RD_BITS_8 |
  100. DAVINCI_VC_CTRL_RD_UNSIGNED |
  101. DAVINCI_VC_CTRL_WD_BITS_8 |
  102. DAVINCI_VC_CTRL_WD_UNSIGNED, 1);
  103. break;
  104. case SNDRV_PCM_FORMAT_S8:
  105. dma_params->data_type = 1;
  106. MOD_REG_BIT(w, DAVINCI_VC_CTRL_RD_BITS_8 |
  107. DAVINCI_VC_CTRL_WD_BITS_8, 1);
  108. MOD_REG_BIT(w, DAVINCI_VC_CTRL_RD_UNSIGNED |
  109. DAVINCI_VC_CTRL_WD_UNSIGNED, 0);
  110. break;
  111. case SNDRV_PCM_FORMAT_S16_LE:
  112. dma_params->data_type = 2;
  113. MOD_REG_BIT(w, DAVINCI_VC_CTRL_RD_BITS_8 |
  114. DAVINCI_VC_CTRL_RD_UNSIGNED |
  115. DAVINCI_VC_CTRL_WD_BITS_8 |
  116. DAVINCI_VC_CTRL_WD_UNSIGNED, 0);
  117. break;
  118. default:
  119. printk(KERN_WARNING "davinci-vcif: unsupported PCM format");
  120. return -EINVAL;
  121. }
  122. dma_params->acnt = dma_params->data_type;
  123. writel(w, davinci_vc->base + DAVINCI_VC_CTRL);
  124. return 0;
  125. }
  126. static int davinci_vcif_trigger(struct snd_pcm_substream *substream, int cmd,
  127. struct snd_soc_dai *dai)
  128. {
  129. int ret = 0;
  130. switch (cmd) {
  131. case SNDRV_PCM_TRIGGER_START:
  132. case SNDRV_PCM_TRIGGER_RESUME:
  133. case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
  134. davinci_vcif_start(substream);
  135. case SNDRV_PCM_TRIGGER_STOP:
  136. case SNDRV_PCM_TRIGGER_SUSPEND:
  137. case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
  138. davinci_vcif_stop(substream);
  139. break;
  140. default:
  141. ret = -EINVAL;
  142. }
  143. return ret;
  144. }
  145. #define DAVINCI_VCIF_RATES SNDRV_PCM_RATE_8000_48000
  146. static struct snd_soc_dai_ops davinci_vcif_dai_ops = {
  147. .trigger = davinci_vcif_trigger,
  148. .hw_params = davinci_vcif_hw_params,
  149. };
  150. struct snd_soc_dai davinci_vcif_dai = {
  151. .name = "davinci-vcif",
  152. .playback = {
  153. .channels_min = 1,
  154. .channels_max = 2,
  155. .rates = DAVINCI_VCIF_RATES,
  156. .formats = SNDRV_PCM_FMTBIT_S16_LE,},
  157. .capture = {
  158. .channels_min = 1,
  159. .channels_max = 2,
  160. .rates = DAVINCI_VCIF_RATES,
  161. .formats = SNDRV_PCM_FMTBIT_S16_LE,},
  162. .ops = &davinci_vcif_dai_ops,
  163. };
  164. EXPORT_SYMBOL_GPL(davinci_vcif_dai);
  165. static int davinci_vcif_probe(struct platform_device *pdev)
  166. {
  167. struct davinci_vc *davinci_vc = platform_get_drvdata(pdev);
  168. struct davinci_vcif_dev *davinci_vcif_dev;
  169. int ret;
  170. davinci_vcif_dev = kzalloc(sizeof(struct davinci_vcif_dev), GFP_KERNEL);
  171. if (!davinci_vcif_dev) {
  172. dev_dbg(&pdev->dev,
  173. "could not allocate memory for private data\n");
  174. return -ENOMEM;
  175. }
  176. /* DMA tx params */
  177. davinci_vcif_dev->davinci_vc = davinci_vc;
  178. davinci_vcif_dev->dma_params[SNDRV_PCM_STREAM_PLAYBACK].channel =
  179. davinci_vc->davinci_vcif.dma_tx_channel;
  180. davinci_vcif_dev->dma_params[SNDRV_PCM_STREAM_PLAYBACK].dma_addr =
  181. davinci_vc->davinci_vcif.dma_tx_addr;
  182. /* DMA rx params */
  183. davinci_vcif_dev->dma_params[SNDRV_PCM_STREAM_CAPTURE].channel =
  184. davinci_vc->davinci_vcif.dma_rx_channel;
  185. davinci_vcif_dev->dma_params[SNDRV_PCM_STREAM_CAPTURE].dma_addr =
  186. davinci_vc->davinci_vcif.dma_rx_addr;
  187. davinci_vcif_dai.dev = &pdev->dev;
  188. davinci_vcif_dai.capture.dma_data = davinci_vcif_dev->dma_params;
  189. davinci_vcif_dai.playback.dma_data = davinci_vcif_dev->dma_params;
  190. davinci_vcif_dai.private_data = davinci_vcif_dev;
  191. ret = snd_soc_register_dai(&davinci_vcif_dai);
  192. if (ret != 0) {
  193. dev_err(&pdev->dev, "could not register dai\n");
  194. goto fail;
  195. }
  196. return 0;
  197. fail:
  198. kfree(davinci_vcif_dev);
  199. return ret;
  200. }
  201. static int davinci_vcif_remove(struct platform_device *pdev)
  202. {
  203. snd_soc_unregister_dai(&davinci_vcif_dai);
  204. return 0;
  205. }
  206. static struct platform_driver davinci_vcif_driver = {
  207. .probe = davinci_vcif_probe,
  208. .remove = davinci_vcif_remove,
  209. .driver = {
  210. .name = "davinci_vcif",
  211. .owner = THIS_MODULE,
  212. },
  213. };
  214. static int __init davinci_vcif_init(void)
  215. {
  216. return platform_driver_probe(&davinci_vcif_driver, davinci_vcif_probe);
  217. }
  218. module_init(davinci_vcif_init);
  219. static void __exit davinci_vcif_exit(void)
  220. {
  221. platform_driver_unregister(&davinci_vcif_driver);
  222. }
  223. module_exit(davinci_vcif_exit);
  224. MODULE_AUTHOR("Miguel Aguilar");
  225. MODULE_DESCRIPTION("Texas Instruments DaVinci ASoC Voice Codec Interface");
  226. MODULE_LICENSE("GPL");