src/dev/qemu/fw_cfg.cc - public/gem5 - Git at Google

 /*
  * Copyright 2022 Google, Inc.
  *
  * 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.
  */

 #include "dev/qemu/fw_cfg.hh"

 #include <cstring>
 #include <sstream>
 #include <string>

 #include "base/compiler.hh"
 #include "base/cprintf.hh"
 #include "base/logging.hh"
 #include "base/trace.hh"
 #include "debug/QemuFwCfg.hh"
 #include "debug/QemuFwCfgVerbose.hh"
 #include "mem/packet_access.hh"
 #include "sim/byteswap.hh"

 namespace gem5
 {

 namespace qemu
 {

 void
 FwCfgItemFixed::read(void *buf, uint64_t offset, uint32_t to_read)
 {
     // Get access to the data we need to fill this buffer.
     const void *data = bytes();
     const uint64_t total_length = length();

     if (offset > total_length) {
         // We're completely off the end, so return only zeroes.
         std::memset(buf, 0, to_read);
         return;
     }

     if (offset + to_read > total_length) {
         // We're partially off the end, truncate this read and zero fill.

         // Figure out how far past the end we're attempting to read.
         uint64_t overflow = offset + to_read - total_length;

         // Reduce the requested read size to what we can actually fill.
         to_read -= overflow;

         // Zero out the part we won't read data into.
         std::memset((uint8_t *)buf + to_read, 0, overflow);
     }

     // Do the read.
     std::memcpy(buf, (uint8_t *)data + offset, to_read);
 }

 FwCfg::FwCfg(const Params &p, const AddrRangeList &addr_ranges) :
     PioDevice(p),
     signature(".[FW_CFG_SIGNATURE]", false, "QEMU CFG", 0),
     // The ID says we support the traditional interface but not DMA. To enable
     // DMA, this should be equal to 3.
     id(".[FW_CFG_ID]", false, "\x1", 1),
     addrRanges(addr_ranges)
 {
     // Add the unnamed, fixed items.
     addItem(&signature);
     addItem(&id);

     for (auto factory: p.items) {
         // Process named items and add them to the index.
         auto &item = factory->item();

         uint32_t &next_index =
             item.archSpecific() ? nextArchIndex : nextGenericIndex;
         const uint32_t &max_index =
             item.archSpecific() ? MaxArchIndex : MaxGenericIndex;

         // Automatically assign an ID if a fixed one wasn't specified.
         if (!item.index())
             item.index(next_index++);

         panic_if(item.index() >= max_index,
                 "Firmware config device out of %s indexes.",
                 item.archSpecific() ? "arch" : "generic");

         addItem(&item);
     }

     directory.update(names, numbers);
     addItem(&directory);
 };

 void
 FwCfg::addItem(FwCfgItem *item)
 {
     const auto [kit, ksuccess] =
         numbers.insert(std::make_pair(item->index(), item));

     panic_if(!ksuccess, "Duplicate firmware config item key %#x, "
             "paths %s and %s.",
             item->index(), item->path(), kit->second->path());

     const std::string &path = item->path();
     if (path.empty() || path[0] != '.') {
         const auto res =
             names.insert(std::make_pair(item->path(), item->index()));

         panic_if(!res.second, "Duplicate firmware config item path %s.",
                 item->path());
     }
 }

 void
 FwCfg::select(uint16_t key)
 {
     DPRINTF(QemuFwCfg, "Selecting item with key %#x.\n", key);

     // Clear any previous selection.
     offset = 0;
     current = nullptr;

     auto iter = numbers.find(key);
     if (iter == numbers.end()) {
         warn("Firmware config failed to select item with key %#x.", key);
         return;
     }

     auto item = iter->second;

     current = item;
     if (current)
         DPRINTF(QemuFwCfg, "Selected item with path %s.\n", item->path());
     else
         DPRINTF(QemuFwCfg, "No item is currently selected.\n");
 }

 void
 FwCfg::readItem(void *buf, uint32_t length)
 {
     if (!current) {
         DPRINTF(QemuFwCfgVerbose,
                 "Tried to read while nothing was selected.\n");
         std::memset(buf, 0, length);
         return;
     }

     current->read(buf, offset, length);

     if (gem5::debug::QemuFwCfgVerbose) {
         std::stringstream data_str;
         for (int idx = 0; idx < length; idx++)
             ccprintf(data_str, " %02x", ((uint8_t *)buf)[idx]);

         DPRINTF(QemuFwCfgVerbose, "Read [%#x-%#x) =>%s.\n",
                 offset, offset + length, data_str.str());
     }

     offset += length;
 }

 FwCfg::Directory::Directory() :
     FwCfgItemFixed(".[FW_CFG_FILE_DIR]", false, 0x19)
 {}

 void
 FwCfg::Directory::update(
         const std::map<std::string, uint16_t> &names,
         const std::map<uint16_t, FwCfgItem *> &numbers)
 {
     uint32_t count = names.size();

     struct GEM5_PACKED File
     {
         uint32_t size;
         uint16_t select;
         uint16_t reserved;
         char name[56];
     };

     uint64_t bytes = sizeof(count) + sizeof(File) * count;
     data.resize(bytes);

     uint8_t *ptr = data.data();

     uint32_t be_count = htobe(count);
     std::memcpy(ptr, &be_count, sizeof(be_count));
     ptr += sizeof(be_count);

     for (auto &[name, index]: names) {
         // Fill in the entry.
         File file{(uint32_t)numbers.at(index)->length(), index, 0, {}};
         std::memset(file.name, 0, sizeof(file.name));
         std::strncpy(file.name, name.c_str(), sizeof(file.name) - 1);

         // Fix endianness.
         file.size = htobe(file.size);
         file.select = htobe(file.select);

         // Copy it to the buffer and update ptr.
         std::memcpy(ptr, &file, sizeof(file));
         ptr += sizeof(file);
     }
 }

 FwCfgIo::FwCfgIo(const Params &p) : FwCfg(p, {
         // This covers both the 16 bit selector, and the 8 bit data reg which
         // overlaps it.
         {p.selector_addr, p.selector_addr + 2}}),
     selectorAddr(p.selector_addr), dataAddr(p.selector_addr + 1)
 {}

 Tick
 FwCfgIo::read(PacketPtr pkt)
 {
     const Addr addr = pkt->getAddr();
     const auto size = pkt->getSize();

     pkt->makeResponse();
     // The default response is all zeroes.
     std::memset(pkt->getPtr<uint8_t>(), 0, size);

     if (addr == selectorAddr) {
         warn("Read from firmware config selector register not supported.");
     } else if (addr == dataAddr) {
         if (size == 1) {
             readItem(pkt->getPtr<void>(), size);
         } else {
             warn("Read from firmware config data register with width %d not "
                     "supported.", size);
         }
     } else {
         panic("Unregognized firmware config read [%#x-%#x).",
                 addr, addr + size);
     }

     return 0;
 }

 Tick
 FwCfgIo::write(PacketPtr pkt)
 {
     const Addr addr = pkt->getAddr();
     const auto size = pkt->getSize();

     pkt->makeResponse();

     if (addr == selectorAddr) {
         if (size != 2) {
             warn("Write to firmware config selector register with width %d "
                     "not supported.", size);
         } else {
             auto key = pkt->getLE<uint16_t>();
             select(key);
         }
     } else if (addr == dataAddr) {
         // Writes to the firmware config data can only be done through the
         // DMA interface.
         warn("Write to firmware config data register not supported.");
     } else {
         panic("Unrecognized firmware config write [%#x-%#x).",
                 addr, addr + size);
     }

     return 0;
 }

 FwCfgMmio::FwCfgMmio(const Params &p) : FwCfg(p, {
         {p.selector_addr, p.selector_addr + 2},
         {p.data_addr_range}}),
     selectorAddr(p.selector_addr),
     dataAddr(p.data_addr_range.start()), dataSize(p.data_addr_range.size())
 {}

 Tick
 FwCfgMmio::read(PacketPtr pkt)
 {
     const Addr addr = pkt->getAddr();
     const auto size = pkt->getSize();

     pkt->makeResponse();
     // The default response is all zeroes.
     std::memset(pkt->getPtr<uint8_t>(), 0, size);

     if (addr == selectorAddr) {
         warn("Read from firmware config selector register not supported.");
     } else if (addr == dataAddr) {
         if (size == dataSize) {
             readItem(pkt->getPtr<void>(), size);
         } else {
             warn("Read from firmware config data register with width %d not "
                     "supported.", size);
         }
     } else {
         panic("Unregognized firmware config read [%#x-%#x).",
                 addr, addr + size);
     }

     return 0;
 }

 Tick
 FwCfgMmio::write(PacketPtr pkt)
 {
     const Addr addr = pkt->getAddr();
     const auto size = pkt->getSize();

     pkt->makeResponse();

     if (addr == selectorAddr) {
         if (size != 2) {
             warn("Write to firmware config selector register with width %d "
                     "not supported.", size);
         } else {
             auto key = pkt->getBE<uint16_t>();
             select(key);
         }
     } else if (addr == dataAddr) {
         // Writes to the firmware config data can only be done through the
         // DMA interface.
         warn("Write to firmware config data register not supported.");
     } else {
         panic("Unrecognized firmware config write [%#x-%#x).",
                 addr, addr + size);
     }

     return 0;
 }

 } // namespace qemu
 } // namespace gem5
	/*
	* Copyright 2022 Google, Inc.
	*
	* 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.
	*/

	#include "dev/qemu/fw_cfg.hh"

	#include <cstring>
	#include <sstream>
	#include <string>

	#include "base/compiler.hh"
	#include "base/cprintf.hh"
	#include "base/logging.hh"
	#include "base/trace.hh"
	#include "debug/QemuFwCfg.hh"
	#include "debug/QemuFwCfgVerbose.hh"
	#include "mem/packet_access.hh"
	#include "sim/byteswap.hh"

	namespace gem5
	{

	namespace qemu
	{

	void
	FwCfgItemFixed::read(void *buf, uint64_t offset, uint32_t to_read)
	{
	// Get access to the data we need to fill this buffer.
	const void *data = bytes();
	const uint64_t total_length = length();

	if (offset > total_length) {
	// We're completely off the end, so return only zeroes.
	std::memset(buf, 0, to_read);
	return;
	}

	if (offset + to_read > total_length) {
	// We're partially off the end, truncate this read and zero fill.

	// Figure out how far past the end we're attempting to read.
	uint64_t overflow = offset + to_read - total_length;

	// Reduce the requested read size to what we can actually fill.
	to_read -= overflow;

	// Zero out the part we won't read data into.
	std::memset((uint8_t *)buf + to_read, 0, overflow);
	}

	// Do the read.
	std::memcpy(buf, (uint8_t *)data + offset, to_read);
	}

	FwCfg::FwCfg(const Params &p, const AddrRangeList &addr_ranges) :
	PioDevice(p),
	signature(".[FW_CFG_SIGNATURE]", false, "QEMU CFG", 0),
	// The ID says we support the traditional interface but not DMA. To enable
	// DMA, this should be equal to 3.
	id(".[FW_CFG_ID]", false, "\x1", 1),
	addrRanges(addr_ranges)
	{
	// Add the unnamed, fixed items.
	addItem(&signature);
	addItem(&id);

	for (auto factory: p.items) {
	// Process named items and add them to the index.
	auto &item = factory->item();

	uint32_t &next_index =
	item.archSpecific() ? nextArchIndex : nextGenericIndex;
	const uint32_t &max_index =
	item.archSpecific() ? MaxArchIndex : MaxGenericIndex;

	// Automatically assign an ID if a fixed one wasn't specified.
	if (!item.index())
	item.index(next_index++);

	panic_if(item.index() >= max_index,
	"Firmware config device out of %s indexes.",
	item.archSpecific() ? "arch" : "generic");

	addItem(&item);
	}

	directory.update(names, numbers);
	addItem(&directory);
	};

	void
	FwCfg::addItem(FwCfgItem *item)
	{
	const auto [kit, ksuccess] =
	numbers.insert(std::make_pair(item->index(), item));

	panic_if(!ksuccess, "Duplicate firmware config item key %#x, "
	"paths %s and %s.",
	item->index(), item->path(), kit->second->path());

	const std::string &path = item->path();
	if (path.empty() \|\| path[0] != '.') {
	const auto res =
	names.insert(std::make_pair(item->path(), item->index()));

	panic_if(!res.second, "Duplicate firmware config item path %s.",
	item->path());
	}
	}

	void
	FwCfg::select(uint16_t key)
	{
	DPRINTF(QemuFwCfg, "Selecting item with key %#x.\n", key);

	// Clear any previous selection.
	offset = 0;
	current = nullptr;

	auto iter = numbers.find(key);
	if (iter == numbers.end()) {
	warn("Firmware config failed to select item with key %#x.", key);
	return;
	}

	auto item = iter->second;

	current = item;
	if (current)
	DPRINTF(QemuFwCfg, "Selected item with path %s.\n", item->path());
	else
	DPRINTF(QemuFwCfg, "No item is currently selected.\n");
	}

	void
	FwCfg::readItem(void *buf, uint32_t length)
	{
	if (!current) {
	DPRINTF(QemuFwCfgVerbose,
	"Tried to read while nothing was selected.\n");
	std::memset(buf, 0, length);
	return;
	}

	current->read(buf, offset, length);

	if (gem5::debug::QemuFwCfgVerbose) {
	std::stringstream data_str;
	for (int idx = 0; idx < length; idx++)
	ccprintf(data_str, " %02x", ((uint8_t *)buf)[idx]);

	DPRINTF(QemuFwCfgVerbose, "Read [%#x-%#x) =>%s.\n",
	offset, offset + length, data_str.str());
	}

	offset += length;
	}

	FwCfg::Directory::Directory() :
	FwCfgItemFixed(".[FW_CFG_FILE_DIR]", false, 0x19)
	{}

	void
	FwCfg::Directory::update(
	const std::map<std::string, uint16_t> &names,
	const std::map<uint16_t, FwCfgItem *> &numbers)
	{
	uint32_t count = names.size();

	struct GEM5_PACKED File
	{
	uint32_t size;
	uint16_t select;
	uint16_t reserved;
	char name[56];
	};

	uint64_t bytes = sizeof(count) + sizeof(File) * count;
	data.resize(bytes);

	uint8_t *ptr = data.data();

	uint32_t be_count = htobe(count);
	std::memcpy(ptr, &be_count, sizeof(be_count));
	ptr += sizeof(be_count);

	for (auto &[name, index]: names) {
	// Fill in the entry.
	File file{(uint32_t)numbers.at(index)->length(), index, 0, {}};
	std::memset(file.name, 0, sizeof(file.name));
	std::strncpy(file.name, name.c_str(), sizeof(file.name) - 1);

	// Fix endianness.
	file.size = htobe(file.size);
	file.select = htobe(file.select);

	// Copy it to the buffer and update ptr.
	std::memcpy(ptr, &file, sizeof(file));
	ptr += sizeof(file);
	}
	}

	FwCfgIo::FwCfgIo(const Params &p) : FwCfg(p, {
	// This covers both the 16 bit selector, and the 8 bit data reg which
	// overlaps it.
	{p.selector_addr, p.selector_addr + 2}}),
	selectorAddr(p.selector_addr), dataAddr(p.selector_addr + 1)
	{}

	Tick
	FwCfgIo::read(PacketPtr pkt)
	{
	const Addr addr = pkt->getAddr();
	const auto size = pkt->getSize();

	pkt->makeResponse();
	// The default response is all zeroes.
	std::memset(pkt->getPtr<uint8_t>(), 0, size);

	if (addr == selectorAddr) {
	warn("Read from firmware config selector register not supported.");
	} else if (addr == dataAddr) {
	if (size == 1) {
	readItem(pkt->getPtr<void>(), size);
	} else {
	warn("Read from firmware config data register with width %d not "
	"supported.", size);
	}
	} else {
	panic("Unregognized firmware config read [%#x-%#x).",
	addr, addr + size);
	}

	return 0;
	}

	Tick
	FwCfgIo::write(PacketPtr pkt)
	{
	const Addr addr = pkt->getAddr();
	const auto size = pkt->getSize();

	pkt->makeResponse();

	if (addr == selectorAddr) {
	if (size != 2) {
	warn("Write to firmware config selector register with width %d "
	"not supported.", size);
	} else {
	auto key = pkt->getLE<uint16_t>();
	select(key);
	}
	} else if (addr == dataAddr) {
	// Writes to the firmware config data can only be done through the
	// DMA interface.
	warn("Write to firmware config data register not supported.");
	} else {
	panic("Unrecognized firmware config write [%#x-%#x).",
	addr, addr + size);
	}

	return 0;
	}

	FwCfgMmio::FwCfgMmio(const Params &p) : FwCfg(p, {
	{p.selector_addr, p.selector_addr + 2},
	{p.data_addr_range}}),
	selectorAddr(p.selector_addr),
	dataAddr(p.data_addr_range.start()), dataSize(p.data_addr_range.size())
	{}

	Tick
	FwCfgMmio::read(PacketPtr pkt)
	{
	const Addr addr = pkt->getAddr();
	const auto size = pkt->getSize();

	pkt->makeResponse();
	// The default response is all zeroes.
	std::memset(pkt->getPtr<uint8_t>(), 0, size);

	if (addr == selectorAddr) {
	warn("Read from firmware config selector register not supported.");
	} else if (addr == dataAddr) {
	if (size == dataSize) {
	readItem(pkt->getPtr<void>(), size);
	} else {
	warn("Read from firmware config data register with width %d not "
	"supported.", size);
	}
	} else {
	panic("Unregognized firmware config read [%#x-%#x).",
	addr, addr + size);
	}

	return 0;
	}

	Tick
	FwCfgMmio::write(PacketPtr pkt)
	{
	const Addr addr = pkt->getAddr();
	const auto size = pkt->getSize();

	pkt->makeResponse();

	if (addr == selectorAddr) {
	if (size != 2) {
	warn("Write to firmware config selector register with width %d "
	"not supported.", size);
	} else {
	auto key = pkt->getBE<uint16_t>();
	select(key);
	}
	} else if (addr == dataAddr) {
	// Writes to the firmware config data can only be done through the
	// DMA interface.
	warn("Write to firmware config data register not supported.");
	} else {
	panic("Unrecognized firmware config write [%#x-%#x).",
	addr, addr + size);
	}

	return 0;
	}

	} // namespace qemu
	} // namespace gem5