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)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)request_id);
129 if (NULL == request_table) {
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_ENABLE: {
1141 service_request_data = NULL;
1145 case ZBLIB_SERVICE_OPS_DISABLE: {
1146 service_request_data = NULL;
1150 case ZBLIB_SERVICE_OPS_ZB_HW_RESET: {
1151 service_request_data = NULL;
1155 case ZBLIB_SERVICE_OPS_FORM_NETWORK: {
1156 service_request_data = NULL;
1160 case ZBLIB_SERVICE_OPS_COEX_START: {
1161 ZigbeeServiceCoexStart_t *in_req;
1162 ZigbeeServiceCoexStart_t *req = NULL;
1164 in_req = (ZigbeeServiceCoexStart_t *)request_data;
1165 if (NULL != in_req) {
1166 /* Allocate memory */
1167 req = (ZigbeeServiceCoexStart_t *)
1168 g_malloc0(sizeof(ZigbeeServiceCoexStart_t));
1171 req->channel = in_req->channel;
1174 service_request_data = (gpointer)req;
1178 case ZBLIB_SERVICE_OPS_COEX_STOP: {
1179 service_request_data = NULL;
1183 case ZBLIB_SERVICE_OPS_LEAVE_NETWORK: {
1184 service_request_data = NULL;
1188 case ZBLIB_SERVICE_OPS_GET_NETWORK_INFO: {
1189 service_request_data = NULL;
1193 case ZBLIB_SERVICE_OPS_PERMIT_JOIN: {
1194 ZigbeeServicePermitJoin_t *in_req;
1195 ZigbeeServicePermitJoin_t *req = NULL;
1197 in_req = (ZigbeeServicePermitJoin_t *)request_data;
1198 if (NULL != in_req) {
1199 /* Allocate memory */
1200 req = (ZigbeeServicePermitJoin_t *)
1201 g_malloc0(sizeof(ZigbeeServicePermitJoin_t));
1204 req->permit_join = in_req->permit_join;
1205 req->duration = in_req->duration;
1208 service_request_data = (gpointer)req;
1212 case ZBLIB_SERVICE_OPS_LEAVE_REQUEST: {
1213 ZigbeeServiceLeaveRequest_t *in_req;
1214 ZigbeeServiceLeaveRequest_t *req = NULL;
1216 in_req = (ZigbeeServiceLeaveRequest_t *)request_data;
1217 if (NULL != in_req) {
1218 /* Allocate memory */
1219 req = (ZigbeeServiceLeaveRequest_t *)
1220 g_malloc0(sizeof(ZigbeeServiceLeaveRequest_t));
1223 memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
1224 req->remove_child = in_req->remove_child;
1225 req->rejoin = in_req->rejoin;
1228 service_request_data = (gpointer)req;
1232 case ZBLIB_SERVICE_OPS_GET_DEVICE_LIST: {
1233 service_request_data = NULL;
1237 case ZBLIB_SERVICE_OPS_GET_MAC: {
1238 service_request_data = NULL;
1242 case ZBLIB_SERVICE_OPS_GET_DEVICE_INFO: {
1243 service_request_data = NULL;
1247 case ZBLIB_SERVICE_OPS_GET_ENDPOINT_LIST: {
1248 ZigbeeServiceGetEndpointList_t *in_req;
1249 ZigbeeServiceGetEndpointList_t *req = NULL;
1251 in_req = (ZigbeeServiceGetEndpointList_t *)request_data;
1252 if (NULL != in_req) {
1253 /* Allocate memory */
1254 req = (ZigbeeServiceGetEndpointList_t *)
1255 g_malloc0(sizeof(ZigbeeServiceGetEndpointList_t));
1258 memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
1261 service_request_data = (gpointer)req;
1265 case ZBLIB_SERVICE_OPS_GET_CLUSTER_LIST: {
1266 ZigbeeServiceGetClusterList_t *in_req;
1267 ZigbeeServiceGetClusterList_t *req = NULL;
1269 in_req = (ZigbeeServiceGetClusterList_t *)request_data;
1270 if (NULL != in_req) {
1271 /* Allocate memory */
1272 req = (ZigbeeServiceGetClusterList_t *)
1273 g_malloc0(sizeof(ZigbeeServiceGetClusterList_t));
1276 memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
1277 req->endpoint = in_req->endpoint;
1280 service_request_data = (gpointer)req;
1284 case ZBLIB_SERVICE_OPS_GET_NODE_TYPE: {
1285 ZigbeeServiceGetNodeType_t *in_req;
1286 ZigbeeServiceGetNodeType_t *req = NULL;
1288 in_req = (ZigbeeServiceGetNodeType_t *)request_data;
1289 if (NULL != in_req) {
1290 /* Allocate memory */
1291 req = (ZigbeeServiceGetNodeType_t *)
1292 g_malloc0(sizeof(ZigbeeServiceGetNodeType_t));
1295 memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
1298 service_request_data = (gpointer)req;
1303 Z_LOGE("Unexpected operation [%x]", ops_id);
1307 return service_request_data;
1310 static gpointer __zblib_request_create_zcl_thermostat_request_data(guint request_type,
1311 gpointer request_data, guint request_data_len)
1313 gpointer thermostat_request_data = NULL;
1316 NOT_USED(request_data_len);
1319 ops_id = __zblib_request_get_ops_id(request_type);
1321 case ZBLIB_ZCL_THERMOSTAT_OPS_GET_LOCAL_TEMP: {
1322 ZigbeeZclThermostatGetLocalTemp_t *in_req;
1323 ZigbeeZclThermostatGetLocalTemp_t *req = NULL;
1325 in_req = (ZigbeeZclThermostatGetLocalTemp_t *)request_data;
1326 if (NULL != in_req) {
1327 /* Allocate memory */
1328 req = (ZigbeeZclThermostatGetLocalTemp_t *)
1329 g_malloc0(sizeof(ZigbeeZclThermostatGetLocalTemp_t));
1332 memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
1333 req->endpoint = in_req->endpoint;
1336 thermostat_request_data = (gpointer)req;
1340 case ZBLIB_ZCL_THERMOSTAT_OPS_GET_WEEKLY_SCHEDULE: {
1341 ZigbeeZclThermostatGetWeeklySchedule_t *in_req;
1342 ZigbeeZclThermostatGetWeeklySchedule_t *req = NULL;
1344 in_req = (ZigbeeZclThermostatGetWeeklySchedule_t *)request_data;
1345 if (NULL != in_req) {
1346 /* Allocate memory */
1347 req = (ZigbeeZclThermostatGetWeeklySchedule_t *)
1348 g_malloc0(sizeof(ZigbeeZclThermostatGetWeeklySchedule_t));
1351 memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
1352 req->endpoint = in_req->endpoint;
1353 req->num_of_days = in_req->num_of_days;
1354 req->mode = in_req->mode;
1357 thermostat_request_data = (gpointer)req;
1361 case ZBLIB_ZCL_THERMOSTAT_OPS_SET_WEEKLY_SCHEDULE: {
1362 ZigbeeZclThermostatSetWeeklySchedule_t *in_req;
1363 ZigbeeZclThermostatSetWeeklySchedule_t *req = NULL;
1365 in_req = (ZigbeeZclThermostatSetWeeklySchedule_t *)request_data;
1366 if (NULL != in_req) {
1367 /* Allocate memory */
1368 req = (ZigbeeZclThermostatSetWeeklySchedule_t *)
1369 g_malloc0(sizeof(ZigbeeZclThermostatSetWeeklySchedule_t));
1372 memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
1373 req->endpoint = in_req->endpoint;
1374 req->no_of_transitions = in_req->no_of_transitions;
1375 req->num_of_days = in_req->num_of_days;
1376 req->mode = in_req->mode;
1377 memcpy(req->payload,
1378 in_req->payload, ZIGBEE_THERMSTAT_PAYLOAD_MAX_LEN);
1379 req->payload_len = in_req->payload_len;
1382 thermostat_request_data = (gpointer)req;
1386 case ZBLIB_ZCL_THERMOSTAT_OPS_CLEAR_WEEKLY_SCHEDULE: {
1387 ZigbeeZclThermostatClearWeeklySchedule_t *in_req;
1388 ZigbeeZclThermostatClearWeeklySchedule_t *req = NULL;
1390 in_req = (ZigbeeZclThermostatClearWeeklySchedule_t *)request_data;
1391 if (NULL != in_req) {
1392 /* Allocate memory */
1393 req = (ZigbeeZclThermostatClearWeeklySchedule_t *)
1394 g_malloc0(sizeof(ZigbeeZclThermostatClearWeeklySchedule_t));
1397 memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
1398 req->endpoint = in_req->endpoint;
1401 thermostat_request_data = (gpointer)req;
1405 case ZBLIB_ZCL_THERMOSTAT_OPS_SETPOINT_RAISE_LOWER: {
1406 ZigbeeZclThermostatSetpointRaiseLower_t *in_req;
1407 ZigbeeZclThermostatSetpointRaiseLower_t *req = NULL;
1409 in_req = (ZigbeeZclThermostatSetpointRaiseLower_t *)request_data;
1410 if (NULL != in_req) {
1411 /* Allocate memory */
1412 req = (ZigbeeZclThermostatSetpointRaiseLower_t *)
1413 g_malloc0(sizeof(ZigbeeZclThermostatSetpointRaiseLower_t));
1416 req->node_id = in_req->node_id;
1417 req->endpoint = in_req->endpoint;
1418 req->mode = in_req->mode;
1419 req->amount = in_req->amount;
1422 thermostat_request_data = (gpointer)req;
1430 return thermostat_request_data;
1433 static gpointer __zblib_request_create_zcl_basic_request_data(guint request_type,
1434 gpointer request_data, guint request_data_len)
1436 gpointer zclbasic_control_request_data = NULL;
1439 NOT_USED(request_data_len);
1442 ops_id = __zblib_request_get_ops_id(request_type);
1444 case ZBLIB_ZCL_BASIC_OPS_RESET_FACTORY_DEFAULT: {
1445 ZigbeeZclBasicResetFactoryDefault_t *in_req;
1446 ZigbeeZclBasicResetFactoryDefault_t *req = NULL;
1448 in_req = (ZigbeeZclBasicResetFactoryDefault_t *)request_data;
1449 if (NULL != in_req) {
1450 /* Allocate memory */
1451 req = (ZigbeeZclBasicResetFactoryDefault_t *)
1452 g_malloc0(sizeof(ZigbeeZclBasicResetFactoryDefault_t));
1455 req->node_id = in_req->node_id;
1456 req->dest_ep = in_req->dest_ep;
1459 zclbasic_control_request_data = (gpointer)req;
1467 return zclbasic_control_request_data;
1470 static gpointer __zblib_request_create_zcl_global_control_request_data(guint request_type,
1471 gpointer request_data, guint request_data_len)
1473 gpointer zclglobal_control_request_data = NULL;
1476 NOT_USED(request_data_len);
1479 ops_id = __zblib_request_get_ops_id(request_type);
1481 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_READ_ATTRIBUTES_REQ: {
1482 ZigbeeZclGlobalControlReadAttributesRequest_t *in_req;
1483 ZigbeeZclGlobalControlReadAttributesRequest_t *req = NULL;
1485 in_req = (ZigbeeZclGlobalControlReadAttributesRequest_t *)request_data;
1486 if (NULL != in_req) {
1487 /* Allocate memory */
1488 req = (ZigbeeZclGlobalControlReadAttributesRequest_t *)
1489 g_malloc0(sizeof(ZigbeeZclGlobalControlReadAttributesRequest_t));
1492 req->attribute_id = g_strdup(in_req->attribute_id);
1493 req->attribute_id_len = in_req->attribute_id_len;
1494 req->node_id = in_req->node_id;
1495 req->cluster_id = in_req->cluster_id;
1496 req->zcl_frame_ctrl = in_req->zcl_frame_ctrl;
1497 req->dest_ep = in_req->dest_ep;
1500 zclglobal_control_request_data = (gpointer)req;
1504 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_REQ: {
1505 ZigbeeZclGlobalControlWriteAttributesRequest_t *in_req;
1506 ZigbeeZclGlobalControlWriteAttributesRequest_t *req = NULL;
1508 in_req = (ZigbeeZclGlobalControlWriteAttributesRequest_t *)request_data;
1509 if (NULL != in_req) {
1510 /* Allocate memory */
1511 req = (ZigbeeZclGlobalControlWriteAttributesRequest_t *)
1512 g_malloc0(sizeof(ZigbeeZclGlobalControlWriteAttributesRequest_t));
1515 req->write_records = g_strdup(in_req->write_records);
1516 req->records_len = in_req->records_len;
1517 req->node_id = in_req->node_id;
1518 req->cluster_id = in_req->cluster_id;
1519 req->zcl_frame_ctrl = in_req->zcl_frame_ctrl;
1520 req->src_ep = in_req->src_ep;
1521 req->dest_ep = in_req->dest_ep;
1524 zclglobal_control_request_data = (gpointer)req;
1528 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_UNDIVIDED_REQ: {
1529 ZigbeeZclGlobalControlWriteAttributesUndividedRequest_t *in_req;
1530 ZigbeeZclGlobalControlWriteAttributesUndividedRequest_t *req = NULL;
1532 in_req = (ZigbeeZclGlobalControlWriteAttributesUndividedRequest_t *)request_data;
1533 if (NULL != in_req) {
1534 /* Allocate memory */
1535 req = (ZigbeeZclGlobalControlWriteAttributesUndividedRequest_t *)
1536 g_malloc0(sizeof(ZigbeeZclGlobalControlWriteAttributesUndividedRequest_t));
1539 req->write_records = g_strdup(in_req->write_records);
1540 req->records_len = in_req->records_len;
1541 req->node_id = in_req->node_id;
1542 req->cluster_id = in_req->cluster_id;
1543 req->zcl_frame_ctrl = in_req->zcl_frame_ctrl;
1544 req->src_ep = in_req->src_ep;
1545 req->dest_ep = in_req->dest_ep;
1548 zclglobal_control_request_data = (gpointer)req;
1552 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_NO_RESP: {
1553 ZigbeeZclGlobalControlWriteAttributesNoResponse_t *in_req;
1554 ZigbeeZclGlobalControlWriteAttributesNoResponse_t *req = NULL;
1556 in_req = (ZigbeeZclGlobalControlWriteAttributesNoResponse_t *)request_data;
1557 if (NULL != in_req) {
1558 /* Allocate memory */
1559 req = (ZigbeeZclGlobalControlWriteAttributesNoResponse_t *)
1560 g_malloc0(sizeof(ZigbeeZclGlobalControlWriteAttributesNoResponse_t));
1563 req->write_records = g_strdup(in_req->write_records);
1564 req->records_len = in_req->records_len;
1565 req->node_id = in_req->node_id;
1566 req->cluster_id = in_req->cluster_id;
1567 req->zcl_frame_ctrl = in_req->zcl_frame_ctrl;
1568 req->src_ep = in_req->src_ep;
1569 req->dest_ep = in_req->dest_ep;
1572 zclglobal_control_request_data = (gpointer)req;
1576 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_STRUCTURED: {
1577 ZigbeeZclGlobalControlWriteAttributesStructed_t *in_req;
1578 ZigbeeZclGlobalControlWriteAttributesStructed_t *req = NULL;
1580 in_req = (ZigbeeZclGlobalControlWriteAttributesStructed_t *)request_data;
1581 if (NULL != in_req) {
1582 /* Allocate memory */
1583 req = (ZigbeeZclGlobalControlWriteAttributesStructed_t *)
1584 g_malloc0(sizeof(ZigbeeZclGlobalControlWriteAttributesStructed_t));
1587 req->write_records = g_strdup(in_req->write_records);
1588 req->records_len = in_req->records_len;
1589 req->node_id = in_req->node_id;
1590 req->cluster_id = in_req->cluster_id;
1591 req->zcl_frame_ctrl = in_req->zcl_frame_ctrl;
1592 req->src_ep = in_req->src_ep;
1593 req->dest_ep = in_req->dest_ep;
1596 zclglobal_control_request_data = (gpointer)req;
1600 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_READ_ATTRIBUTES_STRUCTURED: {
1601 ZigbeeZclGlobalControlReadAttributesStructed_t *in_req;
1602 ZigbeeZclGlobalControlReadAttributesStructed_t *req = NULL;
1604 in_req = (ZigbeeZclGlobalControlReadAttributesStructed_t *)request_data;
1605 if (NULL != in_req) {
1606 /* Allocate memory */
1607 req = (ZigbeeZclGlobalControlReadAttributesStructed_t *)
1608 g_malloc0(sizeof(ZigbeeZclGlobalControlReadAttributesStructed_t));
1611 req->read_records = g_strdup(in_req->read_records);
1612 req->records_len = in_req->records_len;
1613 req->node_id = in_req->node_id;
1614 req->cluster_id = in_req->cluster_id;
1615 req->zcl_frame_ctrl = in_req->zcl_frame_ctrl;
1616 req->src_ep = in_req->src_ep;
1617 req->dest_ep = in_req->dest_ep;
1620 zclglobal_control_request_data = (gpointer)req;
1624 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_CONFIGURE_REPORTING_REQ: {
1625 ZigbeeZclGlobalControlConfigureReportingReq_t *in_req;
1626 ZigbeeZclGlobalControlConfigureReportingReq_t *req = NULL;
1628 in_req = (ZigbeeZclGlobalControlConfigureReportingReq_t *)request_data;
1629 if (NULL != in_req) {
1630 /* Allocate memory */
1631 req = (ZigbeeZclGlobalControlConfigureReportingReq_t *)
1632 g_malloc0(sizeof(ZigbeeZclGlobalControlConfigureReportingReq_t));
1635 req->read_records = g_strdup(in_req->read_records);
1636 req->records_len = in_req->records_len;
1637 req->node_id = in_req->node_id;
1638 req->cluster_id = in_req->cluster_id;
1639 req->zcl_frame_ctrl = in_req->zcl_frame_ctrl;
1640 req->src_ep = in_req->src_ep;
1641 req->dest_ep = in_req->dest_ep;
1644 zclglobal_control_request_data = (gpointer)req;
1648 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_READ_CONFIGURE_REPORTING: {
1649 ZigbeeZclGlobalControlReadConfigureReporting_t *in_req;
1650 ZigbeeZclGlobalControlReadConfigureReporting_t *req = NULL;
1652 in_req = (ZigbeeZclGlobalControlReadConfigureReporting_t *)request_data;
1653 if (NULL != in_req) {
1654 /* Allocate memory */
1655 req = (ZigbeeZclGlobalControlReadConfigureReporting_t *)
1656 g_malloc0(sizeof(ZigbeeZclGlobalControlReadConfigureReporting_t));
1659 req->read_records = g_strdup(in_req->read_records);
1660 req->records_len = in_req->records_len;
1661 req->node_id = in_req->node_id;
1662 req->cluster_id = in_req->cluster_id;
1663 req->zcl_frame_ctrl = in_req->zcl_frame_ctrl;
1664 req->src_ep = in_req->src_ep;
1665 req->dest_ep = in_req->dest_ep;
1668 zclglobal_control_request_data = (gpointer)req;
1672 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_DISCOVER_ATTRIBUTES: {
1673 ZigbeeZclGlobalControlDiscoverAttributes_t *in_req;
1674 ZigbeeZclGlobalControlDiscoverAttributes_t *req = NULL;
1676 in_req = (ZigbeeZclGlobalControlDiscoverAttributes_t *)request_data;
1677 if (NULL != in_req) {
1678 /* Allocate memory */
1679 req = (ZigbeeZclGlobalControlDiscoverAttributes_t *)
1680 g_malloc0(sizeof(ZigbeeZclGlobalControlDiscoverAttributes_t));
1683 req->node_id = in_req->node_id;
1684 req->dest_ep = in_req->dest_ep;
1685 req->zcl_frame_ctrl = in_req->zcl_frame_ctrl;
1686 req->cluster_id = in_req->cluster_id;
1687 req->start_attribute = in_req->start_attribute;
1688 req->max = in_req->max;
1691 zclglobal_control_request_data = (gpointer)req;
1695 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_DISCOVER_ATTRIBUTES_EXTENDED: {
1696 ZigbeeZclGlobalControlDiscoverAttributesExtended_t *in_req;
1697 ZigbeeZclGlobalControlDiscoverAttributesExtended_t *req = NULL;
1699 in_req = (ZigbeeZclGlobalControlDiscoverAttributesExtended_t *)request_data;
1700 if (NULL != in_req) {
1701 /* Allocate memory */
1702 req = (ZigbeeZclGlobalControlDiscoverAttributesExtended_t *)
1703 g_malloc0(sizeof(ZigbeeZclGlobalControlDiscoverAttributesExtended_t));
1706 req->node_id = in_req->node_id;
1707 req->dest_ep = in_req->dest_ep;
1708 req->zcl_frame_ctrl = in_req->zcl_frame_ctrl;
1709 req->cluster_id = in_req->cluster_id;
1710 req->start_attribute = in_req->start_attribute;
1711 req->max = in_req->max;
1714 zclglobal_control_request_data = (gpointer)req;
1718 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_DISCOVER_COMMANDS_RECEIVED: {
1719 ZigbeeZclGlobalControlDiscoverCommandsReceived_t *in_req;
1720 ZigbeeZclGlobalControlDiscoverCommandsReceived_t *req = NULL;
1722 in_req = (ZigbeeZclGlobalControlDiscoverCommandsReceived_t *)request_data;
1723 if (NULL != in_req) {
1724 /* Allocate memory */
1725 req = (ZigbeeZclGlobalControlDiscoverCommandsReceived_t *)
1726 g_malloc0(sizeof(ZigbeeZclGlobalControlDiscoverCommandsReceived_t));
1729 req->node_id = in_req->node_id;
1730 req->dest_ep = in_req->dest_ep;
1731 req->zcl_frame_ctrl = in_req->zcl_frame_ctrl;
1732 req->cluster_id = in_req->cluster_id;
1733 req->start_attribute = in_req->start_attribute;
1734 req->max = in_req->max;
1737 zclglobal_control_request_data = (gpointer)req;
1741 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_DISCOVER_COMMANDS_GENERATED: {
1742 ZigbeeZclGlobalControlDiscoverCommandsGenerated_t *in_req;
1743 ZigbeeZclGlobalControlDiscoverCommandsGenerated_t *req = NULL;
1745 in_req = (ZigbeeZclGlobalControlDiscoverCommandsGenerated_t *)request_data;
1746 if (NULL != in_req) {
1747 /* Allocate memory */
1748 req = (ZigbeeZclGlobalControlDiscoverCommandsGenerated_t *)
1749 g_malloc0(sizeof(ZigbeeZclGlobalControlDiscoverCommandsGenerated_t));
1752 req->node_id = in_req->node_id;
1753 req->dest_ep = in_req->dest_ep;
1754 req->zcl_frame_ctrl = in_req->zcl_frame_ctrl;
1755 req->cluster_id = in_req->cluster_id;
1756 req->start_attribute = in_req->start_attribute;
1757 req->max = in_req->max;
1760 zclglobal_control_request_data = (gpointer)req;
1768 return zclglobal_control_request_data;
1771 static gpointer __zblib_request_create_zcl_ias_zone_request_data(guint request_type,
1772 gpointer request_data, guint request_data_len)
1774 gpointer zclias_control_request_data = NULL;
1777 NOT_USED(request_data_len);
1780 ops_id = __zblib_request_get_ops_id(request_type);
1782 case ZBLIB_ZCL_IAS_ZONE_OPS_ENROLL_RESPONSE: {
1783 ZigbeeZclIasZoneEnrollResponse_t *in_req;
1784 ZigbeeZclIasZoneEnrollResponse_t *req = NULL;
1786 in_req = (ZigbeeZclIasZoneEnrollResponse_t *)request_data;
1787 if (NULL != in_req) {
1788 /* Allocate memory */
1789 req = (ZigbeeZclIasZoneEnrollResponse_t *)
1790 g_malloc0(sizeof(ZigbeeZclIasZoneEnrollResponse_t));
1793 req->node_id = in_req->node_id;
1794 req->dest_ep = in_req->dest_ep;
1795 req->enroll_code = in_req->enroll_code;
1796 req->zone_id = in_req->zone_id;
1799 zclias_control_request_data = (gpointer)req;
1807 return zclias_control_request_data;
1810 static gpointer __zblib_request_create_zcl_identify_request_data(guint request_type,
1811 gpointer request_data, guint request_data_len)
1813 gpointer zclidentify_control_request_data = NULL;
1816 NOT_USED(request_data_len);
1819 ops_id = __zblib_request_get_ops_id(request_type);
1821 case ZBLIB_ZCL_IDENTIFY_OPS_IDENTIFY: {
1822 ZigbeeZclIdentifyIdentify_t *in_req;
1823 ZigbeeZclIdentifyIdentify_t *req = NULL;
1825 in_req = (ZigbeeZclIdentifyIdentify_t *)request_data;
1826 if (NULL != in_req) {
1827 /* Allocate memory */
1828 req = (ZigbeeZclIdentifyIdentify_t *)
1829 g_malloc0(sizeof(ZigbeeZclIdentifyIdentify_t));
1832 req->node_id = in_req->node_id;
1833 req->dest_ep = in_req->dest_ep;
1834 req->identify_time = in_req->identify_time;
1837 zclidentify_control_request_data = (gpointer)req;
1841 case ZBLIB_ZCL_IDENTIFY_OPS_QUERY: {
1842 ZigbeeZclIdentifyQuery_t *in_req;
1843 ZigbeeZclIdentifyQuery_t *req = NULL;
1845 in_req = (ZigbeeZclIdentifyQuery_t *)request_data;
1846 if (NULL != in_req) {
1847 /* Allocate memory */
1848 req = (ZigbeeZclIdentifyQuery_t *)
1849 g_malloc0(sizeof(ZigbeeZclIdentifyQuery_t));
1852 req->node_id = in_req->node_id;
1855 zclidentify_control_request_data = (gpointer)req;
1863 return zclidentify_control_request_data;
1866 static gpointer __zblib_request_create_zcl_color_control_request_data(guint request_type,
1867 gpointer request_data, guint request_data_len)
1869 gpointer zcl_color_request_data = NULL;
1872 NOT_USED(request_data_len);
1875 ops_id = __zblib_request_get_ops_id(request_type);
1877 case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_TO_HUE: {
1878 ZigbeeZclColorControlMoveToHue_t *in_req;
1879 ZigbeeZclColorControlMoveToHue_t *req = NULL;
1881 in_req = (ZigbeeZclColorControlMoveToHue_t *)request_data;
1882 if (NULL != in_req) {
1883 /* Allocate memory */
1884 req = (ZigbeeZclColorControlMoveToHue_t *)
1885 g_malloc0(sizeof(ZigbeeZclColorControlMoveToHue_t));
1888 req->node_id = in_req->node_id;
1889 req->dest_ep = in_req->dest_ep;
1890 req->hue = in_req->hue;
1891 req->direction = in_req->direction;
1892 req->transition_time = in_req->transition_time;
1895 zcl_color_request_data = (gpointer)req;
1899 case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_HUE: {
1900 ZigbeeZclColorControlMoveHue_t *in_req;
1901 ZigbeeZclColorControlMoveHue_t *req = NULL;
1903 in_req = (ZigbeeZclColorControlMoveHue_t *)request_data;
1904 if (NULL != in_req) {
1905 /* Allocate memory */
1906 req = (ZigbeeZclColorControlMoveHue_t *)
1907 g_malloc0(sizeof(ZigbeeZclColorControlMoveHue_t));
1910 req->node_id = in_req->node_id;
1911 req->dest_ep = in_req->dest_ep;
1912 req->move_mode = in_req->move_mode;
1913 req->rate = in_req->rate;
1916 zcl_color_request_data = (gpointer)req;
1920 case ZBLIB_ZCL_COLOR_CONTROL_OPS_STEP_HUE: {
1921 ZigbeeZclColorControlStepHue_t *in_req;
1922 ZigbeeZclColorControlStepHue_t *req = NULL;
1924 in_req = (ZigbeeZclColorControlStepHue_t *)request_data;
1925 if (NULL != in_req) {
1926 /* Allocate memory */
1927 req = (ZigbeeZclColorControlStepHue_t *)
1928 g_malloc0(sizeof(ZigbeeZclColorControlStepHue_t));
1931 req->node_id = in_req->node_id;
1932 req->dest_ep = in_req->dest_ep;
1933 req->step_mode = in_req->step_mode;
1934 req->step_size = in_req->step_size;
1935 req->transition_time = in_req->transition_time;
1938 zcl_color_request_data = (gpointer)req;
1942 case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_TO_STAURATION: {
1943 ZigbeeZclColorControlMoveToSaturation_t *in_req;
1944 ZigbeeZclColorControlMoveToSaturation_t *req = NULL;
1946 in_req = (ZigbeeZclColorControlMoveToSaturation_t *)request_data;
1947 if (NULL != in_req) {
1948 /* Allocate memory */
1949 req = (ZigbeeZclColorControlMoveToSaturation_t *)
1950 g_malloc0(sizeof(ZigbeeZclColorControlMoveToSaturation_t));
1953 req->node_id = in_req->node_id;
1954 req->dest_ep = in_req->dest_ep;
1955 req->saturation = in_req->saturation;
1956 req->transition_time = in_req->transition_time;
1959 zcl_color_request_data = (gpointer)req;
1963 case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_STAURATION: {
1964 ZigbeeZclColorControlMoveSaturation_t *in_req;
1965 ZigbeeZclColorControlMoveSaturation_t *req = NULL;
1967 in_req = (ZigbeeZclColorControlMoveSaturation_t *)request_data;
1968 if (NULL != in_req) {
1969 /* Allocate memory */
1970 req = (ZigbeeZclColorControlMoveSaturation_t *)
1971 g_malloc0(sizeof(ZigbeeZclColorControlMoveSaturation_t));
1974 req->node_id = in_req->node_id;
1975 req->dest_ep = in_req->dest_ep;
1976 req->move_mode = in_req->move_mode;
1977 req->rate = in_req->rate;
1980 zcl_color_request_data = (gpointer)req;
1984 case ZBLIB_ZCL_COLOR_CONTROL_OPS_STEP_STAURATION: {
1985 ZigbeeZclColorControlStepSaturation_t *in_req;
1986 ZigbeeZclColorControlStepSaturation_t *req = NULL;
1988 in_req = (ZigbeeZclColorControlStepSaturation_t *)request_data;
1989 if (NULL != in_req) {
1990 /* Allocate memory */
1991 req = (ZigbeeZclColorControlStepSaturation_t *)
1992 g_malloc0(sizeof(ZigbeeZclColorControlStepSaturation_t));
1995 req->node_id = in_req->node_id;
1996 req->dest_ep = in_req->dest_ep;
1997 req->step_mode = in_req->step_mode;
1998 req->step_size = in_req->step_size;
1999 req->transition_time = in_req->transition_time;
2002 zcl_color_request_data = (gpointer)req;
2006 case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_TO_HUE_AND_SATURATION: {
2007 ZigbeeZclColorControlMoveToHueAndSaturation_t *in_req;
2008 ZigbeeZclColorControlMoveToHueAndSaturation_t *req = NULL;
2010 in_req = (ZigbeeZclColorControlMoveToHueAndSaturation_t *)request_data;
2011 if (NULL != in_req) {
2012 /* Allocate memory */
2013 req = (ZigbeeZclColorControlMoveToHueAndSaturation_t *)
2014 g_malloc0(sizeof(ZigbeeZclColorControlMoveToHueAndSaturation_t));
2017 req->node_id = in_req->node_id;
2018 req->dest_ep = in_req->dest_ep;
2019 req->hue = in_req->hue;
2020 req->saturation = in_req->saturation;
2021 req->transition_time = in_req->transition_time;
2024 zcl_color_request_data = (gpointer)req;
2028 case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_TO_COLOR: {
2029 ZigbeeZclColorControlMoveToColor_t *in_req;
2030 ZigbeeZclColorControlMoveToColor_t *req = NULL;
2032 in_req = (ZigbeeZclColorControlMoveToColor_t *)request_data;
2033 if (NULL != in_req) {
2034 /* Allocate memory */
2035 req = (ZigbeeZclColorControlMoveToColor_t *)
2036 g_malloc0(sizeof(ZigbeeZclColorControlMoveToColor_t));
2039 req->node_id = in_req->node_id;
2040 req->dest_ep = in_req->dest_ep;
2041 req->color_x = in_req->color_x;
2042 req->color_y = in_req->color_y;
2043 req->transition_time = in_req->transition_time;
2046 zcl_color_request_data = (gpointer)req;
2050 case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_COLOR: {
2051 ZigbeeZclColorControlMoveColor_t *in_req;
2052 ZigbeeZclColorControlMoveColor_t *req = NULL;
2054 in_req = (ZigbeeZclColorControlMoveColor_t *)request_data;
2055 if (NULL != in_req) {
2056 /* Allocate memory */
2057 req = (ZigbeeZclColorControlMoveColor_t *)
2058 g_malloc0(sizeof(ZigbeeZclColorControlMoveColor_t));
2061 req->node_id = in_req->node_id;
2062 req->dest_ep = in_req->dest_ep;
2063 req->rate_x = in_req->rate_x;
2064 req->rate_y = in_req->rate_y;
2067 zcl_color_request_data = (gpointer)req;
2071 case ZBLIB_ZCL_COLOR_CONTROL_OPS_STEP_COLOR: {
2072 ZigbeeZclColorControlStepColor_t *in_req;
2073 ZigbeeZclColorControlStepColor_t *req = NULL;
2075 in_req = (ZigbeeZclColorControlStepColor_t *)request_data;
2076 if (NULL != in_req) {
2077 /* Allocate memory */
2078 req = (ZigbeeZclColorControlStepColor_t *)
2079 g_malloc0(sizeof(ZigbeeZclColorControlStepColor_t));
2082 req->node_id = in_req->node_id;
2083 req->dest_ep = in_req->dest_ep;
2084 req->step_x = in_req->step_x;
2085 req->step_y = in_req->step_y;
2086 req->transition_time = in_req->transition_time;
2089 zcl_color_request_data = (gpointer)req;
2093 case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_COLOR_TEMPERATURE: {
2094 ZigbeeZclColorControlMoveColorTemperature_t *in_req;
2095 ZigbeeZclColorControlMoveColorTemperature_t *req = NULL;
2097 in_req = (ZigbeeZclColorControlMoveColorTemperature_t *)request_data;
2098 if (NULL != in_req) {
2099 /* Allocate memory */
2100 req = (ZigbeeZclColorControlMoveColorTemperature_t *)
2101 g_malloc0(sizeof(ZigbeeZclColorControlMoveColorTemperature_t));
2104 req->node_id = in_req->node_id;
2105 req->dest_ep = in_req->dest_ep;
2106 req->color_temperature = in_req->color_temperature;
2107 req->transition_time = in_req->transition_time;
2110 zcl_color_request_data = (gpointer)req;
2118 return zcl_color_request_data;
2121 static gpointer __zblib_request_create_zcl_group_request_data(guint request_type,
2122 gpointer request_data, guint request_data_len)
2124 gpointer zcl_group_request_data = NULL;
2127 NOT_USED(request_data_len);
2130 ops_id = __zblib_request_get_ops_id(request_type);
2132 case ZBLIB_ZCL_GROUP_OPS_ADD_GROUP: {
2133 ZigbeeZclGroupAddGroup_t *in_req;
2134 ZigbeeZclGroupAddGroup_t *req = NULL;
2136 in_req = (ZigbeeZclGroupAddGroup_t *)request_data;
2137 if (NULL != in_req) {
2138 /* Allocate memory */
2139 req = (ZigbeeZclGroupAddGroup_t *)
2140 g_malloc0(sizeof(ZigbeeZclGroupAddGroup_t));
2143 req->node_id = in_req->node_id;
2144 req->dest_ep = in_req->dest_ep;
2145 req->group_id = in_req->group_id;
2146 g_strlcpy(req->group_name,
2147 in_req->group_name, ZIGBEE_ZCL_GROUP_NAME_MAX_LEN + 1);
2150 zcl_group_request_data = (gpointer)req;
2154 case ZBLIB_ZCL_GROUP_OPS_VIEW_GROUP: {
2155 ZigbeeZclGroupViewGroup_t *in_req;
2156 ZigbeeZclGroupViewGroup_t *req = NULL;
2158 in_req = (ZigbeeZclGroupViewGroup_t *)request_data;
2159 if (NULL != in_req) {
2160 /* Allocate memory */
2161 req = (ZigbeeZclGroupViewGroup_t *)
2162 g_malloc0(sizeof(ZigbeeZclGroupViewGroup_t));
2165 req->node_id = in_req->node_id;
2166 req->dest_ep = in_req->dest_ep;
2169 zcl_group_request_data = (gpointer)req;
2173 case ZBLIB_ZCL_GROUP_OPS_GET_GROUP_MEMBERSHIP: {
2174 ZigbeeZclGroupGetGroupMembership_t *in_req;
2175 ZigbeeZclGroupGetGroupMembership_t *req = NULL;
2177 in_req = (ZigbeeZclGroupGetGroupMembership_t *)request_data;
2178 if (NULL != in_req) {
2179 /* Allocate memory */
2180 req = (ZigbeeZclGroupGetGroupMembership_t *)
2181 g_malloc0(sizeof(ZigbeeZclGroupGetGroupMembership_t));
2184 req->node_id = in_req->node_id;
2185 req->dest_ep = in_req->dest_ep;
2186 req->group_count = in_req->group_count;
2187 req->group_list = (gshort *)g_memdup(in_req->group_list,
2188 in_req->group_count);
2191 zcl_group_request_data = (gpointer)req;
2195 case ZBLIB_ZCL_GROUP_OPS_REMOVE_GROUP: {
2196 ZigbeeZclGroupRemoveGroup_t *in_req;
2197 ZigbeeZclGroupRemoveGroup_t *req = NULL;
2199 in_req = (ZigbeeZclGroupRemoveGroup_t *)request_data;
2200 if (NULL != in_req) {
2201 /* Allocate memory */
2202 req = (ZigbeeZclGroupRemoveGroup_t *)
2203 g_malloc0(sizeof(ZigbeeZclGroupRemoveGroup_t));
2206 req->node_id = in_req->node_id;
2207 req->dest_ep = in_req->dest_ep;
2208 req->group_id = in_req->group_id;
2211 zcl_group_request_data = (gpointer)req;
2215 case ZBLIB_ZCL_GROUP_OPS_REMOVE_ALL_GROUP: {
2216 ZigbeeZclGroupRemoveAllGroup_t *in_req;
2217 ZigbeeZclGroupRemoveAllGroup_t *req = NULL;
2219 in_req = (ZigbeeZclGroupRemoveAllGroup_t *)request_data;
2220 if (NULL != in_req) {
2221 /* Allocate memory */
2222 req = (ZigbeeZclGroupRemoveAllGroup_t *)
2223 g_malloc0(sizeof(ZigbeeZclGroupRemoveAllGroup_t));
2226 req->node_id = in_req->node_id;
2227 req->dest_ep = in_req->dest_ep;
2230 zcl_group_request_data = (gpointer)req;
2234 case ZBLIB_ZCL_GROUP_OPS_ADD_GROUP_IF_IDENTIFYING: {
2235 ZigbeeZclGroupAddGroupIfIdentifying_t *in_req;
2236 ZigbeeZclGroupAddGroupIfIdentifying_t *req = NULL;
2238 in_req = (ZigbeeZclGroupAddGroupIfIdentifying_t *)request_data;
2239 if (NULL != in_req) {
2240 /* Allocate memory */
2241 req = (ZigbeeZclGroupAddGroupIfIdentifying_t *)
2242 g_malloc0(sizeof(ZigbeeZclGroupAddGroupIfIdentifying_t));
2245 req->node_id = in_req->node_id;
2246 req->dest_ep = in_req->dest_ep;
2247 req->group_id = in_req->group_id;
2248 g_strlcpy(req->group_name,
2249 in_req->group_name, ZIGBEE_ZCL_GROUP_NAME_MAX_LEN + 1);
2252 zcl_group_request_data = (gpointer)req;
2260 return zcl_group_request_data;
2263 static gpointer __zblib_request_create_zcl_poll_control_request_data(guint request_type,
2264 gpointer request_data, guint request_data_len)
2266 gpointer zcl_poll_control_request_data = NULL;
2269 NOT_USED(request_data_len);
2272 ops_id = __zblib_request_get_ops_id(request_type);
2274 case ZBLIB_ZCL_POLL_CONTROL_OPS_CHECK_IN_RESPONSE: {
2275 ZigbeeZclPollControlCheckInResponse_t *in_req;
2276 ZigbeeZclPollControlCheckInResponse_t *req = NULL;
2278 in_req = (ZigbeeZclPollControlCheckInResponse_t *)request_data;
2279 if (NULL != in_req) {
2280 /* Allocate memory */
2281 req = (ZigbeeZclPollControlCheckInResponse_t *)
2282 g_malloc0(sizeof(ZigbeeZclPollControlCheckInResponse_t));
2285 req->node_id = in_req->node_id;
2286 req->dest_ep = in_req->dest_ep;
2287 req->start_fast_polling = in_req->start_fast_polling;
2288 req->fast_poll_timeout = in_req->fast_poll_timeout;
2291 zcl_poll_control_request_data = (gpointer)req;
2295 case ZBLIB_ZCL_POLL_CONTROL_OPS_FAST_POLL_STOP: {
2296 ZigbeeZclPollControlFastPollStop_t *in_req;
2297 ZigbeeZclPollControlFastPollStop_t *req = NULL;
2299 in_req = (ZigbeeZclPollControlFastPollStop_t *)request_data;
2300 if (NULL != in_req) {
2301 /* Allocate memory */
2302 req = (ZigbeeZclPollControlFastPollStop_t *)
2303 g_malloc0(sizeof(ZigbeeZclPollControlFastPollStop_t));
2306 req->node_id = in_req->node_id;
2307 req->dest_ep = in_req->dest_ep;
2310 zcl_poll_control_request_data = (gpointer)req;
2314 case ZBLIB_ZCL_POLL_CONTROL_OPS_SET_LONG_POLL_INTERVAL: {
2315 ZigbeeZclPollControlSetLongPollInterval_t *in_req;
2316 ZigbeeZclPollControlSetLongPollInterval_t *req = NULL;
2318 in_req = (ZigbeeZclPollControlSetLongPollInterval_t *)request_data;
2319 if (NULL != in_req) {
2320 /* Allocate memory */
2321 req = (ZigbeeZclPollControlSetLongPollInterval_t *)
2322 g_malloc0(sizeof(ZigbeeZclPollControlSetLongPollInterval_t));
2325 req->node_id = in_req->node_id;
2326 req->dest_ep = in_req->dest_ep;
2327 req->new_long_poll_interval = in_req->new_long_poll_interval;
2330 zcl_poll_control_request_data = (gpointer)req;
2334 case ZBLIB_ZCL_POLL_CONTROL_OPS_SET_SHORT_POLL_INTERVAL: {
2335 ZigbeeZclPollControlSetShortPollInterval_t *in_req;
2336 ZigbeeZclPollControlSetShortPollInterval_t *req = NULL;
2338 in_req = (ZigbeeZclPollControlSetShortPollInterval_t *)request_data;
2339 if (NULL != in_req) {
2340 /* Allocate memory */
2341 req = (ZigbeeZclPollControlSetShortPollInterval_t *)
2342 g_malloc0(sizeof(ZigbeeZclPollControlSetShortPollInterval_t));
2345 req->node_id = in_req->node_id;
2346 req->dest_ep = in_req->dest_ep;
2347 req->new_short_poll_interval = in_req->new_short_poll_interval;
2350 zcl_poll_control_request_data = (gpointer)req;
2358 return zcl_poll_control_request_data;
2361 static gpointer __zblib_request_create_zcl_scene_request_data(guint request_type,
2362 gpointer request_data, guint request_data_len)
2364 gpointer zcl_scene_request_data = NULL;
2367 NOT_USED(request_data_len);
2370 ops_id = __zblib_request_get_ops_id(request_type);
2372 case ZBLIB_ZCL_SCENE_OPS_ADD_SCENE: {
2373 ZigbeeZclSceneAddScene_t *in_req;
2374 ZigbeeZclSceneAddScene_t *req = NULL;
2376 in_req = (ZigbeeZclSceneAddScene_t *)request_data;
2377 if (NULL != in_req) {
2378 /* Allocate memory */
2379 req = (ZigbeeZclSceneAddScene_t *)
2380 g_malloc0(sizeof(ZigbeeZclSceneAddScene_t));
2383 req->node_id = in_req->node_id;
2384 req->dest_ep = in_req->dest_ep;
2385 req->group_id = in_req->group_id;
2386 req->scene_id = in_req->scene_id;
2387 req->transition_time = in_req->transition_time;
2388 g_strlcpy(req->scene_name,
2389 in_req->scene_name, ZIGBEE_ZCL_SCENE_NAME_MAX_LEN + 1);
2390 req->ext_field_set_len = in_req->ext_field_set_len;
2391 req->ext_field_set = (char *)g_memdup(in_req->ext_field_set,
2392 in_req->ext_field_set_len);
2395 zcl_scene_request_data = (gpointer)req;
2399 case ZBLIB_ZCL_SCENE_OPS_VIEW_SCENE: {
2400 ZigbeeZclSceneViewScene_t *in_req;
2401 ZigbeeZclSceneViewScene_t *req = NULL;
2403 in_req = (ZigbeeZclSceneViewScene_t *)request_data;
2404 if (NULL != in_req) {
2405 /* Allocate memory */
2406 req = (ZigbeeZclSceneViewScene_t *)
2407 g_malloc0(sizeof(ZigbeeZclSceneViewScene_t));
2410 req->node_id = in_req->node_id;
2411 req->dest_ep = in_req->dest_ep;
2412 req->group_id = in_req->group_id;
2413 req->scene_id = in_req->scene_id;
2416 zcl_scene_request_data = (gpointer)req;
2420 case ZBLIB_ZCL_SCENE_OPS_REMOVE_SCENE: {
2421 ZigbeeZclSceneRemoveScene_t *in_req;
2422 ZigbeeZclSceneRemoveScene_t *req = NULL;
2424 in_req = (ZigbeeZclSceneRemoveScene_t *)request_data;
2425 if (NULL != in_req) {
2426 /* Allocate memory */
2427 req = (ZigbeeZclSceneRemoveScene_t *)
2428 g_malloc0(sizeof(ZigbeeZclSceneRemoveScene_t));
2431 req->node_id = in_req->node_id;
2432 req->dest_ep = in_req->dest_ep;
2433 req->group_id = in_req->group_id;
2434 req->scene_id = in_req->scene_id;
2437 zcl_scene_request_data = (gpointer)req;
2441 case ZBLIB_ZCL_SCENE_OPS_STORE_SCENE: {
2442 ZigbeeZclSceneStoreScene_t *in_req;
2443 ZigbeeZclSceneStoreScene_t *req = NULL;
2445 in_req = (ZigbeeZclSceneStoreScene_t *)request_data;
2446 if (NULL != in_req) {
2447 /* Allocate memory */
2448 req = (ZigbeeZclSceneStoreScene_t *)
2449 g_malloc0(sizeof(ZigbeeZclSceneStoreScene_t));
2452 req->node_id = in_req->node_id;
2453 req->dest_ep = in_req->dest_ep;
2454 req->group_id = in_req->group_id;
2455 req->scene_id = in_req->scene_id;
2458 zcl_scene_request_data = (gpointer)req;
2462 case ZBLIB_ZCL_SCENE_OPS_RECALL_SCENE: {
2463 ZigbeeZclSceneRecallScene_t *in_req;
2464 ZigbeeZclSceneRecallScene_t *req = NULL;
2466 in_req = (ZigbeeZclSceneRecallScene_t *)request_data;
2467 if (NULL != in_req) {
2468 /* Allocate memory */
2469 req = (ZigbeeZclSceneRecallScene_t *)
2470 g_malloc0(sizeof(ZigbeeZclSceneRecallScene_t));
2473 req->node_id = in_req->node_id;
2474 req->dest_ep = in_req->dest_ep;
2475 req->group_id = in_req->group_id;
2476 req->scene_id = in_req->scene_id;
2479 zcl_scene_request_data = (gpointer)req;
2483 case ZBLIB_ZCL_SCENE_OPS_REMOVE_ALL_SCENE: {
2484 ZigbeeZclSceneRemoveAllScene_t *in_req;
2485 ZigbeeZclSceneRemoveAllScene_t *req = NULL;
2487 in_req = (ZigbeeZclSceneRemoveAllScene_t *)request_data;
2488 if (NULL != in_req) {
2489 /* Allocate memory */
2490 req = (ZigbeeZclSceneRemoveAllScene_t *)
2491 g_malloc0(sizeof(ZigbeeZclSceneRemoveAllScene_t));
2494 req->node_id = in_req->node_id;
2495 req->dest_ep = in_req->dest_ep;
2496 req->group_id = in_req->group_id;
2499 zcl_scene_request_data = (gpointer)req;
2503 case ZBLIB_ZCL_SCENE_OPS_GET_SCENE_MEMBERSHIP: {
2504 ZigbeeZclSceneGetSceneMembership_t *in_req;
2505 ZigbeeZclSceneGetSceneMembership_t *req = NULL;
2507 in_req = (ZigbeeZclSceneGetSceneMembership_t *)request_data;
2508 if (NULL != in_req) {
2509 /* Allocate memory */
2510 req = (ZigbeeZclSceneGetSceneMembership_t *)
2511 g_malloc0(sizeof(ZigbeeZclSceneGetSceneMembership_t));
2514 req->node_id = in_req->node_id;
2515 req->dest_ep = in_req->dest_ep;
2516 req->group_id = in_req->group_id;
2519 zcl_scene_request_data = (gpointer)req;
2527 return zcl_scene_request_data;
2530 static gpointer __zblib_request_create_zdo_dev_control_request_data(guint request_type,
2531 gpointer request_data, guint request_data_len)
2533 gpointer zdodev_control_request_data = NULL;
2536 NOT_USED(request_data_len);
2539 ops_id = __zblib_request_get_ops_id(request_type);
2541 case ZBLIB_ZDO_DEV_CONTROL_OPS_NWK_ADDR_REQ: {
2542 ZigbeeZdoDevControlNwkAddrReq_t *in_req;
2543 ZigbeeZdoDevControlNwkAddrReq_t *req = NULL;
2545 in_req = (ZigbeeZdoDevControlNwkAddrReq_t *)request_data;
2546 if (NULL != in_req) {
2547 /* Allocate memory */
2548 req = (ZigbeeZdoDevControlNwkAddrReq_t *)
2549 g_malloc0(sizeof(ZigbeeZdoDevControlNwkAddrReq_t));
2552 memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
2553 req->request_type = in_req->request_type;
2554 req->start_index = in_req->start_index;
2557 zdodev_control_request_data = (gpointer)req;
2561 case ZBLIB_ZDO_DEV_CONTROL_OPS_MATCHED_DESCRIPTOR_REQ: {
2562 ZigbeeZdoDevControlMatchedDescriptorReq_t *in_req;
2563 ZigbeeZdoDevControlMatchedDescriptorReq_t *req = NULL;
2565 in_req = (ZigbeeZdoDevControlMatchedDescriptorReq_t *)request_data;
2566 if (NULL != in_req) {
2567 /* Allocate memory */
2568 req = (ZigbeeZdoDevControlMatchedDescriptorReq_t *)
2569 g_malloc0(sizeof(ZigbeeZdoDevControlMatchedDescriptorReq_t));
2572 req->node_id = in_req->node_id;
2573 req->profile_id = in_req->profile_id;
2574 req->num_in_cl = in_req->num_in_cl;
2575 req->in_cl = g_strdup(in_req->in_cl);
2576 req->num_out_cl = in_req->num_out_cl;
2577 req->out_cl = g_strdup(in_req->out_cl);
2580 zdodev_control_request_data = (gpointer)req;
2584 case ZBLIB_ZDO_DEV_CONTROL_OPS_IEEE_ADDR_REQ: {
2585 ZigbeeZdoDevControlIeeeAddrReq_t *in_req;
2586 ZigbeeZdoDevControlIeeeAddrReq_t *req = NULL;
2588 in_req = (ZigbeeZdoDevControlIeeeAddrReq_t *)request_data;
2589 if (NULL != in_req) {
2590 /* Allocate memory */
2591 req = (ZigbeeZdoDevControlIeeeAddrReq_t *)
2592 g_malloc0(sizeof(ZigbeeZdoDevControlIeeeAddrReq_t));
2595 req->node_id = in_req->node_id;
2598 zdodev_control_request_data = (gpointer)req;
2602 case ZBLIB_ZDO_DEV_CONTROL_OPS_ACTIVE_EP_REQ: {
2603 ZigbeeZdoDevControlActiveEpReq_t *in_req;
2604 ZigbeeZdoDevControlActiveEpReq_t *req = NULL;
2606 in_req = (ZigbeeZdoDevControlActiveEpReq_t *)request_data;
2607 if (NULL != in_req) {
2608 /* Allocate memory */
2609 req = (ZigbeeZdoDevControlActiveEpReq_t *)
2610 g_malloc0(sizeof(ZigbeeZdoDevControlActiveEpReq_t));
2613 req->node_id = in_req->node_id;
2616 zdodev_control_request_data = (gpointer)req;
2620 case ZBLIB_ZDO_DEV_CONTROL_OPS_NODE_DESC_REQ: {
2621 ZigbeeZdoDevControlNodeDescriptorReq_t *in_req;
2622 ZigbeeZdoDevControlNodeDescriptorReq_t *req = NULL;
2624 in_req = (ZigbeeZdoDevControlNodeDescriptorReq_t *)request_data;
2625 if (NULL != in_req) {
2626 /* Allocate memory */
2627 req = (ZigbeeZdoDevControlNodeDescriptorReq_t *)
2628 g_malloc0(sizeof(ZigbeeZdoDevControlNodeDescriptorReq_t));
2631 req->node_id = in_req->node_id;
2634 zdodev_control_request_data = (gpointer)req;
2638 case ZBLIB_ZDO_DEV_CONTROL_OPS_POWER_DESC_REQ: {
2639 ZigbeeZdoDevControlPowerDescriptorReq_t *in_req;
2640 ZigbeeZdoDevControlPowerDescriptorReq_t *req = NULL;
2642 in_req = (ZigbeeZdoDevControlPowerDescriptorReq_t *)request_data;
2643 if (NULL != in_req) {
2644 /* Allocate memory */
2645 req = (ZigbeeZdoDevControlPowerDescriptorReq_t *)
2646 g_malloc0(sizeof(ZigbeeZdoDevControlPowerDescriptorReq_t));
2649 req->node_id = in_req->node_id;
2652 zdodev_control_request_data = (gpointer)req;
2656 case ZBLIB_ZDO_DEV_CONTROL_OPS_COMPLEX_DESC_REQ: {
2657 ZigbeeZdoDevControlComplexDescriptorReq_t *in_req;
2658 ZigbeeZdoDevControlComplexDescriptorReq_t *req = NULL;
2660 in_req = (ZigbeeZdoDevControlComplexDescriptorReq_t *)request_data;
2661 if (NULL != in_req) {
2662 /* Allocate memory */
2663 req = (ZigbeeZdoDevControlComplexDescriptorReq_t *)
2664 g_malloc0(sizeof(ZigbeeZdoDevControlComplexDescriptorReq_t));
2667 req->node_id = in_req->node_id;
2670 zdodev_control_request_data = (gpointer)req;
2674 case ZBLIB_ZDO_DEV_CONTROL_OPS_USER_DESC_REQ: {
2675 ZigbeeZdoDevControlUserDescriptorReq_t *in_req;
2676 ZigbeeZdoDevControlUserDescriptorReq_t *req = NULL;
2678 in_req = (ZigbeeZdoDevControlUserDescriptorReq_t *)request_data;
2679 if (NULL != in_req) {
2680 /* Allocate memory */
2681 req = (ZigbeeZdoDevControlUserDescriptorReq_t *)
2682 g_malloc0(sizeof(ZigbeeZdoDevControlUserDescriptorReq_t));
2685 req->node_id = in_req->node_id;
2688 zdodev_control_request_data = (gpointer)req;
2692 case ZBLIB_ZDO_DEV_CONTROL_OPS_USER_DESC_SET_REQ: {
2693 ZigbeeZdoDevControlUserDescriptorSetReq_t *in_req;
2694 ZigbeeZdoDevControlUserDescriptorSetReq_t *req = NULL;
2696 in_req = (ZigbeeZdoDevControlUserDescriptorSetReq_t *)request_data;
2697 if (NULL != in_req) {
2698 /* Allocate memory */
2699 req = (ZigbeeZdoDevControlUserDescriptorSetReq_t *)
2700 g_malloc0(sizeof(ZigbeeZdoDevControlUserDescriptorSetReq_t));
2703 req->node_id = in_req->node_id;
2704 req->user_descriptor_len = in_req->user_descriptor_len;
2705 memcpy(req->user_descriptor,
2706 in_req->user_descriptor, in_req->user_descriptor_len);
2709 zdodev_control_request_data = (gpointer)req;
2713 case ZBLIB_ZDO_DEV_CONTROL_OPS_DEVICE_ANNOUNCE: {
2714 ZigbeeZdoDevControlDeviceAnnounce_t *in_req;
2715 ZigbeeZdoDevControlDeviceAnnounce_t *req = NULL;
2717 in_req = (ZigbeeZdoDevControlDeviceAnnounce_t *)request_data;
2718 if (NULL != in_req) {
2719 /* Allocate memory */
2720 req = (ZigbeeZdoDevControlDeviceAnnounce_t *)
2721 g_malloc0(sizeof(ZigbeeZdoDevControlDeviceAnnounce_t));
2724 req->node_id = in_req->node_id;
2725 memcpy(req->mac_addr, in_req->mac_addr, ZIGBEE_EUI64_SIZE);
2726 req->capability = in_req->capability;
2729 zdodev_control_request_data = (gpointer)req;
2733 case ZBLIB_ZDO_DEV_CONTROL_OPS_SIMPLE_DESC_REQ: {
2734 ZigbeeZdoDevControlSimpleDescriptorReq_t *in_req;
2735 ZigbeeZdoDevControlSimpleDescriptorReq_t *req = NULL;
2737 in_req = (ZigbeeZdoDevControlSimpleDescriptorReq_t *)request_data;
2738 if (NULL != in_req) {
2739 /* Allocate memory */
2740 req = (ZigbeeZdoDevControlSimpleDescriptorReq_t *)
2741 g_malloc0(sizeof(ZigbeeZdoDevControlSimpleDescriptorReq_t));
2744 req->node_id = in_req->node_id;
2745 req->endpoint = in_req->endpoint;
2748 zdodev_control_request_data = (gpointer)req;
2752 case ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_LQI_REQ: {
2753 ZigbeeZdoDevControlMgmtLqiReq_t *in_req;
2754 ZigbeeZdoDevControlMgmtLqiReq_t *req = NULL;
2756 in_req = (ZigbeeZdoDevControlMgmtLqiReq_t *)request_data;
2757 if (NULL != in_req) {
2758 /* Allocate memory */
2759 req = (ZigbeeZdoDevControlMgmtLqiReq_t *)
2760 g_malloc0(sizeof(ZigbeeZdoDevControlMgmtLqiReq_t));
2763 req->node_id = in_req->node_id;
2764 req->start_index = in_req->start_index;
2767 zdodev_control_request_data = (gpointer)req;
2771 case ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_RTG_REQ: {
2772 ZigbeeZdoDevControlMgmtRtgReq_t *in_req;
2773 ZigbeeZdoDevControlMgmtRtgReq_t *req = NULL;
2775 in_req = (ZigbeeZdoDevControlMgmtRtgReq_t *)request_data;
2776 if (NULL != in_req) {
2777 /* Allocate memory */
2778 req = (ZigbeeZdoDevControlMgmtRtgReq_t *)
2779 g_malloc0(sizeof(ZigbeeZdoDevControlMgmtRtgReq_t));
2782 req->node_id = in_req->node_id;
2783 req->start_index = in_req->start_index;
2786 zdodev_control_request_data = (gpointer)req;
2790 case ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_BIND_REQ: {
2791 ZigbeeZdoDevControlMgmtBindReq_t *in_req;
2792 ZigbeeZdoDevControlMgmtBindReq_t *req = NULL;
2794 in_req = (ZigbeeZdoDevControlMgmtBindReq_t *)request_data;
2795 if (NULL != in_req) {
2796 /* Allocate memory */
2797 req = (ZigbeeZdoDevControlMgmtBindReq_t *)
2798 g_malloc0(sizeof(ZigbeeZdoDevControlMgmtBindReq_t));
2801 req->node_id = in_req->node_id;
2802 req->start_index = in_req->start_index;
2805 zdodev_control_request_data = (gpointer)req;
2809 case ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_PERMIT_JOIN_REQ: {
2810 ZigbeeZdoDevControlMgmtPermitJoinReq_t *in_req;
2811 ZigbeeZdoDevControlMgmtPermitJoinReq_t *req = NULL;
2813 in_req = (ZigbeeZdoDevControlMgmtPermitJoinReq_t *)request_data;
2814 if (NULL != in_req) {
2815 /* Allocate memory */
2816 req = (ZigbeeZdoDevControlMgmtPermitJoinReq_t *)
2817 g_malloc0(sizeof(ZigbeeZdoDevControlMgmtPermitJoinReq_t));
2820 req->addr = in_req->addr;
2821 req->duration = in_req->duration;
2822 req->tc_significance = in_req->tc_significance;
2825 zdodev_control_request_data = (gpointer)req;
2829 case ZBLIB_ZDO_DEV_CONTROL_OPS_NWK_UPDATE_REQ: {
2830 ZigbeeZdoDevControlNwkUpdateReq_t *in_req;
2831 ZigbeeZdoDevControlNwkUpdateReq_t *req = NULL;
2833 in_req = (ZigbeeZdoDevControlNwkUpdateReq_t *)request_data;
2834 if (NULL != in_req) {
2835 /* Allocate memory */
2836 req = (ZigbeeZdoDevControlNwkUpdateReq_t *)
2837 g_malloc0(sizeof(ZigbeeZdoDevControlNwkUpdateReq_t));
2840 req->node_id = in_req->node_id;
2841 req->scan_channel = in_req->scan_channel;
2842 req->scan_duration = in_req->scan_duration;
2843 req->scan_count = in_req->scan_count;
2844 req->network_update_id = in_req->network_update_id;
2847 zdodev_control_request_data = (gpointer)req;
2851 case ZBLIB_ZDO_DEV_CONTROL_OPS_NWK_DISC_REQ: {
2852 ZigbeeZdoDevControlNwkDescriptorReq_t *in_req;
2853 ZigbeeZdoDevControlNwkDescriptorReq_t *req = NULL;
2855 in_req = (ZigbeeZdoDevControlNwkDescriptorReq_t *)request_data;
2856 if (NULL != in_req) {
2857 /* Allocate memory */
2858 req = (ZigbeeZdoDevControlNwkDescriptorReq_t *)
2859 g_malloc0(sizeof(ZigbeeZdoDevControlNwkDescriptorReq_t));
2862 req->node_id = in_req->node_id;
2863 req->scan_channel = in_req->scan_channel;
2864 req->scan_duration = in_req->scan_duration;
2865 req->scan_count = in_req->scan_count;
2866 req->start_index = in_req->start_index;
2869 zdodev_control_request_data = (gpointer)req;
2877 return zdodev_control_request_data;
2880 static gpointer __zblib_request_create_zdo_bind_request_data(guint request_type,
2881 gpointer request_data, guint request_data_len)
2883 gpointer zdo_bind_request_data = NULL;
2886 NOT_USED(request_data_len);
2889 ops_id = __zblib_request_get_ops_id(request_type);
2891 case ZBLIB_ZDO_BIND_OPS_BIND_REQ: {
2892 ZigbeeZdoBindBindReq_t *in_req;
2893 ZigbeeZdoBindBindReq_t *req = NULL;
2895 in_req = (ZigbeeZdoBindBindReq_t *)request_data;
2896 if (NULL != in_req) {
2897 /* Allocate memory */
2898 req = (ZigbeeZdoBindBindReq_t *)
2899 g_malloc0(sizeof(ZigbeeZdoBindBindReq_t));
2902 req->node_id = in_req->node_id;
2903 g_strlcpy(req->src_addr,
2904 in_req->src_addr, ZIGBEE_ZDO_BIND_ADDRESS_MAX_LEN + 1);
2905 req->src_ep = in_req->src_ep;
2906 req->cluster_id = in_req->cluster_id;
2907 g_strlcpy(req->dst_addr,
2908 in_req->dst_addr, ZIGBEE_ZDO_BIND_ADDRESS_MAX_LEN + 1);
2909 req->bind_type = in_req->bind_type;
2910 req->group_addr = in_req->group_addr;
2911 req->dst_ep = in_req->dst_ep;
2914 zdo_bind_request_data = (gpointer)req;
2918 case ZBLIB_ZDO_BIND_OPS_UNBIND_REQ: {
2919 ZigbeeZdoBindUnbindReq_t *in_req;
2920 ZigbeeZdoBindUnbindReq_t *req = NULL;
2922 in_req = (ZigbeeZdoBindUnbindReq_t *)request_data;
2923 if (NULL != in_req) {
2924 /* Allocate memory */
2925 req = (ZigbeeZdoBindUnbindReq_t *)
2926 g_malloc0(sizeof(ZigbeeZdoBindUnbindReq_t));
2929 req->node_id = in_req->node_id;
2930 g_strlcpy(req->src_addr,
2931 in_req->src_addr, ZIGBEE_ZDO_BIND_ADDRESS_MAX_LEN + 1);
2932 req->src_ep = in_req->src_ep;
2933 req->cluster_id = in_req->cluster_id;
2934 g_strlcpy(req->dst_addr,
2935 in_req->dst_addr, ZIGBEE_ZDO_BIND_ADDRESS_MAX_LEN + 1);
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;
3104 case ZBLIB_ZCL_ALARM_OPS_RESET_ALARM: {
3105 ZigbeeZclAlarmResetAlarm_t *req = NULL;
3107 req = (ZigbeeZclAlarmResetAlarm_t *)request->request_data;
3114 case ZBLIB_ZCL_ALARM_OPS_RESET_ALL_ALARM: {
3115 ZigbeeZclAlarmResetAllAlarm_t *req = NULL;
3117 req = (ZigbeeZclAlarmResetAllAlarm_t *)request->request_data;
3124 case ZBLIB_ZCL_ALARM_OPS_ALARM: {
3125 ZigbeeZclAlarmAlarm_t *req = NULL;
3127 req = (ZigbeeZclAlarmAlarm_t *)request->request_data;
3134 case ZBLIB_ZCL_ALARM_OPS_RESET_ALARM_LOG: {
3135 ZigbeeZclAlarmResetAlarmLogs_t *req = NULL;
3137 req = (ZigbeeZclAlarmResetAlarmLogs_t *)request->request_data;
3144 case ZBLIB_ZCL_ALARM_OPS_GET_ALARM: {
3153 static void __zblib_request_free_custom_request_data(ZigBeeRequest *request,
3159 ops_id = __zblib_request_get_ops_id(request_type);
3161 case ZBLIB_CUSTOM_OPS_APS_SEND: {
3162 ZigbeeCustomApsSend_t *req = NULL;
3164 req = (ZigbeeCustomApsSend_t *)request->request_data;
3171 case ZBLIB_CUSTOM_OPS_ZCL_SEND: {
3172 ZigbeeCustomZclSend_t *req = NULL;
3174 req = (ZigbeeCustomZclSend_t *)request->request_data;
3181 case ZBLIB_CUSTOM_OPS_SEND_TO_LOCAL: {
3182 ZigbeeCustomSendToLocal_t *req = NULL;
3184 req = (ZigbeeCustomSendToLocal_t *)request->request_data;
3196 static void __zblib_request_free_zcl_door_lock_request_data(ZigBeeRequest *request,
3202 ops_id = __zblib_request_get_ops_id(request_type);
3204 case ZBLIB_ZCL_DOOR_LOCK_OPS_SUBSCRIBE_LOCK_EVENT: {
3205 ZigbeeZclDoorLockSubscriberLockEvent_t *req = NULL;
3207 req = (ZigbeeZclDoorLockSubscriberLockEvent_t *)request->request_data;
3214 case ZBLIB_ZCL_DOOR_LOCK_OPS_SET_DOOR_LOCK_PIN: {
3215 ZigbeeZclDoorLockSetDoorLockPin_t *req = NULL;
3217 req = (ZigbeeZclDoorLockSetDoorLockPin_t *)request->request_data;
3224 case ZBLIB_ZCL_DOOR_LOCK_OPS_SET_DOOR_LOCK: {
3225 ZigbeeZclDoorLockSetDoorLock_t *req = NULL;
3227 req = (ZigbeeZclDoorLockSetDoorLock_t *)request->request_data;
3234 case ZBLIB_ZCL_DOOR_LOCK_OPS_GET_LOCK_STATE: {
3235 ZigbeeZclDoorLockGetDoorLock_t *req = NULL;
3237 req = (ZigbeeZclDoorLockGetDoorLock_t *)request->request_data;
3249 static void __zblib_request_free_zcl_fan_control_request_data(ZigBeeRequest *request,
3255 ops_id = __zblib_request_get_ops_id(request_type);
3257 case ZBLIB_ZCL_FAN_CONTROL_OPS_SET_FAN_MODE: {
3258 ZigbeeZclFanControlSetFanMode_t *req = NULL;
3260 req = (ZigbeeZclFanControlSetFanMode_t *)request->request_data;
3267 case ZBLIB_ZCL_FAN_CONTROL_OPS_GET_FAN_MODE: {
3268 ZigbeeZclFanControlGetFanMode_t *req = NULL;
3270 req = (ZigbeeZclFanControlGetFanMode_t *)request->request_data;
3277 case ZBLIB_ZCL_FAN_CONTROL_OPS_SET_FAN_MODE_SEQUENCE: {
3278 ZigbeeZclFanControlSetFanModeSequence_t *req = NULL;
3280 req = (ZigbeeZclFanControlSetFanModeSequence_t *)request->request_data;
3287 case ZBLIB_ZCL_FAN_CONTROL_OPS_GET_FAN_MODE_SEQUENCE: {
3288 ZigbeeZclFanControlGetFanModeSequence_t *req = NULL;
3290 req = (ZigbeeZclFanControlGetFanModeSequence_t *)request->request_data;
3302 static void __zblib_request_free_zcl_level_control_request_data(ZigBeeRequest *request,
3308 ops_id = __zblib_request_get_ops_id(request_type);
3310 case ZBLIB_ZCL_LEVEL_CONTROL_OPS_MOVE_TO_LEVEL: {
3311 ZigbeeZclLevelControlMoveToLevel_t *req = NULL;
3313 req = (ZigbeeZclLevelControlMoveToLevel_t *)request->request_data;
3320 case ZBLIB_ZCL_LEVEL_CONTROL_OPS_MOVE: {
3321 ZigbeeZclLevelControlMove_t *req = NULL;
3323 req = (ZigbeeZclLevelControlMove_t *)request->request_data;
3330 case ZBLIB_ZCL_LEVEL_CONTROL_OPS_STEP: {
3331 ZigbeeZclLevelControlStep_t *req = NULL;
3333 req = (ZigbeeZclLevelControlStep_t *)request->request_data;
3340 case ZBLIB_ZCL_LEVEL_CONTROL_OPS_MOVE_TO_LEVEL_WITH_ON_OFF: {
3341 ZigbeeZclLevelControlMoveToLevelWithOnOff_t *req = NULL;
3343 req = (ZigbeeZclLevelControlMoveToLevelWithOnOff_t *)request->request_data;
3350 case ZBLIB_ZCL_LEVEL_CONTROL_OPS_MOVE_WITH_ON_OFF: {
3351 ZigbeeZclLevelControlMoveWithOnOff_t *req = NULL;
3353 req = (ZigbeeZclLevelControlMoveWithOnOff_t *)request->request_data;
3360 case ZBLIB_ZCL_LEVEL_CONTROL_OPS_STEP_WITH_ON_OFF: {
3361 ZigbeeZclLevelControlStepWithOnOff_t *req = NULL;
3363 req = (ZigbeeZclLevelControlStepWithOnOff_t *)request->request_data;
3370 case ZBLIB_ZCL_LEVEL_CONTROL_OPS_STOP: {
3371 ZigbeeZclLevelControlStop_t *req = NULL;
3373 req = (ZigbeeZclLevelControlStop_t *)request->request_data;
3385 static void __zblib_request_free_mfglib_control_request_data(ZigBeeRequest *request,
3391 ops_id = __zblib_request_get_ops_id(request_type);
3393 case ZBLIB_MFGLIB_CONTROL_OPS_START: {
3394 ZigbeeMfglibControlStart_t *req = NULL;
3396 req = (ZigbeeMfglibControlStart_t *)request->request_data;
3403 case ZBLIB_MFGLIB_CONTROL_OPS_END: {
3404 ZigbeeMfglibControlEnd_t *req = NULL;
3406 req = (ZigbeeMfglibControlEnd_t *)request->request_data;
3413 case ZBLIB_MFGLIB_CONTROL_OPS_START_TONE: {
3414 ZigbeeMfglibControlStartTone_t *req = NULL;
3416 req = (ZigbeeMfglibControlStartTone_t *)request->request_data;
3423 case ZBLIB_MFGLIB_CONTROL_OPS_STOP_TONE: {
3424 ZigbeeMfglibControlStopTone_t *req = NULL;
3426 req = (ZigbeeMfglibControlStopTone_t *)request->request_data;
3433 case ZBLIB_MFGLIB_CONTROL_OPS_START_STREAM: {
3434 ZigbeeMfglibControlStartStream_t *req = NULL;
3436 req = (ZigbeeMfglibControlStartStream_t *)request->request_data;
3443 case ZBLIB_MFGLIB_CONTROL_OPS_STOP_STREAM: {
3444 ZigbeeMfglibControlStopStream_t *req = NULL;
3446 req = (ZigbeeMfglibControlStopStream_t *)request->request_data;
3453 case ZBLIB_MFGLIB_CONTROL_OPS_SEND_PACKET: {
3454 ZigbeeMfglibControlSendPacket_t *req = NULL;
3456 req = (ZigbeeMfglibControlSendPacket_t *)request->request_data;
3463 case ZBLIB_MFGLIB_CONTROL_OPS_SET_CHANNEL: {
3464 ZigbeeMfglibControlSetChannel_t *req = NULL;
3466 req = (ZigbeeMfglibControlSetChannel_t *)request->request_data;
3473 case ZBLIB_MFGLIB_CONTROL_OPS_GET_CHANNEL: {
3474 ZigbeeMfglibControlGetChannel_t *req = NULL;
3476 req = (ZigbeeMfglibControlGetChannel_t *)request->request_data;
3483 case ZBLIB_MFGLIB_CONTROL_OPS_SET_POWER: {
3484 ZigbeeMfglibControlSetPower_t *req = NULL;
3486 req = (ZigbeeMfglibControlSetPower_t *)request->request_data;
3493 case ZBLIB_MFGLIB_CONTROL_OPS_GET_POWER: {
3494 ZigbeeMfglibControlGetPower_t *req = NULL;
3496 req = (ZigbeeMfglibControlGetPower_t *)request->request_data;
3503 case ZBLIB_MFGLIB_CONTROL_OPS_SET_SYNOFFSET: {
3504 ZigbeeMfglibControlSetSynOffset_t *req = NULL;
3506 req = (ZigbeeMfglibControlSetSynOffset_t *)request->request_data;
3513 case ZBLIB_MFGLIB_CONTROL_OPS_GET_SYNOFFSET: {
3514 ZigbeeMfglibControlGetSynOffset_t *req = NULL;
3516 req = (ZigbeeMfglibControlGetSynOffset_t *)request->request_data;
3523 case ZBLIB_MFGLIB_CONTROL_OPS_RX_START: {
3524 ZigbeeMfglibControlRxStart_t *req = NULL;
3526 req = (ZigbeeMfglibControlRxStart_t *)request->request_data;
3533 case ZBLIB_MFGLIB_CONTROL_OPS_RX_STOP: {
3534 ZigbeeMfglibControlRxStop_t *req = NULL;
3536 req = (ZigbeeMfglibControlRxStop_t *)request->request_data;
3543 case ZBLIB_MFGLIB_CONTROL_OPS_RX_VERIFY: {
3544 ZigbeeMfglibControlRxVerify_t *req = NULL;
3546 req = (ZigbeeMfglibControlRxVerify_t *)request->request_data;
3553 case ZBLIB_MFGLIB_CONTROL_OPS_GET_RSSI: {
3554 ZigbeeMfglibControlGetRssi_t *req = NULL;
3556 req = (ZigbeeMfglibControlGetRssi_t *)request->request_data;
3568 static void __zblib_request_free_zcl_on_off_request_data(ZigBeeRequest *request,
3574 ops_id = __zblib_request_get_ops_id(request_type);
3576 case ZBLIB_ZCL_ON_OFF_OPS_SET_ON_OFF: {
3577 ZigbeeZclOnOffSetOnOff_t *req = NULL;
3579 req = (ZigbeeZclOnOffSetOnOff_t *)request->request_data;
3586 case ZBLIB_ZCL_ON_OFF_OPS_GET_ON_OFF_STATE: {
3587 ZigbeeZclOnOffGetOnOffState_t *req = NULL;
3589 req = (ZigbeeZclOnOffGetOnOffState_t *)request->request_data;
3601 static void __zblib_request_free_service_request_data(ZigBeeRequest *request,
3607 ops_id = __zblib_request_get_ops_id(request_type);
3609 case ZBLIB_SERVICE_OPS_ENABLE: {
3613 case ZBLIB_SERVICE_OPS_DISABLE: {
3617 case ZBLIB_SERVICE_OPS_ZB_HW_RESET: {
3621 case ZBLIB_SERVICE_OPS_FORM_NETWORK: {
3625 case ZBLIB_SERVICE_OPS_COEX_START: {
3626 ZigbeeServiceCoexStart_t *req = NULL;
3628 req = (ZigbeeServiceCoexStart_t *)request->request_data;
3635 case ZBLIB_SERVICE_OPS_COEX_STOP: {
3639 case ZBLIB_SERVICE_OPS_LEAVE_NETWORK: {
3643 case ZBLIB_SERVICE_OPS_GET_NETWORK_INFO: {
3647 case ZBLIB_SERVICE_OPS_PERMIT_JOIN: {
3648 ZigbeeServicePermitJoin_t *req = NULL;
3650 req = (ZigbeeServicePermitJoin_t *)request->request_data;
3657 case ZBLIB_SERVICE_OPS_LEAVE_REQUEST: {
3658 ZigbeeServiceLeaveRequest_t *req = NULL;
3660 req = (ZigbeeServiceLeaveRequest_t *)request->request_data;
3667 case ZBLIB_SERVICE_OPS_GET_DEVICE_LIST: {
3671 case ZBLIB_SERVICE_OPS_GET_MAC: {
3675 case ZBLIB_SERVICE_OPS_GET_DEVICE_INFO: {
3679 case ZBLIB_SERVICE_OPS_GET_ENDPOINT_LIST: {
3680 ZigbeeServiceGetEndpointList_t *req = NULL;
3682 req = (ZigbeeServiceGetEndpointList_t *)request->request_data;
3689 case ZBLIB_SERVICE_OPS_GET_CLUSTER_LIST: {
3690 ZigbeeServiceGetClusterList_t *req = NULL;
3692 req = (ZigbeeServiceGetClusterList_t *)request->request_data;
3699 case ZBLIB_SERVICE_OPS_GET_NODE_TYPE: {
3700 ZigbeeServiceGetNodeType_t *req = NULL;
3702 req = (ZigbeeServiceGetNodeType_t *)request->request_data;
3714 static void __zblib_request_free_zcl_thermostat_request_data(ZigBeeRequest *request,
3720 ops_id = __zblib_request_get_ops_id(request_type);
3722 case ZBLIB_ZCL_THERMOSTAT_OPS_GET_LOCAL_TEMP: {
3723 ZigbeeZclThermostatGetLocalTemp_t *req = NULL;
3725 req = (ZigbeeZclThermostatGetLocalTemp_t *)request->request_data;
3732 case ZBLIB_ZCL_THERMOSTAT_OPS_GET_WEEKLY_SCHEDULE: {
3733 ZigbeeZclThermostatGetWeeklySchedule_t *req = NULL;
3735 req = (ZigbeeZclThermostatGetWeeklySchedule_t *)request->request_data;
3742 case ZBLIB_ZCL_THERMOSTAT_OPS_SET_WEEKLY_SCHEDULE: {
3743 ZigbeeZclThermostatSetWeeklySchedule_t *req = NULL;
3745 req = (ZigbeeZclThermostatSetWeeklySchedule_t *)request->request_data;
3752 case ZBLIB_ZCL_THERMOSTAT_OPS_CLEAR_WEEKLY_SCHEDULE: {
3753 ZigbeeZclThermostatClearWeeklySchedule_t *req = NULL;
3755 req = (ZigbeeZclThermostatClearWeeklySchedule_t *)request->request_data;
3762 case ZBLIB_ZCL_THERMOSTAT_OPS_SETPOINT_RAISE_LOWER: {
3763 ZigbeeZclThermostatSetpointRaiseLower_t *req = NULL;
3765 req = (ZigbeeZclThermostatSetpointRaiseLower_t *)request->request_data;
3777 static void __zblib_request_free_zcl_basic_request_data(ZigBeeRequest *request,
3783 ops_id = __zblib_request_get_ops_id(request_type);
3785 case ZBLIB_ZCL_BASIC_OPS_RESET_FACTORY_DEFAULT: {
3786 ZigbeeZclBasicResetFactoryDefault_t *req = NULL;
3788 req = (ZigbeeZclBasicResetFactoryDefault_t *)request->request_data;
3800 static void __zblib_request_free_zcl_global_control_request_data(ZigBeeRequest *request,
3806 ops_id = __zblib_request_get_ops_id(request_type);
3808 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_READ_ATTRIBUTES_REQ: {
3809 ZigbeeZclGlobalControlReadAttributesRequest_t *req = NULL;
3811 req = (ZigbeeZclGlobalControlReadAttributesRequest_t *)request->request_data;
3813 g_free(req->attribute_id);
3819 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_REQ: {
3820 ZigbeeZclGlobalControlWriteAttributesRequest_t *req = NULL;
3822 req = (ZigbeeZclGlobalControlWriteAttributesRequest_t *)request->request_data;
3824 g_free(req->write_records);
3830 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_UNDIVIDED_REQ: {
3831 ZigbeeZclGlobalControlWriteAttributesUndividedRequest_t *req = NULL;
3833 req = (ZigbeeZclGlobalControlWriteAttributesUndividedRequest_t *)request->request_data;
3835 g_free(req->write_records);
3841 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_NO_RESP: {
3842 ZigbeeZclGlobalControlWriteAttributesNoResponse_t *req = NULL;
3844 req = (ZigbeeZclGlobalControlWriteAttributesNoResponse_t *)request->request_data;
3846 g_free(req->write_records);
3852 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_STRUCTURED: {
3853 ZigbeeZclGlobalControlWriteAttributesStructed_t *req = NULL;
3855 req = (ZigbeeZclGlobalControlWriteAttributesStructed_t *)request->request_data;
3857 g_free(req->write_records);
3863 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_READ_ATTRIBUTES_STRUCTURED: {
3864 ZigbeeZclGlobalControlReadAttributesStructed_t *req = NULL;
3866 req = (ZigbeeZclGlobalControlReadAttributesStructed_t *)request->request_data;
3868 g_free(req->read_records);
3874 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_CONFIGURE_REPORTING_REQ: {
3875 ZigbeeZclGlobalControlConfigureReportingReq_t *req = NULL;
3877 req = (ZigbeeZclGlobalControlConfigureReportingReq_t *)request->request_data;
3879 g_free(req->read_records);
3885 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_READ_CONFIGURE_REPORTING: {
3886 ZigbeeZclGlobalControlReadConfigureReporting_t *req = NULL;
3888 req = (ZigbeeZclGlobalControlReadConfigureReporting_t *)request->request_data;
3890 g_free(req->read_records);
3896 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_DISCOVER_ATTRIBUTES: {
3897 ZigbeeZclGlobalControlDiscoverAttributes_t *req = NULL;
3899 req = (ZigbeeZclGlobalControlDiscoverAttributes_t *)request->request_data;
3906 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_DISCOVER_ATTRIBUTES_EXTENDED: {
3907 ZigbeeZclGlobalControlDiscoverAttributesExtended_t *req = NULL;
3909 req = (ZigbeeZclGlobalControlDiscoverAttributesExtended_t *)request->request_data;
3916 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_DISCOVER_COMMANDS_RECEIVED: {
3917 ZigbeeZclGlobalControlDiscoverCommandsReceived_t *req = NULL;
3919 req = (ZigbeeZclGlobalControlDiscoverCommandsReceived_t *)request->request_data;
3926 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_DISCOVER_COMMANDS_GENERATED: {
3927 ZigbeeZclGlobalControlDiscoverCommandsGenerated_t *req = NULL;
3929 req = (ZigbeeZclGlobalControlDiscoverCommandsGenerated_t *)request->request_data;
3941 static void __zblib_request_free_zcl_ias_zone_request_data(ZigBeeRequest *request,
3947 ops_id = __zblib_request_get_ops_id(request_type);
3949 case ZBLIB_ZCL_IAS_ZONE_OPS_ENROLL_RESPONSE: {
3950 ZigbeeZclIasZoneEnrollResponse_t *req = NULL;
3952 req = (ZigbeeZclIasZoneEnrollResponse_t *)request->request_data;
3964 static void __zblib_request_free_zcl_identify_request_data(ZigBeeRequest *request,
3970 ops_id = __zblib_request_get_ops_id(request_type);
3972 case ZBLIB_ZCL_IDENTIFY_OPS_IDENTIFY: {
3973 ZigbeeZclIdentifyIdentify_t *req = NULL;
3975 req = (ZigbeeZclIdentifyIdentify_t *)request->request_data;
3982 case ZBLIB_ZCL_IDENTIFY_OPS_QUERY: {
3983 ZigbeeZclIdentifyQuery_t *req = NULL;
3985 req = (ZigbeeZclIdentifyQuery_t *)request->request_data;
3997 static void __zblib_request_free_zcl_color_control_request_data(ZigBeeRequest *request,
4003 ops_id = __zblib_request_get_ops_id(request_type);
4005 case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_TO_HUE: {
4006 ZigbeeZclColorControlMoveToHue_t *req = NULL;
4008 req = (ZigbeeZclColorControlMoveToHue_t *)request->request_data;
4015 case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_HUE: {
4016 ZigbeeZclColorControlMoveHue_t *req = NULL;
4018 req = (ZigbeeZclColorControlMoveHue_t *)request->request_data;
4025 case ZBLIB_ZCL_COLOR_CONTROL_OPS_STEP_HUE: {
4026 ZigbeeZclColorControlStepHue_t *req = NULL;
4028 req = (ZigbeeZclColorControlStepHue_t *)request->request_data;
4035 case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_TO_STAURATION: {
4036 ZigbeeZclColorControlMoveToSaturation_t *req = NULL;
4038 req = (ZigbeeZclColorControlMoveToSaturation_t *)request->request_data;
4045 case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_STAURATION: {
4046 ZigbeeZclColorControlMoveSaturation_t *req = NULL;
4048 req = (ZigbeeZclColorControlMoveSaturation_t *)request->request_data;
4055 case ZBLIB_ZCL_COLOR_CONTROL_OPS_STEP_STAURATION: {
4056 ZigbeeZclColorControlStepSaturation_t *req = NULL;
4058 req = (ZigbeeZclColorControlStepSaturation_t *)request->request_data;
4065 case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_TO_HUE_AND_SATURATION: {
4066 ZigbeeZclColorControlMoveToHueAndSaturation_t *req = NULL;
4068 req = (ZigbeeZclColorControlMoveToHueAndSaturation_t *)request->request_data;
4075 case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_TO_COLOR: {
4076 ZigbeeZclColorControlMoveToColor_t *req = NULL;
4078 req = (ZigbeeZclColorControlMoveToColor_t *)request->request_data;
4085 case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_COLOR: {
4086 ZigbeeZclColorControlMoveColor_t *req = NULL;
4088 req = (ZigbeeZclColorControlMoveColor_t *)request->request_data;
4095 case ZBLIB_ZCL_COLOR_CONTROL_OPS_STEP_COLOR: {
4096 ZigbeeZclColorControlStepColor_t *req = NULL;
4098 req = (ZigbeeZclColorControlStepColor_t *)request->request_data;
4105 case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_COLOR_TEMPERATURE: {
4106 ZigbeeZclColorControlMoveColorTemperature_t *req = NULL;
4108 req = (ZigbeeZclColorControlMoveColorTemperature_t *)request->request_data;
4120 static void __zblib_request_free_zcl_group_request_data(ZigBeeRequest *request,
4126 ops_id = __zblib_request_get_ops_id(request_type);
4128 case ZBLIB_ZCL_GROUP_OPS_ADD_GROUP: {
4129 ZigbeeZclGroupAddGroup_t *req = NULL;
4131 req = (ZigbeeZclGroupAddGroup_t *)request->request_data;
4138 case ZBLIB_ZCL_GROUP_OPS_VIEW_GROUP: {
4139 ZigbeeZclGroupViewGroup_t *req = NULL;
4141 req = (ZigbeeZclGroupViewGroup_t *)request->request_data;
4148 case ZBLIB_ZCL_GROUP_OPS_GET_GROUP_MEMBERSHIP: {
4149 ZigbeeZclGroupGetGroupMembership_t *req = NULL;
4151 req = (ZigbeeZclGroupGetGroupMembership_t *)request->request_data;
4153 g_free(req->group_list);
4159 case ZBLIB_ZCL_GROUP_OPS_REMOVE_GROUP: {
4160 ZigbeeZclGroupRemoveGroup_t *req = NULL;
4162 req = (ZigbeeZclGroupRemoveGroup_t *)request->request_data;
4169 case ZBLIB_ZCL_GROUP_OPS_REMOVE_ALL_GROUP: {
4170 ZigbeeZclGroupRemoveAllGroup_t *req = NULL;
4172 req = (ZigbeeZclGroupRemoveAllGroup_t *)request->request_data;
4179 case ZBLIB_ZCL_GROUP_OPS_ADD_GROUP_IF_IDENTIFYING: {
4180 ZigbeeZclGroupAddGroupIfIdentifying_t *req = NULL;
4182 req = (ZigbeeZclGroupAddGroupIfIdentifying_t *)request->request_data;
4194 static void __zblib_request_free_zcl_poll_control_request_data(ZigBeeRequest *request,
4200 ops_id = __zblib_request_get_ops_id(request_type);
4202 case ZBLIB_ZCL_POLL_CONTROL_OPS_CHECK_IN_RESPONSE: {
4203 ZigbeeZclPollControlCheckInResponse_t *req = NULL;
4205 req = (ZigbeeZclPollControlCheckInResponse_t *)request->request_data;
4212 case ZBLIB_ZCL_POLL_CONTROL_OPS_FAST_POLL_STOP: {
4213 ZigbeeZclPollControlFastPollStop_t *req = NULL;
4215 req = (ZigbeeZclPollControlFastPollStop_t *)request->request_data;
4222 case ZBLIB_ZCL_POLL_CONTROL_OPS_SET_LONG_POLL_INTERVAL: {
4223 ZigbeeZclPollControlSetLongPollInterval_t *req = NULL;
4225 req = (ZigbeeZclPollControlSetLongPollInterval_t *)request->request_data;
4232 case ZBLIB_ZCL_POLL_CONTROL_OPS_SET_SHORT_POLL_INTERVAL: {
4233 ZigbeeZclPollControlSetShortPollInterval_t *req = NULL;
4235 req = (ZigbeeZclPollControlSetShortPollInterval_t *)request->request_data;
4247 static void __zblib_request_free_zcl_scene_request_data(ZigBeeRequest *request,
4253 ops_id = __zblib_request_get_ops_id(request_type);
4255 case ZBLIB_ZCL_SCENE_OPS_ADD_SCENE: {
4256 ZigbeeZclSceneAddScene_t *req = NULL;
4258 req = (ZigbeeZclSceneAddScene_t *)request->request_data;
4260 g_free(req->ext_field_set);
4266 case ZBLIB_ZCL_SCENE_OPS_VIEW_SCENE: {
4267 ZigbeeZclSceneViewScene_t *req = NULL;
4269 req = (ZigbeeZclSceneViewScene_t *)request->request_data;
4276 case ZBLIB_ZCL_SCENE_OPS_REMOVE_SCENE: {
4277 ZigbeeZclSceneRemoveScene_t *req = NULL;
4279 req = (ZigbeeZclSceneRemoveScene_t *)request->request_data;
4286 case ZBLIB_ZCL_SCENE_OPS_STORE_SCENE: {
4287 ZigbeeZclSceneStoreScene_t *req = NULL;
4289 req = (ZigbeeZclSceneStoreScene_t *)request->request_data;
4296 case ZBLIB_ZCL_SCENE_OPS_RECALL_SCENE: {
4297 ZigbeeZclSceneRecallScene_t *req = NULL;
4299 req = (ZigbeeZclSceneRecallScene_t *)request->request_data;
4306 case ZBLIB_ZCL_SCENE_OPS_REMOVE_ALL_SCENE: {
4307 ZigbeeZclSceneRemoveAllScene_t *req = NULL;
4309 req = (ZigbeeZclSceneRemoveAllScene_t *)request->request_data;
4316 case ZBLIB_ZCL_SCENE_OPS_GET_SCENE_MEMBERSHIP: {
4317 ZigbeeZclSceneGetSceneMembership_t *req = NULL;
4319 req = (ZigbeeZclSceneGetSceneMembership_t *)request->request_data;
4331 static void __zblib_request_free_zdo_dev_control_request_data(ZigBeeRequest *request,
4337 ops_id = __zblib_request_get_ops_id(request_type);
4339 case ZBLIB_ZDO_DEV_CONTROL_OPS_NWK_ADDR_REQ: {
4340 ZigbeeZdoDevControlNwkAddrReq_t *req = NULL;
4342 req = (ZigbeeZdoDevControlNwkAddrReq_t *)request->request_data;
4349 case ZBLIB_ZDO_DEV_CONTROL_OPS_MATCHED_DESCRIPTOR_REQ: {
4350 ZigbeeZdoDevControlMatchedDescriptorReq_t *req = NULL;
4352 req = (ZigbeeZdoDevControlMatchedDescriptorReq_t *)request->request_data;
4355 g_free(req->out_cl);
4361 case ZBLIB_ZDO_DEV_CONTROL_OPS_IEEE_ADDR_REQ: {
4362 ZigbeeZdoDevControlIeeeAddrReq_t *req = NULL;
4364 req = (ZigbeeZdoDevControlIeeeAddrReq_t *)request->request_data;
4371 case ZBLIB_ZDO_DEV_CONTROL_OPS_ACTIVE_EP_REQ: {
4372 ZigbeeZdoDevControlActiveEpReq_t *req = NULL;
4374 req = (ZigbeeZdoDevControlActiveEpReq_t *)request->request_data;
4381 case ZBLIB_ZDO_DEV_CONTROL_OPS_NODE_DESC_REQ: {
4382 ZigbeeZdoDevControlNodeDescriptorReq_t *req = NULL;
4384 req = (ZigbeeZdoDevControlNodeDescriptorReq_t *)request->request_data;
4391 case ZBLIB_ZDO_DEV_CONTROL_OPS_POWER_DESC_REQ: {
4392 ZigbeeZdoDevControlPowerDescriptorReq_t *req = NULL;
4394 req = (ZigbeeZdoDevControlPowerDescriptorReq_t *)request->request_data;
4401 case ZBLIB_ZDO_DEV_CONTROL_OPS_COMPLEX_DESC_REQ: {
4402 ZigbeeZdoDevControlComplexDescriptorReq_t *req = NULL;
4404 req = (ZigbeeZdoDevControlComplexDescriptorReq_t *)request->request_data;
4411 case ZBLIB_ZDO_DEV_CONTROL_OPS_USER_DESC_REQ: {
4412 ZigbeeZdoDevControlUserDescriptorReq_t *req = NULL;
4414 req = (ZigbeeZdoDevControlUserDescriptorReq_t *)request->request_data;
4421 case ZBLIB_ZDO_DEV_CONTROL_OPS_USER_DESC_SET_REQ: {
4422 ZigbeeZdoDevControlUserDescriptorSetReq_t *req = NULL;
4424 req = (ZigbeeZdoDevControlUserDescriptorSetReq_t *)request->request_data;
4431 case ZBLIB_ZDO_DEV_CONTROL_OPS_DEVICE_ANNOUNCE: {
4432 ZigbeeZdoDevControlDeviceAnnounce_t *req = NULL;
4434 req = (ZigbeeZdoDevControlDeviceAnnounce_t *)request->request_data;
4441 case ZBLIB_ZDO_DEV_CONTROL_OPS_SIMPLE_DESC_REQ: {
4442 ZigbeeZdoDevControlSimpleDescriptorReq_t *req = NULL;
4444 req = (ZigbeeZdoDevControlSimpleDescriptorReq_t *)request->request_data;
4451 case ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_LQI_REQ: {
4452 ZigbeeZdoDevControlMgmtLqiReq_t *req = NULL;
4454 req = (ZigbeeZdoDevControlMgmtLqiReq_t *)request->request_data;
4461 case ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_RTG_REQ: {
4462 ZigbeeZdoDevControlMgmtRtgReq_t *req = NULL;
4464 req = (ZigbeeZdoDevControlMgmtRtgReq_t *)request->request_data;
4471 case ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_BIND_REQ: {
4472 ZigbeeZdoDevControlMgmtBindReq_t *req = NULL;
4474 req = (ZigbeeZdoDevControlMgmtBindReq_t *)request->request_data;
4481 case ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_PERMIT_JOIN_REQ: {
4482 ZigbeeZdoDevControlMgmtPermitJoinReq_t *req = NULL;
4484 req = (ZigbeeZdoDevControlMgmtPermitJoinReq_t *)request->request_data;
4491 case ZBLIB_ZDO_DEV_CONTROL_OPS_NWK_UPDATE_REQ: {
4492 ZigbeeZdoDevControlNwkUpdateReq_t *req = NULL;
4494 req = (ZigbeeZdoDevControlNwkUpdateReq_t *)request->request_data;
4501 case ZBLIB_ZDO_DEV_CONTROL_OPS_NWK_DISC_REQ: {
4502 ZigbeeZdoDevControlNwkDescriptorReq_t *req = NULL;
4504 req = (ZigbeeZdoDevControlNwkDescriptorReq_t *)request->request_data;
4516 static void __zblib_request_free_zdo_bind_request_data(ZigBeeRequest *request,
4522 ops_id = __zblib_request_get_ops_id(request_type);
4524 case ZBLIB_ZDO_BIND_OPS_BIND_REQ: {
4525 ZigbeeZdoBindBindReq_t *req = NULL;
4527 req = (ZigbeeZdoBindBindReq_t *)request->request_data;
4534 case ZBLIB_ZDO_BIND_OPS_UNBIND_REQ: {
4535 ZigbeeZdoBindUnbindReq_t *req = NULL;
4537 req = (ZigbeeZdoBindUnbindReq_t *)request->request_data;
4549 static void __zblib_request_free_request_data(ZigBeeRequest *request)
4552 ZblibDriverType_e driver_type;
4554 zblib_check_null_ret("request", request);
4556 request_type = request->request_type;
4558 /* Fetch driver type */
4559 driver_type = __zblib_request_get_driver_type(request_type);
4560 switch (driver_type) {
4561 case ZBLIB_DRIVER_TYPE_ZCL_ALARM: {
4562 __zblib_request_free_zcl_alarm_request_data(request, request_type);
4566 case ZBLIB_DRIVER_TYPE_CUSTOM: {
4567 __zblib_request_free_custom_request_data(request, request_type);
4571 case ZBLIB_DRIVER_TYPE_ZCL_DOOR_LOCK: {
4572 __zblib_request_free_zcl_door_lock_request_data(request, request_type);
4576 case ZBLIB_DRIVER_TYPE_ZCL_FAN_CONTROL: {
4577 __zblib_request_free_zcl_fan_control_request_data(request, request_type);
4581 case ZBLIB_DRIVER_TYPE_ZCL_LEVEL_CONTROL: {
4582 __zblib_request_free_zcl_level_control_request_data(request, request_type);
4586 case ZBLIB_DRIVER_TYPE_MFGLIB_CONTROL: {
4587 __zblib_request_free_mfglib_control_request_data(request, request_type);
4591 case ZBLIB_DRIVER_TYPE_ZCL_ON_OFF: {
4592 __zblib_request_free_zcl_on_off_request_data(request, request_type);
4596 case ZBLIB_DRIVER_TYPE_SERVICE: {
4597 __zblib_request_free_service_request_data(request, request_type);
4601 case ZBLIB_DRIVER_TYPE_ZCL_THERMOSTAT: {
4602 __zblib_request_free_zcl_thermostat_request_data(request, request_type);
4606 case ZBLIB_DRIVER_TYPE_ZCL_BASIC: {
4607 __zblib_request_free_zcl_basic_request_data(request, request_type);
4611 case ZBLIB_DRIVER_TYPE_ZCL_GLOBAL_CONTROL: {
4612 __zblib_request_free_zcl_global_control_request_data(request, request_type);
4616 case ZBLIB_DRIVER_TYPE_ZCL_IAS_ZONE: {
4617 __zblib_request_free_zcl_ias_zone_request_data(request, request_type);
4621 case ZBLIB_DRIVER_TYPE_ZCL_IDENTIFY: {
4622 __zblib_request_free_zcl_identify_request_data(request, request_type);
4626 case ZBLIB_DRIVER_TYPE_ZCL_COLOR_CONTROL: {
4627 __zblib_request_free_zcl_color_control_request_data(request, request_type);
4631 case ZBLIB_DRIVER_TYPE_ZCL_GROUP: {
4632 __zblib_request_free_zcl_group_request_data(request, request_type);
4636 case ZBLIB_DRIVER_TYPE_ZCL_POLL_CONTROL: {
4637 __zblib_request_free_zcl_poll_control_request_data(request, request_type);
4641 case ZBLIB_DRIVER_TYPE_ZCL_SCENE: {
4642 __zblib_request_free_zcl_scene_request_data(request, request_type);
4646 case ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL: {
4647 __zblib_request_free_zdo_dev_control_request_data(request, request_type);
4651 case ZBLIB_DRIVER_TYPE_ZDO_BIND: {
4652 __zblib_request_free_zdo_bind_request_data(request, request_type);
4656 case ZBLIB_DRIVER_TYPE_NONE: /* Fall through */
4658 Z_LOGE("Unhandled driver type: [%d]", driver_type);
4664 gint zblib_request_new(ZigBeeServiceInterface *service_interface,
4665 guint request_type, gpointer request_data, guint request_data_len)
4667 ZigBeeService *service = NULL;
4668 ZigBeeRequest *request = NULL;
4669 GHashTable *request_table = NULL;
4671 zblib_check_null_ret_error("service_interface", service_interface, ZIGBEE_REQUEST_INVALID_REQUEST_ID);
4673 service = zblib_service_interface_ref_service(service_interface);
4674 zblib_check_null_ret_error("service", service, ZIGBEE_REQUEST_INVALID_REQUEST_ID);
4676 /* Allocate ZigBee request memory */
4677 request = g_malloc0(sizeof(ZigBeeRequest));
4679 /* Update request */
4680 request->service_interface = service_interface;
4681 request->ref_count = 1; /* Initialize reference count to '1' for new request */
4683 /* Update request data for specific request */
4684 request->request_data = __zblib_request_create_request_data(request_type,
4685 request_data, request_data_len);
4686 request->request_type = request_type;
4688 /* Generate request ID */
4689 request->request_id = zblib_service_generate_request_id(service);
4690 if (ZIGBEE_REQUEST_INVALID_REQUEST_ID == request->request_id) {
4691 Z_LOGE("zblib_service_genrate_request_id failed!");
4693 /* Free resources */
4694 __zblib_request_free_request_data(request);
4697 return ZIGBEE_REQUEST_INVALID_REQUEST_ID;
4700 /* Fetch request table from service */
4701 request_table = zblib_service_ref_request_hash_table(service);
4702 if (NULL == request_table) {
4703 Z_LOGE("zblib_service_ref_request_hash_table failed!");
4705 /* Free resources */
4706 __zblib_request_free_request_data(request);
4709 return ZIGBEE_REQUEST_INVALID_REQUEST_ID;
4712 /* Insert request to request table */
4713 g_hash_table_insert(request_table, (gpointer)(request->request_id), request);
4715 return request->request_id;
4718 void zblib_request_free(ZigBeeServiceInterface *service_interface,
4721 ZigBeeService *service = NULL;
4722 ZigBeeRequest *request = NULL;
4724 zblib_check_null_ret("service_interface", service_interface);
4727 service = zblib_service_interface_ref_service(service_interface);
4728 zblib_check_null_ret("service", service);
4730 /* Fetch request based on request_id */
4731 request = __zblib_request_ref_request_by_request_id(service, request_id);
4732 zblib_check_null_ret("request", request);
4734 /* Free resources */
4735 __zblib_request_free_request_data(request);
4739 gboolean zblib_request_set_response_cb(ZigBeeServiceInterface *service_interface,
4741 gpointer resp_cb, gpointer resp_cb_data)
4743 ZigBeeService *service = NULL;
4744 ZigBeeRequest *request = NULL;
4746 zblib_check_null_ret_error("service_interface", service_interface, FALSE);
4749 service = zblib_service_interface_ref_service(service_interface);
4750 zblib_check_null_ret_error("service", service, FALSE);
4752 /* Fetch request based on request_id */
4753 request = __zblib_request_ref_request_by_by_request_id(service, request_id);
4754 if (NULL == request) {
4755 Z_LOGE("No request available for request_id: [%d]", request_id);
4759 /* Update response callback and response callback data */
4760 request->resp_cb = resp_cb;
4761 request->resp_cb_data = resp_cb_data;
4766 gpointer zblib_request_ref_response_cb(ZigBeeServiceInterface *service_interface,
4767 guint request_id, gpointer *resp_cb_data)
4769 ZigBeeService *service = NULL;
4770 ZigBeeRequest *request = NULL;
4772 zblib_check_null_ret_error("service_interface", service_interface, NULL);
4775 service = zblib_service_interface_ref_service(service_interface);
4776 zblib_check_null_ret_error("service", service, NULL);
4778 /* Fetch request based on request_id */
4779 request = __zblib_request_ref_request_by_by_request_id(service, request_id);
4780 if (NULL == request) {
4781 Z_LOGE("No request available for request_id: [%d]", request_id);
4785 /* Response callback data */
4786 *resp_cb_data = request->resp_cb_data;
4788 /* Return response callback */
4789 return request->resp_cb;
4792 ZigBeeRequest *zblib_request_ref(ZigBeeRequest *request)
4794 zblib_check_null_ret_error("request", request, NULL);
4796 request->ref_count++;
4801 void zblib_request_unref(ZigBeeRequest *request)
4803 zblib_check_null_ret("request", request);
4805 request->ref_count--;
4806 if (0 == request->ref_count) {
4807 Z_LOGD("Reference count is ZERO!");
4809 /* Free 'request' */
4810 __zblib_request_free_request_data(request);
4815 guint zblib_request_ref_request_type(ZigBeeRequest *request)
4817 zblib_check_null_ret_error("request", request, 0);
4819 return request->request_type;
4822 ZigBeeServiceInterface *zblib_request_ref_service_interface(ZigBeeService *service,
4825 ZigBeeRequest *request = NULL;
4827 zblib_check_null_ret_error("service", service, NULL);
4829 /* Fetch request based on request_id */
4830 request = __zblib_request_ref_request_by_by_request_id(service, request_id);
4831 if (NULL == request) {
4832 Z_LOGE("No request available for request_id: [%d]", request_id);
4836 return request->service_interface;
4839 gpointer zblib_request_ref_request_data(ZigBeeRequest *request)
4841 zblib_check_null_ret_error("request", request, NULL);
4843 return request->request_data;
4846 gpointer zblib_request_ref_request_data_by_id(ZigBeeService *service,
4849 ZigBeeRequest *request = NULL;
4851 /* Fetch request based on request_id */
4852 request = __zblib_request_ref_request_by_by_request_id(service, request_id);
4853 if (NULL == request) {
4854 Z_LOGE("No request available for request_id: [%d]", request_id);
4858 return request->request_data;
4861 guint zblib_request_generate_request_type(ZblibDriverType_e driver_type,
4867 * request_type consists of driver_type and ops_id
4868 * request_type = driver_type | 0x00 | 0x00 | ops_id
4870 request_type = (driver_type << 24) | (ops_id);
4872 return request_type;
4875 gint zblib_request_ref_request_type_by_request_id(ZigBeeService *service,
4878 return __zblib_request_ref_request_type_by_request_id(service, request_id);
4881 ZblibDriverType_e zblib_request_get_driver_type(guint request_type)
4883 return __zblib_request_get_driver_type(request_type);
4886 guint zblib_request_get_ops_id(guint request_type)
4888 return __zblib_request_get_ops_id(request_type);