1 /*
2  * Copyright (C) 2021 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 "hci_evt_status_params_cmd_complete.h"
17 
18 #include <securec.h>
19 
20 #include "platform/include/allocator.h"
21 #include "platform/include/list.h"
22 #include "platform/include/mutex.h"
23 
24 #include "hci/cmd/hci_cmd.h"
25 #include "hci/hci.h"
26 #include "hci/hci_def.h"
27 
28 #include "hci_evt.h"
29 #include "hci_evt_cmd_complete.h"
30 
HciEventOnReadRssiComplete(const void * param,uint8_t length)31 static void HciEventOnReadRssiComplete(const void *param, uint8_t length)
32 {
33     HciReadRssiReturnParam returnParam = {0};
34     (void)memcpy_s(
35         &returnParam, sizeof(returnParam), param, (length > sizeof(returnParam)) ? sizeof(returnParam) : length);
36 
37     HciEventCallbacks *callbacks = NULL;
38     HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
39     if (callbacks->readRssiComplete != NULL) {
40         callbacks->readRssiComplete(&returnParam);
41     }
42     HCI_FOREACH_EVT_CALLBACKS_END;
43 }
44 
HciEventOnReadFailedContactCounterComplete(const void * param,uint8_t length)45 static void HciEventOnReadFailedContactCounterComplete(const void *param, uint8_t length)
46 {
47     HciReadFailedContactCounterReturnParam returnParam = {0};
48     (void)memcpy_s(
49         &returnParam, sizeof(returnParam), param, (length > sizeof(returnParam)) ? sizeof(returnParam) : length);
50 
51     HciEventCallbacks *callbacks = NULL;
52     HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
53     if (callbacks->readFailedContactCounterComplete != NULL) {
54         callbacks->readFailedContactCounterComplete(&returnParam);
55     }
56     HCI_FOREACH_EVT_CALLBACKS_END;
57 }
58 
HciEventOnResetFailedContactCounterComplete(const void * param,uint8_t length)59 static void HciEventOnResetFailedContactCounterComplete(const void *param, uint8_t length)
60 {
61     HciResetFailedContactCounterReturnParam returnParam = {0};
62     (void)memcpy_s(
63         &returnParam, sizeof(returnParam), param, (length > sizeof(returnParam)) ? sizeof(returnParam) : length);
64 
65     HciEventCallbacks *callbacks = NULL;
66     HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
67     if (callbacks->resetFailedContactCounterComplete != NULL) {
68         callbacks->resetFailedContactCounterComplete(&returnParam);
69     }
70     HCI_FOREACH_EVT_CALLBACKS_END;
71 }
72 
HciEventOnReadLinkQualityComplete(const void * param,uint8_t length)73 static void HciEventOnReadLinkQualityComplete(const void *param, uint8_t length)
74 {
75     HciReadLinkQualityReturnParam returnParam = {0};
76     (void)memcpy_s(
77         &returnParam, sizeof(returnParam), param, (length > sizeof(returnParam)) ? sizeof(returnParam) : length);
78 
79     HciEventCallbacks *callbacks = NULL;
80     HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
81     if (callbacks->readLinkQualityComplete != NULL) {
82         callbacks->readLinkQualityComplete(&returnParam);
83     }
84     HCI_FOREACH_EVT_CALLBACKS_END;
85 }
86 
HciEventOnReadAFHChannelMapComplete(const void * param,uint8_t length)87 static void HciEventOnReadAFHChannelMapComplete(const void *param, uint8_t length)
88 {
89     HciReadAfhChannelMapReturnParam returnParam = {0};
90     (void)memcpy_s(
91         &returnParam, sizeof(returnParam), param, (length > sizeof(returnParam)) ? sizeof(returnParam) : length);
92 
93     HciEventCallbacks *callbacks = NULL;
94     HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
95     if (callbacks->readAfhChannelMapComplete != NULL) {
96         callbacks->readAfhChannelMapComplete(&returnParam);
97     }
98     HCI_FOREACH_EVT_CALLBACKS_END;
99 }
100 
HciEventOnReadClockComplete(const void * param,uint8_t length)101 static void HciEventOnReadClockComplete(const void *param, uint8_t length)
102 {
103     HciReadClockReturnParam returnParam = {0};
104     (void)memcpy_s(
105         &returnParam, sizeof(returnParam), param, (length > sizeof(returnParam)) ? sizeof(returnParam) : length);
106 
107     HciEventCallbacks *callbacks = NULL;
108     HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
109     if (callbacks->readClockComplete != NULL) {
110         callbacks->readClockComplete(&returnParam);
111     }
112     HCI_FOREACH_EVT_CALLBACKS_END;
113 }
114 
HciEventOnReadEncryptionKeySizeComplete(const void * param,uint8_t length)115 static void HciEventOnReadEncryptionKeySizeComplete(const void *param, uint8_t length)
116 {
117     HciReadEncryptionKeySizeReturnParam returnParam = {0};
118     (void)memcpy_s(
119         &returnParam, sizeof(returnParam), param, (length > sizeof(returnParam)) ? sizeof(returnParam) : length);
120 
121     HciEventCallbacks *callbacks = NULL;
122     HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
123     if (callbacks->readEncryptionKeySizeComplete != NULL) {
124         callbacks->readEncryptionKeySizeComplete(&returnParam);
125     }
126     HCI_FOREACH_EVT_CALLBACKS_END;
127 }
128 
HciEventOnReadLocalAMPInfoComplete(const void * param,uint8_t length)129 static void HciEventOnReadLocalAMPInfoComplete(const void *param, uint8_t length)
130 {
131     HciReadLocalAMPInfoReturnParam returnParam = {0};
132     (void)memcpy_s(
133         &returnParam, sizeof(returnParam), param, (length > sizeof(returnParam)) ? sizeof(returnParam) : length);
134 
135     HciEventCallbacks *callbacks = NULL;
136     HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
137     if (callbacks->readLocalAmpInfoComplete != NULL) {
138         callbacks->readLocalAmpInfoComplete(&returnParam);
139     }
140     HCI_FOREACH_EVT_CALLBACKS_END;
141 }
142 
HciEventOnReadLocalAMPASSOCComplete(const void * param,uint8_t length)143 static void HciEventOnReadLocalAMPASSOCComplete(const void *param, uint8_t length)
144 {
145     HciReadLocalAmpAssocReturnParam returnParam = {0};
146     (void)memcpy_s(
147         &returnParam, sizeof(returnParam), param, (length > sizeof(returnParam)) ? sizeof(returnParam) : length);
148 
149     HciEventCallbacks *callbacks = NULL;
150     HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
151     if (callbacks->readLocalAmpAssocComplete != NULL) {
152         callbacks->readLocalAmpAssocComplete(&returnParam);
153     }
154     HCI_FOREACH_EVT_CALLBACKS_END;
155 }
156 
HciEventOnWriteRemoteAMPASSOCComplete(const void * param,uint8_t length)157 static void HciEventOnWriteRemoteAMPASSOCComplete(const void *param, uint8_t length)
158 {
159     HciWriteRemoteAmpAssocReturnParam returnParam = {0};
160     (void)memcpy_s(
161         &returnParam, sizeof(returnParam), param, (length > sizeof(returnParam)) ? sizeof(returnParam) : length);
162 
163     HciEventCallbacks *callbacks = NULL;
164     HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
165     if (callbacks->writeRemoteAmpAssocComplete != NULL) {
166         callbacks->writeRemoteAmpAssocComplete(&returnParam);
167     }
168     HCI_FOREACH_EVT_CALLBACKS_END;
169 }
170 
HciEventOnGetMWSTransportLayerConfigurationComplete(const void * param,uint8_t length)171 static void HciEventOnGetMWSTransportLayerConfigurationComplete(const void *param, uint8_t length)
172 {
173     HciGetMwsTransportLayerConfigurationReturnParam returnParam = {0};
174     (void)memcpy_s(
175         &returnParam, sizeof(returnParam), param, (length > sizeof(returnParam)) ? sizeof(returnParam) : length);
176 
177     HciEventCallbacks *callbacks = NULL;
178     HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
179     if (callbacks->getMwsTransportLayerConfigurationComplete != NULL) {
180         callbacks->getMwsTransportLayerConfigurationComplete(&returnParam);
181     }
182     HCI_FOREACH_EVT_CALLBACKS_END;
183 }
184 
HciEventOnSetTriggeredClockCaptureComplete(const void * param,uint8_t length)185 static void HciEventOnSetTriggeredClockCaptureComplete(const void *param, uint8_t length)
186 {
187     HciSetTriggeredClockCaptureReturnParam returnParam = {0};
188     (void)memcpy_s(
189         &returnParam, sizeof(returnParam), param, (length > sizeof(returnParam)) ? sizeof(returnParam) : length);
190 
191     HciEventCallbacks *callbacks = NULL;
192     HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
193     if (callbacks->setTriggeredClockCaptureComplete != NULL) {
194         callbacks->setTriggeredClockCaptureComplete(&returnParam);
195     }
196     HCI_FOREACH_EVT_CALLBACKS_END;
197 }
198 
199 static HciEventCommandCompleteFunc g_statusParametersCommandCompleteMap[] = {
200     NULL,                                                 // 0x0000
201     HciEventOnReadFailedContactCounterComplete,           // 0x0001
202     HciEventOnResetFailedContactCounterComplete,          // 0x0002
203     HciEventOnReadLinkQualityComplete,                    // 0x0003
204     NULL,                                                 // 0x0004
205     HciEventOnReadRssiComplete,                           // 0x0005
206     HciEventOnReadAFHChannelMapComplete,                  // 0x0006
207     HciEventOnReadClockComplete,                          // 0x0007
208     HciEventOnReadEncryptionKeySizeComplete,              // 0x0008
209     HciEventOnReadLocalAMPInfoComplete,                   // 0x0009
210     HciEventOnReadLocalAMPASSOCComplete,                  // 0x000A
211     HciEventOnWriteRemoteAMPASSOCComplete,                // 0x000B
212     HciEventOnGetMWSTransportLayerConfigurationComplete,  // 0x000C
213     HciEventOnSetTriggeredClockCaptureComplete,           // 0x000D
214 };
215 
216 #define STATUSPARAMETERS_OCF_MAX 0x000D
217 
HciEventOnStatusParametersCommandComplete(uint16_t opCode,const void * param,uint8_t length)218 void HciEventOnStatusParametersCommandComplete(uint16_t opCode, const void *param, uint8_t length)
219 {
220     uint16_t ocf = GET_OCF(opCode);
221     if (ocf > STATUSPARAMETERS_OCF_MAX) {
222         return;
223     }
224 
225     HciEventCommandCompleteFunc func = g_statusParametersCommandCompleteMap[ocf];
226     if (func != NULL) {
227         func(param, length);
228     }
229 }