qemu

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 "qemu/log.h"
27
#include "sysemu/reset.h"
28
#include "ui/console.h"
29
#include "hw/arm/omap.h"            /* For I2SCodec */
30
#include "hw/boards.h"              /* for current_machine */
31
#include "hw/input/tsc2xxx.h"
32
#include "hw/irq.h"
33
#include "migration/vmstate.h"
34
#include "qapi/error.h"
35

36
#define TSC_DATA_REGISTERS_PAGE		0x0
37
#define TSC_CONTROL_REGISTERS_PAGE	0x1
38
#define TSC_AUDIO_REGISTERS_PAGE	0x2
39

40
#define TSC_VERBOSE
41

42
#define TSC_CUT_RESOLUTION(value, p)	((value) >> (16 - resolution[p]))
43

44
typedef struct {
45
    qemu_irq pint;
46
    qemu_irq kbint;
47
    qemu_irq davint;
48
    QEMUTimer *timer;
49
    QEMUSoundCard card;
50
    uWireSlave chip;
51
    I2SCodec codec;
52
    uint8_t in_fifo[16384];
53
    uint8_t out_fifo[16384];
54
    uint16_t model;
55

56
    int32_t x, y;
57
    bool pressure;
58

59
    uint8_t page, offset;
60
    uint16_t dav;
61

62
    bool state;
63
    bool irq;
64
    bool command;
65
    bool busy;
66
    bool enabled;
67
    bool host_mode;
68
    uint8_t function, nextfunction;
69
    uint8_t precision, nextprecision;
70
    uint8_t filter;
71
    uint8_t pin_func;
72
    uint8_t ref;
73
    uint8_t timing;
74
    uint8_t noise;
75

76
    uint16_t audio_ctrl1;
77
    uint16_t audio_ctrl2;
78
    uint16_t audio_ctrl3;
79
    uint16_t pll[3];
80
    uint16_t volume;
81
    int64_t volume_change;
82
    bool softstep;
83
    uint16_t dac_power;
84
    int64_t powerdown;
85
    uint16_t filter_data[0x14];
86

87
    const char *name;
88
    SWVoiceIn *adc_voice[1];
89
    SWVoiceOut *dac_voice[1];
90
    int i2s_rx_rate;
91
    int i2s_tx_rate;
92

93
    int tr[8];
94

95
    struct {
96
        uint16_t down;
97
        uint16_t mask;
98
        int scan;
99
        int debounce;
100
        int mode;
101
        int intr;
102
    } kb;
103
    int64_t now; /* Time at migration */
104
} TSC210xState;
105

106
static const int resolution[4] = { 12, 8, 10, 12 };
107

108
#define TSC_MODE_NO_SCAN	0x0
109
#define TSC_MODE_XY_SCAN	0x1
110
#define TSC_MODE_XYZ_SCAN	0x2
111
#define TSC_MODE_X		0x3
112
#define TSC_MODE_Y		0x4
113
#define TSC_MODE_Z		0x5
114
#define TSC_MODE_BAT1		0x6
115
#define TSC_MODE_BAT2		0x7
116
#define TSC_MODE_AUX		0x8
117
#define TSC_MODE_AUX_SCAN	0x9
118
#define TSC_MODE_TEMP1		0xa
119
#define TSC_MODE_PORT_SCAN	0xb
120
#define TSC_MODE_TEMP2		0xc
121
#define TSC_MODE_XX_DRV		0xd
122
#define TSC_MODE_YY_DRV		0xe
123
#define TSC_MODE_YX_DRV		0xf
124

125
static const uint16_t mode_regs[16] = {
126
    0x0000,	/* No scan */
127
    0x0600,	/* X, Y scan */
128
    0x0780,	/* X, Y, Z scan */
129
    0x0400,	/* X */
130
    0x0200,	/* Y */
131
    0x0180,	/* Z */
132
    0x0040,	/* BAT1 */
133
    0x0030,	/* BAT2 */
134
    0x0010,	/* AUX */
135
    0x0010,	/* AUX scan */
136
    0x0004,	/* TEMP1 */
137
    0x0070,	/* Port scan */
138
    0x0002,	/* TEMP2 */
139
    0x0000,	/* X+, X- drivers */
140
    0x0000,	/* Y+, Y- drivers */
141
    0x0000,	/* Y+, X- drivers */
142
};
143

144
#define X_TRANSFORM(s)			\
145
    ((s->y * s->tr[0] - s->x * s->tr[1]) / s->tr[2] + s->tr[3])
146
#define Y_TRANSFORM(s)			\
147
    ((s->y * s->tr[4] - s->x * s->tr[5]) / s->tr[6] + s->tr[7])
148
#define Z1_TRANSFORM(s)			\
149
    ((400 - ((s)->x >> 7) + ((s)->pressure << 10)) << 4)
150
#define Z2_TRANSFORM(s)			\
151
    ((4000 + ((s)->y >> 7) - ((s)->pressure << 10)) << 4)
152

153
#define BAT1_VAL			0x8660
154
#define BAT2_VAL			0x0000
155
#define AUX1_VAL			0x35c0
156
#define AUX2_VAL			0xffff
157
#define TEMP1_VAL			0x8c70
158
#define TEMP2_VAL			0xa5b0
159

160
#define TSC_POWEROFF_DELAY		50
161
#define TSC_SOFTSTEP_DELAY		50
162

163
static void tsc210x_reset(TSC210xState *s)
164
{
165
    s->state = false;
166
    s->pin_func = 2;
167
    s->enabled = false;
168
    s->busy = false;
169
    s->nextfunction = 0;
170
    s->ref = 0;
171
    s->timing = 0;
172
    s->irq = false;
173
    s->dav = 0;
174

175
    s->audio_ctrl1 = 0x0000;
176
    s->audio_ctrl2 = 0x4410;
177
    s->audio_ctrl3 = 0x0000;
178
    s->pll[0] = 0x1004;
179
    s->pll[1] = 0x0000;
180
    s->pll[2] = 0x1fff;
181
    s->volume = 0xffff;
182
    s->dac_power = 0x8540;
183
    s->softstep = true;
184
    s->volume_change = 0;
185
    s->powerdown = 0;
186
    s->filter_data[0x00] = 0x6be3;
187
    s->filter_data[0x01] = 0x9666;
188
    s->filter_data[0x02] = 0x675d;
189
    s->filter_data[0x03] = 0x6be3;
190
    s->filter_data[0x04] = 0x9666;
191
    s->filter_data[0x05] = 0x675d;
192
    s->filter_data[0x06] = 0x7d83;
193
    s->filter_data[0x07] = 0x84ee;
194
    s->filter_data[0x08] = 0x7d83;
195
    s->filter_data[0x09] = 0x84ee;
196
    s->filter_data[0x0a] = 0x6be3;
197
    s->filter_data[0x0b] = 0x9666;
198
    s->filter_data[0x0c] = 0x675d;
199
    s->filter_data[0x0d] = 0x6be3;
200
    s->filter_data[0x0e] = 0x9666;
201
    s->filter_data[0x0f] = 0x675d;
202
    s->filter_data[0x10] = 0x7d83;
203
    s->filter_data[0x11] = 0x84ee;
204
    s->filter_data[0x12] = 0x7d83;
205
    s->filter_data[0x13] = 0x84ee;
206

207
    s->i2s_tx_rate = 0;
208
    s->i2s_rx_rate = 0;
209

210
    s->kb.scan = 1;
211
    s->kb.debounce = 0;
212
    s->kb.mask = 0x0000;
213
    s->kb.mode = 3;
214
    s->kb.intr = 0;
215

216
    qemu_set_irq(s->pint, !s->irq);
217
    qemu_set_irq(s->davint, !s->dav);
218
    qemu_irq_raise(s->kbint);
219
}
220

221
typedef struct {
222
    int rate;
223
    int dsor;
224
    int fsref;
225
} TSC210xRateInfo;
226

227
/*  { rate,   dsor, fsref }	*/
228
static const TSC210xRateInfo tsc2102_rates[] = {
229
    /* Fsref / 6.0 */
230
    { 7350,	63,	1 },
231
    { 8000,	63,	0 },
232
    /* Fsref / 6.0 */
233
    { 7350,	54,	1 },
234
    { 8000,	54,	0 },
235
    /* Fsref / 5.0 */
236
    { 8820,	45,	1 },
237
    { 9600,	45,	0 },
238
    /* Fsref / 4.0 */
239
    { 11025,	36,	1 },
240
    { 12000,	36,	0 },
241
    /* Fsref / 3.0 */
242
    { 14700,	27,	1 },
243
    { 16000,	27,	0 },
244
    /* Fsref / 2.0 */
245
    { 22050,	18,	1 },
246
    { 24000,	18,	0 },
247
    /* Fsref / 1.5 */
248
    { 29400,	9,	1 },
249
    { 32000,	9,	0 },
250
    /* Fsref */
251
    { 44100,	0,	1 },
252
    { 48000,	0,	0 },
253

254
    { 0,	0, 	0 },
255
};
256

257
static inline void tsc210x_out_flush(TSC210xState *s, int len)
258
{
259
    uint8_t *data = s->codec.out.fifo + s->codec.out.start;
260
    uint8_t *end = data + len;
261

262
    while (data < end)
263
        data += AUD_write(s->dac_voice[0], data, end - data) ?: (end - data);
264

265
    s->codec.out.len -= len;
266
    if (s->codec.out.len)
267
        memmove(s->codec.out.fifo, end, s->codec.out.len);
268
    s->codec.out.start = 0;
269
}
270

271
static void tsc210x_audio_out_cb(TSC210xState *s, int free_b)
272
{
273
    if (s->codec.out.len >= free_b) {
274
        tsc210x_out_flush(s, free_b);
275
        return;
276
    }
277

278
    s->codec.out.size = MIN(free_b, 16384);
279
    qemu_irq_raise(s->codec.tx_start);
280
}
281

282
static void tsc2102_audio_rate_update(TSC210xState *s)
283
{
284
    const TSC210xRateInfo *rate;
285

286
    s->codec.tx_rate = 0;
287
    s->codec.rx_rate = 0;
288
    if (s->dac_power & (1 << 15))				/* PWDNC */
289
        return;
290

291
    for (rate = tsc2102_rates; rate->rate; rate ++)
292
        if (rate->dsor == (s->audio_ctrl1 & 0x3f) &&		/* DACFS */
293
                        rate->fsref == ((s->audio_ctrl3 >> 13) & 1))/* REFFS */
294
            break;
295
    if (!rate->rate) {
296
        printf("%s: unknown sampling rate configured\n", __func__);
297
        return;
298
    }
299

300
    s->codec.tx_rate = rate->rate;
301
}
302

303
static void tsc2102_audio_output_update(TSC210xState *s)
304
{
305
    int enable;
306
    struct audsettings fmt;
307

308
    if (s->dac_voice[0]) {
309
        tsc210x_out_flush(s, s->codec.out.len);
310
        s->codec.out.size = 0;
311
        AUD_set_active_out(s->dac_voice[0], 0);
312
        AUD_close_out(&s->card, s->dac_voice[0]);
313
        s->dac_voice[0] = NULL;
314
    }
315
    s->codec.cts = 0;
316

317
    enable =
318
            (~s->dac_power & (1 << 15)) &&			/* PWDNC */
319
            (~s->dac_power & (1 << 10));			/* DAPWDN */
320
    if (!enable || !s->codec.tx_rate)
321
        return;
322

323
    /* Force our own sampling rate even in slave DAC mode */
324
    fmt.endianness = 0;
325
    fmt.nchannels = 2;
326
    fmt.freq = s->codec.tx_rate;
327
    fmt.fmt = AUDIO_FORMAT_S16;
328

329
    s->dac_voice[0] = AUD_open_out(&s->card, s->dac_voice[0],
330
                    "tsc2102.sink", s, (void *) tsc210x_audio_out_cb, &fmt);
331
    if (s->dac_voice[0]) {
332
        s->codec.cts = 1;
333
        AUD_set_active_out(s->dac_voice[0], 1);
334
    }
335
}
336

337
static uint16_t tsc2102_data_register_read(TSC210xState *s, int reg)
338
{
339
    switch (reg) {
340
    case 0x00:	/* X */
341
        s->dav &= 0xfbff;
342
        return TSC_CUT_RESOLUTION(X_TRANSFORM(s), s->precision) +
343
                (s->noise & 3);
344

345
    case 0x01:	/* Y */
346
        s->noise ++;
347
        s->dav &= 0xfdff;
348
        return TSC_CUT_RESOLUTION(Y_TRANSFORM(s), s->precision) ^
349
                (s->noise & 3);
350

351
    case 0x02:	/* Z1 */
352
        s->dav &= 0xfeff;
353
        return TSC_CUT_RESOLUTION(Z1_TRANSFORM(s), s->precision) -
354
                (s->noise & 3);
355

356
    case 0x03:	/* Z2 */
357
        s->dav &= 0xff7f;
358
        return TSC_CUT_RESOLUTION(Z2_TRANSFORM(s), s->precision) |
359
                (s->noise & 3);
360

361
    case 0x04:	/* KPData */
362
        if ((s->model & 0xff00) == 0x2300) {
363
            if (s->kb.intr && (s->kb.mode & 2)) {
364
                s->kb.intr = 0;
365
                qemu_irq_raise(s->kbint);
366
            }
367
            return s->kb.down;
368
        }
369

370
        return 0xffff;
371

372
    case 0x05:	/* BAT1 */
373
        s->dav &= 0xffbf;
374
        return TSC_CUT_RESOLUTION(BAT1_VAL, s->precision) +
375
                (s->noise & 6);
376

377
    case 0x06:	/* BAT2 */
378
        s->dav &= 0xffdf;
379
        return TSC_CUT_RESOLUTION(BAT2_VAL, s->precision);
380

381
    case 0x07:	/* AUX1 */
382
        s->dav &= 0xffef;
383
        return TSC_CUT_RESOLUTION(AUX1_VAL, s->precision);
384

385
    case 0x08:	/* AUX2 */
386
        s->dav &= 0xfff7;
387
        return 0xffff;
388

389
    case 0x09:	/* TEMP1 */
390
        s->dav &= 0xfffb;
391
        return TSC_CUT_RESOLUTION(TEMP1_VAL, s->precision) -
392
                (s->noise & 5);
393

394
    case 0x0a:	/* TEMP2 */
395
        s->dav &= 0xfffd;
396
        return TSC_CUT_RESOLUTION(TEMP2_VAL, s->precision) ^
397
                (s->noise & 3);
398

399
    case 0x0b:	/* DAC */
400
        s->dav &= 0xfffe;
401
        return 0xffff;
402

403
    default:
404
#ifdef TSC_VERBOSE
405
        fprintf(stderr, "tsc2102_data_register_read: "
406
                        "no such register: 0x%02x\n", reg);
407
#endif
408
        return 0xffff;
409
    }
410
}
411

412
static uint16_t tsc2102_control_register_read(
413
                TSC210xState *s, int reg)
414
{
415
    switch (reg) {
416
    case 0x00:	/* TSC ADC */
417
        return (s->pressure << 15) | ((!s->busy) << 14) |
418
                (s->nextfunction << 10) | (s->nextprecision << 8) | s->filter; 
419

420
    case 0x01:	/* Status / Keypad Control */
421
        if ((s->model & 0xff00) == 0x2100)
422
            return (s->pin_func << 14) | ((!s->enabled) << 13) |
423
                    (s->host_mode << 12) | ((!!s->dav) << 11) | s->dav;
424
        else
425
            return (s->kb.intr << 15) | ((s->kb.scan || !s->kb.down) << 14) |
426
                    (s->kb.debounce << 11);
427

428
    case 0x02:	/* DAC Control */
429
        if ((s->model & 0xff00) == 0x2300)
430
            return s->dac_power & 0x8000;
431
        else
432
            goto bad_reg;
433

434
    case 0x03:	/* Reference */
435
        return s->ref;
436

437
    case 0x04:	/* Reset */
438
        return 0xffff;
439

440
    case 0x05:	/* Configuration */
441
        return s->timing;
442

443
    case 0x06:	/* Secondary configuration */
444
        if ((s->model & 0xff00) == 0x2100)
445
            goto bad_reg;
446
        return ((!s->dav) << 15) | ((s->kb.mode & 1) << 14) | s->pll[2];
447

448
    case 0x10:	/* Keypad Mask */
449
        if ((s->model & 0xff00) == 0x2100)
450
            goto bad_reg;
451
        return s->kb.mask;
452

453
    default:
454
    bad_reg:
455
#ifdef TSC_VERBOSE
456
        fprintf(stderr, "tsc2102_control_register_read: "
457
                        "no such register: 0x%02x\n", reg);
458
#endif
459
        return 0xffff;
460
    }
461
}
462

463
static uint16_t tsc2102_audio_register_read(TSC210xState *s, int reg)
464
{
465
    int l_ch, r_ch;
466
    uint16_t val;
467

468
    switch (reg) {
469
    case 0x00:	/* Audio Control 1 */
470
        return s->audio_ctrl1;
471

472
    case 0x01:
473
        return 0xff00;
474

475
    case 0x02:	/* DAC Volume Control */
476
        return s->volume;
477

478
    case 0x03:
479
        return 0x8b00;
480

481
    case 0x04:	/* Audio Control 2 */
482
        l_ch = 1;
483
        r_ch = 1;
484
        if (s->softstep && !(s->dac_power & (1 << 10))) {
485
            l_ch = (qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) >
486
                            s->volume_change + TSC_SOFTSTEP_DELAY);
487
            r_ch = (qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) >
488
                            s->volume_change + TSC_SOFTSTEP_DELAY);
489
        }
490

491
        return s->audio_ctrl2 | (l_ch << 3) | (r_ch << 2);
492

493
    case 0x05:	/* Stereo DAC Power Control */
494
        return 0x2aa0 | s->dac_power |
495
                (((s->dac_power & (1 << 10)) &&
496
                  (qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) >
497
                   s->powerdown + TSC_POWEROFF_DELAY)) << 6);
498

499
    case 0x06:	/* Audio Control 3 */
500
        val = s->audio_ctrl3 | 0x0001;
501
        s->audio_ctrl3 &= 0xff3f;
502
        return val;
503

504
    case 0x07:	/* LCH_BASS_BOOST_N0 */
505
    case 0x08:	/* LCH_BASS_BOOST_N1 */
506
    case 0x09:	/* LCH_BASS_BOOST_N2 */
507
    case 0x0a:	/* LCH_BASS_BOOST_N3 */
508
    case 0x0b:	/* LCH_BASS_BOOST_N4 */
509
    case 0x0c:	/* LCH_BASS_BOOST_N5 */
510
    case 0x0d:	/* LCH_BASS_BOOST_D1 */
511
    case 0x0e:	/* LCH_BASS_BOOST_D2 */
512
    case 0x0f:	/* LCH_BASS_BOOST_D4 */
513
    case 0x10:	/* LCH_BASS_BOOST_D5 */
514
    case 0x11:	/* RCH_BASS_BOOST_N0 */
515
    case 0x12:	/* RCH_BASS_BOOST_N1 */
516
    case 0x13:	/* RCH_BASS_BOOST_N2 */
517
    case 0x14:	/* RCH_BASS_BOOST_N3 */
518
    case 0x15:	/* RCH_BASS_BOOST_N4 */
519
    case 0x16:	/* RCH_BASS_BOOST_N5 */
520
    case 0x17:	/* RCH_BASS_BOOST_D1 */
521
    case 0x18:	/* RCH_BASS_BOOST_D2 */
522
    case 0x19:	/* RCH_BASS_BOOST_D4 */
523
    case 0x1a:	/* RCH_BASS_BOOST_D5 */
524
        return s->filter_data[reg - 0x07];
525

526
    case 0x1b:	/* PLL Programmability 1 */
527
        return s->pll[0];
528

529
    case 0x1c:	/* PLL Programmability 2 */
530
        return s->pll[1];
531

532
    case 0x1d:	/* Audio Control 4 */
533
        return (!s->softstep) << 14;
534

535
    default:
536
#ifdef TSC_VERBOSE
537
        fprintf(stderr, "tsc2102_audio_register_read: "
538
                        "no such register: 0x%02x\n", reg);
539
#endif
540
        return 0xffff;
541
    }
542
}
543

544
static void tsc2102_data_register_write(
545
                TSC210xState *s, int reg, uint16_t value)
546
{
547
    switch (reg) {
548
    case 0x00:	/* X */
549
    case 0x01:	/* Y */
550
    case 0x02:	/* Z1 */
551
    case 0x03:	/* Z2 */
552
    case 0x05:	/* BAT1 */
553
    case 0x06:	/* BAT2 */
554
    case 0x07:	/* AUX1 */
555
    case 0x08:	/* AUX2 */
556
    case 0x09:	/* TEMP1 */
557
    case 0x0a:	/* TEMP2 */
558
        return;
559

560
    default:
561
        qemu_log_mask(LOG_GUEST_ERROR, "tsc2102_data_register_write: "
562
                                       "no such register: 0x%02x\n", reg);
563
    }
564
}
565

566
static void tsc2102_control_register_write(
567
                TSC210xState *s, int reg, uint16_t value)
568
{
569
    switch (reg) {
570
    case 0x00:	/* TSC ADC */
571
        s->host_mode = value >> 15;
572
        s->enabled = !(value & 0x4000);
573
        if (s->busy && !s->enabled)
574
            timer_del(s->timer);
575
        s->busy = s->busy && s->enabled;
576
        s->nextfunction = (value >> 10) & 0xf;
577
        s->nextprecision = (value >> 8) & 3;
578
        s->filter = value & 0xff;
579
        return;
580

581
    case 0x01:	/* Status / Keypad Control */
582
        if ((s->model & 0xff00) == 0x2100)
583
            s->pin_func = value >> 14;
584
        else {
585
            s->kb.scan = (value >> 14) & 1;
586
            s->kb.debounce = (value >> 11) & 7;
587
            if (s->kb.intr && s->kb.scan) {
588
                s->kb.intr = 0;
589
                qemu_irq_raise(s->kbint);
590
            }
591
        }
592
        return;
593

594
    case 0x02:	/* DAC Control */
595
        if ((s->model & 0xff00) == 0x2300) {
596
            s->dac_power &= 0x7fff;
597
            s->dac_power |= 0x8000 & value;
598
        } else
599
            goto bad_reg;
600
        break;
601

602
    case 0x03:	/* Reference */
603
        s->ref = value & 0x1f;
604
        return;
605

606
    case 0x04:	/* Reset */
607
        if (value == 0xbb00) {
608
            if (s->busy)
609
                timer_del(s->timer);
610
            tsc210x_reset(s);
611
#ifdef TSC_VERBOSE
612
        } else {
613
            fprintf(stderr, "tsc2102_control_register_write: "
614
                            "wrong value written into RESET\n");
615
#endif
616
        }
617
        return;
618

619
    case 0x05:	/* Configuration */
620
        s->timing = value & 0x3f;
621
#ifdef TSC_VERBOSE
622
        if (value & ~0x3f)
623
            fprintf(stderr, "tsc2102_control_register_write: "
624
                            "wrong value written into CONFIG\n");
625
#endif
626
        return;
627

628
    case 0x06:	/* Secondary configuration */
629
        if ((s->model & 0xff00) == 0x2100)
630
            goto bad_reg;
631
        s->kb.mode = value >> 14;
632
        s->pll[2] = value & 0x3ffff;
633
        return;
634

635
    case 0x10:	/* Keypad Mask */
636
        if ((s->model & 0xff00) == 0x2100)
637
            goto bad_reg;
638
        s->kb.mask = value;
639
        return;
640

641
    default:
642
    bad_reg:
643
        qemu_log_mask(LOG_GUEST_ERROR, "tsc2102_control_register_write: "
644
                                       "no such register: 0x%02x\n", reg);
645
    }
646
}
647

648
static void tsc2102_audio_register_write(
649
                TSC210xState *s, int reg, uint16_t value)
650
{
651
    switch (reg) {
652
    case 0x00:	/* Audio Control 1 */
653
        s->audio_ctrl1 = value & 0x0f3f;
654
#ifdef TSC_VERBOSE
655
        if ((value & ~0x0f3f) || ((value & 7) != ((value >> 3) & 7)))
656
            fprintf(stderr, "tsc2102_audio_register_write: "
657
                            "wrong value written into Audio 1\n");
658
#endif
659
        tsc2102_audio_rate_update(s);
660
        tsc2102_audio_output_update(s);
661
        return;
662

663
    case 0x01:
664
#ifdef TSC_VERBOSE
665
        if (value != 0xff00)
666
            fprintf(stderr, "tsc2102_audio_register_write: "
667
                            "wrong value written into reg 0x01\n");
668
#endif
669
        return;
670

671
    case 0x02:	/* DAC Volume Control */
672
        s->volume = value;
673
        s->volume_change = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
674
        return;
675

676
    case 0x03:
677
#ifdef TSC_VERBOSE
678
        if (value != 0x8b00)
679
            fprintf(stderr, "tsc2102_audio_register_write: "
680
                            "wrong value written into reg 0x03\n");
681
#endif
682
        return;
683

684
    case 0x04:	/* Audio Control 2 */
685
        s->audio_ctrl2 = value & 0xf7f2;
686
#ifdef TSC_VERBOSE
687
        if (value & ~0xf7fd)
688
            fprintf(stderr, "tsc2102_audio_register_write: "
689
                            "wrong value written into Audio 2\n");
690
#endif
691
        return;
692

693
    case 0x05:	/* Stereo DAC Power Control */
694
        if ((value & ~s->dac_power) & (1 << 10))
695
            s->powerdown = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
696

697
        s->dac_power = value & 0x9543;
698
#ifdef TSC_VERBOSE
699
        if ((value & ~0x9543) != 0x2aa0)
700
            fprintf(stderr, "tsc2102_audio_register_write: "
701
                            "wrong value written into Power\n");
702
#endif
703
        tsc2102_audio_rate_update(s);
704
        tsc2102_audio_output_update(s);
705
        return;
706

707
    case 0x06:	/* Audio Control 3 */
708
        s->audio_ctrl3 &= 0x00c0;
709
        s->audio_ctrl3 |= value & 0xf800;
710
#ifdef TSC_VERBOSE
711
        if (value & ~0xf8c7)
712
            fprintf(stderr, "tsc2102_audio_register_write: "
713
                            "wrong value written into Audio 3\n");
714
#endif
715
        tsc2102_audio_output_update(s);
716
        return;
717

718
    case 0x07:	/* LCH_BASS_BOOST_N0 */
719
    case 0x08:	/* LCH_BASS_BOOST_N1 */
720
    case 0x09:	/* LCH_BASS_BOOST_N2 */
721
    case 0x0a:	/* LCH_BASS_BOOST_N3 */
722
    case 0x0b:	/* LCH_BASS_BOOST_N4 */
723
    case 0x0c:	/* LCH_BASS_BOOST_N5 */
724
    case 0x0d:	/* LCH_BASS_BOOST_D1 */
725
    case 0x0e:	/* LCH_BASS_BOOST_D2 */
726
    case 0x0f:	/* LCH_BASS_BOOST_D4 */
727
    case 0x10:	/* LCH_BASS_BOOST_D5 */
728
    case 0x11:	/* RCH_BASS_BOOST_N0 */
729
    case 0x12:	/* RCH_BASS_BOOST_N1 */
730
    case 0x13:	/* RCH_BASS_BOOST_N2 */
731
    case 0x14:	/* RCH_BASS_BOOST_N3 */
732
    case 0x15:	/* RCH_BASS_BOOST_N4 */
733
    case 0x16:	/* RCH_BASS_BOOST_N5 */
734
    case 0x17:	/* RCH_BASS_BOOST_D1 */
735
    case 0x18:	/* RCH_BASS_BOOST_D2 */
736
    case 0x19:	/* RCH_BASS_BOOST_D4 */
737
    case 0x1a:	/* RCH_BASS_BOOST_D5 */
738
        s->filter_data[reg - 0x07] = value;
739
        return;
740

741
    case 0x1b:	/* PLL Programmability 1 */
742
        s->pll[0] = value & 0xfffc;
743
#ifdef TSC_VERBOSE
744
        if (value & ~0xfffc)
745
            fprintf(stderr, "tsc2102_audio_register_write: "
746
                            "wrong value written into PLL 1\n");
747
#endif
748
        return;
749

750
    case 0x1c:	/* PLL Programmability 2 */
751
        s->pll[1] = value & 0xfffc;
752
#ifdef TSC_VERBOSE
753
        if (value & ~0xfffc)
754
            fprintf(stderr, "tsc2102_audio_register_write: "
755
                            "wrong value written into PLL 2\n");
756
#endif
757
        return;
758

759
    case 0x1d:	/* Audio Control 4 */
760
        s->softstep = !(value & 0x4000);
761
#ifdef TSC_VERBOSE
762
        if (value & ~0x4000)
763
            fprintf(stderr, "tsc2102_audio_register_write: "
764
                            "wrong value written into Audio 4\n");
765
#endif
766
        return;
767

768
    default:
769
        qemu_log_mask(LOG_GUEST_ERROR, "tsc2102_audio_register_write: "
770
                                       "no such register: 0x%02x\n", reg);
771
    }
772
}
773

774
/* This handles most of the chip logic.  */
775
static void tsc210x_pin_update(TSC210xState *s)
776
{
777
    int64_t expires;
778
    bool pin_state;
779

780
    switch (s->pin_func) {
781
    case 0:
782
        pin_state = s->pressure;
783
        break;
784
    case 1:
785
        pin_state = !!s->dav;
786
        break;
787
    case 2:
788
    default:
789
        pin_state = s->pressure && !s->dav;
790
    }
791

792
    if (!s->enabled)
793
        pin_state = false;
794

795
    if (pin_state != s->irq) {
796
        s->irq = pin_state;
797
        qemu_set_irq(s->pint, !s->irq);
798
    }
799

800
    switch (s->nextfunction) {
801
    case TSC_MODE_XY_SCAN:
802
    case TSC_MODE_XYZ_SCAN:
803
        if (!s->pressure)
804
            return;
805
        break;
806

807
    case TSC_MODE_X:
808
    case TSC_MODE_Y:
809
    case TSC_MODE_Z:
810
        if (!s->pressure)
811
            return;
812
        /* Fall through */
813
    case TSC_MODE_BAT1:
814
    case TSC_MODE_BAT2:
815
    case TSC_MODE_AUX:
816
    case TSC_MODE_TEMP1:
817
    case TSC_MODE_TEMP2:
818
        if (s->dav)
819
            s->enabled = false;
820
        break;
821

822
    case TSC_MODE_AUX_SCAN:
823
    case TSC_MODE_PORT_SCAN:
824
        break;
825

826
    case TSC_MODE_NO_SCAN:
827
    case TSC_MODE_XX_DRV:
828
    case TSC_MODE_YY_DRV:
829
    case TSC_MODE_YX_DRV:
830
    default:
831
        return;
832
    }
833

834
    if (!s->enabled || s->busy || s->dav)
835
        return;
836

837
    s->busy = true;
838
    s->precision = s->nextprecision;
839
    s->function = s->nextfunction;
840
    expires = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) +
841
        (NANOSECONDS_PER_SECOND >> 10);
842
    timer_mod(s->timer, expires);
843
}
844

845
static uint16_t tsc210x_read(TSC210xState *s)
846
{
847
    uint16_t ret = 0x0000;
848

849
    if (!s->command)
850
        fprintf(stderr, "tsc210x_read: SPI underrun!\n");
851

852
    switch (s->page) {
853
    case TSC_DATA_REGISTERS_PAGE:
854
        ret = tsc2102_data_register_read(s, s->offset);
855
        if (!s->dav)
856
            qemu_irq_raise(s->davint);
857
        break;
858
    case TSC_CONTROL_REGISTERS_PAGE:
859
        ret = tsc2102_control_register_read(s, s->offset);
860
        break;
861
    case TSC_AUDIO_REGISTERS_PAGE:
862
        ret = tsc2102_audio_register_read(s, s->offset);
863
        break;
864
    default:
865
        hw_error("tsc210x_read: wrong memory page\n");
866
    }
867

868
    tsc210x_pin_update(s);
869

870
    /* Allow sequential reads.  */
871
    s->offset ++;
872
    s->state = false;
873
    return ret;
874
}
875

876
static void tsc210x_write(TSC210xState *s, uint16_t value)
877
{
878
    /*
879
     * This is a two-state state machine for reading
880
     * command and data every second time.
881
     */
882
    if (!s->state) {
883
        s->command = (value >> 15) != 0;
884
        s->page = (value >> 11) & 0x0f;
885
        s->offset = (value >> 5) & 0x3f;
886
        s->state = true;
887
    } else {
888
        if (s->command)
889
            fprintf(stderr, "tsc210x_write: SPI overrun!\n");
890
        else
891
            switch (s->page) {
892
            case TSC_DATA_REGISTERS_PAGE:
893
                tsc2102_data_register_write(s, s->offset, value);
894
                break;
895
            case TSC_CONTROL_REGISTERS_PAGE:
896
                tsc2102_control_register_write(s, s->offset, value);
897
                break;
898
            case TSC_AUDIO_REGISTERS_PAGE:
899
                tsc2102_audio_register_write(s, s->offset, value);
900
                break;
901
            default:
902
                hw_error("tsc210x_write: wrong memory page\n");
903
            }
904

905
        tsc210x_pin_update(s);
906
        s->state = false;
907
    }
908
}
909

910
uint32_t tsc210x_txrx(void *opaque, uint32_t value, int len)
911
{
912
    TSC210xState *s = opaque;
913
    uint32_t ret = 0;
914

915
    if (len != 16) {
916
        qemu_log_mask(LOG_GUEST_ERROR,
917
                      "%s: bad SPI word width %i\n", __func__, len);
918
        return 0;
919
    }
920

921
    /* TODO: sequential reads etc - how do we make sure the host doesn't
922
     * unintentionally read out a conversion result from a register while
923
     * transmitting the command word of the next command?  */
924
    if (!value || (s->state && s->command))
925
        ret = tsc210x_read(s);
926
    if (value || (s->state && !s->command))
927
        tsc210x_write(s, value);
928

929
    return ret;
930
}
931

932
static void tsc210x_timer_tick(void *opaque)
933
{
934
    TSC210xState *s = opaque;
935

936
    /* Timer ticked -- a set of conversions has been finished.  */
937

938
    if (!s->busy)
939
        return;
940

941
    s->busy = false;
942
    s->dav |= mode_regs[s->function];
943
    tsc210x_pin_update(s);
944
    qemu_irq_lower(s->davint);
945
}
946

947
static void tsc210x_touchscreen_event(void *opaque,
948
                int x, int y, int z, int buttons_state)
949
{
950
    TSC210xState *s = opaque;
951
    int p = s->pressure;
952

953
    if (buttons_state) {
954
        s->x = x;
955
        s->y = y;
956
    }
957
    s->pressure = !!buttons_state;
958

959
    /*
960
     * Note: We would get better responsiveness in the guest by
961
     * signaling TS events immediately, but for now we simulate
962
     * the first conversion delay for sake of correctness.
963
     */
964
    if (p != s->pressure)
965
        tsc210x_pin_update(s);
966
}
967

968
static void tsc210x_i2s_swallow(TSC210xState *s)
969
{
970
    if (s->dac_voice[0])
971
        tsc210x_out_flush(s, s->codec.out.len);
972
    else
973
        s->codec.out.len = 0;
974
}
975

976
static void tsc210x_i2s_set_rate(TSC210xState *s, int in, int out)
977
{
978
    s->i2s_tx_rate = out;
979
    s->i2s_rx_rate = in;
980
}
981

982
static int tsc210x_pre_save(void *opaque)
983
{
984
    TSC210xState *s = (TSC210xState *) opaque;
985
    s->now = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
986

987
    return 0;
988
}
989

990
static int tsc210x_post_load(void *opaque, int version_id)
991
{
992
    TSC210xState *s = (TSC210xState *) opaque;
993
    int64_t now = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
994

995
    if (s->function >= ARRAY_SIZE(mode_regs)) {
996
        return -EINVAL;
997
    }
998
    if (s->nextfunction >= ARRAY_SIZE(mode_regs)) {
999
        return -EINVAL;
1000
    }
1001
    if (s->precision >= ARRAY_SIZE(resolution)) {
1002
        return -EINVAL;
1003
    }
1004
    if (s->nextprecision >= ARRAY_SIZE(resolution)) {
1005
        return -EINVAL;
1006
    }
1007

1008
    s->volume_change -= s->now;
1009
    s->volume_change += now;
1010
    s->powerdown -= s->now;
1011
    s->powerdown += now;
1012

1013
    s->busy = timer_pending(s->timer);
1014
    qemu_set_irq(s->pint, !s->irq);
1015
    qemu_set_irq(s->davint, !s->dav);
1016

1017
    return 0;
1018
}
1019

1020
static const VMStateField vmstatefields_tsc210x[] = {
1021
    VMSTATE_BOOL(enabled, TSC210xState),
1022
    VMSTATE_BOOL(host_mode, TSC210xState),
1023
    VMSTATE_BOOL(irq, TSC210xState),
1024
    VMSTATE_BOOL(command, TSC210xState),
1025
    VMSTATE_BOOL(pressure, TSC210xState),
1026
    VMSTATE_BOOL(softstep, TSC210xState),
1027
    VMSTATE_BOOL(state, TSC210xState),
1028
    VMSTATE_UINT16(dav, TSC210xState),
1029
    VMSTATE_INT32(x, TSC210xState),
1030
    VMSTATE_INT32(y, TSC210xState),
1031
    VMSTATE_UINT8(offset, TSC210xState),
1032
    VMSTATE_UINT8(page, TSC210xState),
1033
    VMSTATE_UINT8(filter, TSC210xState),
1034
    VMSTATE_UINT8(pin_func, TSC210xState),
1035
    VMSTATE_UINT8(ref, TSC210xState),
1036
    VMSTATE_UINT8(timing, TSC210xState),
1037
    VMSTATE_UINT8(noise, TSC210xState),
1038
    VMSTATE_UINT8(function, TSC210xState),
1039
    VMSTATE_UINT8(nextfunction, TSC210xState),
1040
    VMSTATE_UINT8(precision, TSC210xState),
1041
    VMSTATE_UINT8(nextprecision, TSC210xState),
1042
    VMSTATE_UINT16(audio_ctrl1, TSC210xState),
1043
    VMSTATE_UINT16(audio_ctrl2, TSC210xState),
1044
    VMSTATE_UINT16(audio_ctrl3, TSC210xState),
1045
    VMSTATE_UINT16_ARRAY(pll, TSC210xState, 3),
1046
    VMSTATE_UINT16(volume, TSC210xState),
1047
    VMSTATE_UINT16(dac_power, TSC210xState),
1048
    VMSTATE_INT64(volume_change, TSC210xState),
1049
    VMSTATE_INT64(powerdown, TSC210xState),
1050
    VMSTATE_INT64(now, TSC210xState),
1051
    VMSTATE_UINT16_ARRAY(filter_data, TSC210xState, 0x14),
1052
    VMSTATE_TIMER_PTR(timer, TSC210xState),
1053
    VMSTATE_END_OF_LIST()
1054
};
1055

1056
static const VMStateDescription vmstate_tsc2102 = {
1057
    .name = "tsc2102",
1058
    .version_id = 1,
1059
    .minimum_version_id = 1,
1060
    .pre_save = tsc210x_pre_save,
1061
    .post_load = tsc210x_post_load,
1062
    .fields = vmstatefields_tsc210x,
1063
};
1064

1065
static const VMStateDescription vmstate_tsc2301 = {
1066
    .name = "tsc2301",
1067
    .version_id = 1,
1068
    .minimum_version_id = 1,
1069
    .pre_save = tsc210x_pre_save,
1070
    .post_load = tsc210x_post_load,
1071
    .fields = vmstatefields_tsc210x,
1072
};
1073

1074
static void tsc210x_init(TSC210xState *s,
1075
                         const char *name,
1076
                         const VMStateDescription *vmsd)
1077
{
1078
    s->tr[0] = 0;
1079
    s->tr[1] = 1;
1080
    s->tr[2] = 1;
1081
    s->tr[3] = 0;
1082
    s->tr[4] = 1;
1083
    s->tr[5] = 0;
1084
    s->tr[6] = 1;
1085
    s->tr[7] = 0;
1086

1087
    s->chip.opaque = s;
1088
    s->chip.send = (void *) tsc210x_write;
1089
    s->chip.receive = (void *) tsc210x_read;
1090

1091
    s->codec.opaque = s;
1092
    s->codec.tx_swallow = (void *) tsc210x_i2s_swallow;
1093
    s->codec.set_rate = (void *) tsc210x_i2s_set_rate;
1094
    s->codec.in.fifo = s->in_fifo;
1095
    s->codec.out.fifo = s->out_fifo;
1096

1097
    tsc210x_reset(s);
1098

1099
    qemu_add_mouse_event_handler(tsc210x_touchscreen_event, s, 1, name);
1100

1101
    if (current_machine->audiodev) {
1102
        s->card.name = g_strdup(current_machine->audiodev);
1103
        s->card.state = audio_state_by_name(s->card.name, &error_fatal);
1104
    }
1105
    AUD_register_card(s->name, &s->card, &error_fatal);
1106

1107
    qemu_register_reset((void *) tsc210x_reset, s);
1108
    vmstate_register(NULL, 0, vmsd, s);
1109
}
1110

1111
uWireSlave *tsc2102_init(qemu_irq pint)
1112
{
1113
    TSC210xState *s;
1114

1115
    s = g_new0(TSC210xState, 1);
1116
    s->x = 160;
1117
    s->y = 160;
1118
    s->pressure = 0;
1119
    s->precision = s->nextprecision = 0;
1120
    s->timer = timer_new_ns(QEMU_CLOCK_VIRTUAL, tsc210x_timer_tick, s);
1121
    s->pint = pint;
1122
    s->model = 0x2102;
1123
    s->name = "tsc2102";
1124

1125
    tsc210x_init(s, "QEMU TSC2102-driven Touchscreen", &vmstate_tsc2102);
1126

1127
    return &s->chip;
1128
}
1129

1130
uWireSlave *tsc2301_init(qemu_irq penirq, qemu_irq kbirq, qemu_irq dav)
1131
{
1132
    TSC210xState *s;
1133

1134
    s = g_new0(TSC210xState, 1);
1135
    s->x = 400;
1136
    s->y = 240;
1137
    s->pressure = 0;
1138
    s->precision = s->nextprecision = 0;
1139
    s->timer = timer_new_ns(QEMU_CLOCK_VIRTUAL, tsc210x_timer_tick, s);
1140
    s->pint = penirq;
1141
    s->kbint = kbirq;
1142
    s->davint = dav;
1143
    s->model = 0x2301;
1144
    s->name = "tsc2301";
1145

1146
    tsc210x_init(s, "QEMU TSC2301-driven Touchscreen", &vmstate_tsc2301);
1147

1148
    return &s->chip;
1149
}
1150

1151
I2SCodec *tsc210x_codec(uWireSlave *chip)
1152
{
1153
    TSC210xState *s = (TSC210xState *) chip->opaque;
1154

1155
    return &s->codec;
1156
}
1157

1158
/*
1159
 * Use tslib generated calibration data to generate ADC input values
1160
 * from the touchscreen.  Assuming 12-bit precision was used during
1161
 * tslib calibration.
1162
 */
1163
void tsc210x_set_transform(uWireSlave *chip, const MouseTransformInfo *info)
1164
{
1165
    TSC210xState *s = (TSC210xState *) chip->opaque;
1166
#if 0
1167
    int64_t ltr[8];
1168

1169
    ltr[0] = (int64_t) info->a[1] * info->y;
1170
    ltr[1] = (int64_t) info->a[4] * info->x;
1171
    ltr[2] = (int64_t) info->a[1] * info->a[3] -
1172
            (int64_t) info->a[4] * info->a[0];
1173
    ltr[3] = (int64_t) info->a[2] * info->a[4] -
1174
            (int64_t) info->a[5] * info->a[1];
1175
    ltr[4] = (int64_t) info->a[0] * info->y;
1176
    ltr[5] = (int64_t) info->a[3] * info->x;
1177
    ltr[6] = (int64_t) info->a[4] * info->a[0] -
1178
            (int64_t) info->a[1] * info->a[3];
1179
    ltr[7] = (int64_t) info->a[2] * info->a[3] -
1180
            (int64_t) info->a[5] * info->a[0];
1181

1182
    /* Avoid integer overflow */
1183
    s->tr[0] = ltr[0] >> 11;
1184
    s->tr[1] = ltr[1] >> 11;
1185
    s->tr[2] = muldiv64(ltr[2], 1, info->a[6]);
1186
    s->tr[3] = muldiv64(ltr[3], 1 << 4, ltr[2]);
1187
    s->tr[4] = ltr[4] >> 11;
1188
    s->tr[5] = ltr[5] >> 11;
1189
    s->tr[6] = muldiv64(ltr[6], 1, info->a[6]);
1190
    s->tr[7] = muldiv64(ltr[7], 1 << 4, ltr[6]);
1191
#else
1192

1193
    /* This version assumes touchscreen X & Y axis are parallel or
1194
     * perpendicular to LCD's  X & Y axis in some way.  */
1195
    if (abs(info->a[0]) > abs(info->a[1])) {
1196
        s->tr[0] = 0;
1197
        s->tr[1] = -info->a[6] * info->x;
1198
        s->tr[2] = info->a[0];
1199
        s->tr[3] = -info->a[2] / info->a[0];
1200
        s->tr[4] = info->a[6] * info->y;
1201
        s->tr[5] = 0;
1202
        s->tr[6] = info->a[4];
1203
        s->tr[7] = -info->a[5] / info->a[4];
1204
    } else {
1205
        s->tr[0] = info->a[6] * info->y;
1206
        s->tr[1] = 0;
1207
        s->tr[2] = info->a[1];
1208
        s->tr[3] = -info->a[2] / info->a[1];
1209
        s->tr[4] = 0;
1210
        s->tr[5] = -info->a[6] * info->x;
1211
        s->tr[6] = info->a[3];
1212
        s->tr[7] = -info->a[5] / info->a[3];
1213
    }
1214

1215
    s->tr[0] >>= 11;
1216
    s->tr[1] >>= 11;
1217
    s->tr[3] <<= 4;
1218
    s->tr[4] >>= 11;
1219
    s->tr[5] >>= 11;
1220
    s->tr[7] <<= 4;
1221
#endif
1222
}
1223

1224
void tsc210x_key_event(uWireSlave *chip, int key, int down)
1225
{
1226
    TSC210xState *s = (TSC210xState *) chip->opaque;
1227

1228
    if (down)
1229
        s->kb.down |= 1 << key;
1230
    else
1231
        s->kb.down &= ~(1 << key);
1232

1233
    if (down && (s->kb.down & ~s->kb.mask) && !s->kb.intr) {
1234
        s->kb.intr = 1;
1235
        qemu_irq_lower(s->kbint);
1236
    } else if (s->kb.intr && !(s->kb.down & ~s->kb.mask) &&
1237
                    !(s->kb.mode & 1)) {
1238
        s->kb.intr = 0;
1239
        qemu_irq_raise(s->kbint);
1240
    }
1241
}
1242