git.oblomov.eu Git - linux-2.6/blob - sound/aoa/codecs/snd-aoa-codec-onyx.c

   1 /*
   2  * Apple Onboard Audio driver for Onyx codec
   3  *
   4  * Copyright 2006 Johannes Berg <johannes@sipsolutions.net>
   5  *
   6  * GPL v2, can be found in COPYING.
   7  *
   8  *
   9  * This is a driver for the pcm3052 codec chip (codenamed Onyx)
  10  * that is present in newer Apple hardware (with digital output).
  11  *
  12  * The Onyx codec has the following connections (listed by the bit
  13  * to be used in aoa_codec.connected):
  14  *  0: analog output
  15  *  1: digital output
  16  *  2: line input
  17  *  3: microphone input
  18  * Note that even though I know of no machine that has for example
  19  * the digital output connected but not the analog, I have handled
  20  * all the different cases in the code so that this driver may serve
  21  * as a good example of what to do.
  22  *
  23  * NOTE: This driver assumes that there's at most one chip to be
  24  *       used with one alsa card, in form of creating all kinds
  25  *       of mixer elements without regard for their existence.
  26  *       But snd-aoa assumes that there's at most one card, so
  27  *       this means you can only have one onyx on a system. This
  28  *       should probably be fixed by changing the assumption of
  29  *       having just a single card on a system, and making the
  30  *       'card' pointer accessible to anyone who needs it instead
  31  *       of hiding it in the aoa_snd_* functions...
  32  *
  33  */
  34 #include <linux/delay.h>
  35 #include <linux/module.h>
  36 MODULE_AUTHOR("Johannes Berg <johannes@sipsolutions.net>");
  37 MODULE_LICENSE("GPL");
  38 MODULE_DESCRIPTION("pcm3052 (onyx) codec driver for snd-aoa");
  39
  40 #include "snd-aoa-codec-onyx.h"
  41 #include "../aoa.h"
  42 #include "../soundbus/soundbus.h"
  43
  44
  45 #define PFX "snd-aoa-codec-onyx: "
  46
  47 struct onyx {
  48         /* cache registers 65 to 80, they are write-only! */
  49         u8                      cache[16];
  50         struct i2c_client       i2c;
  51         struct aoa_codec        codec;
  52         u32                     initialised:1,
  53                                 spdif_locked:1,
  54                                 analog_locked:1,
  55                                 original_mute:2;
  56         int                     open_count;
  57         struct codec_info       *codec_info;
  58
  59         /* mutex serializes concurrent access to the device
  60          * and this structure.
  61          */
  62         struct mutex mutex;
  63 };
  64 #define codec_to_onyx(c) container_of(c, struct onyx, codec)
  65
  66 /* both return 0 if all ok, else on error */
  67 static int onyx_read_register(struct onyx *onyx, u8 reg, u8 *value)
  68 {
  69         s32 v;
  70
  71         if (reg != ONYX_REG_CONTROL) {
  72                 *value = onyx->cache[reg-FIRSTREGISTER];
  73                 return 0;
  74         }
  75         v = i2c_smbus_read_byte_data(&onyx->i2c, reg);
  76         if (v < 0)
  77                 return -1;
  78         *value = (u8)v;
  79         onyx->cache[ONYX_REG_CONTROL-FIRSTREGISTER] = *value;
  80         return 0;
  81 }
  82
  83 static int onyx_write_register(struct onyx *onyx, u8 reg, u8 value)
  84 {
  85         int result;
  86
  87         result = i2c_smbus_write_byte_data(&onyx->i2c, reg, value);
  88         if (!result)
  89                 onyx->cache[reg-FIRSTREGISTER] = value;
  90         return result;
  91 }
  92
  93 /* alsa stuff */
  94
  95 static int onyx_dev_register(struct snd_device *dev)
  96 {
  97         return 0;
  98 }
  99
 100 static struct snd_device_ops ops = {
 101         .dev_register = onyx_dev_register,
 102 };
 103
 104 /* this is necessary because most alsa mixer programs
 105  * can't properly handle the negative range */
 106 #define VOLUME_RANGE_SHIFT      128
 107
 108 static int onyx_snd_vol_info(struct snd_kcontrol *kcontrol,
 109         struct snd_ctl_elem_info *uinfo)
 110 {
 111         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
 112         uinfo->count = 2;
 113         uinfo->value.integer.min = -128 + VOLUME_RANGE_SHIFT;
 114         uinfo->value.integer.max = -1 + VOLUME_RANGE_SHIFT;
 115         return 0;
 116 }
 117
 118 static int onyx_snd_vol_get(struct snd_kcontrol *kcontrol,
 119         struct snd_ctl_elem_value *ucontrol)
 120 {
 121         struct onyx *onyx = snd_kcontrol_chip(kcontrol);
 122         s8 l, r;
 123
 124         mutex_lock(&onyx->mutex);
 125         onyx_read_register(onyx, ONYX_REG_DAC_ATTEN_LEFT, &l);
 126         onyx_read_register(onyx, ONYX_REG_DAC_ATTEN_RIGHT, &r);
 127         mutex_unlock(&onyx->mutex);
 128
 129         ucontrol->value.integer.value[0] = l + VOLUME_RANGE_SHIFT;
 130         ucontrol->value.integer.value[1] = r + VOLUME_RANGE_SHIFT;
 131
 132         return 0;
 133 }
 134
 135 static int onyx_snd_vol_put(struct snd_kcontrol *kcontrol,
 136         struct snd_ctl_elem_value *ucontrol)
 137 {
 138         struct onyx *onyx = snd_kcontrol_chip(kcontrol);
 139         s8 l, r;
 140
 141         mutex_lock(&onyx->mutex);
 142         onyx_read_register(onyx, ONYX_REG_DAC_ATTEN_LEFT, &l);
 143         onyx_read_register(onyx, ONYX_REG_DAC_ATTEN_RIGHT, &r);
 144
 145         if (l + VOLUME_RANGE_SHIFT == ucontrol->value.integer.value[0] &&
 146             r + VOLUME_RANGE_SHIFT == ucontrol->value.integer.value[1]) {
 147                 mutex_unlock(&onyx->mutex);
 148                 return 0;
 149         }
 150
 151         onyx_write_register(onyx, ONYX_REG_DAC_ATTEN_LEFT,
 152                             ucontrol->value.integer.value[0]
 153                              - VOLUME_RANGE_SHIFT);
 154         onyx_write_register(onyx, ONYX_REG_DAC_ATTEN_RIGHT,
 155                             ucontrol->value.integer.value[1]
 156                              - VOLUME_RANGE_SHIFT);
 157         mutex_unlock(&onyx->mutex);
 158
 159         return 1;
 160 }
 161
 162 static struct snd_kcontrol_new volume_control = {
 163         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 164         .name = "Master Playback Volume",
 165         .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
 166         .info = onyx_snd_vol_info,
 167         .get = onyx_snd_vol_get,
 168         .put = onyx_snd_vol_put,
 169 };
 170
 171 /* like above, this is necessary because a lot
 172  * of alsa mixer programs don't handle ranges
 173  * that don't start at 0 properly.
 174  * even alsamixer is one of them... */
 175 #define INPUTGAIN_RANGE_SHIFT   (-3)
 176
 177 static int onyx_snd_inputgain_info(struct snd_kcontrol *kcontrol,
 178         struct snd_ctl_elem_info *uinfo)
 179 {
 180         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
 181         uinfo->count = 1;
 182         uinfo->value.integer.min = 3 + INPUTGAIN_RANGE_SHIFT;
 183         uinfo->value.integer.max = 28 + INPUTGAIN_RANGE_SHIFT;
 184         return 0;
 185 }
 186
 187 static int onyx_snd_inputgain_get(struct snd_kcontrol *kcontrol,
 188         struct snd_ctl_elem_value *ucontrol)
 189 {
 190         struct onyx *onyx = snd_kcontrol_chip(kcontrol);
 191         u8 ig;
 192
 193         mutex_lock(&onyx->mutex);
 194         onyx_read_register(onyx, ONYX_REG_ADC_CONTROL, &ig);
 195         mutex_unlock(&onyx->mutex);
 196
 197         ucontrol->value.integer.value[0] =
 198                 (ig & ONYX_ADC_PGA_GAIN_MASK) + INPUTGAIN_RANGE_SHIFT;
 199
 200         return 0;
 201 }
 202
 203 static int onyx_snd_inputgain_put(struct snd_kcontrol *kcontrol,
 204         struct snd_ctl_elem_value *ucontrol)
 205 {
 206         struct onyx *onyx = snd_kcontrol_chip(kcontrol);
 207         u8 v, n;
 208
 209         mutex_lock(&onyx->mutex);
 210         onyx_read_register(onyx, ONYX_REG_ADC_CONTROL, &v);
 211         n = v;
 212         n &= ~ONYX_ADC_PGA_GAIN_MASK;
 213         n |= (ucontrol->value.integer.value[0] - INPUTGAIN_RANGE_SHIFT)
 214                 & ONYX_ADC_PGA_GAIN_MASK;
 215         onyx_write_register(onyx, ONYX_REG_ADC_CONTROL, n);
 216         mutex_unlock(&onyx->mutex);
 217
 218         return n != v;
 219 }
 220
 221 static struct snd_kcontrol_new inputgain_control = {
 222         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 223         .name = "Master Capture Volume",
 224         .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
 225         .info = onyx_snd_inputgain_info,
 226         .get = onyx_snd_inputgain_get,
 227         .put = onyx_snd_inputgain_put,
 228 };
 229
 230 static int onyx_snd_capture_source_info(struct snd_kcontrol *kcontrol,
 231         struct snd_ctl_elem_info *uinfo)
 232 {
 233         static char *texts[] = { "Line-In", "Microphone" };
 234
 235         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
 236         uinfo->count = 1;
 237         uinfo->value.enumerated.items = 2;
 238         if (uinfo->value.enumerated.item > 1)
 239                 uinfo->value.enumerated.item = 1;
 240         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
 241         return 0;
 242 }
 243
 244 static int onyx_snd_capture_source_get(struct snd_kcontrol *kcontrol,
 245         struct snd_ctl_elem_value *ucontrol)
 246 {
 247         struct onyx *onyx = snd_kcontrol_chip(kcontrol);
 248         s8 v;
 249
 250         mutex_lock(&onyx->mutex);
 251         onyx_read_register(onyx, ONYX_REG_ADC_CONTROL, &v);
 252         mutex_unlock(&onyx->mutex);
 253
 254         ucontrol->value.enumerated.item[0] = !!(v&ONYX_ADC_INPUT_MIC);
 255
 256         return 0;
 257 }
 258
 259 static void onyx_set_capture_source(struct onyx *onyx, int mic)
 260 {
 261         s8 v;
 262
 263         mutex_lock(&onyx->mutex);
 264         onyx_read_register(onyx, ONYX_REG_ADC_CONTROL, &v);
 265         v &= ~ONYX_ADC_INPUT_MIC;
 266         if (mic)
 267                 v |= ONYX_ADC_INPUT_MIC;
 268         onyx_write_register(onyx, ONYX_REG_ADC_CONTROL, v);
 269         mutex_unlock(&onyx->mutex);
 270 }
 271
 272 static int onyx_snd_capture_source_put(struct snd_kcontrol *kcontrol,
 273         struct snd_ctl_elem_value *ucontrol)
 274 {
 275         onyx_set_capture_source(snd_kcontrol_chip(kcontrol),
 276                                 ucontrol->value.enumerated.item[0]);
 277         return 1;
 278 }
 279
 280 static struct snd_kcontrol_new capture_source_control = {
 281         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 282         /* If we name this 'Input Source', it properly shows up in
 283          * alsamixer as a selection, * but it's shown under the
 284          * 'Playback' category.
 285          * If I name it 'Capture Source', it shows up in strange
 286          * ways (two bools of which one can be selected at a
 287          * time) but at least it's shown in the 'Capture'
 288          * category.
 289          * I was told that this was due to backward compatibility,
 290          * but I don't understand then why the mangling is *not*
 291          * done when I name it "Input Source".....
 292          */
 293         .name = "Capture Source",
 294         .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
 295         .info = onyx_snd_capture_source_info,
 296         .get = onyx_snd_capture_source_get,
 297         .put = onyx_snd_capture_source_put,
 298 };
 299
 300 static int onyx_snd_mute_info(struct snd_kcontrol *kcontrol,
 301         struct snd_ctl_elem_info *uinfo)
 302 {
 303         uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
 304         uinfo->count = 2;
 305         uinfo->value.integer.min = 0;
 306         uinfo->value.integer.max = 1;
 307         return 0;
 308 }
 309
 310 static int onyx_snd_mute_get(struct snd_kcontrol *kcontrol,
 311         struct snd_ctl_elem_value *ucontrol)
 312 {
 313         struct onyx *onyx = snd_kcontrol_chip(kcontrol);
 314         u8 c;
 315
 316         mutex_lock(&onyx->mutex);
 317         onyx_read_register(onyx, ONYX_REG_DAC_CONTROL, &c);
 318         mutex_unlock(&onyx->mutex);
 319
 320         ucontrol->value.integer.value[0] = !(c & ONYX_MUTE_LEFT);
 321         ucontrol->value.integer.value[1] = !(c & ONYX_MUTE_RIGHT);
 322
 323         return 0;
 324 }
 325
 326 static int onyx_snd_mute_put(struct snd_kcontrol *kcontrol,
 327         struct snd_ctl_elem_value *ucontrol)
 328 {
 329         struct onyx *onyx = snd_kcontrol_chip(kcontrol);
 330         u8 v = 0, c = 0;
 331         int err = -EBUSY;
 332
 333         mutex_lock(&onyx->mutex);
 334         if (onyx->analog_locked)
 335                 goto out_unlock;
 336
 337         onyx_read_register(onyx, ONYX_REG_DAC_CONTROL, &v);
 338         c = v;
 339         c &= ~(ONYX_MUTE_RIGHT | ONYX_MUTE_LEFT);
 340         if (!ucontrol->value.integer.value[0])
 341                 c |= ONYX_MUTE_LEFT;
 342         if (!ucontrol->value.integer.value[1])
 343                 c |= ONYX_MUTE_RIGHT;
 344         err = onyx_write_register(onyx, ONYX_REG_DAC_CONTROL, c);
 345
 346  out_unlock:
 347         mutex_unlock(&onyx->mutex);
 348
 349         return !err ? (v != c) : err;
 350 }
 351
 352 static struct snd_kcontrol_new mute_control = {
 353         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 354         .name = "Master Playback Switch",
 355         .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
 356         .info = onyx_snd_mute_info,
 357         .get = onyx_snd_mute_get,
 358         .put = onyx_snd_mute_put,
 359 };
 360
 361
 362 static int onyx_snd_single_bit_info(struct snd_kcontrol *kcontrol,
 363         struct snd_ctl_elem_info *uinfo)
 364 {
 365         uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
 366         uinfo->count = 1;
 367         uinfo->value.integer.min = 0;
 368         uinfo->value.integer.max = 1;
 369         return 0;
 370 }
 371
 372 #define FLAG_POLARITY_INVERT    1
 373 #define FLAG_SPDIFLOCK          2
 374
 375 static int onyx_snd_single_bit_get(struct snd_kcontrol *kcontrol,
 376         struct snd_ctl_elem_value *ucontrol)
 377 {
 378         struct onyx *onyx = snd_kcontrol_chip(kcontrol);
 379         u8 c;
 380         long int pv = kcontrol->private_value;
 381         u8 polarity = (pv >> 16) & FLAG_POLARITY_INVERT;
 382         u8 address = (pv >> 8) & 0xff;
 383         u8 mask = pv & 0xff;
 384
 385         mutex_lock(&onyx->mutex);
 386         onyx_read_register(onyx, address, &c);
 387         mutex_unlock(&onyx->mutex);
 388
 389         ucontrol->value.integer.value[0] = !!(c & mask) ^ polarity;
 390
 391         return 0;
 392 }
 393
 394 static int onyx_snd_single_bit_put(struct snd_kcontrol *kcontrol,
 395         struct snd_ctl_elem_value *ucontrol)
 396 {
 397         struct onyx *onyx = snd_kcontrol_chip(kcontrol);
 398         u8 v = 0, c = 0;
 399         int err;
 400         long int pv = kcontrol->private_value;
 401         u8 polarity = (pv >> 16) & FLAG_POLARITY_INVERT;
 402         u8 spdiflock = (pv >> 16) & FLAG_SPDIFLOCK;
 403         u8 address = (pv >> 8) & 0xff;
 404         u8 mask = pv & 0xff;
 405
 406         mutex_lock(&onyx->mutex);
 407         if (spdiflock && onyx->spdif_locked) {
 408                 /* even if alsamixer doesn't care.. */
 409                 err = -EBUSY;
 410                 goto out_unlock;
 411         }
 412         onyx_read_register(onyx, address, &v);
 413         c = v;
 414         c &= ~(mask);
 415         if (!!ucontrol->value.integer.value[0] ^ polarity)
 416                 c |= mask;
 417         err = onyx_write_register(onyx, address, c);
 418
 419  out_unlock:
 420         mutex_unlock(&onyx->mutex);
 421
 422         return !err ? (v != c) : err;
 423 }
 424
 425 #define SINGLE_BIT(n, type, description, address, mask, flags)          \
 426 static struct snd_kcontrol_new n##_control = {                          \
 427         .iface = SNDRV_CTL_ELEM_IFACE_##type,                           \
 428         .name = description,                                            \
 429         .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,                      \
 430         .info = onyx_snd_single_bit_info,                               \
 431         .get = onyx_snd_single_bit_get,                                 \
 432         .put = onyx_snd_single_bit_put,                                 \
 433         .private_value = (flags << 16) | (address << 8) | mask          \
 434 }
 435
 436 SINGLE_BIT(spdif,
 437            MIXER,
 438            SNDRV_CTL_NAME_IEC958("", PLAYBACK, SWITCH),
 439            ONYX_REG_DIG_INFO4,
 440            ONYX_SPDIF_ENABLE,
 441            FLAG_SPDIFLOCK);
 442 SINGLE_BIT(ovr1,
 443            MIXER,
 444            "Oversampling Rate",
 445            ONYX_REG_DAC_CONTROL,
 446            ONYX_OVR1,
 447            0);
 448 SINGLE_BIT(flt0,
 449            MIXER,
 450            "Fast Digital Filter Rolloff",
 451            ONYX_REG_DAC_FILTER,
 452            ONYX_ROLLOFF_FAST,
 453            FLAG_POLARITY_INVERT);
 454 SINGLE_BIT(hpf,
 455            MIXER,
 456            "Highpass Filter",
 457            ONYX_REG_ADC_HPF_BYPASS,
 458            ONYX_HPF_DISABLE,
 459            FLAG_POLARITY_INVERT);
 460 SINGLE_BIT(dm12,
 461            MIXER,
 462            "Digital De-Emphasis",
 463            ONYX_REG_DAC_DEEMPH,
 464            ONYX_DIGDEEMPH_CTRL,
 465            0);
 466
 467 static int onyx_spdif_info(struct snd_kcontrol *kcontrol,
 468                            struct snd_ctl_elem_info *uinfo)
 469 {
 470         uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
 471         uinfo->count = 1;
 472         return 0;
 473 }
 474
 475 static int onyx_spdif_mask_get(struct snd_kcontrol *kcontrol,
 476                                struct snd_ctl_elem_value *ucontrol)
 477 {
 478         /* datasheet page 30, all others are 0 */
 479         ucontrol->value.iec958.status[0] = 0x3e;
 480         ucontrol->value.iec958.status[1] = 0xff;
 481
 482         ucontrol->value.iec958.status[3] = 0x3f;
 483         ucontrol->value.iec958.status[4] = 0x0f;
 484
 485         return 0;
 486 }
 487
 488 static struct snd_kcontrol_new onyx_spdif_mask = {
 489         .access =       SNDRV_CTL_ELEM_ACCESS_READ,
 490         .iface =        SNDRV_CTL_ELEM_IFACE_PCM,
 491         .name =         SNDRV_CTL_NAME_IEC958("",PLAYBACK,CON_MASK),
 492         .info =         onyx_spdif_info,
 493         .get =          onyx_spdif_mask_get,
 494 };
 495
 496 static int onyx_spdif_get(struct snd_kcontrol *kcontrol,
 497                           struct snd_ctl_elem_value *ucontrol)
 498 {
 499         struct onyx *onyx = snd_kcontrol_chip(kcontrol);
 500         u8 v;
 501
 502         mutex_lock(&onyx->mutex);
 503         onyx_read_register(onyx, ONYX_REG_DIG_INFO1, &v);
 504         ucontrol->value.iec958.status[0] = v & 0x3e;
 505
 506         onyx_read_register(onyx, ONYX_REG_DIG_INFO2, &v);
 507         ucontrol->value.iec958.status[1] = v;
 508
 509         onyx_read_register(onyx, ONYX_REG_DIG_INFO3, &v);
 510         ucontrol->value.iec958.status[3] = v & 0x3f;
 511
 512         onyx_read_register(onyx, ONYX_REG_DIG_INFO4, &v);
 513         ucontrol->value.iec958.status[4] = v & 0x0f;
 514         mutex_unlock(&onyx->mutex);
 515
 516         return 0;
 517 }
 518
 519 static int onyx_spdif_put(struct snd_kcontrol *kcontrol,
 520                           struct snd_ctl_elem_value *ucontrol)
 521 {
 522         struct onyx *onyx = snd_kcontrol_chip(kcontrol);
 523         u8 v;
 524
 525         mutex_lock(&onyx->mutex);
 526         onyx_read_register(onyx, ONYX_REG_DIG_INFO1, &v);
 527         v = (v & ~0x3e) | (ucontrol->value.iec958.status[0] & 0x3e);
 528         onyx_write_register(onyx, ONYX_REG_DIG_INFO1, v);
 529
 530         v = ucontrol->value.iec958.status[1];
 531         onyx_write_register(onyx, ONYX_REG_DIG_INFO2, v);
 532
 533         onyx_read_register(onyx, ONYX_REG_DIG_INFO3, &v);
 534         v = (v & ~0x3f) | (ucontrol->value.iec958.status[3] & 0x3f);
 535         onyx_write_register(onyx, ONYX_REG_DIG_INFO3, v);
 536
 537         onyx_read_register(onyx, ONYX_REG_DIG_INFO4, &v);
 538         v = (v & ~0x0f) | (ucontrol->value.iec958.status[4] & 0x0f);
 539         onyx_write_register(onyx, ONYX_REG_DIG_INFO4, v);
 540         mutex_unlock(&onyx->mutex);
 541
 542         return 1;
 543 }
 544
 545 static struct snd_kcontrol_new onyx_spdif_ctrl = {
 546         .access =       SNDRV_CTL_ELEM_ACCESS_READWRITE,
 547         .iface =        SNDRV_CTL_ELEM_IFACE_PCM,
 548         .name =         SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT),
 549         .info =         onyx_spdif_info,
 550         .get =          onyx_spdif_get,
 551         .put =          onyx_spdif_put,
 552 };
 553
 554 /* our registers */
 555
 556 static u8 register_map[] = {
 557         ONYX_REG_DAC_ATTEN_LEFT,
 558         ONYX_REG_DAC_ATTEN_RIGHT,
 559         ONYX_REG_CONTROL,
 560         ONYX_REG_DAC_CONTROL,
 561         ONYX_REG_DAC_DEEMPH,
 562         ONYX_REG_DAC_FILTER,
 563         ONYX_REG_DAC_OUTPHASE,
 564         ONYX_REG_ADC_CONTROL,
 565         ONYX_REG_ADC_HPF_BYPASS,
 566         ONYX_REG_DIG_INFO1,
 567         ONYX_REG_DIG_INFO2,
 568         ONYX_REG_DIG_INFO3,
 569         ONYX_REG_DIG_INFO4
 570 };
 571
 572 static u8 initial_values[ARRAY_SIZE(register_map)] = {
 573         0x80, 0x80, /* muted */
 574         ONYX_MRST | ONYX_SRST, /* but handled specially! */
 575         ONYX_MUTE_LEFT | ONYX_MUTE_RIGHT,
 576         0, /* no deemphasis */
 577         ONYX_DAC_FILTER_ALWAYS,
 578         ONYX_OUTPHASE_INVERTED,
 579         (-1 /*dB*/ + 8) & 0xF, /* line in selected, -1 dB gain*/
 580         ONYX_ADC_HPF_ALWAYS,
 581         (1<<2), /* pcm audio */
 582         2,      /* category: pcm coder */
 583         0,      /* sampling frequency 44.1 kHz, clock accuracy level II */
 584         1       /* 24 bit depth */
 585 };
 586
 587 /* reset registers of chip, either to initial or to previous values */
 588 static int onyx_register_init(struct onyx *onyx)
 589 {
 590         int i;
 591         u8 val;
 592         u8 regs[sizeof(initial_values)];
 593
 594         if (!onyx->initialised) {
 595                 memcpy(regs, initial_values, sizeof(initial_values));
 596                 if (onyx_read_register(onyx, ONYX_REG_CONTROL, &val))
 597                         return -1;
 598                 val &= ~ONYX_SILICONVERSION;
 599                 val |= initial_values[3];
 600                 regs[3] = val;
 601         } else {
 602                 for (i=0; i<sizeof(register_map); i++)
 603                         regs[i] = onyx->cache[register_map[i]-FIRSTREGISTER];
 604         }
 605
 606         for (i=0; i<sizeof(register_map); i++) {
 607                 if (onyx_write_register(onyx, register_map[i], regs[i]))
 608                         return -1;
 609         }
 610         onyx->initialised = 1;
 611         return 0;
 612 }
 613
 614 static struct transfer_info onyx_transfers[] = {
 615         /* this is first so we can skip it if no input is present...
 616          * No hardware exists with that, but it's here as an example
 617          * of what to do :) */
 618         {
 619                 /* analog input */
 620                 .formats = SNDRV_PCM_FMTBIT_S8 |
 621                            SNDRV_PCM_FMTBIT_S16_BE |
 622                            SNDRV_PCM_FMTBIT_S24_BE,
 623                 .rates = SNDRV_PCM_RATE_8000_96000,
 624                 .transfer_in = 1,
 625                 .must_be_clock_source = 0,
 626                 .tag = 0,
 627         },
 628         {
 629                 /* if analog and digital are currently off, anything should go,
 630                  * so this entry describes everything we can do... */
 631                 .formats = SNDRV_PCM_FMTBIT_S8 |
 632                            SNDRV_PCM_FMTBIT_S16_BE |
 633                            SNDRV_PCM_FMTBIT_S24_BE
 634 #ifdef SNDRV_PCM_FMTBIT_COMPRESSED_16BE
 635                            | SNDRV_PCM_FMTBIT_COMPRESSED_16BE
 636 #endif
 637                 ,
 638                 .rates = SNDRV_PCM_RATE_8000_96000,
 639                 .tag = 0,
 640         },
 641         {
 642                 /* analog output */
 643                 .formats = SNDRV_PCM_FMTBIT_S8 |
 644                            SNDRV_PCM_FMTBIT_S16_BE |
 645                            SNDRV_PCM_FMTBIT_S24_BE,
 646                 .rates = SNDRV_PCM_RATE_8000_96000,
 647                 .transfer_in = 0,
 648                 .must_be_clock_source = 0,
 649                 .tag = 1,
 650         },
 651         {
 652                 /* digital pcm output, also possible for analog out */
 653                 .formats = SNDRV_PCM_FMTBIT_S8 |
 654                            SNDRV_PCM_FMTBIT_S16_BE |
 655                            SNDRV_PCM_FMTBIT_S24_BE,
 656                 .rates = SNDRV_PCM_RATE_32000 |
 657                          SNDRV_PCM_RATE_44100 |
 658                          SNDRV_PCM_RATE_48000,
 659                 .transfer_in = 0,
 660                 .must_be_clock_source = 0,
 661                 .tag = 2,
 662         },
 663 #ifdef SNDRV_PCM_FMTBIT_COMPRESSED_16BE
 664 Once alsa gets supports for this kind of thing we can add it...
 665         {
 666                 /* digital compressed output */
 667                 .formats =  SNDRV_PCM_FMTBIT_COMPRESSED_16BE,
 668                 .rates = SNDRV_PCM_RATE_32000 |
 669                          SNDRV_PCM_RATE_44100 |
 670                          SNDRV_PCM_RATE_48000,
 671                 .tag = 2,
 672         },
 673 #endif
 674         {}
 675 };
 676
 677 static int onyx_usable(struct codec_info_item *cii,
 678                        struct transfer_info *ti,
 679                        struct transfer_info *out)
 680 {
 681         u8 v;
 682         struct onyx *onyx = cii->codec_data;
 683         int spdif_enabled, analog_enabled;
 684
 685         mutex_lock(&onyx->mutex);
 686         onyx_read_register(onyx, ONYX_REG_DIG_INFO4, &v);
 687         spdif_enabled = !!(v & ONYX_SPDIF_ENABLE);
 688         onyx_read_register(onyx, ONYX_REG_DAC_CONTROL, &v);
 689         analog_enabled =
 690                 (v & (ONYX_MUTE_RIGHT|ONYX_MUTE_LEFT))
 691                  != (ONYX_MUTE_RIGHT|ONYX_MUTE_LEFT);
 692         mutex_unlock(&onyx->mutex);
 693
 694         switch (ti->tag) {
 695         case 0: return 1;
 696         case 1: return analog_enabled;
 697         case 2: return spdif_enabled;
 698         }
 699         return 1;
 700 }
 701
 702 static int onyx_prepare(struct codec_info_item *cii,
 703                         struct bus_info *bi,
 704                         struct snd_pcm_substream *substream)
 705 {
 706         u8 v;
 707         struct onyx *onyx = cii->codec_data;
 708         int err = -EBUSY;
 709
 710         mutex_lock(&onyx->mutex);
 711
 712 #ifdef SNDRV_PCM_FMTBIT_COMPRESSED_16BE
 713         if (substream->runtime->format == SNDRV_PCM_FMTBIT_COMPRESSED_16BE) {
 714                 /* mute and lock analog output */
 715                 onyx_read_register(onyx, ONYX_REG_DAC_CONTROL, &v);
 716                 if (onyx_write_register(onyx
 717                                         ONYX_REG_DAC_CONTROL,
 718                                         v | ONYX_MUTE_RIGHT | ONYX_MUTE_LEFT))
 719                         goto out_unlock;
 720                 onyx->analog_locked = 1;
 721                 err = 0;
 722                 goto out_unlock;
 723         }
 724 #endif
 725         switch (substream->runtime->rate) {
 726         case 32000:
 727         case 44100:
 728         case 48000:
 729                 /* these rates are ok for all outputs */
 730                 /* FIXME: program spdif channel control bits here so that
 731                  *        userspace doesn't have to if it only plays pcm! */
 732                 err = 0;
 733                 goto out_unlock;
 734         default:
 735                 /* got some rate that the digital output can't do,
 736                  * so disable and lock it */
 737                 onyx_read_register(cii->codec_data, ONYX_REG_DIG_INFO4, &v);
 738                 if (onyx_write_register(onyx,
 739                                         ONYX_REG_DIG_INFO4,
 740                                         v & ~ONYX_SPDIF_ENABLE))
 741                         goto out_unlock;
 742                 onyx->spdif_locked = 1;
 743                 err = 0;
 744                 goto out_unlock;
 745         }
 746
 747  out_unlock:
 748         mutex_unlock(&onyx->mutex);
 749
 750         return err;
 751 }
 752
 753 static int onyx_open(struct codec_info_item *cii,
 754                      struct snd_pcm_substream *substream)
 755 {
 756         struct onyx *onyx = cii->codec_data;
 757
 758         mutex_lock(&onyx->mutex);
 759         onyx->open_count++;
 760         mutex_unlock(&onyx->mutex);
 761
 762         return 0;
 763 }
 764
 765 static int onyx_close(struct codec_info_item *cii,
 766                       struct snd_pcm_substream *substream)
 767 {
 768         struct onyx *onyx = cii->codec_data;
 769
 770         mutex_lock(&onyx->mutex);
 771         onyx->open_count--;
 772         if (!onyx->open_count)
 773                 onyx->spdif_locked = onyx->analog_locked = 0;
 774         mutex_unlock(&onyx->mutex);
 775
 776         return 0;
 777 }
 778
 779 static int onyx_switch_clock(struct codec_info_item *cii,
 780                              enum clock_switch what)
 781 {
 782         struct onyx *onyx = cii->codec_data;
 783
 784         mutex_lock(&onyx->mutex);
 785         /* this *MUST* be more elaborate later... */
 786         switch (what) {
 787         case CLOCK_SWITCH_PREPARE_SLAVE:
 788                 onyx->codec.gpio->methods->all_amps_off(onyx->codec.gpio);
 789                 break;
 790         case CLOCK_SWITCH_SLAVE:
 791                 onyx->codec.gpio->methods->all_amps_restore(onyx->codec.gpio);
 792                 break;
 793         default: /* silence warning */
 794                 break;
 795         }
 796         mutex_unlock(&onyx->mutex);
 797
 798         return 0;
 799 }
 800
 801 #ifdef CONFIG_PM
 802
 803 static int onyx_suspend(struct codec_info_item *cii, pm_message_t state)
 804 {
 805         struct onyx *onyx = cii->codec_data;
 806         u8 v;
 807         int err = -ENXIO;
 808
 809         mutex_lock(&onyx->mutex);
 810         if (onyx_read_register(onyx, ONYX_REG_CONTROL, &v))
 811                 goto out_unlock;
 812         onyx_write_register(onyx, ONYX_REG_CONTROL, v | ONYX_ADPSV | ONYX_DAPSV);
 813         /* Apple does a sleep here but the datasheet says to do it on resume */
 814         err = 0;
 815  out_unlock:
 816         mutex_unlock(&onyx->mutex);
 817
 818         return err;
 819 }
 820
 821 static int onyx_resume(struct codec_info_item *cii)
 822 {
 823         struct onyx *onyx = cii->codec_data;
 824         u8 v;
 825         int err = -ENXIO;
 826
 827         mutex_lock(&onyx->mutex);
 828
 829         /* reset codec */
 830         onyx->codec.gpio->methods->set_hw_reset(onyx->codec.gpio, 0);
 831         msleep(1);
 832         onyx->codec.gpio->methods->set_hw_reset(onyx->codec.gpio, 1);
 833         msleep(1);
 834         onyx->codec.gpio->methods->set_hw_reset(onyx->codec.gpio, 0);
 835         msleep(1);
 836
 837         /* take codec out of suspend (if it still is after reset) */
 838         if (onyx_read_register(onyx, ONYX_REG_CONTROL, &v))
 839                 goto out_unlock;
 840         onyx_write_register(onyx, ONYX_REG_CONTROL, v & ~(ONYX_ADPSV | ONYX_DAPSV));
 841         /* FIXME: should divide by sample rate, but 8k is the lowest we go */
 842         msleep(2205000/8000);
 843         /* reset all values */
 844         onyx_register_init(onyx);
 845         err = 0;
 846  out_unlock:
 847         mutex_unlock(&onyx->mutex);
 848
 849         return err;
 850 }
 851
 852 #endif /* CONFIG_PM */
 853
 854 static struct codec_info onyx_codec_info = {
 855         .transfers = onyx_transfers,
 856         .sysclock_factor = 256,
 857         .bus_factor = 64,
 858         .owner = THIS_MODULE,
 859         .usable = onyx_usable,
 860         .prepare = onyx_prepare,
 861         .open = onyx_open,
 862         .close = onyx_close,
 863         .switch_clock = onyx_switch_clock,
 864 #ifdef CONFIG_PM
 865         .suspend = onyx_suspend,
 866         .resume = onyx_resume,
 867 #endif
 868 };
 869
 870 static int onyx_init_codec(struct aoa_codec *codec)
 871 {
 872         struct onyx *onyx = codec_to_onyx(codec);
 873         struct snd_kcontrol *ctl;
 874         struct codec_info *ci = &onyx_codec_info;
 875         u8 v;
 876         int err;
 877
 878         if (!onyx->codec.gpio || !onyx->codec.gpio->methods) {
 879                 printk(KERN_ERR PFX "gpios not assigned!!\n");
 880                 return -EINVAL;
 881         }
 882
 883         onyx->codec.gpio->methods->set_hw_reset(onyx->codec.gpio, 0);
 884         msleep(1);
 885         onyx->codec.gpio->methods->set_hw_reset(onyx->codec.gpio, 1);
 886         msleep(1);
 887         onyx->codec.gpio->methods->set_hw_reset(onyx->codec.gpio, 0);
 888         msleep(1);
 889
 890         if (onyx_register_init(onyx)) {
 891                 printk(KERN_ERR PFX "failed to initialise onyx registers\n");
 892                 return -ENODEV;
 893         }
 894
 895         if (aoa_snd_device_new(SNDRV_DEV_LOWLEVEL, onyx, &ops)) {
 896                 printk(KERN_ERR PFX "failed to create onyx snd device!\n");
 897                 return -ENODEV;
 898         }
 899
 900         /* nothing connected? what a joke! */
 901         if ((onyx->codec.connected & 0xF) == 0)
 902                 return -ENOTCONN;
 903
 904         /* if no inputs are present... */
 905         if ((onyx->codec.connected & 0xC) == 0) {
 906                 if (!onyx->codec_info)
 907                         onyx->codec_info = kmalloc(sizeof(struct codec_info), GFP_KERNEL);
 908                 if (!onyx->codec_info)
 909                         return -ENOMEM;
 910                 ci = onyx->codec_info;
 911                 *ci = onyx_codec_info;
 912                 ci->transfers++;
 913         }
 914
 915         /* if no outputs are present... */
 916         if ((onyx->codec.connected & 3) == 0) {
 917                 if (!onyx->codec_info)
 918                         onyx->codec_info = kmalloc(sizeof(struct codec_info), GFP_KERNEL);
 919                 if (!onyx->codec_info)
 920                         return -ENOMEM;
 921                 ci = onyx->codec_info;
 922                 /* this is fine as there have to be inputs
 923                  * if we end up in this part of the code */
 924                 *ci = onyx_codec_info;
 925                 ci->transfers[1].formats = 0;
 926         }
 927
 928         if (onyx->codec.soundbus_dev->attach_codec(onyx->codec.soundbus_dev,
 929                                                    aoa_get_card(),
 930                                                    ci, onyx)) {
 931                 printk(KERN_ERR PFX "error creating onyx pcm\n");
 932                 return -ENODEV;
 933         }
 934 #define ADDCTL(n)                                                       \
 935         do {                                                            \
 936                 ctl = snd_ctl_new1(&n, onyx);                           \
 937                 if (ctl) {                                              \
 938                         ctl->id.device =                                \
 939                                 onyx->codec.soundbus_dev->pcm->device;  \
 940                         err = aoa_snd_ctl_add(ctl);                     \
 941                         if (err)                                        \
 942                                 goto error;                             \
 943                 }                                                       \
 944         } while (0)
 945
 946         if (onyx->codec.soundbus_dev->pcm) {
 947                 /* give the user appropriate controls
 948                  * depending on what inputs are connected */
 949                 if ((onyx->codec.connected & 0xC) == 0xC)
 950                         ADDCTL(capture_source_control);
 951                 else if (onyx->codec.connected & 4)
 952                         onyx_set_capture_source(onyx, 0);
 953                 else
 954                         onyx_set_capture_source(onyx, 1);
 955                 if (onyx->codec.connected & 0xC)
 956                         ADDCTL(inputgain_control);
 957
 958                 /* depending on what output is connected,
 959                  * give the user appropriate controls */
 960                 if (onyx->codec.connected & 1) {
 961                         ADDCTL(volume_control);
 962                         ADDCTL(mute_control);
 963                         ADDCTL(ovr1_control);
 964                         ADDCTL(flt0_control);
 965                         ADDCTL(hpf_control);
 966                         ADDCTL(dm12_control);
 967                         /* spdif control defaults to off */
 968                 }
 969                 if (onyx->codec.connected & 2) {
 970                         ADDCTL(onyx_spdif_mask);
 971                         ADDCTL(onyx_spdif_ctrl);
 972                 }
 973                 if ((onyx->codec.connected & 3) == 3)
 974                         ADDCTL(spdif_control);
 975                 /* if only S/PDIF is connected, enable it unconditionally */
 976                 if ((onyx->codec.connected & 3) == 2) {
 977                         onyx_read_register(onyx, ONYX_REG_DIG_INFO4, &v);
 978                         v |= ONYX_SPDIF_ENABLE;
 979                         onyx_write_register(onyx, ONYX_REG_DIG_INFO4, v);
 980                 }
 981         }
 982 #undef ADDCTL
 983         printk(KERN_INFO PFX "attached to onyx codec via i2c\n");
 984
 985         return 0;
 986  error:
 987         onyx->codec.soundbus_dev->detach_codec(onyx->codec.soundbus_dev, onyx);
 988         snd_device_free(aoa_get_card(), onyx);
 989         return err;
 990 }
 991
 992 static void onyx_exit_codec(struct aoa_codec *codec)
 993 {
 994         struct onyx *onyx = codec_to_onyx(codec);
 995
 996         if (!onyx->codec.soundbus_dev) {
 997                 printk(KERN_ERR PFX "onyx_exit_codec called without soundbus_dev!\n");
 998                 return;
 999         }
1000         onyx->codec.soundbus_dev->detach_codec(onyx->codec.soundbus_dev, onyx);
1001 }
1002
1003 static struct i2c_driver onyx_driver;
1004
1005 static int onyx_create(struct i2c_adapter *adapter,
1006                        struct device_node *node,
1007                        int addr)
1008 {
1009         struct onyx *onyx;
1010         u8 dummy;
1011
1012         onyx = kzalloc(sizeof(struct onyx), GFP_KERNEL);
1013
1014         if (!onyx)
1015                 return -ENOMEM;
1016
1017         mutex_init(&onyx->mutex);
1018         onyx->i2c.driver = &onyx_driver;
1019         onyx->i2c.adapter = adapter;
1020         onyx->i2c.addr = addr & 0x7f;
1021         strlcpy(onyx->i2c.name, "onyx audio codec", I2C_NAME_SIZE-1);
1022
1023         if (i2c_attach_client(&onyx->i2c)) {
1024                 printk(KERN_ERR PFX "failed to attach to i2c\n");
1025                 goto fail;
1026         }
1027
1028         /* we try to read from register ONYX_REG_CONTROL
1029          * to check if the codec is present */
1030         if (onyx_read_register(onyx, ONYX_REG_CONTROL, &dummy) != 0) {
1031                 i2c_detach_client(&onyx->i2c);
1032                 printk(KERN_ERR PFX "failed to read control register\n");
1033                 goto fail;
1034         }
1035
1036         strlcpy(onyx->codec.name, "onyx", MAX_CODEC_NAME_LEN-1);
1037         onyx->codec.owner = THIS_MODULE;
1038         onyx->codec.init = onyx_init_codec;
1039         onyx->codec.exit = onyx_exit_codec;
1040         onyx->codec.node = of_node_get(node);
1041
1042         if (aoa_codec_register(&onyx->codec)) {
1043                 i2c_detach_client(&onyx->i2c);
1044                 goto fail;
1045         }
1046         printk(KERN_DEBUG PFX "created and attached onyx instance\n");
1047         return 0;
1048  fail:
1049         kfree(onyx);
1050         return -EINVAL;
1051 }
1052
1053 static int onyx_i2c_attach(struct i2c_adapter *adapter)
1054 {
1055         struct device_node *busnode, *dev = NULL;
1056         struct pmac_i2c_bus *bus;
1057
1058         bus = pmac_i2c_adapter_to_bus(adapter);
1059         if (bus == NULL)
1060                 return -ENODEV;
1061         busnode = pmac_i2c_get_bus_node(bus);
1062
1063         while ((dev = of_get_next_child(busnode, dev)) != NULL) {
1064                 if (device_is_compatible(dev, "pcm3052")) {
1065                         u32 *addr;
1066                         printk(KERN_DEBUG PFX "found pcm3052\n");
1067                         addr = (u32 *) get_property(dev, "reg", NULL);
1068                         if (!addr)
1069                                 return -ENODEV;
1070                         return onyx_create(adapter, dev, (*addr)>>1);
1071                 }
1072         }
1073
1074         /* if that didn't work, try desperate mode for older
1075          * machines that have stuff missing from the device tree */
1076
1077         if (!device_is_compatible(busnode, "k2-i2c"))
1078                 return -ENODEV;
1079
1080         printk(KERN_DEBUG PFX "found k2-i2c, checking if onyx chip is on it\n");
1081         /* probe both possible addresses for the onyx chip */
1082         if (onyx_create(adapter, NULL, 0x46) == 0)
1083                 return 0;
1084         return onyx_create(adapter, NULL, 0x47);
1085 }
1086
1087 static int onyx_i2c_detach(struct i2c_client *client)
1088 {
1089         struct onyx *onyx = container_of(client, struct onyx, i2c);
1090         int err;
1091
1092         if ((err = i2c_detach_client(client)))
1093                 return err;
1094         aoa_codec_unregister(&onyx->codec);
1095         of_node_put(onyx->codec.node);
1096         if (onyx->codec_info)
1097                 kfree(onyx->codec_info);
1098         kfree(onyx);
1099         return 0;
1100 }
1101
1102 static struct i2c_driver onyx_driver = {
1103         .driver = {
1104                 .name = "aoa_codec_onyx",
1105                 .owner = THIS_MODULE,
1106         },
1107         .attach_adapter = onyx_i2c_attach,
1108         .detach_client = onyx_i2c_detach,
1109 };
1110
1111 static int __init onyx_init(void)
1112 {
1113         return i2c_add_driver(&onyx_driver);
1114 }
1115
1116 static void __exit onyx_exit(void)
1117 {
1118         i2c_del_driver(&onyx_driver);
1119 }
1120
1121 module_init(onyx_init);
1122 module_exit(onyx_exit);