pl111.cc revision 8661 
1/*
2 * Copyright (c) 2010 ARM Limited
3 * All rights reserved
4 *
5 * The license below extends only to copyright in the software and shall
6 * not be construed as granting a license to any other intellectual
7 * property including but not limited to intellectual property relating
8 * to a hardware implementation of the functionality of the software
9 * licensed hereunder.  You may use the software subject to the license
10 * terms below provided that you ensure that this notice is replicated
11 * unmodified and in its entirety in all distributions of the software,
12 * modified or unmodified, in source code or in binary form.
13 *
14 * Redistribution and use in source and binary forms, with or without
15 * modification, are permitted provided that the following conditions are
16 * met: redistributions of source code must retain the above copyright
17 * notice, this list of conditions and the following disclaimer;
18 * redistributions in binary form must reproduce the above copyright
19 * notice, this list of conditions and the following disclaimer in the
20 * documentation and/or other materials provided with the distribution;
21 * neither the name of the copyright holders nor the names of its
22 * contributors may be used to endorse or promote products derived from
23 * this software without specific prior written permission.
24 *
25 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
26 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
27 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
28 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
29 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
30 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
31 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
32 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
33 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
34 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
35 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
36 *
37 * Authors: William Wang
38 *          Ali Saidi
39 */
40
41#include "base/vnc/vncserver.hh"
42#include "base/bitmap.hh"
43#include "base/output.hh"
44#include "base/trace.hh"
45#include "debug/PL111.hh"
46#include "debug/Uart.hh"
47#include "dev/arm/amba_device.hh"
48#include "dev/arm/gic.hh"
49#include "dev/arm/pl111.hh"
50#include "mem/packet.hh"
51#include "mem/packet_access.hh"
52
53using namespace AmbaDev;
54
55// initialize clcd registers
56Pl111::Pl111(const Params *p)
57    : AmbaDmaDevice(p), lcdTiming0(0), lcdTiming1(0), lcdTiming2(0),
58      lcdTiming3(0), lcdUpbase(0), lcdLpbase(0), lcdControl(0), lcdImsc(0),
59      lcdRis(0), lcdMis(0),
60      clcdCrsrCtrl(0), clcdCrsrConfig(0), clcdCrsrPalette0(0),
61      clcdCrsrPalette1(0), clcdCrsrXY(0), clcdCrsrClip(0), clcdCrsrImsc(0),
62      clcdCrsrIcr(0), clcdCrsrRis(0), clcdCrsrMis(0), clock(p->clock),
63      vncserver(p->vnc), bmp(NULL), width(LcdMaxWidth), height(LcdMaxHeight),
64      bytesPerPixel(4), startTime(0), startAddr(0), maxAddr(0), curAddr(0),
65      waterMark(0), dmaPendingNum(0), readEvent(this), fillFifoEvent(this),
66      dmaDoneEvent(maxOutstandingDma, this), intEvent(this)
67{
68    pioSize = 0xFFFF;
69
70    pic = simout.create(csprintf("%s.framebuffer.bmp", sys->name()), true);
71
72    dmaBuffer = new uint8_t[LcdMaxWidth * LcdMaxHeight * sizeof(uint32_t)];
73
74    memset(lcdPalette, 0, sizeof(lcdPalette));
75    memset(cursorImage, 0, sizeof(cursorImage));
76    memset(dmaBuffer, 0, sizeof(dmaBuffer));
77
78    if (vncserver)
79        vncserver->setFramebufferAddr(dmaBuffer);
80}
81
82// read registers and frame buffer
83Tick
84Pl111::read(PacketPtr pkt)
85{
86    // use a temporary data since the LCD registers are read/written with
87    // different size operations
88
89    uint32_t data = 0;
90
91    assert(pkt->getAddr() >= pioAddr &&
92           pkt->getAddr() < pioAddr + pioSize);
93
94    Addr daddr = pkt->getAddr() - pioAddr;
95    pkt->allocate();
96
97    DPRINTF(PL111, " read register %#x size=%d\n", daddr, pkt->getSize());
98
99    switch (daddr) {
100      case LcdTiming0:
101        data = lcdTiming0;
102        break;
103      case LcdTiming1:
104        data = lcdTiming1;
105        break;
106      case LcdTiming2:
107        data = lcdTiming2;
108        break;
109      case LcdTiming3:
110        data = lcdTiming3;
111        break;
112      case LcdUpBase:
113        data = lcdUpbase;
114        break;
115      case LcdLpBase:
116        data = lcdLpbase;
117        break;
118      case LcdControl:
119        data = lcdControl;
120        break;
121      case LcdImsc:
122        data = lcdImsc;
123        break;
124      case LcdRis:
125        data = lcdRis;
126        break;
127      case LcdMis:
128        data = lcdMis;
129        break;
130      case LcdIcr:
131        panic("LCD register at offset %#x is Write-Only\n", daddr);
132        break;
133      case LcdUpCurr:
134        data = curAddr;
135        break;
136      case LcdLpCurr:
137        data = curAddr;
138        break;
139      case ClcdCrsrCtrl:
140        data = clcdCrsrCtrl;
141        break;
142      case ClcdCrsrConfig:
143        data = clcdCrsrConfig;
144        break;
145      case ClcdCrsrPalette0:
146        data = clcdCrsrPalette0;
147        break;
148      case ClcdCrsrPalette1:
149        data = clcdCrsrPalette1;
150        break;
151      case ClcdCrsrXY:
152        data = clcdCrsrXY;
153        break;
154      case ClcdCrsrClip:
155        data = clcdCrsrClip;
156        break;
157      case ClcdCrsrImsc:
158        data = clcdCrsrImsc;
159        break;
160      case ClcdCrsrIcr:
161        panic("CLCD register at offset %#x is Write-Only\n", daddr);
162        break;
163      case ClcdCrsrRis:
164        data = clcdCrsrRis;
165        break;
166      case ClcdCrsrMis:
167        data = clcdCrsrMis;
168        break;
169      default:
170        if (AmbaDev::readId(pkt, AMBA_ID, pioAddr)) {
171            // Hack for variable size accesses
172            data = pkt->get<uint32_t>();
173            break;
174        } else if (daddr >= CrsrImage && daddr <= 0xBFC) {
175            // CURSOR IMAGE
176            int index;
177            index = (daddr - CrsrImage) >> 2;
178            data= cursorImage[index];
179            break;
180        } else if (daddr >= LcdPalette && daddr <= 0x3FC) {
181            // LCD Palette
182            int index;
183            index = (daddr - LcdPalette) >> 2;
184            data = lcdPalette[index];
185            break;
186        } else {
187            panic("Tried to read CLCD register at offset %#x that \
188                       doesn't exist\n", daddr);
189            break;
190        }
191    }
192
193    switch(pkt->getSize()) {
194      case 1:
195        pkt->set<uint8_t>(data);
196        break;
197      case 2:
198        pkt->set<uint16_t>(data);
199        break;
200      case 4:
201        pkt->set<uint32_t>(data);
202        break;
203      default:
204        panic("CLCD controller read size too big?\n");
205        break;
206    }
207
208    pkt->makeAtomicResponse();
209    return pioDelay;
210}
211
212// write registers and frame buffer
213Tick
214Pl111::write(PacketPtr pkt)
215{
216    // use a temporary data since the LCD registers are read/written with
217    // different size operations
218    //
219    uint32_t data = 0;
220
221    switch(pkt->getSize()) {
222      case 1:
223        data = pkt->get<uint8_t>();
224        break;
225      case 2:
226        data = pkt->get<uint16_t>();
227        break;
228      case 4:
229        data = pkt->get<uint32_t>();
230        break;
231      default:
232        panic("PL111 CLCD controller write size too big?\n");
233        break;
234    }
235
236    assert(pkt->getAddr() >= pioAddr &&
237           pkt->getAddr() < pioAddr + pioSize);
238
239    Addr daddr = pkt->getAddr() - pioAddr;
240
241    DPRINTF(PL111, " write register %#x value %#x size=%d\n", daddr,
242            pkt->get<uint8_t>(), pkt->getSize());
243
244    switch (daddr) {
245      case LcdTiming0:
246        lcdTiming0 = data;
247        // width = 16 * (PPL+1)
248        width = (lcdTiming0.ppl + 1) << 4;
249        break;
250      case LcdTiming1:
251        lcdTiming1 = data;
252        // height = LPP + 1
253        height = (lcdTiming1.lpp) + 1;
254        break;
255      case LcdTiming2:
256        lcdTiming2 = data;
257        break;
258      case LcdTiming3:
259        lcdTiming3 = data;
260        break;
261      case LcdUpBase:
262        lcdUpbase = data;
263        DPRINTF(PL111, "####### Upper panel base set to: %#x #######\n", lcdUpbase);
264        break;
265      case LcdLpBase:
266        warn_once("LCD dual screen mode not supported\n");
267        lcdLpbase = data;
268        DPRINTF(PL111, "###### Lower panel base set to: %#x #######\n", lcdLpbase);
269        break;
270      case LcdControl:
271        int old_lcdpwr;
272        old_lcdpwr = lcdControl.lcdpwr;
273        lcdControl = data;
274
275        DPRINTF(PL111, "LCD power is:%d\n", lcdControl.lcdpwr);
276
277        // LCD power enable
278        if (lcdControl.lcdpwr && !old_lcdpwr) {
279            updateVideoParams();
280            DPRINTF(PL111, " lcd size: height %d width %d\n", height, width);
281            waterMark = lcdControl.watermark ? 8 : 4;
282            startDma();
283        }
284        break;
285      case LcdImsc:
286        lcdImsc = data;
287        if (lcdImsc.vcomp)
288            panic("Interrupting on vcomp not supported\n");
289
290        lcdMis = lcdImsc & lcdRis;
291
292        if (!lcdMis)
293            gic->clearInt(intNum);
294
295         break;
296      case LcdRis:
297        panic("LCD register at offset %#x is Read-Only\n", daddr);
298        break;
299      case LcdMis:
300        panic("LCD register at offset %#x is Read-Only\n", daddr);
301        break;
302      case LcdIcr:
303        lcdRis = lcdRis & ~data;
304        lcdMis = lcdImsc & lcdRis;
305
306        if (!lcdMis)
307            gic->clearInt(intNum);
308
309        break;
310      case LcdUpCurr:
311        panic("LCD register at offset %#x is Read-Only\n", daddr);
312        break;
313      case LcdLpCurr:
314        panic("LCD register at offset %#x is Read-Only\n", daddr);
315        break;
316      case ClcdCrsrCtrl:
317        clcdCrsrCtrl = data;
318        break;
319      case ClcdCrsrConfig:
320        clcdCrsrConfig = data;
321        break;
322      case ClcdCrsrPalette0:
323        clcdCrsrPalette0 = data;
324        break;
325      case ClcdCrsrPalette1:
326        clcdCrsrPalette1 = data;
327        break;
328      case ClcdCrsrXY:
329        clcdCrsrXY = data;
330        break;
331      case ClcdCrsrClip:
332        clcdCrsrClip = data;
333        break;
334      case ClcdCrsrImsc:
335        clcdCrsrImsc = data;
336        break;
337      case ClcdCrsrIcr:
338        clcdCrsrIcr = data;
339        break;
340      case ClcdCrsrRis:
341        panic("CLCD register at offset %#x is Read-Only\n", daddr);
342        break;
343      case ClcdCrsrMis:
344        panic("CLCD register at offset %#x is Read-Only\n", daddr);
345        break;
346      default:
347        if (daddr >= CrsrImage && daddr <= 0xBFC) {
348            // CURSOR IMAGE
349            int index;
350            index = (daddr - CrsrImage) >> 2;
351            cursorImage[index] = data;
352            break;
353        } else if (daddr >= LcdPalette && daddr <= 0x3FC) {
354            // LCD Palette
355            int index;
356            index = (daddr - LcdPalette) >> 2;
357            lcdPalette[index] = data;
358            break;
359        } else {
360            panic("Tried to write PL111 register at offset %#x that \
361                       doesn't exist\n", daddr);
362            break;
363        }
364    }
365
366    pkt->makeAtomicResponse();
367    return pioDelay;
368}
369
370void
371Pl111::updateVideoParams()
372{
373        if (lcdControl.lcdbpp == bpp24) {
374            bytesPerPixel = 4;
375        } else if (lcdControl.lcdbpp == bpp16m565) {
376            bytesPerPixel = 2;
377        }
378
379        if (vncserver) {
380            if (lcdControl.lcdbpp == bpp24 && lcdControl.bgr)
381                vncserver->setFrameBufferParams(VideoConvert::bgr8888, width,
382                       height);
383            else if (lcdControl.lcdbpp == bpp24 && !lcdControl.bgr)
384                vncserver->setFrameBufferParams(VideoConvert::rgb8888, width,
385                       height);
386            else if (lcdControl.lcdbpp == bpp16m565 && lcdControl.bgr)
387                vncserver->setFrameBufferParams(VideoConvert::bgr565, width,
388                       height);
389            else if (lcdControl.lcdbpp == bpp16m565 && !lcdControl.bgr)
390                vncserver->setFrameBufferParams(VideoConvert::rgb565, width,
391                       height);
392            else
393                panic("Unimplemented video mode\n");
394        }
395
396        if (bmp)
397            delete bmp;
398
399        if (lcdControl.lcdbpp == bpp24 && lcdControl.bgr)
400            bmp = new Bitmap(VideoConvert::bgr8888, width, height, dmaBuffer);
401        else if (lcdControl.lcdbpp == bpp24 && !lcdControl.bgr)
402            bmp = new Bitmap(VideoConvert::rgb8888, width, height, dmaBuffer);
403        else if (lcdControl.lcdbpp == bpp16m565 && lcdControl.bgr)
404            bmp = new Bitmap(VideoConvert::bgr565, width, height, dmaBuffer);
405        else if (lcdControl.lcdbpp == bpp16m565 && !lcdControl.bgr)
406            bmp = new Bitmap(VideoConvert::rgb565, width, height, dmaBuffer);
407        else
408            panic("Unimplemented video mode\n");
409}
410
411void
412Pl111::startDma()
413{
414    if (dmaPendingNum != 0 || readEvent.scheduled())
415        return;
416    readFramebuffer();
417}
418
419void
420Pl111::readFramebuffer()
421{
422    // initialization for dma read from frame buffer to dma buffer
423    uint32_t length = height * width;
424    if (startAddr != lcdUpbase)
425        startAddr = lcdUpbase;
426
427    // Updating base address, interrupt if we're supposed to
428    lcdRis.baseaddr = 1;
429    if (!intEvent.scheduled())
430        schedule(intEvent, nextCycle());
431
432    curAddr = 0;
433    startTime = curTick();
434
435    maxAddr = static_cast<Addr>(length * bytesPerPixel);
436
437    DPRINTF(PL111, " lcd frame buffer size of %d bytes \n", maxAddr);
438
439    dmaPendingNum = 0;
440
441    fillFifo();
442}
443
444void
445Pl111::fillFifo()
446{
447    while ((dmaPendingNum < maxOutstandingDma) && (maxAddr >= curAddr + dmaSize )) {
448        // concurrent dma reads need different dma done events
449        // due to assertion in scheduling state
450        ++dmaPendingNum;
451
452        assert(!dmaDoneEvent[dmaPendingNum-1].scheduled());
453
454        // We use a uncachable request here because the requests from the CPU
455        // will be uncacheable as well. If we have uncacheable and cacheable
456        // requests in the memory system for the same address it won't be
457        // pleased
458        dmaPort->dmaAction(MemCmd::ReadReq, curAddr + startAddr, dmaSize,
459                &dmaDoneEvent[dmaPendingNum-1], curAddr + dmaBuffer, 0,
460                Request::UNCACHEABLE);
461        curAddr += dmaSize;
462    }
463}
464
465void
466Pl111::dmaDone()
467{
468    Tick maxFrameTime = lcdTiming2.cpl * height * clock;
469
470    --dmaPendingNum;
471
472    if (maxAddr == curAddr && !dmaPendingNum) {
473        if ((curTick() - startTime) > maxFrameTime) {
474            warn("CLCD controller buffer underrun, took %d cycles when should"
475                 " have taken %d\n", curTick() - startTime, maxFrameTime);
476            lcdRis.underflow = 1;
477            if (!intEvent.scheduled())
478                schedule(intEvent, nextCycle());
479        }
480
481        assert(!readEvent.scheduled());
482        if (vncserver)
483            vncserver->setDirty();
484
485        DPRINTF(PL111, "-- write out frame buffer into bmp\n");
486
487        assert(bmp);
488        pic->seekp(0);
489        bmp->write(pic);
490
491        DPRINTF(PL111, "-- schedule next dma read event at %d tick \n",
492                maxFrameTime + curTick());
493
494        if (lcdControl.lcden)
495            schedule(readEvent, nextCycle(startTime + maxFrameTime));
496    }
497
498    if (dmaPendingNum > (maxOutstandingDma - waterMark))
499        return;
500
501    if (!fillFifoEvent.scheduled())
502        schedule(fillFifoEvent, nextCycle());
503}
504
505
506Tick
507Pl111::nextCycle()
508{
509    Tick nextTick = curTick() + clock - 1;
510    nextTick -= nextTick%clock;
511    return nextTick;
512}
513
514Tick
515Pl111::nextCycle(Tick beginTick)
516{
517    Tick nextTick = beginTick;
518    if (nextTick%clock!=0)
519        nextTick = nextTick - (nextTick%clock) + clock;
520
521    assert(nextTick >= curTick());
522    return nextTick;
523}
524
525void
526Pl111::serialize(std::ostream &os)
527{
528    DPRINTF(PL111, "Serializing ARM PL111\n");
529
530    uint32_t lcdTiming0_serial = lcdTiming0;
531    SERIALIZE_SCALAR(lcdTiming0_serial);
532
533    uint32_t lcdTiming1_serial = lcdTiming1;
534    SERIALIZE_SCALAR(lcdTiming1_serial);
535
536    uint32_t lcdTiming2_serial = lcdTiming2;
537    SERIALIZE_SCALAR(lcdTiming2_serial);
538
539    uint32_t lcdTiming3_serial = lcdTiming3;
540    SERIALIZE_SCALAR(lcdTiming3_serial);
541
542    SERIALIZE_SCALAR(lcdUpbase);
543    SERIALIZE_SCALAR(lcdLpbase);
544
545    uint32_t lcdControl_serial = lcdControl;
546    SERIALIZE_SCALAR(lcdControl_serial);
547
548    uint8_t lcdImsc_serial = lcdImsc;
549    SERIALIZE_SCALAR(lcdImsc_serial);
550
551    uint8_t lcdRis_serial = lcdRis;
552    SERIALIZE_SCALAR(lcdRis_serial);
553
554    uint8_t lcdMis_serial = lcdMis;
555    SERIALIZE_SCALAR(lcdMis_serial);
556
557    SERIALIZE_ARRAY(lcdPalette, LcdPaletteSize);
558    SERIALIZE_ARRAY(cursorImage, CrsrImageSize);
559
560    SERIALIZE_SCALAR(clcdCrsrCtrl);
561    SERIALIZE_SCALAR(clcdCrsrConfig);
562    SERIALIZE_SCALAR(clcdCrsrPalette0);
563    SERIALIZE_SCALAR(clcdCrsrPalette1);
564    SERIALIZE_SCALAR(clcdCrsrXY);
565    SERIALIZE_SCALAR(clcdCrsrClip);
566
567    uint8_t clcdCrsrImsc_serial = clcdCrsrImsc;
568    SERIALIZE_SCALAR(clcdCrsrImsc_serial);
569
570    uint8_t clcdCrsrIcr_serial = clcdCrsrIcr;
571    SERIALIZE_SCALAR(clcdCrsrIcr_serial);
572
573    uint8_t clcdCrsrRis_serial = clcdCrsrRis;
574    SERIALIZE_SCALAR(clcdCrsrRis_serial);
575
576    uint8_t clcdCrsrMis_serial = clcdCrsrMis;
577    SERIALIZE_SCALAR(clcdCrsrMis_serial);
578
579    SERIALIZE_SCALAR(clock);
580    SERIALIZE_SCALAR(height);
581    SERIALIZE_SCALAR(width);
582    SERIALIZE_SCALAR(bytesPerPixel);
583
584    SERIALIZE_ARRAY(dmaBuffer, height * width);
585    SERIALIZE_SCALAR(startTime);
586    SERIALIZE_SCALAR(startAddr);
587    SERIALIZE_SCALAR(maxAddr);
588    SERIALIZE_SCALAR(curAddr);
589    SERIALIZE_SCALAR(waterMark);
590    SERIALIZE_SCALAR(dmaPendingNum);
591
592    Tick int_event_time = 0;
593    Tick read_event_time = 0;
594    Tick fill_fifo_event_time = 0;
595
596    if (readEvent.scheduled())
597        read_event_time = readEvent.when();
598    if (fillFifoEvent.scheduled())
599        fill_fifo_event_time = fillFifoEvent.when();
600    if (intEvent.scheduled())
601        int_event_time = intEvent.when();
602
603    SERIALIZE_SCALAR(read_event_time);
604    SERIALIZE_SCALAR(fill_fifo_event_time);
605    SERIALIZE_SCALAR(int_event_time);
606
607    vector<Tick> dma_done_event_tick;
608    dma_done_event_tick.resize(maxOutstandingDma);
609    for (int x = 0; x < maxOutstandingDma; x++) {
610        dma_done_event_tick[x] = dmaDoneEvent[x].scheduled() ?
611            dmaDoneEvent[x].when() : 0;
612    }
613    arrayParamOut(os, "dma_done_event_tick", dma_done_event_tick);
614}
615
616void
617Pl111::unserialize(Checkpoint *cp, const std::string &section)
618{
619    DPRINTF(PL111, "Unserializing ARM PL111\n");
620
621    uint32_t lcdTiming0_serial;
622    UNSERIALIZE_SCALAR(lcdTiming0_serial);
623    lcdTiming0 = lcdTiming0_serial;
624
625    uint32_t lcdTiming1_serial;
626    UNSERIALIZE_SCALAR(lcdTiming1_serial);
627    lcdTiming1 = lcdTiming1_serial;
628
629    uint32_t lcdTiming2_serial;
630    UNSERIALIZE_SCALAR(lcdTiming2_serial);
631    lcdTiming2 = lcdTiming2_serial;
632
633    uint32_t lcdTiming3_serial;
634    UNSERIALIZE_SCALAR(lcdTiming3_serial);
635    lcdTiming3 = lcdTiming3_serial;
636
637    UNSERIALIZE_SCALAR(lcdUpbase);
638    UNSERIALIZE_SCALAR(lcdLpbase);
639
640    uint32_t lcdControl_serial;
641    UNSERIALIZE_SCALAR(lcdControl_serial);
642    lcdControl = lcdControl_serial;
643
644    uint8_t lcdImsc_serial;
645    UNSERIALIZE_SCALAR(lcdImsc_serial);
646    lcdImsc = lcdImsc_serial;
647
648    uint8_t lcdRis_serial;
649    UNSERIALIZE_SCALAR(lcdRis_serial);
650    lcdRis = lcdRis_serial;
651
652    uint8_t lcdMis_serial;
653    UNSERIALIZE_SCALAR(lcdMis_serial);
654    lcdMis = lcdMis_serial;
655
656    UNSERIALIZE_ARRAY(lcdPalette, LcdPaletteSize);
657    UNSERIALIZE_ARRAY(cursorImage, CrsrImageSize);
658
659    UNSERIALIZE_SCALAR(clcdCrsrCtrl);
660    UNSERIALIZE_SCALAR(clcdCrsrConfig);
661    UNSERIALIZE_SCALAR(clcdCrsrPalette0);
662    UNSERIALIZE_SCALAR(clcdCrsrPalette1);
663    UNSERIALIZE_SCALAR(clcdCrsrXY);
664    UNSERIALIZE_SCALAR(clcdCrsrClip);
665
666    uint8_t clcdCrsrImsc_serial;
667    UNSERIALIZE_SCALAR(clcdCrsrImsc_serial);
668    clcdCrsrImsc = clcdCrsrImsc_serial;
669
670    uint8_t clcdCrsrIcr_serial;
671    UNSERIALIZE_SCALAR(clcdCrsrIcr_serial);
672    clcdCrsrIcr = clcdCrsrIcr_serial;
673
674    uint8_t clcdCrsrRis_serial;
675    UNSERIALIZE_SCALAR(clcdCrsrRis_serial);
676    clcdCrsrRis = clcdCrsrRis_serial;
677
678    uint8_t clcdCrsrMis_serial;
679    UNSERIALIZE_SCALAR(clcdCrsrMis_serial);
680    clcdCrsrMis = clcdCrsrMis_serial;
681
682    UNSERIALIZE_SCALAR(clock);
683    UNSERIALIZE_SCALAR(height);
684    UNSERIALIZE_SCALAR(width);
685    UNSERIALIZE_SCALAR(bytesPerPixel);
686
687    UNSERIALIZE_ARRAY(dmaBuffer, height * width);
688    UNSERIALIZE_SCALAR(startTime);
689    UNSERIALIZE_SCALAR(startAddr);
690    UNSERIALIZE_SCALAR(maxAddr);
691    UNSERIALIZE_SCALAR(curAddr);
692    UNSERIALIZE_SCALAR(waterMark);
693    UNSERIALIZE_SCALAR(dmaPendingNum);
694
695    Tick int_event_time = 0;
696    Tick read_event_time = 0;
697    Tick fill_fifo_event_time = 0;
698
699    UNSERIALIZE_SCALAR(read_event_time);
700    UNSERIALIZE_SCALAR(fill_fifo_event_time);
701    UNSERIALIZE_SCALAR(int_event_time);
702
703    if (int_event_time)
704        schedule(intEvent, int_event_time);
705    if (read_event_time)
706        schedule(readEvent, read_event_time);
707    if (fill_fifo_event_time)
708        schedule(fillFifoEvent, fill_fifo_event_time);
709
710    vector<Tick> dma_done_event_tick;
711    dma_done_event_tick.resize(maxOutstandingDma);
712    arrayParamIn(cp, section, "dma_done_event_tick", dma_done_event_tick);
713    for (int x = 0; x < maxOutstandingDma; x++) {
714        if (dma_done_event_tick[x])
715            schedule(dmaDoneEvent[x], dma_done_event_tick[x]);
716    }
717
718    if (lcdControl.lcdpwr) {
719        updateVideoParams();
720        if (vncserver)
721            vncserver->setDirty();
722    }
723}
724
725void
726Pl111::generateInterrupt()
727{
728    DPRINTF(PL111, "Generate Interrupt: lcdImsc=0x%x lcdRis=0x%x lcdMis=0x%x\n",
729            (uint32_t)lcdImsc, (uint32_t)lcdRis, (uint32_t)lcdMis);
730    lcdMis = lcdImsc & lcdRis;
731
732    if (lcdMis.underflow || lcdMis.baseaddr || lcdMis.vcomp || lcdMis.ahbmaster) {
733        gic->sendInt(intNum);
734        DPRINTF(PL111, " -- Generated\n");
735    }
736}
737
738void
739Pl111::addressRanges(AddrRangeList& range_list)
740{
741    range_list.clear();
742    range_list.push_back(RangeSize(pioAddr, pioSize));
743}
744
745Pl111 *
746Pl111Params::create()
747{
748    return new Pl111(this);
749}
750
751
752