← Back to branch summary

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

« back to all changes in this revision

Viewing changes to .pc/linaro-patches-1.5.0/0045-OMAP-Refactor-DSS-DSI.patch/hw/display/omap_dss.c

  • Committer: Package Import Robot
  • Author(s): Serge Hallyn
  • Date: 2013-10-22 22:47:07 UTC
  • mfrom: (1.8.3) (10.1.42 sid)
  • Revision ID: package-import@ubuntu.com-20131022224707-1lya34fw3k3f24tv
Tags: 1.6.0+dfsg-2ubuntu1
http://bugs.debian.org/709241
* Merge 1.6.0~rc0+dfsg-2exp from debian experimental.  Remaining changes:
  - debian/control
    * update maintainer
    * remove libiscsi, usb-redir, vde, vnc-jpeg, and libssh2-1-dev
      from build-deps
    * enable rbd
    * add qemu-system and qemu-common B/R to qemu-keymaps
    * add D:udev, R:qemu, R:qemu-common and B:qemu-common to
      qemu-system-common
    * qemu-system-arm, qemu-system-ppc, qemu-system-sparc:
      - add qemu-kvm to Provides
      - add qemu-common, qemu-kvm, kvm to B/R
      - remove openbios-sparc from qemu-system-sparc D
      - drop openbios-ppc and openhackware Depends to Suggests (for now)
    * qemu-system-x86:
      - add qemu-common to Breaks/Replaces.
      - add cpu-checker to Recommends.
    * qemu-user: add B/R:qemu-kvm
    * qemu-kvm:
      - add armhf armel powerpc sparc to Architecture
      - C/R/P: qemu-kvm-spice
    * add qemu-common package
    * drop qemu-slof which is not packaged in ubuntu
  - add qemu-system-common.links for tap ifup/down scripts and OVMF link.
  - qemu-system-x86.links:
    * remove pxe rom links which are in kvm-ipxe
    * add symlink for kvm.1 manpage
  - debian/rules
    * add kvm-spice symlink to qemu-kvm
    * call dh_installmodules for qemu-system-x86
    * update dh_installinit to install upstart script
    * run dh_installman (Closes: #709241) (cherrypicked from 1.5.0+dfsg-2)
  - Add qemu-utils.links for kvm-* symlinks.
  - Add qemu-system-x86.qemu-kvm.upstart and .default
  - Add qemu-system-x86.modprobe to set nesting=1
  - Add qemu-system-common.preinst to add kvm group
  - qemu-system-common.postinst: remove bad group acl if there, then have
    udev relabel /dev/kvm.
  - New linaro patches from qemu-linaro rebasing branch
  - Dropped patches:
    * xen-simplify-xen_enabled.patch
    * sparc-linux-user-fix-missing-symbols-in-.rel-.rela.plt-sections.patch
    * main_loop-do-not-set-nonblocking-if-xen_enabled.patch
    * xen_machine_pv-do-not-create-a-dummy-CPU-in-machine-.patch
    * virtio-rng-fix-crash
  - Kept patches:
    * expose_vms_qemu64cpu.patch - updated
    * linaro arm patches from qemu-linaro rebasing branch
  - New patches:
    * fix-pci-add: change CONFIG variable in ifdef to make sure that
      pci_add is defined.
* Add linaro patches
* Add experimental mach-virt patches for arm virtualization.
* qemu-system-common.install: add debian/tmp/usr/lib to install the
  qemu-bridge-helper

Show diffs side-by-side

added added

removed removed

Lines of Context:
.pc/linaro-patches-1.5.0/0045-OMAP-Refactor-DSS-DSI.patch/hw/display/omap_dss.c
1
 
/*
2
 
 * OMAP2 Display Subsystem.
3
 
 *
4
 
 * Copyright (C) 2008 Nokia Corporation
5
 
 * Written by Andrzej Zaborowski <andrew@openedhand.com>
6
 
 *
7
 
 * This program is free software; you can redistribute it and/or
8
 
 * modify it under the terms of the GNU General Public License as
9
 
 * published by the Free Software Foundation; either version 2 or
10
 
 * (at your option) version 3 of the License.
11
 
 *
12
 
 * This program is distributed in the hope that it will be useful,
13
 
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15
 
 * GNU General Public License for more details.
16
 
 *
17
 
 * You should have received a copy of the GNU General Public License along
18
 
 * with this program; if not, see <http://www.gnu.org/licenses/>.
19
 
 */
20
 
#include "hw/hw.h"
21
 
#include "ui/console.h"
22
 
#include "hw/arm/omap.h"
23
 
 
24
 
struct omap_dss_s {
25
 
    qemu_irq irq;
26
 
    qemu_irq drq;
27
 
    DisplayState *state;
28
 
    MemoryRegion iomem_diss1, iomem_disc1, iomem_rfbi1, iomem_venc1, iomem_im3;
29
 
 
30
 
    int autoidle;
31
 
    int control;
32
 
    int enable;
33
 
 
34
 
    struct omap_dss_panel_s {
35
 
        int enable;
36
 
        int nx;
37
 
        int ny;
38
 
 
39
 
        int x;
40
 
        int y;
41
 
    } dig, lcd;
42
 
 
43
 
    struct {
44
 
        uint32_t idlemode;
45
 
        uint32_t irqst;
46
 
        uint32_t irqen;
47
 
        uint32_t control;
48
 
        uint32_t config;
49
 
        uint32_t capable;
50
 
        uint32_t timing[4];
51
 
        int line;
52
 
        uint32_t bg[2];
53
 
        uint32_t trans[2];
54
 
 
55
 
        struct omap_dss_plane_s {
56
 
            int enable;
57
 
            int bpp;
58
 
            int posx;
59
 
            int posy;
60
 
            int nx;
61
 
            int ny;
62
 
 
63
 
            hwaddr addr[3];
64
 
 
65
 
            uint32_t attr;
66
 
            uint32_t tresh;
67
 
            int rowinc;
68
 
            int colinc;
69
 
            int wininc;
70
 
        } l[3];
71
 
 
72
 
        int invalidate;
73
 
        uint16_t palette[256];
74
 
    } dispc;
75
 
 
76
 
    struct {
77
 
        int idlemode;
78
 
        uint32_t control;
79
 
        int enable;
80
 
        int pixels;
81
 
        int busy;
82
 
        int skiplines;
83
 
        uint16_t rxbuf;
84
 
        uint32_t config[2];
85
 
        uint32_t time[4];
86
 
        uint32_t data[6];
87
 
        uint16_t vsync;
88
 
        uint16_t hsync;
89
 
        struct rfbi_chip_s *chip[2];
90
 
    } rfbi;
91
 
};
92
 
 
93
 
static void omap_dispc_interrupt_update(struct omap_dss_s *s)
94
 
{
95
 
    qemu_set_irq(s->irq, s->dispc.irqst & s->dispc.irqen);
96
 
}
97
 
 
98
 
static void omap_rfbi_reset(struct omap_dss_s *s)
99
 
{
100
 
    s->rfbi.idlemode = 0;
101
 
    s->rfbi.control = 2;
102
 
    s->rfbi.enable = 0;
103
 
    s->rfbi.pixels = 0;
104
 
    s->rfbi.skiplines = 0;
105
 
    s->rfbi.busy = 0;
106
 
    s->rfbi.config[0] = 0x00310000;
107
 
    s->rfbi.config[1] = 0x00310000;
108
 
    s->rfbi.time[0] = 0;
109
 
    s->rfbi.time[1] = 0;
110
 
    s->rfbi.time[2] = 0;
111
 
    s->rfbi.time[3] = 0;
112
 
    s->rfbi.data[0] = 0;
113
 
    s->rfbi.data[1] = 0;
114
 
    s->rfbi.data[2] = 0;
115
 
    s->rfbi.data[3] = 0;
116
 
    s->rfbi.data[4] = 0;
117
 
    s->rfbi.data[5] = 0;
118
 
    s->rfbi.vsync = 0;
119
 
    s->rfbi.hsync = 0;
120
 
}
121
 
 
122
 
void omap_dss_reset(struct omap_dss_s *s)
123
 
{
124
 
    s->autoidle = 0;
125
 
    s->control = 0;
126
 
    s->enable = 0;
127
 
 
128
 
    s->dig.enable = 0;
129
 
    s->dig.nx = 1;
130
 
    s->dig.ny = 1;
131
 
 
132
 
    s->lcd.enable = 0;
133
 
    s->lcd.nx = 1;
134
 
    s->lcd.ny = 1;
135
 
 
136
 
    s->dispc.idlemode = 0;
137
 
    s->dispc.irqst = 0;
138
 
    s->dispc.irqen = 0;
139
 
    s->dispc.control = 0;
140
 
    s->dispc.config = 0;
141
 
    s->dispc.capable = 0x161;
142
 
    s->dispc.timing[0] = 0;
143
 
    s->dispc.timing[1] = 0;
144
 
    s->dispc.timing[2] = 0;
145
 
    s->dispc.timing[3] = 0;
146
 
    s->dispc.line = 0;
147
 
    s->dispc.bg[0] = 0;
148
 
    s->dispc.bg[1] = 0;
149
 
    s->dispc.trans[0] = 0;
150
 
    s->dispc.trans[1] = 0;
151
 
 
152
 
    s->dispc.l[0].enable = 0;
153
 
    s->dispc.l[0].bpp = 0;
154
 
    s->dispc.l[0].addr[0] = 0;
155
 
    s->dispc.l[0].addr[1] = 0;
156
 
    s->dispc.l[0].addr[2] = 0;
157
 
    s->dispc.l[0].posx = 0;
158
 
    s->dispc.l[0].posy = 0;
159
 
    s->dispc.l[0].nx = 1;
160
 
    s->dispc.l[0].ny = 1;
161
 
    s->dispc.l[0].attr = 0;
162
 
    s->dispc.l[0].tresh = 0;
163
 
    s->dispc.l[0].rowinc = 1;
164
 
    s->dispc.l[0].colinc = 1;
165
 
    s->dispc.l[0].wininc = 0;
166
 
 
167
 
    omap_rfbi_reset(s);
168
 
    omap_dispc_interrupt_update(s);
169
 
}
170
 
 
171
 
static uint64_t omap_diss_read(void *opaque, hwaddr addr,
172
 
                               unsigned size)
173
 
{
174
 
    struct omap_dss_s *s = (struct omap_dss_s *) opaque;
175
 
 
176
 
    if (size != 4) {
177
 
        return omap_badwidth_read32(opaque, addr);
178
 
    }
179
 
 
180
 
    switch (addr) {
181
 
    case 0x00:  /* DSS_REVISIONNUMBER */
182
 
        return 0x20;
183
 
 
184
 
    case 0x10:  /* DSS_SYSCONFIG */
185
 
        return s->autoidle;
186
 
 
187
 
    case 0x14:  /* DSS_SYSSTATUS */
188
 
        return 1;                                               /* RESETDONE */
189
 
 
190
 
    case 0x40:  /* DSS_CONTROL */
191
 
        return s->control;
192
 
 
193
 
    case 0x50:  /* DSS_PSA_LCD_REG_1 */
194
 
    case 0x54:  /* DSS_PSA_LCD_REG_2 */
195
 
    case 0x58:  /* DSS_PSA_VIDEO_REG */
196
 
        /* TODO: fake some values when appropriate s->control bits are set */
197
 
        return 0;
198
 
 
199
 
    case 0x5c:  /* DSS_STATUS */
200
 
        return 1 + (s->control & 1);
201
 
 
202
 
    default:
203
 
        break;
204
 
    }
205
 
    OMAP_BAD_REG(addr);
206
 
    return 0;
207
 
}
208
 
 
209
 
static void omap_diss_write(void *opaque, hwaddr addr,
210
 
                            uint64_t value, unsigned size)
211
 
{
212
 
    struct omap_dss_s *s = (struct omap_dss_s *) opaque;
213
 
 
214
 
    if (size != 4) {
215
 
        return omap_badwidth_write32(opaque, addr, value);
216
 
    }
217
 
 
218
 
    switch (addr) {
219
 
    case 0x00:  /* DSS_REVISIONNUMBER */
220
 
    case 0x14:  /* DSS_SYSSTATUS */
221
 
    case 0x50:  /* DSS_PSA_LCD_REG_1 */
222
 
    case 0x54:  /* DSS_PSA_LCD_REG_2 */
223
 
    case 0x58:  /* DSS_PSA_VIDEO_REG */
224
 
    case 0x5c:  /* DSS_STATUS */
225
 
        OMAP_RO_REG(addr);
226
 
        break;
227
 
 
228
 
    case 0x10:  /* DSS_SYSCONFIG */
229
 
        if (value & 2)                                          /* SOFTRESET */
230
 
            omap_dss_reset(s);
231
 
        s->autoidle = value & 1;
232
 
        break;
233
 
 
234
 
    case 0x40:  /* DSS_CONTROL */
235
 
        s->control = value & 0x3dd;
236
 
        break;
237
 
 
238
 
    default:
239
 
        OMAP_BAD_REG(addr);
240
 
    }
241
 
}
242
 
 
243
 
static const MemoryRegionOps omap_diss_ops = {
244
 
    .read = omap_diss_read,
245
 
    .write = omap_diss_write,
246
 
    .endianness = DEVICE_NATIVE_ENDIAN,
247
 
};
248
 
 
249
 
static uint64_t omap_disc_read(void *opaque, hwaddr addr,
250
 
                               unsigned size)
251
 
{
252
 
    struct omap_dss_s *s = (struct omap_dss_s *) opaque;
253
 
 
254
 
    if (size != 4) {
255
 
        return omap_badwidth_read32(opaque, addr);
256
 
    }
257
 
 
258
 
    switch (addr) {
259
 
    case 0x000: /* DISPC_REVISION */
260
 
        return 0x20;
261
 
 
262
 
    case 0x010: /* DISPC_SYSCONFIG */
263
 
        return s->dispc.idlemode;
264
 
 
265
 
    case 0x014: /* DISPC_SYSSTATUS */
266
 
        return 1;                                               /* RESETDONE */
267
 
 
268
 
    case 0x018: /* DISPC_IRQSTATUS */
269
 
        return s->dispc.irqst;
270
 
 
271
 
    case 0x01c: /* DISPC_IRQENABLE */
272
 
        return s->dispc.irqen;
273
 
 
274
 
    case 0x040: /* DISPC_CONTROL */
275
 
        return s->dispc.control;
276
 
 
277
 
    case 0x044: /* DISPC_CONFIG */
278
 
        return s->dispc.config;
279
 
 
280
 
    case 0x048: /* DISPC_CAPABLE */
281
 
        return s->dispc.capable;
282
 
 
283
 
    case 0x04c: /* DISPC_DEFAULT_COLOR0 */
284
 
        return s->dispc.bg[0];
285
 
    case 0x050: /* DISPC_DEFAULT_COLOR1 */
286
 
        return s->dispc.bg[1];
287
 
    case 0x054: /* DISPC_TRANS_COLOR0 */
288
 
        return s->dispc.trans[0];
289
 
    case 0x058: /* DISPC_TRANS_COLOR1 */
290
 
        return s->dispc.trans[1];
291
 
 
292
 
    case 0x05c: /* DISPC_LINE_STATUS */
293
 
        return 0x7ff;
294
 
    case 0x060: /* DISPC_LINE_NUMBER */
295
 
        return s->dispc.line;
296
 
 
297
 
    case 0x064: /* DISPC_TIMING_H */
298
 
        return s->dispc.timing[0];
299
 
    case 0x068: /* DISPC_TIMING_V */
300
 
        return s->dispc.timing[1];
301
 
    case 0x06c: /* DISPC_POL_FREQ */
302
 
        return s->dispc.timing[2];
303
 
    case 0x070: /* DISPC_DIVISOR */
304
 
        return s->dispc.timing[3];
305
 
 
306
 
    case 0x078: /* DISPC_SIZE_DIG */
307
 
        return ((s->dig.ny - 1) << 16) | (s->dig.nx - 1);
308
 
    case 0x07c: /* DISPC_SIZE_LCD */
309
 
        return ((s->lcd.ny - 1) << 16) | (s->lcd.nx - 1);
310
 
 
311
 
    case 0x080: /* DISPC_GFX_BA0 */
312
 
        return s->dispc.l[0].addr[0];
313
 
    case 0x084: /* DISPC_GFX_BA1 */
314
 
        return s->dispc.l[0].addr[1];
315
 
    case 0x088: /* DISPC_GFX_POSITION */
316
 
        return (s->dispc.l[0].posy << 16) | s->dispc.l[0].posx;
317
 
    case 0x08c: /* DISPC_GFX_SIZE */
318
 
        return ((s->dispc.l[0].ny - 1) << 16) | (s->dispc.l[0].nx - 1);
319
 
    case 0x0a0: /* DISPC_GFX_ATTRIBUTES */
320
 
        return s->dispc.l[0].attr;
321
 
    case 0x0a4: /* DISPC_GFX_FIFO_TRESHOLD */
322
 
        return s->dispc.l[0].tresh;
323
 
    case 0x0a8: /* DISPC_GFX_FIFO_SIZE_STATUS */
324
 
        return 256;
325
 
    case 0x0ac: /* DISPC_GFX_ROW_INC */
326
 
        return s->dispc.l[0].rowinc;
327
 
    case 0x0b0: /* DISPC_GFX_PIXEL_INC */
328
 
        return s->dispc.l[0].colinc;
329
 
    case 0x0b4: /* DISPC_GFX_WINDOW_SKIP */
330
 
        return s->dispc.l[0].wininc;
331
 
    case 0x0b8: /* DISPC_GFX_TABLE_BA */
332
 
        return s->dispc.l[0].addr[2];
333
 
 
334
 
    case 0x0bc: /* DISPC_VID1_BA0 */
335
 
    case 0x0c0: /* DISPC_VID1_BA1 */
336
 
    case 0x0c4: /* DISPC_VID1_POSITION */
337
 
    case 0x0c8: /* DISPC_VID1_SIZE */
338
 
    case 0x0cc: /* DISPC_VID1_ATTRIBUTES */
339
 
    case 0x0d0: /* DISPC_VID1_FIFO_TRESHOLD */
340
 
    case 0x0d4: /* DISPC_VID1_FIFO_SIZE_STATUS */
341
 
    case 0x0d8: /* DISPC_VID1_ROW_INC */
342
 
    case 0x0dc: /* DISPC_VID1_PIXEL_INC */
343
 
    case 0x0e0: /* DISPC_VID1_FIR */
344
 
    case 0x0e4: /* DISPC_VID1_PICTURE_SIZE */
345
 
    case 0x0e8: /* DISPC_VID1_ACCU0 */
346
 
    case 0x0ec: /* DISPC_VID1_ACCU1 */
347
 
    case 0x0f0 ... 0x140:       /* DISPC_VID1_FIR_COEF, DISPC_VID1_CONV_COEF */
348
 
    case 0x14c: /* DISPC_VID2_BA0 */
349
 
    case 0x150: /* DISPC_VID2_BA1 */
350
 
    case 0x154: /* DISPC_VID2_POSITION */
351
 
    case 0x158: /* DISPC_VID2_SIZE */
352
 
    case 0x15c: /* DISPC_VID2_ATTRIBUTES */
353
 
    case 0x160: /* DISPC_VID2_FIFO_TRESHOLD */
354
 
    case 0x164: /* DISPC_VID2_FIFO_SIZE_STATUS */
355
 
    case 0x168: /* DISPC_VID2_ROW_INC */
356
 
    case 0x16c: /* DISPC_VID2_PIXEL_INC */
357
 
    case 0x170: /* DISPC_VID2_FIR */
358
 
    case 0x174: /* DISPC_VID2_PICTURE_SIZE */
359
 
    case 0x178: /* DISPC_VID2_ACCU0 */
360
 
    case 0x17c: /* DISPC_VID2_ACCU1 */
361
 
    case 0x180 ... 0x1d0:       /* DISPC_VID2_FIR_COEF, DISPC_VID2_CONV_COEF */
362
 
    case 0x1d4: /* DISPC_DATA_CYCLE1 */
363
 
    case 0x1d8: /* DISPC_DATA_CYCLE2 */
364
 
    case 0x1dc: /* DISPC_DATA_CYCLE3 */
365
 
        return 0;
366
 
 
367
 
    default:
368
 
        break;
369
 
    }
370
 
    OMAP_BAD_REG(addr);
371
 
    return 0;
372
 
}
373
 
 
374
 
static void omap_disc_write(void *opaque, hwaddr addr,
375
 
                            uint64_t value, unsigned size)
376
 
{
377
 
    struct omap_dss_s *s = (struct omap_dss_s *) opaque;
378
 
 
379
 
    if (size != 4) {
380
 
        return omap_badwidth_write32(opaque, addr, value);
381
 
    }
382
 
 
383
 
    switch (addr) {
384
 
    case 0x010: /* DISPC_SYSCONFIG */
385
 
        if (value & 2)                                          /* SOFTRESET */
386
 
            omap_dss_reset(s);
387
 
        s->dispc.idlemode = value & 0x301b;
388
 
        break;
389
 
 
390
 
    case 0x018: /* DISPC_IRQSTATUS */
391
 
        s->dispc.irqst &= ~value;
392
 
        omap_dispc_interrupt_update(s);
393
 
        break;
394
 
 
395
 
    case 0x01c: /* DISPC_IRQENABLE */
396
 
        s->dispc.irqen = value & 0xffff;
397
 
        omap_dispc_interrupt_update(s);
398
 
        break;
399
 
 
400
 
    case 0x040: /* DISPC_CONTROL */
401
 
        s->dispc.control = value & 0x07ff9fff;
402
 
        s->dig.enable = (value >> 1) & 1;
403
 
        s->lcd.enable = (value >> 0) & 1;
404
 
        if (value & (1 << 12))                  /* OVERLAY_OPTIMIZATION */
405
 
            if (!((s->dispc.l[1].attr | s->dispc.l[2].attr) & 1)) {
406
 
                fprintf(stderr, "%s: Overlay Optimization when no overlay "
407
 
                        "region effectively exists leads to "
408
 
                        "unpredictable behaviour!\n", __func__);
409
 
            }
410
 
        if (value & (1 << 6)) {                         /* GODIGITAL */
411
 
            /* XXX: Shadowed fields are:
412
 
             * s->dispc.config
413
 
             * s->dispc.capable
414
 
             * s->dispc.bg[0]
415
 
             * s->dispc.bg[1]
416
 
             * s->dispc.trans[0]
417
 
             * s->dispc.trans[1]
418
 
             * s->dispc.line
419
 
             * s->dispc.timing[0]
420
 
             * s->dispc.timing[1]
421
 
             * s->dispc.timing[2]
422
 
             * s->dispc.timing[3]
423
 
             * s->lcd.nx
424
 
             * s->lcd.ny
425
 
             * s->dig.nx
426
 
             * s->dig.ny
427
 
             * s->dispc.l[0].addr[0]
428
 
             * s->dispc.l[0].addr[1]
429
 
             * s->dispc.l[0].addr[2]
430
 
             * s->dispc.l[0].posx
431
 
             * s->dispc.l[0].posy
432
 
             * s->dispc.l[0].nx
433
 
             * s->dispc.l[0].ny
434
 
             * s->dispc.l[0].tresh
435
 
             * s->dispc.l[0].rowinc
436
 
             * s->dispc.l[0].colinc
437
 
             * s->dispc.l[0].wininc
438
 
             * All they need to be loaded here from their shadow registers.
439
 
             */
440
 
        }
441
 
        if (value & (1 << 5)) {                         /* GOLCD */
442
 
             /* XXX: Likewise for LCD here.  */
443
 
        }
444
 
        s->dispc.invalidate = 1;
445
 
        break;
446
 
 
447
 
    case 0x044: /* DISPC_CONFIG */
448
 
        s->dispc.config = value & 0x3fff;
449
 
        /* XXX:
450
 
         * bits 2:1 (LOADMODE) reset to 0 after set to 1 and palette loaded
451
 
         * bits 2:1 (LOADMODE) reset to 2 after set to 3 and palette loaded
452
 
         */
453
 
        s->dispc.invalidate = 1;
454
 
        break;
455
 
 
456
 
    case 0x048: /* DISPC_CAPABLE */
457
 
        s->dispc.capable = value & 0x3ff;
458
 
        break;
459
 
 
460
 
    case 0x04c: /* DISPC_DEFAULT_COLOR0 */
461
 
        s->dispc.bg[0] = value & 0xffffff;
462
 
        s->dispc.invalidate = 1;
463
 
        break;
464
 
    case 0x050: /* DISPC_DEFAULT_COLOR1 */
465
 
        s->dispc.bg[1] = value & 0xffffff;
466
 
        s->dispc.invalidate = 1;
467
 
        break;
468
 
    case 0x054: /* DISPC_TRANS_COLOR0 */
469
 
        s->dispc.trans[0] = value & 0xffffff;
470
 
        s->dispc.invalidate = 1;
471
 
        break;
472
 
    case 0x058: /* DISPC_TRANS_COLOR1 */
473
 
        s->dispc.trans[1] = value & 0xffffff;
474
 
        s->dispc.invalidate = 1;
475
 
        break;
476
 
 
477
 
    case 0x060: /* DISPC_LINE_NUMBER */
478
 
        s->dispc.line = value & 0x7ff;
479
 
        break;
480
 
 
481
 
    case 0x064: /* DISPC_TIMING_H */
482
 
        s->dispc.timing[0] = value & 0x0ff0ff3f;
483
 
        break;
484
 
    case 0x068: /* DISPC_TIMING_V */
485
 
        s->dispc.timing[1] = value & 0x0ff0ff3f;
486
 
        break;
487
 
    case 0x06c: /* DISPC_POL_FREQ */
488
 
        s->dispc.timing[2] = value & 0x0003ffff;
489
 
        break;
490
 
    case 0x070: /* DISPC_DIVISOR */
491
 
        s->dispc.timing[3] = value & 0x00ff00ff;
492
 
        break;
493
 
 
494
 
    case 0x078: /* DISPC_SIZE_DIG */
495
 
        s->dig.nx = ((value >>  0) & 0x7ff) + 1;                /* PPL */
496
 
        s->dig.ny = ((value >> 16) & 0x7ff) + 1;                /* LPP */
497
 
        s->dispc.invalidate = 1;
498
 
        break;
499
 
    case 0x07c: /* DISPC_SIZE_LCD */
500
 
        s->lcd.nx = ((value >>  0) & 0x7ff) + 1;                /* PPL */
501
 
        s->lcd.ny = ((value >> 16) & 0x7ff) + 1;                /* LPP */
502
 
        s->dispc.invalidate = 1;
503
 
        break;
504
 
    case 0x080: /* DISPC_GFX_BA0 */
505
 
        s->dispc.l[0].addr[0] = (hwaddr) value;
506
 
        s->dispc.invalidate = 1;
507
 
        break;
508
 
    case 0x084: /* DISPC_GFX_BA1 */
509
 
        s->dispc.l[0].addr[1] = (hwaddr) value;
510
 
        s->dispc.invalidate = 1;
511
 
        break;
512
 
    case 0x088: /* DISPC_GFX_POSITION */
513
 
        s->dispc.l[0].posx = ((value >>  0) & 0x7ff);           /* GFXPOSX */
514
 
        s->dispc.l[0].posy = ((value >> 16) & 0x7ff);           /* GFXPOSY */
515
 
        s->dispc.invalidate = 1;
516
 
        break;
517
 
    case 0x08c: /* DISPC_GFX_SIZE */
518
 
        s->dispc.l[0].nx = ((value >>  0) & 0x7ff) + 1;         /* GFXSIZEX */
519
 
        s->dispc.l[0].ny = ((value >> 16) & 0x7ff) + 1;         /* GFXSIZEY */
520
 
        s->dispc.invalidate = 1;
521
 
        break;
522
 
    case 0x0a0: /* DISPC_GFX_ATTRIBUTES */
523
 
        s->dispc.l[0].attr = value & 0x7ff;
524
 
        if (value & (3 << 9))
525
 
            fprintf(stderr, "%s: Big-endian pixel format not supported\n",
526
 
                            __FUNCTION__);
527
 
        s->dispc.l[0].enable = value & 1;
528
 
        s->dispc.l[0].bpp = (value >> 1) & 0xf;
529
 
        s->dispc.invalidate = 1;
530
 
        break;
531
 
    case 0x0a4: /* DISPC_GFX_FIFO_TRESHOLD */
532
 
        s->dispc.l[0].tresh = value & 0x01ff01ff;
533
 
        break;
534
 
    case 0x0ac: /* DISPC_GFX_ROW_INC */
535
 
        s->dispc.l[0].rowinc = value;
536
 
        s->dispc.invalidate = 1;
537
 
        break;
538
 
    case 0x0b0: /* DISPC_GFX_PIXEL_INC */
539
 
        s->dispc.l[0].colinc = value;
540
 
        s->dispc.invalidate = 1;
541
 
        break;
542
 
    case 0x0b4: /* DISPC_GFX_WINDOW_SKIP */
543
 
        s->dispc.l[0].wininc = value;
544
 
        break;
545
 
    case 0x0b8: /* DISPC_GFX_TABLE_BA */
546
 
        s->dispc.l[0].addr[2] = (hwaddr) value;
547
 
        s->dispc.invalidate = 1;
548
 
        break;
549
 
 
550
 
    case 0x0bc: /* DISPC_VID1_BA0 */
551
 
    case 0x0c0: /* DISPC_VID1_BA1 */
552
 
    case 0x0c4: /* DISPC_VID1_POSITION */
553
 
    case 0x0c8: /* DISPC_VID1_SIZE */
554
 
    case 0x0cc: /* DISPC_VID1_ATTRIBUTES */
555
 
    case 0x0d0: /* DISPC_VID1_FIFO_TRESHOLD */
556
 
    case 0x0d8: /* DISPC_VID1_ROW_INC */
557
 
    case 0x0dc: /* DISPC_VID1_PIXEL_INC */
558
 
    case 0x0e0: /* DISPC_VID1_FIR */
559
 
    case 0x0e4: /* DISPC_VID1_PICTURE_SIZE */
560
 
    case 0x0e8: /* DISPC_VID1_ACCU0 */
561
 
    case 0x0ec: /* DISPC_VID1_ACCU1 */
562
 
    case 0x0f0 ... 0x140:       /* DISPC_VID1_FIR_COEF, DISPC_VID1_CONV_COEF */
563
 
    case 0x14c: /* DISPC_VID2_BA0 */
564
 
    case 0x150: /* DISPC_VID2_BA1 */
565
 
    case 0x154: /* DISPC_VID2_POSITION */
566
 
    case 0x158: /* DISPC_VID2_SIZE */
567
 
    case 0x15c: /* DISPC_VID2_ATTRIBUTES */
568
 
    case 0x160: /* DISPC_VID2_FIFO_TRESHOLD */
569
 
    case 0x168: /* DISPC_VID2_ROW_INC */
570
 
    case 0x16c: /* DISPC_VID2_PIXEL_INC */
571
 
    case 0x170: /* DISPC_VID2_FIR */
572
 
    case 0x174: /* DISPC_VID2_PICTURE_SIZE */
573
 
    case 0x178: /* DISPC_VID2_ACCU0 */
574
 
    case 0x17c: /* DISPC_VID2_ACCU1 */
575
 
    case 0x180 ... 0x1d0:       /* DISPC_VID2_FIR_COEF, DISPC_VID2_CONV_COEF */
576
 
    case 0x1d4: /* DISPC_DATA_CYCLE1 */
577
 
    case 0x1d8: /* DISPC_DATA_CYCLE2 */
578
 
    case 0x1dc: /* DISPC_DATA_CYCLE3 */
579
 
        break;
580
 
 
581
 
    default:
582
 
        OMAP_BAD_REG(addr);
583
 
    }
584
 
}
585
 
 
586
 
static const MemoryRegionOps omap_disc_ops = {
587
 
    .read = omap_disc_read,
588
 
    .write = omap_disc_write,
589
 
    .endianness = DEVICE_NATIVE_ENDIAN,
590
 
};
591
 
 
592
 
static void omap_rfbi_transfer_stop(struct omap_dss_s *s)
593
 
{
594
 
    if (!s->rfbi.busy)
595
 
        return;
596
 
 
597
 
    /* TODO: in non-Bypass mode we probably need to just deassert the DRQ.  */
598
 
 
599
 
    s->rfbi.busy = 0;
600
 
}
601
 
 
602
 
static void omap_rfbi_transfer_start(struct omap_dss_s *s)
603
 
{
604
 
    void *data;
605
 
    hwaddr len;
606
 
    hwaddr data_addr;
607
 
    int pitch;
608
 
    static void *bounce_buffer;
609
 
    static hwaddr bounce_len;
610
 
 
611
 
    if (!s->rfbi.enable || s->rfbi.busy)
612
 
        return;
613
 
 
614
 
    if (s->rfbi.control & (1 << 1)) {                           /* BYPASS */
615
 
        /* TODO: in non-Bypass mode we probably need to just assert the
616
 
         * DRQ and wait for DMA to write the pixels.  */
617
 
        fprintf(stderr, "%s: Bypass mode unimplemented\n", __FUNCTION__);
618
 
        return;
619
 
    }
620
 
 
621
 
    if (!(s->dispc.control & (1 << 11)))                        /* RFBIMODE */
622
 
        return;
623
 
    /* TODO: check that LCD output is enabled in DISPC.  */
624
 
 
625
 
    s->rfbi.busy = 1;
626
 
 
627
 
    len = s->rfbi.pixels * 2;
628
 
 
629
 
    data_addr = s->dispc.l[0].addr[0];
630
 
    data = cpu_physical_memory_map(data_addr, &len, 0);
631
 
    if (data && len != s->rfbi.pixels * 2) {
632
 
        cpu_physical_memory_unmap(data, len, 0, 0);
633
 
        data = NULL;
634
 
        len = s->rfbi.pixels * 2;
635
 
    }
636
 
    if (!data) {
637
 
        if (len > bounce_len) {
638
 
            bounce_buffer = g_realloc(bounce_buffer, len);
639
 
        }
640
 
        data = bounce_buffer;
641
 
        cpu_physical_memory_read(data_addr, data, len);
642
 
    }
643
 
 
644
 
    /* TODO bpp */
645
 
    s->rfbi.pixels = 0;
646
 
 
647
 
    /* TODO: negative values */
648
 
    pitch = s->dispc.l[0].nx + (s->dispc.l[0].rowinc - 1) / 2;
649
 
 
650
 
    if ((s->rfbi.control & (1 << 2)) && s->rfbi.chip[0])
651
 
        s->rfbi.chip[0]->block(s->rfbi.chip[0]->opaque, 1, data, len, pitch);
652
 
    if ((s->rfbi.control & (1 << 3)) && s->rfbi.chip[1])
653
 
        s->rfbi.chip[1]->block(s->rfbi.chip[1]->opaque, 1, data, len, pitch);
654
 
 
655
 
    if (data != bounce_buffer) {
656
 
        cpu_physical_memory_unmap(data, len, 0, len);
657
 
    }
658
 
 
659
 
    omap_rfbi_transfer_stop(s);
660
 
 
661
 
    /* TODO */
662
 
    s->dispc.irqst |= 1;                                        /* FRAMEDONE */
663
 
    omap_dispc_interrupt_update(s);
664
 
}
665
 
 
666
 
static uint64_t omap_rfbi_read(void *opaque, hwaddr addr,
667
 
                               unsigned size)
668
 
{
669
 
    struct omap_dss_s *s = (struct omap_dss_s *) opaque;
670
 
 
671
 
    if (size != 4) {
672
 
        return omap_badwidth_read32(opaque, addr);
673
 
    }
674
 
 
675
 
    switch (addr) {
676
 
    case 0x00:  /* RFBI_REVISION */
677
 
        return 0x10;
678
 
 
679
 
    case 0x10:  /* RFBI_SYSCONFIG */
680
 
        return s->rfbi.idlemode;
681
 
 
682
 
    case 0x14:  /* RFBI_SYSSTATUS */
683
 
        return 1 | (s->rfbi.busy << 8);                         /* RESETDONE */
684
 
 
685
 
    case 0x40:  /* RFBI_CONTROL */
686
 
        return s->rfbi.control;
687
 
 
688
 
    case 0x44:  /* RFBI_PIXELCNT */
689
 
        return s->rfbi.pixels;
690
 
 
691
 
    case 0x48:  /* RFBI_LINE_NUMBER */
692
 
        return s->rfbi.skiplines;
693
 
 
694
 
    case 0x58:  /* RFBI_READ */
695
 
    case 0x5c:  /* RFBI_STATUS */
696
 
        return s->rfbi.rxbuf;
697
 
 
698
 
    case 0x60:  /* RFBI_CONFIG0 */
699
 
        return s->rfbi.config[0];
700
 
    case 0x64:  /* RFBI_ONOFF_TIME0 */
701
 
        return s->rfbi.time[0];
702
 
    case 0x68:  /* RFBI_CYCLE_TIME0 */
703
 
        return s->rfbi.time[1];
704
 
    case 0x6c:  /* RFBI_DATA_CYCLE1_0 */
705
 
        return s->rfbi.data[0];
706
 
    case 0x70:  /* RFBI_DATA_CYCLE2_0 */
707
 
        return s->rfbi.data[1];
708
 
    case 0x74:  /* RFBI_DATA_CYCLE3_0 */
709
 
        return s->rfbi.data[2];
710
 
 
711
 
    case 0x78:  /* RFBI_CONFIG1 */
712
 
        return s->rfbi.config[1];
713
 
    case 0x7c:  /* RFBI_ONOFF_TIME1 */
714
 
        return s->rfbi.time[2];
715
 
    case 0x80:  /* RFBI_CYCLE_TIME1 */
716
 
        return s->rfbi.time[3];
717
 
    case 0x84:  /* RFBI_DATA_CYCLE1_1 */
718
 
        return s->rfbi.data[3];
719
 
    case 0x88:  /* RFBI_DATA_CYCLE2_1 */
720
 
        return s->rfbi.data[4];
721
 
    case 0x8c:  /* RFBI_DATA_CYCLE3_1 */
722
 
        return s->rfbi.data[5];
723
 
 
724
 
    case 0x90:  /* RFBI_VSYNC_WIDTH */
725
 
        return s->rfbi.vsync;
726
 
    case 0x94:  /* RFBI_HSYNC_WIDTH */
727
 
        return s->rfbi.hsync;
728
 
    }
729
 
    OMAP_BAD_REG(addr);
730
 
    return 0;
731
 
}
732
 
 
733
 
static void omap_rfbi_write(void *opaque, hwaddr addr,
734
 
                            uint64_t value, unsigned size)
735
 
{
736
 
    struct omap_dss_s *s = (struct omap_dss_s *) opaque;
737
 
 
738
 
    if (size != 4) {
739
 
        return omap_badwidth_write32(opaque, addr, value);
740
 
    }
741
 
 
742
 
    switch (addr) {
743
 
    case 0x10:  /* RFBI_SYSCONFIG */
744
 
        if (value & 2)                                          /* SOFTRESET */
745
 
            omap_rfbi_reset(s);
746
 
        s->rfbi.idlemode = value & 0x19;
747
 
        break;
748
 
 
749
 
    case 0x40:  /* RFBI_CONTROL */
750
 
        s->rfbi.control = value & 0xf;
751
 
        s->rfbi.enable = value & 1;
752
 
        if (value & (1 << 4) &&                                 /* ITE */
753
 
                        !(s->rfbi.config[0] & s->rfbi.config[1] & 0xc))
754
 
            omap_rfbi_transfer_start(s);
755
 
        break;
756
 
 
757
 
    case 0x44:  /* RFBI_PIXELCNT */
758
 
        s->rfbi.pixels = value;
759
 
        break;
760
 
 
761
 
    case 0x48:  /* RFBI_LINE_NUMBER */
762
 
        s->rfbi.skiplines = value & 0x7ff;
763
 
        break;
764
 
 
765
 
    case 0x4c:  /* RFBI_CMD */
766
 
        if ((s->rfbi.control & (1 << 2)) && s->rfbi.chip[0])
767
 
            s->rfbi.chip[0]->write(s->rfbi.chip[0]->opaque, 0, value & 0xffff);
768
 
        if ((s->rfbi.control & (1 << 3)) && s->rfbi.chip[1])
769
 
            s->rfbi.chip[1]->write(s->rfbi.chip[1]->opaque, 0, value & 0xffff);
770
 
        break;
771
 
    case 0x50:  /* RFBI_PARAM */
772
 
        if ((s->rfbi.control & (1 << 2)) && s->rfbi.chip[0])
773
 
            s->rfbi.chip[0]->write(s->rfbi.chip[0]->opaque, 1, value & 0xffff);
774
 
        if ((s->rfbi.control & (1 << 3)) && s->rfbi.chip[1])
775
 
            s->rfbi.chip[1]->write(s->rfbi.chip[1]->opaque, 1, value & 0xffff);
776
 
        break;
777
 
    case 0x54:  /* RFBI_DATA */
778
 
        /* TODO: take into account the format set up in s->rfbi.config[?] and
779
 
         * s->rfbi.data[?], but special-case the most usual scenario so that
780
 
         * speed doesn't suffer.  */
781
 
        if ((s->rfbi.control & (1 << 2)) && s->rfbi.chip[0]) {
782
 
            s->rfbi.chip[0]->write(s->rfbi.chip[0]->opaque, 1, value & 0xffff);
783
 
            s->rfbi.chip[0]->write(s->rfbi.chip[0]->opaque, 1, value >> 16);
784
 
        }
785
 
        if ((s->rfbi.control & (1 << 3)) && s->rfbi.chip[1]) {
786
 
            s->rfbi.chip[1]->write(s->rfbi.chip[1]->opaque, 1, value & 0xffff);
787
 
            s->rfbi.chip[1]->write(s->rfbi.chip[1]->opaque, 1, value >> 16);
788
 
        }
789
 
        if (!-- s->rfbi.pixels)
790
 
            omap_rfbi_transfer_stop(s);
791
 
        break;
792
 
    case 0x58:  /* RFBI_READ */
793
 
        if ((s->rfbi.control & (1 << 2)) && s->rfbi.chip[0])
794
 
            s->rfbi.rxbuf = s->rfbi.chip[0]->read(s->rfbi.chip[0]->opaque, 1);
795
 
        else if ((s->rfbi.control & (1 << 3)) && s->rfbi.chip[1])
796
 
            s->rfbi.rxbuf = s->rfbi.chip[1]->read(s->rfbi.chip[1]->opaque, 1);
797
 
        if (!-- s->rfbi.pixels)
798
 
            omap_rfbi_transfer_stop(s);
799
 
        break;
800
 
 
801
 
    case 0x5c:  /* RFBI_STATUS */
802
 
        if ((s->rfbi.control & (1 << 2)) && s->rfbi.chip[0])
803
 
            s->rfbi.rxbuf = s->rfbi.chip[0]->read(s->rfbi.chip[0]->opaque, 0);
804
 
        else if ((s->rfbi.control & (1 << 3)) && s->rfbi.chip[1])
805
 
            s->rfbi.rxbuf = s->rfbi.chip[1]->read(s->rfbi.chip[1]->opaque, 0);
806
 
        if (!-- s->rfbi.pixels)
807
 
            omap_rfbi_transfer_stop(s);
808
 
        break;
809
 
 
810
 
    case 0x60:  /* RFBI_CONFIG0 */
811
 
        s->rfbi.config[0] = value & 0x003f1fff;
812
 
        break;
813
 
 
814
 
    case 0x64:  /* RFBI_ONOFF_TIME0 */
815
 
        s->rfbi.time[0] = value & 0x3fffffff;
816
 
        break;
817
 
    case 0x68:  /* RFBI_CYCLE_TIME0 */
818
 
        s->rfbi.time[1] = value & 0x0fffffff;
819
 
        break;
820
 
    case 0x6c:  /* RFBI_DATA_CYCLE1_0 */
821
 
        s->rfbi.data[0] = value & 0x0f1f0f1f;
822
 
        break;
823
 
    case 0x70:  /* RFBI_DATA_CYCLE2_0 */
824
 
        s->rfbi.data[1] = value & 0x0f1f0f1f;
825
 
        break;
826
 
    case 0x74:  /* RFBI_DATA_CYCLE3_0 */
827
 
        s->rfbi.data[2] = value & 0x0f1f0f1f;
828
 
        break;
829
 
    case 0x78:  /* RFBI_CONFIG1 */
830
 
        s->rfbi.config[1] = value & 0x003f1fff;
831
 
        break;
832
 
 
833
 
    case 0x7c:  /* RFBI_ONOFF_TIME1 */
834
 
        s->rfbi.time[2] = value & 0x3fffffff;
835
 
        break;
836
 
    case 0x80:  /* RFBI_CYCLE_TIME1 */
837
 
        s->rfbi.time[3] = value & 0x0fffffff;
838
 
        break;
839
 
    case 0x84:  /* RFBI_DATA_CYCLE1_1 */
840
 
        s->rfbi.data[3] = value & 0x0f1f0f1f;
841
 
        break;
842
 
    case 0x88:  /* RFBI_DATA_CYCLE2_1 */
843
 
        s->rfbi.data[4] = value & 0x0f1f0f1f;
844
 
        break;
845
 
    case 0x8c:  /* RFBI_DATA_CYCLE3_1 */
846
 
        s->rfbi.data[5] = value & 0x0f1f0f1f;
847
 
        break;
848
 
 
849
 
    case 0x90:  /* RFBI_VSYNC_WIDTH */
850
 
        s->rfbi.vsync = value & 0xffff;
851
 
        break;
852
 
    case 0x94:  /* RFBI_HSYNC_WIDTH */
853
 
        s->rfbi.hsync = value & 0xffff;
854
 
        break;
855
 
 
856
 
    default:
857
 
        OMAP_BAD_REG(addr);
858
 
    }
859
 
}
860
 
 
861
 
static const MemoryRegionOps omap_rfbi_ops = {
862
 
    .read = omap_rfbi_read,
863
 
    .write = omap_rfbi_write,
864
 
    .endianness = DEVICE_NATIVE_ENDIAN,
865
 
};
866
 
 
867
 
static uint64_t omap_venc_read(void *opaque, hwaddr addr,
868
 
                               unsigned size)
869
 
{
870
 
    if (size != 4) {
871
 
        return omap_badwidth_read32(opaque, addr);
872
 
    }
873
 
 
874
 
    switch (addr) {
875
 
    case 0x00:  /* REV_ID */
876
 
    case 0x04:  /* STATUS */
877
 
    case 0x08:  /* F_CONTROL */
878
 
    case 0x10:  /* VIDOUT_CTRL */
879
 
    case 0x14:  /* SYNC_CTRL */
880
 
    case 0x1c:  /* LLEN */
881
 
    case 0x20:  /* FLENS */
882
 
    case 0x24:  /* HFLTR_CTRL */
883
 
    case 0x28:  /* CC_CARR_WSS_CARR */
884
 
    case 0x2c:  /* C_PHASE */
885
 
    case 0x30:  /* GAIN_U */
886
 
    case 0x34:  /* GAIN_V */
887
 
    case 0x38:  /* GAIN_Y */
888
 
    case 0x3c:  /* BLACK_LEVEL */
889
 
    case 0x40:  /* BLANK_LEVEL */
890
 
    case 0x44:  /* X_COLOR */
891
 
    case 0x48:  /* M_CONTROL */
892
 
    case 0x4c:  /* BSTAMP_WSS_DATA */
893
 
    case 0x50:  /* S_CARR */
894
 
    case 0x54:  /* LINE21 */
895
 
    case 0x58:  /* LN_SEL */
896
 
    case 0x5c:  /* L21__WC_CTL */
897
 
    case 0x60:  /* HTRIGGER_VTRIGGER */
898
 
    case 0x64:  /* SAVID__EAVID */
899
 
    case 0x68:  /* FLEN__FAL */
900
 
    case 0x6c:  /* LAL__PHASE_RESET */
901
 
    case 0x70:  /* HS_INT_START_STOP_X */
902
 
    case 0x74:  /* HS_EXT_START_STOP_X */
903
 
    case 0x78:  /* VS_INT_START_X */
904
 
    case 0x7c:  /* VS_INT_STOP_X__VS_INT_START_Y */
905
 
    case 0x80:  /* VS_INT_STOP_Y__VS_INT_START_X */
906
 
    case 0x84:  /* VS_EXT_STOP_X__VS_EXT_START_Y */
907
 
    case 0x88:  /* VS_EXT_STOP_Y */
908
 
    case 0x90:  /* AVID_START_STOP_X */
909
 
    case 0x94:  /* AVID_START_STOP_Y */
910
 
    case 0xa0:  /* FID_INT_START_X__FID_INT_START_Y */
911
 
    case 0xa4:  /* FID_INT_OFFSET_Y__FID_EXT_START_X */
912
 
    case 0xa8:  /* FID_EXT_START_Y__FID_EXT_OFFSET_Y */
913
 
    case 0xb0:  /* TVDETGP_INT_START_STOP_X */
914
 
    case 0xb4:  /* TVDETGP_INT_START_STOP_Y */
915
 
    case 0xb8:  /* GEN_CTRL */
916
 
    case 0xc4:  /* DAC_TST__DAC_A */
917
 
    case 0xc8:  /* DAC_B__DAC_C */
918
 
        return 0;
919
 
 
920
 
    default:
921
 
        break;
922
 
    }
923
 
    OMAP_BAD_REG(addr);
924
 
    return 0;
925
 
}
926
 
 
927
 
static void omap_venc_write(void *opaque, hwaddr addr,
928
 
                            uint64_t value, unsigned size)
929
 
{
930
 
    if (size != 4) {
931
 
        return omap_badwidth_write32(opaque, addr, size);
932
 
    }
933
 
 
934
 
    switch (addr) {
935
 
    case 0x08:  /* F_CONTROL */
936
 
    case 0x10:  /* VIDOUT_CTRL */
937
 
    case 0x14:  /* SYNC_CTRL */
938
 
    case 0x1c:  /* LLEN */
939
 
    case 0x20:  /* FLENS */
940
 
    case 0x24:  /* HFLTR_CTRL */
941
 
    case 0x28:  /* CC_CARR_WSS_CARR */
942
 
    case 0x2c:  /* C_PHASE */
943
 
    case 0x30:  /* GAIN_U */
944
 
    case 0x34:  /* GAIN_V */
945
 
    case 0x38:  /* GAIN_Y */
946
 
    case 0x3c:  /* BLACK_LEVEL */
947
 
    case 0x40:  /* BLANK_LEVEL */
948
 
    case 0x44:  /* X_COLOR */
949
 
    case 0x48:  /* M_CONTROL */
950
 
    case 0x4c:  /* BSTAMP_WSS_DATA */
951
 
    case 0x50:  /* S_CARR */
952
 
    case 0x54:  /* LINE21 */
953
 
    case 0x58:  /* LN_SEL */
954
 
    case 0x5c:  /* L21__WC_CTL */
955
 
    case 0x60:  /* HTRIGGER_VTRIGGER */
956
 
    case 0x64:  /* SAVID__EAVID */
957
 
    case 0x68:  /* FLEN__FAL */
958
 
    case 0x6c:  /* LAL__PHASE_RESET */
959
 
    case 0x70:  /* HS_INT_START_STOP_X */
960
 
    case 0x74:  /* HS_EXT_START_STOP_X */
961
 
    case 0x78:  /* VS_INT_START_X */
962
 
    case 0x7c:  /* VS_INT_STOP_X__VS_INT_START_Y */
963
 
    case 0x80:  /* VS_INT_STOP_Y__VS_INT_START_X */
964
 
    case 0x84:  /* VS_EXT_STOP_X__VS_EXT_START_Y */
965
 
    case 0x88:  /* VS_EXT_STOP_Y */
966
 
    case 0x90:  /* AVID_START_STOP_X */
967
 
    case 0x94:  /* AVID_START_STOP_Y */
968
 
    case 0xa0:  /* FID_INT_START_X__FID_INT_START_Y */
969
 
    case 0xa4:  /* FID_INT_OFFSET_Y__FID_EXT_START_X */
970
 
    case 0xa8:  /* FID_EXT_START_Y__FID_EXT_OFFSET_Y */
971
 
    case 0xb0:  /* TVDETGP_INT_START_STOP_X */
972
 
    case 0xb4:  /* TVDETGP_INT_START_STOP_Y */
973
 
    case 0xb8:  /* GEN_CTRL */
974
 
    case 0xc4:  /* DAC_TST__DAC_A */
975
 
    case 0xc8:  /* DAC_B__DAC_C */
976
 
        break;
977
 
 
978
 
    default:
979
 
        OMAP_BAD_REG(addr);
980
 
    }
981
 
}
982
 
 
983
 
static const MemoryRegionOps omap_venc_ops = {
984
 
    .read = omap_venc_read,
985
 
    .write = omap_venc_write,
986
 
    .endianness = DEVICE_NATIVE_ENDIAN,
987
 
};
988
 
 
989
 
static uint64_t omap_im3_read(void *opaque, hwaddr addr,
990
 
                              unsigned size)
991
 
{
992
 
    if (size != 4) {
993
 
        return omap_badwidth_read32(opaque, addr);
994
 
    }
995
 
 
996
 
    switch (addr) {
997
 
    case 0x0a8: /* SBIMERRLOGA */
998
 
    case 0x0b0: /* SBIMERRLOG */
999
 
    case 0x190: /* SBIMSTATE */
1000
 
    case 0x198: /* SBTMSTATE_L */
1001
 
    case 0x19c: /* SBTMSTATE_H */
1002
 
    case 0x1a8: /* SBIMCONFIG_L */
1003
 
    case 0x1ac: /* SBIMCONFIG_H */
1004
 
    case 0x1f8: /* SBID_L */
1005
 
    case 0x1fc: /* SBID_H */
1006
 
        return 0;
1007
 
 
1008
 
    default:
1009
 
        break;
1010
 
    }
1011
 
    OMAP_BAD_REG(addr);
1012
 
    return 0;
1013
 
}
1014
 
 
1015
 
static void omap_im3_write(void *opaque, hwaddr addr,
1016
 
                           uint64_t value, unsigned size)
1017
 
{
1018
 
    if (size != 4) {
1019
 
        return omap_badwidth_write32(opaque, addr, value);
1020
 
    }
1021
 
 
1022
 
    switch (addr) {
1023
 
    case 0x0b0: /* SBIMERRLOG */
1024
 
    case 0x190: /* SBIMSTATE */
1025
 
    case 0x198: /* SBTMSTATE_L */
1026
 
    case 0x19c: /* SBTMSTATE_H */
1027
 
    case 0x1a8: /* SBIMCONFIG_L */
1028
 
    case 0x1ac: /* SBIMCONFIG_H */
1029
 
        break;
1030
 
 
1031
 
    default:
1032
 
        OMAP_BAD_REG(addr);
1033
 
    }
1034
 
}
1035
 
 
1036
 
static const MemoryRegionOps omap_im3_ops = {
1037
 
    .read = omap_im3_read,
1038
 
    .write = omap_im3_write,
1039
 
    .endianness = DEVICE_NATIVE_ENDIAN,
1040
 
};
1041
 
 
1042
 
struct omap_dss_s *omap_dss_init(struct omap_target_agent_s *ta,
1043
 
                MemoryRegion *sysmem,
1044
 
                hwaddr l3_base,
1045
 
                qemu_irq irq, qemu_irq drq,
1046
 
                omap_clk fck1, omap_clk fck2, omap_clk ck54m,
1047
 
                omap_clk ick1, omap_clk ick2)
1048
 
{
1049
 
    struct omap_dss_s *s = (struct omap_dss_s *)
1050
 
            g_malloc0(sizeof(struct omap_dss_s));
1051
 
 
1052
 
    s->irq = irq;
1053
 
    s->drq = drq;
1054
 
    omap_dss_reset(s);
1055
 
 
1056
 
    memory_region_init_io(&s->iomem_diss1, &omap_diss_ops, s, "omap.diss1",
1057
 
                          omap_l4_region_size(ta, 0));
1058
 
    memory_region_init_io(&s->iomem_disc1, &omap_disc_ops, s, "omap.disc1",
1059
 
                          omap_l4_region_size(ta, 1));
1060
 
    memory_region_init_io(&s->iomem_rfbi1, &omap_rfbi_ops, s, "omap.rfbi1",
1061
 
                          omap_l4_region_size(ta, 2));
1062
 
    memory_region_init_io(&s->iomem_venc1, &omap_venc_ops, s, "omap.venc1",
1063
 
                          omap_l4_region_size(ta, 3));
1064
 
    memory_region_init_io(&s->iomem_im3, &omap_im3_ops, s,
1065
 
                          "omap.im3", 0x1000);
1066
 
 
1067
 
    omap_l4_attach(ta, 0, &s->iomem_diss1);
1068
 
    omap_l4_attach(ta, 1, &s->iomem_disc1);
1069
 
    omap_l4_attach(ta, 2, &s->iomem_rfbi1);
1070
 
    omap_l4_attach(ta, 3, &s->iomem_venc1);
1071
 
    memory_region_add_subregion(sysmem, l3_base, &s->iomem_im3);
1072
 
 
1073
 
#if 0
1074
 
    s->state = graphic_console_init(omap_update_display,
1075
 
                                    omap_invalidate_display, omap_screen_dump, s);
1076
 
#endif
1077
 
 
1078
 
    return s;
1079
 
}
1080
 
 
1081
 
void omap_rfbi_attach(struct omap_dss_s *s, int cs, struct rfbi_chip_s *chip)
1082
 
{
1083
 
    if (cs < 0 || cs > 1)
1084
 
        hw_error("%s: wrong CS %i\n", __FUNCTION__, cs);
1085
 
    s->rfbi.chip[cs] = chip;
1086
 
}