1 /* 2 * Copyright (c) 2021-2022 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 #ifndef USB_HOST_MANAGER_H 17 #define USB_HOST_MANAGER_H 18 19 #include <map> 20 #include <string> 21 #include <vector> 22 23 #include "system_ability.h" 24 #include "usb_device.h" 25 #include "usb_right_manager.h" 26 #include "usb_interface_type.h" 27 #include "v1_2/iusb_interface.h" 28 #include "iremote_object.h" 29 #ifdef USB_MANAGER_PASS_THROUGH 30 #include "mem_mgr_proxy.h" 31 #include "mem_mgr_client.h" 32 #include "v2_0/iusb_host_interface.h" 33 #include "system_ability_definition.h" 34 #include "usb_manager_subscriber.h" 35 #include "usb_bulkcallback_impl.h" 36 #include "usb_transfer_callback_impl.h" 37 #endif // USB_MANAGER_PASS_THROUGH 38 39 namespace OHOS { 40 namespace USB { 41 struct DeviceClassUsage { 42 uint8_t usage; 43 std::string description; 44 DeviceClassUsageDeviceClassUsage45 DeviceClassUsage(int8_t uage, std::string des) 46 : usage(uage), description(des) {}; 47 }; 48 49 typedef std::map<std::string, UsbDevice *> MAP_STR_DEVICE; 50 class UsbHostManager { 51 public: 52 explicit UsbHostManager(SystemAbility *systemAbility); 53 ~UsbHostManager(); 54 #ifdef USB_MANAGER_PASS_THROUGH 55 bool InitUsbHostInterface(); 56 void Stop(); 57 int32_t BindUsbdSubscriber(const sptr<HDI::Usb::V2_0::IUsbdSubscriber> &subscriber); 58 int32_t UnbindUsbdSubscriber(const sptr<HDI::Usb::V2_0::IUsbdSubscriber> &subscriber); 59 #endif // USB_MANAGER_PASS_THROUGH 60 void GetDevices(MAP_STR_DEVICE &devices); 61 bool GetProductName(const std::string &deviceName, std::string &productName); 62 bool DelDevice(uint8_t busNum, uint8_t devNum); 63 bool AddDevice(UsbDevice *dev); 64 bool Dump(int fd, const std::string &args); 65 void ExecuteStrategy(UsbDevice *devInfo); 66 67 int32_t OpenDevice(uint8_t busNum, uint8_t devAddr); 68 int32_t Close(uint8_t busNum, uint8_t devAddr); 69 int32_t ResetDevice(uint8_t busNum, uint8_t devAddr); 70 int32_t ClaimInterface(uint8_t busNum, uint8_t devAddr, uint8_t interfaceid, uint8_t force); 71 int32_t SetInterface(uint8_t busNum, uint8_t devAddr, uint8_t interfaceid, uint8_t altIndex); 72 int32_t ReleaseInterface(uint8_t busNum, uint8_t devAddr, uint8_t interface); 73 int32_t SetActiveConfig(uint8_t busNum, uint8_t devAddr, uint8_t configIndex); 74 int32_t ManageGlobalInterface(bool disable); 75 int32_t ManageDevice(int32_t vendorId, int32_t productId, bool disable); 76 int32_t ManageInterfaceType(const std::vector<UsbDeviceType> &disableType, bool disable); 77 int32_t UsbAttachKernelDriver(uint8_t busNum, uint8_t devAddr, uint8_t interfaceid); 78 int32_t UsbDetachKernelDriver(uint8_t busNum, uint8_t devAddr, uint8_t interfaceid); 79 int32_t ClearHalt(uint8_t busNum, uint8_t devAddr, uint8_t interfaceId, uint8_t endpointId); 80 81 int32_t GetDevices(std::vector<UsbDevice> &deviceList); 82 int32_t GetDeviceInfo(uint8_t busNum, uint8_t devAddr, UsbDevice &dev); 83 int32_t GetDeviceInfoDescriptor( 84 const HDI::Usb::V1_0::UsbDev &uDev, std::vector<uint8_t> &descriptor, UsbDevice &dev); 85 int32_t GetConfigDescriptor(UsbDevice &dev, std::vector<uint8_t> &descriptor); 86 int32_t GetActiveConfig(uint8_t busNum, uint8_t devAddr, uint8_t &configIndex); 87 int32_t GetRawDescriptor(uint8_t busNum, uint8_t devAddr, std::vector<uint8_t> &bufferData); 88 int32_t GetFileDescriptor(uint8_t busNum, uint8_t devAddr, int32_t &fd); 89 int32_t GetDeviceSpeed(uint8_t busNum, uint8_t devAddr, uint8_t &speed); 90 int32_t GetInterfaceActiveStatus(uint8_t busNum, uint8_t devAddr, uint8_t interfaceid, bool &unactivated); 91 92 int32_t BulkTransferRead(const HDI::Usb::V1_0::UsbDev &dev, const HDI::Usb::V1_0::UsbPipe &pipe, 93 std::vector<uint8_t> &bufferData, int32_t timeout); 94 int32_t BulkTransferReadwithLength(const HDI::Usb::V1_0::UsbDev &dev, const HDI::Usb::V1_0::UsbPipe &pipe, 95 int32_t length, std::vector<uint8_t> &bufferData, int32_t timeOut); 96 int32_t BulkTransferWrite(const HDI::Usb::V1_0::UsbDev &dev, const HDI::Usb::V1_0::UsbPipe &pipe, 97 const std::vector<uint8_t>& bufferData, int32_t timeout); 98 int32_t ControlTransfer(const HDI::Usb::V1_0::UsbDev &dev, const HDI::Usb::V1_0::UsbCtrlTransfer &ctrl, 99 std::vector<uint8_t> &bufferData); 100 int32_t UsbControlTransfer(const HDI::Usb::V1_0::UsbDev &dev, 101 const HDI::Usb::V1_2::UsbCtrlTransferParams &ctrlParams, std::vector<uint8_t> &bufferData); 102 int32_t RequestQueue(const HDI::Usb::V1_0::UsbDev &dev, const HDI::Usb::V1_0::UsbPipe &pipe, 103 const std::vector<uint8_t> &clientData, const std::vector<uint8_t> &bufferData); 104 int32_t RequestWait(const HDI::Usb::V1_0::UsbDev &dev, int32_t timeOut, std::vector<uint8_t> &clientData, 105 std::vector<uint8_t> &bufferData); 106 int32_t RequestCancel(uint8_t busNum, uint8_t devAddr, uint8_t interfaceId, uint8_t endpointId); 107 int32_t UsbCancelTransfer(const HDI::Usb::V1_0::UsbDev &devInfo, const int32_t &endpoint); 108 int32_t UsbSubmitTransfer(const HDI::Usb::V1_0::UsbDev &devInfo, HDI::Usb::V1_2::USBTransferInfo &info, 109 const sptr<IRemoteObject> &cb, sptr<Ashmem> &ashmem); 110 int32_t RegBulkCallback(const HDI::Usb::V1_0::UsbDev &devInfo, const HDI::Usb::V1_0::UsbPipe &pipe, 111 const sptr<IRemoteObject> &cb); 112 int32_t UnRegBulkCallback(const HDI::Usb::V1_0::UsbDev &devInfo, const HDI::Usb::V1_0::UsbPipe &pipe); 113 int32_t BulkRead( 114 const HDI::Usb::V1_0::UsbDev &devInfo, const HDI::Usb::V1_0::UsbPipe &pipe, sptr<Ashmem> &ashmem); 115 int32_t BulkWrite( 116 const HDI::Usb::V1_0::UsbDev &devInfo, const HDI::Usb::V1_0::UsbPipe &pipe, sptr<Ashmem> &ashmem); 117 int32_t BulkCancel(const HDI::Usb::V1_0::UsbDev &devInfo, const HDI::Usb::V1_0::UsbPipe &pipe); 118 119 private: 120 bool PublishCommonEvent(const std::string &event, const UsbDevice &dev); 121 void ReportHostPlugSysEvent(const std::string &event, const UsbDevice &dev); 122 std::string ConcatenateToDescription(const UsbDeviceType &interfaceType, const std::string& str); 123 int32_t GetDeviceDescription(int32_t baseClass, std::string &description, uint8_t &usage); 124 int32_t GetInterfaceDescription(const UsbDevice &dev, std::string &description, int32_t &baseClass); 125 std::string GetInterfaceUsageDescription(const UsbDeviceType &interfaceType); 126 int32_t FillDevStrings(UsbDevice &dev); 127 std::string GetDevStringValFromIdx(uint8_t busNum, uint8_t devAddr, uint8_t idx); 128 bool IsEdmEnabled(); 129 int32_t ExecuteManageDevicePolicy(std::vector<UsbDeviceId> &whiteList); 130 int32_t ExecuteManageInterfaceType(const std::vector<UsbDeviceType> &disableType, bool disable); 131 int32_t GetEdmPolicy(bool &IsGlobalDisabled, std::vector<UsbDeviceType> &disableType, 132 std::vector<UsbDeviceId> &trustUsbDeviceIds); 133 int32_t GetUsbPolicy(bool &IsGlobalDisabled, std::vector<UsbDeviceType> &disableType, 134 std::vector<UsbDeviceId> &trustUsbDeviceIds); 135 int32_t GetEdmTypePolicy(sptr<IRemoteObject> remote, std::vector<UsbDeviceType> &disableType); 136 int32_t GetEdmGlobalPolicy(sptr<IRemoteObject> remote, bool &IsGlobalDisabled); 137 int32_t GetEdmStroageTypePolicy(sptr<IRemoteObject> remote, std::vector<UsbDeviceType> &disableType); 138 int32_t GetEdmWhiteListPolicy(sptr<IRemoteObject> remote, std::vector<UsbDeviceId> &trustUsbDeviceIds); 139 int32_t ManageInterface(const HDI::Usb::V1_0::UsbDev &dev, uint8_t interfaceId, bool disable); 140 void ExecuteManageDeviceType(const std::vector<UsbDeviceType> &disableType, bool disable, 141 const std::unordered_map<InterfaceType, std::vector<int32_t>> &map, bool isDev); 142 int32_t ManageGlobalInterfaceImpl(bool disable); 143 int32_t ManageDeviceImpl(int32_t vendorId, int32_t productId, bool disable); 144 int32_t ManageInterfaceTypeImpl(InterfaceType interfaceType, bool disable); 145 int32_t ManageDeviceTypeImpl(InterfaceType interfaceType, bool disable); 146 void ReportManageDeviceInfo(const std::string &operationType, UsbDevice* device, 147 const UsbInterface* interface, bool isInterfaceType); 148 MAP_STR_DEVICE devices_; 149 SystemAbility *systemAbility_; 150 std::mutex mutex_; 151 std::shared_ptr<UsbRightManager> usbRightManager_; 152 sptr<HDI::Usb::V1_0::IUsbdBulkCallback> hdiCb_ = nullptr; 153 std::mutex hdiCbMutex_; 154 std::mutex transferMutex_; 155 class UsbSubmitTransferDeathRecipient : public IRemoteObject::DeathRecipient { 156 public: UsbSubmitTransferDeathRecipient(const HDI::Usb::V1_0::UsbDev & devInfo,const int32_t endpoint,UsbHostManager * service,const sptr<IRemoteObject> cb)157 UsbSubmitTransferDeathRecipient(const HDI::Usb::V1_0::UsbDev &devInfo, const int32_t endpoint, 158 UsbHostManager *service, const sptr<IRemoteObject> cb) 159 : devInfo_(devInfo), endpoint_(endpoint), service_(service), cb_(cb) {}; ~UsbSubmitTransferDeathRecipient()160 ~UsbSubmitTransferDeathRecipient() {}; 161 void OnRemoteDied(const wptr<IRemoteObject> &object) override; 162 private: 163 const HDI::Usb::V1_0::UsbDev devInfo_; 164 const int32_t endpoint_; 165 UsbHostManager *service_; 166 const sptr<IRemoteObject> cb_; 167 }; 168 169 #ifdef USB_MANAGER_PASS_THROUGH 170 sptr<HDI::Usb::V2_0::IUsbHostInterface> usbHostInterface_ = nullptr; 171 sptr<HDI::Usb::V2_0::IUsbdBulkCallback> usbHostHdiCb_ = nullptr; 172 sptr<UsbManagerSubscriber> usbManagerSubscriber_; 173 #else 174 sptr<HDI::Usb::V1_2::IUsbInterface> usbd_ = nullptr; 175 #endif // USB_MANAGER_PASS_THROUGH 176 }; 177 } // namespace USB 178 } // namespace OHOS 179 180 #endif // USB_HOST_MANAGER_H 181