1 // SPDX-License-Identifier: GPL-2.0+
3 * EFI Human Interface Infrastructure ... database and packages
5 * Copyright (c) 2017 Leif Lindholm
6 * Copyright (c) 2018 AKASHI Takahiro, Linaro Limited
10 #include <efi_loader.h>
12 #include <asm/unaligned.h>
14 const efi_guid_t efi_guid_hii_database_protocol
15 = EFI_HII_DATABASE_PROTOCOL_GUID;
16 const efi_guid_t efi_guid_hii_string_protocol = EFI_HII_STRING_PROTOCOL_GUID;
18 static LIST_HEAD(efi_package_lists);
19 static LIST_HEAD(efi_keyboard_layout_list);
21 struct efi_hii_packagelist {
22 struct list_head link;
23 // TODO should there be an associated efi_object?
24 efi_handle_t driver_handle;
26 struct list_head string_tables; /* list of efi_string_table */
27 struct list_head guid_list;
28 struct list_head keyboard_packages;
30 /* we could also track fonts, images, etc */
33 static int efi_hii_packagelist_exists(efi_hii_handle_t package_list)
35 struct efi_hii_packagelist *hii;
38 list_for_each_entry(hii, &efi_package_lists, link) {
39 if (hii == package_list) {
48 static u32 efi_hii_package_type(struct efi_hii_package_header *header)
52 fields = get_unaligned_le32(&header->fields);
54 return (fields >> __EFI_HII_PACKAGE_TYPE_SHIFT)
55 & __EFI_HII_PACKAGE_TYPE_MASK;
58 static u32 efi_hii_package_len(struct efi_hii_package_header *header)
62 fields = get_unaligned_le32(&header->fields);
64 return (fields >> __EFI_HII_PACKAGE_LEN_SHIFT)
65 & __EFI_HII_PACKAGE_LEN_MASK;
68 struct efi_string_info {
70 /* we could also track font info, etc */
73 struct efi_string_table {
74 struct list_head link;
75 efi_string_id_t language_name;
80 * string id starts at 1 so value is stbl->strings[id-1],
81 * and strings[] is a array of stbl->nstrings elements
83 struct efi_string_info *strings;
86 struct efi_guid_data {
87 struct list_head link;
88 struct efi_hii_guid_package package;
91 struct efi_keyboard_layout_data {
92 struct list_head link; /* in package */
93 struct list_head link_sys; /* in global list */
94 struct efi_hii_keyboard_layout keyboard_layout;
97 struct efi_keyboard_package_data {
98 struct list_head link; /* in package_list */
99 struct list_head keyboard_layout_list;
102 static void free_strings_table(struct efi_string_table *stbl)
106 for (i = 0; i < stbl->nstrings; i++)
107 free(stbl->strings[i].string);
109 free(stbl->language);
113 static void remove_strings_package(struct efi_hii_packagelist *hii)
115 while (!list_empty(&hii->string_tables)) {
116 struct efi_string_table *stbl;
118 stbl = list_first_entry(&hii->string_tables,
119 struct efi_string_table, link);
120 list_del(&stbl->link);
121 free_strings_table(stbl);
126 add_strings_package(struct efi_hii_packagelist *hii,
127 struct efi_hii_strings_package *strings_package)
129 struct efi_hii_string_block *block;
131 u32 nstrings = 0, idx = 0;
132 struct efi_string_table *stbl = NULL;
135 EFI_PRINT("header_size: %08x\n",
136 get_unaligned_le32(&strings_package->header_size));
137 EFI_PRINT("string_info_offset: %08x\n",
138 get_unaligned_le32(&strings_package->string_info_offset));
139 EFI_PRINT("language_name: %u\n",
140 get_unaligned_le16(&strings_package->language_name));
141 EFI_PRINT("language: %s\n", strings_package->language);
143 /* count # of string entries: */
144 end = ((void *)strings_package)
145 + efi_hii_package_len(&strings_package->header);
146 block = ((void *)strings_package)
147 + get_unaligned_le32(&strings_package->string_info_offset);
149 while ((void *)block < end) {
150 switch (block->block_type) {
151 case EFI_HII_SIBT_STRING_UCS2: {
152 struct efi_hii_sibt_string_ucs2_block *ucs2;
154 ucs2 = (void *)block;
156 block = efi_hii_sibt_string_ucs2_block_next(ucs2);
159 case EFI_HII_SIBT_END:
163 EFI_PRINT("unknown HII string block type: %02x\n",
165 return EFI_INVALID_PARAMETER;
169 stbl = calloc(sizeof(*stbl), 1);
171 ret = EFI_OUT_OF_RESOURCES;
174 stbl->strings = calloc(sizeof(stbl->strings[0]), nstrings);
175 if (!stbl->strings) {
176 ret = EFI_OUT_OF_RESOURCES;
179 stbl->language_name =
180 get_unaligned_le16(&strings_package->language_name);
181 stbl->language = strdup((char *)strings_package->language);
182 if (!stbl->language) {
183 ret = EFI_OUT_OF_RESOURCES;
186 stbl->nstrings = nstrings;
188 /* and now parse string entries and populate efi_string_table */
189 block = ((void *)strings_package)
190 + get_unaligned_le32(&strings_package->string_info_offset);
192 while ((void *)block < end) {
193 switch (block->block_type) {
194 case EFI_HII_SIBT_STRING_UCS2: {
195 struct efi_hii_sibt_string_ucs2_block *ucs2;
197 ucs2 = (void *)block;
198 EFI_PRINT("%4u: \"%ls\"\n", idx + 1, ucs2->string_text);
199 stbl->strings[idx].string =
200 u16_strdup(ucs2->string_text);
201 if (!stbl->strings[idx].string) {
202 ret = EFI_OUT_OF_RESOURCES;
206 /* FIXME: accessing u16 * here */
207 block = efi_hii_sibt_string_ucs2_block_next(ucs2);
210 case EFI_HII_SIBT_END:
213 EFI_PRINT("unknown HII string block type: %02x\n",
215 ret = EFI_INVALID_PARAMETER;
221 list_add(&stbl->link, &hii->string_tables);
222 if (hii->max_string_id < nstrings)
223 hii->max_string_id = nstrings;
229 free(stbl->language);
231 free(stbl->strings[--idx].string);
239 static void remove_guid_package(struct efi_hii_packagelist *hii)
241 struct efi_guid_data *data;
243 while (!list_empty(&hii->guid_list)) {
244 data = list_first_entry(&hii->guid_list,
245 struct efi_guid_data, link);
246 list_del(&data->link);
252 add_guid_package(struct efi_hii_packagelist *hii,
253 struct efi_hii_guid_package *package)
255 struct efi_guid_data *data;
257 data = calloc(sizeof(*data), 1);
259 return EFI_OUT_OF_RESOURCES;
261 /* TODO: we don't know any about data field */
262 memcpy(&data->package, package, sizeof(*package));
263 list_add_tail(&data->link, &hii->guid_list);
268 static void free_keyboard_layouts(struct efi_keyboard_package_data *package)
270 struct efi_keyboard_layout_data *layout_data;
272 while (!list_empty(&package->keyboard_layout_list)) {
273 layout_data = list_first_entry(&package->keyboard_layout_list,
274 struct efi_keyboard_layout_data,
276 list_del(&layout_data->link);
277 list_del(&layout_data->link_sys);
282 static void remove_keyboard_package(struct efi_hii_packagelist *hii)
284 struct efi_keyboard_package_data *package;
286 while (!list_empty(&hii->keyboard_packages)) {
287 package = list_first_entry(&hii->keyboard_packages,
288 struct efi_keyboard_package_data,
290 free_keyboard_layouts(package);
291 list_del(&package->link);
297 add_keyboard_package(struct efi_hii_packagelist *hii,
298 struct efi_hii_keyboard_package *keyboard_package)
300 struct efi_keyboard_package_data *package_data;
301 struct efi_hii_keyboard_layout *layout;
302 struct efi_keyboard_layout_data *layout_data;
303 u16 layout_count, layout_length;
306 package_data = malloc(sizeof(*package_data));
308 return EFI_OUT_OF_RESOURCES;
309 INIT_LIST_HEAD(&package_data->link);
310 INIT_LIST_HEAD(&package_data->keyboard_layout_list);
312 layout = &keyboard_package->layout[0];
313 layout_count = get_unaligned_le16(&keyboard_package->layout_count);
314 for (i = 0; i < layout_count; i++) {
315 layout_length = get_unaligned_le16(&layout->layout_length);
316 layout_data = malloc(sizeof(*layout_data) + layout_length);
320 memcpy(&layout_data->keyboard_layout, layout, layout_length);
321 list_add_tail(&layout_data->link,
322 &package_data->keyboard_layout_list);
323 list_add_tail(&layout_data->link_sys,
324 &efi_keyboard_layout_list);
326 layout += layout_length;
329 list_add_tail(&package_data->link, &hii->keyboard_packages);
334 free_keyboard_layouts(package_data);
337 return EFI_OUT_OF_RESOURCES;
340 static struct efi_hii_packagelist *new_packagelist(void)
342 struct efi_hii_packagelist *hii;
344 hii = malloc(sizeof(*hii));
345 list_add_tail(&hii->link, &efi_package_lists);
346 hii->max_string_id = 0;
347 INIT_LIST_HEAD(&hii->string_tables);
348 INIT_LIST_HEAD(&hii->guid_list);
349 INIT_LIST_HEAD(&hii->keyboard_packages);
354 static void free_packagelist(struct efi_hii_packagelist *hii)
356 remove_strings_package(hii);
357 remove_guid_package(hii);
358 remove_keyboard_package(hii);
360 list_del(&hii->link);
365 add_packages(struct efi_hii_packagelist *hii,
366 const struct efi_hii_package_list_header *package_list)
368 struct efi_hii_package_header *package;
370 efi_status_t ret = EFI_SUCCESS;
372 end = ((void *)package_list)
373 + get_unaligned_le32(&package_list->package_length);
375 EFI_PRINT("package_list: %pUl (%u)\n", &package_list->package_list_guid,
376 get_unaligned_le32(&package_list->package_length));
378 package = ((void *)package_list) + sizeof(*package_list);
379 while ((void *)package < end) {
380 EFI_PRINT("package=%p, package type=%x, length=%u\n", package,
381 efi_hii_package_type(package),
382 efi_hii_package_len(package));
384 switch (efi_hii_package_type(package)) {
385 case EFI_HII_PACKAGE_TYPE_GUID:
386 ret = add_guid_package(hii,
387 (struct efi_hii_guid_package *)package);
389 case EFI_HII_PACKAGE_FORMS:
390 EFI_PRINT("Form package not supported\n");
391 ret = EFI_INVALID_PARAMETER;
393 case EFI_HII_PACKAGE_STRINGS:
394 ret = add_strings_package(hii,
395 (struct efi_hii_strings_package *)package);
397 case EFI_HII_PACKAGE_FONTS:
398 EFI_PRINT("Font package not supported\n");
399 ret = EFI_INVALID_PARAMETER;
401 case EFI_HII_PACKAGE_IMAGES:
402 EFI_PRINT("Image package not supported\n");
403 ret = EFI_INVALID_PARAMETER;
405 case EFI_HII_PACKAGE_SIMPLE_FONTS:
406 EFI_PRINT("Simple font package not supported\n");
407 ret = EFI_INVALID_PARAMETER;
409 case EFI_HII_PACKAGE_DEVICE_PATH:
410 EFI_PRINT("Device path package not supported\n");
411 ret = EFI_INVALID_PARAMETER;
413 case EFI_HII_PACKAGE_KEYBOARD_LAYOUT:
414 ret = add_keyboard_package(hii,
415 (struct efi_hii_keyboard_package *)package);
417 case EFI_HII_PACKAGE_ANIMATIONS:
418 EFI_PRINT("Animation package not supported\n");
419 ret = EFI_INVALID_PARAMETER;
421 case EFI_HII_PACKAGE_END:
423 case EFI_HII_PACKAGE_TYPE_SYSTEM_BEGIN:
424 case EFI_HII_PACKAGE_TYPE_SYSTEM_END:
429 if (ret != EFI_SUCCESS)
432 package = (void *)package + efi_hii_package_len(package);
435 // TODO in theory there is some notifications that should be sent..
440 * EFI_HII_DATABASE_PROTOCOL
443 static efi_status_t EFIAPI
444 new_package_list(const struct efi_hii_database_protocol *this,
445 const struct efi_hii_package_list_header *package_list,
446 const efi_handle_t driver_handle,
447 efi_hii_handle_t *handle)
449 struct efi_hii_packagelist *hii;
452 EFI_ENTRY("%p, %p, %p, %p", this, package_list, driver_handle, handle);
454 if (!package_list || !handle)
455 return EFI_EXIT(EFI_INVALID_PARAMETER);
457 hii = new_packagelist();
459 return EFI_EXIT(EFI_OUT_OF_RESOURCES);
461 ret = add_packages(hii, package_list);
462 if (ret != EFI_SUCCESS) {
463 free_packagelist(hii);
464 return EFI_EXIT(ret);
467 hii->driver_handle = driver_handle;
470 return EFI_EXIT(EFI_SUCCESS);
473 static efi_status_t EFIAPI
474 remove_package_list(const struct efi_hii_database_protocol *this,
475 efi_hii_handle_t handle)
477 struct efi_hii_packagelist *hii = handle;
479 EFI_ENTRY("%p, %p", this, handle);
481 if (!handle || !efi_hii_packagelist_exists(handle))
482 return EFI_EXIT(EFI_NOT_FOUND);
484 free_packagelist(hii);
486 return EFI_EXIT(EFI_SUCCESS);
489 static efi_status_t EFIAPI
490 update_package_list(const struct efi_hii_database_protocol *this,
491 efi_hii_handle_t handle,
492 const struct efi_hii_package_list_header *package_list)
494 struct efi_hii_packagelist *hii = handle;
495 struct efi_hii_package_header *package;
497 efi_status_t ret = EFI_SUCCESS;
499 EFI_ENTRY("%p, %p, %p", this, handle, package_list);
501 if (!handle || !efi_hii_packagelist_exists(handle))
502 return EFI_EXIT(EFI_NOT_FOUND);
505 return EFI_EXIT(EFI_INVALID_PARAMETER);
507 EFI_PRINT("package_list: %pUl (%u)\n", &package_list->package_list_guid,
508 get_unaligned_le32(&package_list->package_length));
510 package = ((void *)package_list) + sizeof(*package_list);
511 end = ((void *)package_list)
512 + get_unaligned_le32(&package_list->package_length);
514 while ((void *)package < end) {
515 EFI_PRINT("package=%p, package type=%x, length=%u\n", package,
516 efi_hii_package_type(package),
517 efi_hii_package_len(package));
519 switch (efi_hii_package_type(package)) {
520 case EFI_HII_PACKAGE_TYPE_GUID:
521 remove_guid_package(hii);
523 case EFI_HII_PACKAGE_FORMS:
524 EFI_PRINT("Form package not supported\n");
525 ret = EFI_INVALID_PARAMETER;
527 case EFI_HII_PACKAGE_STRINGS:
528 remove_strings_package(hii);
530 case EFI_HII_PACKAGE_FONTS:
531 EFI_PRINT("Font package not supported\n");
532 ret = EFI_INVALID_PARAMETER;
534 case EFI_HII_PACKAGE_IMAGES:
535 EFI_PRINT("Image package not supported\n");
536 ret = EFI_INVALID_PARAMETER;
538 case EFI_HII_PACKAGE_SIMPLE_FONTS:
539 EFI_PRINT("Simple font package not supported\n");
540 ret = EFI_INVALID_PARAMETER;
542 case EFI_HII_PACKAGE_DEVICE_PATH:
543 EFI_PRINT("Device path package not supported\n");
544 ret = EFI_INVALID_PARAMETER;
546 case EFI_HII_PACKAGE_KEYBOARD_LAYOUT:
547 remove_keyboard_package(hii);
549 case EFI_HII_PACKAGE_ANIMATIONS:
550 EFI_PRINT("Animation package not supported\n");
551 ret = EFI_INVALID_PARAMETER;
553 case EFI_HII_PACKAGE_END:
555 case EFI_HII_PACKAGE_TYPE_SYSTEM_BEGIN:
556 case EFI_HII_PACKAGE_TYPE_SYSTEM_END:
561 /* TODO: already removed some packages */
562 if (ret != EFI_SUCCESS)
563 return EFI_EXIT(ret);
565 package = ((void *)package)
566 + efi_hii_package_len(package);
569 ret = add_packages(hii, package_list);
571 return EFI_EXIT(ret);
574 static efi_status_t EFIAPI
575 list_package_lists(const struct efi_hii_database_protocol *this,
577 const efi_guid_t *package_guid,
578 efi_uintn_t *handle_buffer_length,
579 efi_hii_handle_t *handle)
581 struct efi_hii_packagelist *hii =
582 (struct efi_hii_packagelist *)handle;
583 int package_cnt, package_max;
584 efi_status_t ret = EFI_SUCCESS;
586 EFI_ENTRY("%p, %u, %pUl, %p, %p", this, package_type, package_guid,
587 handle_buffer_length, handle);
589 if (!handle_buffer_length ||
590 (*handle_buffer_length && !handle))
591 return EFI_EXIT(EFI_INVALID_PARAMETER);
593 if ((package_type != EFI_HII_PACKAGE_TYPE_GUID && package_guid) ||
594 (package_type == EFI_HII_PACKAGE_TYPE_GUID && !package_guid))
595 return EFI_EXIT(EFI_INVALID_PARAMETER);
597 EFI_PRINT("package type=%x, guid=%pUl, length=%zu\n", (int)package_type,
598 package_guid, *handle_buffer_length);
601 package_max = *handle_buffer_length / sizeof(*handle);
602 list_for_each_entry(hii, &efi_package_lists, link) {
603 switch (package_type) {
604 case EFI_HII_PACKAGE_TYPE_ALL:
606 case EFI_HII_PACKAGE_TYPE_GUID:
607 if (!list_empty(&hii->guid_list))
610 case EFI_HII_PACKAGE_FORMS:
611 EFI_PRINT("Form package not supported\n");
612 ret = EFI_INVALID_PARAMETER;
614 case EFI_HII_PACKAGE_STRINGS:
615 if (!list_empty(&hii->string_tables))
618 case EFI_HII_PACKAGE_FONTS:
619 EFI_PRINT("Font package not supported\n");
620 ret = EFI_INVALID_PARAMETER;
622 case EFI_HII_PACKAGE_IMAGES:
623 EFI_PRINT("Image package not supported\n");
624 ret = EFI_INVALID_PARAMETER;
626 case EFI_HII_PACKAGE_SIMPLE_FONTS:
627 EFI_PRINT("Simple font package not supported\n");
628 ret = EFI_INVALID_PARAMETER;
630 case EFI_HII_PACKAGE_DEVICE_PATH:
631 EFI_PRINT("Device path package not supported\n");
632 ret = EFI_INVALID_PARAMETER;
634 case EFI_HII_PACKAGE_KEYBOARD_LAYOUT:
635 if (!list_empty(&hii->keyboard_packages))
638 case EFI_HII_PACKAGE_ANIMATIONS:
639 EFI_PRINT("Animation package not supported\n");
640 ret = EFI_INVALID_PARAMETER;
642 case EFI_HII_PACKAGE_END:
643 case EFI_HII_PACKAGE_TYPE_SYSTEM_BEGIN:
644 case EFI_HII_PACKAGE_TYPE_SYSTEM_END:
650 if (package_cnt <= package_max)
653 ret = EFI_BUFFER_TOO_SMALL;
655 *handle_buffer_length = package_cnt * sizeof(*handle);
657 return EFI_EXIT(ret);
660 static efi_status_t EFIAPI
661 export_package_lists(const struct efi_hii_database_protocol *this,
662 efi_hii_handle_t handle,
663 efi_uintn_t *buffer_size,
664 struct efi_hii_package_list_header *buffer)
666 EFI_ENTRY("%p, %p, %p, %p", this, handle, buffer_size, buffer);
668 if (!buffer_size || !buffer)
669 return EFI_EXIT(EFI_INVALID_PARAMETER);
671 return EFI_EXIT(EFI_NOT_FOUND);
674 static efi_status_t EFIAPI
675 register_package_notify(const struct efi_hii_database_protocol *this,
677 const efi_guid_t *package_guid,
678 const void *package_notify_fn,
679 efi_uintn_t notify_type,
680 efi_handle_t *notify_handle)
682 EFI_ENTRY("%p, %u, %pUl, %p, %zu, %p", this, package_type,
683 package_guid, package_notify_fn, notify_type,
687 return EFI_EXIT(EFI_INVALID_PARAMETER);
689 if ((package_type != EFI_HII_PACKAGE_TYPE_GUID && package_guid) ||
690 (package_type == EFI_HII_PACKAGE_TYPE_GUID && !package_guid))
691 return EFI_EXIT(EFI_INVALID_PARAMETER);
693 return EFI_EXIT(EFI_OUT_OF_RESOURCES);
696 static efi_status_t EFIAPI
697 unregister_package_notify(const struct efi_hii_database_protocol *this,
698 efi_handle_t notification_handle)
700 EFI_ENTRY("%p, %p", this, notification_handle);
702 return EFI_EXIT(EFI_NOT_FOUND);
705 static efi_status_t EFIAPI
706 find_keyboard_layouts(const struct efi_hii_database_protocol *this,
707 u16 *key_guid_buffer_length,
708 efi_guid_t *key_guid_buffer)
710 struct efi_keyboard_layout_data *layout_data;
711 int package_cnt, package_max;
712 efi_status_t ret = EFI_SUCCESS;
714 EFI_ENTRY("%p, %p, %p", this, key_guid_buffer_length, key_guid_buffer);
716 if (!key_guid_buffer_length ||
717 (*key_guid_buffer_length && !key_guid_buffer))
718 return EFI_EXIT(EFI_INVALID_PARAMETER);
721 package_max = *key_guid_buffer_length / sizeof(*key_guid_buffer);
722 list_for_each_entry(layout_data, &efi_keyboard_layout_list, link_sys) {
724 if (package_cnt <= package_max)
725 memcpy(key_guid_buffer++,
726 &layout_data->keyboard_layout.guid,
727 sizeof(*key_guid_buffer));
729 ret = EFI_BUFFER_TOO_SMALL;
731 *key_guid_buffer_length = package_cnt * sizeof(*key_guid_buffer);
733 return EFI_EXIT(ret);
736 static efi_status_t EFIAPI
737 get_keyboard_layout(const struct efi_hii_database_protocol *this,
738 efi_guid_t *key_guid,
739 u16 *keyboard_layout_length,
740 struct efi_hii_keyboard_layout *keyboard_layout)
742 struct efi_keyboard_layout_data *layout_data;
745 EFI_ENTRY("%p, %pUl, %p, %p", this, key_guid, keyboard_layout_length,
748 if (!keyboard_layout_length ||
749 (*keyboard_layout_length && !keyboard_layout))
750 return EFI_EXIT(EFI_INVALID_PARAMETER);
752 /* TODO: no notion of current keyboard layout */
754 return EFI_EXIT(EFI_INVALID_PARAMETER);
756 list_for_each_entry(layout_data, &efi_keyboard_layout_list, link_sys) {
757 if (!guidcmp(&layout_data->keyboard_layout.guid, key_guid))
761 return EFI_EXIT(EFI_NOT_FOUND);
765 get_unaligned_le16(&layout_data->keyboard_layout.layout_length);
766 if (*keyboard_layout_length < layout_length) {
767 *keyboard_layout_length = layout_length;
768 return EFI_EXIT(EFI_BUFFER_TOO_SMALL);
771 memcpy(keyboard_layout, &layout_data->keyboard_layout, layout_length);
773 return EFI_EXIT(EFI_SUCCESS);
776 static efi_status_t EFIAPI
777 set_keyboard_layout(const struct efi_hii_database_protocol *this,
778 efi_guid_t *key_guid)
780 EFI_ENTRY("%p, %pUl", this, key_guid);
782 return EFI_EXIT(EFI_NOT_FOUND);
785 static efi_status_t EFIAPI
786 get_package_list_handle(const struct efi_hii_database_protocol *this,
787 efi_hii_handle_t package_list_handle,
788 efi_handle_t *driver_handle)
790 struct efi_hii_packagelist *hii;
792 EFI_ENTRY("%p, %p, %p", this, package_list_handle, driver_handle);
795 return EFI_EXIT(EFI_INVALID_PARAMETER);
797 list_for_each_entry(hii, &efi_package_lists, link) {
798 if (hii == package_list_handle) {
799 *driver_handle = hii->driver_handle;
800 return EFI_EXIT(EFI_SUCCESS);
804 return EFI_EXIT(EFI_NOT_FOUND);
807 const struct efi_hii_database_protocol efi_hii_database = {
808 .new_package_list = new_package_list,
809 .remove_package_list = remove_package_list,
810 .update_package_list = update_package_list,
811 .list_package_lists = list_package_lists,
812 .export_package_lists = export_package_lists,
813 .register_package_notify = register_package_notify,
814 .unregister_package_notify = unregister_package_notify,
815 .find_keyboard_layouts = find_keyboard_layouts,
816 .get_keyboard_layout = get_keyboard_layout,
817 .set_keyboard_layout = set_keyboard_layout,
818 .get_package_list_handle = get_package_list_handle
822 * EFI_HII_STRING_PROTOCOL
825 static bool language_match(char *language, char *languages)
829 n = strlen(language);
830 /* match primary language? */
831 if (!strncasecmp(language, languages, n) &&
832 (languages[n] == ';' || languages[n] == '\0'))
838 static efi_status_t EFIAPI
839 new_string(const struct efi_hii_string_protocol *this,
840 efi_hii_handle_t package_list,
841 efi_string_id_t *string_id,
843 const u16 *language_name,
844 const efi_string_t string,
845 const struct efi_font_info *string_font_info)
847 struct efi_hii_packagelist *hii = package_list;
848 struct efi_string_table *stbl;
850 EFI_ENTRY("%p, %p, %p, \"%s\", %p, \"%ls\", %p", this, package_list,
851 string_id, language, language_name, string,
854 if (!package_list || !efi_hii_packagelist_exists(package_list))
855 return EFI_EXIT(EFI_NOT_FOUND);
857 if (!string_id || !language || !string)
858 return EFI_EXIT(EFI_INVALID_PARAMETER);
860 list_for_each_entry(stbl, &hii->string_tables, link) {
861 if (language_match((char *)language, stbl->language)) {
862 efi_string_id_t new_id;
866 new_id = ++hii->max_string_id;
867 if (stbl->nstrings < new_id) {
868 buf = realloc(stbl->strings,
869 sizeof(stbl->strings[0])
872 return EFI_EXIT(EFI_OUT_OF_RESOURCES);
874 memset(&stbl->strings[stbl->nstrings], 0,
875 (new_id - stbl->nstrings)
876 * sizeof(stbl->strings[0]));
878 stbl->nstrings = new_id;
881 str = u16_strdup(string);
883 return EFI_EXIT(EFI_OUT_OF_RESOURCES);
885 stbl->strings[new_id - 1].string = str;
888 return EFI_EXIT(EFI_SUCCESS);
892 return EFI_EXIT(EFI_NOT_FOUND);
895 static efi_status_t EFIAPI
896 get_string(const struct efi_hii_string_protocol *this,
898 efi_hii_handle_t package_list,
899 efi_string_id_t string_id,
901 efi_uintn_t *string_size,
902 struct efi_font_info **string_font_info)
904 struct efi_hii_packagelist *hii = package_list;
905 struct efi_string_table *stbl;
907 EFI_ENTRY("%p, \"%s\", %p, %u, %p, %p, %p", this, language,
908 package_list, string_id, string, string_size,
911 if (!package_list || !efi_hii_packagelist_exists(package_list))
912 return EFI_EXIT(EFI_NOT_FOUND);
914 list_for_each_entry(stbl, &hii->string_tables, link) {
915 if (language_match((char *)language, stbl->language)) {
919 if (stbl->nstrings < string_id)
920 return EFI_EXIT(EFI_NOT_FOUND);
922 str = stbl->strings[string_id - 1].string;
924 len = (u16_strlen(str) + 1) * sizeof(u16);
925 if (*string_size < len) {
928 return EFI_EXIT(EFI_BUFFER_TOO_SMALL);
930 memcpy(string, str, len);
933 return EFI_EXIT(EFI_NOT_FOUND);
936 return EFI_EXIT(EFI_SUCCESS);
940 return EFI_EXIT(EFI_NOT_FOUND);
943 static efi_status_t EFIAPI
944 set_string(const struct efi_hii_string_protocol *this,
945 efi_hii_handle_t package_list,
946 efi_string_id_t string_id,
948 const efi_string_t string,
949 const struct efi_font_info *string_font_info)
951 struct efi_hii_packagelist *hii = package_list;
952 struct efi_string_table *stbl;
954 EFI_ENTRY("%p, %p, %u, \"%s\", \"%ls\", %p", this, package_list,
955 string_id, language, string, string_font_info);
957 if (!package_list || !efi_hii_packagelist_exists(package_list))
958 return EFI_EXIT(EFI_NOT_FOUND);
960 if (string_id > hii->max_string_id)
961 return EFI_EXIT(EFI_NOT_FOUND);
963 if (!string || !language)
964 return EFI_EXIT(EFI_INVALID_PARAMETER);
966 list_for_each_entry(stbl, &hii->string_tables, link) {
967 if (language_match((char *)language, stbl->language)) {
970 if (hii->max_string_id < string_id)
971 return EFI_EXIT(EFI_NOT_FOUND);
973 if (stbl->nstrings < string_id) {
976 buf = realloc(stbl->strings,
978 * sizeof(stbl->strings[0]));
980 return EFI_EXIT(EFI_OUT_OF_RESOURCES);
982 memset(&stbl->strings[string_id - 1], 0,
983 (string_id - stbl->nstrings)
984 * sizeof(stbl->strings[0]));
988 str = u16_strdup(string);
990 return EFI_EXIT(EFI_OUT_OF_RESOURCES);
992 free(stbl->strings[string_id - 1].string);
993 stbl->strings[string_id - 1].string = str;
995 return EFI_EXIT(EFI_SUCCESS);
999 return EFI_EXIT(EFI_NOT_FOUND);
1002 static efi_status_t EFIAPI
1003 get_languages(const struct efi_hii_string_protocol *this,
1004 efi_hii_handle_t package_list,
1006 efi_uintn_t *languages_size)
1008 struct efi_hii_packagelist *hii = package_list;
1009 struct efi_string_table *stbl;
1013 EFI_ENTRY("%p, %p, %p, %p", this, package_list, languages,
1016 if (!package_list || !efi_hii_packagelist_exists(package_list))
1017 return EFI_EXIT(EFI_NOT_FOUND);
1019 if (!languages_size ||
1020 (*languages_size && !languages))
1021 return EFI_EXIT(EFI_INVALID_PARAMETER);
1023 /* figure out required size: */
1024 list_for_each_entry(stbl, &hii->string_tables, link) {
1025 len += strlen((char *)stbl->language) + 1;
1028 if (*languages_size < len) {
1029 *languages_size = len;
1031 return EFI_EXIT(EFI_BUFFER_TOO_SMALL);
1034 p = (char *)languages;
1035 list_for_each_entry(stbl, &hii->string_tables, link) {
1036 if (p != (char *)languages)
1038 strcpy(p, stbl->language);
1039 p += strlen((char *)stbl->language);
1043 EFI_PRINT("languages: %s\n", languages);
1045 return EFI_EXIT(EFI_SUCCESS);
1048 static efi_status_t EFIAPI
1049 get_secondary_languages(const struct efi_hii_string_protocol *this,
1050 efi_hii_handle_t package_list,
1051 const u8 *primary_language,
1052 u8 *secondary_languages,
1053 efi_uintn_t *secondary_languages_size)
1055 struct efi_hii_packagelist *hii = package_list;
1056 struct efi_string_table *stbl;
1059 EFI_ENTRY("%p, %p, \"%s\", %p, %p", this, package_list,
1060 primary_language, secondary_languages,
1061 secondary_languages_size);
1063 if (!package_list || !efi_hii_packagelist_exists(package_list))
1064 return EFI_EXIT(EFI_NOT_FOUND);
1066 if (!secondary_languages_size ||
1067 (*secondary_languages_size && !secondary_languages))
1068 return EFI_EXIT(EFI_INVALID_PARAMETER);
1070 list_for_each_entry(stbl, &hii->string_tables, link) {
1071 if (language_match((char *)primary_language, stbl->language)) {
1077 return EFI_EXIT(EFI_INVALID_LANGUAGE);
1080 * TODO: What is secondary language?
1081 * *secondary_languages = '\0';
1082 * *secondary_languages_size = 0;
1085 return EFI_EXIT(EFI_NOT_FOUND);
1088 const struct efi_hii_string_protocol efi_hii_string = {
1089 .new_string = new_string,
1090 .get_string = get_string,
1091 .set_string = set_string,
1092 .get_languages = get_languages,
1093 .get_secondary_languages = get_secondary_languages