1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3  * efi_selftest_controllers
4  *
5  * Copyright (c) 2017 Heinrich Schuchardt <xypron.glpk@gmx.de>
6  *
7  * This unit test checks the following protocol services:
8  * ConnectController, DisconnectController,
9  * InstallProtocol, ReinstallProtocol, UninstallProtocol,
10  * OpenProtocol, CloseProtcol, OpenProtocolInformation
11  */
12 
13 #include <efi_selftest.h>
14 
15 #define NUMBER_OF_CHILD_CONTROLLERS 4
16 
17 static int interface1 = 1;
18 static int interface2 = 2;
19 static struct efi_boot_services *boottime;
20 const efi_guid_t guid_driver_binding_protocol =
21 			EFI_DRIVER_BINDING_PROTOCOL_GUID;
22 static efi_guid_t guid_controller =
23 	EFI_GUID(0xe6ab1d96, 0x6bff, 0xdb42,
24 		 0xaa, 0x05, 0xc8, 0x1f, 0x7f, 0x45, 0x26, 0x34);
25 static efi_guid_t guid_child_controller =
26 	EFI_GUID(0x1d41f6f5, 0x2c41, 0xddfb,
27 		 0xe2, 0x9b, 0xb8, 0x0e, 0x2e, 0xe8, 0x3a, 0x85);
28 static efi_handle_t handle_controller;
29 static efi_handle_t handle_child_controller[NUMBER_OF_CHILD_CONTROLLERS];
30 static efi_handle_t handle_driver;
31 
32 /*
33  * Count child controllers
34  *
35  * @handle	handle on which child controllers are installed
36  * @protocol	protocol for which the child controlles where installed
37  * @count	number of child controllers
38  * @return	status code
39  */
40 static efi_status_t count_child_controllers(efi_handle_t handle,
41 					    efi_guid_t *protocol,
42 					    efi_uintn_t *count)
43 {
44 	efi_status_t ret;
45 	efi_uintn_t entry_count;
46 	struct efi_open_protocol_info_entry *entry_buffer;
47 
48 	*count = 0;
49 	ret = boottime->open_protocol_information(handle, protocol,
50 						  &entry_buffer, &entry_count);
51 	if (ret != EFI_SUCCESS)
52 		return ret;
53 	if (!entry_count)
54 		return EFI_SUCCESS;
55 	while (entry_count) {
56 		if (entry_buffer[--entry_count].attributes &
57 		    EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER)
58 			++*count;
59 	}
60 	ret = boottime->free_pool(entry_buffer);
61 	if (ret != EFI_SUCCESS)
62 		efi_st_error("Cannot free buffer\n");
63 	return ret;
64 }
65 
66 /*
67  * Check if the driver supports the controller.
68  *
69  * @this			driver binding protocol
70  * @controller_handle		handle of the controller
71  * @remaining_device_path	path specifying the child controller
72  * @return			status code
73  */
74 static efi_status_t EFIAPI supported(
75 		struct efi_driver_binding_protocol *this,
76 		efi_handle_t controller_handle,
77 		struct efi_device_path *remaining_device_path)
78 {
79 	efi_status_t ret;
80 	void *interface;
81 
82 	ret = boottime->open_protocol(
83 			controller_handle, &guid_controller,
84 			&interface, handle_driver,
85 			controller_handle, EFI_OPEN_PROTOCOL_BY_DRIVER);
86 	switch (ret) {
87 	case EFI_ACCESS_DENIED:
88 	case EFI_ALREADY_STARTED:
89 		return ret;
90 	case EFI_SUCCESS:
91 		break;
92 	default:
93 		return EFI_UNSUPPORTED;
94 	}
95 	ret = boottime->close_protocol(
96 				controller_handle, &guid_controller,
97 				handle_driver, controller_handle);
98 	if (ret != EFI_SUCCESS)
99 		ret = EFI_UNSUPPORTED;
100 	return ret;
101 }
102 
103 /*
104  * Create child controllers and attach driver.
105  *
106  * @this			driver binding protocol
107  * @controller_handle		handle of the controller
108  * @remaining_device_path	path specifying the child controller
109  * @return			status code
110  */
111 static efi_status_t EFIAPI start(
112 		struct efi_driver_binding_protocol *this,
113 		efi_handle_t controller_handle,
114 		struct efi_device_path *remaining_device_path)
115 {
116 	size_t i;
117 	efi_status_t ret;
118 	void *interface;
119 
120 	/* Attach driver to controller */
121 	ret = boottime->open_protocol(
122 			controller_handle, &guid_controller,
123 			&interface, handle_driver,
124 			controller_handle, EFI_OPEN_PROTOCOL_BY_DRIVER);
125 	switch (ret) {
126 	case EFI_ACCESS_DENIED:
127 	case EFI_ALREADY_STARTED:
128 		return ret;
129 	case EFI_SUCCESS:
130 		break;
131 	default:
132 		return EFI_UNSUPPORTED;
133 	}
134 
135 	/* Create child controllers */
136 	for (i = 0; i < NUMBER_OF_CHILD_CONTROLLERS; ++i) {
137 		/* Creating a new handle for the child controller */
138 		handle_child_controller[i] = 0;
139 		ret = boottime->install_protocol_interface(
140 			&handle_child_controller[i], &guid_child_controller,
141 			EFI_NATIVE_INTERFACE, NULL);
142 		if (ret != EFI_SUCCESS) {
143 			efi_st_error("InstallProtocolInterface failed\n");
144 			return EFI_ST_FAILURE;
145 		}
146 		ret = boottime->open_protocol(
147 			controller_handle, &guid_controller,
148 			&interface, handle_child_controller[i],
149 			handle_child_controller[i],
150 			EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER);
151 		if (ret != EFI_SUCCESS) {
152 			efi_st_error("OpenProtocol failed\n");
153 			return EFI_ST_FAILURE;
154 		}
155 	}
156 	return ret;
157 }
158 
159 /*
160  * Remove a single child controller from the parent controller.
161  *
162  * @controller_handle	parent controller
163  * @child_handle	child controller
164  * @return		status code
165  */
166 static efi_status_t disconnect_child(efi_handle_t controller_handle,
167 				     efi_handle_t child_handle)
168 {
169 	efi_status_t ret;
170 
171 	ret = boottime->close_protocol(
172 				controller_handle, &guid_controller,
173 				child_handle, child_handle);
174 	if (ret != EFI_SUCCESS) {
175 		efi_st_error("Cannot close protocol\n");
176 		return ret;
177 	}
178 	ret = boottime->uninstall_protocol_interface(
179 				child_handle, &guid_child_controller, NULL);
180 	if (ret != EFI_SUCCESS) {
181 		efi_st_error("Cannot uninstall protocol interface\n");
182 		return ret;
183 	}
184 	return ret;
185 }
186 
187 /*
188  * Remove child controllers and disconnect the controller.
189  *
190  * @this			driver binding protocol
191  * @controller_handle		handle of the controller
192  * @number_of_children		number of child controllers to remove
193  * @child_handle_buffer		handles of the child controllers to remove
194  * @return			status code
195  */
196 static efi_status_t EFIAPI stop(
197 		struct efi_driver_binding_protocol *this,
198 		efi_handle_t controller_handle,
199 		size_t number_of_children,
200 		efi_handle_t *child_handle_buffer)
201 {
202 	efi_status_t ret;
203 	efi_uintn_t count;
204 	struct efi_open_protocol_info_entry *entry_buffer;
205 
206 	/* Destroy provided child controllers */
207 	if (number_of_children) {
208 		efi_uintn_t i;
209 
210 		for (i = 0; i < number_of_children; ++i) {
211 			ret = disconnect_child(controller_handle,
212 					       child_handle_buffer[i]);
213 			if (ret != EFI_SUCCESS)
214 				return ret;
215 		}
216 		return EFI_SUCCESS;
217 	}
218 
219 	/* Destroy all children */
220 	ret = boottime->open_protocol_information(
221 					controller_handle, &guid_controller,
222 					&entry_buffer, &count);
223 	if (ret != EFI_SUCCESS) {
224 		efi_st_error("OpenProtocolInformation failed\n");
225 		return ret;
226 	}
227 	while (count) {
228 		if (entry_buffer[--count].attributes &
229 		    EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) {
230 			ret = disconnect_child(
231 					controller_handle,
232 					entry_buffer[count].agent_handle);
233 			if (ret != EFI_SUCCESS)
234 				return ret;
235 		}
236 	}
237 	ret = boottime->free_pool(entry_buffer);
238 	if (ret != EFI_SUCCESS)
239 		efi_st_error("Cannot free buffer\n");
240 
241 	/* Detach driver from controller */
242 	ret = boottime->close_protocol(
243 			controller_handle, &guid_controller,
244 			handle_driver, controller_handle);
245 	if (ret != EFI_SUCCESS) {
246 		efi_st_error("Cannot close protocol\n");
247 		return ret;
248 	}
249 	return EFI_SUCCESS;
250 }
251 
252 /* Driver binding protocol interface */
253 static struct efi_driver_binding_protocol binding_interface = {
254 	supported,
255 	start,
256 	stop,
257 	0xffffffff,
258 	NULL,
259 	NULL,
260 	};
261 
262 /*
263  * Setup unit test.
264  *
265  * @handle	handle of the loaded image
266  * @systable	system table
267  */
268 static int setup(const efi_handle_t img_handle,
269 		 const struct efi_system_table *systable)
270 {
271 	efi_status_t ret;
272 
273 	boottime = systable->boottime;
274 
275 	/* Create controller handle */
276 	ret = boottime->install_protocol_interface(
277 			&handle_controller, &guid_controller,
278 			EFI_NATIVE_INTERFACE, &interface1);
279 	if (ret != EFI_SUCCESS) {
280 		efi_st_error("InstallProtocolInterface failed\n");
281 		return EFI_ST_FAILURE;
282 	}
283 	/* Create driver handle */
284 	ret = boottime->install_protocol_interface(
285 			&handle_driver,  &guid_driver_binding_protocol,
286 			EFI_NATIVE_INTERFACE, &binding_interface);
287 	if (ret != EFI_SUCCESS) {
288 		efi_st_error("InstallProtocolInterface failed\n");
289 		return EFI_ST_FAILURE;
290 	}
291 
292 	return EFI_ST_SUCCESS;
293 }
294 
295 /*
296  * Execute unit test.
297  *
298  * The number of child controllers is checked after each of the following
299  * actions:
300  *
301  * Connect a controller to a driver.
302  * Disconnect and destroy a child controller.
303  * Disconnect and destroy the remaining child controllers.
304  *
305  * Connect a controller to a driver.
306  * Reinstall the driver protocol on the controller.
307  * Uninstall the driver protocol from the controller.
308  */
309 static int execute(void)
310 {
311 	efi_status_t ret;
312 	efi_uintn_t count;
313 
314 	/* Connect controller to driver */
315 	ret = boottime->connect_controller(handle_controller, NULL, NULL, 1);
316 	if (ret != EFI_SUCCESS) {
317 		efi_st_error("Failed to connect controller\n");
318 		return EFI_ST_FAILURE;
319 	}
320 	/* Check number of child controllers */
321 	ret = count_child_controllers(handle_controller, &guid_controller,
322 				      &count);
323 	if (ret != EFI_SUCCESS || count != NUMBER_OF_CHILD_CONTROLLERS) {
324 		efi_st_error("Number of children %u != %u\n",
325 			     (unsigned int)count, NUMBER_OF_CHILD_CONTROLLERS);
326 	}
327 	/* Destroy second child controller */
328 	ret = boottime->disconnect_controller(handle_controller,
329 					      handle_driver,
330 					      handle_child_controller[1]);
331 	if (ret != EFI_SUCCESS) {
332 		efi_st_error("Failed to disconnect child controller\n");
333 		return EFI_ST_FAILURE;
334 	}
335 	/* Check number of child controllers */
336 	ret = count_child_controllers(handle_controller, &guid_controller,
337 				      &count);
338 	if (ret != EFI_SUCCESS || count != NUMBER_OF_CHILD_CONTROLLERS - 1) {
339 		efi_st_error("Destroying single child controller failed\n");
340 		return EFI_ST_FAILURE;
341 	}
342 	/* Destroy remaining child controllers and disconnect controller */
343 	ret = boottime->disconnect_controller(handle_controller, NULL, NULL);
344 	if (ret != EFI_SUCCESS) {
345 		efi_st_error("Failed to disconnect controller\n");
346 		return EFI_ST_FAILURE;
347 	}
348 	/* Check number of child controllers */
349 	ret = count_child_controllers(handle_controller, &guid_controller,
350 				      &count);
351 	if (ret != EFI_SUCCESS || count) {
352 		efi_st_error("Destroying child controllers failed\n");
353 		return EFI_ST_FAILURE;
354 	}
355 
356 	/* Connect controller to driver */
357 	ret = boottime->connect_controller(handle_controller, NULL, NULL, 1);
358 	if (ret != EFI_SUCCESS) {
359 		efi_st_error("Failed to connect controller\n");
360 		return EFI_ST_FAILURE;
361 	}
362 	/* Check number of child controllers */
363 	ret = count_child_controllers(handle_controller, &guid_controller,
364 				      &count);
365 	if (ret != EFI_SUCCESS || count != NUMBER_OF_CHILD_CONTROLLERS) {
366 		efi_st_error("Number of children %u != %u\n",
367 			     (unsigned int)count, NUMBER_OF_CHILD_CONTROLLERS);
368 	}
369 	/* Try to uninstall controller protocol using the wrong interface */
370 	ret = boottime->uninstall_protocol_interface(handle_controller,
371 						     &guid_controller,
372 						     &interface2);
373 	if (ret == EFI_SUCCESS) {
374 		efi_st_error(
375 			"Interface not checked when uninstalling protocol\n");
376 		return EFI_ST_FAILURE;
377 	}
378 	/* Reinstall controller protocol */
379 	ret = boottime->reinstall_protocol_interface(handle_controller,
380 						     &guid_controller,
381 						     &interface1,
382 						     &interface2);
383 	if (ret != EFI_SUCCESS) {
384 		efi_st_error("Failed to reinstall protocols\n");
385 		return EFI_ST_FAILURE;
386 	}
387 	/* Check number of child controllers */
388 	ret = count_child_controllers(handle_controller, &guid_controller,
389 				      &count);
390 	if (ret != EFI_SUCCESS || count != NUMBER_OF_CHILD_CONTROLLERS) {
391 		efi_st_error("Number of children %u != %u\n",
392 			     (unsigned int)count, NUMBER_OF_CHILD_CONTROLLERS);
393 	}
394 	/* Uninstall controller protocol */
395 	ret = boottime->uninstall_protocol_interface(handle_controller,
396 						     &guid_controller,
397 						     &interface2);
398 	if (ret != EFI_SUCCESS) {
399 		efi_st_error("Failed to uninstall protocols\n");
400 		return EFI_ST_FAILURE;
401 	}
402 	/* Check number of child controllers */
403 	ret = count_child_controllers(handle_controller, &guid_controller,
404 				      &count);
405 	if (ret == EFI_SUCCESS)
406 		efi_st_error("Uninstall failed\n");
407 	return EFI_ST_SUCCESS;
408 }
409 
410 EFI_UNIT_TEST(controllers) = {
411 	.name = "controllers",
412 	.phase = EFI_EXECUTE_BEFORE_BOOTTIME_EXIT,
413 	.setup = setup,
414 	.execute = execute,
415 };
416