OpenCores
URL https://opencores.org/ocsvn/eco32/eco32/trunk

Subversion Repositories eco32

[/] [eco32/] [trunk/] [sim/] [dspkbd.c] - Blame information for rev 278

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 8 hellwig
/*
2 25 hellwig
 * dspkbd.h -- display & keyboard controller simulation
3 8 hellwig
 */
4
 
5
 
6
#include <stdio.h>
7
#include <stdlib.h>
8
#include <string.h>
9
#include <setjmp.h>
10
 
11
#include "common.h"
12
#include "console.h"
13
#include "error.h"
14
#include "except.h"
15
#include "cpu.h"
16
#include "timer.h"
17
#include "dspkbd.h"
18
 
19
 
20
static Bool debug = false;
21
static Bool debugKeycode = false;
22 251 hellwig
static Bool volatile installed = false;
23 8 hellwig
 
24
 
25
static void blinkScreen(void);
26
 
27
static void keyPressed(unsigned int xKeycode);
28
static void keyReleased(unsigned int xKeycode);
29
 
30
 
31
/**************************************************************/
32
/**************************************************************/
33
 
34
/* common definitions, global variables */
35
 
36
 
37
#include <pthread.h>
38
#include <unistd.h>
39
#include <time.h>
40
#include <X11/Xlib.h>
41
#include <X11/Xutil.h>
42
#include <X11/Xatom.h>
43
 
44
 
45
#define WINDOW_SIZE_X           640
46
#define WINDOW_SIZE_Y           480
47
#define WINDOW_POS_X            100
48
#define WINDOW_POS_Y            100
49
 
50
 
51
#define C2B(c,ch)               (((((c) & 0xFF) * ch.scale) >> 8) * ch.factor)
52 251 hellwig
#define RGB2PIXEL(r,g,b)        (0xFF000000 | \
53
                                 C2B(r, vga.red) | \
54 8 hellwig
                                 C2B(g, vga.green) | \
55
                                 C2B(b, vga.blue))
56
 
57
 
58
typedef struct {
59
  unsigned long scale;
60
  unsigned long factor;
61
} ColorChannel;
62
 
63
 
64
typedef struct {
65
  int argc;
66
  char **argv;
67
  Display *display;
68
  Window win;
69
  GC gc;
70
  XImage *image;
71
  ColorChannel red, green, blue;
72
  XExposeEvent expose;
73
  XClientMessageEvent shutdown;
74
} VGA;
75
 
76
 
77
static VGA vga;
78
 
79
 
80
/**************************************************************/
81
 
82
/* monitor server */
83
 
84
 
85
static ColorChannel mask2channel(unsigned long mask) {
86
  unsigned long f;
87
  ColorChannel ch;
88
 
89
  if (mask == 0) {
90
    error("color mask is 0 in mask2channel");
91
  }
92
  for (f = 1; (mask & 1) == 0; f <<= 1) {
93
    mask >>= 1;
94
  }
95
  ch.factor = f;
96
  ch.scale = mask + 1;
97
  while ((mask & 1) != 0) {
98
    mask >>= 1;
99
  }
100
  if (mask != 0) {
101
    error("scattered color mask bits in mask2channel");
102
  }
103
  return ch;
104
}
105
 
106
 
107
static void initMonitor(int argc, char *argv[]) {
108
  int screenNum;
109
  Window rootWin;
110
  XVisualInfo visualTemp;
111
  XVisualInfo *visualInfo;
112
  int visualCount;
113
  int bestMatch;
114
  int bestDepth;
115
  Visual *visual;
116
  int i;
117
  unsigned long pixel;
118
  int x, y;
119
  Colormap colormap;
120
  XSetWindowAttributes attrib;
121
  XSizeHints *sizeHints;
122
  XWMHints *wmHints;
123
  XClassHint *classHints;
124
  XTextProperty windowName;
125
  XGCValues gcValues;
126
 
127
  /* connect to X server */
128
  if (XInitThreads() == 0) {
129
    error("no thread support for X11");
130
  }
131
  vga.display = XOpenDisplay(NULL);
132
  if (vga.display == NULL) {
133
    error("cannot connect to X server");
134
  }
135
  screenNum = DefaultScreen(vga.display);
136
  rootWin = RootWindow(vga.display, screenNum);
137
  /* find TrueColor visual */
138
  visualTemp.screen = screenNum;
139
  visualTemp.class = TrueColor;
140
  visualInfo = XGetVisualInfo(vga.display,
141
                              VisualClassMask | VisualScreenMask,
142
                              &visualTemp, &visualCount);
143
  if (visualInfo == NULL || visualCount == 0) {
144
    error("no TrueColor visual found");
145
  }
146
  bestMatch = 0;
147
  bestDepth = visualInfo[0].depth;
148
  visual = visualInfo[0].visual;
149
  for (i = 1; i < visualCount; i++) {
150
    if (visualInfo[i].depth > bestDepth) {
151
      bestMatch = i;
152
      bestDepth = visualInfo[i].depth;
153
      visual = visualInfo[i].visual;
154
    }
155
  }
156
  /* build color channels */
157
  vga.red = mask2channel(visualInfo[bestMatch].red_mask);
158
  vga.green = mask2channel(visualInfo[bestMatch].green_mask);
159
  vga.blue = mask2channel(visualInfo[bestMatch].blue_mask);
160
  /* create and initialize image */
161
  vga.image = XCreateImage(vga.display, visual, bestDepth, ZPixmap,
162
                           0, NULL, WINDOW_SIZE_X, WINDOW_SIZE_Y, 32, 0);
163
  if (vga.image == NULL) {
164
    error("cannot allocate image");
165
  }
166
  vga.image->data = malloc(vga.image->height * vga.image->bytes_per_line);
167
  if (vga.image->data == NULL) {
168
    error("cannot allocate image memory");
169
  }
170
  pixel = RGB2PIXEL(0, 0, 0);
171
  for (y = 0; y < WINDOW_SIZE_Y; y++) {
172
    for (x = 0; x < WINDOW_SIZE_X; x++) {
173
      XPutPixel(vga.image, x, y, pixel);
174
    }
175
  }
176
  /* allocate a colormap */
177
  colormap = XCreateColormap(vga.display, rootWin, visual, AllocNone);
178
  /* create the window */
179
  attrib.colormap = colormap;
180
  attrib.event_mask = ExposureMask | KeyPressMask | KeyReleaseMask;
181
  attrib.background_pixel = RGB2PIXEL(0, 0, 0);
182
  attrib.border_pixel = RGB2PIXEL(0, 0, 0);
183
  vga.win =
184
    XCreateWindow(vga.display, rootWin,
185
                  WINDOW_POS_X, WINDOW_POS_Y,
186
                  WINDOW_SIZE_X, WINDOW_SIZE_Y,
187
                  0, bestDepth, InputOutput, visual,
188
                  CWEventMask | CWColormap | CWBackPixel | CWBorderPixel,
189
                  &attrib);
190
  /* give hints to window manager */
191
  sizeHints = XAllocSizeHints();
192
  wmHints = XAllocWMHints();
193
  classHints = XAllocClassHint();
194
  if (sizeHints == NULL ||
195
      wmHints == NULL ||
196
      classHints == NULL) {
197
    error("hint allocation failed");
198
  }
199
  sizeHints->flags = PMinSize | PMaxSize;
200
  sizeHints->min_width = WINDOW_SIZE_X;
201
  sizeHints->min_height = WINDOW_SIZE_Y;
202
  sizeHints->max_width = WINDOW_SIZE_X;
203
  sizeHints->max_height = WINDOW_SIZE_Y;
204
  wmHints->flags = StateHint | InputHint;
205
  wmHints->input = True;
206
  wmHints->initial_state = NormalState;
207 159 hellwig
  classHints->res_name = "ECO32 Console";
208 8 hellwig
  classHints->res_class = "ECO32";
209
  if (XStringListToTextProperty(&classHints->res_name, 1, &windowName) == 0) {
210
    error("property allocation failed");
211
  }
212
  XSetWMProperties(vga.display, vga.win, &windowName, NULL,
213
                   argv, argc, sizeHints, wmHints, classHints);
214
  /* create a GC */
215
  vga.gc = XCreateGC(vga.display, vga.win, 0, &gcValues);
216
  /* finally get the window displayed */
217
  XMapWindow(vga.display, vga.win);
218
  /* prepare expose event */
219
  vga.expose.type = Expose;
220
  vga.expose.display = vga.display;
221
  vga.expose.window = vga.win;
222
  vga.expose.x = 0;
223
  vga.expose.y = 0;
224
  vga.expose.width = WINDOW_SIZE_X;
225
  vga.expose.height = WINDOW_SIZE_Y;
226
  vga.expose.count = 0;
227
  /* prepare shutdown event */
228
  vga.shutdown.type = ClientMessage;
229
  vga.shutdown.display = vga.display;
230
  vga.shutdown.window = vga.win;
231
  vga.shutdown.message_type = XA_WM_COMMAND;
232 251 hellwig
  vga.shutdown.format = 8;
233 8 hellwig
  /* say that the graphics controller is installed */
234
  XSync(vga.display, False);
235
  installed = true;
236
}
237
 
238
 
239
static void exitMonitor(void) {
240
  XFreeGC(vga.display, vga.gc);
241
  XUnmapWindow(vga.display, vga.win);
242
  XDestroyWindow(vga.display, vga.win);
243
  XDestroyImage(vga.image);
244
  XCloseDisplay(vga.display);
245
  installed = false;
246
}
247
 
248
 
249
static int ioErrorHandler(Display *display) {
250
  error("connection to monitor window lost");
251
  /* never reached */
252
  return 0;
253
}
254
 
255
 
256
static void *server(void *ignore) {
257
  Bool run;
258
  XEvent event;
259
 
260
  initMonitor(vga.argc, vga.argv);
261
  XSetIOErrorHandler(ioErrorHandler);
262
  run = true;
263
  while (run) {
264
    XNextEvent(vga.display, &event);
265
    switch (event.type) {
266
      case Expose:
267
        blinkScreen();
268
        XPutImage(vga.display, vga.win, vga.gc, vga.image,
269
                  event.xexpose.x, event.xexpose.y,
270
                  event.xexpose.x, event.xexpose.y,
271
                  event.xexpose.width, event.xexpose.height);
272
        break;
273
      case ClientMessage:
274
        if (event.xclient.message_type == XA_WM_COMMAND &&
275 251 hellwig
            event.xclient.format == 8) {
276 8 hellwig
          run = false;
277
        }
278
        break;
279
      case KeyPress:
280
        keyPressed(event.xkey.keycode);
281
        break;
282
      case KeyRelease:
283
        keyReleased(event.xkey.keycode);
284
        break;
285
      default:
286
        break;
287
    }
288
  }
289
  exitMonitor();
290
  return NULL;
291
}
292
 
293
 
294
/**************************************************************/
295
 
296
/* refresh timer */
297
 
298
 
299 251 hellwig
static Bool volatile refreshRunning = false;
300
static Bool volatile blink = false;
301 8 hellwig
 
302
 
303
static void *refresh(void *ignore) {
304
  static int blinkCounter = 0;
305
  struct timespec delay;
306
 
307
  while (refreshRunning) {
308
    if (++blinkCounter == 5) {
309
      blinkCounter = 0;
310
      blink = !blink;
311
    }
312
    XSendEvent(vga.display, vga.win, False, 0, (XEvent *) &vga.expose);
313
    XFlush(vga.display);
314
    delay.tv_sec = 0;
315
    delay.tv_nsec = 100 * 1000 * 1000;
316
    nanosleep(&delay, &delay);
317
  }
318
  return NULL;
319
}
320
 
321
 
322
/**************************************************************/
323
 
324
/* server interface */
325
 
326
 
327
static int myArgc = 1;
328
static char *myArgv[] = {
329
  "eco32",
330
  NULL
331
};
332
 
333 251 hellwig
static pthread_t monitorThread;
334
static pthread_t refreshThread;
335 8 hellwig
 
336 251 hellwig
 
337 8 hellwig
static void vgaInit(void) {
338
  /* start monitor server in a separate thread */
339
  vga.argc = myArgc;
340
  vga.argv = myArgv;
341 251 hellwig
  if (pthread_create(&monitorThread, NULL, server, NULL) != 0) {
342 8 hellwig
    error("cannot start monitor server");
343
  }
344 251 hellwig
  while (!installed) ;
345 8 hellwig
  /* start refresh timer in another thread */
346
  refreshRunning = true;
347 251 hellwig
  if (pthread_create(&refreshThread, NULL, refresh, NULL) != 0) {
348 8 hellwig
    error("cannot start refresh timer");
349
  }
350
}
351
 
352
 
353
static void vgaExit(void) {
354
  refreshRunning = false;
355 251 hellwig
  pthread_join(refreshThread, NULL);
356 8 hellwig
  XSendEvent(vga.display, vga.win, False, 0, (XEvent *) &vga.shutdown);
357
  XSync(vga.display, False);
358 251 hellwig
  pthread_join(monitorThread, NULL);
359 8 hellwig
}
360
 
361
 
362
static void vgaWrite(int x, int y, int r, int g, int b) {
363
  XPutPixel(vga.image, x, y, RGB2PIXEL(r, g, b));
364
}
365
 
366
 
367
/**************************************************************/
368
/**************************************************************/
369
 
370
 
371
#define CELL_SIZE_X     8
372
#define CELL_SIZE_Y     16
373
 
374
#define TEXT_SIZE_X     (WINDOW_SIZE_X / CELL_SIZE_X)
375
#define TEXT_SIZE_Y     (WINDOW_SIZE_Y / CELL_SIZE_Y)
376
 
377
 
378
static Half text[TEXT_SIZE_Y][TEXT_SIZE_X];
379
 
380
static Byte font[] = {
381
#include "font"
382
};
383
 
384
 
385
static void updateCharacter(int x, int y, Half c) {
386
  int xx, yy;
387
  int i, j;
388
  Byte pixels;
389
  int r, g, b;
390
 
391
  xx = x * CELL_SIZE_X;
392
  yy = y * CELL_SIZE_Y;
393
  for (j = 0; j < CELL_SIZE_Y; j++) {
394
    pixels = font[(c & 0x00FF) * CELL_SIZE_Y + j];
395
    for (i = 0; i < CELL_SIZE_X; i++) {
396
      if ((pixels & (1 << (CELL_SIZE_X - 1 - i))) != 0 &&
397
          !((c & 0x8000) != 0 && blink)) {
398
        /* foreground */
399
        if (c & 0x0800) {
400
          /* intensify bit is on */
401
          r = (c & 0x0400) ? 255 : 73;
402
          g = (c & 0x0200) ? 255 : 73;
403
          b = (c & 0x0100) ? 255 : 73;
404
        } else {
405
          /* intensify bit is off */
406
          r = (c & 0x0400) ? 146 : 0;
407
          g = (c & 0x0200) ? 146 : 0;
408
          b = (c & 0x0100) ? 146 : 0;
409
        }
410
      } else {
411
        /* background */
412
        r = (c & 0x4000) ? 146 : 0;
413
        g = (c & 0x2000) ? 146 : 0;
414
        b = (c & 0x1000) ? 146 : 0;
415
      }
416
      vgaWrite(xx + i, yy + j, r, g, b);
417
    }
418
  }
419
}
420
 
421
 
422
static void blinkScreen(void) {
423
  static Bool previousBlink = false;
424
  int x, y;
425
  Half c;
426
 
427
  if (previousBlink == blink) {
428
    /* blink state didn't change, nothing to do */
429
    return;
430
  }
431
  previousBlink = blink;
432
  for (y = 0; y < TEXT_SIZE_Y; y++) {
433
    for (x = 0; x < TEXT_SIZE_X; x++) {
434
      /* update the character if it is blinking */
435
      c = text[y][x];
436
      if (c & 0x8000) {
437
        updateCharacter(x, y, c);
438
      }
439
    }
440
  }
441
}
442
 
443
 
444
static Half readCharAndAttr(int x, int y) {
445
  return text[y][x];
446
}
447
 
448
 
449
static void writeCharAndAttr(int x, int y, Half c) {
450
  text[y][x] = c;
451
  updateCharacter(x, y, c);
452
}
453
 
454
 
455
static char *screen[] = {
456
#include "screen"
457
};
458
 
459
 
460
static void loadSplashScreen(void) {
461
  int x, y;
462
  char *p;
463
 
464
  for (y = 0; y < TEXT_SIZE_Y; y++) {
465
    p = screen[y];
466
    for (x = 0; x < TEXT_SIZE_X; x++) {
467
      writeCharAndAttr(x, y, (Half) 0x0700 | (Half) *p);
468
      p++;
469
    }
470
  }
471
}
472
 
473
 
474
/**************************************************************/
475
 
476
 
477
Word displayRead(Word addr) {
478
  int x, y;
479
  Word data;
480
 
481
  if (debug) {
482
    cPrintf("\n**** DISPLAY READ from 0x%08X", addr);
483
  }
484
  if (!installed) {
485
    throwException(EXC_BUS_TIMEOUT);
486
  }
487
  x = (addr >> 2) & ((1 << 7) - 1);
488
  y = (addr >> 9) & ((1 << 5) - 1);
489
  if (x >= TEXT_SIZE_X || y >= TEXT_SIZE_Y) {
490
    throwException(EXC_BUS_TIMEOUT);
491
  }
492
  data = readCharAndAttr(x, y);
493
  if (debug) {
494
    cPrintf(", data = 0x%08X ****\n", data);
495
  }
496
  return data;
497
}
498
 
499
 
500
void displayWrite(Word addr, Word data) {
501
  int x, y;
502
 
503
  if (debug) {
504
    cPrintf("\n**** DISPLAY WRITE to 0x%08X, data = 0x%08X ****\n",
505
            addr, data);
506
  }
507
  if (!installed) {
508
    throwException(EXC_BUS_TIMEOUT);
509
  }
510
  x = (addr >> 2) & ((1 << 7) - 1);
511
  y = (addr >> 9) & ((1 << 5) - 1);
512
  if (x >= TEXT_SIZE_X || y >= TEXT_SIZE_Y) {
513
    throwException(EXC_BUS_TIMEOUT);
514
  }
515
  writeCharAndAttr(x, y, data);
516
}
517
 
518
 
519
void displayReset(void) {
520
  if (!installed) {
521
    return;
522
  }
523
  cPrintf("Resetting Display...\n");
524
  loadSplashScreen();
525
}
526
 
527
 
528
void displayInit(void) {
529
  if (!installed) {
530
    vgaInit();
531
  }
532
  displayReset();
533
}
534
 
535
 
536
void displayExit(void) {
537
  if (!installed) {
538
    return;
539
  }
540
  vgaExit();
541
}
542
 
543
 
544
/**************************************************************/
545
/**************************************************************/
546
 
547
 
548
#define MAX_MAKE        2
549
#define MAX_BREAK       3
550
 
551
 
552
typedef struct {
553
  unsigned int xKeycode;
554
  int pcNumMake;
555
  Byte pcKeyMake[MAX_MAKE];
556
  int pcNumBreak;
557
  Byte pcKeyBreak[MAX_BREAK];
558
} Keycode;
559
 
560
 
561
static Keycode kbdCodeTbl[] = {
562
  { 0x09, 1, { 0x76, 0x00 }, 2, { 0xF0, 0x76, 0x00 } },
563
  { 0x43, 1, { 0x05, 0x00 }, 2, { 0xF0, 0x05, 0x00 } },
564
  { 0x44, 1, { 0x06, 0x00 }, 2, { 0xF0, 0x06, 0x00 } },
565
  { 0x45, 1, { 0x04, 0x00 }, 2, { 0xF0, 0x04, 0x00 } },
566
  { 0x46, 1, { 0x0C, 0x00 }, 2, { 0xF0, 0x0C, 0x00 } },
567
  { 0x47, 1, { 0x03, 0x00 }, 2, { 0xF0, 0x03, 0x00 } },
568
  { 0x48, 1, { 0x0B, 0x00 }, 2, { 0xF0, 0x0B, 0x00 } },
569
  { 0x49, 1, { 0x83, 0x00 }, 2, { 0xF0, 0x83, 0x00 } },
570
  { 0x4A, 1, { 0x0A, 0x00 }, 2, { 0xF0, 0x0A, 0x00 } },
571
  { 0x4B, 1, { 0x01, 0x00 }, 2, { 0xF0, 0x01, 0x00 } },
572
  { 0x4C, 1, { 0x09, 0x00 }, 2, { 0xF0, 0x09, 0x00 } },
573
  { 0x5F, 1, { 0x78, 0x00 }, 2, { 0xF0, 0x78, 0x00 } },
574
  { 0x60, 1, { 0x07, 0x00 }, 2, { 0xF0, 0x07, 0x00 } },
575
  /*------------------------------------------------*/
576
  { 0x31, 1, { 0x0E, 0x00 }, 2, { 0xF0, 0x0E, 0x00 } },
577
  { 0x0A, 1, { 0x16, 0x00 }, 2, { 0xF0, 0x16, 0x00 } },
578
  { 0x0B, 1, { 0x1E, 0x00 }, 2, { 0xF0, 0x1E, 0x00 } },
579
  { 0x0C, 1, { 0x26, 0x00 }, 2, { 0xF0, 0x26, 0x00 } },
580
  { 0x0D, 1, { 0x25, 0x00 }, 2, { 0xF0, 0x25, 0x00 } },
581
  { 0x0E, 1, { 0x2E, 0x00 }, 2, { 0xF0, 0x2E, 0x00 } },
582
  { 0x0F, 1, { 0x36, 0x00 }, 2, { 0xF0, 0x36, 0x00 } },
583
  { 0x10, 1, { 0x3D, 0x00 }, 2, { 0xF0, 0x3D, 0x00 } },
584
  { 0x11, 1, { 0x3E, 0x00 }, 2, { 0xF0, 0x3E, 0x00 } },
585
  { 0x12, 1, { 0x46, 0x00 }, 2, { 0xF0, 0x46, 0x00 } },
586
  { 0x13, 1, { 0x45, 0x00 }, 2, { 0xF0, 0x45, 0x00 } },
587
  { 0x14, 1, { 0x4E, 0x00 }, 2, { 0xF0, 0x4E, 0x00 } },
588
  { 0x15, 1, { 0x55, 0x00 }, 2, { 0xF0, 0x55, 0x00 } },
589
  { 0x16, 1, { 0x66, 0x00 }, 2, { 0xF0, 0x66, 0x00 } },
590
  /*------------------------------------------------*/
591
  { 0x17, 1, { 0x0D, 0x00 }, 2, { 0xF0, 0x0D, 0x00 } },
592
  { 0x18, 1, { 0x15, 0x00 }, 2, { 0xF0, 0x15, 0x00 } },
593
  { 0x19, 1, { 0x1D, 0x00 }, 2, { 0xF0, 0x1D, 0x00 } },
594
  { 0x1A, 1, { 0x24, 0x00 }, 2, { 0xF0, 0x24, 0x00 } },
595
  { 0x1B, 1, { 0x2D, 0x00 }, 2, { 0xF0, 0x2D, 0x00 } },
596
  { 0x1C, 1, { 0x2C, 0x00 }, 2, { 0xF0, 0x2C, 0x00 } },
597
  { 0x1D, 1, { 0x35, 0x00 }, 2, { 0xF0, 0x35, 0x00 } },
598
  { 0x1E, 1, { 0x3C, 0x00 }, 2, { 0xF0, 0x3C, 0x00 } },
599
  { 0x1F, 1, { 0x43, 0x00 }, 2, { 0xF0, 0x43, 0x00 } },
600
  { 0x20, 1, { 0x44, 0x00 }, 2, { 0xF0, 0x44, 0x00 } },
601
  { 0x21, 1, { 0x4D, 0x00 }, 2, { 0xF0, 0x4D, 0x00 } },
602
  { 0x22, 1, { 0x54, 0x00 }, 2, { 0xF0, 0x54, 0x00 } },
603
  { 0x23, 1, { 0x5B, 0x00 }, 2, { 0xF0, 0x5B, 0x00 } },
604
  { 0x24, 1, { 0x5A, 0x00 }, 2, { 0xF0, 0x5A, 0x00 } },
605
  /*------------------------------------------------*/
606
  { 0x42, 1, { 0x58, 0x00 }, 2, { 0xF0, 0x58, 0x00 } },
607
  { 0x26, 1, { 0x1C, 0x00 }, 2, { 0xF0, 0x1C, 0x00 } },
608
  { 0x27, 1, { 0x1B, 0x00 }, 2, { 0xF0, 0x1B, 0x00 } },
609
  { 0x28, 1, { 0x23, 0x00 }, 2, { 0xF0, 0x23, 0x00 } },
610
  { 0x29, 1, { 0x2B, 0x00 }, 2, { 0xF0, 0x2B, 0x00 } },
611
  { 0x2A, 1, { 0x34, 0x00 }, 2, { 0xF0, 0x34, 0x00 } },
612
  { 0x2B, 1, { 0x33, 0x00 }, 2, { 0xF0, 0x33, 0x00 } },
613
  { 0x2C, 1, { 0x3B, 0x00 }, 2, { 0xF0, 0x3B, 0x00 } },
614
  { 0x2D, 1, { 0x42, 0x00 }, 2, { 0xF0, 0x42, 0x00 } },
615
  { 0x2E, 1, { 0x4B, 0x00 }, 2, { 0xF0, 0x4B, 0x00 } },
616
  { 0x2F, 1, { 0x4C, 0x00 }, 2, { 0xF0, 0x4C, 0x00 } },
617
  { 0x30, 1, { 0x52, 0x00 }, 2, { 0xF0, 0x52, 0x00 } },
618
  { 0x33, 1, { 0x5D, 0x00 }, 2, { 0xF0, 0x5D, 0x00 } },
619
  /*------------------------------------------------*/
620
  { 0x32, 1, { 0x12, 0x00 }, 2, { 0xF0, 0x12, 0x00 } },
621
  { 0x5E, 1, { 0x61, 0x00 }, 2, { 0xF0, 0x61, 0x00 } },
622
  { 0x34, 1, { 0x1A, 0x00 }, 2, { 0xF0, 0x1A, 0x00 } },
623
  { 0x35, 1, { 0x22, 0x00 }, 2, { 0xF0, 0x22, 0x00 } },
624
  { 0x36, 1, { 0x21, 0x00 }, 2, { 0xF0, 0x21, 0x00 } },
625
  { 0x37, 1, { 0x2A, 0x00 }, 2, { 0xF0, 0x2A, 0x00 } },
626
  { 0x38, 1, { 0x32, 0x00 }, 2, { 0xF0, 0x32, 0x00 } },
627
  { 0x39, 1, { 0x31, 0x00 }, 2, { 0xF0, 0x31, 0x00 } },
628
  { 0x3A, 1, { 0x3A, 0x00 }, 2, { 0xF0, 0x3A, 0x00 } },
629
  { 0x3B, 1, { 0x41, 0x00 }, 2, { 0xF0, 0x41, 0x00 } },
630
  { 0x3C, 1, { 0x49, 0x00 }, 2, { 0xF0, 0x49, 0x00 } },
631
  { 0x3D, 1, { 0x4A, 0x00 }, 2, { 0xF0, 0x4A, 0x00 } },
632
  { 0x3E, 1, { 0x59, 0x00 }, 2, { 0xF0, 0x59, 0x00 } },
633
  /*------------------------------------------------*/
634
  { 0x25, 1, { 0x14, 0x00 }, 2, { 0xF0, 0x14, 0x00 } },
635
  { 0x73, 2, { 0xE0, 0x1F }, 3, { 0xE0, 0xF0, 0x1F } },
636
  { 0x40, 1, { 0x11, 0x00 }, 2, { 0xF0, 0x11, 0x00 } },
637
  { 0x41, 1, { 0x29, 0x00 }, 2, { 0xF0, 0x29, 0x00 } },
638
  { 0x71, 2, { 0xE0, 0x11 }, 3, { 0xE0, 0xF0, 0x11 } },
639
  { 0x74, 2, { 0xE0, 0x27 }, 3, { 0xE0, 0xF0, 0x27 } },
640
  { 0x75, 2, { 0xE0, 0x2F }, 3, { 0xE0, 0xF0, 0x2F } },
641
  { 0x6D, 2, { 0xE0, 0x14 }, 3, { 0xE0, 0xF0, 0x14 } },
642
  /*------------------------------------------------*/
643
  { 0x6A, 2, { 0xE0, 0x70 }, 3, { 0xE0, 0xF0, 0x70 } },
644
  { 0x61, 2, { 0xE0, 0x6C }, 3, { 0xE0, 0xF0, 0x6C } },
645
  { 0x63, 2, { 0xE0, 0x7D }, 3, { 0xE0, 0xF0, 0x7D } },
646
  { 0x6B, 2, { 0xE0, 0x71 }, 3, { 0xE0, 0xF0, 0x71 } },
647
  { 0x67, 2, { 0xE0, 0x69 }, 3, { 0xE0, 0xF0, 0x69 } },
648
  { 0x69, 2, { 0xE0, 0x7A }, 3, { 0xE0, 0xF0, 0x7A } },
649
  { 0x62, 2, { 0xE0, 0x75 }, 3, { 0xE0, 0xF0, 0x75 } },
650
  { 0x64, 2, { 0xE0, 0x6B }, 3, { 0xE0, 0xF0, 0x6B } },
651
  { 0x68, 2, { 0xE0, 0x72 }, 3, { 0xE0, 0xF0, 0x72 } },
652
  { 0x66, 2, { 0xE0, 0x74 }, 3, { 0xE0, 0xF0, 0x74 } },
653
  /*------------------------------------------------*/
654
  { 0x4D, 1, { 0x77, 0x00 }, 2, { 0xF0, 0x77, 0x00 } },
655
  { 0x70, 2, { 0xE0, 0x4A }, 3, { 0xE0, 0xF0, 0x4A } },
656
  { 0x3F, 1, { 0x7C, 0x00 }, 2, { 0xF0, 0x7C, 0x00 } },
657
  { 0x52, 1, { 0x7B, 0x00 }, 2, { 0xF0, 0x7B, 0x00 } },
658
  { 0x4F, 1, { 0x6C, 0x00 }, 2, { 0xF0, 0x6C, 0x00 } },
659
  { 0x50, 1, { 0x75, 0x00 }, 2, { 0xF0, 0x75, 0x00 } },
660
  { 0x51, 1, { 0x7D, 0x00 }, 2, { 0xF0, 0x7D, 0x00 } },
661
  { 0x56, 1, { 0x79, 0x00 }, 2, { 0xF0, 0x79, 0x00 } },
662
  { 0x53, 1, { 0x6B, 0x00 }, 2, { 0xF0, 0x6B, 0x00 } },
663
  { 0x54, 1, { 0x73, 0x00 }, 2, { 0xF0, 0x73, 0x00 } },
664
  { 0x55, 1, { 0x74, 0x00 }, 2, { 0xF0, 0x74, 0x00 } },
665
  { 0x57, 1, { 0x69, 0x00 }, 2, { 0xF0, 0x69, 0x00 } },
666
  { 0x58, 1, { 0x72, 0x00 }, 2, { 0xF0, 0x72, 0x00 } },
667
  { 0x59, 1, { 0x7A, 0x00 }, 2, { 0xF0, 0x7A, 0x00 } },
668
  { 0x6C, 2, { 0xE0, 0x5A }, 3, { 0xE0, 0xF0, 0x5A } },
669
  { 0x5A, 1, { 0x70, 0x00 }, 2, { 0xF0, 0x70, 0x00 } },
670
  { 0x5B, 1, { 0x71, 0x00 }, 2, { 0xF0, 0x71, 0x00 } },
671
};
672
 
673
 
674
static int keycodeCompare(const void *code1, const void *code2) {
675
  return ((Keycode *) code1)->xKeycode - ((Keycode *) code2)->xKeycode;
676
}
677
 
678
 
679
static void initKeycode(void) {
680
  qsort(kbdCodeTbl, sizeof(kbdCodeTbl)/sizeof(kbdCodeTbl[0]),
681
        sizeof(kbdCodeTbl[0]), keycodeCompare);
682
}
683
 
684
 
685
static Keycode *lookupKeycode(unsigned int xKeycode) {
686
  int lo, hi, tst;
687
  int res;
688
 
689
  lo = 0;
690
  hi = sizeof(kbdCodeTbl) / sizeof(kbdCodeTbl[0]) - 1;
691
  while (lo <= hi) {
692
    tst = (lo + hi) / 2;
693
    res = kbdCodeTbl[tst].xKeycode - xKeycode;
694
    if (res == 0) {
695
      return &kbdCodeTbl[tst];
696
    }
697
    if (res < 0) {
698
      lo = tst + 1;
699
    } else {
700
      hi = tst - 1;
701
    }
702
  }
703
  return NULL;
704
}
705
 
706
 
707
/**************************************************************/
708
 
709
 
710
#define KBD_BUF_MAX             100
711
#define KBD_BUF_NEXT(p)         (((p) + 1) % KBD_BUF_MAX)
712
 
713
 
714
static Byte kbdBuf[KBD_BUF_MAX];
715
static int kbdBufWritePtr;
716
static int kbdBufReadPtr;
717
 
718
 
719
static void kbdBufInit(void) {
720
  initKeycode();
721
  kbdBufWritePtr = 0;
722
  kbdBufReadPtr = 0;
723
}
724
 
725
 
726
static int kbdBufFree(void) {
727
  if (kbdBufReadPtr <= kbdBufWritePtr) {
728
    return KBD_BUF_MAX - (kbdBufWritePtr - kbdBufReadPtr) - 1;
729
  } else {
730
    return (kbdBufReadPtr - kbdBufWritePtr) - 1;
731
  }
732
}
733
 
734
 
735
static void keyPressed(unsigned int xKeycode) {
736
  Keycode *p;
737
  int i;
738
 
739
  if (debugKeycode) {
740
    cPrintf("**** KEY PRESSED: 0x%08X ****\n", xKeycode);
741
  }
742
  p = lookupKeycode(xKeycode);
743
  if (p == NULL) {
744
    /* keycode not found */
745
    return;
746
  }
747
  if (kbdBufFree() < (MAX_MAKE + MAX_BREAK) * 4) {
748
    /* buffer full */
749
    return;
750
  }
751
  for (i = 0; i < p->pcNumMake; i++) {
752
    kbdBuf[kbdBufWritePtr] = p->pcKeyMake[i];
753
    kbdBufWritePtr = KBD_BUF_NEXT(kbdBufWritePtr);
754
  }
755
}
756
 
757
 
758
static void keyReleased(unsigned int xKeycode) {
759
  Keycode *p;
760
  int i;
761
 
762
  if (debugKeycode) {
763
    cPrintf("**** KEY RELEASED: 0x%08X ****\n", xKeycode);
764
  }
765
  p = lookupKeycode(xKeycode);
766
  if (p == NULL) {
767
    /* keycode not found */
768
    return;
769
  }
770
  if (kbdBufFree() < MAX_BREAK * 4) {
771
    /* buffer full */
772
    return;
773
  }
774
  for (i = 0; i < p->pcNumBreak; i++) {
775
    kbdBuf[kbdBufWritePtr] = p->pcKeyBreak[i];
776
    kbdBufWritePtr = KBD_BUF_NEXT(kbdBufWritePtr);
777
  }
778
}
779
 
780
 
781
/**************************************************************/
782
 
783
 
784
static Word kbdCtrl;
785
static Word kbdData;
786
 
787
 
788
static void kbdCallback(int dev) {
789
  if (debug) {
790
    cPrintf("\n**** KEYBOARD CALLBACK ****\n");
791
  }
792 25 hellwig
  timerStart(KEYBOARD_USEC, kbdCallback, dev);
793 8 hellwig
  if (kbdBufWritePtr == kbdBufReadPtr) {
794
    /* no character ready */
795
    return;
796
  }
797
  /* any character typed */
798
  kbdData = kbdBuf[kbdBufReadPtr];
799
  kbdBufReadPtr = KBD_BUF_NEXT(kbdBufReadPtr);
800
  kbdCtrl |= KEYBOARD_RDY;
801
  if (kbdCtrl & KEYBOARD_IEN) {
802
    /* raise keyboard interrupt */
803
    cpuSetInterrupt(IRQ_KEYBOARD);
804
  }
805
}
806
 
807
 
808
Word keyboardRead(Word addr) {
809
  Word data;
810
 
811
  if (debug) {
812
    cPrintf("\n**** KEYBOARD READ from 0x%08X", addr);
813
  }
814
  if (!installed) {
815
    throwException(EXC_BUS_TIMEOUT);
816
  }
817
  if (addr == KEYBOARD_CTRL) {
818
    data = kbdCtrl;
819
  } else
820
  if (addr == KEYBOARD_DATA) {
821
    kbdCtrl &= ~KEYBOARD_RDY;
822
    if (kbdCtrl & KEYBOARD_IEN) {
823
      /* lower keyboard interrupt */
824
      cpuResetInterrupt(IRQ_KEYBOARD);
825
    }
826
    data = kbdData;
827
  } else {
828
    /* illegal register */
829
    throwException(EXC_BUS_TIMEOUT);
830
  }
831
  if (debug) {
832
    cPrintf(", data = 0x%08X ****\n", data);
833
  }
834
  return data;
835
}
836
 
837
 
838
void keyboardWrite(Word addr, Word data) {
839
  if (debug) {
840
    cPrintf("\n**** KEYBOARD WRITE to 0x%08X, data = 0x%08X ****\n",
841
            addr, data);
842
  }
843
  if (!installed) {
844
    throwException(EXC_BUS_TIMEOUT);
845
  }
846
  if (addr == KEYBOARD_CTRL) {
847
    if (data & KEYBOARD_IEN) {
848
      kbdCtrl |= KEYBOARD_IEN;
849
    } else {
850
      kbdCtrl &= ~KEYBOARD_IEN;
851
    }
852
    if (data & KEYBOARD_RDY) {
853
      kbdCtrl |= KEYBOARD_RDY;
854
    } else {
855
      kbdCtrl &= ~KEYBOARD_RDY;
856
    }
857
    if ((kbdCtrl & KEYBOARD_IEN) != 0 &&
858
        (kbdCtrl & KEYBOARD_RDY) != 0) {
859
      /* raise keyboard interrupt */
860
      cpuSetInterrupt(IRQ_KEYBOARD);
861
    } else {
862
      /* lower keyboard interrupt */
863
      cpuResetInterrupt(IRQ_KEYBOARD);
864
    }
865
  } else
866
  if (addr == KEYBOARD_DATA) {
867
    /* this register is read-only */
868
    throwException(EXC_BUS_TIMEOUT);
869
  } else {
870
    /* illegal register */
871
    throwException(EXC_BUS_TIMEOUT);
872
  }
873
}
874
 
875
 
876
void keyboardReset(void) {
877
  if (!installed) {
878
    return;
879
  }
880
  cPrintf("Resetting Keyboard...\n");
881
  kbdBufInit();
882
  kbdCtrl = 0;
883
  kbdData = 0;
884 25 hellwig
  timerStart(KEYBOARD_USEC, kbdCallback, 0);
885 8 hellwig
}
886
 
887
 
888
void keyboardInit(void) {
889
  if (!installed) {
890
    vgaInit();
891
  }
892
  keyboardReset();
893
}
894
 
895
 
896
void keyboardExit(void) {
897
  if (!installed) {
898
    return;
899
  }
900
  vgaExit();
901
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.