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