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 <linux/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 const char * const texts[4] = {
 469                 "44.1kHz", "Off", "48kHz", "32kHz",
 470         };
 471         return snd_ctl_enum_info(uinfo, 1, 4, texts);
 472 }
 473
 474 static int snd_akm4xxx_deemphasis_get(struct snd_kcontrol *kcontrol,
 475                                       struct snd_ctl_elem_value *ucontrol)
 476 {
 477         struct snd_akm4xxx *ak = snd_kcontrol_chip(kcontrol);
 478         int chip = AK_GET_CHIP(kcontrol->private_value);
 479         int addr = AK_GET_ADDR(kcontrol->private_value);
 480         int shift = AK_GET_SHIFT(kcontrol->private_value);
 481         ucontrol->value.enumerated.item[0] =
 482                 (snd_akm4xxx_get(ak, chip, addr) >> shift) & 3;
 483         return 0;
 484 }
 485
 486 static int snd_akm4xxx_deemphasis_put(struct snd_kcontrol *kcontrol,
 487                                       struct snd_ctl_elem_value *ucontrol)
 488 {
 489         struct snd_akm4xxx *ak = snd_kcontrol_chip(kcontrol);
 490         int chip = AK_GET_CHIP(kcontrol->private_value);
 491         int addr = AK_GET_ADDR(kcontrol->private_value);
 492         int shift = AK_GET_SHIFT(kcontrol->private_value);
 493         unsigned char nval = ucontrol->value.enumerated.item[0] & 3;
 494         int change;
 495
 496         nval = (nval << shift) |
 497                 (snd_akm4xxx_get(ak, chip, addr) & ~(3 << shift));
 498         change = snd_akm4xxx_get(ak, chip, addr) != nval;
 499         if (change)
 500                 snd_akm4xxx_write(ak, chip, addr, nval);
 501         return change;
 502 }
 503
 504 #define ak4xxx_switch_info      snd_ctl_boolean_mono_info
 505
 506 static int ak4xxx_switch_get(struct snd_kcontrol *kcontrol,
 507                              struct snd_ctl_elem_value *ucontrol)
 508 {
 509         struct snd_akm4xxx *ak = snd_kcontrol_chip(kcontrol);
 510         int chip = AK_GET_CHIP(kcontrol->private_value);
 511         int addr = AK_GET_ADDR(kcontrol->private_value);
 512         int shift = AK_GET_SHIFT(kcontrol->private_value);
 513         int invert = AK_GET_INVERT(kcontrol->private_value);
 514         /* we observe the (1<<shift) bit only */
 515         unsigned char val = snd_akm4xxx_get(ak, chip, addr) & (1<<shift);
 516         if (invert)
 517                 val = ! val;
 518         ucontrol->value.integer.value[0] = (val & (1<<shift)) != 0;
 519         return 0;
 520 }
 521
 522 static int ak4xxx_switch_put(struct snd_kcontrol *kcontrol,
 523                              struct snd_ctl_elem_value *ucontrol)
 524 {
 525         struct snd_akm4xxx *ak = snd_kcontrol_chip(kcontrol);
 526         int chip = AK_GET_CHIP(kcontrol->private_value);
 527         int addr = AK_GET_ADDR(kcontrol->private_value);
 528         int shift = AK_GET_SHIFT(kcontrol->private_value);
 529         int invert = AK_GET_INVERT(kcontrol->private_value);
 530         long flag = ucontrol->value.integer.value[0];
 531         unsigned char val, oval;
 532         int change;
 533
 534         if (invert)
 535                 flag = ! flag;
 536         oval = snd_akm4xxx_get(ak, chip, addr);
 537         if (flag)
 538                 val = oval | (1<<shift);
 539         else
 540                 val = oval & ~(1<<shift);
 541         change = (oval != val);
 542         if (change)
 543                 snd_akm4xxx_write(ak, chip, addr, val);
 544         return change;
 545 }
 546
 547 #define AK5365_NUM_INPUTS 5
 548
 549 static int ak4xxx_capture_num_inputs(struct snd_akm4xxx *ak, int mixer_ch)
 550 {
 551         int num_names;
 552         const char **input_names;
 553
 554         input_names = ak->adc_info[mixer_ch].input_names;
 555         num_names = 0;
 556         while (num_names < AK5365_NUM_INPUTS && input_names[num_names])
 557                 ++num_names;
 558         return num_names;
 559 }
 560
 561 static int ak4xxx_capture_source_info(struct snd_kcontrol *kcontrol,
 562                                       struct snd_ctl_elem_info *uinfo)
 563 {
 564         struct snd_akm4xxx *ak = snd_kcontrol_chip(kcontrol);
 565         int mixer_ch = AK_GET_SHIFT(kcontrol->private_value);
 566         unsigned int num_names;
 567
 568         num_names = ak4xxx_capture_num_inputs(ak, mixer_ch);
 569         if (!num_names)
 570                 return -EINVAL;
 571         return snd_ctl_enum_info(uinfo, 1, num_names,
 572                                  ak->adc_info[mixer_ch].input_names);
 573 }
 574
 575 static int ak4xxx_capture_source_get(struct snd_kcontrol *kcontrol,
 576                                      struct snd_ctl_elem_value *ucontrol)
 577 {
 578         struct snd_akm4xxx *ak = snd_kcontrol_chip(kcontrol);
 579         int chip = AK_GET_CHIP(kcontrol->private_value);
 580         int addr = AK_GET_ADDR(kcontrol->private_value);
 581         int mask = AK_GET_MASK(kcontrol->private_value);
 582         unsigned char val;
 583
 584         val = snd_akm4xxx_get(ak, chip, addr) & mask;
 585         ucontrol->value.enumerated.item[0] = val;
 586         return 0;
 587 }
 588
 589 static int ak4xxx_capture_source_put(struct snd_kcontrol *kcontrol,
 590                                      struct snd_ctl_elem_value *ucontrol)
 591 {
 592         struct snd_akm4xxx *ak = snd_kcontrol_chip(kcontrol);
 593         int mixer_ch = AK_GET_SHIFT(kcontrol->private_value);
 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 oval, val;
 598         int num_names = ak4xxx_capture_num_inputs(ak, mixer_ch);
 599
 600         if (ucontrol->value.enumerated.item[0] >= num_names)
 601                 return -EINVAL;
 602
 603         oval = snd_akm4xxx_get(ak, chip, addr);
 604         val = oval & ~mask;
 605         val |= ucontrol->value.enumerated.item[0] & mask;
 606         if (val != oval) {
 607                 snd_akm4xxx_write(ak, chip, addr, val);
 608                 return 1;
 609         }
 610         return 0;
 611 }
 612
 613 /*
 614  * build AK4xxx controls
 615  */
 616
 617 static int build_dac_controls(struct snd_akm4xxx *ak)
 618 {
 619         int idx, err, mixer_ch, num_stereo;
 620         struct snd_kcontrol_new knew;
 621
 622         mixer_ch = 0;
 623         for (idx = 0; idx < ak->num_dacs; ) {
 624                 /* mute control for Revolution 7.1 - AK4381 */
 625                 if (ak->type == SND_AK4381
 626                                 &&  ak->dac_info[mixer_ch].switch_name) {
 627                         memset(&knew, 0, sizeof(knew));
 628                         knew.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
 629                         knew.count = 1;
 630                         knew.access = SNDRV_CTL_ELEM_ACCESS_READWRITE;
 631                         knew.name = ak->dac_info[mixer_ch].switch_name;
 632                         knew.info = ak4xxx_switch_info;
 633                         knew.get = ak4xxx_switch_get;
 634                         knew.put = ak4xxx_switch_put;
 635                         knew.access = 0;
 636                         /* register 1, bit 0 (SMUTE): 0 = normal operation,
 637                            1 = mute */
 638                         knew.private_value =
 639                                 AK_COMPOSE(idx/2, 1, 0, 0) | AK_INVERT;
 640                         err = snd_ctl_add(ak->card, snd_ctl_new1(&knew, ak));
 641                         if (err < 0)
 642                                 return err;
 643                 }
 644                 memset(&knew, 0, sizeof(knew));
 645                 if (! ak->dac_info || ! ak->dac_info[mixer_ch].name) {
 646                         knew.name = "DAC Volume";
 647                         knew.index = mixer_ch + ak->idx_offset * 2;
 648                         num_stereo = 1;
 649                 } else {
 650                         knew.name = ak->dac_info[mixer_ch].name;
 651                         num_stereo = ak->dac_info[mixer_ch].num_channels;
 652                 }
 653                 knew.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
 654                 knew.count = 1;
 655                 knew.access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
 656                         SNDRV_CTL_ELEM_ACCESS_TLV_READ;
 657                 if (num_stereo == 2) {
 658                         knew.info = snd_akm4xxx_stereo_volume_info;
 659                         knew.get = snd_akm4xxx_stereo_volume_get;
 660                         knew.put = snd_akm4xxx_stereo_volume_put;
 661                 } else {
 662                         knew.info = snd_akm4xxx_volume_info;
 663                         knew.get = snd_akm4xxx_volume_get;
 664                         knew.put = snd_akm4xxx_volume_put;
 665                 }
 666                 switch (ak->type) {
 667                 case SND_AK4524:
 668                         /* register 6 & 7 */
 669                         knew.private_value =
 670                                 AK_COMPOSE(idx/2, (idx%2) + 6, 0, 127) |
 671                                 AK_VOL_CVT;
 672                         knew.tlv.p = db_scale_vol_datt;
 673                         break;
 674                 case SND_AK4528:
 675                         /* register 4 & 5 */
 676                         knew.private_value =
 677                                 AK_COMPOSE(idx/2, (idx%2) + 4, 0, 127) |
 678                                 AK_VOL_CVT;
 679                         knew.tlv.p = db_scale_vol_datt;
 680                         break;
 681                 case SND_AK4529: {
 682                         /* registers 2-7 and b,c */
 683                         int val = idx < 6 ? idx + 2 : (idx - 6) + 0xb;
 684                         knew.private_value =
 685                                 AK_COMPOSE(0, val, 0, 255) | AK_INVERT;
 686                         knew.tlv.p = db_scale_8bit;
 687                         break;
 688                 }
 689                 case SND_AK4355:
 690                         /* register 4-9, chip #0 only */
 691                         knew.private_value = AK_COMPOSE(0, idx + 4, 0, 255);
 692                         knew.tlv.p = db_scale_8bit;
 693                         break;
 694                 case SND_AK4358: {
 695                         /* register 4-9 and 11-12, chip #0 only */
 696                         int  addr = idx < 6 ? idx + 4 : idx + 5;
 697                         knew.private_value =
 698                                 AK_COMPOSE(0, addr, 0, 127) | AK_NEEDSMSB;
 699                         knew.tlv.p = db_scale_7bit;
 700                         break;
 701                 }
 702                 case SND_AK4381:
 703                         /* register 3 & 4 */
 704                         knew.private_value =
 705                                 AK_COMPOSE(idx/2, (idx%2) + 3, 0, 255);
 706                         knew.tlv.p = db_scale_linear;
 707                         break;
 708                 case SND_AK4620:
 709                         /* register 6 & 7 */
 710                         knew.private_value =
 711                                 AK_COMPOSE(idx/2, (idx%2) + 6, 0, 255);
 712                         knew.tlv.p = db_scale_linear;
 713                         break;
 714                 default:
 715                         return -EINVAL;
 716                 }
 717
 718                 err = snd_ctl_add(ak->card, snd_ctl_new1(&knew, ak));
 719                 if (err < 0)
 720                         return err;
 721
 722                 idx += num_stereo;
 723                 mixer_ch++;
 724         }
 725         return 0;
 726 }
 727
 728 static int build_adc_controls(struct snd_akm4xxx *ak)
 729 {
 730         int idx, err, mixer_ch, num_stereo, max_steps;
 731         struct snd_kcontrol_new knew;
 732
 733         mixer_ch = 0;
 734         if (ak->type == SND_AK4528)
 735                 return 0;       /* no controls */
 736         for (idx = 0; idx < ak->num_adcs;) {
 737                 memset(&knew, 0, sizeof(knew));
 738                 if (! ak->adc_info || ! ak->adc_info[mixer_ch].name) {
 739                         knew.name = "ADC Volume";
 740                         knew.index = mixer_ch + ak->idx_offset * 2;
 741                         num_stereo = 1;
 742                 } else {
 743                         knew.name = ak->adc_info[mixer_ch].name;
 744                         num_stereo = ak->adc_info[mixer_ch].num_channels;
 745                 }
 746                 knew.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
 747                 knew.count = 1;
 748                 knew.access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
 749                         SNDRV_CTL_ELEM_ACCESS_TLV_READ;
 750                 if (num_stereo == 2) {
 751                         knew.info = snd_akm4xxx_stereo_volume_info;
 752                         knew.get = snd_akm4xxx_stereo_volume_get;
 753                         knew.put = snd_akm4xxx_stereo_volume_put;
 754                 } else {
 755                         knew.info = snd_akm4xxx_volume_info;
 756                         knew.get = snd_akm4xxx_volume_get;
 757                         knew.put = snd_akm4xxx_volume_put;
 758                 }
 759                 /* register 4 & 5 */
 760                 if (ak->type == SND_AK5365)
 761                         max_steps = 152;
 762                 else
 763                         max_steps = 164;
 764                 knew.private_value =
 765                         AK_COMPOSE(idx/2, (idx%2) + 4, 0, max_steps) |
 766                         AK_VOL_CVT | AK_IPGA;
 767                 knew.tlv.p = db_scale_vol_datt;
 768                 err = snd_ctl_add(ak->card, snd_ctl_new1(&knew, ak));
 769                 if (err < 0)
 770                         return err;
 771
 772                 if (ak->type == SND_AK5365 && (idx % 2) == 0) {
 773                         if (! ak->adc_info ||
 774                             ! ak->adc_info[mixer_ch].switch_name) {
 775                                 knew.name = "Capture Switch";
 776                                 knew.index = mixer_ch + ak->idx_offset * 2;
 777                         } else
 778                                 knew.name = ak->adc_info[mixer_ch].switch_name;
 779                         knew.info = ak4xxx_switch_info;
 780                         knew.get = ak4xxx_switch_get;
 781                         knew.put = ak4xxx_switch_put;
 782                         knew.access = 0;
 783                         /* register 2, bit 0 (SMUTE): 0 = normal operation,
 784                            1 = mute */
 785                         knew.private_value =
 786                                 AK_COMPOSE(idx/2, 2, 0, 0) | AK_INVERT;
 787                         err = snd_ctl_add(ak->card, snd_ctl_new1(&knew, ak));
 788                         if (err < 0)
 789                                 return err;
 790
 791                         memset(&knew, 0, sizeof(knew));
 792                         if (!ak->adc_info ||
 793                                 !ak->adc_info[mixer_ch].selector_name) {
 794                                 knew.name = "Capture Channel";
 795                                 knew.index = mixer_ch + ak->idx_offset * 2;
 796                         } else
 797                                 knew.name = ak->adc_info[mixer_ch].selector_name;
 798
 799                         knew.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
 800                         knew.info = ak4xxx_capture_source_info;
 801                         knew.get = ak4xxx_capture_source_get;
 802                         knew.put = ak4xxx_capture_source_put;
 803                         knew.access = 0;
 804                         /* input selector control: reg. 1, bits 0-2.
 805                          * mis-use 'shift' to pass mixer_ch */
 806                         knew.private_value
 807                                 = AK_COMPOSE(idx/2, 1, mixer_ch, 0x07);
 808                         err = snd_ctl_add(ak->card, snd_ctl_new1(&knew, ak));
 809                         if (err < 0)
 810                                 return err;
 811                 }
 812
 813                 idx += num_stereo;
 814                 mixer_ch++;
 815         }
 816         return 0;
 817 }
 818
 819 static int build_deemphasis(struct snd_akm4xxx *ak, int num_emphs)
 820 {
 821         int idx, err;
 822         struct snd_kcontrol_new knew;
 823
 824         for (idx = 0; idx < num_emphs; idx++) {
 825                 memset(&knew, 0, sizeof(knew));
 826                 knew.name = "Deemphasis";
 827                 knew.index = idx + ak->idx_offset;
 828                 knew.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
 829                 knew.count = 1;
 830                 knew.info = snd_akm4xxx_deemphasis_info;
 831                 knew.get = snd_akm4xxx_deemphasis_get;
 832                 knew.put = snd_akm4xxx_deemphasis_put;
 833                 switch (ak->type) {
 834                 case SND_AK4524:
 835                 case SND_AK4528:
 836                 case SND_AK4620:
 837                         /* register 3 */
 838                         knew.private_value = AK_COMPOSE(idx, 3, 0, 0);
 839                         break;
 840                 case SND_AK4529: {
 841                         int shift = idx == 3 ? 6 : (2 - idx) * 2;
 842                         /* register 8 with shift */
 843                         knew.private_value = AK_COMPOSE(0, 8, shift, 0);
 844                         break;
 845                 }
 846                 case SND_AK4355:
 847                 case SND_AK4358:
 848                         knew.private_value = AK_COMPOSE(idx, 3, 0, 0);
 849                         break;
 850                 case SND_AK4381:
 851                         knew.private_value = AK_COMPOSE(idx, 1, 1, 0);
 852                         break;
 853                 default:
 854                         return -EINVAL;
 855                 }
 856                 err = snd_ctl_add(ak->card, snd_ctl_new1(&knew, ak));
 857                 if (err < 0)
 858                         return err;
 859         }
 860         return 0;
 861 }
 862
 863 static void proc_regs_read(struct snd_info_entry *entry,
 864                 struct snd_info_buffer *buffer)
 865 {
 866         struct snd_akm4xxx *ak = entry->private_data;
 867         int reg, val, chip;
 868         for (chip = 0; chip < ak->num_chips; chip++) {
 869                 for (reg = 0; reg < ak->total_regs; reg++) {
 870                         val =  snd_akm4xxx_get(ak, chip, reg);
 871                         snd_iprintf(buffer, "chip %d: 0x%02x = 0x%02x\n", chip,
 872                                         reg, val);
 873                 }
 874         }
 875 }
 876
 877 static int proc_init(struct snd_akm4xxx *ak)
 878 {
 879         struct snd_info_entry *entry;
 880         int err;
 881         err = snd_card_proc_new(ak->card, ak->name, &entry);
 882         if (err < 0)
 883                 return err;
 884         snd_info_set_text_ops(entry, ak, proc_regs_read);
 885         return 0;
 886 }
 887
 888 int snd_akm4xxx_build_controls(struct snd_akm4xxx *ak)
 889 {
 890         int err, num_emphs;
 891
 892         err = build_dac_controls(ak);
 893         if (err < 0)
 894                 return err;
 895
 896         err = build_adc_controls(ak);
 897         if (err < 0)
 898                 return err;
 899         if (ak->type == SND_AK4355 || ak->type == SND_AK4358)
 900                 num_emphs = 1;
 901         else if (ak->type == SND_AK4620)
 902                 num_emphs = 0;
 903         else
 904                 num_emphs = ak->num_dacs / 2;
 905         err = build_deemphasis(ak, num_emphs);
 906         if (err < 0)
 907                 return err;
 908         err = proc_init(ak);
 909         if (err < 0)
 910                 return err;
 911
 912         return 0;
 913 }
 914 EXPORT_SYMBOL(snd_akm4xxx_build_controls);
 915
 916 static int __init alsa_akm4xxx_module_init(void)
 917 {
 918         return 0;
 919 }
 920
 921 static void __exit alsa_akm4xxx_module_exit(void)
 922 {
 923 }
 924
 925 module_init(alsa_akm4xxx_module_init)
 926 module_exit(alsa_akm4xxx_module_exit)