hw/tsc2005.c

   1 /*
   2  * TI TSC2005 emulator.
   3  *
   4  * Copyright (c) 2006 Andrzej Zaborowski  <balrog@zabor.org>
   5  * Copyright (C) 2008 Nokia Corporation
   6  *
   7  * This program is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License as
   9  * published by the Free Software Foundation; either version 2 or
  10  * (at your option) version 3 of the License.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License along
  18  * with this program; if not, see <http://www.gnu.org/licenses/>.
  19  */
  20
  21 #include "hw.h"
  22 #include "qemu-timer.h"
  23 #include "console.h"
  24 #include "devices.h"
  25
  26 #define TSC_CUT_RESOLUTION(value, p)    ((value) >> (16 - (p ? 12 : 10)))
  27
  28 typedef struct {
  29     qemu_irq pint;      /* Combination of the nPENIRQ and DAV signals */
  30     QEMUTimer *timer;
  31     uint16_t model;
  32
  33     int x, y;
  34     int pressure;
  35
  36     int state, reg, irq, command;
  37     uint16_t data, dav;
  38
  39     int busy;
  40     int enabled;
  41     int host_mode;
  42     int function;
  43     int nextfunction;
  44     int precision;
  45     int nextprecision;
  46     int filter;
  47     int pin_func;
  48     int timing[2];
  49     int noise;
  50     int reset;
  51     int pdst;
  52     int pnd0;
  53     uint16_t temp_thr[2];
  54     uint16_t aux_thr[2];
  55
  56     int tr[8];
  57 } TSC2005State;
  58
  59 enum {
  60     TSC_MODE_XYZ_SCAN   = 0x0,
  61     TSC_MODE_XY_SCAN,
  62     TSC_MODE_X,
  63     TSC_MODE_Y,
  64     TSC_MODE_Z,
  65     TSC_MODE_AUX,
  66     TSC_MODE_TEMP1,
  67     TSC_MODE_TEMP2,
  68     TSC_MODE_AUX_SCAN,
  69     TSC_MODE_X_TEST,
  70     TSC_MODE_Y_TEST,
  71     TSC_MODE_TS_TEST,
  72     TSC_MODE_RESERVED,
  73     TSC_MODE_XX_DRV,
  74     TSC_MODE_YY_DRV,
  75     TSC_MODE_YX_DRV,
  76 };
  77
  78 static const uint16_t mode_regs[16] = {
  79     0xf000,     /* X, Y, Z scan */
  80     0xc000,     /* X, Y scan */
  81     0x8000,     /* X */
  82     0x4000,     /* Y */
  83     0x3000,     /* Z */
  84     0x0800,     /* AUX */
  85     0x0400,     /* TEMP1 */
  86     0x0200,     /* TEMP2 */
  87     0x0800,     /* AUX scan */
  88     0x0040,     /* X test */
  89     0x0020,     /* Y test */
  90     0x0080,     /* Short-circuit test */
  91     0x0000,     /* Reserved */
  92     0x0000,     /* X+, X- drivers */
  93     0x0000,     /* Y+, Y- drivers */
  94     0x0000,     /* Y+, X- drivers */
  95 };
  96
  97 #define X_TRANSFORM(s)                  \
  98     ((s->y * s->tr[0] - s->x * s->tr[1]) / s->tr[2] + s->tr[3])
  99 #define Y_TRANSFORM(s)                  \
 100     ((s->y * s->tr[4] - s->x * s->tr[5]) / s->tr[6] + s->tr[7])
 101 #define Z1_TRANSFORM(s)                 \
 102     ((400 - ((s)->x >> 7) + ((s)->pressure << 10)) << 4)
 103 #define Z2_TRANSFORM(s)                 \
 104     ((4000 + ((s)->y >> 7) - ((s)->pressure << 10)) << 4)
 105
 106 #define AUX_VAL                         (700 << 4)      /* +/- 3 at 12-bit */
 107 #define TEMP1_VAL                       (1264 << 4)     /* +/- 5 at 12-bit */
 108 #define TEMP2_VAL                       (1531 << 4)     /* +/- 5 at 12-bit */
 109
 110 static uint16_t tsc2005_read(TSC2005State *s, int reg)
 111 {
 112     uint16_t ret;
 113
 114     switch (reg) {
 115     case 0x0:   /* X */
 116         s->dav &= ~mode_regs[TSC_MODE_X];
 117         return TSC_CUT_RESOLUTION(X_TRANSFORM(s), s->precision) +
 118                 (s->noise & 3);
 119     case 0x1:   /* Y */
 120         s->dav &= ~mode_regs[TSC_MODE_Y];
 121         s->noise ++;
 122         return TSC_CUT_RESOLUTION(Y_TRANSFORM(s), s->precision) ^
 123                 (s->noise & 3);
 124     case 0x2:   /* Z1 */
 125         s->dav &= 0xdfff;
 126         return TSC_CUT_RESOLUTION(Z1_TRANSFORM(s), s->precision) -
 127                 (s->noise & 3);
 128     case 0x3:   /* Z2 */
 129         s->dav &= 0xefff;
 130         return TSC_CUT_RESOLUTION(Z2_TRANSFORM(s), s->precision) |
 131                 (s->noise & 3);
 132
 133     case 0x4:   /* AUX */
 134         s->dav &= ~mode_regs[TSC_MODE_AUX];
 135         return TSC_CUT_RESOLUTION(AUX_VAL, s->precision);
 136
 137     case 0x5:   /* TEMP1 */
 138         s->dav &= ~mode_regs[TSC_MODE_TEMP1];
 139         return TSC_CUT_RESOLUTION(TEMP1_VAL, s->precision) -
 140                 (s->noise & 5);
 141     case 0x6:   /* TEMP2 */
 142         s->dav &= 0xdfff;
 143         s->dav &= ~mode_regs[TSC_MODE_TEMP2];
 144         return TSC_CUT_RESOLUTION(TEMP2_VAL, s->precision) ^
 145                 (s->noise & 3);
 146
 147     case 0x7:   /* Status */
 148         ret = s->dav | (s->reset << 7) | (s->pdst << 2) | 0x0;
 149         s->dav &= ~(mode_regs[TSC_MODE_X_TEST] | mode_regs[TSC_MODE_Y_TEST] |
 150                         mode_regs[TSC_MODE_TS_TEST]);
 151         s->reset = 1;
 152         return ret;
 153
 154     case 0x8:   /* AUX high treshold */
 155         return s->aux_thr[1];
 156     case 0x9:   /* AUX low treshold */
 157         return s->aux_thr[0];
 158
 159     case 0xa:   /* TEMP high treshold */
 160         return s->temp_thr[1];
 161     case 0xb:   /* TEMP low treshold */
 162         return s->temp_thr[0];
 163
 164     case 0xc:   /* CFR0 */
 165         return (s->pressure << 15) | ((!s->busy) << 14) |
 166                 (s->nextprecision << 13) | s->timing[0];
 167     case 0xd:   /* CFR1 */
 168         return s->timing[1];
 169     case 0xe:   /* CFR2 */
 170         return (s->pin_func << 14) | s->filter;
 171
 172     case 0xf:   /* Function select status */
 173         return s->function >= 0 ? 1 << s->function : 0;
 174     }
 175
 176     /* Never gets here */
 177     return 0xffff;
 178 }
 179
 180 static void tsc2005_write(TSC2005State *s, int reg, uint16_t data)
 181 {
 182     switch (reg) {
 183     case 0x8:   /* AUX high treshold */
 184         s->aux_thr[1] = data;
 185         break;
 186     case 0x9:   /* AUX low treshold */
 187         s->aux_thr[0] = data;
 188         break;
 189
 190     case 0xa:   /* TEMP high treshold */
 191         s->temp_thr[1] = data;
 192         break;
 193     case 0xb:   /* TEMP low treshold */
 194         s->temp_thr[0] = data;
 195         break;
 196
 197     case 0xc:   /* CFR0 */
 198         s->host_mode = data >> 15;
 199         if (s->enabled != !(data & 0x4000)) {
 200             s->enabled = !(data & 0x4000);
 201             fprintf(stderr, "%s: touchscreen sense %sabled\n",
 202                             __FUNCTION__, s->enabled ? "en" : "dis");
 203             if (s->busy && !s->enabled)
 204                 qemu_del_timer(s->timer);
 205             s->busy &= s->enabled;
 206         }
 207         s->nextprecision = (data >> 13) & 1;
 208         s->timing[0] = data & 0x1fff;
 209         if ((s->timing[0] >> 11) == 3)
 210             fprintf(stderr, "%s: illegal conversion clock setting\n",
 211                             __FUNCTION__);
 212         break;
 213     case 0xd:   /* CFR1 */
 214         s->timing[1] = data & 0xf07;
 215         break;
 216     case 0xe:   /* CFR2 */
 217         s->pin_func = (data >> 14) & 3;
 218         s->filter = data & 0x3fff;
 219         break;
 220
 221     default:
 222         fprintf(stderr, "%s: write into read-only register %x\n",
 223                         __FUNCTION__, reg);
 224     }
 225 }
 226
 227 /* This handles most of the chip's logic.  */
 228 static void tsc2005_pin_update(TSC2005State *s)
 229 {
 230     int64_t expires;
 231     int pin_state;
 232
 233     switch (s->pin_func) {
 234     case 0:
 235         pin_state = !s->pressure && !!s->dav;
 236         break;
 237     case 1:
 238     case 3:
 239     default:
 240         pin_state = !s->dav;
 241         break;
 242     case 2:
 243         pin_state = !s->pressure;
 244     }
 245
 246     if (pin_state != s->irq) {
 247         s->irq = pin_state;
 248         qemu_set_irq(s->pint, s->irq);
 249     }
 250
 251     switch (s->nextfunction) {
 252     case TSC_MODE_XYZ_SCAN:
 253     case TSC_MODE_XY_SCAN:
 254         if (!s->host_mode && s->dav)
 255             s->enabled = 0;
 256         if (!s->pressure)
 257             return;
 258         /* Fall through */
 259     case TSC_MODE_AUX_SCAN:
 260         break;
 261
 262     case TSC_MODE_X:
 263     case TSC_MODE_Y:
 264     case TSC_MODE_Z:
 265         if (!s->pressure)
 266             return;
 267         /* Fall through */
 268     case TSC_MODE_AUX:
 269     case TSC_MODE_TEMP1:
 270     case TSC_MODE_TEMP2:
 271     case TSC_MODE_X_TEST:
 272     case TSC_MODE_Y_TEST:
 273     case TSC_MODE_TS_TEST:
 274         if (s->dav)
 275             s->enabled = 0;
 276         break;
 277
 278     case TSC_MODE_RESERVED:
 279     case TSC_MODE_XX_DRV:
 280     case TSC_MODE_YY_DRV:
 281     case TSC_MODE_YX_DRV:
 282     default:
 283         return;
 284     }
 285
 286     if (!s->enabled || s->busy)
 287         return;
 288
 289     s->busy = 1;
 290     s->precision = s->nextprecision;
 291     s->function = s->nextfunction;
 292     s->pdst = !s->pnd0; /* Synchronised on internal clock */
 293     expires = qemu_get_clock(vm_clock) + (ticks_per_sec >> 7);
 294     qemu_mod_timer(s->timer, expires);
 295 }
 296
 297 static void tsc2005_reset(TSC2005State *s)
 298 {
 299     s->state = 0;
 300     s->pin_func = 0;
 301     s->enabled = 0;
 302     s->busy = 0;
 303     s->nextprecision = 0;
 304     s->nextfunction = 0;
 305     s->timing[0] = 0;
 306     s->timing[1] = 0;
 307     s->irq = 0;
 308     s->dav = 0;
 309     s->reset = 0;
 310     s->pdst = 1;
 311     s->pnd0 = 0;
 312     s->function = -1;
 313     s->temp_thr[0] = 0x000;
 314     s->temp_thr[1] = 0xfff;
 315     s->aux_thr[0] = 0x000;
 316     s->aux_thr[1] = 0xfff;
 317
 318     tsc2005_pin_update(s);
 319 }
 320
 321 static uint8_t tsc2005_txrx_word(void *opaque, uint8_t value)
 322 {
 323     TSC2005State *s = opaque;
 324     uint32_t ret = 0;
 325
 326     switch (s->state ++) {
 327     case 0:
 328         if (value & 0x80) {
 329             /* Command */
 330             if (value & (1 << 1))
 331                 tsc2005_reset(s);
 332             else {
 333                 s->nextfunction = (value >> 3) & 0xf;
 334                 s->nextprecision = (value >> 2) & 1;
 335                 if (s->enabled != !(value & 1)) {
 336                     s->enabled = !(value & 1);
 337                     fprintf(stderr, "%s: touchscreen sense %sabled\n",
 338                                     __FUNCTION__, s->enabled ? "en" : "dis");
 339                     if (s->busy && !s->enabled)
 340                         qemu_del_timer(s->timer);
 341                     s->busy &= s->enabled;
 342                 }
 343                 tsc2005_pin_update(s);
 344             }
 345
 346             s->state = 0;
 347         } else if (value) {
 348             /* Data transfer */
 349             s->reg = (value >> 3) & 0xf;
 350             s->pnd0 = (value >> 1) & 1;
 351             s->command = value & 1;
 352
 353             if (s->command) {
 354                 /* Read */
 355                 s->data = tsc2005_read(s, s->reg);
 356                 tsc2005_pin_update(s);
 357             } else
 358                 s->data = 0;
 359         } else
 360             s->state = 0;
 361         break;
 362
 363     case 1:
 364         if (s->command)
 365             ret = (s->data >> 8) & 0xff;
 366         else
 367             s->data |= value << 8;
 368         break;
 369
 370     case 2:
 371         if (s->command)
 372             ret = s->data & 0xff;
 373         else {
 374             s->data |= value;
 375             tsc2005_write(s, s->reg, s->data);
 376             tsc2005_pin_update(s);
 377         }
 378
 379         s->state = 0;
 380         break;
 381     }
 382
 383     return ret;
 384 }
 385
 386 uint32_t tsc2005_txrx(void *opaque, uint32_t value, int len)
 387 {
 388     uint32_t ret = 0;
 389
 390     len &= ~7;
 391     while (len > 0) {
 392         len -= 8;
 393         ret |= tsc2005_txrx_word(opaque, (value >> len) & 0xff) << len;
 394     }
 395
 396     return ret;
 397 }
 398
 399 static void tsc2005_timer_tick(void *opaque)
 400 {
 401     TSC2005State *s = opaque;
 402
 403     /* Timer ticked -- a set of conversions has been finished.  */
 404
 405     if (!s->busy)
 406         return;
 407
 408     s->busy = 0;
 409     s->dav |= mode_regs[s->function];
 410     s->function = -1;
 411     tsc2005_pin_update(s);
 412 }
 413
 414 static void tsc2005_touchscreen_event(void *opaque,
 415                 int x, int y, int z, int buttons_state)
 416 {
 417     TSC2005State *s = opaque;
 418     int p = s->pressure;
 419
 420     if (buttons_state) {
 421         s->x = x;
 422         s->y = y;
 423     }
 424     s->pressure = !!buttons_state;
 425
 426     /*
 427      * Note: We would get better responsiveness in the guest by
 428      * signaling TS events immediately, but for now we simulate
 429      * the first conversion delay for sake of correctness.
 430      */
 431     if (p != s->pressure)
 432         tsc2005_pin_update(s);
 433 }
 434
 435 static void tsc2005_save(QEMUFile *f, void *opaque)
 436 {
 437     TSC2005State *s = (TSC2005State *) opaque;
 438     int i;
 439
 440     qemu_put_be16(f, s->x);
 441     qemu_put_be16(f, s->y);
 442     qemu_put_byte(f, s->pressure);
 443
 444     qemu_put_byte(f, s->state);
 445     qemu_put_byte(f, s->reg);
 446     qemu_put_byte(f, s->command);
 447
 448     qemu_put_byte(f, s->irq);
 449     qemu_put_be16s(f, &s->dav);
 450     qemu_put_be16s(f, &s->data);
 451
 452     qemu_put_timer(f, s->timer);
 453     qemu_put_byte(f, s->enabled);
 454     qemu_put_byte(f, s->host_mode);
 455     qemu_put_byte(f, s->function);
 456     qemu_put_byte(f, s->nextfunction);
 457     qemu_put_byte(f, s->precision);
 458     qemu_put_byte(f, s->nextprecision);
 459     qemu_put_be16(f, s->filter);
 460     qemu_put_byte(f, s->pin_func);
 461     qemu_put_be16(f, s->timing[0]);
 462     qemu_put_be16(f, s->timing[1]);
 463     qemu_put_be16s(f, &s->temp_thr[0]);
 464     qemu_put_be16s(f, &s->temp_thr[1]);
 465     qemu_put_be16s(f, &s->aux_thr[0]);
 466     qemu_put_be16s(f, &s->aux_thr[1]);
 467     qemu_put_be32(f, s->noise);
 468     qemu_put_byte(f, s->reset);
 469     qemu_put_byte(f, s->pdst);
 470     qemu_put_byte(f, s->pnd0);
 471
 472     for (i = 0; i < 8; i ++)
 473         qemu_put_be32(f, s->tr[i]);
 474 }
 475
 476 static int tsc2005_load(QEMUFile *f, void *opaque, int version_id)
 477 {
 478     TSC2005State *s = (TSC2005State *) opaque;
 479     int i;
 480
 481     s->x = qemu_get_be16(f);
 482     s->y = qemu_get_be16(f);
 483     s->pressure = qemu_get_byte(f);
 484
 485     s->state = qemu_get_byte(f);
 486     s->reg = qemu_get_byte(f);
 487     s->command = qemu_get_byte(f);
 488
 489     s->irq = qemu_get_byte(f);
 490     qemu_get_be16s(f, &s->dav);
 491     qemu_get_be16s(f, &s->data);
 492
 493     qemu_get_timer(f, s->timer);
 494     s->enabled = qemu_get_byte(f);
 495     s->host_mode = qemu_get_byte(f);
 496     s->function = qemu_get_byte(f);
 497     s->nextfunction = qemu_get_byte(f);
 498     s->precision = qemu_get_byte(f);
 499     s->nextprecision = qemu_get_byte(f);
 500     s->filter = qemu_get_be16(f);
 501     s->pin_func = qemu_get_byte(f);
 502     s->timing[0] = qemu_get_be16(f);
 503     s->timing[1] = qemu_get_be16(f);
 504     qemu_get_be16s(f, &s->temp_thr[0]);
 505     qemu_get_be16s(f, &s->temp_thr[1]);
 506     qemu_get_be16s(f, &s->aux_thr[0]);
 507     qemu_get_be16s(f, &s->aux_thr[1]);
 508     s->noise = qemu_get_be32(f);
 509     s->reset = qemu_get_byte(f);
 510     s->pdst = qemu_get_byte(f);
 511     s->pnd0 = qemu_get_byte(f);
 512
 513     for (i = 0; i < 8; i ++)
 514         s->tr[i] = qemu_get_be32(f);
 515
 516     s->busy = qemu_timer_pending(s->timer);
 517     tsc2005_pin_update(s);
 518
 519     return 0;
 520 }
 521
 522 void *tsc2005_init(qemu_irq pintdav)
 523 {
 524     TSC2005State *s;
 525
 526     s = (TSC2005State *)
 527             qemu_mallocz(sizeof(TSC2005State));
 528     s->x = 400;
 529     s->y = 240;
 530     s->pressure = 0;
 531     s->precision = s->nextprecision = 0;
 532     s->timer = qemu_new_timer(vm_clock, tsc2005_timer_tick, s);
 533     s->pint = pintdav;
 534     s->model = 0x2005;
 535
 536     s->tr[0] = 0;
 537     s->tr[1] = 1;
 538     s->tr[2] = 1;
 539     s->tr[3] = 0;
 540     s->tr[4] = 1;
 541     s->tr[5] = 0;
 542     s->tr[6] = 1;
 543     s->tr[7] = 0;
 544
 545     tsc2005_reset(s);
 546
 547     qemu_add_mouse_event_handler(tsc2005_touchscreen_event, s, 1,
 548                     "QEMU TSC2005-driven Touchscreen");
 549
 550     qemu_register_reset((void *) tsc2005_reset, s);
 551     register_savevm("tsc2005", -1, 0, tsc2005_save, tsc2005_load, s);
 552
 553     return s;
 554 }
 555
 556 /*
 557  * Use tslib generated calibration data to generate ADC input values
 558  * from the touchscreen.  Assuming 12-bit precision was used during
 559  * tslib calibration.
 560  */
 561 void tsc2005_set_transform(void *opaque, MouseTransformInfo *info)
 562 {
 563     TSC2005State *s = (TSC2005State *) opaque;
 564
 565     /* This version assumes touchscreen X & Y axis are parallel or
 566      * perpendicular to LCD's  X & Y axis in some way.  */
 567     if (abs(info->a[0]) > abs(info->a[1])) {
 568         s->tr[0] = 0;
 569         s->tr[1] = -info->a[6] * info->x;
 570         s->tr[2] = info->a[0];
 571         s->tr[3] = -info->a[2] / info->a[0];
 572         s->tr[4] = info->a[6] * info->y;
 573         s->tr[5] = 0;
 574         s->tr[6] = info->a[4];
 575         s->tr[7] = -info->a[5] / info->a[4];
 576     } else {
 577         s->tr[0] = info->a[6] * info->y;
 578         s->tr[1] = 0;
 579         s->tr[2] = info->a[1];
 580         s->tr[3] = -info->a[2] / info->a[1];
 581         s->tr[4] = 0;
 582         s->tr[5] = -info->a[6] * info->x;
 583         s->tr[6] = info->a[3];
 584         s->tr[7] = -info->a[5] / info->a[3];
 585     }
 586
 587     s->tr[0] >>= 11;
 588     s->tr[1] >>= 11;
 589     s->tr[3] <<= 4;
 590     s->tr[4] >>= 11;
 591     s->tr[5] >>= 11;
 592     s->tr[7] <<= 4;
 593 }