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