hw/input/tsc210x.c

   1 /*
   2  * TI TSC2102 (touchscreen/sensors/audio controller) emulator.
   3  * TI TSC2301 (touchscreen/sensors/keypad).
   4  *
   5  * Copyright (c) 2006 Andrzej Zaborowski  <[email protected]>
   6  * Copyright (C) 2008 Nokia Corporation
   7  *
   8  * This program is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU General Public License as
  10  * published by the Free Software Foundation; either version 2 or
  11  * (at your option) version 3 of the License.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License along
  19  * with this program; if not, see <http://www.gnu.org/licenses/>.
  20  */
  21
  22 #include "hw/hw.h"
  23 #include "audio/audio.h"
  24 #include "qemu/timer.h"
  25 #include "ui/console.h"
  26 #include "hw/arm/omap.h"        /* For I2SCodec and uWireSlave */
  27 #include "hw/devices.h"
  28
  29 #define TSC_DATA_REGISTERS_PAGE         0x0
  30 #define TSC_CONTROL_REGISTERS_PAGE      0x1
  31 #define TSC_AUDIO_REGISTERS_PAGE        0x2
  32
  33 #define TSC_VERBOSE
  34
  35 #define TSC_CUT_RESOLUTION(value, p)    ((value) >> (16 - resolution[p]))
  36
  37 typedef struct {
  38     qemu_irq pint;
  39     qemu_irq kbint;
  40     qemu_irq davint;
  41     QEMUTimer *timer;
  42     QEMUSoundCard card;
  43     uWireSlave chip;
  44     I2SCodec codec;
  45     uint8_t in_fifo[16384];
  46     uint8_t out_fifo[16384];
  47     uint16_t model;
  48
  49     int x, y;
  50     int pressure;
  51
  52     int state, page, offset, irq;
  53     uint16_t command, dav;
  54
  55     int busy;
  56     int enabled;
  57     int host_mode;
  58     int function;
  59     int nextfunction;
  60     int precision;
  61     int nextprecision;
  62     int filter;
  63     int pin_func;
  64     int ref;
  65     int timing;
  66     int noise;
  67
  68     uint16_t audio_ctrl1;
  69     uint16_t audio_ctrl2;
  70     uint16_t audio_ctrl3;
  71     uint16_t pll[3];
  72     uint16_t volume;
  73     int64_t volume_change;
  74     int softstep;
  75     uint16_t dac_power;
  76     int64_t powerdown;
  77     uint16_t filter_data[0x14];
  78
  79     const char *name;
  80     SWVoiceIn *adc_voice[1];
  81     SWVoiceOut *dac_voice[1];
  82     int i2s_rx_rate;
  83     int i2s_tx_rate;
  84
  85     int tr[8];
  86
  87     struct {
  88         uint16_t down;
  89         uint16_t mask;
  90         int scan;
  91         int debounce;
  92         int mode;
  93         int intr;
  94     } kb;
  95 } TSC210xState;
  96
  97 static const int resolution[4] = { 12, 8, 10, 12 };
  98
  99 #define TSC_MODE_NO_SCAN        0x0
 100 #define TSC_MODE_XY_SCAN        0x1
 101 #define TSC_MODE_XYZ_SCAN       0x2
 102 #define TSC_MODE_X              0x3
 103 #define TSC_MODE_Y              0x4
 104 #define TSC_MODE_Z              0x5
 105 #define TSC_MODE_BAT1           0x6
 106 #define TSC_MODE_BAT2           0x7
 107 #define TSC_MODE_AUX            0x8
 108 #define TSC_MODE_AUX_SCAN       0x9
 109 #define TSC_MODE_TEMP1          0xa
 110 #define TSC_MODE_PORT_SCAN      0xb
 111 #define TSC_MODE_TEMP2          0xc
 112 #define TSC_MODE_XX_DRV         0xd
 113 #define TSC_MODE_YY_DRV         0xe
 114 #define TSC_MODE_YX_DRV         0xf
 115
 116 static const uint16_t mode_regs[16] = {
 117     0x0000,     /* No scan */
 118     0x0600,     /* X, Y scan */
 119     0x0780,     /* X, Y, Z scan */
 120     0x0400,     /* X */
 121     0x0200,     /* Y */
 122     0x0180,     /* Z */
 123     0x0040,     /* BAT1 */
 124     0x0030,     /* BAT2 */
 125     0x0010,     /* AUX */
 126     0x0010,     /* AUX scan */
 127     0x0004,     /* TEMP1 */
 128     0x0070,     /* Port scan */
 129     0x0002,     /* TEMP2 */
 130     0x0000,     /* X+, X- drivers */
 131     0x0000,     /* Y+, Y- drivers */
 132     0x0000,     /* Y+, X- drivers */
 133 };
 134
 135 #define X_TRANSFORM(s)                  \
 136     ((s->y * s->tr[0] - s->x * s->tr[1]) / s->tr[2] + s->tr[3])
 137 #define Y_TRANSFORM(s)                  \
 138     ((s->y * s->tr[4] - s->x * s->tr[5]) / s->tr[6] + s->tr[7])
 139 #define Z1_TRANSFORM(s)                 \
 140     ((400 - ((s)->x >> 7) + ((s)->pressure << 10)) << 4)
 141 #define Z2_TRANSFORM(s)                 \
 142     ((4000 + ((s)->y >> 7) - ((s)->pressure << 10)) << 4)
 143
 144 #define BAT1_VAL                        0x8660
 145 #define BAT2_VAL                        0x0000
 146 #define AUX1_VAL                        0x35c0
 147 #define AUX2_VAL                        0xffff
 148 #define TEMP1_VAL                       0x8c70
 149 #define TEMP2_VAL                       0xa5b0
 150
 151 #define TSC_POWEROFF_DELAY              50
 152 #define TSC_SOFTSTEP_DELAY              50
 153
 154 static void tsc210x_reset(TSC210xState *s)
 155 {
 156     s->state = 0;
 157     s->pin_func = 2;
 158     s->enabled = 0;
 159     s->busy = 0;
 160     s->nextfunction = 0;
 161     s->ref = 0;
 162     s->timing = 0;
 163     s->irq = 0;
 164     s->dav = 0;
 165
 166     s->audio_ctrl1 = 0x0000;
 167     s->audio_ctrl2 = 0x4410;
 168     s->audio_ctrl3 = 0x0000;
 169     s->pll[0] = 0x1004;
 170     s->pll[1] = 0x0000;
 171     s->pll[2] = 0x1fff;
 172     s->volume = 0xffff;
 173     s->dac_power = 0x8540;
 174     s->softstep = 1;
 175     s->volume_change = 0;
 176     s->powerdown = 0;
 177     s->filter_data[0x00] = 0x6be3;
 178     s->filter_data[0x01] = 0x9666;
 179     s->filter_data[0x02] = 0x675d;
 180     s->filter_data[0x03] = 0x6be3;
 181     s->filter_data[0x04] = 0x9666;
 182     s->filter_data[0x05] = 0x675d;
 183     s->filter_data[0x06] = 0x7d83;
 184     s->filter_data[0x07] = 0x84ee;
 185     s->filter_data[0x08] = 0x7d83;
 186     s->filter_data[0x09] = 0x84ee;
 187     s->filter_data[0x0a] = 0x6be3;
 188     s->filter_data[0x0b] = 0x9666;
 189     s->filter_data[0x0c] = 0x675d;
 190     s->filter_data[0x0d] = 0x6be3;
 191     s->filter_data[0x0e] = 0x9666;
 192     s->filter_data[0x0f] = 0x675d;
 193     s->filter_data[0x10] = 0x7d83;
 194     s->filter_data[0x11] = 0x84ee;
 195     s->filter_data[0x12] = 0x7d83;
 196     s->filter_data[0x13] = 0x84ee;
 197
 198     s->i2s_tx_rate = 0;
 199     s->i2s_rx_rate = 0;
 200
 201     s->kb.scan = 1;
 202     s->kb.debounce = 0;
 203     s->kb.mask = 0x0000;
 204     s->kb.mode = 3;
 205     s->kb.intr = 0;
 206
 207     qemu_set_irq(s->pint, !s->irq);
 208     qemu_set_irq(s->davint, !s->dav);
 209     qemu_irq_raise(s->kbint);
 210 }
 211
 212 typedef struct {
 213     int rate;
 214     int dsor;
 215     int fsref;
 216 } TSC210xRateInfo;
 217
 218 /*  { rate,  dsor,  fsref } */
 219 static const TSC210xRateInfo tsc2101_rates[] = {
 220     /* Fsref / 6.0 */
 221     { 7350,     7,      1 },
 222     { 8000,     7,      0 },
 223     /* Fsref / 5.5 */
 224     { 8018,     6,      1 },
 225     { 8727,     6,      0 },
 226     /* Fsref / 5.0 */
 227     { 8820,     5,      1 },
 228     { 9600,     5,      0 },
 229     /* Fsref / 4.0 */
 230     { 11025,    4,      1 },
 231     { 12000,    4,      0 },
 232     /* Fsref / 3.0 */
 233     { 14700,    3,      1 },
 234     { 16000,    3,      0 },
 235     /* Fsref / 2.0 */
 236     { 22050,    2,      1 },
 237     { 24000,    2,      0 },
 238     /* Fsref / 1.5 */
 239     { 29400,    1,      1 },
 240     { 32000,    1,      0 },
 241     /* Fsref */
 242     { 44100,    0,      1 },
 243     { 48000,    0,      0 },
 244
 245     { 0,        0,      0 },
 246 };
 247
 248 /*  { rate,   dsor, fsref }     */
 249 static const TSC210xRateInfo tsc2102_rates[] = {
 250     /* Fsref / 6.0 */
 251     { 7350,     63,     1 },
 252     { 8000,     63,     0 },
 253     /* Fsref / 6.0 */
 254     { 7350,     54,     1 },
 255     { 8000,     54,     0 },
 256     /* Fsref / 5.0 */
 257     { 8820,     45,     1 },
 258     { 9600,     45,     0 },
 259     /* Fsref / 4.0 */
 260     { 11025,    36,     1 },
 261     { 12000,    36,     0 },
 262     /* Fsref / 3.0 */
 263     { 14700,    27,     1 },
 264     { 16000,    27,     0 },
 265     /* Fsref / 2.0 */
 266     { 22050,    18,     1 },
 267     { 24000,    18,     0 },
 268     /* Fsref / 1.5 */
 269     { 29400,    9,      1 },
 270     { 32000,    9,      0 },
 271     /* Fsref */
 272     { 44100,    0,      1 },
 273     { 48000,    0,      0 },
 274
 275     { 0,        0,      0 },
 276 };
 277
 278 static inline void tsc210x_out_flush(TSC210xState *s, int len)
 279 {
 280     uint8_t *data = s->codec.out.fifo + s->codec.out.start;
 281     uint8_t *end = data + len;
 282
 283     while (data < end)
 284         data += AUD_write(s->dac_voice[0], data, end - data) ?: (end - data);
 285
 286     s->codec.out.len -= len;
 287     if (s->codec.out.len)
 288         memmove(s->codec.out.fifo, end, s->codec.out.len);
 289     s->codec.out.start = 0;
 290 }
 291
 292 static void tsc210x_audio_out_cb(TSC210xState *s, int free_b)
 293 {
 294     if (s->codec.out.len >= free_b) {
 295         tsc210x_out_flush(s, free_b);
 296         return;
 297     }
 298
 299     s->codec.out.size = MIN(free_b, 16384);
 300     qemu_irq_raise(s->codec.tx_start);
 301 }
 302
 303 static void tsc2102_audio_rate_update(TSC210xState *s)
 304 {
 305     const TSC210xRateInfo *rate;
 306
 307     s->codec.tx_rate = 0;
 308     s->codec.rx_rate = 0;
 309     if (s->dac_power & (1 << 15))                               /* PWDNC */
 310         return;
 311
 312     for (rate = tsc2102_rates; rate->rate; rate ++)
 313         if (rate->dsor == (s->audio_ctrl1 & 0x3f) &&            /* DACFS */
 314                         rate->fsref == ((s->audio_ctrl3 >> 13) & 1))/* REFFS */
 315             break;
 316     if (!rate->rate) {
 317         printf("%s: unknown sampling rate configured\n", __FUNCTION__);
 318         return;
 319     }
 320
 321     s->codec.tx_rate = rate->rate;
 322 }
 323
 324 static void tsc2102_audio_output_update(TSC210xState *s)
 325 {
 326     int enable;
 327     struct audsettings fmt;
 328
 329     if (s->dac_voice[0]) {
 330         tsc210x_out_flush(s, s->codec.out.len);
 331         s->codec.out.size = 0;
 332         AUD_set_active_out(s->dac_voice[0], 0);
 333         AUD_close_out(&s->card, s->dac_voice[0]);
 334         s->dac_voice[0] = NULL;
 335     }
 336     s->codec.cts = 0;
 337
 338     enable =
 339             (~s->dac_power & (1 << 15)) &&                      /* PWDNC */
 340             (~s->dac_power & (1 << 10));                        /* DAPWDN */
 341     if (!enable || !s->codec.tx_rate)
 342         return;
 343
 344     /* Force our own sampling rate even in slave DAC mode */
 345     fmt.endianness = 0;
 346     fmt.nchannels = 2;
 347     fmt.freq = s->codec.tx_rate;
 348     fmt.fmt = AUD_FMT_S16;
 349
 350     s->dac_voice[0] = AUD_open_out(&s->card, s->dac_voice[0],
 351                     "tsc2102.sink", s, (void *) tsc210x_audio_out_cb, &fmt);
 352     if (s->dac_voice[0]) {
 353         s->codec.cts = 1;
 354         AUD_set_active_out(s->dac_voice[0], 1);
 355     }
 356 }
 357
 358 static uint16_t tsc2102_data_register_read(TSC210xState *s, int reg)
 359 {
 360     switch (reg) {
 361     case 0x00:  /* X */
 362         s->dav &= 0xfbff;
 363         return TSC_CUT_RESOLUTION(X_TRANSFORM(s), s->precision) +
 364                 (s->noise & 3);
 365
 366     case 0x01:  /* Y */
 367         s->noise ++;
 368         s->dav &= 0xfdff;
 369         return TSC_CUT_RESOLUTION(Y_TRANSFORM(s), s->precision) ^
 370                 (s->noise & 3);
 371
 372     case 0x02:  /* Z1 */
 373         s->dav &= 0xfeff;
 374         return TSC_CUT_RESOLUTION(Z1_TRANSFORM(s), s->precision) -
 375                 (s->noise & 3);
 376
 377     case 0x03:  /* Z2 */
 378         s->dav &= 0xff7f;
 379         return TSC_CUT_RESOLUTION(Z2_TRANSFORM(s), s->precision) |
 380                 (s->noise & 3);
 381
 382     case 0x04:  /* KPData */
 383         if ((s->model & 0xff00) == 0x2300) {
 384             if (s->kb.intr && (s->kb.mode & 2)) {
 385                 s->kb.intr = 0;
 386                 qemu_irq_raise(s->kbint);
 387             }
 388             return s->kb.down;
 389         }
 390
 391         return 0xffff;
 392
 393     case 0x05:  /* BAT1 */
 394         s->dav &= 0xffbf;
 395         return TSC_CUT_RESOLUTION(BAT1_VAL, s->precision) +
 396                 (s->noise & 6);
 397
 398     case 0x06:  /* BAT2 */
 399         s->dav &= 0xffdf;
 400         return TSC_CUT_RESOLUTION(BAT2_VAL, s->precision);
 401
 402     case 0x07:  /* AUX1 */
 403         s->dav &= 0xffef;
 404         return TSC_CUT_RESOLUTION(AUX1_VAL, s->precision);
 405
 406     case 0x08:  /* AUX2 */
 407         s->dav &= 0xfff7;
 408         return 0xffff;
 409
 410     case 0x09:  /* TEMP1 */
 411         s->dav &= 0xfffb;
 412         return TSC_CUT_RESOLUTION(TEMP1_VAL, s->precision) -
 413                 (s->noise & 5);
 414
 415     case 0x0a:  /* TEMP2 */
 416         s->dav &= 0xfffd;
 417         return TSC_CUT_RESOLUTION(TEMP2_VAL, s->precision) ^
 418                 (s->noise & 3);
 419
 420     case 0x0b:  /* DAC */
 421         s->dav &= 0xfffe;
 422         return 0xffff;
 423
 424     default:
 425 #ifdef TSC_VERBOSE
 426         fprintf(stderr, "tsc2102_data_register_read: "
 427                         "no such register: 0x%02x\n", reg);
 428 #endif
 429         return 0xffff;
 430     }
 431 }
 432
 433 static uint16_t tsc2102_control_register_read(
 434                 TSC210xState *s, int reg)
 435 {
 436     switch (reg) {
 437     case 0x00:  /* TSC ADC */
 438         return (s->pressure << 15) | ((!s->busy) << 14) |
 439                 (s->nextfunction << 10) | (s->nextprecision << 8) | s->filter;
 440
 441     case 0x01:  /* Status / Keypad Control */
 442         if ((s->model & 0xff00) == 0x2100)
 443             return (s->pin_func << 14) | ((!s->enabled) << 13) |
 444                     (s->host_mode << 12) | ((!!s->dav) << 11) | s->dav;
 445         else
 446             return (s->kb.intr << 15) | ((s->kb.scan || !s->kb.down) << 14) |
 447                     (s->kb.debounce << 11);
 448
 449     case 0x02:  /* DAC Control */
 450         if ((s->model & 0xff00) == 0x2300)
 451             return s->dac_power & 0x8000;
 452         else
 453             goto bad_reg;
 454
 455     case 0x03:  /* Reference */
 456         return s->ref;
 457
 458     case 0x04:  /* Reset */
 459         return 0xffff;
 460
 461     case 0x05:  /* Configuration */
 462         return s->timing;
 463
 464     case 0x06:  /* Secondary configuration */
 465         if ((s->model & 0xff00) == 0x2100)
 466             goto bad_reg;
 467         return ((!s->dav) << 15) | ((s->kb.mode & 1) << 14) | s->pll[2];
 468
 469     case 0x10:  /* Keypad Mask */
 470         if ((s->model & 0xff00) == 0x2100)
 471             goto bad_reg;
 472         return s->kb.mask;
 473
 474     default:
 475     bad_reg:
 476 #ifdef TSC_VERBOSE
 477         fprintf(stderr, "tsc2102_control_register_read: "
 478                         "no such register: 0x%02x\n", reg);
 479 #endif
 480         return 0xffff;
 481     }
 482 }
 483
 484 static uint16_t tsc2102_audio_register_read(TSC210xState *s, int reg)
 485 {
 486     int l_ch, r_ch;
 487     uint16_t val;
 488
 489     switch (reg) {
 490     case 0x00:  /* Audio Control 1 */
 491         return s->audio_ctrl1;
 492
 493     case 0x01:
 494         return 0xff00;
 495
 496     case 0x02:  /* DAC Volume Control */
 497         return s->volume;
 498
 499     case 0x03:
 500         return 0x8b00;
 501
 502     case 0x04:  /* Audio Control 2 */
 503         l_ch = 1;
 504         r_ch = 1;
 505         if (s->softstep && !(s->dac_power & (1 << 10))) {
 506             l_ch = (qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) >
 507                             s->volume_change + TSC_SOFTSTEP_DELAY);
 508             r_ch = (qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) >
 509                             s->volume_change + TSC_SOFTSTEP_DELAY);
 510         }
 511
 512         return s->audio_ctrl2 | (l_ch << 3) | (r_ch << 2);
 513
 514     case 0x05:  /* Stereo DAC Power Control */
 515         return 0x2aa0 | s->dac_power |
 516                 (((s->dac_power & (1 << 10)) &&
 517                   (qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) >
 518                    s->powerdown + TSC_POWEROFF_DELAY)) << 6);
 519
 520     case 0x06:  /* Audio Control 3 */
 521         val = s->audio_ctrl3 | 0x0001;
 522         s->audio_ctrl3 &= 0xff3f;
 523         return val;
 524
 525     case 0x07:  /* LCH_BASS_BOOST_N0 */
 526     case 0x08:  /* LCH_BASS_BOOST_N1 */
 527     case 0x09:  /* LCH_BASS_BOOST_N2 */
 528     case 0x0a:  /* LCH_BASS_BOOST_N3 */
 529     case 0x0b:  /* LCH_BASS_BOOST_N4 */
 530     case 0x0c:  /* LCH_BASS_BOOST_N5 */
 531     case 0x0d:  /* LCH_BASS_BOOST_D1 */
 532     case 0x0e:  /* LCH_BASS_BOOST_D2 */
 533     case 0x0f:  /* LCH_BASS_BOOST_D4 */
 534     case 0x10:  /* LCH_BASS_BOOST_D5 */
 535     case 0x11:  /* RCH_BASS_BOOST_N0 */
 536     case 0x12:  /* RCH_BASS_BOOST_N1 */
 537     case 0x13:  /* RCH_BASS_BOOST_N2 */
 538     case 0x14:  /* RCH_BASS_BOOST_N3 */
 539     case 0x15:  /* RCH_BASS_BOOST_N4 */
 540     case 0x16:  /* RCH_BASS_BOOST_N5 */
 541     case 0x17:  /* RCH_BASS_BOOST_D1 */
 542     case 0x18:  /* RCH_BASS_BOOST_D2 */
 543     case 0x19:  /* RCH_BASS_BOOST_D4 */
 544     case 0x1a:  /* RCH_BASS_BOOST_D5 */
 545         return s->filter_data[reg - 0x07];
 546
 547     case 0x1b:  /* PLL Programmability 1 */
 548         return s->pll[0];
 549
 550     case 0x1c:  /* PLL Programmability 2 */
 551         return s->pll[1];
 552
 553     case 0x1d:  /* Audio Control 4 */
 554         return (!s->softstep) << 14;
 555
 556     default:
 557 #ifdef TSC_VERBOSE
 558         fprintf(stderr, "tsc2102_audio_register_read: "
 559                         "no such register: 0x%02x\n", reg);
 560 #endif
 561         return 0xffff;
 562     }
 563 }
 564
 565 static void tsc2102_data_register_write(
 566                 TSC210xState *s, int reg, uint16_t value)
 567 {
 568     switch (reg) {
 569     case 0x00:  /* X */
 570     case 0x01:  /* Y */
 571     case 0x02:  /* Z1 */
 572     case 0x03:  /* Z2 */
 573     case 0x05:  /* BAT1 */
 574     case 0x06:  /* BAT2 */
 575     case 0x07:  /* AUX1 */
 576     case 0x08:  /* AUX2 */
 577     case 0x09:  /* TEMP1 */
 578     case 0x0a:  /* TEMP2 */
 579         return;
 580
 581     default:
 582 #ifdef TSC_VERBOSE
 583         fprintf(stderr, "tsc2102_data_register_write: "
 584                         "no such register: 0x%02x\n", reg);
 585 #endif
 586     }
 587 }
 588
 589 static void tsc2102_control_register_write(
 590                 TSC210xState *s, int reg, uint16_t value)
 591 {
 592     switch (reg) {
 593     case 0x00:  /* TSC ADC */
 594         s->host_mode = value >> 15;
 595         s->enabled = !(value & 0x4000);
 596         if (s->busy && !s->enabled)
 597             timer_del(s->timer);
 598         s->busy &= s->enabled;
 599         s->nextfunction = (value >> 10) & 0xf;
 600         s->nextprecision = (value >> 8) & 3;
 601         s->filter = value & 0xff;
 602         return;
 603
 604     case 0x01:  /* Status / Keypad Control */
 605         if ((s->model & 0xff00) == 0x2100)
 606             s->pin_func = value >> 14;
 607         else {
 608             s->kb.scan = (value >> 14) & 1;
 609             s->kb.debounce = (value >> 11) & 7;
 610             if (s->kb.intr && s->kb.scan) {
 611                 s->kb.intr = 0;
 612                 qemu_irq_raise(s->kbint);
 613             }
 614         }
 615         return;
 616
 617     case 0x02:  /* DAC Control */
 618         if ((s->model & 0xff00) == 0x2300) {
 619             s->dac_power &= 0x7fff;
 620             s->dac_power |= 0x8000 & value;
 621         } else
 622             goto bad_reg;
 623         break;
 624
 625     case 0x03:  /* Reference */
 626         s->ref = value & 0x1f;
 627         return;
 628
 629     case 0x04:  /* Reset */
 630         if (value == 0xbb00) {
 631             if (s->busy)
 632                 timer_del(s->timer);
 633             tsc210x_reset(s);
 634 #ifdef TSC_VERBOSE
 635         } else {
 636             fprintf(stderr, "tsc2102_control_register_write: "
 637                             "wrong value written into RESET\n");
 638 #endif
 639         }
 640         return;
 641
 642     case 0x05:  /* Configuration */
 643         s->timing = value & 0x3f;
 644 #ifdef TSC_VERBOSE
 645         if (value & ~0x3f)
 646             fprintf(stderr, "tsc2102_control_register_write: "
 647                             "wrong value written into CONFIG\n");
 648 #endif
 649         return;
 650
 651     case 0x06:  /* Secondary configuration */
 652         if ((s->model & 0xff00) == 0x2100)
 653             goto bad_reg;
 654         s->kb.mode = value >> 14;
 655         s->pll[2] = value & 0x3ffff;
 656         return;
 657
 658     case 0x10:  /* Keypad Mask */
 659         if ((s->model & 0xff00) == 0x2100)
 660             goto bad_reg;
 661         s->kb.mask = value;
 662         return;
 663
 664     default:
 665     bad_reg:
 666 #ifdef TSC_VERBOSE
 667         fprintf(stderr, "tsc2102_control_register_write: "
 668                         "no such register: 0x%02x\n", reg);
 669 #endif
 670     }
 671 }
 672
 673 static void tsc2102_audio_register_write(
 674                 TSC210xState *s, int reg, uint16_t value)
 675 {
 676     switch (reg) {
 677     case 0x00:  /* Audio Control 1 */
 678         s->audio_ctrl1 = value & 0x0f3f;
 679 #ifdef TSC_VERBOSE
 680         if ((value & ~0x0f3f) || ((value & 7) != ((value >> 3) & 7)))
 681             fprintf(stderr, "tsc2102_audio_register_write: "
 682                             "wrong value written into Audio 1\n");
 683 #endif
 684         tsc2102_audio_rate_update(s);
 685         tsc2102_audio_output_update(s);
 686         return;
 687
 688     case 0x01:
 689 #ifdef TSC_VERBOSE
 690         if (value != 0xff00)
 691             fprintf(stderr, "tsc2102_audio_register_write: "
 692                             "wrong value written into reg 0x01\n");
 693 #endif
 694         return;
 695
 696     case 0x02:  /* DAC Volume Control */
 697         s->volume = value;
 698         s->volume_change = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
 699         return;
 700
 701     case 0x03:
 702 #ifdef TSC_VERBOSE
 703         if (value != 0x8b00)
 704             fprintf(stderr, "tsc2102_audio_register_write: "
 705                             "wrong value written into reg 0x03\n");
 706 #endif
 707         return;
 708
 709     case 0x04:  /* Audio Control 2 */
 710         s->audio_ctrl2 = value & 0xf7f2;
 711 #ifdef TSC_VERBOSE
 712         if (value & ~0xf7fd)
 713             fprintf(stderr, "tsc2102_audio_register_write: "
 714                             "wrong value written into Audio 2\n");
 715 #endif
 716         return;
 717
 718     case 0x05:  /* Stereo DAC Power Control */
 719         if ((value & ~s->dac_power) & (1 << 10))
 720             s->powerdown = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
 721
 722         s->dac_power = value & 0x9543;
 723 #ifdef TSC_VERBOSE
 724         if ((value & ~0x9543) != 0x2aa0)
 725             fprintf(stderr, "tsc2102_audio_register_write: "
 726                             "wrong value written into Power\n");
 727 #endif
 728         tsc2102_audio_rate_update(s);
 729         tsc2102_audio_output_update(s);
 730         return;
 731
 732     case 0x06:  /* Audio Control 3 */
 733         s->audio_ctrl3 &= 0x00c0;
 734         s->audio_ctrl3 |= value & 0xf800;
 735 #ifdef TSC_VERBOSE
 736         if (value & ~0xf8c7)
 737             fprintf(stderr, "tsc2102_audio_register_write: "
 738                             "wrong value written into Audio 3\n");
 739 #endif
 740         tsc2102_audio_output_update(s);
 741         return;
 742
 743     case 0x07:  /* LCH_BASS_BOOST_N0 */
 744     case 0x08:  /* LCH_BASS_BOOST_N1 */
 745     case 0x09:  /* LCH_BASS_BOOST_N2 */
 746     case 0x0a:  /* LCH_BASS_BOOST_N3 */
 747     case 0x0b:  /* LCH_BASS_BOOST_N4 */
 748     case 0x0c:  /* LCH_BASS_BOOST_N5 */
 749     case 0x0d:  /* LCH_BASS_BOOST_D1 */
 750     case 0x0e:  /* LCH_BASS_BOOST_D2 */
 751     case 0x0f:  /* LCH_BASS_BOOST_D4 */
 752     case 0x10:  /* LCH_BASS_BOOST_D5 */
 753     case 0x11:  /* RCH_BASS_BOOST_N0 */
 754     case 0x12:  /* RCH_BASS_BOOST_N1 */
 755     case 0x13:  /* RCH_BASS_BOOST_N2 */
 756     case 0x14:  /* RCH_BASS_BOOST_N3 */
 757     case 0x15:  /* RCH_BASS_BOOST_N4 */
 758     case 0x16:  /* RCH_BASS_BOOST_N5 */
 759     case 0x17:  /* RCH_BASS_BOOST_D1 */
 760     case 0x18:  /* RCH_BASS_BOOST_D2 */
 761     case 0x19:  /* RCH_BASS_BOOST_D4 */
 762     case 0x1a:  /* RCH_BASS_BOOST_D5 */
 763         s->filter_data[reg - 0x07] = value;
 764         return;
 765
 766     case 0x1b:  /* PLL Programmability 1 */
 767         s->pll[0] = value & 0xfffc;
 768 #ifdef TSC_VERBOSE
 769         if (value & ~0xfffc)
 770             fprintf(stderr, "tsc2102_audio_register_write: "
 771                             "wrong value written into PLL 1\n");
 772 #endif
 773         return;
 774
 775     case 0x1c:  /* PLL Programmability 2 */
 776         s->pll[1] = value & 0xfffc;
 777 #ifdef TSC_VERBOSE
 778         if (value & ~0xfffc)
 779             fprintf(stderr, "tsc2102_audio_register_write: "
 780                             "wrong value written into PLL 2\n");
 781 #endif
 782         return;
 783
 784     case 0x1d:  /* Audio Control 4 */
 785         s->softstep = !(value & 0x4000);
 786 #ifdef TSC_VERBOSE
 787         if (value & ~0x4000)
 788             fprintf(stderr, "tsc2102_audio_register_write: "
 789                             "wrong value written into Audio 4\n");
 790 #endif
 791         return;
 792
 793     default:
 794 #ifdef TSC_VERBOSE
 795         fprintf(stderr, "tsc2102_audio_register_write: "
 796                         "no such register: 0x%02x\n", reg);
 797 #endif
 798     }
 799 }
 800
 801 /* This handles most of the chip logic.  */
 802 static void tsc210x_pin_update(TSC210xState *s)
 803 {
 804     int64_t expires;
 805     int pin_state;
 806
 807     switch (s->pin_func) {
 808     case 0:
 809         pin_state = s->pressure;
 810         break;
 811     case 1:
 812         pin_state = !!s->dav;
 813         break;
 814     case 2:
 815     default:
 816         pin_state = s->pressure && !s->dav;
 817     }
 818
 819     if (!s->enabled)
 820         pin_state = 0;
 821
 822     if (pin_state != s->irq) {
 823         s->irq = pin_state;
 824         qemu_set_irq(s->pint, !s->irq);
 825     }
 826
 827     switch (s->nextfunction) {
 828     case TSC_MODE_XY_SCAN:
 829     case TSC_MODE_XYZ_SCAN:
 830         if (!s->pressure)
 831             return;
 832         break;
 833
 834     case TSC_MODE_X:
 835     case TSC_MODE_Y:
 836     case TSC_MODE_Z:
 837         if (!s->pressure)
 838             return;
 839         /* Fall through */
 840     case TSC_MODE_BAT1:
 841     case TSC_MODE_BAT2:
 842     case TSC_MODE_AUX:
 843     case TSC_MODE_TEMP1:
 844     case TSC_MODE_TEMP2:
 845         if (s->dav)
 846             s->enabled = 0;
 847         break;
 848
 849     case TSC_MODE_AUX_SCAN:
 850     case TSC_MODE_PORT_SCAN:
 851         break;
 852
 853     case TSC_MODE_NO_SCAN:
 854     case TSC_MODE_XX_DRV:
 855     case TSC_MODE_YY_DRV:
 856     case TSC_MODE_YX_DRV:
 857     default:
 858         return;
 859     }
 860
 861     if (!s->enabled || s->busy || s->dav)
 862         return;
 863
 864     s->busy = 1;
 865     s->precision = s->nextprecision;
 866     s->function = s->nextfunction;
 867     expires = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + (get_ticks_per_sec() >> 10);
 868     timer_mod(s->timer, expires);
 869 }
 870
 871 static uint16_t tsc210x_read(TSC210xState *s)
 872 {
 873     uint16_t ret = 0x0000;
 874
 875     if (!s->command)
 876         fprintf(stderr, "tsc210x_read: SPI underrun!\n");
 877
 878     switch (s->page) {
 879     case TSC_DATA_REGISTERS_PAGE:
 880         ret = tsc2102_data_register_read(s, s->offset);
 881         if (!s->dav)
 882             qemu_irq_raise(s->davint);
 883         break;
 884     case TSC_CONTROL_REGISTERS_PAGE:
 885         ret = tsc2102_control_register_read(s, s->offset);
 886         break;
 887     case TSC_AUDIO_REGISTERS_PAGE:
 888         ret = tsc2102_audio_register_read(s, s->offset);
 889         break;
 890     default:
 891         hw_error("tsc210x_read: wrong memory page\n");
 892     }
 893
 894     tsc210x_pin_update(s);
 895
 896     /* Allow sequential reads.  */
 897     s->offset ++;
 898     s->state = 0;
 899     return ret;
 900 }
 901
 902 static void tsc210x_write(TSC210xState *s, uint16_t value)
 903 {
 904     /*
 905      * This is a two-state state machine for reading
 906      * command and data every second time.
 907      */
 908     if (!s->state) {
 909         s->command = value >> 15;
 910         s->page = (value >> 11) & 0x0f;
 911         s->offset = (value >> 5) & 0x3f;
 912         s->state = 1;
 913     } else {
 914         if (s->command)
 915             fprintf(stderr, "tsc210x_write: SPI overrun!\n");
 916         else
 917             switch (s->page) {
 918             case TSC_DATA_REGISTERS_PAGE:
 919                 tsc2102_data_register_write(s, s->offset, value);
 920                 break;
 921             case TSC_CONTROL_REGISTERS_PAGE:
 922                 tsc2102_control_register_write(s, s->offset, value);
 923                 break;
 924             case TSC_AUDIO_REGISTERS_PAGE:
 925                 tsc2102_audio_register_write(s, s->offset, value);
 926                 break;
 927             default:
 928                 hw_error("tsc210x_write: wrong memory page\n");
 929             }
 930
 931         tsc210x_pin_update(s);
 932         s->state = 0;
 933     }
 934 }
 935
 936 uint32_t tsc210x_txrx(void *opaque, uint32_t value, int len)
 937 {
 938     TSC210xState *s = opaque;
 939     uint32_t ret = 0;
 940
 941     if (len != 16)
 942         hw_error("%s: FIXME: bad SPI word width %i\n", __FUNCTION__, len);
 943
 944     /* TODO: sequential reads etc - how do we make sure the host doesn't
 945      * unintentionally read out a conversion result from a register while
 946      * transmitting the command word of the next command?  */
 947     if (!value || (s->state && s->command))
 948         ret = tsc210x_read(s);
 949     if (value || (s->state && !s->command))
 950         tsc210x_write(s, value);
 951
 952     return ret;
 953 }
 954
 955 static void tsc210x_timer_tick(void *opaque)
 956 {
 957     TSC210xState *s = opaque;
 958
 959     /* Timer ticked -- a set of conversions has been finished.  */
 960
 961     if (!s->busy)
 962         return;
 963
 964     s->busy = 0;
 965     s->dav |= mode_regs[s->function];
 966     tsc210x_pin_update(s);
 967     qemu_irq_lower(s->davint);
 968 }
 969
 970 static void tsc210x_touchscreen_event(void *opaque,
 971                 int x, int y, int z, int buttons_state)
 972 {
 973     TSC210xState *s = opaque;
 974     int p = s->pressure;
 975
 976     if (buttons_state) {
 977         s->x = x;
 978         s->y = y;
 979     }
 980     s->pressure = !!buttons_state;
 981
 982     /*
 983      * Note: We would get better responsiveness in the guest by
 984      * signaling TS events immediately, but for now we simulate
 985      * the first conversion delay for sake of correctness.
 986      */
 987     if (p != s->pressure)
 988         tsc210x_pin_update(s);
 989 }
 990
 991 static void tsc210x_i2s_swallow(TSC210xState *s)
 992 {
 993     if (s->dac_voice[0])
 994         tsc210x_out_flush(s, s->codec.out.len);
 995     else
 996         s->codec.out.len = 0;
 997 }
 998
 999 static void tsc210x_i2s_set_rate(TSC210xState *s, int in, int out)
1000 {
1001     s->i2s_tx_rate = out;
1002     s->i2s_rx_rate = in;
1003 }
1004
1005 static void tsc210x_save(QEMUFile *f, void *opaque)
1006 {
1007     TSC210xState *s = (TSC210xState *) opaque;
1008     int64_t now = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
1009     int i;
1010
1011     qemu_put_be16(f, s->x);
1012     qemu_put_be16(f, s->y);
1013     qemu_put_byte(f, s->pressure);
1014
1015     qemu_put_byte(f, s->state);
1016     qemu_put_byte(f, s->page);
1017     qemu_put_byte(f, s->offset);
1018     qemu_put_byte(f, s->command);
1019
1020     qemu_put_byte(f, s->irq);
1021     qemu_put_be16s(f, &s->dav);
1022
1023     timer_put(f, s->timer);
1024     qemu_put_byte(f, s->enabled);
1025     qemu_put_byte(f, s->host_mode);
1026     qemu_put_byte(f, s->function);
1027     qemu_put_byte(f, s->nextfunction);
1028     qemu_put_byte(f, s->precision);
1029     qemu_put_byte(f, s->nextprecision);
1030     qemu_put_byte(f, s->filter);
1031     qemu_put_byte(f, s->pin_func);
1032     qemu_put_byte(f, s->ref);
1033     qemu_put_byte(f, s->timing);
1034     qemu_put_be32(f, s->noise);
1035
1036     qemu_put_be16s(f, &s->audio_ctrl1);
1037     qemu_put_be16s(f, &s->audio_ctrl2);
1038     qemu_put_be16s(f, &s->audio_ctrl3);
1039     qemu_put_be16s(f, &s->pll[0]);
1040     qemu_put_be16s(f, &s->pll[1]);
1041     qemu_put_be16s(f, &s->volume);
1042     qemu_put_sbe64(f, (s->volume_change - now));
1043     qemu_put_sbe64(f, (s->powerdown - now));
1044     qemu_put_byte(f, s->softstep);
1045     qemu_put_be16s(f, &s->dac_power);
1046
1047     for (i = 0; i < 0x14; i ++)
1048         qemu_put_be16s(f, &s->filter_data[i]);
1049 }
1050
1051 static int tsc210x_load(QEMUFile *f, void *opaque, int version_id)
1052 {
1053     TSC210xState *s = (TSC210xState *) opaque;
1054     int64_t now = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
1055     int i;
1056
1057     s->x = qemu_get_be16(f);
1058     s->y = qemu_get_be16(f);
1059     s->pressure = qemu_get_byte(f);
1060
1061     s->state = qemu_get_byte(f);
1062     s->page = qemu_get_byte(f);
1063     s->offset = qemu_get_byte(f);
1064     s->command = qemu_get_byte(f);
1065
1066     s->irq = qemu_get_byte(f);
1067     qemu_get_be16s(f, &s->dav);
1068
1069     timer_get(f, s->timer);
1070     s->enabled = qemu_get_byte(f);
1071     s->host_mode = qemu_get_byte(f);
1072     s->function = qemu_get_byte(f);
1073     if (s->function < 0 || s->function >= ARRAY_SIZE(mode_regs)) {
1074         return -EINVAL;
1075     }
1076     s->nextfunction = qemu_get_byte(f);
1077     if (s->nextfunction < 0 || s->nextfunction >= ARRAY_SIZE(mode_regs)) {
1078         return -EINVAL;
1079     }
1080     s->precision = qemu_get_byte(f);
1081     if (s->precision < 0 || s->precision >= ARRAY_SIZE(resolution)) {
1082         return -EINVAL;
1083     }
1084     s->nextprecision = qemu_get_byte(f);
1085     if (s->nextprecision < 0 || s->nextprecision >= ARRAY_SIZE(resolution)) {
1086         return -EINVAL;
1087     }
1088     s->filter = qemu_get_byte(f);
1089     s->pin_func = qemu_get_byte(f);
1090     s->ref = qemu_get_byte(f);
1091     s->timing = qemu_get_byte(f);
1092     s->noise = qemu_get_be32(f);
1093
1094     qemu_get_be16s(f, &s->audio_ctrl1);
1095     qemu_get_be16s(f, &s->audio_ctrl2);
1096     qemu_get_be16s(f, &s->audio_ctrl3);
1097     qemu_get_be16s(f, &s->pll[0]);
1098     qemu_get_be16s(f, &s->pll[1]);
1099     qemu_get_be16s(f, &s->volume);
1100     s->volume_change = qemu_get_sbe64(f) + now;
1101     s->powerdown = qemu_get_sbe64(f) + now;
1102     s->softstep = qemu_get_byte(f);
1103     qemu_get_be16s(f, &s->dac_power);
1104
1105     for (i = 0; i < 0x14; i ++)
1106         qemu_get_be16s(f, &s->filter_data[i]);
1107
1108     s->busy = timer_pending(s->timer);
1109     qemu_set_irq(s->pint, !s->irq);
1110     qemu_set_irq(s->davint, !s->dav);
1111
1112     return 0;
1113 }
1114
1115 uWireSlave *tsc2102_init(qemu_irq pint)
1116 {
1117     TSC210xState *s;
1118
1119     s = (TSC210xState *)
1120             g_malloc0(sizeof(TSC210xState));
1121     memset(s, 0, sizeof(TSC210xState));
1122     s->x = 160;
1123     s->y = 160;
1124     s->pressure = 0;
1125     s->precision = s->nextprecision = 0;
1126     s->timer = timer_new_ns(QEMU_CLOCK_VIRTUAL, tsc210x_timer_tick, s);
1127     s->pint = pint;
1128     s->model = 0x2102;
1129     s->name = "tsc2102";
1130
1131     s->tr[0] = 0;
1132     s->tr[1] = 1;
1133     s->tr[2] = 1;
1134     s->tr[3] = 0;
1135     s->tr[4] = 1;
1136     s->tr[5] = 0;
1137     s->tr[6] = 1;
1138     s->tr[7] = 0;
1139
1140     s->chip.opaque = s;
1141     s->chip.send = (void *) tsc210x_write;
1142     s->chip.receive = (void *) tsc210x_read;
1143
1144     s->codec.opaque = s;
1145     s->codec.tx_swallow = (void *) tsc210x_i2s_swallow;
1146     s->codec.set_rate = (void *) tsc210x_i2s_set_rate;
1147     s->codec.in.fifo = s->in_fifo;
1148     s->codec.out.fifo = s->out_fifo;
1149
1150     tsc210x_reset(s);
1151
1152     qemu_add_mouse_event_handler(tsc210x_touchscreen_event, s, 1,
1153                     "QEMU TSC2102-driven Touchscreen");
1154
1155     AUD_register_card(s->name, &s->card);
1156
1157     qemu_register_reset((void *) tsc210x_reset, s);
1158     register_savevm(NULL, s->name, -1, 0,
1159                     tsc210x_save, tsc210x_load, s);
1160
1161     return &s->chip;
1162 }
1163
1164 uWireSlave *tsc2301_init(qemu_irq penirq, qemu_irq kbirq, qemu_irq dav)
1165 {
1166     TSC210xState *s;
1167
1168     s = (TSC210xState *)
1169             g_malloc0(sizeof(TSC210xState));
1170     memset(s, 0, sizeof(TSC210xState));
1171     s->x = 400;
1172     s->y = 240;
1173     s->pressure = 0;
1174     s->precision = s->nextprecision = 0;
1175     s->timer = timer_new_ns(QEMU_CLOCK_VIRTUAL, tsc210x_timer_tick, s);
1176     s->pint = penirq;
1177     s->kbint = kbirq;
1178     s->davint = dav;
1179     s->model = 0x2301;
1180     s->name = "tsc2301";
1181
1182     s->tr[0] = 0;
1183     s->tr[1] = 1;
1184     s->tr[2] = 1;
1185     s->tr[3] = 0;
1186     s->tr[4] = 1;
1187     s->tr[5] = 0;
1188     s->tr[6] = 1;
1189     s->tr[7] = 0;
1190
1191     s->chip.opaque = s;
1192     s->chip.send = (void *) tsc210x_write;
1193     s->chip.receive = (void *) tsc210x_read;
1194
1195     s->codec.opaque = s;
1196     s->codec.tx_swallow = (void *) tsc210x_i2s_swallow;
1197     s->codec.set_rate = (void *) tsc210x_i2s_set_rate;
1198     s->codec.in.fifo = s->in_fifo;
1199     s->codec.out.fifo = s->out_fifo;
1200
1201     tsc210x_reset(s);
1202
1203     qemu_add_mouse_event_handler(tsc210x_touchscreen_event, s, 1,
1204                     "QEMU TSC2301-driven Touchscreen");
1205
1206     AUD_register_card(s->name, &s->card);
1207
1208     qemu_register_reset((void *) tsc210x_reset, s);
1209     register_savevm(NULL, s->name, -1, 0, tsc210x_save, tsc210x_load, s);
1210
1211     return &s->chip;
1212 }
1213
1214 I2SCodec *tsc210x_codec(uWireSlave *chip)
1215 {
1216     TSC210xState *s = (TSC210xState *) chip->opaque;
1217
1218     return &s->codec;
1219 }
1220
1221 /*
1222  * Use tslib generated calibration data to generate ADC input values
1223  * from the touchscreen.  Assuming 12-bit precision was used during
1224  * tslib calibration.
1225  */
1226 void tsc210x_set_transform(uWireSlave *chip,
1227                 MouseTransformInfo *info)
1228 {
1229     TSC210xState *s = (TSC210xState *) chip->opaque;
1230 #if 0
1231     int64_t ltr[8];
1232
1233     ltr[0] = (int64_t) info->a[1] * info->y;
1234     ltr[1] = (int64_t) info->a[4] * info->x;
1235     ltr[2] = (int64_t) info->a[1] * info->a[3] -
1236             (int64_t) info->a[4] * info->a[0];
1237     ltr[3] = (int64_t) info->a[2] * info->a[4] -
1238             (int64_t) info->a[5] * info->a[1];
1239     ltr[4] = (int64_t) info->a[0] * info->y;
1240     ltr[5] = (int64_t) info->a[3] * info->x;
1241     ltr[6] = (int64_t) info->a[4] * info->a[0] -
1242             (int64_t) info->a[1] * info->a[3];
1243     ltr[7] = (int64_t) info->a[2] * info->a[3] -
1244             (int64_t) info->a[5] * info->a[0];
1245
1246     /* Avoid integer overflow */
1247     s->tr[0] = ltr[0] >> 11;
1248     s->tr[1] = ltr[1] >> 11;
1249     s->tr[2] = muldiv64(ltr[2], 1, info->a[6]);
1250     s->tr[3] = muldiv64(ltr[3], 1 << 4, ltr[2]);
1251     s->tr[4] = ltr[4] >> 11;
1252     s->tr[5] = ltr[5] >> 11;
1253     s->tr[6] = muldiv64(ltr[6], 1, info->a[6]);
1254     s->tr[7] = muldiv64(ltr[7], 1 << 4, ltr[6]);
1255 #else
1256
1257     /* This version assumes touchscreen X & Y axis are parallel or
1258      * perpendicular to LCD's  X & Y axis in some way.  */
1259     if (abs(info->a[0]) > abs(info->a[1])) {
1260         s->tr[0] = 0;
1261         s->tr[1] = -info->a[6] * info->x;
1262         s->tr[2] = info->a[0];
1263         s->tr[3] = -info->a[2] / info->a[0];
1264         s->tr[4] = info->a[6] * info->y;
1265         s->tr[5] = 0;
1266         s->tr[6] = info->a[4];
1267         s->tr[7] = -info->a[5] / info->a[4];
1268     } else {
1269         s->tr[0] = info->a[6] * info->y;
1270         s->tr[1] = 0;
1271         s->tr[2] = info->a[1];
1272         s->tr[3] = -info->a[2] / info->a[1];
1273         s->tr[4] = 0;
1274         s->tr[5] = -info->a[6] * info->x;
1275         s->tr[6] = info->a[3];
1276         s->tr[7] = -info->a[5] / info->a[3];
1277     }
1278
1279     s->tr[0] >>= 11;
1280     s->tr[1] >>= 11;
1281     s->tr[3] <<= 4;
1282     s->tr[4] >>= 11;
1283     s->tr[5] >>= 11;
1284     s->tr[7] <<= 4;
1285 #endif
1286 }
1287
1288 void tsc210x_key_event(uWireSlave *chip, int key, int down)
1289 {
1290     TSC210xState *s = (TSC210xState *) chip->opaque;
1291
1292     if (down)
1293         s->kb.down |= 1 << key;
1294     else
1295         s->kb.down &= ~(1 << key);
1296
1297     if (down && (s->kb.down & ~s->kb.mask) && !s->kb.intr) {
1298         s->kb.intr = 1;
1299         qemu_irq_lower(s->kbint);
1300     } else if (s->kb.intr && !(s->kb.down & ~s->kb.mask) &&
1301                     !(s->kb.mode & 1)) {
1302         s->kb.intr = 0;
1303         qemu_irq_raise(s->kbint);
1304     }
1305 }