ASoC: ac108: Adds ac108 codec and machine code
[platform/kernel/linux-rpi.git] / sound / soc / codecs / ac101.c
1 /*
2  * ac101.c
3  *
4  * (C) Copyright 2017-2018
5  * Seeed Technology Co., Ltd. <www.seeedstudio.com>
6  *
7  * PeterYang <linsheng.yang@seeed.cc>
8  *
9  * (C) Copyright 2014-2017
10  * Reuuimlla Technology Co., Ltd. <www.reuuimllatech.com>
11  *
12  * huangxin <huangxin@Reuuimllatech.com>
13  * liushaohua <liushaohua@allwinnertech.com>
14  *
15  * X-Powers AC101 codec driver
16  *
17  * This program is free software; you can redistribute it and/or
18  * modify it under the terms of the GNU General Public License as
19  * published by the Free Software Foundation; either version 2 of
20  * the License, or (at your option) any later version.
21  *
22  */
23
24 /* #undef AC101_DEBG
25  * use 'make DEBUG=1' to enable debugging
26  */
27 #include <linux/module.h>
28 #include <sound/pcm.h>
29 #include <sound/pcm_params.h>
30 #include <sound/soc.h>
31 #include <sound/soc-dapm.h>
32 #include <sound/tlv.h>
33 #include <linux/i2c.h>
34 #include <linux/irq.h>
35 #include <linux/workqueue.h>
36 #include <linux/clk.h>
37 #include <linux/gpio/consumer.h>
38 #include <linux/regmap.h>
39 #include <linux/input.h>
40 #include <linux/delay.h>
41 #include "ac101_regs.h"
42 #include "ac10x.h"
43
44 /*
45  * *** To sync channels ***
46  *
47  * 1. disable clock in codec   hw_params()
48  * 2. clear   fifo  in bcm2835 hw_params()
49  * 3. clear   fifo  in bcm2385 prepare()
50  * 4. enable  RX    in bcm2835 trigger()
51  * 5. enable  clock in machine trigger()
52  */
53
54 /*Default initialize configuration*/
55 static bool speaker_double_used = 1;
56 static int double_speaker_val   = 0x1B;
57 static int single_speaker_val   = 0x19;
58 static int headset_val          = 0x3B;
59 static int mainmic_val          = 0x4;
60 static int headsetmic_val       = 0x4;
61 static bool dmic_used           = 0;
62 static int adc_digital_val      = 0xb0b0;
63 static bool drc_used            = false;
64
65 #define AC101_RATES  (SNDRV_PCM_RATE_8000_96000 &               \
66                 ~(SNDRV_PCM_RATE_32000 | SNDRV_PCM_RATE_64000 | \
67                 SNDRV_PCM_RATE_88200))
68 #define AC101_FORMATS (/*SNDRV_PCM_FMTBIT_S16_LE | \
69                         SNDRV_PCM_FMTBIT_S24_LE |*/     \
70                         SNDRV_PCM_FMTBIT_S32_LE | \
71                         0)
72
73 static struct ac10x_priv* static_ac10x;
74
75
76 int ac101_read(struct snd_soc_codec *codec, unsigned reg) {
77         struct ac10x_priv *ac10x = snd_soc_codec_get_drvdata(codec);
78         int r, v = 0;
79
80         if ((r = regmap_read(ac10x->regmap101, reg, &v)) < 0) {
81                 dev_err(codec->dev, "read reg %02X fail\n",
82                          reg);
83                 return r;
84         }
85         return v;
86 }
87
88 int ac101_write(struct snd_soc_codec *codec, unsigned reg, unsigned val) {
89         struct ac10x_priv *ac10x = snd_soc_codec_get_drvdata(codec);
90         int v;
91
92         v = regmap_write(ac10x->regmap101, reg, val);
93         return v;
94 }
95
96 int ac101_update_bits(struct snd_soc_codec *codec, unsigned reg,
97                         unsigned mask, unsigned value
98 ) {
99         struct ac10x_priv *ac10x = snd_soc_codec_get_drvdata(codec);
100         int v;
101
102         v = regmap_update_bits(ac10x->regmap101, reg, mask, value);
103         return v;
104 }
105
106
107
108 #ifdef CONFIG_AC101_SWITCH_DETECT
109 /******************************************************************************/
110 /********************************switch****************************************/
111 /******************************************************************************/
112 #define KEY_HEADSETHOOK         226             /* key define */
113 #define HEADSET_FILTER_CNT      (10)
114
115 /*
116  * switch_hw_config:config the 53 codec register
117  */
118 static void switch_hw_config(struct snd_soc_codec *codec)
119 {
120         int r;
121
122         AC101_DBG();
123
124         /*HMIC/MMIC BIAS voltage level select:2.5v*/
125         ac101_update_bits(codec, OMIXER_BST1_CTRL, (0xf<<BIASVOLTAGE), (0xf<<BIASVOLTAGE));
126         /*debounce when Key down or keyup*/
127         ac101_update_bits(codec, HMIC_CTRL1, (0xf<<HMIC_M), (0x0<<HMIC_M));
128         /*debounce when earphone plugin or pullout*/
129         ac101_update_bits(codec, HMIC_CTRL1, (0xf<<HMIC_N), (0x0<<HMIC_N));
130         /*Down Sample Setting Select: Downby 4,32Hz*/
131         ac101_update_bits(codec, HMIC_CTRL2, (0x3<<HMIC_SAMPLE_SELECT), (0x02<<HMIC_SAMPLE_SELECT));
132         /*Hmic_th2 for detecting Keydown or Keyup.*/
133         ac101_update_bits(codec, HMIC_CTRL2, (0x1f<<HMIC_TH2), (0x8<<HMIC_TH2));
134         /*Hmic_th1[4:0],detecting eraphone plugin or pullout*/
135         ac101_update_bits(codec, HMIC_CTRL2, (0x1f<<HMIC_TH1), (0x1<<HMIC_TH1));
136         /*Headset microphone BIAS working mode: when HBIASEN = 1 */
137         ac101_update_bits(codec, ADC_APC_CTRL, (0x1<<HBIASMOD), (0x1<<HBIASMOD));
138         /*Headset microphone BIAS Enable*/
139         ac101_update_bits(codec, ADC_APC_CTRL, (0x1<<HBIASEN), (0x1<<HBIASEN));
140         /*Headset microphone BIAS Current sensor & ADC Enable*/
141         ac101_update_bits(codec, ADC_APC_CTRL, (0x1<<HBIASADCEN), (0x1<<HBIASADCEN));
142         /*Earphone Plugin/out Irq Enable*/
143         ac101_update_bits(codec, HMIC_CTRL1, (0x1<<HMIC_PULLOUT_IRQ), (0x1<<HMIC_PULLOUT_IRQ));
144         ac101_update_bits(codec, HMIC_CTRL1, (0x1<<HMIC_PLUGIN_IRQ), (0x1<<HMIC_PLUGIN_IRQ));
145
146         /*Hmic KeyUp/key down Irq Enable*/
147         ac101_update_bits(codec, HMIC_CTRL1, (0x1<<HMIC_KEYDOWN_IRQ), (0x1<<HMIC_KEYDOWN_IRQ));
148         ac101_update_bits(codec, HMIC_CTRL1, (0x1<<HMIC_KEYUP_IRQ), (0x1<<HMIC_KEYUP_IRQ));
149
150         /*headphone calibration clock frequency select*/
151         ac101_update_bits(codec, SPKOUT_CTRL, (0x7<<HPCALICKS), (0x7<<HPCALICKS));
152
153         /*clear hmic interrupt */
154         r = HMIC_PEND_ALL;
155         ac101_write(codec, HMIC_STS, r);
156
157         return;
158 }
159
160 /*
161  * switch_status_update: update the switch state.
162  */
163 static void switch_status_update(struct ac10x_priv *ac10x)
164 {
165         AC101_DBG("ac10x->state:%d\n", ac10x->state);
166
167         input_report_switch(ac10x->inpdev, SW_HEADPHONE_INSERT, ac10x->state);
168         input_sync(ac10x->inpdev);
169         return;
170 }
171
172 /*
173  * work_cb_clear_irq: clear audiocodec pending and Record the interrupt.
174  */
175 static void work_cb_clear_irq(struct work_struct *work)
176 {
177         int reg_val = 0;
178         struct ac10x_priv *ac10x = container_of(work, struct ac10x_priv, work_clear_irq);
179         struct snd_soc_codec *codec = ac10x->codec;
180
181         ac10x->irq_cntr++;
182
183         reg_val = ac101_read(codec, HMIC_STS);
184         if (BIT(HMIC_PULLOUT_PEND) & reg_val) {
185                 ac10x->pullout_cntr++;
186                 AC101_DBG("ac10x->pullout_cntr: %d\n", ac10x->pullout_cntr);
187         }
188
189         reg_val |= HMIC_PEND_ALL;
190         ac101_write(codec, HMIC_STS, reg_val);
191
192         reg_val = ac101_read(codec, HMIC_STS);
193         if ((reg_val & HMIC_PEND_ALL) != 0){
194                 reg_val |= HMIC_PEND_ALL;
195                 ac101_write(codec, HMIC_STS, reg_val);
196         }
197
198         if (cancel_work_sync(&ac10x->work_switch) != 0) {
199                 ac10x->irq_cntr--;
200         }
201
202         if (0 == schedule_work(&ac10x->work_switch)) {
203                 ac10x->irq_cntr--;
204                 AC101_DBG("[work_cb_clear_irq] add work struct failed!\n");
205         }
206 }
207
208 enum {
209         HBIAS_LEVEL_1 = 0x02,
210         HBIAS_LEVEL_2 = 0x0B,
211         HBIAS_LEVEL_3 = 0x13,
212         HBIAS_LEVEL_4 = 0x17,
213         HBIAS_LEVEL_5 = 0x19,
214 };
215
216 static int __ac101_get_hmic_data(struct snd_soc_codec *codec) {
217         #ifdef AC101_DEBG
218         static long counter;
219         #endif
220         int r, d;
221
222         d = GET_HMIC_DATA(ac101_read(codec, HMIC_STS));
223
224         r = 0x1 << HMIC_DATA_PEND;
225         ac101_write(codec, HMIC_STS, r);
226
227         /* prevent i2c accessing too frequently */
228         usleep_range(1500, 3000);
229
230         AC101_DBG("HMIC_DATA(%3ld): %02X\n", counter++, d);
231         return d;
232 }
233
234 /*
235  * work_cb_earphone_switch: judge the status of the headphone
236  */
237 static void work_cb_earphone_switch(struct work_struct *work)
238 {
239         struct ac10x_priv *ac10x = container_of(work, struct ac10x_priv, work_switch);
240         struct snd_soc_codec *codec = ac10x->codec;
241
242         static int hook_flag1 = 0, hook_flag2 = 0;
243         static int KEY_VOLUME_FLAG = 0;
244
245         unsigned filter_buf = 0;
246         int filt_index = 0;
247         int t = 0;
248
249         ac10x->irq_cntr--;
250
251         /* read HMIC_DATA */
252         t = __ac101_get_hmic_data(codec);
253
254         if ((t >= HBIAS_LEVEL_2) && (ac10x->mode == FOUR_HEADPHONE_PLUGIN)) {
255                 t = __ac101_get_hmic_data(codec);
256
257                 if (t >= HBIAS_LEVEL_5){
258                         msleep(150);
259                         t = __ac101_get_hmic_data(codec);
260                         if (((t < HBIAS_LEVEL_2 && t >= HBIAS_LEVEL_1 - 1) || t >= HBIAS_LEVEL_5)
261                         && (ac10x->pullout_cntr == 0)) {
262                                 input_report_key(ac10x->inpdev, KEY_HEADSETHOOK, 1);
263                                 input_sync(ac10x->inpdev);
264
265                                 AC101_DBG("KEY_HEADSETHOOK1\n");
266
267                                 if (hook_flag1 != hook_flag2)
268                                         hook_flag1 = hook_flag2 = 0;
269                                 hook_flag1++;
270                         }
271                         if (ac10x->pullout_cntr)
272                                 ac10x->pullout_cntr--;
273                 } else if (t >= HBIAS_LEVEL_4) {
274                         msleep(80);
275                         t = __ac101_get_hmic_data(codec);
276                         if (t < HBIAS_LEVEL_5 && t >= HBIAS_LEVEL_4 && (ac10x->pullout_cntr == 0)) {
277                                 KEY_VOLUME_FLAG = 1;
278                                 input_report_key(ac10x->inpdev, KEY_VOLUMEUP, 1);
279                                 input_sync(ac10x->inpdev);
280                                 input_report_key(ac10x->inpdev, KEY_VOLUMEUP, 0);
281                                 input_sync(ac10x->inpdev);
282
283                                 AC101_DBG("HMIC_DATA: %d KEY_VOLUMEUP\n", t);
284                         }
285                         if (ac10x->pullout_cntr)
286                                 ac10x->pullout_cntr--;
287                 } else if (t >= HBIAS_LEVEL_3){
288                         msleep(80);
289                         t = __ac101_get_hmic_data(codec);
290                         if (t < HBIAS_LEVEL_4 && t >= HBIAS_LEVEL_3  && (ac10x->pullout_cntr == 0)){
291                                 KEY_VOLUME_FLAG = 1;
292                                 input_report_key(ac10x->inpdev, KEY_VOLUMEDOWN, 1);
293                                 input_sync(ac10x->inpdev);
294                                 input_report_key(ac10x->inpdev, KEY_VOLUMEDOWN, 0);
295                                 input_sync(ac10x->inpdev);
296                                 AC101_DBG("KEY_VOLUMEDOWN\n");
297                         }
298                         if (ac10x->pullout_cntr)
299                                 ac10x->pullout_cntr--;
300                 }
301         } else if ((t < HBIAS_LEVEL_2 && t >= HBIAS_LEVEL_1) && (ac10x->mode == FOUR_HEADPHONE_PLUGIN)) {
302                 t = __ac101_get_hmic_data(codec);
303                 if (t < HBIAS_LEVEL_2 && t >= HBIAS_LEVEL_1) {
304                         if (KEY_VOLUME_FLAG) {
305                                 KEY_VOLUME_FLAG = 0;
306                         }
307                         if (hook_flag1 == (++hook_flag2)) {
308                                 hook_flag1 = hook_flag2 = 0;
309                                 input_report_key(ac10x->inpdev, KEY_HEADSETHOOK, 0);
310                                 input_sync(ac10x->inpdev);
311
312                                 AC101_DBG("KEY_HEADSETHOOK0\n");
313                         }
314                 }
315         } else {
316                 while (ac10x->irq_cntr == 0 && ac10x->irq != 0) {
317                         msleep(20);
318
319                         t = __ac101_get_hmic_data(codec);
320
321                         if (filt_index <= HEADSET_FILTER_CNT) {
322                                 if (filt_index++ == 0) {
323                                         filter_buf = t;
324                                 } else if (filter_buf != t) {
325                                         filt_index = 0;
326                                 }
327                                 continue;
328                         }
329
330                         filt_index = 0;
331                         if (filter_buf >= HBIAS_LEVEL_2) {
332                                 ac10x->mode = THREE_HEADPHONE_PLUGIN;
333                                 ac10x->state = 2;
334                         } else if (filter_buf >= HBIAS_LEVEL_1 - 1) {
335                                 ac10x->mode = FOUR_HEADPHONE_PLUGIN;
336                                 ac10x->state = 1;
337                         } else {
338                                 ac10x->mode = HEADPHONE_IDLE;
339                                 ac10x->state = 0;
340                         }
341                         switch_status_update(ac10x);
342                         ac10x->pullout_cntr = 0;
343                         break;
344                 }
345         }
346 }
347
348 /*
349  * audio_hmic_irq:  the interrupt handlers
350  */
351 static irqreturn_t audio_hmic_irq(int irq, void *para)
352 {
353         struct ac10x_priv *ac10x = (struct ac10x_priv *)para;
354         if (ac10x == NULL) {
355                 return -EINVAL;
356         }
357
358         if (0 == schedule_work(&ac10x->work_clear_irq)){
359                 AC101_DBG("[audio_hmic_irq] work already in queue_codec_irq, adding failed!\n");
360         }
361         return IRQ_HANDLED;
362 }
363
364 static int ac101_switch_probe(struct ac10x_priv *ac10x) {
365         struct i2c_client *i2c = ac10x->i2c101;
366         long ret;
367
368         ac10x->gpiod_irq = devm_gpiod_get_optional(&i2c->dev, "switch-irq", GPIOD_IN);
369         if (IS_ERR(ac10x->gpiod_irq)) {
370                 ac10x->gpiod_irq = NULL;
371                 dev_err(&i2c->dev, "failed get switch-irq in device tree\n");
372                 goto _err_irq;
373         }
374
375         gpiod_direction_input(ac10x->gpiod_irq);
376
377         ac10x->irq = gpiod_to_irq(ac10x->gpiod_irq);
378         if (IS_ERR_VALUE(ac10x->irq)) {
379                 pr_info("[ac101] map gpio to irq failed, errno = %ld\n", ac10x->irq);
380                 ac10x->irq = 0;
381                 goto _err_irq;
382         }
383
384         /* request irq, set irq type to falling edge trigger */
385         ret = devm_request_irq(ac10x->codec->dev, ac10x->irq, audio_hmic_irq, IRQF_TRIGGER_FALLING, "SWTICH_EINT", ac10x);
386         if (IS_ERR_VALUE(ret)) {
387                 pr_info("[ac101] request virq %ld failed, errno = %ld\n", ac10x->irq, ret);
388                 goto _err_irq;
389         }
390
391         ac10x->mode = HEADPHONE_IDLE;
392         ac10x->state = -1;
393
394         /*use for judge the state of switch*/
395         INIT_WORK(&ac10x->work_switch, work_cb_earphone_switch);
396         INIT_WORK(&ac10x->work_clear_irq, work_cb_clear_irq);
397
398         /********************create input device************************/
399         ac10x->inpdev = devm_input_allocate_device(ac10x->codec->dev);
400         if (!ac10x->inpdev) {
401                 AC101_DBG("input_allocate_device: not enough memory for input device\n");
402                 ret = -ENOMEM;
403                 goto _err_input_allocate_device;
404         }
405
406         ac10x->inpdev->name          = "seed-voicecard-headset";
407         ac10x->inpdev->phys          = dev_name(ac10x->codec->dev);
408         ac10x->inpdev->id.bustype    = BUS_I2C;
409         ac10x->inpdev->dev.parent    = ac10x->codec->dev;
410         input_set_drvdata(ac10x->inpdev, ac10x->codec);
411
412         ac10x->inpdev->evbit[0] = BIT_MASK(EV_KEY) | BIT(EV_SW);
413
414         set_bit(KEY_HEADSETHOOK, ac10x->inpdev->keybit);
415         set_bit(KEY_VOLUMEUP,    ac10x->inpdev->keybit);
416         set_bit(KEY_VOLUMEDOWN,  ac10x->inpdev->keybit);
417         input_set_capability(ac10x->inpdev, EV_SW, SW_HEADPHONE_INSERT);
418
419         ret = input_register_device(ac10x->inpdev);
420         if (ret) {
421                 AC101_DBG("input_register_device: input_register_device failed\n");
422                 goto _err_input_register_device;
423         }
424
425         /* the first headset state checking */
426         switch_hw_config(ac10x->codec);
427         ac10x->irq_cntr = 1;
428         schedule_work(&ac10x->work_switch);
429
430         return 0;
431
432 _err_input_register_device:
433 _err_input_allocate_device:
434
435         if (ac10x->irq) {
436                 devm_free_irq(&i2c->dev, ac10x->irq, ac10x);
437                 ac10x->irq = 0;
438         }
439 _err_irq:
440         return ret;
441 }
442 /******************************************************************************/
443 /********************************switch****************************************/
444 /******************************************************************************/
445 #endif
446
447
448
449 void drc_config(struct snd_soc_codec *codec)
450 {
451         int reg_val;
452         reg_val = ac101_read(codec, 0xa3);
453         reg_val &= ~(0x7ff<<0);
454         reg_val |= 1<<0;
455         ac101_write(codec, 0xa3, reg_val);
456         ac101_write(codec, 0xa4, 0x2baf);
457
458         reg_val = ac101_read(codec, 0xa5);
459         reg_val &= ~(0x7ff<<0);
460         reg_val |= 1<<0;
461         ac101_write(codec, 0xa5, reg_val);
462         ac101_write(codec, 0xa6, 0x2baf);
463
464         reg_val = ac101_read(codec, 0xa7);
465         reg_val &= ~(0x7ff<<0);
466         ac101_write(codec, 0xa7, reg_val);
467         ac101_write(codec, 0xa8, 0x44a);
468
469         reg_val = ac101_read(codec, 0xa9);
470         reg_val &= ~(0x7ff<<0);
471         ac101_write(codec, 0xa9, reg_val);
472         ac101_write(codec, 0xaa, 0x1e06);
473
474         reg_val = ac101_read(codec, 0xab);
475         reg_val &= ~(0x7ff<<0);
476         reg_val |= (0x352<<0);
477         ac101_write(codec, 0xab, reg_val);
478         ac101_write(codec, 0xac, 0x6910);
479
480         reg_val = ac101_read(codec, 0xad);
481         reg_val &= ~(0x7ff<<0);
482         reg_val |= (0x77a<<0);
483         ac101_write(codec, 0xad, reg_val);
484         ac101_write(codec, 0xae, 0xaaaa);
485
486         reg_val = ac101_read(codec, 0xaf);
487         reg_val &= ~(0x7ff<<0);
488         reg_val |= (0x2de<<0);
489         ac101_write(codec, 0xaf, reg_val);
490         ac101_write(codec, 0xb0, 0xc982);
491
492         ac101_write(codec, 0x16, 0x9f9f);
493
494 }
495
496 void drc_enable(struct snd_soc_codec *codec,bool on)
497 {
498         int reg_val;
499         if (on) {
500                 ac101_write(codec, 0xb5, 0xA080);
501                 reg_val = ac101_read(codec, MOD_CLK_ENA);
502                 reg_val |= (0x1<<6);
503                 ac101_write(codec, MOD_CLK_ENA, reg_val);
504                 reg_val = ac101_read(codec, MOD_RST_CTRL);
505                 reg_val |= (0x1<<6);
506                 ac101_write(codec, MOD_RST_CTRL, reg_val);
507
508                 reg_val = ac101_read(codec, 0xa0);
509                 reg_val |= (0x7<<0);
510                 ac101_write(codec, 0xa0, reg_val);
511         } else {
512                 ac101_write(codec, 0xb5, 0x0);
513                 reg_val = ac101_read(codec, MOD_CLK_ENA);
514                 reg_val &= ~(0x1<<6);
515                 ac101_write(codec, MOD_CLK_ENA, reg_val);
516                 reg_val = ac101_read(codec, MOD_RST_CTRL);
517                 reg_val &= ~(0x1<<6);
518                 ac101_write(codec, MOD_RST_CTRL, reg_val);
519
520                 reg_val = ac101_read(codec, 0xa0);
521                 reg_val &= ~(0x7<<0);
522                 ac101_write(codec, 0xa0, reg_val);
523         }
524 }
525
526 void set_configuration(struct snd_soc_codec *codec)
527 {
528         if (speaker_double_used) {
529                 ac101_update_bits(codec, SPKOUT_CTRL, (0x1f<<SPK_VOL), (double_speaker_val<<SPK_VOL));
530         } else {
531                 ac101_update_bits(codec, SPKOUT_CTRL, (0x1f<<SPK_VOL), (single_speaker_val<<SPK_VOL));
532         }
533         ac101_update_bits(codec, HPOUT_CTRL, (0x3f<<HP_VOL), (headset_val<<HP_VOL));
534         ac101_update_bits(codec, ADC_SRCBST_CTRL, (0x7<<ADC_MIC1G), (mainmic_val<<ADC_MIC1G));
535         ac101_update_bits(codec, ADC_SRCBST_CTRL, (0x7<<ADC_MIC2G), (headsetmic_val<<ADC_MIC2G));
536         if (dmic_used) {
537                 ac101_write(codec, ADC_VOL_CTRL, adc_digital_val);
538         }
539         if (drc_used) {
540                 drc_config(codec);
541         }
542         /*headphone calibration clock frequency select*/
543         ac101_update_bits(codec, SPKOUT_CTRL, (0x7<<HPCALICKS), (0x7<<HPCALICKS));
544
545         /* I2S1 DAC Timeslot 0 data <- I2S1 DAC channel 0 */
546         // "AIF1IN0L Mux" <= "AIF1DACL"
547         // "AIF1IN0R Mux" <= "AIF1DACR"
548         ac101_update_bits(codec, AIF1_DACDAT_CTRL, 0x3 << AIF1_DA0L_SRC, 0x0 << AIF1_DA0L_SRC);
549         ac101_update_bits(codec, AIF1_DACDAT_CTRL, 0x3 << AIF1_DA0R_SRC, 0x0 << AIF1_DA0R_SRC);
550         /* Timeslot 0 Left & Right Channel enable */
551         ac101_update_bits(codec, AIF1_DACDAT_CTRL, 0x3 << AIF1_DA0R_ENA, 0x3 << AIF1_DA0R_ENA);
552
553         /* DAC Digital Mixer Source Select <- I2S1 DA0 */
554         // "DACL Mixer" += "AIF1IN0L Mux"
555         // "DACR Mixer" += "AIF1IN0R Mux"
556         ac101_update_bits(codec, DAC_MXR_SRC, 0xF << DACL_MXR_ADCL, 0x8 << DACL_MXR_ADCL);
557         ac101_update_bits(codec, DAC_MXR_SRC, 0xF << DACR_MXR_ADCR, 0x8 << DACR_MXR_ADCR);
558         /* Internal DAC Analog Left & Right Channel enable */
559         ac101_update_bits(codec, OMIXER_DACA_CTRL, 0x3 << DACALEN, 0x3 << DACALEN);
560
561         /* Output Mixer Source Select */
562         // "Left Output Mixer"  += "DACL Mixer"
563         // "Right Output Mixer" += "DACR Mixer"
564         ac101_update_bits(codec, OMIXER_SR, 0x1 << LMIXMUTEDACL, 0x1 << LMIXMUTEDACL);
565         ac101_update_bits(codec, OMIXER_SR, 0x1 << RMIXMUTEDACR, 0x1 << RMIXMUTEDACR);
566         /* Left & Right Analog Output Mixer enable */
567         ac101_update_bits(codec, OMIXER_DACA_CTRL, 0x3 << LMIXEN, 0x3 << LMIXEN);
568
569         /* Headphone Ouput Control */ 
570         // "HP_R Mux" <= "DACR Mixer"
571         // "HP_L Mux" <= "DACL Mixer"
572         ac101_update_bits(codec, HPOUT_CTRL, 0x1 << LHPS, 0x0 << LHPS);
573         ac101_update_bits(codec, HPOUT_CTRL, 0x1 << RHPS, 0x0 << RHPS);
574
575         /* Speaker Output Control */
576         // "SPK_L Mux" <= "SPK_LR Adder"
577         // "SPK_R Mux" <= "SPK_LR Adder"
578         ac101_update_bits(codec, SPKOUT_CTRL, (0x1 << LSPKS) | (0x1 << RSPKS), (0x1 << LSPKS) | (0x1 << RSPKS));
579         /* Enable Left & Right Speaker */
580         ac101_update_bits(codec, SPKOUT_CTRL, (0x1 << LSPK_EN) | (0x1 << RSPK_EN), (0x1 << LSPK_EN) | (0x1 << RSPK_EN));
581         return;
582 }
583
584 static int late_enable_dac(struct snd_soc_codec* codec, int event) {
585         struct ac10x_priv *ac10x = snd_soc_codec_get_drvdata(codec);
586
587         mutex_lock(&ac10x->dac_mutex);
588         switch (event) {
589         case SND_SOC_DAPM_PRE_PMU:
590                 AC101_DBG();
591                 if (ac10x->dac_enable == 0){
592                         /*enable dac module clk*/
593                         ac101_update_bits(codec, MOD_CLK_ENA, (0x1<<MOD_CLK_DAC_DIG), (0x1<<MOD_CLK_DAC_DIG));
594                         ac101_update_bits(codec, MOD_RST_CTRL, (0x1<<MOD_RESET_DAC_DIG), (0x1<<MOD_RESET_DAC_DIG));
595                         ac101_update_bits(codec, DAC_DIG_CTRL, (0x1<<ENDA), (0x1<<ENDA));
596                         ac101_update_bits(codec, DAC_DIG_CTRL, (0x1<<ENHPF),(0x1<<ENHPF));
597                 }
598                 ac10x->dac_enable++;
599                 break;
600         case SND_SOC_DAPM_POST_PMD:
601                 if (ac10x->dac_enable != 0){
602                         ac10x->dac_enable = 0;
603
604                         ac101_update_bits(codec, DAC_DIG_CTRL, (0x1<<ENHPF),(0x0<<ENHPF));
605                         ac101_update_bits(codec, DAC_DIG_CTRL, (0x1<<ENDA), (0x0<<ENDA));
606                         /*disable dac module clk*/
607                         ac101_update_bits(codec, MOD_CLK_ENA, (0x1<<MOD_CLK_DAC_DIG), (0x0<<MOD_CLK_DAC_DIG));
608                         ac101_update_bits(codec, MOD_RST_CTRL, (0x1<<MOD_RESET_DAC_DIG), (0x0<<MOD_RESET_DAC_DIG));
609                 }
610                 break;
611         }
612         mutex_unlock(&ac10x->dac_mutex);
613         return 0;
614 }
615
616 static int ac101_headphone_event(struct snd_soc_codec* codec, int event) {
617         switch (event) {
618         case SND_SOC_DAPM_POST_PMU:
619                 /*open*/
620                 AC101_DBG("post:open\n");
621                 ac101_update_bits(codec, OMIXER_DACA_CTRL, (0xf<<HPOUTPUTENABLE), (0xf<<HPOUTPUTENABLE));
622                 msleep(10);
623                 ac101_update_bits(codec, HPOUT_CTRL, (0x1<<HPPA_EN), (0x1<<HPPA_EN));
624                 ac101_update_bits(codec, HPOUT_CTRL, (0x3<<LHPPA_MUTE), (0x3<<LHPPA_MUTE));
625                 break;
626         case SND_SOC_DAPM_PRE_PMD:
627                 /*close*/
628                 AC101_DBG("pre:close\n");
629                 ac101_update_bits(codec, HPOUT_CTRL, (0x3<<LHPPA_MUTE), (0x0<<LHPPA_MUTE));
630                 msleep(10);
631                 ac101_update_bits(codec, OMIXER_DACA_CTRL, (0xf<<HPOUTPUTENABLE), (0x0<<HPOUTPUTENABLE));
632                 ac101_update_bits(codec, HPOUT_CTRL, (0x1<<HPPA_EN), (0x0<<HPPA_EN));
633                 break;
634         }
635         return 0;
636 }
637
638 static int ac101_sysclk_started(void) {
639         int reg_val;
640
641         reg_val = ac101_read(static_ac10x->codec, SYSCLK_CTRL);
642         return (reg_val & (0x1<<SYSCLK_ENA));
643 }
644
645 static int ac101_aif1clk(struct snd_soc_codec* codec, int event, int quick) {
646         struct ac10x_priv *ac10x = snd_soc_codec_get_drvdata(codec);
647         int ret = 0;
648
649         switch (event) {
650         case SND_SOC_DAPM_PRE_PMU:
651                 if (ac10x->aif1_clken == 0){
652                         ret = ac101_update_bits(codec, SYSCLK_CTRL, (0x1<<AIF1CLK_ENA), (0x1<<AIF1CLK_ENA));
653                         if(!quick || _MASTER_MULTI_CODEC != _MASTER_AC101) {
654                                 /* enable aif1clk & sysclk */
655                                 ret = ret || ac101_update_bits(codec, MOD_CLK_ENA, (0x1<<MOD_CLK_AIF1), (0x1<<MOD_CLK_AIF1));
656                                 ret = ret || ac101_update_bits(codec, MOD_RST_CTRL, (0x1<<MOD_RESET_AIF1), (0x1<<MOD_RESET_AIF1));
657                         }
658                         ret = ret || ac101_update_bits(codec, SYSCLK_CTRL, (0x1<<SYSCLK_ENA), (0x1<<SYSCLK_ENA));
659
660                         if (ret) {
661                                 AC101_DBG("start sysclk failed\n");
662                         } else {
663                                 AC101_DBG("hw sysclk enable\n");
664                                 ac10x->aif1_clken++;
665                         }
666                 }
667                 break;
668         case SND_SOC_DAPM_POST_PMD:
669                 if (ac10x->aif1_clken != 0) {
670                         /* disable aif1clk & sysclk */
671                         ret = ac101_update_bits(codec, SYSCLK_CTRL, (0x1<<AIF1CLK_ENA),(0x0<<AIF1CLK_ENA));
672                         ret = ret || ac101_update_bits(codec, MOD_CLK_ENA, (0x1<<MOD_CLK_AIF1), (0x0<<MOD_CLK_AIF1));
673                         ret = ret || ac101_update_bits(codec, MOD_RST_CTRL, (0x1<<MOD_RESET_AIF1), (0x0<<MOD_RESET_AIF1));
674                         ret = ret || ac101_update_bits(codec, SYSCLK_CTRL, (0x1<<SYSCLK_ENA), (0x0<<SYSCLK_ENA));
675
676                         if (ret) {
677                                 AC101_DBG("stop sysclk failed\n");
678                         } else {
679                                 AC101_DBG("hw sysclk disable\n");
680                                 ac10x->aif1_clken = 0;
681                         }
682                         break;
683                 }
684         }
685
686         AC101_DBG("event=%d pre_up/%d post_down/%d\n", event, SND_SOC_DAPM_PRE_PMU, SND_SOC_DAPM_POST_PMD);
687
688         return ret;
689 }
690
691 /**
692  * snd_ac101_get_volsw - single mixer get callback
693  * @kcontrol: mixer control
694  * @ucontrol: control element information
695  *
696  * Callback to get the value of a single mixer control, or a double mixer
697  * control that spans 2 registers.
698  *
699  * Returns 0 for success.
700  */
701 static int snd_ac101_get_volsw(struct snd_kcontrol *kcontrol,
702         struct snd_ctl_elem_value *ucontrol
703 ){
704         struct soc_mixer_control *mc =
705                 (struct soc_mixer_control *)kcontrol->private_value;
706         unsigned int val, mask = (1 << fls(mc->max)) - 1;
707         unsigned int invert = mc->invert;
708         int ret;
709
710         if ((ret = ac101_read(static_ac10x->codec, mc->reg)) < 0)
711                 return ret;
712
713         val = (ret >> mc->shift) & mask;
714         ucontrol->value.integer.value[0] = val - mc->min;
715         if (invert) {
716                 ucontrol->value.integer.value[0] =
717                         mc->max - ucontrol->value.integer.value[0];
718         }
719
720         if (snd_soc_volsw_is_stereo(mc)) {
721                 val = (ret >> mc->rshift) & mask;
722                 ucontrol->value.integer.value[1] = val - mc->min;
723                 if (invert) {
724                         ucontrol->value.integer.value[1] =
725                                 mc->max - ucontrol->value.integer.value[1];
726                 }
727         }
728         return 0;
729 }
730
731 /**
732  * snd_ac101_put_volsw - single mixer put callback
733  * @kcontrol: mixer control
734  * @ucontrol: control element information
735  *
736  * Callback to set the value of a single mixer control, or a double mixer
737  * control that spans 2 registers.
738  *
739  * Returns 0 for success.
740  */
741 static int snd_ac101_put_volsw(struct snd_kcontrol *kcontrol,
742         struct snd_ctl_elem_value *ucontrol
743 ){
744         struct soc_mixer_control *mc =
745                 (struct soc_mixer_control *)kcontrol->private_value;
746         unsigned int sign_bit = mc->sign_bit;
747         unsigned int val, mask = (1 << fls(mc->max)) - 1;
748         unsigned int invert = mc->invert;
749         int ret;
750
751         if (sign_bit)
752                 mask = BIT(sign_bit + 1) - 1;
753
754         val = ((ucontrol->value.integer.value[0] + mc->min) & mask);
755         if (invert) {
756                 val = mc->max - val;
757         }
758
759         ret = ac101_update_bits(static_ac10x->codec, mc->reg, mask << mc->shift, val << mc->shift);
760
761         if (! snd_soc_volsw_is_stereo(mc)) {
762                 return ret;
763         }
764         val = ((ucontrol->value.integer.value[1] + mc->min) & mask);
765         if (invert) {
766                 val = mc->max - val;
767         }
768
769         ret = ac101_update_bits(static_ac10x->codec, mc->reg, mask << mc->rshift, val << mc->rshift);
770         return ret;
771 }
772
773
774 static const DECLARE_TLV_DB_SCALE(dac_vol_tlv, -11925, 75, 0);
775 static const DECLARE_TLV_DB_SCALE(dac_mix_vol_tlv, -600, 600, 0);
776 static const DECLARE_TLV_DB_SCALE(dig_vol_tlv, -7308, 116, 0);
777 static const DECLARE_TLV_DB_SCALE(speaker_vol_tlv, -4800, 150, 0);
778 static const DECLARE_TLV_DB_SCALE(headphone_vol_tlv, -6300, 100, 0);
779
780 static struct snd_kcontrol_new ac101_controls[] = {
781         /*DAC*/
782         SOC_DOUBLE_TLV("DAC volume", DAC_VOL_CTRL, DAC_VOL_L, DAC_VOL_R, 0xff, 0, dac_vol_tlv),
783         SOC_DOUBLE_TLV("DAC mixer gain", DAC_MXR_GAIN, DACL_MXR_GAIN, DACR_MXR_GAIN, 0xf, 0, dac_mix_vol_tlv),
784         SOC_SINGLE_TLV("digital volume", DAC_DBG_CTRL, DVC, 0x3f, 1, dig_vol_tlv),
785         SOC_SINGLE_TLV("speaker volume", SPKOUT_CTRL, SPK_VOL, 0x1f, 0, speaker_vol_tlv),
786         SOC_SINGLE_TLV("headphone volume", HPOUT_CTRL, HP_VOL, 0x3f, 0, headphone_vol_tlv),
787 };
788
789 /* PLL divisors */
790 struct pll_div {
791         unsigned int pll_in;
792         unsigned int pll_out;
793         int m;
794         int n_i;
795         int n_f;
796 };
797
798 struct aif1_fs {
799         unsigned samp_rate;
800         int bclk_div;
801         int srbit;
802         #define _SERIES_24_576K         0
803         #define _SERIES_22_579K         1
804         int series;
805 };
806
807 struct kv_map {
808         int val;
809         int bit;
810 };
811
812 /*
813  * Note : pll code from original tdm/i2s driver.
814  * freq_out = freq_in * N/(M*(2k+1)) , k=1,N=N_i+N_f,N_f=factor*0.2;
815  *              N_i[0,1023], N_f_factor[0,7], m[1,64]=REG_VAL[1-63,0]
816  */
817 static const struct pll_div codec_pll_div[] = {
818         {128000,   _FREQ_22_579K,  1, 529, 1},
819         {192000,   _FREQ_22_579K,  1, 352, 4},
820         {256000,   _FREQ_22_579K,  1, 264, 3},
821         {384000,   _FREQ_22_579K,  1, 176, 2}, /*((176+2*0.2)*6000000)/(38*(2*1+1))*/
822         {1411200,  _FREQ_22_579K,  1,  48, 0},
823         {2822400,  _FREQ_22_579K,  1,  24, 0}, /* accurate, 11025 * 256 */
824         {5644800,  _FREQ_22_579K,  1,  12, 0}, /* accurate, 22050 * 256 */
825         {6000000,  _FREQ_22_579K, 38, 429, 0}, /*((429+0*0.2)*6000000)/(38*(2*1+1))*/
826         {11289600, _FREQ_22_579K,  1,   6, 0}, /* accurate, 44100 * 256 */
827         {13000000, _FREQ_22_579K, 19,  99, 0},
828         {19200000, _FREQ_22_579K, 25,  88, 1},
829         {24000000, _FREQ_22_579K, 63, 177, 4}, /* 22577778 Hz */
830
831         {128000,   _FREQ_24_576K,  1, 576, 0},
832         {192000,   _FREQ_24_576K,  1, 384, 0},
833         {256000,   _FREQ_24_576K,  1, 288, 0},
834         {384000,   _FREQ_24_576K,  1, 192, 0},
835         {2048000,  _FREQ_24_576K,  1,  36, 0}, /* accurate,  8000 * 256 */
836         {3072000,  _FREQ_24_576K,  1,  24, 0}, /* accurate, 12000 * 256 */
837         {4096000,  _FREQ_24_576K,  1,  18, 0}, /* accurate, 16000 * 256 */
838         {6000000,  _FREQ_24_576K, 25, 307, 1},
839         {6144000,  _FREQ_24_576K,  4,  48, 0}, /* accurate, 24000 * 256 */
840         {12288000, _FREQ_24_576K,  8,  48, 0}, /* accurate, 48000 * 256 */
841         {13000000, _FREQ_24_576K, 42, 238, 1},
842         {19200000, _FREQ_24_576K, 25,  96, 0},
843         {24000000, _FREQ_24_576K, 25,  76, 4}, /* accurate */
844
845         {_FREQ_22_579K, _FREQ_22_579K,  8,  24, 0}, /* accurate, 88200 * 256 */
846         {_FREQ_24_576K, _FREQ_24_576K,  8,  24, 0}, /* accurate, 96000 * 256 */
847 };
848
849 static const struct aif1_fs codec_aif1_fs[] = {
850         {8000, 12, 0},
851         {11025, 8, 1, _SERIES_22_579K},
852         {12000, 8, 2},
853         {16000, 6, 3},
854         {22050, 4, 4, _SERIES_22_579K},
855         {24000, 4, 5},
856         /* {32000, 3, 6}, dividing by 3 is not support */
857         {44100, 2, 7, _SERIES_22_579K},
858         {48000, 2, 8},
859         {96000, 1, 9},
860 };
861
862 static const struct kv_map codec_aif1_lrck[] = {
863         {16, 0},
864         {32, 1},
865         {64, 2},
866         {128, 3},
867         {256, 4},
868 };
869
870 static const struct kv_map codec_aif1_wsize[] = {
871         {8, 0},
872         {16, 1},
873         {20, 2},
874         {24, 3},
875         {32, 3},
876 };
877
878 static const unsigned ac101_bclkdivs[] = {
879           1,   2,   4,   6,
880           8,  12,  16,  24,
881          32,  48,  64,  96,
882         128, 192,   0,   0,
883 };
884
885 static int ac101_aif_play(struct ac10x_priv* ac10x) {
886         struct snd_soc_codec * codec = ac10x->codec;
887
888         late_enable_dac(codec, SND_SOC_DAPM_PRE_PMU);
889         ac101_headphone_event(codec, SND_SOC_DAPM_POST_PMU);
890         if (drc_used) {
891                 drc_enable(codec, 1);
892         }
893
894         /* Enable Left & Right Speaker */
895         ac101_update_bits(codec, SPKOUT_CTRL, (0x1 << LSPK_EN) | (0x1 << RSPK_EN), (0x1 << LSPK_EN) | (0x1 << RSPK_EN));
896         if (ac10x->gpiod_spk_amp_gate) {
897                 gpiod_set_value(ac10x->gpiod_spk_amp_gate, 1);
898         }
899         return 0;
900 }
901
902 static void ac10x_work_aif_play(struct work_struct *work) {
903         struct ac10x_priv *ac10x = container_of(work, struct ac10x_priv, dlywork.work);
904
905         ac101_aif_play(ac10x);
906         return;
907 }
908
909 int ac101_aif_mute(struct snd_soc_dai *codec_dai, int mute)
910 {
911         struct snd_soc_codec *codec = codec_dai->codec;
912         struct ac10x_priv *ac10x = snd_soc_codec_get_drvdata(codec);
913
914         AC101_DBG("mute=%d\n",  mute);
915
916         ac101_write(codec, DAC_VOL_CTRL, mute? 0: 0xA0A0);
917
918         if (!mute) {
919                 #if _MASTER_MULTI_CODEC != _MASTER_AC101
920                 /* enable global clock */
921                 ac10x->aif1_clken = 0;
922                 ac101_aif1clk(codec, SND_SOC_DAPM_PRE_PMU, 0);
923                 ac101_aif_play(ac10x);
924                 #else
925                 schedule_delayed_work(&ac10x->dlywork, msecs_to_jiffies(50));
926                 #endif
927         } else {
928                 #if _MASTER_MULTI_CODEC == _MASTER_AC101
929                 cancel_delayed_work_sync(&ac10x->dlywork);
930                 #endif
931
932                 if (ac10x->gpiod_spk_amp_gate) {
933                         gpiod_set_value(ac10x->gpiod_spk_amp_gate, 0);
934                 }
935                 /* Disable Left & Right Speaker */
936                 ac101_update_bits(codec, SPKOUT_CTRL, (0x1 << LSPK_EN) | (0x1 << RSPK_EN), (0x0 << LSPK_EN) | (0x0 << RSPK_EN));
937                 if (drc_used) {
938                         drc_enable(codec, 0);
939                 }
940                 ac101_headphone_event(codec, SND_SOC_DAPM_PRE_PMD);
941                 late_enable_dac(codec, SND_SOC_DAPM_POST_PMD);
942
943                 #if _MASTER_MULTI_CODEC != _MASTER_AC101
944                 ac10x->aif1_clken = 1;
945                 ac101_aif1clk(codec, SND_SOC_DAPM_POST_PMD, 0);
946                 #endif
947         }
948         return 0;
949 }
950
951 void ac101_aif_shutdown(struct snd_pcm_substream *substream, struct snd_soc_dai *codec_dai)
952 {
953         struct snd_soc_codec *codec = codec_dai->codec;
954         struct ac10x_priv *ac10x = snd_soc_codec_get_drvdata(codec);
955
956         AC101_DBG("stream = %s, play: %d, capt: %d, active: %d\n", 
957                 snd_pcm_stream_str(substream),
958                 codec_dai->playback_active, codec_dai->capture_active,
959                 codec_dai->active);
960
961         if (!codec_dai->active) {
962                 ac10x->aif1_clken = 1;
963                 ac101_aif1clk(codec, SND_SOC_DAPM_POST_PMD, 0);
964         } else {
965                 ac101_aif1clk(codec, SND_SOC_DAPM_PRE_PMU, 0);
966         }
967 }
968
969 static int ac101_set_pll(struct snd_soc_dai *codec_dai, int pll_id, int source,
970                         unsigned int freq_in, unsigned int freq_out)
971 {
972         struct snd_soc_codec *codec = codec_dai->codec;
973         int i, m, n_i, n_f;
974
975         AC101_DBG("pll_id:%d\n",  pll_id);
976
977         /* clear volatile reserved bits*/
978         ac101_update_bits(codec, SYSCLK_CTRL, 0xFF & ~(0x1 << SYSCLK_ENA), 0x0);
979
980         /* select aif1 clk srouce from mclk1 */
981         ac101_update_bits(codec, SYSCLK_CTRL, (0x3<<AIF1CLK_SRC), (0x0<<AIF1CLK_SRC));
982         /* disable pll */
983         ac101_update_bits(codec, PLL_CTRL2, (0x1<<PLL_EN), (0<<PLL_EN));
984
985         if (!freq_out)
986                 return 0;
987         if ((freq_in < 128000) || (freq_in > _FREQ_24_576K)) {
988                 return -EINVAL;
989         } else if ((freq_in == _FREQ_24_576K) || (freq_in == _FREQ_22_579K)) {
990                 if (pll_id == AC101_MCLK1) {
991                         /*select aif1 clk source from mclk1*/
992                         ac101_update_bits(codec, SYSCLK_CTRL, (0x3<<AIF1CLK_SRC), (0x0<<AIF1CLK_SRC));
993                         return 0;
994                 }
995         }
996
997         switch (pll_id) {
998         case AC101_MCLK1:
999                 /*pll source from MCLK1*/
1000                 ac101_update_bits(codec, SYSCLK_CTRL, (0x3<<PLLCLK_SRC), (0x0<<PLLCLK_SRC));
1001                 break;
1002         case AC101_BCLK1:
1003                 /*pll source from BCLK1*/
1004                 ac101_update_bits(codec, SYSCLK_CTRL, (0x3<<PLLCLK_SRC), (0x2<<PLLCLK_SRC));
1005                 break;
1006         default:
1007                 return -EINVAL;
1008         }
1009
1010         /* freq_out = freq_in * n/(m*(2k+1)) , k=1,N=N_i+N_f */
1011         for (i = m = n_i = n_f = 0; i < ARRAY_SIZE(codec_pll_div); i++) {
1012                 if ((codec_pll_div[i].pll_in == freq_in) && (codec_pll_div[i].pll_out == freq_out)) {
1013                         m   = codec_pll_div[i].m;
1014                         n_i = codec_pll_div[i].n_i;
1015                         n_f = codec_pll_div[i].n_f;
1016                         break;
1017                 }
1018         }
1019         /* config pll m */
1020         if (m  == 64) m = 0;
1021         ac101_update_bits(codec, PLL_CTRL1, (0x3f<<PLL_POSTDIV_M), (m<<PLL_POSTDIV_M));
1022         /* config pll n */
1023         ac101_update_bits(codec, PLL_CTRL2, (0x3ff<<PLL_PREDIV_NI), (n_i<<PLL_PREDIV_NI));
1024         ac101_update_bits(codec, PLL_CTRL2, (0x7<<PLL_POSTDIV_NF), (n_f<<PLL_POSTDIV_NF));
1025         /* enable pll */
1026         ac101_update_bits(codec, PLL_CTRL2, (0x1<<PLL_EN), (1<<PLL_EN));
1027         ac101_update_bits(codec, SYSCLK_CTRL, (0x1<<PLLCLK_ENA),  (0x1<<PLLCLK_ENA));
1028         ac101_update_bits(codec, SYSCLK_CTRL, (0x3<<AIF1CLK_SRC), (0x3<<AIF1CLK_SRC));
1029
1030         return 0;
1031 }
1032
1033 int ac101_hw_params(struct snd_pcm_substream *substream,
1034         struct snd_pcm_hw_params *params,
1035         struct snd_soc_dai *codec_dai)
1036 {
1037         int i = 0;
1038         int AIF_CLK_CTRL = AIF1_CLK_CTRL;
1039         int aif1_word_size = 24;
1040         int aif1_slot_size = 32;
1041         int aif1_lrck_div;
1042         struct snd_soc_codec *codec = codec_dai->codec;
1043         struct ac10x_priv *ac10x = snd_soc_codec_get_drvdata(codec);
1044         int reg_val, freq_out;
1045         unsigned channels;
1046
1047         AC101_DBG("+++\n");
1048
1049         if (_MASTER_MULTI_CODEC == _MASTER_AC101 && ac101_sysclk_started()) {
1050                 /* not configure hw_param twice if stream is playback, tell the caller it's started */
1051                 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
1052                         return 1;
1053                 }
1054         }
1055
1056         /* get channels count & slot size */
1057         channels = params_channels(params);
1058
1059         switch (params_format(params)) {
1060         case SNDRV_PCM_FORMAT_S24_LE:
1061         case SNDRV_PCM_FORMAT_S32_LE:
1062                 aif1_slot_size = 32;
1063                 break;
1064         case SNDRV_PCM_FORMAT_S16_LE:
1065         default:
1066                 aif1_slot_size = 16;
1067                 break;
1068         }
1069
1070         /* set LRCK/BCLK ratio */
1071         aif1_lrck_div = aif1_slot_size * channels;
1072         for (i = 0; i < ARRAY_SIZE(codec_aif1_lrck); i++) {
1073                 if (codec_aif1_lrck[i].val == aif1_lrck_div) {
1074                         break;
1075                 }
1076         }
1077         ac101_update_bits(codec, AIF_CLK_CTRL, (0x7<<AIF1_LRCK_DIV), codec_aif1_lrck[i].bit<<AIF1_LRCK_DIV);
1078
1079         /* set PLL output freq */
1080         freq_out = _FREQ_24_576K;
1081         for (i = 0; i < ARRAY_SIZE(codec_aif1_fs); i++) {
1082                 if (codec_aif1_fs[i].samp_rate == params_rate(params)) {
1083                         if (codec_dai->capture_active && dmic_used && codec_aif1_fs[i].samp_rate == 44100) {
1084                                 ac101_update_bits(codec, AIF_SR_CTRL, (0xf<<AIF1_FS), (0x4<<AIF1_FS));
1085                         } else {
1086                                 ac101_update_bits(codec, AIF_SR_CTRL, (0xf<<AIF1_FS), ((codec_aif1_fs[i].srbit)<<AIF1_FS));
1087                         }
1088                         if (codec_aif1_fs[i].series == _SERIES_22_579K)
1089                                 freq_out = _FREQ_22_579K;
1090                         break;
1091                 }
1092         }
1093
1094         /* set I2S word size */
1095         for (i = 0; i < ARRAY_SIZE(codec_aif1_wsize); i++) {
1096                 if (codec_aif1_wsize[i].val == aif1_word_size) {
1097                         break;
1098                 }
1099         }
1100         ac101_update_bits(codec, AIF_CLK_CTRL, (0x3<<AIF1_WORK_SIZ), ((codec_aif1_wsize[i].bit)<<AIF1_WORK_SIZ));
1101
1102         /* set TDM slot size */
1103         if ((reg_val = codec_aif1_wsize[i].bit) > 2) reg_val = 2;
1104         ac101_update_bits(codec, AIF1_ADCDAT_CTRL, 0x3 << AIF1_SLOT_SIZ, reg_val << AIF1_SLOT_SIZ);
1105
1106         /* setting pll if it's master mode */
1107         reg_val = ac101_read(codec, AIF_CLK_CTRL);
1108         if ((reg_val & (0x1 << AIF1_MSTR_MOD)) == 0) {
1109                 unsigned bclkdiv;
1110
1111                 ac101_set_pll(codec_dai, AC101_MCLK1, 0, ac10x->sysclk, freq_out);
1112
1113                 bclkdiv = freq_out / (aif1_lrck_div * params_rate(params));
1114                 for (i = 0; i < ARRAY_SIZE(ac101_bclkdivs) - 1; i++) {
1115                         if (ac101_bclkdivs[i] >= bclkdiv) {
1116                                 break;
1117                         }
1118                 }
1119                 ac101_update_bits(codec, AIF_CLK_CTRL, (0xf<<AIF1_BCLK_DIV), i<<AIF1_BCLK_DIV);
1120         } else {
1121                 /* set pll clock source to BCLK if slave mode */
1122                 ac101_set_pll(codec_dai, AC101_BCLK1, 0, aif1_lrck_div * params_rate(params), freq_out);
1123         }
1124
1125         #if _MASTER_MULTI_CODEC == _MASTER_AC101
1126         /* Master mode, to clear cpu_dai fifos, disable output bclk & lrck */
1127         ac101_aif1clk(codec, SND_SOC_DAPM_POST_PMD, 0);
1128         #endif
1129
1130         AC101_DBG("rate: %d , channels: %d , samp_res: %d",
1131                 params_rate(params), channels, aif1_slot_size);
1132
1133         AC101_DBG("---\n");
1134         return 0;
1135 }
1136
1137 int ac101_set_dai_fmt(struct snd_soc_dai *codec_dai, unsigned int fmt)
1138 {
1139         int reg_val;
1140         int AIF_CLK_CTRL = AIF1_CLK_CTRL;
1141         struct snd_soc_codec *codec = codec_dai->codec;
1142
1143         AC101_DBG();
1144
1145         /*
1146          *      master or slave selection
1147          *      0 = Master mode
1148          *      1 = Slave mode
1149          */
1150         reg_val = ac101_read(codec, AIF_CLK_CTRL);
1151         reg_val &= ~(0x1<<AIF1_MSTR_MOD);
1152         switch(fmt & SND_SOC_DAIFMT_MASTER_MASK) {
1153         case SND_SOC_DAIFMT_CBM_CFM:   /* codec clk & frm master, ap is slave*/
1154                 #if _MASTER_MULTI_CODEC == _MASTER_AC101
1155                 pr_warn("AC101 as Master\n");
1156                 reg_val |= (0x0<<AIF1_MSTR_MOD);
1157                 break;
1158                 #else
1159                 pr_warn("AC108 as Master\n");
1160                 #endif
1161         case SND_SOC_DAIFMT_CBS_CFS:   /* codec clk & frm slave, ap is master*/
1162                 pr_warn("AC101 as Slave\n");
1163                 reg_val |= (0x1<<AIF1_MSTR_MOD);
1164                 break;
1165         default:
1166                 pr_err("unknwon master/slave format\n");
1167                 return -EINVAL;
1168         }
1169
1170         /*
1171          * Enable TDM mode
1172          */
1173         reg_val |=  (0x1 << AIF1_TDMM_ENA);
1174         ac101_write(codec, AIF_CLK_CTRL, reg_val);
1175
1176         /* i2s mode selection */
1177         reg_val = ac101_read(codec, AIF_CLK_CTRL);
1178         reg_val&=~(3<<AIF1_DATA_FMT);
1179         switch(fmt & SND_SOC_DAIFMT_FORMAT_MASK){
1180         case SND_SOC_DAIFMT_I2S:        /* I2S1 mode */
1181                 reg_val |= (0x0<<AIF1_DATA_FMT);
1182                 break;
1183         case SND_SOC_DAIFMT_RIGHT_J:    /* Right Justified mode */
1184                 reg_val |= (0x2<<AIF1_DATA_FMT);
1185                 break;
1186         case SND_SOC_DAIFMT_LEFT_J:     /* Left Justified mode */
1187                 reg_val |= (0x1<<AIF1_DATA_FMT);
1188                 break;
1189         case SND_SOC_DAIFMT_DSP_A:      /* L reg_val msb after FRM LRC */
1190                 reg_val |= (0x3<<AIF1_DATA_FMT);
1191                 break;
1192         case SND_SOC_DAIFMT_DSP_B:
1193                 /* TODO: data offset set to 0 */
1194                 reg_val |= (0x3<<AIF1_DATA_FMT);
1195                 break;
1196         default:
1197                 pr_err("%s, line:%d\n", __func__, __LINE__);
1198                 return -EINVAL;
1199         }
1200         ac101_write(codec, AIF_CLK_CTRL, reg_val);
1201
1202         /* DAI signal inversions */
1203         reg_val = ac101_read(codec, AIF_CLK_CTRL);
1204         switch(fmt & SND_SOC_DAIFMT_INV_MASK){
1205         case SND_SOC_DAIFMT_NB_NF:     /* normal bit clock + nor frame */
1206                 reg_val &= ~(0x1<<AIF1_LRCK_INV);
1207                 reg_val &= ~(0x1<<AIF1_BCLK_INV);
1208                 break;
1209         case SND_SOC_DAIFMT_NB_IF:     /* normal bclk + inv frm */
1210                 reg_val |= (0x1<<AIF1_LRCK_INV);
1211                 reg_val &= ~(0x1<<AIF1_BCLK_INV);
1212                 break;
1213         case SND_SOC_DAIFMT_IB_NF:     /* invert bclk + nor frm */
1214                 reg_val &= ~(0x1<<AIF1_LRCK_INV);
1215                 reg_val |= (0x1<<AIF1_BCLK_INV);
1216                 break;
1217         case SND_SOC_DAIFMT_IB_IF:     /* invert bclk + inv frm */
1218                 reg_val |= (0x1<<AIF1_LRCK_INV);
1219                 reg_val |= (0x1<<AIF1_BCLK_INV);
1220                 break;
1221         }
1222         ac101_write(codec, AIF_CLK_CTRL, reg_val);
1223
1224         return 0;
1225 }
1226
1227 int ac101_audio_startup(struct snd_pcm_substream *substream,
1228         struct snd_soc_dai *codec_dai)
1229 {
1230         // struct snd_soc_codec *codec = codec_dai->codec;
1231
1232         AC101_DBG("\n\n\n");
1233
1234         if (substream->stream == SNDRV_PCM_STREAM_CAPTURE) {
1235         }
1236         return 0;
1237 }
1238
1239 #if _MASTER_MULTI_CODEC == _MASTER_AC101
1240 static int ac101_set_clock(int y_start_n_stop) {
1241         int r;
1242
1243         if (y_start_n_stop) {
1244                 /* enable global clock */
1245                 r = ac101_aif1clk(static_ac10x->codec, SND_SOC_DAPM_PRE_PMU, 1);
1246         } else {
1247                 /* disable global clock */
1248                 static_ac10x->aif1_clken = 1;
1249                 r = ac101_aif1clk(static_ac10x->codec, SND_SOC_DAPM_POST_PMD, 0);
1250         }
1251         return r;
1252 }
1253 #endif
1254
1255 int ac101_trigger(struct snd_pcm_substream *substream, int cmd,
1256                   struct snd_soc_dai *dai)
1257 {
1258         struct snd_soc_codec *codec = dai->codec;
1259         struct ac10x_priv *ac10x = snd_soc_codec_get_drvdata(codec);
1260         int ret = 0;
1261
1262         AC101_DBG("stream=%s  cmd=%d\n",
1263                 snd_pcm_stream_str(substream),
1264                 cmd);
1265
1266         switch (cmd) {
1267         case SNDRV_PCM_TRIGGER_START:
1268         case SNDRV_PCM_TRIGGER_RESUME:
1269         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
1270                 #if _MASTER_MULTI_CODEC == _MASTER_AC101
1271                 if (ac10x->aif1_clken == 0){
1272                         /*
1273                          * enable aif1clk, it' here due to reduce time between 'AC108 Sysclk Enable' and 'AC101 Sysclk Enable'
1274                          * Or else the two AC108 chips lost the sync.
1275                          */
1276                         ret = 0;
1277                         ret = ret || ac101_update_bits(codec, MOD_CLK_ENA, (0x1<<MOD_CLK_AIF1), (0x1<<MOD_CLK_AIF1));
1278                         ret = ret || ac101_update_bits(codec, MOD_RST_CTRL, (0x1<<MOD_RESET_AIF1), (0x1<<MOD_RESET_AIF1));
1279                 }
1280                 #endif
1281                 break;
1282         case SNDRV_PCM_TRIGGER_STOP:
1283         case SNDRV_PCM_TRIGGER_SUSPEND:
1284         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
1285                 break;
1286         default:
1287                 ret = -EINVAL;
1288         }
1289         return ret;
1290 }
1291
1292 #if 0
1293 static int ac101_set_dai_sysclk(struct snd_soc_dai *codec_dai,
1294                                   int clk_id, unsigned int freq, int dir)
1295 {
1296         struct snd_soc_codec *codec = codec_dai->codec;
1297         struct ac10x_priv *ac10x = snd_soc_codec_get_drvdata(codec);
1298
1299         AC101_DBG("id=%d freq=%d, dir=%d\n", 
1300                 clk_id, freq, dir);
1301
1302         ac10x->sysclk = freq;
1303
1304         return 0;
1305 }
1306
1307 static const struct snd_soc_dai_ops ac101_aif1_dai_ops = {
1308         //.startup      = ac101_audio_startup,
1309         //.shutdown     = ac101_aif_shutdown,
1310         //.set_sysclk   = ac101_set_dai_sysclk,
1311         //.set_pll      = ac101_set_pll,
1312         //.set_fmt      = ac101_set_dai_fmt,
1313         //.hw_params    = ac101_hw_params,
1314         //.trigger      = ac101_trigger,
1315         //.digital_mute = ac101_aif_mute,
1316 };
1317
1318 static struct snd_soc_dai_driver ac101_dai[] = {
1319         {
1320                 .name = "ac10x-aif1",
1321                 .id = AIF1_CLK,
1322                 .playback = {
1323                         .stream_name = "Playback",
1324                         .channels_min = 1,
1325                         .channels_max = 8,
1326                         .rates = AC101_RATES,
1327                         .formats = AC101_FORMATS,
1328                 },
1329                 #if 0
1330                 .capture = {
1331                         .stream_name = "Capture",
1332                         .channels_min = 1,
1333                         .channels_max = 8,
1334                         .rates = AC101_RATES,
1335                         .formats = AC101_FORMATS,
1336                 },
1337                 #endif
1338                 .ops = &ac101_aif1_dai_ops,
1339         }
1340 };
1341 #endif
1342
1343 static void codec_resume_work(struct work_struct *work)
1344 {
1345         struct ac10x_priv *ac10x = container_of(work, struct ac10x_priv, codec_resume);
1346         struct snd_soc_codec *codec = ac10x->codec;
1347
1348         AC101_DBG("+++\n");
1349
1350         set_configuration(codec);
1351         if (drc_used) {
1352                 drc_config(codec);
1353         }
1354         /*enable this bit to prevent leakage from ldoin*/
1355         ac101_update_bits(codec, ADDA_TUNE3, (0x1<<OSCEN), (0x1<<OSCEN));
1356
1357         AC101_DBG("---\n");
1358         return;
1359 }
1360
1361 int ac101_set_bias_level(struct snd_soc_codec *codec, enum snd_soc_bias_level level)
1362 {
1363         switch (level) {
1364         case SND_SOC_BIAS_ON:
1365                 AC101_DBG("SND_SOC_BIAS_ON\n");
1366                 break;
1367         case SND_SOC_BIAS_PREPARE:
1368                 AC101_DBG("SND_SOC_BIAS_PREPARE\n");
1369                 break;
1370         case SND_SOC_BIAS_STANDBY:
1371                 AC101_DBG("SND_SOC_BIAS_STANDBY\n");
1372                 #ifdef CONFIG_AC101_SWITCH_DETECT
1373                 switch_hw_config(codec);
1374                 #endif
1375                 break;
1376         case SND_SOC_BIAS_OFF:
1377                 #ifdef CONFIG_AC101_SWITCH_DETECT
1378                 ac101_update_bits(codec, ADC_APC_CTRL, (0x1<<HBIASEN), (0<<HBIASEN));
1379                 ac101_update_bits(codec, ADC_APC_CTRL, (0x1<<HBIASADCEN), (0<<HBIASADCEN));
1380                 #endif
1381                 ac101_update_bits(codec, OMIXER_DACA_CTRL, (0xf<<HPOUTPUTENABLE), (0<<HPOUTPUTENABLE));
1382                 ac101_update_bits(codec, ADDA_TUNE3, (0x1<<OSCEN), (0<<OSCEN));
1383                 AC101_DBG("SND_SOC_BIAS_OFF\n");
1384                 break;
1385         }
1386         snd_soc_codec_get_dapm(codec)->bias_level = level;
1387         return 0;
1388 }
1389
1390 int ac101_codec_probe(struct snd_soc_codec *codec)
1391 {
1392         int ret = 0;
1393         struct ac10x_priv *ac10x;
1394
1395         ac10x = dev_get_drvdata(codec->dev);
1396         if (ac10x == NULL) {
1397                 AC101_DBG("not set client data!\n");
1398                 return -ENOMEM;
1399         }
1400         ac10x->codec = codec;
1401
1402         INIT_DELAYED_WORK(&ac10x->dlywork, ac10x_work_aif_play);
1403         INIT_WORK(&ac10x->codec_resume, codec_resume_work);
1404         ac10x->dac_enable = 0;
1405         ac10x->aif1_clken = 0;
1406         mutex_init(&ac10x->dac_mutex);
1407
1408         #if _MASTER_MULTI_CODEC == _MASTER_AC101
1409         seeed_voice_card_register_set_clock(SNDRV_PCM_STREAM_PLAYBACK, ac101_set_clock);
1410         #endif
1411
1412         set_configuration(ac10x->codec);
1413
1414         /*enable this bit to prevent leakage from ldoin*/
1415         ac101_update_bits(codec, ADDA_TUNE3, (0x1<<OSCEN), (0x1<<OSCEN));
1416         ac101_write(codec, DAC_VOL_CTRL, 0);
1417
1418         /* customized get/put inteface */
1419         for (ret = 0; ret < ARRAY_SIZE(ac101_controls); ret++) {
1420                 struct snd_kcontrol_new* skn = &ac101_controls[ret];
1421
1422                 skn->get = snd_ac101_get_volsw;
1423                 skn->put = snd_ac101_put_volsw;
1424         }
1425         ret = snd_soc_add_codec_controls(codec, ac101_controls, ARRAY_SIZE(ac101_controls));
1426         if (ret) {
1427                 pr_err("[ac10x] Failed to register audio mode control, "
1428                                 "will continue without it.\n");
1429         }
1430
1431         #ifdef CONFIG_AC101_SWITCH_DETECT
1432         ret = ac101_switch_probe(ac10x);
1433         if (ret) {
1434                 // not care the switch return value
1435         }
1436         #endif
1437
1438         return 0;
1439 }
1440
1441 /* power down chip */
1442 int ac101_codec_remove(struct snd_soc_codec *codec)
1443 {
1444         #ifdef CONFIG_AC101_SWITCH_DETECT
1445         struct ac10x_priv *ac10x = snd_soc_codec_get_drvdata(codec);
1446
1447         if (ac10x->irq) {
1448                 devm_free_irq(codec->dev, ac10x->irq, ac10x);
1449                 ac10x->irq = 0;
1450         }
1451
1452         if (cancel_work_sync(&ac10x->work_switch) != 0) {
1453         }
1454
1455         if (cancel_work_sync(&ac10x->work_clear_irq) != 0) {
1456         }
1457
1458         if (ac10x->inpdev) {
1459                 input_unregister_device(ac10x->inpdev);
1460                 ac10x->inpdev = NULL;
1461         }
1462         #endif
1463
1464         return 0;
1465 }
1466
1467 int ac101_codec_suspend(struct snd_soc_codec *codec)
1468 {
1469         struct ac10x_priv *ac10x = snd_soc_codec_get_drvdata(codec);
1470
1471         AC101_DBG("[codec]:suspend\n");
1472         regcache_cache_only(ac10x->regmap101, true);
1473         return 0;
1474 }
1475
1476 int ac101_codec_resume(struct snd_soc_codec *codec)
1477 {
1478         struct ac10x_priv *ac10x = snd_soc_codec_get_drvdata(codec);
1479         int ret;
1480
1481         AC101_DBG("[codec]:resume");
1482
1483         /* Sync reg_cache with the hardware */
1484         regcache_cache_only(ac10x->regmap101, false);
1485         ret = regcache_sync(ac10x->regmap101);
1486         if (ret != 0) {
1487                 dev_err(codec->dev, "Failed to sync register cache: %d\n", ret);
1488                 regcache_cache_only(ac10x->regmap101, true);
1489                 return ret;
1490         }
1491
1492         #ifdef CONFIG_AC101_SWITCH_DETECT
1493         ac10x->mode = HEADPHONE_IDLE;
1494         ac10x->state = -1;
1495         #endif
1496
1497         ac101_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
1498         schedule_work(&ac10x->codec_resume);
1499         return 0;
1500 }
1501
1502 /***************************************************************************/
1503 static ssize_t ac101_debug_store(struct device *dev,
1504         struct device_attribute *attr, const char *buf, size_t count)
1505 {
1506         struct ac10x_priv *ac10x = dev_get_drvdata(dev);
1507         int val = 0, flag = 0;
1508         u16 value_w, value_r;
1509         u8 reg, num, i=0;
1510
1511         val = simple_strtol(buf, NULL, 16);
1512         flag = (val >> 24) & 0xF;
1513         if (flag) {
1514                 reg = (val >> 16) & 0xFF;
1515                 value_w =  val & 0xFFFF;
1516                 ac101_write(ac10x->codec, reg, value_w);
1517                 printk("write 0x%x to reg:0x%x\n", value_w, reg);
1518         } else {
1519                 reg = (val >> 8) & 0xFF;
1520                 num = val & 0xff;
1521                 printk("\n");
1522                 printk("read:start add:0x%x,count:0x%x\n", reg, num);
1523
1524                 regcache_cache_bypass(ac10x->regmap101, true);
1525                 do {
1526                         value_r = ac101_read(ac10x->codec, reg);
1527                         printk("0x%x: 0x%04x ", reg++, value_r);
1528                         if (++i % 4 == 0 || i == num)
1529                                 printk("\n");
1530                 } while (i < num);
1531                 regcache_cache_bypass(ac10x->regmap101, false);
1532         }
1533         return count;
1534 }
1535 static ssize_t ac101_debug_show(struct device *dev,
1536         struct device_attribute *attr, char *buf)
1537 {
1538         printk("echo flag|reg|val > ac10x\n");
1539         printk("eg read star addres=0x06,count 0x10:echo 0610 >ac10x\n");
1540         printk("eg write value:0x13fe to address:0x06 :echo 10613fe > ac10x\n");
1541         return 0;
1542 }
1543 static DEVICE_ATTR(ac10x, 0644, ac101_debug_show, ac101_debug_store);
1544
1545 static struct attribute *audio_debug_attrs[] = {
1546         &dev_attr_ac10x.attr,
1547         NULL,
1548 };
1549
1550 static struct attribute_group audio_debug_attr_group = {
1551         .name   = "ac101_debug",
1552         .attrs  = audio_debug_attrs,
1553 };
1554 /***************************************************************************/
1555
1556 /************************************************************/
1557 static bool ac101_volatile_reg(struct device *dev, unsigned int reg)
1558 {
1559         switch (reg) {
1560         case PLL_CTRL2:
1561         case HMIC_STS:
1562                 return true;
1563         }
1564         return false;
1565 }
1566
1567 static const struct regmap_config ac101_regmap = {
1568         .reg_bits = 8,
1569         .val_bits = 16,
1570         .reg_stride = 1,
1571         .max_register = 0xB5,
1572         .cache_type = REGCACHE_FLAT,
1573         .volatile_reg = ac101_volatile_reg,
1574 };
1575
1576 /* Sync reg_cache from the hardware */
1577 int ac10x_fill_regcache(struct device* dev, struct regmap* map) {
1578         int r, i, n;
1579         int v;
1580
1581         n = regmap_get_max_register(map);
1582         for (i = 0; i < n; i++) {
1583                 regcache_cache_bypass(map, true);
1584                 r = regmap_read(map, i, &v);
1585                 if (r) {
1586                         dev_err(dev, "failed to read register %d\n", i);
1587                         continue;
1588                 }
1589                 regcache_cache_bypass(map, false);
1590
1591                 regcache_cache_only(map, true);
1592                 r = regmap_write(map, i, v);
1593                 regcache_cache_only(map, false);
1594         }
1595         regcache_cache_bypass(map, false);
1596         regcache_cache_only(map, false);
1597
1598         return 0;
1599 }
1600
1601 int ac101_probe(struct i2c_client *i2c, const struct i2c_device_id *id)
1602 {
1603         struct ac10x_priv *ac10x = i2c_get_clientdata(i2c);
1604         int ret = 0;
1605         unsigned v = 0;
1606
1607         AC101_DBG();
1608
1609         static_ac10x = ac10x;
1610
1611         ac10x->regmap101 = devm_regmap_init_i2c(i2c, &ac101_regmap);
1612         if (IS_ERR(ac10x->regmap101)) {
1613                 ret = PTR_ERR(ac10x->regmap101);
1614                 dev_err(&i2c->dev, "Fail to initialize I/O: %d\n", ret);
1615                 return ret;
1616         }
1617
1618         /* Chip reset */
1619         regcache_cache_only(ac10x->regmap101, false);
1620         ret = regmap_write(ac10x->regmap101, CHIP_AUDIO_RST, 0);
1621         msleep(50);
1622
1623         /* sync regcache for FLAT type */
1624         ac10x_fill_regcache(&i2c->dev, ac10x->regmap101);
1625
1626         ret = regmap_read(ac10x->regmap101, CHIP_AUDIO_RST, &v);
1627         if (ret < 0) {
1628                 dev_err(&i2c->dev, "failed to read vendor ID: %d\n", ret);
1629                 return ret;
1630         }
1631
1632         if (v != AC101_CHIP_ID) {
1633                 dev_err(&i2c->dev, "chip is not AC101 (%X)\n", v);
1634                 dev_err(&i2c->dev, "Expected %X\n", AC101_CHIP_ID);
1635                 return -ENODEV;
1636         }
1637
1638         ret = sysfs_create_group(&i2c->dev.kobj, &audio_debug_attr_group);
1639         if (ret) {
1640                 pr_err("failed to create attr group\n");
1641         }
1642
1643         ac10x->gpiod_spk_amp_gate = devm_gpiod_get_optional(&i2c->dev, "spk-amp-switch", GPIOD_OUT_LOW);
1644         if (IS_ERR(ac10x->gpiod_spk_amp_gate)) {
1645                 ac10x->gpiod_spk_amp_gate = NULL;
1646                 dev_err(&i2c->dev, "failed get spk-amp-switch in device tree\n");
1647         }
1648
1649         return 0;
1650 }
1651
1652 void ac101_shutdown(struct i2c_client *i2c)
1653 {
1654         struct ac10x_priv *ac10x = i2c_get_clientdata(i2c);
1655         struct snd_soc_codec *codec = ac10x->codec;
1656         int reg_val;
1657
1658         if (codec == NULL) {
1659                 pr_err(": no sound card.\n");
1660                 return;
1661         }
1662
1663         /*set headphone volume to 0*/
1664         reg_val = ac101_read(codec, HPOUT_CTRL);
1665         reg_val &= ~(0x3f<<HP_VOL);
1666         ac101_write(codec, HPOUT_CTRL, reg_val);
1667
1668         /*disable pa*/
1669         reg_val = ac101_read(codec, HPOUT_CTRL);
1670         reg_val &= ~(0x1<<HPPA_EN);
1671         ac101_write(codec, HPOUT_CTRL, reg_val);
1672
1673         /*hardware xzh support*/
1674         reg_val = ac101_read(codec, OMIXER_DACA_CTRL);
1675         reg_val &= ~(0xf<<HPOUTPUTENABLE);
1676         ac101_write(codec, OMIXER_DACA_CTRL, reg_val);
1677
1678         /*unmute l/r headphone pa*/
1679         reg_val = ac101_read(codec, HPOUT_CTRL);
1680         reg_val &= ~((0x1<<RHPPA_MUTE)|(0x1<<LHPPA_MUTE));
1681         ac101_write(codec, HPOUT_CTRL, reg_val);
1682         return;
1683 }
1684
1685 int ac101_remove(struct i2c_client *i2c)
1686 {
1687         sysfs_remove_group(&i2c->dev.kobj, &audio_debug_attr_group);
1688         return 0;
1689 }
1690
1691 MODULE_DESCRIPTION("ASoC ac10x driver");
1692 MODULE_AUTHOR("huangxin,liushaohua");
1693 MODULE_AUTHOR("PeterYang<linsheng.yang@seeed.cc>");