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