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 static int ad1980_reset(struct snd_soc_codec *codec, int try_warm) 206 { 207 struct snd_ac97 *ac97 = snd_soc_codec_get_drvdata(codec); 208 unsigned int retry_cnt = 0; 209 210 do { 211 if (try_warm && soc_ac97_ops->warm_reset) { 212 soc_ac97_ops->warm_reset(ac97); 213 if (snd_soc_read(codec, AC97_RESET) == 0x0090) 214 return 1; 215 } 216 217 soc_ac97_ops->reset(ac97); 218 /* 219 * Set bit 16slot in register 74h, then every slot will has only 220 * 16 bits. This command is sent out in 20bit mode, in which 221 * case the first nibble of data is eaten by the addr. (Tag is 222 * always 16 bit) 223 */ 224 snd_soc_write(codec, AC97_AD_SERIAL_CFG, 0x9900); 225 226 if (snd_soc_read(codec, AC97_RESET) == 0x0090) 227 return 0; 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); 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 /* Read out vendor ID to make sure it is ad1980 */ 264 if (snd_soc_read(codec, AC97_VENDOR_ID1) != 0x4144) { 265 ret = -ENODEV; 266 goto reset_err; 267 } 268 269 vendor_id2 = snd_soc_read(codec, AC97_VENDOR_ID2); 270 271 if (vendor_id2 != 0x5370) { 272 if (vendor_id2 != 0x5374) { 273 ret = -ENODEV; 274 goto reset_err; 275 } else { 276 dev_warn(codec->dev, 277 "Found AD1981 - only 2/2 IN/OUT Channels supported\n"); 278 } 279 } 280 281 /* unmute captures and playbacks volume */ 282 snd_soc_write(codec, AC97_MASTER, 0x0000); 283 snd_soc_write(codec, AC97_PCM, 0x0000); 284 snd_soc_write(codec, AC97_REC_GAIN, 0x0000); 285 snd_soc_write(codec, AC97_CENTER_LFE_MASTER, 0x0000); 286 snd_soc_write(codec, AC97_SURROUND_MASTER, 0x0000); 287 288 /*power on LFE/CENTER/Surround DACs*/ 289 ext_status = snd_soc_read(codec, AC97_EXTENDED_STATUS); 290 snd_soc_write(codec, AC97_EXTENDED_STATUS, ext_status&~0x3800); 291 292 return 0; 293 294 reset_err: 295 snd_soc_codec_exit_regmap(codec); 296 err_free_ac97: 297 snd_soc_free_ac97_codec(ac97); 298 return ret; 299 } 300 301 static int ad1980_soc_remove(struct snd_soc_codec *codec) 302 { 303 struct snd_ac97 *ac97 = snd_soc_codec_get_drvdata(codec); 304 305 snd_soc_codec_exit_regmap(codec); 306 snd_soc_free_ac97_codec(ac97); 307 return 0; 308 } 309 310 static struct snd_soc_codec_driver soc_codec_dev_ad1980 = { 311 .probe = ad1980_soc_probe, 312 .remove = ad1980_soc_remove, 313 314 .controls = ad1980_snd_ac97_controls, 315 .num_controls = ARRAY_SIZE(ad1980_snd_ac97_controls), 316 .dapm_widgets = ad1980_dapm_widgets, 317 .num_dapm_widgets = ARRAY_SIZE(ad1980_dapm_widgets), 318 .dapm_routes = ad1980_dapm_routes, 319 .num_dapm_routes = ARRAY_SIZE(ad1980_dapm_routes), 320 }; 321 322 static int ad1980_probe(struct platform_device *pdev) 323 { 324 return snd_soc_register_codec(&pdev->dev, 325 &soc_codec_dev_ad1980, &ad1980_dai, 1); 326 } 327 328 static int ad1980_remove(struct platform_device *pdev) 329 { 330 snd_soc_unregister_codec(&pdev->dev); 331 return 0; 332 } 333 334 static struct platform_driver ad1980_codec_driver = { 335 .driver = { 336 .name = "ad1980", 337 }, 338 339 .probe = ad1980_probe, 340 .remove = ad1980_remove, 341 }; 342 343 module_platform_driver(ad1980_codec_driver); 344 345 MODULE_DESCRIPTION("ASoC ad1980 driver (Obsolete)"); 346 MODULE_AUTHOR("Roy Huang, Cliff Cai"); 347 MODULE_LICENSE("GPL"); 348