pl111.cc (10367:bf52480abd01) pl111.cc (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;
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 pkt->allocate();
108
109 DPRINTF(PL111, " read register %#x size=%d\n", daddr, pkt->getSize());
110
111 switch (daddr) {
112 case LcdTiming0:
113 data = lcdTiming0;
114 break;
115 case LcdTiming1:
116 data = lcdTiming1;
117 break;
118 case LcdTiming2:
119 data = lcdTiming2;
120 break;
121 case LcdTiming3:
122 data = lcdTiming3;
123 break;
124 case LcdUpBase:
125 data = lcdUpbase;
126 break;
127 case LcdLpBase:
128 data = lcdLpbase;
129 break;
130 case LcdControl:
131 data = lcdControl;
132 break;
133 case LcdImsc:
134 data = lcdImsc;
135 break;
136 case LcdRis:
137 data = lcdRis;
138 break;
139 case LcdMis:
140 data = lcdMis;
141 break;
142 case LcdIcr:
143 panic("LCD register at offset %#x is Write-Only\n", daddr);
144 break;
145 case LcdUpCurr:
146 data = curAddr;
147 break;
148 case LcdLpCurr:
149 data = curAddr;
150 break;
151 case ClcdCrsrCtrl:
152 data = clcdCrsrCtrl;
153 break;
154 case ClcdCrsrConfig:
155 data = clcdCrsrConfig;
156 break;
157 case ClcdCrsrPalette0:
158 data = clcdCrsrPalette0;
159 break;
160 case ClcdCrsrPalette1:
161 data = clcdCrsrPalette1;
162 break;
163 case ClcdCrsrXY:
164 data = clcdCrsrXY;
165 break;
166 case ClcdCrsrClip:
167 data = clcdCrsrClip;
168 break;
169 case ClcdCrsrImsc:
170 data = clcdCrsrImsc;
171 break;
172 case ClcdCrsrIcr:
173 panic("CLCD register at offset %#x is Write-Only\n", daddr);
174 break;
175 case ClcdCrsrRis:
176 data = clcdCrsrRis;
177 break;
178 case ClcdCrsrMis:
179 data = clcdCrsrMis;
180 break;
181 default:
182 if (readId(pkt, AMBA_ID, pioAddr)) {
183 // Hack for variable size accesses
184 data = pkt->get<uint32_t>();
185 break;
186 } else if (daddr >= CrsrImage && daddr <= 0xBFC) {
187 // CURSOR IMAGE
188 int index;
189 index = (daddr - CrsrImage) >> 2;
190 data= cursorImage[index];
191 break;
192 } else if (daddr >= LcdPalette && daddr <= 0x3FC) {
193 // LCD Palette
194 int index;
195 index = (daddr - LcdPalette) >> 2;
196 data = lcdPalette[index];
197 break;
198 } else {
199 panic("Tried to read CLCD register at offset %#x that "
200 "doesn't exist\n", daddr);
201 break;
202 }
203 }
204
205 switch(pkt->getSize()) {
206 case 1:
207 pkt->set<uint8_t>(data);
208 break;
209 case 2:
210 pkt->set<uint16_t>(data);
211 break;
212 case 4:
213 pkt->set<uint32_t>(data);
214 break;
215 default:
216 panic("CLCD controller read size too big?\n");
217 break;
218 }
219
220 pkt->makeAtomicResponse();
221 return pioDelay;
222}
223
224// write registers and frame buffer
225Tick
226Pl111::write(PacketPtr pkt)
227{
228 // use a temporary data since the LCD registers are read/written with
229 // different size operations
230 //
231 uint32_t data = 0;
232
233 switch(pkt->getSize()) {
234 case 1:
235 data = pkt->get<uint8_t>();
236 break;
237 case 2:
238 data = pkt->get<uint16_t>();
239 break;
240 case 4:
241 data = pkt->get<uint32_t>();
242 break;
243 default:
244 panic("PL111 CLCD controller write size too big?\n");
245 break;
246 }
247
248 assert(pkt->getAddr() >= pioAddr &&
249 pkt->getAddr() < pioAddr + pioSize);
250
251 Addr daddr = pkt->getAddr() - pioAddr;
252
253 DPRINTF(PL111, " write register %#x value %#x size=%d\n", daddr,
254 pkt->get<uint8_t>(), pkt->getSize());
255
256 switch (daddr) {
257 case LcdTiming0:
258 lcdTiming0 = data;
259 // width = 16 * (PPL+1)
260 width = (lcdTiming0.ppl + 1) << 4;
261 break;
262 case LcdTiming1:
263 lcdTiming1 = data;
264 // height = LPP + 1
265 height = (lcdTiming1.lpp) + 1;
266 break;
267 case LcdTiming2:
268 lcdTiming2 = data;
269 break;
270 case LcdTiming3:
271 lcdTiming3 = data;
272 break;
273 case LcdUpBase:
274 lcdUpbase = data;
275 DPRINTF(PL111, "####### Upper panel base set to: %#x #######\n", lcdUpbase);
276 break;
277 case LcdLpBase:
278 warn_once("LCD dual screen mode not supported\n");
279 lcdLpbase = data;
280 DPRINTF(PL111, "###### Lower panel base set to: %#x #######\n", lcdLpbase);
281 break;
282 case LcdControl:
283 int old_lcdpwr;
284 old_lcdpwr = lcdControl.lcdpwr;
285 lcdControl = data;
286
287 DPRINTF(PL111, "LCD power is:%d\n", lcdControl.lcdpwr);
288
289 // LCD power enable
290 if (lcdControl.lcdpwr && !old_lcdpwr) {
291 updateVideoParams();
292 DPRINTF(PL111, " lcd size: height %d width %d\n", height, width);
293 waterMark = lcdControl.watermark ? 8 : 4;
294 startDma();
295 }
296 break;
297 case LcdImsc:
298 lcdImsc = data;
299 if (lcdImsc.vcomp)
300 panic("Interrupting on vcomp not supported\n");
301
302 lcdMis = lcdImsc & lcdRis;
303
304 if (!lcdMis)
305 gic->clearInt(intNum);
306
307 break;
308 case LcdRis:
309 panic("LCD register at offset %#x is Read-Only\n", daddr);
310 break;
311 case LcdMis:
312 panic("LCD register at offset %#x is Read-Only\n", daddr);
313 break;
314 case LcdIcr:
315 lcdRis = lcdRis & ~data;
316 lcdMis = lcdImsc & lcdRis;
317
318 if (!lcdMis)
319 gic->clearInt(intNum);
320
321 break;
322 case LcdUpCurr:
323 panic("LCD register at offset %#x is Read-Only\n", daddr);
324 break;
325 case LcdLpCurr:
326 panic("LCD register at offset %#x is Read-Only\n", daddr);
327 break;
328 case ClcdCrsrCtrl:
329 clcdCrsrCtrl = data;
330 break;
331 case ClcdCrsrConfig:
332 clcdCrsrConfig = data;
333 break;
334 case ClcdCrsrPalette0:
335 clcdCrsrPalette0 = data;
336 break;
337 case ClcdCrsrPalette1:
338 clcdCrsrPalette1 = data;
339 break;
340 case ClcdCrsrXY:
341 clcdCrsrXY = data;
342 break;
343 case ClcdCrsrClip:
344 clcdCrsrClip = data;
345 break;
346 case ClcdCrsrImsc:
347 clcdCrsrImsc = data;
348 break;
349 case ClcdCrsrIcr:
350 clcdCrsrIcr = data;
351 break;
352 case ClcdCrsrRis:
353 panic("CLCD register at offset %#x is Read-Only\n", daddr);
354 break;
355 case ClcdCrsrMis:
356 panic("CLCD register at offset %#x is Read-Only\n", daddr);
357 break;
358 default:
359 if (daddr >= CrsrImage && daddr <= 0xBFC) {
360 // CURSOR IMAGE
361 int index;
362 index = (daddr - CrsrImage) >> 2;
363 cursorImage[index] = data;
364 break;
365 } else if (daddr >= LcdPalette && daddr <= 0x3FC) {
366 // LCD Palette
367 int index;
368 index = (daddr - LcdPalette) >> 2;
369 lcdPalette[index] = data;
370 break;
371 } else {
372 panic("Tried to write PL111 register at offset %#x that "
373 "doesn't exist\n", daddr);
374 break;
375 }
376 }
377
378 pkt->makeAtomicResponse();
379 return pioDelay;
380}
381
382void
383Pl111::updateVideoParams()
384{
385 if (lcdControl.lcdbpp == bpp24) {
386 bytesPerPixel = 4;
387 } else if (lcdControl.lcdbpp == bpp16m565) {
388 bytesPerPixel = 2;
389 }
390
391 if (vnc) {
392 if (lcdControl.lcdbpp == bpp24 && lcdControl.bgr)
393 vnc->setFrameBufferParams(VideoConvert::bgr8888, width,
394 height);
395 else if (lcdControl.lcdbpp == bpp24 && !lcdControl.bgr)
396 vnc->setFrameBufferParams(VideoConvert::rgb8888, width,
397 height);
398 else if (lcdControl.lcdbpp == bpp16m565 && lcdControl.bgr)
399 vnc->setFrameBufferParams(VideoConvert::bgr565, width,
400 height);
401 else if (lcdControl.lcdbpp == bpp16m565 && !lcdControl.bgr)
402 vnc->setFrameBufferParams(VideoConvert::rgb565, width,
403 height);
404 else
405 panic("Unimplemented video mode\n");
406 }
407
408 if (bmp)
409 delete bmp;
410
411 if (lcdControl.lcdbpp == bpp24 && lcdControl.bgr)
412 bmp = new Bitmap(VideoConvert::bgr8888, width, height, dmaBuffer);
413 else if (lcdControl.lcdbpp == bpp24 && !lcdControl.bgr)
414 bmp = new Bitmap(VideoConvert::rgb8888, width, height, dmaBuffer);
415 else if (lcdControl.lcdbpp == bpp16m565 && lcdControl.bgr)
416 bmp = new Bitmap(VideoConvert::bgr565, width, height, dmaBuffer);
417 else if (lcdControl.lcdbpp == bpp16m565 && !lcdControl.bgr)
418 bmp = new Bitmap(VideoConvert::rgb565, width, height, dmaBuffer);
419 else
420 panic("Unimplemented video mode\n");
421}
422
423void
424Pl111::startDma()
425{
426 if (dmaPendingNum != 0 || readEvent.scheduled())
427 return;
428 readFramebuffer();
429}
430
431void
432Pl111::readFramebuffer()
433{
434 // initialization for dma read from frame buffer to dma buffer
435 uint32_t length = height * width;
436 if (startAddr != lcdUpbase)
437 startAddr = lcdUpbase;
438
439 // Updating base address, interrupt if we're supposed to
440 lcdRis.baseaddr = 1;
441 if (!intEvent.scheduled())
442 schedule(intEvent, clockEdge());
443
444 curAddr = 0;
445 startTime = curTick();
446
447 maxAddr = static_cast<Addr>(length * bytesPerPixel);
448
449 DPRINTF(PL111, " lcd frame buffer size of %d bytes \n", maxAddr);
450
451 fillFifo();
452}
453
454void
455Pl111::fillFifo()
456{
457 while ((dmaPendingNum < maxOutstandingDma) && (maxAddr >= curAddr + dmaSize )) {
458 // concurrent dma reads need different dma done events
459 // due to assertion in scheduling state
460 ++dmaPendingNum;
461
462 assert(!dmaDoneEventFree.empty());
463 DmaDoneEvent *event(dmaDoneEventFree.back());
464 dmaDoneEventFree.pop_back();
465 assert(!event->scheduled());
466
467 // We use a uncachable request here because the requests from the CPU
468 // will be uncacheable as well. If we have uncacheable and cacheable
469 // requests in the memory system for the same address it won't be
470 // pleased
471 dmaPort.dmaAction(MemCmd::ReadReq, curAddr + startAddr, dmaSize,
472 event, curAddr + dmaBuffer,
473 0, Request::UNCACHEABLE);
474 curAddr += dmaSize;
475 }
476}
477
478void
479Pl111::dmaDone()
480{
481 DPRINTF(PL111, "DMA Done\n");
482
483 Tick maxFrameTime = lcdTiming2.cpl * height * pixelClock;
484
485 --dmaPendingNum;
486
487 if (maxAddr == curAddr && !dmaPendingNum) {
488 if ((curTick() - startTime) > maxFrameTime) {
489 warn("CLCD controller buffer underrun, took %d ticks when should"
490 " have taken %d\n", curTick() - startTime, maxFrameTime);
491 lcdRis.underflow = 1;
492 if (!intEvent.scheduled())
493 schedule(intEvent, clockEdge());
494 }
495
496 assert(!readEvent.scheduled());
497 if (vnc)
498 vnc->setDirty();
499
500 if (enableCapture) {
501 DPRINTF(PL111, "-- write out frame buffer into bmp\n");
502
503 if (!pic)
504 pic = simout.create(csprintf("%s.framebuffer.bmp", sys->name()), true);
505
506 assert(bmp);
507 assert(pic);
508 pic->seekp(0);
509 bmp->write(pic);
510 }
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
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