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@suse.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@suse.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 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 DECLARE_TLV_DB_SCALE(db_scale_vol_datt, -6350, 50, 1);
 166 static DECLARE_TLV_DB_SCALE(db_scale_8bit, -12750, 50, 1);
 167 static DECLARE_TLV_DB_SCALE(db_scale_7bit, -6350, 50, 1);
 168 static 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 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 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 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 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 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 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         unsigned char *ptr, reg, data, *inits;
 263
 264         memset(ak->images, 0, sizeof(ak->images));
 265         memset(ak->volumes, 0, sizeof(ak->volumes));
 266
 267         switch (ak->type) {
 268         case SND_AK4524:
 269                 inits = inits_ak4524;
 270                 num_chips = ak->num_dacs / 2;
 271                 break;
 272         case SND_AK4528:
 273                 inits = inits_ak4528;
 274                 num_chips = ak->num_dacs / 2;
 275                 break;
 276         case SND_AK4529:
 277                 inits = inits_ak4529;
 278                 num_chips = 1;
 279                 break;
 280         case SND_AK4355:
 281                 inits = inits_ak4355;
 282                 num_chips = 1;
 283                 break;
 284         case SND_AK4358:
 285                 inits = inits_ak4358;
 286                 num_chips = 1;
 287                 break;
 288         case SND_AK4381:
 289                 inits = inits_ak4381;
 290                 num_chips = ak->num_dacs / 2;
 291                 break;
 292         case SND_AK5365:
 293                 /* FIXME: any init sequence? */
 294                 return;
 295         default:
 296                 snd_BUG();
 297                 return;
 298         }
 299
 300         for (chip = 0; chip < num_chips; chip++) {
 301                 ptr = inits;
 302                 while (*ptr != 0xff) {
 303                         reg = *ptr++;
 304                         data = *ptr++;
 305                         snd_akm4xxx_write(ak, chip, reg, data);
 306                 }
 307         }
 308 }
 309
 310 EXPORT_SYMBOL(snd_akm4xxx_init);
 311
 312 /*
 313  * Mixer callbacks
 314  */
 315 #define AK_IPGA                         (1<<20) /* including IPGA */
 316 #define AK_VOL_CVT                      (1<<21) /* need dB conversion */
 317 #define AK_NEEDSMSB                     (1<<22) /* need MSB update bit */
 318 #define AK_INVERT                       (1<<23) /* data is inverted */
 319 #define AK_GET_CHIP(val)                (((val) >> 8) & 0xff)
 320 #define AK_GET_ADDR(val)                ((val) & 0xff)
 321 #define AK_GET_SHIFT(val)               (((val) >> 16) & 0x0f)
 322 #define AK_GET_VOL_CVT(val)             (((val) >> 21) & 1)
 323 #define AK_GET_IPGA(val)                (((val) >> 20) & 1)
 324 #define AK_GET_NEEDSMSB(val)            (((val) >> 22) & 1)
 325 #define AK_GET_INVERT(val)              (((val) >> 23) & 1)
 326 #define AK_GET_MASK(val)                (((val) >> 24) & 0xff)
 327 #define AK_COMPOSE(chip,addr,shift,mask) \
 328         (((chip) << 8) | (addr) | ((shift) << 16) | ((mask) << 24))
 329
 330 static int snd_akm4xxx_volume_info(struct snd_kcontrol *kcontrol,
 331                                    struct snd_ctl_elem_info *uinfo)
 332 {
 333         unsigned int mask = AK_GET_MASK(kcontrol->private_value);
 334
 335         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
 336         uinfo->count = 1;
 337         uinfo->value.integer.min = 0;
 338         uinfo->value.integer.max = mask;
 339         return 0;
 340 }
 341
 342 static int snd_akm4xxx_volume_get(struct snd_kcontrol *kcontrol,
 343                                   struct snd_ctl_elem_value *ucontrol)
 344 {
 345         struct snd_akm4xxx *ak = snd_kcontrol_chip(kcontrol);
 346         int chip = AK_GET_CHIP(kcontrol->private_value);
 347         int addr = AK_GET_ADDR(kcontrol->private_value);
 348
 349         ucontrol->value.integer.value[0] = snd_akm4xxx_get_vol(ak, chip, addr);
 350         return 0;
 351 }
 352
 353 static int put_ak_reg(struct snd_kcontrol *kcontrol, int addr,
 354                       unsigned char nval)
 355 {
 356         struct snd_akm4xxx *ak = snd_kcontrol_chip(kcontrol);
 357         unsigned int mask = AK_GET_MASK(kcontrol->private_value);
 358         int chip = AK_GET_CHIP(kcontrol->private_value);
 359
 360         if (snd_akm4xxx_get_vol(ak, chip, addr) == nval)
 361                 return 0;
 362
 363         snd_akm4xxx_set_vol(ak, chip, addr, nval);
 364         if (AK_GET_VOL_CVT(kcontrol->private_value) && nval < 128)
 365                 nval = vol_cvt_datt[nval];
 366         if (AK_GET_IPGA(kcontrol->private_value) && nval >= 128)
 367                 nval++; /* need to correct + 1 since both 127 and 128 are 0dB */
 368         if (AK_GET_INVERT(kcontrol->private_value))
 369                 nval = mask - nval;
 370         if (AK_GET_NEEDSMSB(kcontrol->private_value))
 371                 nval |= 0x80;
 372         snd_akm4xxx_write(ak, chip, addr, nval);
 373         return 1;
 374 }
 375
 376 static int snd_akm4xxx_volume_put(struct snd_kcontrol *kcontrol,
 377                                   struct snd_ctl_elem_value *ucontrol)
 378 {
 379         return put_ak_reg(kcontrol, AK_GET_ADDR(kcontrol->private_value),
 380                           ucontrol->value.integer.value[0]);
 381 }
 382
 383 static int snd_akm4xxx_stereo_volume_info(struct snd_kcontrol *kcontrol,
 384                                           struct snd_ctl_elem_info *uinfo)
 385 {
 386         unsigned int mask = AK_GET_MASK(kcontrol->private_value);
 387
 388         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
 389         uinfo->count = 2;
 390         uinfo->value.integer.min = 0;
 391         uinfo->value.integer.max = mask;
 392         return 0;
 393 }
 394
 395 static int snd_akm4xxx_stereo_volume_get(struct snd_kcontrol *kcontrol,
 396                                          struct snd_ctl_elem_value *ucontrol)
 397 {
 398         struct snd_akm4xxx *ak = snd_kcontrol_chip(kcontrol);
 399         int chip = AK_GET_CHIP(kcontrol->private_value);
 400         int addr = AK_GET_ADDR(kcontrol->private_value);
 401
 402         ucontrol->value.integer.value[0] = snd_akm4xxx_get_vol(ak, chip, addr);
 403         ucontrol->value.integer.value[1] = snd_akm4xxx_get_vol(ak, chip, addr+1);
 404         return 0;
 405 }
 406
 407 static int snd_akm4xxx_stereo_volume_put(struct snd_kcontrol *kcontrol,
 408                                          struct snd_ctl_elem_value *ucontrol)
 409 {
 410         int addr = AK_GET_ADDR(kcontrol->private_value);
 411         int change;
 412
 413         change = put_ak_reg(kcontrol, addr, ucontrol->value.integer.value[0]);
 414         change |= put_ak_reg(kcontrol, addr + 1,
 415                              ucontrol->value.integer.value[1]);
 416         return change;
 417 }
 418
 419 static int snd_akm4xxx_deemphasis_info(struct snd_kcontrol *kcontrol,
 420                                        struct snd_ctl_elem_info *uinfo)
 421 {
 422         static char *texts[4] = {
 423                 "44.1kHz", "Off", "48kHz", "32kHz",
 424         };
 425         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
 426         uinfo->count = 1;
 427         uinfo->value.enumerated.items = 4;
 428         if (uinfo->value.enumerated.item >= 4)
 429                 uinfo->value.enumerated.item = 3;
 430         strcpy(uinfo->value.enumerated.name,
 431                texts[uinfo->value.enumerated.item]);
 432         return 0;
 433 }
 434
 435 static int snd_akm4xxx_deemphasis_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         int shift = AK_GET_SHIFT(kcontrol->private_value);
 442         ucontrol->value.enumerated.item[0] =
 443                 (snd_akm4xxx_get(ak, chip, addr) >> shift) & 3;
 444         return 0;
 445 }
 446
 447 static int snd_akm4xxx_deemphasis_put(struct snd_kcontrol *kcontrol,
 448                                       struct snd_ctl_elem_value *ucontrol)
 449 {
 450         struct snd_akm4xxx *ak = snd_kcontrol_chip(kcontrol);
 451         int chip = AK_GET_CHIP(kcontrol->private_value);
 452         int addr = AK_GET_ADDR(kcontrol->private_value);
 453         int shift = AK_GET_SHIFT(kcontrol->private_value);
 454         unsigned char nval = ucontrol->value.enumerated.item[0] & 3;
 455         int change;
 456
 457         nval = (nval << shift) |
 458                 (snd_akm4xxx_get(ak, chip, addr) & ~(3 << shift));
 459         change = snd_akm4xxx_get(ak, chip, addr) != nval;
 460         if (change)
 461                 snd_akm4xxx_write(ak, chip, addr, nval);
 462         return change;
 463 }
 464
 465 static int ak4xxx_switch_info(struct snd_kcontrol *kcontrol,
 466                               struct snd_ctl_elem_info *uinfo)
 467 {
 468         uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
 469         uinfo->count = 1;
 470         uinfo->value.integer.min = 0;
 471         uinfo->value.integer.max = 1;
 472         return 0;
 473 }
 474
 475 static int ak4xxx_switch_get(struct snd_kcontrol *kcontrol,
 476                              struct snd_ctl_elem_value *ucontrol)
 477 {
 478         struct snd_akm4xxx *ak = snd_kcontrol_chip(kcontrol);
 479         int chip = AK_GET_CHIP(kcontrol->private_value);
 480         int addr = AK_GET_ADDR(kcontrol->private_value);
 481         int shift = AK_GET_SHIFT(kcontrol->private_value);
 482         int invert = AK_GET_INVERT(kcontrol->private_value);
 483         unsigned char val = snd_akm4xxx_get(ak, chip, addr);
 484
 485         if (invert)
 486                 val = ! val;
 487         ucontrol->value.integer.value[0] = (val & (1<<shift)) != 0;
 488         return 0;
 489 }
 490
 491 static int ak4xxx_switch_put(struct snd_kcontrol *kcontrol,
 492                              struct snd_ctl_elem_value *ucontrol)
 493 {
 494         struct snd_akm4xxx *ak = snd_kcontrol_chip(kcontrol);
 495         int chip = AK_GET_CHIP(kcontrol->private_value);
 496         int addr = AK_GET_ADDR(kcontrol->private_value);
 497         int shift = AK_GET_SHIFT(kcontrol->private_value);
 498         int invert = AK_GET_INVERT(kcontrol->private_value);
 499         long flag = ucontrol->value.integer.value[0];
 500         unsigned char val, oval;
 501         int change;
 502
 503         if (invert)
 504                 flag = ! flag;
 505         oval = snd_akm4xxx_get(ak, chip, addr);
 506         if (flag)
 507                 val = oval | (1<<shift);
 508         else
 509                 val = oval & ~(1<<shift);
 510         change = (oval != val);
 511         if (change)
 512                 snd_akm4xxx_write(ak, chip, addr, val);
 513         return change;
 514 }
 515
 516 /*
 517  * build AK4xxx controls
 518  */
 519
 520 static int build_dac_controls(struct snd_akm4xxx *ak)
 521 {
 522         int idx, err, mixer_ch, num_stereo;
 523         struct snd_kcontrol_new knew;
 524
 525         mixer_ch = 0;
 526         for (idx = 0; idx < ak->num_dacs; ) {
 527                 memset(&knew, 0, sizeof(knew));
 528                 if (! ak->dac_info || ! ak->dac_info[mixer_ch].name) {
 529                         knew.name = "DAC Volume";
 530                         knew.index = mixer_ch + ak->idx_offset * 2;
 531                         num_stereo = 1;
 532                 } else {
 533                         knew.name = ak->dac_info[mixer_ch].name;
 534                         num_stereo = ak->dac_info[mixer_ch].num_channels;
 535                 }
 536                 knew.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
 537                 knew.count = 1;
 538                 knew.access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
 539                         SNDRV_CTL_ELEM_ACCESS_TLV_READ;
 540                 if (num_stereo == 2) {
 541                         knew.info = snd_akm4xxx_stereo_volume_info;
 542                         knew.get = snd_akm4xxx_stereo_volume_get;
 543                         knew.put = snd_akm4xxx_stereo_volume_put;
 544                 } else {
 545                         knew.info = snd_akm4xxx_volume_info;
 546                         knew.get = snd_akm4xxx_volume_get;
 547                         knew.put = snd_akm4xxx_volume_put;
 548                 }
 549                 switch (ak->type) {
 550                 case SND_AK4524:
 551                         /* register 6 & 7 */
 552                         knew.private_value =
 553                                 AK_COMPOSE(idx/2, (idx%2) + 6, 0, 127) |
 554                                 AK_VOL_CVT;
 555                         knew.tlv.p = db_scale_vol_datt;
 556                         break;
 557                 case SND_AK4528:
 558                         /* register 4 & 5 */
 559                         knew.private_value =
 560                                 AK_COMPOSE(idx/2, (idx%2) + 4, 0, 127) |
 561                                 AK_VOL_CVT;
 562                         knew.tlv.p = db_scale_vol_datt;
 563                         break;
 564                 case SND_AK4529: {
 565                         /* registers 2-7 and b,c */
 566                         int val = idx < 6 ? idx + 2 : (idx - 6) + 0xb;
 567                         knew.private_value =
 568                                 AK_COMPOSE(0, val, 0, 255) | AK_INVERT;
 569                         knew.tlv.p = db_scale_8bit;
 570                         break;
 571                 }
 572                 case SND_AK4355:
 573                         /* register 4-9, chip #0 only */
 574                         knew.private_value = AK_COMPOSE(0, idx + 4, 0, 255);
 575                         knew.tlv.p = db_scale_8bit;
 576                         break;
 577                 case SND_AK4358: {
 578                         /* register 4-9 and 11-12, chip #0 only */
 579                         int  addr = idx < 6 ? idx + 4 : idx + 5;
 580                         knew.private_value =
 581                                 AK_COMPOSE(0, addr, 0, 127) | AK_NEEDSMSB;
 582                         knew.tlv.p = db_scale_7bit;
 583                         break;
 584                 }
 585                 case SND_AK4381:
 586                         /* register 3 & 4 */
 587                         knew.private_value =
 588                                 AK_COMPOSE(idx/2, (idx%2) + 3, 0, 255);
 589                         knew.tlv.p = db_scale_linear;
 590                         break;
 591                 default:
 592                         return -EINVAL;
 593                 }
 594
 595                 err = snd_ctl_add(ak->card, snd_ctl_new1(&knew, ak));
 596                 if (err < 0)
 597                         return err;
 598
 599                 idx += num_stereo;
 600                 mixer_ch++;
 601         }
 602         return 0;
 603 }
 604
 605 static int build_adc_controls(struct snd_akm4xxx *ak)
 606 {
 607         int idx, err, mixer_ch, num_stereo;
 608         struct snd_kcontrol_new knew;
 609
 610         mixer_ch = 0;
 611         for (idx = 0; idx < ak->num_adcs;) {
 612                 memset(&knew, 0, sizeof(knew));
 613                 if (! ak->adc_info || ! ak->adc_info[mixer_ch].name) {
 614                         knew.name = "ADC Volume";
 615                         knew.index = mixer_ch + ak->idx_offset * 2;
 616                         num_stereo = 1;
 617                 } else {
 618                         knew.name = ak->adc_info[mixer_ch].name;
 619                         num_stereo = ak->adc_info[mixer_ch].num_channels;
 620                 }
 621                 knew.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
 622                 knew.count = 1;
 623                 knew.access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
 624                         SNDRV_CTL_ELEM_ACCESS_TLV_READ;
 625                 if (num_stereo == 2) {
 626                         knew.info = snd_akm4xxx_stereo_volume_info;
 627                         knew.get = snd_akm4xxx_stereo_volume_get;
 628                         knew.put = snd_akm4xxx_stereo_volume_put;
 629                 } else {
 630                         knew.info = snd_akm4xxx_volume_info;
 631                         knew.get = snd_akm4xxx_volume_get;
 632                         knew.put = snd_akm4xxx_volume_put;
 633                 }
 634                 /* register 4 & 5 */
 635                 if (ak->type == SND_AK5365)
 636                         knew.private_value =
 637                                 AK_COMPOSE(idx/2, (idx%2) + 4, 0, 151) |
 638                                 AK_VOL_CVT | AK_IPGA;
 639                 else
 640                         knew.private_value =
 641                                 AK_COMPOSE(idx/2, (idx%2) + 4, 0, 163) |
 642                                 AK_VOL_CVT | AK_IPGA;
 643                 knew.tlv.p = db_scale_vol_datt;
 644                 err = snd_ctl_add(ak->card, snd_ctl_new1(&knew, ak));
 645                 if (err < 0)
 646                         return err;
 647
 648                 if (ak->type == SND_AK5365 && (idx % 2) == 0) {
 649                         if (! ak->adc_info ||
 650                             ! ak->adc_info[mixer_ch].switch_name)
 651                                 knew.name = "Capture Switch";
 652                         else
 653                                 knew.name = ak->adc_info[mixer_ch].switch_name;
 654                         knew.info = ak4xxx_switch_info;
 655                         knew.get = ak4xxx_switch_get;
 656                         knew.put = ak4xxx_switch_put;
 657                         knew.access = 0;
 658                         /* register 2, bit 0 (SMUTE): 0 = normal operation,
 659                            1 = mute */
 660                         knew.private_value =
 661                                 AK_COMPOSE(idx/2, 2, 0, 0) | AK_INVERT;
 662                         err = snd_ctl_add(ak->card, snd_ctl_new1(&knew, ak));
 663                         if (err < 0)
 664                                 return err;
 665                 }
 666
 667                 idx += num_stereo;
 668                 mixer_ch++;
 669         }
 670         return 0;
 671 }
 672
 673 static int build_deemphasis(struct snd_akm4xxx *ak, int num_emphs)
 674 {
 675         int idx, err;
 676         struct snd_kcontrol_new knew;
 677
 678         for (idx = 0; idx < num_emphs; idx++) {
 679                 memset(&knew, 0, sizeof(knew));
 680                 knew.name = "Deemphasis";
 681                 knew.index = idx + ak->idx_offset;
 682                 knew.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
 683                 knew.count = 1;
 684                 knew.info = snd_akm4xxx_deemphasis_info;
 685                 knew.get = snd_akm4xxx_deemphasis_get;
 686                 knew.put = snd_akm4xxx_deemphasis_put;
 687                 switch (ak->type) {
 688                 case SND_AK4524:
 689                 case SND_AK4528:
 690                         /* register 3 */
 691                         knew.private_value = AK_COMPOSE(idx, 3, 0, 0);
 692                         break;
 693                 case SND_AK4529: {
 694                         int shift = idx == 3 ? 6 : (2 - idx) * 2;
 695                         /* register 8 with shift */
 696                         knew.private_value = AK_COMPOSE(0, 8, shift, 0);
 697                         break;
 698                 }
 699                 case SND_AK4355:
 700                 case SND_AK4358:
 701                         knew.private_value = AK_COMPOSE(idx, 3, 0, 0);
 702                         break;
 703                 case SND_AK4381:
 704                         knew.private_value = AK_COMPOSE(idx, 1, 1, 0);
 705                         break;
 706                 default:
 707                         return -EINVAL;
 708                 }
 709                 err = snd_ctl_add(ak->card, snd_ctl_new1(&knew, ak));
 710                 if (err < 0)
 711                         return err;
 712         }
 713         return 0;
 714 }
 715
 716 int snd_akm4xxx_build_controls(struct snd_akm4xxx *ak)
 717 {
 718         int err, num_emphs;
 719
 720         err = build_dac_controls(ak);
 721         if (err < 0)
 722                 return err;
 723
 724         err = build_adc_controls(ak);
 725         if (err < 0)
 726                 return err;
 727
 728         if (ak->type == SND_AK4355 || ak->type == SND_AK4358)
 729                 num_emphs = 1;
 730         else
 731                 num_emphs = ak->num_dacs / 2;
 732         err = build_deemphasis(ak, num_emphs);
 733         if (err < 0)
 734                 return err;
 735
 736         return 0;
 737 }
 738
 739 EXPORT_SYMBOL(snd_akm4xxx_build_controls);
 740
 741 static int __init alsa_akm4xxx_module_init(void)
 742 {
 743         return 0;
 744 }
 745
 746 static void __exit alsa_akm4xxx_module_exit(void)
 747 {
 748 }
 749
 750 module_init(alsa_akm4xxx_module_init)
 751 module_exit(alsa_akm4xxx_module_exit)