]>
Commit | Line | Data |
---|---|---|
1 | Index: target_bfin_new.c | |
2 | =================================================================== | |
3 | --- target_bfin_new.c (revision 2656) | |
4 | +++ target_bfin_new.c (working copy) | |
5 | @@ -21,6 +21,7 @@ | |
6 | #include <config.h> | |
7 | #endif /* HAVE_CONFIG_H */ | |
8 | ||
9 | +#include <errno.h> | |
10 | #include <stdio.h> | |
11 | #include <stdlib.h> | |
12 | #include <stdint.h> | |
13 | @@ -30,8 +31,11 @@ | |
14 | #include <time.h> | |
15 | #include <stdarg.h> | |
16 | #include <getopt.h> | |
17 | +#include <pthread.h> | |
18 | +#include <fcntl.h> | |
19 | ||
20 | #include "gdbproxy.h" | |
21 | +#include "rpmisc.h" | |
22 | ||
23 | #include "part.h" | |
24 | #include "chain.h" | |
25 | @@ -4672,6 +4676,177 @@ bfin_out_treg (char *in, unsigned int re | |
26 | return bfin_out_treg_value (in, reg_no, value); | |
27 | } | |
28 | \f | |
29 | +#define DR_OUT (cpu->chain->parts->parts[cpu->chain->active_part]->active_instruction->data_register->out) | |
30 | +#define DR_IN (cpu->chain->parts->parts[cpu->chain->active_part]->active_instruction->data_register->in) | |
31 | + | |
32 | +static unsigned int btc_port = 2001; | |
33 | +static int btc_listen_sock = -1; | |
34 | + | |
35 | +static pthread_t btc_thread; | |
36 | + | |
37 | +static char *btc_read_buff = NULL; | |
38 | +static size_t btc_read_len = 0; | |
39 | +static inline void btc_read_maybe_queue(void) | |
40 | +{ | |
41 | + if (DR_OUT->data[40 - 1 - 7] == 0) | |
42 | + return; | |
43 | + | |
44 | + size_t i; | |
45 | + uint32_t data = 0; | |
46 | + for (i = 0; i < 32; ++i) | |
47 | + data |= DR_OUT->data[i] << (32 - 1 - i); | |
48 | + | |
49 | + printf("got from Blackfin: 0x%08x\n", data); | |
50 | + | |
51 | + btc_read_buff = realloc(btc_read_buff, btc_read_len + 4); | |
52 | + memcpy(btc_read_buff + btc_read_len, &data, 4); | |
53 | + btc_read_len += 4; | |
54 | +} | |
55 | + | |
56 | +static inline int jtag_strdup_parse_line(char *buf) | |
57 | +{ | |
58 | + int ret; | |
59 | + buf = strdup(buf); | |
60 | + ret = jtag_parse_line(cpu->chain, buf); | |
61 | + free(buf); | |
62 | + return ret; | |
63 | +} | |
64 | + | |
65 | +static size_t btc_write(size_t length, void *data) | |
66 | +{ | |
67 | + size_t i, j, b; | |
68 | + char *buf = data; | |
69 | + char dr_cmd[] = "dr 0000000000000000000000000000000000000000"; /* need 40bits */ | |
70 | + | |
71 | + /* in full duplex, we need to look at 7th bit | |
72 | + * to see if Blackfin is sending to us | |
73 | + */ | |
74 | + for (i = 0; i < length; i += 4) { | |
75 | + dr_cmd[3 + 6] = '0'; | |
76 | + jtag_strdup_parse_line(dr_cmd); | |
77 | + while (1) { | |
78 | + jtag_strdup_parse_line("shift dr"); | |
79 | + //jtag_strdup_parse_line("dr"); | |
80 | + //printf("{ in:%s\n out:%s}\n", register_get_string(DR_IN), register_get_string(DR_OUT)); | |
81 | + | |
82 | + btc_read_maybe_queue(); | |
83 | + | |
84 | + if (DR_OUT->data[40 - 1 - 6] == 0) | |
85 | + break; | |
86 | + } | |
87 | + | |
88 | + dr_cmd[3 + 6] = '1'; | |
89 | + for (j = 0; j < 4; ++j) { | |
90 | + //printf("byte: %c (0x%02x): 0y", buf[i+j], buf[i+j]); | |
91 | + for (b = 0; b < 8; ++b) { | |
92 | + char bit = ((buf[i+j] >> b) & 0x1) + '0'; | |
93 | + dr_cmd[3 + 8 + 8*j + b] = bit; | |
94 | + //printf("%c", bit); | |
95 | + } | |
96 | + //printf("\n"); | |
97 | + } | |
98 | + //printf("dr_cmd: %s\n", dr_cmd); | |
99 | + jtag_strdup_parse_line(dr_cmd); | |
100 | + jtag_strdup_parse_line("shift dr"); | |
101 | + btc_read_maybe_queue(); | |
102 | + } | |
103 | + | |
104 | + return 0; | |
105 | +} | |
106 | + | |
107 | +static void *btc_thread_main(void *arg) | |
108 | +{ | |
109 | + int btc_sock; | |
110 | + ssize_t io_ret; | |
111 | + char buf[1024]; | |
112 | + | |
113 | + { | |
114 | + int fd = open("/dev/null", O_WRONLY); | |
115 | + dup2(fd, STDOUT_FILENO); | |
116 | + close(fd); | |
117 | + } | |
118 | + | |
119 | + while (1) { | |
120 | + btc_sock = sock_accept(btc_listen_sock); | |
121 | + fcntl(btc_sock, F_SETFL, fcntl(btc_sock, F_GETFL) | O_NONBLOCK); | |
122 | +// dup2(btc_sock, STDOUT_FILENO); | |
123 | + | |
124 | + jtag_strdup_parse_line("instruction EMUDAT_40_SCAN"); | |
125 | + jtag_strdup_parse_line("shift ir"); | |
126 | + | |
127 | + while (1) { | |
128 | +#if 0 | |
129 | + memset(buf, 'a', sizeof(buf)); | |
130 | + io_ret = read(btc_sock, buf, sizeof(buf)-1); | |
131 | + if (io_ret <= 0) | |
132 | + break; | |
133 | + while (io_ret > 0) | |
134 | + if (buf[io_ret-1] == '\n' || buf[io_ret-1] == '\r') | |
135 | + --io_ret; | |
136 | + else | |
137 | + break; | |
138 | + if (io_ret <= 0) | |
139 | + continue; | |
140 | + buf[io_ret] = '\0'; | |
141 | + printf("SOCKET: '%s'\n", buf); | |
142 | + | |
143 | + if (buf[0] == '!') | |
144 | + printf("jtag_parse_line: %i\n", jtag_parse_line(cpu->chain, buf+1)); | |
145 | + else | |
146 | + btc_write(io_ret, buf); | |
147 | +#else | |
148 | + char byte; | |
149 | + io_ret = read(btc_sock, &byte, 1); | |
150 | + if (io_ret == 0 || (io_ret == -1 && errno != EAGAIN)) | |
151 | + break; | |
152 | + | |
153 | + if (io_ret > 0) | |
154 | + btc_write(1, &byte); | |
155 | + else { | |
156 | + jtag_strdup_parse_line("dr 0000000000000000000000000000000000000000"); | |
157 | + jtag_strdup_parse_line("shift dr"); | |
158 | + btc_read_maybe_queue(); | |
159 | + } | |
160 | + | |
161 | + if (btc_read_len) { | |
162 | + write(btc_sock, btc_read_buff, 1); | |
163 | + btc_read_len = 0; | |
164 | + } | |
165 | +#endif | |
166 | + } | |
167 | + | |
168 | + close(btc_sock); | |
169 | + } | |
170 | + | |
171 | + return NULL; | |
172 | +} | |
173 | + | |
174 | +#define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0])) | |
175 | +static void bfin_btc_init(void) | |
176 | +{ | |
177 | + size_t i; | |
178 | + char *btc_command_init[] = { | |
179 | + /* declare a 40bit version of emudat */ | |
180 | + "register EMUDAT_40 40", | |
181 | + "instruction EMUDAT_40_SCAN 10100 EMUDAT_40", | |
182 | + | |
183 | + /* set emudat to 40bits */ | |
184 | + "instruction DBGCTL_SCAN", | |
185 | + "shift ir", | |
186 | + "shift dr", | |
187 | + "dr 0000000100000000", | |
188 | + "shift dr" | |
189 | + }; | |
190 | + | |
191 | + btc_listen_sock = listen_sock_open(&btc_port); | |
192 | + if (btc_listen_sock == -1) | |
193 | + return; | |
194 | + | |
195 | + pthread_create(&btc_thread, NULL, btc_thread_main, NULL); | |
196 | + for (i = 0; i < ARRAY_SIZE(btc_command_init); ++i) | |
197 | + jtag_strdup_parse_line(btc_command_init[i]); | |
198 | +} | |
199 | +\f | |
200 | ||
201 | /* Target method */ | |
202 | static void | |
203 | @@ -5208,6 +5383,8 @@ bfin_open (int argc, | |
204 | cpu->cores[0].name = "Core"; | |
205 | } | |
206 | ||
207 | + bfin_btc_init(); | |
208 | + | |
209 | return RP_VAL_TARGETRET_OK; | |
210 | } | |
211 | ||
212 | Index: rpmisc.c | |
213 | =================================================================== | |
214 | --- rpmisc.c (revision 2656) | |
215 | +++ rpmisc.c (working copy) | |
216 | @@ -98,13 +98,14 @@ | |
217 | ||
218 | ||
219 | /* Sockets */ | |
220 | -#if defined(WIN32) | |
221 | +#if !defined(WIN32) | |
222 | +# undef INVALID_SOCKET | |
223 | +# define INVALID_SOCKET -1 | |
224 | +# undef SOCKET_ERROR | |
225 | +# define SOCKET_ERROR -1 | |
226 | +#endif | |
227 | static int dbg_sock = INVALID_SOCKET; | |
228 | static int dbg_listen_sock = INVALID_SOCKET; | |
229 | -#else | |
230 | -static int dbg_sock = -1; | |
231 | -static int dbg_listen_sock = -1; | |
232 | -#endif | |
233 | ||
234 | /* Log functions */ | |
235 | static void rp_log_local(int level, const char *fmt, ...); | |
236 | @@ -140,29 +141,21 @@ void dbg_sock_cleanup(void) | |
237 | } | |
238 | ||
239 | /* Open listen socket in a mode expected by gdb */ | |
240 | -int dbg_listen_sock_open(unsigned int *port) | |
241 | +int listen_sock_open(unsigned int *port) | |
242 | { | |
243 | struct sockaddr_in sa; | |
244 | int tmp; | |
245 | int ret; | |
246 | unsigned int p; | |
247 | + int sock; | |
248 | ||
249 | assert(port == NULL || *port < 0x10000); | |
250 | ||
251 | -#if defined(WIN32) | |
252 | - assert(dbg_sock == INVALID_SOCKET && dbg_listen_sock == INVALID_SOCKET); | |
253 | - | |
254 | - if ((dbg_listen_sock = socket(PF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET) | |
255 | - return FALSE; | |
256 | -#else | |
257 | - assert(dbg_sock == -1 && dbg_listen_sock == -1); | |
258 | - | |
259 | - if ((dbg_listen_sock = socket(PF_INET, SOCK_STREAM, 0)) < 0) | |
260 | - return FALSE; | |
261 | -#endif | |
262 | + if ((sock = socket(PF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET) | |
263 | + return INVALID_SOCKET; | |
264 | ||
265 | tmp = 1; | |
266 | - setsockopt(dbg_listen_sock, | |
267 | + setsockopt(sock, | |
268 | SOL_SOCKET, | |
269 | SO_REUSEADDR, | |
270 | (char *) &tmp, | |
271 | @@ -178,13 +171,8 @@ int dbg_listen_sock_open(unsigned int *p | |
272 | else | |
273 | sa.sin_port = htons((unsigned short int) *port); | |
274 | ||
275 | -#if defined(WIN32) | |
276 | - if ((ret = bind(dbg_listen_sock, (struct sockaddr *) &sa, sizeof (sa))) == SOCKET_ERROR) | |
277 | - return FALSE; | |
278 | -#else | |
279 | - if ((ret = bind(dbg_listen_sock, (struct sockaddr *) &sa, sizeof (sa))) != 0) | |
280 | - return FALSE; | |
281 | -#endif | |
282 | + if ((ret = bind(sock, (struct sockaddr *) &sa, sizeof (sa))) == SOCKET_ERROR) | |
283 | + return INVALID_SOCKET; | |
284 | } | |
285 | else | |
286 | { | |
287 | @@ -194,79 +182,68 @@ int dbg_listen_sock_open(unsigned int *p | |
288 | { | |
289 | sa.sin_port = htons(p); | |
290 | ||
291 | -#if defined(WIN32) | |
292 | - if ((ret = bind(dbg_listen_sock, (struct sockaddr *) &sa, sizeof (sa))) != SOCKET_ERROR) | |
293 | + if ((ret = bind(sock, (struct sockaddr *) &sa, sizeof (sa))) != SOCKET_ERROR) | |
294 | break; | |
295 | -#else | |
296 | - if ((ret = bind(dbg_listen_sock, (struct sockaddr *) &sa, sizeof (sa))) == 0) | |
297 | - break; | |
298 | -#endif | |
299 | } | |
300 | ||
301 | if (p == 0x10000) | |
302 | { | |
303 | /* No sockets available */ | |
304 | - return FALSE; | |
305 | + return INVALID_SOCKET; | |
306 | } | |
307 | ||
308 | *port = p; | |
309 | } | |
310 | ||
311 | -#if defined(WIN32) | |
312 | - assert(dbg_listen_sock != INVALID_SOCKET); | |
313 | + assert(sock != INVALID_SOCKET); | |
314 | ||
315 | - if ((ret = listen(dbg_listen_sock, 1)) == SOCKET_ERROR) | |
316 | - return FALSE; | |
317 | -#else | |
318 | - assert(dbg_listen_sock >= 0); | |
319 | + if ((ret = listen(sock, 1)) == SOCKET_ERROR) | |
320 | + return INVALID_SOCKET; | |
321 | ||
322 | - if ((ret = listen(dbg_listen_sock, 1)) != 0) | |
323 | - return FALSE; | |
324 | -#endif | |
325 | + return sock; | |
326 | +} | |
327 | +int dbg_listen_sock_open(unsigned int *port) | |
328 | +{ | |
329 | + assert(dbg_sock == INVALID_SOCKET && dbg_listen_sock == INVALID_SOCKET); | |
330 | ||
331 | - return TRUE; | |
332 | + dbg_listen_sock = listen_sock_open(port); | |
333 | + | |
334 | + return (dbg_listen_sock == INVALID_SOCKET ? FALSE : TRUE); | |
335 | } | |
336 | ||
337 | /* Accept incoming connection and set mode expected by gdb */ | |
338 | -int dbg_sock_accept(void) | |
339 | +int sock_accept(int listen_sock) | |
340 | { | |
341 | socklen_t tmp; | |
342 | struct sockaddr_in sa; | |
343 | struct protoent *pe; | |
344 | - | |
345 | -#if defined(WIN32) | |
346 | - assert(dbg_sock == INVALID_SOCKET); | |
347 | - assert(dbg_listen_sock != INVALID_SOCKET); | |
348 | + int sock; | |
349 | ||
350 | tmp = sizeof(sa); | |
351 | - if ((dbg_sock = accept(dbg_listen_sock, (struct sockaddr *) &sa, &tmp)) | |
352 | + if ((sock = accept(listen_sock, (struct sockaddr *) &sa, &tmp)) | |
353 | == INVALID_SOCKET) | |
354 | { | |
355 | - return FALSE; | |
356 | + return INVALID_SOCKET; | |
357 | } | |
358 | ||
359 | if ((pe = getprotobyname("tcp")) == NULL) | |
360 | - return FALSE; | |
361 | -#else | |
362 | - assert(dbg_sock < 0); | |
363 | - assert(dbg_listen_sock >= 0); | |
364 | - | |
365 | - tmp = sizeof(sa); | |
366 | - if ((dbg_sock = accept(dbg_listen_sock, (struct sockaddr *) &sa, &tmp)) < 0) | |
367 | - return FALSE; | |
368 | - | |
369 | - if ((pe = getprotobyname("tcp")) == NULL) | |
370 | - return FALSE; | |
371 | -#endif | |
372 | + return INVALID_SOCKET; | |
373 | ||
374 | tmp = 1; | |
375 | - setsockopt(dbg_sock, | |
376 | + setsockopt(sock, | |
377 | pe->p_proto, | |
378 | TCP_NODELAY, | |
379 | (char *) &tmp, | |
380 | sizeof(tmp)); | |
381 | ||
382 | - return TRUE; | |
383 | + return sock; | |
384 | +} | |
385 | +int dbg_sock_accept(void) | |
386 | +{ | |
387 | + assert(dbg_sock == INVALID_SOCKET); | |
388 | + assert(dbg_listen_sock != INVALID_SOCKET); | |
389 | + dbg_sock = sock_accept(dbg_listen_sock); | |
390 | + return (dbg_sock == INVALID_SOCKET ? FALSE : TRUE); | |
391 | } | |
392 | ||
393 | /* Close connection to debugger side */ | |
394 | Index: rpmisc.h | |
395 | =================================================================== | |
396 | --- rpmisc.h (revision 2656) | |
397 | +++ rpmisc.h (working copy) | |
398 | @@ -39,6 +39,9 @@ int dbg_sock_accept(void); | |
399 | int dbg_sock_readchar(int ms); | |
400 | int dbg_listen_sock_open(unsigned int *port); | |
401 | ||
402 | +int listen_sock_open(unsigned int *port); | |
403 | +int sock_accept(int listen_sock); | |
404 | + | |
405 | /* Return values for readchar: either character | |
406 | code or one of the following*/ | |
407 | #define RP_VAL_MISCREADCHARRET_TMOUT (-2) |