1// SPDX-License-Identifier: GPL-2.0+ 2/* 3 * Copyright 2020 Google LLC 4 * 5 * Modified from coreboot nhlt.c 6 */ 7 8#define LOG_CATEGORY LOGC_ACPI 9 10#include <common.h> 11#include <binman.h> 12#include <dm.h> 13#include <log.h> 14#include <malloc.h> 15#include <tables_csum.h> 16#include <acpi/acpi_table.h> 17#include <asm/acpi_nhlt.h> 18#include <asm/unaligned.h> 19#include <dm/acpi.h> 20 21#define NHLT_RID 1 22#define NHLT_SSID 1 23#define WAVEFORMAT_TAG 0xfffe 24#define DEFAULT_VIRTUAL_BUS_ID 0 25 26static const struct sub_format pcm_subformat = { 27 .data1 = 0x00000001, 28 .data2 = 0x0000, 29 .data3 = 0x0010, 30 .data4 = { 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71 }, 31}; 32 33struct nhlt *nhlt_init(void) 34{ 35 struct nhlt *nhlt; 36 37 nhlt = malloc(sizeof(*nhlt)); 38 39 if (!nhlt) 40 return NULL; 41 42 memset(nhlt, 0, sizeof(*nhlt)); 43 nhlt->subsystem_id = NHLT_SSID; 44 45 return nhlt; 46} 47 48struct nhlt_endpoint *nhlt_add_endpoint(struct nhlt *nhlt, int link_type, 49 int device_type, int dir, 50 u16 vid, u16 did) 51{ 52 struct nhlt_endpoint *endp; 53 54 if (link_type < NHLT_LINK_HDA || link_type >= NHLT_MAX_LINK_TYPES) 55 return NULL; 56 57 if (nhlt->num_endpoints >= MAX_ENDPOINTS) 58 return NULL; 59 60 endp = &nhlt->endpoints[nhlt->num_endpoints]; 61 62 endp->link_type = link_type; 63 endp->instance_id = nhlt->current_instance_id[link_type]; 64 endp->vendor_id = vid; 65 endp->device_id = did; 66 endp->revision_id = NHLT_RID; 67 endp->subsystem_id = nhlt->subsystem_id; 68 endp->device_type = device_type; 69 endp->direction = dir; 70 endp->virtual_bus_id = DEFAULT_VIRTUAL_BUS_ID; 71 endp->num_formats = 0; 72 73 nhlt->num_endpoints++; 74 75 return endp; 76} 77 78static int append_specific_config(struct nhlt_specific_config *spec_cfg, 79 const void *config, size_t config_sz) 80{ 81 size_t new_sz; 82 void *new_cfg; 83 84 new_sz = spec_cfg->size + config_sz; 85 new_cfg = malloc(new_sz); 86 if (!new_cfg) 87 return -ENOMEM; 88 89 /* Append new config */ 90 memcpy(new_cfg, spec_cfg->capabilities, spec_cfg->size); 91 memcpy(new_cfg + spec_cfg->size, config, config_sz); 92 93 free(spec_cfg->capabilities); 94 95 /* Update with new config data */ 96 spec_cfg->size = new_sz; 97 spec_cfg->capabilities = new_cfg; 98 99 return 0; 100} 101 102int nhlt_endpoint_append_config(struct nhlt_endpoint *endp, const void *config, 103 size_t config_sz) 104{ 105 return append_specific_config(&endp->config, config, config_sz); 106} 107 108struct nhlt_format *nhlt_add_format(struct nhlt_endpoint *endp, 109 int num_channels, int sample_freq_khz, 110 int container_bits_per_sample, 111 int valid_bits_per_sample, 112 uint32_t speaker_mask) 113{ 114 struct nhlt_format *fmt; 115 struct nhlt_waveform *wave; 116 117 if (endp->num_formats >= MAX_FORMATS) 118 return NULL; 119 120 fmt = &endp->formats[endp->num_formats]; 121 wave = &fmt->waveform; 122 123 wave->tag = WAVEFORMAT_TAG; 124 wave->num_channels = num_channels; 125 wave->samples_per_second = sample_freq_khz * 1000; 126 wave->bits_per_sample = container_bits_per_sample; 127 wave->extra_size = sizeof(wave->valid_bits_per_sample); 128 wave->extra_size += sizeof(wave->channel_mask); 129 wave->extra_size += sizeof(wave->sub_format); 130 wave->valid_bits_per_sample = valid_bits_per_sample; 131 wave->channel_mask = speaker_mask; 132 memcpy(&wave->sub_format, &pcm_subformat, sizeof(wave->sub_format)); 133 134 /* Calculate the dervied fields */ 135 wave->block_align = wave->num_channels * wave->bits_per_sample / 8; 136 wave->bytes_per_second = wave->block_align * wave->samples_per_second; 137 138 endp->num_formats++; 139 140 return fmt; 141} 142 143int nhlt_format_append_config(struct nhlt_format *fmt, const void *config, 144 size_t config_sz) 145{ 146 return append_specific_config(&fmt->config, config, config_sz); 147} 148 149int nhlt_endpoint_add_formats(struct nhlt_endpoint *endp, 150 const struct nhlt_format_config *formats, 151 size_t num_formats) 152{ 153 ofnode node; 154 size_t i; 155 156 node = binman_section_find_node("private-files"); 157 158 for (i = 0; i < num_formats; i++) { 159 const struct nhlt_format_config *cfg = &formats[i]; 160 struct nhlt_format *fmt; 161 void *data; 162 int size; 163 int ret; 164 165 fmt = nhlt_add_format(endp, cfg->num_channels, 166 cfg->sample_freq_khz, 167 cfg->container_bits_per_sample, 168 cfg->valid_bits_per_sample, 169 cfg->speaker_mask); 170 if (!fmt) 171 return -ENOSPC; 172 173 if (!cfg->settings_file) 174 continue; 175 176 ret = binman_entry_map(node, cfg->settings_file, &data, &size); 177 if (ret) { 178 log_warning("Failed to find settings file %s\n", 179 cfg->settings_file); 180 return log_msg_ret("settings", ret); 181 } 182 183 ret = nhlt_format_append_config(fmt, data, size); 184 if (ret) 185 return log_msg_ret("append", ret); 186 } 187 188 return 0; 189} 190 191void nhlt_next_instance(struct nhlt *nhlt, int link_type) 192{ 193 if (link_type < NHLT_LINK_HDA || link_type >= NHLT_MAX_LINK_TYPES) 194 return; 195 196 nhlt->current_instance_id[link_type]++; 197} 198 199static size_t calc_specific_config_size(struct nhlt_specific_config *cfg) 200{ 201 return sizeof(cfg->size) + cfg->size; 202} 203 204static size_t calc_format_size(struct nhlt_format *fmt) 205{ 206 size_t sz = 0; 207 208 /* Wave format first */ 209 sz += sizeof(fmt->waveform.tag); 210 sz += sizeof(fmt->waveform.num_channels); 211 sz += sizeof(fmt->waveform.samples_per_second); 212 sz += sizeof(fmt->waveform.bytes_per_second); 213 sz += sizeof(fmt->waveform.block_align); 214 sz += sizeof(fmt->waveform.bits_per_sample); 215 sz += sizeof(fmt->waveform.extra_size); 216 sz += sizeof(fmt->waveform.valid_bits_per_sample); 217 sz += sizeof(fmt->waveform.channel_mask); 218 sz += sizeof(fmt->waveform.sub_format); 219 220 sz += calc_specific_config_size(&fmt->config); 221 222 return sz; 223} 224 225static size_t calc_endpoint_size(struct nhlt_endpoint *endp) 226{ 227 int i; 228 size_t sz = 0; 229 230 sz += sizeof(endp->length) + sizeof(endp->link_type); 231 sz += sizeof(endp->instance_id) + sizeof(endp->vendor_id); 232 sz += sizeof(endp->device_id) + sizeof(endp->revision_id); 233 sz += sizeof(endp->subsystem_id) + sizeof(endp->device_type); 234 sz += sizeof(endp->direction) + sizeof(endp->virtual_bus_id); 235 sz += calc_specific_config_size(&endp->config); 236 sz += sizeof(endp->num_formats); 237 238 for (i = 0; i < endp->num_formats; i++) 239 sz += calc_format_size(&endp->formats[i]); 240 241 /* Adjust endpoint length to reflect current configuration */ 242 endp->length = sz; 243 244 return sz; 245} 246 247static size_t calc_endpoints_size(struct nhlt *nhlt) 248{ 249 size_t sz = 0; 250 int i; 251 252 for (i = 0; i < nhlt->num_endpoints; i++) 253 sz += calc_endpoint_size(&nhlt->endpoints[i]); 254 255 return sz; 256} 257 258static size_t calc_size(struct nhlt *nhlt) 259{ 260 return sizeof(nhlt->num_endpoints) + calc_endpoints_size(nhlt); 261} 262 263size_t nhlt_current_size(struct nhlt *nhlt) 264{ 265 return calc_size(nhlt) + sizeof(struct acpi_table_header); 266} 267 268static void nhlt_free_resources(struct nhlt *nhlt) 269{ 270 int i, j; 271 272 /* Free all specific configs */ 273 for (i = 0; i < nhlt->num_endpoints; i++) { 274 struct nhlt_endpoint *endp = &nhlt->endpoints[i]; 275 276 free(endp->config.capabilities); 277 for (j = 0; j < endp->num_formats; j++) { 278 struct nhlt_format *fmt = &endp->formats[j]; 279 280 free(fmt->config.capabilities); 281 } 282 } 283 284 /* Free nhlt object proper */ 285 free(nhlt); 286} 287 288struct cursor { 289 u8 *start; 290 u8 *buf; 291}; 292 293static void ser8(struct cursor *cur, uint val) 294{ 295 *cur->buf = val; 296 cur->buf += sizeof(u8); 297} 298 299static void ser16(struct cursor *cur, uint val) 300{ 301 put_unaligned_le16(val, cur->buf); 302 cur->buf += sizeof(u16); 303} 304 305static void ser32(struct cursor *cur, uint val) 306{ 307 put_unaligned_le32(val, cur->buf); 308 cur->buf += sizeof(u32); 309} 310 311static void serblob(struct cursor *cur, void *from, size_t sz) 312{ 313 memcpy(cur->buf, from, sz); 314 cur->buf += sz; 315} 316 317static void serialise_specific_config(struct nhlt_specific_config *cfg, 318 struct cursor *cur) 319{ 320 log_debug("%zx\n", cur->buf - cur->start); 321 ser32(cur, cfg->size); 322 serblob(cur, cfg->capabilities, cfg->size); 323} 324 325static void serialise_waveform(struct nhlt_waveform *wave, struct cursor *cur) 326{ 327 log_debug("%zx\n", cur->buf - cur->start); 328 ser16(cur, wave->tag); 329 ser16(cur, wave->num_channels); 330 ser32(cur, wave->samples_per_second); 331 ser32(cur, wave->bytes_per_second); 332 ser16(cur, wave->block_align); 333 ser16(cur, wave->bits_per_sample); 334 ser16(cur, wave->extra_size); 335 ser16(cur, wave->valid_bits_per_sample); 336 ser32(cur, wave->channel_mask); 337 ser32(cur, wave->sub_format.data1); 338 ser16(cur, wave->sub_format.data2); 339 ser16(cur, wave->sub_format.data3); 340 serblob(cur, wave->sub_format.data4, sizeof(wave->sub_format.data4)); 341} 342 343static void serialise_format(struct nhlt_format *fmt, struct cursor *cur) 344{ 345 log_debug("%zx\n", cur->buf - cur->start); 346 serialise_waveform(&fmt->waveform, cur); 347 serialise_specific_config(&fmt->config, cur); 348} 349 350static void serialise_endpoint(struct nhlt_endpoint *endp, struct cursor *cur) 351{ 352 int i; 353 354 log_debug("%zx\n", cur->buf - cur->start); 355 ser32(cur, endp->length); 356 ser8(cur, endp->link_type); 357 ser8(cur, endp->instance_id); 358 ser16(cur, endp->vendor_id); 359 ser16(cur, endp->device_id); 360 ser16(cur, endp->revision_id); 361 ser32(cur, endp->subsystem_id); 362 ser8(cur, endp->device_type); 363 ser8(cur, endp->direction); 364 ser8(cur, endp->virtual_bus_id); 365 serialise_specific_config(&endp->config, cur); 366 ser8(cur, endp->num_formats); 367 368 for (i = 0; i < endp->num_formats; i++) 369 serialise_format(&endp->formats[i], cur); 370} 371 372static void nhlt_serialise_endpoints(struct nhlt *nhlt, struct cursor *cur) 373{ 374 int i; 375 376 ser8(cur, nhlt->num_endpoints); 377 378 for (i = 0; i < nhlt->num_endpoints; i++) 379 serialise_endpoint(&nhlt->endpoints[i], cur); 380} 381 382int nhlt_serialise_oem_overrides(struct acpi_ctx *ctx, struct nhlt *nhlt, 383 const char *oem_id, const char *oem_table_id, 384 uint32_t oem_revision) 385{ 386 struct cursor cur; 387 struct acpi_table_header *header; 388 size_t sz; 389 size_t oem_id_len; 390 size_t oem_table_id_len; 391 int ret; 392 393 log_debug("ACPI: * NHLT\n"); 394 sz = nhlt_current_size(nhlt); 395 396 /* Create header */ 397 header = (void *)ctx->current; 398 memset(header, '\0', sizeof(struct acpi_table_header)); 399 memcpy(header->signature, "NHLT", 4); 400 header->length = sz; 401 header->revision = acpi_get_table_revision(ACPITAB_NHLT); 402 403 if (oem_id) { 404 oem_id_len = min((int)strlen(oem_id), 6); 405 memcpy(header->oem_id, oem_id, oem_id_len); 406 } 407 if (oem_table_id) { 408 oem_table_id_len = min((int)strlen(oem_table_id), 8); 409 memcpy(header->oem_table_id, oem_table_id, oem_table_id_len); 410 } 411 header->oem_revision = oem_revision; 412 memcpy(header->creator_id, ASLC_ID, 4); 413 414 cur.buf = (void *)(header + 1); 415 cur.start = (void *)header; 416 nhlt_serialise_endpoints(nhlt, &cur); 417 418 header->checksum = table_compute_checksum(header, sz); 419 nhlt_free_resources(nhlt); 420 assert(cur.buf - cur.start == sz); 421 422 ret = acpi_add_table(ctx, ctx->current); 423 if (ret) 424 return log_msg_ret("add", ret); 425 acpi_inc_align(ctx, sz); 426 427 return 0; 428} 429 430static int _nhlt_add_single_endpoint(struct nhlt *nhlt, int virtual_bus_id, 431 const struct nhlt_endp_descriptor *epd) 432{ 433 struct nhlt_endpoint *endp; 434 int ret; 435 436 endp = nhlt_add_endpoint(nhlt, epd->link, epd->device, epd->direction, 437 epd->vid, epd->did); 438 if (!endp) 439 return -EINVAL; 440 441 endp->virtual_bus_id = virtual_bus_id; 442 443 ret = nhlt_endpoint_append_config(endp, epd->cfg, epd->cfg_size); 444 if (ret) 445 return ret; 446 447 ret = nhlt_endpoint_add_formats(endp, epd->formats, epd->num_formats); 448 if (ret) 449 return log_msg_ret("formats", ret); 450 451 return 0; 452} 453 454static int _nhlt_add_endpoints(struct nhlt *nhlt, int virtual_bus_id, 455 const struct nhlt_endp_descriptor *epds, 456 size_t num_epds) 457{ 458 size_t i; 459 int ret; 460 461 for (i = 0; i < num_epds; i++) { 462 ret = _nhlt_add_single_endpoint(nhlt, virtual_bus_id, &epds[i]); 463 if (ret) 464 return log_ret(ret); 465 } 466 467 return 0; 468} 469 470int nhlt_add_endpoints(struct nhlt *nhlt, 471 const struct nhlt_endp_descriptor *epds, size_t num_epds) 472{ 473 int ret; 474 475 ret = _nhlt_add_endpoints(nhlt, DEFAULT_VIRTUAL_BUS_ID, epds, num_epds); 476 477 return ret; 478} 479 480int nhlt_add_ssp_endpoints(struct nhlt *nhlt, int virtual_bus_id, 481 const struct nhlt_endp_descriptor *epds, 482 size_t num_epds) 483{ 484 int ret; 485 486 ret = _nhlt_add_endpoints(nhlt, virtual_bus_id, epds, num_epds); 487 if (!ret) 488 nhlt_next_instance(nhlt, NHLT_LINK_SSP); 489 490 return ret; 491} 492