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 #include "devmgr_service_proxy.h"
17 #include "devhost_service_stub.h"
18 #include "devmgr_service_if.h"
19 #include "devmgr_service_stub.h"
20 #include "devsvc_manager_clnt.h"
21 #include "hdf_base.h"
22 #include "hdf_log.h"
23 #include "hdf_sbuf.h"
24 #include "osal_mem.h"
25 
26 #define HDF_LOG_TAG devmgr_service_proxy
27 
DevmgrServiceProxyAttachDeviceHost(struct IDevmgrService * inst,uint16_t hostId,struct IDevHostService * service)28 int DevmgrServiceProxyAttachDeviceHost(struct IDevmgrService *inst, uint16_t hostId, struct IDevHostService *service)
29 {
30     int status = HDF_FAILURE;
31     struct HdfSBuf *data = HdfSbufTypedObtain(SBUF_IPC);
32     struct HdfSBuf *reply = HdfSbufTypedObtain(SBUF_IPC);
33     struct HdfRemoteDispatcher *dipatcher = NULL;
34     struct HdfRemoteService *remoteService = NULL;
35     struct DevmgrServiceProxy *serviceProxy = (struct DevmgrServiceProxy *)inst;
36     struct DevHostServiceStub *hostStub = (struct DevHostServiceStub *)service;
37     if ((serviceProxy->remote == NULL) || (data == NULL) || (reply == NULL) || (hostStub == NULL)) {
38         HDF_LOGE("DevmgrServiceProxyAttachDeviceHost failed, host id is %{public}u", hostId);
39         goto FINISHED;
40     }
41     remoteService = serviceProxy->remote;
42     dipatcher = remoteService->dispatcher;
43     const int waitTimes = 100;
44     const int sleepInterval = 20000; // 20ms
45     int timeout = waitTimes;
46     do {
47         HDF_LOGI("wait devmgr attach device host : %{public}d, will retry %{public}d times", hostId, timeout);
48         if (!HdfRemoteServiceWriteInterfaceToken(remoteService, data) || !HdfSbufWriteInt32(data, hostId) ||
49             HdfSbufWriteRemoteService(data, hostStub->remote) != HDF_SUCCESS) {
50             HDF_LOGE("failed to attach host, write sbuf error");
51             goto FINISHED;
52         }
53         status = dipatcher->Dispatch(remoteService, DEVMGR_SERVICE_ATTACH_DEVICE_HOST, data, reply);
54         HDF_LOGD("current status is %{public}d", status);
55         HdfSbufFlush(data);
56         HdfSbufFlush(reply);
57         timeout--;
58         usleep(sleepInterval);
59     } while ((status != HDF_SUCCESS) && (timeout > 0));
60     HDF_LOGI("Attach device host dispatch finish, status is %{public}d", status);
61 FINISHED:
62     HdfSbufRecycle(reply);
63     HdfSbufRecycle(data);
64     return status;
65 }
66 
DevmgrServiceProxyAttachDevice(struct IDevmgrService * inst,struct IHdfDeviceToken * token)67 int DevmgrServiceProxyAttachDevice(struct IDevmgrService *inst, struct IHdfDeviceToken *token)
68 {
69     int status = HDF_FAILURE;
70     struct HdfSBuf *data = HdfSbufTypedObtain(SBUF_IPC);
71     struct HdfSBuf *reply = HdfSbufTypedObtain(SBUF_IPC);
72     struct DevmgrServiceProxy *serviceProxy = (struct DevmgrServiceProxy *)inst;
73     if (serviceProxy == NULL || serviceProxy->remote == NULL || data == NULL || reply == NULL || token == NULL) {
74         HDF_LOGE("DevmgrServiceProxyAttachDevice failed");
75         goto FINISHED;
76     }
77     struct HdfRemoteService *remoteService = serviceProxy->remote;
78     const char *srvName = (token->servName == NULL) ? "" : token->servName;
79     const char *deviceName = (token->deviceName == NULL) ? "" : token->deviceName;
80     if (!HdfRemoteServiceWriteInterfaceToken(remoteService, data) || !HdfSbufWriteInt32(data, token->devid) ||
81         !HdfSbufWriteString(data, srvName) || !HdfSbufWriteString(data, deviceName)) {
82         goto FINISHED;
83     }
84 
85     status = remoteService->dispatcher->Dispatch(remoteService, DEVMGR_SERVICE_ATTACH_DEVICE, data, reply);
86 FINISHED:
87     HdfSbufRecycle(reply);
88     HdfSbufRecycle(data);
89     return status;
90 }
91 
DevmgrServiceProxyDetachDevice(struct IDevmgrService * inst,devid_t devid)92 int DevmgrServiceProxyDetachDevice(struct IDevmgrService *inst, devid_t devid)
93 {
94     int status = HDF_FAILURE;
95     struct HdfSBuf *data = HdfSbufTypedObtain(SBUF_IPC);
96     struct HdfSBuf *reply = HdfSbufTypedObtain(SBUF_IPC);
97     struct DevmgrServiceProxy *serviceProxy = (struct DevmgrServiceProxy *)inst;
98     if (serviceProxy == NULL || serviceProxy->remote == NULL || data == NULL || reply == NULL) {
99         HDF_LOGE("DevmgrServiceProxyDetachDevice failed");
100         goto FINISHED;
101     }
102     struct HdfRemoteService *remoteService = serviceProxy->remote;
103     if (!HdfRemoteServiceWriteInterfaceToken(remoteService, data) || !HdfSbufWriteInt32(data, devid)) {
104         goto FINISHED;
105     }
106 
107     status = remoteService->dispatcher->Dispatch(remoteService, DEVMGR_SERVICE_DETACH_DEVICE, data, reply);
108 FINISHED:
109     HdfSbufRecycle(reply);
110     HdfSbufRecycle(data);
111     return status;
112 }
113 
DevmgrServiceProxyProcessLoad(struct IDevmgrService * inst,const char * svcName,int code)114 static int DevmgrServiceProxyProcessLoad(struct IDevmgrService *inst, const char *svcName, int code)
115 {
116     struct DevmgrServiceProxy *serviceProxy = (struct DevmgrServiceProxy *)inst;
117     if (serviceProxy == NULL || serviceProxy->remote == NULL || svcName == NULL) {
118         HDF_LOGE("DevmgrServiceProxyProcessLoad code: %{public}d failed", code);
119         return HDF_ERR_INVALID_PARAM;
120     }
121 
122     struct HdfSBuf *data = HdfSbufTypedObtain(SBUF_IPC);
123     struct HdfRemoteService *remoteService = serviceProxy->remote;
124     if (!HdfRemoteServiceWriteInterfaceToken(remoteService, data) || !HdfSbufWriteString(data, svcName)) {
125         HdfSbufRecycle(data);
126         return HDF_FAILURE;
127     }
128 
129     int status = remoteService->dispatcher->Dispatch(remoteService, code, data, NULL);
130     HdfSbufRecycle(data);
131     return status;
132 }
133 
DevmgrServiceProxyLoadDevice(struct IDevmgrService * inst,const char * svcName)134 int DevmgrServiceProxyLoadDevice(struct IDevmgrService *inst, const char *svcName)
135 {
136     return DevmgrServiceProxyProcessLoad(inst, svcName, DEVMGR_SERVICE_LOAD_DEVICE);
137 }
138 
DevmgrServiceProxyUnLoadDevice(struct IDevmgrService * inst,const char * svcName)139 int DevmgrServiceProxyUnLoadDevice(struct IDevmgrService *inst, const char *svcName)
140 {
141     return DevmgrServiceProxyProcessLoad(inst, svcName, DEVMGR_SERVICE_UNLOAD_DEVICE);
142 }
143 
DevmgrServiceProxyConstruct(struct DevmgrServiceProxy * inst)144 static void DevmgrServiceProxyConstruct(struct DevmgrServiceProxy *inst)
145 {
146     struct IDevmgrService *pvtbl = (struct IDevmgrService *)inst;
147     pvtbl->AttachDeviceHost = DevmgrServiceProxyAttachDeviceHost;
148     pvtbl->AttachDevice = DevmgrServiceProxyAttachDevice;
149     pvtbl->DetachDevice = DevmgrServiceProxyDetachDevice;
150     pvtbl->LoadDevice = DevmgrServiceProxyLoadDevice;
151     pvtbl->UnloadDevice = DevmgrServiceProxyUnLoadDevice;
152     pvtbl->StartService = NULL;
153 }
154 
DevmgrServiceProxyObtain(struct HdfRemoteService * service)155 static struct IDevmgrService *DevmgrServiceProxyObtain(struct HdfRemoteService *service)
156 {
157     if (service != NULL) {
158         struct DevmgrServiceProxy *demgrServicProxy =
159             (struct DevmgrServiceProxy *)OsalMemCalloc(sizeof(struct DevmgrServiceProxy));
160         if (demgrServicProxy != NULL) {
161             demgrServicProxy->remote = service;
162             DevmgrServiceProxyConstruct(demgrServicProxy);
163             return &demgrServicProxy->super;
164         }
165     }
166     HDF_LOGE("DevmgrServiceProxyObtain failed");
167     return NULL;
168 }
169 
DevmgrServiceProxyCreate(void)170 struct HdfObject *DevmgrServiceProxyCreate(void)
171 {
172     static struct IDevmgrService *instance = NULL;
173     if (instance != NULL) {
174         return (struct HdfObject *)instance;
175     }
176     struct IDevSvcManager *serviceManagerIf = NULL;
177     struct DevSvcManagerClnt *serviceManager = (struct DevSvcManagerClnt *)DevSvcManagerClntGetInstance();
178     if ((serviceManager == NULL) || (serviceManager->devSvcMgrIf == NULL)) {
179         HDF_LOGE("Fail to Create Service Manager Client");
180         return NULL;
181     }
182     serviceManagerIf = serviceManager->devSvcMgrIf;
183     if (serviceManagerIf->GetService == NULL) {
184         HDF_LOGE("Get Service is not implement!!!");
185         return NULL;
186     }
187     struct HdfRemoteService *remote =
188         (struct HdfRemoteService *)serviceManagerIf->GetService(serviceManagerIf, DEVICE_MANAGER_SERVICE);
189     if (remote != NULL) {
190         if (!HdfRemoteServiceSetInterfaceDesc(remote, "HDI.IDeviceManager.V1_0")) {
191             HDF_LOGE("%{public}s: failed to init interface desc", __func__);
192             HdfRemoteServiceRecycle(remote);
193             return NULL;
194         }
195         instance = DevmgrServiceProxyObtain(remote);
196     }
197 
198     return (struct HdfObject *)instance;
199 }
200 
DevmgrServiceProxyRelease(struct HdfObject * object)201 void DevmgrServiceProxyRelease(struct HdfObject *object)
202 {
203     struct DevmgrServiceProxy *instance = (struct DevmgrServiceProxy *)object;
204     if (instance != NULL) {
205         if (instance->remote != NULL) {
206             HdfRemoteServiceRecycle(instance->remote);
207             instance->remote = NULL;
208         }
209         OsalMemFree(instance);
210     }
211 }
212