git.sur5r.net Git - u-boot/blob - lib/efi_driver/efi_uclass.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  *  Uclass for EFI drivers
   4  *
   5  *  Copyright (c) 2017 Heinrich Schuchardt
   6  *
   7  * For each EFI driver the uclass
   8  * - creates a handle
   9  * - installs the driver binding protocol
  10  *
  11  * The uclass provides the bind, start, and stop entry points for the driver
  12  * binding protocol.
  13  *
  14  * In bind() and stop() it checks if the controller implements the protocol
  15  * supported by the EFI driver. In the start() function it calls the bind()
  16  * function of the EFI driver. In the stop() function it destroys the child
  17  * controllers.
  18  */
  19
  20 #include <efi_driver.h>
  21
  22 /*
  23  * Check node type. We do not support partitions as controller handles.
  24  *
  25  * @handle      handle to be checked
  26  * @return      status code
  27  */
  28 static efi_status_t check_node_type(efi_handle_t handle)
  29 {
  30         efi_status_t r, ret = EFI_SUCCESS;
  31         const struct efi_device_path *dp;
  32
  33         /* Open the device path protocol */
  34         r = EFI_CALL(systab.boottime->open_protocol(
  35                         handle, &efi_guid_device_path, (void **)&dp,
  36                         NULL, NULL, EFI_OPEN_PROTOCOL_GET_PROTOCOL));
  37         if (r == EFI_SUCCESS && dp) {
  38                 /* Get the last node */
  39                 const struct efi_device_path *node = efi_dp_last_node(dp);
  40                 /* We do not support partitions as controller */
  41                 if (!node || node->type == DEVICE_PATH_TYPE_MEDIA_DEVICE)
  42                         ret = EFI_UNSUPPORTED;
  43         }
  44         return ret;
  45 }
  46
  47 /*
  48  * Check if the driver supports the controller.
  49  *
  50  * @this                        driver binding protocol
  51  * @controller_handle           handle of the controller
  52  * @remaining_device_path       path specifying the child controller
  53  * @return                      status code
  54  */
  55 static efi_status_t EFIAPI efi_uc_supported(
  56                 struct efi_driver_binding_protocol *this,
  57                 efi_handle_t controller_handle,
  58                 struct efi_device_path *remaining_device_path)
  59 {
  60         efi_status_t r, ret;
  61         void *interface;
  62         struct efi_driver_binding_extended_protocol *bp =
  63                         (struct efi_driver_binding_extended_protocol *)this;
  64
  65         EFI_ENTRY("%p, %p, %ls", this, controller_handle,
  66                   efi_dp_str(remaining_device_path));
  67
  68         ret = EFI_CALL(systab.boottime->open_protocol(
  69                         controller_handle, bp->ops->protocol,
  70                         &interface, this->driver_binding_handle,
  71                         controller_handle, EFI_OPEN_PROTOCOL_BY_DRIVER));
  72         switch (ret) {
  73         case EFI_ACCESS_DENIED:
  74         case EFI_ALREADY_STARTED:
  75                 goto out;
  76         case EFI_SUCCESS:
  77                 break;
  78         default:
  79                 ret = EFI_UNSUPPORTED;
  80                 goto out;
  81         }
  82
  83         ret = check_node_type(controller_handle);
  84
  85         r = EFI_CALL(systab.boottime->close_protocol(
  86                                 controller_handle, bp->ops->protocol,
  87                                 this->driver_binding_handle,
  88                                 controller_handle));
  89         if (r != EFI_SUCCESS)
  90                 ret = EFI_UNSUPPORTED;
  91 out:
  92         return EFI_EXIT(ret);
  93 }
  94
  95 /*
  96  * Create child controllers and attach driver.
  97  *
  98  * @this                        driver binding protocol
  99  * @controller_handle           handle of the controller
 100  * @remaining_device_path       path specifying the child controller
 101  * @return                      status code
 102  */
 103 static efi_status_t EFIAPI efi_uc_start(
 104                 struct efi_driver_binding_protocol *this,
 105                 efi_handle_t controller_handle,
 106                 struct efi_device_path *remaining_device_path)
 107 {
 108         efi_status_t r, ret;
 109         void *interface = NULL;
 110         struct efi_driver_binding_extended_protocol *bp =
 111                         (struct efi_driver_binding_extended_protocol *)this;
 112
 113         EFI_ENTRY("%p, %pUl, %ls", this, controller_handle,
 114                   efi_dp_str(remaining_device_path));
 115
 116         /* Attach driver to controller */
 117         ret = EFI_CALL(systab.boottime->open_protocol(
 118                         controller_handle, bp->ops->protocol,
 119                         &interface, this->driver_binding_handle,
 120                         controller_handle, EFI_OPEN_PROTOCOL_BY_DRIVER));
 121         switch (ret) {
 122         case EFI_ACCESS_DENIED:
 123         case EFI_ALREADY_STARTED:
 124                 goto out;
 125         case EFI_SUCCESS:
 126                 break;
 127         default:
 128                 ret =  EFI_UNSUPPORTED;
 129                 goto out;
 130         }
 131         ret = check_node_type(controller_handle);
 132         if (ret != EFI_SUCCESS) {
 133                 r = EFI_CALL(systab.boottime->close_protocol(
 134                                 controller_handle, bp->ops->protocol,
 135                                 this->driver_binding_handle,
 136                                 controller_handle));
 137                 if (r != EFI_SUCCESS)
 138                         EFI_PRINT("Failure to close handle\n");
 139                 goto out;
 140         }
 141
 142         /* TODO: driver specific stuff */
 143         bp->ops->bind(controller_handle, interface);
 144
 145 out:
 146         return EFI_EXIT(ret);
 147 }
 148
 149 /*
 150  * Remove a single child controller from the parent controller.
 151  *
 152  * @controller_handle   parent controller
 153  * @child_handle        child controller
 154  * @return              status code
 155  */
 156 static efi_status_t disconnect_child(efi_handle_t controller_handle,
 157                                      efi_handle_t child_handle)
 158 {
 159         efi_status_t ret;
 160         efi_guid_t *guid_controller = NULL;
 161         efi_guid_t *guid_child_controller = NULL;
 162
 163         ret = EFI_CALL(systab.boottime->close_protocol(
 164                                 controller_handle, guid_controller,
 165                                 child_handle, child_handle));
 166         if (ret != EFI_SUCCESS) {
 167                 EFI_PRINT("Cannot close protocol\n");
 168                 return ret;
 169         }
 170         ret = EFI_CALL(systab.boottime->uninstall_protocol_interface(
 171                                 child_handle, guid_child_controller, NULL));
 172         if (ret != EFI_SUCCESS) {
 173                 EFI_PRINT("Cannot uninstall protocol interface\n");
 174                 return ret;
 175         }
 176         return ret;
 177 }
 178
 179 /*
 180  * Remove child controllers and disconnect the controller.
 181  *
 182  * @this                        driver binding protocol
 183  * @controller_handle           handle of the controller
 184  * @number_of_children          number of child controllers to remove
 185  * @child_handle_buffer         handles of the child controllers to remove
 186  * @return                      status code
 187  */
 188 static efi_status_t EFIAPI efi_uc_stop(
 189                 struct efi_driver_binding_protocol *this,
 190                 efi_handle_t controller_handle,
 191                 size_t number_of_children,
 192                 efi_handle_t *child_handle_buffer)
 193 {
 194         efi_status_t ret;
 195         efi_uintn_t count;
 196         struct efi_open_protocol_info_entry *entry_buffer;
 197         efi_guid_t *guid_controller = NULL;
 198
 199         EFI_ENTRY("%p, %pUl, %zu, %p", this, controller_handle,
 200                   number_of_children, child_handle_buffer);
 201
 202         /* Destroy provided child controllers */
 203         if (number_of_children) {
 204                 efi_uintn_t i;
 205
 206                 for (i = 0; i < number_of_children; ++i) {
 207                         ret = disconnect_child(controller_handle,
 208                                                child_handle_buffer[i]);
 209                         if (ret != EFI_SUCCESS)
 210                                 return ret;
 211                 }
 212                 return EFI_SUCCESS;
 213         }
 214
 215         /* Destroy all children */
 216         ret = EFI_CALL(systab.boottime->open_protocol_information(
 217                                         controller_handle, guid_controller,
 218                                         &entry_buffer, &count));
 219         if (ret != EFI_SUCCESS)
 220                 goto out;
 221         while (count) {
 222                 if (entry_buffer[--count].attributes &
 223                     EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) {
 224                         ret = disconnect_child(
 225                                         controller_handle,
 226                                         entry_buffer[count].agent_handle);
 227                         if (ret != EFI_SUCCESS)
 228                                 goto out;
 229                 }
 230         }
 231         ret = EFI_CALL(systab.boottime->free_pool(entry_buffer));
 232         if (ret != EFI_SUCCESS)
 233                 printf("%s(%u) %s: ERROR: Cannot free pool\n",
 234                        __FILE__, __LINE__, __func__);
 235
 236         /* Detach driver from controller */
 237         ret = EFI_CALL(systab.boottime->close_protocol(
 238                         controller_handle, guid_controller,
 239                         this->driver_binding_handle, controller_handle));
 240 out:
 241         return EFI_EXIT(ret);
 242 }
 243
 244 static efi_status_t efi_add_driver(struct driver *drv)
 245 {
 246         efi_status_t ret;
 247         const struct efi_driver_ops *ops = drv->ops;
 248         struct efi_driver_binding_extended_protocol *bp;
 249
 250         debug("EFI: Adding driver '%s'\n", drv->name);
 251         if (!ops->protocol) {
 252                 printf("EFI: ERROR: protocol GUID missing for driver '%s'\n",
 253                        drv->name);
 254                 return EFI_INVALID_PARAMETER;
 255         }
 256         bp = calloc(1, sizeof(struct efi_driver_binding_extended_protocol));
 257         if (!bp)
 258                 return EFI_OUT_OF_RESOURCES;
 259
 260         bp->bp.supported = efi_uc_supported;
 261         bp->bp.start = efi_uc_start;
 262         bp->bp.stop = efi_uc_stop;
 263         bp->bp.version = 0xffffffff;
 264         bp->ops = drv->ops;
 265
 266         ret = efi_create_handle(&bp->bp.driver_binding_handle);
 267         if (ret != EFI_SUCCESS) {
 268                 free(bp);
 269                 goto out;
 270         }
 271         bp->bp.image_handle = bp->bp.driver_binding_handle;
 272         ret = efi_add_protocol(bp->bp.driver_binding_handle,
 273                                &efi_guid_driver_binding_protocol, bp);
 274         if (ret != EFI_SUCCESS) {
 275                 efi_delete_handle(bp->bp.driver_binding_handle);
 276                 free(bp);
 277                 goto out;
 278         }
 279 out:
 280         return ret;
 281 }
 282
 283 /*
 284  * Initialize the EFI drivers.
 285  * Called by board_init_r().
 286  *
 287  * @return      0 = success, any other value will stop further execution
 288  */
 289 efi_status_t efi_driver_init(void)
 290 {
 291         struct driver *drv;
 292         efi_status_t ret = EFI_SUCCESS;
 293
 294         /* Save 'gd' pointer */
 295         efi_save_gd();
 296
 297         debug("EFI: Initializing EFI driver framework\n");
 298         for (drv = ll_entry_start(struct driver, driver);
 299              drv < ll_entry_end(struct driver, driver); ++drv) {
 300                 if (drv->id == UCLASS_EFI) {
 301                         ret = efi_add_driver(drv);
 302                         if (ret != EFI_SUCCESS) {
 303                                 printf("EFI: ERROR: failed to add driver %s\n",
 304                                        drv->name);
 305                                 break;
 306                         }
 307                 }
 308         }
 309         return ret;
 310 }
 311
 312 static int efi_uc_init(struct uclass *class)
 313 {
 314         printf("EFI: Initializing UCLASS_EFI\n");
 315         return 0;
 316 }
 317
 318 static int efi_uc_destroy(struct uclass *class)
 319 {
 320         printf("Destroying  UCLASS_EFI\n");
 321         return 0;
 322 }
 323
 324 UCLASS_DRIVER(efi) = {
 325         .name           = "efi",
 326         .id             = UCLASS_EFI,
 327         .init           = efi_uc_init,
 328         .destroy        = efi_uc_destroy,
 329 };