1 /* $NetBSD: wzero3_kbd.c,v 1.8 2012/10/27 17:17:52 chs Exp $ */ 2 3 /*- 4 * Copyright (C) 2008, 2009, 2010 NONAKA Kimihiro <nonaka@netbsd.org> 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 17 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 18 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 19 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 21 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 22 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 23 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 24 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 25 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 26 */ 27 28 #include <sys/cdefs.h> 29 __KERNEL_RCSID(0, "$NetBSD: wzero3_kbd.c,v 1.8 2012/10/27 17:17:52 chs Exp $"); 30 31 #include <sys/param.h> 32 #include <sys/systm.h> 33 #include <sys/device.h> 34 #include <sys/kernel.h> 35 #include <sys/malloc.h> 36 #include <sys/callout.h> 37 #include <sys/bus.h> 38 39 #include <dev/sysmon/sysmonvar.h> 40 #include <dev/sysmon/sysmon_taskq.h> 41 42 #include <arm/xscale/pxa2x0cpu.h> 43 #include <arm/xscale/pxa2x0var.h> 44 #include <arm/xscale/pxa2x0_gpio.h> 45 46 #include <machine/bootinfo.h> 47 #include <machine/config_hook.h> 48 #include <machine/platid.h> 49 #include <machine/platid_mask.h> 50 51 #include <dev/hpc/hpckbdvar.h> 52 53 #include <arch/hpcarm/dev/wzero3_reg.h> 54 55 #ifdef DEBUG 56 #define DPRINTF(arg) printf arg 57 #else 58 #define DPRINTF(arg) /* nothing */ 59 #endif 60 61 #define CSR_READ1(r) bus_space_read_1(sc->sc_iot, sc->sc_ioh, (r)) 62 #define CSR_WRITE1(r,v) bus_space_write_1(sc->sc_iot, sc->sc_ioh, (r), (v)) 63 #define CSR_READ2(r) bus_space_read_2(sc->sc_iot, sc->sc_ioh, (r)) 64 #define CSR_WRITE2(r,v) bus_space_write_2(sc->sc_iot, sc->sc_ioh, (r), (v)) 65 #define CSR_READ4(r) bus_space_read_4(sc->sc_iot, sc->sc_ioh, (r)) 66 #define CSR_WRITE4(r,v) bus_space_write_4(sc->sc_iot, sc->sc_ioh, (r), (v)) 67 68 /* register */ 69 #define KBDCOL_L (0x00) /* Write */ 70 #define KBDCOL_U (0x04) /* Write */ 71 #define KBDCHARGE (0x08) /* Write */ 72 #define KBDDATA (0x08) /* Read */ 73 #define REGMAPSIZE 0x0c 74 75 #define KEYWAIT 20 /* us */ 76 77 #define WS003SH_NCOLUMN 12 78 #define WS003SH_NROW 7 79 80 struct wzero3kbd_softc { 81 device_t sc_dev; 82 83 bus_space_tag_t sc_iot; 84 bus_space_handle_t sc_ioh; 85 86 int sc_ncolumn; 87 int sc_nrow; 88 uint8_t *sc_okeystat; 89 uint8_t *sc_keystat; 90 91 void *sc_key_ih; 92 void *sc_power_ih; 93 void *sc_reset_ih; 94 95 int sc_key_pin; 96 int sc_power_pin; 97 int sc_reset_pin; 98 99 struct hpckbd_ic_if sc_if; 100 struct hpckbd_if *sc_hpckbd; 101 102 struct sysmon_pswitch sc_smpsw; /* for reset key */ 103 104 int sc_enabled; 105 106 /* polling stuff */ 107 struct callout sc_keyscan_ch; 108 int sc_interval; 109 #define KEY_INTERVAL 50 /* ms */ 110 111 #if defined(KEYTEST) || defined(KEYTEST2) || defined(KEYTEST3) || defined(KEYTEST4) || defined(KEYTEST5) 112 void *sc_test_ih; 113 int sc_test_pin; 114 int sc_nouse_pin; 115 int sc_nouse_pin2; 116 int sc_nouse_pin3; 117 int sc_bit; 118 #endif 119 }; 120 121 static int wzero3kbd_match(device_t, cfdata_t, void *); 122 static void wzero3kbd_attach(device_t, device_t, void *); 123 124 CFATTACH_DECL_NEW(wzero3kbd, sizeof(struct wzero3kbd_softc), 125 wzero3kbd_match, wzero3kbd_attach, NULL, NULL); 126 127 static int wzero3kbd_intr(void *arg); 128 #if defined(KEYTEST) 129 static int wzero3kbd_intr2(void *arg); 130 #endif 131 #if defined(KEYTEST3) 132 static int wzero3kbd_intr3(void *arg); 133 #endif 134 static void wzero3kbd_tick(void *arg); 135 static int wzero3kbd_power_intr(void *arg); 136 static int wzero3kbd_reset_intr(void *arg); 137 static int wzero3kbd_input_establish(void *arg, struct hpckbd_if *kbdif); 138 static void wzero3kbd_sysmon_reset_event(void *arg); 139 static int wzero3kbd_poll(void *arg); 140 static int wzero3kbd_poll1(void *arg); 141 142 /* 143 * WS003SH/WS004SH/WS007SH keyscan map 144 col#0 col#1 col#2 col#3 col#4 col#5 col#6 col#7 col#8 col#9 col#10 col#11 145 row#0: CTRL 1 3 5 6 7 9 0 BS (none) ROTATE CAMERA 146 row#1: (none) 2 4 r y 8 i o p (none) VOL- VOL+ 147 row#2: TAB q e t g u j k (none) (none) (none) (none) 148 row#3: (none) w s f v h m l (none) (none) SHIFT (none) 149 row#4: CALL a d c b n . (none) ENTER (none) WIN (none) 150 row#5: MAIL z x - SPACE / (none) UP (none) (none) LSOFT FN 151 row#6: IE MOJI (none) OK ACTION , LEFT DOWN RIGHT (none) RSOFT (none) 152 */ 153 154 /* 155 * WS011SH keyscan map 156 col#0 col#1 col#2 col#3 col#4 col#5 col#6 col#7 col#8 col#9 col#10 col#11 157 row#0 Ctrl (none) (none) (none) (none) (none) (none) (none) Del (none) ROTATE (none) 158 row#1 (none) (none) (none) R Y (none) I O P (none) (none) (none) 159 row#2 Tab Q E T G U J K (none) (none) (none) (none) 160 row#3 (none) W S F V H M L (none) (none) Shift (none) 161 row#4 (none) A D C B N . (none) Enter (none) (none) (none) 162 row#5 (none) Z X - Space / (none) UP (none) (none) (none) Fn 163 row#6 (none) MOJI HAN/ZEN OK (none) , LEFT DOWN RIGHT (none) (none) (none) 164 */ 165 166 /* 167 * WS020SH keyscan map 168 col#0 col#1 col#2 col#3 col#4 col#5 col#6 col#7 col#8 col#9 col#10 col#11 169 row#0 Ctrl (none) (none) (none) (none) (none) (none) (none) Del (none) ROTATE (none) 170 row#1 (none) (none) (none) R Y (none) I O P (none) MEDIA (none) 171 row#2 Tab Q E T G U J K (none) (none) (none) (none) 172 row#3 (none) W S F V H M L (none) (none) LShift (none) 173 row#4 (none) A D C B N . (none) Enter (none) RShift (none) 174 row#5 (none) Z X - Space / (none) UP (none) DOWN (none) Fn 175 row#6 (none) MOJI HAN/ZEN OK (none) , LEFT (none) RIGHT (none) (none) (none) 176 */ 177 178 static const struct wzero3kbd_model { 179 platid_mask_t *platid; 180 int key_pin; 181 int power_pin; 182 int reset_pin; 183 int ncolumn; 184 int nrow; 185 } wzero3kbd_table[] = { 186 /* WS003SH */ 187 { 188 &platid_mask_MACH_SHARP_WZERO3_WS003SH, 189 -1, /* XXX */ 190 GPIO_WS003SH_POWER_BUTTON, 191 -1, /* None */ 192 WS003SH_NCOLUMN, 193 WS003SH_NROW, 194 }, 195 /* WS004SH */ 196 { 197 &platid_mask_MACH_SHARP_WZERO3_WS004SH, 198 -1, /* XXX */ 199 GPIO_WS003SH_POWER_BUTTON, 200 -1, /* None */ 201 WS003SH_NCOLUMN, 202 WS003SH_NROW, 203 }, 204 /* WS007SH */ 205 { 206 &platid_mask_MACH_SHARP_WZERO3_WS007SH, 207 -1, /* XXX */ 208 GPIO_WS007SH_POWER_BUTTON, 209 GPIO_WS007SH_RESET_BUTTON, 210 WS003SH_NCOLUMN, 211 WS003SH_NROW, 212 }, 213 /* WS011SH */ 214 { 215 &platid_mask_MACH_SHARP_WZERO3_WS011SH, 216 -1, /* XXX */ 217 GPIO_WS011SH_POWER_BUTTON, 218 GPIO_WS011SH_RESET_BUTTON, 219 WS003SH_NCOLUMN, 220 WS003SH_NROW, 221 }, 222 /* WS020SH */ 223 { 224 &platid_mask_MACH_SHARP_WZERO3_WS020SH, 225 -1, /* XXX */ 226 GPIO_WS020SH_POWER_BUTTON, 227 GPIO_WS020SH_RESET_BUTTON, 228 WS003SH_NCOLUMN, 229 WS003SH_NROW, 230 }, 231 232 { NULL, -1, -1, -1, 0, 0, } 233 }; 234 235 static const struct wzero3kbd_model * 236 wzero3kbd_lookup(void) 237 { 238 const struct wzero3kbd_model *model; 239 240 for (model = wzero3kbd_table; model->platid != NULL; model++) { 241 if (platid_match(&platid, model->platid)) { 242 return model; 243 } 244 } 245 return NULL; 246 } 247 248 static int 249 wzero3kbd_match(device_t parent, cfdata_t cf, void *aux) 250 { 251 252 if (strcmp(cf->cf_name, "wzero3kbd") != 0) 253 return 0; 254 if (wzero3kbd_lookup() == NULL) 255 return 0; 256 return 1; 257 } 258 259 static void 260 wzero3kbd_attach(device_t parent, device_t self, void *aux) 261 { 262 struct wzero3kbd_softc *sc = device_private(self); 263 struct pxaip_attach_args *pxa = (struct pxaip_attach_args *)aux; 264 struct hpckbd_attach_args haa; 265 const struct wzero3kbd_model *model; 266 267 sc->sc_dev = self; 268 269 model = wzero3kbd_lookup(); 270 if (model == NULL) { 271 aprint_error(": unknown model\n"); 272 return; 273 } 274 275 aprint_normal(": keyboard\n"); 276 aprint_naive("\n"); 277 278 sc->sc_key_pin = model->key_pin; 279 sc->sc_power_pin = model->power_pin; 280 sc->sc_reset_pin = model->reset_pin; 281 sc->sc_ncolumn = model->ncolumn; 282 sc->sc_nrow = model->nrow; 283 284 sc->sc_iot = pxa->pxa_iot; 285 if (bus_space_map(sc->sc_iot, PXA2X0_CS2_START, REGMAPSIZE, 0, 286 &sc->sc_ioh)) { 287 aprint_error_dev(self, "couldn't map registers.\n"); 288 return; 289 } 290 291 sc->sc_okeystat = malloc(sc->sc_nrow * sc->sc_ncolumn, M_DEVBUF, 292 M_NOWAIT | M_ZERO); 293 sc->sc_keystat = malloc(sc->sc_nrow * sc->sc_ncolumn, M_DEVBUF, 294 M_NOWAIT | M_ZERO); 295 if (sc->sc_okeystat == NULL || sc->sc_keystat == NULL) { 296 aprint_error_dev(self, "couldn't alloc memory.\n"); 297 if (sc->sc_okeystat) 298 free(sc->sc_okeystat, M_DEVBUF); 299 if (sc->sc_keystat) 300 free(sc->sc_keystat, M_DEVBUF); 301 return; 302 } 303 304 sc->sc_if.hii_ctx = sc; 305 sc->sc_if.hii_establish = wzero3kbd_input_establish; 306 sc->sc_if.hii_poll = wzero3kbd_poll; 307 308 /* Attach console if not using serial. */ 309 if (!(bootinfo->bi_cnuse & BI_CNUSE_SERIAL)) 310 hpckbd_cnattach(&sc->sc_if); 311 312 /* Install interrupt handler. */ 313 if (sc->sc_key_pin >= 0) { 314 pxa2x0_gpio_set_function(sc->sc_key_pin, GPIO_IN); 315 sc->sc_key_ih = pxa2x0_gpio_intr_establish(sc->sc_key_pin, 316 IST_EDGE_BOTH, IPL_TTY, wzero3kbd_intr, sc); 317 if (sc->sc_key_ih == NULL) { 318 aprint_error_dev(sc->sc_dev, 319 "couldn't establish key interrupt\n"); 320 } 321 } else { 322 sc->sc_interval = KEY_INTERVAL / (1000 / hz); 323 if (sc->sc_interval < 1) 324 sc->sc_interval = 1; 325 callout_init(&sc->sc_keyscan_ch, 0); 326 callout_reset(&sc->sc_keyscan_ch, sc->sc_interval, 327 wzero3kbd_tick, sc); 328 } 329 330 /* power key */ 331 if (sc->sc_power_pin >= 0) { 332 pxa2x0_gpio_set_function(sc->sc_power_pin, GPIO_IN); 333 sc->sc_power_ih = pxa2x0_gpio_intr_establish( 334 sc->sc_power_pin, IST_EDGE_BOTH, IPL_TTY, 335 wzero3kbd_power_intr, sc); 336 if (sc->sc_power_ih == NULL) { 337 aprint_error_dev(sc->sc_dev, 338 "couldn't establish power key interrupt\n"); 339 } 340 } 341 342 /* reset button */ 343 if (sc->sc_reset_pin >= 0) { 344 pxa2x0_gpio_set_function(sc->sc_reset_pin, GPIO_IN); 345 sc->sc_reset_ih = pxa2x0_gpio_intr_establish( 346 sc->sc_reset_pin, IST_EDGE_BOTH, IPL_TTY, 347 wzero3kbd_reset_intr, sc); 348 if (sc->sc_reset_ih == NULL) { 349 aprint_error_dev(sc->sc_dev, 350 "couldn't establish reset key interrupt\n"); 351 } 352 353 sc->sc_smpsw.smpsw_name = device_xname(self); 354 sc->sc_smpsw.smpsw_type = PSWITCH_TYPE_RESET; 355 if (sysmon_pswitch_register(&sc->sc_smpsw) != 0) { 356 aprint_error_dev(sc->sc_dev, 357 "unable to register reset event handler\n"); 358 } 359 } 360 361 /* Attach hpckbd. */ 362 haa.haa_ic = &sc->sc_if; 363 config_found(self, &haa, hpckbd_print); 364 365 #if defined(KEYTEST) || defined(KEYTEST2) || defined(KEYTEST3) || defined(KEYTEST4) || defined(KEYTEST5) 366 sc->sc_test_ih = NULL; 367 sc->sc_test_pin = -1; 368 sc->sc_nouse_pin = -1; 369 sc->sc_nouse_pin2 = -1; 370 sc->sc_nouse_pin3 = -1; 371 sc->sc_bit = 0x01; 372 if (platid_match(&platid, &platid_mask_MACH_SHARP_WZERO3_WS003SH) 373 || platid_match(&platid, &platid_mask_MACH_SHARP_WZERO3_WS004SH)) { 374 sc->sc_nouse_pin = GPIO_WS003SH_SD_DETECT; /* SD_DETECT */ 375 sc->sc_nouse_pin2 = 86; /* Vsync? */ 376 sc->sc_nouse_pin3 = 89; /* RESET? */ 377 } 378 if (platid_match(&platid, &platid_mask_MACH_SHARP_WZERO3_WS007SH)) { 379 sc->sc_nouse_pin = GPIO_WS007SH_SD_DETECT; /* SD_DETECT */ 380 sc->sc_nouse_pin2 = 77; /* Vsync? */ 381 } 382 if (platid_match(&platid, &platid_mask_MACH_SHARP_WZERO3_WS011SH)) { 383 sc->sc_nouse_pin = GPIO_WS011SH_SD_DETECT; /* SD_DETECT */ 384 sc->sc_nouse_pin2 = 77; /* Vsync? */ 385 } 386 if (platid_match(&platid, &platid_mask_MACH_SHARP_WZERO3_WS020SH)) { 387 sc->sc_nouse_pin = GPIO_WS020SH_SD_DETECT; /* SD_DETECT */ 388 sc->sc_nouse_pin2 = 77; /* Vsync? */ 389 } 390 391 #ifdef KEYTEST 392 for (sc->sc_test_pin = 2; sc->sc_test_pin < PXA270_GPIO_NPINS; sc->sc_test_pin++) { 393 if (sc->sc_test_pin != sc->sc_nouse_pin 394 && sc->sc_test_pin != sc->sc_nouse_pin2 395 && sc->sc_test_pin != sc->sc_nouse_pin3 396 && sc->sc_test_pin != sc->sc_key_pin 397 && sc->sc_test_pin != sc->sc_power_pin 398 && sc->sc_test_pin != sc->sc_reset_pin 399 && GPIO_IS_GPIO_IN(pxa2x0_gpio_get_function(sc->sc_test_pin))) 400 break; 401 } 402 if (sc->sc_test_pin < PXA270_GPIO_NPINS) { 403 printf("GPIO_IN: GPIO pin #%d\n", sc->sc_test_pin); 404 sc->sc_test_ih = pxa2x0_gpio_intr_establish(sc->sc_test_pin, 405 IST_EDGE_BOTH, IPL_TTY, wzero3kbd_intr2, sc); 406 } else { 407 sc->sc_test_pin = -1; 408 } 409 #endif 410 411 #ifdef KEYTEST3 412 { 413 int i; 414 printf("pin: "); 415 for (i = 0; i < PXA270_GPIO_NPINS; i++) { 416 if (i == sc->sc_nouse_pin 417 || i == sc->sc_nouse_pin2 418 || i == sc->sc_nouse_pin3 419 || i == sc->sc_key_pin 420 || i == sc->sc_power_pin 421 || i == sc->sc_reset_pin) 422 continue; 423 424 printf("%d, ", i); 425 if (GPIO_IS_GPIO_IN(pxa2x0_gpio_get_function(i))) { 426 pxa2x0_gpio_intr_establish(i, IST_EDGE_BOTH, 427 IPL_TTY, wzero3kbd_intr3, (void *)(long)i); 428 } 429 } 430 } 431 #endif 432 433 #ifdef KEYTEST4 434 for (sc->sc_test_pin = 2; sc->sc_test_pin < PXA270_GPIO_NPINS; sc->sc_test_pin++) { 435 if (sc->sc_test_pin != sc->sc_nouse_pin 436 && sc->sc_test_pin != sc->sc_nouse_pin2 437 && sc->sc_test_pin != sc->sc_nouse_pin3 438 && sc->sc_test_pin != sc->sc_key_pin 439 && sc->sc_test_pin != sc->sc_power_pin 440 && sc->sc_test_pin != sc->sc_reset_pin 441 && GPIO_IS_GPIO_OUT(pxa2x0_gpio_get_function(sc->sc_test_pin))) 442 break; 443 } 444 if (sc->sc_test_pin < PXA270_GPIO_NPINS) { 445 printf("GPIO_OUT: GPIO pin #%d\n", sc->sc_test_pin); 446 } else { 447 sc->sc_test_pin = -1; 448 } 449 #endif 450 #ifdef KEYTEST5 451 sc->sc_test_pin = 0x00; 452 sc->sc_bit = 0x01; 453 #endif 454 #endif 455 } 456 457 static int 458 wzero3kbd_intr(void *arg) 459 { 460 struct wzero3kbd_softc *sc = (struct wzero3kbd_softc *)arg; 461 462 #if defined(KEYTEST) || defined(KEYTEST2) || defined(KEYTEST3) || defined(KEYTEST4) || defined(KEYTEST5) 463 printf("wzero3kbd_intr: GPIO pin #%d = %s\n", sc->sc_key_pin, 464 pxa2x0_gpio_get_bit(sc->sc_key_pin) ? "on" : "off"); 465 #endif 466 467 #if defined(KEYTEST4) 468 if (sc->sc_test_pin >= 0) { 469 if (pxa2x0_gpio_get_bit(sc->sc_test_pin)) { 470 printf("GPIO_OUT: GPIO pin #%d: L\n",sc->sc_test_pin); 471 pxa2x0_gpio_clear_bit(sc->sc_test_pin); 472 } else { 473 printf("GPIO_OUT: GPIO pin #%d: H\n", sc->sc_test_pin); 474 pxa2x0_gpio_set_bit(sc->sc_test_pin); 475 } 476 } 477 #endif 478 #if defined(KEYTEST5) 479 printf("CPLD(%#x): value=%#x, mask=%#x\n", 480 sc->sc_test_pin, CSR_READ4(sc->sc_test_pin), sc->sc_bit); 481 if (CSR_READ4(sc->sc_test_pin) & sc->sc_bit) { 482 printf("CPLD_OUT: CPLD: L\n"); 483 CSR_WRITE4(sc->sc_test_pin, 484 CSR_READ4(sc->sc_test_pin) & ~sc->sc_bit); 485 } else { 486 printf("CPLD_OUT: CPLD: H\n"); 487 CSR_WRITE4(sc->sc_test_pin, 488 CSR_READ4(sc->sc_test_pin) | sc->sc_bit); 489 } 490 #endif 491 492 (void) wzero3kbd_poll1(sc); 493 494 pxa2x0_gpio_clear_intr(sc->sc_key_pin); 495 496 return 1; 497 } 498 499 #if defined(KEYTEST) 500 static int 501 wzero3kbd_intr2(void *arg) 502 { 503 struct wzero3kbd_softc *sc = (struct wzero3kbd_softc *)arg; 504 505 printf("wzero3kbd_intr2: GPIO_IN: GPIO pin #%d = %s\n", sc->sc_test_pin, 506 pxa2x0_gpio_get_bit(sc->sc_test_pin) ? "on" : "off"); 507 508 return 1; 509 } 510 #endif 511 512 #if defined(KEYTEST3) 513 static int 514 wzero3kbd_intr3(void *arg) 515 { 516 int pin = (int)arg; 517 518 printf("wzero3kbd_intr3: GPIO pin #%d = %s\n", pin, 519 pxa2x0_gpio_get_bit(pin) ? "on" : "off"); 520 521 return 1; 522 } 523 #endif 524 525 526 static void 527 wzero3kbd_tick(void *arg) 528 { 529 struct wzero3kbd_softc *sc = (struct wzero3kbd_softc *)arg; 530 531 (void) wzero3kbd_poll1(sc); 532 533 callout_schedule(&sc->sc_keyscan_ch, sc->sc_interval); 534 } 535 536 static int 537 wzero3kbd_power_intr(void *arg) 538 { 539 struct wzero3kbd_softc *sc = (struct wzero3kbd_softc *)arg; 540 541 #if defined(KEYTEST) || defined(KEYTEST2) || defined(KEYTEST3) || defined(KEYTEST4) 542 printf("wzero3kbd_power_intr: status = %s\n", 543 pxa2x0_gpio_get_bit(sc->sc_power_pin) ? "on" : "off"); 544 #endif 545 546 #if defined(KEYTEST) 547 if (pxa2x0_gpio_get_bit(sc->sc_power_pin)) { 548 if (sc->sc_test_pin >= 0) { 549 int orig_pin = sc->sc_test_pin; 550 pxa2x0_gpio_intr_disestablish(sc->sc_test_ih); 551 sc->sc_test_ih = NULL; 552 553 for (;;) { 554 if (++sc->sc_test_pin >= PXA270_GPIO_NPINS) 555 sc->sc_test_pin = 2; 556 if (sc->sc_test_pin == orig_pin) 557 break; 558 if (sc->sc_test_pin != sc->sc_nouse_pin 559 && sc->sc_test_pin != sc->sc_nouse_pin2 560 && sc->sc_test_pin != sc->sc_nouse_pin3 561 && sc->sc_test_pin != sc->sc_key_pin 562 && sc->sc_test_pin != sc->sc_power_pin 563 && sc->sc_test_pin != sc->sc_reset_pin 564 && GPIO_IS_GPIO_IN(pxa2x0_gpio_get_function(sc->sc_test_pin))) 565 break; 566 } 567 if (sc->sc_test_pin != orig_pin) { 568 printf("GPIO_IN: GPIO pin #%d\n", 569 sc->sc_test_pin); 570 sc->sc_test_ih = 571 pxa2x0_gpio_intr_establish(sc->sc_test_pin, 572 IST_EDGE_BOTH, IPL_TTY, wzero3kbd_intr2,sc); 573 } else { 574 sc->sc_test_pin = -1; 575 } 576 } 577 } 578 #endif 579 580 #if defined(KEYTEST2) 581 if (pxa2x0_gpio_get_bit(sc->sc_power_pin)) { 582 sc->sc_enabled ^= 2; 583 if (sc->sc_enabled & 2) { 584 printf("print col/row\n"); 585 } else { 586 printf("keyscan\n"); 587 } 588 } 589 #endif 590 #if defined(KEYTEST4) 591 if (pxa2x0_gpio_get_bit(sc->sc_power_pin)) { 592 if (sc->sc_test_pin >= 0) { 593 int orig_pin = sc->sc_test_pin; 594 for (;;) { 595 if (++sc->sc_test_pin >= PXA270_GPIO_NPINS) 596 sc->sc_test_pin = 2; 597 if (sc->sc_test_pin == orig_pin) 598 break; 599 if (sc->sc_test_pin != sc->sc_nouse_pin 600 && sc->sc_test_pin != sc->sc_nouse_pin2 601 && sc->sc_test_pin != sc->sc_nouse_pin3 602 && sc->sc_test_pin != sc->sc_key_pin 603 && sc->sc_test_pin != sc->sc_power_pin 604 && sc->sc_test_pin != sc->sc_reset_pin 605 && GPIO_IS_GPIO_OUT(pxa2x0_gpio_get_function(sc->sc_test_pin))) 606 break; 607 } 608 if (sc->sc_test_pin != orig_pin) { 609 printf("GPIO_OUT: GPIO pin #%d\n", sc->sc_test_pin); 610 } else { 611 sc->sc_test_pin = -1; 612 } 613 } 614 } 615 #endif 616 #if defined(KEYTEST5) 617 if (pxa2x0_gpio_get_bit(sc->sc_power_pin)) { 618 sc->sc_bit <<= 1; 619 if (sc->sc_bit & ~0xff) { 620 sc->sc_bit = 0x01; 621 sc->sc_test_pin += 0x4; 622 if (sc->sc_test_pin >= 0x20) { 623 sc->sc_test_pin = 0x00; 624 } 625 } 626 printf("CPLD(%#x), mask=%#x\n", sc->sc_test_pin, sc->sc_bit); 627 } 628 #endif 629 630 pxa2x0_gpio_clear_intr(sc->sc_power_pin); 631 632 return 1; 633 } 634 635 static int 636 wzero3kbd_reset_intr(void *arg) 637 { 638 struct wzero3kbd_softc *sc = (struct wzero3kbd_softc *)arg; 639 640 sysmon_task_queue_sched(0, wzero3kbd_sysmon_reset_event, sc); 641 642 pxa2x0_gpio_clear_intr(sc->sc_reset_pin); 643 644 return 1; 645 } 646 647 static int 648 wzero3kbd_input_establish(void *arg, struct hpckbd_if *kbdif) 649 { 650 struct wzero3kbd_softc *sc = (struct wzero3kbd_softc *)arg; 651 652 /* Save hpckbd interface. */ 653 sc->sc_hpckbd = kbdif; 654 sc->sc_enabled = 1; 655 656 return 0; 657 } 658 659 static void 660 wzero3kbd_sysmon_reset_event(void *arg) 661 { 662 struct wzero3kbd_softc *sc = (struct wzero3kbd_softc *)arg; 663 664 sysmon_pswitch_event(&sc->sc_smpsw, PSWITCH_EVENT_PRESSED); 665 } 666 667 static int 668 wzero3kbd_poll(void *arg) 669 { 670 int keydown; 671 672 keydown = wzero3kbd_poll1(arg); 673 674 return keydown; 675 } 676 677 static int 678 wzero3kbd_poll1(void *arg) 679 { 680 struct wzero3kbd_softc *sc = (struct wzero3kbd_softc *)arg; 681 int row, col, data; 682 int keycol; 683 int keydown; 684 int i; 685 int s; 686 687 if (!sc->sc_enabled) { 688 DPRINTF(("wzero3kbd_poll: disabled\n")); 689 return 0; 690 } 691 692 s = spltty(); 693 694 for (col = 0; col < sc->sc_ncolumn; col++) { 695 /* deselect column# and charge */ 696 CSR_WRITE1(KBDCOL_L, 0); 697 CSR_WRITE1(KBDCOL_U, 0); 698 CSR_WRITE1(KBDCHARGE, 1); 699 delay(KEYWAIT); 700 CSR_WRITE1(KBDCHARGE, 0); 701 702 /* select scan column# */ 703 keycol = 1 << col; 704 CSR_WRITE1(KBDCOL_L, keycol & 0xff); 705 CSR_WRITE1(KBDCOL_U, keycol >> 8); 706 delay(KEYWAIT); 707 CSR_WRITE1(KBDCHARGE, 0); 708 709 /* read key data */ 710 data = CSR_READ1(KBDDATA); 711 for (row = 0; row < sc->sc_nrow; row++) { 712 #ifdef KEYTEST2 713 if (!(sc->sc_enabled & 2)) { 714 #endif 715 sc->sc_keystat[row + col * sc->sc_nrow] = 716 (data >> row) & 1; 717 #ifdef KEYTEST2 718 } else if (data & (1 << row)) { 719 printf("col = %d, row = %d, idx = %d, data = 0x%02x\n", col, row, row + col * sc->sc_nrow, data); 720 } 721 #endif 722 } 723 } 724 725 /* deselect column# and charge */ 726 CSR_WRITE1(KBDCOL_L, 0); 727 CSR_WRITE1(KBDCOL_U, 0); 728 CSR_WRITE1(KBDCHARGE, 1); 729 delay(KEYWAIT); 730 CSR_WRITE1(KBDCHARGE, 0); 731 732 /* send key scan code */ 733 keydown = 0; 734 for (i = 0; i < sc->sc_nrow * sc->sc_ncolumn; i++) { 735 if (sc->sc_keystat[i] == sc->sc_okeystat[i]) 736 continue; 737 738 keydown |= sc->sc_keystat[i]; 739 hpckbd_input(sc->sc_hpckbd, sc->sc_keystat[i], i); 740 sc->sc_okeystat[i] = sc->sc_keystat[i]; 741 } 742 743 splx(s); 744 745 return keydown; 746 } 747