sound/aoa/codecs/onyx.c

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