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