drivers/core/dump.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright (c) 2015 Google, Inc
   4  */
   5
   6 #include <common.h>
   7 #include <dm.h>
   8 #include <malloc.h>
   9 #include <mapmem.h>
  10 #include <sort.h>
  11 #include <dm/root.h>
  12 #include <dm/util.h>
  13 #include <dm/uclass-internal.h>
  14
  15 /**
  16  * struct sort_info - information used for sorting
  17  *
  18  * @dev: List of devices
  19  * @alloced: Maximum number of devices in @dev
  20  */
  21 struct sort_info {
  22         struct udevice **dev;
  23         int size;
  24 };
  25
  26 static int h_cmp_uclass_id(const void *d1, const void *d2)
  27 {
  28         const struct udevice *const *dev1 = d1;
  29         const struct udevice *const *dev2 = d2;
  30
  31         return device_get_uclass_id(*dev1) - device_get_uclass_id(*dev2);
  32 }
  33
  34 static void show_devices(struct udevice *dev, int depth, int last_flag,
  35                          struct udevice **devs)
  36 {
  37         int i, is_last;
  38         struct udevice *child;
  39         u32 flags = dev_get_flags(dev);
  40
  41         /* print the first 20 characters to not break the tree-format. */
  42         printf(CONFIG_IS_ENABLED(USE_TINY_PRINTF) ? " %s  %d  [ %c ]   %s  " :
  43                " %-10.10s  %3d  [ %c ]   %-20.20s  ", dev->uclass->uc_drv->name,
  44                dev_get_uclass_index(dev, NULL),
  45                flags & DM_FLAG_ACTIVATED ? '+' : ' ', dev->driver->name);
  46
  47         for (i = depth; i >= 0; i--) {
  48                 is_last = (last_flag >> i) & 1;
  49                 if (i) {
  50                         if (is_last)
  51                                 printf("    ");
  52                         else
  53                                 printf("|   ");
  54                 } else {
  55                         if (is_last)
  56                                 printf("`-- ");
  57                         else
  58                                 printf("|-- ");
  59                 }
  60         }
  61
  62         printf("%s\n", dev->name);
  63
  64         if (devs) {
  65                 int count;
  66                 int i;
  67
  68                 count = 0;
  69                 device_foreach_child(child, dev)
  70                         devs[count++] = child;
  71                 qsort(devs, count, sizeof(struct udevice *), h_cmp_uclass_id);
  72
  73                 for (i = 0; i < count; i++) {
  74                         show_devices(devs[i], depth + 1,
  75                                      (last_flag << 1) | (i == count - 1),
  76                                      devs + count);
  77                 }
  78         } else {
  79                 device_foreach_child(child, dev) {
  80                         is_last = list_is_last(&child->sibling_node,
  81                                                &dev->child_head);
  82                         show_devices(child, depth + 1,
  83                                      (last_flag << 1) | is_last, NULL);
  84                 }
  85         }
  86 }
  87
  88 void dm_dump_tree(bool sort)
  89 {
  90         struct udevice *root;
  91
  92         root = dm_root();
  93         if (root) {
  94                 int dev_count, uclasses;
  95                 struct udevice **devs = NULL;
  96
  97                 dm_get_stats(&dev_count, &uclasses);
  98
  99                 printf(" Class     Index  Probed  Driver                Name\n");
 100                 printf("-----------------------------------------------------------\n");
 101                 if (sort) {
 102                         devs = calloc(dev_count, sizeof(struct udevice *));
 103                         if (!devs) {
 104                                 printf("(out of memory)\n");
 105                                 return;
 106                         }
 107                 }
 108                 show_devices(root, -1, 0, devs);
 109                 free(devs);
 110         }
 111 }
 112
 113 /**
 114  * dm_display_line() - Display information about a single device
 115  *
 116  * Displays a single line of information with an option prefix
 117  *
 118  * @dev:        Device to display
 119  */
 120 static void dm_display_line(struct udevice *dev, int index)
 121 {
 122         printf("%-3i %c %s @ %08lx", index,
 123                dev_get_flags(dev) & DM_FLAG_ACTIVATED ? '*' : ' ',
 124                dev->name, (ulong)map_to_sysmem(dev));
 125         if (dev->seq_ != -1)
 126                 printf(", seq %d", dev_seq(dev));
 127         puts("\n");
 128 }
 129
 130 void dm_dump_uclass(void)
 131 {
 132         struct uclass *uc;
 133         int ret;
 134         int id;
 135
 136         for (id = 0; id < UCLASS_COUNT; id++) {
 137                 struct udevice *dev;
 138                 int i = 0;
 139
 140                 ret = uclass_get(id, &uc);
 141                 if (ret)
 142                         continue;
 143
 144                 printf("uclass %d: %s\n", id, uc->uc_drv->name);
 145                 uclass_foreach_dev(dev, uc) {
 146                         dm_display_line(dev, i);
 147                         i++;
 148                 }
 149                 puts("\n");
 150         }
 151 }
 152
 153 void dm_dump_driver_compat(void)
 154 {
 155         struct driver *d = ll_entry_start(struct driver, driver);
 156         const int n_ents = ll_entry_count(struct driver, driver);
 157         struct driver *entry;
 158         const struct udevice_id *match;
 159
 160         puts("Driver                Compatible\n");
 161         puts("--------------------------------\n");
 162         for (entry = d; entry < d + n_ents; entry++) {
 163                 match = entry->of_match;
 164
 165                 printf("%-20.20s", entry->name);
 166                 if (match) {
 167                         printf("  %s", match->compatible);
 168                         match++;
 169                 }
 170                 printf("\n");
 171
 172                 for (; match && match->compatible; match++)
 173                         printf("%-20.20s  %s\n", "", match->compatible);
 174         }
 175 }
 176
 177 void dm_dump_drivers(void)
 178 {
 179         struct driver *d = ll_entry_start(struct driver, driver);
 180         const int n_ents = ll_entry_count(struct driver, driver);
 181         struct driver *entry;
 182         struct udevice *udev;
 183         struct uclass *uc;
 184         int ret;
 185         int i;
 186
 187         puts("Driver                    uid uclass               Devices\n");
 188         puts("----------------------------------------------------------\n");
 189
 190         for (entry = d; entry < d + n_ents; entry++) {
 191                 ret = uclass_get(entry->id, &uc);
 192
 193                 printf("%-25.25s %-3.3d %-20.20s ", entry->name, entry->id,
 194                        !ret ? uc->uc_drv->name : "<no uclass>");
 195
 196                 if (ret) {
 197                         puts("\n");
 198                         continue;
 199                 }
 200
 201                 i = 0;
 202                 uclass_foreach_dev(udev, uc) {
 203                         if (udev->driver != entry)
 204                                 continue;
 205                         if (i)
 206                                 printf("%-51.51s", "");
 207
 208                         printf("%-25.25s\n", udev->name);
 209                         i++;
 210                 }
 211                 if (!i)
 212                         puts("<none>\n");
 213         }
 214 }
 215
 216 void dm_dump_static_driver_info(void)
 217 {
 218         struct driver_info *drv = ll_entry_start(struct driver_info,
 219                                                  driver_info);
 220         const int n_ents = ll_entry_count(struct driver_info, driver_info);
 221         struct driver_info *entry;
 222
 223         puts("Driver                    Address\n");
 224         puts("---------------------------------\n");
 225         for (entry = drv; entry != drv + n_ents; entry++)
 226                 printf("%-25.25s %p\n", entry->name, entry->plat);
 227 }
 228
 229 void dm_dump_mem(struct dm_stats *stats)
 230 {
 231         int total, total_delta;
 232         int i;
 233
 234         /* Support SPL printf() */
 235         printf("Struct sizes: udevice %x, driver %x, uclass %x, uc_driver %x\n",
 236                (int)sizeof(struct udevice), (int)sizeof(struct driver),
 237                (int)sizeof(struct uclass), (int)sizeof(struct uclass_driver));
 238         printf("Memory: device %x:%x, device names %x, uclass %x:%x\n",
 239                stats->dev_count, stats->dev_size, stats->dev_name_size,
 240                stats->uc_count, stats->uc_size);
 241         printf("\n");
 242         printf("%-15s  %5s  %5s  %5s  %5s  %5s\n", "Attached type", "Count",
 243                "Size", "Cur", "Tags", "Save");
 244         printf("%-15s  %5s  %5s  %5s  %5s  %5s\n", "---------------", "-----",
 245                "-----", "-----", "-----", "-----");
 246         total_delta = 0;
 247         for (i = 0; i < DM_TAG_ATTACH_COUNT; i++) {
 248                 int cur_size, new_size, delta;
 249
 250                 cur_size = stats->dev_count * sizeof(struct udevice);
 251                 new_size = stats->dev_count * (sizeof(struct udevice) -
 252                         sizeof(void *));
 253                 /*
 254                  * Let's assume we can fit each dmtag_node into 32 bits. We can
 255                  * limit the 'tiny tags' feature to SPL with
 256                  * CONFIG_SPL_SYS_MALLOC_F_LEN <= 64KB, so needing 14 bits to
 257                  * point to anything in that region (with 4-byte alignment).
 258                  * So:
 259                  *    4 bits for tag
 260                  *    14 bits for offset of dev
 261                  *    14 bits for offset of data
 262                  */
 263                 new_size += stats->attach_count[i] * sizeof(u32);
 264                 delta = cur_size - new_size;
 265                 total_delta += delta;
 266                 printf("%-16s %5x %6x %6x %6x %6x (%d)\n", tag_get_name(i),
 267                        stats->attach_count[i], stats->attach_size[i],
 268                        cur_size, new_size, delta > 0 ? delta : 0, delta);
 269         }
 270         printf("%-16s %5x %6x\n", "uclass", stats->uc_attach_count,
 271                stats->uc_attach_size);
 272         printf("%-16s %5x %6x  %5s  %5s  %6x (%d)\n", "Attached total",
 273                stats->attach_count_total + stats->uc_attach_count,
 274                stats->attach_size_total + stats->uc_attach_size, "", "",
 275                total_delta > 0 ? total_delta : 0, total_delta);
 276         printf("%-16s %5x %6x\n", "tags", stats->tag_count, stats->tag_size);
 277         printf("\n");
 278         printf("Total size: %x (%d)\n", stats->total_size, stats->total_size);
 279         printf("\n");
 280
 281         total = stats->total_size;
 282         total -= total_delta;
 283         printf("With tags:       %x (%d)\n", total, total);
 284
 285         /* Use singly linked lists in struct udevice (3 nodes in each) */
 286         total -= sizeof(void *) * 3 * stats->dev_count;
 287         printf("- singly-linked: %x (%d)\n", total, total);
 288
 289         /* Use an index into the struct_driver list instead of a pointer */
 290         total = total + stats->dev_count * (1 - sizeof(void *));
 291         printf("- driver index:  %x (%d)\n", total, total);
 292
 293         /* Same with the uclass */
 294         total = total + stats->dev_count * (1 - sizeof(void *));
 295         printf("- uclass index:  %x (%d)\n", total, total);
 296
 297         /* Drop the device name */
 298         printf("Drop device name (not SRAM): %x (%d)\n", stats->dev_name_size,
 299                stats->dev_name_size);
 300 }