1 /* $NetBSD: ztp.c,v 1.10 2010/02/24 22:37:56 dyoung Exp $ */ 2 /* $OpenBSD: zts.c,v 1.9 2005/04/24 18:55:49 uwe Exp $ */ 3 4 /* 5 * Copyright (c) 2005 Dale Rahn <drahn@openbsd.org> 6 * 7 * Permission to use, copy, modify, and distribute this software for any 8 * purpose with or without fee is hereby granted, provided that the above 9 * copyright notice and this permission notice appear in all copies. 10 * 11 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 12 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 13 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 14 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 15 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 16 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 17 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 18 */ 19 20 #include <sys/cdefs.h> 21 __KERNEL_RCSID(0, "$NetBSD: ztp.c,v 1.10 2010/02/24 22:37:56 dyoung Exp $"); 22 23 #include "lcd.h" 24 25 #include <sys/types.h> 26 #include <sys/param.h> 27 #include <sys/systm.h> 28 #include <sys/device.h> 29 #include <sys/malloc.h> 30 #include <sys/kernel.h> 31 #include <sys/callout.h> 32 33 #include <dev/wscons/wsconsio.h> 34 #include <dev/wscons/wsmousevar.h> 35 #include <dev/wscons/wsdisplayvar.h> 36 37 #include <dev/hpc/hpcfbio.h> /* XXX: for tpctl */ 38 #include <dev/hpc/hpctpanelvar.h> 39 40 #include <arm/xscale/pxa2x0cpu.h> 41 #include <arm/xscale/pxa2x0reg.h> 42 #include <arm/xscale/pxa2x0var.h> 43 #include <arm/xscale/xscalereg.h> 44 #include <arm/xscale/pxa2x0_lcd.h> 45 #include <arm/xscale/pxa2x0_gpio.h> 46 47 #include <zaurus/dev/zsspvar.h> 48 49 #ifdef ZTP_DEBUG 50 #define DPRINTF(s) printf s 51 #else 52 #define DPRINTF(s) 53 #endif 54 55 /* 56 * ADS784x touch screen controller 57 */ 58 #define ADSCTRL_PD0_SH 0 /* PD0 bit */ 59 #define ADSCTRL_PD1_SH 1 /* PD1 bit */ 60 #define ADSCTRL_DFR_SH 2 /* SER/DFR bit */ 61 #define ADSCTRL_MOD_SH 3 /* Mode bit */ 62 #define ADSCTRL_ADR_SH 4 /* Address setting */ 63 #define ADSCTRL_STS_SH 7 /* Start bit */ 64 65 #define GPIO_TP_INT_C3K 11 66 #define GPIO_HSYNC_C3K 22 67 68 #define POLL_TIMEOUT_RATE0 ((hz * 150)/1000) 69 #define POLL_TIMEOUT_RATE1 (hz / 100) /* XXX every tick */ 70 71 #define CCNT_HS_400_VGA_C3K 6250 /* 15.024us */ 72 73 /* XXX need to ask zaurus_lcd.c for the screen dimension */ 74 #define CURRENT_DISPLAY (&sharp_zaurus_C3000) 75 extern const struct lcd_panel_geometry sharp_zaurus_C3000; 76 77 /* Settable via sysctl. */ 78 int ztp_rawmode; 79 80 static const struct wsmouse_calibcoords ztp_default_calib = { 81 0, 0, 479, 639, /* minx, miny, maxx, maxy */ 82 5, /* samplelen */ 83 { 84 { 1929, 2021, 240, 320 }, /* rawx, rawy, x, y */ 85 { 545, 3464, 48, 64 }, 86 { 3308, 3452, 48, 576 }, 87 { 2854, 768, 432, 576 }, 88 { 542, 593, 432, 64 } 89 } 90 }; 91 92 struct ztp_pos { 93 int x; 94 int y; 95 int z; /* touch pressure */ 96 }; 97 98 struct ztp_softc { 99 device_t sc_dev; 100 struct callout sc_tp_poll; 101 void *sc_gh; 102 int sc_enabled; 103 int sc_buttons; /* button emulation ? */ 104 struct device *sc_wsmousedev; 105 struct ztp_pos sc_oldpos; 106 int sc_resx; 107 int sc_resy; 108 struct tpcalib_softc sc_tpcalib; 109 }; 110 111 static int ztp_match(device_t, cfdata_t, void *); 112 static void ztp_attach(device_t, device_t, void *); 113 114 CFATTACH_DECL_NEW(ztp, sizeof(struct ztp_softc), 115 ztp_match, ztp_attach, NULL, NULL); 116 117 static int ztp_enable(void *); 118 static void ztp_disable(void *); 119 static bool ztp_suspend(device_t dv, const pmf_qual_t *); 120 static bool ztp_resume(device_t dv, const pmf_qual_t *); 121 static void ztp_poll(void *); 122 static int ztp_irq(void *); 123 static int ztp_ioctl(void *, u_long, void *, int, struct lwp *); 124 125 static const struct wsmouse_accessops ztp_accessops = { 126 ztp_enable, 127 ztp_ioctl, 128 ztp_disable 129 }; 130 131 static int 132 ztp_match(device_t parent, cfdata_t cf, void *aux) 133 { 134 135 return 1; 136 } 137 138 static void 139 ztp_attach(device_t parent, device_t self, void *aux) 140 { 141 struct ztp_softc *sc = device_private(self); 142 struct wsmousedev_attach_args a; 143 144 sc->sc_dev = self; 145 146 aprint_normal("\n"); 147 aprint_naive("\n"); 148 149 callout_init(&sc->sc_tp_poll, 0); 150 callout_setfunc(&sc->sc_tp_poll, ztp_poll, sc); 151 152 /* Initialize ADS7846 Difference Reference mode */ 153 (void)zssp_ic_send(ZSSP_IC_ADS7846, 154 (1<<ADSCTRL_ADR_SH) | (1<<ADSCTRL_STS_SH)); 155 delay(5000); 156 (void)zssp_ic_send(ZSSP_IC_ADS7846, 157 (3<<ADSCTRL_ADR_SH) | (1<<ADSCTRL_STS_SH)); 158 delay(5000); 159 (void)zssp_ic_send(ZSSP_IC_ADS7846, 160 (4<<ADSCTRL_ADR_SH) | (1<<ADSCTRL_STS_SH)); 161 delay(5000); 162 (void)zssp_ic_send(ZSSP_IC_ADS7846, 163 (5<<ADSCTRL_ADR_SH) | (1<<ADSCTRL_STS_SH)); 164 delay(5000); 165 166 a.accessops = &ztp_accessops; 167 a.accesscookie = sc; 168 169 #if NLCD > 0 170 sc->sc_resx = CURRENT_DISPLAY->panel_height; 171 sc->sc_resy = CURRENT_DISPLAY->panel_width; 172 #else 173 sc->sc_resx = 480; /* XXX */ 174 sc->sc_resy = 640; /* XXX */ 175 #endif 176 177 sc->sc_wsmousedev = config_found(self, &a, wsmousedevprint); 178 179 /* Initialize calibration, set default parameters. */ 180 tpcalib_init(&sc->sc_tpcalib); 181 tpcalib_ioctl(&sc->sc_tpcalib, WSMOUSEIO_SCALIBCOORDS, 182 __UNCONST(&ztp_default_calib), 0, 0); 183 } 184 185 static int 186 ztp_enable(void *v) 187 { 188 struct ztp_softc *sc = (struct ztp_softc *)v; 189 190 DPRINTF(("%s: ztp_enable()\n", device_xname(sc->sc_dev))); 191 192 if (sc->sc_enabled) { 193 DPRINTF(("%s: already enabled\n", device_xname(sc->sc_dev))); 194 return EBUSY; 195 } 196 197 callout_stop(&sc->sc_tp_poll); 198 199 if (!pmf_device_register(sc->sc_dev, ztp_suspend, ztp_resume)) 200 aprint_error_dev(sc->sc_dev, 201 "couldn't establish power handler\n"); 202 203 pxa2x0_gpio_set_function(GPIO_TP_INT_C3K, GPIO_IN); 204 205 /* XXX */ 206 if (sc->sc_gh == NULL) { 207 sc->sc_gh = pxa2x0_gpio_intr_establish(GPIO_TP_INT_C3K, 208 IST_EDGE_FALLING, IPL_TTY, ztp_irq, sc); 209 } else { 210 pxa2x0_gpio_intr_unmask(sc->sc_gh); 211 } 212 213 /* enable interrupts */ 214 sc->sc_enabled = 1; 215 sc->sc_buttons = 0; 216 217 return 0; 218 } 219 220 static void 221 ztp_disable(void *v) 222 { 223 struct ztp_softc *sc = (struct ztp_softc *)v; 224 225 DPRINTF(("%s: ztp_disable()\n", device_xname(sc->sc_dev))); 226 227 callout_stop(&sc->sc_tp_poll); 228 229 pmf_device_deregister(sc->sc_dev); 230 231 if (sc->sc_gh) { 232 pxa2x0_gpio_intr_mask(sc->sc_gh); 233 } 234 235 /* disable interrupts */ 236 sc->sc_enabled = 0; 237 } 238 239 static bool 240 ztp_suspend(device_t dv, const pmf_qual_t *qual) 241 { 242 struct ztp_softc *sc = device_private(dv); 243 244 DPRINTF(("%s: ztp_suspend()\n", device_xname(sc->sc_dev))); 245 246 sc->sc_enabled = 0; 247 pxa2x0_gpio_intr_mask(sc->sc_gh); 248 249 callout_stop(&sc->sc_tp_poll); 250 251 /* Turn off reference voltage but leave ADC on. */ 252 (void)zssp_ic_send(ZSSP_IC_ADS7846, (1 << ADSCTRL_PD1_SH) | 253 (1 << ADSCTRL_ADR_SH) | (1 << ADSCTRL_STS_SH)); 254 255 pxa2x0_gpio_set_function(GPIO_TP_INT_C3K, GPIO_OUT | GPIO_SET); 256 257 return true; 258 } 259 260 static bool 261 ztp_resume(device_t dv, const pmf_qual_t *qual) 262 { 263 struct ztp_softc *sc = device_private(dv); 264 265 DPRINTF(("%s: ztp_resume()\n", device_xname(sc->sc_dev))); 266 267 pxa2x0_gpio_set_function(GPIO_TP_INT_C3K, GPIO_IN); 268 pxa2x0_gpio_intr_mask(sc->sc_gh); 269 270 /* Enable automatic low power mode. */ 271 (void)zssp_ic_send(ZSSP_IC_ADS7846, 272 (4 << ADSCTRL_ADR_SH) | (1 << ADSCTRL_STS_SH)); 273 274 pxa2x0_gpio_intr_unmask(sc->sc_gh); 275 sc->sc_enabled = 1; 276 277 return true; 278 } 279 280 #define HSYNC() \ 281 do { \ 282 while (pxa2x0_gpio_get_bit(GPIO_HSYNC_C3K) == 0) \ 283 continue; \ 284 while (pxa2x0_gpio_get_bit(GPIO_HSYNC_C3K) != 0) \ 285 continue; \ 286 } while (/*CONSTCOND*/0) 287 288 static inline uint32_t pxa2x0_ccnt_enable(uint32_t); 289 static inline uint32_t pxa2x0_read_ccnt(void); 290 static uint32_t ztp_sync_ads784x(int, int, uint32_t); 291 static void ztp_sync_send(uint32_t); 292 static int ztp_readpos(struct ztp_pos *); 293 294 static inline uint32_t 295 pxa2x0_ccnt_enable(uint32_t reg) 296 { 297 uint32_t rv; 298 299 __asm volatile("mrc p14, 0, %0, c0, c1, 0" : "=r" (rv)); 300 __asm volatile("mcr p14, 0, %0, c0, c1, 0" : : "r" (reg)); 301 302 return rv; 303 } 304 305 static inline uint32_t 306 pxa2x0_read_ccnt(void) 307 { 308 uint32_t rv; 309 310 __asm volatile("mrc p14, 0, %0, c1, c1, 0" : "=r" (rv)); 311 312 return rv; 313 } 314 315 /* 316 * Communicate synchronously with the ADS784x touch screen controller. 317 */ 318 static uint32_t 319 ztp_sync_ads784x(int dorecv/* XXX */, int dosend/* XXX */, uint32_t cmd) 320 { 321 uint32_t ccen; 322 uint32_t rv = 0; 323 324 /* XXX poll hsync only if LCD is enabled */ 325 326 /* start clock counter */ 327 ccen = pxa2x0_ccnt_enable(PMNC_E); 328 329 HSYNC(); 330 331 if (dorecv) { 332 /* read SSDR and disable ADS784x */ 333 rv = zssp_ic_stop(ZSSP_IC_ADS7846); 334 } 335 336 if (dosend) { 337 ztp_sync_send(cmd); 338 } 339 340 /* stop clock counter */ 341 pxa2x0_ccnt_enable(ccen); 342 343 return rv; 344 } 345 346 void 347 ztp_sync_send(uint32_t cmd) 348 { 349 volatile uint32_t base, now; 350 uint32_t tck; 351 352 /* XXX */ 353 tck = CCNT_HS_400_VGA_C3K - 151; 354 355 /* send dummy command; discard SSDR */ 356 (void)zssp_ic_send(ZSSP_IC_ADS7846, cmd); 357 358 /* wait for refresh */ 359 HSYNC(); 360 361 /* wait after refresh */ 362 base = pxa2x0_read_ccnt(); 363 now = pxa2x0_read_ccnt(); 364 while ((now - base) < tck) 365 now = pxa2x0_read_ccnt(); 366 367 /* send the actual command; keep ADS784x enabled */ 368 zssp_ic_start(ZSSP_IC_ADS7846, cmd); 369 } 370 371 static int 372 ztp_readpos(struct ztp_pos *pos) 373 { 374 int cmd; 375 int t0, t1; 376 int down; 377 378 /* XXX */ 379 pxa2x0_gpio_set_function(GPIO_HSYNC_C3K, GPIO_IN); 380 381 /* check that pen is down */ 382 cmd = (1 << ADSCTRL_PD0_SH) | (1 << ADSCTRL_PD1_SH) | 383 (3 << ADSCTRL_ADR_SH) | (1 << ADSCTRL_STS_SH); 384 t0 = zssp_ic_send(ZSSP_IC_ADS7846, cmd); 385 DPRINTF(("ztp_readpos(): t0 = %d\n", t0)); 386 387 down = (t0 >= 10); 388 if (down == 0) 389 goto out; 390 391 /* Y */ 392 cmd = (1 << ADSCTRL_PD0_SH) | (1 << ADSCTRL_PD1_SH) | 393 (1 << ADSCTRL_ADR_SH) | (1 << ADSCTRL_STS_SH); 394 (void)ztp_sync_ads784x(0, 1, cmd); 395 396 /* Y */ 397 cmd = (1 << ADSCTRL_PD0_SH) | (1 << ADSCTRL_PD1_SH) | 398 (1 << ADSCTRL_ADR_SH) | (1 << ADSCTRL_STS_SH); 399 (void)ztp_sync_ads784x(1, 1, cmd); 400 401 /* X */ 402 cmd = (1 << ADSCTRL_PD0_SH) | (1 << ADSCTRL_PD1_SH) | 403 (5 << ADSCTRL_ADR_SH) | (1 << ADSCTRL_STS_SH); 404 pos->y = ztp_sync_ads784x(1, 1, cmd); 405 DPRINTF(("ztp_readpos(): y = %d\n", pos->y)); 406 407 /* T0 */ 408 cmd = (1 << ADSCTRL_PD0_SH) | (1 << ADSCTRL_PD1_SH) | 409 (3 << ADSCTRL_ADR_SH) | (1 << ADSCTRL_STS_SH); 410 pos->x = ztp_sync_ads784x(1, 1, cmd); 411 DPRINTF(("ztp_readpos(): x = %d\n", pos->x)); 412 413 /* T1 */ 414 cmd = (1 << ADSCTRL_PD0_SH) | (1 << ADSCTRL_PD1_SH) | 415 (4 << ADSCTRL_ADR_SH) | (1 << ADSCTRL_STS_SH); 416 t0 = ztp_sync_ads784x(1, 1, cmd); 417 t1 = ztp_sync_ads784x(1, 0, cmd); 418 DPRINTF(("ztp_readpos(): t0 = %d, t1 = %d\n", t0, t1)); 419 420 /* check that pen is still down */ 421 /* XXX pressure sensitivity varies with X or what? */ 422 if (t0 == 0 || (pos->x * (t1 - t0) / t0) >= 15000) 423 down = 0; 424 pos->z = down; 425 426 out: 427 /* Enable automatic low power mode. */ 428 cmd = (4 << ADSCTRL_ADR_SH) | (1 << ADSCTRL_STS_SH); 429 (void)zssp_ic_send(ZSSP_IC_ADS7846, cmd); 430 431 return down; 432 } 433 434 static void 435 ztp_poll(void *v) 436 { 437 int s; 438 439 s = spltty(); 440 (void)ztp_irq(v); 441 splx(s); 442 } 443 444 static int 445 ztp_irq(void *v) 446 { 447 extern int zkbd_modstate; 448 struct ztp_softc *sc = (struct ztp_softc *)v; 449 struct ztp_pos tp = { 0, 0, 0 }; 450 int pindown; 451 int down; 452 int x, y; 453 int s; 454 455 if (!sc->sc_enabled) 456 return 0; 457 458 s = splhigh(); 459 460 pindown = pxa2x0_gpio_get_bit(GPIO_TP_INT_C3K) ? 0 : 1; 461 DPRINTF(("%s: pindown = %d\n", device_xname(sc->sc_dev), pindown)); 462 if (pindown) { 463 pxa2x0_gpio_intr_mask(sc->sc_gh); 464 callout_schedule(&sc->sc_tp_poll, POLL_TIMEOUT_RATE1); 465 } 466 467 down = ztp_readpos(&tp); 468 DPRINTF(("%s: x = %d, y = %d, z = %d, down = %d\n", 469 device_xname(sc->sc_dev), tp.x, tp.y, tp.z, down)); 470 471 if (!pindown) { 472 pxa2x0_gpio_intr_unmask(sc->sc_gh); 473 callout_schedule(&sc->sc_tp_poll, POLL_TIMEOUT_RATE0); 474 } 475 pxa2x0_gpio_clear_intr(GPIO_TP_INT_C3K); 476 477 splx(s); 478 479 if (down) { 480 if (!ztp_rawmode) { 481 tpcalib_trans(&sc->sc_tpcalib, tp.x, tp.y, &x, &y); 482 DPRINTF(("%s: x = %d, y = %d\n", 483 device_xname(sc->sc_dev), x, y)); 484 tp.x = x; 485 tp.y = y; 486 } 487 } 488 489 if (zkbd_modstate != 0 && down) { 490 if (zkbd_modstate & (1 << 1)) { 491 /* Fn */ 492 down = 2; 493 } else if (zkbd_modstate & (1 << 2)) { 494 /* 'Alt' */ 495 down = 4; 496 } 497 } 498 if (!down) { 499 /* x/y values are not reliable when pen is up */ 500 tp = sc->sc_oldpos; 501 } 502 503 if (down || sc->sc_buttons != down) { 504 wsmouse_input(sc->sc_wsmousedev, down, tp.x, tp.y, 0, 0, 505 WSMOUSE_INPUT_ABSOLUTE_X | WSMOUSE_INPUT_ABSOLUTE_Y); 506 sc->sc_buttons = down; 507 sc->sc_oldpos = tp; 508 } 509 510 return 1; 511 } 512 513 static int 514 ztp_ioctl(void *v, u_long cmd, void *data, int flag, struct lwp *l) 515 { 516 struct ztp_softc *sc = (struct ztp_softc *)v; 517 struct wsmouse_id *id; 518 519 switch (cmd) { 520 case WSMOUSEIO_GTYPE: 521 *(u_int *)data = WSMOUSE_TYPE_TPANEL; 522 return 0; 523 524 case WSMOUSEIO_GETID: 525 /* 526 * return unique ID string, 527 * "<vendor> <model> <serial number>" 528 */ 529 id = (struct wsmouse_id *)data; 530 if (id->type != WSMOUSE_ID_TYPE_UIDSTR) 531 return EINVAL; 532 strlcpy(id->data, "Sharp SL-C3x00 SN000000", WSMOUSE_ID_MAXLEN); 533 id->length = strlen(id->data); 534 return 0; 535 536 case WSMOUSEIO_SCALIBCOORDS: 537 case WSMOUSEIO_GCALIBCOORDS: 538 return tpcalib_ioctl(&sc->sc_tpcalib, cmd, data, flag, l); 539 } 540 541 return EPASSTHROUGH; 542 } 543