sound/i2c/other/ak4xxx-adda.c

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