acpi_nhlt.c 11 KB

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