max98504.c 9.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * MAX98504 ALSA SoC Audio driver
  4. *
  5. * Copyright 2013 - 2014 Maxim Integrated Products
  6. * Copyright 2016 Samsung Electronics Co., Ltd.
  7. */
  8. #include <linux/delay.h>
  9. #include <linux/i2c.h>
  10. #include <linux/module.h>
  11. #include <linux/regulator/consumer.h>
  12. #include <linux/slab.h>
  13. #include <linux/types.h>
  14. #include <sound/soc.h>
  15. #include "max98504.h"
  16. static const char * const max98504_supply_names[] = {
  17. "DVDD",
  18. "DIOVDD",
  19. "PVDD",
  20. };
  21. #define MAX98504_NUM_SUPPLIES ARRAY_SIZE(max98504_supply_names)
  22. struct max98504_priv {
  23. struct regmap *regmap;
  24. struct regulator_bulk_data supplies[MAX98504_NUM_SUPPLIES];
  25. unsigned int pcm_rx_channels;
  26. bool brownout_enable;
  27. unsigned int brownout_threshold;
  28. unsigned int brownout_attenuation;
  29. unsigned int brownout_attack_hold;
  30. unsigned int brownout_timed_hold;
  31. unsigned int brownout_release_rate;
  32. };
  33. static struct reg_default max98504_reg_defaults[] = {
  34. { 0x01, 0},
  35. { 0x02, 0},
  36. { 0x03, 0},
  37. { 0x04, 0},
  38. { 0x10, 0},
  39. { 0x11, 0},
  40. { 0x12, 0},
  41. { 0x13, 0},
  42. { 0x14, 0},
  43. { 0x15, 0},
  44. { 0x16, 0},
  45. { 0x17, 0},
  46. { 0x18, 0},
  47. { 0x19, 0},
  48. { 0x1A, 0},
  49. { 0x20, 0},
  50. { 0x21, 0},
  51. { 0x22, 0},
  52. { 0x23, 0},
  53. { 0x24, 0},
  54. { 0x25, 0},
  55. { 0x26, 0},
  56. { 0x27, 0},
  57. { 0x28, 0},
  58. { 0x30, 0},
  59. { 0x31, 0},
  60. { 0x32, 0},
  61. { 0x33, 0},
  62. { 0x34, 0},
  63. { 0x35, 0},
  64. { 0x36, 0},
  65. { 0x37, 0},
  66. { 0x38, 0},
  67. { 0x39, 0},
  68. { 0x40, 0},
  69. { 0x41, 0},
  70. };
  71. static bool max98504_volatile_register(struct device *dev, unsigned int reg)
  72. {
  73. switch (reg) {
  74. case MAX98504_INTERRUPT_STATUS:
  75. case MAX98504_INTERRUPT_FLAGS:
  76. case MAX98504_INTERRUPT_FLAG_CLEARS:
  77. case MAX98504_WATCHDOG_CLEAR:
  78. case MAX98504_GLOBAL_ENABLE:
  79. case MAX98504_SOFTWARE_RESET:
  80. return true;
  81. default:
  82. return false;
  83. }
  84. }
  85. static bool max98504_readable_register(struct device *dev, unsigned int reg)
  86. {
  87. switch (reg) {
  88. case MAX98504_SOFTWARE_RESET:
  89. case MAX98504_WATCHDOG_CLEAR:
  90. case MAX98504_INTERRUPT_FLAG_CLEARS:
  91. return false;
  92. default:
  93. return true;
  94. }
  95. }
  96. static int max98504_pcm_rx_ev(struct snd_soc_dapm_widget *w,
  97. struct snd_kcontrol *kcontrol, int event)
  98. {
  99. struct snd_soc_component *c = snd_soc_dapm_to_component(w->dapm);
  100. struct max98504_priv *max98504 = snd_soc_component_get_drvdata(c);
  101. switch (event) {
  102. case SND_SOC_DAPM_PRE_PMU:
  103. regmap_write(max98504->regmap, MAX98504_PCM_RX_ENABLE,
  104. max98504->pcm_rx_channels);
  105. break;
  106. case SND_SOC_DAPM_POST_PMD:
  107. regmap_write(max98504->regmap, MAX98504_PCM_RX_ENABLE, 0);
  108. break;
  109. }
  110. return 0;
  111. }
  112. static int max98504_component_probe(struct snd_soc_component *c)
  113. {
  114. struct max98504_priv *max98504 = snd_soc_component_get_drvdata(c);
  115. struct regmap *map = max98504->regmap;
  116. int ret;
  117. ret = regulator_bulk_enable(MAX98504_NUM_SUPPLIES, max98504->supplies);
  118. if (ret < 0)
  119. return ret;
  120. regmap_write(map, MAX98504_SOFTWARE_RESET, 0x1);
  121. msleep(20);
  122. if (!max98504->brownout_enable)
  123. return 0;
  124. regmap_write(map, MAX98504_PVDD_BROWNOUT_ENABLE, 0x1);
  125. regmap_write(map, MAX98504_PVDD_BROWNOUT_CONFIG_1,
  126. (max98504->brownout_threshold & 0x1f) << 3 |
  127. (max98504->brownout_attenuation & 0x3));
  128. regmap_write(map, MAX98504_PVDD_BROWNOUT_CONFIG_2,
  129. max98504->brownout_attack_hold & 0xff);
  130. regmap_write(map, MAX98504_PVDD_BROWNOUT_CONFIG_3,
  131. max98504->brownout_timed_hold & 0xff);
  132. regmap_write(map, MAX98504_PVDD_BROWNOUT_CONFIG_4,
  133. max98504->brownout_release_rate & 0xff);
  134. return 0;
  135. }
  136. static void max98504_component_remove(struct snd_soc_component *c)
  137. {
  138. struct max98504_priv *max98504 = snd_soc_component_get_drvdata(c);
  139. regulator_bulk_disable(MAX98504_NUM_SUPPLIES, max98504->supplies);
  140. }
  141. static const char *spk_source_mux_text[] = {
  142. "PCM Monomix", "Analog In", "PDM Left", "PDM Right"
  143. };
  144. static const struct soc_enum spk_source_mux_enum =
  145. SOC_ENUM_SINGLE(MAX98504_SPEAKER_SOURCE_SELECT,
  146. 0, ARRAY_SIZE(spk_source_mux_text),
  147. spk_source_mux_text);
  148. static const struct snd_kcontrol_new spk_source_mux =
  149. SOC_DAPM_ENUM("SPK Source", spk_source_mux_enum);
  150. static const struct snd_soc_dapm_route max98504_dapm_routes[] = {
  151. { "SPKOUT", NULL, "Global Enable" },
  152. { "SPK Source", "PCM Monomix", "DAC PCM" },
  153. { "SPK Source", "Analog In", "AIN" },
  154. { "SPK Source", "PDM Left", "DAC PDM" },
  155. { "SPK Source", "PDM Right", "DAC PDM" },
  156. };
  157. static const struct snd_soc_dapm_widget max98504_dapm_widgets[] = {
  158. SND_SOC_DAPM_SUPPLY("Global Enable", MAX98504_GLOBAL_ENABLE,
  159. 0, 0, NULL, 0),
  160. SND_SOC_DAPM_INPUT("AIN"),
  161. SND_SOC_DAPM_AIF_OUT("AIF2OUTL", "AIF2 Capture", 0, SND_SOC_NOPM, 0, 0),
  162. SND_SOC_DAPM_AIF_OUT("AIF2OUTR", "AIF2 Capture", 1, SND_SOC_NOPM, 0, 0),
  163. SND_SOC_DAPM_DAC_E("DAC PCM", NULL, SND_SOC_NOPM, 0, 0,
  164. max98504_pcm_rx_ev,
  165. SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
  166. SND_SOC_DAPM_DAC("DAC PDM", NULL, MAX98504_PDM_RX_ENABLE, 0, 0),
  167. SND_SOC_DAPM_MUX("SPK Source", SND_SOC_NOPM, 0, 0, &spk_source_mux),
  168. SND_SOC_DAPM_REG(snd_soc_dapm_spk, "SPKOUT",
  169. MAX98504_SPEAKER_ENABLE, 0, 1, 1, 0),
  170. };
  171. static int max98504_set_tdm_slot(struct snd_soc_dai *dai,
  172. unsigned int tx_mask, unsigned int rx_mask,
  173. int slots, int slot_width)
  174. {
  175. struct max98504_priv *max98504 = snd_soc_dai_get_drvdata(dai);
  176. struct regmap *map = max98504->regmap;
  177. switch (dai->id) {
  178. case MAX98504_DAI_ID_PCM:
  179. regmap_write(map, MAX98504_PCM_TX_ENABLE, tx_mask);
  180. max98504->pcm_rx_channels = rx_mask;
  181. break;
  182. case MAX98504_DAI_ID_PDM:
  183. regmap_write(map, MAX98504_PDM_TX_ENABLE, tx_mask);
  184. break;
  185. default:
  186. WARN_ON(1);
  187. }
  188. return 0;
  189. }
  190. static int max98504_set_channel_map(struct snd_soc_dai *dai,
  191. unsigned int tx_num, unsigned int *tx_slot,
  192. unsigned int rx_num, unsigned int *rx_slot)
  193. {
  194. struct max98504_priv *max98504 = snd_soc_dai_get_drvdata(dai);
  195. struct regmap *map = max98504->regmap;
  196. unsigned int i, sources = 0;
  197. for (i = 0; i < tx_num; i++)
  198. if (tx_slot[i])
  199. sources |= (1 << i);
  200. switch (dai->id) {
  201. case MAX98504_DAI_ID_PCM:
  202. regmap_write(map, MAX98504_PCM_TX_CHANNEL_SOURCES,
  203. sources);
  204. break;
  205. case MAX98504_DAI_ID_PDM:
  206. regmap_write(map, MAX98504_PDM_TX_CONTROL, sources);
  207. break;
  208. default:
  209. WARN_ON(1);
  210. }
  211. regmap_write(map, MAX98504_MEASUREMENT_ENABLE, sources ? 0x3 : 0x01);
  212. return 0;
  213. }
  214. static const struct snd_soc_dai_ops max98504_dai_ops = {
  215. .set_tdm_slot = max98504_set_tdm_slot,
  216. .set_channel_map = max98504_set_channel_map,
  217. };
  218. #define MAX98504_FORMATS (SNDRV_PCM_FMTBIT_S8|SNDRV_PCM_FMTBIT_S16_LE|\
  219. SNDRV_PCM_FMTBIT_S24_LE|SNDRV_PCM_FMTBIT_S32_LE)
  220. #define MAX98504_PDM_RATES (SNDRV_PCM_RATE_8000|SNDRV_PCM_RATE_16000|\
  221. SNDRV_PCM_RATE_32000|SNDRV_PCM_RATE_44100|\
  222. SNDRV_PCM_RATE_48000|SNDRV_PCM_RATE_88200|\
  223. SNDRV_PCM_RATE_96000)
  224. static struct snd_soc_dai_driver max98504_dai[] = {
  225. /* TODO: Add the PCM interface definitions */
  226. {
  227. .name = "max98504-aif2",
  228. .id = MAX98504_DAI_ID_PDM,
  229. .playback = {
  230. .stream_name = "AIF2 Playback",
  231. .channels_min = 1,
  232. .channels_max = 2,
  233. .rates = MAX98504_PDM_RATES,
  234. .formats = MAX98504_FORMATS,
  235. },
  236. .capture = {
  237. .stream_name = "AIF2 Capture",
  238. .channels_min = 1,
  239. .channels_max = 2,
  240. .rates = MAX98504_PDM_RATES,
  241. .formats = MAX98504_FORMATS,
  242. },
  243. .ops = &max98504_dai_ops,
  244. },
  245. };
  246. static const struct snd_soc_component_driver max98504_component_driver = {
  247. .probe = max98504_component_probe,
  248. .remove = max98504_component_remove,
  249. .dapm_widgets = max98504_dapm_widgets,
  250. .num_dapm_widgets = ARRAY_SIZE(max98504_dapm_widgets),
  251. .dapm_routes = max98504_dapm_routes,
  252. .num_dapm_routes = ARRAY_SIZE(max98504_dapm_routes),
  253. };
  254. static const struct regmap_config max98504_regmap = {
  255. .reg_bits = 16,
  256. .val_bits = 8,
  257. .max_register = MAX98504_MAX_REGISTER,
  258. .reg_defaults = max98504_reg_defaults,
  259. .num_reg_defaults = ARRAY_SIZE(max98504_reg_defaults),
  260. .volatile_reg = max98504_volatile_register,
  261. .readable_reg = max98504_readable_register,
  262. .cache_type = REGCACHE_RBTREE,
  263. };
  264. static int max98504_i2c_probe(struct i2c_client *client,
  265. const struct i2c_device_id *id)
  266. {
  267. struct device *dev = &client->dev;
  268. struct device_node *node = dev->of_node;
  269. struct max98504_priv *max98504;
  270. int i, ret;
  271. max98504 = devm_kzalloc(dev, sizeof(*max98504), GFP_KERNEL);
  272. if (!max98504)
  273. return -ENOMEM;
  274. if (node) {
  275. if (!of_property_read_u32(node, "maxim,brownout-threshold",
  276. &max98504->brownout_threshold))
  277. max98504->brownout_enable = true;
  278. of_property_read_u32(node, "maxim,brownout-attenuation",
  279. &max98504->brownout_attenuation);
  280. of_property_read_u32(node, "maxim,brownout-attack-hold-ms",
  281. &max98504->brownout_attack_hold);
  282. of_property_read_u32(node, "maxim,brownout-timed-hold-ms",
  283. &max98504->brownout_timed_hold);
  284. of_property_read_u32(node, "maxim,brownout-release-rate-ms",
  285. &max98504->brownout_release_rate);
  286. }
  287. max98504->regmap = devm_regmap_init_i2c(client, &max98504_regmap);
  288. if (IS_ERR(max98504->regmap)) {
  289. ret = PTR_ERR(max98504->regmap);
  290. dev_err(&client->dev, "regmap initialization failed: %d\n", ret);
  291. return ret;
  292. }
  293. for (i = 0; i < MAX98504_NUM_SUPPLIES; i++)
  294. max98504->supplies[i].supply = max98504_supply_names[i];
  295. ret = devm_regulator_bulk_get(dev, MAX98504_NUM_SUPPLIES,
  296. max98504->supplies);
  297. if (ret < 0)
  298. return ret;
  299. i2c_set_clientdata(client, max98504);
  300. return devm_snd_soc_register_component(dev, &max98504_component_driver,
  301. max98504_dai, ARRAY_SIZE(max98504_dai));
  302. }
  303. #ifdef CONFIG_OF
  304. static const struct of_device_id max98504_of_match[] = {
  305. { .compatible = "maxim,max98504" },
  306. { },
  307. };
  308. MODULE_DEVICE_TABLE(of, max98504_of_match);
  309. #endif
  310. static const struct i2c_device_id max98504_i2c_id[] = {
  311. { "max98504" },
  312. { }
  313. };
  314. MODULE_DEVICE_TABLE(i2c, max98504_i2c_id);
  315. static struct i2c_driver max98504_i2c_driver = {
  316. .driver = {
  317. .name = "max98504",
  318. .of_match_table = of_match_ptr(max98504_of_match),
  319. },
  320. .probe = max98504_i2c_probe,
  321. .id_table = max98504_i2c_id,
  322. };
  323. module_i2c_driver(max98504_i2c_driver);
  324. MODULE_DESCRIPTION("ASoC MAX98504 driver");
  325. MODULE_LICENSE("GPL");