1// SPDX-License-Identifier: GPL-2.0+ 2/* 3 * Copyright (c) 2013 Google, Inc 4 * 5 * (C) Copyright 2012 6 * Pavel Herrmann <morpheus.ibis@gmail.com> 7 */ 8 9#define LOG_CATEGORY UCLASS_ROOT 10 11#include <errno.h> 12#include <fdtdec.h> 13#include <log.h> 14#include <malloc.h> 15#include <asm-generic/sections.h> 16#include <asm/global_data.h> 17#include <linux/libfdt.h> 18#include <dm/acpi.h> 19#include <dm/device.h> 20#include <dm/device-internal.h> 21#include <dm/lists.h> 22#include <dm/of.h> 23#include <dm/of_access.h> 24#include <dm/platdata.h> 25#include <dm/read.h> 26#include <dm/root.h> 27#include <dm/uclass.h> 28#include <dm/uclass-internal.h> 29#include <dm/util.h> 30#include <linux/list.h> 31#include <linux/printk.h> 32 33DECLARE_GLOBAL_DATA_PTR; 34 35static struct driver_info root_info = { 36 .name = "root_driver", 37}; 38 39struct udevice *dm_root(void) 40{ 41 if (!gd->dm_root) { 42 dm_warn("Virtual root driver does not exist!\n"); 43 return NULL; 44 } 45 46 return gd->dm_root; 47} 48 49void dm_fixup_for_gd_move(struct global_data *new_gd) 50{ 51 /* The sentinel node has moved, so update things that point to it */ 52 if (gd->dm_root) { 53 new_gd->uclass_root->next->prev = new_gd->uclass_root; 54 new_gd->uclass_root->prev->next = new_gd->uclass_root; 55 } 56} 57 58static int dm_setup_inst(void) 59{ 60 DM_ROOT_NON_CONST = DM_DEVICE_GET(root); 61 62 if (CONFIG_IS_ENABLED(OF_PLATDATA_RT)) { 63 struct udevice_rt *urt; 64 void *start, *end; 65 int each_size; 66 void *base; 67 int n_ents; 68 uint size; 69 70 /* Allocate the udevice_rt table */ 71 each_size = dm_udevice_size(); 72 start = ll_entry_start(struct udevice, udevice); 73 end = ll_entry_end(struct udevice, udevice); 74 size = end - start; 75 n_ents = size / each_size; 76 urt = calloc(n_ents, sizeof(struct udevice_rt)); 77 if (!urt) 78 return log_msg_ret("urt", -ENOMEM); 79 gd_set_dm_udevice_rt(urt); 80 81 /* Now allocate space for the priv/plat data, and copy it in */ 82 size = __priv_data_end - __priv_data_start; 83 84 base = calloc(1, size); 85 if (!base) 86 return log_msg_ret("priv", -ENOMEM); 87 memcpy(base, __priv_data_start, size); 88 gd_set_dm_priv_base(base); 89 } 90 91 return 0; 92} 93 94int dm_init(bool of_live) 95{ 96 int ret; 97 98 if (gd->dm_root) { 99 dm_warn("Virtual root driver already exists!\n"); 100 return -EINVAL; 101 } 102 if (CONFIG_IS_ENABLED(OF_PLATDATA_INST)) { 103 gd->uclass_root = &uclass_head; 104 } else { 105 gd->uclass_root = &DM_UCLASS_ROOT_S_NON_CONST; 106 INIT_LIST_HEAD(DM_UCLASS_ROOT_NON_CONST); 107 } 108 109 if (CONFIG_IS_ENABLED(OF_PLATDATA_INST)) { 110 ret = dm_setup_inst(); 111 if (ret) { 112 log_debug("dm_setup_inst() failed: %d\n", ret); 113 return ret; 114 } 115 } else { 116 ret = device_bind_by_name(NULL, false, &root_info, 117 &DM_ROOT_NON_CONST); 118 if (ret) 119 return ret; 120 if (CONFIG_IS_ENABLED(OF_CONTROL)) 121 dev_set_ofnode(DM_ROOT_NON_CONST, ofnode_root()); 122 ret = device_probe(DM_ROOT_NON_CONST); 123 if (ret) 124 return ret; 125 } 126 127 INIT_LIST_HEAD((struct list_head *)&gd->dmtag_list); 128 129 return 0; 130} 131 132int dm_uninit(void) 133{ 134 /* Remove non-vital devices first */ 135 device_remove(dm_root(), DM_REMOVE_NON_VITAL); 136 device_remove(dm_root(), DM_REMOVE_NORMAL); 137 device_unbind(dm_root()); 138 gd->dm_root = NULL; 139 140 return 0; 141} 142 143#if CONFIG_IS_ENABLED(DM_DEVICE_REMOVE) 144int dm_remove_devices_flags(uint flags) 145{ 146 device_remove(dm_root(), flags); 147 148 return 0; 149} 150#endif 151 152int dm_scan_plat(bool pre_reloc_only) 153{ 154 int ret; 155 156 if (CONFIG_IS_ENABLED(OF_PLATDATA_DRIVER_RT)) { 157 struct driver_rt *dyn; 158 int n_ents; 159 160 n_ents = ll_entry_count(struct driver_info, driver_info); 161 dyn = calloc(n_ents, sizeof(struct driver_rt)); 162 if (!dyn) 163 return -ENOMEM; 164 gd_set_dm_driver_rt(dyn); 165 } 166 167 ret = lists_bind_drivers(DM_ROOT_NON_CONST, pre_reloc_only); 168 if (ret == -ENOENT) { 169 dm_warn("Some drivers were not found\n"); 170 ret = 0; 171 } 172 173 return ret; 174} 175 176#if CONFIG_IS_ENABLED(OF_REAL) 177/** 178 * dm_scan_fdt_node() - Scan the device tree and bind drivers for a node 179 * 180 * This scans the subnodes of a device tree node and and creates a driver 181 * for each one. 182 * 183 * @parent: Parent device for the devices that will be created 184 * @node: Node to scan 185 * @pre_reloc_only: If true, bind only drivers with the DM_FLAG_PRE_RELOC 186 * flag. If false bind all drivers. 187 * Return: 0 if OK, -ve on error 188 */ 189static int dm_scan_fdt_node(struct udevice *parent, ofnode parent_node, 190 bool pre_reloc_only) 191{ 192 int ret = 0, err = 0; 193 ofnode node; 194 195 if (!ofnode_valid(parent_node)) 196 return 0; 197 198 for (node = ofnode_first_subnode(parent_node); 199 ofnode_valid(node); 200 node = ofnode_next_subnode(node)) { 201 const char *node_name = ofnode_get_name(node); 202 203 if (!ofnode_is_enabled(node)) { 204 pr_debug(" - ignoring disabled device\n"); 205 continue; 206 } 207 err = lists_bind_fdt(parent, node, NULL, NULL, pre_reloc_only); 208 if (err && !ret) { 209 ret = err; 210 debug("%s: ret=%d\n", node_name, ret); 211 } 212 } 213 214 if (ret) 215 dm_warn("Some drivers failed to bind\n"); 216 217 return ret; 218} 219 220int dm_scan_fdt_dev(struct udevice *dev) 221{ 222 return dm_scan_fdt_node(dev, dev_ofnode(dev), 223 gd->flags & GD_FLG_RELOC ? false : true); 224} 225 226int dm_scan_fdt(bool pre_reloc_only) 227{ 228 return dm_scan_fdt_node(gd->dm_root, ofnode_root(), pre_reloc_only); 229} 230 231static int dm_scan_fdt_ofnode_path(const char *path, bool pre_reloc_only) 232{ 233 ofnode node; 234 235 node = ofnode_path(path); 236 237 return dm_scan_fdt_node(gd->dm_root, node, pre_reloc_only); 238} 239 240int dm_extended_scan(bool pre_reloc_only) 241{ 242 int ret, i; 243 const char * const nodes[] = { 244 "/chosen", 245 "/clocks", 246 "/firmware" 247 }; 248 249 ret = dm_scan_fdt(pre_reloc_only); 250 if (ret) { 251 debug("dm_scan_fdt() failed: %d\n", ret); 252 return ret; 253 } 254 255 /* Some nodes aren't devices themselves but may contain some */ 256 for (i = 0; i < ARRAY_SIZE(nodes); i++) { 257 ret = dm_scan_fdt_ofnode_path(nodes[i], pre_reloc_only); 258 if (ret) { 259 debug("dm_scan_fdt() scan for %s failed: %d\n", 260 nodes[i], ret); 261 return ret; 262 } 263 } 264 265 return ret; 266} 267#endif 268 269__weak int dm_scan_other(bool pre_reloc_only) 270{ 271 return 0; 272} 273 274#if CONFIG_IS_ENABLED(OF_PLATDATA_INST) && CONFIG_IS_ENABLED(READ_ONLY) 275void *dm_priv_to_rw(void *priv) 276{ 277 long offset = priv - (void *)__priv_data_start; 278 279 return gd_dm_priv_base() + offset; 280} 281#endif 282 283static int dm_probe_devices(struct udevice *dev, bool pre_reloc_only) 284{ 285 ofnode node = dev_ofnode(dev); 286 struct udevice *child; 287 int ret; 288 289 if (pre_reloc_only && 290 (!ofnode_valid(node) || !ofnode_pre_reloc(node)) && 291 !(dev->driver->flags & DM_FLAG_PRE_RELOC)) 292 goto probe_children; 293 294 if (dev_get_flags(dev) & DM_FLAG_PROBE_AFTER_BIND) { 295 ret = device_probe(dev); 296 if (ret) 297 return ret; 298 } 299 300probe_children: 301 list_for_each_entry(child, &dev->child_head, sibling_node) 302 dm_probe_devices(child, pre_reloc_only); 303 304 return 0; 305} 306 307/** 308 * dm_scan() - Scan tables to bind devices 309 * 310 * Runs through the driver_info tables and binds the devices it finds. Then runs 311 * through the devicetree nodes. Finally calls dm_scan_other() to add any 312 * special devices 313 * 314 * @pre_reloc_only: If true, bind only nodes with special devicetree properties, 315 * or drivers with the DM_FLAG_PRE_RELOC flag. If false bind all drivers. 316 */ 317static int dm_scan(bool pre_reloc_only) 318{ 319 int ret; 320 321 ret = dm_scan_plat(pre_reloc_only); 322 if (ret) { 323 debug("dm_scan_plat() failed: %d\n", ret); 324 return ret; 325 } 326 327 if (CONFIG_IS_ENABLED(OF_REAL)) { 328 ret = dm_extended_scan(pre_reloc_only); 329 if (ret) { 330 debug("dm_extended_scan() failed: %d\n", ret); 331 return ret; 332 } 333 } 334 335 ret = dm_scan_other(pre_reloc_only); 336 if (ret) 337 return ret; 338 339 return dm_probe_devices(gd->dm_root, pre_reloc_only); 340} 341 342int dm_init_and_scan(bool pre_reloc_only) 343{ 344 int ret; 345 346 ret = dm_init(CONFIG_IS_ENABLED(OF_LIVE)); 347 if (ret) { 348 debug("dm_init() failed: %d\n", ret); 349 return ret; 350 } 351 if (!CONFIG_IS_ENABLED(OF_PLATDATA_INST)) { 352 ret = dm_scan(pre_reloc_only); 353 if (ret) { 354 log_debug("dm_scan() failed: %d\n", ret); 355 return ret; 356 } 357 } 358 if (CONFIG_IS_ENABLED(DM_EVENT)) { 359 ret = event_notify_null(gd->flags & GD_FLG_RELOC ? 360 EVT_DM_POST_INIT_R : 361 EVT_DM_POST_INIT_F); 362 if (ret) 363 return log_msg_ret("ev", ret); 364 } 365 366 return 0; 367} 368 369void dm_get_stats(int *device_countp, int *uclass_countp) 370{ 371 *device_countp = device_get_decendent_count(gd->dm_root); 372 *uclass_countp = uclass_get_count(); 373} 374 375void dev_collect_stats(struct dm_stats *stats, const struct udevice *parent) 376{ 377 const struct udevice *dev; 378 int i; 379 380 stats->dev_count++; 381 stats->dev_size += sizeof(struct udevice); 382 stats->dev_name_size += strlen(parent->name) + 1; 383 for (i = 0; i < DM_TAG_ATTACH_COUNT; i++) { 384 int size = dev_get_attach_size(parent, i); 385 386 if (size || 387 (i == DM_TAG_DRIVER_DATA && parent->driver_data)) { 388 stats->attach_count[i]++; 389 stats->attach_size[i] += size; 390 stats->attach_count_total++; 391 stats->attach_size_total += size; 392 } 393 } 394 395 list_for_each_entry(dev, &parent->child_head, sibling_node) 396 dev_collect_stats(stats, dev); 397} 398 399void uclass_collect_stats(struct dm_stats *stats) 400{ 401 struct uclass *uc; 402 403 list_for_each_entry(uc, gd->uclass_root, sibling_node) { 404 int size; 405 406 stats->uc_count++; 407 stats->uc_size += sizeof(struct uclass); 408 size = uc->uc_drv->priv_auto; 409 if (size) { 410 stats->uc_attach_count++; 411 stats->uc_attach_size += size; 412 } 413 } 414} 415 416void dm_get_mem(struct dm_stats *stats) 417{ 418 memset(stats, '\0', sizeof(*stats)); 419 dev_collect_stats(stats, gd->dm_root); 420 uclass_collect_stats(stats); 421 dev_tag_collect_stats(stats); 422 423 stats->total_size = stats->dev_size + stats->uc_size + 424 stats->attach_size_total + stats->uc_attach_size + 425 stats->tag_size; 426} 427 428#if CONFIG_IS_ENABLED(ACPIGEN) 429static int root_acpi_get_name(const struct udevice *dev, char *out_name) 430{ 431 return acpi_copy_name(out_name, "\\_SB"); 432} 433 434struct acpi_ops root_acpi_ops = { 435 .get_name = root_acpi_get_name, 436}; 437#endif 438 439/* This is the root driver - all drivers are children of this */ 440U_BOOT_DRIVER(root_driver) = { 441 .name = "root_driver", 442 .id = UCLASS_ROOT, 443 ACPI_OPS_PTR(&root_acpi_ops) 444}; 445 446/* This is the root uclass */ 447UCLASS_DRIVER(root) = { 448 .name = "root", 449 .id = UCLASS_ROOT, 450}; 451