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 static void print_time(unsigned long us_time)
  94 {
  95         char str[15], *s;
  96         int grab = 3;
  97
  98         /* We don't seem to have %'d in U-Boot */
  99         sprintf(str, "%12lu", us_time);
 100         for (s = str + 3; *s; s += grab) {
 101                 if (s != str + 3)
 102                         putc(s[-1] != ' ' ? ',' : ' ');
 103                 printf("%.*s", grab, s);
 104                 grab = 3;
 105         }
 106 }
 107
 108 static uint32_t print_time_record(enum bootstage_id id,
 109                         struct bootstage_record *rec, uint32_t prev)
 110 {
 111         print_time(rec->time_us);
 112         print_time(rec->time_us - prev);
 113         if (rec->name)
 114                 printf("  %s\n", rec->name);
 115         else if (id >= BOOTSTAGE_ID_USER)
 116                 printf("  user_%d\n", id - BOOTSTAGE_ID_USER);
 117         else
 118                 printf("  id=%d\n", id);
 119         return rec->time_us;
 120 }
 121
 122 static int h_compare_record(const void *r1, const void *r2)
 123 {
 124         const struct bootstage_record *rec1 = r1, *rec2 = r2;
 125
 126         return rec1->time_us > rec2->time_us ? 1 : -1;
 127 }
 128
 129 void bootstage_report(void)
 130 {
 131         struct bootstage_record *rec = record;
 132         int id;
 133         uint32_t prev;
 134
 135         puts("Timer summary in microseconds:\n");
 136         printf("%11s%11s  %s\n", "Mark", "Elapsed", "Stage");
 137
 138         /* Fake the first record - we could get it from early boot */
 139         rec->name = "reset";
 140         rec->time_us = 0;
 141         prev = print_time_record(BOOTSTAGE_ID_AWAKE, rec, 0);
 142
 143         /* Sort records by increasing time */
 144         qsort(record, ARRAY_SIZE(record), sizeof(*rec), h_compare_record);
 145
 146         for (id = 0; id < BOOTSTAGE_ID_COUNT; id++, rec++) {
 147                 if (rec->time_us != 0)
 148                         prev = print_time_record(rec->id, rec, prev);
 149         }
 150         if (next_id > BOOTSTAGE_ID_COUNT)
 151                 printf("(Overflowed internal boot id table by %d entries\n"
 152                         "- please increase CONFIG_BOOTSTAGE_USER_COUNT\n",
 153                        next_id - BOOTSTAGE_ID_COUNT);
 154 }
 155
 156 ulong __timer_get_boot_us(void)
 157 {
 158         static ulong base_time;
 159
 160         /*
 161          * We can't implement this properly. Return 0 on the first call and
 162          * larger values after that.
 163          */
 164         if (base_time)
 165                 return get_timer(base_time) * 1000;
 166         base_time = get_timer(0);
 167         return 0;
 168 }
 169
 170 ulong timer_get_boot_us(void)
 171         __attribute__((weak, alias("__timer_get_boot_us")));