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 controllers were 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