]>
Commit | Line | Data |
---|---|---|
92b46605 L |
1 | #include "common.h" |
2 | #include <stdlib.h> | |
f338df2a | 3 | #include <string.h> |
92b46605 L |
4 | #include <ctype.h> |
5 | #include <avr/eeprom.h> | |
6 | ||
7 | #include "command.h" | |
8 | #include "debug.h" | |
9 | ||
10 | /* | |
11 | * Debugging | |
12 | */ | |
13 | #ifdef DEBUG | |
14 | ||
f338df2a | 15 | //uint8_t eeprom_read_byte (const uint8_t *__p) |
92b46605 L |
16 | |
17 | static void print_blanks(uint_fast8_t count) | |
18 | { | |
19 | while(count--) | |
20 | putchar(' '); | |
21 | } | |
22 | ||
f338df2a L |
23 | static uint8_t ram_read_byte(const uint8_t *p) |
24 | { | |
25 | return *p; | |
26 | } | |
92b46605 | 27 | |
f338df2a L |
28 | void dump_mem(const uint8_t *startaddr, int len, |
29 | uint8_t (*readfkt)(const uint8_t *), char *title) | |
30 | { | |
31 | uint8_t buf[16]; | |
32 | uint8_t llen = 16; | |
33 | uint8_t pre = (size_t) startaddr % 16; | |
34 | const uint8_t *addr = (uint8_t *) ((size_t) startaddr & ~0x0f); | |
35 | len += pre; | |
36 | uint8_t i; | |
37 | ||
38 | if (title && *title) | |
39 | printf_P(PSTR("%s\n"),title); | |
40 | ||
41 | while (len) { | |
42 | if (len < 16) | |
43 | llen = len; | |
44 | ||
45 | for (i = pre; i < llen; i++) | |
46 | buf[i] = readfkt(addr + i); | |
47 | ||
48 | printf_P(PSTR("%04x:"), addr); | |
49 | for (i = 0; i < llen; i++) { | |
50 | if ((i % 8) == 0) | |
51 | putchar(' '); | |
52 | if (i < pre) | |
53 | printf_P(PSTR(".. ")); | |
54 | else | |
55 | printf_P(PSTR("%.2x "), buf[i]); | |
56 | } | |
57 | /* fill line with whitespace for nice ASCII print */ | |
58 | print_blanks(3 * (16u - i) + (16u-i)/8 + 1 + pre); | |
59 | /* Print data in ASCII characters */ | |
60 | for (i = pre; i < llen; i++) | |
61 | printf_P(PSTR("%c"), isprint(buf[i]) ? buf[i] : '.'); | |
62 | putchar('\n'); | |
63 | ||
64 | pre = 0; | |
65 | addr += 16; | |
66 | len -= llen; | |
67 | } | |
68 | } | |
69 | ||
70 | #if 0 | |
92b46605 L |
71 | void dump_ram(const uint8_t *startaddr, int len, char *title) |
72 | { | |
73 | uint8_t llen = 16; | |
74 | uint8_t pre = (size_t) startaddr % 16; | |
75 | const uint8_t *addr = (uint8_t *) ((size_t) startaddr & ~0x0f); | |
76 | len += pre; | |
77 | uint8_t i; | |
78 | ||
79 | if (title && *title) | |
80 | printf_P(PSTR("%s\n"),title); | |
81 | ||
82 | while (len) { | |
83 | if (len < 16) | |
84 | llen = len; | |
85 | ||
86 | printf_P(PSTR(" %.4x:"), (size_t) addr); | |
87 | print_blanks(3 * pre); | |
88 | for (i = pre; i < llen; i++) | |
89 | printf_P(PSTR(" %.2x"), addr[i]); | |
90 | print_blanks(3 * (16 - i + 1) + pre); | |
91 | for (i = pre; i < llen; i++) | |
92 | printf_P(PSTR("%c"), isprint(addr[i]) ? addr[i] : '.'); | |
93 | putchar('\n'); | |
94 | ||
95 | pre = 0; | |
96 | addr += 16; | |
97 | len -= llen; | |
98 | } | |
99 | } | |
f338df2a L |
100 | #endif |
101 | #if 0 | |
92b46605 L |
102 | void dump_heap(void) |
103 | { | |
104 | extern unsigned int __brkval; | |
105 | ||
106 | dump_ram((uint8_t *) __malloc_heap_start, | |
107 | __brkval - (unsigned int) __malloc_heap_start, | |
108 | "=== Heap:"); | |
109 | } | |
f338df2a | 110 | #endif |
92b46605 | 111 | |
f338df2a | 112 | #if 0 |
92b46605 | 113 | /* TODO: combine with dump_ram() */ |
f338df2a L |
114 | void dump_eep(const uint8_t *addr, unsigned int len, |
115 | uint8_t (*readfkt)(const uint8_t *)) | |
92b46605 L |
116 | { |
117 | uint_fast8_t i; | |
118 | uint8_t buf[16]; | |
119 | ||
120 | printf_P(PSTR("eeprom dump:")); | |
121 | while (len) { | |
122 | printf_P(PSTR("\n 0x%.4x:"), (unsigned int) addr); | |
123 | for (i = 0; i<16; i++) | |
f338df2a | 124 | buf[i] = readfkt(addr + i); |
92b46605 L |
125 | for (i = 0; i<16; i++) |
126 | printf_P(PSTR(" %.2x"), buf[i]); | |
127 | printf_P(PSTR(" ")); | |
128 | for (i = 0; i<16; i++) | |
129 | printf_P(PSTR("%c"), isprint(buf[i]) ? buf[i] : '.'); | |
130 | ||
131 | addr += 16; | |
132 | len -= len > 16 ? 16 : len; | |
133 | } | |
134 | putchar('\n'); | |
135 | } | |
f338df2a L |
136 | #endif |
137 | ||
92b46605 L |
138 | |
139 | /* | |
140 | * EEPROM Display | |
141 | * md addr {len} | |
142 | */ | |
d0581f88 | 143 | command_ret_t do_dump_mem(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) |
92b46605 | 144 | { |
f338df2a L |
145 | // static const uint8_t *addr; |
146 | // static uint16_t length = 128; | |
147 | uint8_t (*readhow)(const uint8_t *); | |
148 | ||
149 | (void) cmdtp; (void) flag; | |
92b46605 L |
150 | |
151 | if (argc < 2) | |
152 | return CMD_RET_USAGE; | |
153 | ||
f338df2a L |
154 | const uint8_t *addr; |
155 | uint16_t length = 128; | |
156 | ||
157 | if (strchr(argv[0],'r') != NULL) | |
158 | readhow = ram_read_byte; | |
159 | else if (strchr(argv[0],'e') != NULL) | |
160 | readhow = eeprom_read_byte; | |
161 | else | |
162 | return CMD_RET_USAGE; | |
92b46605 | 163 | |
f338df2a L |
164 | /* Address is specified since argc > 1 */ |
165 | addr = (const uint8_t *) (size_t) strtoul(argv[1], NULL, 16); | |
166 | ||
167 | /* If another parameter, it is the length to display. */ | |
168 | if (argc > 2) | |
169 | length = (uint16_t) strtoul(argv[2], NULL, 16); | |
92b46605 L |
170 | |
171 | /* Print the lines. */ | |
f338df2a | 172 | dump_mem(addr, length, readhow, NULL); |
92b46605 | 173 | |
d0581f88 | 174 | return CMD_RET_SUCCESS; |
92b46605 L |
175 | } |
176 | ||
d0581f88 | 177 | command_ret_t do_eep_cp(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) |
92b46605 L |
178 | { |
179 | uint16_t src, dest, count; | |
180 | int_fast8_t step; | |
181 | ||
182 | (void) cmdtp; | |
183 | (void) flag; | |
184 | ||
185 | if (argc != 4) | |
186 | return CMD_RET_USAGE; | |
187 | ||
188 | src = (size_t) strtoul(argv[1], NULL, 16); | |
189 | dest = (size_t) strtoul(argv[2], NULL, 16); | |
190 | count = (size_t) strtoul(argv[3], NULL, 16); | |
191 | ||
192 | if (src > E2END) { | |
193 | debug("src > EEPROM size: 0x%04x\n", src); | |
d0581f88 | 194 | return CMD_RET_FAILURE; |
92b46605 L |
195 | } |
196 | if (dest > E2END) { | |
197 | debug("dest > EEPROM size: 0x%04x\n", dest); | |
d0581f88 | 198 | return CMD_RET_FAILURE; |
92b46605 L |
199 | } |
200 | if (count > E2END+1) { | |
201 | debug("count > EEPROM size: 0x%04x\n", count); | |
d0581f88 | 202 | return CMD_RET_FAILURE; |
92b46605 L |
203 | } |
204 | if (count == 0) { | |
69988dc1 | 205 | debug("Zero length?\n"); |
d0581f88 | 206 | return CMD_RET_FAILURE; |
92b46605 L |
207 | } |
208 | ||
209 | if (dest > src) { | |
210 | src += count - 1; | |
211 | dest += count - 1; | |
212 | step = -1; | |
213 | } else | |
214 | step = 1; | |
215 | ||
216 | while (count-- > 0) { | |
217 | uint8_t data; | |
218 | data = eeprom_read_byte((uint8_t *) src); | |
219 | eeprom_write_byte((uint8_t *) dest, data); | |
220 | src += step; | |
221 | dest += step; | |
222 | ||
223 | } | |
d0581f88 | 224 | return CMD_RET_SUCCESS; |
92b46605 | 225 | } |
69988dc1 L |
226 | |
227 | /*------------------------------------------------------------------------------*/ | |
228 | ||
229 | ||
dea9a315 L |
230 | #if 0 |
231 | ||
69988dc1 L |
232 | struct __freelist { |
233 | size_t sz; | |
234 | struct __freelist *nx; | |
235 | }; | |
236 | ||
237 | extern char *__brkval; /* first location not yet allocated */ | |
238 | extern struct __freelist *__flp; /* freelist pointer (head of freelist) */ | |
239 | ||
240 | #define STACK_POINTER() ((char *)AVR_STACK_POINTER_REG) | |
241 | ||
242 | void | |
243 | printfreelist(const char * title) | |
244 | { | |
245 | struct __freelist *fp1; | |
246 | int i; | |
247 | unsigned int freesum = 0; | |
248 | ||
249 | if (!__flp) { | |
250 | printf("%s no free list\n", title ? title : ""); | |
251 | } else { | |
252 | printf("Free list: %s\n", title ? title : ""); | |
253 | for (i = 0, fp1 = __flp; fp1; i++, fp1 = fp1->nx) { | |
254 | printf(" entry %d @ %04x: size %4u, next ", | |
255 | i, (size_t)fp1, fp1->sz); | |
256 | if (fp1->nx) | |
257 | printf("%04x\n", (size_t)fp1->nx); | |
258 | else | |
259 | printf("NULL\n"); | |
260 | freesum += fp1->sz; | |
261 | } | |
262 | } | |
263 | ||
264 | freesum += (size_t) STACK_POINTER() - __malloc_margin - (size_t) __brkval; | |
265 | ||
266 | printf("SP: %04x, __brkval: %04x, Total free: %04u\n", | |
267 | (size_t) STACK_POINTER(), (size_t) __brkval, freesum); | |
268 | } | |
269 | ||
dea9a315 | 270 | #endif |
69988dc1 | 271 | |
92b46605 L |
272 | #endif /* DEBUG */ |
273 |