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 }