iv123 lin / TARGET_ST_BLUENRG

ver:init

source/bluenrg-hci/hci/controller/bluenrg_gatt_aci.c@0:88b85febcb45, 2017-06-18 (annotated)

Committer:
iv123
Date:
Sun Jun 18 16:10:28 2017 +0000
Revision:
0:88b85febcb45
Initial commit

Who changed what in which revision?

UserRevisionLine numberNew contents of line
iv123 0:88b85febcb45 1 /******************** (C) COPYRIGHT 2014 STMicroelectronics ********************
iv123 0:88b85febcb45 2 * File Name : bluenrg_gatt_aci.c
iv123 0:88b85febcb45 3 * Author : AMS - AAS
iv123 0:88b85febcb45 4 * Version : V1.0.0
iv123 0:88b85febcb45 5 * Date : 26-Jun-2014
iv123 0:88b85febcb45 6 * Description : File with GATT commands for BlueNRG FW6.3.
iv123 0:88b85febcb45 7 ********************************************************************************
iv123 0:88b85febcb45 8 * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
iv123 0:88b85febcb45 9 * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE TIME.
iv123 0:88b85febcb45 10 * AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY DIRECT,
iv123 0:88b85febcb45 11 * INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING FROM THE
iv123 0:88b85febcb45 12 * CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE CODING
iv123 0:88b85febcb45 13 * INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
iv123 0:88b85febcb45 14 *******************************************************************************/
iv123 0:88b85febcb45 15
iv123 0:88b85febcb45 16 #include "ble_hal_types.h"
iv123 0:88b85febcb45 17 #include "ble_osal.h"
iv123 0:88b85febcb45 18 #include "ble_status.h"
iv123 0:88b85febcb45 19 #include "ble_hal.h"
iv123 0:88b85febcb45 20 #include "ble_hci_const.h"
iv123 0:88b85febcb45 21 #include "bluenrg_aci_const.h"
iv123 0:88b85febcb45 22 #include "bluenrg_gatt_aci.h"
iv123 0:88b85febcb45 23 #include "bluenrg_gatt_server.h"
iv123 0:88b85febcb45 24 #include "bluenrg_gap.h"
iv123 0:88b85febcb45 25
iv123 0:88b85febcb45 26 #define MIN(a,b) ((a) < (b) )? (a) : (b)
iv123 0:88b85febcb45 27 #define MAX(a,b) ((a) > (b) )? (a) : (b)
iv123 0:88b85febcb45 28
iv123 0:88b85febcb45 29
iv123 0:88b85febcb45 30 tBleStatus aci_gatt_init(void)
iv123 0:88b85febcb45 31 {
iv123 0:88b85febcb45 32 struct hci_request rq;
iv123 0:88b85febcb45 33 uint8_t status;
iv123 0:88b85febcb45 34
iv123 0:88b85febcb45 35 Osal_MemSet(&rq, 0, sizeof(rq));
iv123 0:88b85febcb45 36 rq.ogf = OGF_VENDOR_CMD;
iv123 0:88b85febcb45 37 rq.ocf = OCF_GATT_INIT;
iv123 0:88b85febcb45 38 rq.rparam = &status;
iv123 0:88b85febcb45 39 rq.rlen = 1;
iv123 0:88b85febcb45 40
iv123 0:88b85febcb45 41 if (hci_send_req(&rq, FALSE) < 0)
iv123 0:88b85febcb45 42 return BLE_STATUS_TIMEOUT;
iv123 0:88b85febcb45 43
iv123 0:88b85febcb45 44 return status;
iv123 0:88b85febcb45 45 }
iv123 0:88b85febcb45 46
iv123 0:88b85febcb45 47 tBleStatus aci_gatt_add_serv(uint8_t service_uuid_type, const uint8_t* service_uuid, uint8_t service_type, uint8_t max_attr_records, uint16_t *serviceHandle)
iv123 0:88b85febcb45 48 {
iv123 0:88b85febcb45 49 struct hci_request rq;
iv123 0:88b85febcb45 50 gatt_add_serv_rp resp;
iv123 0:88b85febcb45 51 uint8_t buffer[19];
iv123 0:88b85febcb45 52 uint8_t uuid_len;
iv123 0:88b85febcb45 53 uint8_t indx = 0;
iv123 0:88b85febcb45 54
iv123 0:88b85febcb45 55 buffer[indx] = service_uuid_type;
iv123 0:88b85febcb45 56 indx++;
iv123 0:88b85febcb45 57
iv123 0:88b85febcb45 58 if(service_uuid_type == UUID_TYPE_16){
iv123 0:88b85febcb45 59 uuid_len = 2;
iv123 0:88b85febcb45 60 }
iv123 0:88b85febcb45 61 else {
iv123 0:88b85febcb45 62 uuid_len = 16;
iv123 0:88b85febcb45 63 }
iv123 0:88b85febcb45 64 Osal_MemCpy(buffer + indx, service_uuid, uuid_len);
iv123 0:88b85febcb45 65 indx += uuid_len;
iv123 0:88b85febcb45 66
iv123 0:88b85febcb45 67 buffer[indx] = service_type;
iv123 0:88b85febcb45 68 indx++;
iv123 0:88b85febcb45 69
iv123 0:88b85febcb45 70 buffer[indx] = max_attr_records;
iv123 0:88b85febcb45 71 indx++;
iv123 0:88b85febcb45 72
iv123 0:88b85febcb45 73
iv123 0:88b85febcb45 74 Osal_MemSet(&resp, 0, sizeof(resp));
iv123 0:88b85febcb45 75
iv123 0:88b85febcb45 76 Osal_MemSet(&rq, 0, sizeof(rq));
iv123 0:88b85febcb45 77 rq.ogf = OGF_VENDOR_CMD;
iv123 0:88b85febcb45 78 rq.ocf = OCF_GATT_ADD_SERV;
iv123 0:88b85febcb45 79 rq.cparam = (void *)buffer;
iv123 0:88b85febcb45 80 rq.clen = indx;
iv123 0:88b85febcb45 81 rq.rparam = &resp;
iv123 0:88b85febcb45 82 rq.rlen = GATT_ADD_SERV_RP_SIZE;
iv123 0:88b85febcb45 83
iv123 0:88b85febcb45 84 if (hci_send_req(&rq, FALSE) < 0)
iv123 0:88b85febcb45 85 return BLE_STATUS_TIMEOUT;
iv123 0:88b85febcb45 86
iv123 0:88b85febcb45 87 if (resp.status) {
iv123 0:88b85febcb45 88 return resp.status;
iv123 0:88b85febcb45 89 }
iv123 0:88b85febcb45 90
iv123 0:88b85febcb45 91 *serviceHandle = btohs(resp.handle);
iv123 0:88b85febcb45 92
iv123 0:88b85febcb45 93 return 0;
iv123 0:88b85febcb45 94 }
iv123 0:88b85febcb45 95
iv123 0:88b85febcb45 96 tBleStatus aci_gatt_include_service(uint16_t service_handle, uint16_t included_start_handle,
iv123 0:88b85febcb45 97 uint16_t included_end_handle, uint8_t included_uuid_type,
iv123 0:88b85febcb45 98 const uint8_t* included_uuid, uint16_t *included_handle)
iv123 0:88b85febcb45 99 {
iv123 0:88b85febcb45 100 struct hci_request rq;
iv123 0:88b85febcb45 101 gatt_include_serv_rp resp;
iv123 0:88b85febcb45 102 uint8_t buffer[23];
iv123 0:88b85febcb45 103 uint8_t uuid_len;
iv123 0:88b85febcb45 104 uint8_t indx = 0;
iv123 0:88b85febcb45 105
iv123 0:88b85febcb45 106 service_handle = htobs(service_handle);
iv123 0:88b85febcb45 107 Osal_MemCpy(buffer, &service_handle, 2);
iv123 0:88b85febcb45 108 indx += 2;
iv123 0:88b85febcb45 109
iv123 0:88b85febcb45 110 included_start_handle = htobs(included_start_handle);
iv123 0:88b85febcb45 111 Osal_MemCpy(buffer+indx, &included_start_handle, 2);
iv123 0:88b85febcb45 112 indx += 2;
iv123 0:88b85febcb45 113
iv123 0:88b85febcb45 114 included_end_handle = htobs(included_end_handle);
iv123 0:88b85febcb45 115 Osal_MemCpy(buffer+indx, &included_end_handle, 2);
iv123 0:88b85febcb45 116 indx += 2;
iv123 0:88b85febcb45 117
iv123 0:88b85febcb45 118 if(included_uuid_type == UUID_TYPE_16){
iv123 0:88b85febcb45 119 uuid_len = 2;
iv123 0:88b85febcb45 120 } else {
iv123 0:88b85febcb45 121 uuid_len = 16;
iv123 0:88b85febcb45 122 }
iv123 0:88b85febcb45 123
iv123 0:88b85febcb45 124 buffer[indx] = included_uuid_type;
iv123 0:88b85febcb45 125 indx++;
iv123 0:88b85febcb45 126
iv123 0:88b85febcb45 127 Osal_MemCpy(buffer + indx, included_uuid, uuid_len);
iv123 0:88b85febcb45 128 indx += uuid_len;
iv123 0:88b85febcb45 129
iv123 0:88b85febcb45 130 Osal_MemSet(&resp, 0, sizeof(resp));
iv123 0:88b85febcb45 131
iv123 0:88b85febcb45 132 Osal_MemSet(&rq, 0, sizeof(rq));
iv123 0:88b85febcb45 133 rq.ogf = OGF_VENDOR_CMD;
iv123 0:88b85febcb45 134 rq.ocf = OCF_GATT_INCLUDE_SERV;
iv123 0:88b85febcb45 135 rq.cparam = (void *)buffer;
iv123 0:88b85febcb45 136 rq.clen = indx;
iv123 0:88b85febcb45 137 rq.rparam = &resp;
iv123 0:88b85febcb45 138 rq.rlen = GATT_INCLUDE_SERV_RP_SIZE;
iv123 0:88b85febcb45 139
iv123 0:88b85febcb45 140 if (hci_send_req(&rq, FALSE) < 0)
iv123 0:88b85febcb45 141 return BLE_STATUS_TIMEOUT;
iv123 0:88b85febcb45 142
iv123 0:88b85febcb45 143 if (resp.status) {
iv123 0:88b85febcb45 144 return resp.status;
iv123 0:88b85febcb45 145 }
iv123 0:88b85febcb45 146
iv123 0:88b85febcb45 147 *included_handle = btohs(resp.handle);
iv123 0:88b85febcb45 148
iv123 0:88b85febcb45 149 return 0;
iv123 0:88b85febcb45 150 }
iv123 0:88b85febcb45 151
iv123 0:88b85febcb45 152 tBleStatus aci_gatt_add_char(uint16_t serviceHandle,
iv123 0:88b85febcb45 153 uint8_t charUuidType,
iv123 0:88b85febcb45 154 const uint8_t* charUuid,
iv123 0:88b85febcb45 155 uint8_t charValueLen,
iv123 0:88b85febcb45 156 uint8_t charProperties,
iv123 0:88b85febcb45 157 uint8_t secPermissions,
iv123 0:88b85febcb45 158 uint8_t gattEvtMask,
iv123 0:88b85febcb45 159 uint8_t encryKeySize,
iv123 0:88b85febcb45 160 uint8_t isVariable,
iv123 0:88b85febcb45 161 uint16_t* charHandle)
iv123 0:88b85febcb45 162 {
iv123 0:88b85febcb45 163 struct hci_request rq;
iv123 0:88b85febcb45 164 gatt_add_serv_rp resp;
iv123 0:88b85febcb45 165 uint8_t buffer[25];
iv123 0:88b85febcb45 166 uint8_t uuid_len;
iv123 0:88b85febcb45 167 uint8_t indx = 0;
iv123 0:88b85febcb45 168
iv123 0:88b85febcb45 169 serviceHandle = htobs(serviceHandle);
iv123 0:88b85febcb45 170 Osal_MemCpy(buffer + indx, &serviceHandle, 2);
iv123 0:88b85febcb45 171 indx += 2;
iv123 0:88b85febcb45 172
iv123 0:88b85febcb45 173 buffer[indx] = charUuidType;
iv123 0:88b85febcb45 174 indx++;
iv123 0:88b85febcb45 175
iv123 0:88b85febcb45 176 if(charUuidType == UUID_TYPE_16){
iv123 0:88b85febcb45 177 uuid_len = 2;
iv123 0:88b85febcb45 178 }
iv123 0:88b85febcb45 179 else {
iv123 0:88b85febcb45 180 uuid_len = 16;
iv123 0:88b85febcb45 181 }
iv123 0:88b85febcb45 182 Osal_MemCpy(buffer + indx, charUuid, uuid_len);
iv123 0:88b85febcb45 183 indx += uuid_len;
iv123 0:88b85febcb45 184
iv123 0:88b85febcb45 185 buffer[indx] = charValueLen;
iv123 0:88b85febcb45 186 indx++;
iv123 0:88b85febcb45 187
iv123 0:88b85febcb45 188 buffer[indx] = charProperties;
iv123 0:88b85febcb45 189 indx++;
iv123 0:88b85febcb45 190
iv123 0:88b85febcb45 191 buffer[indx] = secPermissions;
iv123 0:88b85febcb45 192 indx++;
iv123 0:88b85febcb45 193
iv123 0:88b85febcb45 194 buffer[indx] = gattEvtMask;
iv123 0:88b85febcb45 195 indx++;
iv123 0:88b85febcb45 196
iv123 0:88b85febcb45 197 buffer[indx] = encryKeySize;
iv123 0:88b85febcb45 198 indx++;
iv123 0:88b85febcb45 199
iv123 0:88b85febcb45 200 buffer[indx] = isVariable;
iv123 0:88b85febcb45 201 indx++;
iv123 0:88b85febcb45 202
iv123 0:88b85febcb45 203 Osal_MemSet(&resp, 0, sizeof(resp));
iv123 0:88b85febcb45 204
iv123 0:88b85febcb45 205 Osal_MemSet(&rq, 0, sizeof(rq));
iv123 0:88b85febcb45 206 rq.ogf = OGF_VENDOR_CMD;
iv123 0:88b85febcb45 207 rq.ocf = OCF_GATT_ADD_CHAR;
iv123 0:88b85febcb45 208 rq.cparam = (void *)buffer;
iv123 0:88b85febcb45 209 rq.clen = indx;
iv123 0:88b85febcb45 210 rq.rparam = &resp;
iv123 0:88b85febcb45 211 rq.rlen = GATT_ADD_CHAR_RP_SIZE;
iv123 0:88b85febcb45 212
iv123 0:88b85febcb45 213 if (hci_send_req(&rq, FALSE) < 0)
iv123 0:88b85febcb45 214 return BLE_STATUS_TIMEOUT;
iv123 0:88b85febcb45 215
iv123 0:88b85febcb45 216 if (resp.status) {
iv123 0:88b85febcb45 217 return resp.status;
iv123 0:88b85febcb45 218 }
iv123 0:88b85febcb45 219
iv123 0:88b85febcb45 220 *charHandle = btohs(resp.handle);
iv123 0:88b85febcb45 221
iv123 0:88b85febcb45 222 return 0;
iv123 0:88b85febcb45 223 }
iv123 0:88b85febcb45 224
iv123 0:88b85febcb45 225 tBleStatus aci_gatt_add_char_desc(uint16_t serviceHandle,
iv123 0:88b85febcb45 226 uint16_t charHandle,
iv123 0:88b85febcb45 227 uint8_t descUuidType,
iv123 0:88b85febcb45 228 const uint8_t* uuid,
iv123 0:88b85febcb45 229 uint8_t descValueMaxLen,
iv123 0:88b85febcb45 230 uint8_t descValueLen,
iv123 0:88b85febcb45 231 const void* descValue,
iv123 0:88b85febcb45 232 uint8_t secPermissions,
iv123 0:88b85febcb45 233 uint8_t accPermissions,
iv123 0:88b85febcb45 234 uint8_t gattEvtMask,
iv123 0:88b85febcb45 235 uint8_t encryKeySize,
iv123 0:88b85febcb45 236 uint8_t isVariable,
iv123 0:88b85febcb45 237 uint16_t* descHandle)
iv123 0:88b85febcb45 238 {
iv123 0:88b85febcb45 239 struct hci_request rq;
iv123 0:88b85febcb45 240 gatt_add_char_desc_rp resp;
iv123 0:88b85febcb45 241 uint8_t buffer[HCI_MAX_PAYLOAD_SIZE];
iv123 0:88b85febcb45 242 uint8_t uuid_len;
iv123 0:88b85febcb45 243 uint8_t indx = 0;
iv123 0:88b85febcb45 244
iv123 0:88b85febcb45 245 serviceHandle = htobs(serviceHandle);
iv123 0:88b85febcb45 246 Osal_MemCpy(buffer + indx, &serviceHandle, 2);
iv123 0:88b85febcb45 247 indx += 2;
iv123 0:88b85febcb45 248
iv123 0:88b85febcb45 249 charHandle = htobs(charHandle);
iv123 0:88b85febcb45 250 Osal_MemCpy(buffer + indx, &charHandle, 2);
iv123 0:88b85febcb45 251 indx += 2;
iv123 0:88b85febcb45 252
iv123 0:88b85febcb45 253 buffer[indx] = descUuidType;
iv123 0:88b85febcb45 254 indx++;
iv123 0:88b85febcb45 255
iv123 0:88b85febcb45 256 if(descUuidType == UUID_TYPE_16){
iv123 0:88b85febcb45 257 uuid_len = 2;
iv123 0:88b85febcb45 258 }
iv123 0:88b85febcb45 259 else {
iv123 0:88b85febcb45 260 uuid_len = 16;
iv123 0:88b85febcb45 261 }
iv123 0:88b85febcb45 262 Osal_MemCpy(buffer + indx, uuid, uuid_len);
iv123 0:88b85febcb45 263 indx += uuid_len;
iv123 0:88b85febcb45 264
iv123 0:88b85febcb45 265 buffer[indx] = descValueMaxLen;
iv123 0:88b85febcb45 266 indx++;
iv123 0:88b85febcb45 267
iv123 0:88b85febcb45 268 buffer[indx] = descValueLen;
iv123 0:88b85febcb45 269 indx++;
iv123 0:88b85febcb45 270
iv123 0:88b85febcb45 271 if ((descValueLen+indx+5) > HCI_MAX_PAYLOAD_SIZE)
iv123 0:88b85febcb45 272 return BLE_STATUS_INVALID_PARAMS;
iv123 0:88b85febcb45 273
iv123 0:88b85febcb45 274 Osal_MemCpy(buffer + indx, descValue, descValueLen);
iv123 0:88b85febcb45 275 indx += descValueLen;
iv123 0:88b85febcb45 276
iv123 0:88b85febcb45 277 buffer[indx] = secPermissions;
iv123 0:88b85febcb45 278 indx++;
iv123 0:88b85febcb45 279
iv123 0:88b85febcb45 280 buffer[indx] = accPermissions;
iv123 0:88b85febcb45 281 indx++;
iv123 0:88b85febcb45 282
iv123 0:88b85febcb45 283 buffer[indx] = gattEvtMask;
iv123 0:88b85febcb45 284 indx++;
iv123 0:88b85febcb45 285
iv123 0:88b85febcb45 286 buffer[indx] = encryKeySize;
iv123 0:88b85febcb45 287 indx++;
iv123 0:88b85febcb45 288
iv123 0:88b85febcb45 289 buffer[indx] = isVariable;
iv123 0:88b85febcb45 290 indx++;
iv123 0:88b85febcb45 291
iv123 0:88b85febcb45 292 Osal_MemSet(&resp, 0, sizeof(resp));
iv123 0:88b85febcb45 293
iv123 0:88b85febcb45 294 Osal_MemSet(&rq, 0, sizeof(rq));
iv123 0:88b85febcb45 295 rq.ogf = OGF_VENDOR_CMD;
iv123 0:88b85febcb45 296 rq.ocf = OCF_GATT_ADD_CHAR_DESC;
iv123 0:88b85febcb45 297 rq.cparam = (void *)buffer;
iv123 0:88b85febcb45 298 rq.clen = indx;
iv123 0:88b85febcb45 299 rq.rparam = &resp;
iv123 0:88b85febcb45 300 rq.rlen = GATT_ADD_CHAR_DESC_RP_SIZE;
iv123 0:88b85febcb45 301
iv123 0:88b85febcb45 302 if (hci_send_req(&rq, FALSE) < 0)
iv123 0:88b85febcb45 303 return BLE_STATUS_TIMEOUT;
iv123 0:88b85febcb45 304
iv123 0:88b85febcb45 305 if (resp.status) {
iv123 0:88b85febcb45 306 return resp.status;
iv123 0:88b85febcb45 307 }
iv123 0:88b85febcb45 308
iv123 0:88b85febcb45 309 *descHandle = btohs(resp.handle);
iv123 0:88b85febcb45 310
iv123 0:88b85febcb45 311 return 0;
iv123 0:88b85febcb45 312 }
iv123 0:88b85febcb45 313
iv123 0:88b85febcb45 314
iv123 0:88b85febcb45 315 tBleStatus aci_gatt_update_char_value(uint16_t servHandle,
iv123 0:88b85febcb45 316 uint16_t charHandle,
iv123 0:88b85febcb45 317 uint8_t charValOffset,
iv123 0:88b85febcb45 318 uint8_t charValueLen,
iv123 0:88b85febcb45 319 const void *charValue)
iv123 0:88b85febcb45 320 {
iv123 0:88b85febcb45 321 struct hci_request rq;
iv123 0:88b85febcb45 322 uint8_t status;
iv123 0:88b85febcb45 323 uint8_t buffer[HCI_MAX_PAYLOAD_SIZE];
iv123 0:88b85febcb45 324 uint8_t indx = 0;
iv123 0:88b85febcb45 325
iv123 0:88b85febcb45 326 if ((charValueLen+6) > HCI_MAX_PAYLOAD_SIZE)
iv123 0:88b85febcb45 327 return BLE_STATUS_INVALID_PARAMS;
iv123 0:88b85febcb45 328
iv123 0:88b85febcb45 329 servHandle = htobs(servHandle);
iv123 0:88b85febcb45 330 Osal_MemCpy(buffer + indx, &servHandle, 2);
iv123 0:88b85febcb45 331 indx += 2;
iv123 0:88b85febcb45 332
iv123 0:88b85febcb45 333 charHandle = htobs(charHandle);
iv123 0:88b85febcb45 334 Osal_MemCpy(buffer + indx, &charHandle, 2);
iv123 0:88b85febcb45 335 indx += 2;
iv123 0:88b85febcb45 336
iv123 0:88b85febcb45 337 buffer[indx] = charValOffset;
iv123 0:88b85febcb45 338 indx++;
iv123 0:88b85febcb45 339
iv123 0:88b85febcb45 340 buffer[indx] = charValueLen;
iv123 0:88b85febcb45 341 indx++;
iv123 0:88b85febcb45 342
iv123 0:88b85febcb45 343 Osal_MemCpy(buffer + indx, charValue, charValueLen);
iv123 0:88b85febcb45 344 indx += charValueLen;
iv123 0:88b85febcb45 345
iv123 0:88b85febcb45 346 Osal_MemSet(&rq, 0, sizeof(rq));
iv123 0:88b85febcb45 347 rq.ogf = OGF_VENDOR_CMD;
iv123 0:88b85febcb45 348 rq.ocf = OCF_GATT_UPD_CHAR_VAL;
iv123 0:88b85febcb45 349 rq.cparam = (void *)buffer;
iv123 0:88b85febcb45 350 rq.clen = indx;
iv123 0:88b85febcb45 351 rq.rparam = &status;
iv123 0:88b85febcb45 352 rq.rlen = 1;
iv123 0:88b85febcb45 353
iv123 0:88b85febcb45 354 if (hci_send_req(&rq, FALSE) < 0)
iv123 0:88b85febcb45 355 return BLE_STATUS_TIMEOUT;
iv123 0:88b85febcb45 356
iv123 0:88b85febcb45 357 if (status) {
iv123 0:88b85febcb45 358 return status;
iv123 0:88b85febcb45 359 }
iv123 0:88b85febcb45 360
iv123 0:88b85febcb45 361 return 0;
iv123 0:88b85febcb45 362 }
iv123 0:88b85febcb45 363
iv123 0:88b85febcb45 364 tBleStatus aci_gatt_del_char(uint16_t servHandle, uint16_t charHandle)
iv123 0:88b85febcb45 365 {
iv123 0:88b85febcb45 366 struct hci_request rq;
iv123 0:88b85febcb45 367 uint8_t status;
iv123 0:88b85febcb45 368 gatt_del_char_cp cp;
iv123 0:88b85febcb45 369
iv123 0:88b85febcb45 370 cp.service_handle = htobs(servHandle);
iv123 0:88b85febcb45 371 cp.char_handle = htobs(charHandle);
iv123 0:88b85febcb45 372
iv123 0:88b85febcb45 373 Osal_MemSet(&rq, 0, sizeof(rq));
iv123 0:88b85febcb45 374 rq.ogf = OGF_VENDOR_CMD;
iv123 0:88b85febcb45 375 rq.ocf = OCF_GATT_DEL_CHAR;
iv123 0:88b85febcb45 376 rq.cparam = &cp;
iv123 0:88b85febcb45 377 rq.clen = GATT_DEL_CHAR_CP_SIZE;
iv123 0:88b85febcb45 378 rq.rparam = &status;
iv123 0:88b85febcb45 379 rq.rlen = 1;
iv123 0:88b85febcb45 380
iv123 0:88b85febcb45 381 if (hci_send_req(&rq, FALSE) < 0)
iv123 0:88b85febcb45 382 return BLE_STATUS_TIMEOUT;
iv123 0:88b85febcb45 383
iv123 0:88b85febcb45 384 return status;
iv123 0:88b85febcb45 385 }
iv123 0:88b85febcb45 386
iv123 0:88b85febcb45 387 tBleStatus aci_gatt_del_service(uint16_t servHandle)
iv123 0:88b85febcb45 388 {
iv123 0:88b85febcb45 389 struct hci_request rq;
iv123 0:88b85febcb45 390 uint8_t status;
iv123 0:88b85febcb45 391 gatt_del_serv_cp cp;
iv123 0:88b85febcb45 392
iv123 0:88b85febcb45 393 cp.service_handle = htobs(servHandle);
iv123 0:88b85febcb45 394
iv123 0:88b85febcb45 395 Osal_MemSet(&rq, 0, sizeof(rq));
iv123 0:88b85febcb45 396 rq.ogf = OGF_VENDOR_CMD;
iv123 0:88b85febcb45 397 rq.ocf = OCF_GATT_DEL_SERV;
iv123 0:88b85febcb45 398 rq.cparam = &cp;
iv123 0:88b85febcb45 399 rq.clen = GATT_DEL_SERV_CP_SIZE;
iv123 0:88b85febcb45 400 rq.rparam = &status;
iv123 0:88b85febcb45 401 rq.rlen = 1;
iv123 0:88b85febcb45 402
iv123 0:88b85febcb45 403 if (hci_send_req(&rq, FALSE) < 0)
iv123 0:88b85febcb45 404 return BLE_STATUS_TIMEOUT;
iv123 0:88b85febcb45 405
iv123 0:88b85febcb45 406 return status;
iv123 0:88b85febcb45 407 }
iv123 0:88b85febcb45 408
iv123 0:88b85febcb45 409 tBleStatus aci_gatt_del_include_service(uint16_t servHandle, uint16_t includeServHandle)
iv123 0:88b85febcb45 410 {
iv123 0:88b85febcb45 411 struct hci_request rq;
iv123 0:88b85febcb45 412 uint8_t status;
iv123 0:88b85febcb45 413 gatt_del_inc_serv_cp cp;
iv123 0:88b85febcb45 414
iv123 0:88b85febcb45 415 cp.service_handle = htobs(servHandle);
iv123 0:88b85febcb45 416 cp.inc_serv_handle = htobs(includeServHandle);
iv123 0:88b85febcb45 417
iv123 0:88b85febcb45 418 Osal_MemSet(&rq, 0, sizeof(rq));
iv123 0:88b85febcb45 419 rq.ogf = OGF_VENDOR_CMD;
iv123 0:88b85febcb45 420 rq.ocf = OCF_GATT_DEL_INC_SERV;
iv123 0:88b85febcb45 421 rq.cparam = &cp;
iv123 0:88b85febcb45 422 rq.clen = GATT_DEL_INC_SERV_CP_SIZE;
iv123 0:88b85febcb45 423 rq.rparam = &status;
iv123 0:88b85febcb45 424 rq.rlen = 1;
iv123 0:88b85febcb45 425
iv123 0:88b85febcb45 426 if (hci_send_req(&rq, FALSE) < 0)
iv123 0:88b85febcb45 427 return BLE_STATUS_TIMEOUT;
iv123 0:88b85febcb45 428
iv123 0:88b85febcb45 429 return status;
iv123 0:88b85febcb45 430 }
iv123 0:88b85febcb45 431
iv123 0:88b85febcb45 432 tBleStatus aci_gatt_set_event_mask(uint32_t event_mask)
iv123 0:88b85febcb45 433 {
iv123 0:88b85febcb45 434 struct hci_request rq;
iv123 0:88b85febcb45 435 uint8_t status;
iv123 0:88b85febcb45 436 gatt_set_evt_mask_cp cp;
iv123 0:88b85febcb45 437
iv123 0:88b85febcb45 438 cp.evt_mask = htobs(event_mask);
iv123 0:88b85febcb45 439
iv123 0:88b85febcb45 440 Osal_MemSet(&rq, 0, sizeof(rq));
iv123 0:88b85febcb45 441 rq.ogf = OGF_VENDOR_CMD;
iv123 0:88b85febcb45 442 rq.ocf = OCF_GATT_SET_EVT_MASK;
iv123 0:88b85febcb45 443 rq.cparam = &cp;
iv123 0:88b85febcb45 444 rq.clen = GATT_SET_EVT_MASK_CP_SIZE;
iv123 0:88b85febcb45 445 rq.rparam = &status;
iv123 0:88b85febcb45 446 rq.rlen = 1;
iv123 0:88b85febcb45 447
iv123 0:88b85febcb45 448 if (hci_send_req(&rq, FALSE) < 0)
iv123 0:88b85febcb45 449 return BLE_STATUS_TIMEOUT;
iv123 0:88b85febcb45 450
iv123 0:88b85febcb45 451 return status;
iv123 0:88b85febcb45 452 }
iv123 0:88b85febcb45 453
iv123 0:88b85febcb45 454 tBleStatus aci_gatt_exchange_configuration(uint16_t conn_handle)
iv123 0:88b85febcb45 455 {
iv123 0:88b85febcb45 456 struct hci_request rq;
iv123 0:88b85febcb45 457 uint8_t status;
iv123 0:88b85febcb45 458 gatt_exchange_config_cp cp;
iv123 0:88b85febcb45 459
iv123 0:88b85febcb45 460 cp.conn_handle = htobs(conn_handle);
iv123 0:88b85febcb45 461
iv123 0:88b85febcb45 462 Osal_MemSet(&rq, 0, sizeof(rq));
iv123 0:88b85febcb45 463 rq.ogf = OGF_VENDOR_CMD;
iv123 0:88b85febcb45 464 rq.ocf = OCF_GATT_EXCHANGE_CONFIG;
iv123 0:88b85febcb45 465 rq.cparam = &cp;
iv123 0:88b85febcb45 466 rq.clen = GATT_EXCHANGE_CONFIG_CP_SIZE;
iv123 0:88b85febcb45 467 rq.event = EVT_CMD_STATUS;
iv123 0:88b85febcb45 468 rq.rparam = &status;
iv123 0:88b85febcb45 469 rq.rlen = 1;
iv123 0:88b85febcb45 470
iv123 0:88b85febcb45 471 if (hci_send_req(&rq, FALSE) < 0)
iv123 0:88b85febcb45 472 return BLE_STATUS_TIMEOUT;
iv123 0:88b85febcb45 473
iv123 0:88b85febcb45 474 return status;
iv123 0:88b85febcb45 475 }
iv123 0:88b85febcb45 476
iv123 0:88b85febcb45 477 tBleStatus aci_att_find_information_req(uint16_t conn_handle, uint16_t start_handle, uint16_t end_handle)
iv123 0:88b85febcb45 478 {
iv123 0:88b85febcb45 479 struct hci_request rq;
iv123 0:88b85febcb45 480 uint8_t status;
iv123 0:88b85febcb45 481 att_find_info_req_cp cp;
iv123 0:88b85febcb45 482
iv123 0:88b85febcb45 483 cp.conn_handle = htobs(conn_handle);
iv123 0:88b85febcb45 484 cp.start_handle = htobs(start_handle);
iv123 0:88b85febcb45 485 cp.end_handle = htobs(end_handle);
iv123 0:88b85febcb45 486
iv123 0:88b85febcb45 487 Osal_MemSet(&rq, 0, sizeof(rq));
iv123 0:88b85febcb45 488 rq.ogf = OGF_VENDOR_CMD;
iv123 0:88b85febcb45 489 rq.ocf = OCF_ATT_FIND_INFO_REQ;
iv123 0:88b85febcb45 490 rq.cparam = &cp;
iv123 0:88b85febcb45 491 rq.clen = ATT_FIND_INFO_REQ_CP_SIZE;
iv123 0:88b85febcb45 492 rq.rparam = &status;
iv123 0:88b85febcb45 493 rq.rlen = 1;
iv123 0:88b85febcb45 494
iv123 0:88b85febcb45 495 if (hci_send_req(&rq, FALSE) < 0)
iv123 0:88b85febcb45 496 return BLE_STATUS_TIMEOUT;
iv123 0:88b85febcb45 497
iv123 0:88b85febcb45 498 return status;
iv123 0:88b85febcb45 499 }
iv123 0:88b85febcb45 500
iv123 0:88b85febcb45 501 tBleStatus aci_att_find_by_type_value_req(uint16_t conn_handle, uint16_t start_handle, uint16_t end_handle,
iv123 0:88b85febcb45 502 uint8_t* uuid, uint8_t attr_val_len, uint8_t* attr_val)
iv123 0:88b85febcb45 503 {
iv123 0:88b85febcb45 504 struct hci_request rq;
iv123 0:88b85febcb45 505 uint8_t status;
iv123 0:88b85febcb45 506 att_find_by_type_value_req_cp cp;
iv123 0:88b85febcb45 507
iv123 0:88b85febcb45 508 if(attr_val_len > sizeof(cp.attr_val))
iv123 0:88b85febcb45 509 return BLE_STATUS_INVALID_PARAMS;
iv123 0:88b85febcb45 510
iv123 0:88b85febcb45 511 cp.conn_handle = htobs(conn_handle);
iv123 0:88b85febcb45 512 cp.start_handle = htobs(start_handle);
iv123 0:88b85febcb45 513 cp.end_handle = htobs(end_handle);
iv123 0:88b85febcb45 514 Osal_MemCpy(cp.uuid, uuid, 2);
iv123 0:88b85febcb45 515 cp.attr_val_len = attr_val_len;
iv123 0:88b85febcb45 516 Osal_MemCpy(cp.attr_val, attr_val, attr_val_len);
iv123 0:88b85febcb45 517
iv123 0:88b85febcb45 518 Osal_MemSet(&rq, 0, sizeof(rq));
iv123 0:88b85febcb45 519 rq.ogf = OGF_VENDOR_CMD;
iv123 0:88b85febcb45 520 rq.ocf = OCF_ATT_FIND_BY_TYPE_VALUE_REQ;
iv123 0:88b85febcb45 521 rq.cparam = &cp;
iv123 0:88b85febcb45 522 rq.clen = ATT_FIND_BY_TYPE_VALUE_REQ_CP_SIZE + attr_val_len;
iv123 0:88b85febcb45 523 rq.rparam = &status;
iv123 0:88b85febcb45 524 rq.rlen = 1;
iv123 0:88b85febcb45 525
iv123 0:88b85febcb45 526 if (hci_send_req(&rq, FALSE) < 0)
iv123 0:88b85febcb45 527 return BLE_STATUS_TIMEOUT;
iv123 0:88b85febcb45 528
iv123 0:88b85febcb45 529 return status;
iv123 0:88b85febcb45 530 }
iv123 0:88b85febcb45 531
iv123 0:88b85febcb45 532 tBleStatus aci_att_read_by_type_req(uint16_t conn_handle, uint16_t start_handle, uint16_t end_handle,
iv123 0:88b85febcb45 533 uint8_t uuid_type, uint8_t* uuid)
iv123 0:88b85febcb45 534 {
iv123 0:88b85febcb45 535 struct hci_request rq;
iv123 0:88b85febcb45 536 uint8_t status;
iv123 0:88b85febcb45 537 att_read_by_type_req_cp cp;
iv123 0:88b85febcb45 538 uint8_t uuid_len;
iv123 0:88b85febcb45 539
iv123 0:88b85febcb45 540 if(uuid_type == UUID_TYPE_16){
iv123 0:88b85febcb45 541 uuid_len = 2;
iv123 0:88b85febcb45 542 }
iv123 0:88b85febcb45 543 else{
iv123 0:88b85febcb45 544 uuid_len = 16;
iv123 0:88b85febcb45 545 }
iv123 0:88b85febcb45 546
iv123 0:88b85febcb45 547 cp.conn_handle = htobs(conn_handle);
iv123 0:88b85febcb45 548 cp.start_handle = htobs(start_handle);
iv123 0:88b85febcb45 549 cp.end_handle = htobs(end_handle);
iv123 0:88b85febcb45 550 cp.uuid_type = uuid_type;
iv123 0:88b85febcb45 551 Osal_MemCpy(cp.uuid, uuid, uuid_len);
iv123 0:88b85febcb45 552
iv123 0:88b85febcb45 553 Osal_MemSet(&rq, 0, sizeof(rq));
iv123 0:88b85febcb45 554 rq.ogf = OGF_VENDOR_CMD;
iv123 0:88b85febcb45 555 rq.ocf = OCF_ATT_READ_BY_TYPE_REQ;
iv123 0:88b85febcb45 556 rq.cparam = &cp;
iv123 0:88b85febcb45 557 rq.clen = ATT_READ_BY_TYPE_REQ_CP_SIZE + uuid_len;
iv123 0:88b85febcb45 558 rq.rparam = &status;
iv123 0:88b85febcb45 559 rq.rlen = 1;
iv123 0:88b85febcb45 560
iv123 0:88b85febcb45 561 if (hci_send_req(&rq, FALSE) < 0)
iv123 0:88b85febcb45 562 return BLE_STATUS_TIMEOUT;
iv123 0:88b85febcb45 563
iv123 0:88b85febcb45 564 return status;
iv123 0:88b85febcb45 565 }
iv123 0:88b85febcb45 566
iv123 0:88b85febcb45 567 tBleStatus aci_att_read_by_group_type_req(uint16_t conn_handle, uint16_t start_handle, uint16_t end_handle,
iv123 0:88b85febcb45 568 uint8_t uuid_type, uint8_t* uuid)
iv123 0:88b85febcb45 569 {
iv123 0:88b85febcb45 570 struct hci_request rq;
iv123 0:88b85febcb45 571 uint8_t status;
iv123 0:88b85febcb45 572 att_read_by_group_type_req_cp cp;
iv123 0:88b85febcb45 573 uint8_t uuid_len;
iv123 0:88b85febcb45 574
iv123 0:88b85febcb45 575 if(uuid_type == UUID_TYPE_16){
iv123 0:88b85febcb45 576 uuid_len = 2;
iv123 0:88b85febcb45 577 }
iv123 0:88b85febcb45 578 else{
iv123 0:88b85febcb45 579 uuid_len = 16;
iv123 0:88b85febcb45 580 }
iv123 0:88b85febcb45 581
iv123 0:88b85febcb45 582 cp.conn_handle = htobs(conn_handle);
iv123 0:88b85febcb45 583 cp.start_handle = htobs(start_handle);
iv123 0:88b85febcb45 584 cp.end_handle = htobs(end_handle);
iv123 0:88b85febcb45 585 cp.uuid_type = uuid_type;
iv123 0:88b85febcb45 586 Osal_MemCpy(cp.uuid, uuid, uuid_len);
iv123 0:88b85febcb45 587
iv123 0:88b85febcb45 588 Osal_MemSet(&rq, 0, sizeof(rq));
iv123 0:88b85febcb45 589 rq.ogf = OGF_VENDOR_CMD;
iv123 0:88b85febcb45 590 rq.ocf = OCF_ATT_READ_BY_GROUP_TYPE_REQ;
iv123 0:88b85febcb45 591 rq.cparam = &cp;
iv123 0:88b85febcb45 592 rq.clen = ATT_READ_BY_GROUP_TYPE_REQ_CP_SIZE + uuid_len;
iv123 0:88b85febcb45 593 rq.rparam = &status;
iv123 0:88b85febcb45 594 rq.rlen = 1;
iv123 0:88b85febcb45 595
iv123 0:88b85febcb45 596 if (hci_send_req(&rq, FALSE) < 0)
iv123 0:88b85febcb45 597 return BLE_STATUS_TIMEOUT;
iv123 0:88b85febcb45 598
iv123 0:88b85febcb45 599 return status;
iv123 0:88b85febcb45 600 }
iv123 0:88b85febcb45 601
iv123 0:88b85febcb45 602 tBleStatus aci_att_prepare_write_req(uint16_t conn_handle, uint16_t attr_handle, uint16_t value_offset,
iv123 0:88b85febcb45 603 uint8_t attr_val_len, uint8_t* attr_val)
iv123 0:88b85febcb45 604 {
iv123 0:88b85febcb45 605 struct hci_request rq;
iv123 0:88b85febcb45 606 uint8_t status;
iv123 0:88b85febcb45 607 att_prepare_write_req_cp cp;
iv123 0:88b85febcb45 608
iv123 0:88b85febcb45 609 if(attr_val_len > sizeof(cp.attr_val))
iv123 0:88b85febcb45 610 return BLE_STATUS_INVALID_PARAMS;
iv123 0:88b85febcb45 611
iv123 0:88b85febcb45 612 cp.conn_handle = htobs(conn_handle);
iv123 0:88b85febcb45 613 cp.attr_handle = htobs(attr_handle);
iv123 0:88b85febcb45 614 cp.value_offset = htobs(value_offset);
iv123 0:88b85febcb45 615 cp.attr_val_len = attr_val_len;
iv123 0:88b85febcb45 616 Osal_MemCpy(cp.attr_val, attr_val, attr_val_len);
iv123 0:88b85febcb45 617
iv123 0:88b85febcb45 618 Osal_MemSet(&rq, 0, sizeof(rq));
iv123 0:88b85febcb45 619 rq.ogf = OGF_VENDOR_CMD;
iv123 0:88b85febcb45 620 rq.ocf = OCF_ATT_PREPARE_WRITE_REQ;
iv123 0:88b85febcb45 621 rq.cparam = &cp;
iv123 0:88b85febcb45 622 rq.clen = ATT_PREPARE_WRITE_REQ_CP_SIZE + attr_val_len;
iv123 0:88b85febcb45 623 rq.rparam = &status;
iv123 0:88b85febcb45 624 rq.rlen = 1;
iv123 0:88b85febcb45 625
iv123 0:88b85febcb45 626 if (hci_send_req(&rq, FALSE) < 0)
iv123 0:88b85febcb45 627 return BLE_STATUS_TIMEOUT;
iv123 0:88b85febcb45 628
iv123 0:88b85febcb45 629 return status;
iv123 0:88b85febcb45 630 }
iv123 0:88b85febcb45 631
iv123 0:88b85febcb45 632 tBleStatus aci_att_execute_write_req(uint16_t conn_handle, uint8_t execute)
iv123 0:88b85febcb45 633 {
iv123 0:88b85febcb45 634 struct hci_request rq;
iv123 0:88b85febcb45 635 uint8_t status;
iv123 0:88b85febcb45 636 att_execute_write_req_cp cp;
iv123 0:88b85febcb45 637
iv123 0:88b85febcb45 638 cp.conn_handle = htobs(conn_handle);
iv123 0:88b85febcb45 639 cp.execute = execute;
iv123 0:88b85febcb45 640
iv123 0:88b85febcb45 641 Osal_MemSet(&rq, 0, sizeof(rq));
iv123 0:88b85febcb45 642 rq.ogf = OGF_VENDOR_CMD;
iv123 0:88b85febcb45 643 rq.ocf = OCF_ATT_EXECUTE_WRITE_REQ;
iv123 0:88b85febcb45 644 rq.cparam = &cp;
iv123 0:88b85febcb45 645 rq.clen = ATT_EXECUTE_WRITE_REQ_CP_SIZE;
iv123 0:88b85febcb45 646 rq.rparam = &status;
iv123 0:88b85febcb45 647 rq.rlen = 1;
iv123 0:88b85febcb45 648
iv123 0:88b85febcb45 649 if (hci_send_req(&rq, FALSE) < 0)
iv123 0:88b85febcb45 650 return BLE_STATUS_TIMEOUT;
iv123 0:88b85febcb45 651
iv123 0:88b85febcb45 652 return status;
iv123 0:88b85febcb45 653 }
iv123 0:88b85febcb45 654
iv123 0:88b85febcb45 655 tBleStatus aci_gatt_disc_all_prim_services(uint16_t conn_handle)
iv123 0:88b85febcb45 656 {
iv123 0:88b85febcb45 657 struct hci_request rq;
iv123 0:88b85febcb45 658 uint8_t status;
iv123 0:88b85febcb45 659 gatt_disc_all_prim_services_cp cp;
iv123 0:88b85febcb45 660
iv123 0:88b85febcb45 661 cp.conn_handle = htobs(conn_handle);
iv123 0:88b85febcb45 662
iv123 0:88b85febcb45 663 Osal_MemSet(&rq, 0, sizeof(rq));
iv123 0:88b85febcb45 664 rq.ogf = OGF_VENDOR_CMD;
iv123 0:88b85febcb45 665 rq.ocf = OCF_GATT_DISC_ALL_PRIM_SERVICES;
iv123 0:88b85febcb45 666 rq.cparam = &cp;
iv123 0:88b85febcb45 667 rq.clen = GATT_DISC_ALL_PRIM_SERVICES_CP_SIZE;
iv123 0:88b85febcb45 668 rq.event = EVT_CMD_STATUS;
iv123 0:88b85febcb45 669 rq.rparam = &status;
iv123 0:88b85febcb45 670 rq.rlen = 1;
iv123 0:88b85febcb45 671
iv123 0:88b85febcb45 672 if (hci_send_req(&rq, FALSE) < 0)
iv123 0:88b85febcb45 673 return BLE_STATUS_TIMEOUT;
iv123 0:88b85febcb45 674
iv123 0:88b85febcb45 675 return status;
iv123 0:88b85febcb45 676 }
iv123 0:88b85febcb45 677
iv123 0:88b85febcb45 678 tBleStatus aci_gatt_disc_prim_service_by_uuid(uint16_t conn_handle, uint8_t uuid_type, uint8_t* uuid)
iv123 0:88b85febcb45 679 {
iv123 0:88b85febcb45 680 struct hci_request rq;
iv123 0:88b85febcb45 681 uint8_t status;
iv123 0:88b85febcb45 682 gatt_disc_prim_service_by_uuid_cp cp;
iv123 0:88b85febcb45 683 uint8_t uuid_len;
iv123 0:88b85febcb45 684
iv123 0:88b85febcb45 685 if(uuid_type == UUID_TYPE_16){
iv123 0:88b85febcb45 686 uuid_len = 2;
iv123 0:88b85febcb45 687 }
iv123 0:88b85febcb45 688 else{
iv123 0:88b85febcb45 689 uuid_len = 16;
iv123 0:88b85febcb45 690 }
iv123 0:88b85febcb45 691
iv123 0:88b85febcb45 692 cp.conn_handle = htobs(conn_handle);
iv123 0:88b85febcb45 693 cp.uuid_type = uuid_type;
iv123 0:88b85febcb45 694 Osal_MemCpy(cp.uuid, uuid, uuid_len);
iv123 0:88b85febcb45 695
iv123 0:88b85febcb45 696 Osal_MemSet(&rq, 0, sizeof(rq));
iv123 0:88b85febcb45 697 rq.ogf = OGF_VENDOR_CMD;
iv123 0:88b85febcb45 698 rq.ocf = OCF_GATT_DISC_PRIM_SERVICE_BY_UUID;
iv123 0:88b85febcb45 699 rq.cparam = &cp;
iv123 0:88b85febcb45 700 rq.clen = GATT_DISC_PRIM_SERVICE_BY_UUID_CP_SIZE + uuid_len;
iv123 0:88b85febcb45 701 rq.event = EVT_CMD_STATUS;
iv123 0:88b85febcb45 702 rq.rparam = &status;
iv123 0:88b85febcb45 703 rq.rlen = 1;
iv123 0:88b85febcb45 704
iv123 0:88b85febcb45 705 if (hci_send_req(&rq, FALSE) < 0)
iv123 0:88b85febcb45 706 return BLE_STATUS_TIMEOUT;
iv123 0:88b85febcb45 707
iv123 0:88b85febcb45 708 return status;
iv123 0:88b85febcb45 709 }
iv123 0:88b85febcb45 710
iv123 0:88b85febcb45 711 tBleStatus aci_gatt_find_included_services(uint16_t conn_handle, uint16_t start_service_handle,
iv123 0:88b85febcb45 712 uint16_t end_service_handle)
iv123 0:88b85febcb45 713 {
iv123 0:88b85febcb45 714 struct hci_request rq;
iv123 0:88b85febcb45 715 uint8_t status;
iv123 0:88b85febcb45 716 gatt_find_included_services_cp cp;
iv123 0:88b85febcb45 717
iv123 0:88b85febcb45 718 cp.conn_handle = htobs(conn_handle);
iv123 0:88b85febcb45 719 cp.start_handle = htobs(start_service_handle);
iv123 0:88b85febcb45 720 cp.end_handle = htobs(end_service_handle);
iv123 0:88b85febcb45 721
iv123 0:88b85febcb45 722 Osal_MemSet(&rq, 0, sizeof(rq));
iv123 0:88b85febcb45 723 rq.ogf = OGF_VENDOR_CMD;
iv123 0:88b85febcb45 724 rq.ocf = OCF_GATT_FIND_INCLUDED_SERVICES;
iv123 0:88b85febcb45 725 rq.cparam = &cp;
iv123 0:88b85febcb45 726 rq.clen = GATT_FIND_INCLUDED_SERVICES_CP_SIZE;
iv123 0:88b85febcb45 727 rq.event = EVT_CMD_STATUS;
iv123 0:88b85febcb45 728 rq.rparam = &status;
iv123 0:88b85febcb45 729 rq.rlen = 1;
iv123 0:88b85febcb45 730
iv123 0:88b85febcb45 731 if (hci_send_req(&rq, FALSE) < 0)
iv123 0:88b85febcb45 732 return BLE_STATUS_TIMEOUT;
iv123 0:88b85febcb45 733
iv123 0:88b85febcb45 734 return status;
iv123 0:88b85febcb45 735 }
iv123 0:88b85febcb45 736
iv123 0:88b85febcb45 737 tBleStatus aci_gatt_disc_all_charac_of_serv(uint16_t conn_handle, uint16_t start_attr_handle,
iv123 0:88b85febcb45 738 uint16_t end_attr_handle)
iv123 0:88b85febcb45 739 {
iv123 0:88b85febcb45 740 struct hci_request rq;
iv123 0:88b85febcb45 741 uint8_t status;
iv123 0:88b85febcb45 742 gatt_disc_all_charac_of_serv_cp cp;
iv123 0:88b85febcb45 743
iv123 0:88b85febcb45 744 cp.conn_handle = htobs(conn_handle);
iv123 0:88b85febcb45 745 cp.start_attr_handle = htobs(start_attr_handle);
iv123 0:88b85febcb45 746 cp.end_attr_handle = htobs(end_attr_handle);
iv123 0:88b85febcb45 747
iv123 0:88b85febcb45 748 Osal_MemSet(&rq, 0, sizeof(rq));
iv123 0:88b85febcb45 749 rq.ogf = OGF_VENDOR_CMD;
iv123 0:88b85febcb45 750 rq.ocf = OCF_GATT_DISC_ALL_CHARAC_OF_SERV;
iv123 0:88b85febcb45 751 rq.cparam = &cp;
iv123 0:88b85febcb45 752 rq.clen = GATT_DISC_ALL_CHARAC_OF_SERV_CP_SIZE;
iv123 0:88b85febcb45 753 rq.event = EVT_CMD_STATUS;
iv123 0:88b85febcb45 754 rq.rparam = &status;
iv123 0:88b85febcb45 755 rq.rlen = 1;
iv123 0:88b85febcb45 756
iv123 0:88b85febcb45 757 if (hci_send_req(&rq, FALSE) < 0)
iv123 0:88b85febcb45 758 return BLE_STATUS_TIMEOUT;
iv123 0:88b85febcb45 759
iv123 0:88b85febcb45 760 return status;
iv123 0:88b85febcb45 761 }
iv123 0:88b85febcb45 762
iv123 0:88b85febcb45 763 tBleStatus aci_gatt_disc_charac_by_uuid(uint16_t conn_handle, uint16_t start_handle,
iv123 0:88b85febcb45 764 uint16_t end_handle, uint8_t charUuidType,
iv123 0:88b85febcb45 765 const uint8_t* charUuid)
iv123 0:88b85febcb45 766 {
iv123 0:88b85febcb45 767 struct hci_request rq;
iv123 0:88b85febcb45 768 uint8_t status;
iv123 0:88b85febcb45 769
iv123 0:88b85febcb45 770 uint8_t buffer[23];
iv123 0:88b85febcb45 771 uint8_t uuid_len;
iv123 0:88b85febcb45 772 uint8_t indx = 0;
iv123 0:88b85febcb45 773
iv123 0:88b85febcb45 774 conn_handle = htobs(conn_handle);
iv123 0:88b85febcb45 775 Osal_MemCpy(buffer + indx, &conn_handle, 2);
iv123 0:88b85febcb45 776 indx += 2;
iv123 0:88b85febcb45 777
iv123 0:88b85febcb45 778 start_handle = htobs(start_handle);
iv123 0:88b85febcb45 779 Osal_MemCpy(buffer + indx, &start_handle, 2);
iv123 0:88b85febcb45 780 indx += 2;
iv123 0:88b85febcb45 781
iv123 0:88b85febcb45 782 end_handle = htobs(end_handle);
iv123 0:88b85febcb45 783 Osal_MemCpy(buffer + indx, &end_handle, 2);
iv123 0:88b85febcb45 784 indx += 2;
iv123 0:88b85febcb45 785
iv123 0:88b85febcb45 786 buffer[indx] = charUuidType;
iv123 0:88b85febcb45 787 indx++;
iv123 0:88b85febcb45 788
iv123 0:88b85febcb45 789 if(charUuidType == 0x01){
iv123 0:88b85febcb45 790 uuid_len = 2;
iv123 0:88b85febcb45 791 }
iv123 0:88b85febcb45 792 else {
iv123 0:88b85febcb45 793 uuid_len = 16;
iv123 0:88b85febcb45 794 }
iv123 0:88b85febcb45 795 Osal_MemCpy(buffer + indx, charUuid, uuid_len);
iv123 0:88b85febcb45 796 indx += uuid_len;
iv123 0:88b85febcb45 797
iv123 0:88b85febcb45 798 Osal_MemSet(&rq, 0, sizeof(rq));
iv123 0:88b85febcb45 799 rq.ogf = OGF_VENDOR_CMD;
iv123 0:88b85febcb45 800 rq.ocf = OCF_GATT_DISC_CHARAC_BY_UUID;
iv123 0:88b85febcb45 801 rq.cparam = (void *)buffer;
iv123 0:88b85febcb45 802 rq.clen = indx;
iv123 0:88b85febcb45 803 rq.event = EVT_CMD_STATUS;
iv123 0:88b85febcb45 804 rq.rparam = &status;
iv123 0:88b85febcb45 805 rq.rlen = 1;
iv123 0:88b85febcb45 806
iv123 0:88b85febcb45 807 if (hci_send_req(&rq, FALSE) < 0)
iv123 0:88b85febcb45 808 return BLE_STATUS_TIMEOUT;
iv123 0:88b85febcb45 809
iv123 0:88b85febcb45 810 return status;
iv123 0:88b85febcb45 811 }
iv123 0:88b85febcb45 812
iv123 0:88b85febcb45 813 tBleStatus aci_gatt_disc_all_charac_descriptors(uint16_t conn_handle, uint16_t char_val_handle,
iv123 0:88b85febcb45 814 uint16_t char_end_handle)
iv123 0:88b85febcb45 815 {
iv123 0:88b85febcb45 816 struct hci_request rq;
iv123 0:88b85febcb45 817 uint8_t status;
iv123 0:88b85febcb45 818 gatt_disc_all_charac_descriptors_cp cp;
iv123 0:88b85febcb45 819
iv123 0:88b85febcb45 820 cp.conn_handle = htobs(conn_handle);
iv123 0:88b85febcb45 821 cp.char_val_handle = htobs(char_val_handle);
iv123 0:88b85febcb45 822 cp.char_end_handle = htobs(char_end_handle);
iv123 0:88b85febcb45 823
iv123 0:88b85febcb45 824 Osal_MemSet(&rq, 0, sizeof(rq));
iv123 0:88b85febcb45 825 rq.ogf = OGF_VENDOR_CMD;
iv123 0:88b85febcb45 826 rq.ocf = OCF_GATT_DISC_ALL_CHARAC_DESCRIPTORS;
iv123 0:88b85febcb45 827 rq.cparam = &cp;
iv123 0:88b85febcb45 828 rq.clen = GATT_DISC_ALL_CHARAC_DESCRIPTORS_CP_SIZE;
iv123 0:88b85febcb45 829 rq.event = EVT_CMD_STATUS;
iv123 0:88b85febcb45 830 rq.rparam = &status;
iv123 0:88b85febcb45 831 rq.rlen = 1;
iv123 0:88b85febcb45 832
iv123 0:88b85febcb45 833 if (hci_send_req(&rq, FALSE) < 0)
iv123 0:88b85febcb45 834 return BLE_STATUS_TIMEOUT;
iv123 0:88b85febcb45 835
iv123 0:88b85febcb45 836 return status;
iv123 0:88b85febcb45 837 }
iv123 0:88b85febcb45 838
iv123 0:88b85febcb45 839 tBleStatus aci_gatt_read_charac_val(uint16_t conn_handle, uint16_t attr_handle)
iv123 0:88b85febcb45 840 {
iv123 0:88b85febcb45 841 struct hci_request rq;
iv123 0:88b85febcb45 842 uint8_t status;
iv123 0:88b85febcb45 843 gatt_read_charac_val_cp cp;
iv123 0:88b85febcb45 844
iv123 0:88b85febcb45 845 cp.conn_handle = htobs(conn_handle);
iv123 0:88b85febcb45 846 cp.attr_handle = htobs(attr_handle);
iv123 0:88b85febcb45 847
iv123 0:88b85febcb45 848 Osal_MemSet(&rq, 0, sizeof(rq));
iv123 0:88b85febcb45 849 rq.ogf = OGF_VENDOR_CMD;
iv123 0:88b85febcb45 850 rq.ocf = OCF_GATT_READ_CHARAC_VAL;
iv123 0:88b85febcb45 851 rq.cparam = &cp;
iv123 0:88b85febcb45 852 rq.clen = GATT_READ_CHARAC_VAL_CP_SIZE;
iv123 0:88b85febcb45 853 rq.event = EVT_CMD_STATUS;
iv123 0:88b85febcb45 854 rq.rparam = &status;
iv123 0:88b85febcb45 855 rq.rlen = 1;
iv123 0:88b85febcb45 856
iv123 0:88b85febcb45 857 if (hci_send_req(&rq, FALSE) < 0)
iv123 0:88b85febcb45 858 return BLE_STATUS_TIMEOUT;
iv123 0:88b85febcb45 859
iv123 0:88b85febcb45 860 return status;
iv123 0:88b85febcb45 861 }
iv123 0:88b85febcb45 862
iv123 0:88b85febcb45 863 tBleStatus aci_gatt_read_using_charac_uuid(uint16_t conn_handle, uint16_t start_handle, uint16_t end_handle,
iv123 0:88b85febcb45 864 uint8_t uuid_type, uint8_t* uuid)
iv123 0:88b85febcb45 865 {
iv123 0:88b85febcb45 866 struct hci_request rq;
iv123 0:88b85febcb45 867 uint8_t status;
iv123 0:88b85febcb45 868 gatt_read_using_charac_uuid_cp cp;
iv123 0:88b85febcb45 869 uint8_t uuid_len;
iv123 0:88b85febcb45 870
iv123 0:88b85febcb45 871 if(uuid_type == UUID_TYPE_16){
iv123 0:88b85febcb45 872 uuid_len = 2;
iv123 0:88b85febcb45 873 }
iv123 0:88b85febcb45 874 else{
iv123 0:88b85febcb45 875 uuid_len = 16;
iv123 0:88b85febcb45 876 }
iv123 0:88b85febcb45 877
iv123 0:88b85febcb45 878 cp.conn_handle = htobs(conn_handle);
iv123 0:88b85febcb45 879 cp.start_handle = htobs(start_handle);
iv123 0:88b85febcb45 880 cp.end_handle = htobs(end_handle);
iv123 0:88b85febcb45 881 cp.uuid_type = uuid_type;
iv123 0:88b85febcb45 882 Osal_MemCpy(cp.uuid, uuid, uuid_len);
iv123 0:88b85febcb45 883
iv123 0:88b85febcb45 884 Osal_MemSet(&rq, 0, sizeof(rq));
iv123 0:88b85febcb45 885 rq.ogf = OGF_VENDOR_CMD;
iv123 0:88b85febcb45 886 rq.ocf = OCF_GATT_READ_USING_CHARAC_UUID;
iv123 0:88b85febcb45 887 rq.cparam = &cp;
iv123 0:88b85febcb45 888 rq.clen = GATT_READ_USING_CHARAC_UUID_CP_SIZE + uuid_len;
iv123 0:88b85febcb45 889 rq.rparam = &status;
iv123 0:88b85febcb45 890 rq.rlen = 1;
iv123 0:88b85febcb45 891
iv123 0:88b85febcb45 892 if (hci_send_req(&rq, FALSE) < 0)
iv123 0:88b85febcb45 893 return BLE_STATUS_TIMEOUT;
iv123 0:88b85febcb45 894
iv123 0:88b85febcb45 895 return status;
iv123 0:88b85febcb45 896 }
iv123 0:88b85febcb45 897
iv123 0:88b85febcb45 898 tBleStatus aci_gatt_read_long_charac_val(uint16_t conn_handle, uint16_t attr_handle,
iv123 0:88b85febcb45 899 uint16_t val_offset)
iv123 0:88b85febcb45 900 {
iv123 0:88b85febcb45 901 struct hci_request rq;
iv123 0:88b85febcb45 902 uint8_t status;
iv123 0:88b85febcb45 903 gatt_read_long_charac_val_cp cp;
iv123 0:88b85febcb45 904
iv123 0:88b85febcb45 905 cp.conn_handle = htobs(conn_handle);
iv123 0:88b85febcb45 906 cp.attr_handle = htobs(attr_handle);
iv123 0:88b85febcb45 907 cp.val_offset = htobs(val_offset);
iv123 0:88b85febcb45 908
iv123 0:88b85febcb45 909 Osal_MemSet(&rq, 0, sizeof(rq));
iv123 0:88b85febcb45 910 rq.ogf = OGF_VENDOR_CMD;
iv123 0:88b85febcb45 911 rq.ocf = OCF_GATT_READ_LONG_CHARAC_VAL;
iv123 0:88b85febcb45 912 rq.cparam = &cp;
iv123 0:88b85febcb45 913 rq.clen = GATT_READ_LONG_CHARAC_VAL_CP_SIZE;
iv123 0:88b85febcb45 914 rq.event = EVT_CMD_STATUS;
iv123 0:88b85febcb45 915 rq.rparam = &status;
iv123 0:88b85febcb45 916 rq.rlen = 1;
iv123 0:88b85febcb45 917
iv123 0:88b85febcb45 918 if (hci_send_req(&rq, FALSE) < 0)
iv123 0:88b85febcb45 919 return BLE_STATUS_TIMEOUT;
iv123 0:88b85febcb45 920
iv123 0:88b85febcb45 921 return status;
iv123 0:88b85febcb45 922 }
iv123 0:88b85febcb45 923
iv123 0:88b85febcb45 924 tBleStatus aci_gatt_read_multiple_charac_val(uint16_t conn_handle, uint8_t num_handles,
iv123 0:88b85febcb45 925 uint8_t* set_of_handles)
iv123 0:88b85febcb45 926 {
iv123 0:88b85febcb45 927 struct hci_request rq;
iv123 0:88b85febcb45 928 uint8_t status;
iv123 0:88b85febcb45 929 gatt_read_multiple_charac_val_cp cp;
iv123 0:88b85febcb45 930
iv123 0:88b85febcb45 931 if(num_handles*2 > sizeof(cp.set_of_handles))
iv123 0:88b85febcb45 932 return BLE_STATUS_INVALID_PARAMS;
iv123 0:88b85febcb45 933
iv123 0:88b85febcb45 934 cp.conn_handle = htobs(conn_handle);
iv123 0:88b85febcb45 935 cp.num_handles = htobs(num_handles);
iv123 0:88b85febcb45 936 Osal_MemCpy(cp.set_of_handles, set_of_handles, 2*num_handles);
iv123 0:88b85febcb45 937
iv123 0:88b85febcb45 938 Osal_MemSet(&rq, 0, sizeof(rq));
iv123 0:88b85febcb45 939 rq.ogf = OGF_VENDOR_CMD;
iv123 0:88b85febcb45 940 rq.ocf = OCF_GATT_READ_MULTIPLE_CHARAC_VAL;
iv123 0:88b85febcb45 941 rq.cparam = &cp;
iv123 0:88b85febcb45 942 rq.clen = GATT_READ_MULTIPLE_CHARAC_VAL_CP_SIZE + 2*num_handles;
iv123 0:88b85febcb45 943 rq.event = EVT_CMD_STATUS;
iv123 0:88b85febcb45 944 rq.rparam = &status;
iv123 0:88b85febcb45 945 rq.rlen = 1;
iv123 0:88b85febcb45 946
iv123 0:88b85febcb45 947 if (hci_send_req(&rq, FALSE) < 0)
iv123 0:88b85febcb45 948 return BLE_STATUS_TIMEOUT;
iv123 0:88b85febcb45 949
iv123 0:88b85febcb45 950 return status;
iv123 0:88b85febcb45 951 }
iv123 0:88b85febcb45 952
iv123 0:88b85febcb45 953
iv123 0:88b85febcb45 954
iv123 0:88b85febcb45 955 tBleStatus aci_gatt_write_charac_value(uint16_t conn_handle, uint16_t attr_handle,
iv123 0:88b85febcb45 956 uint8_t value_len, uint8_t *attr_value)
iv123 0:88b85febcb45 957 {
iv123 0:88b85febcb45 958 struct hci_request rq;
iv123 0:88b85febcb45 959 uint8_t status;
iv123 0:88b85febcb45 960 uint8_t buffer[HCI_MAX_PAYLOAD_SIZE];
iv123 0:88b85febcb45 961 uint8_t indx = 0;
iv123 0:88b85febcb45 962
iv123 0:88b85febcb45 963 if ((value_len+5) > HCI_MAX_PAYLOAD_SIZE)
iv123 0:88b85febcb45 964 return BLE_STATUS_INVALID_PARAMS;
iv123 0:88b85febcb45 965
iv123 0:88b85febcb45 966 conn_handle = htobs(conn_handle);
iv123 0:88b85febcb45 967 Osal_MemCpy(buffer + indx, &conn_handle, 2);
iv123 0:88b85febcb45 968 indx += 2;
iv123 0:88b85febcb45 969
iv123 0:88b85febcb45 970 attr_handle = htobs(attr_handle);
iv123 0:88b85febcb45 971 Osal_MemCpy(buffer + indx, &attr_handle, 2);
iv123 0:88b85febcb45 972 indx += 2;
iv123 0:88b85febcb45 973
iv123 0:88b85febcb45 974 buffer[indx] = value_len;
iv123 0:88b85febcb45 975 indx++;
iv123 0:88b85febcb45 976
iv123 0:88b85febcb45 977 Osal_MemCpy(buffer + indx, attr_value, value_len);
iv123 0:88b85febcb45 978 indx += value_len;
iv123 0:88b85febcb45 979
iv123 0:88b85febcb45 980 Osal_MemSet(&rq, 0, sizeof(rq));
iv123 0:88b85febcb45 981 rq.ogf = OGF_VENDOR_CMD;
iv123 0:88b85febcb45 982 rq.ocf = OCF_GATT_WRITE_CHAR_VALUE;
iv123 0:88b85febcb45 983 rq.cparam = (void *)buffer;
iv123 0:88b85febcb45 984 rq.clen = indx;
iv123 0:88b85febcb45 985 rq.event = EVT_CMD_STATUS;
iv123 0:88b85febcb45 986 rq.rparam = &status;
iv123 0:88b85febcb45 987 rq.rlen = 1;
iv123 0:88b85febcb45 988
iv123 0:88b85febcb45 989 if (hci_send_req(&rq, FALSE) < 0)
iv123 0:88b85febcb45 990 return BLE_STATUS_TIMEOUT;
iv123 0:88b85febcb45 991
iv123 0:88b85febcb45 992 return status;
iv123 0:88b85febcb45 993 }
iv123 0:88b85febcb45 994
iv123 0:88b85febcb45 995 tBleStatus aci_gatt_write_long_charac_val(uint16_t conn_handle, uint16_t attr_handle,
iv123 0:88b85febcb45 996 uint16_t val_offset, uint8_t val_len, const uint8_t* attr_val)
iv123 0:88b85febcb45 997 {
iv123 0:88b85febcb45 998 struct hci_request rq;
iv123 0:88b85febcb45 999 uint8_t status;
iv123 0:88b85febcb45 1000 gatt_write_long_charac_val_cp cp;
iv123 0:88b85febcb45 1001
iv123 0:88b85febcb45 1002 if(val_len > sizeof(cp.attr_val))
iv123 0:88b85febcb45 1003 return BLE_STATUS_INVALID_PARAMS;
iv123 0:88b85febcb45 1004
iv123 0:88b85febcb45 1005 cp.conn_handle = htobs(conn_handle);
iv123 0:88b85febcb45 1006 cp.attr_handle = htobs(attr_handle);
iv123 0:88b85febcb45 1007 cp.val_offset = htobs(val_offset);
iv123 0:88b85febcb45 1008 cp.val_len = val_len;
iv123 0:88b85febcb45 1009 Osal_MemCpy(cp.attr_val, attr_val, val_len);
iv123 0:88b85febcb45 1010
iv123 0:88b85febcb45 1011 Osal_MemSet(&rq, 0, sizeof(rq));
iv123 0:88b85febcb45 1012 rq.ogf = OGF_VENDOR_CMD;
iv123 0:88b85febcb45 1013 rq.ocf = OCF_GATT_WRITE_LONG_CHARAC_VAL;
iv123 0:88b85febcb45 1014 rq.cparam = &cp;
iv123 0:88b85febcb45 1015 rq.clen = GATT_WRITE_LONG_CHARAC_VAL_CP_SIZE + val_len;
iv123 0:88b85febcb45 1016 rq.event = EVT_CMD_STATUS;
iv123 0:88b85febcb45 1017 rq.rparam = &status;
iv123 0:88b85febcb45 1018 rq.rlen = 1;
iv123 0:88b85febcb45 1019
iv123 0:88b85febcb45 1020 if (hci_send_req(&rq, FALSE) < 0)
iv123 0:88b85febcb45 1021 return BLE_STATUS_TIMEOUT;
iv123 0:88b85febcb45 1022
iv123 0:88b85febcb45 1023 return status;
iv123 0:88b85febcb45 1024 }
iv123 0:88b85febcb45 1025
iv123 0:88b85febcb45 1026 tBleStatus aci_gatt_write_charac_reliable(uint16_t conn_handle, uint16_t attr_handle,
iv123 0:88b85febcb45 1027 uint16_t val_offset, uint8_t val_len, uint8_t* attr_val)
iv123 0:88b85febcb45 1028 {
iv123 0:88b85febcb45 1029 struct hci_request rq;
iv123 0:88b85febcb45 1030 uint8_t status;
iv123 0:88b85febcb45 1031 gatt_write_charac_reliable_cp cp;
iv123 0:88b85febcb45 1032
iv123 0:88b85febcb45 1033 if(val_len > sizeof(cp.attr_val))
iv123 0:88b85febcb45 1034 return BLE_STATUS_INVALID_PARAMS;
iv123 0:88b85febcb45 1035
iv123 0:88b85febcb45 1036 cp.conn_handle = htobs(conn_handle);
iv123 0:88b85febcb45 1037 cp.attr_handle = htobs(attr_handle);
iv123 0:88b85febcb45 1038 cp.val_offset = htobs(val_offset);
iv123 0:88b85febcb45 1039 cp.val_len = val_len;
iv123 0:88b85febcb45 1040 Osal_MemCpy(cp.attr_val, attr_val, val_len);
iv123 0:88b85febcb45 1041
iv123 0:88b85febcb45 1042 Osal_MemSet(&rq, 0, sizeof(rq));
iv123 0:88b85febcb45 1043 rq.ogf = OGF_VENDOR_CMD;
iv123 0:88b85febcb45 1044 rq.ocf = OCF_GATT_WRITE_CHARAC_RELIABLE;
iv123 0:88b85febcb45 1045 rq.cparam = &cp;
iv123 0:88b85febcb45 1046 rq.clen = GATT_WRITE_CHARAC_RELIABLE_CP_SIZE + val_len;
iv123 0:88b85febcb45 1047 rq.event = EVT_CMD_STATUS;
iv123 0:88b85febcb45 1048 rq.rparam = &status;
iv123 0:88b85febcb45 1049 rq.rlen = 1;
iv123 0:88b85febcb45 1050
iv123 0:88b85febcb45 1051 if (hci_send_req(&rq, FALSE) < 0)
iv123 0:88b85febcb45 1052 return BLE_STATUS_TIMEOUT;
iv123 0:88b85febcb45 1053
iv123 0:88b85febcb45 1054 return status;
iv123 0:88b85febcb45 1055 }
iv123 0:88b85febcb45 1056
iv123 0:88b85febcb45 1057 tBleStatus aci_gatt_write_long_charac_desc(uint16_t conn_handle, uint16_t attr_handle,
iv123 0:88b85febcb45 1058 uint16_t val_offset, uint8_t val_len, uint8_t* attr_val)
iv123 0:88b85febcb45 1059 {
iv123 0:88b85febcb45 1060 struct hci_request rq;
iv123 0:88b85febcb45 1061 uint8_t status;
iv123 0:88b85febcb45 1062 gatt_write_charac_reliable_cp cp;
iv123 0:88b85febcb45 1063
iv123 0:88b85febcb45 1064 if(val_len > sizeof(cp.attr_val))
iv123 0:88b85febcb45 1065 return BLE_STATUS_INVALID_PARAMS;
iv123 0:88b85febcb45 1066
iv123 0:88b85febcb45 1067 cp.conn_handle = htobs(conn_handle);
iv123 0:88b85febcb45 1068 cp.attr_handle = htobs(attr_handle);
iv123 0:88b85febcb45 1069 cp.val_offset = htobs(val_offset);
iv123 0:88b85febcb45 1070 cp.val_len = val_len;
iv123 0:88b85febcb45 1071 Osal_MemCpy(cp.attr_val, attr_val, val_len);
iv123 0:88b85febcb45 1072
iv123 0:88b85febcb45 1073 Osal_MemSet(&rq, 0, sizeof(rq));
iv123 0:88b85febcb45 1074 rq.ogf = OGF_VENDOR_CMD;
iv123 0:88b85febcb45 1075 rq.ocf = OCF_GATT_WRITE_LONG_CHARAC_DESC;
iv123 0:88b85febcb45 1076 rq.cparam = &cp;
iv123 0:88b85febcb45 1077 rq.clen = GATT_WRITE_LONG_CHARAC_DESC_CP_SIZE + val_len;
iv123 0:88b85febcb45 1078 rq.event = EVT_CMD_STATUS;
iv123 0:88b85febcb45 1079 rq.rparam = &status;
iv123 0:88b85febcb45 1080 rq.rlen = 1;
iv123 0:88b85febcb45 1081
iv123 0:88b85febcb45 1082 if (hci_send_req(&rq, FALSE) < 0)
iv123 0:88b85febcb45 1083 return BLE_STATUS_TIMEOUT;
iv123 0:88b85febcb45 1084
iv123 0:88b85febcb45 1085 return status;
iv123 0:88b85febcb45 1086 }
iv123 0:88b85febcb45 1087
iv123 0:88b85febcb45 1088 tBleStatus aci_gatt_read_long_charac_desc(uint16_t conn_handle, uint16_t attr_handle,
iv123 0:88b85febcb45 1089 uint16_t val_offset)
iv123 0:88b85febcb45 1090 {
iv123 0:88b85febcb45 1091 struct hci_request rq;
iv123 0:88b85febcb45 1092 uint8_t status;
iv123 0:88b85febcb45 1093 gatt_read_long_charac_desc_cp cp;
iv123 0:88b85febcb45 1094
iv123 0:88b85febcb45 1095 cp.conn_handle = htobs(conn_handle);
iv123 0:88b85febcb45 1096 cp.attr_handle = htobs(attr_handle);
iv123 0:88b85febcb45 1097 cp.val_offset = htobs(val_offset);
iv123 0:88b85febcb45 1098
iv123 0:88b85febcb45 1099 Osal_MemSet(&rq, 0, sizeof(rq));
iv123 0:88b85febcb45 1100 rq.ogf = OGF_VENDOR_CMD;
iv123 0:88b85febcb45 1101 rq.ocf = OCF_GATT_READ_LONG_CHARAC_DESC;
iv123 0:88b85febcb45 1102 rq.cparam = &cp;
iv123 0:88b85febcb45 1103 rq.clen = GATT_READ_LONG_CHARAC_DESC_CP_SIZE;
iv123 0:88b85febcb45 1104 rq.event = EVT_CMD_STATUS;
iv123 0:88b85febcb45 1105 rq.rparam = &status;
iv123 0:88b85febcb45 1106 rq.rlen = 1;
iv123 0:88b85febcb45 1107
iv123 0:88b85febcb45 1108 if (hci_send_req(&rq, FALSE) < 0)
iv123 0:88b85febcb45 1109 return BLE_STATUS_TIMEOUT;
iv123 0:88b85febcb45 1110
iv123 0:88b85febcb45 1111 return status;
iv123 0:88b85febcb45 1112 }
iv123 0:88b85febcb45 1113
iv123 0:88b85febcb45 1114 tBleStatus aci_gatt_write_charac_descriptor(uint16_t conn_handle, uint16_t attr_handle,
iv123 0:88b85febcb45 1115 uint8_t value_len, uint8_t *attr_value)
iv123 0:88b85febcb45 1116 {
iv123 0:88b85febcb45 1117 struct hci_request rq;
iv123 0:88b85febcb45 1118 uint8_t status;
iv123 0:88b85febcb45 1119 uint8_t buffer[HCI_MAX_PAYLOAD_SIZE];
iv123 0:88b85febcb45 1120 uint8_t indx = 0;
iv123 0:88b85febcb45 1121
iv123 0:88b85febcb45 1122 if ((value_len+5) > HCI_MAX_PAYLOAD_SIZE)
iv123 0:88b85febcb45 1123 return BLE_STATUS_INVALID_PARAMS;
iv123 0:88b85febcb45 1124
iv123 0:88b85febcb45 1125 conn_handle = htobs(conn_handle);
iv123 0:88b85febcb45 1126 Osal_MemCpy(buffer + indx, &conn_handle, 2);
iv123 0:88b85febcb45 1127 indx += 2;
iv123 0:88b85febcb45 1128
iv123 0:88b85febcb45 1129 attr_handle = htobs(attr_handle);
iv123 0:88b85febcb45 1130 Osal_MemCpy(buffer + indx, &attr_handle, 2);
iv123 0:88b85febcb45 1131 indx += 2;
iv123 0:88b85febcb45 1132
iv123 0:88b85febcb45 1133 buffer[indx] = value_len;
iv123 0:88b85febcb45 1134 indx++;
iv123 0:88b85febcb45 1135
iv123 0:88b85febcb45 1136 Osal_MemCpy(buffer + indx, attr_value, value_len);
iv123 0:88b85febcb45 1137 indx += value_len;
iv123 0:88b85febcb45 1138
iv123 0:88b85febcb45 1139 Osal_MemSet(&rq, 0, sizeof(rq));
iv123 0:88b85febcb45 1140 rq.ogf = OGF_VENDOR_CMD;
iv123 0:88b85febcb45 1141 rq.ocf = OCF_GATT_WRITE_CHAR_DESCRIPTOR;
iv123 0:88b85febcb45 1142 rq.cparam = (void *)buffer;
iv123 0:88b85febcb45 1143 rq.clen = indx;
iv123 0:88b85febcb45 1144 rq.event = EVT_CMD_STATUS;
iv123 0:88b85febcb45 1145 rq.rparam = &status;
iv123 0:88b85febcb45 1146 rq.rlen = 1;
iv123 0:88b85febcb45 1147
iv123 0:88b85febcb45 1148 if (hci_send_req(&rq, FALSE) < 0)
iv123 0:88b85febcb45 1149 return BLE_STATUS_TIMEOUT;
iv123 0:88b85febcb45 1150
iv123 0:88b85febcb45 1151 return status;
iv123 0:88b85febcb45 1152 }
iv123 0:88b85febcb45 1153
iv123 0:88b85febcb45 1154 tBleStatus aci_gatt_read_charac_desc(uint16_t conn_handle, uint16_t attr_handle)
iv123 0:88b85febcb45 1155 {
iv123 0:88b85febcb45 1156 struct hci_request rq;
iv123 0:88b85febcb45 1157 uint8_t status;
iv123 0:88b85febcb45 1158 gatt_read_long_charac_desc_cp cp;
iv123 0:88b85febcb45 1159
iv123 0:88b85febcb45 1160 cp.conn_handle = htobs(conn_handle);
iv123 0:88b85febcb45 1161 cp.attr_handle = htobs(attr_handle);
iv123 0:88b85febcb45 1162
iv123 0:88b85febcb45 1163 Osal_MemSet(&rq, 0, sizeof(rq));
iv123 0:88b85febcb45 1164 rq.ogf = OGF_VENDOR_CMD;
iv123 0:88b85febcb45 1165 rq.ocf = OCF_GATT_READ_CHAR_DESCRIPTOR;
iv123 0:88b85febcb45 1166 rq.cparam = &cp;
iv123 0:88b85febcb45 1167 rq.clen = GATT_READ_CHAR_DESCRIPTOR_CP_SIZE;
iv123 0:88b85febcb45 1168 rq.event = EVT_CMD_STATUS;
iv123 0:88b85febcb45 1169 rq.rparam = &status;
iv123 0:88b85febcb45 1170 rq.rlen = 1;
iv123 0:88b85febcb45 1171
iv123 0:88b85febcb45 1172 if (hci_send_req(&rq, FALSE) < 0)
iv123 0:88b85febcb45 1173 return BLE_STATUS_TIMEOUT;
iv123 0:88b85febcb45 1174
iv123 0:88b85febcb45 1175 return status;
iv123 0:88b85febcb45 1176 }
iv123 0:88b85febcb45 1177
iv123 0:88b85febcb45 1178 tBleStatus aci_gatt_write_without_response(uint16_t conn_handle, uint16_t attr_handle,
iv123 0:88b85febcb45 1179 uint8_t val_len, const uint8_t* attr_val)
iv123 0:88b85febcb45 1180 {
iv123 0:88b85febcb45 1181 struct hci_request rq;
iv123 0:88b85febcb45 1182 uint8_t status;
iv123 0:88b85febcb45 1183 gatt_write_without_resp_cp cp;
iv123 0:88b85febcb45 1184
iv123 0:88b85febcb45 1185 if(val_len > sizeof(cp.attr_val))
iv123 0:88b85febcb45 1186 return BLE_STATUS_INVALID_PARAMS;
iv123 0:88b85febcb45 1187
iv123 0:88b85febcb45 1188 cp.conn_handle = htobs(conn_handle);
iv123 0:88b85febcb45 1189 cp.attr_handle = htobs(attr_handle);
iv123 0:88b85febcb45 1190 cp.val_len = val_len;
iv123 0:88b85febcb45 1191 Osal_MemCpy(cp.attr_val, attr_val, val_len);
iv123 0:88b85febcb45 1192
iv123 0:88b85febcb45 1193 Osal_MemSet(&rq, 0, sizeof(rq));
iv123 0:88b85febcb45 1194 rq.ogf = OGF_VENDOR_CMD;
iv123 0:88b85febcb45 1195 rq.ocf = OCF_GATT_WRITE_WITHOUT_RESPONSE;
iv123 0:88b85febcb45 1196 rq.cparam = &cp;
iv123 0:88b85febcb45 1197 rq.clen = GATT_WRITE_WITHOUT_RESPONSE_CP_SIZE + val_len;
iv123 0:88b85febcb45 1198 rq.rparam = &status;
iv123 0:88b85febcb45 1199 rq.rlen = 1;
iv123 0:88b85febcb45 1200
iv123 0:88b85febcb45 1201 if (hci_send_req(&rq, FALSE) < 0)
iv123 0:88b85febcb45 1202 return BLE_STATUS_TIMEOUT;
iv123 0:88b85febcb45 1203
iv123 0:88b85febcb45 1204 return status;
iv123 0:88b85febcb45 1205 }
iv123 0:88b85febcb45 1206
iv123 0:88b85febcb45 1207 tBleStatus aci_gatt_signed_write_without_resp(uint16_t conn_handle, uint16_t attr_handle,
iv123 0:88b85febcb45 1208 uint8_t val_len, uint8_t* attr_val)
iv123 0:88b85febcb45 1209 {
iv123 0:88b85febcb45 1210 struct hci_request rq;
iv123 0:88b85febcb45 1211 uint8_t status;
iv123 0:88b85febcb45 1212 gatt_signed_write_without_resp_cp cp;
iv123 0:88b85febcb45 1213
iv123 0:88b85febcb45 1214 if(val_len > sizeof(cp.attr_val))
iv123 0:88b85febcb45 1215 return BLE_STATUS_INVALID_PARAMS;
iv123 0:88b85febcb45 1216
iv123 0:88b85febcb45 1217 cp.conn_handle = htobs(conn_handle);
iv123 0:88b85febcb45 1218 cp.attr_handle = htobs(attr_handle);
iv123 0:88b85febcb45 1219 cp.val_len = val_len;
iv123 0:88b85febcb45 1220 Osal_MemCpy(cp.attr_val, attr_val, val_len);
iv123 0:88b85febcb45 1221
iv123 0:88b85febcb45 1222 Osal_MemSet(&rq, 0, sizeof(rq));
iv123 0:88b85febcb45 1223 rq.ogf = OGF_VENDOR_CMD;
iv123 0:88b85febcb45 1224 rq.ocf = OCF_GATT_SIGNED_WRITE_WITHOUT_RESPONSE;
iv123 0:88b85febcb45 1225 rq.cparam = &cp;
iv123 0:88b85febcb45 1226 rq.clen = GATT_SIGNED_WRITE_WITHOUT_RESPONSE_CP_SIZE + val_len;
iv123 0:88b85febcb45 1227 rq.rparam = &status;
iv123 0:88b85febcb45 1228 rq.rlen = 1;
iv123 0:88b85febcb45 1229
iv123 0:88b85febcb45 1230 if (hci_send_req(&rq, FALSE) < 0)
iv123 0:88b85febcb45 1231 return BLE_STATUS_TIMEOUT;
iv123 0:88b85febcb45 1232
iv123 0:88b85febcb45 1233 return status;
iv123 0:88b85febcb45 1234 }
iv123 0:88b85febcb45 1235
iv123 0:88b85febcb45 1236 tBleStatus aci_gatt_confirm_indication(uint16_t conn_handle)
iv123 0:88b85febcb45 1237 {
iv123 0:88b85febcb45 1238 struct hci_request rq;
iv123 0:88b85febcb45 1239 uint8_t status;
iv123 0:88b85febcb45 1240 gatt_confirm_indication_cp cp;
iv123 0:88b85febcb45 1241
iv123 0:88b85febcb45 1242 cp.conn_handle = htobs(conn_handle);
iv123 0:88b85febcb45 1243
iv123 0:88b85febcb45 1244 Osal_MemSet(&rq, 0, sizeof(rq));
iv123 0:88b85febcb45 1245 rq.ogf = OGF_VENDOR_CMD;
iv123 0:88b85febcb45 1246 rq.ocf = OCF_GATT_CONFIRM_INDICATION;
iv123 0:88b85febcb45 1247 rq.cparam = &cp;
iv123 0:88b85febcb45 1248 rq.clen = GATT_CONFIRM_INDICATION_CP_SIZE;
iv123 0:88b85febcb45 1249 rq.rparam = &status;
iv123 0:88b85febcb45 1250 rq.rlen = 1;
iv123 0:88b85febcb45 1251
iv123 0:88b85febcb45 1252 if (hci_send_req(&rq, FALSE) < 0)
iv123 0:88b85febcb45 1253 return BLE_STATUS_TIMEOUT;
iv123 0:88b85febcb45 1254
iv123 0:88b85febcb45 1255 return status;
iv123 0:88b85febcb45 1256 }
iv123 0:88b85febcb45 1257
iv123 0:88b85febcb45 1258 tBleStatus aci_gatt_write_response(uint16_t conn_handle,
iv123 0:88b85febcb45 1259 uint16_t attr_handle,
iv123 0:88b85febcb45 1260 uint8_t write_status,
iv123 0:88b85febcb45 1261 uint8_t err_code,
iv123 0:88b85febcb45 1262 uint8_t att_val_len,
iv123 0:88b85febcb45 1263 uint8_t *att_val)
iv123 0:88b85febcb45 1264 {
iv123 0:88b85febcb45 1265 struct hci_request rq;
iv123 0:88b85febcb45 1266 uint8_t status;
iv123 0:88b85febcb45 1267 uint8_t buffer[HCI_MAX_PAYLOAD_SIZE];
iv123 0:88b85febcb45 1268 uint8_t indx = 0;
iv123 0:88b85febcb45 1269
iv123 0:88b85febcb45 1270 if ((att_val_len+7) > HCI_MAX_PAYLOAD_SIZE)
iv123 0:88b85febcb45 1271 return BLE_STATUS_INVALID_PARAMS;
iv123 0:88b85febcb45 1272
iv123 0:88b85febcb45 1273 conn_handle = htobs(conn_handle);
iv123 0:88b85febcb45 1274 Osal_MemCpy(buffer + indx, &conn_handle, 2);
iv123 0:88b85febcb45 1275 indx += 2;
iv123 0:88b85febcb45 1276
iv123 0:88b85febcb45 1277 attr_handle = htobs(attr_handle);
iv123 0:88b85febcb45 1278 Osal_MemCpy(buffer + indx, &attr_handle, 2);
iv123 0:88b85febcb45 1279 indx += 2;
iv123 0:88b85febcb45 1280
iv123 0:88b85febcb45 1281 buffer[indx] = write_status;
iv123 0:88b85febcb45 1282 indx += 1;
iv123 0:88b85febcb45 1283
iv123 0:88b85febcb45 1284 buffer[indx] = err_code;
iv123 0:88b85febcb45 1285 indx += 1;
iv123 0:88b85febcb45 1286
iv123 0:88b85febcb45 1287 buffer[indx] = att_val_len;
iv123 0:88b85febcb45 1288 indx += 1;
iv123 0:88b85febcb45 1289
iv123 0:88b85febcb45 1290 Osal_MemCpy(buffer + indx, att_val, att_val_len);
iv123 0:88b85febcb45 1291 indx += att_val_len;
iv123 0:88b85febcb45 1292
iv123 0:88b85febcb45 1293 Osal_MemSet(&rq, 0, sizeof(rq));
iv123 0:88b85febcb45 1294 rq.ogf = OGF_VENDOR_CMD;
iv123 0:88b85febcb45 1295 rq.ocf = OCF_GATT_WRITE_RESPONSE;
iv123 0:88b85febcb45 1296 rq.cparam = (void *)buffer;
iv123 0:88b85febcb45 1297 rq.clen = indx;
iv123 0:88b85febcb45 1298 rq.rparam = &status;
iv123 0:88b85febcb45 1299 rq.rlen = 1;
iv123 0:88b85febcb45 1300
iv123 0:88b85febcb45 1301 if (hci_send_req(&rq, FALSE) < 0)
iv123 0:88b85febcb45 1302 return BLE_STATUS_TIMEOUT;
iv123 0:88b85febcb45 1303
iv123 0:88b85febcb45 1304 if (status) {
iv123 0:88b85febcb45 1305 return status;
iv123 0:88b85febcb45 1306 }
iv123 0:88b85febcb45 1307
iv123 0:88b85febcb45 1308 return 0;
iv123 0:88b85febcb45 1309 }
iv123 0:88b85febcb45 1310
iv123 0:88b85febcb45 1311 tBleStatus aci_gatt_allow_read(uint16_t conn_handle)
iv123 0:88b85febcb45 1312 {
iv123 0:88b85febcb45 1313 struct hci_request rq;
iv123 0:88b85febcb45 1314 gatt_allow_read_cp cp;
iv123 0:88b85febcb45 1315 uint8_t status;
iv123 0:88b85febcb45 1316
iv123 0:88b85febcb45 1317 cp.conn_handle = htobs(conn_handle);
iv123 0:88b85febcb45 1318
iv123 0:88b85febcb45 1319 Osal_MemSet(&rq, 0, sizeof(rq));
iv123 0:88b85febcb45 1320 rq.ogf = OGF_VENDOR_CMD;
iv123 0:88b85febcb45 1321 rq.ocf = OCF_GATT_ALLOW_READ;
iv123 0:88b85febcb45 1322 rq.cparam = &cp;
iv123 0:88b85febcb45 1323 rq.clen = GATT_ALLOW_READ_CP_SIZE;
iv123 0:88b85febcb45 1324 rq.rparam = &status;
iv123 0:88b85febcb45 1325 rq.rlen = 1;
iv123 0:88b85febcb45 1326
iv123 0:88b85febcb45 1327 if (hci_send_req(&rq, FALSE) < 0)
iv123 0:88b85febcb45 1328 return BLE_STATUS_TIMEOUT;
iv123 0:88b85febcb45 1329
iv123 0:88b85febcb45 1330 return status;
iv123 0:88b85febcb45 1331 }
iv123 0:88b85febcb45 1332
iv123 0:88b85febcb45 1333 tBleStatus aci_gatt_set_security_permission(uint16_t service_handle, uint16_t attr_handle,
iv123 0:88b85febcb45 1334 uint8_t security_permission)
iv123 0:88b85febcb45 1335 {
iv123 0:88b85febcb45 1336 struct hci_request rq;
iv123 0:88b85febcb45 1337 gatt_set_security_permission_cp cp;
iv123 0:88b85febcb45 1338 uint8_t status;
iv123 0:88b85febcb45 1339
iv123 0:88b85febcb45 1340 cp.service_handle = htobs(service_handle);
iv123 0:88b85febcb45 1341 cp.attr_handle = htobs(attr_handle);
iv123 0:88b85febcb45 1342 cp.security_permission = security_permission;
iv123 0:88b85febcb45 1343
iv123 0:88b85febcb45 1344 Osal_MemSet(&rq, 0, sizeof(rq));
iv123 0:88b85febcb45 1345 rq.ogf = OGF_VENDOR_CMD;
iv123 0:88b85febcb45 1346 rq.ocf = OCF_GATT_SET_SECURITY_PERMISSION;
iv123 0:88b85febcb45 1347 rq.cparam = &cp;
iv123 0:88b85febcb45 1348 rq.clen = GATT_GATT_SET_SECURITY_PERMISSION_CP_SIZE;
iv123 0:88b85febcb45 1349 rq.rparam = &status;
iv123 0:88b85febcb45 1350 rq.rlen = 1;
iv123 0:88b85febcb45 1351
iv123 0:88b85febcb45 1352 if (hci_send_req(&rq, FALSE) < 0)
iv123 0:88b85febcb45 1353 return BLE_STATUS_TIMEOUT;
iv123 0:88b85febcb45 1354
iv123 0:88b85febcb45 1355 return status;
iv123 0:88b85febcb45 1356 }
iv123 0:88b85febcb45 1357
iv123 0:88b85febcb45 1358 tBleStatus aci_gatt_set_desc_value(uint16_t servHandle,
iv123 0:88b85febcb45 1359 uint16_t charHandle,
iv123 0:88b85febcb45 1360 uint16_t charDescHandle,
iv123 0:88b85febcb45 1361 uint16_t charDescValOffset,
iv123 0:88b85febcb45 1362 uint8_t charDescValueLen,
iv123 0:88b85febcb45 1363 const void *charDescValue)
iv123 0:88b85febcb45 1364 {
iv123 0:88b85febcb45 1365 struct hci_request rq;
iv123 0:88b85febcb45 1366 uint8_t status;
iv123 0:88b85febcb45 1367 uint8_t buffer[HCI_MAX_PAYLOAD_SIZE];
iv123 0:88b85febcb45 1368 uint8_t indx = 0;
iv123 0:88b85febcb45 1369
iv123 0:88b85febcb45 1370 if ((charDescValueLen+9) > HCI_MAX_PAYLOAD_SIZE)
iv123 0:88b85febcb45 1371 return BLE_STATUS_INVALID_PARAMS;
iv123 0:88b85febcb45 1372
iv123 0:88b85febcb45 1373 servHandle = htobs(servHandle);
iv123 0:88b85febcb45 1374 Osal_MemCpy(buffer + indx, &servHandle, 2);
iv123 0:88b85febcb45 1375 indx += 2;
iv123 0:88b85febcb45 1376
iv123 0:88b85febcb45 1377 charHandle = htobs(charHandle);
iv123 0:88b85febcb45 1378 Osal_MemCpy(buffer + indx, &charHandle, 2);
iv123 0:88b85febcb45 1379 indx += 2;
iv123 0:88b85febcb45 1380
iv123 0:88b85febcb45 1381 charDescHandle = htobs(charDescHandle);
iv123 0:88b85febcb45 1382 Osal_MemCpy(buffer + indx, &charDescHandle, 2);
iv123 0:88b85febcb45 1383 indx += 2;
iv123 0:88b85febcb45 1384
iv123 0:88b85febcb45 1385 Osal_MemCpy(buffer + indx, &charDescValOffset, 2);
iv123 0:88b85febcb45 1386 indx += 2;
iv123 0:88b85febcb45 1387
iv123 0:88b85febcb45 1388 buffer[indx] = charDescValueLen;
iv123 0:88b85febcb45 1389 indx++;
iv123 0:88b85febcb45 1390
iv123 0:88b85febcb45 1391 Osal_MemCpy(buffer + indx, charDescValue, charDescValueLen);
iv123 0:88b85febcb45 1392 indx += charDescValueLen;
iv123 0:88b85febcb45 1393
iv123 0:88b85febcb45 1394 Osal_MemSet(&rq, 0, sizeof(rq));
iv123 0:88b85febcb45 1395 rq.ogf = OGF_VENDOR_CMD;
iv123 0:88b85febcb45 1396 rq.ocf = OCF_GATT_SET_DESC_VAL;
iv123 0:88b85febcb45 1397 rq.cparam = (void *)buffer;
iv123 0:88b85febcb45 1398 rq.clen = indx;
iv123 0:88b85febcb45 1399 rq.rparam = &status;
iv123 0:88b85febcb45 1400 rq.rlen = 1;
iv123 0:88b85febcb45 1401
iv123 0:88b85febcb45 1402 if (hci_send_req(&rq, FALSE) < 0)
iv123 0:88b85febcb45 1403 return BLE_STATUS_TIMEOUT;
iv123 0:88b85febcb45 1404
iv123 0:88b85febcb45 1405 return status;
iv123 0:88b85febcb45 1406 }
iv123 0:88b85febcb45 1407
iv123 0:88b85febcb45 1408 tBleStatus aci_gatt_read_handle_value(uint16_t attr_handle, uint16_t data_len, uint16_t *data_len_out_p, uint8_t *data)
iv123 0:88b85febcb45 1409 {
iv123 0:88b85febcb45 1410 struct hci_request rq;
iv123 0:88b85febcb45 1411 gatt_read_handle_val_cp cp;
iv123 0:88b85febcb45 1412 gatt_read_handle_val_rp rp;
iv123 0:88b85febcb45 1413
iv123 0:88b85febcb45 1414 if(data_len > sizeof(rp.value))
iv123 0:88b85febcb45 1415 return BLE_STATUS_INVALID_PARAMS;
iv123 0:88b85febcb45 1416
iv123 0:88b85febcb45 1417 cp.attr_handle = htobs(attr_handle);
iv123 0:88b85febcb45 1418
iv123 0:88b85febcb45 1419 Osal_MemSet(&rq, 0, sizeof(rq));
iv123 0:88b85febcb45 1420 rq.ogf = OGF_VENDOR_CMD;
iv123 0:88b85febcb45 1421 rq.ocf = OCF_GATT_READ_HANDLE_VALUE;
iv123 0:88b85febcb45 1422 rq.cparam = &cp;
iv123 0:88b85febcb45 1423 rq.clen = sizeof(cp);
iv123 0:88b85febcb45 1424 rq.rparam = &rp;
iv123 0:88b85febcb45 1425 rq.rlen = sizeof(rp);
iv123 0:88b85febcb45 1426
iv123 0:88b85febcb45 1427 if (hci_send_req(&rq, FALSE) < 0)
iv123 0:88b85febcb45 1428 return BLE_STATUS_TIMEOUT;
iv123 0:88b85febcb45 1429
iv123 0:88b85febcb45 1430 if(rp.status)
iv123 0:88b85febcb45 1431 return rp.status;
iv123 0:88b85febcb45 1432
iv123 0:88b85febcb45 1433 *data_len_out_p = btohs(rp.value_len);
iv123 0:88b85febcb45 1434
iv123 0:88b85febcb45 1435 Osal_MemCpy(data, rp.value, MIN(data_len, *data_len_out_p));
iv123 0:88b85febcb45 1436
iv123 0:88b85febcb45 1437 return 0;
iv123 0:88b85febcb45 1438 }
iv123 0:88b85febcb45 1439
iv123 0:88b85febcb45 1440 tBleStatus aci_gatt_read_handle_value_offset_IDB05A1(uint16_t attr_handle, uint8_t offset, uint16_t data_len, uint16_t *data_len_out_p, uint8_t *data)
iv123 0:88b85febcb45 1441 {
iv123 0:88b85febcb45 1442 struct hci_request rq;
iv123 0:88b85febcb45 1443 gatt_read_handle_val_offset_cp cp;
iv123 0:88b85febcb45 1444 gatt_read_handle_val_offset_rp rp;
iv123 0:88b85febcb45 1445
iv123 0:88b85febcb45 1446 if(data_len > sizeof(rp.value))
iv123 0:88b85febcb45 1447 return BLE_STATUS_INVALID_PARAMS;
iv123 0:88b85febcb45 1448
iv123 0:88b85febcb45 1449 cp.attr_handle = htobs(attr_handle);
iv123 0:88b85febcb45 1450 cp.offset = offset;
iv123 0:88b85febcb45 1451
iv123 0:88b85febcb45 1452 Osal_MemSet(&rq, 0, sizeof(rq));
iv123 0:88b85febcb45 1453 rq.ogf = OGF_VENDOR_CMD;
iv123 0:88b85febcb45 1454 rq.ocf = OCF_GATT_READ_HANDLE_VALUE_OFFSET;
iv123 0:88b85febcb45 1455 rq.cparam = &cp;
iv123 0:88b85febcb45 1456 rq.clen = sizeof(cp);
iv123 0:88b85febcb45 1457 rq.rparam = &rp;
iv123 0:88b85febcb45 1458 rq.rlen = sizeof(rp);
iv123 0:88b85febcb45 1459
iv123 0:88b85febcb45 1460 if (hci_send_req(&rq, FALSE) < 0)
iv123 0:88b85febcb45 1461 return BLE_STATUS_TIMEOUT;
iv123 0:88b85febcb45 1462
iv123 0:88b85febcb45 1463 if(rp.status)
iv123 0:88b85febcb45 1464 return rp.status;
iv123 0:88b85febcb45 1465
iv123 0:88b85febcb45 1466 *data_len_out_p = rp.value_len;
iv123 0:88b85febcb45 1467
iv123 0:88b85febcb45 1468 Osal_MemCpy(data, rp.value, MIN(data_len, *data_len_out_p));
iv123 0:88b85febcb45 1469
iv123 0:88b85febcb45 1470 return 0;
iv123 0:88b85febcb45 1471 }