2 * Copyright (c) 2010-2012, 2015 ARM Limited
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.
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.
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.
38 #include "dev/arm/pl111.hh"
40 #include "base/output.hh"
41 #include "base/trace.hh"
42 #include "base/vnc/vncinput.hh"
43 #include "debug/PL111.hh"
44 #include "debug/Uart.hh"
45 #include "dev/arm/amba_device.hh"
46 #include "dev/arm/base_gic.hh"
47 #include "mem/packet.hh"
48 #include "mem/packet_access.hh"
49 #include "sim/system.hh"
51 // clang complains about std::set being overloaded with Packet::set if
52 // we open up the entire namespace std
55 // initialize clcd registers
56 Pl111::Pl111(const Params
*p
)
57 : AmbaDmaDevice(p
), lcdTiming0(0), lcdTiming1(0), lcdTiming2(0),
58 lcdTiming3(0), lcdUpbase(0), lcdLpbase(0), lcdControl(0), lcdImsc(0),
60 clcdCrsrCtrl(0), clcdCrsrConfig(0), clcdCrsrPalette0(0),
61 clcdCrsrPalette1(0), clcdCrsrXY(0), clcdCrsrClip(0), clcdCrsrImsc(0),
62 clcdCrsrIcr(0), clcdCrsrRis(0), clcdCrsrMis(0),
63 pixelClock(p
->pixel_clock
),
64 converter(PixelConverter::rgba8888_le
), fb(LcdMaxWidth
, LcdMaxHeight
),
65 vnc(p
->vnc
), bmp(&fb
), pic(NULL
),
66 width(LcdMaxWidth
), height(LcdMaxHeight
),
67 bytesPerPixel(4), startTime(0), startAddr(0), maxAddr(0), curAddr(0),
68 waterMark(0), dmaPendingNum(0),
69 readEvent([this]{ readFramebuffer(); }, name()),
70 fillFifoEvent([this]{ fillFifo(); }, name()),
71 dmaDoneEventAll(maxOutstandingDma
, this),
72 dmaDoneEventFree(maxOutstandingDma
),
73 intEvent([this]{ generateInterrupt(); }, name()),
74 enableCapture(p
->enable_capture
)
78 dmaBuffer
= new uint8_t[buffer_size
];
80 memset(lcdPalette
, 0, sizeof(lcdPalette
));
81 memset(cursorImage
, 0, sizeof(cursorImage
));
82 memset(dmaBuffer
, 0, buffer_size
);
84 for (int i
= 0; i
< maxOutstandingDma
; ++i
)
85 dmaDoneEventFree
[i
] = &dmaDoneEventAll
[i
];
88 vnc
->setFrameBuffer(&fb
);
96 // read registers and frame buffer
98 Pl111::read(PacketPtr pkt
)
100 // use a temporary data since the LCD registers are read/written with
101 // different size operations
105 assert(pkt
->getAddr() >= pioAddr
&&
106 pkt
->getAddr() < pioAddr
+ pioSize
);
108 Addr daddr
= pkt
->getAddr() - pioAddr
;
110 DPRINTF(PL111
, " read register %#x size=%d\n", daddr
, pkt
->getSize());
144 panic("LCD register at offset %#x is Write-Only\n", daddr
);
156 data
= clcdCrsrConfig
;
158 case ClcdCrsrPalette0
:
159 data
= clcdCrsrPalette0
;
161 case ClcdCrsrPalette1
:
162 data
= clcdCrsrPalette1
;
174 panic("CLCD register at offset %#x is Write-Only\n", daddr
);
183 if (readId(pkt
, AMBA_ID
, pioAddr
)) {
184 // Hack for variable size accesses
185 data
= pkt
->getLE
<uint32_t>();
187 } else if (daddr
>= CrsrImage
&& daddr
<= 0xBFC) {
190 index
= (daddr
- CrsrImage
) >> 2;
191 data
= cursorImage
[index
];
193 } else if (daddr
>= LcdPalette
&& daddr
<= 0x3FC) {
196 index
= (daddr
- LcdPalette
) >> 2;
197 data
= lcdPalette
[index
];
200 panic("Tried to read CLCD register at offset %#x that "
201 "doesn't exist\n", daddr
);
206 switch(pkt
->getSize()) {
208 pkt
->setLE
<uint8_t>(data
);
211 pkt
->setLE
<uint16_t>(data
);
214 pkt
->setLE
<uint32_t>(data
);
217 panic("CLCD controller read size too big?\n");
221 pkt
->makeAtomicResponse();
225 // write registers and frame buffer
227 Pl111::write(PacketPtr pkt
)
229 // use a temporary data since the LCD registers are read/written with
230 // different size operations
234 switch(pkt
->getSize()) {
236 data
= pkt
->getLE
<uint8_t>();
239 data
= pkt
->getLE
<uint16_t>();
242 data
= pkt
->getLE
<uint32_t>();
245 panic("PL111 CLCD controller write size too big?\n");
249 assert(pkt
->getAddr() >= pioAddr
&&
250 pkt
->getAddr() < pioAddr
+ pioSize
);
252 Addr daddr
= pkt
->getAddr() - pioAddr
;
254 DPRINTF(PL111
, " write register %#x value %#x size=%d\n", daddr
,
255 pkt
->getLE
<uint8_t>(), pkt
->getSize());
260 // width = 16 * (PPL+1)
261 width
= (lcdTiming0
.ppl
+ 1) << 4;
266 height
= (lcdTiming1
.lpp
) + 1;
276 DPRINTF(PL111
, "####### Upper panel base set to: %#x #######\n", lcdUpbase
);
279 warn_once("LCD dual screen mode not supported\n");
281 DPRINTF(PL111
, "###### Lower panel base set to: %#x #######\n", lcdLpbase
);
285 old_lcdpwr
= lcdControl
.lcdpwr
;
288 DPRINTF(PL111
, "LCD power is:%d\n", lcdControl
.lcdpwr
);
291 if (lcdControl
.lcdpwr
&& !old_lcdpwr
) {
293 DPRINTF(PL111
, " lcd size: height %d width %d\n", height
, width
);
294 waterMark
= lcdControl
.watermark
? 8 : 4;
301 panic("Interrupting on vcomp not supported\n");
303 lcdMis
= lcdImsc
& lcdRis
;
306 gic
->clearInt(intNum
);
310 panic("LCD register at offset %#x is Read-Only\n", daddr
);
313 panic("LCD register at offset %#x is Read-Only\n", daddr
);
316 lcdRis
= lcdRis
& ~data
;
317 lcdMis
= lcdImsc
& lcdRis
;
320 gic
->clearInt(intNum
);
324 panic("LCD register at offset %#x is Read-Only\n", daddr
);
327 panic("LCD register at offset %#x is Read-Only\n", daddr
);
333 clcdCrsrConfig
= data
;
335 case ClcdCrsrPalette0
:
336 clcdCrsrPalette0
= data
;
338 case ClcdCrsrPalette1
:
339 clcdCrsrPalette1
= data
;
354 panic("CLCD register at offset %#x is Read-Only\n", daddr
);
357 panic("CLCD register at offset %#x is Read-Only\n", daddr
);
360 if (daddr
>= CrsrImage
&& daddr
<= 0xBFC) {
363 index
= (daddr
- CrsrImage
) >> 2;
364 cursorImage
[index
] = data
;
366 } else if (daddr
>= LcdPalette
&& daddr
<= 0x3FC) {
369 index
= (daddr
- LcdPalette
) >> 2;
370 lcdPalette
[index
] = data
;
373 panic("Tried to write PL111 register at offset %#x that "
374 "doesn't exist\n", daddr
);
379 pkt
->makeAtomicResponse();
384 Pl111::pixelConverter() const
389 switch (lcdControl
.lcdbpp
) {
407 panic("Unimplemented video mode\n");
410 if (lcdControl
.bgr
) {
411 return PixelConverter(
413 offsets
[2], offsets
[1], offsets
[0],
415 LittleEndianByteOrder
);
417 return PixelConverter(
419 offsets
[0], offsets
[1], offsets
[2],
421 LittleEndianByteOrder
);
426 Pl111::updateVideoParams()
428 if (lcdControl
.lcdbpp
== bpp24
) {
430 } else if (lcdControl
.lcdbpp
== bpp16m565
) {
434 fb
.resize(width
, height
);
435 converter
= pixelConverter();
437 // Workaround configuration bugs where multiple display
438 // controllers are attached to the same VNC server by reattaching
439 // enabled devices. This isn't ideal, but works as long as only
440 // one display controller is active at a time.
441 if (lcdControl
.lcdpwr
&& vnc
)
442 vnc
->setFrameBuffer(&fb
);
448 if (dmaPendingNum
!= 0 || readEvent
.scheduled())
454 Pl111::readFramebuffer()
456 // initialization for dma read from frame buffer to dma buffer
457 uint32_t length
= height
* width
;
458 if (startAddr
!= lcdUpbase
)
459 startAddr
= lcdUpbase
;
461 // Updating base address, interrupt if we're supposed to
463 if (!intEvent
.scheduled())
464 schedule(intEvent
, clockEdge());
467 startTime
= curTick();
469 maxAddr
= static_cast<Addr
>(length
* bytesPerPixel
);
471 DPRINTF(PL111
, " lcd frame buffer size of %d bytes \n", maxAddr
);
479 while ((dmaPendingNum
< maxOutstandingDma
) && (maxAddr
>= curAddr
+ dmaSize
)) {
480 // concurrent dma reads need different dma done events
481 // due to assertion in scheduling state
484 assert(!dmaDoneEventFree
.empty());
485 DmaDoneEvent
*event(dmaDoneEventFree
.back());
486 dmaDoneEventFree
.pop_back();
487 assert(!event
->scheduled());
489 // We use a uncachable request here because the requests from the CPU
490 // will be uncacheable as well. If we have uncacheable and cacheable
491 // requests in the memory system for the same address it won't be
493 dmaPort
.dmaAction(MemCmd::ReadReq
, curAddr
+ startAddr
, dmaSize
,
494 event
, curAddr
+ dmaBuffer
,
495 0, Request::UNCACHEABLE
);
503 DPRINTF(PL111
, "DMA Done\n");
505 Tick maxFrameTime
= lcdTiming2
.cpl
* height
* pixelClock
;
509 if (maxAddr
== curAddr
&& !dmaPendingNum
) {
510 if ((curTick() - startTime
) > maxFrameTime
) {
511 warn("CLCD controller buffer underrun, took %d ticks when should"
512 " have taken %d\n", curTick() - startTime
, maxFrameTime
);
513 lcdRis
.underflow
= 1;
514 if (!intEvent
.scheduled())
515 schedule(intEvent
, clockEdge());
518 assert(!readEvent
.scheduled());
519 fb
.copyIn(dmaBuffer
, converter
);
524 DPRINTF(PL111
, "-- write out frame buffer into bmp\n");
527 pic
= simout
.create(csprintf("%s.framebuffer.bmp", sys
->name()),
531 pic
->stream()->seekp(0);
532 bmp
.write(*pic
->stream());
535 // schedule the next read based on when the last frame started
536 // and the desired fps (i.e. maxFrameTime), we turn the
537 // argument into a relative number of cycles in the future
538 if (lcdControl
.lcden
)
539 schedule(readEvent
, clockEdge(ticksToCycles(startTime
-
544 if (dmaPendingNum
> (maxOutstandingDma
- waterMark
))
547 if (!fillFifoEvent
.scheduled())
548 schedule(fillFifoEvent
, clockEdge());
552 Pl111::serialize(CheckpointOut
&cp
) const
554 DPRINTF(PL111
, "Serializing ARM PL111\n");
556 uint32_t lcdTiming0_serial
= lcdTiming0
;
557 SERIALIZE_SCALAR(lcdTiming0_serial
);
559 uint32_t lcdTiming1_serial
= lcdTiming1
;
560 SERIALIZE_SCALAR(lcdTiming1_serial
);
562 uint32_t lcdTiming2_serial
= lcdTiming2
;
563 SERIALIZE_SCALAR(lcdTiming2_serial
);
565 uint32_t lcdTiming3_serial
= lcdTiming3
;
566 SERIALIZE_SCALAR(lcdTiming3_serial
);
568 SERIALIZE_SCALAR(lcdUpbase
);
569 SERIALIZE_SCALAR(lcdLpbase
);
571 uint32_t lcdControl_serial
= lcdControl
;
572 SERIALIZE_SCALAR(lcdControl_serial
);
574 uint8_t lcdImsc_serial
= lcdImsc
;
575 SERIALIZE_SCALAR(lcdImsc_serial
);
577 uint8_t lcdRis_serial
= lcdRis
;
578 SERIALIZE_SCALAR(lcdRis_serial
);
580 uint8_t lcdMis_serial
= lcdMis
;
581 SERIALIZE_SCALAR(lcdMis_serial
);
583 SERIALIZE_ARRAY(lcdPalette
, LcdPaletteSize
);
584 SERIALIZE_ARRAY(cursorImage
, CrsrImageSize
);
586 SERIALIZE_SCALAR(clcdCrsrCtrl
);
587 SERIALIZE_SCALAR(clcdCrsrConfig
);
588 SERIALIZE_SCALAR(clcdCrsrPalette0
);
589 SERIALIZE_SCALAR(clcdCrsrPalette1
);
590 SERIALIZE_SCALAR(clcdCrsrXY
);
591 SERIALIZE_SCALAR(clcdCrsrClip
);
593 uint8_t clcdCrsrImsc_serial
= clcdCrsrImsc
;
594 SERIALIZE_SCALAR(clcdCrsrImsc_serial
);
596 uint8_t clcdCrsrIcr_serial
= clcdCrsrIcr
;
597 SERIALIZE_SCALAR(clcdCrsrIcr_serial
);
599 uint8_t clcdCrsrRis_serial
= clcdCrsrRis
;
600 SERIALIZE_SCALAR(clcdCrsrRis_serial
);
602 uint8_t clcdCrsrMis_serial
= clcdCrsrMis
;
603 SERIALIZE_SCALAR(clcdCrsrMis_serial
);
605 SERIALIZE_SCALAR(height
);
606 SERIALIZE_SCALAR(width
);
607 SERIALIZE_SCALAR(bytesPerPixel
);
609 SERIALIZE_ARRAY(dmaBuffer
, buffer_size
);
610 SERIALIZE_SCALAR(startTime
);
611 SERIALIZE_SCALAR(startAddr
);
612 SERIALIZE_SCALAR(maxAddr
);
613 SERIALIZE_SCALAR(curAddr
);
614 SERIALIZE_SCALAR(waterMark
);
615 SERIALIZE_SCALAR(dmaPendingNum
);
617 Tick int_event_time
= 0;
618 Tick read_event_time
= 0;
619 Tick fill_fifo_event_time
= 0;
621 if (readEvent
.scheduled())
622 read_event_time
= readEvent
.when();
623 if (fillFifoEvent
.scheduled())
624 fill_fifo_event_time
= fillFifoEvent
.when();
625 if (intEvent
.scheduled())
626 int_event_time
= intEvent
.when();
628 SERIALIZE_SCALAR(read_event_time
);
629 SERIALIZE_SCALAR(fill_fifo_event_time
);
630 SERIALIZE_SCALAR(int_event_time
);
632 vector
<Tick
> dma_done_event_tick
;
633 dma_done_event_tick
.resize(maxOutstandingDma
);
634 for (int x
= 0; x
< maxOutstandingDma
; x
++) {
635 dma_done_event_tick
[x
] = dmaDoneEventAll
[x
].scheduled() ?
636 dmaDoneEventAll
[x
].when() : 0;
638 SERIALIZE_CONTAINER(dma_done_event_tick
);
642 Pl111::unserialize(CheckpointIn
&cp
)
644 DPRINTF(PL111
, "Unserializing ARM PL111\n");
646 uint32_t lcdTiming0_serial
;
647 UNSERIALIZE_SCALAR(lcdTiming0_serial
);
648 lcdTiming0
= lcdTiming0_serial
;
650 uint32_t lcdTiming1_serial
;
651 UNSERIALIZE_SCALAR(lcdTiming1_serial
);
652 lcdTiming1
= lcdTiming1_serial
;
654 uint32_t lcdTiming2_serial
;
655 UNSERIALIZE_SCALAR(lcdTiming2_serial
);
656 lcdTiming2
= lcdTiming2_serial
;
658 uint32_t lcdTiming3_serial
;
659 UNSERIALIZE_SCALAR(lcdTiming3_serial
);
660 lcdTiming3
= lcdTiming3_serial
;
662 UNSERIALIZE_SCALAR(lcdUpbase
);
663 UNSERIALIZE_SCALAR(lcdLpbase
);
665 uint32_t lcdControl_serial
;
666 UNSERIALIZE_SCALAR(lcdControl_serial
);
667 lcdControl
= lcdControl_serial
;
669 uint8_t lcdImsc_serial
;
670 UNSERIALIZE_SCALAR(lcdImsc_serial
);
671 lcdImsc
= lcdImsc_serial
;
673 uint8_t lcdRis_serial
;
674 UNSERIALIZE_SCALAR(lcdRis_serial
);
675 lcdRis
= lcdRis_serial
;
677 uint8_t lcdMis_serial
;
678 UNSERIALIZE_SCALAR(lcdMis_serial
);
679 lcdMis
= lcdMis_serial
;
681 UNSERIALIZE_ARRAY(lcdPalette
, LcdPaletteSize
);
682 UNSERIALIZE_ARRAY(cursorImage
, CrsrImageSize
);
684 UNSERIALIZE_SCALAR(clcdCrsrCtrl
);
685 UNSERIALIZE_SCALAR(clcdCrsrConfig
);
686 UNSERIALIZE_SCALAR(clcdCrsrPalette0
);
687 UNSERIALIZE_SCALAR(clcdCrsrPalette1
);
688 UNSERIALIZE_SCALAR(clcdCrsrXY
);
689 UNSERIALIZE_SCALAR(clcdCrsrClip
);
691 uint8_t clcdCrsrImsc_serial
;
692 UNSERIALIZE_SCALAR(clcdCrsrImsc_serial
);
693 clcdCrsrImsc
= clcdCrsrImsc_serial
;
695 uint8_t clcdCrsrIcr_serial
;
696 UNSERIALIZE_SCALAR(clcdCrsrIcr_serial
);
697 clcdCrsrIcr
= clcdCrsrIcr_serial
;
699 uint8_t clcdCrsrRis_serial
;
700 UNSERIALIZE_SCALAR(clcdCrsrRis_serial
);
701 clcdCrsrRis
= clcdCrsrRis_serial
;
703 uint8_t clcdCrsrMis_serial
;
704 UNSERIALIZE_SCALAR(clcdCrsrMis_serial
);
705 clcdCrsrMis
= clcdCrsrMis_serial
;
707 UNSERIALIZE_SCALAR(height
);
708 UNSERIALIZE_SCALAR(width
);
709 UNSERIALIZE_SCALAR(bytesPerPixel
);
711 UNSERIALIZE_ARRAY(dmaBuffer
, buffer_size
);
712 UNSERIALIZE_SCALAR(startTime
);
713 UNSERIALIZE_SCALAR(startAddr
);
714 UNSERIALIZE_SCALAR(maxAddr
);
715 UNSERIALIZE_SCALAR(curAddr
);
716 UNSERIALIZE_SCALAR(waterMark
);
717 UNSERIALIZE_SCALAR(dmaPendingNum
);
719 Tick int_event_time
= 0;
720 Tick read_event_time
= 0;
721 Tick fill_fifo_event_time
= 0;
723 UNSERIALIZE_SCALAR(read_event_time
);
724 UNSERIALIZE_SCALAR(fill_fifo_event_time
);
725 UNSERIALIZE_SCALAR(int_event_time
);
728 schedule(intEvent
, int_event_time
);
730 schedule(readEvent
, read_event_time
);
731 if (fill_fifo_event_time
)
732 schedule(fillFifoEvent
, fill_fifo_event_time
);
734 vector
<Tick
> dma_done_event_tick
;
735 dma_done_event_tick
.resize(maxOutstandingDma
);
736 UNSERIALIZE_CONTAINER(dma_done_event_tick
);
737 dmaDoneEventFree
.clear();
738 for (int x
= 0; x
< maxOutstandingDma
; x
++) {
739 if (dma_done_event_tick
[x
])
740 schedule(dmaDoneEventAll
[x
], dma_done_event_tick
[x
]);
742 dmaDoneEventFree
.push_back(&dmaDoneEventAll
[x
]);
744 assert(maxOutstandingDma
- dmaDoneEventFree
.size() == dmaPendingNum
);
746 if (lcdControl
.lcdpwr
) {
748 fb
.copyIn(dmaBuffer
, converter
);
755 Pl111::generateInterrupt()
757 DPRINTF(PL111
, "Generate Interrupt: lcdImsc=0x%x lcdRis=0x%x lcdMis=0x%x\n",
758 (uint32_t)lcdImsc
, (uint32_t)lcdRis
, (uint32_t)lcdMis
);
759 lcdMis
= lcdImsc
& lcdRis
;
761 if (lcdMis
.underflow
|| lcdMis
.baseaddr
|| lcdMis
.vcomp
|| lcdMis
.ahbmaster
) {
762 gic
->sendInt(intNum
);
763 DPRINTF(PL111
, " -- Generated\n");
768 Pl111::getAddrRanges() const
770 AddrRangeList ranges
;
771 ranges
.push_back(RangeSize(pioAddr
, pioSize
));
776 Pl111Params::create()
778 return new Pl111(this);