← Back to branch summary

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

« back to all changes in this revision

Viewing changes to debian/patches/ubuntu/linaro/0018-hw-omap_i2c-non-whitespace-changes-from-overhaul-pat.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/0018-hw-omap_i2c-non-whitespace-changes-from-overhaul-pat.patch
 
1
From 548ab59088ffe9abf79e9a7ce36b69a6b8e30577 Mon Sep 17 00:00:00 2001
 
2
From: Peter Maydell <peter.maydell@linaro.org>
 
3
Date: Mon, 18 Feb 2013 16:58:26 +0000
 
4
Subject: [PATCH 18/70] hw/omap_i2c: non-whitespace changes from overhaul patch
 
5
 
 
6
---
 
7
 hw/i2c/omap_i2c.c | 171 ++++++++++++++++++++++++++++++++++++++++++------------
 
8
 1 file changed, 135 insertions(+), 36 deletions(-)
 
9
 
 
10
diff --git a/hw/i2c/omap_i2c.c b/hw/i2c/omap_i2c.c
 
11
index c054815..565a3cd 100644
 
12
--- a/hw/i2c/omap_i2c.c
 
13
+++ b/hw/i2c/omap_i2c.c
 
14
@@ -2,6 +2,7 @@
 
15
  * TI OMAP on-chip I2C controller.  Only "new I2C" mode supported.
 
16
  *
 
17
  * Copyright (C) 2007 Andrzej Zaborowski  <balrog@zabor.org>
 
18
+ * Copyright (C) 2009 Nokia Corporation
 
19
  *
 
20
  * This program is free software; you can redistribute it and/or
 
21
  * modify it under the terms of the GNU General Public License as
 
22
@@ -40,15 +41,19 @@ typedef struct OMAPI2CState {
 
23
     void *iclk;
 
24
     void *fclk;
 
25
 
 
26
-    uint8_t mask;
 
27
+    uint16_t mask;
 
28
     uint16_t stat;
 
29
+    uint16_t we;
 
30
     uint16_t dma;
 
31
     uint16_t count;
 
32
     int count_cur;
 
33
+    uint16_t sysc;
 
34
     uint16_t control;
 
35
-    uint16_t addr[2];
 
36
+    uint16_t own_addr[4];
 
37
+    uint16_t slave_addr;
 
38
+    uint8_t sblock;
 
39
     uint8_t divider;
 
40
-    uint8_t times[2];
 
41
+    uint16_t times[2];
 
42
     uint16_t test;
 
43
     int fifostart;
 
44
     int fifolen;
 
45
@@ -162,15 +167,23 @@ static void omap_i2c_reset(DeviceState *dev)
 
46
     s->dma = 0;
 
47
     s->count = 0;
 
48
     s->count_cur = 0;
 
49
+    s->we = 0;
 
50
+    s->sysc = 0;
 
51
     s->fifolen = 0;
 
52
     s->fifostart = 0;
 
53
     s->control = 0;
 
54
-    s->addr[0] = 0;
 
55
-    s->addr[1] = 0;
 
56
+    s->own_addr[0] = 0;
 
57
+    s->own_addr[1] = 0;
 
58
+    s->own_addr[2] = 0;
 
59
+    s->own_addr[3] = 0;
 
60
+    s->slave_addr = 0;
 
61
+    s->sblock = 0;
 
62
     s->divider = 0;
 
63
     s->times[0] = 0;
 
64
     s->times[1] = 0;
 
65
     s->test = 0;
 
66
+    
 
67
+    i2c_end_transfer(s->bus);
 
68
 }
 
69
 
 
70
 static uint32_t omap_i2c_read(void *opaque, hwaddr addr)
 
71
@@ -189,7 +202,9 @@ static uint32_t omap_i2c_read(void *opaque, hwaddr addr)
 
72
     case 0x08: /* I2C_STAT */
 
73
         return s->stat | (i2c_bus_busy(s->bus) << 12);
 
74
 
 
75
-    case 0x0c: /* I2C_IV */
 
76
+    case 0x0c: /* I2C_IV / I2C_WE */
 
77
+        if (s->revision >= OMAP3_INTR_REV)
 
78
+            return s->we;
 
79
         if (s->revision >= OMAP2_INTR_REV)
 
80
             break;
 
81
         ret = ffs(s->stat & s->mask);
 
82
@@ -249,16 +264,16 @@ static uint32_t omap_i2c_read(void *opaque, hwaddr addr)
 
83
         return ret;
 
84
 
 
85
     case 0x20: /* I2C_SYSC */
 
86
-        return 0;
 
87
+        return s->sysc;
 
88
 
 
89
     case 0x24: /* I2C_CON */
 
90
         return s->control;
 
91
 
 
92
-    case 0x28: /* I2C_OA */
 
93
-        return s->addr[0];
 
94
+    case 0x28: /* I2C_OA / I2C_OA0 */
 
95
+        return s->own_addr[0];
 
96
 
 
97
     case 0x2c: /* I2C_SA */
 
98
-        return s->addr[1];
 
99
+        return s->slave_addr;
 
100
 
 
101
     case 0x30: /* I2C_PSC */
 
102
         return s->divider;
 
103
@@ -273,8 +288,38 @@ static uint32_t omap_i2c_read(void *opaque, hwaddr addr)
 
104
         if (s->test & (1 << 15)) {                             /* ST_EN */
 
105
             s->test ^= 0xa;
 
106
             return s->test;
 
107
-        } else
 
108
-            return s->test & ~0x300f;
 
109
+        }
 
110
+        return s->test & ~0x300f;
 
111
+    case 0x40: /* I2C_BUFSTAT */
 
112
+        if (s->revision >= OMAP3_INTR_REV) {
 
113
+            switch (s->fifosize) {
 
114
+            case 8:  ret = 0x0000; break;
 
115
+            case 16: ret = 0x4000; break;
 
116
+            case 32: ret = 0x8000; break;
 
117
+            case 64: ret = 0xc000; break;
 
118
+            default: ret = 0x0000; break;
 
119
+            }
 
120
+            ret |= ((s->fifolen) & 0x3f) << 8;  /* RXSTAT */
 
121
+            ret |= (s->count_cur) & 0x3f;       /* TXSTAT */
 
122
+            return ret;
 
123
+        }
 
124
+        break;
 
125
+    case 0x44: /* I2C_OA1 */
 
126
+    case 0x48: /* I2C_OA2 */
 
127
+    case 0x4c: /* I2C_OA3 */
 
128
+        if (s->revision >= OMAP3_INTR_REV)
 
129
+            return s->own_addr[(addr >> 2) & 3];
 
130
+        break;
 
131
+    case 0x50: /* I2C_ACTOA */
 
132
+        if (s->revision >= OMAP3_INTR_REV)
 
133
+            return 0; /* TODO: determine accessed slave own address */
 
134
+        break;
 
135
+    case 0x54: /* I2C_SBLOCK */
 
136
+        if (s->revision >= OMAP3_INTR_REV)
 
137
+            return s->sblock;
 
138
+        break;
 
139
+    default:
 
140
+        break;
 
141
     }
 
142
 
 
143
     OMAP_BAD_REG(addr);
 
144
@@ -290,28 +335,44 @@ static void omap_i2c_write(void *opaque, hwaddr addr,
 
145
 
 
146
     switch (offset) {
 
147
     case 0x00: /* I2C_REV */
 
148
-    case 0x0c: /* I2C_IV */
 
149
     case 0x10: /* I2C_SYSS */
 
150
+    case 0x40: /* I2C_BUFSTAT */
 
151
+    case 0x50: /* I2C_ACTOA */
 
152
         OMAP_RO_REG(addr);
 
153
-        return;
 
154
-
 
155
+        break;
 
156
     case 0x04: /* I2C_IE */
 
157
-        s->mask = value & (s->revision < OMAP2_INTR_REV ? 0x1f : 0x3f);
 
158
+        if (s->revision >= OMAP3_INTR_REV)
 
159
+            s->mask = value & 0x63ff;
 
160
+        else
 
161
+            s->mask = value & (s->revision < OMAP2_INTR_REV ? 0x1f : 0x3f);
 
162
+        omap_i2c_interrupts_update(s);
 
163
         break;
 
164
-
 
165
     case 0x08: /* I2C_STAT */
 
166
-        if (s->revision < OMAP2_INTR_REV) {
 
167
+        if (s->revision < OMAP2_INTR_REV)
 
168
             OMAP_RO_REG(addr);
 
169
-            return;
 
170
+        else {
 
171
+            /* RRDY and XRDY are reset by hardware. (in all versions???) */
 
172
+            s->stat &= ~(value & (s->revision < OMAP3_INTR_REV ? 0x27 : 0x63e7));
 
173
+            omap_i2c_interrupts_update(s);
 
174
         }
 
175
+        break;
 
176
 
 
177
-        /* RRDY and XRDY are reset by hardware. (in all versions???) */
 
178
-        s->stat &= ~(value & 0x27);
 
179
-        omap_i2c_interrupts_update(s);
 
180
+    case 0x0c: /* I2C_IV / I2C_WE */
 
181
+        if (s->revision < OMAP3_INTR_REV)
 
182
+            OMAP_RO_REG(addr);
 
183
+        else
 
184
+            s->we = value & 0x636f;
 
185
         break;
 
186
 
 
187
     case 0x14: /* I2C_BUF */
 
188
-        s->dma = value & 0x8080;
 
189
+        if (s->revision < OMAP3_INTR_REV)
 
190
+            s->dma = value & 0x8080;
 
191
+        else {
 
192
+            s->dma = value & 0xbfbf;
 
193
+            if ((value & (1 << 14))    /* RXFIFO_CLR */
 
194
+                || (value & (1 << 6))) /* TXFIFO_CLR */
 
195
+                s->fifolen = 0;
 
196
+        }
 
197
         if (value & (1 << 15))                                 /* RDMA_EN */
 
198
             s->mask &= ~(1 << 3);                              /* RRDY_IE */
 
199
         if (value & (1 << 7))                                  /* XDMA_EN */
 
200
@@ -355,25 +416,33 @@ static void omap_i2c_write(void *opaque, hwaddr addr,
 
201
     case 0x20: /* I2C_SYSC */
 
202
         if (s->revision < OMAP2_INTR_REV) {
 
203
             OMAP_BAD_REG(addr);
 
204
-            return;
 
205
+            break;
 
206
         }
 
207
 
 
208
         if (value & 2) {
 
209
             omap_i2c_reset(DEVICE(s));
 
210
+        } else if (s->revision >= OMAP3_INTR_REV) {
 
211
+            s->sysc = value & 0x031d;
 
212
         }
 
213
         break;
 
214
 
 
215
     case 0x24: /* I2C_CON */
 
216
-        s->control = value & 0xcf87;
 
217
+        s->control = value & (s->revision < OMAP3_INTR_REV ? 0xcf87 : 0xbff3);
 
218
         if (~value & (1 << 15)) {                              /* I2C_EN */
 
219
             if (s->revision < OMAP2_INTR_REV) {
 
220
                 omap_i2c_reset(DEVICE(s));
 
221
             }
 
222
             break;
 
223
         }
 
224
+        if (s->revision >= OMAP3_INTR_REV && ((value >> 12) & 3) > 1) { /* OPMODE */
 
225
+            fprintf(stderr,
 
226
+                    "%s: only FS and HS modes are supported\n",
 
227
+                    __FUNCTION__);
 
228
+            break;
 
229
+        }
 
230
         if ((value & (1 << 10))) { /* MST */
 
231
             if (value & 1) { /* STT */
 
232
-                nack = !!i2c_start_transfer(s->bus, s->addr[1], /*SA*/
 
233
+                nack = !!i2c_start_transfer(s->bus, s->slave_addr, /*SA*/
 
234
                                             (~value >> 9) & 1);                        /* TRX */
 
235
                 s->stat |= nack << 1;                          /* NACK */
 
236
                 s->control &= ~(1 << 0);                               /* STT */
 
237
@@ -392,13 +461,17 @@ static void omap_i2c_write(void *opaque, hwaddr addr,
 
238
             }
 
239
         }
 
240
         break;
 
241
-
 
242
-    case 0x28: /* I2C_OA */
 
243
-        s->addr[0] = value & 0x3ff;
 
244
+    case 0x28: /* I2C_OA / I2C_OA0 */
 
245
+        s->own_addr[0] = value & (s->revision < OMAP3_INTR_REV
 
246
+                                  ? 0x3ff : 0xe3ff);
 
247
+        /*i2c_set_slave_address(&s->slave[0],
 
248
+          value & (s->revision >= OMAP3_INTR_REV
 
249
+          && (s->control & 0x80)
 
250
+          ? 0x3ff: 0x7f));*/
 
251
         break;
 
252
 
 
253
     case 0x2c: /* I2C_SA */
 
254
-        s->addr[1] = value & 0x3ff;
 
255
+        s->slave_addr = value & 0x3ff;
 
256
         break;
 
257
 
 
258
     case 0x30: /* I2C_PSC */
 
259
@@ -406,27 +479,53 @@ static void omap_i2c_write(void *opaque, hwaddr addr,
 
260
         break;
 
261
 
 
262
     case 0x34: /* I2C_SCLL */
 
263
-        s->times[0] = value;
 
264
+        s->times[0] = value & (s->revision < OMAP3_INTR_REV ? 0xff : 0xffff);
 
265
         break;
 
266
 
 
267
     case 0x38: /* I2C_SCLH */
 
268
-        s->times[1] = value;
 
269
+        s->times[1] = value & (s->revision < OMAP3_INTR_REV ? 0xff : 0xffff);
 
270
         break;
 
271
 
 
272
     case 0x3c: /* I2C_SYSTEST */
 
273
-        s->test = value & 0xf80f;
 
274
+        value &= s->revision < OMAP3_INTR_REV ? 0xf805 : 0xf815;
 
275
+        if ((value & (1 << 15))) { /* ST_EN */
 
276
+            fprintf(stderr, "%s: System Test not supported\n",
 
277
+                    __FUNCTION__);
 
278
+            s->test = (s->test & 0x0a) | value;
 
279
+        } else
 
280
+            s->test = (s->test & 0x1f) | (value & 0xf800);
 
281
         if (value & (1 << 11))                                 /* SBB */
 
282
             if (s->revision >= OMAP2_INTR_REV) {
 
283
                 s->stat |= 0x3f;
 
284
+                if (s->revision >= OMAP3_INTR_REV)
 
285
+                    s->stat |= 0x600;
 
286
                 omap_i2c_interrupts_update(s);
 
287
             }
 
288
-        if (value & (1 << 15))                                 /* ST_EN */
 
289
-            fprintf(stderr, "%s: System Test not supported\n", __FUNCTION__);
 
290
         break;
 
291
 
 
292
+    case 0x44: /* I2C_OA1 */
 
293
+    case 0x48: /* I2C_OA2 */
 
294
+    case 0x4c: /* I2C_OA3 */
 
295
+        if (s->revision < OMAP3_INTR_REV)
 
296
+            OMAP_BAD_REG(addr);
 
297
+        else {
 
298
+            addr = (addr >> 2) & 3;
 
299
+            s->own_addr[addr] = value & 0x3ff;
 
300
+            /*i2c_set_slave_address(&s->slave[addr],
 
301
+              value & ((s->control & (0x80 >> addr))
 
302
+              ? 0x3ff: 0x7f));*/
 
303
+        }
 
304
+        break;
 
305
+    case 0x54: /* I2C_SBLOCK */
 
306
+        if (s->revision < OMAP3_INTR_REV)
 
307
+            OMAP_BAD_REG(addr);
 
308
+        else {
 
309
+            s->sblock = value & 0x0f;
 
310
+        }
 
311
+        break;
 
312
     default:
 
313
         OMAP_BAD_REG(addr);
 
314
-        return;
 
315
+            break;
 
316
     }
 
317
 }
 
318
 
 
319
-- 
 
320
1.8.5.2
 
321