2010-11-15 21:04:03 +01:00
|
|
|
/*
|
|
|
|
* Copyright (c) 2010 ARM Limited
|
|
|
|
* All rights reserved
|
|
|
|
*
|
|
|
|
* The license below extends only to copyright in the software and shall
|
|
|
|
* not be construed as granting a license to any other intellectual
|
|
|
|
* property including but not limited to intellectual property relating
|
|
|
|
* to a hardware implementation of the functionality of the software
|
|
|
|
* licensed hereunder. You may use the software subject to the license
|
|
|
|
* terms below provided that you ensure that this notice is replicated
|
|
|
|
* unmodified and in its entirety in all distributions of the software,
|
|
|
|
* modified or unmodified, in source code or in binary form.
|
|
|
|
*
|
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
* modification, are permitted provided that the following conditions are
|
|
|
|
* met: redistributions of source code must retain the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer;
|
|
|
|
* redistributions in binary form must reproduce the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
|
|
* documentation and/or other materials provided with the distribution;
|
|
|
|
* neither the name of the copyright holders nor the names of its
|
|
|
|
* contributors may be used to endorse or promote products derived from
|
|
|
|
* this software without specific prior written permission.
|
|
|
|
*
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
|
|
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
|
|
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
|
|
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
|
|
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
|
|
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
|
|
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
|
|
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
|
|
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
|
|
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
*
|
|
|
|
* Authors: William Wang
|
2011-02-12 01:29:36 +01:00
|
|
|
* Ali Saidi
|
2010-11-15 21:04:03 +01:00
|
|
|
*/
|
|
|
|
|
2011-04-15 19:44:06 +02:00
|
|
|
#include "base/vnc/vncserver.hh"
|
2011-02-12 01:29:36 +01:00
|
|
|
#include "base/bitmap.hh"
|
|
|
|
#include "base/output.hh"
|
2010-11-15 21:04:03 +01:00
|
|
|
#include "base/trace.hh"
|
|
|
|
#include "dev/arm/amba_device.hh"
|
|
|
|
#include "dev/arm/gic.hh"
|
|
|
|
#include "dev/arm/pl111.hh"
|
|
|
|
#include "mem/packet.hh"
|
|
|
|
#include "mem/packet_access.hh"
|
|
|
|
|
|
|
|
using namespace AmbaDev;
|
|
|
|
|
|
|
|
// initialize clcd registers
|
|
|
|
Pl111::Pl111(const Params *p)
|
|
|
|
: AmbaDmaDevice(p), lcdTiming0(0), lcdTiming1(0), lcdTiming2(0),
|
|
|
|
lcdTiming3(0), lcdUpbase(0), lcdLpbase(0), lcdControl(0), lcdImsc(0),
|
2011-02-12 01:29:36 +01:00
|
|
|
lcdRis(0), lcdMis(0),
|
2010-11-15 21:04:03 +01:00
|
|
|
clcdCrsrCtrl(0), clcdCrsrConfig(0), clcdCrsrPalette0(0),
|
|
|
|
clcdCrsrPalette1(0), clcdCrsrXY(0), clcdCrsrClip(0), clcdCrsrImsc(0),
|
|
|
|
clcdCrsrIcr(0), clcdCrsrRis(0), clcdCrsrMis(0), clock(p->clock),
|
2011-02-12 01:29:36 +01:00
|
|
|
vncserver(p->vnc), bmp(NULL), width(LcdMaxWidth), height(LcdMaxHeight),
|
|
|
|
bytesPerPixel(4), startTime(0), startAddr(0), maxAddr(0), curAddr(0),
|
2010-11-15 21:04:03 +01:00
|
|
|
waterMark(0), dmaPendingNum(0), readEvent(this), fillFifoEvent(this),
|
|
|
|
dmaDoneEvent(maxOutstandingDma, this), intEvent(this)
|
|
|
|
{
|
|
|
|
pioSize = 0xFFFF;
|
|
|
|
|
2011-02-12 01:29:36 +01:00
|
|
|
pic = simout.create("framebuffer.bmp", true);
|
|
|
|
|
|
|
|
dmaBuffer = new uint8_t[LcdMaxWidth * LcdMaxHeight * sizeof(uint32_t)];
|
|
|
|
|
2010-11-15 21:04:03 +01:00
|
|
|
memset(lcdPalette, 0, sizeof(lcdPalette));
|
|
|
|
memset(cursorImage, 0, sizeof(cursorImage));
|
|
|
|
memset(dmaBuffer, 0, sizeof(dmaBuffer));
|
2011-02-12 01:29:36 +01:00
|
|
|
|
|
|
|
if (vncserver)
|
|
|
|
vncserver->setFramebufferAddr(dmaBuffer);
|
2010-11-15 21:04:03 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// read registers and frame buffer
|
|
|
|
Tick
|
|
|
|
Pl111::read(PacketPtr pkt)
|
|
|
|
{
|
|
|
|
// use a temporary data since the LCD registers are read/written with
|
|
|
|
// different size operations
|
|
|
|
|
|
|
|
uint32_t data = 0;
|
|
|
|
|
2011-02-12 01:29:36 +01:00
|
|
|
assert(pkt->getAddr() >= pioAddr &&
|
|
|
|
pkt->getAddr() < pioAddr + pioSize);
|
2010-11-15 21:04:03 +01:00
|
|
|
|
2011-02-12 01:29:36 +01:00
|
|
|
Addr daddr = pkt->getAddr() - pioAddr;
|
|
|
|
pkt->allocate();
|
2010-11-15 21:04:03 +01:00
|
|
|
|
2011-02-12 01:29:36 +01:00
|
|
|
DPRINTF(PL111, " read register %#x size=%d\n", daddr, pkt->getSize());
|
2010-11-15 21:04:03 +01:00
|
|
|
|
2011-02-12 01:29:36 +01:00
|
|
|
switch (daddr) {
|
|
|
|
case LcdTiming0:
|
|
|
|
data = lcdTiming0;
|
|
|
|
break;
|
|
|
|
case LcdTiming1:
|
|
|
|
data = lcdTiming1;
|
|
|
|
break;
|
|
|
|
case LcdTiming2:
|
|
|
|
data = lcdTiming2;
|
|
|
|
break;
|
|
|
|
case LcdTiming3:
|
|
|
|
data = lcdTiming3;
|
|
|
|
break;
|
|
|
|
case LcdUpBase:
|
|
|
|
data = lcdUpbase;
|
|
|
|
break;
|
|
|
|
case LcdLpBase:
|
|
|
|
data = lcdLpbase;
|
|
|
|
break;
|
|
|
|
case LcdControl:
|
|
|
|
data = lcdControl;
|
|
|
|
break;
|
|
|
|
case LcdImsc:
|
|
|
|
data = lcdImsc;
|
|
|
|
break;
|
|
|
|
case LcdRis:
|
|
|
|
data = lcdRis;
|
|
|
|
break;
|
|
|
|
case LcdMis:
|
|
|
|
data = lcdMis;
|
|
|
|
break;
|
|
|
|
case LcdIcr:
|
|
|
|
panic("LCD register at offset %#x is Write-Only\n", daddr);
|
|
|
|
break;
|
|
|
|
case LcdUpCurr:
|
|
|
|
data = curAddr;
|
|
|
|
break;
|
|
|
|
case LcdLpCurr:
|
|
|
|
data = curAddr;
|
|
|
|
break;
|
|
|
|
case ClcdCrsrCtrl:
|
|
|
|
data = clcdCrsrCtrl;
|
|
|
|
break;
|
|
|
|
case ClcdCrsrConfig:
|
|
|
|
data = clcdCrsrConfig;
|
|
|
|
break;
|
|
|
|
case ClcdCrsrPalette0:
|
|
|
|
data = clcdCrsrPalette0;
|
|
|
|
break;
|
|
|
|
case ClcdCrsrPalette1:
|
|
|
|
data = clcdCrsrPalette1;
|
|
|
|
break;
|
|
|
|
case ClcdCrsrXY:
|
|
|
|
data = clcdCrsrXY;
|
|
|
|
break;
|
|
|
|
case ClcdCrsrClip:
|
|
|
|
data = clcdCrsrClip;
|
|
|
|
break;
|
|
|
|
case ClcdCrsrImsc:
|
|
|
|
data = clcdCrsrImsc;
|
|
|
|
break;
|
|
|
|
case ClcdCrsrIcr:
|
|
|
|
panic("CLCD register at offset %#x is Write-Only\n", daddr);
|
|
|
|
break;
|
|
|
|
case ClcdCrsrRis:
|
|
|
|
data = clcdCrsrRis;
|
|
|
|
break;
|
|
|
|
case ClcdCrsrMis:
|
|
|
|
data = clcdCrsrMis;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
if (AmbaDev::readId(pkt, AMBA_ID, pioAddr)) {
|
|
|
|
// Hack for variable size accesses
|
|
|
|
data = pkt->get<uint32_t>();
|
|
|
|
break;
|
|
|
|
} else if (daddr >= CrsrImage && daddr <= 0xBFC) {
|
|
|
|
// CURSOR IMAGE
|
|
|
|
int index;
|
|
|
|
index = (daddr - CrsrImage) >> 2;
|
|
|
|
data= cursorImage[index];
|
|
|
|
break;
|
|
|
|
} else if (daddr >= LcdPalette && daddr <= 0x3FC) {
|
|
|
|
// LCD Palette
|
|
|
|
int index;
|
|
|
|
index = (daddr - LcdPalette) >> 2;
|
|
|
|
data = lcdPalette[index];
|
|
|
|
break;
|
|
|
|
} else {
|
|
|
|
panic("Tried to read CLCD register at offset %#x that \
|
2010-11-15 21:04:03 +01:00
|
|
|
doesn't exist\n", daddr);
|
2011-02-12 01:29:36 +01:00
|
|
|
break;
|
2010-11-15 21:04:03 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
switch(pkt->getSize()) {
|
|
|
|
case 1:
|
|
|
|
pkt->set<uint8_t>(data);
|
|
|
|
break;
|
|
|
|
case 2:
|
|
|
|
pkt->set<uint16_t>(data);
|
|
|
|
break;
|
|
|
|
case 4:
|
|
|
|
pkt->set<uint32_t>(data);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
panic("CLCD controller read size too big?\n");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
pkt->makeAtomicResponse();
|
|
|
|
return pioDelay;
|
|
|
|
}
|
|
|
|
|
|
|
|
// write registers and frame buffer
|
|
|
|
Tick
|
|
|
|
Pl111::write(PacketPtr pkt)
|
|
|
|
{
|
|
|
|
// use a temporary data since the LCD registers are read/written with
|
|
|
|
// different size operations
|
|
|
|
//
|
|
|
|
uint32_t data = 0;
|
|
|
|
|
|
|
|
switch(pkt->getSize()) {
|
|
|
|
case 1:
|
|
|
|
data = pkt->get<uint8_t>();
|
|
|
|
break;
|
|
|
|
case 2:
|
|
|
|
data = pkt->get<uint16_t>();
|
|
|
|
break;
|
|
|
|
case 4:
|
|
|
|
data = pkt->get<uint32_t>();
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
panic("PL111 CLCD controller write size too big?\n");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2011-02-12 01:29:36 +01:00
|
|
|
assert(pkt->getAddr() >= pioAddr &&
|
|
|
|
pkt->getAddr() < pioAddr + pioSize);
|
2010-11-15 21:04:03 +01:00
|
|
|
|
2011-02-12 01:29:36 +01:00
|
|
|
Addr daddr = pkt->getAddr() - pioAddr;
|
2010-11-15 21:04:03 +01:00
|
|
|
|
2011-02-12 01:29:36 +01:00
|
|
|
DPRINTF(PL111, " write register %#x value %#x size=%d\n", daddr,
|
|
|
|
pkt->get<uint8_t>(), pkt->getSize());
|
2010-11-15 21:04:03 +01:00
|
|
|
|
2011-02-12 01:29:36 +01:00
|
|
|
switch (daddr) {
|
|
|
|
case LcdTiming0:
|
|
|
|
lcdTiming0 = data;
|
|
|
|
// width = 16 * (PPL+1)
|
|
|
|
width = (lcdTiming0.ppl + 1) << 4;
|
|
|
|
break;
|
|
|
|
case LcdTiming1:
|
|
|
|
lcdTiming1 = data;
|
|
|
|
// height = LPP + 1
|
|
|
|
height = (lcdTiming1.lpp) + 1;
|
|
|
|
break;
|
|
|
|
case LcdTiming2:
|
|
|
|
lcdTiming2 = data;
|
|
|
|
break;
|
|
|
|
case LcdTiming3:
|
|
|
|
lcdTiming3 = data;
|
|
|
|
break;
|
|
|
|
case LcdUpBase:
|
|
|
|
lcdUpbase = data;
|
|
|
|
DPRINTF(PL111, "####### Upper panel base set to: %#x #######\n", lcdUpbase);
|
|
|
|
break;
|
|
|
|
case LcdLpBase:
|
|
|
|
warn("LCD dual screen mode not supported\n");
|
|
|
|
lcdLpbase = data;
|
|
|
|
DPRINTF(PL111, "###### Lower panel base set to: %#x #######\n", lcdLpbase);
|
|
|
|
break;
|
|
|
|
case LcdControl:
|
|
|
|
int old_lcdpwr;
|
|
|
|
old_lcdpwr = lcdControl.lcdpwr;
|
|
|
|
lcdControl = data;
|
|
|
|
|
|
|
|
DPRINTF(PL111, "LCD power is:%d\n", lcdControl.lcdpwr);
|
|
|
|
|
|
|
|
// LCD power enable
|
|
|
|
if (lcdControl.lcdpwr && !old_lcdpwr) {
|
|
|
|
updateVideoParams();
|
|
|
|
DPRINTF(PL111, " lcd size: height %d width %d\n", height, width);
|
|
|
|
waterMark = lcdControl.watermark ? 8 : 4;
|
|
|
|
startDma();
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case LcdImsc:
|
|
|
|
lcdImsc = data;
|
|
|
|
if (lcdImsc.vcomp)
|
|
|
|
panic("Interrupting on vcomp not supported\n");
|
2010-11-15 21:04:03 +01:00
|
|
|
|
2011-02-12 01:29:36 +01:00
|
|
|
lcdMis = lcdImsc & lcdRis;
|
|
|
|
|
|
|
|
if (!lcdMis)
|
|
|
|
gic->clearInt(intNum);
|
|
|
|
|
|
|
|
break;
|
|
|
|
case LcdRis:
|
|
|
|
panic("LCD register at offset %#x is Read-Only\n", daddr);
|
|
|
|
break;
|
|
|
|
case LcdMis:
|
|
|
|
panic("LCD register at offset %#x is Read-Only\n", daddr);
|
|
|
|
break;
|
|
|
|
case LcdIcr:
|
|
|
|
lcdRis = lcdRis & ~data;
|
|
|
|
lcdMis = lcdImsc & lcdRis;
|
|
|
|
|
|
|
|
if (!lcdMis)
|
|
|
|
gic->clearInt(intNum);
|
|
|
|
|
|
|
|
break;
|
|
|
|
case LcdUpCurr:
|
|
|
|
panic("LCD register at offset %#x is Read-Only\n", daddr);
|
|
|
|
break;
|
|
|
|
case LcdLpCurr:
|
|
|
|
panic("LCD register at offset %#x is Read-Only\n", daddr);
|
|
|
|
break;
|
|
|
|
case ClcdCrsrCtrl:
|
|
|
|
clcdCrsrCtrl = data;
|
|
|
|
break;
|
|
|
|
case ClcdCrsrConfig:
|
|
|
|
clcdCrsrConfig = data;
|
|
|
|
break;
|
|
|
|
case ClcdCrsrPalette0:
|
|
|
|
clcdCrsrPalette0 = data;
|
|
|
|
break;
|
|
|
|
case ClcdCrsrPalette1:
|
|
|
|
clcdCrsrPalette1 = data;
|
|
|
|
break;
|
|
|
|
case ClcdCrsrXY:
|
|
|
|
clcdCrsrXY = data;
|
|
|
|
break;
|
|
|
|
case ClcdCrsrClip:
|
|
|
|
clcdCrsrClip = data;
|
|
|
|
break;
|
|
|
|
case ClcdCrsrImsc:
|
|
|
|
clcdCrsrImsc = data;
|
|
|
|
break;
|
|
|
|
case ClcdCrsrIcr:
|
|
|
|
clcdCrsrIcr = data;
|
|
|
|
break;
|
|
|
|
case ClcdCrsrRis:
|
|
|
|
panic("CLCD register at offset %#x is Read-Only\n", daddr);
|
|
|
|
break;
|
|
|
|
case ClcdCrsrMis:
|
|
|
|
panic("CLCD register at offset %#x is Read-Only\n", daddr);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
if (daddr >= CrsrImage && daddr <= 0xBFC) {
|
|
|
|
// CURSOR IMAGE
|
|
|
|
int index;
|
|
|
|
index = (daddr - CrsrImage) >> 2;
|
|
|
|
cursorImage[index] = data;
|
|
|
|
break;
|
|
|
|
} else if (daddr >= LcdPalette && daddr <= 0x3FC) {
|
|
|
|
// LCD Palette
|
|
|
|
int index;
|
|
|
|
index = (daddr - LcdPalette) >> 2;
|
|
|
|
lcdPalette[index] = data;
|
|
|
|
break;
|
|
|
|
} else {
|
|
|
|
panic("Tried to write PL111 register at offset %#x that \
|
2010-11-15 21:04:03 +01:00
|
|
|
doesn't exist\n", daddr);
|
2011-02-12 01:29:36 +01:00
|
|
|
break;
|
2010-11-15 21:04:03 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
pkt->makeAtomicResponse();
|
|
|
|
return pioDelay;
|
|
|
|
}
|
|
|
|
|
2011-02-12 01:29:36 +01:00
|
|
|
void
|
|
|
|
Pl111::updateVideoParams()
|
|
|
|
{
|
|
|
|
if (lcdControl.lcdbpp == bpp24) {
|
|
|
|
bytesPerPixel = 4;
|
|
|
|
} else if (lcdControl.lcdbpp == bpp16m565) {
|
|
|
|
bytesPerPixel = 2;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (vncserver) {
|
|
|
|
if (lcdControl.lcdbpp == bpp24 && lcdControl.bgr)
|
|
|
|
vncserver->setFrameBufferParams(VideoConvert::bgr8888, width,
|
|
|
|
height);
|
|
|
|
else if (lcdControl.lcdbpp == bpp24 && !lcdControl.bgr)
|
|
|
|
vncserver->setFrameBufferParams(VideoConvert::rgb8888, width,
|
|
|
|
height);
|
|
|
|
else if (lcdControl.lcdbpp == bpp16m565 && lcdControl.bgr)
|
|
|
|
vncserver->setFrameBufferParams(VideoConvert::bgr565, width,
|
|
|
|
height);
|
|
|
|
else if (lcdControl.lcdbpp == bpp16m565 && !lcdControl.bgr)
|
|
|
|
vncserver->setFrameBufferParams(VideoConvert::rgb565, width,
|
|
|
|
height);
|
|
|
|
else
|
|
|
|
panic("Unimplemented video mode\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
if (bmp)
|
|
|
|
delete bmp;
|
|
|
|
|
|
|
|
if (lcdControl.lcdbpp == bpp24 && lcdControl.bgr)
|
|
|
|
bmp = new Bitmap(VideoConvert::bgr8888, width, height, dmaBuffer);
|
|
|
|
else if (lcdControl.lcdbpp == bpp24 && !lcdControl.bgr)
|
|
|
|
bmp = new Bitmap(VideoConvert::rgb8888, width, height, dmaBuffer);
|
|
|
|
else if (lcdControl.lcdbpp == bpp16m565 && lcdControl.bgr)
|
|
|
|
bmp = new Bitmap(VideoConvert::bgr565, width, height, dmaBuffer);
|
|
|
|
else if (lcdControl.lcdbpp == bpp16m565 && !lcdControl.bgr)
|
|
|
|
bmp = new Bitmap(VideoConvert::rgb565, width, height, dmaBuffer);
|
|
|
|
else
|
|
|
|
panic("Unimplemented video mode\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
Pl111::startDma()
|
|
|
|
{
|
|
|
|
if (dmaPendingNum != 0 || readEvent.scheduled())
|
|
|
|
return;
|
|
|
|
readFramebuffer();
|
|
|
|
}
|
|
|
|
|
2010-11-15 21:04:03 +01:00
|
|
|
void
|
|
|
|
Pl111::readFramebuffer()
|
|
|
|
{
|
|
|
|
// initialization for dma read from frame buffer to dma buffer
|
2011-02-12 01:29:36 +01:00
|
|
|
uint32_t length = height * width;
|
|
|
|
if (startAddr != lcdUpbase)
|
2010-11-15 21:04:03 +01:00
|
|
|
startAddr = lcdUpbase;
|
2011-02-12 01:29:36 +01:00
|
|
|
|
|
|
|
// Updating base address, interrupt if we're supposed to
|
|
|
|
lcdRis.baseaddr = 1;
|
|
|
|
if (!intEvent.scheduled())
|
|
|
|
schedule(intEvent, nextCycle());
|
|
|
|
|
2010-11-15 21:04:03 +01:00
|
|
|
curAddr = 0;
|
2011-01-08 06:50:29 +01:00
|
|
|
startTime = curTick();
|
2011-02-12 01:29:36 +01:00
|
|
|
|
|
|
|
maxAddr = static_cast<Addr>(length * bytesPerPixel);
|
|
|
|
|
|
|
|
DPRINTF(PL111, " lcd frame buffer size of %d bytes \n", maxAddr);
|
|
|
|
|
|
|
|
dmaPendingNum = 0;
|
2010-11-15 21:04:03 +01:00
|
|
|
|
|
|
|
fillFifo();
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
Pl111::fillFifo()
|
|
|
|
{
|
|
|
|
while ((dmaPendingNum < maxOutstandingDma) && (maxAddr >= curAddr + dmaSize )) {
|
|
|
|
// concurrent dma reads need different dma done events
|
|
|
|
// due to assertion in scheduling state
|
|
|
|
++dmaPendingNum;
|
2011-02-12 01:29:36 +01:00
|
|
|
|
2010-11-15 21:04:03 +01:00
|
|
|
assert(!dmaDoneEvent[dmaPendingNum-1].scheduled());
|
2011-02-12 01:29:36 +01:00
|
|
|
|
|
|
|
// We use a uncachable request here because the requests from the CPU
|
|
|
|
// will be uncacheable as well. If we have uncacheable and cacheable
|
|
|
|
// requests in the memory system for the same address it won't be
|
|
|
|
// pleased
|
|
|
|
dmaPort->dmaAction(MemCmd::ReadReq, curAddr + startAddr, dmaSize,
|
|
|
|
&dmaDoneEvent[dmaPendingNum-1], curAddr + dmaBuffer, 0,
|
|
|
|
Request::UNCACHEABLE);
|
2010-11-15 21:04:03 +01:00
|
|
|
curAddr += dmaSize;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
Pl111::dmaDone()
|
|
|
|
{
|
2011-02-12 01:29:36 +01:00
|
|
|
Tick maxFrameTime = lcdTiming2.cpl * height * clock;
|
2010-11-15 21:04:03 +01:00
|
|
|
|
|
|
|
--dmaPendingNum;
|
|
|
|
|
|
|
|
if (maxAddr == curAddr && !dmaPendingNum) {
|
2011-02-12 01:29:36 +01:00
|
|
|
if ((curTick() - startTime) > maxFrameTime) {
|
2010-11-15 21:04:03 +01:00
|
|
|
warn("CLCD controller buffer underrun, took %d cycles when should"
|
2011-01-08 06:50:29 +01:00
|
|
|
" have taken %d\n", curTick() - startTime, maxFrameTime);
|
2011-02-12 01:29:36 +01:00
|
|
|
lcdRis.underflow = 1;
|
|
|
|
if (!intEvent.scheduled())
|
|
|
|
schedule(intEvent, nextCycle());
|
|
|
|
}
|
2010-11-15 21:04:03 +01:00
|
|
|
|
|
|
|
assert(!readEvent.scheduled());
|
2011-02-12 01:29:36 +01:00
|
|
|
if (vncserver)
|
|
|
|
vncserver->setDirty();
|
2010-11-15 21:04:03 +01:00
|
|
|
|
|
|
|
DPRINTF(PL111, "-- write out frame buffer into bmp\n");
|
2011-02-12 01:29:36 +01:00
|
|
|
|
|
|
|
assert(bmp);
|
|
|
|
pic->seekp(0);
|
|
|
|
bmp->write(pic);
|
2010-11-15 21:04:03 +01:00
|
|
|
|
|
|
|
DPRINTF(PL111, "-- schedule next dma read event at %d tick \n",
|
2011-01-08 06:50:29 +01:00
|
|
|
maxFrameTime + curTick());
|
2011-02-12 01:29:36 +01:00
|
|
|
|
|
|
|
if (lcdControl.lcden)
|
|
|
|
schedule(readEvent, nextCycle(startTime + maxFrameTime));
|
2010-11-15 21:04:03 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
if (dmaPendingNum > (maxOutstandingDma - waterMark))
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (!fillFifoEvent.scheduled())
|
|
|
|
schedule(fillFifoEvent, nextCycle());
|
|
|
|
}
|
|
|
|
|
2011-02-12 01:29:36 +01:00
|
|
|
|
2010-11-15 21:04:03 +01:00
|
|
|
Tick
|
|
|
|
Pl111::nextCycle()
|
|
|
|
{
|
2011-01-08 06:50:29 +01:00
|
|
|
Tick nextTick = curTick() + clock - 1;
|
2010-11-15 21:04:03 +01:00
|
|
|
nextTick -= nextTick%clock;
|
|
|
|
return nextTick;
|
|
|
|
}
|
|
|
|
|
|
|
|
Tick
|
|
|
|
Pl111::nextCycle(Tick beginTick)
|
|
|
|
{
|
|
|
|
Tick nextTick = beginTick;
|
|
|
|
if (nextTick%clock!=0)
|
|
|
|
nextTick = nextTick - (nextTick%clock) + clock;
|
|
|
|
|
2011-01-08 06:50:29 +01:00
|
|
|
assert(nextTick >= curTick());
|
2010-11-15 21:04:03 +01:00
|
|
|
return nextTick;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
Pl111::serialize(std::ostream &os)
|
|
|
|
{
|
|
|
|
DPRINTF(PL111, "Serializing ARM PL111\n");
|
|
|
|
|
|
|
|
uint32_t lcdTiming0_serial = lcdTiming0;
|
|
|
|
SERIALIZE_SCALAR(lcdTiming0_serial);
|
|
|
|
|
|
|
|
uint32_t lcdTiming1_serial = lcdTiming1;
|
|
|
|
SERIALIZE_SCALAR(lcdTiming1_serial);
|
|
|
|
|
|
|
|
uint32_t lcdTiming2_serial = lcdTiming2;
|
|
|
|
SERIALIZE_SCALAR(lcdTiming2_serial);
|
|
|
|
|
|
|
|
uint32_t lcdTiming3_serial = lcdTiming3;
|
|
|
|
SERIALIZE_SCALAR(lcdTiming3_serial);
|
|
|
|
|
|
|
|
SERIALIZE_SCALAR(lcdUpbase);
|
|
|
|
SERIALIZE_SCALAR(lcdLpbase);
|
|
|
|
|
|
|
|
uint32_t lcdControl_serial = lcdControl;
|
|
|
|
SERIALIZE_SCALAR(lcdControl_serial);
|
|
|
|
|
|
|
|
uint8_t lcdImsc_serial = lcdImsc;
|
|
|
|
SERIALIZE_SCALAR(lcdImsc_serial);
|
|
|
|
|
|
|
|
uint8_t lcdRis_serial = lcdRis;
|
|
|
|
SERIALIZE_SCALAR(lcdRis_serial);
|
|
|
|
|
|
|
|
uint8_t lcdMis_serial = lcdMis;
|
|
|
|
SERIALIZE_SCALAR(lcdMis_serial);
|
|
|
|
|
|
|
|
SERIALIZE_ARRAY(lcdPalette, LcdPaletteSize);
|
|
|
|
SERIALIZE_ARRAY(cursorImage, CrsrImageSize);
|
|
|
|
|
|
|
|
SERIALIZE_SCALAR(clcdCrsrCtrl);
|
|
|
|
SERIALIZE_SCALAR(clcdCrsrConfig);
|
|
|
|
SERIALIZE_SCALAR(clcdCrsrPalette0);
|
|
|
|
SERIALIZE_SCALAR(clcdCrsrPalette1);
|
|
|
|
SERIALIZE_SCALAR(clcdCrsrXY);
|
|
|
|
SERIALIZE_SCALAR(clcdCrsrClip);
|
|
|
|
|
|
|
|
uint8_t clcdCrsrImsc_serial = clcdCrsrImsc;
|
|
|
|
SERIALIZE_SCALAR(clcdCrsrImsc_serial);
|
|
|
|
|
|
|
|
uint8_t clcdCrsrIcr_serial = clcdCrsrIcr;
|
|
|
|
SERIALIZE_SCALAR(clcdCrsrIcr_serial);
|
|
|
|
|
|
|
|
uint8_t clcdCrsrRis_serial = clcdCrsrRis;
|
|
|
|
SERIALIZE_SCALAR(clcdCrsrRis_serial);
|
|
|
|
|
|
|
|
uint8_t clcdCrsrMis_serial = clcdCrsrMis;
|
|
|
|
SERIALIZE_SCALAR(clcdCrsrMis_serial);
|
|
|
|
|
|
|
|
SERIALIZE_SCALAR(clock);
|
|
|
|
SERIALIZE_SCALAR(height);
|
|
|
|
SERIALIZE_SCALAR(width);
|
2011-02-12 01:29:36 +01:00
|
|
|
SERIALIZE_SCALAR(bytesPerPixel);
|
2010-11-15 21:04:03 +01:00
|
|
|
|
2011-02-12 01:29:36 +01:00
|
|
|
SERIALIZE_ARRAY(dmaBuffer, height * width);
|
2010-11-15 21:04:03 +01:00
|
|
|
SERIALIZE_SCALAR(startTime);
|
|
|
|
SERIALIZE_SCALAR(startAddr);
|
|
|
|
SERIALIZE_SCALAR(maxAddr);
|
|
|
|
SERIALIZE_SCALAR(curAddr);
|
|
|
|
SERIALIZE_SCALAR(waterMark);
|
|
|
|
SERIALIZE_SCALAR(dmaPendingNum);
|
2011-02-23 22:10:48 +01:00
|
|
|
|
|
|
|
Tick int_event_time = 0;
|
|
|
|
Tick read_event_time = 0;
|
|
|
|
Tick fill_fifo_event_time = 0;
|
|
|
|
|
|
|
|
if (readEvent.scheduled())
|
|
|
|
read_event_time = readEvent.when();
|
|
|
|
if (fillFifoEvent.scheduled())
|
|
|
|
fill_fifo_event_time = fillFifoEvent.when();
|
|
|
|
if (intEvent.scheduled())
|
|
|
|
int_event_time = intEvent.when();
|
|
|
|
|
|
|
|
SERIALIZE_SCALAR(read_event_time);
|
|
|
|
SERIALIZE_SCALAR(fill_fifo_event_time);
|
|
|
|
SERIALIZE_SCALAR(int_event_time);
|
|
|
|
|
|
|
|
vector<Tick> dma_done_event_tick;
|
|
|
|
dma_done_event_tick.resize(maxOutstandingDma);
|
|
|
|
for (int x = 0; x < maxOutstandingDma; x++) {
|
|
|
|
dma_done_event_tick[x] = dmaDoneEvent[x].scheduled() ?
|
|
|
|
dmaDoneEvent[x].when() : 0;
|
|
|
|
}
|
|
|
|
arrayParamOut(os, "dma_done_event_tick", dma_done_event_tick);
|
2010-11-15 21:04:03 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
Pl111::unserialize(Checkpoint *cp, const std::string §ion)
|
|
|
|
{
|
|
|
|
DPRINTF(PL111, "Unserializing ARM PL111\n");
|
|
|
|
|
|
|
|
uint32_t lcdTiming0_serial;
|
|
|
|
UNSERIALIZE_SCALAR(lcdTiming0_serial);
|
|
|
|
lcdTiming0 = lcdTiming0_serial;
|
|
|
|
|
|
|
|
uint32_t lcdTiming1_serial;
|
|
|
|
UNSERIALIZE_SCALAR(lcdTiming1_serial);
|
|
|
|
lcdTiming1 = lcdTiming1_serial;
|
|
|
|
|
|
|
|
uint32_t lcdTiming2_serial;
|
|
|
|
UNSERIALIZE_SCALAR(lcdTiming2_serial);
|
|
|
|
lcdTiming2 = lcdTiming2_serial;
|
|
|
|
|
|
|
|
uint32_t lcdTiming3_serial;
|
|
|
|
UNSERIALIZE_SCALAR(lcdTiming3_serial);
|
|
|
|
lcdTiming3 = lcdTiming3_serial;
|
|
|
|
|
|
|
|
UNSERIALIZE_SCALAR(lcdUpbase);
|
|
|
|
UNSERIALIZE_SCALAR(lcdLpbase);
|
|
|
|
|
|
|
|
uint32_t lcdControl_serial;
|
|
|
|
UNSERIALIZE_SCALAR(lcdControl_serial);
|
|
|
|
lcdControl = lcdControl_serial;
|
|
|
|
|
|
|
|
uint8_t lcdImsc_serial;
|
|
|
|
UNSERIALIZE_SCALAR(lcdImsc_serial);
|
|
|
|
lcdImsc = lcdImsc_serial;
|
|
|
|
|
|
|
|
uint8_t lcdRis_serial;
|
|
|
|
UNSERIALIZE_SCALAR(lcdRis_serial);
|
|
|
|
lcdRis = lcdRis_serial;
|
|
|
|
|
|
|
|
uint8_t lcdMis_serial;
|
|
|
|
UNSERIALIZE_SCALAR(lcdMis_serial);
|
|
|
|
lcdMis = lcdMis_serial;
|
|
|
|
|
|
|
|
UNSERIALIZE_ARRAY(lcdPalette, LcdPaletteSize);
|
|
|
|
UNSERIALIZE_ARRAY(cursorImage, CrsrImageSize);
|
|
|
|
|
|
|
|
UNSERIALIZE_SCALAR(clcdCrsrCtrl);
|
|
|
|
UNSERIALIZE_SCALAR(clcdCrsrConfig);
|
|
|
|
UNSERIALIZE_SCALAR(clcdCrsrPalette0);
|
|
|
|
UNSERIALIZE_SCALAR(clcdCrsrPalette1);
|
|
|
|
UNSERIALIZE_SCALAR(clcdCrsrXY);
|
|
|
|
UNSERIALIZE_SCALAR(clcdCrsrClip);
|
|
|
|
|
|
|
|
uint8_t clcdCrsrImsc_serial;
|
|
|
|
UNSERIALIZE_SCALAR(clcdCrsrImsc_serial);
|
|
|
|
clcdCrsrImsc = clcdCrsrImsc_serial;
|
|
|
|
|
|
|
|
uint8_t clcdCrsrIcr_serial;
|
|
|
|
UNSERIALIZE_SCALAR(clcdCrsrIcr_serial);
|
|
|
|
clcdCrsrIcr = clcdCrsrIcr_serial;
|
|
|
|
|
|
|
|
uint8_t clcdCrsrRis_serial;
|
|
|
|
UNSERIALIZE_SCALAR(clcdCrsrRis_serial);
|
|
|
|
clcdCrsrRis = clcdCrsrRis_serial;
|
|
|
|
|
|
|
|
uint8_t clcdCrsrMis_serial;
|
|
|
|
UNSERIALIZE_SCALAR(clcdCrsrMis_serial);
|
|
|
|
clcdCrsrMis = clcdCrsrMis_serial;
|
|
|
|
|
|
|
|
UNSERIALIZE_SCALAR(clock);
|
|
|
|
UNSERIALIZE_SCALAR(height);
|
|
|
|
UNSERIALIZE_SCALAR(width);
|
2011-02-12 01:29:36 +01:00
|
|
|
UNSERIALIZE_SCALAR(bytesPerPixel);
|
2010-11-15 21:04:03 +01:00
|
|
|
|
2011-02-12 01:29:36 +01:00
|
|
|
UNSERIALIZE_ARRAY(dmaBuffer, height * width);
|
2010-11-15 21:04:03 +01:00
|
|
|
UNSERIALIZE_SCALAR(startTime);
|
|
|
|
UNSERIALIZE_SCALAR(startAddr);
|
|
|
|
UNSERIALIZE_SCALAR(maxAddr);
|
|
|
|
UNSERIALIZE_SCALAR(curAddr);
|
|
|
|
UNSERIALIZE_SCALAR(waterMark);
|
|
|
|
UNSERIALIZE_SCALAR(dmaPendingNum);
|
2011-02-12 01:29:36 +01:00
|
|
|
|
2011-02-23 22:10:48 +01:00
|
|
|
Tick int_event_time = 0;
|
|
|
|
Tick read_event_time = 0;
|
|
|
|
Tick fill_fifo_event_time = 0;
|
|
|
|
|
|
|
|
UNSERIALIZE_SCALAR(read_event_time);
|
|
|
|
UNSERIALIZE_SCALAR(fill_fifo_event_time);
|
|
|
|
UNSERIALIZE_SCALAR(int_event_time);
|
|
|
|
|
|
|
|
if (int_event_time)
|
|
|
|
schedule(intEvent, int_event_time);
|
|
|
|
if (read_event_time)
|
|
|
|
schedule(readEvent, read_event_time);
|
|
|
|
if (fill_fifo_event_time)
|
|
|
|
schedule(fillFifoEvent, fill_fifo_event_time);
|
|
|
|
|
|
|
|
vector<Tick> dma_done_event_tick;
|
|
|
|
dma_done_event_tick.resize(maxOutstandingDma);
|
|
|
|
arrayParamIn(cp, section, "dma_done_event_tick", dma_done_event_tick);
|
|
|
|
for (int x = 0; x < maxOutstandingDma; x++) {
|
|
|
|
if (dma_done_event_tick[x])
|
|
|
|
schedule(dmaDoneEvent[x], dma_done_event_tick[x]);
|
|
|
|
}
|
|
|
|
|
2011-04-04 18:42:23 +02:00
|
|
|
if (lcdControl.lcdpwr) {
|
|
|
|
updateVideoParams();
|
|
|
|
if (vncserver)
|
|
|
|
vncserver->setDirty();
|
|
|
|
}
|
2010-11-15 21:04:03 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
Pl111::generateInterrupt()
|
|
|
|
{
|
|
|
|
DPRINTF(PL111, "Generate Interrupt: lcdImsc=0x%x lcdRis=0x%x lcdMis=0x%x\n",
|
2011-02-12 01:29:36 +01:00
|
|
|
(uint32_t)lcdImsc, (uint32_t)lcdRis, (uint32_t)lcdMis);
|
2010-11-15 21:04:03 +01:00
|
|
|
lcdMis = lcdImsc & lcdRis;
|
|
|
|
|
2011-02-12 01:29:36 +01:00
|
|
|
if (lcdMis.underflow || lcdMis.baseaddr || lcdMis.vcomp || lcdMis.ahbmaster) {
|
2010-11-15 21:04:03 +01:00
|
|
|
gic->sendInt(intNum);
|
|
|
|
DPRINTF(PL111, " -- Generated\n");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
Pl111::addressRanges(AddrRangeList& range_list)
|
|
|
|
{
|
|
|
|
range_list.clear();
|
|
|
|
range_list.push_back(RangeSize(pioAddr, pioSize));
|
|
|
|
}
|
|
|
|
|
|
|
|
Pl111 *
|
|
|
|
Pl111Params::create()
|
|
|
|
{
|
|
|
|
return new Pl111(this);
|
|
|
|
}
|
|
|
|
|
2011-02-12 01:29:36 +01:00
|
|
|
|