Annotation of sys/arch/zaurus/dev/zts.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: zts.c,v 1.11 2007/05/29 21:09:43 robert Exp $ */
! 2: /*
! 3: * Copyright (c) 2005 Dale Rahn <drahn@openbsd.org>
! 4: *
! 5: * Permission to use, copy, modify, and distribute this software for any
! 6: * purpose with or without fee is hereby granted, provided that the above
! 7: * copyright notice and this permission notice appear in all copies.
! 8: *
! 9: * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
! 10: * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
! 11: * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
! 12: * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
! 13: * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
! 14: * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
! 15: * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
! 16: */
! 17:
! 18: #include <sys/types.h>
! 19: #include <sys/param.h>
! 20: #include <sys/systm.h>
! 21: #include <sys/device.h>
! 22: #include <sys/malloc.h>
! 23: #include <sys/timeout.h>
! 24: #include <sys/kernel.h>
! 25:
! 26: #include <arm/xscale/pxa2x0reg.h>
! 27: #include <arm/xscale/pxa2x0_gpio.h>
! 28:
! 29: #include <zaurus/dev/zaurus_sspvar.h>
! 30:
! 31: #include <dev/wscons/wsconsio.h>
! 32: #include <dev/wscons/wsmousevar.h>
! 33:
! 34: #include <dev/wscons/wsdisplayvar.h>
! 35: #include <arm/xscale/pxa2x0var.h>
! 36: #include <arm/xscale/pxa2x0_lcd.h>
! 37:
! 38: #ifdef ZTS_DEBUG
! 39: #define DPRINTF(x) do { printf x; } while (0)
! 40: #else
! 41: #define DPRINTF(x)
! 42: #endif
! 43:
! 44: /*
! 45: * ADS784x touch screen controller
! 46: */
! 47: #define ADSCTRL_PD0_SH 0 /* PD0 bit */
! 48: #define ADSCTRL_PD1_SH 1 /* PD1 bit */
! 49: #define ADSCTRL_DFR_SH 2 /* SER/DFR bit */
! 50: #define ADSCTRL_MOD_SH 3 /* Mode bit */
! 51: #define ADSCTRL_ADR_SH 4 /* Address setting */
! 52: #define ADSCTRL_STS_SH 7 /* Start bit */
! 53:
! 54: #define GPIO_TP_INT_C3K 11
! 55: #define GPIO_HSYNC_C3K 22
! 56:
! 57: #define POLL_TIMEOUT_RATE0 ((hz * 150)/1000)
! 58: #define POLL_TIMEOUT_RATE1 (hz / 100) /* XXX every tick */
! 59:
! 60: #define CCNT_HS_400_VGA_C3K 6250 /* 15.024us */
! 61:
! 62: struct tsscale {
! 63: int minx, maxx;
! 64: int miny, maxy;
! 65: int swapxy;
! 66: int resx, resy;
! 67: } zts_scale = {
! 68: /* C3000 */
! 69: 209, 3620, 312, 3780, 0, 640, 480
! 70: };
! 71:
! 72: int zts_match(struct device *, void *, void *);
! 73: void zts_attach(struct device *, struct device *, void *);
! 74: int zts_enable(void *);
! 75: void zts_disable(void *);
! 76: void zts_power(int, void *);
! 77: void zts_poll(void *);
! 78: int zts_irq(void *);
! 79: int zts_ioctl(void *, u_long, caddr_t, int, struct proc *);
! 80:
! 81: struct zts_softc {
! 82: struct device sc_dev;
! 83: struct timeout sc_ts_poll;
! 84: void *sc_gh;
! 85: void *sc_powerhook;
! 86: int sc_enabled;
! 87: int sc_buttons; /* button emulation ? */
! 88: struct device *sc_wsmousedev;
! 89: int sc_oldx;
! 90: int sc_oldy;
! 91: int sc_rawmode;
! 92:
! 93: struct tsscale sc_tsscale;
! 94: };
! 95:
! 96: struct cfattach zts_ca = {
! 97: sizeof(struct zts_softc), zts_match, zts_attach
! 98: };
! 99:
! 100: struct cfdriver zts_cd = {
! 101: NULL, "zts", DV_DULL
! 102: };
! 103:
! 104: int
! 105: zts_match(struct device *parent, void *cf, void *aux)
! 106: {
! 107: return 1;
! 108: }
! 109:
! 110: const struct wsmouse_accessops zts_accessops = {
! 111: zts_enable,
! 112: zts_ioctl,
! 113: zts_disable
! 114: };
! 115:
! 116: void
! 117: zts_attach(struct device *parent, struct device *self, void *aux)
! 118: {
! 119: struct zts_softc *sc = (struct zts_softc *)self;
! 120: struct wsmousedev_attach_args a;
! 121:
! 122: timeout_set(&sc->sc_ts_poll, zts_poll, sc);
! 123:
! 124: /* Initialize ADS7846 Difference Reference mode */
! 125: (void)zssp_ic_send(ZSSP_IC_ADS7846,
! 126: (1<<ADSCTRL_ADR_SH) | (1<<ADSCTRL_STS_SH));
! 127: delay(5000);
! 128: (void)zssp_ic_send(ZSSP_IC_ADS7846,
! 129: (3<<ADSCTRL_ADR_SH) | (1<<ADSCTRL_STS_SH));
! 130: delay(5000);
! 131: (void)zssp_ic_send(ZSSP_IC_ADS7846,
! 132: (4<<ADSCTRL_ADR_SH) | (1<<ADSCTRL_STS_SH));
! 133: delay(5000);
! 134: (void)zssp_ic_send(ZSSP_IC_ADS7846,
! 135: (5<<ADSCTRL_ADR_SH) | (1<<ADSCTRL_STS_SH));
! 136: delay(5000);
! 137:
! 138: a.accessops = &zts_accessops;
! 139: a.accesscookie = sc;
! 140: printf("\n");
! 141:
! 142: /* Copy the default scalue values to each softc */
! 143: bcopy(&zts_scale, &sc->sc_tsscale, sizeof(sc->sc_tsscale));
! 144:
! 145: sc->sc_wsmousedev = config_found(self, &a, wsmousedevprint);
! 146: }
! 147:
! 148: int
! 149: zts_enable(void *v)
! 150: {
! 151: struct zts_softc *sc = v;
! 152:
! 153: if (sc->sc_enabled)
! 154: return EBUSY;
! 155:
! 156: timeout_del(&sc->sc_ts_poll);
! 157:
! 158: sc->sc_powerhook = powerhook_establish(zts_power, sc);
! 159: if (sc->sc_powerhook == NULL) {
! 160: printf("%s: enable failed\n", sc->sc_dev.dv_xname);
! 161: return ENOMEM;
! 162: }
! 163:
! 164: pxa2x0_gpio_set_function(GPIO_TP_INT_C3K, GPIO_IN);
! 165:
! 166: /* XXX */
! 167: if (sc->sc_gh == NULL)
! 168: sc->sc_gh = pxa2x0_gpio_intr_establish(GPIO_TP_INT_C3K,
! 169: IST_EDGE_FALLING, IPL_TTY, zts_irq, sc,
! 170: sc->sc_dev.dv_xname);
! 171: else
! 172: pxa2x0_gpio_intr_unmask(sc->sc_gh);
! 173:
! 174: /* enable interrupts */
! 175: sc->sc_enabled = 1;
! 176: sc->sc_buttons = 0;
! 177:
! 178: return 0;
! 179: }
! 180:
! 181: void
! 182: zts_disable(void *v)
! 183: {
! 184: struct zts_softc *sc = v;
! 185:
! 186: timeout_del(&sc->sc_ts_poll);
! 187:
! 188: if (sc->sc_powerhook != NULL) {
! 189: powerhook_disestablish(sc->sc_powerhook);
! 190: sc->sc_powerhook = NULL;
! 191: }
! 192:
! 193: if (sc->sc_gh != NULL) {
! 194: #if 0
! 195: pxa2x0_gpio_intr_disestablish(sc->sc_gh);
! 196: sc->sc_gh = NULL;
! 197: #endif
! 198: }
! 199:
! 200: /* disable interrupts */
! 201: sc->sc_enabled = 0;
! 202: }
! 203:
! 204: void
! 205: zts_power(int why, void *v)
! 206: {
! 207: struct zts_softc *sc = v;
! 208:
! 209: switch (why) {
! 210: case PWR_STANDBY:
! 211: case PWR_SUSPEND:
! 212: sc->sc_enabled = 0;
! 213: #if 0
! 214: pxa2x0_gpio_intr_disestablish(sc->sc_gh);
! 215: #endif
! 216: timeout_del(&sc->sc_ts_poll);
! 217:
! 218: pxa2x0_gpio_intr_mask(sc->sc_gh);
! 219:
! 220: /* Turn off reference voltage but leave ADC on. */
! 221: (void)zssp_ic_send(ZSSP_IC_ADS7846, (1 << ADSCTRL_PD1_SH) |
! 222: (1 << ADSCTRL_ADR_SH) | (1 << ADSCTRL_STS_SH));
! 223:
! 224: pxa2x0_gpio_set_function(GPIO_TP_INT_C3K,
! 225: GPIO_OUT | GPIO_SET);
! 226: break;
! 227:
! 228: case PWR_RESUME:
! 229: pxa2x0_gpio_set_function(GPIO_TP_INT_C3K, GPIO_IN);
! 230: pxa2x0_gpio_intr_mask(sc->sc_gh);
! 231:
! 232: /* Enable automatic low power mode. */
! 233: (void)zssp_ic_send(ZSSP_IC_ADS7846,
! 234: (4 << ADSCTRL_ADR_SH) | (1 << ADSCTRL_STS_SH));
! 235:
! 236: #if 0
! 237: sc->sc_gh = pxa2x0_gpio_intr_establish(GPIO_TP_INT_C3K,
! 238: IST_EDGE_FALLING, IPL_TTY, zts_irq, sc,
! 239: sc->sc_dev.dv_xname);
! 240: #else
! 241: pxa2x0_gpio_intr_unmask(sc->sc_gh);
! 242: #endif
! 243: sc->sc_enabled = 1;
! 244: break;
! 245: }
! 246: }
! 247:
! 248: struct zts_pos {
! 249: int x;
! 250: int y;
! 251: int z; /* touch pressure */
! 252: };
! 253:
! 254: #define NSAMPLES 3
! 255: struct zts_pos zts_samples[NSAMPLES];
! 256: int ztsavgloaded = 0;
! 257:
! 258: int zts_readpos(struct zts_pos *);
! 259: void zts_avgpos(struct zts_pos *);
! 260:
! 261: #define HSYNC() \
! 262: do { \
! 263: while (pxa2x0_gpio_get_bit(GPIO_HSYNC_C3K) == 0); \
! 264: while (pxa2x0_gpio_get_bit(GPIO_HSYNC_C3K) != 0); \
! 265: } while (0)
! 266:
! 267: int pxa2x0_ccnt_enable(int);
! 268: u_int32_t pxa2x0_read_ccnt(void);
! 269: u_int32_t zts_sync_ads784x(int, int, u_int32_t);
! 270: void zts_sync_send(u_int32_t);
! 271:
! 272: int
! 273: pxa2x0_ccnt_enable(int on)
! 274: {
! 275: u_int32_t rv;
! 276:
! 277: on = on ? 0x1 : 0x0;
! 278: __asm __volatile("mrc p14, 0, %0, c0, c1, 0" : "=r" (rv));
! 279: __asm __volatile("mcr p14, 0, %0, c0, c1, 0" : : "r" (on));
! 280: return ((int)(rv & 0x1));
! 281: }
! 282:
! 283: u_int32_t
! 284: pxa2x0_read_ccnt(void)
! 285: {
! 286: u_int32_t rv;
! 287:
! 288: __asm __volatile("mrc p14, 0, %0, c1, c1, 0" : "=r" (rv));
! 289: return (rv);
! 290: }
! 291:
! 292: /*
! 293: * Communicate synchronously with the ADS784x touch screen controller.
! 294: */
! 295: u_int32_t
! 296: zts_sync_ads784x(int dorecv/* XXX */, int dosend/* XXX */, u_int32_t cmd)
! 297: {
! 298: int ccen;
! 299: u_int32_t rv;
! 300:
! 301: /* XXX poll hsync only if LCD is enabled */
! 302:
! 303: /* start clock counter */
! 304: ccen = pxa2x0_ccnt_enable(1);
! 305:
! 306: HSYNC();
! 307:
! 308: if (dorecv)
! 309: /* read SSDR and disable ADS784x */
! 310: rv = zssp_ic_stop(ZSSP_IC_ADS7846);
! 311: else
! 312: rv = 0;
! 313:
! 314: if (dosend)
! 315: zts_sync_send(cmd);
! 316:
! 317: /* stop clock counter */
! 318: pxa2x0_ccnt_enable(ccen);
! 319:
! 320: return (rv);
! 321: }
! 322:
! 323: void
! 324: zts_sync_send(u_int32_t cmd)
! 325: {
! 326: u_int32_t tck;
! 327: u_int32_t a, b;
! 328:
! 329: /* XXX */
! 330: tck = CCNT_HS_400_VGA_C3K - 151;
! 331:
! 332: /* send dummy command; discard SSDR */
! 333: (void)zssp_ic_send(ZSSP_IC_ADS7846, cmd);
! 334:
! 335: /* wait for refresh */
! 336: HSYNC();
! 337:
! 338: /* wait after refresh */
! 339: a = pxa2x0_read_ccnt();
! 340: b = pxa2x0_read_ccnt();
! 341: while ((b - a) < tck)
! 342: b = pxa2x0_read_ccnt();
! 343:
! 344: /* send the actual command; keep ADS784x enabled */
! 345: zssp_ic_start(ZSSP_IC_ADS7846, cmd);
! 346: }
! 347:
! 348: int
! 349: zts_readpos(struct zts_pos *pos)
! 350: {
! 351: int cmd;
! 352: int t0, t1;
! 353: int down;
! 354:
! 355: /* XXX */
! 356: pxa2x0_gpio_set_function(GPIO_HSYNC_C3K, GPIO_IN);
! 357:
! 358: /* check that pen is down */
! 359: cmd = (1 << ADSCTRL_PD0_SH) | (1 << ADSCTRL_PD1_SH) |
! 360: (3 << ADSCTRL_ADR_SH) | (1 << ADSCTRL_STS_SH);
! 361:
! 362: t0 = zssp_ic_send(ZSSP_IC_ADS7846, cmd);
! 363: down = !(t0 < 10);
! 364: if (down == 0)
! 365: goto out;
! 366:
! 367: /* Y */
! 368: cmd = (1 << ADSCTRL_PD0_SH) | (1 << ADSCTRL_PD1_SH) |
! 369: (1 << ADSCTRL_ADR_SH) | (1 << ADSCTRL_STS_SH);
! 370:
! 371: (void)zts_sync_ads784x(0, 1, cmd);
! 372:
! 373: /* Y */
! 374: cmd = (1 << ADSCTRL_PD0_SH) | (1 << ADSCTRL_PD1_SH) |
! 375: (1 << ADSCTRL_ADR_SH) | (1 << ADSCTRL_STS_SH);
! 376:
! 377: (void)zts_sync_ads784x(1, 1, cmd);
! 378:
! 379: /* X */
! 380: cmd = (1 << ADSCTRL_PD0_SH) | (1 << ADSCTRL_PD1_SH) |
! 381: (5 << ADSCTRL_ADR_SH) | (1 << ADSCTRL_STS_SH);
! 382:
! 383: pos->y = zts_sync_ads784x(1, 1, cmd);
! 384:
! 385: /* T0 */
! 386: cmd = (1 << ADSCTRL_PD0_SH) | (1 << ADSCTRL_PD1_SH) |
! 387: (3 << ADSCTRL_ADR_SH) | (1 << ADSCTRL_STS_SH);
! 388:
! 389: pos->x = zts_sync_ads784x(1, 1, cmd);
! 390:
! 391: /* T1 */
! 392: cmd = (1 << ADSCTRL_PD0_SH) | (1 << ADSCTRL_PD1_SH) |
! 393: (4 << ADSCTRL_ADR_SH) | (1 << ADSCTRL_STS_SH);
! 394:
! 395: t0 = zts_sync_ads784x(1, 1, cmd);
! 396: t1 = zts_sync_ads784x(1, 0, cmd);
! 397:
! 398: /* check that pen is still down */
! 399: /* XXX pressure sensitivity varies with X or what? */
! 400: if (t0 == 0 || (pos->x * (t1 - t0) / t0) >= 15000)
! 401: down = 0;
! 402: pos->z = down;
! 403:
! 404: out:
! 405: /* Enable automatic low power mode. */
! 406: cmd = (4 << ADSCTRL_ADR_SH) | (1 << ADSCTRL_STS_SH);
! 407: (void)zssp_ic_send(ZSSP_IC_ADS7846, cmd);
! 408:
! 409: return (down);
! 410: }
! 411:
! 412: #define NAVGSAMPLES (NSAMPLES < 3 ? NSAMPLES : 3)
! 413: void
! 414: zts_avgpos(struct zts_pos *pos)
! 415: {
! 416: struct zts_pos *tpp = zts_samples;
! 417: int diff[NAVGSAMPLES];
! 418: int mindiff, mindiffv;
! 419: int n;
! 420: int i;
! 421: static int tail;
! 422:
! 423: if (ztsavgloaded < NAVGSAMPLES) {
! 424: tpp[(tail + ztsavgloaded) % NSAMPLES] = *pos;
! 425: ztsavgloaded++;
! 426: return;
! 427: }
! 428:
! 429: tpp[tail] = *pos;
! 430: tail = (tail+1) % NSAMPLES;
! 431:
! 432: /* X */
! 433: i = tail;
! 434: for (n = 0 ; n < NAVGSAMPLES; n++) {
! 435: int alt;
! 436: alt = (i+1) % NSAMPLES;
! 437: diff[n] = tpp[i].x - tpp[alt].x;
! 438: if (diff[n] < 0)
! 439: diff[n] = - diff[n]; /* ABS */
! 440: i = alt;
! 441: }
! 442: mindiffv = diff[0];
! 443: mindiff = 0;
! 444: for (n = 1; n < NAVGSAMPLES; n++) {
! 445: if (diff[n] < mindiffv) {
! 446: mindiffv = diff[n];
! 447: mindiff = n;
! 448: }
! 449: }
! 450: pos->x = (tpp[(tail + mindiff) % NSAMPLES].x +
! 451: tpp[(tail + mindiff + 1) % NSAMPLES].x) / 2;
! 452:
! 453: /* Y */
! 454: i = tail;
! 455: for (n = 0 ; n < NAVGSAMPLES; n++) {
! 456: int alt;
! 457: alt = (i+1) % NSAMPLES;
! 458: diff[n] = tpp[i].y - tpp[alt].y;
! 459: if (diff[n] < 0)
! 460: diff[n] = - diff[n]; /* ABS */
! 461: i = alt;
! 462: }
! 463: mindiffv = diff[0];
! 464: mindiff = 0;
! 465: for (n = 1; n < NAVGSAMPLES; n++) {
! 466: if (diff[n] < mindiffv) {
! 467: mindiffv = diff[n];
! 468: mindiff = n;
! 469: }
! 470: }
! 471: pos->y = (tpp[(tail + mindiff) % NSAMPLES].y +
! 472: tpp[(tail + mindiff + 1) % NSAMPLES].y) / 2;
! 473: }
! 474:
! 475: void
! 476: zts_poll(void *v)
! 477: {
! 478: int s;
! 479:
! 480: s = spltty();
! 481: (void)zts_irq(v);
! 482: splx(s);
! 483: }
! 484:
! 485: #define TS_STABLE 8
! 486: int
! 487: zts_irq(void *v)
! 488: {
! 489: struct zts_softc *sc = v;
! 490: struct zts_pos tp;
! 491: int s;
! 492: int pindown;
! 493: int down;
! 494: extern int zkbd_modstate;
! 495:
! 496: if (!sc->sc_enabled)
! 497: return 0;
! 498:
! 499: s = splhigh();
! 500: pindown = pxa2x0_gpio_get_bit(GPIO_TP_INT_C3K) ? 0 : 1;
! 501: if (pindown) {
! 502: pxa2x0_gpio_intr_mask(sc->sc_gh);
! 503: timeout_add(&sc->sc_ts_poll, POLL_TIMEOUT_RATE1);
! 504: }
! 505:
! 506: down = zts_readpos(&tp);
! 507:
! 508: if (!pindown) {
! 509: pxa2x0_gpio_intr_unmask(sc->sc_gh);
! 510: timeout_add(&sc->sc_ts_poll, POLL_TIMEOUT_RATE0);
! 511: ztsavgloaded = 0;
! 512: }
! 513: pxa2x0_gpio_clear_intr(GPIO_TP_INT_C3K);
! 514: splx(s);
! 515:
! 516: if (down) {
! 517: zts_avgpos(&tp);
! 518: if (!sc->sc_rawmode) {
! 519: /* Scale down to the screen resolution. */
! 520: tp.x = ((tp.x - sc->sc_tsscale.minx) *
! 521: sc->sc_tsscale.resx) /
! 522: (sc->sc_tsscale.maxx - sc->sc_tsscale.minx);
! 523: tp.y = ((tp.y - sc->sc_tsscale.miny) *
! 524: sc->sc_tsscale.resy) /
! 525: (sc->sc_tsscale.maxy - sc->sc_tsscale.miny);
! 526: }
! 527: }
! 528:
! 529: if (zkbd_modstate != 0 && down) {
! 530: if(zkbd_modstate & (1 << 1)) {
! 531: /* Fn */
! 532: down = 2;
! 533: }
! 534: if(zkbd_modstate & (1 << 2)) {
! 535: /* 'Alt' */
! 536: down = 4;
! 537: }
! 538: }
! 539: if (!down) {
! 540: /* x/y values are not reliable when pen is up */
! 541: tp.x = sc->sc_oldx;
! 542: tp.y = sc->sc_oldy;
! 543: }
! 544:
! 545: if (down || sc->sc_buttons != down) {
! 546: DPRINTF(("%s: tp.z = %d, tp.x = %d, tp.y = %d\n",
! 547: sc->sc_dev.dv_xname, tp.z, tp.x, tp.y));
! 548:
! 549: wsmouse_input(sc->sc_wsmousedev, down, tp.x, tp.y,
! 550: 0 /* z */, 0 /* w */,
! 551: WSMOUSE_INPUT_ABSOLUTE_X | WSMOUSE_INPUT_ABSOLUTE_Y |
! 552: WSMOUSE_INPUT_ABSOLUTE_Z);
! 553: sc->sc_buttons = down;
! 554: sc->sc_oldx = tp.x;
! 555: sc->sc_oldy = tp.y;
! 556: }
! 557:
! 558: return 1;
! 559: }
! 560:
! 561: int
! 562: zts_ioctl(void *v, u_long cmd, caddr_t data, int flag, struct proc *p)
! 563: {
! 564: int error = 0;
! 565: struct zts_softc *sc = v;
! 566: struct wsmouse_calibcoords *wsmc = (struct wsmouse_calibcoords *)data;
! 567:
! 568: DPRINTF(("zts_ioctl(%d, '%c', %d)\n",
! 569: IOCPARM_LEN(cmd), IOCGROUP(cmd), cmd & 0xff));
! 570:
! 571: switch (cmd) {
! 572: case WSMOUSEIO_SCALIBCOORDS:
! 573: if (!(wsmc->minx >= 0 && wsmc->maxx >= 0 &&
! 574: wsmc->miny >= 0 && wsmc->maxy >= 0 &&
! 575: wsmc->resx >= 0 && wsmc->resy >= 0 &&
! 576: wsmc->minx < 32768 && wsmc->maxx < 32768 &&
! 577: wsmc->miny < 32768 && wsmc->maxy < 32768 &&
! 578: wsmc->resx < 32768 && wsmc->resy < 32768 &&
! 579: wsmc->swapxy >= 0 && wsmc->swapxy <= 1 &&
! 580: wsmc->samplelen >= 0 && wsmc->samplelen <= 1))
! 581: return (EINVAL);
! 582:
! 583: sc->sc_tsscale.minx = wsmc->minx;
! 584: sc->sc_tsscale.maxx = wsmc->maxx;
! 585: sc->sc_tsscale.miny = wsmc->miny;
! 586: sc->sc_tsscale.maxy = wsmc->maxy;
! 587: sc->sc_tsscale.swapxy = wsmc->swapxy;
! 588: sc->sc_tsscale.resx = wsmc->resx;
! 589: sc->sc_tsscale.resy = wsmc->resy;
! 590: sc->sc_rawmode = wsmc->samplelen;
! 591: break;
! 592: case WSMOUSEIO_GCALIBCOORDS:
! 593: wsmc->minx = sc->sc_tsscale.minx;
! 594: wsmc->maxx = sc->sc_tsscale.maxx;
! 595: wsmc->miny = sc->sc_tsscale.miny;
! 596: wsmc->maxy = sc->sc_tsscale.maxy;
! 597: wsmc->swapxy = sc->sc_tsscale.swapxy;
! 598: wsmc->resx = sc->sc_tsscale.resx;
! 599: wsmc->resy = sc->sc_tsscale.resy;
! 600: wsmc->samplelen = sc->sc_rawmode;
! 601: break;
! 602: case WSMOUSEIO_GTYPE:
! 603: *(u_int *)data = WSMOUSE_TYPE_TPANEL;
! 604: break;
! 605: default:
! 606: error = ENOTTY;
! 607: break;
! 608: }
! 609:
! 610: return (error);
! 611: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to zts.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / zaurus / dev