1/*
2 * Copyright (c) 2010-2013 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

--- 21 unchanged lines hidden (view full) ---

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: Chris Emmons
38 */
39
40#include "base/vnc/vncinput.hh"
41#include "base/bitmap.hh"
42#include "base/output.hh"
43#include "base/trace.hh"
44#include "debug/HDLcd.hh"
45#include "debug/Uart.hh"
46#include "dev/arm/amba_device.hh"
47#include "dev/arm/base_gic.hh"
48#include "dev/arm/hdlcd.hh"
49#include "mem/packet.hh"
50#include "mem/packet_access.hh"
51#include "sim/system.hh"
52
53using std::vector;
54
55
56// initialize hdlcd registers
57HDLcd::HDLcd(const Params *p)
58 : AmbaDmaDevice(p), version(VERSION_RESETV),
59 int_rawstat(0), int_clear(0), int_mask(0), int_status(0),
60 fb_base(0), fb_line_length(0), fb_line_count(0), fb_line_pitch(0),
61 bus_options(BUS_OPTIONS_RESETV),
62 v_sync(0), v_back_porch(0), v_data(0), v_front_porch(0),
63 h_sync(0), h_back_porch(0), h_data(0), h_front_porch(0),
64 polarities(0), command(0), pixel_format(0),
65 red_select(0), green_select(0), blue_select(0),
66 pixelClock(p->pixel_clock), vnc(p->vnc), bmp(NULL), pic(NULL),
67 frameReadStartTime(0),
68 dmaStartAddr(0), dmaCurAddr(0), dmaMaxAddr(0), dmaPendingNum(0),
69 frameUnderrun(false), virtualDisplayBuffer(NULL), pixelBufferSize(0),
70 pixelIndex(0), doUpdateParams(false), frameUnderway(false),
71 dmaBytesInFlight(0),
72 startFrameEvent(this), endFrameEvent(this), renderPixelEvent(this),
73 fillPixelBufferEvent(this), intEvent(this),
74 dmaDoneEventAll(MAX_OUTSTANDING_DMA_REQ_CAPACITY, this),
75 dmaDoneEventFree(MAX_OUTSTANDING_DMA_REQ_CAPACITY),
76 enableCapture(p->enable_capture)
77{
78 pioSize = 0xFFFF;
79
80 for (int i = 0; i < MAX_OUTSTANDING_DMA_REQ_CAPACITY; ++i)
81 dmaDoneEventFree[i] = &dmaDoneEventAll[i];
82
83 if (vnc)
84 vnc->setFramebufferAddr(NULL);
85}
86
87HDLcd::~HDLcd()
88{
89 if (virtualDisplayBuffer)
90 delete [] virtualDisplayBuffer;
91}
92
93// read registers and frame buffer
94Tick
95HDLcd::read(PacketPtr pkt)
96{
97 uint32_t data = 0;
98 const Addr daddr = pkt->getAddr() - pioAddr;

--- 211 unchanged lines hidden (view full) ---

310
311 pkt->makeAtomicResponse();
312 return pioDelay;
313}
314
315void
316HDLcd::updateVideoParams(bool unserializing = false)
317{
318 const uint16_t bpp = bytesPerPixel() << 3;
319 const size_t buffer_size = bytesPerPixel() * width() * height();
320
321 // updating these parameters while LCD is enabled is not supported
322 if (frameUnderway && !unserializing)
323 panic("Attempting to change some HDLCD parameters while the controller"
324 " is active is not allowed");
325
326 // resize the virtualDisplayBuffer unless we are unserializing - it may
327 // have changed size
328 // there must be no outstanding DMA transactions for this to work
329 if (!unserializing) {
330 assert(dmaPendingNum == 0);
331 if (virtualDisplayBuffer)
332 delete [] virtualDisplayBuffer;
333 virtualDisplayBuffer = new uint8_t[buffer_size];
334 memset(virtualDisplayBuffer, 0, buffer_size);
335 }
336
337 assert(virtualDisplayBuffer);
338 if (vnc)
339 vnc->setFramebufferAddr(virtualDisplayBuffer);
340
341 if (bmp)
342 delete bmp;
343
344 DPRINTF(HDLcd, "bpp = %d\n", bpp);
345 DPRINTF(HDLcd, "display size = %d x %d\n", width(), height());
346#if TRACING_ON
347 const size_t totalLinesPerFrame = v_back_porch.val + 1 +
348 v_data.val + 1 +
349 v_front_porch.val + 1 +
350 v_sync.val + 1;
351 const double fps = (double)SimClock::Frequency /
352 (double)(PClksPerLine() * totalLinesPerFrame * pixelClock);
353#endif
354 DPRINTF(HDLcd, "simulated refresh rate ~ %.1ffps generating ~ %.1fMB/s "
355 "traffic ([%.1fMHz, T=%d sim clocks] pclk, %d bpp => %.1fMB/s peak requirement)\n",
356 fps,
357 fps * buffer_size / 1024 / 1024,
358 (double)SimClock::Frequency / pixelClock / 1000000.0,
359 pixelClock,
360 bpp,
361 (double)(SimClock::Frequency / pixelClock * (bpp / 8)) / 1024 / 1024);
362
363 if (pixel_format.big_endian)
364 panic("Big Endian pixel format not implemented by HDLcd controller");
365
366 if (vnc) {
367 if ((bpp == 24) &&
368 (red_select.size == 8) &&
369 (blue_select.size == 8) &&
370 (green_select.size == 8) &&
371 (green_select.offset == 8)) {
372 if ((blue_select.offset == 0) &&
373 (red_select.offset == 16)) {
374 vnc->setFrameBufferParams(VideoConvert::rgb8888, width(),
375 height());
376 bmp = new Bitmap(VideoConvert::rgb8888, width(), height(),
377 virtualDisplayBuffer);
378 DPRINTF(HDLcd, "color mode: rgb888\n");
379 } else if ((red_select.offset == 0) &&
380 (blue_select.offset == 16)) {
381 vnc->setFrameBufferParams(VideoConvert::bgr8888, width(),
382 height());
383 bmp = new Bitmap(VideoConvert::bgr8888, width(), height(),
384 virtualDisplayBuffer);
385 DPRINTF(HDLcd, "color mode: bgr888\n");
386 }
387 } else if ((bpp == 16) &&
388 (red_select.size == 5) &&
389 (blue_select.size == 5) &&
390 (green_select.size == 6) &&
391 (green_select.offset == 5)) {
392 if ((blue_select.offset == 0) &&
393 (red_select.offset == 11)) {
394 vnc->setFrameBufferParams(VideoConvert::rgb565, width(),
395 height());
396 bmp = new Bitmap(VideoConvert::rgb565, width(), height(),
397 virtualDisplayBuffer);
398 DPRINTF(HDLcd, "color mode: rgb565\n");
399 } else if ((red_select.offset == 0) &&
400 (blue_select.offset == 11)) {
401 vnc->setFrameBufferParams(VideoConvert::bgr565, width(),
402 height());
403 bmp = new Bitmap(VideoConvert::bgr565, width(), height(),
404 virtualDisplayBuffer);
405 DPRINTF(HDLcd, "color mode: bgr565\n");
406 }
407 } else {
408 DPRINTF(HDLcd, "color mode: undefined\n");
409 panic("Unimplemented video mode\n");
410 }
411 }
412}
413
414void
415HDLcd::startFrame()
416{
417 // 0. Check that we are in the appropriate state
418 assert(!frameUnderway);
419 if (!command.enable)
420 return;
421 DPRINTF(HDLcd, "Frame read started\n");
422 if (doUpdateParams) {
423 updateVideoParams();
424 doUpdateParams = false;
425 }
426 frameUnderway = true;
427 assert(virtualDisplayBuffer);
428 assert(pixelBufferSize == 0);
429 assert(dmaBytesInFlight == 0);
430 assert(dmaPendingNum == 0);
431 assert(dmaDoneEventFree.size() == dmaDoneEventAll.size());
432 assert(!renderPixelEvent.scheduled());
433 // currently only support positive line pitches equal to the line length
434 assert(width() * bytesPerPixel() == fb_line_pitch);
435

--- 43 unchanged lines hidden (view full) ---

479 dmaDoneEventFree.pop_back();
480 assert(event);
481 assert(!event->scheduled());
482
483 // We use a uncachable request here because the requests from the CPU
484 // will be uncacheable as well. If we have uncacheable and cacheable
485 // requests in the memory system for the same address it won't be
486 // pleased
487 event->setTransactionSize(transaction_size);
488 dmaPort.dmaAction(MemCmd::ReadReq, dmaCurAddr, transaction_size, event,
489 virtualDisplayBuffer + dmaCurAddr - dmaStartAddr,
490 0, Request::UNCACHEABLE);
491 dmaCurAddr += transaction_size;
492 dmaBytesInFlight += transaction_size;
493 }
494}
495
496void
497HDLcd::renderPixel()
498{

--- 45 unchanged lines hidden (view full) ---

544 }
545 } else {
546 nextEventTick += pixelClock * count;
547 }
548
549 schedule(renderPixelEvent, nextEventTick);
550}
551
552void
553HDLcd::endFrame() {
554 assert(pixelBufferSize == 0);
555 assert(dmaPendingNum == 0);
556 assert(dmaBytesInFlight == 0);
557 assert(dmaDoneEventFree.size() == dmaDoneEventAll.size());
558
559 if (vnc)
560 vnc->setDirty();
561
562 if (enableCapture) {
563 if (!pic)
564 pic = simout.create(csprintf("%s.framebuffer.bmp", sys->name()), true);
565
566 assert(bmp);
567 assert(pic);
568 pic->seekp(0);
569 bmp->write(pic);
570 }
571
572 // start the next frame
573 frameUnderway = false;
574 startFrame();
575}
576
577void

--- 81 unchanged lines hidden (view full) ---

659
660 SERIALIZE_SCALAR(frameReadStartTime);
661 SERIALIZE_SCALAR(dmaStartAddr);
662 SERIALIZE_SCALAR(dmaCurAddr);
663 SERIALIZE_SCALAR(dmaMaxAddr);
664 SERIALIZE_SCALAR(dmaPendingNum);
665 SERIALIZE_SCALAR(frameUnderrun);
666
667 const size_t buffer_size = bytesPerPixel() * width() * height();
668 SERIALIZE_ARRAY(virtualDisplayBuffer, buffer_size);
669
670 SERIALIZE_SCALAR(pixelBufferSize);
671 SERIALIZE_SCALAR(pixelIndex);
672 SERIALIZE_SCALAR(doUpdateParams);
673 SERIALIZE_SCALAR(frameUnderway);
674 SERIALIZE_SCALAR(dmaBytesInFlight);
675
676 Tick start_event_time = 0;

--- 95 unchanged lines hidden (view full) ---

772 UNSERIALIZE_SCALAR(frameReadStartTime);
773 UNSERIALIZE_SCALAR(dmaStartAddr);
774 UNSERIALIZE_SCALAR(dmaCurAddr);
775 UNSERIALIZE_SCALAR(dmaMaxAddr);
776 UNSERIALIZE_SCALAR(dmaPendingNum);
777 UNSERIALIZE_SCALAR(frameUnderrun);
778 UNSERIALIZE_SCALAR(dmaBytesInFlight);
779
780 const size_t buffer_size = bytesPerPixel() * width() * height();
781 virtualDisplayBuffer = new uint8_t[buffer_size];
782 UNSERIALIZE_ARRAY(virtualDisplayBuffer, buffer_size);
783
784 UNSERIALIZE_SCALAR(pixelBufferSize);
785 UNSERIALIZE_SCALAR(pixelIndex);
786 UNSERIALIZE_SCALAR(doUpdateParams);
787 UNSERIALIZE_SCALAR(frameUnderway);
788
789 Tick start_event_time = 0;
790 Tick end_event_time = 0;

--- 27 unchanged lines hidden (view full) ---

818 schedule(dmaDoneEventAll[x], dma_done_event_tick[x]);
819 } else
820 dmaDoneEventFree.push_back(&dmaDoneEventAll[x]);
821 }
822 assert(MAX_OUTSTANDING_DMA_REQ_CAPACITY - dmaDoneEventFree.size() == dmaPendingNum);
823
824 if (frameUnderway) {
825 updateVideoParams(true);
826 if (vnc)
827 vnc->setDirty();
828 }
829}
830
831void
832HDLcd::generateInterrupt()
833{

--- 24 unchanged lines hidden ---