1 /* 2 * Regmap support for HD-audio verbs 3 * 4 * A virtual register is translated to one or more hda verbs for write, 5 * vice versa for read. 6 * 7 * A few limitations: 8 * - Provided for not all verbs but only subset standard non-volatile verbs. 9 * - For reading, only AC_VERB_GET_* variants can be used. 10 * - For writing, mapped to the *corresponding* AC_VERB_SET_* variants, 11 * so can't handle asymmetric verbs for read and write 12 */ 13 14 #include <linux/slab.h> 15 #include <linux/device.h> 16 #include <linux/regmap.h> 17 #include <linux/export.h> 18 #include <linux/pm.h> 19 #include <linux/pm_runtime.h> 20 #include <sound/core.h> 21 #include <sound/hdaudio.h> 22 #include <sound/hda_regmap.h> 23 24 static int codec_pm_lock(struct hdac_device *codec) 25 { 26 return snd_hdac_keep_power_up(codec); 27 } 28 29 static void codec_pm_unlock(struct hdac_device *codec, int lock) 30 { 31 if (lock == 1) 32 snd_hdac_power_down_pm(codec); 33 } 34 35 #define get_verb(reg) (((reg) >> 8) & 0xfff) 36 37 static bool hda_volatile_reg(struct device *dev, unsigned int reg) 38 { 39 struct hdac_device *codec = dev_to_hdac_dev(dev); 40 unsigned int verb = get_verb(reg); 41 42 switch (verb) { 43 case AC_VERB_GET_PROC_COEF: 44 return !codec->cache_coef; 45 case AC_VERB_GET_COEF_INDEX: 46 case AC_VERB_GET_PROC_STATE: 47 case AC_VERB_GET_POWER_STATE: 48 case AC_VERB_GET_PIN_SENSE: 49 case AC_VERB_GET_HDMI_DIP_SIZE: 50 case AC_VERB_GET_HDMI_ELDD: 51 case AC_VERB_GET_HDMI_DIP_INDEX: 52 case AC_VERB_GET_HDMI_DIP_DATA: 53 case AC_VERB_GET_HDMI_DIP_XMIT: 54 case AC_VERB_GET_HDMI_CP_CTRL: 55 case AC_VERB_GET_HDMI_CHAN_SLOT: 56 case AC_VERB_GET_DEVICE_SEL: 57 case AC_VERB_GET_DEVICE_LIST: /* read-only volatile */ 58 return true; 59 } 60 61 return false; 62 } 63 64 static bool hda_writeable_reg(struct device *dev, unsigned int reg) 65 { 66 struct hdac_device *codec = dev_to_hdac_dev(dev); 67 unsigned int verb = get_verb(reg); 68 const unsigned int *v; 69 int i; 70 71 snd_array_for_each(&codec->vendor_verbs, i, v) { 72 if (verb == *v) 73 return true; 74 } 75 76 if (codec->caps_overwriting) 77 return true; 78 79 switch (verb & 0xf00) { 80 case AC_VERB_GET_STREAM_FORMAT: 81 case AC_VERB_GET_AMP_GAIN_MUTE: 82 return true; 83 case AC_VERB_GET_PROC_COEF: 84 return codec->cache_coef; 85 case 0xf00: 86 break; 87 default: 88 return false; 89 } 90 91 switch (verb) { 92 case AC_VERB_GET_CONNECT_SEL: 93 case AC_VERB_GET_SDI_SELECT: 94 case AC_VERB_GET_PIN_WIDGET_CONTROL: 95 case AC_VERB_GET_UNSOLICITED_RESPONSE: /* only as SET_UNSOLICITED_ENABLE */ 96 case AC_VERB_GET_BEEP_CONTROL: 97 case AC_VERB_GET_EAPD_BTLENABLE: 98 case AC_VERB_GET_DIGI_CONVERT_1: 99 case AC_VERB_GET_DIGI_CONVERT_2: /* only for beep control */ 100 case AC_VERB_GET_VOLUME_KNOB_CONTROL: 101 case AC_VERB_GET_GPIO_MASK: 102 case AC_VERB_GET_GPIO_DIRECTION: 103 case AC_VERB_GET_GPIO_DATA: /* not for volatile read */ 104 case AC_VERB_GET_GPIO_WAKE_MASK: 105 case AC_VERB_GET_GPIO_UNSOLICITED_RSP_MASK: 106 case AC_VERB_GET_GPIO_STICKY_MASK: 107 return true; 108 } 109 110 return false; 111 } 112 113 static bool hda_readable_reg(struct device *dev, unsigned int reg) 114 { 115 struct hdac_device *codec = dev_to_hdac_dev(dev); 116 unsigned int verb = get_verb(reg); 117 118 if (codec->caps_overwriting) 119 return true; 120 121 switch (verb) { 122 case AC_VERB_PARAMETERS: 123 case AC_VERB_GET_CONNECT_LIST: 124 case AC_VERB_GET_SUBSYSTEM_ID: 125 return true; 126 /* below are basically writable, but disabled for reducing unnecessary 127 * writes at sync 128 */ 129 case AC_VERB_GET_CONFIG_DEFAULT: /* usually just read */ 130 case AC_VERB_GET_CONV: /* managed in PCM code */ 131 case AC_VERB_GET_CVT_CHAN_COUNT: /* managed in HDMI CA code */ 132 return true; 133 } 134 135 return hda_writeable_reg(dev, reg); 136 } 137 138 /* 139 * Stereo amp pseudo register: 140 * for making easier to handle the stereo volume control, we provide a 141 * fake register to deal both left and right channels by a single 142 * (pseudo) register access. A verb consisting of SET_AMP_GAIN with 143 * *both* SET_LEFT and SET_RIGHT bits takes a 16bit value, the lower 8bit 144 * for the left and the upper 8bit for the right channel. 145 */ 146 static bool is_stereo_amp_verb(unsigned int reg) 147 { 148 if (((reg >> 8) & 0x700) != AC_VERB_SET_AMP_GAIN_MUTE) 149 return false; 150 return (reg & (AC_AMP_SET_LEFT | AC_AMP_SET_RIGHT)) == 151 (AC_AMP_SET_LEFT | AC_AMP_SET_RIGHT); 152 } 153 154 /* read a pseudo stereo amp register (16bit left+right) */ 155 static int hda_reg_read_stereo_amp(struct hdac_device *codec, 156 unsigned int reg, unsigned int *val) 157 { 158 unsigned int left, right; 159 int err; 160 161 reg &= ~(AC_AMP_SET_LEFT | AC_AMP_SET_RIGHT); 162 err = snd_hdac_exec_verb(codec, reg | AC_AMP_GET_LEFT, 0, &left); 163 if (err < 0) 164 return err; 165 err = snd_hdac_exec_verb(codec, reg | AC_AMP_GET_RIGHT, 0, &right); 166 if (err < 0) 167 return err; 168 *val = left | (right << 8); 169 return 0; 170 } 171 172 /* write a pseudo stereo amp register (16bit left+right) */ 173 static int hda_reg_write_stereo_amp(struct hdac_device *codec, 174 unsigned int reg, unsigned int val) 175 { 176 int err; 177 unsigned int verb, left, right; 178 179 verb = AC_VERB_SET_AMP_GAIN_MUTE << 8; 180 if (reg & AC_AMP_GET_OUTPUT) 181 verb |= AC_AMP_SET_OUTPUT; 182 else 183 verb |= AC_AMP_SET_INPUT | ((reg & 0xf) << 8); 184 reg = (reg & ~0xfffff) | verb; 185 186 left = val & 0xff; 187 right = (val >> 8) & 0xff; 188 if (left == right) { 189 reg |= AC_AMP_SET_LEFT | AC_AMP_SET_RIGHT; 190 return snd_hdac_exec_verb(codec, reg | left, 0, NULL); 191 } 192 193 err = snd_hdac_exec_verb(codec, reg | AC_AMP_SET_LEFT | left, 0, NULL); 194 if (err < 0) 195 return err; 196 err = snd_hdac_exec_verb(codec, reg | AC_AMP_SET_RIGHT | right, 0, NULL); 197 if (err < 0) 198 return err; 199 return 0; 200 } 201 202 /* read a pseudo coef register (16bit) */ 203 static int hda_reg_read_coef(struct hdac_device *codec, unsigned int reg, 204 unsigned int *val) 205 { 206 unsigned int verb; 207 int err; 208 209 if (!codec->cache_coef) 210 return -EINVAL; 211 /* LSB 8bit = coef index */ 212 verb = (reg & ~0xfff00) | (AC_VERB_SET_COEF_INDEX << 8); 213 err = snd_hdac_exec_verb(codec, verb, 0, NULL); 214 if (err < 0) 215 return err; 216 verb = (reg & ~0xfffff) | (AC_VERB_GET_COEF_INDEX << 8); 217 return snd_hdac_exec_verb(codec, verb, 0, val); 218 } 219 220 /* write a pseudo coef register (16bit) */ 221 static int hda_reg_write_coef(struct hdac_device *codec, unsigned int reg, 222 unsigned int val) 223 { 224 unsigned int verb; 225 int err; 226 227 if (!codec->cache_coef) 228 return -EINVAL; 229 /* LSB 8bit = coef index */ 230 verb = (reg & ~0xfff00) | (AC_VERB_SET_COEF_INDEX << 8); 231 err = snd_hdac_exec_verb(codec, verb, 0, NULL); 232 if (err < 0) 233 return err; 234 verb = (reg & ~0xfffff) | (AC_VERB_GET_COEF_INDEX << 8) | 235 (val & 0xffff); 236 return snd_hdac_exec_verb(codec, verb, 0, NULL); 237 } 238 239 static int hda_reg_read(void *context, unsigned int reg, unsigned int *val) 240 { 241 struct hdac_device *codec = context; 242 int verb = get_verb(reg); 243 int err; 244 int pm_lock = 0; 245 246 if (verb != AC_VERB_GET_POWER_STATE) { 247 pm_lock = codec_pm_lock(codec); 248 if (pm_lock < 0) 249 return -EAGAIN; 250 } 251 reg |= (codec->addr << 28); 252 if (is_stereo_amp_verb(reg)) { 253 err = hda_reg_read_stereo_amp(codec, reg, val); 254 goto out; 255 } 256 if (verb == AC_VERB_GET_PROC_COEF) { 257 err = hda_reg_read_coef(codec, reg, val); 258 goto out; 259 } 260 if ((verb & 0x700) == AC_VERB_SET_AMP_GAIN_MUTE) 261 reg &= ~AC_AMP_FAKE_MUTE; 262 263 err = snd_hdac_exec_verb(codec, reg, 0, val); 264 if (err < 0) 265 goto out; 266 /* special handling for asymmetric reads */ 267 if (verb == AC_VERB_GET_POWER_STATE) { 268 if (*val & AC_PWRST_ERROR) 269 *val = -1; 270 else /* take only the actual state */ 271 *val = (*val >> 4) & 0x0f; 272 } 273 out: 274 codec_pm_unlock(codec, pm_lock); 275 return err; 276 } 277 278 static int hda_reg_write(void *context, unsigned int reg, unsigned int val) 279 { 280 struct hdac_device *codec = context; 281 unsigned int verb; 282 int i, bytes, err; 283 int pm_lock = 0; 284 285 if (codec->caps_overwriting) 286 return 0; 287 288 reg &= ~0x00080000U; /* drop GET bit */ 289 reg |= (codec->addr << 28); 290 verb = get_verb(reg); 291 292 if (verb != AC_VERB_SET_POWER_STATE) { 293 pm_lock = codec_pm_lock(codec); 294 if (pm_lock < 0) 295 return codec->lazy_cache ? 0 : -EAGAIN; 296 } 297 298 if (is_stereo_amp_verb(reg)) { 299 err = hda_reg_write_stereo_amp(codec, reg, val); 300 goto out; 301 } 302 303 if (verb == AC_VERB_SET_PROC_COEF) { 304 err = hda_reg_write_coef(codec, reg, val); 305 goto out; 306 } 307 308 switch (verb & 0xf00) { 309 case AC_VERB_SET_AMP_GAIN_MUTE: 310 if ((reg & AC_AMP_FAKE_MUTE) && (val & AC_AMP_MUTE)) 311 val = 0; 312 verb = AC_VERB_SET_AMP_GAIN_MUTE; 313 if (reg & AC_AMP_GET_LEFT) 314 verb |= AC_AMP_SET_LEFT >> 8; 315 else 316 verb |= AC_AMP_SET_RIGHT >> 8; 317 if (reg & AC_AMP_GET_OUTPUT) { 318 verb |= AC_AMP_SET_OUTPUT >> 8; 319 } else { 320 verb |= AC_AMP_SET_INPUT >> 8; 321 verb |= reg & 0xf; 322 } 323 break; 324 } 325 326 switch (verb) { 327 case AC_VERB_SET_DIGI_CONVERT_1: 328 bytes = 2; 329 break; 330 case AC_VERB_SET_CONFIG_DEFAULT_BYTES_0: 331 bytes = 4; 332 break; 333 default: 334 bytes = 1; 335 break; 336 } 337 338 for (i = 0; i < bytes; i++) { 339 reg &= ~0xfffff; 340 reg |= (verb + i) << 8 | ((val >> (8 * i)) & 0xff); 341 err = snd_hdac_exec_verb(codec, reg, 0, NULL); 342 if (err < 0) 343 goto out; 344 } 345 346 out: 347 codec_pm_unlock(codec, pm_lock); 348 return err; 349 } 350 351 static const struct regmap_config hda_regmap_cfg = { 352 .name = "hdaudio", 353 .reg_bits = 32, 354 .val_bits = 32, 355 .max_register = 0xfffffff, 356 .writeable_reg = hda_writeable_reg, 357 .readable_reg = hda_readable_reg, 358 .volatile_reg = hda_volatile_reg, 359 .cache_type = REGCACHE_RBTREE, 360 .reg_read = hda_reg_read, 361 .reg_write = hda_reg_write, 362 .use_single_read = true, 363 .use_single_write = true, 364 }; 365 366 /** 367 * snd_hdac_regmap_init - Initialize regmap for HDA register accesses 368 * @codec: the codec object 369 * 370 * Returns zero for success or a negative error code. 371 */ 372 int snd_hdac_regmap_init(struct hdac_device *codec) 373 { 374 struct regmap *regmap; 375 376 regmap = regmap_init(&codec->dev, NULL, codec, &hda_regmap_cfg); 377 if (IS_ERR(regmap)) 378 return PTR_ERR(regmap); 379 codec->regmap = regmap; 380 snd_array_init(&codec->vendor_verbs, sizeof(unsigned int), 8); 381 return 0; 382 } 383 EXPORT_SYMBOL_GPL(snd_hdac_regmap_init); 384 385 /** 386 * snd_hdac_regmap_init - Release the regmap from HDA codec 387 * @codec: the codec object 388 */ 389 void snd_hdac_regmap_exit(struct hdac_device *codec) 390 { 391 if (codec->regmap) { 392 regmap_exit(codec->regmap); 393 codec->regmap = NULL; 394 snd_array_free(&codec->vendor_verbs); 395 } 396 } 397 EXPORT_SYMBOL_GPL(snd_hdac_regmap_exit); 398 399 /** 400 * snd_hdac_regmap_add_vendor_verb - add a vendor-specific verb to regmap 401 * @codec: the codec object 402 * @verb: verb to allow accessing via regmap 403 * 404 * Returns zero for success or a negative error code. 405 */ 406 int snd_hdac_regmap_add_vendor_verb(struct hdac_device *codec, 407 unsigned int verb) 408 { 409 unsigned int *p = snd_array_new(&codec->vendor_verbs); 410 411 if (!p) 412 return -ENOMEM; 413 *p = verb | 0x800; /* set GET bit */ 414 return 0; 415 } 416 EXPORT_SYMBOL_GPL(snd_hdac_regmap_add_vendor_verb); 417 418 /* 419 * helper functions 420 */ 421 422 /* write a pseudo-register value (w/o power sequence) */ 423 static int reg_raw_write(struct hdac_device *codec, unsigned int reg, 424 unsigned int val) 425 { 426 if (!codec->regmap) 427 return hda_reg_write(codec, reg, val); 428 else 429 return regmap_write(codec->regmap, reg, val); 430 } 431 432 /** 433 * snd_hdac_regmap_write_raw - write a pseudo register with power mgmt 434 * @codec: the codec object 435 * @reg: pseudo register 436 * @val: value to write 437 * 438 * Returns zero if successful or a negative error code. 439 */ 440 int snd_hdac_regmap_write_raw(struct hdac_device *codec, unsigned int reg, 441 unsigned int val) 442 { 443 int err; 444 445 err = reg_raw_write(codec, reg, val); 446 if (err == -EAGAIN) { 447 err = snd_hdac_power_up_pm(codec); 448 if (err >= 0) 449 err = reg_raw_write(codec, reg, val); 450 snd_hdac_power_down_pm(codec); 451 } 452 return err; 453 } 454 EXPORT_SYMBOL_GPL(snd_hdac_regmap_write_raw); 455 456 static int reg_raw_read(struct hdac_device *codec, unsigned int reg, 457 unsigned int *val, bool uncached) 458 { 459 if (uncached || !codec->regmap) 460 return hda_reg_read(codec, reg, val); 461 else 462 return regmap_read(codec->regmap, reg, val); 463 } 464 465 static int __snd_hdac_regmap_read_raw(struct hdac_device *codec, 466 unsigned int reg, unsigned int *val, 467 bool uncached) 468 { 469 int err; 470 471 err = reg_raw_read(codec, reg, val, uncached); 472 if (err == -EAGAIN) { 473 err = snd_hdac_power_up_pm(codec); 474 if (err >= 0) 475 err = reg_raw_read(codec, reg, val, uncached); 476 snd_hdac_power_down_pm(codec); 477 } 478 return err; 479 } 480 481 /** 482 * snd_hdac_regmap_read_raw - read a pseudo register with power mgmt 483 * @codec: the codec object 484 * @reg: pseudo register 485 * @val: pointer to store the read value 486 * 487 * Returns zero if successful or a negative error code. 488 */ 489 int snd_hdac_regmap_read_raw(struct hdac_device *codec, unsigned int reg, 490 unsigned int *val) 491 { 492 return __snd_hdac_regmap_read_raw(codec, reg, val, false); 493 } 494 EXPORT_SYMBOL_GPL(snd_hdac_regmap_read_raw); 495 496 /* Works like snd_hdac_regmap_read_raw(), but this doesn't read from the 497 * cache but always via hda verbs. 498 */ 499 int snd_hdac_regmap_read_raw_uncached(struct hdac_device *codec, 500 unsigned int reg, unsigned int *val) 501 { 502 return __snd_hdac_regmap_read_raw(codec, reg, val, true); 503 } 504 505 /** 506 * snd_hdac_regmap_update_raw - update a pseudo register with power mgmt 507 * @codec: the codec object 508 * @reg: pseudo register 509 * @mask: bit mask to udpate 510 * @val: value to update 511 * 512 * Returns zero if successful or a negative error code. 513 */ 514 int snd_hdac_regmap_update_raw(struct hdac_device *codec, unsigned int reg, 515 unsigned int mask, unsigned int val) 516 { 517 unsigned int orig; 518 int err; 519 520 val &= mask; 521 err = snd_hdac_regmap_read_raw(codec, reg, &orig); 522 if (err < 0) 523 return err; 524 val |= orig & ~mask; 525 if (val == orig) 526 return 0; 527 err = snd_hdac_regmap_write_raw(codec, reg, val); 528 if (err < 0) 529 return err; 530 return 1; 531 } 532 EXPORT_SYMBOL_GPL(snd_hdac_regmap_update_raw); 533