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