00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
#include <config.h>
00035
00036
#include <stdio.h>
00037
#include <string.h>
00038
#include <stdlib.h>
00039
#include <errno.h>
00040
#include <sys/types.h>
00041
#include <sys/wait.h>
00042
#include <unistd.h>
00043
#include <fcntl.h>
00044
#include <sys/ioctl.h>
00045
#include <signal.h>
00046
00047
#include "avrerror.h"
00048
#include "avrmalloc.h"
00049
#include "display.h"
00050
00051
enum
00052 {
00053 MAX_BUF = 1024,
00054 };
00055
00056
00057
00058
00059
static int global_pipe_fd = -1;
00060
00061
00062
00063
00064
static pid_t global_child_pid = -1;
00065
00066
00067
00068
00069
00070
00071
00072
00073
00074
00075
00076
00077
00078
00079
00080
00081
00082
00083
00084
int
00085 display_open (
char *prog,
int no_xterm,
int flash_sz,
int sram_sz,
00086
int sram_start,
int eeprom_sz)
00087 {
00088 pid_t pid;
00089
int pfd[2];
00090
00091
int res;
00092
00093
if (prog == NULL)
00094 {
00095 prog = getenv (
"SIM_DISP_PROG");
00096
if (prog == NULL)
00097
return -1;
00098 }
00099
00100
00101
00102
00103
00104 res = pipe (pfd);
00105
if (res < 0)
00106 {
00107
avr_warning (
"pipe failed: %s\n", strerror (errno));
00108
return -1;
00109 }
00110
00111
00112
00113 pid = fork ();
00114
if (pid < 0)
00115 {
00116
avr_warning (
"fork failed: %s\n", strerror (errno));
00117
return -1;
00118 }
00119
else if (pid > 0)
00120 {
00121
00122 close (pfd[0]);
00123
00124
00125 global_child_pid = pid;
00126
00127 global_pipe_fd = pfd[1];
00128
return global_pipe_fd;
00129 }
00130
else
00131 {
00132
char pfd_env[20];
00133
char fl_sz[20], sr_sz[20], sr_start[20], eep_sz[20];
00134
char spfd[10];
00135
00136
00137 close (pfd[1]);
00138
00139
00140 snprintf (fl_sz,
sizeof (fl_sz) - 1,
"%d", flash_sz);
00141 snprintf (sr_sz,
sizeof (sr_sz) - 1,
"%d", sram_sz);
00142 snprintf (sr_start,
sizeof (sr_start) - 1,
"%d", sram_start);
00143 snprintf (eep_sz,
sizeof (eep_sz) - 1,
"%d", eeprom_sz);
00144 snprintf (spfd,
sizeof (spfd) - 1,
"%d", pfd[0]);
00145
00146
00147 snprintf (pfd_env,
sizeof (pfd_env),
"SIM_PIPE_FD=%d", pfd[0]);
00148 putenv (pfd_env);
00149
00150
00151
00152
00153
00154
00155
00156
00157
00158
if (no_xterm)
00159 {
00160 execlp (prog, prog,
"--pfd", spfd, fl_sz, sr_sz, sr_start, eep_sz,
00161 NULL);
00162 }
00163
else
00164 {
00165
00166 execlp (
"xterm",
"xterm",
"-geom",
"100x50",
"-e", prog,
"--pfd",
00167 spfd, fl_sz, sr_sz, sr_start, eep_sz, NULL);
00168 }
00169
00170
00171
avr_warning (
"exec failed: %s\n", strerror (errno));
00172 _exit (1);
00173 }
00174
00175
return -1;
00176 }
00177
00178
00179
00180
void
00181 display_close (
void)
00182 {
00183
if (global_pipe_fd < 0)
00184
return;
00185
00186
display_send_msg (
"q");
00187 close (global_pipe_fd);
00188 global_pipe_fd = -1;
00189
00190 kill (global_child_pid, SIGINT);
00191 waitpid (0, NULL, 0);
00192 }
00193
00194
static unsigned char
00195 checksum (
char *s)
00196 {
00197
unsigned char CC = 0;
00198
while (*s)
00199 {
00200 CC += *s;
00201 s++;
00202 }
00203
00204
return CC;
00205 }
00206
00207
00208
00209
00210
00211
00212
00213
00214
00215
00216
00217
00218
00219
void
00220 display_send_msg (
char *msg)
00221 {
00222
int len = strlen (msg) + 4 + 1;
00223
int res;
00224
char *enc_msg;
00225
00226 enc_msg =
avr_new0 (
char, len + 1);
00227
00228 snprintf (enc_msg, len,
"$%s#%02x", msg, checksum (msg));
00229
#if defined(DISP_DEBUG_OUTPUT_ON)
00230
fprintf (stderr,
"DISP: %s\n", enc_msg);
00231
#endif
00232
00233 res = write (global_pipe_fd, enc_msg, len);
00234
if ((res < 0) && (errno == EINTR))
00235 {
00236
00237
00238
avr_warning (
"Interrupted write()\n");
00239 res = write (global_pipe_fd, enc_msg, len);
00240 }
00241
if (res < 0)
00242
avr_error (
"write failed: %s\n", strerror (errno));
00243
if (res < len)
00244
avr_error (
"incomplete write\n");
00245
00246
avr_free (enc_msg);
00247 }
00248
00249
static char global_buf[MAX_BUF + 1];
00250
00251
00252
00253
00254
void
00255 display_clock (
int clock)
00256 {
00257
if (global_pipe_fd < 0)
00258
return;
00259
00260 snprintf (global_buf, MAX_BUF,
"n%x", clock);
00261 global_buf[MAX_BUF] =
'\0';
00262
display_send_msg (global_buf);
00263 }
00264
00265
00266
00267
00268
void
00269 display_pc (
int val)
00270 {
00271
if (global_pipe_fd < 0)
00272
return;
00273
00274 snprintf (global_buf, MAX_BUF,
"p%x", val);
00275 global_buf[MAX_BUF] =
'\0';
00276
display_send_msg (global_buf);
00277 }
00278
00279
00280
00281
00282
00283
void
00284 display_reg (
int reg, uint8_t val)
00285 {
00286
if (global_pipe_fd < 0)
00287
return;
00288
00289 snprintf (global_buf, MAX_BUF,
"r%x:%02x", reg, val);
00290 global_buf[MAX_BUF] =
'\0';
00291
display_send_msg (global_buf);
00292 }
00293
00294
00295
00296
00297
00298
void
00299 display_io_reg (
int reg, uint8_t val)
00300 {
00301
if (global_pipe_fd < 0)
00302
return;
00303
00304 snprintf (global_buf, MAX_BUF,
"i%x:%02x", reg, val);
00305 global_buf[MAX_BUF] =
'\0';
00306
display_send_msg (global_buf);
00307 }
00308
00309
00310
00311
00312
00313
00314
00315
void
00316 display_io_reg_name (
int reg,
char *name)
00317 {
00318
if (global_pipe_fd < 0)
00319
return;
00320
00321 snprintf (global_buf, MAX_BUF,
"I%x:%s", reg, name);
00322 global_buf[MAX_BUF] =
'\0';
00323
display_send_msg (global_buf);
00324 }
00325
00326
00327
00328
00329
00330
00331
00332
00333
00334
00335
00336
00337
00338
00339
void
00340 display_flash (
int addr,
int len, uint16_t * vals)
00341 {
00342
int bytes;
00343
int i;
00344
00345
if (global_pipe_fd < 0)
00346
return;
00347
00348 bytes = snprintf (global_buf, MAX_BUF,
"f%x,%x:", addr, len);
00349
00350
for (i = 0; i < len; i++)
00351 {
00352
if (MAX_BUF - bytes < 0)
00353
avr_error (
"buffer overflow");
00354
00355 bytes +=
00356 snprintf (global_buf + bytes, MAX_BUF - bytes,
"%04x", vals[i]);
00357 }
00358
00359 global_buf[MAX_BUF] =
'\0';
00360
display_send_msg (global_buf);
00361 }
00362
00363
00364
00365
00366
00367
00368
00369
00370
00371
void
00372 display_sram (
int addr,
int len, uint8_t * vals)
00373 {
00374
int bytes;
00375
int i;
00376
00377
if (global_pipe_fd < 0)
00378
return;
00379
00380 bytes = snprintf (global_buf, MAX_BUF,
"s%x,%x:", addr, len);
00381
00382
for (i = 0; i < len; i++)
00383 {
00384
if (MAX_BUF - bytes < 0)
00385
avr_error (
"buffer overflow");
00386
00387 bytes +=
00388 snprintf (global_buf + bytes, MAX_BUF - bytes,
"%02x", vals[i]);
00389 }
00390
00391 global_buf[MAX_BUF] =
'\0';
00392
display_send_msg (global_buf);
00393 }
00394
00395
00396
00397
00398
00399
00400
00401
00402
00403
void
00404 display_eeprom (
int addr,
int len, uint8_t * vals)
00405 {
00406
int bytes;
00407
int i;
00408
00409
if (global_pipe_fd < 0)
00410
return;
00411
00412 bytes = snprintf (global_buf, MAX_BUF,
"e%x,%x:", addr, len);
00413
00414
for (i = 0; i < len; i++)
00415 {
00416
if (MAX_BUF - bytes < 0)
00417
avr_error (
"buffer overflow");
00418
00419 bytes +=
00420 snprintf (global_buf + bytes, MAX_BUF - bytes,
"%02x", vals[i]);
00421 }
00422
00423 global_buf[MAX_BUF] =
'\0';
00424
display_send_msg (global_buf);
00425 }