drivers/sound/max98095.c

   1 /*
   2  * max98095.c -- MAX98095 ALSA SoC Audio driver
   3  *
   4  * Copyright 2011 Maxim Integrated Products
   5  *
   6  * Modified for uboot by R. Chandrasekar (rcsekar@samsung.com)
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License version 2 as
  10  * published by the Free Software Foundation.
  11  */
  12
  13 #include <common.h>
  14 #include <asm/arch/clk.h>
  15 #include <asm/arch/cpu.h>
  16 #include <asm/arch/power.h>
  17 #include <asm/gpio.h>
  18 #include <asm/io.h>
  19 #include <common.h>
  20 #include <div64.h>
  21 #include <fdtdec.h>
  22 #include <i2c.h>
  23 #include <sound.h>
  24 #include "i2s.h"
  25 #include "max98095.h"
  26
  27 struct max98095_priv {
  28         unsigned int sysclk;
  29         unsigned int rate;
  30         unsigned int fmt;
  31 };
  32
  33 static struct sound_codec_info g_codec_info;
  34 struct max98095_priv g_max98095_info;
  35 unsigned int g_max98095_i2c_dev_addr;
  36
  37 /* Index 0 is reserved. */
  38 int rate_table[] = {0, 8000, 11025, 16000, 22050, 24000, 32000, 44100, 48000,
  39                 88200, 96000};
  40
  41 /*
  42  * Writes value to a device register through i2c
  43  *
  44  * @param priv  Private data for driver
  45  * @param reg   reg number to be write
  46  * @param data  data to be writen to the above registor
  47  *
  48  * @return      int value 1 for change, 0 for no change or negative error code.
  49  */
  50 static int max98095_i2c_write(struct max98095_priv *priv, unsigned int reg,
  51                               unsigned char data)
  52 {
  53         debug("%s: Write Addr : 0x%02X, Data :  0x%02X\n",
  54               __func__, reg, data);
  55         return i2c_write(g_max98095_i2c_dev_addr, reg, 1, &data, 1);
  56 }
  57
  58 /*
  59  * Read a value from a device register through i2c
  60  *
  61  * @param priv  Private data for driver
  62  * @param reg   reg number to be read
  63  * @param data  address of read data to be stored
  64  *
  65  * @return      int value 0 for success, -1 in case of error.
  66  */
  67 static unsigned int max98095_i2c_read(struct max98095_priv *priv,
  68                                       unsigned int reg, unsigned char *data)
  69 {
  70         int ret;
  71
  72         ret = i2c_read(g_max98095_i2c_dev_addr, reg, 1, data, 1);
  73         if (ret != 0) {
  74                 debug("%s: Error while reading register %#04x\n",
  75                       __func__, reg);
  76                 return -1;
  77         }
  78
  79         return 0;
  80 }
  81
  82 /*
  83  * update device register bits through i2c
  84  *
  85  * @param priv  Private data for driver
  86  * @param reg   codec register
  87  * @param mask  register mask
  88  * @param value new value
  89  *
  90  * @return int value 0 for success, non-zero error code.
  91  */
  92 static int max98095_bic_or(struct max98095_priv *priv, unsigned int reg,
  93                            unsigned char mask, unsigned char value)
  94 {
  95         int change, ret = 0;
  96         unsigned char old, new;
  97
  98         if (max98095_i2c_read(priv, reg, &old) != 0)
  99                 return -1;
 100         new = (old & ~mask) | (value & mask);
 101         change  = (old != new) ? 1 : 0;
 102         if (change)
 103                 ret = max98095_i2c_write(priv, reg, new);
 104         if (ret < 0)
 105                 return ret;
 106
 107         return change;
 108 }
 109
 110 /*
 111  * codec mclk clock divider coefficients based on sampling rate
 112  *
 113  * @param rate sampling rate
 114  * @param value address of indexvalue to be stored
 115  *
 116  * @return      0 for success or negative error code.
 117  */
 118 static int rate_value(int rate, u8 *value)
 119 {
 120         int i;
 121
 122         for (i = 1; i < ARRAY_SIZE(rate_table); i++) {
 123                 if (rate_table[i] >= rate) {
 124                         *value = i;
 125                         return 0;
 126                 }
 127         }
 128         *value = 1;
 129
 130         return -1;
 131 }
 132
 133 /*
 134  * Sets hw params for max98095
 135  *
 136  * @param priv          max98095 information pointer
 137  * @param rate          Sampling rate
 138  * @param bits_per_sample       Bits per sample
 139  *
 140  * @return -1 for error  and 0  Success.
 141  */
 142 static int max98095_hw_params(struct max98095_priv *priv,
 143                               enum en_max_audio_interface aif_id,
 144                               unsigned int rate, unsigned int bits_per_sample)
 145 {
 146         u8 regval;
 147         int error;
 148         unsigned short M98095_DAI_CLKMODE;
 149         unsigned short M98095_DAI_FORMAT;
 150         unsigned short M98095_DAI_FILTERS;
 151
 152         if (aif_id == AIF1) {
 153                 M98095_DAI_CLKMODE = M98095_027_DAI1_CLKMODE;
 154                 M98095_DAI_FORMAT = M98095_02A_DAI1_FORMAT;
 155                 M98095_DAI_FILTERS = M98095_02E_DAI1_FILTERS;
 156         } else {
 157                 M98095_DAI_CLKMODE = M98095_031_DAI2_CLKMODE;
 158                 M98095_DAI_FORMAT = M98095_034_DAI2_FORMAT;
 159                 M98095_DAI_FILTERS = M98095_038_DAI2_FILTERS;
 160         }
 161
 162         switch (bits_per_sample) {
 163         case 16:
 164                 error = max98095_bic_or(priv, M98095_DAI_FORMAT, M98095_DAI_WS,
 165                                         0);
 166                 break;
 167         case 24:
 168                 error = max98095_bic_or(priv, M98095_DAI_FORMAT, M98095_DAI_WS,
 169                                         M98095_DAI_WS);
 170                 break;
 171         default:
 172                 debug("%s: Illegal bits per sample %d.\n",
 173                       __func__, bits_per_sample);
 174                 return -1;
 175         }
 176
 177         if (rate_value(rate, &regval)) {
 178                 debug("%s: Failed to set sample rate to %d.\n",
 179                       __func__, rate);
 180                 return -1;
 181         }
 182         priv->rate = rate;
 183
 184         error |= max98095_bic_or(priv, M98095_DAI_CLKMODE, M98095_CLKMODE_MASK,
 185                                  regval);
 186
 187         /* Update sample rate mode */
 188         if (rate < 50000)
 189                 error |= max98095_bic_or(priv, M98095_DAI_FILTERS,
 190                                          M98095_DAI_DHF, 0);
 191         else
 192                 error |= max98095_bic_or(priv, M98095_DAI_FILTERS,
 193                                          M98095_DAI_DHF, M98095_DAI_DHF);
 194
 195         if (error < 0) {
 196                 debug("%s: Error setting hardware params.\n", __func__);
 197                 return -1;
 198         }
 199
 200         return 0;
 201 }
 202
 203 /*
 204  * Configures Audio interface system clock for the given frequency
 205  *
 206  * @param priv          max98095 information
 207  * @param freq          Sampling frequency in Hz
 208  *
 209  * @return -1 for error and 0 success.
 210  */
 211 static int max98095_set_sysclk(struct max98095_priv *priv, unsigned int freq)
 212 {
 213         int error = 0;
 214
 215         /* Requested clock frequency is already setup */
 216         if (freq == priv->sysclk)
 217                 return 0;
 218
 219         /* Setup clocks for slave mode, and using the PLL
 220          * PSCLK = 0x01 (when master clk is 10MHz to 20MHz)
 221          *      0x02 (when master clk is 20MHz to 40MHz)..
 222          *      0x03 (when master clk is 40MHz to 60MHz)..
 223          */
 224         if ((freq >= 10000000) && (freq < 20000000)) {
 225                 error = max98095_i2c_write(priv, M98095_026_SYS_CLK, 0x10);
 226         } else if ((freq >= 20000000) && (freq < 40000000)) {
 227                 error = max98095_i2c_write(priv, M98095_026_SYS_CLK, 0x20);
 228         } else if ((freq >= 40000000) && (freq < 60000000)) {
 229                 error = max98095_i2c_write(priv, M98095_026_SYS_CLK, 0x30);
 230         } else {
 231                 debug("%s: Invalid master clock frequency\n", __func__);
 232                 return -1;
 233         }
 234
 235         debug("%s: Clock at %uHz\n", __func__, freq);
 236
 237         if (error < 0)
 238                 return -1;
 239
 240         priv->sysclk = freq;
 241         return 0;
 242 }
 243
 244 /*
 245  * Sets Max98095 I2S format
 246  *
 247  * @param priv          max98095 information
 248  * @param fmt           i2S format - supports a subset of the options defined
 249  *                      in i2s.h.
 250  *
 251  * @return -1 for error and 0  Success.
 252  */
 253 static int max98095_set_fmt(struct max98095_priv *priv, int fmt,
 254                             enum en_max_audio_interface aif_id)
 255 {
 256         u8 regval = 0;
 257         int error = 0;
 258         unsigned short M98095_DAI_CLKCFG_HI;
 259         unsigned short M98095_DAI_CLKCFG_LO;
 260         unsigned short M98095_DAI_FORMAT;
 261         unsigned short M98095_DAI_CLOCK;
 262
 263         if (fmt == priv->fmt)
 264                 return 0;
 265
 266         priv->fmt = fmt;
 267
 268         if (aif_id == AIF1) {
 269                 M98095_DAI_CLKCFG_HI = M98095_028_DAI1_CLKCFG_HI;
 270                 M98095_DAI_CLKCFG_LO = M98095_029_DAI1_CLKCFG_LO;
 271                 M98095_DAI_FORMAT = M98095_02A_DAI1_FORMAT;
 272                 M98095_DAI_CLOCK = M98095_02B_DAI1_CLOCK;
 273         } else {
 274                 M98095_DAI_CLKCFG_HI = M98095_032_DAI2_CLKCFG_HI;
 275                 M98095_DAI_CLKCFG_LO = M98095_033_DAI2_CLKCFG_LO;
 276                 M98095_DAI_FORMAT = M98095_034_DAI2_FORMAT;
 277                 M98095_DAI_CLOCK = M98095_035_DAI2_CLOCK;
 278         }
 279
 280         switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
 281         case SND_SOC_DAIFMT_CBS_CFS:
 282                 /* Slave mode PLL */
 283                 error |= max98095_i2c_write(priv, M98095_DAI_CLKCFG_HI, 0x80);
 284                 error |= max98095_i2c_write(priv, M98095_DAI_CLKCFG_LO, 0x00);
 285                 break;
 286         case SND_SOC_DAIFMT_CBM_CFM:
 287                 /* Set to master mode */
 288                 regval |= M98095_DAI_MAS;
 289                 break;
 290         case SND_SOC_DAIFMT_CBS_CFM:
 291         case SND_SOC_DAIFMT_CBM_CFS:
 292         default:
 293                 debug("%s: Clock mode unsupported\n", __func__);
 294                 return -1;
 295         }
 296
 297         switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
 298         case SND_SOC_DAIFMT_I2S:
 299                 regval |= M98095_DAI_DLY;
 300                 break;
 301         case SND_SOC_DAIFMT_LEFT_J:
 302                 break;
 303         default:
 304                 debug("%s: Unrecognized format.\n", __func__);
 305                 return -1;
 306         }
 307
 308         switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
 309         case SND_SOC_DAIFMT_NB_NF:
 310                 break;
 311         case SND_SOC_DAIFMT_NB_IF:
 312                 regval |= M98095_DAI_WCI;
 313                 break;
 314         case SND_SOC_DAIFMT_IB_NF:
 315                 regval |= M98095_DAI_BCI;
 316                 break;
 317         case SND_SOC_DAIFMT_IB_IF:
 318                 regval |= M98095_DAI_BCI | M98095_DAI_WCI;
 319                 break;
 320         default:
 321                 debug("%s: Unrecognized inversion settings.\n", __func__);
 322                 return -1;
 323         }
 324
 325         error |= max98095_bic_or(priv, M98095_DAI_FORMAT,
 326                                  M98095_DAI_MAS | M98095_DAI_DLY |
 327                                  M98095_DAI_BCI | M98095_DAI_WCI, regval);
 328
 329         error |= max98095_i2c_write(priv, M98095_DAI_CLOCK, M98095_DAI_BSEL64);
 330
 331         if (error < 0) {
 332                 debug("%s: Error setting i2s format.\n", __func__);
 333                 return -1;
 334         }
 335
 336         return 0;
 337 }
 338
 339 /*
 340  * resets the audio codec
 341  *
 342  * @param priv  Private data for driver
 343  * @return -1 for error and 0 success.
 344  */
 345 static int max98095_reset(struct max98095_priv *priv)
 346 {
 347         int i, ret;
 348
 349         /*
 350          * Gracefully reset the DSP core and the codec hardware in a proper
 351          * sequence.
 352          */
 353         ret = max98095_i2c_write(priv, M98095_00F_HOST_CFG, 0);
 354         if (ret != 0) {
 355                 debug("%s: Failed to reset DSP: %d\n", __func__, ret);
 356                 return ret;
 357         }
 358
 359         ret = max98095_i2c_write(priv, M98095_097_PWR_SYS, 0);
 360         if (ret != 0) {
 361                 debug("%s: Failed to reset codec: %d\n", __func__, ret);
 362                 return ret;
 363         }
 364
 365         /*
 366          * Reset to hardware default for registers, as there is not a soft
 367          * reset hardware control register.
 368          */
 369         for (i = M98095_010_HOST_INT_CFG; i < M98095_REG_MAX_CACHED; i++) {
 370                 ret = max98095_i2c_write(priv, i, 0);
 371                 if (ret < 0) {
 372                         debug("%s: Failed to reset: %d\n", __func__, ret);
 373                         return ret;
 374                 }
 375         }
 376
 377         return 0;
 378 }
 379
 380 /*
 381  * Intialise max98095 codec device
 382  *
 383  * @param priv          max98095 information
 384  *
 385  * @returns -1 for error  and 0 Success.
 386  */
 387 static int max98095_device_init(struct max98095_priv *priv,
 388                                 enum en_max_audio_interface aif_id)
 389 {
 390         unsigned char id;
 391         int error = 0;
 392
 393         /* reset the codec, the DSP core, and disable all interrupts */
 394         error = max98095_reset(priv);
 395         if (error != 0) {
 396                 debug("Reset\n");
 397                 return error;
 398         }
 399
 400         /* initialize private data */
 401         priv->sysclk = -1U;
 402         priv->rate = -1U;
 403         priv->fmt = -1U;
 404
 405         error = max98095_i2c_read(priv, M98095_0FF_REV_ID, &id);
 406         if (error < 0) {
 407                 debug("%s: Failure reading hardware revision: %d\n",
 408                       __func__, id);
 409                 goto err_access;
 410         }
 411         debug("%s: Hardware revision: %c\n", __func__, (id - 0x40) + 'A');
 412
 413         error |= max98095_i2c_write(priv, M98095_097_PWR_SYS, M98095_PWRSV);
 414
 415         /*
 416          * initialize registers to hardware default configuring audio
 417          * interface2 to DAC
 418          */
 419         if (aif_id == AIF1)
 420                 error |= max98095_i2c_write(priv, M98095_048_MIX_DAC_LR,
 421                                             M98095_DAI1L_TO_DACL |
 422                                             M98095_DAI1R_TO_DACR);
 423         else
 424                 error |= max98095_i2c_write(priv, M98095_048_MIX_DAC_LR,
 425                                             M98095_DAI2M_TO_DACL |
 426                                             M98095_DAI2M_TO_DACR);
 427
 428         error |= max98095_i2c_write(priv, M98095_092_PWR_EN_OUT,
 429                                     M98095_SPK_SPREADSPECTRUM);
 430         error |= max98095_i2c_write(priv, M98095_04E_CFG_HP, M98095_HPNORMAL);
 431         if (aif_id == AIF1)
 432                 error |= max98095_i2c_write(priv, M98095_02C_DAI1_IOCFG,
 433                                             M98095_S1NORMAL | M98095_SDATA);
 434         else
 435                 error |= max98095_i2c_write(priv, M98095_036_DAI2_IOCFG,
 436                                             M98095_S2NORMAL | M98095_SDATA);
 437
 438         /* take the codec out of the shut down */
 439         error |= max98095_bic_or(priv, M98095_097_PWR_SYS, M98095_SHDNRUN,
 440                                  M98095_SHDNRUN);
 441         /*
 442          * route DACL and DACR output to HO and Speakers
 443          * Ordering: DACL, DACR, DACL, DACR
 444          */
 445         error |= max98095_i2c_write(priv, M98095_050_MIX_SPK_LEFT, 0x01);
 446         error |= max98095_i2c_write(priv, M98095_051_MIX_SPK_RIGHT, 0x01);
 447         error |= max98095_i2c_write(priv, M98095_04C_MIX_HP_LEFT, 0x01);
 448         error |= max98095_i2c_write(priv, M98095_04D_MIX_HP_RIGHT, 0x01);
 449
 450         /* power Enable */
 451         error |= max98095_i2c_write(priv, M98095_091_PWR_EN_OUT, 0xF3);
 452
 453         /* set Volume */
 454         error |= max98095_i2c_write(priv, M98095_064_LVL_HP_L, 15);
 455         error |= max98095_i2c_write(priv, M98095_065_LVL_HP_R, 15);
 456         error |= max98095_i2c_write(priv, M98095_067_LVL_SPK_L, 16);
 457         error |= max98095_i2c_write(priv, M98095_068_LVL_SPK_R, 16);
 458
 459         /* Enable DAIs */
 460         error |= max98095_i2c_write(priv, M98095_093_BIAS_CTRL, 0x30);
 461         if (aif_id == AIF1)
 462                 error |= max98095_i2c_write(priv, M98095_096_PWR_DAC_CK, 0x01);
 463         else
 464                 error |= max98095_i2c_write(priv, M98095_096_PWR_DAC_CK, 0x07);
 465
 466 err_access:
 467         if (error < 0)
 468                 return -1;
 469
 470         return 0;
 471 }
 472
 473 static int max98095_do_init(struct sound_codec_info *pcodec_info,
 474                             enum en_max_audio_interface aif_id,
 475                             int sampling_rate, int mclk_freq,
 476                             int bits_per_sample)
 477 {
 478         int ret = 0;
 479
 480         /* Enable codec clock */
 481         set_xclkout();
 482
 483         /* shift the device address by 1 for 7 bit addressing */
 484         g_max98095_i2c_dev_addr = pcodec_info->i2c_dev_addr >> 1;
 485
 486         ret = max98095_device_init(&g_max98095_info, aif_id);
 487         if (ret < 0) {
 488                 debug("%s: max98095 codec chip init failed\n", __func__);
 489                 return ret;
 490         }
 491
 492         ret = max98095_set_sysclk(&g_max98095_info, mclk_freq);
 493         if (ret < 0) {
 494                 debug("%s: max98095 codec set sys clock failed\n", __func__);
 495                 return ret;
 496         }
 497
 498         ret = max98095_hw_params(&g_max98095_info, aif_id, sampling_rate,
 499                                  bits_per_sample);
 500
 501         if (ret == 0) {
 502                 ret = max98095_set_fmt(&g_max98095_info,
 503                                        SND_SOC_DAIFMT_I2S |
 504                                        SND_SOC_DAIFMT_NB_NF |
 505                                        SND_SOC_DAIFMT_CBS_CFS,
 506                                        aif_id);
 507         }
 508
 509         return ret;
 510 }
 511
 512 static int get_max98095_codec_values(struct sound_codec_info *pcodec_info,
 513                                 const void *blob)
 514 {
 515         int error = 0;
 516         enum fdt_compat_id compat;
 517         int node;
 518         int parent;
 519
 520         /* Get the node from FDT for codec */
 521         node = fdtdec_next_compatible(blob, 0, COMPAT_MAXIM_98095_CODEC);
 522         if (node <= 0) {
 523                 debug("EXYNOS_SOUND: No node for codec in device tree\n");
 524                 debug("node = %d\n", node);
 525                 return -1;
 526         }
 527
 528         parent = fdt_parent_offset(blob, node);
 529         if (parent < 0) {
 530                 debug("%s: Cannot find node parent\n", __func__);
 531                 return -1;
 532         }
 533
 534         compat = fdtdec_lookup(blob, parent);
 535         switch (compat) {
 536         case COMPAT_SAMSUNG_S3C2440_I2C:
 537                 pcodec_info->i2c_bus = i2c_get_bus_num_fdt(parent);
 538                 error |= pcodec_info->i2c_bus;
 539                 debug("i2c bus = %d\n", pcodec_info->i2c_bus);
 540                 pcodec_info->i2c_dev_addr = fdtdec_get_int(blob, node,
 541                                                         "reg", 0);
 542                 error |= pcodec_info->i2c_dev_addr;
 543                 debug("i2c dev addr = %x\n", pcodec_info->i2c_dev_addr);
 544                 break;
 545         default:
 546                 debug("%s: Unknown compat id %d\n", __func__, compat);
 547                 return -1;
 548         }
 549         if (error == -1) {
 550                 debug("fail to get max98095 codec node properties\n");
 551                 return -1;
 552         }
 553
 554         return 0;
 555 }
 556
 557 /* max98095 Device Initialisation */
 558 int max98095_init(const void *blob, enum en_max_audio_interface aif_id,
 559                   int sampling_rate, int mclk_freq,
 560                   int bits_per_sample)
 561 {
 562         int ret;
 563         int old_bus = i2c_get_bus_num();
 564         struct sound_codec_info *pcodec_info = &g_codec_info;
 565
 566         if (get_max98095_codec_values(pcodec_info, blob) < 0) {
 567                 debug("FDT Codec values failed\n");
 568                 return -1;
 569         }
 570
 571         i2c_set_bus_num(pcodec_info->i2c_bus);
 572         ret = max98095_do_init(pcodec_info, aif_id, sampling_rate, mclk_freq,
 573                                bits_per_sample);
 574         i2c_set_bus_num(old_bus);
 575
 576         return ret;
 577 }