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