ad193x.c 15 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586
  1. /*
  2. * AD193X Audio Codec driver supporting AD1936/7/8/9
  3. *
  4. * Copyright 2010 Analog Devices Inc.
  5. *
  6. * Licensed under the GPL-2 or later.
  7. */
  8. #include <linux/init.h>
  9. #include <linux/module.h>
  10. #include <linux/kernel.h>
  11. #include <linux/device.h>
  12. #include <linux/i2c.h>
  13. #include <linux/spi/spi.h>
  14. #include <linux/slab.h>
  15. #include <sound/core.h>
  16. #include <sound/pcm.h>
  17. #include <sound/pcm_params.h>
  18. #include <sound/initval.h>
  19. #include <sound/soc.h>
  20. #include <sound/tlv.h>
  21. #include <sound/soc-dapm.h>
  22. #include "ad193x.h"
  23. /* codec private data */
  24. struct ad193x_priv {
  25. unsigned int sysclk;
  26. struct snd_soc_codec codec;
  27. u8 reg_cache[AD193X_NUM_REGS];
  28. };
  29. /* ad193x register cache & default register settings */
  30. static const u8 ad193x_reg[AD193X_NUM_REGS] = {
  31. 0, 0, 0, 0, 0, 0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0, 0, 0,
  32. };
  33. static struct snd_soc_codec *ad193x_codec;
  34. struct snd_soc_codec_device soc_codec_dev_ad193x;
  35. /*
  36. * AD193X volume/mute/de-emphasis etc. controls
  37. */
  38. static const char *ad193x_deemp[] = {"None", "48kHz", "44.1kHz", "32kHz"};
  39. static const struct soc_enum ad193x_deemp_enum =
  40. SOC_ENUM_SINGLE(AD193X_DAC_CTRL2, 1, 4, ad193x_deemp);
  41. static const struct snd_kcontrol_new ad193x_snd_controls[] = {
  42. /* DAC volume control */
  43. SOC_DOUBLE_R("DAC1 Volume", AD193X_DAC_L1_VOL,
  44. AD193X_DAC_R1_VOL, 0, 0xFF, 1),
  45. SOC_DOUBLE_R("DAC2 Volume", AD193X_DAC_L2_VOL,
  46. AD193X_DAC_R2_VOL, 0, 0xFF, 1),
  47. SOC_DOUBLE_R("DAC3 Volume", AD193X_DAC_L3_VOL,
  48. AD193X_DAC_R3_VOL, 0, 0xFF, 1),
  49. SOC_DOUBLE_R("DAC4 Volume", AD193X_DAC_L4_VOL,
  50. AD193X_DAC_R4_VOL, 0, 0xFF, 1),
  51. /* ADC switch control */
  52. SOC_DOUBLE("ADC1 Switch", AD193X_ADC_CTRL0, AD193X_ADCL1_MUTE,
  53. AD193X_ADCR1_MUTE, 1, 1),
  54. SOC_DOUBLE("ADC2 Switch", AD193X_ADC_CTRL0, AD193X_ADCL2_MUTE,
  55. AD193X_ADCR2_MUTE, 1, 1),
  56. /* DAC switch control */
  57. SOC_DOUBLE("DAC1 Switch", AD193X_DAC_CHNL_MUTE, AD193X_DACL1_MUTE,
  58. AD193X_DACR1_MUTE, 1, 1),
  59. SOC_DOUBLE("DAC2 Switch", AD193X_DAC_CHNL_MUTE, AD193X_DACL2_MUTE,
  60. AD193X_DACR2_MUTE, 1, 1),
  61. SOC_DOUBLE("DAC3 Switch", AD193X_DAC_CHNL_MUTE, AD193X_DACL3_MUTE,
  62. AD193X_DACR3_MUTE, 1, 1),
  63. SOC_DOUBLE("DAC4 Switch", AD193X_DAC_CHNL_MUTE, AD193X_DACL4_MUTE,
  64. AD193X_DACR4_MUTE, 1, 1),
  65. /* ADC high-pass filter */
  66. SOC_SINGLE("ADC High Pass Filter Switch", AD193X_ADC_CTRL0,
  67. AD193X_ADC_HIGHPASS_FILTER, 1, 0),
  68. /* DAC de-emphasis */
  69. SOC_ENUM("Playback Deemphasis", ad193x_deemp_enum),
  70. };
  71. static const struct snd_soc_dapm_widget ad193x_dapm_widgets[] = {
  72. SND_SOC_DAPM_DAC("DAC", "Playback", AD193X_DAC_CTRL0, 0, 1),
  73. SND_SOC_DAPM_ADC("ADC", "Capture", SND_SOC_NOPM, 0, 0),
  74. SND_SOC_DAPM_SUPPLY("PLL_PWR", AD193X_PLL_CLK_CTRL0, 0, 1, NULL, 0),
  75. SND_SOC_DAPM_SUPPLY("ADC_PWR", AD193X_ADC_CTRL0, 0, 1, NULL, 0),
  76. SND_SOC_DAPM_OUTPUT("DAC1OUT"),
  77. SND_SOC_DAPM_OUTPUT("DAC2OUT"),
  78. SND_SOC_DAPM_OUTPUT("DAC3OUT"),
  79. SND_SOC_DAPM_OUTPUT("DAC4OUT"),
  80. SND_SOC_DAPM_INPUT("ADC1IN"),
  81. SND_SOC_DAPM_INPUT("ADC2IN"),
  82. };
  83. static const struct snd_soc_dapm_route audio_paths[] = {
  84. { "DAC", NULL, "PLL_PWR" },
  85. { "ADC", NULL, "PLL_PWR" },
  86. { "DAC", NULL, "ADC_PWR" },
  87. { "ADC", NULL, "ADC_PWR" },
  88. { "DAC1OUT", "DAC1 Switch", "DAC" },
  89. { "DAC2OUT", "DAC2 Switch", "DAC" },
  90. { "DAC3OUT", "DAC3 Switch", "DAC" },
  91. { "DAC4OUT", "DAC4 Switch", "DAC" },
  92. { "ADC", "ADC1 Switch", "ADC1IN" },
  93. { "ADC", "ADC2 Switch", "ADC2IN" },
  94. };
  95. /*
  96. * DAI ops entries
  97. */
  98. static int ad193x_mute(struct snd_soc_dai *dai, int mute)
  99. {
  100. struct snd_soc_codec *codec = dai->codec;
  101. int reg;
  102. reg = snd_soc_read(codec, AD193X_DAC_CTRL2);
  103. reg = (mute > 0) ? reg | AD193X_DAC_MASTER_MUTE : reg &
  104. (~AD193X_DAC_MASTER_MUTE);
  105. snd_soc_write(codec, AD193X_DAC_CTRL2, reg);
  106. return 0;
  107. }
  108. static int ad193x_set_tdm_slot(struct snd_soc_dai *dai, unsigned int tx_mask,
  109. unsigned int rx_mask, int slots, int width)
  110. {
  111. struct snd_soc_codec *codec = dai->codec;
  112. int dac_reg = snd_soc_read(codec, AD193X_DAC_CTRL1);
  113. int adc_reg = snd_soc_read(codec, AD193X_ADC_CTRL2);
  114. dac_reg &= ~AD193X_DAC_CHAN_MASK;
  115. adc_reg &= ~AD193X_ADC_CHAN_MASK;
  116. switch (slots) {
  117. case 2:
  118. dac_reg |= AD193X_DAC_2_CHANNELS << AD193X_DAC_CHAN_SHFT;
  119. adc_reg |= AD193X_ADC_2_CHANNELS << AD193X_ADC_CHAN_SHFT;
  120. break;
  121. case 4:
  122. dac_reg |= AD193X_DAC_4_CHANNELS << AD193X_DAC_CHAN_SHFT;
  123. adc_reg |= AD193X_ADC_4_CHANNELS << AD193X_ADC_CHAN_SHFT;
  124. break;
  125. case 8:
  126. dac_reg |= AD193X_DAC_8_CHANNELS << AD193X_DAC_CHAN_SHFT;
  127. adc_reg |= AD193X_ADC_8_CHANNELS << AD193X_ADC_CHAN_SHFT;
  128. break;
  129. case 16:
  130. dac_reg |= AD193X_DAC_16_CHANNELS << AD193X_DAC_CHAN_SHFT;
  131. adc_reg |= AD193X_ADC_16_CHANNELS << AD193X_ADC_CHAN_SHFT;
  132. break;
  133. default:
  134. return -EINVAL;
  135. }
  136. snd_soc_write(codec, AD193X_DAC_CTRL1, dac_reg);
  137. snd_soc_write(codec, AD193X_ADC_CTRL2, adc_reg);
  138. return 0;
  139. }
  140. static int ad193x_set_dai_fmt(struct snd_soc_dai *codec_dai,
  141. unsigned int fmt)
  142. {
  143. struct snd_soc_codec *codec = codec_dai->codec;
  144. int adc_reg1, adc_reg2, dac_reg;
  145. adc_reg1 = snd_soc_read(codec, AD193X_ADC_CTRL1);
  146. adc_reg2 = snd_soc_read(codec, AD193X_ADC_CTRL2);
  147. dac_reg = snd_soc_read(codec, AD193X_DAC_CTRL1);
  148. /* At present, the driver only support AUX ADC mode(SND_SOC_DAIFMT_I2S
  149. * with TDM) and ADC&DAC TDM mode(SND_SOC_DAIFMT_DSP_A)
  150. */
  151. switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
  152. case SND_SOC_DAIFMT_I2S:
  153. adc_reg1 &= ~AD193X_ADC_SERFMT_MASK;
  154. adc_reg1 |= AD193X_ADC_SERFMT_TDM;
  155. break;
  156. case SND_SOC_DAIFMT_DSP_A:
  157. adc_reg1 &= ~AD193X_ADC_SERFMT_MASK;
  158. adc_reg1 |= AD193X_ADC_SERFMT_AUX;
  159. break;
  160. default:
  161. return -EINVAL;
  162. }
  163. switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
  164. case SND_SOC_DAIFMT_NB_NF: /* normal bit clock + frame */
  165. adc_reg2 &= ~AD193X_ADC_LEFT_HIGH;
  166. adc_reg2 &= ~AD193X_ADC_BCLK_INV;
  167. dac_reg &= ~AD193X_DAC_LEFT_HIGH;
  168. dac_reg &= ~AD193X_DAC_BCLK_INV;
  169. break;
  170. case SND_SOC_DAIFMT_NB_IF: /* normal bclk + invert frm */
  171. adc_reg2 |= AD193X_ADC_LEFT_HIGH;
  172. adc_reg2 &= ~AD193X_ADC_BCLK_INV;
  173. dac_reg |= AD193X_DAC_LEFT_HIGH;
  174. dac_reg &= ~AD193X_DAC_BCLK_INV;
  175. break;
  176. case SND_SOC_DAIFMT_IB_NF: /* invert bclk + normal frm */
  177. adc_reg2 &= ~AD193X_ADC_LEFT_HIGH;
  178. adc_reg2 |= AD193X_ADC_BCLK_INV;
  179. dac_reg &= ~AD193X_DAC_LEFT_HIGH;
  180. dac_reg |= AD193X_DAC_BCLK_INV;
  181. break;
  182. case SND_SOC_DAIFMT_IB_IF: /* invert bclk + frm */
  183. adc_reg2 |= AD193X_ADC_LEFT_HIGH;
  184. adc_reg2 |= AD193X_ADC_BCLK_INV;
  185. dac_reg |= AD193X_DAC_LEFT_HIGH;
  186. dac_reg |= AD193X_DAC_BCLK_INV;
  187. break;
  188. default:
  189. return -EINVAL;
  190. }
  191. switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
  192. case SND_SOC_DAIFMT_CBM_CFM: /* codec clk & frm master */
  193. adc_reg2 |= AD193X_ADC_LCR_MASTER;
  194. adc_reg2 |= AD193X_ADC_BCLK_MASTER;
  195. dac_reg |= AD193X_DAC_LCR_MASTER;
  196. dac_reg |= AD193X_DAC_BCLK_MASTER;
  197. break;
  198. case SND_SOC_DAIFMT_CBS_CFM: /* codec clk slave & frm master */
  199. adc_reg2 |= AD193X_ADC_LCR_MASTER;
  200. adc_reg2 &= ~AD193X_ADC_BCLK_MASTER;
  201. dac_reg |= AD193X_DAC_LCR_MASTER;
  202. dac_reg &= ~AD193X_DAC_BCLK_MASTER;
  203. break;
  204. case SND_SOC_DAIFMT_CBM_CFS: /* codec clk master & frame slave */
  205. adc_reg2 &= ~AD193X_ADC_LCR_MASTER;
  206. adc_reg2 |= AD193X_ADC_BCLK_MASTER;
  207. dac_reg &= ~AD193X_DAC_LCR_MASTER;
  208. dac_reg |= AD193X_DAC_BCLK_MASTER;
  209. break;
  210. case SND_SOC_DAIFMT_CBS_CFS: /* codec clk & frm slave */
  211. adc_reg2 &= ~AD193X_ADC_LCR_MASTER;
  212. adc_reg2 &= ~AD193X_ADC_BCLK_MASTER;
  213. dac_reg &= ~AD193X_DAC_LCR_MASTER;
  214. dac_reg &= ~AD193X_DAC_BCLK_MASTER;
  215. break;
  216. default:
  217. return -EINVAL;
  218. }
  219. snd_soc_write(codec, AD193X_ADC_CTRL1, adc_reg1);
  220. snd_soc_write(codec, AD193X_ADC_CTRL2, adc_reg2);
  221. snd_soc_write(codec, AD193X_DAC_CTRL1, dac_reg);
  222. return 0;
  223. }
  224. static int ad193x_set_dai_sysclk(struct snd_soc_dai *codec_dai,
  225. int clk_id, unsigned int freq, int dir)
  226. {
  227. struct snd_soc_codec *codec = codec_dai->codec;
  228. struct ad193x_priv *ad193x = snd_soc_codec_get_drvdata(codec);
  229. switch (freq) {
  230. case 12288000:
  231. case 18432000:
  232. case 24576000:
  233. case 36864000:
  234. ad193x->sysclk = freq;
  235. return 0;
  236. }
  237. return -EINVAL;
  238. }
  239. static int ad193x_hw_params(struct snd_pcm_substream *substream,
  240. struct snd_pcm_hw_params *params,
  241. struct snd_soc_dai *dai)
  242. {
  243. int word_len = 0, reg = 0, master_rate = 0;
  244. struct snd_soc_pcm_runtime *rtd = substream->private_data;
  245. struct snd_soc_device *socdev = rtd->socdev;
  246. struct snd_soc_codec *codec = socdev->card->codec;
  247. struct ad193x_priv *ad193x = snd_soc_codec_get_drvdata(codec);
  248. /* bit size */
  249. switch (params_format(params)) {
  250. case SNDRV_PCM_FORMAT_S16_LE:
  251. word_len = 3;
  252. break;
  253. case SNDRV_PCM_FORMAT_S20_3LE:
  254. word_len = 1;
  255. break;
  256. case SNDRV_PCM_FORMAT_S24_LE:
  257. case SNDRV_PCM_FORMAT_S32_LE:
  258. word_len = 0;
  259. break;
  260. }
  261. switch (ad193x->sysclk) {
  262. case 12288000:
  263. master_rate = AD193X_PLL_INPUT_256;
  264. break;
  265. case 18432000:
  266. master_rate = AD193X_PLL_INPUT_384;
  267. break;
  268. case 24576000:
  269. master_rate = AD193X_PLL_INPUT_512;
  270. break;
  271. case 36864000:
  272. master_rate = AD193X_PLL_INPUT_768;
  273. break;
  274. }
  275. reg = snd_soc_read(codec, AD193X_PLL_CLK_CTRL0);
  276. reg = (reg & AD193X_PLL_INPUT_MASK) | master_rate;
  277. snd_soc_write(codec, AD193X_PLL_CLK_CTRL0, reg);
  278. reg = snd_soc_read(codec, AD193X_DAC_CTRL2);
  279. reg = (reg & (~AD193X_DAC_WORD_LEN_MASK)) | word_len;
  280. snd_soc_write(codec, AD193X_DAC_CTRL2, reg);
  281. reg = snd_soc_read(codec, AD193X_ADC_CTRL1);
  282. reg = (reg & (~AD193X_ADC_WORD_LEN_MASK)) | word_len;
  283. snd_soc_write(codec, AD193X_ADC_CTRL1, reg);
  284. return 0;
  285. }
  286. static int ad193x_bus_probe(struct device *dev, void *ctrl_data, int bus_type)
  287. {
  288. struct snd_soc_codec *codec;
  289. struct ad193x_priv *ad193x;
  290. int ret;
  291. if (ad193x_codec) {
  292. dev_err(dev, "Another ad193x is registered\n");
  293. return -EINVAL;
  294. }
  295. ad193x = kzalloc(sizeof(struct ad193x_priv), GFP_KERNEL);
  296. if (ad193x == NULL)
  297. return -ENOMEM;
  298. dev_set_drvdata(dev, ad193x);
  299. codec = &ad193x->codec;
  300. mutex_init(&codec->mutex);
  301. codec->control_data = ctrl_data;
  302. codec->dev = dev;
  303. snd_soc_codec_set_drvdata(codec, ad193x);
  304. codec->reg_cache = ad193x->reg_cache;
  305. codec->reg_cache_size = AD193X_NUM_REGS;
  306. codec->name = "AD193X";
  307. codec->owner = THIS_MODULE;
  308. codec->dai = &ad193x_dai;
  309. codec->num_dai = 1;
  310. INIT_LIST_HEAD(&codec->dapm_widgets);
  311. INIT_LIST_HEAD(&codec->dapm_paths);
  312. ad193x_dai.dev = codec->dev;
  313. ad193x_codec = codec;
  314. memcpy(codec->reg_cache, ad193x_reg, AD193X_NUM_REGS);
  315. if (bus_type == SND_SOC_I2C)
  316. ret = snd_soc_codec_set_cache_io(codec, 8, 8, bus_type);
  317. else
  318. ret = snd_soc_codec_set_cache_io(codec, 16, 8, bus_type);
  319. if (ret < 0) {
  320. dev_err(codec->dev, "failed to set cache I/O: %d\n",
  321. ret);
  322. kfree(ad193x);
  323. return ret;
  324. }
  325. /* default setting for ad193x */
  326. /* unmute dac channels */
  327. snd_soc_write(codec, AD193X_DAC_CHNL_MUTE, 0x0);
  328. /* de-emphasis: 48kHz, powedown dac */
  329. snd_soc_write(codec, AD193X_DAC_CTRL2, 0x1A);
  330. /* powerdown dac, dac in tdm mode */
  331. snd_soc_write(codec, AD193X_DAC_CTRL0, 0x41);
  332. /* high-pass filter enable */
  333. snd_soc_write(codec, AD193X_ADC_CTRL0, 0x3);
  334. /* sata delay=1, adc aux mode */
  335. snd_soc_write(codec, AD193X_ADC_CTRL1, 0x43);
  336. /* pll input: mclki/xi */
  337. snd_soc_write(codec, AD193X_PLL_CLK_CTRL0, 0x99); /* mclk=24.576Mhz: 0x9D; mclk=12.288Mhz: 0x99 */
  338. snd_soc_write(codec, AD193X_PLL_CLK_CTRL1, 0x04);
  339. ad193x->sysclk = 12288000;
  340. ret = snd_soc_register_codec(codec);
  341. if (ret != 0) {
  342. dev_err(codec->dev, "Failed to register codec: %d\n", ret);
  343. kfree(ad193x);
  344. return ret;
  345. }
  346. ret = snd_soc_register_dai(&ad193x_dai);
  347. if (ret != 0) {
  348. dev_err(codec->dev, "Failed to register DAI: %d\n", ret);
  349. snd_soc_unregister_codec(codec);
  350. kfree(ad193x);
  351. return ret;
  352. }
  353. return 0;
  354. }
  355. static int ad193x_bus_remove(struct device *dev)
  356. {
  357. struct ad193x_priv *ad193x = dev_get_drvdata(dev);
  358. snd_soc_unregister_dai(&ad193x_dai);
  359. snd_soc_unregister_codec(&ad193x->codec);
  360. kfree(ad193x);
  361. ad193x_codec = NULL;
  362. return 0;
  363. }
  364. static struct snd_soc_dai_ops ad193x_dai_ops = {
  365. .hw_params = ad193x_hw_params,
  366. .digital_mute = ad193x_mute,
  367. .set_tdm_slot = ad193x_set_tdm_slot,
  368. .set_sysclk = ad193x_set_dai_sysclk,
  369. .set_fmt = ad193x_set_dai_fmt,
  370. };
  371. /* codec DAI instance */
  372. struct snd_soc_dai ad193x_dai = {
  373. .name = "AD193X",
  374. .playback = {
  375. .stream_name = "Playback",
  376. .channels_min = 2,
  377. .channels_max = 8,
  378. .rates = SNDRV_PCM_RATE_48000,
  379. .formats = SNDRV_PCM_FMTBIT_S32_LE | SNDRV_PCM_FMTBIT_S16_LE |
  380. SNDRV_PCM_FMTBIT_S20_3LE | SNDRV_PCM_FMTBIT_S24_LE,
  381. },
  382. .capture = {
  383. .stream_name = "Capture",
  384. .channels_min = 2,
  385. .channels_max = 4,
  386. .rates = SNDRV_PCM_RATE_48000,
  387. .formats = SNDRV_PCM_FMTBIT_S32_LE | SNDRV_PCM_FMTBIT_S16_LE |
  388. SNDRV_PCM_FMTBIT_S20_3LE | SNDRV_PCM_FMTBIT_S24_LE,
  389. },
  390. .ops = &ad193x_dai_ops,
  391. };
  392. EXPORT_SYMBOL_GPL(ad193x_dai);
  393. static int ad193x_probe(struct platform_device *pdev)
  394. {
  395. struct snd_soc_device *socdev = platform_get_drvdata(pdev);
  396. struct snd_soc_codec *codec;
  397. int ret = 0;
  398. if (ad193x_codec == NULL) {
  399. dev_err(&pdev->dev, "Codec device not registered\n");
  400. return -ENODEV;
  401. }
  402. socdev->card->codec = ad193x_codec;
  403. codec = ad193x_codec;
  404. /* register pcms */
  405. ret = snd_soc_new_pcms(socdev, SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1);
  406. if (ret < 0) {
  407. dev_err(codec->dev, "failed to create pcms: %d\n", ret);
  408. goto pcm_err;
  409. }
  410. snd_soc_add_controls(codec, ad193x_snd_controls,
  411. ARRAY_SIZE(ad193x_snd_controls));
  412. snd_soc_dapm_new_controls(codec, ad193x_dapm_widgets,
  413. ARRAY_SIZE(ad193x_dapm_widgets));
  414. snd_soc_dapm_add_routes(codec, audio_paths, ARRAY_SIZE(audio_paths));
  415. pcm_err:
  416. return ret;
  417. }
  418. /* power down chip */
  419. static int ad193x_remove(struct platform_device *pdev)
  420. {
  421. struct snd_soc_device *socdev = platform_get_drvdata(pdev);
  422. snd_soc_free_pcms(socdev);
  423. snd_soc_dapm_free(socdev);
  424. return 0;
  425. }
  426. struct snd_soc_codec_device soc_codec_dev_ad193x = {
  427. .probe = ad193x_probe,
  428. .remove = ad193x_remove,
  429. };
  430. EXPORT_SYMBOL_GPL(soc_codec_dev_ad193x);
  431. #if defined(CONFIG_SPI_MASTER)
  432. static int __devinit ad193x_spi_probe(struct spi_device *spi)
  433. {
  434. return ad193x_bus_probe(&spi->dev, spi, SND_SOC_SPI);
  435. }
  436. static int __devexit ad193x_spi_remove(struct spi_device *spi)
  437. {
  438. return ad193x_bus_remove(&spi->dev);
  439. }
  440. static struct spi_driver ad193x_spi_driver = {
  441. .driver = {
  442. .name = "ad193x",
  443. .owner = THIS_MODULE,
  444. },
  445. .probe = ad193x_spi_probe,
  446. .remove = __devexit_p(ad193x_spi_remove),
  447. };
  448. #endif
  449. #if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
  450. static const struct i2c_device_id ad193x_id[] = {
  451. { "ad1936", 0 },
  452. { "ad1937", 0 },
  453. { }
  454. };
  455. MODULE_DEVICE_TABLE(i2c, ad193x_id);
  456. static int __devinit ad193x_i2c_probe(struct i2c_client *client,
  457. const struct i2c_device_id *id)
  458. {
  459. return ad193x_bus_probe(&client->dev, client, SND_SOC_I2C);
  460. }
  461. static int __devexit ad193x_i2c_remove(struct i2c_client *client)
  462. {
  463. return ad193x_bus_remove(&client->dev);
  464. }
  465. static struct i2c_driver ad193x_i2c_driver = {
  466. .driver = {
  467. .name = "ad193x",
  468. },
  469. .probe = ad193x_i2c_probe,
  470. .remove = __devexit_p(ad193x_i2c_remove),
  471. .id_table = ad193x_id,
  472. };
  473. #endif
  474. static int __init ad193x_modinit(void)
  475. {
  476. int ret;
  477. #if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
  478. ret = i2c_add_driver(&ad193x_i2c_driver);
  479. if (ret != 0) {
  480. printk(KERN_ERR "Failed to register AD193X I2C driver: %d\n",
  481. ret);
  482. }
  483. #endif
  484. #if defined(CONFIG_SPI_MASTER)
  485. ret = spi_register_driver(&ad193x_spi_driver);
  486. if (ret != 0) {
  487. printk(KERN_ERR "Failed to register AD193X SPI driver: %d\n",
  488. ret);
  489. }
  490. #endif
  491. return ret;
  492. }
  493. module_init(ad193x_modinit);
  494. static void __exit ad193x_modexit(void)
  495. {
  496. #if defined(CONFIG_SPI_MASTER)
  497. spi_unregister_driver(&ad193x_spi_driver);
  498. #endif
  499. #if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
  500. i2c_del_driver(&ad193x_i2c_driver);
  501. #endif
  502. }
  503. module_exit(ad193x_modexit);
  504. MODULE_DESCRIPTION("ASoC ad193x driver");
  505. MODULE_AUTHOR("Barry Song <21cnbao@gmail.com>");
  506. MODULE_LICENSE("GPL");