← Back to branch summary

~hui.wang/alsa-driver/tiwai-trunk-v419

« back to all changes in this revision

Viewing changes to i2c/other/ak4xxx-adda.c

  • Committer: Hui Wang
  • Date: 2019-04-02 08:15:36 UTC
  • Revision ID: hui.wang@canonical.com-20190402081536-jotgnsumg56flsga
init v4.19 tree

Show diffs side-by-side

added added

removed removed

Lines of Context:
i2c/other/ak4xxx-adda.c
 
1
/*
 
2
 *   ALSA driver for AK4524 / AK4528 / AK4529 / AK4355 / AK4358 / AK4381
 
3
 *   AD and DA converters
 
4
 *
 
5
 *      Copyright (c) 2000-2004 Jaroslav Kysela <perex@perex.cz>,
 
6
 *                              Takashi Iwai <tiwai@suse.de>
 
7
 *
 
8
 *   This program is free software; you can redistribute it and/or modify
 
9
 *   it under the terms of the GNU General Public License as published by
 
10
 *   the Free Software Foundation; either version 2 of the License, or
 
11
 *   (at your option) any later version.
 
12
 *
 
13
 *   This program is distributed in the hope that it will be useful,
 
14
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 
15
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
16
 *   GNU General Public License for more details.
 
17
 *
 
18
 *   You should have received a copy of the GNU General Public License
 
19
 *   along with this program; if not, write to the Free Software
 
20
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 
21
 *
 
22
 */
 
23
 
 
24
#include <linux/io.h>
 
25
#include <linux/delay.h>
 
26
#include <linux/interrupt.h>
 
27
#include <linux/init.h>
 
28
#include <linux/module.h>
 
29
#include <sound/core.h>
 
30
#include <sound/control.h>
 
31
#include <sound/tlv.h>
 
32
#include <sound/ak4xxx-adda.h>
 
33
#include <sound/info.h>
 
34
 
 
35
MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>, Takashi Iwai <tiwai@suse.de>");
 
36
MODULE_DESCRIPTION("Routines for control of AK452x / AK43xx  AD/DA converters");
 
37
MODULE_LICENSE("GPL");
 
38
 
 
39
/* write the given register and save the data to the cache */
 
40
void snd_akm4xxx_write(struct snd_akm4xxx *ak, int chip, unsigned char reg,
 
41
                       unsigned char val)
 
42
{
 
43
        ak->ops.lock(ak, chip);
 
44
        ak->ops.write(ak, chip, reg, val);
 
45
 
 
46
        /* save the data */
 
47
        snd_akm4xxx_set(ak, chip, reg, val);
 
48
        ak->ops.unlock(ak, chip);
 
49
}
 
50
 
 
51
EXPORT_SYMBOL(snd_akm4xxx_write);
 
52
 
 
53
/* reset procedure for AK4524 and AK4528 */
 
54
static void ak4524_reset(struct snd_akm4xxx *ak, int state)
 
55
{
 
56
        unsigned int chip;
 
57
        unsigned char reg;
 
58
 
 
59
        for (chip = 0; chip < ak->num_dacs/2; chip++) {
 
60
                snd_akm4xxx_write(ak, chip, 0x01, state ? 0x00 : 0x03);
 
61
                if (state)
 
62
                        continue;
 
63
                /* DAC volumes */
 
64
                for (reg = 0x04; reg < ak->total_regs; reg++)
 
65
                        snd_akm4xxx_write(ak, chip, reg,
 
66
                                          snd_akm4xxx_get(ak, chip, reg));
 
67
        }
 
68
}
 
69
 
 
70
/* reset procedure for AK4355 and AK4358 */
 
71
static void ak435X_reset(struct snd_akm4xxx *ak, int state)
 
72
{
 
73
        unsigned char reg;
 
74
 
 
75
        if (state) {
 
76
                snd_akm4xxx_write(ak, 0, 0x01, 0x02); /* reset and soft-mute */
 
77
                return;
 
78
        }
 
79
        for (reg = 0x00; reg < ak->total_regs; reg++)
 
80
                if (reg != 0x01)
 
81
                        snd_akm4xxx_write(ak, 0, reg,
 
82
                                          snd_akm4xxx_get(ak, 0, reg));
 
83
        snd_akm4xxx_write(ak, 0, 0x01, 0x01); /* un-reset, unmute */
 
84
}
 
85
 
 
86
/* reset procedure for AK4381 */
 
87
static void ak4381_reset(struct snd_akm4xxx *ak, int state)
 
88
{
 
89
        unsigned int chip;
 
90
        unsigned char reg;
 
91
        for (chip = 0; chip < ak->num_dacs/2; chip++) {
 
92
                snd_akm4xxx_write(ak, chip, 0x00, state ? 0x0c : 0x0f);
 
93
                if (state)
 
94
                        continue;
 
95
                for (reg = 0x01; reg < ak->total_regs; reg++)
 
96
                        snd_akm4xxx_write(ak, chip, reg,
 
97
                                          snd_akm4xxx_get(ak, chip, reg));
 
98
        }
 
99
}
 
100
 
 
101
/*
 
102
 * reset the AKM codecs
 
103
 * @state: 1 = reset codec, 0 = restore the registers
 
104
 *
 
105
 * assert the reset operation and restores the register values to the chips.
 
106
 */
 
107
void snd_akm4xxx_reset(struct snd_akm4xxx *ak, int state)
 
108
{
 
109
        switch (ak->type) {
 
110
        case SND_AK4524:
 
111
        case SND_AK4528:
 
112
        case SND_AK4620:
 
113
                ak4524_reset(ak, state);
 
114
                break;
 
115
        case SND_AK4529:
 
116
                /* FIXME: needed for ak4529? */
 
117
                break;
 
118
        case SND_AK4355:
 
119
                ak435X_reset(ak, state);
 
120
                break;
 
121
        case SND_AK4358:
 
122
                ak435X_reset(ak, state);
 
123
                break;
 
124
        case SND_AK4381:
 
125
                ak4381_reset(ak, state);
 
126
                break;
 
127
        default:
 
128
                break;
 
129
        }
 
130
}
 
131
 
 
132
EXPORT_SYMBOL(snd_akm4xxx_reset);
 
133
 
 
134
 
 
135
/*
 
136
 * Volume conversion table for non-linear volumes
 
137
 * from -63.5dB (mute) to 0dB step 0.5dB
 
138
 *
 
139
 * Used for AK4524/AK4620 input/ouput attenuation, AK4528, and
 
140
 * AK5365 input attenuation
 
141
 */
 
142
static const unsigned char vol_cvt_datt[128] = {
 
143
        0x00, 0x01, 0x01, 0x02, 0x02, 0x03, 0x03, 0x04,
 
144
        0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x06, 0x06,
 
145
        0x06, 0x07, 0x07, 0x08, 0x08, 0x08, 0x09, 0x0a,
 
146
        0x0a, 0x0b, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x0f,
 
147
        0x10, 0x10, 0x11, 0x12, 0x12, 0x13, 0x13, 0x14,
 
148
        0x15, 0x16, 0x17, 0x17, 0x18, 0x19, 0x1a, 0x1c,
 
149
        0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x23,
 
150
        0x24, 0x25, 0x26, 0x28, 0x29, 0x2a, 0x2b, 0x2d,
 
151
        0x2e, 0x30, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35,
 
152
        0x37, 0x38, 0x39, 0x3b, 0x3c, 0x3e, 0x3f, 0x40,
 
153
        0x41, 0x42, 0x43, 0x44, 0x46, 0x47, 0x48, 0x4a,
 
154
        0x4b, 0x4d, 0x4e, 0x50, 0x51, 0x52, 0x53, 0x54,
 
155
        0x55, 0x56, 0x58, 0x59, 0x5b, 0x5c, 0x5e, 0x5f,
 
156
        0x60, 0x61, 0x62, 0x64, 0x65, 0x66, 0x67, 0x69,
 
157
        0x6a, 0x6c, 0x6d, 0x6f, 0x70, 0x71, 0x72, 0x73,
 
158
        0x75, 0x76, 0x77, 0x79, 0x7a, 0x7c, 0x7d, 0x7f,
 
159
};
 
160
 
 
161
/*
 
162
 * dB tables
 
163
 */
 
164
static const DECLARE_TLV_DB_SCALE(db_scale_vol_datt, -6350, 50, 1);
 
165
static const DECLARE_TLV_DB_SCALE(db_scale_8bit, -12750, 50, 1);
 
166
static const DECLARE_TLV_DB_SCALE(db_scale_7bit, -6350, 50, 1);
 
167
static const DECLARE_TLV_DB_LINEAR(db_scale_linear, TLV_DB_GAIN_MUTE, 0);
 
168
 
 
169
/*
 
170
 * initialize all the ak4xxx chips
 
171
 */
 
172
void snd_akm4xxx_init(struct snd_akm4xxx *ak)
 
173
{
 
174
        static const unsigned char inits_ak4524[] = {
 
175
                0x00, 0x07, /* 0: all power up */
 
176
                0x01, 0x00, /* 1: ADC/DAC reset */
 
177
                0x02, 0x60, /* 2: 24bit I2S */
 
178
                0x03, 0x19, /* 3: deemphasis off */
 
179
                0x01, 0x03, /* 1: ADC/DAC enable */
 
180
                0x04, 0x00, /* 4: ADC left muted */
 
181
                0x05, 0x00, /* 5: ADC right muted */
 
182
                0x06, 0x00, /* 6: DAC left muted */
 
183
                0x07, 0x00, /* 7: DAC right muted */
 
184
                0xff, 0xff
 
185
        };
 
186
        static const unsigned char inits_ak4528[] = {
 
187
                0x00, 0x07, /* 0: all power up */
 
188
                0x01, 0x00, /* 1: ADC/DAC reset */
 
189
                0x02, 0x60, /* 2: 24bit I2S */
 
190
                0x03, 0x0d, /* 3: deemphasis off, turn LR highpass filters on */
 
191
                0x01, 0x03, /* 1: ADC/DAC enable */
 
192
                0x04, 0x00, /* 4: ADC left muted */
 
193
                0x05, 0x00, /* 5: ADC right muted */
 
194
                0xff, 0xff
 
195
        };
 
196
        static const unsigned char inits_ak4529[] = {
 
197
                0x09, 0x01, /* 9: ATS=0, RSTN=1 */
 
198
                0x0a, 0x3f, /* A: all power up, no zero/overflow detection */
 
199
                0x00, 0x0c, /* 0: TDM=0, 24bit I2S, SMUTE=0 */
 
200
                0x01, 0x00, /* 1: ACKS=0, ADC, loop off */
 
201
                0x02, 0xff, /* 2: LOUT1 muted */
 
202
                0x03, 0xff, /* 3: ROUT1 muted */
 
203
                0x04, 0xff, /* 4: LOUT2 muted */
 
204
                0x05, 0xff, /* 5: ROUT2 muted */
 
205
                0x06, 0xff, /* 6: LOUT3 muted */
 
206
                0x07, 0xff, /* 7: ROUT3 muted */
 
207
                0x0b, 0xff, /* B: LOUT4 muted */
 
208
                0x0c, 0xff, /* C: ROUT4 muted */
 
209
                0x08, 0x55, /* 8: deemphasis all off */
 
210
                0xff, 0xff
 
211
        };
 
212
        static const unsigned char inits_ak4355[] = {
 
213
                0x01, 0x02, /* 1: reset and soft-mute */
 
214
                0x00, 0x06, /* 0: mode3(i2s), disable auto-clock detect,
 
215
                             * disable DZF, sharp roll-off, RSTN#=0 */
 
216
                0x02, 0x0e, /* 2: DA's power up, normal speed, RSTN#=0 */
 
217
                // 0x02, 0x2e, /* quad speed */
 
218
                0x03, 0x01, /* 3: de-emphasis off */
 
219
                0x04, 0x00, /* 4: LOUT1 volume muted */
 
220
                0x05, 0x00, /* 5: ROUT1 volume muted */
 
221
                0x06, 0x00, /* 6: LOUT2 volume muted */
 
222
                0x07, 0x00, /* 7: ROUT2 volume muted */
 
223
                0x08, 0x00, /* 8: LOUT3 volume muted */
 
224
                0x09, 0x00, /* 9: ROUT3 volume muted */
 
225
                0x0a, 0x00, /* a: DATT speed=0, ignore DZF */
 
226
                0x01, 0x01, /* 1: un-reset, unmute */
 
227
                0xff, 0xff
 
228
        };
 
229
        static const unsigned char inits_ak4358[] = {
 
230
                0x01, 0x02, /* 1: reset and soft-mute */
 
231
                0x00, 0x06, /* 0: mode3(i2s), disable auto-clock detect,
 
232
                             * disable DZF, sharp roll-off, RSTN#=0 */
 
233
                0x02, 0x4e, /* 2: DA's power up, normal speed, RSTN#=0 */
 
234
                /* 0x02, 0x6e,*/ /* quad speed */
 
235
                0x03, 0x01, /* 3: de-emphasis off */
 
236
                0x04, 0x00, /* 4: LOUT1 volume muted */
 
237
                0x05, 0x00, /* 5: ROUT1 volume muted */
 
238
                0x06, 0x00, /* 6: LOUT2 volume muted */
 
239
                0x07, 0x00, /* 7: ROUT2 volume muted */
 
240
                0x08, 0x00, /* 8: LOUT3 volume muted */
 
241
                0x09, 0x00, /* 9: ROUT3 volume muted */
 
242
                0x0b, 0x00, /* b: LOUT4 volume muted */
 
243
                0x0c, 0x00, /* c: ROUT4 volume muted */
 
244
                0x0a, 0x00, /* a: DATT speed=0, ignore DZF */
 
245
                0x01, 0x01, /* 1: un-reset, unmute */
 
246
                0xff, 0xff
 
247
        };
 
248
        static const unsigned char inits_ak4381[] = {
 
249
                0x00, 0x0c, /* 0: mode3(i2s), disable auto-clock detect */
 
250
                0x01, 0x02, /* 1: de-emphasis off, normal speed,
 
251
                             * sharp roll-off, DZF off */
 
252
                // 0x01, 0x12, /* quad speed */
 
253
                0x02, 0x00, /* 2: DZF disabled */
 
254
                0x03, 0x00, /* 3: LATT 0 */
 
255
                0x04, 0x00, /* 4: RATT 0 */
 
256
                0x00, 0x0f, /* 0: power-up, un-reset */
 
257
                0xff, 0xff
 
258
        };
 
259
        static const unsigned char inits_ak4620[] = {
 
260
                0x00, 0x07, /* 0: normal */
 
261
                0x01, 0x00, /* 0: reset */
 
262
                0x01, 0x02, /* 1: RSTAD */
 
263
                0x01, 0x03, /* 1: RSTDA */
 
264
                0x01, 0x0f, /* 1: normal */
 
265
                0x02, 0x60, /* 2: 24bit I2S */
 
266
                0x03, 0x01, /* 3: deemphasis off */
 
267
                0x04, 0x00, /* 4: LIN muted */
 
268
                0x05, 0x00, /* 5: RIN muted */
 
269
                0x06, 0x00, /* 6: LOUT muted */
 
270
                0x07, 0x00, /* 7: ROUT muted */
 
271
                0xff, 0xff
 
272
        };
 
273
 
 
274
        int chip;
 
275
        const unsigned char *ptr, *inits;
 
276
        unsigned char reg, data;
 
277
 
 
278
        memset(ak->images, 0, sizeof(ak->images));
 
279
        memset(ak->volumes, 0, sizeof(ak->volumes));
 
280
 
 
281
        switch (ak->type) {
 
282
        case SND_AK4524:
 
283
                inits = inits_ak4524;
 
284
                ak->num_chips = ak->num_dacs / 2;
 
285
                ak->name = "ak4524";
 
286
                ak->total_regs = 0x08;
 
287
                break;
 
288
        case SND_AK4528:
 
289
                inits = inits_ak4528;
 
290
                ak->num_chips = ak->num_dacs / 2;
 
291
                ak->name = "ak4528";
 
292
                ak->total_regs = 0x06;
 
293
                break;
 
294
        case SND_AK4529:
 
295
                inits = inits_ak4529;
 
296
                ak->num_chips = 1;
 
297
                ak->name = "ak4529";
 
298
                ak->total_regs = 0x0d;
 
299
                break;
 
300
        case SND_AK4355:
 
301
                inits = inits_ak4355;
 
302
                ak->num_chips = 1;
 
303
                ak->name = "ak4355";
 
304
                ak->total_regs = 0x0b;
 
305
                break;
 
306
        case SND_AK4358:
 
307
                inits = inits_ak4358;
 
308
                ak->num_chips = 1;
 
309
                ak->name = "ak4358";
 
310
                ak->total_regs = 0x10;
 
311
                break;
 
312
        case SND_AK4381:
 
313
                inits = inits_ak4381;
 
314
                ak->num_chips = ak->num_dacs / 2;
 
315
                ak->name = "ak4381";
 
316
                ak->total_regs = 0x05;
 
317
                break;
 
318
        case SND_AK5365:
 
319
                /* FIXME: any init sequence? */
 
320
                ak->num_chips = 1;
 
321
                ak->name = "ak5365";
 
322
                ak->total_regs = 0x08;
 
323
                return;
 
324
        case SND_AK4620:
 
325
                inits = inits_ak4620;
 
326
                ak->num_chips = ak->num_dacs / 2;
 
327
                ak->name = "ak4620";
 
328
                ak->total_regs = 0x08;
 
329
                break;
 
330
        default:
 
331
                snd_BUG();
 
332
                return;
 
333
        }
 
334
 
 
335
        for (chip = 0; chip < ak->num_chips; chip++) {
 
336
                ptr = inits;
 
337
                while (*ptr != 0xff) {
 
338
                        reg = *ptr++;
 
339
                        data = *ptr++;
 
340
                        snd_akm4xxx_write(ak, chip, reg, data);
 
341
                        udelay(10);
 
342
                }
 
343
        }
 
344
}
 
345
 
 
346
EXPORT_SYMBOL(snd_akm4xxx_init);
 
347
 
 
348
/*
 
349
 * Mixer callbacks
 
350
 */
 
351
#define AK_IPGA                         (1<<20) /* including IPGA */
 
352
#define AK_VOL_CVT                      (1<<21) /* need dB conversion */
 
353
#define AK_NEEDSMSB                     (1<<22) /* need MSB update bit */
 
354
#define AK_INVERT                       (1<<23) /* data is inverted */
 
355
#define AK_GET_CHIP(val)                (((val) >> 8) & 0xff)
 
356
#define AK_GET_ADDR(val)                ((val) & 0xff)
 
357
#define AK_GET_SHIFT(val)               (((val) >> 16) & 0x0f)
 
358
#define AK_GET_VOL_CVT(val)             (((val) >> 21) & 1)
 
359
#define AK_GET_IPGA(val)                (((val) >> 20) & 1)
 
360
#define AK_GET_NEEDSMSB(val)            (((val) >> 22) & 1)
 
361
#define AK_GET_INVERT(val)              (((val) >> 23) & 1)
 
362
#define AK_GET_MASK(val)                (((val) >> 24) & 0xff)
 
363
#define AK_COMPOSE(chip,addr,shift,mask) \
 
364
        (((chip) << 8) | (addr) | ((shift) << 16) | ((mask) << 24))
 
365
 
 
366
static int snd_akm4xxx_volume_info(struct snd_kcontrol *kcontrol,
 
367
                                   struct snd_ctl_elem_info *uinfo)
 
368
{
 
369
        unsigned int mask = AK_GET_MASK(kcontrol->private_value);
 
370
 
 
371
        uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
 
372
        uinfo->count = 1;
 
373
        uinfo->value.integer.min = 0;
 
374
        uinfo->value.integer.max = mask;
 
375
        return 0;
 
376
}
 
377
 
 
378
static int snd_akm4xxx_volume_get(struct snd_kcontrol *kcontrol,
 
379
                                  struct snd_ctl_elem_value *ucontrol)
 
380
{
 
381
        struct snd_akm4xxx *ak = snd_kcontrol_chip(kcontrol);
 
382
        int chip = AK_GET_CHIP(kcontrol->private_value);
 
383
        int addr = AK_GET_ADDR(kcontrol->private_value);
 
384
 
 
385
        ucontrol->value.integer.value[0] = snd_akm4xxx_get_vol(ak, chip, addr);
 
386
        return 0;
 
387
}
 
388
 
 
389
static int put_ak_reg(struct snd_kcontrol *kcontrol, int addr,
 
390
                      unsigned char nval)
 
391
{
 
392
        struct snd_akm4xxx *ak = snd_kcontrol_chip(kcontrol);
 
393
        unsigned int mask = AK_GET_MASK(kcontrol->private_value);
 
394
        int chip = AK_GET_CHIP(kcontrol->private_value);
 
395
 
 
396
        if (snd_akm4xxx_get_vol(ak, chip, addr) == nval)
 
397
                return 0;
 
398
 
 
399
        snd_akm4xxx_set_vol(ak, chip, addr, nval);
 
400
        if (AK_GET_VOL_CVT(kcontrol->private_value) && nval < 128)
 
401
                nval = vol_cvt_datt[nval];
 
402
        if (AK_GET_IPGA(kcontrol->private_value) && nval >= 128)
 
403
                nval++; /* need to correct + 1 since both 127 and 128 are 0dB */
 
404
        if (AK_GET_INVERT(kcontrol->private_value))
 
405
                nval = mask - nval;
 
406
        if (AK_GET_NEEDSMSB(kcontrol->private_value))
 
407
                nval |= 0x80;
 
408
        /* printk(KERN_DEBUG "DEBUG - AK writing reg: chip %x addr %x,
 
409
           nval %x\n", chip, addr, nval); */
 
410
        snd_akm4xxx_write(ak, chip, addr, nval);
 
411
        return 1;
 
412
}
 
413
 
 
414
static int snd_akm4xxx_volume_put(struct snd_kcontrol *kcontrol,
 
415
                                  struct snd_ctl_elem_value *ucontrol)
 
416
{
 
417
        unsigned int mask = AK_GET_MASK(kcontrol->private_value);
 
418
        unsigned int val = ucontrol->value.integer.value[0];
 
419
        if (val > mask)
 
420
                return -EINVAL;
 
421
        return put_ak_reg(kcontrol, AK_GET_ADDR(kcontrol->private_value), val);
 
422
}
 
423
 
 
424
static int snd_akm4xxx_stereo_volume_info(struct snd_kcontrol *kcontrol,
 
425
                                          struct snd_ctl_elem_info *uinfo)
 
426
{
 
427
        unsigned int mask = AK_GET_MASK(kcontrol->private_value);
 
428
 
 
429
        uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
 
430
        uinfo->count = 2;
 
431
        uinfo->value.integer.min = 0;
 
432
        uinfo->value.integer.max = mask;
 
433
        return 0;
 
434
}
 
435
 
 
436
static int snd_akm4xxx_stereo_volume_get(struct snd_kcontrol *kcontrol,
 
437
                                         struct snd_ctl_elem_value *ucontrol)
 
438
{
 
439
        struct snd_akm4xxx *ak = snd_kcontrol_chip(kcontrol);
 
440
        int chip = AK_GET_CHIP(kcontrol->private_value);
 
441
        int addr = AK_GET_ADDR(kcontrol->private_value);
 
442
 
 
443
        ucontrol->value.integer.value[0] = snd_akm4xxx_get_vol(ak, chip, addr);
 
444
        ucontrol->value.integer.value[1] = snd_akm4xxx_get_vol(ak, chip, addr+1);
 
445
        return 0;
 
446
}
 
447
 
 
448
static int snd_akm4xxx_stereo_volume_put(struct snd_kcontrol *kcontrol,
 
449
                                         struct snd_ctl_elem_value *ucontrol)
 
450
{
 
451
        int addr = AK_GET_ADDR(kcontrol->private_value);
 
452
        unsigned int mask = AK_GET_MASK(kcontrol->private_value);
 
453
        unsigned int val[2];
 
454
        int change;
 
455
 
 
456
        val[0] = ucontrol->value.integer.value[0];
 
457
        val[1] = ucontrol->value.integer.value[1];
 
458
        if (val[0] > mask || val[1] > mask)
 
459
                return -EINVAL;
 
460
        change = put_ak_reg(kcontrol, addr, val[0]);
 
461
        change |= put_ak_reg(kcontrol, addr + 1, val[1]);
 
462
        return change;
 
463
}
 
464
 
 
465
static int snd_akm4xxx_deemphasis_info(struct snd_kcontrol *kcontrol,
 
466
                                       struct snd_ctl_elem_info *uinfo)
 
467
{
 
468
        static const char * const texts[4] = {
 
469
                "44.1kHz", "Off", "48kHz", "32kHz",
 
470
        };
 
471
        return snd_ctl_enum_info(uinfo, 1, 4, texts);
 
472
}
 
473
 
 
474
static int snd_akm4xxx_deemphasis_get(struct snd_kcontrol *kcontrol,
 
475
                                      struct snd_ctl_elem_value *ucontrol)
 
476
{
 
477
        struct snd_akm4xxx *ak = snd_kcontrol_chip(kcontrol);
 
478
        int chip = AK_GET_CHIP(kcontrol->private_value);
 
479
        int addr = AK_GET_ADDR(kcontrol->private_value);
 
480
        int shift = AK_GET_SHIFT(kcontrol->private_value);
 
481
        ucontrol->value.enumerated.item[0] =
 
482
                (snd_akm4xxx_get(ak, chip, addr) >> shift) & 3;
 
483
        return 0;
 
484
}
 
485
 
 
486
static int snd_akm4xxx_deemphasis_put(struct snd_kcontrol *kcontrol,
 
487
                                      struct snd_ctl_elem_value *ucontrol)
 
488
{
 
489
        struct snd_akm4xxx *ak = snd_kcontrol_chip(kcontrol);
 
490
        int chip = AK_GET_CHIP(kcontrol->private_value);
 
491
        int addr = AK_GET_ADDR(kcontrol->private_value);
 
492
        int shift = AK_GET_SHIFT(kcontrol->private_value);
 
493
        unsigned char nval = ucontrol->value.enumerated.item[0] & 3;
 
494
        int change;
 
495
        
 
496
        nval = (nval << shift) |
 
497
                (snd_akm4xxx_get(ak, chip, addr) & ~(3 << shift));
 
498
        change = snd_akm4xxx_get(ak, chip, addr) != nval;
 
499
        if (change)
 
500
                snd_akm4xxx_write(ak, chip, addr, nval);
 
501
        return change;
 
502
}
 
503
 
 
504
#define ak4xxx_switch_info      snd_ctl_boolean_mono_info
 
505
 
 
506
static int ak4xxx_switch_get(struct snd_kcontrol *kcontrol,
 
507
                             struct snd_ctl_elem_value *ucontrol)
 
508
{
 
509
        struct snd_akm4xxx *ak = snd_kcontrol_chip(kcontrol);
 
510
        int chip = AK_GET_CHIP(kcontrol->private_value);
 
511
        int addr = AK_GET_ADDR(kcontrol->private_value);
 
512
        int shift = AK_GET_SHIFT(kcontrol->private_value);
 
513
        int invert = AK_GET_INVERT(kcontrol->private_value);
 
514
        /* we observe the (1<<shift) bit only */
 
515
        unsigned char val = snd_akm4xxx_get(ak, chip, addr) & (1<<shift);
 
516
        if (invert)
 
517
                val = ! val;
 
518
        ucontrol->value.integer.value[0] = (val & (1<<shift)) != 0;
 
519
        return 0;
 
520
}
 
521
 
 
522
static int ak4xxx_switch_put(struct snd_kcontrol *kcontrol,
 
523
                             struct snd_ctl_elem_value *ucontrol)
 
524
{
 
525
        struct snd_akm4xxx *ak = snd_kcontrol_chip(kcontrol);
 
526
        int chip = AK_GET_CHIP(kcontrol->private_value);
 
527
        int addr = AK_GET_ADDR(kcontrol->private_value);
 
528
        int shift = AK_GET_SHIFT(kcontrol->private_value);
 
529
        int invert = AK_GET_INVERT(kcontrol->private_value);
 
530
        long flag = ucontrol->value.integer.value[0];
 
531
        unsigned char val, oval;
 
532
        int change;
 
533
 
 
534
        if (invert)
 
535
                flag = ! flag;
 
536
        oval = snd_akm4xxx_get(ak, chip, addr);
 
537
        if (flag)
 
538
                val = oval | (1<<shift);
 
539
        else
 
540
                val = oval & ~(1<<shift);
 
541
        change = (oval != val);
 
542
        if (change)
 
543
                snd_akm4xxx_write(ak, chip, addr, val);
 
544
        return change;
 
545
}
 
546
 
 
547
#define AK5365_NUM_INPUTS 5
 
548
 
 
549
static int ak4xxx_capture_num_inputs(struct snd_akm4xxx *ak, int mixer_ch)
 
550
{
 
551
        int num_names;
 
552
        const char **input_names;
 
553
 
 
554
        input_names = ak->adc_info[mixer_ch].input_names;
 
555
        num_names = 0;
 
556
        while (num_names < AK5365_NUM_INPUTS && input_names[num_names])
 
557
                ++num_names;
 
558
        return num_names;
 
559
}
 
560
 
 
561
static int ak4xxx_capture_source_info(struct snd_kcontrol *kcontrol,
 
562
                                      struct snd_ctl_elem_info *uinfo)
 
563
{
 
564
        struct snd_akm4xxx *ak = snd_kcontrol_chip(kcontrol);
 
565
        int mixer_ch = AK_GET_SHIFT(kcontrol->private_value);
 
566
        unsigned int num_names;
 
567
 
 
568
        num_names = ak4xxx_capture_num_inputs(ak, mixer_ch);
 
569
        if (!num_names)
 
570
                return -EINVAL;
 
571
        return snd_ctl_enum_info(uinfo, 1, num_names,
 
572
                                 ak->adc_info[mixer_ch].input_names);
 
573
}
 
574
 
 
575
static int ak4xxx_capture_source_get(struct snd_kcontrol *kcontrol,
 
576
                                     struct snd_ctl_elem_value *ucontrol)
 
577
{
 
578
        struct snd_akm4xxx *ak = snd_kcontrol_chip(kcontrol);
 
579
        int chip = AK_GET_CHIP(kcontrol->private_value);
 
580
        int addr = AK_GET_ADDR(kcontrol->private_value);
 
581
        int mask = AK_GET_MASK(kcontrol->private_value);
 
582
        unsigned char val;
 
583
 
 
584
        val = snd_akm4xxx_get(ak, chip, addr) & mask;
 
585
        ucontrol->value.enumerated.item[0] = val;
 
586
        return 0;
 
587
}
 
588
 
 
589
static int ak4xxx_capture_source_put(struct snd_kcontrol *kcontrol,
 
590
                                     struct snd_ctl_elem_value *ucontrol)
 
591
{
 
592
        struct snd_akm4xxx *ak = snd_kcontrol_chip(kcontrol);
 
593
        int mixer_ch = AK_GET_SHIFT(kcontrol->private_value);
 
594
        int chip = AK_GET_CHIP(kcontrol->private_value);
 
595
        int addr = AK_GET_ADDR(kcontrol->private_value);
 
596
        int mask = AK_GET_MASK(kcontrol->private_value);
 
597
        unsigned char oval, val;
 
598
        int num_names = ak4xxx_capture_num_inputs(ak, mixer_ch);
 
599
 
 
600
        if (ucontrol->value.enumerated.item[0] >= num_names)
 
601
                return -EINVAL;
 
602
 
 
603
        oval = snd_akm4xxx_get(ak, chip, addr);
 
604
        val = oval & ~mask;
 
605
        val |= ucontrol->value.enumerated.item[0] & mask;
 
606
        if (val != oval) {
 
607
                snd_akm4xxx_write(ak, chip, addr, val);
 
608
                return 1;
 
609
        }
 
610
        return 0;
 
611
}
 
612
 
 
613
/*
 
614
 * build AK4xxx controls
 
615
 */
 
616
 
 
617
static int build_dac_controls(struct snd_akm4xxx *ak)
 
618
{
 
619
        int idx, err, mixer_ch, num_stereo;
 
620
        struct snd_kcontrol_new knew;
 
621
 
 
622
        mixer_ch = 0;
 
623
        for (idx = 0; idx < ak->num_dacs; ) {
 
624
                /* mute control for Revolution 7.1 - AK4381 */
 
625
                if (ak->type == SND_AK4381 
 
626
                                &&  ak->dac_info[mixer_ch].switch_name) {
 
627
                        memset(&knew, 0, sizeof(knew));
 
628
                        knew.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
 
629
                        knew.count = 1;
 
630
                        knew.access = SNDRV_CTL_ELEM_ACCESS_READWRITE;
 
631
                        knew.name = ak->dac_info[mixer_ch].switch_name;
 
632
                        knew.info = ak4xxx_switch_info;
 
633
                        knew.get = ak4xxx_switch_get;
 
634
                        knew.put = ak4xxx_switch_put;
 
635
                        knew.access = 0;
 
636
                        /* register 1, bit 0 (SMUTE): 0 = normal operation,
 
637
                           1 = mute */
 
638
                        knew.private_value =
 
639
                                AK_COMPOSE(idx/2, 1, 0, 0) | AK_INVERT;
 
640
                        err = snd_ctl_add(ak->card, snd_ctl_new1(&knew, ak));
 
641
                        if (err < 0)
 
642
                                return err;
 
643
                }
 
644
                memset(&knew, 0, sizeof(knew));
 
645
                if (! ak->dac_info || ! ak->dac_info[mixer_ch].name) {
 
646
                        knew.name = "DAC Volume";
 
647
                        knew.index = mixer_ch + ak->idx_offset * 2;
 
648
                        num_stereo = 1;
 
649
                } else {
 
650
                        knew.name = ak->dac_info[mixer_ch].name;
 
651
                        num_stereo = ak->dac_info[mixer_ch].num_channels;
 
652
                }
 
653
                knew.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
 
654
                knew.count = 1;
 
655
                knew.access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
 
656
                        SNDRV_CTL_ELEM_ACCESS_TLV_READ;
 
657
                if (num_stereo == 2) {
 
658
                        knew.info = snd_akm4xxx_stereo_volume_info;
 
659
                        knew.get = snd_akm4xxx_stereo_volume_get;
 
660
                        knew.put = snd_akm4xxx_stereo_volume_put;
 
661
                } else {
 
662
                        knew.info = snd_akm4xxx_volume_info;
 
663
                        knew.get = snd_akm4xxx_volume_get;
 
664
                        knew.put = snd_akm4xxx_volume_put;
 
665
                }
 
666
                switch (ak->type) {
 
667
                case SND_AK4524:
 
668
                        /* register 6 & 7 */
 
669
                        knew.private_value =
 
670
                                AK_COMPOSE(idx/2, (idx%2) + 6, 0, 127) |
 
671
                                AK_VOL_CVT;
 
672
                        knew.tlv.p = db_scale_vol_datt;
 
673
                        break;
 
674
                case SND_AK4528:
 
675
                        /* register 4 & 5 */
 
676
                        knew.private_value =
 
677
                                AK_COMPOSE(idx/2, (idx%2) + 4, 0, 127) |
 
678
                                AK_VOL_CVT;
 
679
                        knew.tlv.p = db_scale_vol_datt;
 
680
                        break;
 
681
                case SND_AK4529: {
 
682
                        /* registers 2-7 and b,c */
 
683
                        int val = idx < 6 ? idx + 2 : (idx - 6) + 0xb;
 
684
                        knew.private_value =
 
685
                                AK_COMPOSE(0, val, 0, 255) | AK_INVERT;
 
686
                        knew.tlv.p = db_scale_8bit;
 
687
                        break;
 
688
                }
 
689
                case SND_AK4355:
 
690
                        /* register 4-9, chip #0 only */
 
691
                        knew.private_value = AK_COMPOSE(0, idx + 4, 0, 255);
 
692
                        knew.tlv.p = db_scale_8bit;
 
693
                        break;
 
694
                case SND_AK4358: {
 
695
                        /* register 4-9 and 11-12, chip #0 only */
 
696
                        int  addr = idx < 6 ? idx + 4 : idx + 5;
 
697
                        knew.private_value =
 
698
                                AK_COMPOSE(0, addr, 0, 127) | AK_NEEDSMSB;
 
699
                        knew.tlv.p = db_scale_7bit;
 
700
                        break;
 
701
                }
 
702
                case SND_AK4381:
 
703
                        /* register 3 & 4 */
 
704
                        knew.private_value =
 
705
                                AK_COMPOSE(idx/2, (idx%2) + 3, 0, 255);
 
706
                        knew.tlv.p = db_scale_linear;
 
707
                        break;
 
708
                case SND_AK4620:
 
709
                        /* register 6 & 7 */
 
710
                        knew.private_value =
 
711
                                AK_COMPOSE(idx/2, (idx%2) + 6, 0, 255);
 
712
                        knew.tlv.p = db_scale_linear;
 
713
                        break;
 
714
                default:
 
715
                        return -EINVAL;
 
716
                }
 
717
 
 
718
                err = snd_ctl_add(ak->card, snd_ctl_new1(&knew, ak));
 
719
                if (err < 0)
 
720
                        return err;
 
721
 
 
722
                idx += num_stereo;
 
723
                mixer_ch++;
 
724
        }
 
725
        return 0;
 
726
}
 
727
 
 
728
static int build_adc_controls(struct snd_akm4xxx *ak)
 
729
{
 
730
        int idx, err, mixer_ch, num_stereo, max_steps;
 
731
        struct snd_kcontrol_new knew;
 
732
 
 
733
        mixer_ch = 0;
 
734
        if (ak->type == SND_AK4528)
 
735
                return 0;       /* no controls */
 
736
        for (idx = 0; idx < ak->num_adcs;) {
 
737
                memset(&knew, 0, sizeof(knew));
 
738
                if (! ak->adc_info || ! ak->adc_info[mixer_ch].name) {
 
739
                        knew.name = "ADC Volume";
 
740
                        knew.index = mixer_ch + ak->idx_offset * 2;
 
741
                        num_stereo = 1;
 
742
                } else {
 
743
                        knew.name = ak->adc_info[mixer_ch].name;
 
744
                        num_stereo = ak->adc_info[mixer_ch].num_channels;
 
745
                }
 
746
                knew.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
 
747
                knew.count = 1;
 
748
                knew.access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
 
749
                        SNDRV_CTL_ELEM_ACCESS_TLV_READ;
 
750
                if (num_stereo == 2) {
 
751
                        knew.info = snd_akm4xxx_stereo_volume_info;
 
752
                        knew.get = snd_akm4xxx_stereo_volume_get;
 
753
                        knew.put = snd_akm4xxx_stereo_volume_put;
 
754
                } else {
 
755
                        knew.info = snd_akm4xxx_volume_info;
 
756
                        knew.get = snd_akm4xxx_volume_get;
 
757
                        knew.put = snd_akm4xxx_volume_put;
 
758
                }
 
759
                /* register 4 & 5 */
 
760
                if (ak->type == SND_AK5365)
 
761
                        max_steps = 152;
 
762
                else
 
763
                        max_steps = 164;
 
764
                knew.private_value =
 
765
                        AK_COMPOSE(idx/2, (idx%2) + 4, 0, max_steps) |
 
766
                        AK_VOL_CVT | AK_IPGA;
 
767
                knew.tlv.p = db_scale_vol_datt;
 
768
                err = snd_ctl_add(ak->card, snd_ctl_new1(&knew, ak));
 
769
                if (err < 0)
 
770
                        return err;
 
771
 
 
772
                if (ak->type == SND_AK5365 && (idx % 2) == 0) {
 
773
                        if (! ak->adc_info || 
 
774
                            ! ak->adc_info[mixer_ch].switch_name) {
 
775
                                knew.name = "Capture Switch";
 
776
                                knew.index = mixer_ch + ak->idx_offset * 2;
 
777
                        } else
 
778
                                knew.name = ak->adc_info[mixer_ch].switch_name;
 
779
                        knew.info = ak4xxx_switch_info;
 
780
                        knew.get = ak4xxx_switch_get;
 
781
                        knew.put = ak4xxx_switch_put;
 
782
                        knew.access = 0;
 
783
                        /* register 2, bit 0 (SMUTE): 0 = normal operation,
 
784
                           1 = mute */
 
785
                        knew.private_value =
 
786
                                AK_COMPOSE(idx/2, 2, 0, 0) | AK_INVERT;
 
787
                        err = snd_ctl_add(ak->card, snd_ctl_new1(&knew, ak));
 
788
                        if (err < 0)
 
789
                                return err;
 
790
 
 
791
                        memset(&knew, 0, sizeof(knew));
 
792
                        knew.name = ak->adc_info[mixer_ch].selector_name;
 
793
                        if (!knew.name) {
 
794
                                knew.name = "Capture Channel";
 
795
                                knew.index = mixer_ch + ak->idx_offset * 2;
 
796
                        }
 
797
 
 
798
                        knew.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
 
799
                        knew.info = ak4xxx_capture_source_info;
 
800
                        knew.get = ak4xxx_capture_source_get;
 
801
                        knew.put = ak4xxx_capture_source_put;
 
802
                        knew.access = 0;
 
803
                        /* input selector control: reg. 1, bits 0-2.
 
804
                         * mis-use 'shift' to pass mixer_ch */
 
805
                        knew.private_value
 
806
                                = AK_COMPOSE(idx/2, 1, mixer_ch, 0x07);
 
807
                        err = snd_ctl_add(ak->card, snd_ctl_new1(&knew, ak));
 
808
                        if (err < 0)
 
809
                                return err;
 
810
                }
 
811
 
 
812
                idx += num_stereo;
 
813
                mixer_ch++;
 
814
        }
 
815
        return 0;
 
816
}
 
817
 
 
818
static int build_deemphasis(struct snd_akm4xxx *ak, int num_emphs)
 
819
{
 
820
        int idx, err;
 
821
        struct snd_kcontrol_new knew;
 
822
 
 
823
        for (idx = 0; idx < num_emphs; idx++) {
 
824
                memset(&knew, 0, sizeof(knew));
 
825
                knew.name = "Deemphasis";
 
826
                knew.index = idx + ak->idx_offset;
 
827
                knew.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
 
828
                knew.count = 1;
 
829
                knew.info = snd_akm4xxx_deemphasis_info;
 
830
                knew.get = snd_akm4xxx_deemphasis_get;
 
831
                knew.put = snd_akm4xxx_deemphasis_put;
 
832
                switch (ak->type) {
 
833
                case SND_AK4524:
 
834
                case SND_AK4528:
 
835
                case SND_AK4620:
 
836
                        /* register 3 */
 
837
                        knew.private_value = AK_COMPOSE(idx, 3, 0, 0);
 
838
                        break;
 
839
                case SND_AK4529: {
 
840
                        int shift = idx == 3 ? 6 : (2 - idx) * 2;
 
841
                        /* register 8 with shift */
 
842
                        knew.private_value = AK_COMPOSE(0, 8, shift, 0);
 
843
                        break;
 
844
                }
 
845
                case SND_AK4355:
 
846
                case SND_AK4358:
 
847
                        knew.private_value = AK_COMPOSE(idx, 3, 0, 0);
 
848
                        break;
 
849
                case SND_AK4381:
 
850
                        knew.private_value = AK_COMPOSE(idx, 1, 1, 0);
 
851
                        break;
 
852
                default:
 
853
                        return -EINVAL;
 
854
                }
 
855
                err = snd_ctl_add(ak->card, snd_ctl_new1(&knew, ak));
 
856
                if (err < 0)
 
857
                        return err;
 
858
        }
 
859
        return 0;
 
860
}
 
861
 
 
862
static void proc_regs_read(struct snd_info_entry *entry,
 
863
                struct snd_info_buffer *buffer)
 
864
{
 
865
        struct snd_akm4xxx *ak = entry->private_data;
 
866
        int reg, val, chip;
 
867
        for (chip = 0; chip < ak->num_chips; chip++) {
 
868
                for (reg = 0; reg < ak->total_regs; reg++) {
 
869
                        val =  snd_akm4xxx_get(ak, chip, reg);
 
870
                        snd_iprintf(buffer, "chip %d: 0x%02x = 0x%02x\n", chip,
 
871
                                        reg, val);
 
872
                }
 
873
        }
 
874
}
 
875
 
 
876
static int proc_init(struct snd_akm4xxx *ak)
 
877
{
 
878
        struct snd_info_entry *entry;
 
879
        int err;
 
880
        err = snd_card_proc_new(ak->card, ak->name, &entry);
 
881
        if (err < 0)
 
882
                return err;
 
883
        snd_info_set_text_ops(entry, ak, proc_regs_read);
 
884
        return 0;
 
885
}
 
886
 
 
887
int snd_akm4xxx_build_controls(struct snd_akm4xxx *ak)
 
888
{
 
889
        int err, num_emphs;
 
890
 
 
891
        err = build_dac_controls(ak);
 
892
        if (err < 0)
 
893
                return err;
 
894
 
 
895
        err = build_adc_controls(ak);
 
896
        if (err < 0)
 
897
                return err;
 
898
        if (ak->type == SND_AK4355 || ak->type == SND_AK4358)
 
899
                num_emphs = 1;
 
900
        else if (ak->type == SND_AK4620)
 
901
                num_emphs = 0;
 
902
        else
 
903
                num_emphs = ak->num_dacs / 2;
 
904
        err = build_deemphasis(ak, num_emphs);
 
905
        if (err < 0)
 
906
                return err;
 
907
        err = proc_init(ak);
 
908
        if (err < 0)
 
909
                return err;
 
910
 
 
911
        return 0;
 
912
}
 
913
EXPORT_SYMBOL(snd_akm4xxx_build_controls);