modules/system/splash/main.cc

/*
 * Copyright (c) 2008-2014, Pedigree Developers
 *
 * Please see the CONTRIB file in the root of the source tree for a full
 * list of contributors.
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
#include "pedigree/kernel/BootstrapInfo.h"
#include "pedigree/kernel/LockGuard.h"
#include "pedigree/kernel/Log.h"
#include "pedigree/kernel/Service.h"
#include "pedigree/kernel/ServiceFeatures.h"
#include "pedigree/kernel/ServiceManager.h"
#include "pedigree/kernel/core/BootIO.h"
#include "pedigree/kernel/graphics/Graphics.h"
#include "pedigree/kernel/graphics/GraphicsService.h"
#include "pedigree/kernel/machine/Display.h"
#include "pedigree/kernel/machine/Framebuffer.h"
#include "pedigree/kernel/machine/InputManager.h"
#include "pedigree/kernel/process/Mutex.h"
#include "pedigree/kernel/process/TerminationDeferral.h"
#include "pedigree/kernel/processor/types.h"
#include "pedigree/kernel/utilities/Cord.h"
#include "pedigree/kernel/utilities/StaticString.h"
#include "pedigree/kernel/utilities/String.h"
#include "pedigree/kernel/utilities/Vector.h"
#include "pedigree/kernel/utilities/assert.h"
#include "pedigree/kernel/utilities/utility.h"
 
#include "font.h"
#include "image.h"
#include "modules/Module.h"
 
static Framebuffer* g_pFramebuffer = 0;
 
static uint8_t* g_pBuffer = 0;
static Graphics::Buffer* g_pFont = 0;
static size_t g_Width = 0;
static size_t g_Height = 0;
static size_t g_DesiredWidth = 1024;
static size_t g_DesiredHeight = 768;
static size_t g_DesiredBpp = 32;
 
static uint32_t g_BackgroundColour = 0x000000;
static uint32_t g_ForegroundColour = 0xFFFFFF;
static uint32_t g_ProgressBorderColour = 0x965000;
static uint32_t g_ProgressColour = 0x966400;
 
static Graphics::PixelFormat g_ColorFormat = Graphics::Bits24_Rgb;
 
static size_t g_ProgressX, g_ProgressY;
static size_t g_ProgressW, g_ProgressH;
static size_t g_LogBoxX, g_LogBoxY;
static size_t g_LogX, g_LogY;
static size_t g_LogW, g_LogH;
 
static GraphicsService::GraphicsParameters g_GraphicsParams;
 
static size_t g_Previous = 0;
static bool g_LogMode = true;
 
static bool g_NoGraphics = false;
 
static Mutex g_PrintLock;
 
static void printChar(char c, size_t x, size_t y) {
  if (!g_pFramebuffer)
    return;
 
  g_pFramebuffer->blit(g_pFont, 0, c * FONT_HEIGHT, x, y, FONT_WIDTH, FONT_HEIGHT);
}
 
static bool printChar(char c) {
  if (!g_pFramebuffer) {
    return false;
  }
 
  if (!c) {
    return false;
  }
 
  if (c == '\t') {
    g_LogX = (g_LogX + 8) & ~7;
  } else if (c == '\r') {
    g_LogX = 0;
  } else if (c == '\n') {
    g_LogX = 0;
    g_LogY++;
  } else if (c >= ' ') {
    g_pFramebuffer->blit(g_pFont, 0, c * FONT_HEIGHT, g_LogBoxX + (g_LogX * FONT_WIDTH),
                         g_LogBoxY + (g_LogY * FONT_HEIGHT), FONT_WIDTH, FONT_HEIGHT);
    g_LogX++;
  }
 
  if (g_LogX >= g_LogW / FONT_WIDTH) {
    g_LogX = 0;
    g_LogY++;
  }
 
  // Overflowed the view?
  if (g_LogY >= (g_LogH / FONT_HEIGHT)) {
    // By how much?
    size_t diff = g_LogY - (g_LogH / FONT_HEIGHT) + 1;
 
    // Scroll up
    g_pFramebuffer->copy(g_LogBoxX, g_LogBoxY + (diff * FONT_HEIGHT), g_LogBoxX, g_LogBoxY, g_LogW,
                         ((g_LogH / FONT_HEIGHT) - diff) * FONT_HEIGHT);
    g_pFramebuffer->rect(g_LogBoxX, g_LogBoxY + ((g_LogH / FONT_HEIGHT) - diff) * FONT_HEIGHT,
                         g_LogW, diff * FONT_HEIGHT, g_BackgroundColour, g_ColorFormat);
 
    g_LogY -= diff;
    return true;
  }
  return false;
}
 
static bool printString(const char* str, size_t len = 0) {
  if (len == 0) {
    len = StringLength(str);
  }
 
  if (!g_NoGraphics) {
    bool scrolled = false;
    for (size_t i = 0; i < len; i++) {
      if (printChar(str[i])) {
        scrolled = true;
      }
    }
    return scrolled;
  } else {
    static HugeStaticString s;
    s += str;
 
    // Truncate the string if we need to.
    if (s.length() >= 79) {
      s.truncate(75);
      s += "...>\n";
    }
 
    BootIO::Colour c = BootIO::LightGrey;
    if (str[1] == 'W')
      c = BootIO::Orange;
    else if (str[1] == 'E' || str[1] == 'F')
      c = BootIO::Red;
    else if (str[1] == 'D')
      c = BootIO::DarkGrey;
 
    bootIO.write(s, c, BootIO::Black);
    s.clear();
  }
  return false;
}
 
static void printString(const LogCord& str) {
  TerminationDeferral lifetime;
  // Progress rendering can log while holding this lock, and another CPU can
  // log while holding a driver lock needed by the renderer. The ring retains
  // messages even when the splash cannot safely display them now.
  if (!g_PrintLock.tryAcquire()) {
    return;
  }
  Framebuffer* parent = nullptr;
  size_t firstRow = g_LogY;
  bool scrolled = false;
  if (!g_NoGraphics && g_pFramebuffer) {
    // Scroll the RAM backing buffer, avoiding reads from slow scanout memory.
    // Publish the completed message once, including any wrapped lines.
    parent = g_pFramebuffer->getParent();
    g_pFramebuffer->setParent(nullptr);
  }
  for (auto it = str.segbegin(); it != str.segend(); ++it) {
    if (printString(it.ptr(), it.length())) {
      scrolled = true;
    }
  }
  if (parent) {
    g_pFramebuffer->setParent(parent);
    if (scrolled) {
      firstRow = 0;
    }
    g_pFramebuffer->redraw(g_LogBoxX, g_LogBoxY + firstRow * FONT_HEIGHT, g_LogW,
                           (g_LogY - firstRow + 1) * FONT_HEIGHT, false);
  }
  g_PrintLock.release();
}
 
static void printStringAt(const char* str, size_t x, size_t y) {
  for (size_t i = 0; i < StringLength(str); i++) {
    printChar(str[i], x, y);
    x += FONT_WIDTH;
  }
}
 
static void centerStringAt(const char* str, size_t midX, size_t midY) {
  size_t stringWidth = StringLength(str) * FONT_WIDTH;
  size_t stringHeight = FONT_HEIGHT;
 
  size_t x = midX - (stringWidth / 2);
  size_t y = midY - (stringHeight / 2);
  printStringAt(str, x, y);
}
 
class StreamingScreenLogger : public Log::LogCallback {
 public:
  virtual ~StreamingScreenLogger();
 
  void callback(const LogCord& cord, bool = true) {
    if (g_LogMode) {
      printString(cord);
    }
  }
};
 
StreamingScreenLogger::~StreamingScreenLogger() = default;
 
static StreamingScreenLogger g_StreamLogger;
 
static void keyCallback(InputManager::InputNotification& note) {
  if (note.type != InputManager::Key)
    return;
 
  uint64_t key = note.data.key.key;
  if (key == '\033') {
    // Because we edit the dimensions of the screen, we can't let a print
    // continue while we run here.
    LockGuard<Mutex> guard(g_PrintLock);
 
    if (!g_LogMode) {
      g_LogMode = true;
    } else {
      g_LogY += (g_LogBoxY / FONT_HEIGHT);
      g_LogX = (g_LogBoxX / FONT_WIDTH);
      g_LogBoxX = g_LogBoxY = 0;
      g_LogW = g_Width;
      g_LogH = g_Height;
    }
  }
}
 
static void progress(const char* text) {
  const bool bFinished =
      g_BootProgressTotal && ((g_BootProgressCurrent + 1) >= g_BootProgressTotal);
  if (bFinished) {
    // Callback removal can wait for an invocation which needs
    // g_PrintLock, so it must happen before this function takes that lock.
    Log::instance().removeCallback(&g_StreamLogger);
 
    EMIT_IF(DEBUGGER) {
      if (!g_NoGraphics) {
        InputManager::instance().removeCallback(keyCallback);
      }
    }
  }
 
  LockGuard<Mutex> guard(g_PrintLock);
 
  // Calculate percentage.
  if (g_BootProgressTotal == 0)
    return;
 
  if (g_NoGraphics) {
    // Prepare to center the progress bar (22 characters wide).
    HugeStaticString s;
    s = " ";
    for (size_t i = 0; i < (80 / 2) - 11; ++i) {
      bootIO.write(s, BootIO::Black, BootIO::Black);
    }
 
    // Render progress bar - style: [###---]
    s = "[";
    size_t pos = (20 * g_BootProgressCurrent) / g_BootProgressTotal;
    for (size_t i = 0; i < 20; ++i) {
      if (i <= pos)
        s += '#';
      else
        s += '-';
    }
    s += "]\r";
    bootIO.write(s, BootIO::White, BootIO::Black);
  } else if (g_LogMode && g_LogH == g_Height) {
    if (bFinished) {
      NOTICE("splash: destroying font pixel buffer");
      g_pFramebuffer->destroyBuffer(g_pFont);
      NOTICE("splash: destroying font heap buffer");
      delete[] g_pBuffer;
 
      NOTICE("splash: destroying framebuffer");
      Graphics::destroyFramebuffer(g_pFramebuffer);
      NOTICE("splash: destroyed framebuffer");
      g_pFramebuffer = 0;
 
      g_BootProgressUpdate = 0;
    }
  } else if (g_pFramebuffer) {
    size_t w = (g_ProgressW * g_BootProgressCurrent) / g_BootProgressTotal;
    if (g_Previous <= g_BootProgressCurrent)
      g_pFramebuffer->rect(g_ProgressX, g_ProgressY, w, g_ProgressH, g_ProgressColour,
                           g_ColorFormat);
    else
      g_pFramebuffer->rect(g_ProgressX + w, g_ProgressY, g_ProgressW - w, g_ProgressH,
                           g_BackgroundColour, g_ColorFormat);
    g_Previous = g_BootProgressCurrent;
 
    char buf[80];
    StringFormat(buf, "%d%%", ((g_BootProgressCurrent * 100) / g_BootProgressTotal));
    centerStringAt(buf, g_ProgressX + (g_ProgressW / 2), g_ProgressY - FONT_HEIGHT);
 
    g_pFramebuffer->redraw(g_ProgressX, g_ProgressY - (FONT_HEIGHT * 2), g_ProgressW,
                           g_ProgressH + (FONT_HEIGHT * 2), true);
 
    if (bFinished) {
      // Clean up font
      NOTICE("splash: destroying font pixel buffer");
      g_pFramebuffer->destroyBuffer(g_pFont);
      NOTICE("splash: destroying font heap buffer");
      delete[] g_pBuffer;
 
      // Destroy the framebuffer now that we're done
      NOTICE("splash: destroying framebuffer");
      Graphics::destroyFramebuffer(g_pFramebuffer);
      NOTICE("splash: destroyed framebuffer");
      g_pFramebuffer = 0;
 
      // No longer wanting any progress callback.
      g_BootProgressUpdate = 0;
    }
  }
}
 
static bool parseVideoMode(const char* value) {
  size_t mode[3] = {};
  for (size_t i = 0; i < 3; ++i) {
    if (*value < '0' || *value > '9') {
      return false;
    }
    while (*value >= '0' && *value <= '9') {
      mode[i] = mode[i] * 10 + (*value++ - '0');
      if (mode[i] > 65535) {
        return false;
      }
    }
    if (!mode[i] || *value != (i == 2 ? '\0' : 'x')) {
      return false;
    }
    if (i != 2) {
      ++value;
    }
  }
  if (mode[2] > 64) {
    return false;
  }
 
  g_DesiredWidth = mode[0];
  g_DesiredHeight = mode[1];
  g_DesiredBpp = mode[2];
  return true;
}
 
static bool parseColour(const char* value, uint32_t& colour) {
  if (StringLength(value) != 6) {
    return false;
  }
 
  uint32_t result = 0;
  for (size_t i = 0; i < 6; ++i) {
    char c = value[i];
    uint32_t digit;
    if (c >= '0' && c <= '9') {
      digit = c - '0';
    } else if (c >= 'a' && c <= 'f') {
      digit = c - 'a' + 10;
    } else if (c >= 'A' && c <= 'F') {
      digit = c - 'A' + 10;
    } else {
      return false;
    }
    result = (result << 4) | digit;
  }
  colour = result;
  return true;
}
 
static bool handleNoSplash() {
  g_NoGraphics = true;
 
  const String title("Pedigree is Loading...\n");
 
  // Prepare to render by making some space between the current BootIO output
  // and the progress bar we're about to add.
  HugeStaticString s;
  s = "\n";
  for (size_t i = 0; i < 2; ++i) {
    bootIO.write(s, BootIO::Black, BootIO::Black);
  }
 
  // Prepare to center text.
  s = " ";
  for (size_t i = 0; i < (80 / 2) - (title.length() / 2); ++i) {
    bootIO.write(s, BootIO::Black, BootIO::Black);
  }
 
  // Render the system title.
  s = title;
  bootIO.write(s, BootIO::White, BootIO::Black);
 
  g_BootProgressUpdate = &progress;
 
  return true;
}
 
static bool handleSplash() {
  g_NoGraphics = false;
 
  // No text mode for us - we're the splash screen!
  g_GraphicsParams.wantTextMode = false;
 
  // Grab the current graphics provider for the system, use it to display the
  // splash screen to the user.
  ServiceFeatures* pFeatures = ServiceManager::instance().enumerateOperations(String("graphics"));
  Service* pService = ServiceManager::instance().getService(String("graphics"));
  bool bSuccess = false;
  if (pFeatures && pFeatures->provides(ServiceFeatures::probe))
    if (pService)
      bSuccess = pService->serve(ServiceFeatures::probe, reinterpret_cast<void*>(&g_GraphicsParams),
                                 sizeof(g_GraphicsParams));
 
  if (!(bSuccess && g_GraphicsParams.providerFound)) {
    NOTICE(
        "splash: this system does not support graphics, using fallback "
        "log callback");
    return handleNoSplash();
  }
 
  Display* pDisplay = g_GraphicsParams.providerResult.pDisplay;
 
  size_t nDesiredWidth = g_DesiredWidth;
  size_t nDesiredHeight = g_DesiredHeight;
  size_t nDesiredBpp = g_DesiredBpp;
 
  // Set up the mode we want
  if (!(nDesiredWidth && nDesiredHeight && nDesiredBpp) ||
      !pDisplay->setScreenMode(nDesiredWidth, nDesiredHeight, nDesiredBpp)) {
    // A firmware framebuffer has already selected its fixed mode. Keep using
    // it when the configured mode is not available.
    Display::ScreenMode currentMode;
    if (pDisplay->getCurrentScreenMode(currentMode) && !currentMode.textMode &&
        pDisplay->setScreenMode(currentMode)) {
      nDesiredWidth = currentMode.width;
      nDesiredHeight = currentMode.height;
      nDesiredBpp = currentMode.pf.nBpp;
    } else {
      bool bModeFound = true;
 
      // 24-bit mode fallbacks
      NOTICE("splash: Falling back to 1024x768x24");
      if (!pDisplay->setScreenMode(1024, 768, 24)) {
        // Attempt to fall back to 800x600
        NOTICE("splash: Falling back to 800x600x24");
        if (!pDisplay->setScreenMode(800, 600, 24)) {
          // Finally try and fall back to 640x480
          NOTICE("splash: Falling back to 640x480x24");
          if (!pDisplay->setScreenMode(640, 480, 24)) {
            bModeFound = false;
          }
        }
      }
 
      if (!bModeFound) {
        // 16-bit mode fallbacks
        NOTICE("splash: Falling back to 1024x768x16");
        if (!pDisplay->setScreenMode(1024, 768, 16)) {
          // Attempt to fall back to 800x600
          NOTICE("splash: Falling back to 800x600x16");
          if (!pDisplay->setScreenMode(800, 600, 16)) {
            // Finally try and fall back to 640x480
            NOTICE("splash: Falling back to 640x480x16");
            if (!pDisplay->setScreenMode(640, 480, 16)) {
              ERROR(
                  "splash: Couldn't find a suitable display mode "
                  "for this system (tried: 1024x768, 800x600, "
                  "640x480).");
              g_NoGraphics = true;
            }
          }
        }
      }
    }
  }
 
  if (g_NoGraphics) {
    NOTICE(
        "splash: this system does not support graphics, using fallback "
        "log callback");
    return handleNoSplash();
  }
 
  Framebuffer* pParentFramebuffer = g_GraphicsParams.providerResult.pFramebuffer;
 
  g_Width = pParentFramebuffer->getWidth();
  g_Height = pParentFramebuffer->getHeight();
 
  g_pFramebuffer = Graphics::createFramebuffer(pParentFramebuffer, 0, 0, g_Width, g_Height);
  g_ColorFormat = g_pFramebuffer->getFormat();
 
  g_pFramebuffer->rect(0, 0, g_Width, g_Height, g_BackgroundColour, g_ColorFormat);
 
  if (!g_LogMode) {
    // Create the logo buffer
    uint8_t* data = header_data;
    g_pBuffer = new uint8_t[width * height * 3];  // 24-bit, hardcoded...
    for (size_t i = 0; i < (width * height); i++)
      HEADER_PIXEL(data, &g_pBuffer[i * 3]);  // 24-bit, hardcoded
 
    size_t origx = (g_Width - width) / 2;
    size_t origy = (g_Height - height) / 3;
 
    g_pFramebuffer->draw(g_pBuffer, 0, 0, origx, origy, width, height, Graphics::Bits24_Bgr);
 
    delete[] g_pBuffer;
  }
 
  // Create the font buffer
  g_pBuffer = new uint8_t[(FONT_WIDTH * FONT_HEIGHT * 3) * 256];  // 24-bit
  ByteSet(g_pBuffer, 0, (FONT_WIDTH * FONT_HEIGHT * 3) * 256);
  size_t offset = 0;
 
  // For each character
  for (size_t character = 0; character < 255; character++) {
    // For each character row
    for (size_t row = 0; row < FONT_HEIGHT; row++) {
      // For each character row bit
      for (size_t col = 0; col < FONT_WIDTH; col++) {
        // Is this bit set?
        size_t fontRow = (character * FONT_HEIGHT) + row;
        if (font_data[fontRow] & (1 << (FONT_WIDTH - 1 - col))) {
          // x: col
          // y: fontRow
          size_t bytesPerPixel = 3;
          size_t bytesPerLine = FONT_WIDTH * bytesPerPixel;
          size_t pixelOffset = (fontRow * bytesPerLine) + (col * bytesPerPixel);
          size_t bufferOffset = pixelOffset;
 
          uint32_t* p = adjust_pointer<uint8_t, uint32_t>(g_pBuffer, bufferOffset);
          *p = g_ForegroundColour;
        }
      }
    }
  }
 
  g_pFont =
      g_pFramebuffer->createBuffer(g_pBuffer, Graphics::Bits24_Rgb, FONT_WIDTH, FONT_HEIGHT * 256);
 
  if (!g_LogMode) {
    g_ProgressX = (g_Width / 2) - 200;
    g_ProgressW = 400;
    g_ProgressY = (g_Height / 3) * 2;
    g_ProgressH = 15;
 
    g_LogBoxX = 0;
    g_LogBoxY = (g_Height / 4) * 3;
    g_LogW = g_Width;
    g_LogH = g_Height - g_LogBoxY;
  } else {
    g_LogBoxX = 0;
    g_LogBoxY = 0;
    g_LogW = g_Width;
    g_LogH = g_Height;
  }
  g_LogX = g_LogY = 0;
 
  if (!g_LogMode) {
    {
      LockGuard<Mutex> guard(g_PrintLock);
      centerStringAt("Please wait, Pedigree is loading...", g_Width / 2,
                     g_ProgressY - (FONT_HEIGHT * 3));
 
      EMIT_IF(DEBUGGER) {
        // Draw a border around the log area
        centerStringAt("< Kernel Log >", g_LogW / 2,
                       g_LogBoxY - 2 - (FONT_HEIGHT / 2) - FONT_HEIGHT);
        centerStringAt(
            "(you can push ESCAPE to view the kernel log, and again to make the "
            "log fill the screen)",
            g_LogW / 2, g_LogBoxY - 2 - (FONT_HEIGHT / 2));
      }
    }
 
    // Draw empty progress bar. Easiest way to draw a nonfilled rect? Draw two
    // filled rects.
    g_pFramebuffer->rect(g_ProgressX - 2, g_ProgressY - 2, g_ProgressW + 4, g_ProgressH + 4,
                         g_ProgressBorderColour, g_ColorFormat);
    g_pFramebuffer->rect(g_ProgressX - 1, g_ProgressY - 1, g_ProgressW + 2, g_ProgressH + 2,
                         g_BackgroundColour, g_ColorFormat);
  }
 
  g_pFramebuffer->redraw(0, 0, g_Width, g_Height, true);
 
  // Replaying the complete kernel backlog through the software renderer can
  // delay the handoff indefinitely on slow machines. Log mode shows the
  // messages emitted after the display is ready instead.
  Log::instance().installCallback(&g_StreamLogger, true);
 
  g_BootProgressUpdate = &progress;
 
  EMIT_IF(DEBUGGER) {
    InputManager::instance().installCallback(InputManager::Key, keyCallback);
  }
 
  return true;
}
 
static bool init() {
  g_NoGraphics = false;
  g_LogMode = true;
  char* cmdline = g_pBootstrapInfo->getCommandLine();
  if (cmdline) {
    Vector<String> cmds = String(cmdline).tokenise(' ');
    for (auto it = cmds.begin(); it != cmds.end(); it++) {
      auto cmd = *it;
      bool valid = true;
      if (cmd == String("nosplash")) {
        g_NoGraphics = true;
        break;
      } else if (cmd == String("splash=image")) {
        g_LogMode = false;
      } else if (cmd == String("splash=log") || cmd == String("splash=logs")) {
        g_LogMode = true;
      } else if (!StringCompareN(cmd.cstr(), "video=", 6)) {
        valid = parseVideoMode(cmd.cstr() + 6);
      } else if (!StringCompareN(cmd.cstr(), "splash-background=", 18)) {
        valid = parseColour(cmd.cstr() + 18, g_BackgroundColour);
      } else if (!StringCompareN(cmd.cstr(), "splash-foreground=", 18)) {
        valid = parseColour(cmd.cstr() + 18, g_ForegroundColour);
      } else if (!StringCompareN(cmd.cstr(), "splash-border=", 14)) {
        valid = parseColour(cmd.cstr() + 14, g_ProgressBorderColour);
      } else if (!StringCompareN(cmd.cstr(), "splash-fill=", 12)) {
        valid = parseColour(cmd.cstr() + 12, g_ProgressColour);
      }
      if (!valid) {
        WARNING("splash: ignoring invalid boot option " << cmd);
      }
    }
  }
 
  if (g_NoGraphics) {
    return handleNoSplash();
  } else {
    return handleSplash();
  }
}
 
static void destroy() {
  Log::instance().removeCallback(&g_StreamLogger);
 
  EMIT_IF(DEBUGGER) {
    if (!g_NoGraphics) {
      InputManager::instance().removeCallback(keyCallback);
    }
  }
 
  LockGuard<Mutex> guard(g_PrintLock);
 
  g_BootProgressUpdate = 0;
}
 
MODULE_INFO("splash", &init, &destroy);
// If no graphics drivers loaded, we can handle that still. But we still need
// to run after the gfx-deps metamodule.
MODULE_OPTIONAL_DEPENDS("gfx-deps");