sound/soc/codecs/max9867.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 //
   3 // MAX9867 ALSA SoC codec driver
   4 //
   5 // Copyright 2013-2015 Maxim Integrated Products
   6 // Copyright 2018 Ladislav Michl <ladis@linux-mips.org>
   7 //
   8
   9 #include <linux/delay.h>
  10 #include <linux/i2c.h>
  11 #include <linux/module.h>
  12 #include <linux/regmap.h>
  13 #include <sound/pcm_params.h>
  14 #include <sound/soc.h>
  15 #include <sound/tlv.h>
  16 #include "max9867.h"
  17
  18 static const char *const max9867_spmode[] = {
  19         "Stereo Diff", "Mono Diff",
  20         "Stereo Cap", "Mono Cap",
  21         "Stereo Single", "Mono Single",
  22         "Stereo Single Fast", "Mono Single Fast"
  23 };
  24 static const char *const max9867_filter_text[] = {"IIR", "FIR"};
  25
  26 static SOC_ENUM_SINGLE_DECL(max9867_filter, MAX9867_CODECFLTR, 7,
  27         max9867_filter_text);
  28 static SOC_ENUM_SINGLE_DECL(max9867_spkmode, MAX9867_MODECONFIG, 0,
  29         max9867_spmode);
  30 static const SNDRV_CTL_TLVD_DECLARE_DB_RANGE(max9867_master_tlv,
  31          0,  2, TLV_DB_SCALE_ITEM(-8600, 200, 1),
  32          3, 17, TLV_DB_SCALE_ITEM(-7800, 400, 0),
  33         18, 25, TLV_DB_SCALE_ITEM(-2000, 200, 0),
  34         26, 34, TLV_DB_SCALE_ITEM( -500, 100, 0),
  35         35, 40, TLV_DB_SCALE_ITEM(  350,  50, 0),
  36 );
  37 static DECLARE_TLV_DB_SCALE(max9867_mic_tlv, 0, 100, 0);
  38 static DECLARE_TLV_DB_SCALE(max9867_line_tlv, -600, 200, 0);
  39 static DECLARE_TLV_DB_SCALE(max9867_adc_tlv, -1200, 100, 0);
  40 static DECLARE_TLV_DB_SCALE(max9867_dac_tlv, -1500, 100, 0);
  41 static DECLARE_TLV_DB_SCALE(max9867_dacboost_tlv, 0, 600, 0);
  42 static const SNDRV_CTL_TLVD_DECLARE_DB_RANGE(max9867_micboost_tlv,
  43         0, 2, TLV_DB_SCALE_ITEM(-2000, 2000, 1),
  44         3, 3, TLV_DB_SCALE_ITEM(3000, 0, 0),
  45 );
  46
  47 static const struct snd_kcontrol_new max9867_snd_controls[] = {
  48         SOC_DOUBLE_R_TLV("Master Playback Volume", MAX9867_LEFTVOL,
  49                         MAX9867_RIGHTVOL, 0, 41, 1, max9867_master_tlv),
  50         SOC_DOUBLE_R_TLV("Line Capture Volume", MAX9867_LEFTLINELVL,
  51                         MAX9867_RIGHTLINELVL, 0, 15, 1, max9867_line_tlv),
  52         SOC_DOUBLE_R_TLV("Mic Capture Volume", MAX9867_LEFTMICGAIN,
  53                         MAX9867_RIGHTMICGAIN, 0, 20, 1, max9867_mic_tlv),
  54         SOC_DOUBLE_R_TLV("Mic Boost Capture Volume", MAX9867_LEFTMICGAIN,
  55                         MAX9867_RIGHTMICGAIN, 5, 4, 0, max9867_micboost_tlv),
  56         SOC_SINGLE("Digital Sidetone Volume", MAX9867_SIDETONE, 0, 31, 1),
  57         SOC_SINGLE_TLV("Digital Playback Volume", MAX9867_DACLEVEL, 0, 15, 1,
  58                         max9867_dac_tlv),
  59         SOC_SINGLE_TLV("Digital Boost Playback Volume", MAX9867_DACLEVEL, 4, 3, 0,
  60                         max9867_dacboost_tlv),
  61         SOC_DOUBLE_TLV("Digital Capture Volume", MAX9867_ADCLEVEL, 0, 4, 15, 1,
  62                         max9867_adc_tlv),
  63         SOC_ENUM("Speaker Mode", max9867_spkmode),
  64         SOC_SINGLE("Volume Smoothing Switch", MAX9867_MODECONFIG, 6, 1, 0),
  65         SOC_SINGLE("Line ZC Switch", MAX9867_MODECONFIG, 5, 1, 0),
  66         SOC_ENUM("DSP Filter", max9867_filter),
  67 };
  68
  69 /* Input mixer */
  70 static const struct snd_kcontrol_new max9867_input_mixer_controls[] = {
  71         SOC_DAPM_DOUBLE("Line Capture Switch", MAX9867_INPUTCONFIG, 7, 5, 1, 0),
  72         SOC_DAPM_DOUBLE("Mic Capture Switch", MAX9867_INPUTCONFIG, 6, 4, 1, 0),
  73 };
  74
  75 /* Output mixer */
  76 static const struct snd_kcontrol_new max9867_output_mixer_controls[] = {
  77         SOC_DAPM_DOUBLE_R("Line Bypass Switch",
  78                           MAX9867_LEFTLINELVL, MAX9867_RIGHTLINELVL, 6, 1, 1),
  79 };
  80
  81 /* Sidetone mixer */
  82 static const struct snd_kcontrol_new max9867_sidetone_mixer_controls[] = {
  83         SOC_DAPM_DOUBLE("Sidetone Switch", MAX9867_SIDETONE, 6, 7, 1, 0),
  84 };
  85
  86 /* Line out switch */
  87 static const struct snd_kcontrol_new max9867_line_out_control =
  88         SOC_DAPM_DOUBLE_R("Switch",
  89                           MAX9867_LEFTVOL, MAX9867_RIGHTVOL, 6, 1, 1);
  90
  91
  92 static const struct snd_soc_dapm_widget max9867_dapm_widgets[] = {
  93         SND_SOC_DAPM_INPUT("MICL"),
  94         SND_SOC_DAPM_INPUT("MICR"),
  95         SND_SOC_DAPM_INPUT("LINL"),
  96         SND_SOC_DAPM_INPUT("LINR"),
  97
  98         SND_SOC_DAPM_PGA("Left Line Input", MAX9867_PWRMAN, 6, 0, NULL, 0),
  99         SND_SOC_DAPM_PGA("Right Line Input", MAX9867_PWRMAN, 5, 0, NULL, 0),
 100         SND_SOC_DAPM_MIXER_NAMED_CTL("Input Mixer", SND_SOC_NOPM, 0, 0,
 101                                      max9867_input_mixer_controls,
 102                                      ARRAY_SIZE(max9867_input_mixer_controls)),
 103         SND_SOC_DAPM_ADC("ADCL", "HiFi Capture", MAX9867_PWRMAN, 1, 0),
 104         SND_SOC_DAPM_ADC("ADCR", "HiFi Capture", MAX9867_PWRMAN, 0, 0),
 105
 106         SND_SOC_DAPM_MIXER("Digital", SND_SOC_NOPM, 0, 0,
 107                            max9867_sidetone_mixer_controls,
 108                            ARRAY_SIZE(max9867_sidetone_mixer_controls)),
 109         SND_SOC_DAPM_MIXER_NAMED_CTL("Output Mixer", SND_SOC_NOPM, 0, 0,
 110                                      max9867_output_mixer_controls,
 111                                      ARRAY_SIZE(max9867_output_mixer_controls)),
 112         SND_SOC_DAPM_DAC("DACL", "HiFi Playback", MAX9867_PWRMAN, 3, 0),
 113         SND_SOC_DAPM_DAC("DACR", "HiFi Playback", MAX9867_PWRMAN, 2, 0),
 114         SND_SOC_DAPM_SWITCH("Master Playback", SND_SOC_NOPM, 0, 0,
 115                             &max9867_line_out_control),
 116         SND_SOC_DAPM_OUTPUT("LOUT"),
 117         SND_SOC_DAPM_OUTPUT("ROUT"),
 118 };
 119
 120 static const struct snd_soc_dapm_route max9867_audio_map[] = {
 121         {"Left Line Input", NULL, "LINL"},
 122         {"Right Line Input", NULL, "LINR"},
 123         {"Input Mixer", "Mic Capture Switch", "MICL"},
 124         {"Input Mixer", "Mic Capture Switch", "MICR"},
 125         {"Input Mixer", "Line Capture Switch", "Left Line Input"},
 126         {"Input Mixer", "Line Capture Switch", "Right Line Input"},
 127         {"ADCL", NULL, "Input Mixer"},
 128         {"ADCR", NULL, "Input Mixer"},
 129
 130         {"Digital", "Sidetone Switch", "ADCL"},
 131         {"Digital", "Sidetone Switch", "ADCR"},
 132         {"DACL", NULL, "Digital"},
 133         {"DACR", NULL, "Digital"},
 134
 135         {"Output Mixer", "Line Bypass Switch", "Left Line Input"},
 136         {"Output Mixer", "Line Bypass Switch", "Right Line Input"},
 137         {"Output Mixer", NULL, "DACL"},
 138         {"Output Mixer", NULL, "DACR"},
 139         {"Master Playback", "Switch", "Output Mixer"},
 140         {"LOUT", NULL, "Master Playback"},
 141         {"ROUT", NULL, "Master Playback"},
 142 };
 143
 144 static const unsigned int max9867_rates_44k1[] = {
 145         11025, 22050, 44100,
 146 };
 147
 148 static const struct snd_pcm_hw_constraint_list max9867_constraints_44k1 = {
 149         .list = max9867_rates_44k1,
 150         .count = ARRAY_SIZE(max9867_rates_44k1),
 151 };
 152
 153 static const unsigned int max9867_rates_48k[] = {
 154         8000, 16000, 32000, 48000,
 155 };
 156
 157 static const struct snd_pcm_hw_constraint_list max9867_constraints_48k = {
 158         .list = max9867_rates_48k,
 159         .count = ARRAY_SIZE(max9867_rates_48k),
 160 };
 161
 162 struct max9867_priv {
 163         struct regmap *regmap;
 164         const struct snd_pcm_hw_constraint_list *constraints;
 165         unsigned int sysclk, pclk;
 166         bool master, dsp_a;
 167 };
 168
 169 static int max9867_startup(struct snd_pcm_substream *substream,
 170                            struct snd_soc_dai *dai)
 171 {
 172         struct max9867_priv *max9867 =
 173                 snd_soc_component_get_drvdata(dai->component);
 174
 175         if (max9867->constraints)
 176                 snd_pcm_hw_constraint_list(substream->runtime, 0,
 177                         SNDRV_PCM_HW_PARAM_RATE, max9867->constraints);
 178
 179         return 0;
 180 }
 181
 182 static int max9867_dai_hw_params(struct snd_pcm_substream *substream,
 183                 struct snd_pcm_hw_params *params, struct snd_soc_dai *dai)
 184 {
 185         int value;
 186         unsigned long int rate, ratio;
 187         struct snd_soc_component *component = dai->component;
 188         struct max9867_priv *max9867 = snd_soc_component_get_drvdata(component);
 189         unsigned int ni = DIV_ROUND_CLOSEST_ULL(96ULL * 0x10000 * params_rate(params),
 190                                                 max9867->pclk);
 191
 192         /* set up the ni value */
 193         regmap_update_bits(max9867->regmap, MAX9867_AUDIOCLKHIGH,
 194                 MAX9867_NI_HIGH_MASK, (0xFF00 & ni) >> 8);
 195         regmap_update_bits(max9867->regmap, MAX9867_AUDIOCLKLOW,
 196                 MAX9867_NI_LOW_MASK, 0x00FF & ni);
 197         if (max9867->master) {
 198                 if (max9867->dsp_a) {
 199                         value = MAX9867_IFC1B_48X;
 200                 } else {
 201                         rate = params_rate(params) * 2 * params_width(params);
 202                         ratio = max9867->pclk / rate;
 203                         switch (params_width(params)) {
 204                         case 8:
 205                         case 16:
 206                                 switch (ratio) {
 207                                 case 2:
 208                                         value = MAX9867_IFC1B_PCLK_2;
 209                                         break;
 210                                 case 4:
 211                                         value = MAX9867_IFC1B_PCLK_4;
 212                                         break;
 213                                 case 8:
 214                                         value = MAX9867_IFC1B_PCLK_8;
 215                                         break;
 216                                 case 16:
 217                                         value = MAX9867_IFC1B_PCLK_16;
 218                                         break;
 219                                 default:
 220                                         return -EINVAL;
 221                                 }
 222                                 break;
 223                         case 24:
 224                                 value = MAX9867_IFC1B_48X;
 225                                 break;
 226                         case 32:
 227                                 value = MAX9867_IFC1B_64X;
 228                                 break;
 229                         default:
 230                                 return -EINVAL;
 231                         }
 232                 }
 233                 regmap_update_bits(max9867->regmap, MAX9867_IFC1B,
 234                         MAX9867_IFC1B_BCLK_MASK, value);
 235         } else {
 236                 /*
 237                  * digital pll locks on to any externally supplied LRCLK signal
 238                  * and also enable rapid lock mode.
 239                  */
 240                 regmap_update_bits(max9867->regmap, MAX9867_AUDIOCLKLOW,
 241                         MAX9867_RAPID_LOCK, MAX9867_RAPID_LOCK);
 242                 regmap_update_bits(max9867->regmap, MAX9867_AUDIOCLKHIGH,
 243                         MAX9867_PLL, MAX9867_PLL);
 244         }
 245         return 0;
 246 }
 247
 248 static int max9867_mute(struct snd_soc_dai *dai, int mute)
 249 {
 250         struct snd_soc_component *component = dai->component;
 251         struct max9867_priv *max9867 = snd_soc_component_get_drvdata(component);
 252
 253         return regmap_update_bits(max9867->regmap, MAX9867_DACLEVEL,
 254                                   1 << 6, !!mute << 6);
 255 }
 256
 257 static int max9867_set_dai_sysclk(struct snd_soc_dai *codec_dai,
 258                 int clk_id, unsigned int freq, int dir)
 259 {
 260         struct snd_soc_component *component = codec_dai->component;
 261         struct max9867_priv *max9867 = snd_soc_component_get_drvdata(component);
 262         int value = 0;
 263
 264         /* Set the prescaler based on the master clock frequency*/
 265         if (freq >= 10000000 && freq <= 20000000) {
 266                 value |= MAX9867_PSCLK_10_20;
 267                 max9867->pclk = freq;
 268         } else if (freq >= 20000000 && freq <= 40000000) {
 269                 value |= MAX9867_PSCLK_20_40;
 270                 max9867->pclk = freq / 2;
 271         } else if (freq >= 40000000 && freq <= 60000000) {
 272                 value |= MAX9867_PSCLK_40_60;
 273                 max9867->pclk = freq / 4;
 274         } else {
 275                 dev_err(component->dev,
 276                         "Invalid clock frequency %uHz (required 10-60MHz)\n",
 277                         freq);
 278                 return -EINVAL;
 279         }
 280         if (freq % 48000 == 0)
 281                 max9867->constraints = &max9867_constraints_48k;
 282         else if (freq % 44100 == 0)
 283                 max9867->constraints = &max9867_constraints_44k1;
 284         else
 285                 dev_warn(component->dev,
 286                          "Unable to set exact rate with %uHz clock frequency\n",
 287                          freq);
 288         max9867->sysclk = freq;
 289         value = value << MAX9867_PSCLK_SHIFT;
 290         /* exact integer mode is not supported */
 291         value &= ~MAX9867_FREQ_MASK;
 292         regmap_update_bits(max9867->regmap, MAX9867_SYSCLK,
 293                         MAX9867_PSCLK_MASK, value);
 294         return 0;
 295 }
 296
 297 static int max9867_dai_set_fmt(struct snd_soc_dai *codec_dai,
 298                 unsigned int fmt)
 299 {
 300         struct snd_soc_component *component = codec_dai->component;
 301         struct max9867_priv *max9867 = snd_soc_component_get_drvdata(component);
 302         u8 iface1A, iface1B;
 303
 304         switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
 305         case SND_SOC_DAIFMT_CBM_CFM:
 306                 max9867->master = true;
 307                 iface1A = MAX9867_MASTER;
 308                 iface1B = MAX9867_IFC1B_48X;
 309                 break;
 310         case SND_SOC_DAIFMT_CBS_CFS:
 311                 max9867->master = false;
 312                 iface1A = iface1B = 0;
 313                 break;
 314         default:
 315                 return -EINVAL;
 316         }
 317
 318         switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
 319         case SND_SOC_DAIFMT_I2S:
 320                 max9867->dsp_a = false;
 321                 iface1A |= MAX9867_I2S_DLY;
 322                 break;
 323         case SND_SOC_DAIFMT_DSP_A:
 324                 max9867->dsp_a = true;
 325                 iface1A |= MAX9867_TDM_MODE | MAX9867_SDOUT_HIZ;
 326                 break;
 327         default:
 328                 return -EINVAL;
 329         }
 330
 331         /* Clock inversion bits, BCI and WCI */
 332         switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
 333         case SND_SOC_DAIFMT_NB_NF:
 334                 break;
 335         case SND_SOC_DAIFMT_IB_IF:
 336                 iface1A |= MAX9867_WCI_MODE | MAX9867_BCI_MODE;
 337                 break;
 338         case SND_SOC_DAIFMT_IB_NF:
 339                 iface1A |= MAX9867_BCI_MODE;
 340                 break;
 341         case SND_SOC_DAIFMT_NB_IF:
 342                 iface1A |= MAX9867_WCI_MODE;
 343                 break;
 344         default:
 345                 return -EINVAL;
 346         }
 347
 348         regmap_write(max9867->regmap, MAX9867_IFC1A, iface1A);
 349         regmap_write(max9867->regmap, MAX9867_IFC1B, iface1B);
 350
 351         return 0;
 352 }
 353
 354 static const struct snd_soc_dai_ops max9867_dai_ops = {
 355         .set_sysclk     = max9867_set_dai_sysclk,
 356         .set_fmt        = max9867_dai_set_fmt,
 357         .digital_mute   = max9867_mute,
 358         .startup        = max9867_startup,
 359         .hw_params      = max9867_dai_hw_params,
 360 };
 361
 362 static struct snd_soc_dai_driver max9867_dai[] = {
 363         {
 364         .name = "max9867-aif1",
 365         .playback = {
 366                 .stream_name = "HiFi Playback",
 367                 .channels_min = 2,
 368                 .channels_max = 2,
 369                 .rates = SNDRV_PCM_RATE_8000_48000,
 370                 .formats = SNDRV_PCM_FMTBIT_S16_LE,
 371         },
 372         .capture = {
 373                 .stream_name = "HiFi Capture",
 374                 .channels_min = 2,
 375                 .channels_max = 2,
 376                 .rates = SNDRV_PCM_RATE_8000_48000,
 377                 .formats = SNDRV_PCM_FMTBIT_S16_LE,
 378         },
 379         .ops = &max9867_dai_ops,
 380         .symmetric_rates = 1,
 381         }
 382 };
 383
 384 #ifdef CONFIG_PM
 385 static int max9867_suspend(struct snd_soc_component *component)
 386 {
 387         snd_soc_component_force_bias_level(component, SND_SOC_BIAS_OFF);
 388
 389         return 0;
 390 }
 391
 392 static int max9867_resume(struct snd_soc_component *component)
 393 {
 394         snd_soc_component_force_bias_level(component, SND_SOC_BIAS_STANDBY);
 395
 396         return 0;
 397 }
 398 #else
 399 #define max9867_suspend NULL
 400 #define max9867_resume  NULL
 401 #endif
 402
 403 static int max9867_set_bias_level(struct snd_soc_component *component,
 404                                   enum snd_soc_bias_level level)
 405 {
 406         int err;
 407         struct max9867_priv *max9867 = snd_soc_component_get_drvdata(component);
 408
 409         switch (level) {
 410         case SND_SOC_BIAS_STANDBY:
 411                 if (snd_soc_component_get_bias_level(component) == SND_SOC_BIAS_OFF) {
 412                         err = regcache_sync(max9867->regmap);
 413                         if (err)
 414                                 return err;
 415
 416                         err = regmap_update_bits(max9867->regmap, MAX9867_PWRMAN,
 417                                                  MAX9867_SHTDOWN, MAX9867_SHTDOWN);
 418                         if (err)
 419                                 return err;
 420                 }
 421                 break;
 422         case SND_SOC_BIAS_OFF:
 423                 err = regmap_update_bits(max9867->regmap, MAX9867_PWRMAN,
 424                                          MAX9867_SHTDOWN, 0);
 425                 if (err)
 426                         return err;
 427
 428                 regcache_mark_dirty(max9867->regmap);
 429                 break;
 430         default:
 431                 break;
 432         }
 433
 434         return 0;
 435 }
 436
 437 static const struct snd_soc_component_driver max9867_component = {
 438         .controls               = max9867_snd_controls,
 439         .num_controls           = ARRAY_SIZE(max9867_snd_controls),
 440         .dapm_routes            = max9867_audio_map,
 441         .num_dapm_routes        = ARRAY_SIZE(max9867_audio_map),
 442         .dapm_widgets           = max9867_dapm_widgets,
 443         .num_dapm_widgets       = ARRAY_SIZE(max9867_dapm_widgets),
 444         .suspend                = max9867_suspend,
 445         .resume                 = max9867_resume,
 446         .set_bias_level         = max9867_set_bias_level,
 447         .idle_bias_on           = 1,
 448         .use_pmdown_time        = 1,
 449         .endianness             = 1,
 450         .non_legacy_dai_naming  = 1,
 451 };
 452
 453 static bool max9867_volatile_register(struct device *dev, unsigned int reg)
 454 {
 455         switch (reg) {
 456         case MAX9867_STATUS:
 457         case MAX9867_JACKSTATUS:
 458         case MAX9867_AUXHIGH:
 459         case MAX9867_AUXLOW:
 460                 return true;
 461         default:
 462                 return false;
 463         }
 464 }
 465
 466 static const struct reg_default max9867_reg[] = {
 467         { 0x04, 0x00 },
 468         { 0x05, 0x00 },
 469         { 0x06, 0x00 },
 470         { 0x07, 0x00 },
 471         { 0x08, 0x00 },
 472         { 0x09, 0x00 },
 473         { 0x0A, 0x00 },
 474         { 0x0B, 0x00 },
 475         { 0x0C, 0x00 },
 476         { 0x0D, 0x00 },
 477         { 0x0E, 0x40 },
 478         { 0x0F, 0x40 },
 479         { 0x10, 0x00 },
 480         { 0x11, 0x00 },
 481         { 0x12, 0x00 },
 482         { 0x13, 0x00 },
 483         { 0x14, 0x00 },
 484         { 0x15, 0x00 },
 485         { 0x16, 0x00 },
 486         { 0x17, 0x00 },
 487 };
 488
 489 static const struct regmap_config max9867_regmap = {
 490         .reg_bits       = 8,
 491         .val_bits       = 8,
 492         .max_register   = MAX9867_REVISION,
 493         .reg_defaults   = max9867_reg,
 494         .num_reg_defaults = ARRAY_SIZE(max9867_reg),
 495         .volatile_reg   = max9867_volatile_register,
 496         .cache_type     = REGCACHE_RBTREE,
 497 };
 498
 499 static int max9867_i2c_probe(struct i2c_client *i2c,
 500                 const struct i2c_device_id *id)
 501 {
 502         struct max9867_priv *max9867;
 503         int ret, reg;
 504
 505         max9867 = devm_kzalloc(&i2c->dev, sizeof(*max9867), GFP_KERNEL);
 506         if (!max9867)
 507                 return -ENOMEM;
 508
 509         i2c_set_clientdata(i2c, max9867);
 510         max9867->regmap = devm_regmap_init_i2c(i2c, &max9867_regmap);
 511         if (IS_ERR(max9867->regmap)) {
 512                 ret = PTR_ERR(max9867->regmap);
 513                 dev_err(&i2c->dev, "Failed to allocate regmap: %d\n", ret);
 514                 return ret;
 515         }
 516         ret = regmap_read(max9867->regmap, MAX9867_REVISION, &reg);
 517         if (ret < 0) {
 518                 dev_err(&i2c->dev, "Failed to read: %d\n", ret);
 519                 return ret;
 520         }
 521         dev_info(&i2c->dev, "device revision: %x\n", reg);
 522         ret = devm_snd_soc_register_component(&i2c->dev, &max9867_component,
 523                         max9867_dai, ARRAY_SIZE(max9867_dai));
 524         if (ret < 0)
 525                 dev_err(&i2c->dev, "Failed to register component: %d\n", ret);
 526         return ret;
 527 }
 528
 529 static const struct i2c_device_id max9867_i2c_id[] = {
 530         { "max9867", 0 },
 531         { }
 532 };
 533 MODULE_DEVICE_TABLE(i2c, max9867_i2c_id);
 534
 535 static const struct of_device_id max9867_of_match[] = {
 536         { .compatible = "maxim,max9867", },
 537         { }
 538 };
 539 MODULE_DEVICE_TABLE(of, max9867_of_match);
 540
 541 static struct i2c_driver max9867_i2c_driver = {
 542         .driver = {
 543                 .name = "max9867",
 544                 .of_match_table = of_match_ptr(max9867_of_match),
 545         },
 546         .probe  = max9867_i2c_probe,
 547         .id_table = max9867_i2c_id,
 548 };
 549
 550 module_i2c_driver(max9867_i2c_driver);
 551
 552 MODULE_AUTHOR("Ladislav Michl <ladis@linux-mips.org>");
 553 MODULE_DESCRIPTION("ASoC MAX9867 driver");
 554 MODULE_LICENSE("GPL");