| // Copyright 2021 The ChromiumOS Authors |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| /* |
| * Device access interface common functions. |
| */ |
| |
| #include "hps/dev.h" |
| |
| #include <optional> |
| |
| #include "base/logging.h" |
| #include <base/strings/stringprintf.h> |
| #include "hps/hps_reg.h" |
| #include "hps/utils.h" |
| |
| namespace hps { |
| namespace { |
| |
| class WakeLockNoOpImpl : public WakeLock { |
| public: |
| WakeLockNoOpImpl() = default; |
| ~WakeLockNoOpImpl() override = default; |
| bool supports_power_management() override { return false; } |
| }; |
| |
| } // namespace |
| |
| bool DevInterface::Read(uint8_t cmd, uint8_t* data, size_t len) { |
| if (this->ReadDevice(cmd, data, len)) { |
| VLOG(2) << base::StringPrintf("Read: cmd: 0x%x len: %zd OK", cmd, len); |
| return true; |
| } |
| VLOG(2) << base::StringPrintf("Read: cmd: 0x%x len: %zd FAILED", cmd, len); |
| return false; |
| } |
| |
| bool DevInterface::Write(uint8_t cmd, const uint8_t* data, size_t len) { |
| if (this->WriteDevice(cmd, data, len)) { |
| VLOG(2) << base::StringPrintf("Write: cmd: 0x%x len: %zd OK", cmd, len); |
| return true; |
| } |
| VLOG(2) << base::StringPrintf("Write: cmd: 0x%x len: %zd FAILED", cmd, len); |
| return false; |
| } |
| |
| /* |
| * Read 1 register. |
| * Returns value read, or -1 for error. |
| */ |
| std::optional<uint16_t> DevInterface::ReadReg(HpsReg r) { |
| auto reg = HpsRegInfo(r); |
| uint8_t res[2]; |
| |
| if (this->ReadDevice(I2cReg(r), res, sizeof(res))) { |
| uint16_t ret = static_cast<uint16_t>(res[0] << 8) | res[1]; |
| VLOG(2) << base::StringPrintf("ReadReg: %s : 0x%.4x OK", reg->name, ret); |
| return ret; |
| } else { |
| VLOG(2) << "ReadReg: " << reg->name << " FAILED"; |
| return std::nullopt; |
| } |
| } |
| |
| std::optional<std::string> DevInterface::ReadStringReg(HpsReg r, size_t len) { |
| auto reg = HpsRegInfo(r); |
| std::string ret(len, '\0'); |
| |
| if (this->ReadDevice(I2cReg(r), reinterpret_cast<uint8_t*>(ret.data()), |
| static_cast<unsigned int>(ret.size()))) { |
| auto terminator = ret.find('\0'); |
| if (terminator != std::string::npos) { |
| ret.resize(terminator); |
| } |
| VLOG(2) << base::StringPrintf("ReadReg: %s (%zu bytes) OK", reg->name, |
| ret.size()); |
| return ret; |
| } else { |
| VLOG(2) << "ReadStringReg: " << reg->name << " FAILED"; |
| return std::nullopt; |
| } |
| } |
| |
| /* |
| * Write 1 register. |
| * Returns false on failure. |
| */ |
| bool DevInterface::WriteReg(HpsReg r, uint16_t data) { |
| auto reg = HpsRegInfo(r); |
| uint8_t buf[2]; |
| |
| buf[0] = data >> 8; |
| buf[1] = data & 0xFF; |
| |
| if (this->WriteDevice(I2cReg(r), buf, sizeof(buf))) { |
| VLOG(2) << base::StringPrintf("WriteReg: %s : 0x%.4x OK", reg->name, data); |
| return true; |
| } else { |
| VLOG(2) << base::StringPrintf("WriteReg: %s : 0x%.4x FAILED", reg->name, |
| data); |
| return false; |
| } |
| } |
| |
| /* |
| * Return the maximum download block size (in bytes). |
| * Default is 256 bytes. |
| */ |
| size_t DevInterface::BlockSizeBytes() { |
| return 256; |
| } |
| |
| std::unique_ptr<WakeLock> DevInterface::CreateWakeLock() { |
| return std::make_unique<WakeLockNoOpImpl>(); |
| } |
| |
| } // namespace hps |