sound/soc/codecs/ad1980.c

   1 /*
   2  * ad1980.c  --  ALSA Soc AD1980 codec support
   3  *
   4  * Copyright:   Analog Device Inc.
   5  * Author:      Roy Huang <roy.huang@analog.com>
   6  *              Cliff Cai <cliff.cai@analog.com>
   7  *
   8  *  This program is free software; you can redistribute  it and/or modify it
   9  *  under  the terms of  the GNU General  Public License as published by the
  10  *  Free Software Foundation;  either version 2 of the  License, or (at your
  11  *  option) any later version.
  12  */
  13
  14 /*
  15  * WARNING:
  16  *
  17  * Because Analog Devices Inc. discontinued the ad1980 sound chip since
  18  * Sep. 2009, this ad1980 driver is not maintained, tested and supported
  19  * by ADI now.
  20  */
  21
  22 #include <linux/init.h>
  23 #include <linux/slab.h>
  24 #include <linux/module.h>
  25 #include <linux/kernel.h>
  26 #include <linux/device.h>
  27 #include <linux/regmap.h>
  28 #include <sound/core.h>
  29 #include <sound/pcm.h>
  30 #include <sound/ac97_codec.h>
  31 #include <sound/initval.h>
  32 #include <sound/soc.h>
  33
  34 static const struct reg_default ad1980_reg_defaults[] = {
  35         { 0x02, 0x8000 },
  36         { 0x04, 0x8000 },
  37         { 0x06, 0x8000 },
  38         { 0x0c, 0x8008 },
  39         { 0x0e, 0x8008 },
  40         { 0x10, 0x8808 },
  41         { 0x12, 0x8808 },
  42         { 0x16, 0x8808 },
  43         { 0x18, 0x8808 },
  44         { 0x1a, 0x0000 },
  45         { 0x1c, 0x8000 },
  46         { 0x20, 0x0000 },
  47         { 0x28, 0x03c7 },
  48         { 0x2c, 0xbb80 },
  49         { 0x2e, 0xbb80 },
  50         { 0x30, 0xbb80 },
  51         { 0x32, 0xbb80 },
  52         { 0x36, 0x8080 },
  53         { 0x38, 0x8080 },
  54         { 0x3a, 0x2000 },
  55         { 0x60, 0x0000 },
  56         { 0x62, 0x0000 },
  57         { 0x72, 0x0000 },
  58         { 0x74, 0x1001 },
  59         { 0x76, 0x0000 },
  60 };
  61
  62 static bool ad1980_readable_reg(struct device *dev, unsigned int reg)
  63 {
  64         switch (reg) {
  65         case AC97_RESET ... AC97_MASTER_MONO:
  66         case AC97_PHONE ... AC97_CD:
  67         case AC97_AUX ... AC97_GENERAL_PURPOSE:
  68         case AC97_POWERDOWN ... AC97_PCM_LR_ADC_RATE:
  69         case AC97_SPDIF:
  70         case AC97_CODEC_CLASS_REV:
  71         case AC97_PCI_SVID:
  72         case AC97_AD_CODEC_CFG:
  73         case AC97_AD_JACK_SPDIF:
  74         case AC97_AD_SERIAL_CFG:
  75         case AC97_VENDOR_ID1:
  76         case AC97_VENDOR_ID2:
  77                 return true;
  78         default:
  79                 return false;
  80         }
  81 }
  82
  83 static bool ad1980_writeable_reg(struct device *dev, unsigned int reg)
  84 {
  85         switch (reg) {
  86         case AC97_VENDOR_ID1:
  87         case AC97_VENDOR_ID2:
  88                 return false;
  89         default:
  90                 return ad1980_readable_reg(dev, reg);
  91         }
  92 }
  93
  94 static const struct regmap_config ad1980_regmap_config = {
  95         .reg_bits = 16,
  96         .reg_stride = 2,
  97         .val_bits = 16,
  98         .max_register = 0x7e,
  99         .cache_type = REGCACHE_RBTREE,
 100
 101         .volatile_reg = regmap_ac97_default_volatile,
 102         .readable_reg = ad1980_readable_reg,
 103         .writeable_reg = ad1980_writeable_reg,
 104
 105         .reg_defaults = ad1980_reg_defaults,
 106         .num_reg_defaults = ARRAY_SIZE(ad1980_reg_defaults),
 107 };
 108
 109 static const char *ad1980_rec_sel[] = {"Mic", "CD", "NC", "AUX", "Line",
 110                 "Stereo Mix", "Mono Mix", "Phone"};
 111
 112 static SOC_ENUM_DOUBLE_DECL(ad1980_cap_src,
 113                             AC97_REC_SEL, 8, 0, ad1980_rec_sel);
 114
 115 static const struct snd_kcontrol_new ad1980_snd_ac97_controls[] = {
 116 SOC_DOUBLE("Master Playback Volume", AC97_MASTER, 8, 0, 31, 1),
 117 SOC_SINGLE("Master Playback Switch", AC97_MASTER, 15, 1, 1),
 118
 119 SOC_DOUBLE("Headphone Playback Volume", AC97_HEADPHONE, 8, 0, 31, 1),
 120 SOC_SINGLE("Headphone Playback Switch", AC97_HEADPHONE, 15, 1, 1),
 121
 122 SOC_DOUBLE("PCM Playback Volume", AC97_PCM, 8, 0, 31, 1),
 123 SOC_SINGLE("PCM Playback Switch", AC97_PCM, 15, 1, 1),
 124
 125 SOC_DOUBLE("PCM Capture Volume", AC97_REC_GAIN, 8, 0, 31, 0),
 126 SOC_SINGLE("PCM Capture Switch", AC97_REC_GAIN, 15, 1, 1),
 127
 128 SOC_SINGLE("Mono Playback Volume", AC97_MASTER_MONO, 0, 31, 1),
 129 SOC_SINGLE("Mono Playback Switch", AC97_MASTER_MONO, 15, 1, 1),
 130
 131 SOC_SINGLE("Phone Capture Volume", AC97_PHONE, 0, 31, 1),
 132 SOC_SINGLE("Phone Capture Switch", AC97_PHONE, 15, 1, 1),
 133
 134 SOC_SINGLE("Mic Volume", AC97_MIC, 0, 31, 1),
 135 SOC_SINGLE("Mic Switch", AC97_MIC, 15, 1, 1),
 136
 137 SOC_SINGLE("Stereo Mic Switch", AC97_AD_MISC, 6, 1, 0),
 138 SOC_DOUBLE("Line HP Swap Switch", AC97_AD_MISC, 10, 5, 1, 0),
 139
 140 SOC_DOUBLE("Surround Playback Volume", AC97_SURROUND_MASTER, 8, 0, 31, 1),
 141 SOC_DOUBLE("Surround Playback Switch", AC97_SURROUND_MASTER, 15, 7, 1, 1),
 142
 143 SOC_DOUBLE("Center/LFE Playback Volume", AC97_CENTER_LFE_MASTER, 8, 0, 31, 1),
 144 SOC_DOUBLE("Center/LFE Playback Switch", AC97_CENTER_LFE_MASTER, 15, 7, 1, 1),
 145
 146 SOC_ENUM("Capture Source", ad1980_cap_src),
 147
 148 SOC_SINGLE("Mic Boost Switch", AC97_MIC, 6, 1, 0),
 149 };
 150
 151 static const struct snd_soc_dapm_widget ad1980_dapm_widgets[] = {
 152 SND_SOC_DAPM_INPUT("MIC1"),
 153 SND_SOC_DAPM_INPUT("MIC2"),
 154 SND_SOC_DAPM_INPUT("CD_L"),
 155 SND_SOC_DAPM_INPUT("CD_R"),
 156 SND_SOC_DAPM_INPUT("AUX_L"),
 157 SND_SOC_DAPM_INPUT("AUX_R"),
 158 SND_SOC_DAPM_INPUT("LINE_IN_L"),
 159 SND_SOC_DAPM_INPUT("LINE_IN_R"),
 160
 161 SND_SOC_DAPM_OUTPUT("LFE_OUT"),
 162 SND_SOC_DAPM_OUTPUT("CENTER_OUT"),
 163 SND_SOC_DAPM_OUTPUT("LINE_OUT_L"),
 164 SND_SOC_DAPM_OUTPUT("LINE_OUT_R"),
 165 SND_SOC_DAPM_OUTPUT("MONO_OUT"),
 166 SND_SOC_DAPM_OUTPUT("HP_OUT_L"),
 167 SND_SOC_DAPM_OUTPUT("HP_OUT_R"),
 168 };
 169
 170 static const struct snd_soc_dapm_route ad1980_dapm_routes[] = {
 171         { "Capture", NULL, "MIC1" },
 172         { "Capture", NULL, "MIC2" },
 173         { "Capture", NULL, "CD_L" },
 174         { "Capture", NULL, "CD_R" },
 175         { "Capture", NULL, "AUX_L" },
 176         { "Capture", NULL, "AUX_R" },
 177         { "Capture", NULL, "LINE_IN_L" },
 178         { "Capture", NULL, "LINE_IN_R" },
 179
 180         { "LFE_OUT", NULL, "Playback" },
 181         { "CENTER_OUT", NULL, "Playback" },
 182         { "LINE_OUT_L", NULL, "Playback" },
 183         { "LINE_OUT_R", NULL, "Playback" },
 184         { "MONO_OUT", NULL, "Playback" },
 185         { "HP_OUT_L", NULL, "Playback" },
 186         { "HP_OUT_R", NULL, "Playback" },
 187 };
 188
 189 static struct snd_soc_dai_driver ad1980_dai = {
 190         .name = "ad1980-hifi",
 191         .playback = {
 192                 .stream_name = "Playback",
 193                 .channels_min = 2,
 194                 .channels_max = 6,
 195                 .rates = SNDRV_PCM_RATE_48000,
 196                 .formats = SND_SOC_STD_AC97_FMTS, },
 197         .capture = {
 198                 .stream_name = "Capture",
 199                 .channels_min = 2,
 200                 .channels_max = 2,
 201                 .rates = SNDRV_PCM_RATE_48000,
 202                 .formats = SND_SOC_STD_AC97_FMTS, },
 203 };
 204
 205 #define AD1980_VENDOR_ID 0x41445300
 206 #define AD1980_VENDOR_MASK 0xffffff00
 207
 208 static int ad1980_reset(struct snd_soc_codec *codec, int try_warm)
 209 {
 210         struct snd_ac97 *ac97 = snd_soc_codec_get_drvdata(codec);
 211         unsigned int retry_cnt = 0;
 212         int ret;
 213
 214         do {
 215                 ret = snd_ac97_reset(ac97, true, AD1980_VENDOR_ID,
 216                         AD1980_VENDOR_MASK);
 217                 if (ret >= 0)
 218                         return 0;
 219
 220                 /*
 221                  * Set bit 16slot in register 74h, then every slot will has only
 222                  * 16 bits. This command is sent out in 20bit mode, in which
 223                  * case the first nibble of data is eaten by the addr. (Tag is
 224                  * always 16 bit)
 225                  */
 226                 snd_soc_write(codec, AC97_AD_SERIAL_CFG, 0x9900);
 227
 228         } while (retry_cnt++ < 10);
 229
 230         dev_err(codec->dev, "Failed to reset: AC97 link error\n");
 231
 232         return -EIO;
 233 }
 234
 235 static int ad1980_soc_probe(struct snd_soc_codec *codec)
 236 {
 237         struct snd_ac97 *ac97;
 238         struct regmap *regmap;
 239         int ret;
 240         u16 vendor_id2;
 241         u16 ext_status;
 242
 243         ac97 = snd_soc_new_ac97_codec(codec, 0, 0);
 244         if (IS_ERR(ac97)) {
 245                 ret = PTR_ERR(ac97);
 246                 dev_err(codec->dev, "Failed to register AC97 codec: %d\n", ret);
 247                 return ret;
 248         }
 249
 250         regmap = regmap_init_ac97(ac97, &ad1980_regmap_config);
 251         if (IS_ERR(regmap)) {
 252                 ret = PTR_ERR(regmap);
 253                 goto err_free_ac97;
 254         }
 255
 256         snd_soc_codec_init_regmap(codec, regmap);
 257         snd_soc_codec_set_drvdata(codec, ac97);
 258
 259         ret = ad1980_reset(codec, 0);
 260         if (ret < 0)
 261                 goto reset_err;
 262
 263         vendor_id2 = snd_soc_read(codec, AC97_VENDOR_ID2);
 264         if (vendor_id2 == 0x5374) {
 265                 dev_warn(codec->dev,
 266                         "Found AD1981 - only 2/2 IN/OUT Channels supported\n");
 267         }
 268
 269         /* unmute captures and playbacks volume */
 270         snd_soc_write(codec, AC97_MASTER, 0x0000);
 271         snd_soc_write(codec, AC97_PCM, 0x0000);
 272         snd_soc_write(codec, AC97_REC_GAIN, 0x0000);
 273         snd_soc_write(codec, AC97_CENTER_LFE_MASTER, 0x0000);
 274         snd_soc_write(codec, AC97_SURROUND_MASTER, 0x0000);
 275
 276         /*power on LFE/CENTER/Surround DACs*/
 277         ext_status = snd_soc_read(codec, AC97_EXTENDED_STATUS);
 278         snd_soc_write(codec, AC97_EXTENDED_STATUS, ext_status&~0x3800);
 279
 280         return 0;
 281
 282 reset_err:
 283         snd_soc_codec_exit_regmap(codec);
 284 err_free_ac97:
 285         snd_soc_free_ac97_codec(ac97);
 286         return ret;
 287 }
 288
 289 static int ad1980_soc_remove(struct snd_soc_codec *codec)
 290 {
 291         struct snd_ac97 *ac97 = snd_soc_codec_get_drvdata(codec);
 292
 293         snd_soc_codec_exit_regmap(codec);
 294         snd_soc_free_ac97_codec(ac97);
 295         return 0;
 296 }
 297
 298 static struct snd_soc_codec_driver soc_codec_dev_ad1980 = {
 299         .probe =        ad1980_soc_probe,
 300         .remove =       ad1980_soc_remove,
 301
 302         .controls = ad1980_snd_ac97_controls,
 303         .num_controls = ARRAY_SIZE(ad1980_snd_ac97_controls),
 304         .dapm_widgets = ad1980_dapm_widgets,
 305         .num_dapm_widgets = ARRAY_SIZE(ad1980_dapm_widgets),
 306         .dapm_routes = ad1980_dapm_routes,
 307         .num_dapm_routes = ARRAY_SIZE(ad1980_dapm_routes),
 308 };
 309
 310 static int ad1980_probe(struct platform_device *pdev)
 311 {
 312         return snd_soc_register_codec(&pdev->dev,
 313                         &soc_codec_dev_ad1980, &ad1980_dai, 1);
 314 }
 315
 316 static int ad1980_remove(struct platform_device *pdev)
 317 {
 318         snd_soc_unregister_codec(&pdev->dev);
 319         return 0;
 320 }
 321
 322 static struct platform_driver ad1980_codec_driver = {
 323         .driver = {
 324                         .name = "ad1980",
 325         },
 326
 327         .probe = ad1980_probe,
 328         .remove = ad1980_remove,
 329 };
 330
 331 module_platform_driver(ad1980_codec_driver);
 332
 333 MODULE_DESCRIPTION("ASoC ad1980 driver (Obsolete)");
 334 MODULE_AUTHOR("Roy Huang, Cliff Cai");
 335 MODULE_LICENSE("GPL");