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