| /* |
| * Copyright (C) 2016 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #ifndef SYSTEM_PERIPHERALMANAGER_DAEMON_I2C_MANAGER_H_ |
| #define SYSTEM_PERIPHERALMANAGER_DAEMON_I2C_MANAGER_H_ |
| |
| #include <stdint.h> |
| |
| #include <map> |
| #include <memory> |
| #include <string> |
| #include <vector> |
| |
| #include <base/macros.h> |
| |
| #include "peripheralmanager/constants.h" |
| #include "pin_mux_manager.h" |
| #include "i2c_driver.h" |
| |
| namespace android { |
| |
| struct I2cDevBus { |
| I2cDevBus(uint32_t b) : bus(b) {} |
| uint32_t bus; |
| std::string mux; |
| std::string mux_group; |
| std::map<uint32_t, std::unique_ptr<I2cDriverInterface>> driver_; |
| }; |
| |
| class I2cDevice { |
| public: |
| I2cDevice(I2cDevBus* bus, uint32_t address) : bus_(bus), address_(address) {} |
| ~I2cDevice() { |
| if (!bus_->mux.empty()) { |
| PinMuxManager::GetPinMuxManager()->ReleaseSource(bus_->mux, |
| bus_->mux_group); |
| } |
| bus_->driver_.erase(address_); |
| } |
| |
| int32_t Read(void* data, uint32_t size, uint32_t* bytes_read) { |
| return bus_->driver_[address_]->Read(data, size, bytes_read); |
| } |
| |
| int32_t ReadRegByte(uint8_t reg, uint8_t* val) { |
| return bus_->driver_[address_]->ReadRegByte(reg, val); |
| } |
| |
| int32_t ReadRegWord(uint8_t reg, uint16_t* val) { |
| return bus_->driver_[address_]->ReadRegWord(reg, val); |
| } |
| |
| int32_t ReadRegBuffer(uint8_t reg, |
| uint8_t* data, |
| uint32_t size, |
| uint32_t* bytes_read) { |
| return bus_->driver_[address_]->ReadRegBuffer(reg, data, size, bytes_read); |
| } |
| |
| int32_t Write(const void* data, uint32_t size, uint32_t* bytes_written) { |
| return bus_->driver_[address_]->Write(data, size, bytes_written); |
| } |
| |
| int32_t WriteRegByte(uint8_t reg, uint8_t val) { |
| return bus_->driver_[address_]->WriteRegByte(reg, val); |
| } |
| |
| int32_t WriteRegWord(uint8_t reg, uint16_t val) { |
| return bus_->driver_[address_]->WriteRegWord(reg, val); |
| } |
| |
| int32_t WriteRegBuffer(uint8_t reg, |
| const uint8_t* data, |
| uint32_t size, |
| uint32_t* bytes_written) { |
| return bus_->driver_[address_]->WriteRegBuffer( |
| reg, data, size, bytes_written); |
| } |
| |
| private: |
| I2cDevBus* bus_; |
| uint32_t address_; |
| }; |
| |
| class I2cManager { |
| public: |
| friend class I2cManagerTest; |
| ~I2cManager(); |
| |
| // Get the singleton. |
| static I2cManager* GetI2cManager(); |
| |
| // Resets the global I2c manager (used for testing). |
| static void ResetI2cManager(); |
| |
| bool RegisterI2cDevBus(const std::string& name, uint32_t bus); |
| |
| std::vector<std::string> GetI2cDevBuses(); |
| bool HasI2cDevBus(const std::string& name); |
| |
| bool SetPinMux(const std::string& name, const std::string& mux); |
| bool SetPinMuxWithGroup(const std::string& name, |
| const std::string& mux, |
| const std::string& group); |
| |
| bool RegisterDriver(std::unique_ptr<I2cDriverInfoBase> driver_info); |
| |
| std::unique_ptr<I2cDevice> OpenI2cDevice(const std::string& name, |
| uint32_t address); |
| |
| private: |
| I2cManager(); |
| |
| std::map<std::string, std::unique_ptr<I2cDriverInfoBase>> driver_infos_; |
| std::map<std::string, I2cDevBus> i2cdev_buses_; |
| |
| DISALLOW_COPY_AND_ASSIGN(I2cManager); |
| }; |
| |
| } // namespace android |
| |
| #endif // SYSTEM_PERIPHERALMANAGER_DAEMON_I2C_MANAGER_H_ |