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