1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * PCM DRM helpers 4 */ 5 #include <linux/bitfield.h> 6 #include <linux/export.h> 7 #include <linux/hdmi.h> 8 #include <linux/unaligned.h> 9 #include <drm/drm_edid.h> 10 #include <drm/drm_eld.h> 11 #include <sound/info.h> 12 #include <sound/pcm.h> 13 #include <sound/pcm_drm_eld.h> 14 15 #define SAD0_CHANNELS_MASK GENMASK(2, 0) /* max number of channels - 1 */ 16 #define SAD0_FORMAT_MASK GENMASK(6, 3) /* audio format */ 17 18 #define SAD1_RATE_MASK GENMASK(6, 0) /* bitfield of supported rates */ 19 #define SAD1_RATE_32000_MASK BIT(0) 20 #define SAD1_RATE_44100_MASK BIT(1) 21 #define SAD1_RATE_48000_MASK BIT(2) 22 #define SAD1_RATE_88200_MASK BIT(3) 23 #define SAD1_RATE_96000_MASK BIT(4) 24 #define SAD1_RATE_176400_MASK BIT(5) 25 #define SAD1_RATE_192000_MASK BIT(6) 26 27 static const unsigned int eld_rates[] = { 28 32000, 29 44100, 30 48000, 31 88200, 32 96000, 33 176400, 34 192000, 35 }; 36 37 static unsigned int map_rate_families(const u8 *sad, 38 unsigned int mask_32000, 39 unsigned int mask_44100, 40 unsigned int mask_48000) 41 { 42 unsigned int rate_mask = 0; 43 44 if (sad[1] & SAD1_RATE_32000_MASK) 45 rate_mask |= mask_32000; 46 if (sad[1] & (SAD1_RATE_44100_MASK | SAD1_RATE_88200_MASK | SAD1_RATE_176400_MASK)) 47 rate_mask |= mask_44100; 48 if (sad[1] & (SAD1_RATE_48000_MASK | SAD1_RATE_96000_MASK | SAD1_RATE_192000_MASK)) 49 rate_mask |= mask_48000; 50 return rate_mask; 51 } 52 53 static unsigned int sad_rate_mask(const u8 *sad) 54 { 55 switch (FIELD_GET(SAD0_FORMAT_MASK, sad[0])) { 56 case HDMI_AUDIO_CODING_TYPE_PCM: 57 return sad[1] & SAD1_RATE_MASK; 58 case HDMI_AUDIO_CODING_TYPE_AC3: 59 case HDMI_AUDIO_CODING_TYPE_DTS: 60 return map_rate_families(sad, 61 SAD1_RATE_32000_MASK, 62 SAD1_RATE_44100_MASK, 63 SAD1_RATE_48000_MASK); 64 case HDMI_AUDIO_CODING_TYPE_EAC3: 65 case HDMI_AUDIO_CODING_TYPE_DTS_HD: 66 case HDMI_AUDIO_CODING_TYPE_MLP: 67 return map_rate_families(sad, 68 0, 69 SAD1_RATE_176400_MASK, 70 SAD1_RATE_192000_MASK); 71 default: 72 /* TODO adjust for other compressed formats as well */ 73 return sad[1] & SAD1_RATE_MASK; 74 } 75 } 76 77 static unsigned int sad_max_channels(const u8 *sad) 78 { 79 switch (FIELD_GET(SAD0_FORMAT_MASK, sad[0])) { 80 case HDMI_AUDIO_CODING_TYPE_PCM: 81 return 1 + FIELD_GET(SAD0_CHANNELS_MASK, sad[0]); 82 case HDMI_AUDIO_CODING_TYPE_AC3: 83 case HDMI_AUDIO_CODING_TYPE_DTS: 84 case HDMI_AUDIO_CODING_TYPE_EAC3: 85 return 2; 86 case HDMI_AUDIO_CODING_TYPE_DTS_HD: 87 case HDMI_AUDIO_CODING_TYPE_MLP: 88 return 8; 89 default: 90 /* TODO adjust for other compressed formats as well */ 91 return 1 + FIELD_GET(SAD0_CHANNELS_MASK, sad[0]); 92 } 93 } 94 95 static int eld_limit_rates(struct snd_pcm_hw_params *params, 96 struct snd_pcm_hw_rule *rule) 97 { 98 struct snd_interval *r = hw_param_interval(params, rule->var); 99 const struct snd_interval *c; 100 unsigned int rate_mask = 7, i; 101 const u8 *sad, *eld = rule->private; 102 103 sad = drm_eld_sad(eld); 104 if (sad) { 105 c = hw_param_interval_c(params, SNDRV_PCM_HW_PARAM_CHANNELS); 106 107 for (i = drm_eld_sad_count(eld); i > 0; i--, sad += 3) { 108 unsigned max_channels = sad_max_channels(sad); 109 110 /* 111 * Exclude SADs which do not include the 112 * requested number of channels. 113 */ 114 if (c->min <= max_channels) 115 rate_mask |= sad_rate_mask(sad); 116 } 117 } 118 119 return snd_interval_list(r, ARRAY_SIZE(eld_rates), eld_rates, 120 rate_mask); 121 } 122 123 static int eld_limit_channels(struct snd_pcm_hw_params *params, 124 struct snd_pcm_hw_rule *rule) 125 { 126 struct snd_interval *c = hw_param_interval(params, rule->var); 127 const struct snd_interval *r; 128 struct snd_interval t = { .min = 1, .max = 2, .integer = 1, }; 129 unsigned int i; 130 const u8 *sad, *eld = rule->private; 131 132 sad = drm_eld_sad(eld); 133 if (sad) { 134 unsigned int rate_mask = 0; 135 136 /* Convert the rate interval to a mask */ 137 r = hw_param_interval_c(params, SNDRV_PCM_HW_PARAM_RATE); 138 for (i = 0; i < ARRAY_SIZE(eld_rates); i++) 139 if (r->min <= eld_rates[i] && r->max >= eld_rates[i]) 140 rate_mask |= BIT(i); 141 142 for (i = drm_eld_sad_count(eld); i > 0; i--, sad += 3) 143 if (rate_mask & sad_rate_mask(sad)) 144 t.max = max(t.max, sad_max_channels(sad)); 145 } 146 147 return snd_interval_refine(c, &t); 148 } 149 150 int snd_pcm_hw_constraint_eld(struct snd_pcm_runtime *runtime, void *eld) 151 { 152 int ret; 153 154 ret = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE, 155 eld_limit_rates, eld, 156 SNDRV_PCM_HW_PARAM_CHANNELS, -1); 157 if (ret < 0) 158 return ret; 159 160 ret = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS, 161 eld_limit_channels, eld, 162 SNDRV_PCM_HW_PARAM_RATE, -1); 163 164 return ret; 165 } 166 EXPORT_SYMBOL_GPL(snd_pcm_hw_constraint_eld); 167 168 #define SND_PRINT_RATES_ADVISED_BUFSIZE 80 169 #define SND_PRINT_BITS_ADVISED_BUFSIZE 16 170 #define SND_PRINT_CHANNEL_ALLOCATION_ADVISED_BUFSIZE 80 171 172 static const char * const eld_connection_type_names[4] = { 173 "HDMI", 174 "DisplayPort", 175 "2-reserved", 176 "3-reserved" 177 }; 178 179 static const char * const cea_audio_coding_type_names[] = { 180 /* 0 */ "undefined", 181 /* 1 */ "LPCM", 182 /* 2 */ "AC-3", 183 /* 3 */ "MPEG1", 184 /* 4 */ "MP3", 185 /* 5 */ "MPEG2", 186 /* 6 */ "AAC-LC", 187 /* 7 */ "DTS", 188 /* 8 */ "ATRAC", 189 /* 9 */ "DSD (One Bit Audio)", 190 /* 10 */ "E-AC-3/DD+ (Dolby Digital Plus)", 191 /* 11 */ "DTS-HD", 192 /* 12 */ "MLP (Dolby TrueHD)", 193 /* 13 */ "DST", 194 /* 14 */ "WMAPro", 195 /* 15 */ "HE-AAC", 196 /* 16 */ "HE-AACv2", 197 /* 17 */ "MPEG Surround", 198 }; 199 200 static const char * const cea_speaker_allocation_names[] = { 201 /* 0 */ "FL/FR", 202 /* 1 */ "LFE", 203 /* 2 */ "FC", 204 /* 3 */ "RL/RR", 205 /* 4 */ "RC", 206 /* 5 */ "FLC/FRC", 207 /* 6 */ "RLC/RRC", 208 /* 7 */ "FLW/FRW", 209 /* 8 */ "FLH/FRH", 210 /* 9 */ "TC", 211 /* 10 */ "FCH", 212 }; 213 214 /* 215 * SS1:SS0 index => sample size 216 */ 217 static const int cea_sample_sizes[4] = { 218 0, /* 0: Refer to Stream Header */ 219 ELD_PCM_BITS_16, /* 1: 16 bits */ 220 ELD_PCM_BITS_20, /* 2: 20 bits */ 221 ELD_PCM_BITS_24, /* 3: 24 bits */ 222 }; 223 224 /* 225 * SF2:SF1:SF0 index => sampling frequency 226 */ 227 static const int cea_sampling_frequencies[8] = { 228 0, /* 0: Refer to Stream Header */ 229 SNDRV_PCM_RATE_32000, /* 1: 32000Hz */ 230 SNDRV_PCM_RATE_44100, /* 2: 44100Hz */ 231 SNDRV_PCM_RATE_48000, /* 3: 48000Hz */ 232 SNDRV_PCM_RATE_88200, /* 4: 88200Hz */ 233 SNDRV_PCM_RATE_96000, /* 5: 96000Hz */ 234 SNDRV_PCM_RATE_176400, /* 6: 176400Hz */ 235 SNDRV_PCM_RATE_192000, /* 7: 192000Hz */ 236 }; 237 238 #define GRAB_BITS(buf, byte, lowbit, bits) \ 239 ({ \ 240 BUILD_BUG_ON(lowbit > 7); \ 241 BUILD_BUG_ON(bits > 8); \ 242 BUILD_BUG_ON(bits <= 0); \ 243 \ 244 (buf[byte] >> (lowbit)) & ((1 << (bits)) - 1); \ 245 }) 246 247 static void hdmi_update_short_audio_desc(struct device *dev, 248 struct snd_cea_sad *a, 249 const unsigned char *buf) 250 { 251 int i; 252 int val; 253 254 val = GRAB_BITS(buf, 1, 0, 7); 255 a->rates = 0; 256 for (i = 0; i < 7; i++) 257 if (val & (1 << i)) 258 a->rates |= cea_sampling_frequencies[i + 1]; 259 260 a->channels = GRAB_BITS(buf, 0, 0, 3); 261 a->channels++; 262 263 a->sample_bits = 0; 264 a->max_bitrate = 0; 265 266 a->format = GRAB_BITS(buf, 0, 3, 4); 267 switch (a->format) { 268 case AUDIO_CODING_TYPE_REF_STREAM_HEADER: 269 dev_info(dev, "HDMI: audio coding type 0 not expected\n"); 270 break; 271 272 case AUDIO_CODING_TYPE_LPCM: 273 val = GRAB_BITS(buf, 2, 0, 3); 274 for (i = 0; i < 3; i++) 275 if (val & (1 << i)) 276 a->sample_bits |= cea_sample_sizes[i + 1]; 277 break; 278 279 case AUDIO_CODING_TYPE_AC3: 280 case AUDIO_CODING_TYPE_MPEG1: 281 case AUDIO_CODING_TYPE_MP3: 282 case AUDIO_CODING_TYPE_MPEG2: 283 case AUDIO_CODING_TYPE_AACLC: 284 case AUDIO_CODING_TYPE_DTS: 285 case AUDIO_CODING_TYPE_ATRAC: 286 a->max_bitrate = GRAB_BITS(buf, 2, 0, 8); 287 a->max_bitrate *= 8000; 288 break; 289 290 case AUDIO_CODING_TYPE_SACD: 291 break; 292 293 case AUDIO_CODING_TYPE_EAC3: 294 break; 295 296 case AUDIO_CODING_TYPE_DTS_HD: 297 break; 298 299 case AUDIO_CODING_TYPE_MLP: 300 break; 301 302 case AUDIO_CODING_TYPE_DST: 303 break; 304 305 case AUDIO_CODING_TYPE_WMAPRO: 306 a->profile = GRAB_BITS(buf, 2, 0, 3); 307 break; 308 309 case AUDIO_CODING_TYPE_REF_CXT: 310 a->format = GRAB_BITS(buf, 2, 3, 5); 311 if (a->format == AUDIO_CODING_XTYPE_HE_REF_CT || 312 a->format >= AUDIO_CODING_XTYPE_FIRST_RESERVED) { 313 dev_info(dev, 314 "HDMI: audio coding xtype %d not expected\n", 315 a->format); 316 a->format = 0; 317 } else 318 a->format += AUDIO_CODING_TYPE_HE_AAC - 319 AUDIO_CODING_XTYPE_HE_AAC; 320 break; 321 } 322 } 323 324 /* 325 * Be careful, ELD buf could be totally rubbish! 326 */ 327 int snd_parse_eld(struct device *dev, struct snd_parsed_hdmi_eld *e, 328 const unsigned char *buf, int size) 329 { 330 int mnl; 331 int i; 332 333 memset(e, 0, sizeof(*e)); 334 e->eld_ver = GRAB_BITS(buf, 0, 3, 5); 335 if (e->eld_ver != ELD_VER_CEA_861D && 336 e->eld_ver != ELD_VER_PARTIAL) { 337 dev_info(dev, "HDMI: Unknown ELD version %d\n", e->eld_ver); 338 goto out_fail; 339 } 340 341 e->baseline_len = GRAB_BITS(buf, 2, 0, 8); 342 mnl = GRAB_BITS(buf, 4, 0, 5); 343 e->cea_edid_ver = GRAB_BITS(buf, 4, 5, 3); 344 345 e->support_hdcp = GRAB_BITS(buf, 5, 0, 1); 346 e->support_ai = GRAB_BITS(buf, 5, 1, 1); 347 e->conn_type = GRAB_BITS(buf, 5, 2, 2); 348 e->sad_count = GRAB_BITS(buf, 5, 4, 4); 349 350 e->aud_synch_delay = GRAB_BITS(buf, 6, 0, 8) * 2; 351 e->spk_alloc = GRAB_BITS(buf, 7, 0, 7); 352 353 e->port_id = get_unaligned_le64(buf + 8); 354 355 /* not specified, but the spec's tendency is little endian */ 356 e->manufacture_id = get_unaligned_le16(buf + 16); 357 e->product_id = get_unaligned_le16(buf + 18); 358 359 if (mnl > ELD_MAX_MNL) { 360 dev_info(dev, "HDMI: MNL is reserved value %d\n", mnl); 361 goto out_fail; 362 } else if (ELD_FIXED_BYTES + mnl > size) { 363 dev_info(dev, "HDMI: out of range MNL %d\n", mnl); 364 goto out_fail; 365 } else 366 strscpy(e->monitor_name, buf + ELD_FIXED_BYTES, mnl + 1); 367 368 for (i = 0; i < e->sad_count; i++) { 369 if (ELD_FIXED_BYTES + mnl + 3 * (i + 1) > size) { 370 dev_info(dev, "HDMI: out of range SAD %d\n", i); 371 goto out_fail; 372 } 373 hdmi_update_short_audio_desc(dev, e->sad + i, 374 buf + ELD_FIXED_BYTES + mnl + 3 * i); 375 } 376 377 /* 378 * HDMI sink's ELD info cannot always be retrieved for now, e.g. 379 * in console or for audio devices. Assume the highest speakers 380 * configuration, to _not_ prohibit multi-channel audio playback. 381 */ 382 if (!e->spk_alloc) 383 e->spk_alloc = 0xffff; 384 385 return 0; 386 387 out_fail: 388 return -EINVAL; 389 } 390 EXPORT_SYMBOL_GPL(snd_parse_eld); 391 392 /* 393 * SNDRV_PCM_RATE_* and AC_PAR_PCM values don't match, print correct rates with 394 * hdmi-specific routine. 395 */ 396 static void hdmi_print_pcm_rates(int pcm, char *buf, int buflen) 397 { 398 static const unsigned int alsa_rates[] = { 399 5512, 8000, 11025, 16000, 22050, 32000, 44100, 48000, 64000, 400 88200, 96000, 176400, 192000, 384000 401 }; 402 int i, j; 403 404 for (i = 0, j = 0; i < ARRAY_SIZE(alsa_rates); i++) 405 if (pcm & (1 << i)) 406 j += scnprintf(buf + j, buflen - j, " %d", 407 alsa_rates[i]); 408 409 buf[j] = '\0'; /* necessary when j == 0 */ 410 } 411 412 static void eld_print_pcm_bits(int pcm, char *buf, int buflen) 413 { 414 static const unsigned int bits[] = { 8, 16, 20, 24, 32 }; 415 int i, j; 416 417 for (i = 0, j = 0; i < ARRAY_SIZE(bits); i++) 418 if (pcm & (ELD_PCM_BITS_8 << i)) 419 j += scnprintf(buf + j, buflen - j, " %d", bits[i]); 420 421 buf[j] = '\0'; /* necessary when j == 0 */ 422 } 423 424 static void hdmi_show_short_audio_desc(struct device *dev, 425 struct snd_cea_sad *a) 426 { 427 char buf[SND_PRINT_RATES_ADVISED_BUFSIZE]; 428 char buf2[8 + SND_PRINT_BITS_ADVISED_BUFSIZE] = ", bits ="; 429 430 if (!a->format) 431 return; 432 433 hdmi_print_pcm_rates(a->rates, buf, sizeof(buf)); 434 435 if (a->format == AUDIO_CODING_TYPE_LPCM) 436 eld_print_pcm_bits(a->sample_bits, buf2 + 8, sizeof(buf2) - 8); 437 else if (a->max_bitrate) 438 snprintf(buf2, sizeof(buf2), 439 ", max bitrate = %d", a->max_bitrate); 440 else 441 buf2[0] = '\0'; 442 443 dev_dbg(dev, 444 "HDMI: supports coding type %s: channels = %d, rates =%s%s\n", 445 cea_audio_coding_type_names[a->format], 446 a->channels, buf, buf2); 447 } 448 449 static void snd_eld_print_channel_allocation(int spk_alloc, char *buf, int buflen) 450 { 451 int i, j; 452 453 for (i = 0, j = 0; i < ARRAY_SIZE(cea_speaker_allocation_names); i++) { 454 if (spk_alloc & (1 << i)) 455 j += scnprintf(buf + j, buflen - j, " %s", 456 cea_speaker_allocation_names[i]); 457 } 458 buf[j] = '\0'; /* necessary when j == 0 */ 459 } 460 461 void snd_show_eld(struct device *dev, struct snd_parsed_hdmi_eld *e) 462 { 463 int i; 464 465 dev_dbg(dev, "HDMI: detected monitor %s at connection type %s\n", 466 e->monitor_name, 467 eld_connection_type_names[e->conn_type]); 468 469 if (e->spk_alloc) { 470 char buf[SND_PRINT_CHANNEL_ALLOCATION_ADVISED_BUFSIZE]; 471 472 snd_eld_print_channel_allocation(e->spk_alloc, buf, sizeof(buf)); 473 dev_dbg(dev, "HDMI: available speakers:%s\n", buf); 474 } 475 476 for (i = 0; i < e->sad_count; i++) 477 hdmi_show_short_audio_desc(dev, e->sad + i); 478 } 479 EXPORT_SYMBOL_GPL(snd_show_eld); 480 481 #ifdef CONFIG_SND_PROC_FS 482 static void hdmi_print_sad_info(int i, struct snd_cea_sad *a, 483 struct snd_info_buffer *buffer) 484 { 485 char buf[SND_PRINT_RATES_ADVISED_BUFSIZE]; 486 487 snd_iprintf(buffer, "sad%d_coding_type\t[0x%x] %s\n", 488 i, a->format, cea_audio_coding_type_names[a->format]); 489 snd_iprintf(buffer, "sad%d_channels\t\t%d\n", i, a->channels); 490 491 hdmi_print_pcm_rates(a->rates, buf, sizeof(buf)); 492 snd_iprintf(buffer, "sad%d_rates\t\t[0x%x]%s\n", i, a->rates, buf); 493 494 if (a->format == AUDIO_CODING_TYPE_LPCM) { 495 eld_print_pcm_bits(a->sample_bits, buf, sizeof(buf)); 496 snd_iprintf(buffer, "sad%d_bits\t\t[0x%x]%s\n", 497 i, a->sample_bits, buf); 498 } 499 500 if (a->max_bitrate) 501 snd_iprintf(buffer, "sad%d_max_bitrate\t%d\n", 502 i, a->max_bitrate); 503 504 if (a->profile) 505 snd_iprintf(buffer, "sad%d_profile\t\t%d\n", i, a->profile); 506 } 507 508 void snd_print_eld_info(struct snd_parsed_hdmi_eld *e, 509 struct snd_info_buffer *buffer) 510 { 511 char buf[SND_PRINT_CHANNEL_ALLOCATION_ADVISED_BUFSIZE]; 512 int i; 513 static const char * const eld_version_names[32] = { 514 "reserved", 515 "reserved", 516 "CEA-861D or below", 517 [3 ... 30] = "reserved", 518 [31] = "partial" 519 }; 520 static const char * const cea_edid_version_names[8] = { 521 "no CEA EDID Timing Extension block present", 522 "CEA-861", 523 "CEA-861-A", 524 "CEA-861-B, C or D", 525 [4 ... 7] = "reserved" 526 }; 527 528 snd_iprintf(buffer, "monitor_name\t\t%s\n", e->monitor_name); 529 snd_iprintf(buffer, "connection_type\t\t%s\n", 530 eld_connection_type_names[e->conn_type]); 531 snd_iprintf(buffer, "eld_version\t\t[0x%x] %s\n", e->eld_ver, 532 eld_version_names[e->eld_ver]); 533 snd_iprintf(buffer, "edid_version\t\t[0x%x] %s\n", e->cea_edid_ver, 534 cea_edid_version_names[e->cea_edid_ver]); 535 snd_iprintf(buffer, "manufacture_id\t\t0x%x\n", e->manufacture_id); 536 snd_iprintf(buffer, "product_id\t\t0x%x\n", e->product_id); 537 snd_iprintf(buffer, "port_id\t\t\t0x%llx\n", (long long)e->port_id); 538 snd_iprintf(buffer, "support_hdcp\t\t%d\n", e->support_hdcp); 539 snd_iprintf(buffer, "support_ai\t\t%d\n", e->support_ai); 540 snd_iprintf(buffer, "audio_sync_delay\t%d\n", e->aud_synch_delay); 541 542 snd_eld_print_channel_allocation(e->spk_alloc, buf, sizeof(buf)); 543 snd_iprintf(buffer, "speakers\t\t[0x%x]%s\n", e->spk_alloc, buf); 544 545 snd_iprintf(buffer, "sad_count\t\t%d\n", e->sad_count); 546 547 for (i = 0; i < e->sad_count; i++) 548 hdmi_print_sad_info(i, e->sad + i, buffer); 549 } 550 EXPORT_SYMBOL_GPL(snd_print_eld_info); 551 #endif /* CONFIG_SND_PROC_FS */ 552