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