1 // SPDX-License-Identifier: GPL-2.0-only
2 //
3 // rt9123.c -- RT9123 (SW I2C Mode) ALSA SoC Codec driver
4 //
5 // Author: ChiYuan Huang <cy_huang@richtek.com>
6
7 #include <linux/acpi.h>
8 #include <linux/bitfield.h>
9 #include <linux/bits.h>
10 #include <linux/byteorder/generic.h>
11 #include <linux/delay.h>
12 #include <linux/err.h>
13 #include <linux/gpio/consumer.h>
14 #include <linux/i2c.h>
15 #include <linux/kernel.h>
16 #include <linux/module.h>
17 #include <linux/of.h>
18 #include <linux/pm_runtime.h>
19 #include <linux/property.h>
20 #include <linux/regmap.h>
21 #include <sound/pcm.h>
22 #include <sound/pcm_params.h>
23 #include <sound/soc.h>
24 #include <sound/soc-dai.h>
25 #include <sound/soc-dapm.h>
26 #include <sound/tlv.h>
27
28 #define RT9123_REG_AMPCTRL 0x01
29 #define RT9123_REG_I2SOPT 0x02
30 #define RT9123_REG_TDMRX 0x03
31 #define RT9123_REG_SILVOLEN 0x04
32 #define RT9123_REG_VOLGAIN 0x12
33 #define RT9123_REG_ANAFLAG 0x36
34 #define RT9123_REG_COMBOID 0xF7
35
36 #define RT9123_MASK_SWRST BIT(15)
37 #define RT9123_MASK_SWMUTE BIT(14)
38 #define RT9123_MASK_AMPON BIT(12)
39 #define RT9123_MASK_AUDBIT GENMASK(14, 12)
40 #define RT9123_MASK_AUDFMT GENMASK(11, 8)
41 #define RT9123_MASK_TDMRXLOC GENMASK(4, 0)
42 #define RT9123_MASK_VENID GENMASK(15, 4)
43
44 #define RT9123_FIXED_VENID 0x340
45
46 struct rt9123_priv {
47 struct gpio_desc *enable;
48 unsigned int dai_fmt;
49 int tdm_slots;
50 int tdm_slot_width;
51 };
52
rt9123_enable_event(struct snd_soc_dapm_widget * w,struct snd_kcontrol * kcontrol,int event)53 static int rt9123_enable_event(struct snd_soc_dapm_widget *w, struct snd_kcontrol *kcontrol,
54 int event)
55 {
56 struct snd_soc_component *comp = snd_soc_dapm_to_component(w->dapm);
57 struct device *dev = comp->dev;
58 unsigned int enable;
59 int ret;
60
61 switch (event) {
62 case SND_SOC_DAPM_POST_PMU:
63 enable = 1;
64 break;
65 case SND_SOC_DAPM_POST_PMD:
66 enable = 0;
67 break;
68 default:
69 return -EINVAL;
70 }
71
72 ret = pm_runtime_resume_and_get(dev);
73 if (ret)
74 return ret;
75
76 /* AMPON bit is located in volatile RG, use pm_runtime to guarantee the RG access */
77 snd_soc_component_write_field(comp, RT9123_REG_AMPCTRL, RT9123_MASK_AMPON, enable);
78
79 pm_runtime_put_autosuspend(dev);
80
81 return 0;
82 }
83
84 static const struct snd_soc_dapm_widget rt9123_dapm_widgets[] = {
85 SND_SOC_DAPM_OUTPUT("SPK"),
86 SND_SOC_DAPM_OUT_DRV_E("Amp Drv", SND_SOC_NOPM, 0, 0, NULL, 0, rt9123_enable_event,
87 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
88 };
89
90 static const struct snd_soc_dapm_route rt9123_dapm_routes[] = {
91 { "Amp Drv", NULL, "HiFi Playback" },
92 { "SPK", NULL, "Amp Drv" },
93 };
94
95 static const DECLARE_TLV_DB_SCALE(dig_tlv, -10375, 25, 0);
96 static const DECLARE_TLV_DB_RANGE(ana_tlv,
97 0, 0, TLV_DB_SCALE_ITEM(-1200, 0, 0),
98 1, 9, TLV_DB_SCALE_ITEM(0, 150, 0),
99 10, 10, TLV_DB_SCALE_ITEM(1400, 0, 0));
100 static const char * const pwmfreq_text[] = { "300KHz", "325KHz", "350KHz", "375KHz" };
101 static const struct soc_enum rt9123_pwm_freq_enum =
102 SOC_ENUM_SINGLE(RT9123_REG_AMPCTRL, 4, ARRAY_SIZE(pwmfreq_text), pwmfreq_text);
103 static const char * const i2sch_text[] = { "(L+R)/2", "LCH", "RCH", "(L+R)/2" };
104 static const struct soc_enum rt9123_i2sch_select_enum =
105 SOC_ENUM_SINGLE(RT9123_REG_I2SOPT, 4, ARRAY_SIZE(i2sch_text), i2sch_text);
106
rt9123_kcontrol_name_comp(struct snd_kcontrol * kcontrol,const char * s)107 static int rt9123_kcontrol_name_comp(struct snd_kcontrol *kcontrol, const char *s)
108 {
109 struct snd_soc_component *comp = snd_kcontrol_chip(kcontrol);
110 const char *kctlname = kcontrol->id.name;
111
112 if (comp && comp->name_prefix)
113 kctlname += strlen(comp->name_prefix) + 1;
114
115 return strcmp(kctlname, s);
116 }
117
rt9123_xhandler_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)118 static int rt9123_xhandler_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
119 {
120 struct snd_soc_component *comp = snd_kcontrol_chip(kcontrol);
121 struct device *dev = comp->dev;
122 int ret;
123
124 ret = pm_runtime_resume_and_get(dev);
125 if (ret)
126 return ret;
127
128 /*
129 * Since the RG bitfield for 'Speaker Volume' and 'PWM Frequency Select' are located in
130 * volatile RG address, special handling here with pm runtime API to guarantee RG read
131 * operation.
132 */
133 if (rt9123_kcontrol_name_comp(kcontrol, "Speaker Volume") == 0)
134 ret = snd_soc_get_volsw(kcontrol, ucontrol);
135 else
136 ret = snd_soc_get_enum_double(kcontrol, ucontrol);
137
138 if (ret < 0)
139 dev_err(dev, "Failed to get control (%d)\n", ret);
140
141 pm_runtime_put_autosuspend(dev);
142 return ret;
143 }
144
rt9123_xhandler_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)145 static int rt9123_xhandler_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
146 {
147 struct snd_soc_component *comp = snd_kcontrol_chip(kcontrol);
148 struct device *dev = comp->dev;
149 int ret;
150
151 ret = pm_runtime_resume_and_get(dev);
152 if (ret)
153 return ret;
154
155 /*
156 * Since the RG bitfield for 'Speaker Volume' and 'PWM Frequency Select' are located in
157 * volatile RG address, special handling here with pm runtime API to guarantee RG write
158 * operation.
159 */
160 if (rt9123_kcontrol_name_comp(kcontrol, "Speaker Volume") == 0)
161 ret = snd_soc_put_volsw(kcontrol, ucontrol);
162 else
163 ret = snd_soc_put_enum_double(kcontrol, ucontrol);
164
165 if (ret < 0)
166 dev_err(dev, "Failed to put control (%d)\n", ret);
167
168 pm_runtime_put_autosuspend(dev);
169 return ret;
170 }
171
172 static const struct snd_kcontrol_new rt9123_controls[] = {
173 SOC_SINGLE_TLV("Master Volume", RT9123_REG_VOLGAIN, 2, 511, 1, dig_tlv),
174 SOC_SINGLE_EXT_TLV("Speaker Volume", RT9123_REG_AMPCTRL, 0, 10, 0, rt9123_xhandler_get,
175 rt9123_xhandler_put, ana_tlv),
176 SOC_ENUM_EXT("PWM Frequency Select", rt9123_pwm_freq_enum, rt9123_xhandler_get,
177 rt9123_xhandler_put),
178 SOC_ENUM("I2S CH Select", rt9123_i2sch_select_enum),
179 SOC_SINGLE("Silence Detect Switch", RT9123_REG_SILVOLEN, 14, 1, 0),
180 };
181
182 static const struct snd_soc_component_driver rt9123_comp_driver = {
183 .controls = rt9123_controls,
184 .num_controls = ARRAY_SIZE(rt9123_controls),
185 .dapm_widgets = rt9123_dapm_widgets,
186 .num_dapm_widgets = ARRAY_SIZE(rt9123_dapm_widgets),
187 .dapm_routes = rt9123_dapm_routes,
188 .num_dapm_routes = ARRAY_SIZE(rt9123_dapm_routes),
189 .use_pmdown_time = 1,
190 .endianness = 1,
191 };
192
rt9123_dai_set_format(struct snd_soc_dai * dai,unsigned int fmt)193 static int rt9123_dai_set_format(struct snd_soc_dai *dai, unsigned int fmt)
194 {
195 struct rt9123_priv *rt9123 = snd_soc_dai_get_drvdata(dai);
196
197 rt9123->dai_fmt = fmt;
198 return 0;
199 }
200
rt9123_dai_set_tdm_slot(struct snd_soc_dai * dai,unsigned int tx_mask,unsigned int rx_mask,int slots,int slot_width)201 static int rt9123_dai_set_tdm_slot(struct snd_soc_dai *dai, unsigned int tx_mask,
202 unsigned int rx_mask, int slots, int slot_width)
203 {
204 struct rt9123_priv *rt9123 = snd_soc_dai_get_drvdata(dai);
205 struct snd_soc_component *comp = dai->component;
206 struct device *dev = dai->dev;
207 unsigned int rx_loc;
208
209 dev_dbg(dev, "(slots, slot_width) = (%d, %d), (txmask, rxmask) = 0x%x, 0x%x\n", slots,
210 slot_width, tx_mask, rx_mask);
211
212 if (slots <= 0 || slot_width <= 0 || slots % 2 || slot_width % 8 ||
213 slots * slot_width > 256) {
214 dev_err(dev, "Invalid slot parameter (%d, %d)\n", slots, slot_width);
215 return -EINVAL;
216 }
217
218 if (!rx_mask || hweight_long(rx_mask) > 1 || ffs(rx_mask) > slots) {
219 dev_err(dev, "Invalid rx_mask 0x%08x, slots = %d\n", rx_mask, slots);
220 return -EINVAL;
221 }
222
223 /* Configure rx channel data location */
224 rx_loc = (ffs(rx_mask) - 1) * slot_width / 8;
225 snd_soc_component_write_field(comp, RT9123_REG_TDMRX, RT9123_MASK_TDMRXLOC, rx_loc);
226
227 rt9123->tdm_slots = slots;
228 rt9123->tdm_slot_width = slot_width;
229
230 return 0;
231 }
232
rt9123_dai_hw_params(struct snd_pcm_substream * substream,struct snd_pcm_hw_params * param,struct snd_soc_dai * dai)233 static int rt9123_dai_hw_params(struct snd_pcm_substream *substream,
234 struct snd_pcm_hw_params *param, struct snd_soc_dai *dai)
235 {
236 struct rt9123_priv *rt9123 = snd_soc_dai_get_drvdata(dai);
237 struct snd_soc_component *comp = dai->component;
238 unsigned int fmtval, width, slot_width;
239 struct device *dev = dai->dev;
240 unsigned int audfmt, audbit;
241
242 fmtval = FIELD_GET(SND_SOC_DAIFMT_FORMAT_MASK, rt9123->dai_fmt);
243 if (rt9123->tdm_slots && fmtval != SND_SOC_DAIFMT_DSP_A && fmtval != SND_SOC_DAIFMT_DSP_B) {
244 dev_err(dev, "TDM only can support DSP_A or DSP_B format\n");
245 return -EINVAL;
246 }
247
248 switch (fmtval) {
249 case SND_SOC_DAIFMT_I2S:
250 audfmt = 0;
251 break;
252 case SND_SOC_DAIFMT_LEFT_J:
253 audfmt = 1;
254 break;
255 case SND_SOC_DAIFMT_RIGHT_J:
256 audfmt = 2;
257 break;
258 case SND_SOC_DAIFMT_DSP_B:
259 audfmt = rt9123->tdm_slots ? 4 : 3;
260 break;
261 case SND_SOC_DAIFMT_DSP_A:
262 audfmt = rt9123->tdm_slots ? 12 : 11;
263 break;
264 default:
265 dev_err(dev, "Unsupported format %d\n", fmtval);
266 return -EINVAL;
267 }
268
269 switch (width = params_width(param)) {
270 case 16:
271 audbit = 0;
272 break;
273 case 20:
274 audbit = 1;
275 break;
276 case 24:
277 audbit = 2;
278 break;
279 case 32:
280 audbit = 3;
281 break;
282 case 8:
283 audbit = 4;
284 break;
285 default:
286 dev_err(dev, "Unsupported width %d\n", width);
287 return -EINVAL;
288 }
289
290 slot_width = params_physical_width(param);
291 if (rt9123->tdm_slots && slot_width > rt9123->tdm_slot_width) {
292 dev_err(dev, "Slot width is larger than TDM slot width\n");
293 return -EINVAL;
294 }
295
296 snd_soc_component_write_field(comp, RT9123_REG_I2SOPT, RT9123_MASK_AUDFMT, audfmt);
297 snd_soc_component_write_field(comp, RT9123_REG_I2SOPT, RT9123_MASK_AUDBIT, audbit);
298
299 return 0;
300 }
301
302 static const struct snd_soc_dai_ops rt9123_dai_ops = {
303 .set_fmt = rt9123_dai_set_format,
304 .set_tdm_slot = rt9123_dai_set_tdm_slot,
305 .hw_params = rt9123_dai_hw_params,
306 };
307
308 static struct snd_soc_dai_driver rt9123_dai_driver = {
309 .name = "HiFi",
310 .playback = {
311 .stream_name = "HiFi Playback",
312 .formats = SNDRV_PCM_FMTBIT_S16 | SNDRV_PCM_FMTBIT_S24 |
313 SNDRV_PCM_FMTBIT_S32,
314 .rates = SNDRV_PCM_RATE_8000 | SNDRV_PCM_RATE_16000 |
315 SNDRV_PCM_RATE_22050 | SNDRV_PCM_RATE_24000 |
316 SNDRV_PCM_RATE_32000 | SNDRV_PCM_RATE_44100 |
317 SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_88200 |
318 SNDRV_PCM_RATE_96000,
319 .rate_min = 8000,
320 .rate_max = 96000,
321 .channels_min = 1,
322 .channels_max = 2,
323 },
324 .ops = &rt9123_dai_ops,
325 };
326
rt9123_readable_reg(struct device * dev,unsigned int reg)327 static bool rt9123_readable_reg(struct device *dev, unsigned int reg)
328 {
329 switch (reg) {
330 case 0x00 ... 0x05:
331 case 0x12 ... 0x13:
332 case 0x20 ... 0x21:
333 case 0x36:
334 return true;
335 default:
336 return false;
337 }
338 }
339
rt9123_writeable_reg(struct device * dev,unsigned int reg)340 static bool rt9123_writeable_reg(struct device *dev, unsigned int reg)
341 {
342 switch (reg) {
343 case 0x01 ... 0x05:
344 case 0x12 ... 0x13:
345 case 0x20 ... 0x21:
346 return true;
347 default:
348 return false;
349 }
350 }
351
rt9123_volatile_reg(struct device * dev,unsigned int reg)352 static bool rt9123_volatile_reg(struct device *dev, unsigned int reg)
353 {
354 switch (reg) {
355 case 0x01:
356 case 0x20:
357 case 0x36:
358 return true;
359 default:
360 return false;
361 }
362 }
363
364 static const struct regmap_config rt9123_regmap_config = {
365 .name = "rt9123",
366 .reg_bits = 8,
367 .val_bits = 16,
368 .val_format_endian = REGMAP_ENDIAN_BIG,
369 .readable_reg = rt9123_readable_reg,
370 .writeable_reg = rt9123_writeable_reg,
371 .volatile_reg = rt9123_volatile_reg,
372 .cache_type = REGCACHE_MAPLE,
373 .num_reg_defaults_raw = RT9123_REG_ANAFLAG + 1,
374 };
375
rt9123_i2c_probe(struct i2c_client * i2c)376 static int rt9123_i2c_probe(struct i2c_client *i2c)
377 {
378 struct device *dev = &i2c->dev;
379 struct rt9123_priv *rt9123;
380 struct regmap *regmap;
381 __be16 value;
382 u16 venid;
383 int ret;
384
385 rt9123 = devm_kzalloc(dev, sizeof(*rt9123), GFP_KERNEL);
386 if (!rt9123)
387 return -ENOMEM;
388
389 rt9123->enable = devm_gpiod_get_optional(dev, "enable", GPIOD_OUT_HIGH);
390 if (IS_ERR(rt9123->enable))
391 return PTR_ERR(rt9123->enable);
392 else if (rt9123->enable)
393 usleep_range(250, 350);
394 else
395 dev_dbg(dev, "No 'enable' GPIO specified, treat it as default on\n");
396
397 /* Check vendor id information */
398 ret = i2c_smbus_read_i2c_block_data(i2c, RT9123_REG_COMBOID, sizeof(value), (u8 *)&value);
399 if (ret < 0)
400 return dev_err_probe(dev, ret, "Failed to read vendor-id\n");
401
402 venid = be16_to_cpu(value);
403 if ((venid & RT9123_MASK_VENID) != RT9123_FIXED_VENID)
404 return dev_err_probe(dev, -ENODEV, "Incorrect vendor-id 0x%04x\n", venid);
405
406 /* Trigger RG reset before regmap init cache */
407 value = cpu_to_be16(RT9123_MASK_SWRST);
408 ret = i2c_smbus_write_i2c_block_data(i2c, RT9123_REG_AMPCTRL, sizeof(value), (u8 *)&value);
409 if (ret)
410 return dev_err_probe(dev, ret, "Failed to trigger RG reset\n");
411
412 /* Need to wait 10ms for the reset to complete */
413 usleep_range(10000, 11000);
414
415 regmap = devm_regmap_init_i2c(i2c, &rt9123_regmap_config);
416 if (IS_ERR(regmap))
417 return dev_err_probe(dev, PTR_ERR(regmap), "Failed to init regmap\n");
418
419 i2c_set_clientdata(i2c, rt9123);
420
421 pm_runtime_set_autosuspend_delay(dev, 500);
422 pm_runtime_use_autosuspend(dev);
423 pm_runtime_set_active(dev);
424 ret = devm_pm_runtime_enable(dev);
425 if (ret)
426 return dev_err_probe(dev, ret, "Failed to enable pm runtime\n");
427
428 return devm_snd_soc_register_component(dev, &rt9123_comp_driver, &rt9123_dai_driver, 1);
429 }
430
431 #ifdef CONFIG_PM
rt9123_runtime_suspend(struct device * dev)432 static int rt9123_runtime_suspend(struct device *dev)
433 {
434 struct rt9123_priv *rt9123 = dev_get_drvdata(dev);
435 struct regmap *regmap = dev_get_regmap(dev, NULL);
436
437 if (rt9123->enable) {
438 regcache_cache_only(regmap, true);
439 regcache_mark_dirty(regmap);
440 gpiod_set_value(rt9123->enable, 0);
441 }
442
443 return 0;
444 }
445
rt9123_runtime_resume(struct device * dev)446 static int rt9123_runtime_resume(struct device *dev)
447 {
448 struct rt9123_priv *rt9123 = dev_get_drvdata(dev);
449 struct regmap *regmap = dev_get_regmap(dev, NULL);
450 int ret;
451
452 if (rt9123->enable) {
453 gpiod_set_value(rt9123->enable, 1);
454 usleep_range(250, 350);
455
456 regcache_cache_only(regmap, false);
457 ret = regcache_sync(regmap);
458 if (ret)
459 return ret;
460 }
461
462 return 0;
463 }
464 #endif
465
466 static const struct dev_pm_ops rt9123_dev_pm_ops = {
467 SET_RUNTIME_PM_OPS(rt9123_runtime_suspend, rt9123_runtime_resume, NULL)
468 };
469
470 #ifdef CONFIG_OF
471 static const struct of_device_id rt9123_device_id[] = {
472 { .compatible = "richtek,rt9123" },
473 {}
474 };
475 MODULE_DEVICE_TABLE(of, rt9123_device_id);
476 #endif
477
478 #ifdef CONFIG_ACPI
479 static const struct acpi_device_id rt9123_acpi_match[] = {
480 { "RT9123", 0 },
481 {}
482 };
483 MODULE_DEVICE_TABLE(acpi, rt9123_acpi_match);
484 #endif
485
486 static struct i2c_driver rt9123_i2c_driver = {
487 .driver = {
488 .name = "rt9123",
489 .of_match_table = of_match_ptr(rt9123_device_id),
490 .acpi_match_table = ACPI_PTR(rt9123_acpi_match),
491 .pm = pm_ptr(&rt9123_dev_pm_ops),
492 },
493 .probe = rt9123_i2c_probe,
494 };
495 module_i2c_driver(rt9123_i2c_driver);
496
497 MODULE_AUTHOR("ChiYuan Huang <cy_huang@richtek.com>");
498 MODULE_DESCRIPTION("ASoC rt9123 Driver");
499 MODULE_LICENSE("GPL");
500