Prex Home / Browse Source - Prex Version: 0.9.0

root/bsp/drv/arm/gba/swkbd.c

DEFINITIONS

1. swkbd_select_page
2. swkbd_toggle_shift
3. swkbd_timeout
4. swkbd_move_cursor
5. swkbd_key_press
6. swkbd_input
7. swkbd_init_image
8. swkbd_init_cursor
9. swkbd_init

   1 /*-
   2  * Copyright (c) 2005, Kohsuke Ohtani
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 3. Neither the name of the author nor the names of any co-contributors
  14  *    may be used to endorse or promote products derived from this software
  15  *    without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  */
  30 /*
  31  * swkbd.c - GBA software keyboard driver
  32  */
  34 /**
  35  * This driver emulates a generic keyboard by using GBA keypad.
  36  *
  37  * <Key assign>
  38  *
  39  * On-screen keyboard:
  40  *
  41  *  A        : Select pointed key
  42  *  B        : Enter key
  43  *  Select   : Hide virtual keyboard
  44  *  Start    :
  45  *  Right    : Move keyboard cursor right
  46  *  Left     : Move keyboard cursor left
  47  *  Up       : Move keyboard cursor up
  48  *  Down     : Move keyboard cursor down
  49  *  Button R : Toggle shift state
  50  *  Button L : Toggle shift state
  51  *
  52  * No on-screen keyboard:
  53  *
  54  *  A        : A key
  55  *  B        : B key
  56  *  Select   : Show virtual keyboard
  57  *  Start    : Enter key
  58  *  Right    : Right key
  59  *  Left     : Left key
  60  *  Up       : Up key
  61  *  Down     : Down key
  62  *  Button R : R key
  63  *  Button L : L Key
  64  *
  65  */
  67 #include <driver.h>
  68 #include <sys/keycode.h>
  69 #include <wscons.h>
  70 #include "lcd.h"
  71 #include "kbd_img.h"
  72 #include "keymap.h"
  74 /*
  75  * Since GBA does not kick interrupt for the button release, we have
  76  * to wait for a while after button is pressed. Otherwise, many key
  77  * events are queued by one button press.
  78  */
  79 #define CURSOR_WAIT     100     /* 100 msec */
  80 #define BUTTON_WAIT     200     /* 200 msec */
  82 struct swkbd_softc {
device_t        dev;            /* device object */
irq_t           irq;            /* irq handle */
timer_t         timer;          /* timer to prevent chattering */
  87         int             kbd_on;         /* 0: direct input, 1: virtual KBD */
  88         int             kbd_page;       /* video page to display keyboard */
  89         int             ignore_key;     /* ignore key input if true */
u_int           pos_x;          /* cursor x position */
u_int           pos_y;          /* cursor y position */
  92         int             cursor_type;    /* current cursor type */
  94         int             shift;          /* shift key state */
  95         int             alt;            /* alt key state */
  96         int             ctrl;           /* control key state */
  97         int             capslk;         /* caps lock key staet */
  98 };
 100 static int      swkbd_init(struct driver *);
 101 static void     swkbd_move_cursor(void);
 103 static struct devops swkbd_devops = {
 104         /* open */      no_open,
 105         /* close */     no_close,
 106         /* read */      no_read,
 107         /* write */     no_write,
 108         /* ioctl */     no_ioctl,
 109         /* devctl */    no_devctl,
 110 };
 112 struct driver swkbd_driver = {
 113         /* name */      "swkbd",
 114         /* devops */    &swkbd_devops,
 115         /* devsz */     sizeof(struct swkbd_softc),
 116         /* flags */     0,
 117         /* probe */     NULL,
 118         /* init */      swkbd_init,
 119         /* shutdown */  NULL,
 120 };
 123 static struct swkbd_softc *swkbd_softc;
 126 /*
 127  * Select keyboard page.
 128  *
 129  *   Page0 ... Text only
 130  *   Page1 ... Text & Normal keyboard
 131  *   Page2 ... Text & Shifted keyboard
 132  */
 133 static void
swkbd_select_page(int page)
 135 {
 137         if (page == 0)
REG_DISPCNT = 0x0840;   /* only BG3 */
 139         else if (page == 1) {
REG_DISPCNT = 0x1A40;   /* use BG1&3 */
swkbd_move_cursor();
 142         } else {
REG_DISPCNT = 0x1C40;   /* use BG2&3 */
swkbd_move_cursor();
 145         }
swkbd_softc->kbd_page = page;
 147 }
 149 /*
 150  * Toggle keyboard type: normal or shift.
 151  */
 152 static void
swkbd_toggle_shift(void)
 154 {
 155         struct swkbd_softc *sc = swkbd_softc;
 156         int page;
 158         if (sc->kbd_page == 0)
 159                 return;
 160         if (sc->capslk)
page = sc->shift ? 1 : 2;
 162         else
page = sc->shift ? 2 : 1;
swkbd_select_page(page);
 165 }
 167 /*
 168  * Timer call back handler.
 169  * Just clear ignoring flag.
 170  */
 171 static void
swkbd_timeout(void *arg)
 173 {
 174         struct swkbd_softc *sc = arg;
sc->ignore_key = 0;
 177 }
 179 /*
 180  * Move cursor to point key.
 181  */
 182 static void
swkbd_move_cursor(void)
 184 {
 185         struct swkbd_softc *sc = swkbd_softc;
uint16_t *oam = OAM;
 187         struct _key_info *ki;
 188         int x, y;
 189         int curcur;     /* current cursor */
 190         int newcur;     /* new cursor */
curcur = sc->cursor_type;
ki = (struct _key_info *)&key_info[sc->pos_y][sc->pos_x];
x = ki->pos_x + 108;
y = sc->pos_y * 8 + 11;
newcur = 0;
 199         switch (ki->width) {
 200         case 9: newcur = 0; break;
 201         case 11: newcur = 1; break;
 202         case 12: newcur = 2; break;
 203         case 13: newcur = 3; break;
 204         case 15: newcur = 4; break;
 205         case 17: newcur = 5; break;
 206         case 19: newcur = 6; break;
 207         case 53: newcur = 7; break;
 208         }
 209         if (newcur != curcur) {
oam[curcur * 4] = (uint16_t)((oam[curcur * 4] & 0xff00) | 160);
oam[curcur * 4 + 1] = (uint16_t)((oam[curcur * 4 + 1] & 0xfe00) | 240);
sc->cursor_type = newcur;
 213         }
oam[newcur * 4] = (uint16_t)((oam[newcur * 4] & 0xff00) | y);
oam[newcur * 4 + 1] = (uint16_t)((oam[newcur * 4 + 1] & 0xfe00) | x);
 216 }
 218 /*
 219  * Process key press
 220  */
 221 static void
swkbd_key_press(void)
 223 {
 224         struct swkbd_softc *sc = swkbd_softc;
 225         struct _key_info *ki;
u_char ac;
ki = (struct _key_info *)&key_info[sc->pos_y][sc->pos_x];
ac = ki->normal;
 231         /* Check meta key */
 232         switch (ac) {
 233         case K_SHFT:
sc->shift = !sc->shift;
swkbd_toggle_shift();
 236                 return;
 237         case K_CTRL:
sc->ctrl = !sc->ctrl;
 239                 return;
 240         case K_ALT:
sc->alt = !sc->alt;
 242                 return;
 243         case K_CAPS:
sc->capslk = !sc->capslk;
swkbd_toggle_shift();
 246                 return;
 247         }
 248         /* Check ctrl & shift state */
 249         if (sc->ctrl) {
 250                 if (ac >= 'a' && ac <= 'z')
ac = ac - 'a' + 0x01;
 252                 else if (ac == '\\')
ac = 0x1c;
 254                 else
ac = 0;
 256         } else if (sc->kbd_page == 2)
ac = ki->shifted;
 259         if (ac == 0)
 260                 return;
 262         /* Check caps lock state */
 263         if (sc->capslk) {
 264                 if (ac >= 'A' && ac <= 'Z')
ac += 'a' - 'A';
 266                 else if (ac >= 'a' && ac <= 'z')
ac -= 'a' - 'A';
 268         }
 270         /* Check alt key */
 271         if (sc->alt)
ac |= 0x80;
wscons_kbd_input(ac);
 276         /*
 277          * Reset meta key status
 278          */
 279         if (sc->shift) {
sc->shift = 0;
swkbd_toggle_shift();
 282         }
 283         if (sc->ctrl)
sc->ctrl = 0;
 285         if (sc->alt)
sc->alt = 0;
 287 }
 289 /*
 290  * Input handler
 291  * This routine will be called by gamepad ISR.
 292  */
 293 void
swkbd_input(u_char c)
 295 {
 296         struct swkbd_softc *sc = swkbd_softc;
 297         int move = 0;
 298         int timeout = BUTTON_WAIT;
 300         if (sc->ignore_key)
 301                 return;
 303         /* Select key */
 304         if (c == '\t') {
sc->kbd_on = !sc->kbd_on;
swkbd_select_page(sc->kbd_on);
 308                 /* Reset meta status */
sc->shift = 0;
sc->alt = 0;
sc->ctrl = 0;
sc->capslk = 0;
 313                 goto out;
 314         }
 316         /* Direct input */
 317         if (!sc->kbd_on) {
wscons_kbd_input(c);
 319                 goto out;
 320         }
 322         switch (c) {
 323         case K_LEFT:
 324                 if (sc->pos_x > 0) {
 325                         if (sc->pos_y == 4 && sc->pos_x >=4 && sc->pos_x <= 8)
sc->pos_x = 3;
sc->pos_x--;
move = 1;
 329                 }
 330                 break;
 331         case K_RGHT:
 332                 if (sc->pos_x < max_x[sc->pos_y]) {
 333                         if (sc->pos_y == 4 && sc->pos_x > 3 && sc->pos_x <= 7)
sc->pos_x = 8;
sc->pos_x++;
move = 1;
 337                 }
 338                 break;
 339         case K_UP:
 340                 if (sc->pos_y > 0 ) {
sc->pos_y--;
move = 1;
 343                         if (sc->pos_x > max_x[sc->pos_y])
sc->pos_x = max_x[sc->pos_y];
 345                 }
 346                 break;
 347         case K_DOWN:
 348                 if (sc->pos_y < 4) {
sc->pos_y++;
move = 1;
 351                         if (sc->pos_x > max_x[sc->pos_y])
sc->pos_x = max_x[sc->pos_y];
 353                 }
 354                 break;
 355         case 'A':
swkbd_key_press();
 357                 break;
 358         case 'B':
wscons_kbd_input('\n');
 360                 break;
 361         case 'R':
 362         case 'L':
sc->shift = sc->shift ? 0 : 1;
swkbd_toggle_shift();
 365                 break;
 366         }
 367         if (move) {
timeout = CURSOR_WAIT;
swkbd_move_cursor();
 370         }
out:
sc->ignore_key = 1;
timer_callout(&sc->timer, timeout, &swkbd_timeout, sc);
 374         return;
 375 }
 377 /*
 378  * Init keyboard image
 379  */
 380 static void
swkbd_init_image(void)
 382 {
uint8_t bit;
uint16_t val1, val2;
uint16_t *pal = BG_PALETTE;
uint16_t *tile1 = KBD1_TILE;
uint16_t *tile2 = KBD2_TILE;
uint16_t *map1 = KBD1_MAP;
uint16_t *map2 = KBD2_MAP;
 390         int i, j, row, col;
 392         /* Load tiles for keyboard image */
 393         for (i = 0; i < 32; i++)
tile1[i] = 0;
 396         for (i = 0; i < 64 * 12; i++) {
bit = 0x01;
 398                 for (j = 0; j < 4; j++) {
val1 = kbd1_bitmap[i] & bit ? 0xff : 0x03;
val2 = kbd2_bitmap[i] & bit ? 0xff : 0x03;
bit = bit << 1;
val1 |= kbd1_bitmap[i] & bit ? 0xff00 : 0x0300;
val2 |= kbd2_bitmap[i] & bit ? 0xff00 : 0x0300;
bit = bit << 1;
tile1[i * 4 + 32 + j] = val1;
tile2[i * 4 + j] = val2;
 407                 }
 408         }
 411         /* Setup map */
i = 1;
 413         for (row = 1; row < 7; row++) {
 414                 for (col = 13; col < 29; col++) {
map1[row * 32 + col] = (uint16_t)i;
map2[row * 32 + col] = (uint16_t)(i + 127);
i++;
 418                 }
 419         }
pal[3] = RGB(0,0,31);   /* Kbd bg color */
pal[255] = RGB(28,28,28);       /* Kbd color */
 424         /* Setup video */
REG_BG1CNT = 0x1284;    /* Size0, 256color, priority0 */
REG_BG2CNT = 0x1484;    /* Size0, 256color, priority0 */
swkbd_select_page(1);
 429 }
 431 /*
 432  * Initialize keyboard cursor
 433  */
 434 static void
swkbd_init_cursor(void)
 436 {
 437         int i, j;
uint8_t bit;
uint16_t val;
uint16_t *oam = OAM;
uint16_t *cur = CURSOR_DATA;
uint16_t *pal = SPL_PALETTE;
 444         /* Move out all objects */
 445         for (i = 0; i < 128; i++) {
oam[0] = 160;
oam[1] = 240;
oam += 4;
 449         }
 450         /* Load cursor splite */
 451         for (i = 0; i < 64 * 7 + 64 * 8; i++) {
bit = 0x01;
 453                 for (j = 0; j < 4; j++) {
val = cursor_bitmap[i] & bit ? 0xff : 0;
bit = bit << 1;
val |= cursor_bitmap[i] & bit ? 0xff00 : 0;
bit = bit << 1;
cur[i * 4 + j] = val;
 459                 }
 460         }
 462         /* Setup cursors */
oam = OAM;
 464         for (i = 0; i < 7; i++) {
oam[0] = (uint16_t)(0x6000 + 160); /* 256 color, Horizontal */
oam[1] = (uint16_t)(0x8000 + 240); /* 32x16 */
oam[2] = (uint16_t)(i * 16); /* Tile number */
oam += 4;
 469         }
 470         /* for space key */
oam[0] = 0x6000 + 160; /* 256 color, Horizontal */
oam[1] = 0xC000 + 240; /* 64x32 */
oam[2] = 112;
pal[255] = RGB(31,0,0); /* cursor color */
 476 }
 478 /*
 479  * Initialize
 480  */
 481 static int
swkbd_init(struct driver *self)
 483 {
 484         struct swkbd_softc *sc;
device_t dev;
dev = device_create(self, "swkbd", D_CHR);
sc = device_private(dev);
sc->dev = dev;
sc->kbd_on = 1;
swkbd_softc = sc;
swkbd_init_cursor();
swkbd_init_image();
swkbd_move_cursor();
 499         return 0;
 500 }