xref: /openbmc/u-boot/lib/efi_loader/efi_hii.c (revision 9ba5e5bc) 
1 // SPDX-License-Identifier:     GPL-2.0+
2 /*
3  *  EFI Human Interface Infrastructure ... database and packages
4  *
5  *  Copyright (c) 2017 Leif Lindholm
6  *  Copyright (c) 2018 AKASHI Takahiro, Linaro Limited
7  */
8 
9 #include <common.h>
10 #include <efi_loader.h>
11 #include <malloc.h>
12 #include <asm/unaligned.h>
13 
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;
17 
18 static LIST_HEAD(efi_package_lists);
19 static LIST_HEAD(efi_keyboard_layout_list);
20 
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;
25 	u32 max_string_id;
26 	struct list_head string_tables;     /* list of efi_string_table */
27 	struct list_head guid_list;
28 	struct list_head keyboard_packages;
29 
30 	/* we could also track fonts, images, etc */
31 };
32 
33 static int efi_hii_packagelist_exists(efi_hii_handle_t package_list)
34 {
35 	struct efi_hii_packagelist *hii;
36 	int found = 0;
37 
38 	list_for_each_entry(hii, &efi_package_lists, link) {
39 		if (hii == package_list) {
40 			found = 1;
41 			break;
42 		}
43 	}
44 
45 	return found;
46 }
47 
48 static u32 efi_hii_package_type(struct efi_hii_package_header *header)
49 {
50 	u32 fields;
51 
52 	fields = get_unaligned_le32(&header->fields);
53 
54 	return (fields >> __EFI_HII_PACKAGE_TYPE_SHIFT)
55 		& __EFI_HII_PACKAGE_TYPE_MASK;
56 }
57 
58 static u32 efi_hii_package_len(struct efi_hii_package_header *header)
59 {
60 	u32 fields;
61 
62 	fields = get_unaligned_le32(&header->fields);
63 
64 	return (fields >> __EFI_HII_PACKAGE_LEN_SHIFT)
65 		& __EFI_HII_PACKAGE_LEN_MASK;
66 }
67 
68 struct efi_string_info {
69 	efi_string_t string;
70 	/* we could also track font info, etc */
71 };
72 
73 struct efi_string_table {
74 	struct list_head link;
75 	efi_string_id_t language_name;
76 	char *language;
77 	u32 nstrings;
78 	/*
79 	 * NOTE:
80 	 *  string id starts at 1 so value is stbl->strings[id-1],
81 	 *  and strings[] is a array of stbl->nstrings elements
82 	 */
83 	struct efi_string_info *strings;
84 };
85 
86 struct efi_guid_data {
87 	struct list_head link;
88 	struct efi_hii_guid_package package;
89 };
90 
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;
95 };
96 
97 struct efi_keyboard_package_data {
98 	struct list_head link;		/* in package_list */
99 	struct list_head keyboard_layout_list;
100 };
101 
102 static void free_strings_table(struct efi_string_table *stbl)
103 {
104 	int i;
105 
106 	for (i = 0; i < stbl->nstrings; i++)
107 		free(stbl->strings[i].string);
108 	free(stbl->strings);
109 	free(stbl->language);
110 	free(stbl);
111 }
112 
113 static void remove_strings_package(struct efi_hii_packagelist *hii)
114 {
115 	while (!list_empty(&hii->string_tables)) {
116 		struct efi_string_table *stbl;
117 
118 		stbl = list_first_entry(&hii->string_tables,
119 					struct efi_string_table, link);
120 		list_del(&stbl->link);
121 		free_strings_table(stbl);
122 	}
123 }
124 
125 static efi_status_t
126 add_strings_package(struct efi_hii_packagelist *hii,
127 		    struct efi_hii_strings_package *strings_package)
128 {
129 	struct efi_hii_string_block *block;
130 	void *end;
131 	u32 nstrings = 0, idx = 0;
132 	struct efi_string_table *stbl = NULL;
133 	efi_status_t ret;
134 
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);
142 
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);
148 
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;
153 
154 			ucs2 = (void *)block;
155 			nstrings++;
156 			block = efi_hii_sibt_string_ucs2_block_next(ucs2);
157 			break;
158 		}
159 		case EFI_HII_SIBT_END:
160 			block = end;
161 			break;
162 		default:
163 			EFI_PRINT("unknown HII string block type: %02x\n",
164 				  block->block_type);
165 			return EFI_INVALID_PARAMETER;
166 		}
167 	}
168 
169 	stbl = calloc(sizeof(*stbl), 1);
170 	if (!stbl) {
171 		ret = EFI_OUT_OF_RESOURCES;
172 		goto error;
173 	}
174 	stbl->strings = calloc(sizeof(stbl->strings[0]), nstrings);
175 	if (!stbl->strings) {
176 		ret = EFI_OUT_OF_RESOURCES;
177 		goto error;
178 	}
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;
184 		goto error;
185 	}
186 	stbl->nstrings = nstrings;
187 
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);
191 
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;
196 
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;
203 				goto error;
204 			}
205 			idx++;
206 			/* FIXME: accessing u16 * here */
207 			block = efi_hii_sibt_string_ucs2_block_next(ucs2);
208 			break;
209 		}
210 		case EFI_HII_SIBT_END:
211 			goto out;
212 		default:
213 			EFI_PRINT("unknown HII string block type: %02x\n",
214 				  block->block_type);
215 			ret = EFI_INVALID_PARAMETER;
216 			goto error;
217 		}
218 	}
219 
220 out:
221 	list_add(&stbl->link, &hii->string_tables);
222 	if (hii->max_string_id < nstrings)
223 		hii->max_string_id = nstrings;
224 
225 	return EFI_SUCCESS;
226 
227 error:
228 	if (stbl) {
229 		free(stbl->language);
230 		if (idx > 0)
231 			while (--idx >= 0)
232 				free(stbl->strings[idx].string);
233 		free(stbl->strings);
234 	}
235 	free(stbl);
236 
237 	return ret;
238 }
239 
240 static void remove_guid_package(struct efi_hii_packagelist *hii)
241 {
242 	struct efi_guid_data *data;
243 
244 	while (!list_empty(&hii->guid_list)) {
245 		data = list_first_entry(&hii->guid_list,
246 					struct efi_guid_data, link);
247 		list_del(&data->link);
248 		free(data);
249 	}
250 }
251 
252 static efi_status_t
253 add_guid_package(struct efi_hii_packagelist *hii,
254 		 struct efi_hii_guid_package *package)
255 {
256 	struct efi_guid_data *data;
257 
258 	data = calloc(sizeof(*data), 1);
259 	if (!data)
260 		return EFI_OUT_OF_RESOURCES;
261 
262 	/* TODO: we don't know any about data field */
263 	memcpy(&data->package, package, sizeof(*package));
264 	list_add_tail(&data->link, &hii->guid_list);
265 
266 	return EFI_SUCCESS;
267 }
268 
269 static void free_keyboard_layouts(struct efi_keyboard_package_data *package)
270 {
271 	struct efi_keyboard_layout_data *layout_data;
272 
273 	while (!list_empty(&package->keyboard_layout_list)) {
274 		layout_data = list_first_entry(&package->keyboard_layout_list,
275 					       struct efi_keyboard_layout_data,
276 					       link);
277 		list_del(&layout_data->link);
278 		list_del(&layout_data->link_sys);
279 		free(layout_data);
280 	}
281 }
282 
283 static void remove_keyboard_package(struct efi_hii_packagelist *hii)
284 {
285 	struct efi_keyboard_package_data *package;
286 
287 	while (!list_empty(&hii->keyboard_packages)) {
288 		package = list_first_entry(&hii->keyboard_packages,
289 					   struct efi_keyboard_package_data,
290 					   link);
291 		free_keyboard_layouts(package);
292 		list_del(&package->link);
293 		free(package);
294 	}
295 }
296 
297 static efi_status_t
298 add_keyboard_package(struct efi_hii_packagelist *hii,
299 		     struct efi_hii_keyboard_package *keyboard_package)
300 {
301 	struct efi_keyboard_package_data *package_data;
302 	struct efi_hii_keyboard_layout *layout;
303 	struct efi_keyboard_layout_data *layout_data;
304 	u16 layout_count, layout_length;
305 	int i;
306 
307 	package_data = malloc(sizeof(*package_data));
308 	if (!package_data)
309 		return EFI_OUT_OF_RESOURCES;
310 	INIT_LIST_HEAD(&package_data->link);
311 	INIT_LIST_HEAD(&package_data->keyboard_layout_list);
312 
313 	layout = &keyboard_package->layout[0];
314 	layout_count = get_unaligned_le16(&keyboard_package->layout_count);
315 	for (i = 0; i < layout_count; i++) {
316 		layout_length = get_unaligned_le16(&layout->layout_length);
317 		layout_data = malloc(sizeof(*layout_data) + layout_length);
318 		if (!layout_data)
319 			goto out;
320 
321 		memcpy(&layout_data->keyboard_layout, layout, layout_length);
322 		list_add_tail(&layout_data->link,
323 			      &package_data->keyboard_layout_list);
324 		list_add_tail(&layout_data->link_sys,
325 			      &efi_keyboard_layout_list);
326 
327 		layout += layout_length;
328 	}
329 
330 	list_add_tail(&package_data->link, &hii->keyboard_packages);
331 
332 	return EFI_SUCCESS;
333 
334 out:
335 	free_keyboard_layouts(package_data);
336 	free(package_data);
337 
338 	return EFI_OUT_OF_RESOURCES;
339 }
340 
341 static struct efi_hii_packagelist *new_packagelist(void)
342 {
343 	struct efi_hii_packagelist *hii;
344 
345 	hii = malloc(sizeof(*hii));
346 	list_add_tail(&hii->link, &efi_package_lists);
347 	hii->max_string_id = 0;
348 	INIT_LIST_HEAD(&hii->string_tables);
349 	INIT_LIST_HEAD(&hii->guid_list);
350 	INIT_LIST_HEAD(&hii->keyboard_packages);
351 
352 	return hii;
353 }
354 
355 static void free_packagelist(struct efi_hii_packagelist *hii)
356 {
357 	remove_strings_package(hii);
358 	remove_guid_package(hii);
359 	remove_keyboard_package(hii);
360 
361 	list_del(&hii->link);
362 	free(hii);
363 }
364 
365 static efi_status_t
366 add_packages(struct efi_hii_packagelist *hii,
367 	     const struct efi_hii_package_list_header *package_list)
368 {
369 	struct efi_hii_package_header *package;
370 	void *end;
371 	efi_status_t ret = EFI_SUCCESS;
372 
373 	end = ((void *)package_list)
374 		+ get_unaligned_le32(&package_list->package_length);
375 
376 	EFI_PRINT("package_list: %pUl (%u)\n", &package_list->package_list_guid,
377 		  get_unaligned_le32(&package_list->package_length));
378 
379 	package = ((void *)package_list) + sizeof(*package_list);
380 	while ((void *)package < end) {
381 		EFI_PRINT("package=%p, package type=%x, length=%u\n", package,
382 			  efi_hii_package_type(package),
383 			  efi_hii_package_len(package));
384 
385 		switch (efi_hii_package_type(package)) {
386 		case EFI_HII_PACKAGE_TYPE_GUID:
387 			ret = add_guid_package(hii,
388 				(struct efi_hii_guid_package *)package);
389 			break;
390 		case EFI_HII_PACKAGE_FORMS:
391 			EFI_PRINT("Form package not supported\n");
392 			ret = EFI_INVALID_PARAMETER;
393 			break;
394 		case EFI_HII_PACKAGE_STRINGS:
395 			ret = add_strings_package(hii,
396 				(struct efi_hii_strings_package *)package);
397 			break;
398 		case EFI_HII_PACKAGE_FONTS:
399 			EFI_PRINT("Font package not supported\n");
400 			ret = EFI_INVALID_PARAMETER;
401 			break;
402 		case EFI_HII_PACKAGE_IMAGES:
403 			EFI_PRINT("Image package not supported\n");
404 			ret = EFI_INVALID_PARAMETER;
405 			break;
406 		case EFI_HII_PACKAGE_SIMPLE_FONTS:
407 			EFI_PRINT("Simple font package not supported\n");
408 			ret = EFI_INVALID_PARAMETER;
409 			break;
410 		case EFI_HII_PACKAGE_DEVICE_PATH:
411 			EFI_PRINT("Device path package not supported\n");
412 			ret = EFI_INVALID_PARAMETER;
413 			break;
414 		case EFI_HII_PACKAGE_KEYBOARD_LAYOUT:
415 			ret = add_keyboard_package(hii,
416 				(struct efi_hii_keyboard_package *)package);
417 			break;
418 		case EFI_HII_PACKAGE_ANIMATIONS:
419 			EFI_PRINT("Animation package not supported\n");
420 			ret = EFI_INVALID_PARAMETER;
421 			break;
422 		case EFI_HII_PACKAGE_END:
423 			goto out;
424 		case EFI_HII_PACKAGE_TYPE_SYSTEM_BEGIN:
425 		case EFI_HII_PACKAGE_TYPE_SYSTEM_END:
426 		default:
427 			break;
428 		}
429 
430 		if (ret != EFI_SUCCESS)
431 			return ret;
432 
433 		package = (void *)package + efi_hii_package_len(package);
434 	}
435 out:
436 	// TODO in theory there is some notifications that should be sent..
437 	return EFI_SUCCESS;
438 }
439 
440 /*
441  * EFI_HII_DATABASE_PROTOCOL
442  */
443 
444 static efi_status_t EFIAPI
445 new_package_list(const struct efi_hii_database_protocol *this,
446 		 const struct efi_hii_package_list_header *package_list,
447 		 const efi_handle_t driver_handle,
448 		 efi_hii_handle_t *handle)
449 {
450 	struct efi_hii_packagelist *hii;
451 	efi_status_t ret;
452 
453 	EFI_ENTRY("%p, %p, %p, %p", this, package_list, driver_handle, handle);
454 
455 	if (!package_list || !handle)
456 		return EFI_EXIT(EFI_INVALID_PARAMETER);
457 
458 	hii = new_packagelist();
459 	if (!hii)
460 		return EFI_EXIT(EFI_OUT_OF_RESOURCES);
461 
462 	ret = add_packages(hii, package_list);
463 	if (ret != EFI_SUCCESS) {
464 		free_packagelist(hii);
465 		return EFI_EXIT(ret);
466 	}
467 
468 	hii->driver_handle = driver_handle;
469 	*handle = hii;
470 
471 	return EFI_EXIT(EFI_SUCCESS);
472 }
473 
474 static efi_status_t EFIAPI
475 remove_package_list(const struct efi_hii_database_protocol *this,
476 		    efi_hii_handle_t handle)
477 {
478 	struct efi_hii_packagelist *hii = handle;
479 
480 	EFI_ENTRY("%p, %p", this, handle);
481 
482 	if (!handle || !efi_hii_packagelist_exists(handle))
483 		return EFI_EXIT(EFI_NOT_FOUND);
484 
485 	free_packagelist(hii);
486 
487 	return EFI_EXIT(EFI_SUCCESS);
488 }
489 
490 static efi_status_t EFIAPI
491 update_package_list(const struct efi_hii_database_protocol *this,
492 		    efi_hii_handle_t handle,
493 		    const struct efi_hii_package_list_header *package_list)
494 {
495 	struct efi_hii_packagelist *hii = handle;
496 	struct efi_hii_package_header *package;
497 	void *end;
498 	efi_status_t ret = EFI_SUCCESS;
499 
500 	EFI_ENTRY("%p, %p, %p", this, handle, package_list);
501 
502 	if (!handle || !efi_hii_packagelist_exists(handle))
503 		return EFI_EXIT(EFI_NOT_FOUND);
504 
505 	if (!package_list)
506 		return EFI_EXIT(EFI_INVALID_PARAMETER);
507 
508 	EFI_PRINT("package_list: %pUl (%u)\n", &package_list->package_list_guid,
509 		  get_unaligned_le32(&package_list->package_length));
510 
511 	package = ((void *)package_list) + sizeof(*package_list);
512 	end = ((void *)package_list)
513 		+ get_unaligned_le32(&package_list->package_length);
514 
515 	while ((void *)package < end) {
516 		EFI_PRINT("package=%p, package type=%x, length=%u\n", package,
517 			  efi_hii_package_type(package),
518 			  efi_hii_package_len(package));
519 
520 		switch (efi_hii_package_type(package)) {
521 		case EFI_HII_PACKAGE_TYPE_GUID:
522 			remove_guid_package(hii);
523 			break;
524 		case EFI_HII_PACKAGE_FORMS:
525 			EFI_PRINT("Form package not supported\n");
526 			ret = EFI_INVALID_PARAMETER;
527 			break;
528 		case EFI_HII_PACKAGE_STRINGS:
529 			remove_strings_package(hii);
530 			break;
531 		case EFI_HII_PACKAGE_FONTS:
532 			EFI_PRINT("Font package not supported\n");
533 			ret = EFI_INVALID_PARAMETER;
534 			break;
535 		case EFI_HII_PACKAGE_IMAGES:
536 			EFI_PRINT("Image package not supported\n");
537 			ret = EFI_INVALID_PARAMETER;
538 			break;
539 		case EFI_HII_PACKAGE_SIMPLE_FONTS:
540 			EFI_PRINT("Simple font package not supported\n");
541 			ret = EFI_INVALID_PARAMETER;
542 			break;
543 		case EFI_HII_PACKAGE_DEVICE_PATH:
544 			EFI_PRINT("Device path package not supported\n");
545 			ret = EFI_INVALID_PARAMETER;
546 			break;
547 		case EFI_HII_PACKAGE_KEYBOARD_LAYOUT:
548 			remove_keyboard_package(hii);
549 			break;
550 		case EFI_HII_PACKAGE_ANIMATIONS:
551 			EFI_PRINT("Animation package not supported\n");
552 			ret = EFI_INVALID_PARAMETER;
553 			break;
554 		case EFI_HII_PACKAGE_END:
555 			goto out;
556 		case EFI_HII_PACKAGE_TYPE_SYSTEM_BEGIN:
557 		case EFI_HII_PACKAGE_TYPE_SYSTEM_END:
558 		default:
559 			break;
560 		}
561 
562 		/* TODO: already removed some packages */
563 		if (ret != EFI_SUCCESS)
564 			return EFI_EXIT(ret);
565 
566 		package = ((void *)package)
567 			  + efi_hii_package_len(package);
568 	}
569 out:
570 	ret = add_packages(hii, package_list);
571 
572 	return EFI_EXIT(ret);
573 }
574 
575 static efi_status_t EFIAPI
576 list_package_lists(const struct efi_hii_database_protocol *this,
577 		   u8 package_type,
578 		   const efi_guid_t *package_guid,
579 		   efi_uintn_t *handle_buffer_length,
580 		   efi_hii_handle_t *handle)
581 {
582 	struct efi_hii_packagelist *hii =
583 				(struct efi_hii_packagelist *)handle;
584 	int package_cnt, package_max;
585 	efi_status_t ret = EFI_SUCCESS;
586 
587 	EFI_ENTRY("%p, %u, %pUl, %p, %p", this, package_type, package_guid,
588 		  handle_buffer_length, handle);
589 
590 	if (!handle_buffer_length ||
591 	    (*handle_buffer_length && !handle))
592 		return EFI_EXIT(EFI_INVALID_PARAMETER);
593 
594 	if ((package_type != EFI_HII_PACKAGE_TYPE_GUID && package_guid) ||
595 	    (package_type == EFI_HII_PACKAGE_TYPE_GUID && !package_guid))
596 		return EFI_EXIT(EFI_INVALID_PARAMETER);
597 
598 	EFI_PRINT("package type=%x, guid=%pUl, length=%zu\n", (int)package_type,
599 		  package_guid, *handle_buffer_length);
600 
601 	package_cnt = 0;
602 	package_max = *handle_buffer_length / sizeof(*handle);
603 	list_for_each_entry(hii, &efi_package_lists, link) {
604 		switch (package_type) {
605 		case EFI_HII_PACKAGE_TYPE_ALL:
606 			break;
607 		case EFI_HII_PACKAGE_TYPE_GUID:
608 			if (!list_empty(&hii->guid_list))
609 				break;
610 			continue;
611 		case EFI_HII_PACKAGE_FORMS:
612 			EFI_PRINT("Form package not supported\n");
613 			ret = EFI_INVALID_PARAMETER;
614 			continue;
615 		case EFI_HII_PACKAGE_STRINGS:
616 			if (!list_empty(&hii->string_tables))
617 				break;
618 			continue;
619 		case EFI_HII_PACKAGE_FONTS:
620 			EFI_PRINT("Font package not supported\n");
621 			ret = EFI_INVALID_PARAMETER;
622 			continue;
623 		case EFI_HII_PACKAGE_IMAGES:
624 			EFI_PRINT("Image package not supported\n");
625 			ret = EFI_INVALID_PARAMETER;
626 			continue;
627 		case EFI_HII_PACKAGE_SIMPLE_FONTS:
628 			EFI_PRINT("Simple font package not supported\n");
629 			ret = EFI_INVALID_PARAMETER;
630 			continue;
631 		case EFI_HII_PACKAGE_DEVICE_PATH:
632 			EFI_PRINT("Device path package not supported\n");
633 			ret = EFI_INVALID_PARAMETER;
634 			continue;
635 		case EFI_HII_PACKAGE_KEYBOARD_LAYOUT:
636 			if (!list_empty(&hii->keyboard_packages))
637 				break;
638 			continue;
639 		case EFI_HII_PACKAGE_ANIMATIONS:
640 			EFI_PRINT("Animation package not supported\n");
641 			ret = EFI_INVALID_PARAMETER;
642 			continue;
643 		case EFI_HII_PACKAGE_END:
644 		case EFI_HII_PACKAGE_TYPE_SYSTEM_BEGIN:
645 		case EFI_HII_PACKAGE_TYPE_SYSTEM_END:
646 		default:
647 			continue;
648 		}
649 
650 		package_cnt++;
651 		if (package_cnt <= package_max)
652 			*handle++ = hii;
653 		else
654 			ret = EFI_BUFFER_TOO_SMALL;
655 	}
656 	*handle_buffer_length = package_cnt * sizeof(*handle);
657 
658 	return EFI_EXIT(ret);
659 }
660 
661 static efi_status_t EFIAPI
662 export_package_lists(const struct efi_hii_database_protocol *this,
663 		     efi_hii_handle_t handle,
664 		     efi_uintn_t *buffer_size,
665 		     struct efi_hii_package_list_header *buffer)
666 {
667 	EFI_ENTRY("%p, %p, %p, %p", this, handle, buffer_size, buffer);
668 
669 	if (!buffer_size || !buffer)
670 		return EFI_EXIT(EFI_INVALID_PARAMETER);
671 
672 	return EFI_EXIT(EFI_NOT_FOUND);
673 }
674 
675 static efi_status_t EFIAPI
676 register_package_notify(const struct efi_hii_database_protocol *this,
677 			u8 package_type,
678 			const efi_guid_t *package_guid,
679 			const void *package_notify_fn,
680 			efi_uintn_t notify_type,
681 			efi_handle_t *notify_handle)
682 {
683 	EFI_ENTRY("%p, %u, %pUl, %p, %zu, %p", this, package_type,
684 		  package_guid, package_notify_fn, notify_type,
685 		  notify_handle);
686 
687 	if (!notify_handle)
688 		return EFI_EXIT(EFI_INVALID_PARAMETER);
689 
690 	if ((package_type != EFI_HII_PACKAGE_TYPE_GUID && package_guid) ||
691 	    (package_type == EFI_HII_PACKAGE_TYPE_GUID && !package_guid))
692 		return EFI_EXIT(EFI_INVALID_PARAMETER);
693 
694 	return EFI_EXIT(EFI_OUT_OF_RESOURCES);
695 }
696 
697 static efi_status_t EFIAPI
698 unregister_package_notify(const struct efi_hii_database_protocol *this,
699 			  efi_handle_t notification_handle)
700 {
701 	EFI_ENTRY("%p, %p", this, notification_handle);
702 
703 	return EFI_EXIT(EFI_NOT_FOUND);
704 }
705 
706 static efi_status_t EFIAPI
707 find_keyboard_layouts(const struct efi_hii_database_protocol *this,
708 		      u16 *key_guid_buffer_length,
709 		      efi_guid_t *key_guid_buffer)
710 {
711 	struct efi_keyboard_layout_data *layout_data;
712 	int package_cnt, package_max;
713 	efi_status_t ret = EFI_SUCCESS;
714 
715 	EFI_ENTRY("%p, %p, %p", this, key_guid_buffer_length, key_guid_buffer);
716 
717 	if (!key_guid_buffer_length ||
718 	    (*key_guid_buffer_length && !key_guid_buffer))
719 		return EFI_EXIT(EFI_INVALID_PARAMETER);
720 
721 	package_cnt = 0;
722 	package_max = *key_guid_buffer_length / sizeof(*key_guid_buffer);
723 	list_for_each_entry(layout_data, &efi_keyboard_layout_list, link_sys) {
724 		package_cnt++;
725 		if (package_cnt <= package_max)
726 			memcpy(key_guid_buffer++,
727 			       &layout_data->keyboard_layout.guid,
728 			       sizeof(*key_guid_buffer));
729 		else
730 			ret = EFI_BUFFER_TOO_SMALL;
731 	}
732 	*key_guid_buffer_length = package_cnt * sizeof(*key_guid_buffer);
733 
734 	return EFI_EXIT(ret);
735 }
736 
737 static efi_status_t EFIAPI
738 get_keyboard_layout(const struct efi_hii_database_protocol *this,
739 		    efi_guid_t *key_guid,
740 		    u16 *keyboard_layout_length,
741 		    struct efi_hii_keyboard_layout *keyboard_layout)
742 {
743 	struct efi_keyboard_layout_data *layout_data;
744 	u16 layout_length;
745 
746 	EFI_ENTRY("%p, %pUl, %p, %p", this, key_guid, keyboard_layout_length,
747 		  keyboard_layout);
748 
749 	if (!keyboard_layout_length ||
750 	    (*keyboard_layout_length && !keyboard_layout))
751 		return EFI_EXIT(EFI_INVALID_PARAMETER);
752 
753 	/* TODO: no notion of current keyboard layout */
754 	if (!key_guid)
755 		return EFI_EXIT(EFI_INVALID_PARAMETER);
756 
757 	list_for_each_entry(layout_data, &efi_keyboard_layout_list, link_sys) {
758 		if (!guidcmp(&layout_data->keyboard_layout.guid, key_guid))
759 			goto found;
760 	}
761 
762 	return EFI_EXIT(EFI_NOT_FOUND);
763 
764 found:
765 	layout_length =
766 		get_unaligned_le16(&layout_data->keyboard_layout.layout_length);
767 	if (*keyboard_layout_length < layout_length) {
768 		*keyboard_layout_length = layout_length;
769 		return EFI_EXIT(EFI_BUFFER_TOO_SMALL);
770 	}
771 
772 	memcpy(keyboard_layout, &layout_data->keyboard_layout, layout_length);
773 
774 	return EFI_EXIT(EFI_SUCCESS);
775 }
776 
777 static efi_status_t EFIAPI
778 set_keyboard_layout(const struct efi_hii_database_protocol *this,
779 		    efi_guid_t *key_guid)
780 {
781 	EFI_ENTRY("%p, %pUl", this, key_guid);
782 
783 	return EFI_EXIT(EFI_NOT_FOUND);
784 }
785 
786 static efi_status_t EFIAPI
787 get_package_list_handle(const struct efi_hii_database_protocol *this,
788 			efi_hii_handle_t package_list_handle,
789 			efi_handle_t *driver_handle)
790 {
791 	struct efi_hii_packagelist *hii;
792 
793 	EFI_ENTRY("%p, %p, %p", this, package_list_handle, driver_handle);
794 
795 	if (!driver_handle)
796 		return EFI_EXIT(EFI_INVALID_PARAMETER);
797 
798 	list_for_each_entry(hii, &efi_package_lists, link) {
799 		if (hii == package_list_handle) {
800 			*driver_handle = hii->driver_handle;
801 			return EFI_EXIT(EFI_SUCCESS);
802 		}
803 	}
804 
805 	return EFI_EXIT(EFI_NOT_FOUND);
806 }
807 
808 const struct efi_hii_database_protocol efi_hii_database = {
809 	.new_package_list = new_package_list,
810 	.remove_package_list = remove_package_list,
811 	.update_package_list = update_package_list,
812 	.list_package_lists = list_package_lists,
813 	.export_package_lists = export_package_lists,
814 	.register_package_notify = register_package_notify,
815 	.unregister_package_notify = unregister_package_notify,
816 	.find_keyboard_layouts = find_keyboard_layouts,
817 	.get_keyboard_layout = get_keyboard_layout,
818 	.set_keyboard_layout = set_keyboard_layout,
819 	.get_package_list_handle = get_package_list_handle
820 };
821 
822 /*
823  * EFI_HII_STRING_PROTOCOL
824  */
825 
826 static bool language_match(char *language, char *languages)
827 {
828 	size_t n;
829 
830 	n = strlen(language);
831 	/* match primary language? */
832 	if (!strncasecmp(language, languages, n) &&
833 	    (languages[n] == ';' || languages[n] == '\0'))
834 		return true;
835 
836 	return false;
837 }
838 
839 static efi_status_t EFIAPI
840 new_string(const struct efi_hii_string_protocol *this,
841 	   efi_hii_handle_t package_list,
842 	   efi_string_id_t *string_id,
843 	   const u8 *language,
844 	   const u16 *language_name,
845 	   const efi_string_t string,
846 	   const struct efi_font_info *string_font_info)
847 {
848 	struct efi_hii_packagelist *hii = package_list;
849 	struct efi_string_table *stbl;
850 
851 	EFI_ENTRY("%p, %p, %p, \"%s\", %p, \"%ls\", %p", this, package_list,
852 		  string_id, language, language_name, string,
853 		  string_font_info);
854 
855 	if (!package_list || !efi_hii_packagelist_exists(package_list))
856 		return EFI_EXIT(EFI_NOT_FOUND);
857 
858 	if (!string_id || !language || !string)
859 		return EFI_EXIT(EFI_INVALID_PARAMETER);
860 
861 	list_for_each_entry(stbl, &hii->string_tables, link) {
862 		if (language_match((char *)language, stbl->language)) {
863 			efi_string_id_t new_id;
864 			void *buf;
865 			efi_string_t str;
866 
867 			new_id = ++hii->max_string_id;
868 			if (stbl->nstrings < new_id) {
869 				buf = realloc(stbl->strings,
870 					      sizeof(stbl->strings[0])
871 						* new_id);
872 				if (!buf)
873 					return EFI_EXIT(EFI_OUT_OF_RESOURCES);
874 
875 				memset(&stbl->strings[stbl->nstrings], 0,
876 				       (new_id - stbl->nstrings)
877 					 * sizeof(stbl->strings[0]));
878 				stbl->strings = buf;
879 				stbl->nstrings = new_id;
880 			}
881 
882 			str = u16_strdup(string);
883 			if (!str)
884 				return EFI_EXIT(EFI_OUT_OF_RESOURCES);
885 
886 			stbl->strings[new_id - 1].string = str;
887 			*string_id = new_id;
888 
889 			return EFI_EXIT(EFI_SUCCESS);
890 		}
891 	}
892 
893 	return EFI_EXIT(EFI_NOT_FOUND);
894 }
895 
896 static efi_status_t EFIAPI
897 get_string(const struct efi_hii_string_protocol *this,
898 	   const u8 *language,
899 	   efi_hii_handle_t package_list,
900 	   efi_string_id_t string_id,
901 	   efi_string_t string,
902 	   efi_uintn_t *string_size,
903 	   struct efi_font_info **string_font_info)
904 {
905 	struct efi_hii_packagelist *hii = package_list;
906 	struct efi_string_table *stbl;
907 
908 	EFI_ENTRY("%p, \"%s\", %p, %u, %p, %p, %p", this, language,
909 		  package_list, string_id, string, string_size,
910 		  string_font_info);
911 
912 	if (!package_list || !efi_hii_packagelist_exists(package_list))
913 		return EFI_EXIT(EFI_NOT_FOUND);
914 
915 	list_for_each_entry(stbl, &hii->string_tables, link) {
916 		if (language_match((char *)language, stbl->language)) {
917 			efi_string_t str;
918 			size_t len;
919 
920 			if (stbl->nstrings < string_id)
921 				return EFI_EXIT(EFI_NOT_FOUND);
922 
923 			str = stbl->strings[string_id - 1].string;
924 			if (str) {
925 				len = (u16_strlen(str) + 1) * sizeof(u16);
926 				if (*string_size < len) {
927 					*string_size = len;
928 
929 					return EFI_EXIT(EFI_BUFFER_TOO_SMALL);
930 				}
931 				memcpy(string, str, len);
932 				*string_size = len;
933 			} else {
934 				return EFI_EXIT(EFI_NOT_FOUND);
935 			}
936 
937 			return EFI_EXIT(EFI_SUCCESS);
938 		}
939 	}
940 
941 	return EFI_EXIT(EFI_NOT_FOUND);
942 }
943 
944 static efi_status_t EFIAPI
945 set_string(const struct efi_hii_string_protocol *this,
946 	   efi_hii_handle_t package_list,
947 	   efi_string_id_t string_id,
948 	   const u8 *language,
949 	   const efi_string_t string,
950 	   const struct efi_font_info *string_font_info)
951 {
952 	struct efi_hii_packagelist *hii = package_list;
953 	struct efi_string_table *stbl;
954 
955 	EFI_ENTRY("%p, %p, %u, \"%s\", \"%ls\", %p", this, package_list,
956 		  string_id, language, string, string_font_info);
957 
958 	if (!package_list || !efi_hii_packagelist_exists(package_list))
959 		return EFI_EXIT(EFI_NOT_FOUND);
960 
961 	if (string_id > hii->max_string_id)
962 		return EFI_EXIT(EFI_NOT_FOUND);
963 
964 	if (!string || !language)
965 		return EFI_EXIT(EFI_INVALID_PARAMETER);
966 
967 	list_for_each_entry(stbl, &hii->string_tables, link) {
968 		if (language_match((char *)language, stbl->language)) {
969 			efi_string_t str;
970 
971 			if (hii->max_string_id < string_id)
972 				return EFI_EXIT(EFI_NOT_FOUND);
973 
974 			if (stbl->nstrings < string_id) {
975 				void *buf;
976 
977 				buf = realloc(stbl->strings,
978 					      string_id
979 						* sizeof(stbl->strings[0]));
980 				if (!buf)
981 					return EFI_EXIT(EFI_OUT_OF_RESOURCES);
982 
983 				memset(&stbl->strings[string_id - 1], 0,
984 				       (string_id - stbl->nstrings)
985 					 * sizeof(stbl->strings[0]));
986 				stbl->strings = buf;
987 			}
988 
989 			str = u16_strdup(string);
990 			if (!str)
991 				return EFI_EXIT(EFI_OUT_OF_RESOURCES);
992 
993 			free(stbl->strings[string_id - 1].string);
994 			stbl->strings[string_id - 1].string = str;
995 
996 			return EFI_EXIT(EFI_SUCCESS);
997 		}
998 	}
999 
1000 	return EFI_EXIT(EFI_NOT_FOUND);
1001 }
1002 
1003 static efi_status_t EFIAPI
1004 get_languages(const struct efi_hii_string_protocol *this,
1005 	      efi_hii_handle_t package_list,
1006 	      u8 *languages,
1007 	      efi_uintn_t *languages_size)
1008 {
1009 	struct efi_hii_packagelist *hii = package_list;
1010 	struct efi_string_table *stbl;
1011 	size_t len = 0;
1012 	char *p;
1013 
1014 	EFI_ENTRY("%p, %p, %p, %p", this, package_list, languages,
1015 		  languages_size);
1016 
1017 	if (!package_list || !efi_hii_packagelist_exists(package_list))
1018 		return EFI_EXIT(EFI_NOT_FOUND);
1019 
1020 	if (!languages_size ||
1021 	    (*languages_size && !languages))
1022 		return EFI_EXIT(EFI_INVALID_PARAMETER);
1023 
1024 	/* figure out required size: */
1025 	list_for_each_entry(stbl, &hii->string_tables, link) {
1026 		len += strlen((char *)stbl->language) + 1;
1027 	}
1028 
1029 	if (*languages_size < len) {
1030 		*languages_size = len;
1031 
1032 		return EFI_EXIT(EFI_BUFFER_TOO_SMALL);
1033 	}
1034 
1035 	p = (char *)languages;
1036 	list_for_each_entry(stbl, &hii->string_tables, link) {
1037 		if (p != (char *)languages)
1038 			*p++ = ';';
1039 		strcpy(p, stbl->language);
1040 		p += strlen((char *)stbl->language);
1041 	}
1042 	*p = '\0';
1043 
1044 	EFI_PRINT("languages: %s\n", languages);
1045 
1046 	return EFI_EXIT(EFI_SUCCESS);
1047 }
1048 
1049 static efi_status_t EFIAPI
1050 get_secondary_languages(const struct efi_hii_string_protocol *this,
1051 			efi_hii_handle_t package_list,
1052 			const u8 *primary_language,
1053 			u8 *secondary_languages,
1054 			efi_uintn_t *secondary_languages_size)
1055 {
1056 	struct efi_hii_packagelist *hii = package_list;
1057 	struct efi_string_table *stbl;
1058 	bool found = false;
1059 
1060 	EFI_ENTRY("%p, %p, \"%s\", %p, %p", this, package_list,
1061 		  primary_language, secondary_languages,
1062 		  secondary_languages_size);
1063 
1064 	if (!package_list || !efi_hii_packagelist_exists(package_list))
1065 		return EFI_EXIT(EFI_NOT_FOUND);
1066 
1067 	if (!secondary_languages_size ||
1068 	    (*secondary_languages_size && !secondary_languages))
1069 		return EFI_EXIT(EFI_INVALID_PARAMETER);
1070 
1071 	list_for_each_entry(stbl, &hii->string_tables, link) {
1072 		if (language_match((char *)primary_language, stbl->language)) {
1073 			found = true;
1074 			break;
1075 		}
1076 	}
1077 	if (!found)
1078 		return EFI_EXIT(EFI_INVALID_LANGUAGE);
1079 
1080 	/*
1081 	 * TODO: What is secondary language?
1082 	 * *secondary_languages = '\0';
1083 	 * *secondary_languages_size = 0;
1084 	 */
1085 
1086 	return EFI_EXIT(EFI_NOT_FOUND);
1087 }
1088 
1089 const struct efi_hii_string_protocol efi_hii_string = {
1090 	.new_string = new_string,
1091 	.get_string = get_string,
1092 	.set_string = set_string,
1093 	.get_languages = get_languages,
1094 	.get_secondary_languages = get_secondary_languages
1095 };
1096