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