2 * Copyright (c) 2016 Samsung Electronics Co., Ltd. All rights reserved.
4 * Contact: Suresh Kumar N (suresh.n@samsung.com)
6 * Licensed under the Apache License, Version 2.0 (the "License");
7 * you may not use this file except in compliance with the License.
8 * You may obtain a copy of the License at
10 * http://www.apache.org/licenses/LICENSE-2.0
12 * Unless required by applicable law or agreed to in writing, software
13 * distributed under the License is distributed on an "AS IS" BASIS,
14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 * See the License for the specific language governing permissions and
16 * limitations under the License.
20 #include <zblib_request.h>
21 #include <zblib_service.h>
22 #include <zblib_service_interface.h>
24 #include <zblib_driver.h>
25 #include <zblib_driver_custom.h>
26 #include <zblib_driver_mfglib_control.h>
27 #include <zblib_driver_service.h>
28 #include <zblib_driver_zcl_alarm.h>
29 #include <zblib_driver_zcl_basic.h>
30 #include <zblib_driver_zcl_color_control.h>
31 #include <zblib_driver_zcl_door_lock.h>
32 #include <zblib_driver_zcl_fan_control.h>
33 #include <zblib_driver_zcl_global_control.h>
34 #include <zblib_driver_zcl_group.h>
35 #include <zblib_driver_zcl_ias_zone.h>
36 #include <zblib_driver_zcl_identify.h>
37 #include <zblib_driver_zcl_level_control.h>
38 #include <zblib_driver_zcl_on_off.h>
39 #include <zblib_driver_zcl_poll_control.h>
40 #include <zblib_driver_zcl_scene.h>
41 #include <zblib_driver_zcl_thermostat.h>
42 #include <zblib_driver_zdo_bind.h>
43 #include <zblib_driver_zdo_dev_control.h>
45 /**< ZigBee Request object */
46 struct zblib_request_type {
47 gint request_id; /**< Request ID */
48 guint request_type; /**< Request type */
49 guint ref_count; /* Reference count */
51 gpointer request_data; /**< Request data */
52 gpointer resp_cb; /**< Response callback */
53 gpointer resp_cb_data; /**< Response callback data */
55 ZigBeeServiceInterface *service_interface; /* Service interface */
58 static ZblibDriverType_e __zblib_request_get_driver_type(guint request_type)
60 ZblibDriverType_e driver_type;
62 driver_type = ((request_type & 0xFF000000) >> 24);
67 static ZblibDriverType_e __zblib_request_get_ops_id(guint request_type)
71 ops_id = (request_type & 0x000000FF);
76 static ZigBeeRequest *__zblib_request_ref_request_by_by_request_id(ZigBeeService *service,
79 ZigBeeRequest *request = NULL;
80 GHashTable *request_table = NULL;
82 /* Fetch request table from service */
83 request_table = zblib_service_ref_request_hash_table(service);
84 if (NULL == request_table) {
85 Z_LOGE("zblib_service_ref_request_hash_table failed!");
89 /* Look-up requets_id in request hash table */
90 request = (ZigBeeRequest *)g_hash_table_lookup(request_table, (gconstpointer)GUINT_TO_POINTER(request_id));
91 if (NULL == request) {
92 Z_LOGE("No request available for request_id: [%d]", request_id);
99 static gint __zblib_request_ref_request_type_by_request_id(ZigBeeService *service,
102 ZigBeeRequest *request = NULL;
104 /* Fetch request based on request_id */
105 request = __zblib_request_ref_request_by_by_request_id(service, request_id);
106 if (NULL == request) {
107 Z_LOGE("No request available for request_id: [%d]", request_id);
111 return (gint)(request->request_type);
114 static ZigBeeRequest *__zblib_request_ref_request_by_request_id(ZigBeeService *service,
117 ZigBeeRequest *request = NULL;
118 GHashTable *request_table = NULL;
120 /* Fetch request table from service */
121 request_table = zblib_service_ref_request_hash_table(service);
122 if (NULL == request_table) {
123 Z_LOGE("zblib_service_ref_request_hash_table failed!");
127 /* Look-up requets_id in request hash table */
128 request = (ZigBeeRequest *)g_hash_table_lookup(request_table, (gconstpointer)GUINT_TO_POINTER(request_id));
129 if (NULL == request) {
130 Z_LOGE("No request available for request_id: [%d]", request_id);
137 static gpointer __zblib_request_create_zcl_alarm_request_data(guint request_type,
138 gpointer request_data, guint request_data_len)
140 gpointer alarm_request_data = NULL;
143 NOT_USED(request_data_len);
146 ops_id = __zblib_request_get_ops_id(request_type);
148 case ZBLIB_ZCL_ALARM_OPS_GET_ALARM_COUNT: {
149 ZigbeeZclAlarmGetAlarmCount_t *in_req;
150 ZigbeeZclAlarmGetAlarmCount_t *req = NULL;
152 in_req = (ZigbeeZclAlarmGetAlarmCount_t *)request_data;
153 if (NULL != in_req) {
154 /* Allocate memory */
155 req = (ZigbeeZclAlarmGetAlarmCount_t *)
156 g_malloc0(sizeof(ZigbeeZclAlarmGetAlarmCount_t));
159 memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
160 req->endpoint = in_req->endpoint;
163 alarm_request_data = (gpointer)req;
167 case ZBLIB_ZCL_ALARM_OPS_RESET_ALARM: {
168 ZigbeeZclAlarmResetAlarm_t *in_req;
169 ZigbeeZclAlarmResetAlarm_t *req = NULL;
171 in_req = (ZigbeeZclAlarmResetAlarm_t *)request_data;
172 if (NULL != in_req) {
173 /* Allocate memory */
174 req = (ZigbeeZclAlarmResetAlarm_t *)
175 g_malloc0(sizeof(ZigbeeZclAlarmResetAlarm_t));
178 req->node_id = in_req->node_id;
179 req->endpoint = in_req->endpoint;
180 req->alarm_code = in_req->alarm_code;
181 req->cluster_id = in_req->cluster_id;
184 alarm_request_data = (gpointer)req;
188 case ZBLIB_ZCL_ALARM_OPS_RESET_ALL_ALARM: {
189 ZigbeeZclAlarmResetAllAlarm_t *in_req;
190 ZigbeeZclAlarmResetAllAlarm_t *req = NULL;
192 in_req = (ZigbeeZclAlarmResetAllAlarm_t *)request_data;
194 /* Allocate memory */
195 req = (ZigbeeZclAlarmResetAllAlarm_t *)
196 g_malloc0(sizeof(ZigbeeZclAlarmResetAllAlarm_t));
199 req->node_id = in_req->node_id;
200 req->endpoint = in_req->endpoint;
203 alarm_request_data = (gpointer)req;
207 case ZBLIB_ZCL_ALARM_OPS_ALARM: {
208 ZigbeeZclAlarmAlarm_t *in_req;
209 ZigbeeZclAlarmAlarm_t *req = NULL;
211 in_req = (ZigbeeZclAlarmAlarm_t *)request_data;
213 /* Allocate memory */
214 req = (ZigbeeZclAlarmAlarm_t *)
215 g_malloc0(sizeof(ZigbeeZclAlarmAlarm_t));
218 memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
219 req->endpoint = in_req->endpoint;
220 req->alarm_code = in_req->alarm_code;
221 req->cluster_id = in_req->cluster_id;
224 alarm_request_data = (gpointer)req;
228 case ZBLIB_ZCL_ALARM_OPS_RESET_ALARM_LOG: {
229 ZigbeeZclAlarmResetAlarmLogs_t *in_req;
230 ZigbeeZclAlarmResetAlarmLogs_t *req = NULL;
232 in_req = (ZigbeeZclAlarmResetAlarmLogs_t *)request_data;
234 /* Allocate memory */
235 req = (ZigbeeZclAlarmResetAlarmLogs_t *)
236 g_malloc0(sizeof(ZigbeeZclAlarmResetAlarmLogs_t));
239 req->node_id = in_req->node_id;
240 req->endpoint = in_req->endpoint;
243 alarm_request_data = (gpointer)req;
247 case ZBLIB_ZCL_ALARM_OPS_GET_ALARM: {
248 ZigbeeZclAlarmGetAlarm_t *in_req;
249 ZigbeeZclAlarmGetAlarm_t *req = NULL;
251 in_req = (ZigbeeZclAlarmGetAlarm_t *)request_data;
253 /* Allocate memory */
254 req = (ZigbeeZclAlarmGetAlarm_t *)
255 g_malloc0(sizeof(ZigbeeZclAlarmGetAlarm_t));
258 req->node_id = in_req->node_id;
259 req->endpoint = in_req->endpoint;
262 alarm_request_data = (gpointer)req;
270 return alarm_request_data;
273 static gpointer __zblib_request_create_custom_request_data(guint request_type,
274 gpointer request_data, guint request_data_len)
276 gpointer custom_request_data = NULL;
279 NOT_USED(request_data_len);
282 ops_id = __zblib_request_get_ops_id(request_type);
284 case ZBLIB_CUSTOM_OPS_APS_SEND: {
285 ZigbeeCustomApsSend_t *in_req;
286 ZigbeeCustomApsSend_t *req = NULL;
288 in_req = (ZigbeeCustomApsSend_t *)request_data;
290 /* Allocate memory */
291 req = (ZigbeeCustomApsSend_t *)
292 g_malloc0(sizeof(ZigbeeCustomApsSend_t));
295 req->node_id = in_req->node_id;
296 req->aps_frame_ctrl = in_req->aps_frame_ctrl;
297 req->src_ep = in_req->src_ep;
298 req->dest_ep = in_req->dest_ep;
299 req->cluster_id = in_req->cluster_id;
300 req->profile_id = in_req->profile_id;
301 req->zcl_frame_ctrl = in_req->zcl_frame_ctrl;
302 req->mfg_code = in_req->mfg_code;
303 req->cmd_id = in_req->cmd_id;
304 req->payload_len = in_req->payload_len;
306 in_req->payload, req->payload_len);
309 custom_request_data = (gpointer)req;
313 case ZBLIB_CUSTOM_OPS_ZCL_SEND: {
314 ZigbeeCustomZclSend_t *in_req;
315 ZigbeeCustomZclSend_t *req = NULL;
317 in_req = (ZigbeeCustomZclSend_t *)request_data;
319 /* Allocate memory */
320 req = (ZigbeeCustomZclSend_t *)
321 g_malloc0(sizeof(ZigbeeCustomZclSend_t));
324 req->node_id = in_req->node_id;
325 req->src_ep = in_req->src_ep;
326 req->dest_ep = in_req->dest_ep;
327 req->cluster_id = in_req->cluster_id;
328 req->zcl_frame_ctrl = in_req->zcl_frame_ctrl;
329 req->cmd_id = in_req->cmd_id;
330 req->payload_len = in_req->payload_len;
332 in_req->payload, req->payload_len);
335 custom_request_data = (gpointer)req;
339 case ZBLIB_CUSTOM_OPS_SEND_TO_LOCAL: {
340 ZigbeeCustomSendToLocal_t *in_req;
341 ZigbeeCustomSendToLocal_t *req = NULL;
343 in_req = (ZigbeeCustomSendToLocal_t *)request_data;
345 /* Allocate memory */
346 req = (ZigbeeCustomSendToLocal_t *)
347 g_malloc0(sizeof(ZigbeeCustomSendToLocal_t));
350 req->length = in_req->length;
352 in_req->data, req->length);
355 custom_request_data = (gpointer)req;
363 return custom_request_data;
366 static gpointer __zblib_request_create_zcl_door_lock_request_data(guint request_type,
367 gpointer request_data, guint request_data_len)
369 gpointer door_lock_request_data = NULL;
372 NOT_USED(request_data_len);
375 ops_id = __zblib_request_get_ops_id(request_type);
377 case ZBLIB_ZCL_DOOR_LOCK_OPS_SUBSCRIBE_LOCK_EVENT: {
378 ZigbeeZclDoorLockSubscriberLockEvent_t *in_req;
379 ZigbeeZclDoorLockSubscriberLockEvent_t *req = NULL;
381 in_req = (ZigbeeZclDoorLockSubscriberLockEvent_t *)request_data;
383 /* Allocate memory */
384 req = (ZigbeeZclDoorLockSubscriberLockEvent_t *)
385 g_malloc0(sizeof(ZigbeeZclDoorLockSubscriberLockEvent_t));
389 in_req->eui64, ZIGBEE_EUI64_SIZE);
390 req->endpoint = in_req->endpoint;
393 door_lock_request_data = (gpointer)req;
397 case ZBLIB_ZCL_DOOR_LOCK_OPS_SET_DOOR_LOCK_PIN: {
398 ZigbeeZclDoorLockSetDoorLockPin_t *in_req;
399 ZigbeeZclDoorLockSetDoorLockPin_t *req = NULL;
401 in_req = (ZigbeeZclDoorLockSetDoorLockPin_t *)request_data;
403 /* Allocate memory */
404 req = (ZigbeeZclDoorLockSetDoorLockPin_t *)
405 g_malloc0(sizeof(ZigbeeZclDoorLockSetDoorLockPin_t));
408 req->uid = in_req->uid;
409 req->ustatus = in_req->ustatus;
410 req->utype = in_req->utype;
412 in_req->eui64, ZIGBEE_EUI64_SIZE);
413 req->endpoint = in_req->endpoint;
415 in_req->pin, ZIGBEE_DOOR_LOCK_MAX_PIN_LEN);
418 door_lock_request_data = (gpointer)req;
422 case ZBLIB_ZCL_DOOR_LOCK_OPS_SET_DOOR_LOCK: {
423 ZigbeeZclDoorLockSetDoorLock_t *in_req;
424 ZigbeeZclDoorLockSetDoorLock_t *req = NULL;
426 in_req = (ZigbeeZclDoorLockSetDoorLock_t *)request_data;
428 /* Allocate memory */
429 req = (ZigbeeZclDoorLockSetDoorLock_t *)
430 g_malloc0(sizeof(ZigbeeZclDoorLockSetDoorLock_t));
434 in_req->eui64, ZIGBEE_EUI64_SIZE);
435 req->endpoint = in_req->endpoint;
437 in_req->pin, ZIGBEE_DOOR_LOCK_MAX_PIN_LEN);
438 req->lock_unlock_type = in_req->lock_unlock_type;
441 door_lock_request_data = (gpointer)req;
445 case ZBLIB_ZCL_DOOR_LOCK_OPS_GET_LOCK_STATE: {
446 ZigbeeZclDoorLockGetDoorLock_t *in_req;
447 ZigbeeZclDoorLockGetDoorLock_t *req = NULL;
449 in_req = (ZigbeeZclDoorLockGetDoorLock_t *)request_data;
451 /* Allocate memory */
452 req = (ZigbeeZclDoorLockGetDoorLock_t *)
453 g_malloc0(sizeof(ZigbeeZclDoorLockGetDoorLock_t));
457 in_req->eui64, ZIGBEE_EUI64_SIZE);
458 req->endpoint = in_req->endpoint;
461 door_lock_request_data = (gpointer)req;
469 return door_lock_request_data;
472 static gpointer __zblib_request_create_zcl_fan_control_request_data(guint request_type,
473 gpointer request_data, guint request_data_len)
475 gpointer fan_control_request_data = NULL;
478 NOT_USED(request_data_len);
481 ops_id = __zblib_request_get_ops_id(request_type);
483 case ZBLIB_ZCL_FAN_CONTROL_OPS_SET_FAN_MODE: {
484 ZigbeeZclFanControlSetFanMode_t *in_req;
485 ZigbeeZclFanControlSetFanMode_t *req = NULL;
487 in_req = (ZigbeeZclFanControlSetFanMode_t *)request_data;
489 /* Allocate memory */
490 req = (ZigbeeZclFanControlSetFanMode_t *)
491 g_malloc0(sizeof(ZigbeeZclFanControlSetFanMode_t));
495 in_req->eui64, ZIGBEE_EUI64_SIZE);
496 req->endpoint = in_req->endpoint;
499 fan_control_request_data = (gpointer)req;
503 case ZBLIB_ZCL_FAN_CONTROL_OPS_GET_FAN_MODE: {
504 ZigbeeZclFanControlGetFanMode_t *in_req;
505 ZigbeeZclFanControlGetFanMode_t *req = NULL;
507 in_req = (ZigbeeZclFanControlGetFanMode_t *)request_data;
509 /* Allocate memory */
510 req = (ZigbeeZclFanControlGetFanMode_t *)
511 g_malloc0(sizeof(ZigbeeZclFanControlGetFanMode_t));
515 in_req->eui64, ZIGBEE_EUI64_SIZE);
516 req->endpoint = in_req->endpoint;
519 fan_control_request_data = (gpointer)req;
523 case ZBLIB_ZCL_FAN_CONTROL_OPS_SET_FAN_MODE_SEQUENCE: {
524 ZigbeeZclFanControlSetFanModeSequence_t *in_req;
525 ZigbeeZclFanControlSetFanModeSequence_t *req = NULL;
527 in_req = (ZigbeeZclFanControlSetFanModeSequence_t *)request_data;
529 /* Allocate memory */
530 req = (ZigbeeZclFanControlSetFanModeSequence_t *)
531 g_malloc0(sizeof(ZigbeeZclFanControlSetFanModeSequence_t));
535 in_req->eui64, ZIGBEE_EUI64_SIZE);
536 req->endpoint = in_req->endpoint;
539 fan_control_request_data = (gpointer)req;
543 case ZBLIB_ZCL_FAN_CONTROL_OPS_GET_FAN_MODE_SEQUENCE: {
544 ZigbeeZclFanControlGetFanModeSequence_t *in_req;
545 ZigbeeZclFanControlGetFanModeSequence_t *req = NULL;
547 in_req = (ZigbeeZclFanControlGetFanModeSequence_t *)request_data;
549 /* Allocate memory */
550 req = (ZigbeeZclFanControlGetFanModeSequence_t *)
551 g_malloc0(sizeof(ZigbeeZclFanControlGetFanModeSequence_t));
555 in_req->eui64, ZIGBEE_EUI64_SIZE);
556 req->endpoint = in_req->endpoint;
559 fan_control_request_data = (gpointer)req;
567 return fan_control_request_data;
570 static gpointer __zblib_request_create_zcl_level_control_request_data(guint request_type,
571 gpointer request_data, guint request_data_len)
573 gpointer level_control_request_data = NULL;
576 NOT_USED(request_data_len);
579 ops_id = __zblib_request_get_ops_id(request_type);
581 case ZBLIB_ZCL_LEVEL_CONTROL_OPS_MOVE_TO_LEVEL: {
582 ZigbeeZclLevelControlMoveToLevel_t *in_req;
583 ZigbeeZclLevelControlMoveToLevel_t *req = NULL;
585 in_req = (ZigbeeZclLevelControlMoveToLevel_t *)request_data;
587 /* Allocate memory */
588 req = (ZigbeeZclLevelControlMoveToLevel_t *)
589 g_malloc0(sizeof(ZigbeeZclLevelControlMoveToLevel_t));
592 req->node_id = in_req->node_id;
593 req->endpoint = in_req->endpoint;
594 req->level = in_req->level;
595 req->transition = in_req->transition;
598 level_control_request_data = (gpointer)req;
602 case ZBLIB_ZCL_LEVEL_CONTROL_OPS_MOVE: {
603 ZigbeeZclLevelControlMove_t *in_req;
604 ZigbeeZclLevelControlMove_t *req = NULL;
606 in_req = (ZigbeeZclLevelControlMove_t *)request_data;
608 /* Allocate memory */
609 req = (ZigbeeZclLevelControlMove_t *)
610 g_malloc0(sizeof(ZigbeeZclLevelControlMove_t));
613 req->node_id = in_req->node_id;
614 req->endpoint = in_req->endpoint;
615 req->move_mode = in_req->move_mode;
616 req->rate = in_req->rate;
619 level_control_request_data = (gpointer)req;
623 case ZBLIB_ZCL_LEVEL_CONTROL_OPS_STEP: {
624 ZigbeeZclLevelControlStep_t *in_req;
625 ZigbeeZclLevelControlStep_t *req = NULL;
627 in_req = (ZigbeeZclLevelControlStep_t *)request_data;
629 /* Allocate memory */
630 req = (ZigbeeZclLevelControlStep_t *)
631 g_malloc0(sizeof(ZigbeeZclLevelControlStep_t));
634 req->node_id = in_req->node_id;
635 req->endpoint = in_req->endpoint;
636 req->step_mode = in_req->step_mode;
637 req->step_size = in_req->step_size;
638 req->transition_time = in_req->transition_time;
641 level_control_request_data = (gpointer)req;
645 case ZBLIB_ZCL_LEVEL_CONTROL_OPS_MOVE_TO_LEVEL_WITH_ON_OFF: {
646 ZigbeeZclLevelControlMoveToLevelWithOnOff_t *in_req;
647 ZigbeeZclLevelControlMoveToLevelWithOnOff_t *req = NULL;
649 in_req = (ZigbeeZclLevelControlMoveToLevelWithOnOff_t *)request_data;
651 /* Allocate memory */
652 req = (ZigbeeZclLevelControlMoveToLevelWithOnOff_t *)
653 g_malloc0(sizeof(ZigbeeZclLevelControlMoveToLevelWithOnOff_t));
656 req->node_id = in_req->node_id;
657 req->endpoint = in_req->endpoint;
658 req->level = in_req->level;
659 req->transition = in_req->transition;
662 level_control_request_data = (gpointer)req;
666 case ZBLIB_ZCL_LEVEL_CONTROL_OPS_MOVE_WITH_ON_OFF: {
667 ZigbeeZclLevelControlMoveWithOnOff_t *in_req;
668 ZigbeeZclLevelControlMoveWithOnOff_t *req = NULL;
670 in_req = (ZigbeeZclLevelControlMoveWithOnOff_t *)request_data;
672 /* Allocate memory */
673 req = (ZigbeeZclLevelControlMoveWithOnOff_t *)
674 g_malloc0(sizeof(ZigbeeZclLevelControlMoveWithOnOff_t));
677 req->node_id = in_req->node_id;
678 req->endpoint = in_req->endpoint;
679 req->move_mode = in_req->move_mode;
680 req->rate = in_req->rate;
683 level_control_request_data = (gpointer)req;
687 case ZBLIB_ZCL_LEVEL_CONTROL_OPS_STEP_WITH_ON_OFF: {
688 ZigbeeZclLevelControlStepWithOnOff_t *in_req;
689 ZigbeeZclLevelControlStepWithOnOff_t *req = NULL;
691 in_req = (ZigbeeZclLevelControlStepWithOnOff_t *)request_data;
693 /* Allocate memory */
694 req = (ZigbeeZclLevelControlStepWithOnOff_t *)
695 g_malloc0(sizeof(ZigbeeZclLevelControlStepWithOnOff_t));
698 req->node_id = in_req->node_id;
699 req->endpoint = in_req->endpoint;
700 req->step_mode = in_req->step_mode;
701 req->step_size = in_req->step_size;
702 req->transition_time = in_req->transition_time;
705 level_control_request_data = (gpointer)req;
709 case ZBLIB_ZCL_LEVEL_CONTROL_OPS_STOP: {
710 ZigbeeZclLevelControlStop_t *in_req;
711 ZigbeeZclLevelControlStop_t *req = NULL;
713 in_req = (ZigbeeZclLevelControlStop_t *)request_data;
715 /* Allocate memory */
716 req = (ZigbeeZclLevelControlStop_t *)
717 g_malloc0(sizeof(ZigbeeZclLevelControlStop_t));
720 req->node_id = in_req->node_id;
721 req->endpoint = in_req->endpoint;
724 level_control_request_data = (gpointer)req;
732 return level_control_request_data;
735 static gpointer __zblib_request_create_mfglib_control_request_data(guint request_type,
736 gpointer request_data, guint request_data_len)
738 gpointer mfglib_control_request_data = NULL;
741 NOT_USED(request_data_len);
744 ops_id = __zblib_request_get_ops_id(request_type);
746 case ZBLIB_MFGLIB_CONTROL_OPS_START: {
747 ZigbeeMfglibControlStart_t *in_req;
748 ZigbeeMfglibControlStart_t *req = NULL;
750 in_req = (ZigbeeMfglibControlStart_t *)request_data;
751 if (NULL != in_req) {
752 /* Allocate memory */
753 req = (ZigbeeMfglibControlStart_t *)
754 g_malloc0(sizeof(ZigbeeMfglibControlStart_t));
757 memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
758 req->mfglib_start = in_req->mfglib_start;
761 mfglib_control_request_data = (gpointer)req;
765 case ZBLIB_MFGLIB_CONTROL_OPS_END: {
766 ZigbeeMfglibControlEnd_t *in_req;
767 ZigbeeMfglibControlEnd_t *req = NULL;
769 in_req = (ZigbeeMfglibControlEnd_t *)request_data;
770 if (NULL != in_req) {
771 /* Allocate memory */
772 req = (ZigbeeMfglibControlEnd_t *)
773 g_malloc0(sizeof(ZigbeeMfglibControlEnd_t));
776 memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
779 mfglib_control_request_data = (gpointer)req;
783 case ZBLIB_MFGLIB_CONTROL_OPS_START_TONE: {
784 ZigbeeMfglibControlStartTone_t *in_req;
785 ZigbeeMfglibControlStartTone_t *req = NULL;
787 in_req = (ZigbeeMfglibControlStartTone_t *)request_data;
788 if (NULL != in_req) {
789 /* Allocate memory */
790 req = (ZigbeeMfglibControlStartTone_t *)
791 g_malloc0(sizeof(ZigbeeMfglibControlStartTone_t));
794 memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
797 mfglib_control_request_data = (gpointer)req;
801 case ZBLIB_MFGLIB_CONTROL_OPS_STOP_TONE: {
802 ZigbeeMfglibControlStopTone_t *in_req;
803 ZigbeeMfglibControlStopTone_t *req = NULL;
805 in_req = (ZigbeeMfglibControlStopTone_t *)request_data;
806 if (NULL != in_req) {
807 /* Allocate memory */
808 req = (ZigbeeMfglibControlStopTone_t *)
809 g_malloc0(sizeof(ZigbeeMfglibControlStopTone_t));
812 memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
815 mfglib_control_request_data = (gpointer)req;
819 case ZBLIB_MFGLIB_CONTROL_OPS_START_STREAM: {
820 ZigbeeMfglibControlStartStream_t *in_req;
821 ZigbeeMfglibControlStartStream_t *req = NULL;
823 in_req = (ZigbeeMfglibControlStartStream_t *)request_data;
824 if (NULL != in_req) {
825 /* Allocate memory */
826 req = (ZigbeeMfglibControlStartStream_t *)
827 g_malloc0(sizeof(ZigbeeMfglibControlStartStream_t));
830 memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
833 mfglib_control_request_data = (gpointer)req;
837 case ZBLIB_MFGLIB_CONTROL_OPS_STOP_STREAM: {
838 ZigbeeMfglibControlStopStream_t *in_req;
839 ZigbeeMfglibControlStopStream_t *req = NULL;
841 in_req = (ZigbeeMfglibControlStopStream_t *)request_data;
842 if (NULL != in_req) {
843 /* Allocate memory */
844 req = (ZigbeeMfglibControlStopStream_t *)
845 g_malloc0(sizeof(ZigbeeMfglibControlStopStream_t));
848 memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
851 mfglib_control_request_data = (gpointer)req;
855 case ZBLIB_MFGLIB_CONTROL_OPS_SEND_PACKET: {
856 ZigbeeMfglibControlSendPacket_t *in_req;
857 ZigbeeMfglibControlSendPacket_t *req = NULL;
859 in_req = (ZigbeeMfglibControlSendPacket_t *)request_data;
860 if (NULL != in_req) {
861 /* Allocate memory */
862 req = (ZigbeeMfglibControlSendPacket_t *)
863 g_malloc0(sizeof(ZigbeeMfglibControlSendPacket_t));
866 memcpy(req->packet_content,
867 in_req->packet_content,
868 ZIGBEE_MFGLIB_CONTROL_PACKET_CONTENT_LEN);
869 req->packet_length = in_req->packet_length;
872 mfglib_control_request_data = (gpointer)req;
876 case ZBLIB_MFGLIB_CONTROL_OPS_SET_CHANNEL: {
877 ZigbeeMfglibControlSetChannel_t *in_req;
878 ZigbeeMfglibControlSetChannel_t *req = NULL;
880 in_req = (ZigbeeMfglibControlSetChannel_t *)request_data;
881 if (NULL != in_req) {
882 /* Allocate memory */
883 req = (ZigbeeMfglibControlSetChannel_t *)
884 g_malloc0(sizeof(ZigbeeMfglibControlSetChannel_t));
887 memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
888 req->channel = in_req->channel;
891 mfglib_control_request_data = (gpointer)req;
895 case ZBLIB_MFGLIB_CONTROL_OPS_GET_CHANNEL: {
896 ZigbeeMfglibControlGetChannel_t *in_req;
897 ZigbeeMfglibControlGetChannel_t *req = NULL;
899 in_req = (ZigbeeMfglibControlGetChannel_t *)request_data;
900 if (NULL != in_req) {
901 /* Allocate memory */
902 req = (ZigbeeMfglibControlGetChannel_t *)
903 g_malloc0(sizeof(ZigbeeMfglibControlGetChannel_t));
906 memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
909 mfglib_control_request_data = (gpointer)req;
913 case ZBLIB_MFGLIB_CONTROL_OPS_SET_POWER: {
914 ZigbeeMfglibControlSetPower_t *in_req;
915 ZigbeeMfglibControlSetPower_t *req = NULL;
917 in_req = (ZigbeeMfglibControlSetPower_t *)request_data;
918 if (NULL != in_req) {
919 /* Allocate memory */
920 req = (ZigbeeMfglibControlSetPower_t *)
921 g_malloc0(sizeof(ZigbeeMfglibControlSetPower_t));
924 memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
925 req->tx_power_mode = in_req->tx_power_mode;
926 req->power = in_req->power;
929 mfglib_control_request_data = (gpointer)req;
933 case ZBLIB_MFGLIB_CONTROL_OPS_GET_POWER: {
934 ZigbeeMfglibControlGetPower_t *in_req;
935 ZigbeeMfglibControlGetPower_t *req = NULL;
937 in_req = (ZigbeeMfglibControlGetPower_t *)request_data;
938 if (NULL != in_req) {
939 /* Allocate memory */
940 req = (ZigbeeMfglibControlGetPower_t *)
941 g_malloc0(sizeof(ZigbeeMfglibControlGetPower_t));
944 memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
947 mfglib_control_request_data = (gpointer)req;
951 case ZBLIB_MFGLIB_CONTROL_OPS_SET_SYNOFFSET: {
952 ZigbeeMfglibControlSetSynOffset_t *in_req;
953 ZigbeeMfglibControlSetSynOffset_t *req = NULL;
955 in_req = (ZigbeeMfglibControlSetSynOffset_t *)request_data;
956 if (NULL != in_req) {
957 /* Allocate memory */
958 req = (ZigbeeMfglibControlSetSynOffset_t *)
959 g_malloc0(sizeof(ZigbeeMfglibControlSetSynOffset_t));
962 memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
963 req->channel = in_req->channel;
966 mfglib_control_request_data = (gpointer)req;
970 case ZBLIB_MFGLIB_CONTROL_OPS_GET_SYNOFFSET: {
971 ZigbeeMfglibControlGetSynOffset_t *in_req;
972 ZigbeeMfglibControlGetSynOffset_t *req = NULL;
974 in_req = (ZigbeeMfglibControlGetSynOffset_t *)request_data;
975 if (NULL != in_req) {
976 /* Allocate memory */
977 req = (ZigbeeMfglibControlGetSynOffset_t *)
978 g_malloc0(sizeof(ZigbeeMfglibControlGetSynOffset_t));
983 ZIGBEE_MFGLIB_CONTROL_PACKET_CONTENT_LEN);
984 req->packet_length = in_req->packet_length;
985 req->link_quality = in_req->link_quality;
986 req->rssi = in_req->rssi;
989 mfglib_control_request_data = (gpointer)req;
993 case ZBLIB_MFGLIB_CONTROL_OPS_RX_START: {
994 ZigbeeMfglibControlRxStart_t *in_req;
995 ZigbeeMfglibControlRxStart_t *req = NULL;
997 in_req = (ZigbeeMfglibControlRxStart_t *)request_data;
998 if (NULL != in_req) {
999 /* Allocate memory */
1000 req = (ZigbeeMfglibControlRxStart_t *)
1001 g_malloc0(sizeof(ZigbeeMfglibControlRxStart_t));
1004 memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
1007 mfglib_control_request_data = (gpointer)req;
1011 case ZBLIB_MFGLIB_CONTROL_OPS_RX_STOP: {
1012 ZigbeeMfglibControlRxStop_t *in_req;
1013 ZigbeeMfglibControlRxStop_t *req = NULL;
1015 in_req = (ZigbeeMfglibControlRxStop_t *)request_data;
1016 if (NULL != in_req) {
1017 /* Allocate memory */
1018 req = (ZigbeeMfglibControlRxStop_t *)
1019 g_malloc0(sizeof(ZigbeeMfglibControlRxStop_t));
1022 memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
1025 mfglib_control_request_data = (gpointer)req;
1029 case ZBLIB_MFGLIB_CONTROL_OPS_RX_VERIFY: {
1030 ZigbeeMfglibControlRxVerify_t *in_req;
1031 ZigbeeMfglibControlRxVerify_t *req = NULL;
1033 in_req = (ZigbeeMfglibControlRxVerify_t *)request_data;
1034 if (NULL != in_req) {
1035 /* Allocate memory */
1036 req = (ZigbeeMfglibControlRxVerify_t *)
1037 g_malloc0(sizeof(ZigbeeMfglibControlRxVerify_t));
1040 memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
1043 mfglib_control_request_data = (gpointer)req;
1047 case ZBLIB_MFGLIB_CONTROL_OPS_GET_RSSI: {
1048 ZigbeeMfglibControlGetRssi_t *in_req;
1049 ZigbeeMfglibControlGetRssi_t *req = NULL;
1051 in_req = (ZigbeeMfglibControlGetRssi_t *)request_data;
1052 if (NULL != in_req) {
1053 /* Allocate memory */
1054 req = (ZigbeeMfglibControlGetRssi_t *)
1055 g_malloc0(sizeof(ZigbeeMfglibControlGetRssi_t));
1058 memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
1061 mfglib_control_request_data = (gpointer)req;
1069 return mfglib_control_request_data;
1072 static gpointer __zblib_request_create_zcl_on_off_request_data(guint request_type,
1073 gpointer request_data, guint request_data_len)
1075 gpointer on_off_request_data = NULL;
1078 NOT_USED(request_data_len);
1081 ops_id = __zblib_request_get_ops_id(request_type);
1083 case ZBLIB_ZCL_ON_OFF_OPS_SET_ON_OFF: {
1084 ZigbeeZclOnOffSetOnOff_t *in_req;
1085 ZigbeeZclOnOffSetOnOff_t *req = NULL;
1087 in_req = (ZigbeeZclOnOffSetOnOff_t *)request_data;
1088 if (NULL != in_req) {
1089 /* Allocate memory */
1090 req = (ZigbeeZclOnOffSetOnOff_t *)
1091 g_malloc0(sizeof(ZigbeeZclOnOffSetOnOff_t));
1094 req->node_id = in_req->node_id;
1095 req->endpoint = in_req->endpoint;
1096 req->on_off_type = in_req->on_off_type;
1099 on_off_request_data = (gpointer)req;
1103 case ZBLIB_ZCL_ON_OFF_OPS_GET_ON_OFF_STATE: {
1104 ZigbeeZclOnOffGetOnOffState_t *in_req;
1105 ZigbeeZclOnOffGetOnOffState_t *req = NULL;
1107 in_req = (ZigbeeZclOnOffGetOnOffState_t *)request_data;
1108 if (NULL != in_req) {
1109 /* Allocate memory */
1110 req = (ZigbeeZclOnOffGetOnOffState_t *)
1111 g_malloc0(sizeof(ZigbeeZclOnOffGetOnOffState_t));
1114 req->node_id = in_req->node_id;
1115 req->endpoint = in_req->endpoint;
1118 on_off_request_data = (gpointer)req;
1126 return on_off_request_data;
1129 static gpointer __zblib_request_create_service_request_data(guint request_type,
1130 gpointer request_data, guint request_data_len)
1132 gpointer service_request_data = NULL;
1135 NOT_USED(request_data_len);
1138 ops_id = __zblib_request_get_ops_id(request_type);
1140 case ZBLIB_SERVICE_OPS_ZB_HW_RESET: {
1141 service_request_data = NULL;
1145 case ZBLIB_SERVICE_OPS_FORM_NETWORK: {
1146 service_request_data = NULL;
1150 case ZBLIB_SERVICE_OPS_COEX_START: {
1151 ZigbeeServiceCoexStart_t *in_req;
1152 ZigbeeServiceCoexStart_t *req = NULL;
1154 in_req = (ZigbeeServiceCoexStart_t *)request_data;
1155 if (NULL != in_req) {
1156 /* Allocate memory */
1157 req = (ZigbeeServiceCoexStart_t *)
1158 g_malloc0(sizeof(ZigbeeServiceCoexStart_t));
1161 req->channel = in_req->channel;
1164 service_request_data = (gpointer)req;
1168 case ZBLIB_SERVICE_OPS_COEX_STOP: {
1169 service_request_data = NULL;
1173 case ZBLIB_SERVICE_OPS_LEAVE_NETWORK: {
1174 service_request_data = NULL;
1178 case ZBLIB_SERVICE_OPS_GET_NETWORK_INFO: {
1179 service_request_data = NULL;
1183 case ZBLIB_SERVICE_OPS_PERMIT_JOIN: {
1184 ZigbeeServicePermitJoin_t *in_req;
1185 ZigbeeServicePermitJoin_t *req = NULL;
1187 in_req = (ZigbeeServicePermitJoin_t *)request_data;
1188 if (NULL != in_req) {
1189 /* Allocate memory */
1190 req = (ZigbeeServicePermitJoin_t *)
1191 g_malloc0(sizeof(ZigbeeServicePermitJoin_t));
1194 req->permit_join = in_req->permit_join;
1195 req->duration = in_req->duration;
1198 service_request_data = (gpointer)req;
1202 case ZBLIB_SERVICE_OPS_LEAVE_REQUEST: {
1203 ZigbeeServiceLeaveRequest_t *in_req;
1204 ZigbeeServiceLeaveRequest_t *req = NULL;
1206 in_req = (ZigbeeServiceLeaveRequest_t *)request_data;
1207 if (NULL != in_req) {
1208 /* Allocate memory */
1209 req = (ZigbeeServiceLeaveRequest_t *)
1210 g_malloc0(sizeof(ZigbeeServiceLeaveRequest_t));
1213 memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
1214 req->remove_child = in_req->remove_child;
1215 req->rejoin = in_req->rejoin;
1218 service_request_data = (gpointer)req;
1222 case ZBLIB_SERVICE_OPS_GET_DEVICE_LIST: {
1223 service_request_data = NULL;
1227 case ZBLIB_SERVICE_OPS_GET_MAC: {
1228 service_request_data = NULL;
1232 case ZBLIB_SERVICE_OPS_GET_DEVICE_INFO: {
1233 service_request_data = NULL;
1237 case ZBLIB_SERVICE_OPS_GET_ENDPOINT_LIST: {
1238 ZigbeeServiceGetEndpointList_t *in_req;
1239 ZigbeeServiceGetEndpointList_t *req = NULL;
1241 in_req = (ZigbeeServiceGetEndpointList_t *)request_data;
1242 if (NULL != in_req) {
1243 /* Allocate memory */
1244 req = (ZigbeeServiceGetEndpointList_t *)
1245 g_malloc0(sizeof(ZigbeeServiceGetEndpointList_t));
1248 memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
1251 service_request_data = (gpointer)req;
1255 case ZBLIB_SERVICE_OPS_GET_CLUSTER_LIST: {
1256 ZigbeeServiceGetClusterList_t *in_req;
1257 ZigbeeServiceGetClusterList_t *req = NULL;
1259 in_req = (ZigbeeServiceGetClusterList_t *)request_data;
1260 if (NULL != in_req) {
1261 /* Allocate memory */
1262 req = (ZigbeeServiceGetClusterList_t *)
1263 g_malloc0(sizeof(ZigbeeServiceGetClusterList_t));
1266 memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
1267 req->endpoint = in_req->endpoint;
1270 service_request_data = (gpointer)req;
1274 case ZBLIB_SERVICE_OPS_GET_NODE_TYPE: {
1275 ZigbeeServiceGetNodeType_t *in_req;
1276 ZigbeeServiceGetNodeType_t *req = NULL;
1278 in_req = (ZigbeeServiceGetNodeType_t *)request_data;
1279 if (NULL != in_req) {
1280 /* Allocate memory */
1281 req = (ZigbeeServiceGetNodeType_t *)
1282 g_malloc0(sizeof(ZigbeeServiceGetNodeType_t));
1285 memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
1288 service_request_data = (gpointer)req;
1293 Z_LOGE("Unexpected operation [%x]", ops_id);
1297 return service_request_data;
1300 static gpointer __zblib_request_create_zcl_thermostat_request_data(guint request_type,
1301 gpointer request_data, guint request_data_len)
1303 gpointer thermostat_request_data = NULL;
1306 NOT_USED(request_data_len);
1309 ops_id = __zblib_request_get_ops_id(request_type);
1311 case ZBLIB_ZCL_THERMOSTAT_OPS_GET_LOCAL_TEMP: {
1312 ZigbeeZclThermostatGetLocalTemp_t *in_req;
1313 ZigbeeZclThermostatGetLocalTemp_t *req = NULL;
1315 in_req = (ZigbeeZclThermostatGetLocalTemp_t *)request_data;
1316 if (NULL != in_req) {
1317 /* Allocate memory */
1318 req = (ZigbeeZclThermostatGetLocalTemp_t *)
1319 g_malloc0(sizeof(ZigbeeZclThermostatGetLocalTemp_t));
1322 memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
1323 req->endpoint = in_req->endpoint;
1326 thermostat_request_data = (gpointer)req;
1330 case ZBLIB_ZCL_THERMOSTAT_OPS_GET_WEEKLY_SCHEDULE: {
1331 ZigbeeZclThermostatGetWeeklySchedule_t *in_req;
1332 ZigbeeZclThermostatGetWeeklySchedule_t *req = NULL;
1334 in_req = (ZigbeeZclThermostatGetWeeklySchedule_t *)request_data;
1335 if (NULL != in_req) {
1336 /* Allocate memory */
1337 req = (ZigbeeZclThermostatGetWeeklySchedule_t *)
1338 g_malloc0(sizeof(ZigbeeZclThermostatGetWeeklySchedule_t));
1341 memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
1342 req->endpoint = in_req->endpoint;
1343 req->num_of_days = in_req->num_of_days;
1344 req->mode = in_req->mode;
1347 thermostat_request_data = (gpointer)req;
1351 case ZBLIB_ZCL_THERMOSTAT_OPS_SET_WEEKLY_SCHEDULE: {
1352 ZigbeeZclThermostatSetWeeklySchedule_t *in_req;
1353 ZigbeeZclThermostatSetWeeklySchedule_t *req = NULL;
1355 in_req = (ZigbeeZclThermostatSetWeeklySchedule_t *)request_data;
1356 if (NULL != in_req) {
1357 /* Allocate memory */
1358 req = (ZigbeeZclThermostatSetWeeklySchedule_t *)
1359 g_malloc0(sizeof(ZigbeeZclThermostatSetWeeklySchedule_t));
1362 memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
1363 req->endpoint = in_req->endpoint;
1364 req->no_of_transitions = in_req->no_of_transitions;
1365 req->num_of_days = in_req->num_of_days;
1366 req->mode = in_req->mode;
1367 memcpy(req->payload,
1368 in_req->payload, ZIGBEE_THERMSTAT_PAYLOAD_MAX_LEN);
1369 req->payload_len = in_req->payload_len;
1372 thermostat_request_data = (gpointer)req;
1376 case ZBLIB_ZCL_THERMOSTAT_OPS_CLEAR_WEEKLY_SCHEDULE: {
1377 ZigbeeZclThermostatClearWeeklySchedule_t *in_req;
1378 ZigbeeZclThermostatClearWeeklySchedule_t *req = NULL;
1380 in_req = (ZigbeeZclThermostatClearWeeklySchedule_t *)request_data;
1381 if (NULL != in_req) {
1382 /* Allocate memory */
1383 req = (ZigbeeZclThermostatClearWeeklySchedule_t *)
1384 g_malloc0(sizeof(ZigbeeZclThermostatClearWeeklySchedule_t));
1387 memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
1388 req->endpoint = in_req->endpoint;
1391 thermostat_request_data = (gpointer)req;
1395 case ZBLIB_ZCL_THERMOSTAT_OPS_SETPOINT_RAISE_LOWER: {
1396 ZigbeeZclThermostatSetpointRaiseLower_t *in_req;
1397 ZigbeeZclThermostatSetpointRaiseLower_t *req = NULL;
1399 in_req = (ZigbeeZclThermostatSetpointRaiseLower_t *)request_data;
1400 if (NULL != in_req) {
1401 /* Allocate memory */
1402 req = (ZigbeeZclThermostatSetpointRaiseLower_t *)
1403 g_malloc0(sizeof(ZigbeeZclThermostatSetpointRaiseLower_t));
1406 req->node_id = in_req->node_id;
1407 req->endpoint = in_req->endpoint;
1408 req->mode = in_req->mode;
1409 req->amount = in_req->amount;
1412 thermostat_request_data = (gpointer)req;
1420 return thermostat_request_data;
1423 static gpointer __zblib_request_create_zcl_basic_request_data(guint request_type,
1424 gpointer request_data, guint request_data_len)
1426 gpointer zclbasic_control_request_data = NULL;
1429 NOT_USED(request_data_len);
1432 ops_id = __zblib_request_get_ops_id(request_type);
1434 case ZBLIB_ZCL_BASIC_OPS_RESET_FACTORY_DEFAULT: {
1435 ZigbeeZclBasicResetFactoryDefault_t *in_req;
1436 ZigbeeZclBasicResetFactoryDefault_t *req = NULL;
1438 in_req = (ZigbeeZclBasicResetFactoryDefault_t *)request_data;
1439 if (NULL != in_req) {
1440 /* Allocate memory */
1441 req = (ZigbeeZclBasicResetFactoryDefault_t *)
1442 g_malloc0(sizeof(ZigbeeZclBasicResetFactoryDefault_t));
1445 req->node_id = in_req->node_id;
1446 req->dest_ep = in_req->dest_ep;
1449 zclbasic_control_request_data = (gpointer)req;
1457 return zclbasic_control_request_data;
1460 static gpointer __zblib_request_create_zcl_global_control_request_data(guint request_type,
1461 gpointer request_data, guint request_data_len)
1463 gpointer zclglobal_control_request_data = NULL;
1466 NOT_USED(request_data_len);
1469 ops_id = __zblib_request_get_ops_id(request_type);
1471 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_READ_ATTRIBUTES_REQ: {
1472 ZigbeeZclGlobalControlReadAttributesRequest_t *in_req;
1473 ZigbeeZclGlobalControlReadAttributesRequest_t *req = NULL;
1475 in_req = (ZigbeeZclGlobalControlReadAttributesRequest_t *)request_data;
1476 if (NULL != in_req) {
1478 /* Allocate memory */
1479 req = (ZigbeeZclGlobalControlReadAttributesRequest_t *)
1480 g_malloc0(sizeof(ZigbeeZclGlobalControlReadAttributesRequest_t));
1483 for (i = 0; i < (in_req->attribute_id_len * sizeof(short)); i++)
1484 Z_LOGE("in_req->attribute_id[%d] = 0x%X", i, in_req->attribute_id[i]);
1485 req->attribute_id = g_memdup(in_req->attribute_id,
1486 in_req->attribute_id_len * sizeof(short));
1487 req->attribute_id_len = in_req->attribute_id_len;
1488 req->node_id = in_req->node_id;
1489 req->cluster_id = in_req->cluster_id;
1490 req->zcl_frame_ctrl = in_req->zcl_frame_ctrl;
1491 req->dest_ep = in_req->dest_ep;
1494 zclglobal_control_request_data = (gpointer)req;
1498 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_REQ: {
1499 ZigbeeZclGlobalControlWriteAttributesRequest_t *in_req;
1500 ZigbeeZclGlobalControlWriteAttributesRequest_t *req = NULL;
1502 in_req = (ZigbeeZclGlobalControlWriteAttributesRequest_t *)request_data;
1503 if (NULL != in_req) {
1504 /* Allocate memory */
1505 req = (ZigbeeZclGlobalControlWriteAttributesRequest_t *)
1506 g_malloc0(sizeof(ZigbeeZclGlobalControlWriteAttributesRequest_t));
1509 req->write_records = g_memdup(in_req->write_records, in_req->records_len);
1510 req->records_len = in_req->records_len;
1511 req->node_id = in_req->node_id;
1512 req->cluster_id = in_req->cluster_id;
1513 req->zcl_frame_ctrl = in_req->zcl_frame_ctrl;
1514 req->src_ep = in_req->src_ep;
1515 req->dest_ep = in_req->dest_ep;
1518 zclglobal_control_request_data = (gpointer)req;
1522 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_UNDIVIDED_REQ: {
1523 ZigbeeZclGlobalControlWriteAttributesUndividedRequest_t *in_req;
1524 ZigbeeZclGlobalControlWriteAttributesUndividedRequest_t *req = NULL;
1526 in_req = (ZigbeeZclGlobalControlWriteAttributesUndividedRequest_t *)request_data;
1527 if (NULL != in_req) {
1528 /* Allocate memory */
1529 req = (ZigbeeZclGlobalControlWriteAttributesUndividedRequest_t *)
1530 g_malloc0(sizeof(ZigbeeZclGlobalControlWriteAttributesUndividedRequest_t));
1533 req->write_records = g_memdup(in_req->write_records, in_req->records_len);
1534 req->records_len = in_req->records_len;
1535 req->node_id = in_req->node_id;
1536 req->cluster_id = in_req->cluster_id;
1537 req->zcl_frame_ctrl = in_req->zcl_frame_ctrl;
1538 req->src_ep = in_req->src_ep;
1539 req->dest_ep = in_req->dest_ep;
1542 zclglobal_control_request_data = (gpointer)req;
1546 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_NO_RESP: {
1547 ZigbeeZclGlobalControlWriteAttributesNoResponse_t *in_req;
1548 ZigbeeZclGlobalControlWriteAttributesNoResponse_t *req = NULL;
1550 in_req = (ZigbeeZclGlobalControlWriteAttributesNoResponse_t *)request_data;
1551 if (NULL != in_req) {
1552 /* Allocate memory */
1553 req = (ZigbeeZclGlobalControlWriteAttributesNoResponse_t *)
1554 g_malloc0(sizeof(ZigbeeZclGlobalControlWriteAttributesNoResponse_t));
1557 req->write_records = g_memdup(in_req->write_records, in_req->records_len);
1558 req->records_len = in_req->records_len;
1559 req->node_id = in_req->node_id;
1560 req->cluster_id = in_req->cluster_id;
1561 req->zcl_frame_ctrl = in_req->zcl_frame_ctrl;
1562 req->src_ep = in_req->src_ep;
1563 req->dest_ep = in_req->dest_ep;
1566 zclglobal_control_request_data = (gpointer)req;
1570 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_STRUCTURED: {
1571 ZigbeeZclGlobalControlWriteAttributesStructed_t *in_req;
1572 ZigbeeZclGlobalControlWriteAttributesStructed_t *req = NULL;
1574 in_req = (ZigbeeZclGlobalControlWriteAttributesStructed_t *)request_data;
1575 if (NULL != in_req) {
1576 /* Allocate memory */
1577 req = (ZigbeeZclGlobalControlWriteAttributesStructed_t *)
1578 g_malloc0(sizeof(ZigbeeZclGlobalControlWriteAttributesStructed_t));
1581 req->write_records = g_memdup(in_req->write_records, in_req->records_len);
1582 req->records_len = in_req->records_len;
1583 req->node_id = in_req->node_id;
1584 req->cluster_id = in_req->cluster_id;
1585 req->zcl_frame_ctrl = in_req->zcl_frame_ctrl;
1586 req->src_ep = in_req->src_ep;
1587 req->dest_ep = in_req->dest_ep;
1590 zclglobal_control_request_data = (gpointer)req;
1594 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_READ_ATTRIBUTES_STRUCTURED: {
1595 ZigbeeZclGlobalControlReadAttributesStructed_t *in_req;
1596 ZigbeeZclGlobalControlReadAttributesStructed_t *req = NULL;
1598 in_req = (ZigbeeZclGlobalControlReadAttributesStructed_t *)request_data;
1599 if (NULL != in_req) {
1600 /* Allocate memory */
1601 req = (ZigbeeZclGlobalControlReadAttributesStructed_t *)
1602 g_malloc0(sizeof(ZigbeeZclGlobalControlReadAttributesStructed_t));
1605 req->read_records = g_memdup(in_req->read_records, in_req->records_len);
1606 req->records_len = in_req->records_len;
1607 req->node_id = in_req->node_id;
1608 req->cluster_id = in_req->cluster_id;
1609 req->zcl_frame_ctrl = in_req->zcl_frame_ctrl;
1610 req->src_ep = in_req->src_ep;
1611 req->dest_ep = in_req->dest_ep;
1614 zclglobal_control_request_data = (gpointer)req;
1618 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_CONFIGURE_REPORTING_REQ: {
1619 ZigbeeZclGlobalControlConfigureReportingReq_t *in_req;
1620 ZigbeeZclGlobalControlConfigureReportingReq_t *req = NULL;
1622 in_req = (ZigbeeZclGlobalControlConfigureReportingReq_t *)request_data;
1623 if (NULL != in_req) {
1624 /* Allocate memory */
1625 req = (ZigbeeZclGlobalControlConfigureReportingReq_t *)
1626 g_malloc0(sizeof(ZigbeeZclGlobalControlConfigureReportingReq_t));
1629 req->read_records = g_memdup(in_req->read_records, in_req->records_len);
1630 req->records_len = in_req->records_len;
1631 req->node_id = in_req->node_id;
1632 req->cluster_id = in_req->cluster_id;
1633 req->zcl_frame_ctrl = in_req->zcl_frame_ctrl;
1634 req->src_ep = in_req->src_ep;
1635 req->dest_ep = in_req->dest_ep;
1638 zclglobal_control_request_data = (gpointer)req;
1642 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_READ_CONFIGURE_REPORTING: {
1643 ZigbeeZclGlobalControlReadConfigureReporting_t *in_req;
1644 ZigbeeZclGlobalControlReadConfigureReporting_t *req = NULL;
1646 in_req = (ZigbeeZclGlobalControlReadConfigureReporting_t *)request_data;
1647 if (NULL != in_req) {
1648 /* Allocate memory */
1649 req = (ZigbeeZclGlobalControlReadConfigureReporting_t *)
1650 g_malloc0(sizeof(ZigbeeZclGlobalControlReadConfigureReporting_t));
1653 req->read_records = g_memdup(in_req->read_records, in_req->records_len);
1654 req->records_len = in_req->records_len;
1655 req->node_id = in_req->node_id;
1656 req->cluster_id = in_req->cluster_id;
1657 req->zcl_frame_ctrl = in_req->zcl_frame_ctrl;
1658 req->src_ep = in_req->src_ep;
1659 req->dest_ep = in_req->dest_ep;
1662 zclglobal_control_request_data = (gpointer)req;
1666 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_DISCOVER_ATTRIBUTES: {
1667 ZigbeeZclGlobalControlDiscoverAttributes_t *in_req;
1668 ZigbeeZclGlobalControlDiscoverAttributes_t *req = NULL;
1670 in_req = (ZigbeeZclGlobalControlDiscoverAttributes_t *)request_data;
1671 if (NULL != in_req) {
1672 /* Allocate memory */
1673 req = (ZigbeeZclGlobalControlDiscoverAttributes_t *)
1674 g_malloc0(sizeof(ZigbeeZclGlobalControlDiscoverAttributes_t));
1677 req->node_id = in_req->node_id;
1678 req->dest_ep = in_req->dest_ep;
1679 req->zcl_frame_ctrl = in_req->zcl_frame_ctrl;
1680 req->cluster_id = in_req->cluster_id;
1681 req->start_attribute = in_req->start_attribute;
1682 req->max_attribute_count = in_req->max_attribute_count;
1685 zclglobal_control_request_data = (gpointer)req;
1689 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_DISCOVER_ATTRIBUTES_EXTENDED: {
1690 ZigbeeZclGlobalControlDiscoverAttributesExtended_t *in_req;
1691 ZigbeeZclGlobalControlDiscoverAttributesExtended_t *req = NULL;
1693 in_req = (ZigbeeZclGlobalControlDiscoverAttributesExtended_t *)request_data;
1694 if (NULL != in_req) {
1695 /* Allocate memory */
1696 req = (ZigbeeZclGlobalControlDiscoverAttributesExtended_t *)
1697 g_malloc0(sizeof(ZigbeeZclGlobalControlDiscoverAttributesExtended_t));
1700 req->node_id = in_req->node_id;
1701 req->dest_ep = in_req->dest_ep;
1702 req->zcl_frame_ctrl = in_req->zcl_frame_ctrl;
1703 req->cluster_id = in_req->cluster_id;
1704 req->start_attribute = in_req->start_attribute;
1705 req->max_attribute_count = in_req->max_attribute_count;
1708 zclglobal_control_request_data = (gpointer)req;
1712 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_DISCOVER_COMMANDS_RECEIVED: {
1713 ZigbeeZclGlobalControlDiscoverCommandsReceived_t *in_req;
1714 ZigbeeZclGlobalControlDiscoverCommandsReceived_t *req = NULL;
1716 in_req = (ZigbeeZclGlobalControlDiscoverCommandsReceived_t *)request_data;
1717 if (NULL != in_req) {
1718 /* Allocate memory */
1719 req = (ZigbeeZclGlobalControlDiscoverCommandsReceived_t *)
1720 g_malloc0(sizeof(ZigbeeZclGlobalControlDiscoverCommandsReceived_t));
1723 req->node_id = in_req->node_id;
1724 req->dest_ep = in_req->dest_ep;
1725 req->zcl_frame_ctrl = in_req->zcl_frame_ctrl;
1726 req->cluster_id = in_req->cluster_id;
1727 req->start_command = in_req->start_command;
1728 req->max_command_count = in_req->max_command_count;
1731 zclglobal_control_request_data = (gpointer)req;
1735 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_DISCOVER_COMMANDS_GENERATED: {
1736 ZigbeeZclGlobalControlDiscoverCommandsGenerated_t *in_req;
1737 ZigbeeZclGlobalControlDiscoverCommandsGenerated_t *req = NULL;
1739 in_req = (ZigbeeZclGlobalControlDiscoverCommandsGenerated_t *)request_data;
1740 if (NULL != in_req) {
1741 /* Allocate memory */
1742 req = (ZigbeeZclGlobalControlDiscoverCommandsGenerated_t *)
1743 g_malloc0(sizeof(ZigbeeZclGlobalControlDiscoverCommandsGenerated_t));
1746 req->node_id = in_req->node_id;
1747 req->dest_ep = in_req->dest_ep;
1748 req->zcl_frame_ctrl = in_req->zcl_frame_ctrl;
1749 req->cluster_id = in_req->cluster_id;
1750 req->start_command = in_req->start_command;
1751 req->max_command_count = in_req->max_command_count;
1754 zclglobal_control_request_data = (gpointer)req;
1762 return zclglobal_control_request_data;
1765 static gpointer __zblib_request_create_zcl_ias_zone_request_data(guint request_type,
1766 gpointer request_data, guint request_data_len)
1768 gpointer zclias_control_request_data = NULL;
1771 NOT_USED(request_data_len);
1774 ops_id = __zblib_request_get_ops_id(request_type);
1776 case ZBLIB_ZCL_IAS_ZONE_OPS_ENROLL_RESPONSE: {
1777 ZigbeeZclIasZoneEnrollResponse_t *in_req;
1778 ZigbeeZclIasZoneEnrollResponse_t *req = NULL;
1780 in_req = (ZigbeeZclIasZoneEnrollResponse_t *)request_data;
1781 if (NULL != in_req) {
1782 /* Allocate memory */
1783 req = (ZigbeeZclIasZoneEnrollResponse_t *)
1784 g_malloc0(sizeof(ZigbeeZclIasZoneEnrollResponse_t));
1787 req->node_id = in_req->node_id;
1788 req->dest_ep = in_req->dest_ep;
1789 req->enroll_code = in_req->enroll_code;
1790 req->zone_id = in_req->zone_id;
1793 zclias_control_request_data = (gpointer)req;
1801 return zclias_control_request_data;
1804 static gpointer __zblib_request_create_zcl_identify_request_data(guint request_type,
1805 gpointer request_data, guint request_data_len)
1807 gpointer zclidentify_control_request_data = NULL;
1810 NOT_USED(request_data_len);
1813 ops_id = __zblib_request_get_ops_id(request_type);
1815 case ZBLIB_ZCL_IDENTIFY_OPS_IDENTIFY: {
1816 ZigbeeZclIdentifyIdentify_t *in_req;
1817 ZigbeeZclIdentifyIdentify_t *req = NULL;
1819 in_req = (ZigbeeZclIdentifyIdentify_t *)request_data;
1820 if (NULL != in_req) {
1821 /* Allocate memory */
1822 req = (ZigbeeZclIdentifyIdentify_t *)
1823 g_malloc0(sizeof(ZigbeeZclIdentifyIdentify_t));
1826 req->node_id = in_req->node_id;
1827 req->dest_ep = in_req->dest_ep;
1828 req->identify_time = in_req->identify_time;
1831 zclidentify_control_request_data = (gpointer)req;
1835 case ZBLIB_ZCL_IDENTIFY_OPS_QUERY: {
1836 ZigbeeZclIdentifyQuery_t *in_req;
1837 ZigbeeZclIdentifyQuery_t *req = NULL;
1839 in_req = (ZigbeeZclIdentifyQuery_t *)request_data;
1840 if (NULL != in_req) {
1841 /* Allocate memory */
1842 req = (ZigbeeZclIdentifyQuery_t *)
1843 g_malloc0(sizeof(ZigbeeZclIdentifyQuery_t));
1846 req->node_id = in_req->node_id;
1847 req->dest_ep = in_req->dest_ep;
1850 zclidentify_control_request_data = (gpointer)req;
1858 return zclidentify_control_request_data;
1861 static gpointer __zblib_request_create_zcl_color_control_request_data(guint request_type,
1862 gpointer request_data, guint request_data_len)
1864 gpointer zcl_color_request_data = NULL;
1867 NOT_USED(request_data_len);
1870 ops_id = __zblib_request_get_ops_id(request_type);
1872 case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_TO_HUE: {
1873 ZigbeeZclColorControlMoveToHue_t *in_req;
1874 ZigbeeZclColorControlMoveToHue_t *req = NULL;
1876 in_req = (ZigbeeZclColorControlMoveToHue_t *)request_data;
1877 if (NULL != in_req) {
1878 /* Allocate memory */
1879 req = (ZigbeeZclColorControlMoveToHue_t *)
1880 g_malloc0(sizeof(ZigbeeZclColorControlMoveToHue_t));
1883 req->node_id = in_req->node_id;
1884 req->dest_ep = in_req->dest_ep;
1885 req->hue = in_req->hue;
1886 req->direction = in_req->direction;
1887 req->transition_time = in_req->transition_time;
1890 zcl_color_request_data = (gpointer)req;
1894 case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_HUE: {
1895 ZigbeeZclColorControlMoveHue_t *in_req;
1896 ZigbeeZclColorControlMoveHue_t *req = NULL;
1898 in_req = (ZigbeeZclColorControlMoveHue_t *)request_data;
1899 if (NULL != in_req) {
1900 /* Allocate memory */
1901 req = (ZigbeeZclColorControlMoveHue_t *)
1902 g_malloc0(sizeof(ZigbeeZclColorControlMoveHue_t));
1905 req->node_id = in_req->node_id;
1906 req->dest_ep = in_req->dest_ep;
1907 req->move_mode = in_req->move_mode;
1908 req->rate = in_req->rate;
1911 zcl_color_request_data = (gpointer)req;
1915 case ZBLIB_ZCL_COLOR_CONTROL_OPS_STEP_HUE: {
1916 ZigbeeZclColorControlStepHue_t *in_req;
1917 ZigbeeZclColorControlStepHue_t *req = NULL;
1919 in_req = (ZigbeeZclColorControlStepHue_t *)request_data;
1920 if (NULL != in_req) {
1921 /* Allocate memory */
1922 req = (ZigbeeZclColorControlStepHue_t *)
1923 g_malloc0(sizeof(ZigbeeZclColorControlStepHue_t));
1926 req->node_id = in_req->node_id;
1927 req->dest_ep = in_req->dest_ep;
1928 req->step_mode = in_req->step_mode;
1929 req->step_size = in_req->step_size;
1930 req->transition_time = in_req->transition_time;
1933 zcl_color_request_data = (gpointer)req;
1937 case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_TO_STAURATION: {
1938 ZigbeeZclColorControlMoveToSaturation_t *in_req;
1939 ZigbeeZclColorControlMoveToSaturation_t *req = NULL;
1941 in_req = (ZigbeeZclColorControlMoveToSaturation_t *)request_data;
1942 if (NULL != in_req) {
1943 /* Allocate memory */
1944 req = (ZigbeeZclColorControlMoveToSaturation_t *)
1945 g_malloc0(sizeof(ZigbeeZclColorControlMoveToSaturation_t));
1948 req->node_id = in_req->node_id;
1949 req->dest_ep = in_req->dest_ep;
1950 req->saturation = in_req->saturation;
1951 req->transition_time = in_req->transition_time;
1954 zcl_color_request_data = (gpointer)req;
1958 case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_STAURATION: {
1959 ZigbeeZclColorControlMoveSaturation_t *in_req;
1960 ZigbeeZclColorControlMoveSaturation_t *req = NULL;
1962 in_req = (ZigbeeZclColorControlMoveSaturation_t *)request_data;
1963 if (NULL != in_req) {
1964 /* Allocate memory */
1965 req = (ZigbeeZclColorControlMoveSaturation_t *)
1966 g_malloc0(sizeof(ZigbeeZclColorControlMoveSaturation_t));
1969 req->node_id = in_req->node_id;
1970 req->dest_ep = in_req->dest_ep;
1971 req->move_mode = in_req->move_mode;
1972 req->rate = in_req->rate;
1975 zcl_color_request_data = (gpointer)req;
1979 case ZBLIB_ZCL_COLOR_CONTROL_OPS_STEP_STAURATION: {
1980 ZigbeeZclColorControlStepSaturation_t *in_req;
1981 ZigbeeZclColorControlStepSaturation_t *req = NULL;
1983 in_req = (ZigbeeZclColorControlStepSaturation_t *)request_data;
1984 if (NULL != in_req) {
1985 /* Allocate memory */
1986 req = (ZigbeeZclColorControlStepSaturation_t *)
1987 g_malloc0(sizeof(ZigbeeZclColorControlStepSaturation_t));
1990 req->node_id = in_req->node_id;
1991 req->dest_ep = in_req->dest_ep;
1992 req->step_mode = in_req->step_mode;
1993 req->step_size = in_req->step_size;
1994 req->transition_time = in_req->transition_time;
1997 zcl_color_request_data = (gpointer)req;
2001 case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_TO_HUE_AND_SATURATION: {
2002 ZigbeeZclColorControlMoveToHueAndSaturation_t *in_req;
2003 ZigbeeZclColorControlMoveToHueAndSaturation_t *req = NULL;
2005 in_req = (ZigbeeZclColorControlMoveToHueAndSaturation_t *)request_data;
2006 if (NULL != in_req) {
2007 /* Allocate memory */
2008 req = (ZigbeeZclColorControlMoveToHueAndSaturation_t *)
2009 g_malloc0(sizeof(ZigbeeZclColorControlMoveToHueAndSaturation_t));
2012 req->node_id = in_req->node_id;
2013 req->dest_ep = in_req->dest_ep;
2014 req->hue = in_req->hue;
2015 req->saturation = in_req->saturation;
2016 req->transition_time = in_req->transition_time;
2019 zcl_color_request_data = (gpointer)req;
2023 case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_TO_COLOR: {
2024 ZigbeeZclColorControlMoveToColor_t *in_req;
2025 ZigbeeZclColorControlMoveToColor_t *req = NULL;
2027 in_req = (ZigbeeZclColorControlMoveToColor_t *)request_data;
2028 if (NULL != in_req) {
2029 /* Allocate memory */
2030 req = (ZigbeeZclColorControlMoveToColor_t *)
2031 g_malloc0(sizeof(ZigbeeZclColorControlMoveToColor_t));
2034 req->node_id = in_req->node_id;
2035 req->dest_ep = in_req->dest_ep;
2036 req->color_x = in_req->color_x;
2037 req->color_y = in_req->color_y;
2038 req->transition_time = in_req->transition_time;
2041 zcl_color_request_data = (gpointer)req;
2045 case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_COLOR: {
2046 ZigbeeZclColorControlMoveColor_t *in_req;
2047 ZigbeeZclColorControlMoveColor_t *req = NULL;
2049 in_req = (ZigbeeZclColorControlMoveColor_t *)request_data;
2050 if (NULL != in_req) {
2051 /* Allocate memory */
2052 req = (ZigbeeZclColorControlMoveColor_t *)
2053 g_malloc0(sizeof(ZigbeeZclColorControlMoveColor_t));
2056 req->node_id = in_req->node_id;
2057 req->dest_ep = in_req->dest_ep;
2058 req->rate_x = in_req->rate_x;
2059 req->rate_y = in_req->rate_y;
2062 zcl_color_request_data = (gpointer)req;
2066 case ZBLIB_ZCL_COLOR_CONTROL_OPS_STEP_COLOR: {
2067 ZigbeeZclColorControlStepColor_t *in_req;
2068 ZigbeeZclColorControlStepColor_t *req = NULL;
2070 in_req = (ZigbeeZclColorControlStepColor_t *)request_data;
2071 if (NULL != in_req) {
2072 /* Allocate memory */
2073 req = (ZigbeeZclColorControlStepColor_t *)
2074 g_malloc0(sizeof(ZigbeeZclColorControlStepColor_t));
2077 req->node_id = in_req->node_id;
2078 req->dest_ep = in_req->dest_ep;
2079 req->step_x = in_req->step_x;
2080 req->step_y = in_req->step_y;
2081 req->transition_time = in_req->transition_time;
2084 zcl_color_request_data = (gpointer)req;
2088 case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_COLOR_TEMPERATURE: {
2089 ZigbeeZclColorControlMoveColorTemperature_t *in_req;
2090 ZigbeeZclColorControlMoveColorTemperature_t *req = NULL;
2092 in_req = (ZigbeeZclColorControlMoveColorTemperature_t *)request_data;
2093 if (NULL != in_req) {
2094 /* Allocate memory */
2095 req = (ZigbeeZclColorControlMoveColorTemperature_t *)
2096 g_malloc0(sizeof(ZigbeeZclColorControlMoveColorTemperature_t));
2099 req->node_id = in_req->node_id;
2100 req->dest_ep = in_req->dest_ep;
2101 req->color_temperature = in_req->color_temperature;
2102 req->transition_time = in_req->transition_time;
2105 zcl_color_request_data = (gpointer)req;
2113 return zcl_color_request_data;
2116 static gpointer __zblib_request_create_zcl_group_request_data(guint request_type,
2117 gpointer request_data, guint request_data_len)
2119 gpointer zcl_group_request_data = NULL;
2122 NOT_USED(request_data_len);
2125 ops_id = __zblib_request_get_ops_id(request_type);
2127 case ZBLIB_ZCL_GROUP_OPS_ADD_GROUP: {
2128 ZigbeeZclGroupAddGroup_t *in_req;
2129 ZigbeeZclGroupAddGroup_t *req = NULL;
2131 in_req = (ZigbeeZclGroupAddGroup_t *)request_data;
2132 if (NULL != in_req) {
2133 /* Allocate memory */
2134 req = (ZigbeeZclGroupAddGroup_t *)
2135 g_malloc0(sizeof(ZigbeeZclGroupAddGroup_t));
2138 req->node_id = in_req->node_id;
2139 req->dest_ep = in_req->dest_ep;
2140 req->group_id = in_req->group_id;
2141 g_strlcpy(req->group_name,
2142 in_req->group_name, ZIGBEE_ZCL_GROUP_NAME_MAX_LEN + 1);
2145 zcl_group_request_data = (gpointer)req;
2149 case ZBLIB_ZCL_GROUP_OPS_VIEW_GROUP: {
2150 ZigbeeZclGroupViewGroup_t *in_req;
2151 ZigbeeZclGroupViewGroup_t *req = NULL;
2153 in_req = (ZigbeeZclGroupViewGroup_t *)request_data;
2154 if (NULL != in_req) {
2155 /* Allocate memory */
2156 req = (ZigbeeZclGroupViewGroup_t *)
2157 g_malloc0(sizeof(ZigbeeZclGroupViewGroup_t));
2160 req->node_id = in_req->node_id;
2161 req->dest_ep = in_req->dest_ep;
2162 req->group_id = in_req->group_id;
2165 zcl_group_request_data = (gpointer)req;
2169 case ZBLIB_ZCL_GROUP_OPS_GET_GROUP_MEMBERSHIP: {
2170 ZigbeeZclGroupGetGroupMembership_t *in_req;
2171 ZigbeeZclGroupGetGroupMembership_t *req = NULL;
2173 in_req = (ZigbeeZclGroupGetGroupMembership_t *)request_data;
2174 if (NULL != in_req) {
2175 /* Allocate memory */
2176 req = (ZigbeeZclGroupGetGroupMembership_t *)
2177 g_malloc0(sizeof(ZigbeeZclGroupGetGroupMembership_t));
2180 req->node_id = in_req->node_id;
2181 req->dest_ep = in_req->dest_ep;
2182 req->group_count = in_req->group_count;
2183 req->group_list = (gushort *)g_memdup(in_req->group_list,
2184 sizeof(gushort) * in_req->group_count);
2187 zcl_group_request_data = (gpointer)req;
2191 case ZBLIB_ZCL_GROUP_OPS_REMOVE_GROUP: {
2192 ZigbeeZclGroupRemoveGroup_t *in_req;
2193 ZigbeeZclGroupRemoveGroup_t *req = NULL;
2195 in_req = (ZigbeeZclGroupRemoveGroup_t *)request_data;
2196 if (NULL != in_req) {
2197 /* Allocate memory */
2198 req = (ZigbeeZclGroupRemoveGroup_t *)
2199 g_malloc0(sizeof(ZigbeeZclGroupRemoveGroup_t));
2202 req->node_id = in_req->node_id;
2203 req->dest_ep = in_req->dest_ep;
2204 req->group_id = in_req->group_id;
2207 zcl_group_request_data = (gpointer)req;
2211 case ZBLIB_ZCL_GROUP_OPS_REMOVE_ALL_GROUP: {
2212 ZigbeeZclGroupRemoveAllGroup_t *in_req;
2213 ZigbeeZclGroupRemoveAllGroup_t *req = NULL;
2215 in_req = (ZigbeeZclGroupRemoveAllGroup_t *)request_data;
2216 if (NULL != in_req) {
2217 /* Allocate memory */
2218 req = (ZigbeeZclGroupRemoveAllGroup_t *)
2219 g_malloc0(sizeof(ZigbeeZclGroupRemoveAllGroup_t));
2222 req->node_id = in_req->node_id;
2223 req->dest_ep = in_req->dest_ep;
2226 zcl_group_request_data = (gpointer)req;
2230 case ZBLIB_ZCL_GROUP_OPS_ADD_GROUP_IF_IDENTIFYING: {
2231 ZigbeeZclGroupAddGroupIfIdentifying_t *in_req;
2232 ZigbeeZclGroupAddGroupIfIdentifying_t *req = NULL;
2234 in_req = (ZigbeeZclGroupAddGroupIfIdentifying_t *)request_data;
2235 if (NULL != in_req) {
2236 /* Allocate memory */
2237 req = (ZigbeeZclGroupAddGroupIfIdentifying_t *)
2238 g_malloc0(sizeof(ZigbeeZclGroupAddGroupIfIdentifying_t));
2241 req->node_id = in_req->node_id;
2242 req->dest_ep = in_req->dest_ep;
2243 req->group_id = in_req->group_id;
2244 g_strlcpy(req->group_name,
2245 in_req->group_name, ZIGBEE_ZCL_GROUP_NAME_MAX_LEN + 1);
2248 zcl_group_request_data = (gpointer)req;
2256 return zcl_group_request_data;
2259 static gpointer __zblib_request_create_zcl_poll_control_request_data(guint request_type,
2260 gpointer request_data, guint request_data_len)
2262 gpointer zcl_poll_control_request_data = NULL;
2265 NOT_USED(request_data_len);
2268 ops_id = __zblib_request_get_ops_id(request_type);
2270 case ZBLIB_ZCL_POLL_CONTROL_OPS_CHECK_IN_RESPONSE: {
2271 ZigbeeZclPollControlCheckInResponse_t *in_req;
2272 ZigbeeZclPollControlCheckInResponse_t *req = NULL;
2274 in_req = (ZigbeeZclPollControlCheckInResponse_t *)request_data;
2275 if (NULL != in_req) {
2276 /* Allocate memory */
2277 req = (ZigbeeZclPollControlCheckInResponse_t *)
2278 g_malloc0(sizeof(ZigbeeZclPollControlCheckInResponse_t));
2281 req->node_id = in_req->node_id;
2282 req->dest_ep = in_req->dest_ep;
2283 req->start_fast_polling = in_req->start_fast_polling;
2284 req->fast_poll_timeout = in_req->fast_poll_timeout;
2287 zcl_poll_control_request_data = (gpointer)req;
2291 case ZBLIB_ZCL_POLL_CONTROL_OPS_FAST_POLL_STOP: {
2292 ZigbeeZclPollControlFastPollStop_t *in_req;
2293 ZigbeeZclPollControlFastPollStop_t *req = NULL;
2295 in_req = (ZigbeeZclPollControlFastPollStop_t *)request_data;
2296 if (NULL != in_req) {
2297 /* Allocate memory */
2298 req = (ZigbeeZclPollControlFastPollStop_t *)
2299 g_malloc0(sizeof(ZigbeeZclPollControlFastPollStop_t));
2302 req->node_id = in_req->node_id;
2303 req->dest_ep = in_req->dest_ep;
2306 zcl_poll_control_request_data = (gpointer)req;
2310 case ZBLIB_ZCL_POLL_CONTROL_OPS_SET_LONG_POLL_INTERVAL: {
2311 ZigbeeZclPollControlSetLongPollInterval_t *in_req;
2312 ZigbeeZclPollControlSetLongPollInterval_t *req = NULL;
2314 in_req = (ZigbeeZclPollControlSetLongPollInterval_t *)request_data;
2315 if (NULL != in_req) {
2316 /* Allocate memory */
2317 req = (ZigbeeZclPollControlSetLongPollInterval_t *)
2318 g_malloc0(sizeof(ZigbeeZclPollControlSetLongPollInterval_t));
2321 req->node_id = in_req->node_id;
2322 req->dest_ep = in_req->dest_ep;
2323 req->new_long_poll_interval = in_req->new_long_poll_interval;
2326 zcl_poll_control_request_data = (gpointer)req;
2330 case ZBLIB_ZCL_POLL_CONTROL_OPS_SET_SHORT_POLL_INTERVAL: {
2331 ZigbeeZclPollControlSetShortPollInterval_t *in_req;
2332 ZigbeeZclPollControlSetShortPollInterval_t *req = NULL;
2334 in_req = (ZigbeeZclPollControlSetShortPollInterval_t *)request_data;
2335 if (NULL != in_req) {
2336 /* Allocate memory */
2337 req = (ZigbeeZclPollControlSetShortPollInterval_t *)
2338 g_malloc0(sizeof(ZigbeeZclPollControlSetShortPollInterval_t));
2341 req->node_id = in_req->node_id;
2342 req->dest_ep = in_req->dest_ep;
2343 req->new_short_poll_interval = in_req->new_short_poll_interval;
2346 zcl_poll_control_request_data = (gpointer)req;
2354 return zcl_poll_control_request_data;
2357 static gpointer __zblib_request_create_zcl_scene_request_data(guint request_type,
2358 gpointer request_data, guint request_data_len)
2360 gpointer zcl_scene_request_data = NULL;
2363 NOT_USED(request_data_len);
2366 ops_id = __zblib_request_get_ops_id(request_type);
2368 case ZBLIB_ZCL_SCENE_OPS_ADD_SCENE: {
2369 ZigbeeZclSceneAddScene_t *in_req;
2370 ZigbeeZclSceneAddScene_t *req = NULL;
2372 in_req = (ZigbeeZclSceneAddScene_t *)request_data;
2373 if (NULL != in_req) {
2374 /* Allocate memory */
2375 req = (ZigbeeZclSceneAddScene_t *)
2376 g_malloc0(sizeof(ZigbeeZclSceneAddScene_t));
2379 req->node_id = in_req->node_id;
2380 req->dest_ep = in_req->dest_ep;
2381 req->group_id = in_req->group_id;
2382 req->scene_id = in_req->scene_id;
2383 req->transition_time = in_req->transition_time;
2384 g_strlcpy(req->scene_name,
2385 in_req->scene_name, ZIGBEE_ZCL_SCENE_NAME_MAX_LEN + 1);
2386 req->ext_field_set_len = in_req->ext_field_set_len;
2387 req->ext_field_set = (guchar *)g_memdup(in_req->ext_field_set,
2388 in_req->ext_field_set_len);
2391 zcl_scene_request_data = (gpointer)req;
2395 case ZBLIB_ZCL_SCENE_OPS_VIEW_SCENE: {
2396 ZigbeeZclSceneViewScene_t *in_req;
2397 ZigbeeZclSceneViewScene_t *req = NULL;
2399 in_req = (ZigbeeZclSceneViewScene_t *)request_data;
2400 if (NULL != in_req) {
2401 /* Allocate memory */
2402 req = (ZigbeeZclSceneViewScene_t *)
2403 g_malloc0(sizeof(ZigbeeZclSceneViewScene_t));
2406 req->node_id = in_req->node_id;
2407 req->dest_ep = in_req->dest_ep;
2408 req->group_id = in_req->group_id;
2409 req->scene_id = in_req->scene_id;
2412 zcl_scene_request_data = (gpointer)req;
2416 case ZBLIB_ZCL_SCENE_OPS_REMOVE_SCENE: {
2417 ZigbeeZclSceneRemoveScene_t *in_req;
2418 ZigbeeZclSceneRemoveScene_t *req = NULL;
2420 in_req = (ZigbeeZclSceneRemoveScene_t *)request_data;
2421 if (NULL != in_req) {
2422 /* Allocate memory */
2423 req = (ZigbeeZclSceneRemoveScene_t *)
2424 g_malloc0(sizeof(ZigbeeZclSceneRemoveScene_t));
2427 req->node_id = in_req->node_id;
2428 req->dest_ep = in_req->dest_ep;
2429 req->group_id = in_req->group_id;
2430 req->scene_id = in_req->scene_id;
2433 zcl_scene_request_data = (gpointer)req;
2437 case ZBLIB_ZCL_SCENE_OPS_STORE_SCENE: {
2438 ZigbeeZclSceneStoreScene_t *in_req;
2439 ZigbeeZclSceneStoreScene_t *req = NULL;
2441 in_req = (ZigbeeZclSceneStoreScene_t *)request_data;
2442 if (NULL != in_req) {
2443 /* Allocate memory */
2444 req = (ZigbeeZclSceneStoreScene_t *)
2445 g_malloc0(sizeof(ZigbeeZclSceneStoreScene_t));
2448 req->node_id = in_req->node_id;
2449 req->dest_ep = in_req->dest_ep;
2450 req->group_id = in_req->group_id;
2451 req->scene_id = in_req->scene_id;
2454 zcl_scene_request_data = (gpointer)req;
2458 case ZBLIB_ZCL_SCENE_OPS_RECALL_SCENE: {
2459 ZigbeeZclSceneRecallScene_t *in_req;
2460 ZigbeeZclSceneRecallScene_t *req = NULL;
2462 in_req = (ZigbeeZclSceneRecallScene_t *)request_data;
2463 if (NULL != in_req) {
2464 /* Allocate memory */
2465 req = (ZigbeeZclSceneRecallScene_t *)
2466 g_malloc0(sizeof(ZigbeeZclSceneRecallScene_t));
2469 req->node_id = in_req->node_id;
2470 req->dest_ep = in_req->dest_ep;
2471 req->group_id = in_req->group_id;
2472 req->scene_id = in_req->scene_id;
2475 zcl_scene_request_data = (gpointer)req;
2479 case ZBLIB_ZCL_SCENE_OPS_REMOVE_ALL_SCENE: {
2480 ZigbeeZclSceneRemoveAllScene_t *in_req;
2481 ZigbeeZclSceneRemoveAllScene_t *req = NULL;
2483 in_req = (ZigbeeZclSceneRemoveAllScene_t *)request_data;
2484 if (NULL != in_req) {
2485 /* Allocate memory */
2486 req = (ZigbeeZclSceneRemoveAllScene_t *)
2487 g_malloc0(sizeof(ZigbeeZclSceneRemoveAllScene_t));
2490 req->node_id = in_req->node_id;
2491 req->dest_ep = in_req->dest_ep;
2492 req->group_id = in_req->group_id;
2495 zcl_scene_request_data = (gpointer)req;
2499 case ZBLIB_ZCL_SCENE_OPS_GET_SCENE_MEMBERSHIP: {
2500 ZigbeeZclSceneGetSceneMembership_t *in_req;
2501 ZigbeeZclSceneGetSceneMembership_t *req = NULL;
2503 in_req = (ZigbeeZclSceneGetSceneMembership_t *)request_data;
2504 if (NULL != in_req) {
2505 /* Allocate memory */
2506 req = (ZigbeeZclSceneGetSceneMembership_t *)
2507 g_malloc0(sizeof(ZigbeeZclSceneGetSceneMembership_t));
2510 req->node_id = in_req->node_id;
2511 req->dest_ep = in_req->dest_ep;
2512 req->group_id = in_req->group_id;
2515 zcl_scene_request_data = (gpointer)req;
2523 return zcl_scene_request_data;
2526 static gpointer __zblib_request_create_zdo_dev_control_request_data(guint request_type,
2527 gpointer request_data, guint request_data_len)
2529 gpointer zdodev_control_request_data = NULL;
2532 NOT_USED(request_data_len);
2535 ops_id = __zblib_request_get_ops_id(request_type);
2537 case ZBLIB_ZDO_DEV_CONTROL_OPS_NWK_ADDR_REQ: {
2538 ZigbeeZdoDevControlNwkAddrReq_t *in_req;
2539 ZigbeeZdoDevControlNwkAddrReq_t *req = NULL;
2541 in_req = (ZigbeeZdoDevControlNwkAddrReq_t *)request_data;
2542 if (NULL != in_req) {
2543 /* Allocate memory */
2544 req = (ZigbeeZdoDevControlNwkAddrReq_t *)
2545 g_malloc0(sizeof(ZigbeeZdoDevControlNwkAddrReq_t));
2548 memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
2549 req->request_type = in_req->request_type;
2550 req->start_index = in_req->start_index;
2553 zdodev_control_request_data = (gpointer)req;
2557 case ZBLIB_ZDO_DEV_CONTROL_OPS_MATCHED_DESCRIPTOR_REQ: {
2558 ZigbeeZdoDevControlMatchedDescriptorReq_t *in_req;
2559 ZigbeeZdoDevControlMatchedDescriptorReq_t *req = NULL;
2561 in_req = (ZigbeeZdoDevControlMatchedDescriptorReq_t *)request_data;
2562 if (NULL != in_req) {
2563 /* Allocate memory */
2564 req = (ZigbeeZdoDevControlMatchedDescriptorReq_t *)
2565 g_malloc0(sizeof(ZigbeeZdoDevControlMatchedDescriptorReq_t));
2568 req->node_id = in_req->node_id;
2569 req->profile_id = in_req->profile_id;
2570 req->num_in_cl = in_req->num_in_cl;
2571 if (in_req->num_in_cl > 0) {
2572 req->in_cl = g_malloc0_n(in_req->num_in_cl, sizeof(unsigned short));
2573 memcpy(req->in_cl, in_req->in_cl,
2574 in_req->num_in_cl * sizeof(unsigned short));
2576 req->num_out_cl = in_req->num_out_cl;
2577 if (in_req->num_out_cl > 0) {
2578 req->out_cl = g_malloc0_n(in_req->num_out_cl, sizeof(unsigned short));
2579 memcpy(req->out_cl, in_req->out_cl,
2580 in_req->num_out_cl * sizeof(unsigned short));
2584 zdodev_control_request_data = (gpointer)req;
2588 case ZBLIB_ZDO_DEV_CONTROL_OPS_IEEE_ADDR_REQ: {
2589 ZigbeeZdoDevControlIeeeAddrReq_t *in_req;
2590 ZigbeeZdoDevControlIeeeAddrReq_t *req = NULL;
2592 in_req = (ZigbeeZdoDevControlIeeeAddrReq_t *)request_data;
2593 if (NULL != in_req) {
2594 /* Allocate memory */
2595 req = (ZigbeeZdoDevControlIeeeAddrReq_t *)
2596 g_malloc0(sizeof(ZigbeeZdoDevControlIeeeAddrReq_t));
2599 req->node_id = in_req->node_id;
2602 zdodev_control_request_data = (gpointer)req;
2606 case ZBLIB_ZDO_DEV_CONTROL_OPS_ACTIVE_EP_REQ: {
2607 ZigbeeZdoDevControlActiveEpReq_t *in_req;
2608 ZigbeeZdoDevControlActiveEpReq_t *req = NULL;
2610 in_req = (ZigbeeZdoDevControlActiveEpReq_t *)request_data;
2611 if (NULL != in_req) {
2612 /* Allocate memory */
2613 req = (ZigbeeZdoDevControlActiveEpReq_t *)
2614 g_malloc0(sizeof(ZigbeeZdoDevControlActiveEpReq_t));
2617 req->node_id = in_req->node_id;
2620 zdodev_control_request_data = (gpointer)req;
2624 case ZBLIB_ZDO_DEV_CONTROL_OPS_NODE_DESC_REQ: {
2625 ZigbeeZdoDevControlNodeDescriptorReq_t *in_req;
2626 ZigbeeZdoDevControlNodeDescriptorReq_t *req = NULL;
2628 in_req = (ZigbeeZdoDevControlNodeDescriptorReq_t *)request_data;
2629 if (NULL != in_req) {
2630 /* Allocate memory */
2631 req = (ZigbeeZdoDevControlNodeDescriptorReq_t *)
2632 g_malloc0(sizeof(ZigbeeZdoDevControlNodeDescriptorReq_t));
2635 req->node_id = in_req->node_id;
2638 zdodev_control_request_data = (gpointer)req;
2642 case ZBLIB_ZDO_DEV_CONTROL_OPS_POWER_DESC_REQ: {
2643 ZigbeeZdoDevControlPowerDescriptorReq_t *in_req;
2644 ZigbeeZdoDevControlPowerDescriptorReq_t *req = NULL;
2646 in_req = (ZigbeeZdoDevControlPowerDescriptorReq_t *)request_data;
2647 if (NULL != in_req) {
2648 /* Allocate memory */
2649 req = (ZigbeeZdoDevControlPowerDescriptorReq_t *)
2650 g_malloc0(sizeof(ZigbeeZdoDevControlPowerDescriptorReq_t));
2653 req->node_id = in_req->node_id;
2656 zdodev_control_request_data = (gpointer)req;
2660 case ZBLIB_ZDO_DEV_CONTROL_OPS_COMPLEX_DESC_REQ: {
2661 ZigbeeZdoDevControlComplexDescriptorReq_t *in_req;
2662 ZigbeeZdoDevControlComplexDescriptorReq_t *req = NULL;
2664 in_req = (ZigbeeZdoDevControlComplexDescriptorReq_t *)request_data;
2665 if (NULL != in_req) {
2666 /* Allocate memory */
2667 req = (ZigbeeZdoDevControlComplexDescriptorReq_t *)
2668 g_malloc0(sizeof(ZigbeeZdoDevControlComplexDescriptorReq_t));
2671 req->node_id = in_req->node_id;
2674 zdodev_control_request_data = (gpointer)req;
2678 case ZBLIB_ZDO_DEV_CONTROL_OPS_USER_DESC_REQ: {
2679 ZigbeeZdoDevControlUserDescriptorReq_t *in_req;
2680 ZigbeeZdoDevControlUserDescriptorReq_t *req = NULL;
2682 in_req = (ZigbeeZdoDevControlUserDescriptorReq_t *)request_data;
2683 if (NULL != in_req) {
2684 /* Allocate memory */
2685 req = (ZigbeeZdoDevControlUserDescriptorReq_t *)
2686 g_malloc0(sizeof(ZigbeeZdoDevControlUserDescriptorReq_t));
2689 req->node_id = in_req->node_id;
2692 zdodev_control_request_data = (gpointer)req;
2696 case ZBLIB_ZDO_DEV_CONTROL_OPS_USER_DESC_SET_REQ: {
2697 ZigbeeZdoDevControlUserDescriptorSetReq_t *in_req;
2698 ZigbeeZdoDevControlUserDescriptorSetReq_t *req = NULL;
2700 in_req = (ZigbeeZdoDevControlUserDescriptorSetReq_t *)request_data;
2701 if (NULL != in_req) {
2702 /* Allocate memory */
2703 req = (ZigbeeZdoDevControlUserDescriptorSetReq_t *)
2704 g_malloc0(sizeof(ZigbeeZdoDevControlUserDescriptorSetReq_t));
2707 req->node_id = in_req->node_id;
2708 req->user_descriptor_len = in_req->user_descriptor_len;
2709 memcpy(req->user_descriptor,
2710 in_req->user_descriptor, in_req->user_descriptor_len);
2713 zdodev_control_request_data = (gpointer)req;
2717 case ZBLIB_ZDO_DEV_CONTROL_OPS_DEVICE_ANNOUNCE: {
2718 ZigbeeZdoDevControlDeviceAnnounce_t *in_req;
2719 ZigbeeZdoDevControlDeviceAnnounce_t *req = NULL;
2721 in_req = (ZigbeeZdoDevControlDeviceAnnounce_t *)request_data;
2722 if (NULL != in_req) {
2723 /* Allocate memory */
2724 req = (ZigbeeZdoDevControlDeviceAnnounce_t *)
2725 g_malloc0(sizeof(ZigbeeZdoDevControlDeviceAnnounce_t));
2728 req->node_id = in_req->node_id;
2729 memcpy(req->mac_addr, in_req->mac_addr, ZIGBEE_EUI64_SIZE);
2730 req->capability = in_req->capability;
2733 zdodev_control_request_data = (gpointer)req;
2737 case ZBLIB_ZDO_DEV_CONTROL_OPS_SIMPLE_DESC_REQ: {
2738 ZigbeeZdoDevControlSimpleDescriptorReq_t *in_req;
2739 ZigbeeZdoDevControlSimpleDescriptorReq_t *req = NULL;
2741 in_req = (ZigbeeZdoDevControlSimpleDescriptorReq_t *)request_data;
2742 if (NULL != in_req) {
2743 /* Allocate memory */
2744 req = (ZigbeeZdoDevControlSimpleDescriptorReq_t *)
2745 g_malloc0(sizeof(ZigbeeZdoDevControlSimpleDescriptorReq_t));
2748 req->node_id = in_req->node_id;
2749 req->endpoint = in_req->endpoint;
2752 zdodev_control_request_data = (gpointer)req;
2756 case ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_LQI_REQ: {
2757 ZigbeeZdoDevControlMgmtLqiReq_t *in_req;
2758 ZigbeeZdoDevControlMgmtLqiReq_t *req = NULL;
2760 in_req = (ZigbeeZdoDevControlMgmtLqiReq_t *)request_data;
2761 if (NULL != in_req) {
2762 /* Allocate memory */
2763 req = (ZigbeeZdoDevControlMgmtLqiReq_t *)
2764 g_malloc0(sizeof(ZigbeeZdoDevControlMgmtLqiReq_t));
2767 req->node_id = in_req->node_id;
2768 req->start_index = in_req->start_index;
2771 zdodev_control_request_data = (gpointer)req;
2775 case ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_RTG_REQ: {
2776 ZigbeeZdoDevControlMgmtRtgReq_t *in_req;
2777 ZigbeeZdoDevControlMgmtRtgReq_t *req = NULL;
2779 in_req = (ZigbeeZdoDevControlMgmtRtgReq_t *)request_data;
2780 if (NULL != in_req) {
2781 /* Allocate memory */
2782 req = (ZigbeeZdoDevControlMgmtRtgReq_t *)
2783 g_malloc0(sizeof(ZigbeeZdoDevControlMgmtRtgReq_t));
2786 req->node_id = in_req->node_id;
2787 req->start_index = in_req->start_index;
2790 zdodev_control_request_data = (gpointer)req;
2794 case ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_BIND_REQ: {
2795 ZigbeeZdoDevControlMgmtBindReq_t *in_req;
2796 ZigbeeZdoDevControlMgmtBindReq_t *req = NULL;
2798 in_req = (ZigbeeZdoDevControlMgmtBindReq_t *)request_data;
2799 if (NULL != in_req) {
2800 /* Allocate memory */
2801 req = (ZigbeeZdoDevControlMgmtBindReq_t *)
2802 g_malloc0(sizeof(ZigbeeZdoDevControlMgmtBindReq_t));
2805 req->node_id = in_req->node_id;
2806 req->start_index = in_req->start_index;
2809 zdodev_control_request_data = (gpointer)req;
2813 case ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_PERMIT_JOIN_REQ: {
2814 ZigbeeZdoDevControlMgmtPermitJoinReq_t *in_req;
2815 ZigbeeZdoDevControlMgmtPermitJoinReq_t *req = NULL;
2817 in_req = (ZigbeeZdoDevControlMgmtPermitJoinReq_t *)request_data;
2818 if (NULL != in_req) {
2819 /* Allocate memory */
2820 req = (ZigbeeZdoDevControlMgmtPermitJoinReq_t *)
2821 g_malloc0(sizeof(ZigbeeZdoDevControlMgmtPermitJoinReq_t));
2824 req->node_id = in_req->node_id;
2825 req->duration = in_req->duration;
2826 req->tc_significance = in_req->tc_significance;
2829 zdodev_control_request_data = (gpointer)req;
2833 case ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_NWK_UPDATE_REQ: {
2834 ZigbeeZdoDevControlMgmtNwkUpdateReq_t *in_req;
2835 ZigbeeZdoDevControlMgmtNwkUpdateReq_t *req = NULL;
2837 in_req = (ZigbeeZdoDevControlMgmtNwkUpdateReq_t *)request_data;
2838 if (NULL != in_req) {
2839 /* Allocate memory */
2840 req = (ZigbeeZdoDevControlMgmtNwkUpdateReq_t *)
2841 g_malloc0(sizeof(ZigbeeZdoDevControlMgmtNwkUpdateReq_t));
2844 req->node_id = in_req->node_id;
2845 req->scan_channel = in_req->scan_channel;
2846 req->scan_duration = in_req->scan_duration;
2847 req->scan_count = in_req->scan_count;
2848 req->network_update_id = in_req->network_update_id;
2851 zdodev_control_request_data = (gpointer)req;
2855 case ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_NWK_DISC_REQ: {
2856 ZigbeeZdoDevControlMgmtNwkDiscoveryReq_t *in_req;
2857 ZigbeeZdoDevControlMgmtNwkDiscoveryReq_t *req = NULL;
2859 in_req = (ZigbeeZdoDevControlMgmtNwkDiscoveryReq_t *)request_data;
2860 if (NULL != in_req) {
2861 /* Allocate memory */
2862 req = (ZigbeeZdoDevControlMgmtNwkDiscoveryReq_t *)
2863 g_malloc0(sizeof(ZigbeeZdoDevControlMgmtNwkDiscoveryReq_t));
2866 req->node_id = in_req->node_id;
2867 req->scan_channel = in_req->scan_channel;
2868 req->scan_duration = in_req->scan_duration;
2869 req->scan_count = in_req->scan_count;
2870 req->start_index = in_req->start_index;
2873 zdodev_control_request_data = (gpointer)req;
2881 return zdodev_control_request_data;
2884 static gpointer __zblib_request_create_zdo_bind_request_data(guint request_type,
2885 gpointer request_data, guint request_data_len)
2887 gpointer zdo_bind_request_data = NULL;
2890 NOT_USED(request_data_len);
2893 ops_id = __zblib_request_get_ops_id(request_type);
2895 case ZBLIB_ZDO_BIND_OPS_BIND_REQ: {
2896 ZigbeeZdoBindBindReq_t *in_req;
2897 ZigbeeZdoBindBindReq_t *req = NULL;
2899 in_req = (ZigbeeZdoBindBindReq_t *)request_data;
2900 if (NULL != in_req) {
2901 /* Allocate memory */
2902 req = (ZigbeeZdoBindBindReq_t *)
2903 g_malloc0(sizeof(ZigbeeZdoBindBindReq_t));
2906 req->node_id = in_req->node_id;
2907 memcpy(req->src_addr, in_req->src_addr, ZIGBEE_EUI64_SIZE);
2908 req->src_ep = in_req->src_ep;
2909 req->cluster_id = in_req->cluster_id;
2910 memcpy(req->dst_addr, in_req->dst_addr, ZIGBEE_EUI64_SIZE);
2911 req->bind_type = in_req->bind_type;
2912 req->group_addr = in_req->group_addr;
2913 req->dst_ep = in_req->dst_ep;
2916 zdo_bind_request_data = (gpointer)req;
2920 case ZBLIB_ZDO_BIND_OPS_UNBIND_REQ: {
2921 ZigbeeZdoBindUnbindReq_t *in_req;
2922 ZigbeeZdoBindUnbindReq_t *req = NULL;
2924 in_req = (ZigbeeZdoBindUnbindReq_t *)request_data;
2925 if (NULL != in_req) {
2926 /* Allocate memory */
2927 req = (ZigbeeZdoBindUnbindReq_t *)
2928 g_malloc0(sizeof(ZigbeeZdoBindUnbindReq_t));
2931 req->node_id = in_req->node_id;
2932 memcpy(req->src_addr, in_req->src_addr, ZIGBEE_EUI64_SIZE);
2933 req->src_ep = in_req->src_ep;
2934 req->cluster_id = in_req->cluster_id;
2935 memcpy(req->dst_addr, in_req->dst_addr, ZIGBEE_EUI64_SIZE);
2936 req->bind_type = in_req->bind_type;
2937 req->group_addr = in_req->group_addr;
2938 req->dst_ep = in_req->dst_ep;
2941 zdo_bind_request_data = (gpointer)req;
2949 return zdo_bind_request_data;
2953 static gpointer __zblib_request_create_request_data(guint request_type,
2954 gpointer request_data, guint request_data_len)
2956 gpointer _request_data = NULL;
2957 ZblibDriverType_e driver_type;
2959 /* Fetch driver type */
2960 driver_type = __zblib_request_get_driver_type(request_type);
2961 switch (driver_type) {
2962 case ZBLIB_DRIVER_TYPE_ZCL_ALARM: {
2963 _request_data = __zblib_request_create_zcl_alarm_request_data(request_type,
2964 request_data, request_data_len);
2968 case ZBLIB_DRIVER_TYPE_CUSTOM: {
2969 _request_data = __zblib_request_create_custom_request_data(request_type,
2970 request_data, request_data_len);
2974 case ZBLIB_DRIVER_TYPE_ZCL_DOOR_LOCK: {
2975 _request_data = __zblib_request_create_zcl_door_lock_request_data(request_type,
2976 request_data, request_data_len);
2980 case ZBLIB_DRIVER_TYPE_ZCL_FAN_CONTROL: {
2981 _request_data = __zblib_request_create_zcl_fan_control_request_data(request_type,
2982 request_data, request_data_len);
2986 case ZBLIB_DRIVER_TYPE_ZCL_LEVEL_CONTROL: {
2987 _request_data = __zblib_request_create_zcl_level_control_request_data(request_type,
2988 request_data, request_data_len);
2992 case ZBLIB_DRIVER_TYPE_MFGLIB_CONTROL: {
2993 _request_data = __zblib_request_create_mfglib_control_request_data(request_type,
2994 request_data, request_data_len);
2998 case ZBLIB_DRIVER_TYPE_ZCL_ON_OFF: {
2999 _request_data = __zblib_request_create_zcl_on_off_request_data(request_type,
3000 request_data, request_data_len);
3004 case ZBLIB_DRIVER_TYPE_SERVICE: {
3005 _request_data = __zblib_request_create_service_request_data(request_type,
3006 request_data, request_data_len);
3010 case ZBLIB_DRIVER_TYPE_ZCL_THERMOSTAT: {
3011 _request_data = __zblib_request_create_zcl_thermostat_request_data(request_type,
3012 request_data, request_data_len);
3016 case ZBLIB_DRIVER_TYPE_ZCL_BASIC: {
3017 _request_data = __zblib_request_create_zcl_basic_request_data(request_type,
3018 request_data, request_data_len);
3022 case ZBLIB_DRIVER_TYPE_ZCL_GLOBAL_CONTROL: {
3023 _request_data = __zblib_request_create_zcl_global_control_request_data(request_type,
3024 request_data, request_data_len);
3028 case ZBLIB_DRIVER_TYPE_ZCL_IAS_ZONE: {
3029 _request_data = __zblib_request_create_zcl_ias_zone_request_data(request_type,
3030 request_data, request_data_len);
3034 case ZBLIB_DRIVER_TYPE_ZCL_IDENTIFY: {
3035 _request_data = __zblib_request_create_zcl_identify_request_data(request_type,
3036 request_data, request_data_len);
3040 case ZBLIB_DRIVER_TYPE_ZCL_COLOR_CONTROL: {
3041 _request_data = __zblib_request_create_zcl_color_control_request_data(request_type,
3042 request_data, request_data_len);
3046 case ZBLIB_DRIVER_TYPE_ZCL_GROUP: {
3047 _request_data = __zblib_request_create_zcl_group_request_data(request_type,
3048 request_data, request_data_len);
3052 case ZBLIB_DRIVER_TYPE_ZCL_POLL_CONTROL: {
3053 _request_data = __zblib_request_create_zcl_poll_control_request_data(request_type,
3054 request_data, request_data_len);
3058 case ZBLIB_DRIVER_TYPE_ZCL_SCENE: {
3059 _request_data = __zblib_request_create_zcl_scene_request_data(request_type,
3060 request_data, request_data_len);
3064 case ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL: {
3065 _request_data = __zblib_request_create_zdo_dev_control_request_data(request_type,
3066 request_data, request_data_len);
3070 case ZBLIB_DRIVER_TYPE_ZDO_BIND: {
3071 _request_data = __zblib_request_create_zdo_bind_request_data(request_type,
3072 request_data, request_data_len);
3076 case ZBLIB_DRIVER_TYPE_NONE: /* Fall through */
3078 Z_LOGE("Unhandled driver type: [%d]", driver_type);
3083 return _request_data;
3086 static void __zblib_request_free_zcl_alarm_request_data(ZigBeeRequest *request,
3092 ops_id = __zblib_request_get_ops_id(request_type);
3094 case ZBLIB_ZCL_ALARM_OPS_GET_ALARM_COUNT: {
3095 ZigbeeZclAlarmGetAlarmCount_t *req = NULL;
3097 req = (ZigbeeZclAlarmGetAlarmCount_t *)request->request_data;
3103 case ZBLIB_ZCL_ALARM_OPS_RESET_ALARM: {
3104 ZigbeeZclAlarmResetAlarm_t *req = NULL;
3106 req = (ZigbeeZclAlarmResetAlarm_t *)request->request_data;
3112 case ZBLIB_ZCL_ALARM_OPS_RESET_ALL_ALARM: {
3113 ZigbeeZclAlarmResetAllAlarm_t *req = NULL;
3115 req = (ZigbeeZclAlarmResetAllAlarm_t *)request->request_data;
3121 case ZBLIB_ZCL_ALARM_OPS_ALARM: {
3122 ZigbeeZclAlarmAlarm_t *req = NULL;
3124 req = (ZigbeeZclAlarmAlarm_t *)request->request_data;
3130 case ZBLIB_ZCL_ALARM_OPS_RESET_ALARM_LOG: {
3131 ZigbeeZclAlarmResetAlarmLogs_t *req = NULL;
3133 req = (ZigbeeZclAlarmResetAlarmLogs_t *)request->request_data;
3139 case ZBLIB_ZCL_ALARM_OPS_GET_ALARM: {
3148 static void __zblib_request_free_custom_request_data(ZigBeeRequest *request,
3154 ops_id = __zblib_request_get_ops_id(request_type);
3156 case ZBLIB_CUSTOM_OPS_APS_SEND: {
3157 ZigbeeCustomApsSend_t *req = NULL;
3159 req = (ZigbeeCustomApsSend_t *)request->request_data;
3165 case ZBLIB_CUSTOM_OPS_ZCL_SEND: {
3166 ZigbeeCustomZclSend_t *req = NULL;
3168 req = (ZigbeeCustomZclSend_t *)request->request_data;
3174 case ZBLIB_CUSTOM_OPS_SEND_TO_LOCAL: {
3175 ZigbeeCustomSendToLocal_t *req = NULL;
3177 req = (ZigbeeCustomSendToLocal_t *)request->request_data;
3188 static void __zblib_request_free_zcl_door_lock_request_data(ZigBeeRequest *request,
3194 ops_id = __zblib_request_get_ops_id(request_type);
3196 case ZBLIB_ZCL_DOOR_LOCK_OPS_SUBSCRIBE_LOCK_EVENT: {
3197 ZigbeeZclDoorLockSubscriberLockEvent_t *req = NULL;
3199 req = (ZigbeeZclDoorLockSubscriberLockEvent_t *)request->request_data;
3205 case ZBLIB_ZCL_DOOR_LOCK_OPS_SET_DOOR_LOCK_PIN: {
3206 ZigbeeZclDoorLockSetDoorLockPin_t *req = NULL;
3208 req = (ZigbeeZclDoorLockSetDoorLockPin_t *)request->request_data;
3214 case ZBLIB_ZCL_DOOR_LOCK_OPS_SET_DOOR_LOCK: {
3215 ZigbeeZclDoorLockSetDoorLock_t *req = NULL;
3217 req = (ZigbeeZclDoorLockSetDoorLock_t *)request->request_data;
3223 case ZBLIB_ZCL_DOOR_LOCK_OPS_GET_LOCK_STATE: {
3224 ZigbeeZclDoorLockGetDoorLock_t *req = NULL;
3226 req = (ZigbeeZclDoorLockGetDoorLock_t *)request->request_data;
3237 static void __zblib_request_free_zcl_fan_control_request_data(ZigBeeRequest *request,
3243 ops_id = __zblib_request_get_ops_id(request_type);
3245 case ZBLIB_ZCL_FAN_CONTROL_OPS_SET_FAN_MODE: {
3246 ZigbeeZclFanControlSetFanMode_t *req = NULL;
3248 req = (ZigbeeZclFanControlSetFanMode_t *)request->request_data;
3254 case ZBLIB_ZCL_FAN_CONTROL_OPS_GET_FAN_MODE: {
3255 ZigbeeZclFanControlGetFanMode_t *req = NULL;
3257 req = (ZigbeeZclFanControlGetFanMode_t *)request->request_data;
3263 case ZBLIB_ZCL_FAN_CONTROL_OPS_SET_FAN_MODE_SEQUENCE: {
3264 ZigbeeZclFanControlSetFanModeSequence_t *req = NULL;
3266 req = (ZigbeeZclFanControlSetFanModeSequence_t *)request->request_data;
3272 case ZBLIB_ZCL_FAN_CONTROL_OPS_GET_FAN_MODE_SEQUENCE: {
3273 ZigbeeZclFanControlGetFanModeSequence_t *req = NULL;
3275 req = (ZigbeeZclFanControlGetFanModeSequence_t *)request->request_data;
3286 static void __zblib_request_free_zcl_level_control_request_data(ZigBeeRequest *request,
3292 ops_id = __zblib_request_get_ops_id(request_type);
3294 case ZBLIB_ZCL_LEVEL_CONTROL_OPS_MOVE_TO_LEVEL: {
3295 ZigbeeZclLevelControlMoveToLevel_t *req = NULL;
3297 req = (ZigbeeZclLevelControlMoveToLevel_t *)request->request_data;
3303 case ZBLIB_ZCL_LEVEL_CONTROL_OPS_MOVE: {
3304 ZigbeeZclLevelControlMove_t *req = NULL;
3306 req = (ZigbeeZclLevelControlMove_t *)request->request_data;
3312 case ZBLIB_ZCL_LEVEL_CONTROL_OPS_STEP: {
3313 ZigbeeZclLevelControlStep_t *req = NULL;
3315 req = (ZigbeeZclLevelControlStep_t *)request->request_data;
3321 case ZBLIB_ZCL_LEVEL_CONTROL_OPS_MOVE_TO_LEVEL_WITH_ON_OFF: {
3322 ZigbeeZclLevelControlMoveToLevelWithOnOff_t *req = NULL;
3324 req = (ZigbeeZclLevelControlMoveToLevelWithOnOff_t *)request->request_data;
3330 case ZBLIB_ZCL_LEVEL_CONTROL_OPS_MOVE_WITH_ON_OFF: {
3331 ZigbeeZclLevelControlMoveWithOnOff_t *req = NULL;
3333 req = (ZigbeeZclLevelControlMoveWithOnOff_t *)request->request_data;
3339 case ZBLIB_ZCL_LEVEL_CONTROL_OPS_STEP_WITH_ON_OFF: {
3340 ZigbeeZclLevelControlStepWithOnOff_t *req = NULL;
3342 req = (ZigbeeZclLevelControlStepWithOnOff_t *)request->request_data;
3348 case ZBLIB_ZCL_LEVEL_CONTROL_OPS_STOP: {
3349 ZigbeeZclLevelControlStop_t *req = NULL;
3351 req = (ZigbeeZclLevelControlStop_t *)request->request_data;
3362 static void __zblib_request_free_mfglib_control_request_data(ZigBeeRequest *request,
3368 ops_id = __zblib_request_get_ops_id(request_type);
3370 case ZBLIB_MFGLIB_CONTROL_OPS_START: {
3371 ZigbeeMfglibControlStart_t *req = NULL;
3373 req = (ZigbeeMfglibControlStart_t *)request->request_data;
3379 case ZBLIB_MFGLIB_CONTROL_OPS_END: {
3380 ZigbeeMfglibControlEnd_t *req = NULL;
3382 req = (ZigbeeMfglibControlEnd_t *)request->request_data;
3388 case ZBLIB_MFGLIB_CONTROL_OPS_START_TONE: {
3389 ZigbeeMfglibControlStartTone_t *req = NULL;
3391 req = (ZigbeeMfglibControlStartTone_t *)request->request_data;
3397 case ZBLIB_MFGLIB_CONTROL_OPS_STOP_TONE: {
3398 ZigbeeMfglibControlStopTone_t *req = NULL;
3400 req = (ZigbeeMfglibControlStopTone_t *)request->request_data;
3406 case ZBLIB_MFGLIB_CONTROL_OPS_START_STREAM: {
3407 ZigbeeMfglibControlStartStream_t *req = NULL;
3409 req = (ZigbeeMfglibControlStartStream_t *)request->request_data;
3415 case ZBLIB_MFGLIB_CONTROL_OPS_STOP_STREAM: {
3416 ZigbeeMfglibControlStopStream_t *req = NULL;
3418 req = (ZigbeeMfglibControlStopStream_t *)request->request_data;
3424 case ZBLIB_MFGLIB_CONTROL_OPS_SEND_PACKET: {
3425 ZigbeeMfglibControlSendPacket_t *req = NULL;
3427 req = (ZigbeeMfglibControlSendPacket_t *)request->request_data;
3433 case ZBLIB_MFGLIB_CONTROL_OPS_SET_CHANNEL: {
3434 ZigbeeMfglibControlSetChannel_t *req = NULL;
3436 req = (ZigbeeMfglibControlSetChannel_t *)request->request_data;
3442 case ZBLIB_MFGLIB_CONTROL_OPS_GET_CHANNEL: {
3443 ZigbeeMfglibControlGetChannel_t *req = NULL;
3445 req = (ZigbeeMfglibControlGetChannel_t *)request->request_data;
3451 case ZBLIB_MFGLIB_CONTROL_OPS_SET_POWER: {
3452 ZigbeeMfglibControlSetPower_t *req = NULL;
3454 req = (ZigbeeMfglibControlSetPower_t *)request->request_data;
3460 case ZBLIB_MFGLIB_CONTROL_OPS_GET_POWER: {
3461 ZigbeeMfglibControlGetPower_t *req = NULL;
3463 req = (ZigbeeMfglibControlGetPower_t *)request->request_data;
3469 case ZBLIB_MFGLIB_CONTROL_OPS_SET_SYNOFFSET: {
3470 ZigbeeMfglibControlSetSynOffset_t *req = NULL;
3472 req = (ZigbeeMfglibControlSetSynOffset_t *)request->request_data;
3478 case ZBLIB_MFGLIB_CONTROL_OPS_GET_SYNOFFSET: {
3479 ZigbeeMfglibControlGetSynOffset_t *req = NULL;
3481 req = (ZigbeeMfglibControlGetSynOffset_t *)request->request_data;
3487 case ZBLIB_MFGLIB_CONTROL_OPS_RX_START: {
3488 ZigbeeMfglibControlRxStart_t *req = NULL;
3490 req = (ZigbeeMfglibControlRxStart_t *)request->request_data;
3496 case ZBLIB_MFGLIB_CONTROL_OPS_RX_STOP: {
3497 ZigbeeMfglibControlRxStop_t *req = NULL;
3499 req = (ZigbeeMfglibControlRxStop_t *)request->request_data;
3505 case ZBLIB_MFGLIB_CONTROL_OPS_RX_VERIFY: {
3506 ZigbeeMfglibControlRxVerify_t *req = NULL;
3508 req = (ZigbeeMfglibControlRxVerify_t *)request->request_data;
3514 case ZBLIB_MFGLIB_CONTROL_OPS_GET_RSSI: {
3515 ZigbeeMfglibControlGetRssi_t *req = NULL;
3517 req = (ZigbeeMfglibControlGetRssi_t *)request->request_data;
3528 static void __zblib_request_free_zcl_on_off_request_data(ZigBeeRequest *request,
3534 ops_id = __zblib_request_get_ops_id(request_type);
3536 case ZBLIB_ZCL_ON_OFF_OPS_SET_ON_OFF: {
3537 ZigbeeZclOnOffSetOnOff_t *req = NULL;
3539 req = (ZigbeeZclOnOffSetOnOff_t *)request->request_data;
3545 case ZBLIB_ZCL_ON_OFF_OPS_GET_ON_OFF_STATE: {
3546 ZigbeeZclOnOffGetOnOffState_t *req = NULL;
3548 req = (ZigbeeZclOnOffGetOnOffState_t *)request->request_data;
3559 static void __zblib_request_free_service_request_data(ZigBeeRequest *request,
3565 ops_id = __zblib_request_get_ops_id(request_type);
3567 case ZBLIB_SERVICE_OPS_ZB_HW_RESET: {
3571 case ZBLIB_SERVICE_OPS_FORM_NETWORK: {
3575 case ZBLIB_SERVICE_OPS_COEX_START: {
3576 ZigbeeServiceCoexStart_t *req = NULL;
3578 req = (ZigbeeServiceCoexStart_t *)request->request_data;
3584 case ZBLIB_SERVICE_OPS_COEX_STOP: {
3588 case ZBLIB_SERVICE_OPS_LEAVE_NETWORK: {
3592 case ZBLIB_SERVICE_OPS_GET_NETWORK_INFO: {
3596 case ZBLIB_SERVICE_OPS_PERMIT_JOIN: {
3597 ZigbeeServicePermitJoin_t *req = NULL;
3599 req = (ZigbeeServicePermitJoin_t *)request->request_data;
3605 case ZBLIB_SERVICE_OPS_LEAVE_REQUEST: {
3606 ZigbeeServiceLeaveRequest_t *req = NULL;
3608 req = (ZigbeeServiceLeaveRequest_t *)request->request_data;
3614 case ZBLIB_SERVICE_OPS_GET_DEVICE_LIST: {
3618 case ZBLIB_SERVICE_OPS_GET_MAC: {
3622 case ZBLIB_SERVICE_OPS_GET_DEVICE_INFO: {
3626 case ZBLIB_SERVICE_OPS_GET_ENDPOINT_LIST: {
3627 ZigbeeServiceGetEndpointList_t *req = NULL;
3629 req = (ZigbeeServiceGetEndpointList_t *)request->request_data;
3635 case ZBLIB_SERVICE_OPS_GET_CLUSTER_LIST: {
3636 ZigbeeServiceGetClusterList_t *req = NULL;
3638 req = (ZigbeeServiceGetClusterList_t *)request->request_data;
3644 case ZBLIB_SERVICE_OPS_GET_NODE_TYPE: {
3645 ZigbeeServiceGetNodeType_t *req = NULL;
3647 req = (ZigbeeServiceGetNodeType_t *)request->request_data;
3658 static void __zblib_request_free_zcl_thermostat_request_data(ZigBeeRequest *request,
3664 ops_id = __zblib_request_get_ops_id(request_type);
3666 case ZBLIB_ZCL_THERMOSTAT_OPS_GET_LOCAL_TEMP: {
3667 ZigbeeZclThermostatGetLocalTemp_t *req = NULL;
3669 req = (ZigbeeZclThermostatGetLocalTemp_t *)request->request_data;
3675 case ZBLIB_ZCL_THERMOSTAT_OPS_GET_WEEKLY_SCHEDULE: {
3676 ZigbeeZclThermostatGetWeeklySchedule_t *req = NULL;
3678 req = (ZigbeeZclThermostatGetWeeklySchedule_t *)request->request_data;
3684 case ZBLIB_ZCL_THERMOSTAT_OPS_SET_WEEKLY_SCHEDULE: {
3685 ZigbeeZclThermostatSetWeeklySchedule_t *req = NULL;
3687 req = (ZigbeeZclThermostatSetWeeklySchedule_t *)request->request_data;
3693 case ZBLIB_ZCL_THERMOSTAT_OPS_CLEAR_WEEKLY_SCHEDULE: {
3694 ZigbeeZclThermostatClearWeeklySchedule_t *req = NULL;
3696 req = (ZigbeeZclThermostatClearWeeklySchedule_t *)request->request_data;
3702 case ZBLIB_ZCL_THERMOSTAT_OPS_SETPOINT_RAISE_LOWER: {
3703 ZigbeeZclThermostatSetpointRaiseLower_t *req = NULL;
3705 req = (ZigbeeZclThermostatSetpointRaiseLower_t *)request->request_data;
3716 static void __zblib_request_free_zcl_basic_request_data(ZigBeeRequest *request,
3722 ops_id = __zblib_request_get_ops_id(request_type);
3724 case ZBLIB_ZCL_BASIC_OPS_RESET_FACTORY_DEFAULT: {
3725 ZigbeeZclBasicResetFactoryDefault_t *req = NULL;
3727 req = (ZigbeeZclBasicResetFactoryDefault_t *)request->request_data;
3738 static void __zblib_request_free_zcl_global_control_request_data(ZigBeeRequest *request,
3744 ops_id = __zblib_request_get_ops_id(request_type);
3746 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_READ_ATTRIBUTES_REQ: {
3747 ZigbeeZclGlobalControlReadAttributesRequest_t *req = NULL;
3749 req = (ZigbeeZclGlobalControlReadAttributesRequest_t *)request->request_data;
3751 g_free(req->attribute_id);
3757 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_REQ: {
3758 ZigbeeZclGlobalControlWriteAttributesRequest_t *req = NULL;
3760 req = (ZigbeeZclGlobalControlWriteAttributesRequest_t *)request->request_data;
3762 g_free(req->write_records);
3768 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_UNDIVIDED_REQ: {
3769 ZigbeeZclGlobalControlWriteAttributesUndividedRequest_t *req = NULL;
3771 req = (ZigbeeZclGlobalControlWriteAttributesUndividedRequest_t *)request->request_data;
3773 g_free(req->write_records);
3779 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_NO_RESP: {
3780 ZigbeeZclGlobalControlWriteAttributesNoResponse_t *req = NULL;
3782 req = (ZigbeeZclGlobalControlWriteAttributesNoResponse_t *)request->request_data;
3784 g_free(req->write_records);
3790 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_STRUCTURED: {
3791 ZigbeeZclGlobalControlWriteAttributesStructed_t *req = NULL;
3793 req = (ZigbeeZclGlobalControlWriteAttributesStructed_t *)request->request_data;
3795 g_free(req->write_records);
3801 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_READ_ATTRIBUTES_STRUCTURED: {
3802 ZigbeeZclGlobalControlReadAttributesStructed_t *req = NULL;
3804 req = (ZigbeeZclGlobalControlReadAttributesStructed_t *)request->request_data;
3806 g_free(req->read_records);
3812 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_CONFIGURE_REPORTING_REQ: {
3813 ZigbeeZclGlobalControlConfigureReportingReq_t *req = NULL;
3815 req = (ZigbeeZclGlobalControlConfigureReportingReq_t *)request->request_data;
3817 g_free(req->read_records);
3823 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_READ_CONFIGURE_REPORTING: {
3824 ZigbeeZclGlobalControlReadConfigureReporting_t *req = NULL;
3826 req = (ZigbeeZclGlobalControlReadConfigureReporting_t *)request->request_data;
3828 g_free(req->read_records);
3834 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_DISCOVER_ATTRIBUTES: {
3835 ZigbeeZclGlobalControlDiscoverAttributes_t *req = NULL;
3837 req = (ZigbeeZclGlobalControlDiscoverAttributes_t *)request->request_data;
3843 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_DISCOVER_ATTRIBUTES_EXTENDED: {
3844 ZigbeeZclGlobalControlDiscoverAttributesExtended_t *req = NULL;
3846 req = (ZigbeeZclGlobalControlDiscoverAttributesExtended_t *)request->request_data;
3852 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_DISCOVER_COMMANDS_RECEIVED: {
3853 ZigbeeZclGlobalControlDiscoverCommandsReceived_t *req = NULL;
3855 req = (ZigbeeZclGlobalControlDiscoverCommandsReceived_t *)request->request_data;
3861 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_DISCOVER_COMMANDS_GENERATED: {
3862 ZigbeeZclGlobalControlDiscoverCommandsGenerated_t *req = NULL;
3864 req = (ZigbeeZclGlobalControlDiscoverCommandsGenerated_t *)request->request_data;
3875 static void __zblib_request_free_zcl_ias_zone_request_data(ZigBeeRequest *request,
3881 ops_id = __zblib_request_get_ops_id(request_type);
3883 case ZBLIB_ZCL_IAS_ZONE_OPS_ENROLL_RESPONSE: {
3884 ZigbeeZclIasZoneEnrollResponse_t *req = NULL;
3886 req = (ZigbeeZclIasZoneEnrollResponse_t *)request->request_data;
3897 static void __zblib_request_free_zcl_identify_request_data(ZigBeeRequest *request,
3903 ops_id = __zblib_request_get_ops_id(request_type);
3905 case ZBLIB_ZCL_IDENTIFY_OPS_IDENTIFY: {
3906 ZigbeeZclIdentifyIdentify_t *req = NULL;
3908 req = (ZigbeeZclIdentifyIdentify_t *)request->request_data;
3914 case ZBLIB_ZCL_IDENTIFY_OPS_QUERY: {
3915 ZigbeeZclIdentifyQuery_t *req = NULL;
3917 req = (ZigbeeZclIdentifyQuery_t *)request->request_data;
3928 static void __zblib_request_free_zcl_color_control_request_data(ZigBeeRequest *request,
3934 ops_id = __zblib_request_get_ops_id(request_type);
3936 case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_TO_HUE: {
3937 ZigbeeZclColorControlMoveToHue_t *req = NULL;
3939 req = (ZigbeeZclColorControlMoveToHue_t *)request->request_data;
3945 case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_HUE: {
3946 ZigbeeZclColorControlMoveHue_t *req = NULL;
3948 req = (ZigbeeZclColorControlMoveHue_t *)request->request_data;
3954 case ZBLIB_ZCL_COLOR_CONTROL_OPS_STEP_HUE: {
3955 ZigbeeZclColorControlStepHue_t *req = NULL;
3957 req = (ZigbeeZclColorControlStepHue_t *)request->request_data;
3963 case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_TO_STAURATION: {
3964 ZigbeeZclColorControlMoveToSaturation_t *req = NULL;
3966 req = (ZigbeeZclColorControlMoveToSaturation_t *)request->request_data;
3972 case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_STAURATION: {
3973 ZigbeeZclColorControlMoveSaturation_t *req = NULL;
3975 req = (ZigbeeZclColorControlMoveSaturation_t *)request->request_data;
3981 case ZBLIB_ZCL_COLOR_CONTROL_OPS_STEP_STAURATION: {
3982 ZigbeeZclColorControlStepSaturation_t *req = NULL;
3984 req = (ZigbeeZclColorControlStepSaturation_t *)request->request_data;
3990 case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_TO_HUE_AND_SATURATION: {
3991 ZigbeeZclColorControlMoveToHueAndSaturation_t *req = NULL;
3993 req = (ZigbeeZclColorControlMoveToHueAndSaturation_t *)request->request_data;
3999 case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_TO_COLOR: {
4000 ZigbeeZclColorControlMoveToColor_t *req = NULL;
4002 req = (ZigbeeZclColorControlMoveToColor_t *)request->request_data;
4008 case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_COLOR: {
4009 ZigbeeZclColorControlMoveColor_t *req = NULL;
4011 req = (ZigbeeZclColorControlMoveColor_t *)request->request_data;
4017 case ZBLIB_ZCL_COLOR_CONTROL_OPS_STEP_COLOR: {
4018 ZigbeeZclColorControlStepColor_t *req = NULL;
4020 req = (ZigbeeZclColorControlStepColor_t *)request->request_data;
4026 case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_COLOR_TEMPERATURE: {
4027 ZigbeeZclColorControlMoveColorTemperature_t *req = NULL;
4029 req = (ZigbeeZclColorControlMoveColorTemperature_t *)request->request_data;
4040 static void __zblib_request_free_zcl_group_request_data(ZigBeeRequest *request,
4046 ops_id = __zblib_request_get_ops_id(request_type);
4048 case ZBLIB_ZCL_GROUP_OPS_ADD_GROUP: {
4049 ZigbeeZclGroupAddGroup_t *req = NULL;
4051 req = (ZigbeeZclGroupAddGroup_t *)request->request_data;
4057 case ZBLIB_ZCL_GROUP_OPS_VIEW_GROUP: {
4058 ZigbeeZclGroupViewGroup_t *req = NULL;
4060 req = (ZigbeeZclGroupViewGroup_t *)request->request_data;
4066 case ZBLIB_ZCL_GROUP_OPS_GET_GROUP_MEMBERSHIP: {
4067 ZigbeeZclGroupGetGroupMembership_t *req = NULL;
4069 req = (ZigbeeZclGroupGetGroupMembership_t *)request->request_data;
4071 g_free(req->group_list);
4077 case ZBLIB_ZCL_GROUP_OPS_REMOVE_GROUP: {
4078 ZigbeeZclGroupRemoveGroup_t *req = NULL;
4080 req = (ZigbeeZclGroupRemoveGroup_t *)request->request_data;
4086 case ZBLIB_ZCL_GROUP_OPS_REMOVE_ALL_GROUP: {
4087 ZigbeeZclGroupRemoveAllGroup_t *req = NULL;
4089 req = (ZigbeeZclGroupRemoveAllGroup_t *)request->request_data;
4095 case ZBLIB_ZCL_GROUP_OPS_ADD_GROUP_IF_IDENTIFYING: {
4096 ZigbeeZclGroupAddGroupIfIdentifying_t *req = NULL;
4098 req = (ZigbeeZclGroupAddGroupIfIdentifying_t *)request->request_data;
4109 static void __zblib_request_free_zcl_poll_control_request_data(ZigBeeRequest *request,
4115 ops_id = __zblib_request_get_ops_id(request_type);
4117 case ZBLIB_ZCL_POLL_CONTROL_OPS_CHECK_IN_RESPONSE: {
4118 ZigbeeZclPollControlCheckInResponse_t *req = NULL;
4120 req = (ZigbeeZclPollControlCheckInResponse_t *)request->request_data;
4126 case ZBLIB_ZCL_POLL_CONTROL_OPS_FAST_POLL_STOP: {
4127 ZigbeeZclPollControlFastPollStop_t *req = NULL;
4129 req = (ZigbeeZclPollControlFastPollStop_t *)request->request_data;
4135 case ZBLIB_ZCL_POLL_CONTROL_OPS_SET_LONG_POLL_INTERVAL: {
4136 ZigbeeZclPollControlSetLongPollInterval_t *req = NULL;
4138 req = (ZigbeeZclPollControlSetLongPollInterval_t *)request->request_data;
4144 case ZBLIB_ZCL_POLL_CONTROL_OPS_SET_SHORT_POLL_INTERVAL: {
4145 ZigbeeZclPollControlSetShortPollInterval_t *req = NULL;
4147 req = (ZigbeeZclPollControlSetShortPollInterval_t *)request->request_data;
4158 static void __zblib_request_free_zcl_scene_request_data(ZigBeeRequest *request,
4164 ops_id = __zblib_request_get_ops_id(request_type);
4166 case ZBLIB_ZCL_SCENE_OPS_ADD_SCENE: {
4167 ZigbeeZclSceneAddScene_t *req = NULL;
4169 req = (ZigbeeZclSceneAddScene_t *)request->request_data;
4171 g_free(req->ext_field_set);
4177 case ZBLIB_ZCL_SCENE_OPS_VIEW_SCENE: {
4178 ZigbeeZclSceneViewScene_t *req = NULL;
4180 req = (ZigbeeZclSceneViewScene_t *)request->request_data;
4186 case ZBLIB_ZCL_SCENE_OPS_REMOVE_SCENE: {
4187 ZigbeeZclSceneRemoveScene_t *req = NULL;
4189 req = (ZigbeeZclSceneRemoveScene_t *)request->request_data;
4195 case ZBLIB_ZCL_SCENE_OPS_STORE_SCENE: {
4196 ZigbeeZclSceneStoreScene_t *req = NULL;
4198 req = (ZigbeeZclSceneStoreScene_t *)request->request_data;
4204 case ZBLIB_ZCL_SCENE_OPS_RECALL_SCENE: {
4205 ZigbeeZclSceneRecallScene_t *req = NULL;
4207 req = (ZigbeeZclSceneRecallScene_t *)request->request_data;
4213 case ZBLIB_ZCL_SCENE_OPS_REMOVE_ALL_SCENE: {
4214 ZigbeeZclSceneRemoveAllScene_t *req = NULL;
4216 req = (ZigbeeZclSceneRemoveAllScene_t *)request->request_data;
4222 case ZBLIB_ZCL_SCENE_OPS_GET_SCENE_MEMBERSHIP: {
4223 ZigbeeZclSceneGetSceneMembership_t *req = NULL;
4225 req = (ZigbeeZclSceneGetSceneMembership_t *)request->request_data;
4236 static void __zblib_request_free_zdo_dev_control_request_data(ZigBeeRequest *request,
4242 ops_id = __zblib_request_get_ops_id(request_type);
4244 case ZBLIB_ZDO_DEV_CONTROL_OPS_NWK_ADDR_REQ: {
4245 ZigbeeZdoDevControlNwkAddrReq_t *req = NULL;
4247 req = (ZigbeeZdoDevControlNwkAddrReq_t *)request->request_data;
4253 case ZBLIB_ZDO_DEV_CONTROL_OPS_MATCHED_DESCRIPTOR_REQ: {
4254 ZigbeeZdoDevControlMatchedDescriptorReq_t *req = NULL;
4256 req = (ZigbeeZdoDevControlMatchedDescriptorReq_t *)request->request_data;
4259 g_free(req->out_cl);
4265 case ZBLIB_ZDO_DEV_CONTROL_OPS_IEEE_ADDR_REQ: {
4266 ZigbeeZdoDevControlIeeeAddrReq_t *req = NULL;
4268 req = (ZigbeeZdoDevControlIeeeAddrReq_t *)request->request_data;
4274 case ZBLIB_ZDO_DEV_CONTROL_OPS_ACTIVE_EP_REQ: {
4275 ZigbeeZdoDevControlActiveEpReq_t *req = NULL;
4277 req = (ZigbeeZdoDevControlActiveEpReq_t *)request->request_data;
4283 case ZBLIB_ZDO_DEV_CONTROL_OPS_NODE_DESC_REQ: {
4284 ZigbeeZdoDevControlNodeDescriptorReq_t *req = NULL;
4286 req = (ZigbeeZdoDevControlNodeDescriptorReq_t *)request->request_data;
4292 case ZBLIB_ZDO_DEV_CONTROL_OPS_POWER_DESC_REQ: {
4293 ZigbeeZdoDevControlPowerDescriptorReq_t *req = NULL;
4295 req = (ZigbeeZdoDevControlPowerDescriptorReq_t *)request->request_data;
4301 case ZBLIB_ZDO_DEV_CONTROL_OPS_COMPLEX_DESC_REQ: {
4302 ZigbeeZdoDevControlComplexDescriptorReq_t *req = NULL;
4304 req = (ZigbeeZdoDevControlComplexDescriptorReq_t *)request->request_data;
4310 case ZBLIB_ZDO_DEV_CONTROL_OPS_USER_DESC_REQ: {
4311 ZigbeeZdoDevControlUserDescriptorReq_t *req = NULL;
4313 req = (ZigbeeZdoDevControlUserDescriptorReq_t *)request->request_data;
4319 case ZBLIB_ZDO_DEV_CONTROL_OPS_USER_DESC_SET_REQ: {
4320 ZigbeeZdoDevControlUserDescriptorSetReq_t *req = NULL;
4322 req = (ZigbeeZdoDevControlUserDescriptorSetReq_t *)request->request_data;
4328 case ZBLIB_ZDO_DEV_CONTROL_OPS_DEVICE_ANNOUNCE: {
4329 ZigbeeZdoDevControlDeviceAnnounce_t *req = NULL;
4331 req = (ZigbeeZdoDevControlDeviceAnnounce_t *)request->request_data;
4337 case ZBLIB_ZDO_DEV_CONTROL_OPS_SIMPLE_DESC_REQ: {
4338 ZigbeeZdoDevControlSimpleDescriptorReq_t *req = NULL;
4340 req = (ZigbeeZdoDevControlSimpleDescriptorReq_t *)request->request_data;
4346 case ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_LQI_REQ: {
4347 ZigbeeZdoDevControlMgmtLqiReq_t *req = NULL;
4349 req = (ZigbeeZdoDevControlMgmtLqiReq_t *)request->request_data;
4355 case ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_RTG_REQ: {
4356 ZigbeeZdoDevControlMgmtRtgReq_t *req = NULL;
4358 req = (ZigbeeZdoDevControlMgmtRtgReq_t *)request->request_data;
4364 case ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_BIND_REQ: {
4365 ZigbeeZdoDevControlMgmtBindReq_t *req = NULL;
4367 req = (ZigbeeZdoDevControlMgmtBindReq_t *)request->request_data;
4373 case ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_PERMIT_JOIN_REQ: {
4374 ZigbeeZdoDevControlMgmtPermitJoinReq_t *req = NULL;
4376 req = (ZigbeeZdoDevControlMgmtPermitJoinReq_t *)request->request_data;
4382 case ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_NWK_UPDATE_REQ: {
4383 ZigbeeZdoDevControlMgmtNwkUpdateReq_t *req = NULL;
4385 req = (ZigbeeZdoDevControlMgmtNwkUpdateReq_t *)request->request_data;
4391 case ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_NWK_DISC_REQ: {
4392 ZigbeeZdoDevControlMgmtNwkDiscoveryReq_t *req = NULL;
4394 req = (ZigbeeZdoDevControlMgmtNwkDiscoveryReq_t *)request->request_data;
4405 static void __zblib_request_free_zdo_bind_request_data(ZigBeeRequest *request,
4411 ops_id = __zblib_request_get_ops_id(request_type);
4413 case ZBLIB_ZDO_BIND_OPS_BIND_REQ: {
4414 ZigbeeZdoBindBindReq_t *req = NULL;
4416 req = (ZigbeeZdoBindBindReq_t *)request->request_data;
4422 case ZBLIB_ZDO_BIND_OPS_UNBIND_REQ: {
4423 ZigbeeZdoBindUnbindReq_t *req = NULL;
4425 req = (ZigbeeZdoBindUnbindReq_t *)request->request_data;
4436 static void __zblib_request_free_request_data(ZigBeeRequest *request)
4439 ZblibDriverType_e driver_type;
4441 zblib_check_null_ret("request", request);
4443 request_type = request->request_type;
4445 /* Fetch driver type */
4446 driver_type = __zblib_request_get_driver_type(request_type);
4447 switch (driver_type) {
4448 case ZBLIB_DRIVER_TYPE_ZCL_ALARM: {
4449 __zblib_request_free_zcl_alarm_request_data(request, request_type);
4453 case ZBLIB_DRIVER_TYPE_CUSTOM: {
4454 __zblib_request_free_custom_request_data(request, request_type);
4458 case ZBLIB_DRIVER_TYPE_ZCL_DOOR_LOCK: {
4459 __zblib_request_free_zcl_door_lock_request_data(request, request_type);
4463 case ZBLIB_DRIVER_TYPE_ZCL_FAN_CONTROL: {
4464 __zblib_request_free_zcl_fan_control_request_data(request, request_type);
4468 case ZBLIB_DRIVER_TYPE_ZCL_LEVEL_CONTROL: {
4469 __zblib_request_free_zcl_level_control_request_data(request, request_type);
4473 case ZBLIB_DRIVER_TYPE_MFGLIB_CONTROL: {
4474 __zblib_request_free_mfglib_control_request_data(request, request_type);
4478 case ZBLIB_DRIVER_TYPE_ZCL_ON_OFF: {
4479 __zblib_request_free_zcl_on_off_request_data(request, request_type);
4483 case ZBLIB_DRIVER_TYPE_SERVICE: {
4484 __zblib_request_free_service_request_data(request, request_type);
4488 case ZBLIB_DRIVER_TYPE_ZCL_THERMOSTAT: {
4489 __zblib_request_free_zcl_thermostat_request_data(request, request_type);
4493 case ZBLIB_DRIVER_TYPE_ZCL_BASIC: {
4494 __zblib_request_free_zcl_basic_request_data(request, request_type);
4498 case ZBLIB_DRIVER_TYPE_ZCL_GLOBAL_CONTROL: {
4499 __zblib_request_free_zcl_global_control_request_data(request, request_type);
4503 case ZBLIB_DRIVER_TYPE_ZCL_IAS_ZONE: {
4504 __zblib_request_free_zcl_ias_zone_request_data(request, request_type);
4508 case ZBLIB_DRIVER_TYPE_ZCL_IDENTIFY: {
4509 __zblib_request_free_zcl_identify_request_data(request, request_type);
4513 case ZBLIB_DRIVER_TYPE_ZCL_COLOR_CONTROL: {
4514 __zblib_request_free_zcl_color_control_request_data(request, request_type);
4518 case ZBLIB_DRIVER_TYPE_ZCL_GROUP: {
4519 __zblib_request_free_zcl_group_request_data(request, request_type);
4523 case ZBLIB_DRIVER_TYPE_ZCL_POLL_CONTROL: {
4524 __zblib_request_free_zcl_poll_control_request_data(request, request_type);
4528 case ZBLIB_DRIVER_TYPE_ZCL_SCENE: {
4529 __zblib_request_free_zcl_scene_request_data(request, request_type);
4533 case ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL: {
4534 __zblib_request_free_zdo_dev_control_request_data(request, request_type);
4538 case ZBLIB_DRIVER_TYPE_ZDO_BIND: {
4539 __zblib_request_free_zdo_bind_request_data(request, request_type);
4543 case ZBLIB_DRIVER_TYPE_NONE: /* Fall through */
4545 Z_LOGE("Unhandled driver type: [%d]", driver_type);
4551 gint zblib_request_new(ZigBeeServiceInterface *service_interface,
4552 guint request_type, gpointer request_data, guint request_data_len)
4554 ZigBeeService *service = NULL;
4555 ZigBeeRequest *request = NULL;
4556 GHashTable *request_table = NULL;
4558 zblib_check_null_ret_error("service_interface", service_interface, ZIGBEE_REQUEST_INVALID_REQUEST_ID);
4560 service = zblib_service_interface_ref_service(service_interface);
4561 zblib_check_null_ret_error("service", service, ZIGBEE_REQUEST_INVALID_REQUEST_ID);
4563 /* Allocate ZigBee request memory */
4564 request = g_malloc0(sizeof(ZigBeeRequest));
4566 /* Update request */
4567 request->service_interface = service_interface;
4568 request->ref_count = 1; /* Initialize reference count to '1' for new request */
4570 /* Update request data for specific request */
4571 request->request_data = __zblib_request_create_request_data(request_type,
4572 request_data, request_data_len);
4573 request->request_type = request_type;
4575 /* Generate request ID */
4576 request->request_id = zblib_service_generate_request_id(service);
4577 if (ZIGBEE_REQUEST_INVALID_REQUEST_ID == request->request_id) {
4578 Z_LOGE("zblib_service_genrate_request_id failed!");
4580 /* Free resources */
4581 __zblib_request_free_request_data(request);
4584 return ZIGBEE_REQUEST_INVALID_REQUEST_ID;
4587 /* Fetch request table from service */
4588 request_table = zblib_service_ref_request_hash_table(service);
4589 if (NULL == request_table) {
4590 Z_LOGE("zblib_service_ref_request_hash_table failed!");
4592 /* Free resources */
4593 __zblib_request_free_request_data(request);
4596 return ZIGBEE_REQUEST_INVALID_REQUEST_ID;
4599 /* Insert request to request table */
4600 g_hash_table_insert(request_table, GINT_TO_POINTER(request->request_id), request);
4602 return request->request_id;
4605 void zblib_request_free(ZigBeeServiceInterface *service_interface,
4608 ZigBeeService *service = NULL;
4609 ZigBeeRequest *request = NULL;
4611 zblib_check_null_ret("service_interface", service_interface);
4614 service = zblib_service_interface_ref_service(service_interface);
4615 zblib_check_null_ret("service", service);
4617 /* Fetch request based on request_id */
4618 request = __zblib_request_ref_request_by_request_id(service, request_id);
4619 zblib_check_null_ret("request", request);
4621 /* Free resources */
4622 __zblib_request_free_request_data(request);
4626 gboolean zblib_request_set_response_cb(ZigBeeServiceInterface *service_interface,
4628 gpointer resp_cb, gpointer resp_cb_data)
4630 ZigBeeService *service = NULL;
4631 ZigBeeRequest *request = NULL;
4633 zblib_check_null_ret_error("service_interface", service_interface, FALSE);
4636 service = zblib_service_interface_ref_service(service_interface);
4637 zblib_check_null_ret_error("service", service, FALSE);
4639 /* Fetch request based on request_id */
4640 request = __zblib_request_ref_request_by_by_request_id(service, request_id);
4641 if (NULL == request) {
4642 Z_LOGE("No request available for request_id: [%d]", request_id);
4646 /* Update response callback and response callback data */
4647 request->resp_cb = resp_cb;
4648 request->resp_cb_data = resp_cb_data;
4653 gpointer zblib_request_ref_response_cb(ZigBeeServiceInterface *service_interface,
4654 guint request_id, gpointer *resp_cb_data)
4656 ZigBeeService *service = NULL;
4657 ZigBeeRequest *request = NULL;
4659 zblib_check_null_ret_error("service_interface", service_interface, NULL);
4662 service = zblib_service_interface_ref_service(service_interface);
4663 zblib_check_null_ret_error("service", service, NULL);
4665 /* Fetch request based on request_id */
4666 request = __zblib_request_ref_request_by_by_request_id(service, request_id);
4667 if (NULL == request) {
4668 Z_LOGE("No request available for request_id: [%d]", request_id);
4672 /* Response callback data */
4673 *resp_cb_data = request->resp_cb_data;
4675 /* Return response callback */
4676 return request->resp_cb;
4679 ZigBeeRequest *zblib_request_ref(ZigBeeRequest *request)
4681 zblib_check_null_ret_error("request", request, NULL);
4683 request->ref_count++;
4688 void zblib_request_unref(ZigBeeRequest *request)
4690 zblib_check_null_ret("request", request);
4692 request->ref_count--;
4693 if (0 == request->ref_count) {
4694 Z_LOGD("Reference count is ZERO!");
4696 /* Free 'request' */
4697 __zblib_request_free_request_data(request);
4702 guint zblib_request_ref_request_type(ZigBeeRequest *request)
4704 zblib_check_null_ret_error("request", request, 0);
4706 return request->request_type;
4709 ZigBeeServiceInterface *zblib_request_ref_service_interface(ZigBeeService *service,
4712 ZigBeeRequest *request = NULL;
4714 zblib_check_null_ret_error("service", service, NULL);
4716 /* Fetch request based on request_id */
4717 request = __zblib_request_ref_request_by_by_request_id(service, request_id);
4718 if (NULL == request) {
4719 Z_LOGE("No request available for request_id: [%d]", request_id);
4723 return request->service_interface;
4726 gpointer zblib_request_ref_request_data(ZigBeeRequest *request)
4728 zblib_check_null_ret_error("request", request, NULL);
4730 return request->request_data;
4733 gpointer zblib_request_ref_request_data_by_id(ZigBeeService *service,
4736 ZigBeeRequest *request = NULL;
4738 /* Fetch request based on request_id */
4739 request = __zblib_request_ref_request_by_by_request_id(service, request_id);
4740 if (NULL == request) {
4741 Z_LOGE("No request available for request_id: [%d]", request_id);
4745 return request->request_data;
4748 guint zblib_request_generate_request_type(ZblibDriverType_e driver_type,
4754 * request_type consists of driver_type and ops_id
4755 * request_type = driver_type | 0x00 | 0x00 | ops_id
4757 request_type = (driver_type << 24) | (ops_id);
4759 return request_type;
4762 gint zblib_request_ref_request_type_by_request_id(ZigBeeService *service,
4765 return __zblib_request_ref_request_type_by_request_id(service, request_id);
4768 ZblibDriverType_e zblib_request_get_driver_type(guint request_type)
4770 return __zblib_request_get_driver_type(request_type);
4773 guint zblib_request_get_ops_id(guint request_type)
4775 return __zblib_request_get_ops_id(request_type);