pl111.cc revision 11793:ef606668d247 
1/*
2 * Copyright (c) 2010-2012, 2015 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 "dev/arm/pl111.hh"
42
43#include "base/output.hh"
44#include "base/trace.hh"
45#include "base/vnc/vncinput.hh"
46#include "debug/PL111.hh"
47#include "debug/Uart.hh"
48#include "dev/arm/amba_device.hh"
49#include "dev/arm/base_gic.hh"
50#include "mem/packet.hh"
51#include "mem/packet_access.hh"
52#include "sim/system.hh"
53
54// clang complains about std::set being overloaded with Packet::set if
55// we open up the entire namespace std
56using std::vector;
57
58// initialize clcd registers
59Pl111::Pl111(const Params *p)
60    : AmbaDmaDevice(p), lcdTiming0(0), lcdTiming1(0), lcdTiming2(0),
61      lcdTiming3(0), lcdUpbase(0), lcdLpbase(0), lcdControl(0), lcdImsc(0),
62      lcdRis(0), lcdMis(0),
63      clcdCrsrCtrl(0), clcdCrsrConfig(0), clcdCrsrPalette0(0),
64      clcdCrsrPalette1(0), clcdCrsrXY(0), clcdCrsrClip(0), clcdCrsrImsc(0),
65      clcdCrsrIcr(0), clcdCrsrRis(0), clcdCrsrMis(0),
66      pixelClock(p->pixel_clock),
67      converter(PixelConverter::rgba8888_le), fb(LcdMaxWidth, LcdMaxHeight),
68      vnc(p->vnc), bmp(&fb), pic(NULL),
69      width(LcdMaxWidth), height(LcdMaxHeight),
70      bytesPerPixel(4), startTime(0), startAddr(0), maxAddr(0), curAddr(0),
71      waterMark(0), dmaPendingNum(0), readEvent(this), fillFifoEvent(this),
72      dmaDoneEventAll(maxOutstandingDma, this),
73      dmaDoneEventFree(maxOutstandingDma),
74      intEvent(this), enableCapture(p->enable_capture)
75{
76    pioSize = 0xFFFF;
77
78    dmaBuffer = new uint8_t[buffer_size];
79
80    memset(lcdPalette, 0, sizeof(lcdPalette));
81    memset(cursorImage, 0, sizeof(cursorImage));
82    memset(dmaBuffer, 0, buffer_size);
83
84    for (int i = 0; i < maxOutstandingDma; ++i)
85        dmaDoneEventFree[i] = &dmaDoneEventAll[i];
86
87    if (vnc)
88        vnc->setFrameBuffer(&fb);
89}
90
91Pl111::~Pl111()
92{
93    delete[] dmaBuffer;
94}
95
96// read registers and frame buffer
97Tick
98Pl111::read(PacketPtr pkt)
99{
100    // use a temporary data since the LCD registers are read/written with
101    // different size operations
102
103    uint32_t data = 0;
104
105    assert(pkt->getAddr() >= pioAddr &&
106           pkt->getAddr() < pioAddr + pioSize);
107
108    Addr daddr = pkt->getAddr() - pioAddr;
109
110    DPRINTF(PL111, " read register %#x size=%d\n", daddr, pkt->getSize());
111
112    switch (daddr) {
113      case LcdTiming0:
114        data = lcdTiming0;
115        break;
116      case LcdTiming1:
117        data = lcdTiming1;
118        break;
119      case LcdTiming2:
120        data = lcdTiming2;
121        break;
122      case LcdTiming3:
123        data = lcdTiming3;
124        break;
125      case LcdUpBase:
126        data = lcdUpbase;
127        break;
128      case LcdLpBase:
129        data = lcdLpbase;
130        break;
131      case LcdControl:
132        data = lcdControl;
133        break;
134      case LcdImsc:
135        data = lcdImsc;
136        break;
137      case LcdRis:
138        data = lcdRis;
139        break;
140      case LcdMis:
141        data = lcdMis;
142        break;
143      case LcdIcr:
144        panic("LCD register at offset %#x is Write-Only\n", daddr);
145        break;
146      case LcdUpCurr:
147        data = curAddr;
148        break;
149      case LcdLpCurr:
150        data = curAddr;
151        break;
152      case ClcdCrsrCtrl:
153        data = clcdCrsrCtrl;
154        break;
155      case ClcdCrsrConfig:
156        data = clcdCrsrConfig;
157        break;
158      case ClcdCrsrPalette0:
159        data = clcdCrsrPalette0;
160        break;
161      case ClcdCrsrPalette1:
162        data = clcdCrsrPalette1;
163        break;
164      case ClcdCrsrXY:
165        data = clcdCrsrXY;
166        break;
167      case ClcdCrsrClip:
168        data = clcdCrsrClip;
169        break;
170      case ClcdCrsrImsc:
171        data = clcdCrsrImsc;
172        break;
173      case ClcdCrsrIcr:
174        panic("CLCD register at offset %#x is Write-Only\n", daddr);
175        break;
176      case ClcdCrsrRis:
177        data = clcdCrsrRis;
178        break;
179      case ClcdCrsrMis:
180        data = clcdCrsrMis;
181        break;
182      default:
183        if (readId(pkt, AMBA_ID, pioAddr)) {
184            // Hack for variable size accesses
185            data = pkt->get<uint32_t>();
186            break;
187        } else if (daddr >= CrsrImage && daddr <= 0xBFC) {
188            // CURSOR IMAGE
189            int index;
190            index = (daddr - CrsrImage) >> 2;
191            data= cursorImage[index];
192            break;
193        } else if (daddr >= LcdPalette && daddr <= 0x3FC) {
194            // LCD Palette
195            int index;
196            index = (daddr - LcdPalette) >> 2;
197            data = lcdPalette[index];
198            break;
199        } else {
200            panic("Tried to read CLCD register at offset %#x that "
201                       "doesn't exist\n", daddr);
202            break;
203        }
204    }
205
206    switch(pkt->getSize()) {
207      case 1:
208        pkt->set<uint8_t>(data);
209        break;
210      case 2:
211        pkt->set<uint16_t>(data);
212        break;
213      case 4:
214        pkt->set<uint32_t>(data);
215        break;
216      default:
217        panic("CLCD controller read size too big?\n");
218        break;
219    }
220
221    pkt->makeAtomicResponse();
222    return pioDelay;
223}
224
225// write registers and frame buffer
226Tick
227Pl111::write(PacketPtr pkt)
228{
229    // use a temporary data since the LCD registers are read/written with
230    // different size operations
231    //
232    uint32_t data = 0;
233
234    switch(pkt->getSize()) {
235      case 1:
236        data = pkt->get<uint8_t>();
237        break;
238      case 2:
239        data = pkt->get<uint16_t>();
240        break;
241      case 4:
242        data = pkt->get<uint32_t>();
243        break;
244      default:
245        panic("PL111 CLCD controller write size too big?\n");
246        break;
247    }
248
249    assert(pkt->getAddr() >= pioAddr &&
250           pkt->getAddr() < pioAddr + pioSize);
251
252    Addr daddr = pkt->getAddr() - pioAddr;
253
254    DPRINTF(PL111, " write register %#x value %#x size=%d\n", daddr,
255            pkt->get<uint8_t>(), pkt->getSize());
256
257    switch (daddr) {
258      case LcdTiming0:
259        lcdTiming0 = data;
260        // width = 16 * (PPL+1)
261        width = (lcdTiming0.ppl + 1) << 4;
262        break;
263      case LcdTiming1:
264        lcdTiming1 = data;
265        // height = LPP + 1
266        height = (lcdTiming1.lpp) + 1;
267        break;
268      case LcdTiming2:
269        lcdTiming2 = data;
270        break;
271      case LcdTiming3:
272        lcdTiming3 = data;
273        break;
274      case LcdUpBase:
275        lcdUpbase = data;
276        DPRINTF(PL111, "####### Upper panel base set to: %#x #######\n", lcdUpbase);
277        break;
278      case LcdLpBase:
279        warn_once("LCD dual screen mode not supported\n");
280        lcdLpbase = data;
281        DPRINTF(PL111, "###### Lower panel base set to: %#x #######\n", lcdLpbase);
282        break;
283      case LcdControl:
284        int old_lcdpwr;
285        old_lcdpwr = lcdControl.lcdpwr;
286        lcdControl = data;
287
288        DPRINTF(PL111, "LCD power is:%d\n", lcdControl.lcdpwr);
289
290        // LCD power enable
291        if (lcdControl.lcdpwr && !old_lcdpwr) {
292            updateVideoParams();
293            DPRINTF(PL111, " lcd size: height %d width %d\n", height, width);
294            waterMark = lcdControl.watermark ? 8 : 4;
295            startDma();
296        }
297        break;
298      case LcdImsc:
299        lcdImsc = data;
300        if (lcdImsc.vcomp)
301            panic("Interrupting on vcomp not supported\n");
302
303        lcdMis = lcdImsc & lcdRis;
304
305        if (!lcdMis)
306            gic->clearInt(intNum);
307
308         break;
309      case LcdRis:
310        panic("LCD register at offset %#x is Read-Only\n", daddr);
311        break;
312      case LcdMis:
313        panic("LCD register at offset %#x is Read-Only\n", daddr);
314        break;
315      case LcdIcr:
316        lcdRis = lcdRis & ~data;
317        lcdMis = lcdImsc & lcdRis;
318
319        if (!lcdMis)
320            gic->clearInt(intNum);
321
322        break;
323      case LcdUpCurr:
324        panic("LCD register at offset %#x is Read-Only\n", daddr);
325        break;
326      case LcdLpCurr:
327        panic("LCD register at offset %#x is Read-Only\n", daddr);
328        break;
329      case ClcdCrsrCtrl:
330        clcdCrsrCtrl = data;
331        break;
332      case ClcdCrsrConfig:
333        clcdCrsrConfig = data;
334        break;
335      case ClcdCrsrPalette0:
336        clcdCrsrPalette0 = data;
337        break;
338      case ClcdCrsrPalette1:
339        clcdCrsrPalette1 = data;
340        break;
341      case ClcdCrsrXY:
342        clcdCrsrXY = data;
343        break;
344      case ClcdCrsrClip:
345        clcdCrsrClip = data;
346        break;
347      case ClcdCrsrImsc:
348        clcdCrsrImsc = data;
349        break;
350      case ClcdCrsrIcr:
351        clcdCrsrIcr = data;
352        break;
353      case ClcdCrsrRis:
354        panic("CLCD register at offset %#x is Read-Only\n", daddr);
355        break;
356      case ClcdCrsrMis:
357        panic("CLCD register at offset %#x is Read-Only\n", daddr);
358        break;
359      default:
360        if (daddr >= CrsrImage && daddr <= 0xBFC) {
361            // CURSOR IMAGE
362            int index;
363            index = (daddr - CrsrImage) >> 2;
364            cursorImage[index] = data;
365            break;
366        } else if (daddr >= LcdPalette && daddr <= 0x3FC) {
367            // LCD Palette
368            int index;
369            index = (daddr - LcdPalette) >> 2;
370            lcdPalette[index] = data;
371            break;
372        } else {
373            panic("Tried to write PL111 register at offset %#x that "
374                       "doesn't exist\n", daddr);
375            break;
376        }
377    }
378
379    pkt->makeAtomicResponse();
380    return pioDelay;
381}
382
383PixelConverter
384Pl111::pixelConverter() const
385{
386    unsigned rw, gw, bw;
387    unsigned offsets[3];
388
389    switch (lcdControl.lcdbpp) {
390      case bpp24:
391        rw = gw = bw = 8;
392        offsets[0] = 0;
393        offsets[1] = 8;
394        offsets[2] = 16;
395        break;
396
397      case bpp16m565:
398        rw = 5;
399        gw = 6;
400        bw = 5;
401        offsets[0] = 0;
402        offsets[1] = 5;
403        offsets[2] = 11;
404        break;
405
406      default:
407        panic("Unimplemented video mode\n");
408    }
409
410    if (lcdControl.bgr) {
411        return PixelConverter(
412            bytesPerPixel,
413            offsets[2], offsets[1], offsets[0],
414            rw, gw, bw,
415            LittleEndianByteOrder);
416    } else {
417        return PixelConverter(
418            bytesPerPixel,
419            offsets[0], offsets[1], offsets[2],
420            rw, gw, bw,
421            LittleEndianByteOrder);
422    }
423}
424
425void
426Pl111::updateVideoParams()
427{
428    if (lcdControl.lcdbpp == bpp24) {
429        bytesPerPixel = 4;
430    } else if (lcdControl.lcdbpp == bpp16m565) {
431        bytesPerPixel = 2;
432    }
433
434    fb.resize(width, height);
435    converter = pixelConverter();
436
437    // Workaround configuration bugs where multiple display
438    // controllers are attached to the same VNC server by reattaching
439    // enabled devices. This isn't ideal, but works as long as only
440    // one display controller is active at a time.
441    if (lcdControl.lcdpwr && vnc)
442        vnc->setFrameBuffer(&fb);
443}
444
445void
446Pl111::startDma()
447{
448    if (dmaPendingNum != 0 || readEvent.scheduled())
449        return;
450    readFramebuffer();
451}
452
453void
454Pl111::readFramebuffer()
455{
456    // initialization for dma read from frame buffer to dma buffer
457    uint32_t length = height * width;
458    if (startAddr != lcdUpbase)
459        startAddr = lcdUpbase;
460
461    // Updating base address, interrupt if we're supposed to
462    lcdRis.baseaddr = 1;
463    if (!intEvent.scheduled())
464        schedule(intEvent, clockEdge());
465
466    curAddr = 0;
467    startTime = curTick();
468
469    maxAddr = static_cast<Addr>(length * bytesPerPixel);
470
471    DPRINTF(PL111, " lcd frame buffer size of %d bytes \n", maxAddr);
472
473    fillFifo();
474}
475
476void
477Pl111::fillFifo()
478{
479    while ((dmaPendingNum < maxOutstandingDma) && (maxAddr >= curAddr + dmaSize )) {
480        // concurrent dma reads need different dma done events
481        // due to assertion in scheduling state
482        ++dmaPendingNum;
483
484        assert(!dmaDoneEventFree.empty());
485        DmaDoneEvent *event(dmaDoneEventFree.back());
486        dmaDoneEventFree.pop_back();
487        assert(!event->scheduled());
488
489        // We use a uncachable request here because the requests from the CPU
490        // will be uncacheable as well. If we have uncacheable and cacheable
491        // requests in the memory system for the same address it won't be
492        // pleased
493        dmaPort.dmaAction(MemCmd::ReadReq, curAddr + startAddr, dmaSize,
494                          event, curAddr + dmaBuffer,
495                          0, Request::UNCACHEABLE);
496        curAddr += dmaSize;
497    }
498}
499
500void
501Pl111::dmaDone()
502{
503    DPRINTF(PL111, "DMA Done\n");
504
505    Tick maxFrameTime = lcdTiming2.cpl * height * pixelClock;
506
507    --dmaPendingNum;
508
509    if (maxAddr == curAddr && !dmaPendingNum) {
510        if ((curTick() - startTime) > maxFrameTime) {
511            warn("CLCD controller buffer underrun, took %d ticks when should"
512                 " have taken %d\n", curTick() - startTime, maxFrameTime);
513            lcdRis.underflow = 1;
514            if (!intEvent.scheduled())
515                schedule(intEvent, clockEdge());
516        }
517
518        assert(!readEvent.scheduled());
519        fb.copyIn(dmaBuffer, converter);
520        if (vnc)
521            vnc->setDirty();
522
523        if (enableCapture) {
524            DPRINTF(PL111, "-- write out frame buffer into bmp\n");
525
526            if (!pic)
527                pic = simout.create(csprintf("%s.framebuffer.bmp", sys->name()),
528                                    true);
529
530            assert(pic);
531            pic->stream()->seekp(0);
532            bmp.write(*pic->stream());
533        }
534
535        // schedule the next read based on when the last frame started
536        // and the desired fps (i.e. maxFrameTime), we turn the
537        // argument into a relative number of cycles in the future
538        if (lcdControl.lcden)
539            schedule(readEvent, clockEdge(ticksToCycles(startTime -
540                                                        curTick() +
541                                                        maxFrameTime)));
542    }
543
544    if (dmaPendingNum > (maxOutstandingDma - waterMark))
545        return;
546
547    if (!fillFifoEvent.scheduled())
548        schedule(fillFifoEvent, clockEdge());
549}
550
551void
552Pl111::serialize(CheckpointOut &cp) const
553{
554    DPRINTF(PL111, "Serializing ARM PL111\n");
555
556    uint32_t lcdTiming0_serial = lcdTiming0;
557    SERIALIZE_SCALAR(lcdTiming0_serial);
558
559    uint32_t lcdTiming1_serial = lcdTiming1;
560    SERIALIZE_SCALAR(lcdTiming1_serial);
561
562    uint32_t lcdTiming2_serial = lcdTiming2;
563    SERIALIZE_SCALAR(lcdTiming2_serial);
564
565    uint32_t lcdTiming3_serial = lcdTiming3;
566    SERIALIZE_SCALAR(lcdTiming3_serial);
567
568    SERIALIZE_SCALAR(lcdUpbase);
569    SERIALIZE_SCALAR(lcdLpbase);
570
571    uint32_t lcdControl_serial = lcdControl;
572    SERIALIZE_SCALAR(lcdControl_serial);
573
574    uint8_t lcdImsc_serial = lcdImsc;
575    SERIALIZE_SCALAR(lcdImsc_serial);
576
577    uint8_t lcdRis_serial = lcdRis;
578    SERIALIZE_SCALAR(lcdRis_serial);
579
580    uint8_t lcdMis_serial = lcdMis;
581    SERIALIZE_SCALAR(lcdMis_serial);
582
583    SERIALIZE_ARRAY(lcdPalette, LcdPaletteSize);
584    SERIALIZE_ARRAY(cursorImage, CrsrImageSize);
585
586    SERIALIZE_SCALAR(clcdCrsrCtrl);
587    SERIALIZE_SCALAR(clcdCrsrConfig);
588    SERIALIZE_SCALAR(clcdCrsrPalette0);
589    SERIALIZE_SCALAR(clcdCrsrPalette1);
590    SERIALIZE_SCALAR(clcdCrsrXY);
591    SERIALIZE_SCALAR(clcdCrsrClip);
592
593    uint8_t clcdCrsrImsc_serial = clcdCrsrImsc;
594    SERIALIZE_SCALAR(clcdCrsrImsc_serial);
595
596    uint8_t clcdCrsrIcr_serial = clcdCrsrIcr;
597    SERIALIZE_SCALAR(clcdCrsrIcr_serial);
598
599    uint8_t clcdCrsrRis_serial = clcdCrsrRis;
600    SERIALIZE_SCALAR(clcdCrsrRis_serial);
601
602    uint8_t clcdCrsrMis_serial = clcdCrsrMis;
603    SERIALIZE_SCALAR(clcdCrsrMis_serial);
604
605    SERIALIZE_SCALAR(height);
606    SERIALIZE_SCALAR(width);
607    SERIALIZE_SCALAR(bytesPerPixel);
608
609    SERIALIZE_ARRAY(dmaBuffer, buffer_size);
610    SERIALIZE_SCALAR(startTime);
611    SERIALIZE_SCALAR(startAddr);
612    SERIALIZE_SCALAR(maxAddr);
613    SERIALIZE_SCALAR(curAddr);
614    SERIALIZE_SCALAR(waterMark);
615    SERIALIZE_SCALAR(dmaPendingNum);
616
617    Tick int_event_time = 0;
618    Tick read_event_time = 0;
619    Tick fill_fifo_event_time = 0;
620
621    if (readEvent.scheduled())
622        read_event_time = readEvent.when();
623    if (fillFifoEvent.scheduled())
624        fill_fifo_event_time = fillFifoEvent.when();
625    if (intEvent.scheduled())
626        int_event_time = intEvent.when();
627
628    SERIALIZE_SCALAR(read_event_time);
629    SERIALIZE_SCALAR(fill_fifo_event_time);
630    SERIALIZE_SCALAR(int_event_time);
631
632    vector<Tick> dma_done_event_tick;
633    dma_done_event_tick.resize(maxOutstandingDma);
634    for (int x = 0; x < maxOutstandingDma; x++) {
635        dma_done_event_tick[x] = dmaDoneEventAll[x].scheduled() ?
636            dmaDoneEventAll[x].when() : 0;
637    }
638    SERIALIZE_CONTAINER(dma_done_event_tick);
639}
640
641void
642Pl111::unserialize(CheckpointIn &cp)
643{
644    DPRINTF(PL111, "Unserializing ARM PL111\n");
645
646    uint32_t lcdTiming0_serial;
647    UNSERIALIZE_SCALAR(lcdTiming0_serial);
648    lcdTiming0 = lcdTiming0_serial;
649
650    uint32_t lcdTiming1_serial;
651    UNSERIALIZE_SCALAR(lcdTiming1_serial);
652    lcdTiming1 = lcdTiming1_serial;
653
654    uint32_t lcdTiming2_serial;
655    UNSERIALIZE_SCALAR(lcdTiming2_serial);
656    lcdTiming2 = lcdTiming2_serial;
657
658    uint32_t lcdTiming3_serial;
659    UNSERIALIZE_SCALAR(lcdTiming3_serial);
660    lcdTiming3 = lcdTiming3_serial;
661
662    UNSERIALIZE_SCALAR(lcdUpbase);
663    UNSERIALIZE_SCALAR(lcdLpbase);
664
665    uint32_t lcdControl_serial;
666    UNSERIALIZE_SCALAR(lcdControl_serial);
667    lcdControl = lcdControl_serial;
668
669    uint8_t lcdImsc_serial;
670    UNSERIALIZE_SCALAR(lcdImsc_serial);
671    lcdImsc = lcdImsc_serial;
672
673    uint8_t lcdRis_serial;
674    UNSERIALIZE_SCALAR(lcdRis_serial);
675    lcdRis = lcdRis_serial;
676
677    uint8_t lcdMis_serial;
678    UNSERIALIZE_SCALAR(lcdMis_serial);
679    lcdMis = lcdMis_serial;
680
681    UNSERIALIZE_ARRAY(lcdPalette, LcdPaletteSize);
682    UNSERIALIZE_ARRAY(cursorImage, CrsrImageSize);
683
684    UNSERIALIZE_SCALAR(clcdCrsrCtrl);
685    UNSERIALIZE_SCALAR(clcdCrsrConfig);
686    UNSERIALIZE_SCALAR(clcdCrsrPalette0);
687    UNSERIALIZE_SCALAR(clcdCrsrPalette1);
688    UNSERIALIZE_SCALAR(clcdCrsrXY);
689    UNSERIALIZE_SCALAR(clcdCrsrClip);
690
691    uint8_t clcdCrsrImsc_serial;
692    UNSERIALIZE_SCALAR(clcdCrsrImsc_serial);
693    clcdCrsrImsc = clcdCrsrImsc_serial;
694
695    uint8_t clcdCrsrIcr_serial;
696    UNSERIALIZE_SCALAR(clcdCrsrIcr_serial);
697    clcdCrsrIcr = clcdCrsrIcr_serial;
698
699    uint8_t clcdCrsrRis_serial;
700    UNSERIALIZE_SCALAR(clcdCrsrRis_serial);
701    clcdCrsrRis = clcdCrsrRis_serial;
702
703    uint8_t clcdCrsrMis_serial;
704    UNSERIALIZE_SCALAR(clcdCrsrMis_serial);
705    clcdCrsrMis = clcdCrsrMis_serial;
706
707    UNSERIALIZE_SCALAR(height);
708    UNSERIALIZE_SCALAR(width);
709    UNSERIALIZE_SCALAR(bytesPerPixel);
710
711    UNSERIALIZE_ARRAY(dmaBuffer, buffer_size);
712    UNSERIALIZE_SCALAR(startTime);
713    UNSERIALIZE_SCALAR(startAddr);
714    UNSERIALIZE_SCALAR(maxAddr);
715    UNSERIALIZE_SCALAR(curAddr);
716    UNSERIALIZE_SCALAR(waterMark);
717    UNSERIALIZE_SCALAR(dmaPendingNum);
718
719    Tick int_event_time = 0;
720    Tick read_event_time = 0;
721    Tick fill_fifo_event_time = 0;
722
723    UNSERIALIZE_SCALAR(read_event_time);
724    UNSERIALIZE_SCALAR(fill_fifo_event_time);
725    UNSERIALIZE_SCALAR(int_event_time);
726
727    if (int_event_time)
728        schedule(intEvent, int_event_time);
729    if (read_event_time)
730        schedule(readEvent, read_event_time);
731    if (fill_fifo_event_time)
732        schedule(fillFifoEvent, fill_fifo_event_time);
733
734    vector<Tick> dma_done_event_tick;
735    dma_done_event_tick.resize(maxOutstandingDma);
736    UNSERIALIZE_CONTAINER(dma_done_event_tick);
737    dmaDoneEventFree.clear();
738    for (int x = 0; x < maxOutstandingDma; x++) {
739        if (dma_done_event_tick[x])
740            schedule(dmaDoneEventAll[x], dma_done_event_tick[x]);
741        else
742            dmaDoneEventFree.push_back(&dmaDoneEventAll[x]);
743    }
744    assert(maxOutstandingDma - dmaDoneEventFree.size() == dmaPendingNum);
745
746    if (lcdControl.lcdpwr) {
747        updateVideoParams();
748        fb.copyIn(dmaBuffer, converter);
749        if (vnc)
750            vnc->setDirty();
751    }
752}
753
754void
755Pl111::generateInterrupt()
756{
757    DPRINTF(PL111, "Generate Interrupt: lcdImsc=0x%x lcdRis=0x%x lcdMis=0x%x\n",
758            (uint32_t)lcdImsc, (uint32_t)lcdRis, (uint32_t)lcdMis);
759    lcdMis = lcdImsc & lcdRis;
760
761    if (lcdMis.underflow || lcdMis.baseaddr || lcdMis.vcomp || lcdMis.ahbmaster) {
762        gic->sendInt(intNum);
763        DPRINTF(PL111, " -- Generated\n");
764    }
765}
766
767AddrRangeList
768Pl111::getAddrRanges() const
769{
770    AddrRangeList ranges;
771    ranges.push_back(RangeSize(pioAddr, pioSize));
772    return ranges;
773}
774
775Pl111 *
776Pl111Params::create()
777{
778    return new Pl111(this);
779}
780
781
782