rt5645.c (7ff6319e7da5c09f0ce86d122d46040807262325) rt5645.c (ca8457bb02d8ecddf7f49ab874127dd4df782b16)
1/*
2 * rt5645.c -- RT5645 ALSA SoC audio codec driver
3 *
4 * Copyright 2013 Realtek Semiconductor Corp.
5 * Author: Bard Liao <bardliao@realtek.com>
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 as

--- 212 unchanged lines hidden (view full) ---

221 { 0xfa, 0x2060 },
222 { 0xfb, 0x4040 },
223 { 0xfc, 0x0000 },
224 { 0xfd, 0x0002 },
225 { 0xfe, 0x10ec },
226 { 0xff, 0x6308 },
227};
228
1/*
2 * rt5645.c -- RT5645 ALSA SoC audio codec driver
3 *
4 * Copyright 2013 Realtek Semiconductor Corp.
5 * Author: Bard Liao <bardliao@realtek.com>
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 as

--- 212 unchanged lines hidden (view full) ---

221 { 0xfa, 0x2060 },
222 { 0xfb, 0x4040 },
223 { 0xfc, 0x0000 },
224 { 0xfd, 0x0002 },
225 { 0xfe, 0x10ec },
226 { 0xff, 0x6308 },
227};
228
229static const struct reg_default rt5650_reg[] = {
230 { 0x00, 0x0000 },
231 { 0x01, 0xc8c8 },
232 { 0x02, 0xc8c8 },
233 { 0x03, 0xc8c8 },
234 { 0x0a, 0x0002 },
235 { 0x0b, 0x2827 },
236 { 0x0c, 0xe000 },
237 { 0x0d, 0x0000 },
238 { 0x0e, 0x0000 },
239 { 0x0f, 0x0808 },
240 { 0x14, 0x3333 },
241 { 0x16, 0x4b00 },
242 { 0x18, 0x018b },
243 { 0x19, 0xafaf },
244 { 0x1a, 0xafaf },
245 { 0x1b, 0x0001 },
246 { 0x1c, 0x2f2f },
247 { 0x1d, 0x2f2f },
248 { 0x1e, 0x0000 },
249 { 0x20, 0x0000 },
250 { 0x27, 0x7060 },
251 { 0x28, 0x7070 },
252 { 0x29, 0x8080 },
253 { 0x2a, 0x5656 },
254 { 0x2b, 0x5454 },
255 { 0x2c, 0xaaa0 },
256 { 0x2d, 0x0000 },
257 { 0x2f, 0x1002 },
258 { 0x31, 0x5000 },
259 { 0x32, 0x0000 },
260 { 0x33, 0x0000 },
261 { 0x34, 0x0000 },
262 { 0x35, 0x0000 },
263 { 0x3b, 0x0000 },
264 { 0x3c, 0x007f },
265 { 0x3d, 0x0000 },
266 { 0x3e, 0x007f },
267 { 0x3f, 0x0000 },
268 { 0x40, 0x001f },
269 { 0x41, 0x0000 },
270 { 0x42, 0x001f },
271 { 0x45, 0x6000 },
272 { 0x46, 0x003e },
273 { 0x47, 0x003e },
274 { 0x48, 0xf807 },
275 { 0x4a, 0x0004 },
276 { 0x4d, 0x0000 },
277 { 0x4e, 0x0000 },
278 { 0x4f, 0x01ff },
279 { 0x50, 0x0000 },
280 { 0x51, 0x0000 },
281 { 0x52, 0x01ff },
282 { 0x53, 0xf000 },
283 { 0x56, 0x0111 },
284 { 0x57, 0x0064 },
285 { 0x58, 0xef0e },
286 { 0x59, 0xf0f0 },
287 { 0x5a, 0xef0e },
288 { 0x5b, 0xf0f0 },
289 { 0x5c, 0xef0e },
290 { 0x5d, 0xf0f0 },
291 { 0x5e, 0xf000 },
292 { 0x5f, 0x0000 },
293 { 0x61, 0x0300 },
294 { 0x62, 0x0000 },
295 { 0x63, 0x00c2 },
296 { 0x64, 0x0000 },
297 { 0x65, 0x0000 },
298 { 0x66, 0x0000 },
299 { 0x6a, 0x0000 },
300 { 0x6c, 0x0aaa },
301 { 0x70, 0x8000 },
302 { 0x71, 0x8000 },
303 { 0x72, 0x8000 },
304 { 0x73, 0x7770 },
305 { 0x74, 0x3e00 },
306 { 0x75, 0x2409 },
307 { 0x76, 0x000a },
308 { 0x77, 0x0c00 },
309 { 0x78, 0x0000 },
310 { 0x79, 0x0123 },
311 { 0x7a, 0x0123 },
312 { 0x80, 0x0000 },
313 { 0x81, 0x0000 },
314 { 0x82, 0x0000 },
315 { 0x83, 0x0000 },
316 { 0x84, 0x0000 },
317 { 0x85, 0x0000 },
318 { 0x8a, 0x0000 },
319 { 0x8e, 0x0004 },
320 { 0x8f, 0x1100 },
321 { 0x90, 0x0646 },
322 { 0x91, 0x0c06 },
323 { 0x93, 0x0000 },
324 { 0x94, 0x0200 },
325 { 0x95, 0x0000 },
326 { 0x9a, 0x2184 },
327 { 0x9b, 0x010a },
328 { 0x9c, 0x0aea },
329 { 0x9d, 0x000c },
330 { 0x9e, 0x0400 },
331 { 0xa0, 0xa0a8 },
332 { 0xa1, 0x0059 },
333 { 0xa2, 0x0001 },
334 { 0xae, 0x6000 },
335 { 0xaf, 0x0000 },
336 { 0xb0, 0x6000 },
337 { 0xb1, 0x0000 },
338 { 0xb2, 0x0000 },
339 { 0xb3, 0x001f },
340 { 0xb4, 0x020c },
341 { 0xb5, 0x1f00 },
342 { 0xb6, 0x0000 },
343 { 0xbb, 0x0000 },
344 { 0xbc, 0x0000 },
345 { 0xbd, 0x0000 },
346 { 0xbe, 0x0000 },
347 { 0xbf, 0x3100 },
348 { 0xc0, 0x0000 },
349 { 0xc1, 0x0000 },
350 { 0xc2, 0x0000 },
351 { 0xc3, 0x2000 },
352 { 0xcd, 0x0000 },
353 { 0xce, 0x0000 },
354 { 0xcf, 0x1813 },
355 { 0xd0, 0x0690 },
356 { 0xd1, 0x1c17 },
357 { 0xd3, 0xb320 },
358 { 0xd4, 0x0000 },
359 { 0xd6, 0x0400 },
360 { 0xd9, 0x0809 },
361 { 0xda, 0x0000 },
362 { 0xdb, 0x0003 },
363 { 0xdc, 0x0049 },
364 { 0xdd, 0x001b },
365 { 0xdf, 0x0008 },
366 { 0xe0, 0x4000 },
367 { 0xe6, 0x8000 },
368 { 0xe7, 0x0200 },
369 { 0xec, 0xb300 },
370 { 0xed, 0x0000 },
371 { 0xf0, 0x001f },
372 { 0xf1, 0x020c },
373 { 0xf2, 0x1f00 },
374 { 0xf3, 0x0000 },
375 { 0xf4, 0x4000 },
376 { 0xf8, 0x0000 },
377 { 0xf9, 0x0000 },
378 { 0xfa, 0x2060 },
379 { 0xfb, 0x4040 },
380 { 0xfc, 0x0000 },
381 { 0xfd, 0x0002 },
382 { 0xfe, 0x10ec },
383 { 0xff, 0x6308 },
384};
385
386struct rt5645_eq_param_s {
387 unsigned short reg;
388 unsigned short val;
389};
390
391static const char *const rt5645_supply_names[] = {
392 "avdd",
393 "cpvdd",
394};
395
396struct rt5645_priv {
397 struct snd_soc_codec *codec;
398 struct rt5645_platform_data pdata;
399 struct regmap *regmap;
400 struct i2c_client *i2c;
401 struct gpio_desc *gpiod_hp_det;
402 struct snd_soc_jack *hp_jack;
403 struct snd_soc_jack *mic_jack;
404 struct snd_soc_jack *btn_jack;
229struct rt5645_eq_param_s {
230 unsigned short reg;
231 unsigned short val;
232};
233
234static const char *const rt5645_supply_names[] = {
235 "avdd",
236 "cpvdd",
237};
238
239struct rt5645_priv {
240 struct snd_soc_codec *codec;
241 struct rt5645_platform_data pdata;
242 struct regmap *regmap;
243 struct i2c_client *i2c;
244 struct gpio_desc *gpiod_hp_det;
245 struct snd_soc_jack *hp_jack;
246 struct snd_soc_jack *mic_jack;
247 struct snd_soc_jack *btn_jack;
405 struct delayed_work jack_detect_work, rcclock_work;
248 struct delayed_work jack_detect_work;
406 struct regulator_bulk_data supplies[ARRAY_SIZE(rt5645_supply_names)];
407 struct rt5645_eq_param_s *eq_param;
249 struct regulator_bulk_data supplies[ARRAY_SIZE(rt5645_supply_names)];
250 struct rt5645_eq_param_s *eq_param;
408 struct timer_list btn_check_timer;
409
410 int codec_type;
411 int sysclk;
412 int sysclk_src;
413 int lrck[RT5645_AIFS];
414 int bclk[RT5645_AIFS];
415 int master[RT5645_AIFS];
416

--- 301 unchanged lines hidden (view full) ---

718
719#define RT5645_HWEQ(xname) \
720{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
721 .info = rt5645_hweq_info, \
722 .get = rt5645_hweq_get, \
723 .put = rt5645_hweq_put \
724}
725
251
252 int codec_type;
253 int sysclk;
254 int sysclk_src;
255 int lrck[RT5645_AIFS];
256 int bclk[RT5645_AIFS];
257 int master[RT5645_AIFS];
258

--- 301 unchanged lines hidden (view full) ---

560
561#define RT5645_HWEQ(xname) \
562{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
563 .info = rt5645_hweq_info, \
564 .get = rt5645_hweq_get, \
565 .put = rt5645_hweq_put \
566}
567
726static int rt5645_spk_put_volsw(struct snd_kcontrol *kcontrol,
727 struct snd_ctl_elem_value *ucontrol)
728{
729 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
730 struct rt5645_priv *rt5645 = snd_soc_component_get_drvdata(component);
731 int ret;
732
733 regmap_update_bits(rt5645->regmap, RT5645_MICBIAS,
734 RT5645_PWR_CLK25M_MASK, RT5645_PWR_CLK25M_PU);
735
736 ret = snd_soc_put_volsw(kcontrol, ucontrol);
737
738 mod_delayed_work(system_power_efficient_wq, &rt5645->rcclock_work,
739 msecs_to_jiffies(200));
740
741 return ret;
742}
743
744static const struct snd_kcontrol_new rt5645_snd_controls[] = {
745 /* Speaker Output Volume */
746 SOC_DOUBLE("Speaker Channel Switch", RT5645_SPK_VOL,
747 RT5645_VOL_L_SFT, RT5645_VOL_R_SFT, 1, 1),
568static const struct snd_kcontrol_new rt5645_snd_controls[] = {
569 /* Speaker Output Volume */
570 SOC_DOUBLE("Speaker Channel Switch", RT5645_SPK_VOL,
571 RT5645_VOL_L_SFT, RT5645_VOL_R_SFT, 1, 1),
748 SOC_DOUBLE_EXT_TLV("Speaker Playback Volume", RT5645_SPK_VOL,
749 RT5645_L_VOL_SFT, RT5645_R_VOL_SFT, 39, 1, snd_soc_get_volsw,
750 rt5645_spk_put_volsw, out_vol_tlv),
572 SOC_DOUBLE_TLV("Speaker Playback Volume", RT5645_SPK_VOL,
573 RT5645_L_VOL_SFT, RT5645_R_VOL_SFT, 39, 1, out_vol_tlv),
751
752 /* ClassD modulator Speaker Gain Ratio */
753 SOC_SINGLE_TLV("Speaker ClassD Playback Volume", RT5645_SPO_CLSD_RATIO,
754 RT5645_SPK_G_CLSD_SFT, 7, 0, spk_clsd_tlv),
755
756 /* Headphone Output Volume */
757 SOC_DOUBLE("Headphone Channel Switch", RT5645_HP_VOL,
758 RT5645_VOL_L_SFT, RT5645_VOL_R_SFT, 1, 1),

--- 911 unchanged lines hidden (view full) ---

1670 snd_soc_update_bits(codec, RT5645_DEPOP_M1,
1671 RT5645_HP_CO_MASK, RT5645_HP_CO_EN);
1672 regmap_write(rt5645->regmap, RT5645_PR_BASE +
1673 0x3e, 0x7400);
1674 snd_soc_write(codec, RT5645_DEPOP_M3, 0x0737);
1675 regmap_write(rt5645->regmap, RT5645_PR_BASE +
1676 RT5645_MAMP_INT_REG2, 0xfc00);
1677 snd_soc_write(codec, RT5645_DEPOP_M2, 0x1140);
574
575 /* ClassD modulator Speaker Gain Ratio */
576 SOC_SINGLE_TLV("Speaker ClassD Playback Volume", RT5645_SPO_CLSD_RATIO,
577 RT5645_SPK_G_CLSD_SFT, 7, 0, spk_clsd_tlv),
578
579 /* Headphone Output Volume */
580 SOC_DOUBLE("Headphone Channel Switch", RT5645_HP_VOL,
581 RT5645_VOL_L_SFT, RT5645_VOL_R_SFT, 1, 1),

--- 911 unchanged lines hidden (view full) ---

1493 snd_soc_update_bits(codec, RT5645_DEPOP_M1,
1494 RT5645_HP_CO_MASK, RT5645_HP_CO_EN);
1495 regmap_write(rt5645->regmap, RT5645_PR_BASE +
1496 0x3e, 0x7400);
1497 snd_soc_write(codec, RT5645_DEPOP_M3, 0x0737);
1498 regmap_write(rt5645->regmap, RT5645_PR_BASE +
1499 RT5645_MAMP_INT_REG2, 0xfc00);
1500 snd_soc_write(codec, RT5645_DEPOP_M2, 0x1140);
1678 msleep(70);
1501 msleep(40);
1679 rt5645->hp_on = true;
1680 } else {
1681 /* depop parameters */
1682 snd_soc_update_bits(codec, RT5645_DEPOP_M2,
1683 RT5645_DEPOP_MASK, RT5645_DEPOP_MAN);
1684 snd_soc_write(codec, RT5645_DEPOP_M1, 0x000d);
1685 regmap_write(rt5645->regmap, RT5645_PR_BASE +
1686 RT5645_HP_DCC_INT1, 0x9f01);

--- 131 unchanged lines hidden (view full) ---

1818 switch (event) {
1819 case SND_SOC_DAPM_POST_PMU:
1820 rt5645_enable_hweq(codec);
1821 snd_soc_update_bits(codec, RT5645_PWR_DIG1,
1822 RT5645_PWR_CLS_D | RT5645_PWR_CLS_D_R |
1823 RT5645_PWR_CLS_D_L,
1824 RT5645_PWR_CLS_D | RT5645_PWR_CLS_D_R |
1825 RT5645_PWR_CLS_D_L);
1502 rt5645->hp_on = true;
1503 } else {
1504 /* depop parameters */
1505 snd_soc_update_bits(codec, RT5645_DEPOP_M2,
1506 RT5645_DEPOP_MASK, RT5645_DEPOP_MAN);
1507 snd_soc_write(codec, RT5645_DEPOP_M1, 0x000d);
1508 regmap_write(rt5645->regmap, RT5645_PR_BASE +
1509 RT5645_HP_DCC_INT1, 0x9f01);

--- 131 unchanged lines hidden (view full) ---

1641 switch (event) {
1642 case SND_SOC_DAPM_POST_PMU:
1643 rt5645_enable_hweq(codec);
1644 snd_soc_update_bits(codec, RT5645_PWR_DIG1,
1645 RT5645_PWR_CLS_D | RT5645_PWR_CLS_D_R |
1646 RT5645_PWR_CLS_D_L,
1647 RT5645_PWR_CLS_D | RT5645_PWR_CLS_D_R |
1648 RT5645_PWR_CLS_D_L);
1649 snd_soc_update_bits(codec, RT5645_GEN_CTRL3,
1650 RT5645_DET_CLK_MASK, RT5645_DET_CLK_MODE1);
1826 break;
1827
1828 case SND_SOC_DAPM_PRE_PMD:
1651 break;
1652
1653 case SND_SOC_DAPM_PRE_PMD:
1654 snd_soc_update_bits(codec, RT5645_GEN_CTRL3,
1655 RT5645_DET_CLK_MASK, RT5645_DET_CLK_DIS);
1829 snd_soc_write(codec, RT5645_EQ_CTRL2, 0);
1830 snd_soc_update_bits(codec, RT5645_PWR_DIG1,
1831 RT5645_PWR_CLS_D | RT5645_PWR_CLS_D_R |
1832 RT5645_PWR_CLS_D_L, 0);
1833 break;
1834
1835 default:
1836 return 0;

--- 1289 unchanged lines hidden (view full) ---

3126 }
3127 } else {
3128 snd_soc_dapm_disable_pin(dapm, "Mic Det Power");
3129 snd_soc_dapm_sync(dapm);
3130 rt5645->jack_type = SND_JACK_HEADPHONE;
3131 }
3132 if (rt5645->pdata.jd_invert)
3133 regmap_update_bits(rt5645->regmap, RT5645_IRQ_CTRL2,
1656 snd_soc_write(codec, RT5645_EQ_CTRL2, 0);
1657 snd_soc_update_bits(codec, RT5645_PWR_DIG1,
1658 RT5645_PWR_CLS_D | RT5645_PWR_CLS_D_R |
1659 RT5645_PWR_CLS_D_L, 0);
1660 break;
1661
1662 default:
1663 return 0;

--- 1289 unchanged lines hidden (view full) ---

2953 }
2954 } else {
2955 snd_soc_dapm_disable_pin(dapm, "Mic Det Power");
2956 snd_soc_dapm_sync(dapm);
2957 rt5645->jack_type = SND_JACK_HEADPHONE;
2958 }
2959 if (rt5645->pdata.jd_invert)
2960 regmap_update_bits(rt5645->regmap, RT5645_IRQ_CTRL2,
3134 RT5645_JD_1_1_MASK, RT5645_JD_1_1_NOR);
2961 RT5645_JD_1_1_MASK, RT5645_JD_1_1_INV);
3135 } else { /* jack out */
3136 rt5645->jack_type = 0;
3137
3138 regmap_update_bits(rt5645->regmap, RT5645_HP_VOL,
3139 RT5645_L_MUTE | RT5645_R_MUTE,
3140 RT5645_L_MUTE | RT5645_R_MUTE);
3141 regmap_update_bits(rt5645->regmap, RT5645_IN1_CTRL2,
3142 RT5645_CBJ_MN_JD, RT5645_CBJ_MN_JD);

--- 4 unchanged lines hidden (view full) ---

3147 rt5645_enable_push_button_irq(codec, false);
3148
3149 if (rt5645->pdata.jd_mode == 0)
3150 snd_soc_dapm_disable_pin(dapm, "LDO2");
3151 snd_soc_dapm_disable_pin(dapm, "Mic Det Power");
3152 snd_soc_dapm_sync(dapm);
3153 if (rt5645->pdata.jd_invert)
3154 regmap_update_bits(rt5645->regmap, RT5645_IRQ_CTRL2,
2962 } else { /* jack out */
2963 rt5645->jack_type = 0;
2964
2965 regmap_update_bits(rt5645->regmap, RT5645_HP_VOL,
2966 RT5645_L_MUTE | RT5645_R_MUTE,
2967 RT5645_L_MUTE | RT5645_R_MUTE);
2968 regmap_update_bits(rt5645->regmap, RT5645_IN1_CTRL2,
2969 RT5645_CBJ_MN_JD, RT5645_CBJ_MN_JD);

--- 4 unchanged lines hidden (view full) ---

2974 rt5645_enable_push_button_irq(codec, false);
2975
2976 if (rt5645->pdata.jd_mode == 0)
2977 snd_soc_dapm_disable_pin(dapm, "LDO2");
2978 snd_soc_dapm_disable_pin(dapm, "Mic Det Power");
2979 snd_soc_dapm_sync(dapm);
2980 if (rt5645->pdata.jd_invert)
2981 regmap_update_bits(rt5645->regmap, RT5645_IRQ_CTRL2,
3155 RT5645_JD_1_1_MASK, RT5645_JD_1_1_INV);
2982 RT5645_JD_1_1_MASK, RT5645_JD_1_1_NOR);
3156 }
3157
3158 return rt5645->jack_type;
3159}
3160
3161static int rt5645_button_detect(struct snd_soc_codec *codec)
3162{
3163 int btn_type, val;

--- 107 unchanged lines hidden (view full) ---

3271 dev_err(rt5645->codec->dev,
3272 "Unexpected button code 0x%04x\n",
3273 btn_type);
3274 break;
3275 }
3276 }
3277 if (btn_type == 0)/* button release */
3278 report = rt5645->jack_type;
2983 }
2984
2985 return rt5645->jack_type;
2986}
2987
2988static int rt5645_button_detect(struct snd_soc_codec *codec)
2989{
2990 int btn_type, val;

--- 107 unchanged lines hidden (view full) ---

3098 dev_err(rt5645->codec->dev,
3099 "Unexpected button code 0x%04x\n",
3100 btn_type);
3101 break;
3102 }
3103 }
3104 if (btn_type == 0)/* button release */
3105 report = rt5645->jack_type;
3279 else {
3280 if (rt5645->pdata.jd_invert) {
3281 mod_timer(&rt5645->btn_check_timer,
3282 msecs_to_jiffies(100));
3283 }
3284 }
3285
3286 break;
3287 /* jack out */
3288 case 0x70: /* 2 port */
3289 case 0x10: /* 2 port */
3290 case 0x20: /* 1 port */
3291 report = 0;
3292 snd_soc_update_bits(rt5645->codec,

--- 7 unchanged lines hidden (view full) ---

3300 snd_soc_jack_report(rt5645->hp_jack, report, SND_JACK_HEADPHONE);
3301 snd_soc_jack_report(rt5645->mic_jack, report, SND_JACK_MICROPHONE);
3302 if (rt5645->en_button_func)
3303 snd_soc_jack_report(rt5645->btn_jack,
3304 report, SND_JACK_BTN_0 | SND_JACK_BTN_1 |
3305 SND_JACK_BTN_2 | SND_JACK_BTN_3);
3306}
3307
3106
3107 break;
3108 /* jack out */
3109 case 0x70: /* 2 port */
3110 case 0x10: /* 2 port */
3111 case 0x20: /* 1 port */
3112 report = 0;
3113 snd_soc_update_bits(rt5645->codec,

--- 7 unchanged lines hidden (view full) ---

3121 snd_soc_jack_report(rt5645->hp_jack, report, SND_JACK_HEADPHONE);
3122 snd_soc_jack_report(rt5645->mic_jack, report, SND_JACK_MICROPHONE);
3123 if (rt5645->en_button_func)
3124 snd_soc_jack_report(rt5645->btn_jack,
3125 report, SND_JACK_BTN_0 | SND_JACK_BTN_1 |
3126 SND_JACK_BTN_2 | SND_JACK_BTN_3);
3127}
3128
3308static void rt5645_rcclock_work(struct work_struct *work)
3309{
3310 struct rt5645_priv *rt5645 =
3311 container_of(work, struct rt5645_priv, rcclock_work.work);
3312
3313 regmap_update_bits(rt5645->regmap, RT5645_MICBIAS,
3314 RT5645_PWR_CLK25M_MASK, RT5645_PWR_CLK25M_PD);
3315}
3316
3317static irqreturn_t rt5645_irq(int irq, void *data)
3318{
3319 struct rt5645_priv *rt5645 = data;
3320
3321 queue_delayed_work(system_power_efficient_wq,
3322 &rt5645->jack_detect_work, msecs_to_jiffies(250));
3323
3324 return IRQ_HANDLED;
3325}
3326
3129static irqreturn_t rt5645_irq(int irq, void *data)
3130{
3131 struct rt5645_priv *rt5645 = data;
3132
3133 queue_delayed_work(system_power_efficient_wq,
3134 &rt5645->jack_detect_work, msecs_to_jiffies(250));
3135
3136 return IRQ_HANDLED;
3137}
3138
3327static void rt5645_btn_check_callback(unsigned long data)
3328{
3329 struct rt5645_priv *rt5645 = (struct rt5645_priv *)data;
3330
3331 queue_delayed_work(system_power_efficient_wq,
3332 &rt5645->jack_detect_work, msecs_to_jiffies(5));
3333}
3334
3335static int rt5645_probe(struct snd_soc_codec *codec)
3336{
3337 struct snd_soc_dapm_context *dapm = snd_soc_codec_get_dapm(codec);
3338 struct rt5645_priv *rt5645 = snd_soc_codec_get_drvdata(codec);
3339
3340 rt5645->codec = codec;
3341
3342 switch (rt5645->codec_type) {

--- 140 unchanged lines hidden (view full) ---

3483
3484 .cache_type = REGCACHE_RBTREE,
3485 .reg_defaults = rt5645_reg,
3486 .num_reg_defaults = ARRAY_SIZE(rt5645_reg),
3487 .ranges = rt5645_ranges,
3488 .num_ranges = ARRAY_SIZE(rt5645_ranges),
3489};
3490
3139static int rt5645_probe(struct snd_soc_codec *codec)
3140{
3141 struct snd_soc_dapm_context *dapm = snd_soc_codec_get_dapm(codec);
3142 struct rt5645_priv *rt5645 = snd_soc_codec_get_drvdata(codec);
3143
3144 rt5645->codec = codec;
3145
3146 switch (rt5645->codec_type) {

--- 140 unchanged lines hidden (view full) ---

3287
3288 .cache_type = REGCACHE_RBTREE,
3289 .reg_defaults = rt5645_reg,
3290 .num_reg_defaults = ARRAY_SIZE(rt5645_reg),
3291 .ranges = rt5645_ranges,
3292 .num_ranges = ARRAY_SIZE(rt5645_ranges),
3293};
3294
3491static const struct regmap_config rt5650_regmap = {
3492 .reg_bits = 8,
3493 .val_bits = 16,
3494 .use_single_rw = true,
3495 .max_register = RT5645_VENDOR_ID2 + 1 + (ARRAY_SIZE(rt5645_ranges) *
3496 RT5645_PR_SPACING),
3497 .volatile_reg = rt5645_volatile_register,
3498 .readable_reg = rt5645_readable_register,
3499
3500 .cache_type = REGCACHE_RBTREE,
3501 .reg_defaults = rt5650_reg,
3502 .num_reg_defaults = ARRAY_SIZE(rt5650_reg),
3503 .ranges = rt5645_ranges,
3504 .num_ranges = ARRAY_SIZE(rt5645_ranges),
3505};
3506
3507static const struct regmap_config temp_regmap = {
3508 .name="nocache",
3509 .reg_bits = 8,
3510 .val_bits = 16,
3511 .use_single_rw = true,
3512 .max_register = RT5645_VENDOR_ID2 + 1,
3513 .cache_type = REGCACHE_NONE,
3514};
3515
3516static const struct i2c_device_id rt5645_i2c_id[] = {
3517 { "rt5645", 0 },
3518 { "rt5650", 0 },
3519 { }
3520};
3521MODULE_DEVICE_TABLE(i2c, rt5645_i2c_id);
3522
3523#ifdef CONFIG_ACPI
3524static struct acpi_device_id rt5645_acpi_match[] = {
3525 { "10EC5645", 0 },
3526 { "10EC5650", 0 },
3527 {},
3528};
3529MODULE_DEVICE_TABLE(acpi, rt5645_acpi_match);
3530#endif
3531
3295static const struct i2c_device_id rt5645_i2c_id[] = {
3296 { "rt5645", 0 },
3297 { "rt5650", 0 },
3298 { }
3299};
3300MODULE_DEVICE_TABLE(i2c, rt5645_i2c_id);
3301
3302#ifdef CONFIG_ACPI
3303static struct acpi_device_id rt5645_acpi_match[] = {
3304 { "10EC5645", 0 },
3305 { "10EC5650", 0 },
3306 {},
3307};
3308MODULE_DEVICE_TABLE(acpi, rt5645_acpi_match);
3309#endif
3310
3532static struct rt5645_platform_data general_platform_data = {
3311static struct rt5645_platform_data *rt5645_pdata;
3312
3313static struct rt5645_platform_data strago_platform_data = {
3533 .dmic1_data_pin = RT5645_DMIC1_DISABLE,
3534 .dmic2_data_pin = RT5645_DMIC_DATA_IN2P,
3535 .jd_mode = 3,
3536};
3537
3314 .dmic1_data_pin = RT5645_DMIC1_DISABLE,
3315 .dmic2_data_pin = RT5645_DMIC_DATA_IN2P,
3316 .jd_mode = 3,
3317};
3318
3319static int strago_quirk_cb(const struct dmi_system_id *id)
3320{
3321 rt5645_pdata = &strago_platform_data;
3322
3323 return 1;
3324}
3325
3538static const struct dmi_system_id dmi_platform_intel_braswell[] = {
3539 {
3540 .ident = "Intel Strago",
3326static const struct dmi_system_id dmi_platform_intel_braswell[] = {
3327 {
3328 .ident = "Intel Strago",
3329 .callback = strago_quirk_cb,
3541 .matches = {
3542 DMI_MATCH(DMI_PRODUCT_NAME, "Strago"),
3543 },
3544 },
3545 {
3330 .matches = {
3331 DMI_MATCH(DMI_PRODUCT_NAME, "Strago"),
3332 },
3333 },
3334 {
3546 .ident = "Google Chrome",
3335 .ident = "Google Celes",
3336 .callback = strago_quirk_cb,
3547 .matches = {
3337 .matches = {
3548 DMI_MATCH(DMI_SYS_VENDOR, "GOOGLE"),
3338 DMI_MATCH(DMI_PRODUCT_NAME, "Celes"),
3549 },
3550 },
3339 },
3340 },
3341 {
3342 .ident = "Google Ultima",
3343 .callback = strago_quirk_cb,
3344 .matches = {
3345 DMI_MATCH(DMI_PRODUCT_NAME, "Ultima"),
3346 },
3347 },
3348 {
3349 .ident = "Google Reks",
3350 .callback = strago_quirk_cb,
3351 .matches = {
3352 DMI_MATCH(DMI_PRODUCT_NAME, "Reks"),
3353 },
3354 },
3551 { }
3552};
3553
3554static struct rt5645_platform_data buddy_platform_data = {
3555 .dmic1_data_pin = RT5645_DMIC_DATA_GPIO5,
3556 .dmic2_data_pin = RT5645_DMIC_DATA_IN2P,
3557 .jd_mode = 3,
3558 .jd_invert = true,
3559};
3560
3355 { }
3356};
3357
3358static struct rt5645_platform_data buddy_platform_data = {
3359 .dmic1_data_pin = RT5645_DMIC_DATA_GPIO5,
3360 .dmic2_data_pin = RT5645_DMIC_DATA_IN2P,
3361 .jd_mode = 3,
3362 .jd_invert = true,
3363};
3364
3365static int buddy_quirk_cb(const struct dmi_system_id *id)
3366{
3367 rt5645_pdata = &buddy_platform_data;
3368
3369 return 1;
3370}
3371
3561static struct dmi_system_id dmi_platform_intel_broadwell[] = {
3562 {
3563 .ident = "Chrome Buddy",
3372static struct dmi_system_id dmi_platform_intel_broadwell[] = {
3373 {
3374 .ident = "Chrome Buddy",
3375 .callback = buddy_quirk_cb,
3564 .matches = {
3565 DMI_MATCH(DMI_PRODUCT_NAME, "Buddy"),
3566 },
3567 },
3568 { }
3569};
3570
3376 .matches = {
3377 DMI_MATCH(DMI_PRODUCT_NAME, "Buddy"),
3378 },
3379 },
3380 { }
3381};
3382
3571static bool rt5645_check_dp(struct device *dev)
3572{
3573 if (device_property_present(dev, "realtek,in2-differential") ||
3574 device_property_present(dev, "realtek,dmic1-data-pin") ||
3575 device_property_present(dev, "realtek,dmic2-data-pin") ||
3576 device_property_present(dev, "realtek,jd-mode"))
3577 return true;
3578
3383
3579 return false;
3580}
3581
3582static int rt5645_parse_dt(struct rt5645_priv *rt5645, struct device *dev)
3583{
3584 rt5645->pdata.in2_diff = device_property_read_bool(dev,
3585 "realtek,in2-differential");
3586 device_property_read_u32(dev,
3587 "realtek,dmic1-data-pin", &rt5645->pdata.dmic1_data_pin);
3588 device_property_read_u32(dev,
3589 "realtek,dmic2-data-pin", &rt5645->pdata.dmic2_data_pin);

--- 5 unchanged lines hidden (view full) ---

3595
3596static int rt5645_i2c_probe(struct i2c_client *i2c,
3597 const struct i2c_device_id *id)
3598{
3599 struct rt5645_platform_data *pdata = dev_get_platdata(&i2c->dev);
3600 struct rt5645_priv *rt5645;
3601 int ret, i;
3602 unsigned int val;
3384static int rt5645_parse_dt(struct rt5645_priv *rt5645, struct device *dev)
3385{
3386 rt5645->pdata.in2_diff = device_property_read_bool(dev,
3387 "realtek,in2-differential");
3388 device_property_read_u32(dev,
3389 "realtek,dmic1-data-pin", &rt5645->pdata.dmic1_data_pin);
3390 device_property_read_u32(dev,
3391 "realtek,dmic2-data-pin", &rt5645->pdata.dmic2_data_pin);

--- 5 unchanged lines hidden (view full) ---

3397
3398static int rt5645_i2c_probe(struct i2c_client *i2c,
3399 const struct i2c_device_id *id)
3400{
3401 struct rt5645_platform_data *pdata = dev_get_platdata(&i2c->dev);
3402 struct rt5645_priv *rt5645;
3403 int ret, i;
3404 unsigned int val;
3603 struct regmap *regmap;
3604
3605 rt5645 = devm_kzalloc(&i2c->dev, sizeof(struct rt5645_priv),
3606 GFP_KERNEL);
3607 if (rt5645 == NULL)
3608 return -ENOMEM;
3609
3610 rt5645->i2c = i2c;
3611 i2c_set_clientdata(i2c, rt5645);
3612
3613 if (pdata)
3614 rt5645->pdata = *pdata;
3405
3406 rt5645 = devm_kzalloc(&i2c->dev, sizeof(struct rt5645_priv),
3407 GFP_KERNEL);
3408 if (rt5645 == NULL)
3409 return -ENOMEM;
3410
3411 rt5645->i2c = i2c;
3412 i2c_set_clientdata(i2c, rt5645);
3413
3414 if (pdata)
3415 rt5645->pdata = *pdata;
3615 else if (dmi_check_system(dmi_platform_intel_broadwell))
3616 rt5645->pdata = buddy_platform_data;
3617 else if (rt5645_check_dp(&i2c->dev))
3416 else if (dmi_check_system(dmi_platform_intel_braswell) ||
3417 dmi_check_system(dmi_platform_intel_broadwell))
3418 rt5645->pdata = *rt5645_pdata;
3419 else
3618 rt5645_parse_dt(rt5645, &i2c->dev);
3420 rt5645_parse_dt(rt5645, &i2c->dev);
3619 else if (dmi_check_system(dmi_platform_intel_braswell))
3620 rt5645->pdata = general_platform_data;
3621
3622 rt5645->gpiod_hp_det = devm_gpiod_get_optional(&i2c->dev, "hp-detect",
3623 GPIOD_IN);
3624
3625 if (IS_ERR(rt5645->gpiod_hp_det)) {
3626 dev_err(&i2c->dev, "failed to initialize gpiod\n");
3627 return PTR_ERR(rt5645->gpiod_hp_det);
3628 }
3629
3421
3422 rt5645->gpiod_hp_det = devm_gpiod_get_optional(&i2c->dev, "hp-detect",
3423 GPIOD_IN);
3424
3425 if (IS_ERR(rt5645->gpiod_hp_det)) {
3426 dev_err(&i2c->dev, "failed to initialize gpiod\n");
3427 return PTR_ERR(rt5645->gpiod_hp_det);
3428 }
3429
3430 rt5645->regmap = devm_regmap_init_i2c(i2c, &rt5645_regmap);
3431 if (IS_ERR(rt5645->regmap)) {
3432 ret = PTR_ERR(rt5645->regmap);
3433 dev_err(&i2c->dev, "Failed to allocate register map: %d\n",
3434 ret);
3435 return ret;
3436 }
3437
3630 for (i = 0; i < ARRAY_SIZE(rt5645->supplies); i++)
3631 rt5645->supplies[i].supply = rt5645_supply_names[i];
3632
3633 ret = devm_regulator_bulk_get(&i2c->dev,
3634 ARRAY_SIZE(rt5645->supplies),
3635 rt5645->supplies);
3636 if (ret) {
3637 dev_err(&i2c->dev, "Failed to request supplies: %d\n", ret);
3638 return ret;
3639 }
3640
3641 ret = regulator_bulk_enable(ARRAY_SIZE(rt5645->supplies),
3642 rt5645->supplies);
3643 if (ret) {
3644 dev_err(&i2c->dev, "Failed to enable supplies: %d\n", ret);
3645 return ret;
3646 }
3647
3438 for (i = 0; i < ARRAY_SIZE(rt5645->supplies); i++)
3439 rt5645->supplies[i].supply = rt5645_supply_names[i];
3440
3441 ret = devm_regulator_bulk_get(&i2c->dev,
3442 ARRAY_SIZE(rt5645->supplies),
3443 rt5645->supplies);
3444 if (ret) {
3445 dev_err(&i2c->dev, "Failed to request supplies: %d\n", ret);
3446 return ret;
3447 }
3448
3449 ret = regulator_bulk_enable(ARRAY_SIZE(rt5645->supplies),
3450 rt5645->supplies);
3451 if (ret) {
3452 dev_err(&i2c->dev, "Failed to enable supplies: %d\n", ret);
3453 return ret;
3454 }
3455
3648 regmap = devm_regmap_init_i2c(i2c, &temp_regmap);
3649 if (IS_ERR(regmap)) {
3650 ret = PTR_ERR(regmap);
3651 dev_err(&i2c->dev, "Failed to allocate temp register map: %d\n",
3652 ret);
3653 return ret;
3654 }
3655 regmap_read(regmap, RT5645_VENDOR_ID2, &val);
3456 regmap_read(rt5645->regmap, RT5645_VENDOR_ID2, &val);
3656
3657 switch (val) {
3658 case RT5645_DEVICE_ID:
3457
3458 switch (val) {
3459 case RT5645_DEVICE_ID:
3659 rt5645->regmap = devm_regmap_init_i2c(i2c, &rt5645_regmap);
3660 rt5645->codec_type = CODEC_TYPE_RT5645;
3661 break;
3662 case RT5650_DEVICE_ID:
3460 rt5645->codec_type = CODEC_TYPE_RT5645;
3461 break;
3462 case RT5650_DEVICE_ID:
3663 rt5645->regmap = devm_regmap_init_i2c(i2c, &rt5650_regmap);
3664 rt5645->codec_type = CODEC_TYPE_RT5650;
3665 break;
3666 default:
3667 dev_err(&i2c->dev,
3668 "Device with ID register %#x is not rt5645 or rt5650\n",
3669 val);
3670 ret = -ENODEV;
3671 goto err_enable;
3672 }
3673
3463 rt5645->codec_type = CODEC_TYPE_RT5650;
3464 break;
3465 default:
3466 dev_err(&i2c->dev,
3467 "Device with ID register %#x is not rt5645 or rt5650\n",
3468 val);
3469 ret = -ENODEV;
3470 goto err_enable;
3471 }
3472
3674 if (IS_ERR(rt5645->regmap)) {
3675 ret = PTR_ERR(rt5645->regmap);
3676 dev_err(&i2c->dev, "Failed to allocate register map: %d\n",
3677 ret);
3678 return ret;
3679 }
3680
3681 regmap_write(rt5645->regmap, RT5645_RESET, 0);
3682
3683 ret = regmap_register_patch(rt5645->regmap, init_list,
3684 ARRAY_SIZE(init_list));
3685 if (ret != 0)
3686 dev_warn(&i2c->dev, "Failed to apply regmap patch: %d\n", ret);
3687
3688 if (rt5645->codec_type == CODEC_TYPE_RT5650) {

--- 104 unchanged lines hidden (view full) ---

3793 RT5645_JD1_MODE_MASK,
3794 RT5645_JD1_MODE_2);
3795 break;
3796 default:
3797 break;
3798 }
3799 }
3800
3473 regmap_write(rt5645->regmap, RT5645_RESET, 0);
3474
3475 ret = regmap_register_patch(rt5645->regmap, init_list,
3476 ARRAY_SIZE(init_list));
3477 if (ret != 0)
3478 dev_warn(&i2c->dev, "Failed to apply regmap patch: %d\n", ret);
3479
3480 if (rt5645->codec_type == CODEC_TYPE_RT5650) {

--- 104 unchanged lines hidden (view full) ---

3585 RT5645_JD1_MODE_MASK,
3586 RT5645_JD1_MODE_2);
3587 break;
3588 default:
3589 break;
3590 }
3591 }
3592
3801 if (rt5645->pdata.jd_invert) {
3802 regmap_update_bits(rt5645->regmap, RT5645_IRQ_CTRL2,
3803 RT5645_JD_1_1_MASK, RT5645_JD_1_1_INV);
3804 setup_timer(&rt5645->btn_check_timer,
3805 rt5645_btn_check_callback, (unsigned long)rt5645);
3806 }
3807
3808 INIT_DELAYED_WORK(&rt5645->jack_detect_work, rt5645_jack_detect_work);
3593 INIT_DELAYED_WORK(&rt5645->jack_detect_work, rt5645_jack_detect_work);
3809 INIT_DELAYED_WORK(&rt5645->rcclock_work, rt5645_rcclock_work);
3810
3811 if (rt5645->i2c->irq) {
3812 ret = request_threaded_irq(rt5645->i2c->irq, NULL, rt5645_irq,
3813 IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING
3814 | IRQF_ONESHOT, "rt5645", rt5645);
3815 if (ret) {
3816 dev_err(&i2c->dev, "Failed to reguest IRQ: %d\n", ret);
3817 goto err_enable;

--- 18 unchanged lines hidden (view full) ---

3836static int rt5645_i2c_remove(struct i2c_client *i2c)
3837{
3838 struct rt5645_priv *rt5645 = i2c_get_clientdata(i2c);
3839
3840 if (i2c->irq)
3841 free_irq(i2c->irq, rt5645);
3842
3843 cancel_delayed_work_sync(&rt5645->jack_detect_work);
3594
3595 if (rt5645->i2c->irq) {
3596 ret = request_threaded_irq(rt5645->i2c->irq, NULL, rt5645_irq,
3597 IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING
3598 | IRQF_ONESHOT, "rt5645", rt5645);
3599 if (ret) {
3600 dev_err(&i2c->dev, "Failed to reguest IRQ: %d\n", ret);
3601 goto err_enable;

--- 18 unchanged lines hidden (view full) ---

3620static int rt5645_i2c_remove(struct i2c_client *i2c)
3621{
3622 struct rt5645_priv *rt5645 = i2c_get_clientdata(i2c);
3623
3624 if (i2c->irq)
3625 free_irq(i2c->irq, rt5645);
3626
3627 cancel_delayed_work_sync(&rt5645->jack_detect_work);
3844 cancel_delayed_work_sync(&rt5645->rcclock_work);
3845
3846 snd_soc_unregister_codec(&i2c->dev);
3847 regulator_bulk_disable(ARRAY_SIZE(rt5645->supplies), rt5645->supplies);
3848
3849 return 0;
3850}
3851
3852static void rt5645_i2c_shutdown(struct i2c_client *i2c)

--- 28 unchanged lines hidden --- 		3628
3629 snd_soc_unregister_codec(&i2c->dev);
3630 regulator_bulk_disable(ARRAY_SIZE(rt5645->supplies), rt5645->supplies);
3631
3632 return 0;
3633}
3634
3635static void rt5645_i2c_shutdown(struct i2c_client *i2c)

--- 28 unchanged lines hidden ---