common/bootstage.c

   1 /*
   2  * Copyright (c) 2011, Google Inc. All rights reserved.
   3  *
   4  * See file CREDITS for list of people who contributed to this
   5  * project.
   6  *
   7  * This program is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License as
   9  * published by the Free Software Foundation; either version 2 of
  10  * the License, or (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  20  * MA 02111-1307 USA
  21  */
  22
  23
  24 /*
  25  * This module records the progress of boot and arbitrary commands, and
  26  * permits accurate timestamping of each.
  27  *
  28  * TBD: Pass timings to kernel in the FDT
  29  */
  30
  31 #include <common.h>
  32 #include <libfdt.h>
  33
  34 DECLARE_GLOBAL_DATA_PTR;
  35
  36 struct bootstage_record {
  37         ulong time_us;
  38         uint32_t start_us;
  39         const char *name;
  40         int flags;              /* see enum bootstage_flags */
  41         enum bootstage_id id;
  42 };
  43
  44 static struct bootstage_record record[BOOTSTAGE_ID_COUNT] = { {1} };
  45 static int next_id = BOOTSTAGE_ID_USER;
  46
  47 ulong bootstage_add_record(enum bootstage_id id, const char *name,
  48                            int flags, ulong mark)
  49 {
  50         struct bootstage_record *rec;
  51
  52         if (flags & BOOTSTAGEF_ALLOC)
  53                 id = next_id++;
  54
  55         if (id < BOOTSTAGE_ID_COUNT) {
  56                 rec = &record[id];
  57
  58                 /* Only record the first event for each */
  59                 if (!rec->time_us) {
  60                         rec->time_us = mark;
  61                         rec->name = name;
  62                         rec->flags = flags;
  63                         rec->id = id;
  64                 }
  65         }
  66
  67         /* Tell the board about this progress */
  68         show_boot_progress(flags & BOOTSTAGEF_ERROR ? -id : id);
  69         return mark;
  70 }
  71
  72
  73 ulong bootstage_mark(enum bootstage_id id)
  74 {
  75         return bootstage_add_record(id, NULL, 0, timer_get_boot_us());
  76 }
  77
  78 ulong bootstage_error(enum bootstage_id id)
  79 {
  80         return bootstage_add_record(id, NULL, BOOTSTAGEF_ERROR,
  81                                     timer_get_boot_us());
  82 }
  83
  84 ulong bootstage_mark_name(enum bootstage_id id, const char *name)
  85 {
  86         int flags = 0;
  87
  88         if (id == BOOTSTAGE_ID_ALLOC)
  89                 flags = BOOTSTAGEF_ALLOC;
  90         return bootstage_add_record(id, name, flags, timer_get_boot_us());
  91 }
  92
  93 uint32_t bootstage_start(enum bootstage_id id, const char *name)
  94 {
  95         struct bootstage_record *rec = &record[id];
  96
  97         rec->start_us = timer_get_boot_us();
  98         rec->name = name;
  99         return rec->start_us;
 100 }
 101
 102 uint32_t bootstage_accum(enum bootstage_id id)
 103 {
 104         struct bootstage_record *rec = &record[id];
 105         uint32_t duration;
 106
 107         duration = (uint32_t)timer_get_boot_us() - rec->start_us;
 108         rec->time_us += duration;
 109         return duration;
 110 }
 111
 112 static void print_time(unsigned long us_time)
 113 {
 114         char str[15], *s;
 115         int grab = 3;
 116
 117         /* We don't seem to have %'d in U-Boot */
 118         sprintf(str, "%12lu", us_time);
 119         for (s = str + 3; *s; s += grab) {
 120                 if (s != str + 3)
 121                         putc(s[-1] != ' ' ? ',' : ' ');
 122                 printf("%.*s", grab, s);
 123                 grab = 3;
 124         }
 125 }
 126
 127 static uint32_t print_time_record(enum bootstage_id id,
 128                         struct bootstage_record *rec, uint32_t prev)
 129 {
 130         if (prev == -1U) {
 131                 printf("%11s", "");
 132                 print_time(rec->time_us);
 133         } else {
 134                 print_time(rec->time_us);
 135                 print_time(rec->time_us - prev);
 136         }
 137         if (rec->name)
 138                 printf("  %s\n", rec->name);
 139         else if (id >= BOOTSTAGE_ID_USER)
 140                 printf("  user_%d\n", id - BOOTSTAGE_ID_USER);
 141         else
 142                 printf("  id=%d\n", id);
 143         return rec->time_us;
 144 }
 145
 146 static int h_compare_record(const void *r1, const void *r2)
 147 {
 148         const struct bootstage_record *rec1 = r1, *rec2 = r2;
 149
 150         return rec1->time_us > rec2->time_us ? 1 : -1;
 151 }
 152
 153 void bootstage_report(void)
 154 {
 155         struct bootstage_record *rec = record;
 156         int id;
 157         uint32_t prev;
 158
 159         puts("Timer summary in microseconds:\n");
 160         printf("%11s%11s  %s\n", "Mark", "Elapsed", "Stage");
 161
 162         /* Fake the first record - we could get it from early boot */
 163         rec->name = "reset";
 164         rec->time_us = 0;
 165         prev = print_time_record(BOOTSTAGE_ID_AWAKE, rec, 0);
 166
 167         /* Sort records by increasing time */
 168         qsort(record, ARRAY_SIZE(record), sizeof(*rec), h_compare_record);
 169
 170         for (id = 0; id < BOOTSTAGE_ID_COUNT; id++, rec++) {
 171                 if (rec->time_us != 0 && !rec->start_us)
 172                         prev = print_time_record(rec->id, rec, prev);
 173         }
 174         if (next_id > BOOTSTAGE_ID_COUNT)
 175                 printf("(Overflowed internal boot id table by %d entries\n"
 176                         "- please increase CONFIG_BOOTSTAGE_USER_COUNT\n",
 177                        next_id - BOOTSTAGE_ID_COUNT);
 178
 179         puts("\nAccumulated time:\n");
 180         for (id = 0, rec = record; id < BOOTSTAGE_ID_COUNT; id++, rec++) {
 181                 if (rec->start_us)
 182                         prev = print_time_record(id, rec, -1);
 183         }
 184 }
 185
 186 ulong __timer_get_boot_us(void)
 187 {
 188         static ulong base_time;
 189
 190         /*
 191          * We can't implement this properly. Return 0 on the first call and
 192          * larger values after that.
 193          */
 194         if (base_time)
 195                 return get_timer(base_time) * 1000;
 196         base_time = get_timer(0);
 197         return 0;
 198 }
 199
 200 ulong timer_get_boot_us(void)
 201         __attribute__((weak, alias("__timer_get_boot_us")));