avr32: use dlmalloc for DMA buffers
[oweals/u-boot.git] / common / iotrace.c
1 /*
2  * Copyright (c) 2014 Google, Inc.
3  *
4  * SPDX-License-Identifier:     GPL-2.0+
5  */
6
7 #define IOTRACE_IMPL
8
9 #include <common.h>
10 #include <asm/io.h>
11
12 DECLARE_GLOBAL_DATA_PTR;
13
14 /* Support up to the machine word length for now */
15 typedef ulong iovalue_t;
16
17 enum iotrace_flags {
18         IOT_8 = 0,
19         IOT_16,
20         IOT_32,
21
22         IOT_READ = 0 << 3,
23         IOT_WRITE = 1 << 3,
24 };
25
26 /**
27  * struct iotrace_record - Holds a single I/O trace record
28  *
29  * @flags: I/O access type
30  * @addr: Address of access
31  * @value: Value written or read
32  */
33 struct iotrace_record {
34         enum iotrace_flags flags;
35         phys_addr_t addr;
36         iovalue_t value;
37 };
38
39 /**
40  * struct iotrace - current trace status and checksum
41  *
42  * @start:      Start address of iotrace buffer
43  * @size:       Size of iotrace buffer in bytes
44  * @offset:     Current write offset into iotrace buffer
45  * @crc32:      Current value of CRC chceksum of trace records
46  * @enabled:    true if enabled, false if disabled
47  */
48 static struct iotrace {
49         ulong start;
50         ulong size;
51         ulong offset;
52         u32 crc32;
53         bool enabled;
54 } iotrace;
55
56 static void add_record(int flags, const void *ptr, ulong value)
57 {
58         struct iotrace_record srec, *rec = &srec;
59
60         /*
61          * We don't support iotrace before relocation. Since the trace buffer
62          * is set up by a command, it can't be enabled at present. To change
63          * this we would need to set the iotrace buffer at build-time. See
64          * lib/trace.c for how this might be done if you are interested.
65          */
66         if (!(gd->flags & GD_FLG_RELOC) || !iotrace.enabled)
67                 return;
68
69         /* Store it if there is room */
70         if (iotrace.offset + sizeof(*rec) < iotrace.size) {
71                 rec = (struct iotrace_record *)map_sysmem(
72                                         iotrace.start + iotrace.offset,
73                                         sizeof(value));
74         }
75
76         rec->flags = flags;
77         rec->addr = map_to_sysmem(ptr);
78         rec->value = value;
79
80         /* Update our checksum */
81         iotrace.crc32 = crc32(iotrace.crc32, (unsigned char *)rec,
82                               sizeof(*rec));
83
84         iotrace.offset += sizeof(struct iotrace_record);
85 }
86
87 u32 iotrace_readl(const void *ptr)
88 {
89         u32 v;
90
91         v = readl(ptr);
92         add_record(IOT_32 | IOT_READ, ptr, v);
93
94         return v;
95 }
96
97 void iotrace_writel(ulong value, const void *ptr)
98 {
99         add_record(IOT_32 | IOT_WRITE, ptr, value);
100         writel(value, ptr);
101 }
102
103 u16 iotrace_readw(const void *ptr)
104 {
105         u32 v;
106
107         v = readw(ptr);
108         add_record(IOT_16 | IOT_READ, ptr, v);
109
110         return v;
111 }
112
113 void iotrace_writew(ulong value, const void *ptr)
114 {
115         add_record(IOT_16 | IOT_WRITE, ptr, value);
116         writew(value, ptr);
117 }
118
119 u8 iotrace_readb(const void *ptr)
120 {
121         u32 v;
122
123         v = readb(ptr);
124         add_record(IOT_8 | IOT_READ, ptr, v);
125
126         return v;
127 }
128
129 void iotrace_writeb(ulong value, const void *ptr)
130 {
131         add_record(IOT_8 | IOT_WRITE, ptr, value);
132         writeb(value, ptr);
133 }
134
135 void iotrace_reset_checksum(void)
136 {
137         iotrace.crc32 = 0;
138 }
139
140 u32 iotrace_get_checksum(void)
141 {
142         return iotrace.crc32;
143 }
144
145 void iotrace_set_enabled(int enable)
146 {
147         iotrace.enabled = enable;
148 }
149
150 int iotrace_get_enabled(void)
151 {
152         return iotrace.enabled;
153 }
154
155 void iotrace_set_buffer(ulong start, ulong size)
156 {
157         iotrace.start = start;
158         iotrace.size = size;
159         iotrace.offset = 0;
160         iotrace.crc32 = 0;
161 }
162
163 void iotrace_get_buffer(ulong *start, ulong *size, ulong *offset, ulong *count)
164 {
165         *start = iotrace.start;
166         *size = iotrace.size;
167         *offset = iotrace.offset;
168         *count = iotrace.offset / sizeof(struct iotrace_record);
169 }