← Back to branch summary

~ubuntu-branches/ubuntu/trusty/qemu/trusty

« back to all changes in this revision

Viewing changes to debian/patches/ubuntu/linaro/0026-hw-tsc2005-Add-tracing.patch

  • Committer: Package Import Robot
  • Author(s): Serge Hallyn
  • Date: 2014-02-04 12:13:08 UTC
  • mfrom: (10.1.45 sid)
  • Revision ID: package-import@ubuntu.com-20140204121308-1xq92lrfs75agw2g
Tags: 1.7.0+dfsg-3ubuntu1~ppa1
* Merge 1.7.0+dfsg-3 from debian.  Remaining changes:
  - debian/patches/ubuntu:
    * expose-vmx_qemu64cpu.patch
    * linaro (omap3) and arm64 patches
    * ubuntu/target-ppc-add-stubs-for-kvm-breakpoints: fix FTBFS
      on ppc
    * ubuntu/CVE-2013-4377.patch: fix denial of service via virtio
  - debian/qemu-system-x86.modprobe: set kvm_intel nested=1 options
  - debian/control:
    * add arm64 to Architectures
    * add qemu-common and qemu-system-aarch64 packages
  - debian/qemu-system-common.install: add debian/tmp/usr/lib
  - debian/qemu-system-common.preinst: add kvm group
  - debian/qemu-system-common.postinst: remove acl placed by udev,
    and add udevadm trigger.
  - qemu-system-x86.links: add eepro100.rom, remove pxe-virtio,
    pxe-e1000 and pxe-rtl8139.
  - add qemu-system-x86.qemu-kvm.upstart and .default
  - qemu-user-static.postinst-in: remove arm64 binfmt
  - debian/rules:
    * allow parallel build
    * add aarch64 to system_targets and sys_systems
    * add qemu-kvm-spice links
    * install qemu-system-x86.modprobe
  - add debian/qemu-system-common.links for OVMF.fd link
* Remove kvm-img, kvm-nbd, kvm-ifup and kvm-ifdown symlinks.

Show diffs side-by-side

added added

removed removed

Lines of Context:
debian/patches/ubuntu/linaro/0026-hw-tsc2005-Add-tracing.patch
 
1
From b1c32ca9f8ac9581184e331f338629e7f869f786 Mon Sep 17 00:00:00 2001
 
2
From: Peter Maydell <peter.maydell@linaro.org>
 
3
Date: Mon, 18 Feb 2013 16:58:27 +0000
 
4
Subject: [PATCH 26/70] hw/tsc2005: Add tracing
 
5
 
 
6
---
 
7
 hw/input/tsc2005.c | 68 +++++++++++++++++++++++++++++++++++++++++++-----------
 
8
 1 file changed, 55 insertions(+), 13 deletions(-)
 
9
 
 
10
diff --git a/hw/input/tsc2005.c b/hw/input/tsc2005.c
 
11
index 81f2a95..50f8163 100644
 
12
--- a/hw/input/tsc2005.c
 
13
+++ b/hw/input/tsc2005.c
 
14
@@ -23,6 +23,15 @@
 
15
 #include "ui/console.h"
 
16
 #include "hw/devices.h"
 
17
 
 
18
+//#define TSC2005_DEBUG
 
19
+
 
20
+#ifdef TSC2005_DEBUG
 
21
+#define TRACE(fmt, ...) fprintf(stderr, "%s@%d: " fmt "\n", \
 
22
+                                __FUNCTION__, __LINE__, ##__VA_ARGS__)
 
23
+#else
 
24
+#define TRACE(...)
 
25
+#endif
 
26
+
 
27
 #define TSC_CUT_RESOLUTION(value, p)   ((value) >> (16 - (p ? 12 : 10)))
 
28
 
 
29
 typedef struct {
 
30
@@ -120,33 +129,46 @@ static uint16_t tsc2005_read(TSC2005State *s, int reg)
 
31
     switch (reg) {
 
32
     case 0x0:  /* X */
 
33
         s->dav &= ~mode_regs[TSC_MODE_X];
 
34
+        TRACE("X = %d", TSC_CUT_RESOLUTION(X_TRANSFORM(s), s->precision) +
 
35
+              (s->noise & 3));
 
36
         return TSC_CUT_RESOLUTION(X_TRANSFORM(s), s->precision) +
 
37
                 (s->noise & 3);
 
38
     case 0x1:  /* Y */
 
39
         s->dav &= ~mode_regs[TSC_MODE_Y];
 
40
         s->noise ++;
 
41
+        TRACE("Y = %d", TSC_CUT_RESOLUTION(Y_TRANSFORM(s), s->precision) ^
 
42
+              (s->noise & 3));
 
43
         return TSC_CUT_RESOLUTION(Y_TRANSFORM(s), s->precision) ^
 
44
                 (s->noise & 3);
 
45
     case 0x2:  /* Z1 */
 
46
         s->dav &= 0xdfff;
 
47
+        TRACE("Z1 = %d", TSC_CUT_RESOLUTION(Z1_TRANSFORM(s), s->precision) -
 
48
+              (s->noise & 3));
 
49
         return TSC_CUT_RESOLUTION(Z1_TRANSFORM(s), s->precision) -
 
50
                 (s->noise & 3);
 
51
     case 0x3:  /* Z2 */
 
52
         s->dav &= 0xefff;
 
53
+        TRACE("Z2 = %d", TSC_CUT_RESOLUTION(Z2_TRANSFORM(s), s->precision) |
 
54
+              (s->noise & 3));
 
55
         return TSC_CUT_RESOLUTION(Z2_TRANSFORM(s), s->precision) |
 
56
                 (s->noise & 3);
 
57
 
 
58
     case 0x4:  /* AUX */
 
59
         s->dav &= ~mode_regs[TSC_MODE_AUX];
 
60
+        TRACE("AUX = %d", TSC_CUT_RESOLUTION(AUX_VAL, s->precision));
 
61
         return TSC_CUT_RESOLUTION(AUX_VAL, s->precision);
 
62
 
 
63
     case 0x5:  /* TEMP1 */
 
64
         s->dav &= ~mode_regs[TSC_MODE_TEMP1];
 
65
+        TRACE("TEMP1 = %d", TSC_CUT_RESOLUTION(TEMP1_VAL, s->precision) -
 
66
+              (s->noise & 5));
 
67
         return TSC_CUT_RESOLUTION(TEMP1_VAL, s->precision) -
 
68
                 (s->noise & 5);
 
69
     case 0x6:  /* TEMP2 */
 
70
         s->dav &= 0xdfff;
 
71
         s->dav &= ~mode_regs[TSC_MODE_TEMP2];
 
72
+        TRACE("TEMP2 = %d", TSC_CUT_RESOLUTION(TEMP2_VAL, s->precision) ^
 
73
+              (s->noise & 3));
 
74
         return TSC_CUT_RESOLUTION(TEMP2_VAL, s->precision) ^
 
75
                 (s->noise & 3);
 
76
 
 
77
@@ -155,31 +177,43 @@ static uint16_t tsc2005_read(TSC2005State *s, int reg)
 
78
         s->dav &= ~(mode_regs[TSC_MODE_X_TEST] | mode_regs[TSC_MODE_Y_TEST] |
 
79
                         mode_regs[TSC_MODE_TS_TEST]);
 
80
         s->reset = 1;
 
81
+        TRACE("STATUS = 0x%04x", ret);
 
82
         return ret;
 
83
 
 
84
     case 0x8:  /* AUX high treshold */
 
85
+        TRACE("AUX high threshold = 0x%04x", s->aux_thr[1]);
 
86
         return s->aux_thr[1];
 
87
     case 0x9:  /* AUX low treshold */
 
88
+        TRACE("AUX low threshold = 0x%04x", s->aux_thr[0]);
 
89
         return s->aux_thr[0];
 
90
 
 
91
     case 0xa:  /* TEMP high treshold */
 
92
+        TRACE("TEMP high threshold = 0x%04x", s->temp_thr[1]);
 
93
         return s->temp_thr[1];
 
94
     case 0xb:  /* TEMP low treshold */
 
95
+        TRACE("TEMP low threshold = 0x%04x", s->temp_thr[0]);
 
96
         return s->temp_thr[0];
 
97
 
 
98
     case 0xc:  /* CFR0 */
 
99
+        TRACE("CFR0 = 0x%04x", (s->pressure << 15) | ((!s->busy) << 14) |
 
100
+              (s->nextprecision << 13) | s->timing[0]);
 
101
         return (s->pressure << 15) | ((!s->busy) << 14) |
 
102
                 (s->nextprecision << 13) | s->timing[0]; 
 
103
     case 0xd:  /* CFR1 */
 
104
+        TRACE("CFR1 = 0x%04x", s->timing[1]);
 
105
         return s->timing[1];
 
106
     case 0xe:  /* CFR2 */
 
107
+        TRACE("CFR2 = 0x%04x", (s->pin_func << 14) | s->filter);
 
108
         return (s->pin_func << 14) | s->filter;
 
109
 
 
110
     case 0xf:  /* Function select status */
 
111
+        TRACE("function select status = 0x%04x",
 
112
+              s->function >= 0 ? 1 << s->function : 0);
 
113
         return s->function >= 0 ? 1 << s->function : 0;
 
114
     }
 
115
 
 
116
     /* Never gets here */
 
117
+    TRACE("unknown register = 0xffff");
 
118
     return 0xffff;
 
119
 }
 
120
 
 
121
@@ -187,46 +221,52 @@ static void tsc2005_write(TSC2005State *s, int reg, uint16_t data)
 
122
 {
 
123
     switch (reg) {
 
124
     case 0x8:  /* AUX high treshold */
 
125
+        TRACE("AUX high threshold = 0x%04x", data);
 
126
         s->aux_thr[1] = data;
 
127
         break;
 
128
     case 0x9:  /* AUX low treshold */
 
129
+        TRACE("AUX low threshold = 0x%04x", data);
 
130
         s->aux_thr[0] = data;
 
131
         break;
 
132
 
 
133
     case 0xa:  /* TEMP high treshold */
 
134
+        TRACE("TEMP high threshold = 0x%04x", data);
 
135
         s->temp_thr[1] = data;
 
136
         break;
 
137
     case 0xb:  /* TEMP low treshold */
 
138
+        TRACE("TEMP low threshold = 0x%04x", data);
 
139
         s->temp_thr[0] = data;
 
140
         break;
 
141
 
 
142
     case 0xc:  /* CFR0 */
 
143
+        TRACE("CFR0 = 0x%04x", data);
 
144
         s->host_mode = data >> 15;
 
145
         if (s->enabled != !(data & 0x4000)) {
 
146
             s->enabled = !(data & 0x4000);
 
147
-            fprintf(stderr, "%s: touchscreen sense %sabled\n",
 
148
-                            __FUNCTION__, s->enabled ? "en" : "dis");
 
149
-            if (s->busy && !s->enabled)
 
150
+            TRACE("touchscreen sense %sabled", s->enabled ? "en" : "dis");
 
151
+            if (s->busy && !s->enabled) {
 
152
                 timer_del(s->timer);
 
153
+            }
 
154
             s->busy &= s->enabled;
 
155
         }
 
156
         s->nextprecision = (data >> 13) & 1;
 
157
         s->timing[0] = data & 0x1fff;
 
158
-        if ((s->timing[0] >> 11) == 3)
 
159
-            fprintf(stderr, "%s: illegal conversion clock setting\n",
 
160
-                            __FUNCTION__);
 
161
+        if ((s->timing[0] >> 11) == 3) {
 
162
+            TRACE("illegal conversion clock setting");
 
163
+        }
 
164
         break;
 
165
     case 0xd:  /* CFR1 */
 
166
+        TRACE("CFR1 = 0x%04x", data);
 
167
         s->timing[1] = data & 0xf07;
 
168
         break;
 
169
     case 0xe:  /* CFR2 */
 
170
+        TRACE("CFR2 = 0x%04x", data);
 
171
         s->pin_func = (data >> 14) & 3;
 
172
         s->filter = data & 0x3fff;
 
173
         break;
 
174
 
 
175
     default:
 
176
-        fprintf(stderr, "%s: write into read-only register %x\n",
 
177
-                        __FUNCTION__, reg);
 
178
+        TRACE("write into read-only register 0x%x, value 0x%04x", reg, data);
 
179
     }
 
180
 }
 
181
 
 
182
@@ -328,7 +368,7 @@ static uint8_t tsc2005_txrx_word(void *opaque, uint8_t value)
 
183
 {
 
184
     TSC2005State *s = opaque;
 
185
     uint32_t ret = 0;
 
186
-
 
187
+    TRACE("value = 0x%08x, state=%d", value, s->state + 1);
 
188
     switch (s->state ++) {
 
189
     case 0:
 
190
         if (value & 0x80) {
 
191
@@ -340,8 +380,8 @@ static uint8_t tsc2005_txrx_word(void *opaque, uint8_t value)
 
192
                 s->nextprecision = (value >> 2) & 1;
 
193
                 if (s->enabled != !(value & 1)) {
 
194
                     s->enabled = !(value & 1);
 
195
-                    fprintf(stderr, "%s: touchscreen sense %sabled\n",
 
196
-                                    __FUNCTION__, s->enabled ? "en" : "dis");
 
197
+                    TRACE("touchscreen sense %sabled",
 
198
+                          s->enabled ? "en" : "dis");
 
199
                     if (s->busy && !s->enabled)
 
200
                         timer_del(s->timer);
 
201
                     s->busy &= s->enabled;
 
202
@@ -392,7 +432,7 @@ static uint8_t tsc2005_txrx_word(void *opaque, uint8_t value)
 
203
 uint32_t tsc2005_txrx(void *opaque, uint32_t value, int len)
 
204
 {
 
205
     uint32_t ret = 0;
 
206
-
 
207
+    TRACE("value=0x%08x, len=%d", value, len);
 
208
     len &= ~7;
 
209
     while (len > 0) {
 
210
         len -= 8;
 
211
@@ -408,8 +448,10 @@ static void tsc2005_timer_tick(void *opaque)
 
212
 
 
213
     /* Timer ticked -- a set of conversions has been finished.  */
 
214
 
 
215
-    if (!s->busy)
 
216
+    if (!s->busy) {
 
217
+        TRACE("not busy -> exit");
 
218
         return;
 
219
+    }
 
220
 
 
221
     s->busy = 0;
 
222
     s->dav |= mode_regs[s->function];
 
223
-- 
 
224
1.8.5.2
 
225