src/dev/arm/pl111.cc

   1 /*
   2  * Copyright (c) 2010-2012 ARM Limited
   3  * All rights reserved
   4  *
   5  * The license below extends only to copyright in the software and shall
   6  * not be construed as granting a license to any other intellectual
   7  * property including but not limited to intellectual property relating
   8  * to a hardware implementation of the functionality of the software
   9  * licensed hereunder.  You may use the software subject to the license
  10  * terms below provided that you ensure that this notice is replicated
  11  * unmodified and in its entirety in all distributions of the software,
  12  * modified or unmodified, in source code or in binary form.
  13  *
  14  * Redistribution and use in source and binary forms, with or without
  15  * modification, are permitted provided that the following conditions are
  16  * met: redistributions of source code must retain the above copyright
  17  * notice, this list of conditions and the following disclaimer;
  18  * redistributions in binary form must reproduce the above copyright
  19  * notice, this list of conditions and the following disclaimer in the
  20  * documentation and/or other materials provided with the distribution;
  21  * neither the name of the copyright holders nor the names of its
  22  * contributors may be used to endorse or promote products derived from
  23  * this software without specific prior written permission.
  24  *
  25  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  26  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  27  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  28  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  29  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  30  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  31  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  32  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  33  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  34  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  35  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  36  *
  37  * Authors: William Wang
  38  *          Ali Saidi
  39  */
  40
  41 #include "base/vnc/vncinput.hh"
  42 #include "base/bitmap.hh"
  43 #include "base/output.hh"
  44 #include "base/trace.hh"
  45 #include "debug/PL111.hh"
  46 #include "debug/Uart.hh"
  47 #include "dev/arm/amba_device.hh"
  48 #include "dev/arm/base_gic.hh"
  49 #include "dev/arm/pl111.hh"
  50 #include "mem/packet.hh"
  51 #include "mem/packet_access.hh"
  52 #include "sim/system.hh"
  53
  54 // clang complains about std::set being overloaded with Packet::set if
  55 // we open up the entire namespace std
  56 using std::vector;
  57
  58 // initialize clcd registers
  59 Pl111::Pl111(const Params *p)
  60     : AmbaDmaDevice(p), lcdTiming0(0), lcdTiming1(0), lcdTiming2(0),
  61       lcdTiming3(0), lcdUpbase(0), lcdLpbase(0), lcdControl(0), lcdImsc(0),
  62       lcdRis(0), lcdMis(0),
  63       clcdCrsrCtrl(0), clcdCrsrConfig(0), clcdCrsrPalette0(0),
  64       clcdCrsrPalette1(0), clcdCrsrXY(0), clcdCrsrClip(0), clcdCrsrImsc(0),
  65       clcdCrsrIcr(0), clcdCrsrRis(0), clcdCrsrMis(0),
  66       pixelClock(p->pixel_clock), vnc(p->vnc), bmp(NULL), pic(NULL),
  67       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       dmaDoneEventAll(maxOutstandingDma, this),
  71       dmaDoneEventFree(maxOutstandingDma),
  72       intEvent(this), enableCapture(p->enable_capture)
  73 {
  74     pioSize = 0xFFFF;
  75
  76     dmaBuffer = new uint8_t[buffer_size];
  77
  78     memset(lcdPalette, 0, sizeof(lcdPalette));
  79     memset(cursorImage, 0, sizeof(cursorImage));
  80     memset(dmaBuffer, 0, buffer_size);
  81
  82     for (int i = 0; i < maxOutstandingDma; ++i)
  83         dmaDoneEventFree[i] = &dmaDoneEventAll[i];
  84
  85     if (vnc)
  86         vnc->setFramebufferAddr(dmaBuffer);
  87 }
  88
  89 Pl111::~Pl111()
  90 {
  91     delete[] dmaBuffer;
  92 }
  93
  94 // read registers and frame buffer
  95 Tick
  96 Pl111::read(PacketPtr pkt)
  97 {
  98     // use a temporary data since the LCD registers are read/written with
  99     // different size operations
 100
 101     uint32_t data = 0;
 102
 103     assert(pkt->getAddr() >= pioAddr &&
 104            pkt->getAddr() < pioAddr + pioSize);
 105
 106     Addr daddr = pkt->getAddr() - pioAddr;
 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 (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
 224 Tick
 225 Pl111::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
 381 void
 382 Pl111::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
 422 void
 423 Pl111::startDma()
 424 {
 425     if (dmaPendingNum != 0 || readEvent.scheduled())
 426         return;
 427     readFramebuffer();
 428 }
 429
 430 void
 431 Pl111::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, clockEdge());
 442
 443     curAddr = 0;
 444     startTime = curTick();
 445
 446     maxAddr = static_cast<Addr>(length * bytesPerPixel);
 447
 448     DPRINTF(PL111, " lcd frame buffer size of %d bytes \n", maxAddr);
 449
 450     fillFifo();
 451 }
 452
 453 void
 454 Pl111::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(!dmaDoneEventFree.empty());
 462         DmaDoneEvent *event(dmaDoneEventFree.back());
 463         dmaDoneEventFree.pop_back();
 464         assert(!event->scheduled());
 465
 466         // We use a uncachable request here because the requests from the CPU
 467         // will be uncacheable as well. If we have uncacheable and cacheable
 468         // requests in the memory system for the same address it won't be
 469         // pleased
 470         dmaPort.dmaAction(MemCmd::ReadReq, curAddr + startAddr, dmaSize,
 471                           event, curAddr + dmaBuffer,
 472                           0, Request::UNCACHEABLE);
 473         curAddr += dmaSize;
 474     }
 475 }
 476
 477 void
 478 Pl111::dmaDone()
 479 {
 480     DPRINTF(PL111, "DMA Done\n");
 481
 482     Tick maxFrameTime = lcdTiming2.cpl * height * pixelClock;
 483
 484     --dmaPendingNum;
 485
 486     if (maxAddr == curAddr && !dmaPendingNum) {
 487         if ((curTick() - startTime) > maxFrameTime) {
 488             warn("CLCD controller buffer underrun, took %d ticks when should"
 489                  " have taken %d\n", curTick() - startTime, maxFrameTime);
 490             lcdRis.underflow = 1;
 491             if (!intEvent.scheduled())
 492                 schedule(intEvent, clockEdge());
 493         }
 494
 495         assert(!readEvent.scheduled());
 496         if (vnc)
 497             vnc->setDirty();
 498
 499         if (enableCapture) {
 500             DPRINTF(PL111, "-- write out frame buffer into bmp\n");
 501
 502             if (!pic)
 503                 pic = simout.create(csprintf("%s.framebuffer.bmp", sys->name()), true);
 504
 505             assert(bmp);
 506             assert(pic);
 507             pic->seekp(0);
 508             bmp->write(pic);
 509         }
 510
 511         // schedule the next read based on when the last frame started
 512         // and the desired fps (i.e. maxFrameTime), we turn the
 513         // argument into a relative number of cycles in the future
 514         if (lcdControl.lcden)
 515             schedule(readEvent, clockEdge(ticksToCycles(startTime -
 516                                                         curTick() +
 517                                                         maxFrameTime)));
 518     }
 519
 520     if (dmaPendingNum > (maxOutstandingDma - waterMark))
 521         return;
 522
 523     if (!fillFifoEvent.scheduled())
 524         schedule(fillFifoEvent, clockEdge());
 525 }
 526
 527 void
 528 Pl111::serialize(std::ostream &os)
 529 {
 530     DPRINTF(PL111, "Serializing ARM PL111\n");
 531
 532     uint32_t lcdTiming0_serial = lcdTiming0;
 533     SERIALIZE_SCALAR(lcdTiming0_serial);
 534
 535     uint32_t lcdTiming1_serial = lcdTiming1;
 536     SERIALIZE_SCALAR(lcdTiming1_serial);
 537
 538     uint32_t lcdTiming2_serial = lcdTiming2;
 539     SERIALIZE_SCALAR(lcdTiming2_serial);
 540
 541     uint32_t lcdTiming3_serial = lcdTiming3;
 542     SERIALIZE_SCALAR(lcdTiming3_serial);
 543
 544     SERIALIZE_SCALAR(lcdUpbase);
 545     SERIALIZE_SCALAR(lcdLpbase);
 546
 547     uint32_t lcdControl_serial = lcdControl;
 548     SERIALIZE_SCALAR(lcdControl_serial);
 549
 550     uint8_t lcdImsc_serial = lcdImsc;
 551     SERIALIZE_SCALAR(lcdImsc_serial);
 552
 553     uint8_t lcdRis_serial = lcdRis;
 554     SERIALIZE_SCALAR(lcdRis_serial);
 555
 556     uint8_t lcdMis_serial = lcdMis;
 557     SERIALIZE_SCALAR(lcdMis_serial);
 558
 559     SERIALIZE_ARRAY(lcdPalette, LcdPaletteSize);
 560     SERIALIZE_ARRAY(cursorImage, CrsrImageSize);
 561
 562     SERIALIZE_SCALAR(clcdCrsrCtrl);
 563     SERIALIZE_SCALAR(clcdCrsrConfig);
 564     SERIALIZE_SCALAR(clcdCrsrPalette0);
 565     SERIALIZE_SCALAR(clcdCrsrPalette1);
 566     SERIALIZE_SCALAR(clcdCrsrXY);
 567     SERIALIZE_SCALAR(clcdCrsrClip);
 568
 569     uint8_t clcdCrsrImsc_serial = clcdCrsrImsc;
 570     SERIALIZE_SCALAR(clcdCrsrImsc_serial);
 571
 572     uint8_t clcdCrsrIcr_serial = clcdCrsrIcr;
 573     SERIALIZE_SCALAR(clcdCrsrIcr_serial);
 574
 575     uint8_t clcdCrsrRis_serial = clcdCrsrRis;
 576     SERIALIZE_SCALAR(clcdCrsrRis_serial);
 577
 578     uint8_t clcdCrsrMis_serial = clcdCrsrMis;
 579     SERIALIZE_SCALAR(clcdCrsrMis_serial);
 580
 581     SERIALIZE_SCALAR(height);
 582     SERIALIZE_SCALAR(width);
 583     SERIALIZE_SCALAR(bytesPerPixel);
 584
 585     SERIALIZE_ARRAY(dmaBuffer, buffer_size);
 586     SERIALIZE_SCALAR(startTime);
 587     SERIALIZE_SCALAR(startAddr);
 588     SERIALIZE_SCALAR(maxAddr);
 589     SERIALIZE_SCALAR(curAddr);
 590     SERIALIZE_SCALAR(waterMark);
 591     SERIALIZE_SCALAR(dmaPendingNum);
 592
 593     Tick int_event_time = 0;
 594     Tick read_event_time = 0;
 595     Tick fill_fifo_event_time = 0;
 596
 597     if (readEvent.scheduled())
 598         read_event_time = readEvent.when();
 599     if (fillFifoEvent.scheduled())
 600         fill_fifo_event_time = fillFifoEvent.when();
 601     if (intEvent.scheduled())
 602         int_event_time = intEvent.when();
 603
 604     SERIALIZE_SCALAR(read_event_time);
 605     SERIALIZE_SCALAR(fill_fifo_event_time);
 606     SERIALIZE_SCALAR(int_event_time);
 607
 608     vector<Tick> dma_done_event_tick;
 609     dma_done_event_tick.resize(maxOutstandingDma);
 610     for (int x = 0; x < maxOutstandingDma; x++) {
 611         dma_done_event_tick[x] = dmaDoneEventAll[x].scheduled() ?
 612             dmaDoneEventAll[x].when() : 0;
 613     }
 614     arrayParamOut(os, "dma_done_event_tick", dma_done_event_tick);
 615 }
 616
 617 void
 618 Pl111::unserialize(Checkpoint *cp, const std::string &section)
 619 {
 620     DPRINTF(PL111, "Unserializing ARM PL111\n");
 621
 622     uint32_t lcdTiming0_serial;
 623     UNSERIALIZE_SCALAR(lcdTiming0_serial);
 624     lcdTiming0 = lcdTiming0_serial;
 625
 626     uint32_t lcdTiming1_serial;
 627     UNSERIALIZE_SCALAR(lcdTiming1_serial);
 628     lcdTiming1 = lcdTiming1_serial;
 629
 630     uint32_t lcdTiming2_serial;
 631     UNSERIALIZE_SCALAR(lcdTiming2_serial);
 632     lcdTiming2 = lcdTiming2_serial;
 633
 634     uint32_t lcdTiming3_serial;
 635     UNSERIALIZE_SCALAR(lcdTiming3_serial);
 636     lcdTiming3 = lcdTiming3_serial;
 637
 638     UNSERIALIZE_SCALAR(lcdUpbase);
 639     UNSERIALIZE_SCALAR(lcdLpbase);
 640
 641     uint32_t lcdControl_serial;
 642     UNSERIALIZE_SCALAR(lcdControl_serial);
 643     lcdControl = lcdControl_serial;
 644
 645     uint8_t lcdImsc_serial;
 646     UNSERIALIZE_SCALAR(lcdImsc_serial);
 647     lcdImsc = lcdImsc_serial;
 648
 649     uint8_t lcdRis_serial;
 650     UNSERIALIZE_SCALAR(lcdRis_serial);
 651     lcdRis = lcdRis_serial;
 652
 653     uint8_t lcdMis_serial;
 654     UNSERIALIZE_SCALAR(lcdMis_serial);
 655     lcdMis = lcdMis_serial;
 656
 657     UNSERIALIZE_ARRAY(lcdPalette, LcdPaletteSize);
 658     UNSERIALIZE_ARRAY(cursorImage, CrsrImageSize);
 659
 660     UNSERIALIZE_SCALAR(clcdCrsrCtrl);
 661     UNSERIALIZE_SCALAR(clcdCrsrConfig);
 662     UNSERIALIZE_SCALAR(clcdCrsrPalette0);
 663     UNSERIALIZE_SCALAR(clcdCrsrPalette1);
 664     UNSERIALIZE_SCALAR(clcdCrsrXY);
 665     UNSERIALIZE_SCALAR(clcdCrsrClip);
 666
 667     uint8_t clcdCrsrImsc_serial;
 668     UNSERIALIZE_SCALAR(clcdCrsrImsc_serial);
 669     clcdCrsrImsc = clcdCrsrImsc_serial;
 670
 671     uint8_t clcdCrsrIcr_serial;
 672     UNSERIALIZE_SCALAR(clcdCrsrIcr_serial);
 673     clcdCrsrIcr = clcdCrsrIcr_serial;
 674
 675     uint8_t clcdCrsrRis_serial;
 676     UNSERIALIZE_SCALAR(clcdCrsrRis_serial);
 677     clcdCrsrRis = clcdCrsrRis_serial;
 678
 679     uint8_t clcdCrsrMis_serial;
 680     UNSERIALIZE_SCALAR(clcdCrsrMis_serial);
 681     clcdCrsrMis = clcdCrsrMis_serial;
 682
 683     UNSERIALIZE_SCALAR(height);
 684     UNSERIALIZE_SCALAR(width);
 685     UNSERIALIZE_SCALAR(bytesPerPixel);
 686
 687     UNSERIALIZE_ARRAY(dmaBuffer, buffer_size);
 688     UNSERIALIZE_SCALAR(startTime);
 689     UNSERIALIZE_SCALAR(startAddr);
 690     UNSERIALIZE_SCALAR(maxAddr);
 691     UNSERIALIZE_SCALAR(curAddr);
 692     UNSERIALIZE_SCALAR(waterMark);
 693     UNSERIALIZE_SCALAR(dmaPendingNum);
 694
 695     Tick int_event_time = 0;
 696     Tick read_event_time = 0;
 697     Tick fill_fifo_event_time = 0;
 698
 699     UNSERIALIZE_SCALAR(read_event_time);
 700     UNSERIALIZE_SCALAR(fill_fifo_event_time);
 701     UNSERIALIZE_SCALAR(int_event_time);
 702
 703     if (int_event_time)
 704         schedule(intEvent, int_event_time);
 705     if (read_event_time)
 706         schedule(readEvent, read_event_time);
 707     if (fill_fifo_event_time)
 708         schedule(fillFifoEvent, fill_fifo_event_time);
 709
 710     vector<Tick> dma_done_event_tick;
 711     dma_done_event_tick.resize(maxOutstandingDma);
 712     arrayParamIn(cp, section, "dma_done_event_tick", dma_done_event_tick);
 713     dmaDoneEventFree.clear();
 714     for (int x = 0; x < maxOutstandingDma; x++) {
 715         if (dma_done_event_tick[x])
 716             schedule(dmaDoneEventAll[x], dma_done_event_tick[x]);
 717         else
 718             dmaDoneEventFree.push_back(&dmaDoneEventAll[x]);
 719     }
 720     assert(maxOutstandingDma - dmaDoneEventFree.size() == dmaPendingNum);
 721
 722     if (lcdControl.lcdpwr) {
 723         updateVideoParams();
 724         if (vnc)
 725             vnc->setDirty();
 726     }
 727 }
 728
 729 void
 730 Pl111::generateInterrupt()
 731 {
 732     DPRINTF(PL111, "Generate Interrupt: lcdImsc=0x%x lcdRis=0x%x lcdMis=0x%x\n",
 733             (uint32_t)lcdImsc, (uint32_t)lcdRis, (uint32_t)lcdMis);
 734     lcdMis = lcdImsc & lcdRis;
 735
 736     if (lcdMis.underflow || lcdMis.baseaddr || lcdMis.vcomp || lcdMis.ahbmaster) {
 737         gic->sendInt(intNum);
 738         DPRINTF(PL111, " -- Generated\n");
 739     }
 740 }
 741
 742 AddrRangeList
 743 Pl111::getAddrRanges() const
 744 {
 745     AddrRangeList ranges;
 746     ranges.push_back(RangeSize(pioAddr, pioSize));
 747     return ranges;
 748 }
 749
 750 Pl111 *
 751 Pl111Params::create()
 752 {
 753     return new Pl111(this);
 754 }
 755
 756