sound/soc/codecs/ak4642.c

   1 /*
   2  * ak4642.c  --  AK4642/AK4643 ALSA Soc Audio driver
   3  *
   4  * Copyright (C) 2009 Renesas Solutions Corp.
   5  * Kuninori Morimoto <morimoto.kuninori@renesas.com>
   6  *
   7  * Based on wm8731.c by Richard Purdie
   8  * Based on ak4535.c by Richard Purdie
   9  * Based on wm8753.c by Liam Girdwood
  10  *
  11  * This program is free software; you can redistribute it and/or modify
  12  * it under the terms of the GNU General Public License version 2 as
  13  * published by the Free Software Foundation.
  14  */
  15
  16 /* ** CAUTION **
  17  *
  18  * This is very simple driver.
  19  * It can use headphone output / stereo input only
  20  *
  21  * AK4642 is tested.
  22  * AK4643 is tested.
  23  * AK4648 is tested.
  24  */
  25
  26 #include <linux/delay.h>
  27 #include <linux/i2c.h>
  28 #include <linux/platform_device.h>
  29 #include <linux/slab.h>
  30 #include <linux/module.h>
  31 #include <sound/soc.h>
  32 #include <sound/initval.h>
  33 #include <sound/tlv.h>
  34
  35 #define AK4642_VERSION "0.0.1"
  36
  37 #define PW_MGMT1        0x00
  38 #define PW_MGMT2        0x01
  39 #define SG_SL1          0x02
  40 #define SG_SL2          0x03
  41 #define MD_CTL1         0x04
  42 #define MD_CTL2         0x05
  43 #define TIMER           0x06
  44 #define ALC_CTL1        0x07
  45 #define ALC_CTL2        0x08
  46 #define L_IVC           0x09
  47 #define L_DVC           0x0a
  48 #define ALC_CTL3        0x0b
  49 #define R_IVC           0x0c
  50 #define R_DVC           0x0d
  51 #define MD_CTL3         0x0e
  52 #define MD_CTL4         0x0f
  53 #define PW_MGMT3        0x10
  54 #define DF_S            0x11
  55 #define FIL3_0          0x12
  56 #define FIL3_1          0x13
  57 #define FIL3_2          0x14
  58 #define FIL3_3          0x15
  59 #define EQ_0            0x16
  60 #define EQ_1            0x17
  61 #define EQ_2            0x18
  62 #define EQ_3            0x19
  63 #define EQ_4            0x1a
  64 #define EQ_5            0x1b
  65 #define FIL1_0          0x1c
  66 #define FIL1_1          0x1d
  67 #define FIL1_2          0x1e
  68 #define FIL1_3          0x1f
  69 #define PW_MGMT4        0x20
  70 #define MD_CTL5         0x21
  71 #define LO_MS           0x22
  72 #define HP_MS           0x23
  73 #define SPK_MS          0x24
  74
  75 /* PW_MGMT1*/
  76 #define PMVCM           (1 << 6) /* VCOM Power Management */
  77 #define PMMIN           (1 << 5) /* MIN Input Power Management */
  78 #define PMDAC           (1 << 2) /* DAC Power Management */
  79 #define PMADL           (1 << 0) /* MIC Amp Lch and ADC Lch Power Management */
  80
  81 /* PW_MGMT2 */
  82 #define HPMTN           (1 << 6)
  83 #define PMHPL           (1 << 5)
  84 #define PMHPR           (1 << 4)
  85 #define MS              (1 << 3) /* master/slave select */
  86 #define MCKO            (1 << 1)
  87 #define PMPLL           (1 << 0)
  88
  89 #define PMHP_MASK       (PMHPL | PMHPR)
  90 #define PMHP            PMHP_MASK
  91
  92 /* PW_MGMT3 */
  93 #define PMADR           (1 << 0) /* MIC L / ADC R Power Management */
  94
  95 /* SG_SL1 */
  96 #define MINS            (1 << 6) /* Switch from MIN to Speaker */
  97 #define DACL            (1 << 4) /* Switch from DAC to Stereo or Receiver */
  98 #define PMMP            (1 << 2) /* MPWR pin Power Management */
  99 #define MGAIN0          (1 << 0) /* MIC amp gain*/
 100
 101 /* TIMER */
 102 #define ZTM(param)      ((param & 0x3) << 4) /* ALC Zoro Crossing TimeOut */
 103 #define WTM(param)      (((param & 0x4) << 4) | ((param & 0x3) << 2))
 104
 105 /* ALC_CTL1 */
 106 #define ALC             (1 << 5) /* ALC Enable */
 107 #define LMTH0           (1 << 0) /* ALC Limiter / Recovery Level */
 108
 109 /* MD_CTL1 */
 110 #define PLL3            (1 << 7)
 111 #define PLL2            (1 << 6)
 112 #define PLL1            (1 << 5)
 113 #define PLL0            (1 << 4)
 114 #define PLL_MASK        (PLL3 | PLL2 | PLL1 | PLL0)
 115
 116 #define BCKO_MASK       (1 << 3)
 117 #define BCKO_64         BCKO_MASK
 118
 119 #define DIF_MASK        (3 << 0)
 120 #define DSP             (0 << 0)
 121 #define RIGHT_J         (1 << 0)
 122 #define LEFT_J          (2 << 0)
 123 #define I2S             (3 << 0)
 124
 125 /* MD_CTL2 */
 126 #define FS0             (1 << 0)
 127 #define FS1             (1 << 1)
 128 #define FS2             (1 << 2)
 129 #define FS3             (1 << 5)
 130 #define FS_MASK         (FS0 | FS1 | FS2 | FS3)
 131
 132 /* MD_CTL3 */
 133 #define BST1            (1 << 3)
 134
 135 /* MD_CTL4 */
 136 #define DACH            (1 << 0)
 137
 138 /*
 139  * Playback Volume (table 39)
 140  *
 141  * max : 0x00 : +12.0 dB
 142  *       ( 0.5 dB step )
 143  * min : 0xFE : -115.0 dB
 144  * mute: 0xFF
 145  */
 146 static const DECLARE_TLV_DB_SCALE(out_tlv, -11500, 50, 1);
 147
 148 static const struct snd_kcontrol_new ak4642_snd_controls[] = {
 149
 150         SOC_DOUBLE_R_TLV("Digital Playback Volume", L_DVC, R_DVC,
 151                          0, 0xFF, 1, out_tlv),
 152
 153         SOC_SINGLE("Headphone Switch", PW_MGMT2, 6, 1, 0),
 154 };
 155
 156 static const struct snd_kcontrol_new ak4642_hpout_mixer_controls[] = {
 157         SOC_DAPM_SINGLE("DACH", MD_CTL4, 0, 1, 0),
 158 };
 159
 160 static const struct snd_kcontrol_new ak4642_lout_mixer_controls[] = {
 161         SOC_DAPM_SINGLE("DACL", SG_SL1, 4, 1, 0),
 162 };
 163
 164 static const struct snd_soc_dapm_widget ak4642_dapm_widgets[] = {
 165
 166         /* Outputs */
 167         SND_SOC_DAPM_OUTPUT("HPOUTL"),
 168         SND_SOC_DAPM_OUTPUT("HPOUTR"),
 169         SND_SOC_DAPM_OUTPUT("LINEOUT"),
 170
 171         SND_SOC_DAPM_MIXER("HPOUTL Mixer", PW_MGMT2, 5, 0,
 172                            &ak4642_hpout_mixer_controls[0],
 173                            ARRAY_SIZE(ak4642_hpout_mixer_controls)),
 174
 175         SND_SOC_DAPM_MIXER("HPOUTR Mixer", PW_MGMT2, 4, 0,
 176                            &ak4642_hpout_mixer_controls[0],
 177                            ARRAY_SIZE(ak4642_hpout_mixer_controls)),
 178
 179         SND_SOC_DAPM_MIXER("LINEOUT Mixer", PW_MGMT1, 3, 0,
 180                            &ak4642_lout_mixer_controls[0],
 181                            ARRAY_SIZE(ak4642_lout_mixer_controls)),
 182
 183         /* DAC */
 184         SND_SOC_DAPM_DAC("DAC", "HiFi Playback", PW_MGMT1, 2, 0),
 185 };
 186
 187 static const struct snd_soc_dapm_route ak4642_intercon[] = {
 188
 189         /* Outputs */
 190         {"HPOUTL", NULL, "HPOUTL Mixer"},
 191         {"HPOUTR", NULL, "HPOUTR Mixer"},
 192         {"LINEOUT", NULL, "LINEOUT Mixer"},
 193
 194         {"HPOUTL Mixer", "DACH", "DAC"},
 195         {"HPOUTR Mixer", "DACH", "DAC"},
 196         {"LINEOUT Mixer", "DACL", "DAC"},
 197 };
 198
 199 /* codec private data */
 200 struct ak4642_priv {
 201         unsigned int sysclk;
 202         enum snd_soc_control_type control_type;
 203 };
 204
 205 /*
 206  * ak4642 register cache
 207  */
 208 static const u8 ak4642_reg[] = {
 209         0x00, 0x00, 0x01, 0x00,
 210         0x02, 0x00, 0x00, 0x00,
 211         0xe1, 0xe1, 0x18, 0x00,
 212         0xe1, 0x18, 0x11, 0x08,
 213         0x00, 0x00, 0x00, 0x00,
 214         0x00, 0x00, 0x00, 0x00,
 215         0x00, 0x00, 0x00, 0x00,
 216         0x00, 0x00, 0x00, 0x00,
 217         0x00, 0x00, 0x00, 0x00,
 218         0x00,
 219 };
 220
 221 static const u8 ak4648_reg[] = {
 222         0x00, 0x00, 0x01, 0x00,
 223         0x02, 0x00, 0x00, 0x00,
 224         0xe1, 0xe1, 0x18, 0x00,
 225         0xe1, 0x18, 0x11, 0xb8,
 226         0x00, 0x00, 0x00, 0x00,
 227         0x00, 0x00, 0x00, 0x00,
 228         0x00, 0x00, 0x00, 0x00,
 229         0x00, 0x00, 0x00, 0x00,
 230         0x00, 0x00, 0x00, 0x00,
 231         0x00, 0x88, 0x88, 0x08,
 232 };
 233
 234 static int ak4642_dai_startup(struct snd_pcm_substream *substream,
 235                               struct snd_soc_dai *dai)
 236 {
 237         int is_play = substream->stream == SNDRV_PCM_STREAM_PLAYBACK;
 238         struct snd_soc_codec *codec = dai->codec;
 239
 240         if (is_play) {
 241                 /*
 242                  * start headphone output
 243                  *
 244                  * PLL, Master Mode
 245                  * Audio I/F Format :MSB justified (ADC & DAC)
 246                  * Bass Boost Level : Middle
 247                  *
 248                  * This operation came from example code of
 249                  * "ASAHI KASEI AK4642" (japanese) manual p97.
 250                  */
 251                 snd_soc_write(codec, L_IVC, 0x91); /* volume */
 252                 snd_soc_write(codec, R_IVC, 0x91); /* volume */
 253         } else {
 254                 /*
 255                  * start stereo input
 256                  *
 257                  * PLL Master Mode
 258                  * Audio I/F Format:MSB justified (ADC & DAC)
 259                  * Pre MIC AMP:+20dB
 260                  * MIC Power On
 261                  * ALC setting:Refer to Table 35
 262                  * ALC bit=“1”
 263                  *
 264                  * This operation came from example code of
 265                  * "ASAHI KASEI AK4642" (japanese) manual p94.
 266                  */
 267                 snd_soc_write(codec, SG_SL1, PMMP | MGAIN0);
 268                 snd_soc_write(codec, TIMER, ZTM(0x3) | WTM(0x3));
 269                 snd_soc_write(codec, ALC_CTL1, ALC | LMTH0);
 270                 snd_soc_update_bits(codec, PW_MGMT1, PMADL, PMADL);
 271                 snd_soc_update_bits(codec, PW_MGMT3, PMADR, PMADR);
 272         }
 273
 274         return 0;
 275 }
 276
 277 static void ak4642_dai_shutdown(struct snd_pcm_substream *substream,
 278                                struct snd_soc_dai *dai)
 279 {
 280         int is_play = substream->stream == SNDRV_PCM_STREAM_PLAYBACK;
 281         struct snd_soc_codec *codec = dai->codec;
 282
 283         if (is_play) {
 284         } else {
 285                 /* stop stereo input */
 286                 snd_soc_update_bits(codec, PW_MGMT1, PMADL, 0);
 287                 snd_soc_update_bits(codec, PW_MGMT3, PMADR, 0);
 288                 snd_soc_update_bits(codec, ALC_CTL1, ALC, 0);
 289         }
 290 }
 291
 292 static int ak4642_dai_set_sysclk(struct snd_soc_dai *codec_dai,
 293         int clk_id, unsigned int freq, int dir)
 294 {
 295         struct snd_soc_codec *codec = codec_dai->codec;
 296         u8 pll;
 297
 298         switch (freq) {
 299         case 11289600:
 300                 pll = PLL2;
 301                 break;
 302         case 12288000:
 303                 pll = PLL2 | PLL0;
 304                 break;
 305         case 12000000:
 306                 pll = PLL2 | PLL1;
 307                 break;
 308         case 24000000:
 309                 pll = PLL2 | PLL1 | PLL0;
 310                 break;
 311         case 13500000:
 312                 pll = PLL3 | PLL2;
 313                 break;
 314         case 27000000:
 315                 pll = PLL3 | PLL2 | PLL0;
 316                 break;
 317         default:
 318                 return -EINVAL;
 319         }
 320         snd_soc_update_bits(codec, MD_CTL1, PLL_MASK, pll);
 321
 322         return 0;
 323 }
 324
 325 static int ak4642_dai_set_fmt(struct snd_soc_dai *dai, unsigned int fmt)
 326 {
 327         struct snd_soc_codec *codec = dai->codec;
 328         u8 data;
 329         u8 bcko;
 330
 331         data = MCKO | PMPLL; /* use MCKO */
 332         bcko = 0;
 333
 334         /* set master/slave audio interface */
 335         switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
 336         case SND_SOC_DAIFMT_CBM_CFM:
 337                 data |= MS;
 338                 bcko = BCKO_64;
 339                 break;
 340         case SND_SOC_DAIFMT_CBS_CFS:
 341                 break;
 342         default:
 343                 return -EINVAL;
 344         }
 345         snd_soc_update_bits(codec, PW_MGMT2, MS | MCKO | PMPLL, data);
 346         snd_soc_update_bits(codec, MD_CTL1, BCKO_MASK, bcko);
 347
 348         /* format type */
 349         data = 0;
 350         switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
 351         case SND_SOC_DAIFMT_LEFT_J:
 352                 data = LEFT_J;
 353                 break;
 354         case SND_SOC_DAIFMT_I2S:
 355                 data = I2S;
 356                 break;
 357         /* FIXME
 358          * Please add RIGHT_J / DSP support here
 359          */
 360         default:
 361                 return -EINVAL;
 362                 break;
 363         }
 364         snd_soc_update_bits(codec, MD_CTL1, DIF_MASK, data);
 365
 366         return 0;
 367 }
 368
 369 static int ak4642_dai_hw_params(struct snd_pcm_substream *substream,
 370                                 struct snd_pcm_hw_params *params,
 371                                 struct snd_soc_dai *dai)
 372 {
 373         struct snd_soc_codec *codec = dai->codec;
 374         u8 rate;
 375
 376         switch (params_rate(params)) {
 377         case 7350:
 378                 rate = FS2;
 379                 break;
 380         case 8000:
 381                 rate = 0;
 382                 break;
 383         case 11025:
 384                 rate = FS2 | FS0;
 385                 break;
 386         case 12000:
 387                 rate = FS0;
 388                 break;
 389         case 14700:
 390                 rate = FS2 | FS1;
 391                 break;
 392         case 16000:
 393                 rate = FS1;
 394                 break;
 395         case 22050:
 396                 rate = FS2 | FS1 | FS0;
 397                 break;
 398         case 24000:
 399                 rate = FS1 | FS0;
 400                 break;
 401         case 29400:
 402                 rate = FS3 | FS2 | FS1;
 403                 break;
 404         case 32000:
 405                 rate = FS3 | FS1;
 406                 break;
 407         case 44100:
 408                 rate = FS3 | FS2 | FS1 | FS0;
 409                 break;
 410         case 48000:
 411                 rate = FS3 | FS1 | FS0;
 412                 break;
 413         default:
 414                 return -EINVAL;
 415                 break;
 416         }
 417         snd_soc_update_bits(codec, MD_CTL2, FS_MASK, rate);
 418
 419         return 0;
 420 }
 421
 422 static int ak4642_set_bias_level(struct snd_soc_codec *codec,
 423                                  enum snd_soc_bias_level level)
 424 {
 425         switch (level) {
 426         case SND_SOC_BIAS_OFF:
 427                 snd_soc_write(codec, PW_MGMT1, 0x00);
 428                 break;
 429         default:
 430                 snd_soc_update_bits(codec, PW_MGMT1, PMVCM, PMVCM);
 431                 break;
 432         }
 433         codec->dapm.bias_level = level;
 434
 435         return 0;
 436 }
 437
 438 static const struct snd_soc_dai_ops ak4642_dai_ops = {
 439         .startup        = ak4642_dai_startup,
 440         .shutdown       = ak4642_dai_shutdown,
 441         .set_sysclk     = ak4642_dai_set_sysclk,
 442         .set_fmt        = ak4642_dai_set_fmt,
 443         .hw_params      = ak4642_dai_hw_params,
 444 };
 445
 446 static struct snd_soc_dai_driver ak4642_dai = {
 447         .name = "ak4642-hifi",
 448         .playback = {
 449                 .stream_name = "Playback",
 450                 .channels_min = 1,
 451                 .channels_max = 2,
 452                 .rates = SNDRV_PCM_RATE_8000_48000,
 453                 .formats = SNDRV_PCM_FMTBIT_S16_LE },
 454         .capture = {
 455                 .stream_name = "Capture",
 456                 .channels_min = 1,
 457                 .channels_max = 2,
 458                 .rates = SNDRV_PCM_RATE_8000_48000,
 459                 .formats = SNDRV_PCM_FMTBIT_S16_LE },
 460         .ops = &ak4642_dai_ops,
 461         .symmetric_rates = 1,
 462 };
 463
 464 static int ak4642_resume(struct snd_soc_codec *codec)
 465 {
 466         snd_soc_cache_sync(codec);
 467         return 0;
 468 }
 469
 470
 471 static int ak4642_probe(struct snd_soc_codec *codec)
 472 {
 473         struct ak4642_priv *ak4642 = snd_soc_codec_get_drvdata(codec);
 474         int ret;
 475
 476         dev_info(codec->dev, "AK4642 Audio Codec %s", AK4642_VERSION);
 477
 478         ret = snd_soc_codec_set_cache_io(codec, 8, 8, ak4642->control_type);
 479         if (ret < 0) {
 480                 dev_err(codec->dev, "Failed to set cache I/O: %d\n", ret);
 481                 return ret;
 482         }
 483
 484         snd_soc_add_controls(codec, ak4642_snd_controls,
 485                              ARRAY_SIZE(ak4642_snd_controls));
 486
 487         ak4642_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
 488
 489         return 0;
 490 }
 491
 492 static int ak4642_remove(struct snd_soc_codec *codec)
 493 {
 494         ak4642_set_bias_level(codec, SND_SOC_BIAS_OFF);
 495         return 0;
 496 }
 497
 498 static struct snd_soc_codec_driver soc_codec_dev_ak4642 = {
 499         .probe                  = ak4642_probe,
 500         .remove                 = ak4642_remove,
 501         .resume                 = ak4642_resume,
 502         .set_bias_level         = ak4642_set_bias_level,
 503         .reg_cache_default      = ak4642_reg,                   /* ak4642 reg */
 504         .reg_cache_size         = ARRAY_SIZE(ak4642_reg),       /* ak4642 reg */
 505         .reg_word_size          = sizeof(u8),
 506         .dapm_widgets           = ak4642_dapm_widgets,
 507         .num_dapm_widgets       = ARRAY_SIZE(ak4642_dapm_widgets),
 508         .dapm_routes            = ak4642_intercon,
 509         .num_dapm_routes        = ARRAY_SIZE(ak4642_intercon),
 510 };
 511
 512 static struct snd_soc_codec_driver soc_codec_dev_ak4648 = {
 513         .probe                  = ak4642_probe,
 514         .remove                 = ak4642_remove,
 515         .resume                 = ak4642_resume,
 516         .set_bias_level         = ak4642_set_bias_level,
 517         .reg_cache_default      = ak4648_reg,                   /* ak4648 reg */
 518         .reg_cache_size         = ARRAY_SIZE(ak4648_reg),       /* ak4648 reg */
 519         .reg_word_size          = sizeof(u8),
 520         .dapm_widgets           = ak4642_dapm_widgets,
 521         .num_dapm_widgets       = ARRAY_SIZE(ak4642_dapm_widgets),
 522         .dapm_routes            = ak4642_intercon,
 523         .num_dapm_routes        = ARRAY_SIZE(ak4642_intercon),
 524 };
 525
 526 #if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
 527 static __devinit int ak4642_i2c_probe(struct i2c_client *i2c,
 528                                       const struct i2c_device_id *id)
 529 {
 530         struct ak4642_priv *ak4642;
 531         int ret;
 532
 533         ak4642 = kzalloc(sizeof(struct ak4642_priv), GFP_KERNEL);
 534         if (!ak4642)
 535                 return -ENOMEM;
 536
 537         i2c_set_clientdata(i2c, ak4642);
 538         ak4642->control_type = SND_SOC_I2C;
 539
 540         ret =  snd_soc_register_codec(&i2c->dev,
 541                                 (struct snd_soc_codec_driver *)id->driver_data,
 542                                 &ak4642_dai, 1);
 543         if (ret < 0)
 544                 kfree(ak4642);
 545         return ret;
 546 }
 547
 548 static __devexit int ak4642_i2c_remove(struct i2c_client *client)
 549 {
 550         snd_soc_unregister_codec(&client->dev);
 551         kfree(i2c_get_clientdata(client));
 552         return 0;
 553 }
 554
 555 static const struct i2c_device_id ak4642_i2c_id[] = {
 556         { "ak4642", (kernel_ulong_t)&soc_codec_dev_ak4642 },
 557         { "ak4643", (kernel_ulong_t)&soc_codec_dev_ak4642 },
 558         { "ak4648", (kernel_ulong_t)&soc_codec_dev_ak4648 },
 559         { }
 560 };
 561 MODULE_DEVICE_TABLE(i2c, ak4642_i2c_id);
 562
 563 static struct i2c_driver ak4642_i2c_driver = {
 564         .driver = {
 565                 .name = "ak4642-codec",
 566                 .owner = THIS_MODULE,
 567         },
 568         .probe          = ak4642_i2c_probe,
 569         .remove         = __devexit_p(ak4642_i2c_remove),
 570         .id_table       = ak4642_i2c_id,
 571 };
 572 #endif
 573
 574 static int __init ak4642_modinit(void)
 575 {
 576         int ret = 0;
 577 #if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
 578         ret = i2c_add_driver(&ak4642_i2c_driver);
 579 #endif
 580         return ret;
 581
 582 }
 583 module_init(ak4642_modinit);
 584
 585 static void __exit ak4642_exit(void)
 586 {
 587 #if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
 588         i2c_del_driver(&ak4642_i2c_driver);
 589 #endif
 590
 591 }
 592 module_exit(ak4642_exit);
 593
 594 MODULE_DESCRIPTION("Soc AK4642 driver");
 595 MODULE_AUTHOR("Kuninori Morimoto <morimoto.kuninori@renesas.com>");
 596 MODULE_LICENSE("GPL");