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