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