Tom Rini | 83d290c | 2018-05-06 17:58:06 -0400 | [diff] [blame] | 1 | // SPDX-License-Identifier: GPL-2.0+ |
Simon Glass | aa53233 | 2014-06-11 23:29:41 -0600 | [diff] [blame] | 2 | /* |
| 3 | * Copyright (c) 2014 Google, Inc. |
Simon Glass | aa53233 | 2014-06-11 23:29:41 -0600 | [diff] [blame] | 4 | */ |
| 5 | |
| 6 | #define IOTRACE_IMPL |
| 7 | |
| 8 | #include <common.h> |
Joe Hershberger | 0eb25b6 | 2015-03-22 17:08:59 -0500 | [diff] [blame] | 9 | #include <mapmem.h> |
Simon Glass | aa53233 | 2014-06-11 23:29:41 -0600 | [diff] [blame] | 10 | #include <asm/io.h> |
| 11 | |
| 12 | DECLARE_GLOBAL_DATA_PTR; |
| 13 | |
Simon Glass | aa53233 | 2014-06-11 23:29:41 -0600 | [diff] [blame] | 14 | /** |
| 15 | * struct iotrace - current trace status and checksum |
| 16 | * |
| 17 | * @start: Start address of iotrace buffer |
Ramon Fried | e0212df | 2018-06-08 20:53:27 +0300 | [diff] [blame] | 18 | * @size: Actual size of iotrace buffer in bytes |
| 19 | * @needed_size: Needed of iotrace buffer in bytes |
Simon Glass | aa53233 | 2014-06-11 23:29:41 -0600 | [diff] [blame] | 20 | * @offset: Current write offset into iotrace buffer |
Ramon Fried | a74440b | 2018-05-30 23:09:58 +0300 | [diff] [blame] | 21 | * @region_start: Address of IO region to trace |
| 22 | * @region_size: Size of region to trace. if 0 will trace all address space |
Simon Glass | aa53233 | 2014-06-11 23:29:41 -0600 | [diff] [blame] | 23 | * @crc32: Current value of CRC chceksum of trace records |
| 24 | * @enabled: true if enabled, false if disabled |
| 25 | */ |
| 26 | static struct iotrace { |
| 27 | ulong start; |
| 28 | ulong size; |
Ramon Fried | e0212df | 2018-06-08 20:53:27 +0300 | [diff] [blame] | 29 | ulong needed_size; |
Simon Glass | aa53233 | 2014-06-11 23:29:41 -0600 | [diff] [blame] | 30 | ulong offset; |
Ramon Fried | a74440b | 2018-05-30 23:09:58 +0300 | [diff] [blame] | 31 | ulong region_start; |
| 32 | ulong region_size; |
Simon Glass | aa53233 | 2014-06-11 23:29:41 -0600 | [diff] [blame] | 33 | u32 crc32; |
| 34 | bool enabled; |
| 35 | } iotrace; |
| 36 | |
| 37 | static void add_record(int flags, const void *ptr, ulong value) |
| 38 | { |
| 39 | struct iotrace_record srec, *rec = &srec; |
| 40 | |
| 41 | /* |
| 42 | * We don't support iotrace before relocation. Since the trace buffer |
| 43 | * is set up by a command, it can't be enabled at present. To change |
| 44 | * this we would need to set the iotrace buffer at build-time. See |
| 45 | * lib/trace.c for how this might be done if you are interested. |
| 46 | */ |
| 47 | if (!(gd->flags & GD_FLG_RELOC) || !iotrace.enabled) |
| 48 | return; |
| 49 | |
Ramon Fried | a74440b | 2018-05-30 23:09:58 +0300 | [diff] [blame] | 50 | if (iotrace.region_size) |
| 51 | if ((ulong)ptr < iotrace.region_start || |
| 52 | (ulong)ptr > iotrace.region_start + iotrace.region_size) |
| 53 | return; |
| 54 | |
Simon Glass | aa53233 | 2014-06-11 23:29:41 -0600 | [diff] [blame] | 55 | /* Store it if there is room */ |
| 56 | if (iotrace.offset + sizeof(*rec) < iotrace.size) { |
| 57 | rec = (struct iotrace_record *)map_sysmem( |
| 58 | iotrace.start + iotrace.offset, |
| 59 | sizeof(value)); |
Ramon Fried | e0212df | 2018-06-08 20:53:27 +0300 | [diff] [blame] | 60 | } else { |
| 61 | WARN_ONCE(1, "WARNING: iotrace buffer exhausted, please check needed length using \"iotrace stats\"\n"); |
| 62 | iotrace.needed_size += sizeof(struct iotrace_record); |
| 63 | return; |
Simon Glass | aa53233 | 2014-06-11 23:29:41 -0600 | [diff] [blame] | 64 | } |
Ramon Fried | e0212df | 2018-06-08 20:53:27 +0300 | [diff] [blame] | 65 | |
Ramon Fried | b5e0e36 | 2018-05-30 23:09:59 +0300 | [diff] [blame] | 66 | rec->timestamp = timer_get_us(); |
Simon Glass | aa53233 | 2014-06-11 23:29:41 -0600 | [diff] [blame] | 67 | rec->flags = flags; |
| 68 | rec->addr = map_to_sysmem(ptr); |
| 69 | rec->value = value; |
| 70 | |
| 71 | /* Update our checksum */ |
| 72 | iotrace.crc32 = crc32(iotrace.crc32, (unsigned char *)rec, |
| 73 | sizeof(*rec)); |
| 74 | |
Ramon Fried | e0212df | 2018-06-08 20:53:27 +0300 | [diff] [blame] | 75 | iotrace.needed_size += sizeof(struct iotrace_record); |
Simon Glass | aa53233 | 2014-06-11 23:29:41 -0600 | [diff] [blame] | 76 | iotrace.offset += sizeof(struct iotrace_record); |
| 77 | } |
| 78 | |
| 79 | u32 iotrace_readl(const void *ptr) |
| 80 | { |
| 81 | u32 v; |
| 82 | |
| 83 | v = readl(ptr); |
| 84 | add_record(IOT_32 | IOT_READ, ptr, v); |
| 85 | |
| 86 | return v; |
| 87 | } |
| 88 | |
| 89 | void iotrace_writel(ulong value, const void *ptr) |
| 90 | { |
| 91 | add_record(IOT_32 | IOT_WRITE, ptr, value); |
| 92 | writel(value, ptr); |
| 93 | } |
| 94 | |
| 95 | u16 iotrace_readw(const void *ptr) |
| 96 | { |
| 97 | u32 v; |
| 98 | |
| 99 | v = readw(ptr); |
| 100 | add_record(IOT_16 | IOT_READ, ptr, v); |
| 101 | |
| 102 | return v; |
| 103 | } |
| 104 | |
| 105 | void iotrace_writew(ulong value, const void *ptr) |
| 106 | { |
| 107 | add_record(IOT_16 | IOT_WRITE, ptr, value); |
| 108 | writew(value, ptr); |
| 109 | } |
| 110 | |
| 111 | u8 iotrace_readb(const void *ptr) |
| 112 | { |
| 113 | u32 v; |
| 114 | |
| 115 | v = readb(ptr); |
| 116 | add_record(IOT_8 | IOT_READ, ptr, v); |
| 117 | |
| 118 | return v; |
| 119 | } |
| 120 | |
| 121 | void iotrace_writeb(ulong value, const void *ptr) |
| 122 | { |
| 123 | add_record(IOT_8 | IOT_WRITE, ptr, value); |
| 124 | writeb(value, ptr); |
| 125 | } |
| 126 | |
| 127 | void iotrace_reset_checksum(void) |
| 128 | { |
| 129 | iotrace.crc32 = 0; |
| 130 | } |
| 131 | |
| 132 | u32 iotrace_get_checksum(void) |
| 133 | { |
| 134 | return iotrace.crc32; |
| 135 | } |
| 136 | |
Ramon Fried | a74440b | 2018-05-30 23:09:58 +0300 | [diff] [blame] | 137 | void iotrace_set_region(ulong start, ulong size) |
| 138 | { |
| 139 | iotrace.region_start = start; |
| 140 | iotrace.region_size = size; |
| 141 | } |
| 142 | |
| 143 | void iotrace_reset_region(void) |
| 144 | { |
| 145 | iotrace.region_start = 0; |
| 146 | iotrace.region_size = 0; |
| 147 | } |
| 148 | |
| 149 | void iotrace_get_region(ulong *start, ulong *size) |
| 150 | { |
| 151 | *start = iotrace.region_start; |
| 152 | *size = iotrace.region_size; |
| 153 | } |
| 154 | |
Simon Glass | aa53233 | 2014-06-11 23:29:41 -0600 | [diff] [blame] | 155 | void iotrace_set_enabled(int enable) |
| 156 | { |
| 157 | iotrace.enabled = enable; |
| 158 | } |
| 159 | |
| 160 | int iotrace_get_enabled(void) |
| 161 | { |
| 162 | return iotrace.enabled; |
| 163 | } |
| 164 | |
| 165 | void iotrace_set_buffer(ulong start, ulong size) |
| 166 | { |
| 167 | iotrace.start = start; |
| 168 | iotrace.size = size; |
| 169 | iotrace.offset = 0; |
| 170 | iotrace.crc32 = 0; |
| 171 | } |
| 172 | |
Ramon Fried | e0212df | 2018-06-08 20:53:27 +0300 | [diff] [blame] | 173 | void iotrace_get_buffer(ulong *start, ulong *size, ulong *needed_size, ulong *offset, ulong *count) |
Simon Glass | aa53233 | 2014-06-11 23:29:41 -0600 | [diff] [blame] | 174 | { |
| 175 | *start = iotrace.start; |
| 176 | *size = iotrace.size; |
Ramon Fried | e0212df | 2018-06-08 20:53:27 +0300 | [diff] [blame] | 177 | *needed_size = iotrace.needed_size; |
Simon Glass | aa53233 | 2014-06-11 23:29:41 -0600 | [diff] [blame] | 178 | *offset = iotrace.offset; |
| 179 | *count = iotrace.offset / sizeof(struct iotrace_record); |
| 180 | } |