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