LXR linux/sound/i2c/other/ak4xxx-adda.c

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