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 alarm_request_data = NULL;
256 return alarm_request_data;
259 static gpointer __zblib_request_create_custom_request_data(guint request_type,
260 gpointer request_data, guint request_data_len)
262 gpointer custom_request_data = NULL;
265 NOT_USED(request_data_len);
268 ops_id = __zblib_request_get_ops_id(request_type);
270 case ZBLIB_CUSTOM_OPS_APS_SEND: {
271 ZigbeeCustomApsSend_t *in_req;
272 ZigbeeCustomApsSend_t *req = NULL;
274 in_req = (ZigbeeCustomApsSend_t *)request_data;
276 /* Allocate memory */
277 req = (ZigbeeCustomApsSend_t *)
278 g_malloc0(sizeof(ZigbeeCustomApsSend_t));
281 req->node_id = in_req->node_id;
282 req->aps_frame_ctrl = in_req->aps_frame_ctrl;
283 req->src_ep = in_req->src_ep;
284 req->dest_ep = in_req->dest_ep;
285 req->cluster_id = in_req->cluster_id;
286 req->profile_id = in_req->profile_id;
287 req->zcl_frame_ctrl = in_req->zcl_frame_ctrl;
288 req->mfg_code = in_req->mfg_code;
290 in_req->payload, ZIGBEE_CUSTOM_SEND_PAYLOAD_LEN);
293 custom_request_data = (gpointer)req;
297 case ZBLIB_CUSTOM_OPS_ZCL_SEND: {
298 ZigbeeCustomZclSend_t *in_req;
299 ZigbeeCustomZclSend_t *req = NULL;
301 in_req = (ZigbeeCustomZclSend_t *)request_data;
303 /* Allocate memory */
304 req = (ZigbeeCustomZclSend_t *)
305 g_malloc0(sizeof(ZigbeeCustomZclSend_t));
308 req->node_id = in_req->node_id;
309 req->src_ep = in_req->src_ep;
310 req->dest_ep = in_req->dest_ep;
311 req->cluster_id = in_req->cluster_id;
312 req->zcl_frame_ctrl = in_req->zcl_frame_ctrl;
313 req->cmd_id = in_req->cmd_id;
315 in_req->payload, ZIGBEE_CUSTOM_SEND_PAYLOAD_LEN);
318 custom_request_data = (gpointer)req;
322 case ZBLIB_CUSTOM_OPS_SEND_TO_LOCAL: {
323 ZigbeeCustomSendToLocal_t *in_req;
324 ZigbeeCustomSendToLocal_t *req = NULL;
326 in_req = (ZigbeeCustomSendToLocal_t *)request_data;
328 /* Allocate memory */
329 req = (ZigbeeCustomSendToLocal_t *)
330 g_malloc0(sizeof(ZigbeeCustomSendToLocal_t));
334 in_req->data, ZIGBEE_CUSTOM_SEND_PAYLOAD_LEN);
337 custom_request_data = (gpointer)req;
345 return custom_request_data;
348 static gpointer __zblib_request_create_zcl_door_lock_request_data(guint request_type,
349 gpointer request_data, guint request_data_len)
351 gpointer door_lock_request_data = NULL;
354 NOT_USED(request_data_len);
357 ops_id = __zblib_request_get_ops_id(request_type);
359 case ZBLIB_ZCL_DOOR_LOCK_OPS_SUBSCRIBE_LOCK_EVENT: {
360 ZigbeeZclDoorLockSubscriberLockEvent_t *in_req;
361 ZigbeeZclDoorLockSubscriberLockEvent_t *req = NULL;
363 in_req = (ZigbeeZclDoorLockSubscriberLockEvent_t *)request_data;
365 /* Allocate memory */
366 req = (ZigbeeZclDoorLockSubscriberLockEvent_t *)
367 g_malloc0(sizeof(ZigbeeZclDoorLockSubscriberLockEvent_t));
371 in_req->eui64, ZIGBEE_EUI64_SIZE);
372 req->endpoint = in_req->endpoint;
375 door_lock_request_data = (gpointer)req;
379 case ZBLIB_ZCL_DOOR_LOCK_OPS_SET_DOOR_LOCK_PIN: {
380 ZigbeeZclDoorLockSetDoorLockPin_t *in_req;
381 ZigbeeZclDoorLockSetDoorLockPin_t *req = NULL;
383 in_req = (ZigbeeZclDoorLockSetDoorLockPin_t *)request_data;
385 /* Allocate memory */
386 req = (ZigbeeZclDoorLockSetDoorLockPin_t *)
387 g_malloc0(sizeof(ZigbeeZclDoorLockSetDoorLockPin_t));
390 req->uid = in_req->uid;
391 req->ustatus = in_req->ustatus;
392 req->utype = in_req->utype;
394 in_req->eui64, ZIGBEE_EUI64_SIZE);
395 req->endpoint = in_req->endpoint;
397 in_req->pin, ZIGBEE_DOOR_LOCK_MAX_PIN_LEN);
400 door_lock_request_data = (gpointer)req;
404 case ZBLIB_ZCL_DOOR_LOCK_OPS_SET_DOOR_LOCK: {
405 ZigbeeZclDoorLockSetDoorLock_t *in_req;
406 ZigbeeZclDoorLockSetDoorLock_t *req = NULL;
408 in_req = (ZigbeeZclDoorLockSetDoorLock_t *)request_data;
410 /* Allocate memory */
411 req = (ZigbeeZclDoorLockSetDoorLock_t *)
412 g_malloc0(sizeof(ZigbeeZclDoorLockSetDoorLock_t));
416 in_req->eui64, ZIGBEE_EUI64_SIZE);
417 req->endpoint = in_req->endpoint;
419 in_req->pin, ZIGBEE_DOOR_LOCK_MAX_PIN_LEN);
420 req->lock_unlock_type = in_req->lock_unlock_type;
423 door_lock_request_data = (gpointer)req;
427 case ZBLIB_ZCL_DOOR_LOCK_OPS_GET_LOCK_STATE: {
428 ZigbeeZclDoorLockGetDoorLock_t *in_req;
429 ZigbeeZclDoorLockGetDoorLock_t *req = NULL;
431 in_req = (ZigbeeZclDoorLockGetDoorLock_t *)request_data;
433 /* Allocate memory */
434 req = (ZigbeeZclDoorLockGetDoorLock_t *)
435 g_malloc0(sizeof(ZigbeeZclDoorLockGetDoorLock_t));
439 in_req->eui64, ZIGBEE_EUI64_SIZE);
440 req->endpoint = in_req->endpoint;
443 door_lock_request_data = (gpointer)req;
451 return door_lock_request_data;
454 static gpointer __zblib_request_create_zcl_fan_control_request_data(guint request_type,
455 gpointer request_data, guint request_data_len)
457 gpointer fan_control_request_data = NULL;
460 NOT_USED(request_data_len);
463 ops_id = __zblib_request_get_ops_id(request_type);
465 case ZBLIB_ZCL_FAN_CONTROL_OPS_SET_FAN_MODE: {
466 ZigbeeZclFanControlSetFanMode_t *in_req;
467 ZigbeeZclFanControlSetFanMode_t *req = NULL;
469 in_req = (ZigbeeZclFanControlSetFanMode_t *)request_data;
471 /* Allocate memory */
472 req = (ZigbeeZclFanControlSetFanMode_t *)
473 g_malloc0(sizeof(ZigbeeZclFanControlSetFanMode_t));
477 in_req->eui64, ZIGBEE_EUI64_SIZE);
478 req->endpoint = in_req->endpoint;
481 fan_control_request_data = (gpointer)req;
485 case ZBLIB_ZCL_FAN_CONTROL_OPS_GET_FAN_MODE: {
486 ZigbeeZclFanControlGetFanMode_t *in_req;
487 ZigbeeZclFanControlGetFanMode_t *req = NULL;
489 in_req = (ZigbeeZclFanControlGetFanMode_t *)request_data;
491 /* Allocate memory */
492 req = (ZigbeeZclFanControlGetFanMode_t *)
493 g_malloc0(sizeof(ZigbeeZclFanControlGetFanMode_t));
497 in_req->eui64, ZIGBEE_EUI64_SIZE);
498 req->endpoint = in_req->endpoint;
501 fan_control_request_data = (gpointer)req;
505 case ZBLIB_ZCL_FAN_CONTROL_OPS_SET_FAN_MODE_SEQUENCE: {
506 ZigbeeZclFanControlSetFanModeSequence_t *in_req;
507 ZigbeeZclFanControlSetFanModeSequence_t *req = NULL;
509 in_req = (ZigbeeZclFanControlSetFanModeSequence_t *)request_data;
511 /* Allocate memory */
512 req = (ZigbeeZclFanControlSetFanModeSequence_t *)
513 g_malloc0(sizeof(ZigbeeZclFanControlSetFanModeSequence_t));
517 in_req->eui64, ZIGBEE_EUI64_SIZE);
518 req->endpoint = in_req->endpoint;
521 fan_control_request_data = (gpointer)req;
525 case ZBLIB_ZCL_FAN_CONTROL_OPS_GET_FAN_MODE_SEQUENCE: {
526 ZigbeeZclFanControlGetFanModeSequence_t *in_req;
527 ZigbeeZclFanControlGetFanModeSequence_t *req = NULL;
529 in_req = (ZigbeeZclFanControlGetFanModeSequence_t *)request_data;
531 /* Allocate memory */
532 req = (ZigbeeZclFanControlGetFanModeSequence_t *)
533 g_malloc0(sizeof(ZigbeeZclFanControlGetFanModeSequence_t));
537 in_req->eui64, ZIGBEE_EUI64_SIZE);
538 req->endpoint = in_req->endpoint;
541 fan_control_request_data = (gpointer)req;
549 return fan_control_request_data;
552 static gpointer __zblib_request_create_zcl_level_control_request_data(guint request_type,
553 gpointer request_data, guint request_data_len)
555 gpointer level_control_request_data = NULL;
558 NOT_USED(request_data_len);
561 ops_id = __zblib_request_get_ops_id(request_type);
563 case ZBLIB_ZCL_LEVEL_CONTROL_OPS_MOVE_TO_LEVEL: {
564 ZigbeeZclLevelControlMoveToLevel_t *in_req;
565 ZigbeeZclLevelControlMoveToLevel_t *req = NULL;
567 in_req = (ZigbeeZclLevelControlMoveToLevel_t *)request_data;
569 /* Allocate memory */
570 req = (ZigbeeZclLevelControlMoveToLevel_t *)
571 g_malloc0(sizeof(ZigbeeZclLevelControlMoveToLevel_t));
574 req->node_id = in_req->node_id;
575 req->endpoint = in_req->endpoint;
576 req->level = in_req->level;
577 req->transition = in_req->transition;
580 level_control_request_data = (gpointer)req;
584 case ZBLIB_ZCL_LEVEL_CONTROL_OPS_MOVE: {
585 ZigbeeZclLevelControlMove_t *in_req;
586 ZigbeeZclLevelControlMove_t *req = NULL;
588 in_req = (ZigbeeZclLevelControlMove_t *)request_data;
590 /* Allocate memory */
591 req = (ZigbeeZclLevelControlMove_t *)
592 g_malloc0(sizeof(ZigbeeZclLevelControlMove_t));
595 req->node_id = in_req->node_id;
596 req->endpoint = in_req->endpoint;
597 req->move_mode = in_req->move_mode;
598 req->rate = in_req->rate;
601 level_control_request_data = (gpointer)req;
605 case ZBLIB_ZCL_LEVEL_CONTROL_OPS_STEP: {
606 ZigbeeZclLevelControlStep_t *in_req;
607 ZigbeeZclLevelControlStep_t *req = NULL;
609 in_req = (ZigbeeZclLevelControlStep_t *)request_data;
611 /* Allocate memory */
612 req = (ZigbeeZclLevelControlStep_t *)
613 g_malloc0(sizeof(ZigbeeZclLevelControlStep_t));
616 req->node_id = in_req->node_id;
617 req->endpoint = in_req->endpoint;
618 req->step_mode = in_req->step_mode;
619 req->move_mode = in_req->move_mode;
620 req->transition_time = in_req->transition_time;
623 level_control_request_data = (gpointer)req;
627 case ZBLIB_ZCL_LEVEL_CONTROL_OPS_MOVE_TO_LEVEL_WITH_ON_OFF: {
628 ZigbeeZclLevelControlMoveToLevelWithOnOff_t *in_req;
629 ZigbeeZclLevelControlMoveToLevelWithOnOff_t *req = NULL;
631 in_req = (ZigbeeZclLevelControlMoveToLevelWithOnOff_t *)request_data;
633 /* Allocate memory */
634 req = (ZigbeeZclLevelControlMoveToLevelWithOnOff_t *)
635 g_malloc0(sizeof(ZigbeeZclLevelControlMoveToLevelWithOnOff_t));
638 req->node_id = in_req->node_id;
639 req->endpoint = in_req->endpoint;
640 req->level = in_req->level;
641 req->transition = in_req->transition;
644 level_control_request_data = (gpointer)req;
648 case ZBLIB_ZCL_LEVEL_CONTROL_OPS_MOVE_WITH_ON_OFF: {
649 ZigbeeZclLevelControlMoveWithOnOff_t *in_req;
650 ZigbeeZclLevelControlMoveWithOnOff_t *req = NULL;
652 in_req = (ZigbeeZclLevelControlMoveWithOnOff_t *)request_data;
654 /* Allocate memory */
655 req = (ZigbeeZclLevelControlMoveWithOnOff_t *)
656 g_malloc0(sizeof(ZigbeeZclLevelControlMoveWithOnOff_t));
659 req->node_id = in_req->node_id;
660 req->endpoint = in_req->endpoint;
661 req->move_mode = in_req->move_mode;
662 req->rate = in_req->rate;
665 level_control_request_data = (gpointer)req;
669 case ZBLIB_ZCL_LEVEL_CONTROL_OPS_STEP_WITH_ON_OFF: {
670 ZigbeeZclLevelControlStepWithOnOff_t *in_req;
671 ZigbeeZclLevelControlStepWithOnOff_t *req = NULL;
673 in_req = (ZigbeeZclLevelControlStepWithOnOff_t *)request_data;
675 /* Allocate memory */
676 req = (ZigbeeZclLevelControlStepWithOnOff_t *)
677 g_malloc0(sizeof(ZigbeeZclLevelControlStepWithOnOff_t));
680 req->node_id = in_req->node_id;
681 req->endpoint = in_req->endpoint;
682 req->step_mode = in_req->step_mode;
683 req->move_mode = in_req->move_mode;
684 req->transition_time = in_req->transition_time;
687 level_control_request_data = (gpointer)req;
691 case ZBLIB_ZCL_LEVEL_CONTROL_OPS_STOP: {
692 ZigbeeZclLevelControlStop_t *in_req;
693 ZigbeeZclLevelControlStop_t *req = NULL;
695 in_req = (ZigbeeZclLevelControlStop_t *)request_data;
697 /* Allocate memory */
698 req = (ZigbeeZclLevelControlStop_t *)
699 g_malloc0(sizeof(ZigbeeZclLevelControlStop_t));
702 req->node_id = in_req->node_id;
703 req->endpoint = in_req->endpoint;
706 level_control_request_data = (gpointer)req;
714 return level_control_request_data;
717 static gpointer __zblib_request_create_mfglib_control_request_data(guint request_type,
718 gpointer request_data, guint request_data_len)
720 gpointer mfglib_control_request_data = NULL;
723 NOT_USED(request_data_len);
726 ops_id = __zblib_request_get_ops_id(request_type);
728 case ZBLIB_MFGLIB_CONTROL_OPS_START: {
729 ZigbeeMfglibControlStart_t *in_req;
730 ZigbeeMfglibControlStart_t *req = NULL;
732 in_req = (ZigbeeMfglibControlStart_t *)request_data;
733 if (NULL != in_req) {
734 /* Allocate memory */
735 req = (ZigbeeMfglibControlStart_t *)
736 g_malloc0(sizeof(ZigbeeMfglibControlStart_t));
739 memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
740 req->mfglib_start = in_req->mfglib_start;
743 mfglib_control_request_data = (gpointer)req;
747 case ZBLIB_MFGLIB_CONTROL_OPS_END: {
748 ZigbeeMfglibControlEnd_t *in_req;
749 ZigbeeMfglibControlEnd_t *req = NULL;
751 in_req = (ZigbeeMfglibControlEnd_t *)request_data;
752 if (NULL != in_req) {
753 /* Allocate memory */
754 req = (ZigbeeMfglibControlEnd_t *)
755 g_malloc0(sizeof(ZigbeeMfglibControlEnd_t));
758 memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
761 mfglib_control_request_data = (gpointer)req;
765 case ZBLIB_MFGLIB_CONTROL_OPS_START_TONE: {
766 ZigbeeMfglibControlStartTone_t *in_req;
767 ZigbeeMfglibControlStartTone_t *req = NULL;
769 in_req = (ZigbeeMfglibControlStartTone_t *)request_data;
770 if (NULL != in_req) {
771 /* Allocate memory */
772 req = (ZigbeeMfglibControlStartTone_t *)
773 g_malloc0(sizeof(ZigbeeMfglibControlStartTone_t));
776 memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
779 mfglib_control_request_data = (gpointer)req;
783 case ZBLIB_MFGLIB_CONTROL_OPS_STOP_TONE: {
784 ZigbeeMfglibControlStopTone_t *in_req;
785 ZigbeeMfglibControlStopTone_t *req = NULL;
787 in_req = (ZigbeeMfglibControlStopTone_t *)request_data;
788 if (NULL != in_req) {
789 /* Allocate memory */
790 req = (ZigbeeMfglibControlStopTone_t *)
791 g_malloc0(sizeof(ZigbeeMfglibControlStopTone_t));
794 memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
797 mfglib_control_request_data = (gpointer)req;
801 case ZBLIB_MFGLIB_CONTROL_OPS_START_STREAM: {
802 ZigbeeMfglibControlStartStream_t *in_req;
803 ZigbeeMfglibControlStartStream_t *req = NULL;
805 in_req = (ZigbeeMfglibControlStartStream_t *)request_data;
806 if (NULL != in_req) {
807 /* Allocate memory */
808 req = (ZigbeeMfglibControlStartStream_t *)
809 g_malloc0(sizeof(ZigbeeMfglibControlStartStream_t));
812 memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
815 mfglib_control_request_data = (gpointer)req;
819 case ZBLIB_MFGLIB_CONTROL_OPS_STOP_STREAM: {
820 ZigbeeMfglibControlStopStream_t *in_req;
821 ZigbeeMfglibControlStopStream_t *req = NULL;
823 in_req = (ZigbeeMfglibControlStopStream_t *)request_data;
824 if (NULL != in_req) {
825 /* Allocate memory */
826 req = (ZigbeeMfglibControlStopStream_t *)
827 g_malloc0(sizeof(ZigbeeMfglibControlStopStream_t));
830 memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
833 mfglib_control_request_data = (gpointer)req;
837 case ZBLIB_MFGLIB_CONTROL_OPS_SEND_PACKET: {
838 ZigbeeMfglibControlSendPacket_t *in_req;
839 ZigbeeMfglibControlSendPacket_t *req = NULL;
841 in_req = (ZigbeeMfglibControlSendPacket_t *)request_data;
842 if (NULL != in_req) {
843 /* Allocate memory */
844 req = (ZigbeeMfglibControlSendPacket_t *)
845 g_malloc0(sizeof(ZigbeeMfglibControlSendPacket_t));
848 memcpy(req->packet_content,
849 in_req->packet_content,
850 ZIGBEE_MFGLIB_CONTROL_PACKET_CONTENT_LEN);
851 req->packet_length = in_req->packet_length;
854 mfglib_control_request_data = (gpointer)req;
858 case ZBLIB_MFGLIB_CONTROL_OPS_SET_CHANNEL: {
859 ZigbeeMfglibControlSetChannel_t *in_req;
860 ZigbeeMfglibControlSetChannel_t *req = NULL;
862 in_req = (ZigbeeMfglibControlSetChannel_t *)request_data;
863 if (NULL != in_req) {
864 /* Allocate memory */
865 req = (ZigbeeMfglibControlSetChannel_t *)
866 g_malloc0(sizeof(ZigbeeMfglibControlSetChannel_t));
869 memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
870 req->channel = in_req->channel;
873 mfglib_control_request_data = (gpointer)req;
877 case ZBLIB_MFGLIB_CONTROL_OPS_GET_CHANNEL: {
878 ZigbeeMfglibControlGetChannel_t *in_req;
879 ZigbeeMfglibControlGetChannel_t *req = NULL;
881 in_req = (ZigbeeMfglibControlGetChannel_t *)request_data;
882 if (NULL != in_req) {
883 /* Allocate memory */
884 req = (ZigbeeMfglibControlGetChannel_t *)
885 g_malloc0(sizeof(ZigbeeMfglibControlGetChannel_t));
888 memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
891 mfglib_control_request_data = (gpointer)req;
895 case ZBLIB_MFGLIB_CONTROL_OPS_SET_POWER: {
896 ZigbeeMfglibControlSetPower_t *in_req;
897 ZigbeeMfglibControlSetPower_t *req = NULL;
899 in_req = (ZigbeeMfglibControlSetPower_t *)request_data;
900 if (NULL != in_req) {
901 /* Allocate memory */
902 req = (ZigbeeMfglibControlSetPower_t *)
903 g_malloc0(sizeof(ZigbeeMfglibControlSetPower_t));
906 memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
907 req->tx_power_mode = in_req->tx_power_mode;
908 req->power = in_req->power;
911 mfglib_control_request_data = (gpointer)req;
915 case ZBLIB_MFGLIB_CONTROL_OPS_GET_POWER: {
916 ZigbeeMfglibControlGetPower_t *in_req;
917 ZigbeeMfglibControlGetPower_t *req = NULL;
919 in_req = (ZigbeeMfglibControlGetPower_t *)request_data;
920 if (NULL != in_req) {
921 /* Allocate memory */
922 req = (ZigbeeMfglibControlGetPower_t *)
923 g_malloc0(sizeof(ZigbeeMfglibControlGetPower_t));
926 memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
929 mfglib_control_request_data = (gpointer)req;
933 case ZBLIB_MFGLIB_CONTROL_OPS_SET_SYNOFFSET: {
934 ZigbeeMfglibControlSetSynOffset_t *in_req;
935 ZigbeeMfglibControlSetSynOffset_t *req = NULL;
937 in_req = (ZigbeeMfglibControlSetSynOffset_t *)request_data;
938 if (NULL != in_req) {
939 /* Allocate memory */
940 req = (ZigbeeMfglibControlSetSynOffset_t *)
941 g_malloc0(sizeof(ZigbeeMfglibControlSetSynOffset_t));
944 memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
945 req->channel = in_req->channel;
948 mfglib_control_request_data = (gpointer)req;
952 case ZBLIB_MFGLIB_CONTROL_OPS_GET_SYNOFFSET: {
953 ZigbeeMfglibControlGetSynOffset_t *in_req;
954 ZigbeeMfglibControlGetSynOffset_t *req = NULL;
956 in_req = (ZigbeeMfglibControlGetSynOffset_t *)request_data;
957 if (NULL != in_req) {
958 /* Allocate memory */
959 req = (ZigbeeMfglibControlGetSynOffset_t *)
960 g_malloc0(sizeof(ZigbeeMfglibControlGetSynOffset_t));
965 ZIGBEE_MFGLIB_CONTROL_PACKET_CONTENT_LEN);
966 req->packet_length = in_req->packet_length;
967 req->link_quality = in_req->link_quality;
968 req->rssi = in_req->rssi;
971 mfglib_control_request_data = (gpointer)req;
975 case ZBLIB_MFGLIB_CONTROL_OPS_RX_START: {
976 ZigbeeMfglibControlRxStart_t *in_req;
977 ZigbeeMfglibControlRxStart_t *req = NULL;
979 in_req = (ZigbeeMfglibControlRxStart_t *)request_data;
980 if (NULL != in_req) {
981 /* Allocate memory */
982 req = (ZigbeeMfglibControlRxStart_t *)
983 g_malloc0(sizeof(ZigbeeMfglibControlRxStart_t));
986 memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
989 mfglib_control_request_data = (gpointer)req;
993 case ZBLIB_MFGLIB_CONTROL_OPS_RX_STOP: {
994 ZigbeeMfglibControlRxStop_t *in_req;
995 ZigbeeMfglibControlRxStop_t *req = NULL;
997 in_req = (ZigbeeMfglibControlRxStop_t *)request_data;
998 if (NULL != in_req) {
999 /* Allocate memory */
1000 req = (ZigbeeMfglibControlRxStop_t *)
1001 g_malloc0(sizeof(ZigbeeMfglibControlRxStop_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_VERIFY: {
1012 ZigbeeMfglibControlRxVerify_t *in_req;
1013 ZigbeeMfglibControlRxVerify_t *req = NULL;
1015 in_req = (ZigbeeMfglibControlRxVerify_t *)request_data;
1016 if (NULL != in_req) {
1017 /* Allocate memory */
1018 req = (ZigbeeMfglibControlRxVerify_t *)
1019 g_malloc0(sizeof(ZigbeeMfglibControlRxVerify_t));
1022 memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
1025 mfglib_control_request_data = (gpointer)req;
1029 case ZBLIB_MFGLIB_CONTROL_OPS_GET_RSSI: {
1030 ZigbeeMfglibControlGetRssi_t *in_req;
1031 ZigbeeMfglibControlGetRssi_t *req = NULL;
1033 in_req = (ZigbeeMfglibControlGetRssi_t *)request_data;
1034 if (NULL != in_req) {
1035 /* Allocate memory */
1036 req = (ZigbeeMfglibControlGetRssi_t *)
1037 g_malloc0(sizeof(ZigbeeMfglibControlGetRssi_t));
1040 memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
1043 mfglib_control_request_data = (gpointer)req;
1051 return mfglib_control_request_data;
1054 static gpointer __zblib_request_create_zcl_on_off_request_data(guint request_type,
1055 gpointer request_data, guint request_data_len)
1057 gpointer on_off_request_data = NULL;
1060 NOT_USED(request_data_len);
1063 ops_id = __zblib_request_get_ops_id(request_type);
1065 case ZBLIB_ZCL_ON_OFF_OPS_SET_ON_OFF: {
1066 ZigbeeZclOnOffSetOnOff_t *in_req;
1067 ZigbeeZclOnOffSetOnOff_t *req = NULL;
1069 in_req = (ZigbeeZclOnOffSetOnOff_t *)request_data;
1070 if (NULL != in_req) {
1071 /* Allocate memory */
1072 req = (ZigbeeZclOnOffSetOnOff_t *)
1073 g_malloc0(sizeof(ZigbeeZclOnOffSetOnOff_t));
1076 req->node_id = in_req->node_id;
1077 req->endpoint = in_req->endpoint;
1078 req->on_off_type = in_req->on_off_type;
1081 on_off_request_data = (gpointer)req;
1085 case ZBLIB_ZCL_ON_OFF_OPS_GET_ON_OFF_STATE: {
1086 ZigbeeZclOnOffGetOnOffState_t *in_req;
1087 ZigbeeZclOnOffGetOnOffState_t *req = NULL;
1089 in_req = (ZigbeeZclOnOffGetOnOffState_t *)request_data;
1090 if (NULL != in_req) {
1091 /* Allocate memory */
1092 req = (ZigbeeZclOnOffGetOnOffState_t *)
1093 g_malloc0(sizeof(ZigbeeZclOnOffGetOnOffState_t));
1096 req->node_id = in_req->node_id;
1097 req->endpoint = in_req->endpoint;
1100 on_off_request_data = (gpointer)req;
1108 return on_off_request_data;
1111 static gpointer __zblib_request_create_service_request_data(guint request_type,
1112 gpointer request_data, guint request_data_len)
1114 gpointer service_request_data = NULL;
1117 NOT_USED(request_data_len);
1120 ops_id = __zblib_request_get_ops_id(request_type);
1122 case ZBLIB_SERVICE_OPS_ENABLE: {
1123 service_request_data = NULL;
1127 case ZBLIB_SERVICE_OPS_DISABLE: {
1128 service_request_data = NULL;
1132 case ZBLIB_SERVICE_OPS_ZB_HW_RESET: {
1133 service_request_data = NULL;
1137 case ZBLIB_SERVICE_OPS_FORM_NETWORK: {
1138 service_request_data = NULL;
1142 case ZBLIB_SERVICE_OPS_COEX_START: {
1143 ZigbeeServiceCoexStart_t *in_req;
1144 ZigbeeServiceCoexStart_t *req = NULL;
1146 in_req = (ZigbeeServiceCoexStart_t *)request_data;
1147 if (NULL != in_req) {
1148 /* Allocate memory */
1149 req = (ZigbeeServiceCoexStart_t *)
1150 g_malloc0(sizeof(ZigbeeServiceCoexStart_t));
1153 req->channel = in_req->channel;
1156 service_request_data = (gpointer)req;
1160 case ZBLIB_SERVICE_OPS_COEX_STOP: {
1161 service_request_data = NULL;
1165 case ZBLIB_SERVICE_OPS_LEAVE_NETWORK: {
1166 service_request_data = NULL;
1170 case ZBLIB_SERVICE_OPS_GET_NETWORK_INFO: {
1171 service_request_data = NULL;
1175 case ZBLIB_SERVICE_OPS_PERMIT_JOIN: {
1176 ZigbeeServicePermitJoin_t *in_req;
1177 ZigbeeServicePermitJoin_t *req = NULL;
1179 in_req = (ZigbeeServicePermitJoin_t *)request_data;
1180 if (NULL != in_req) {
1181 /* Allocate memory */
1182 req = (ZigbeeServicePermitJoin_t *)
1183 g_malloc0(sizeof(ZigbeeServicePermitJoin_t));
1186 req->permit_join = in_req->permit_join;
1187 req->duration = in_req->duration;
1190 service_request_data = (gpointer)req;
1194 case ZBLIB_SERVICE_OPS_LEAVE_REQUEST: {
1195 ZigbeeServiceLeaveRequest_t *in_req;
1196 ZigbeeServiceLeaveRequest_t *req = NULL;
1198 in_req = (ZigbeeServiceLeaveRequest_t *)request_data;
1199 if (NULL != in_req) {
1200 /* Allocate memory */
1201 req = (ZigbeeServiceLeaveRequest_t *)
1202 g_malloc0(sizeof(ZigbeeServiceLeaveRequest_t));
1205 memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
1206 req->remove_child = in_req->remove_child;
1207 req->rejoin = in_req->rejoin;
1210 service_request_data = (gpointer)req;
1214 case ZBLIB_SERVICE_OPS_GET_DEVICE_LIST: {
1215 service_request_data = NULL;
1219 case ZBLIB_SERVICE_OPS_GET_MAC: {
1220 service_request_data = NULL;
1224 case ZBLIB_SERVICE_OPS_GET_DEVICE_INFO: {
1225 service_request_data = NULL;
1229 case ZBLIB_SERVICE_OPS_GET_ENDPOINT_LIST: {
1230 ZigbeeServiceGetEndpointList_t *in_req;
1231 ZigbeeServiceGetEndpointList_t *req = NULL;
1233 in_req = (ZigbeeServiceGetEndpointList_t *)request_data;
1234 if (NULL != in_req) {
1235 /* Allocate memory */
1236 req = (ZigbeeServiceGetEndpointList_t *)
1237 g_malloc0(sizeof(ZigbeeServiceGetEndpointList_t));
1240 memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
1243 service_request_data = (gpointer)req;
1247 case ZBLIB_SERVICE_OPS_GET_CLUSTER_LIST: {
1248 ZigbeeServiceGetClusterList_t *in_req;
1249 ZigbeeServiceGetClusterList_t *req = NULL;
1251 in_req = (ZigbeeServiceGetClusterList_t *)request_data;
1252 if (NULL != in_req) {
1253 /* Allocate memory */
1254 req = (ZigbeeServiceGetClusterList_t *)
1255 g_malloc0(sizeof(ZigbeeServiceGetClusterList_t));
1258 memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
1259 req->endpoint = in_req->endpoint;
1262 service_request_data = (gpointer)req;
1266 case ZBLIB_SERVICE_OPS_GET_NODE_TYPE: {
1267 ZigbeeServiceGetNodeType_t *in_req;
1268 ZigbeeServiceGetNodeType_t *req = NULL;
1270 in_req = (ZigbeeServiceGetNodeType_t *)request_data;
1271 if (NULL != in_req) {
1272 /* Allocate memory */
1273 req = (ZigbeeServiceGetNodeType_t *)
1274 g_malloc0(sizeof(ZigbeeServiceGetNodeType_t));
1277 memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
1280 service_request_data = (gpointer)req;
1288 return service_request_data;
1291 static gpointer __zblib_request_create_zcl_thermostat_request_data(guint request_type,
1292 gpointer request_data, guint request_data_len)
1294 gpointer thermostat_request_data = NULL;
1297 NOT_USED(request_data_len);
1300 ops_id = __zblib_request_get_ops_id(request_type);
1302 case ZBLIB_ZCL_THERMOSTAT_OPS_GET_LOCAL_TEMP: {
1303 ZigbeeZclThermostatGetLocalTemp_t *in_req;
1304 ZigbeeZclThermostatGetLocalTemp_t *req = NULL;
1306 in_req = (ZigbeeZclThermostatGetLocalTemp_t *)request_data;
1307 if (NULL != in_req) {
1308 /* Allocate memory */
1309 req = (ZigbeeZclThermostatGetLocalTemp_t *)
1310 g_malloc0(sizeof(ZigbeeZclThermostatGetLocalTemp_t));
1313 memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
1314 req->endpoint = in_req->endpoint;
1317 thermostat_request_data = (gpointer)req;
1321 case ZBLIB_ZCL_THERMOSTAT_OPS_GET_WEEKLY_SCHEDULE: {
1322 ZigbeeZclThermostatGetWeeklySchedule_t *in_req;
1323 ZigbeeZclThermostatGetWeeklySchedule_t *req = NULL;
1325 in_req = (ZigbeeZclThermostatGetWeeklySchedule_t *)request_data;
1326 if (NULL != in_req) {
1327 /* Allocate memory */
1328 req = (ZigbeeZclThermostatGetWeeklySchedule_t *)
1329 g_malloc0(sizeof(ZigbeeZclThermostatGetWeeklySchedule_t));
1332 memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
1333 req->endpoint = in_req->endpoint;
1334 req->num_of_days = in_req->num_of_days;
1335 req->mode = in_req->mode;
1338 thermostat_request_data = (gpointer)req;
1342 case ZBLIB_ZCL_THERMOSTAT_OPS_SET_WEEKLY_SCHEDULE: {
1343 ZigbeeZclThermostatSetWeeklySchedule_t *in_req;
1344 ZigbeeZclThermostatSetWeeklySchedule_t *req = NULL;
1346 in_req = (ZigbeeZclThermostatSetWeeklySchedule_t *)request_data;
1347 if (NULL != in_req) {
1348 /* Allocate memory */
1349 req = (ZigbeeZclThermostatSetWeeklySchedule_t *)
1350 g_malloc0(sizeof(ZigbeeZclThermostatSetWeeklySchedule_t));
1353 memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
1354 req->endpoint = in_req->endpoint;
1355 req->no_of_transitions = in_req->no_of_transitions;
1356 req->num_of_days = in_req->num_of_days;
1357 req->mode = in_req->mode;
1358 memcpy(req->payload,
1359 in_req->payload, ZIGBEE_THERMSTAT_PAYLOAD_MAX_LEN);
1360 req->payload_len = in_req->payload_len;
1363 thermostat_request_data = (gpointer)req;
1367 case ZBLIB_ZCL_THERMOSTAT_OPS_CLEAR_WEEKLY_SCHEDULE: {
1368 ZigbeeZclThermostatClearWeeklySchedule_t *in_req;
1369 ZigbeeZclThermostatClearWeeklySchedule_t *req = NULL;
1371 in_req = (ZigbeeZclThermostatClearWeeklySchedule_t *)request_data;
1372 if (NULL != in_req) {
1373 /* Allocate memory */
1374 req = (ZigbeeZclThermostatClearWeeklySchedule_t *)
1375 g_malloc0(sizeof(ZigbeeZclThermostatClearWeeklySchedule_t));
1378 memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
1379 req->endpoint = in_req->endpoint;
1382 thermostat_request_data = (gpointer)req;
1386 case ZBLIB_ZCL_THERMOSTAT_OPS_SETPOINT_RAISE_LOWER: {
1387 ZigbeeZclThermostatSetpointRaiseLower_t *in_req;
1388 ZigbeeZclThermostatSetpointRaiseLower_t *req = NULL;
1390 in_req = (ZigbeeZclThermostatSetpointRaiseLower_t *)request_data;
1391 if (NULL != in_req) {
1392 /* Allocate memory */
1393 req = (ZigbeeZclThermostatSetpointRaiseLower_t *)
1394 g_malloc0(sizeof(ZigbeeZclThermostatSetpointRaiseLower_t));
1397 req->node_id = in_req->node_id;
1398 req->endpoint = in_req->endpoint;
1399 req->mode = in_req->mode;
1400 req->amount = in_req->amount;
1403 thermostat_request_data = (gpointer)req;
1411 return thermostat_request_data;
1414 static gpointer __zblib_request_create_zcl_basic_request_data(guint request_type,
1415 gpointer request_data, guint request_data_len)
1417 gpointer zclbasic_control_request_data = NULL;
1420 NOT_USED(request_data_len);
1423 ops_id = __zblib_request_get_ops_id(request_type);
1425 case ZBLIB_ZCL_BASIC_OPS_RESET_FACTORY_DEFAULT: {
1426 ZigbeeZclBasicResetFactoryDefault_t *in_req;
1427 ZigbeeZclBasicResetFactoryDefault_t *req = NULL;
1429 in_req = (ZigbeeZclBasicResetFactoryDefault_t *)request_data;
1430 if (NULL != in_req) {
1431 /* Allocate memory */
1432 req = (ZigbeeZclBasicResetFactoryDefault_t *)
1433 g_malloc0(sizeof(ZigbeeZclBasicResetFactoryDefault_t));
1436 req->node_id = in_req->node_id;
1437 req->dest_ep = in_req->dest_ep;
1440 zclbasic_control_request_data = (gpointer)req;
1448 return zclbasic_control_request_data;
1451 static gpointer __zblib_request_create_zcl_global_control_request_data(guint request_type,
1452 gpointer request_data, guint request_data_len)
1454 gpointer zclglobal_control_request_data = NULL;
1457 NOT_USED(request_data_len);
1460 ops_id = __zblib_request_get_ops_id(request_type);
1462 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_READ_ATTRIBUTES_REQ: {
1463 ZigbeeZclGlobalControlReadAttributesRequest_t *in_req;
1464 ZigbeeZclGlobalControlReadAttributesRequest_t *req = NULL;
1466 in_req = (ZigbeeZclGlobalControlReadAttributesRequest_t *)request_data;
1467 if (NULL != in_req) {
1468 /* Allocate memory */
1469 req = (ZigbeeZclGlobalControlReadAttributesRequest_t *)
1470 g_malloc0(sizeof(ZigbeeZclGlobalControlReadAttributesRequest_t));
1473 req->attribute_id = g_strdup(in_req->attribute_id);
1474 req->attribute_id_len = in_req->attribute_id_len;
1475 req->node_id = in_req->node_id;
1476 req->cluster_id = in_req->cluster_id;
1477 req->zcl_frame_ctrl = in_req->zcl_frame_ctrl;
1478 req->dest_ep = in_req->dest_ep;
1481 zclglobal_control_request_data = (gpointer)req;
1485 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_REQ: {
1486 ZigbeeZclGlobalControlWriteAttributesRequest_t *in_req;
1487 ZigbeeZclGlobalControlWriteAttributesRequest_t *req = NULL;
1489 in_req = (ZigbeeZclGlobalControlWriteAttributesRequest_t *)request_data;
1490 if (NULL != in_req) {
1491 /* Allocate memory */
1492 req = (ZigbeeZclGlobalControlWriteAttributesRequest_t *)
1493 g_malloc0(sizeof(ZigbeeZclGlobalControlWriteAttributesRequest_t));
1496 req->write_records = g_strdup(in_req->write_records);
1497 req->records_len = in_req->records_len;
1498 req->node_id = in_req->node_id;
1499 req->cluster_id = in_req->cluster_id;
1500 req->zcl_frame_ctrl = in_req->zcl_frame_ctrl;
1501 req->src_ep = in_req->src_ep;
1502 req->dest_ep = in_req->dest_ep;
1505 zclglobal_control_request_data = (gpointer)req;
1509 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_UNDIVIDED_REQ: {
1510 ZigbeeZclGlobalControlWriteAttributesUndividedRequest_t *in_req;
1511 ZigbeeZclGlobalControlWriteAttributesUndividedRequest_t *req = NULL;
1513 in_req = (ZigbeeZclGlobalControlWriteAttributesUndividedRequest_t *)request_data;
1514 if (NULL != in_req) {
1515 /* Allocate memory */
1516 req = (ZigbeeZclGlobalControlWriteAttributesUndividedRequest_t *)
1517 g_malloc0(sizeof(ZigbeeZclGlobalControlWriteAttributesUndividedRequest_t));
1520 req->write_records = g_strdup(in_req->write_records);
1521 req->records_len = in_req->records_len;
1522 req->node_id = in_req->node_id;
1523 req->cluster_id = in_req->cluster_id;
1524 req->zcl_frame_ctrl = in_req->zcl_frame_ctrl;
1525 req->src_ep = in_req->src_ep;
1526 req->dest_ep = in_req->dest_ep;
1529 zclglobal_control_request_data = (gpointer)req;
1533 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_NO_RESP: {
1534 ZigbeeZclGlobalControlWriteAttributesNoResponse_t *in_req;
1535 ZigbeeZclGlobalControlWriteAttributesNoResponse_t *req = NULL;
1537 in_req = (ZigbeeZclGlobalControlWriteAttributesNoResponse_t *)request_data;
1538 if (NULL != in_req) {
1539 /* Allocate memory */
1540 req = (ZigbeeZclGlobalControlWriteAttributesNoResponse_t *)
1541 g_malloc0(sizeof(ZigbeeZclGlobalControlWriteAttributesNoResponse_t));
1544 req->write_records = g_strdup(in_req->write_records);
1545 req->records_len = in_req->records_len;
1546 req->node_id = in_req->node_id;
1547 req->cluster_id = in_req->cluster_id;
1548 req->zcl_frame_ctrl = in_req->zcl_frame_ctrl;
1549 req->src_ep = in_req->src_ep;
1550 req->dest_ep = in_req->dest_ep;
1553 zclglobal_control_request_data = (gpointer)req;
1557 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_STRUCTURED: {
1558 ZigbeeZclGlobalControlWriteAttributesStructed_t *in_req;
1559 ZigbeeZclGlobalControlWriteAttributesStructed_t *req = NULL;
1561 in_req = (ZigbeeZclGlobalControlWriteAttributesStructed_t *)request_data;
1562 if (NULL != in_req) {
1563 /* Allocate memory */
1564 req = (ZigbeeZclGlobalControlWriteAttributesStructed_t *)
1565 g_malloc0(sizeof(ZigbeeZclGlobalControlWriteAttributesStructed_t));
1568 req->write_records = g_strdup(in_req->write_records);
1569 req->records_len = in_req->records_len;
1570 req->node_id = in_req->node_id;
1571 req->cluster_id = in_req->cluster_id;
1572 req->zcl_frame_ctrl = in_req->zcl_frame_ctrl;
1573 req->src_ep = in_req->src_ep;
1574 req->dest_ep = in_req->dest_ep;
1577 zclglobal_control_request_data = (gpointer)req;
1581 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_READ_ATTRIBUTES_STRUCTURED: {
1582 ZigbeeZclGlobalControlReadAttributesStructed_t *in_req;
1583 ZigbeeZclGlobalControlReadAttributesStructed_t *req = NULL;
1585 in_req = (ZigbeeZclGlobalControlReadAttributesStructed_t *)request_data;
1586 if (NULL != in_req) {
1587 /* Allocate memory */
1588 req = (ZigbeeZclGlobalControlReadAttributesStructed_t *)
1589 g_malloc0(sizeof(ZigbeeZclGlobalControlReadAttributesStructed_t));
1592 req->read_records = g_strdup(in_req->read_records);
1593 req->records_len = in_req->records_len;
1594 req->node_id = in_req->node_id;
1595 req->cluster_id = in_req->cluster_id;
1596 req->zcl_frame_ctrl = in_req->zcl_frame_ctrl;
1597 req->src_ep = in_req->src_ep;
1598 req->dest_ep = in_req->dest_ep;
1601 zclglobal_control_request_data = (gpointer)req;
1605 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_CONFIGURE_REPORTING_REQ: {
1606 ZigbeeZclGlobalControlConfigureReportingReq_t *in_req;
1607 ZigbeeZclGlobalControlConfigureReportingReq_t *req = NULL;
1609 in_req = (ZigbeeZclGlobalControlConfigureReportingReq_t *)request_data;
1610 if (NULL != in_req) {
1611 /* Allocate memory */
1612 req = (ZigbeeZclGlobalControlConfigureReportingReq_t *)
1613 g_malloc0(sizeof(ZigbeeZclGlobalControlConfigureReportingReq_t));
1616 req->read_records = g_strdup(in_req->read_records);
1617 req->records_len = in_req->records_len;
1618 req->node_id = in_req->node_id;
1619 req->cluster_id = in_req->cluster_id;
1620 req->zcl_frame_ctrl = in_req->zcl_frame_ctrl;
1621 req->src_ep = in_req->src_ep;
1622 req->dest_ep = in_req->dest_ep;
1625 zclglobal_control_request_data = (gpointer)req;
1629 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_READ_CONFIGURE_REPORTING: {
1630 ZigbeeZclGlobalControlReadConfigureReporting_t *in_req;
1631 ZigbeeZclGlobalControlReadConfigureReporting_t *req = NULL;
1633 in_req = (ZigbeeZclGlobalControlReadConfigureReporting_t *)request_data;
1634 if (NULL != in_req) {
1635 /* Allocate memory */
1636 req = (ZigbeeZclGlobalControlReadConfigureReporting_t *)
1637 g_malloc0(sizeof(ZigbeeZclGlobalControlReadConfigureReporting_t));
1640 req->read_records = g_strdup(in_req->read_records);
1641 req->records_len = in_req->records_len;
1642 req->node_id = in_req->node_id;
1643 req->cluster_id = in_req->cluster_id;
1644 req->zcl_frame_ctrl = in_req->zcl_frame_ctrl;
1645 req->src_ep = in_req->src_ep;
1646 req->dest_ep = in_req->dest_ep;
1649 zclglobal_control_request_data = (gpointer)req;
1653 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_DISCOVER_ATTRIBUTES: {
1654 ZigbeeZclGlobalControlDiscoverAttributes_t *in_req;
1655 ZigbeeZclGlobalControlDiscoverAttributes_t *req = NULL;
1657 in_req = (ZigbeeZclGlobalControlDiscoverAttributes_t *)request_data;
1658 if (NULL != in_req) {
1659 /* Allocate memory */
1660 req = (ZigbeeZclGlobalControlDiscoverAttributes_t *)
1661 g_malloc0(sizeof(ZigbeeZclGlobalControlDiscoverAttributes_t));
1664 req->node_id = in_req->node_id;
1665 req->dest_ep = in_req->dest_ep;
1666 req->zcl_frame_ctrl = in_req->zcl_frame_ctrl;
1667 req->cluster_id = in_req->cluster_id;
1668 req->start_attribute = in_req->start_attribute;
1669 req->max = in_req->max;
1672 zclglobal_control_request_data = (gpointer)req;
1676 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_DISCOVER_ATTRIBUTES_EXTENDED: {
1677 ZigbeeZclGlobalControlDiscoverAttributesExtended_t *in_req;
1678 ZigbeeZclGlobalControlDiscoverAttributesExtended_t *req = NULL;
1680 in_req = (ZigbeeZclGlobalControlDiscoverAttributesExtended_t *)request_data;
1681 if (NULL != in_req) {
1682 /* Allocate memory */
1683 req = (ZigbeeZclGlobalControlDiscoverAttributesExtended_t *)
1684 g_malloc0(sizeof(ZigbeeZclGlobalControlDiscoverAttributesExtended_t));
1687 req->node_id = in_req->node_id;
1688 req->dest_ep = in_req->dest_ep;
1689 req->zcl_frame_ctrl = in_req->zcl_frame_ctrl;
1690 req->cluster_id = in_req->cluster_id;
1691 req->start_attribute = in_req->start_attribute;
1692 req->max = in_req->max;
1695 zclglobal_control_request_data = (gpointer)req;
1699 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_DISCOVER_COMMANDS_RECEIVED: {
1700 ZigbeeZclGlobalControlDiscoverCommandsReceived_t *in_req;
1701 ZigbeeZclGlobalControlDiscoverCommandsReceived_t *req = NULL;
1703 in_req = (ZigbeeZclGlobalControlDiscoverCommandsReceived_t *)request_data;
1704 if (NULL != in_req) {
1705 /* Allocate memory */
1706 req = (ZigbeeZclGlobalControlDiscoverCommandsReceived_t *)
1707 g_malloc0(sizeof(ZigbeeZclGlobalControlDiscoverCommandsReceived_t));
1710 req->node_id = in_req->node_id;
1711 req->dest_ep = in_req->dest_ep;
1712 req->zcl_frame_ctrl = in_req->zcl_frame_ctrl;
1713 req->cluster_id = in_req->cluster_id;
1714 req->start_attribute = in_req->start_attribute;
1715 req->max = in_req->max;
1718 zclglobal_control_request_data = (gpointer)req;
1722 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_DISCOVER_COMMANDS_GENERATED: {
1723 ZigbeeZclGlobalControlDiscoverCommandsGenerated_t *in_req;
1724 ZigbeeZclGlobalControlDiscoverCommandsGenerated_t *req = NULL;
1726 in_req = (ZigbeeZclGlobalControlDiscoverCommandsGenerated_t *)request_data;
1727 if (NULL != in_req) {
1728 /* Allocate memory */
1729 req = (ZigbeeZclGlobalControlDiscoverCommandsGenerated_t *)
1730 g_malloc0(sizeof(ZigbeeZclGlobalControlDiscoverCommandsGenerated_t));
1733 req->node_id = in_req->node_id;
1734 req->dest_ep = in_req->dest_ep;
1735 req->zcl_frame_ctrl = in_req->zcl_frame_ctrl;
1736 req->cluster_id = in_req->cluster_id;
1737 req->start_attribute = in_req->start_attribute;
1738 req->max = in_req->max;
1741 zclglobal_control_request_data = (gpointer)req;
1749 return zclglobal_control_request_data;
1752 static gpointer __zblib_request_create_zcl_ias_zone_request_data(guint request_type,
1753 gpointer request_data, guint request_data_len)
1755 gpointer zclias_control_request_data = NULL;
1758 NOT_USED(request_data_len);
1761 ops_id = __zblib_request_get_ops_id(request_type);
1763 case ZBLIB_ZCL_IAS_ZONE_OPS_ENROLL_RESPONSE: {
1764 ZigbeeZclIasZoneEnrollResponse_t *in_req;
1765 ZigbeeZclIasZoneEnrollResponse_t *req = NULL;
1767 in_req = (ZigbeeZclIasZoneEnrollResponse_t *)request_data;
1768 if (NULL != in_req) {
1769 /* Allocate memory */
1770 req = (ZigbeeZclIasZoneEnrollResponse_t *)
1771 g_malloc0(sizeof(ZigbeeZclIasZoneEnrollResponse_t));
1774 req->node_id = in_req->node_id;
1775 req->dest_ep = in_req->dest_ep;
1776 req->enroll_code = in_req->enroll_code;
1777 req->zone_id = in_req->zone_id;
1780 zclias_control_request_data = (gpointer)req;
1788 return zclias_control_request_data;
1791 static gpointer __zblib_request_create_zcl_identify_request_data(guint request_type,
1792 gpointer request_data, guint request_data_len)
1794 gpointer zclidentify_control_request_data = NULL;
1797 NOT_USED(request_data_len);
1800 ops_id = __zblib_request_get_ops_id(request_type);
1802 case ZBLIB_ZCL_IDENTIFY_OPS_IDENTIFY: {
1803 ZigbeeZclIdentifyIdentify_t *in_req;
1804 ZigbeeZclIdentifyIdentify_t *req = NULL;
1806 in_req = (ZigbeeZclIdentifyIdentify_t *)request_data;
1807 if (NULL != in_req) {
1808 /* Allocate memory */
1809 req = (ZigbeeZclIdentifyIdentify_t *)
1810 g_malloc0(sizeof(ZigbeeZclIdentifyIdentify_t));
1813 req->node_id = in_req->node_id;
1814 req->dest_ep = in_req->dest_ep;
1815 req->identify_time = in_req->identify_time;
1818 zclidentify_control_request_data = (gpointer)req;
1822 case ZBLIB_ZCL_IDENTIFY_OPS_QUERY: {
1823 ZigbeeZclIdentifyQuery_t *in_req;
1824 ZigbeeZclIdentifyQuery_t *req = NULL;
1826 in_req = (ZigbeeZclIdentifyQuery_t *)request_data;
1827 if (NULL != in_req) {
1828 /* Allocate memory */
1829 req = (ZigbeeZclIdentifyQuery_t *)
1830 g_malloc0(sizeof(ZigbeeZclIdentifyQuery_t));
1833 req->node_id = in_req->node_id;
1836 zclidentify_control_request_data = (gpointer)req;
1844 return zclidentify_control_request_data;
1847 static gpointer __zblib_request_create_zcl_color_control_request_data(guint request_type,
1848 gpointer request_data, guint request_data_len)
1850 gpointer zcl_color_request_data = NULL;
1853 NOT_USED(request_data_len);
1856 ops_id = __zblib_request_get_ops_id(request_type);
1858 case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_TO_HUE: {
1859 ZigbeeZclColorControlMoveToHue_t *in_req;
1860 ZigbeeZclColorControlMoveToHue_t *req = NULL;
1862 in_req = (ZigbeeZclColorControlMoveToHue_t *)request_data;
1863 if (NULL != in_req) {
1864 /* Allocate memory */
1865 req = (ZigbeeZclColorControlMoveToHue_t *)
1866 g_malloc0(sizeof(ZigbeeZclColorControlMoveToHue_t));
1869 req->node_id = in_req->node_id;
1870 req->dest_ep = in_req->dest_ep;
1871 req->hue = in_req->hue;
1872 req->direction = in_req->direction;
1873 req->transition_time = in_req->transition_time;
1876 zcl_color_request_data = (gpointer)req;
1880 case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_HUE: {
1881 ZigbeeZclColorControlMoveHue_t *in_req;
1882 ZigbeeZclColorControlMoveHue_t *req = NULL;
1884 in_req = (ZigbeeZclColorControlMoveHue_t *)request_data;
1885 if (NULL != in_req) {
1886 /* Allocate memory */
1887 req = (ZigbeeZclColorControlMoveHue_t *)
1888 g_malloc0(sizeof(ZigbeeZclColorControlMoveHue_t));
1891 req->node_id = in_req->node_id;
1892 req->dest_ep = in_req->dest_ep;
1893 req->move_mode = in_req->move_mode;
1894 req->rate = in_req->rate;
1897 zcl_color_request_data = (gpointer)req;
1901 case ZBLIB_ZCL_COLOR_CONTROL_OPS_STEP_HUE: {
1902 ZigbeeZclColorControlStepHue_t *in_req;
1903 ZigbeeZclColorControlStepHue_t *req = NULL;
1905 in_req = (ZigbeeZclColorControlStepHue_t *)request_data;
1906 if (NULL != in_req) {
1907 /* Allocate memory */
1908 req = (ZigbeeZclColorControlStepHue_t *)
1909 g_malloc0(sizeof(ZigbeeZclColorControlStepHue_t));
1912 req->node_id = in_req->node_id;
1913 req->dest_ep = in_req->dest_ep;
1914 req->step_mode = in_req->step_mode;
1915 req->step_size = in_req->step_size;
1916 req->transition_time = in_req->transition_time;
1919 zcl_color_request_data = (gpointer)req;
1923 case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_TO_STAURATION: {
1924 ZigbeeZclColorControlMoveToSaturation_t *in_req;
1925 ZigbeeZclColorControlMoveToSaturation_t *req = NULL;
1927 in_req = (ZigbeeZclColorControlMoveToSaturation_t *)request_data;
1928 if (NULL != in_req) {
1929 /* Allocate memory */
1930 req = (ZigbeeZclColorControlMoveToSaturation_t *)
1931 g_malloc0(sizeof(ZigbeeZclColorControlMoveToSaturation_t));
1934 req->node_id = in_req->node_id;
1935 req->dest_ep = in_req->dest_ep;
1936 req->saturation = in_req->saturation;
1937 req->transition_time = in_req->transition_time;
1940 zcl_color_request_data = (gpointer)req;
1944 case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_STAURATION: {
1945 ZigbeeZclColorControlMoveSaturation_t *in_req;
1946 ZigbeeZclColorControlMoveSaturation_t *req = NULL;
1948 in_req = (ZigbeeZclColorControlMoveSaturation_t *)request_data;
1949 if (NULL != in_req) {
1950 /* Allocate memory */
1951 req = (ZigbeeZclColorControlMoveSaturation_t *)
1952 g_malloc0(sizeof(ZigbeeZclColorControlMoveSaturation_t));
1955 req->node_id = in_req->node_id;
1956 req->dest_ep = in_req->dest_ep;
1957 req->move_mode = in_req->move_mode;
1958 req->rate = in_req->rate;
1961 zcl_color_request_data = (gpointer)req;
1965 case ZBLIB_ZCL_COLOR_CONTROL_OPS_STEP_STAURATION: {
1966 ZigbeeZclColorControlStepSaturation_t *in_req;
1967 ZigbeeZclColorControlStepSaturation_t *req = NULL;
1969 in_req = (ZigbeeZclColorControlStepSaturation_t *)request_data;
1970 if (NULL != in_req) {
1971 /* Allocate memory */
1972 req = (ZigbeeZclColorControlStepSaturation_t *)
1973 g_malloc0(sizeof(ZigbeeZclColorControlStepSaturation_t));
1976 req->node_id = in_req->node_id;
1977 req->dest_ep = in_req->dest_ep;
1978 req->step_mode = in_req->step_mode;
1979 req->step_size = in_req->step_size;
1980 req->transition_time = in_req->transition_time;
1983 zcl_color_request_data = (gpointer)req;
1987 case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_TO_HUE_AND_SATURATION: {
1988 ZigbeeZclColorControlMoveToHueAndSaturation_t *in_req;
1989 ZigbeeZclColorControlMoveToHueAndSaturation_t *req = NULL;
1991 in_req = (ZigbeeZclColorControlMoveToHueAndSaturation_t *)request_data;
1992 if (NULL != in_req) {
1993 /* Allocate memory */
1994 req = (ZigbeeZclColorControlMoveToHueAndSaturation_t *)
1995 g_malloc0(sizeof(ZigbeeZclColorControlMoveToHueAndSaturation_t));
1998 req->node_id = in_req->node_id;
1999 req->dest_ep = in_req->dest_ep;
2000 req->hue = in_req->hue;
2001 req->saturation = in_req->saturation;
2002 req->transition_time = in_req->transition_time;
2005 zcl_color_request_data = (gpointer)req;
2009 case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_TO_COLOR: {
2010 ZigbeeZclColorControlMoveToColor_t *in_req;
2011 ZigbeeZclColorControlMoveToColor_t *req = NULL;
2013 in_req = (ZigbeeZclColorControlMoveToColor_t *)request_data;
2014 if (NULL != in_req) {
2015 /* Allocate memory */
2016 req = (ZigbeeZclColorControlMoveToColor_t *)
2017 g_malloc0(sizeof(ZigbeeZclColorControlMoveToColor_t));
2020 req->node_id = in_req->node_id;
2021 req->dest_ep = in_req->dest_ep;
2022 req->color_x = in_req->color_x;
2023 req->color_y = in_req->color_y;
2024 req->transition_time = in_req->transition_time;
2027 zcl_color_request_data = (gpointer)req;
2031 case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_COLOR: {
2032 ZigbeeZclColorControlMoveColor_t *in_req;
2033 ZigbeeZclColorControlMoveColor_t *req = NULL;
2035 in_req = (ZigbeeZclColorControlMoveColor_t *)request_data;
2036 if (NULL != in_req) {
2037 /* Allocate memory */
2038 req = (ZigbeeZclColorControlMoveColor_t *)
2039 g_malloc0(sizeof(ZigbeeZclColorControlMoveColor_t));
2042 req->node_id = in_req->node_id;
2043 req->dest_ep = in_req->dest_ep;
2044 req->rate_x = in_req->rate_x;
2045 req->rate_y = in_req->rate_y;
2048 zcl_color_request_data = (gpointer)req;
2052 case ZBLIB_ZCL_COLOR_CONTROL_OPS_STEP_COLOR: {
2053 ZigbeeZclColorControlStepColor_t *in_req;
2054 ZigbeeZclColorControlStepColor_t *req = NULL;
2056 in_req = (ZigbeeZclColorControlStepColor_t *)request_data;
2057 if (NULL != in_req) {
2058 /* Allocate memory */
2059 req = (ZigbeeZclColorControlStepColor_t *)
2060 g_malloc0(sizeof(ZigbeeZclColorControlStepColor_t));
2063 req->node_id = in_req->node_id;
2064 req->dest_ep = in_req->dest_ep;
2065 req->rate_x = in_req->rate_x;
2066 req->rate_y = in_req->rate_y;
2067 req->transition_time = in_req->transition_time;
2070 zcl_color_request_data = (gpointer)req;
2074 case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_COLOR_TEMPERATURE: {
2075 ZigbeeZclColorControlMoveColorTemperature_t *in_req;
2076 ZigbeeZclColorControlMoveColorTemperature_t *req = NULL;
2078 in_req = (ZigbeeZclColorControlMoveColorTemperature_t *)request_data;
2079 if (NULL != in_req) {
2080 /* Allocate memory */
2081 req = (ZigbeeZclColorControlMoveColorTemperature_t *)
2082 g_malloc0(sizeof(ZigbeeZclColorControlMoveColorTemperature_t));
2085 req->node_id = in_req->node_id;
2086 req->dest_ep = in_req->dest_ep;
2087 req->color_temperature = in_req->color_temperature;
2088 req->transition_time = in_req->transition_time;
2091 zcl_color_request_data = (gpointer)req;
2099 return zcl_color_request_data;
2102 static gpointer __zblib_request_create_zcl_group_request_data(guint request_type,
2103 gpointer request_data, guint request_data_len)
2105 gpointer zcl_group_request_data = NULL;
2108 NOT_USED(request_data_len);
2111 ops_id = __zblib_request_get_ops_id(request_type);
2113 case ZBLIB_ZCL_GROUP_OPS_ADD_GROUP: {
2114 ZigbeeZclGroupAddGroup_t *in_req;
2115 ZigbeeZclGroupAddGroup_t *req = NULL;
2117 in_req = (ZigbeeZclGroupAddGroup_t *)request_data;
2118 if (NULL != in_req) {
2119 /* Allocate memory */
2120 req = (ZigbeeZclGroupAddGroup_t *)
2121 g_malloc0(sizeof(ZigbeeZclGroupAddGroup_t));
2124 req->node_id = in_req->node_id;
2125 req->dest_ep = in_req->dest_ep;
2126 req->group_id = in_req->group_id;
2127 g_strlcpy(req->group_name,
2128 in_req->group_name, ZIGBEE_ZCL_GROUP_NAME_MAX_LEN + 1);
2131 zcl_group_request_data = (gpointer)req;
2135 case ZBLIB_ZCL_GROUP_OPS_VIEW_GROUP: {
2136 ZigbeeZclGroupViewGroup_t *in_req;
2137 ZigbeeZclGroupViewGroup_t *req = NULL;
2139 in_req = (ZigbeeZclGroupViewGroup_t *)request_data;
2140 if (NULL != in_req) {
2141 /* Allocate memory */
2142 req = (ZigbeeZclGroupViewGroup_t *)
2143 g_malloc0(sizeof(ZigbeeZclGroupViewGroup_t));
2146 req->node_id = in_req->node_id;
2147 req->dest_ep = in_req->dest_ep;
2150 zcl_group_request_data = (gpointer)req;
2154 case ZBLIB_ZCL_GROUP_OPS_GET_GROUP_MEMBERSHIP: {
2155 ZigbeeZclGroupGetGroupMembership_t *in_req;
2156 ZigbeeZclGroupGetGroupMembership_t *req = NULL;
2158 in_req = (ZigbeeZclGroupGetGroupMembership_t *)request_data;
2159 if (NULL != in_req) {
2160 /* Allocate memory */
2161 req = (ZigbeeZclGroupGetGroupMembership_t *)
2162 g_malloc0(sizeof(ZigbeeZclGroupGetGroupMembership_t));
2165 req->node_id = in_req->node_id;
2166 req->dest_ep = in_req->dest_ep;
2167 req->group_count = in_req->group_count;
2168 req->group_list = (gshort *)g_memdup(in_req->group_list,
2169 in_req->group_count);
2172 zcl_group_request_data = (gpointer)req;
2176 case ZBLIB_ZCL_GROUP_OPS_REMOVE_GROUP: {
2177 ZigbeeZclGroupRemoveGroup_t *in_req;
2178 ZigbeeZclGroupRemoveGroup_t *req = NULL;
2180 in_req = (ZigbeeZclGroupRemoveGroup_t *)request_data;
2181 if (NULL != in_req) {
2182 /* Allocate memory */
2183 req = (ZigbeeZclGroupRemoveGroup_t *)
2184 g_malloc0(sizeof(ZigbeeZclGroupRemoveGroup_t));
2187 req->node_id = in_req->node_id;
2188 req->dest_ep = in_req->dest_ep;
2189 req->group_id = in_req->group_id;
2192 zcl_group_request_data = (gpointer)req;
2196 case ZBLIB_ZCL_GROUP_OPS_REMOVE_ALL_GROUP: {
2197 ZigbeeZclGroupRemoveAllGroup_t *in_req;
2198 ZigbeeZclGroupRemoveAllGroup_t *req = NULL;
2200 in_req = (ZigbeeZclGroupRemoveAllGroup_t *)request_data;
2201 if (NULL != in_req) {
2202 /* Allocate memory */
2203 req = (ZigbeeZclGroupRemoveAllGroup_t *)
2204 g_malloc0(sizeof(ZigbeeZclGroupRemoveAllGroup_t));
2207 req->node_id = in_req->node_id;
2208 req->dest_ep = in_req->dest_ep;
2211 zcl_group_request_data = (gpointer)req;
2215 case ZBLIB_ZCL_GROUP_OPS_ADD_GROUP_IF_IDENTIFYING: {
2216 ZigbeeZclGroupAddGroupIfIdentifying_t *in_req;
2217 ZigbeeZclGroupAddGroupIfIdentifying_t *req = NULL;
2219 in_req = (ZigbeeZclGroupAddGroupIfIdentifying_t *)request_data;
2220 if (NULL != in_req) {
2221 /* Allocate memory */
2222 req = (ZigbeeZclGroupAddGroupIfIdentifying_t *)
2223 g_malloc0(sizeof(ZigbeeZclGroupAddGroupIfIdentifying_t));
2226 req->node_id = in_req->node_id;
2227 req->dest_ep = in_req->dest_ep;
2228 req->group_id = in_req->group_id;
2229 g_strlcpy(req->group_name,
2230 in_req->group_name, ZIGBEE_ZCL_GROUP_NAME_MAX_LEN + 1);
2233 zcl_group_request_data = (gpointer)req;
2241 return zcl_group_request_data;
2244 static gpointer __zblib_request_create_zcl_poll_control_request_data(guint request_type,
2245 gpointer request_data, guint request_data_len)
2247 gpointer zcl_poll_control_request_data = NULL;
2250 NOT_USED(request_data_len);
2253 ops_id = __zblib_request_get_ops_id(request_type);
2255 case ZBLIB_ZCL_POLL_CONTROL_OPS_CHECK_IN_RESPONSE: {
2256 ZigbeeZclPollControlCheckInResponse_t *in_req;
2257 ZigbeeZclPollControlCheckInResponse_t *req = NULL;
2259 in_req = (ZigbeeZclPollControlCheckInResponse_t *)request_data;
2260 if (NULL != in_req) {
2261 /* Allocate memory */
2262 req = (ZigbeeZclPollControlCheckInResponse_t *)
2263 g_malloc0(sizeof(ZigbeeZclPollControlCheckInResponse_t));
2266 req->node_id = in_req->node_id;
2267 req->dest_ep = in_req->dest_ep;
2268 req->start_fast_polling = in_req->start_fast_polling;
2269 req->fast_poll_timeout = in_req->fast_poll_timeout;
2272 zcl_poll_control_request_data = (gpointer)req;
2276 case ZBLIB_ZCL_POLL_CONTROL_OPS_FAST_POLL_STOP: {
2277 ZigbeeZclPollControlFastPollStop_t *in_req;
2278 ZigbeeZclPollControlFastPollStop_t *req = NULL;
2280 in_req = (ZigbeeZclPollControlFastPollStop_t *)request_data;
2281 if (NULL != in_req) {
2282 /* Allocate memory */
2283 req = (ZigbeeZclPollControlFastPollStop_t *)
2284 g_malloc0(sizeof(ZigbeeZclPollControlFastPollStop_t));
2287 req->node_id = in_req->node_id;
2288 req->dest_ep = in_req->dest_ep;
2291 zcl_poll_control_request_data = (gpointer)req;
2295 case ZBLIB_ZCL_POLL_CONTROL_OPS_SET_LONG_POLL_INTERVAL: {
2296 ZigbeeZclPollControlSetLongPollInterval_t *in_req;
2297 ZigbeeZclPollControlSetLongPollInterval_t *req = NULL;
2299 in_req = (ZigbeeZclPollControlSetLongPollInterval_t *)request_data;
2300 if (NULL != in_req) {
2301 /* Allocate memory */
2302 req = (ZigbeeZclPollControlSetLongPollInterval_t *)
2303 g_malloc0(sizeof(ZigbeeZclPollControlSetLongPollInterval_t));
2306 req->node_id = in_req->node_id;
2307 req->dest_ep = in_req->dest_ep;
2308 req->new_long_poll_interval = in_req->new_long_poll_interval;
2311 zcl_poll_control_request_data = (gpointer)req;
2315 case ZBLIB_ZCL_POLL_CONTROL_OPS_SET_SHORT_POLL_INTERVAL: {
2316 ZigbeeZclPollControlSetShortPollInterval_t *in_req;
2317 ZigbeeZclPollControlSetShortPollInterval_t *req = NULL;
2319 in_req = (ZigbeeZclPollControlSetShortPollInterval_t *)request_data;
2320 if (NULL != in_req) {
2321 /* Allocate memory */
2322 req = (ZigbeeZclPollControlSetShortPollInterval_t *)
2323 g_malloc0(sizeof(ZigbeeZclPollControlSetShortPollInterval_t));
2326 req->node_id = in_req->node_id;
2327 req->dest_ep = in_req->dest_ep;
2328 req->new_short_poll_interval = in_req->new_short_poll_interval;
2331 zcl_poll_control_request_data = (gpointer)req;
2339 return zcl_poll_control_request_data;
2342 static gpointer __zblib_request_create_zcl_scene_request_data(guint request_type,
2343 gpointer request_data, guint request_data_len)
2345 gpointer zcl_scene_request_data = NULL;
2348 NOT_USED(request_data_len);
2351 ops_id = __zblib_request_get_ops_id(request_type);
2353 case ZBLIB_ZCL_SCENE_OPS_ADD_SCENE: {
2354 ZigbeeZclSceneAddScene_t *in_req;
2355 ZigbeeZclSceneAddScene_t *req = NULL;
2357 in_req = (ZigbeeZclSceneAddScene_t *)request_data;
2358 if (NULL != in_req) {
2359 /* Allocate memory */
2360 req = (ZigbeeZclSceneAddScene_t *)
2361 g_malloc0(sizeof(ZigbeeZclSceneAddScene_t));
2364 req->node_id = in_req->node_id;
2365 req->dest_ep = in_req->dest_ep;
2366 req->group_id = in_req->group_id;
2367 req->scene_id = in_req->scene_id;
2368 req->transition_time = in_req->transition_time;
2369 g_strlcpy(req->scene_name,
2370 in_req->scene_name, ZIGBEE_ZCL_SCENE_NAME_MAX_LEN + 1);
2371 req->ext_field_set_len = in_req->ext_field_set_len;
2372 req->ext_field_set = (gshort *)g_memdup(in_req->ext_field_set,
2373 in_req->ext_field_set_len);
2376 zcl_scene_request_data = (gpointer)req;
2380 case ZBLIB_ZCL_SCENE_OPS_VIEW_SCENE: {
2381 ZigbeeZclSceneViewScene_t *in_req;
2382 ZigbeeZclSceneViewScene_t *req = NULL;
2384 in_req = (ZigbeeZclSceneViewScene_t *)request_data;
2385 if (NULL != in_req) {
2386 /* Allocate memory */
2387 req = (ZigbeeZclSceneViewScene_t *)
2388 g_malloc0(sizeof(ZigbeeZclSceneViewScene_t));
2391 req->node_id = in_req->node_id;
2392 req->dest_ep = in_req->dest_ep;
2393 req->group_id = in_req->group_id;
2394 req->scene_id = in_req->scene_id;
2397 zcl_scene_request_data = (gpointer)req;
2401 case ZBLIB_ZCL_SCENE_OPS_REMOVE_SCENE: {
2402 ZigbeeZclSceneRemoveScene_t *in_req;
2403 ZigbeeZclSceneRemoveScene_t *req = NULL;
2405 in_req = (ZigbeeZclSceneRemoveScene_t *)request_data;
2406 if (NULL != in_req) {
2407 /* Allocate memory */
2408 req = (ZigbeeZclSceneRemoveScene_t *)
2409 g_malloc0(sizeof(ZigbeeZclSceneRemoveScene_t));
2412 req->node_id = in_req->node_id;
2413 req->dest_ep = in_req->dest_ep;
2414 req->group_id = in_req->group_id;
2415 req->scene_id = in_req->scene_id;
2418 zcl_scene_request_data = (gpointer)req;
2422 case ZBLIB_ZCL_SCENE_OPS_STORE_SCENE: {
2423 ZigbeeZclSceneStoreScene_t *in_req;
2424 ZigbeeZclSceneStoreScene_t *req = NULL;
2426 in_req = (ZigbeeZclSceneStoreScene_t *)request_data;
2427 if (NULL != in_req) {
2428 /* Allocate memory */
2429 req = (ZigbeeZclSceneStoreScene_t *)
2430 g_malloc0(sizeof(ZigbeeZclSceneStoreScene_t));
2433 req->node_id = in_req->node_id;
2434 req->dest_ep = in_req->dest_ep;
2435 req->group_id = in_req->group_id;
2436 req->scene_id = in_req->scene_id;
2439 zcl_scene_request_data = (gpointer)req;
2443 case ZBLIB_ZCL_SCENE_OPS_RECALL_SCENE: {
2444 ZigbeeZclSceneRecallScene_t *in_req;
2445 ZigbeeZclSceneRecallScene_t *req = NULL;
2447 in_req = (ZigbeeZclSceneRecallScene_t *)request_data;
2448 if (NULL != in_req) {
2449 /* Allocate memory */
2450 req = (ZigbeeZclSceneRecallScene_t *)
2451 g_malloc0(sizeof(ZigbeeZclSceneRecallScene_t));
2454 req->node_id = in_req->node_id;
2455 req->dest_ep = in_req->dest_ep;
2456 req->group_id = in_req->group_id;
2457 req->scene_id = in_req->scene_id;
2460 zcl_scene_request_data = (gpointer)req;
2464 case ZBLIB_ZCL_SCENE_OPS_REMOVE_ALL_SCENE: {
2465 ZigbeeZclSceneRemoveAllScene_t *in_req;
2466 ZigbeeZclSceneRemoveAllScene_t *req = NULL;
2468 in_req = (ZigbeeZclSceneRemoveAllScene_t *)request_data;
2469 if (NULL != in_req) {
2470 /* Allocate memory */
2471 req = (ZigbeeZclSceneRemoveAllScene_t *)
2472 g_malloc0(sizeof(ZigbeeZclSceneRemoveAllScene_t));
2475 req->node_id = in_req->node_id;
2476 req->dest_ep = in_req->dest_ep;
2477 req->group_id = in_req->group_id;
2480 zcl_scene_request_data = (gpointer)req;
2484 case ZBLIB_ZCL_SCENE_OPS_GET_SCENE_MEMBERSHIP: {
2485 ZigbeeZclSceneGetSceneMembership_t *in_req;
2486 ZigbeeZclSceneGetSceneMembership_t *req = NULL;
2488 in_req = (ZigbeeZclSceneGetSceneMembership_t *)request_data;
2489 if (NULL != in_req) {
2490 /* Allocate memory */
2491 req = (ZigbeeZclSceneGetSceneMembership_t *)
2492 g_malloc0(sizeof(ZigbeeZclSceneGetSceneMembership_t));
2495 req->node_id = in_req->node_id;
2496 req->dest_ep = in_req->dest_ep;
2497 req->group_id = in_req->group_id;
2500 zcl_scene_request_data = (gpointer)req;
2508 return zcl_scene_request_data;
2511 static gpointer __zblib_request_create_zdo_dev_control_request_data(guint request_type,
2512 gpointer request_data, guint request_data_len)
2514 gpointer zdodev_control_request_data = NULL;
2517 NOT_USED(request_data_len);
2520 ops_id = __zblib_request_get_ops_id(request_type);
2522 case ZBLIB_ZDO_DEV_CONTROL_OPS_NWK_ADDR_REQ: {
2523 ZigbeeZdoDevControlNwkAddrReq_t *in_req;
2524 ZigbeeZdoDevControlNwkAddrReq_t *req = NULL;
2526 in_req = (ZigbeeZdoDevControlNwkAddrReq_t *)request_data;
2527 if (NULL != in_req) {
2528 /* Allocate memory */
2529 req = (ZigbeeZdoDevControlNwkAddrReq_t *)
2530 g_malloc0(sizeof(ZigbeeZdoDevControlNwkAddrReq_t));
2533 memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
2534 req->request_type = in_req->request_type;
2535 req->start_index = in_req->start_index;
2538 zdodev_control_request_data = (gpointer)req;
2542 case ZBLIB_ZDO_DEV_CONTROL_OPS_MATCHED_DESCRIPTOR_REQ: {
2543 ZigbeeZdoDevControlMatchedDescriptorReq_t *in_req;
2544 ZigbeeZdoDevControlMatchedDescriptorReq_t *req = NULL;
2546 in_req = (ZigbeeZdoDevControlMatchedDescriptorReq_t *)request_data;
2547 if (NULL != in_req) {
2548 /* Allocate memory */
2549 req = (ZigbeeZdoDevControlMatchedDescriptorReq_t *)
2550 g_malloc0(sizeof(ZigbeeZdoDevControlMatchedDescriptorReq_t));
2553 req->node_id = in_req->node_id;
2554 req->profile_id = in_req->profile_id;
2555 req->num_in_cl = in_req->num_in_cl;
2556 req->in_cl = g_strdup(in_req->in_cl);
2557 req->num_out_cl = in_req->num_out_cl;
2558 req->out_cl = g_strdup(in_req->out_cl);
2561 zdodev_control_request_data = (gpointer)req;
2565 case ZBLIB_ZDO_DEV_CONTROL_OPS_IEEE_ADDR_REQ: {
2566 ZigbeeZdoDevControlIeeeAddrReq_t *in_req;
2567 ZigbeeZdoDevControlIeeeAddrReq_t *req = NULL;
2569 in_req = (ZigbeeZdoDevControlIeeeAddrReq_t *)request_data;
2570 if (NULL != in_req) {
2571 /* Allocate memory */
2572 req = (ZigbeeZdoDevControlIeeeAddrReq_t *)
2573 g_malloc0(sizeof(ZigbeeZdoDevControlIeeeAddrReq_t));
2576 req->node_id = in_req->node_id;
2579 zdodev_control_request_data = (gpointer)req;
2583 case ZBLIB_ZDO_DEV_CONTROL_OPS_ACTIVE_EP_REQ: {
2584 ZigbeeZdoDevControlActiveEpReq_t *in_req;
2585 ZigbeeZdoDevControlActiveEpReq_t *req = NULL;
2587 in_req = (ZigbeeZdoDevControlActiveEpReq_t *)request_data;
2588 if (NULL != in_req) {
2589 /* Allocate memory */
2590 req = (ZigbeeZdoDevControlActiveEpReq_t *)
2591 g_malloc0(sizeof(ZigbeeZdoDevControlActiveEpReq_t));
2594 req->node_id = in_req->node_id;
2597 zdodev_control_request_data = (gpointer)req;
2601 case ZBLIB_ZDO_DEV_CONTROL_OPS_NODE_DESC_REQ: {
2602 ZigbeeZdoDevControlNodeDescriptorReq_t *in_req;
2603 ZigbeeZdoDevControlNodeDescriptorReq_t *req = NULL;
2605 in_req = (ZigbeeZdoDevControlNodeDescriptorReq_t *)request_data;
2606 if (NULL != in_req) {
2607 /* Allocate memory */
2608 req = (ZigbeeZdoDevControlNodeDescriptorReq_t *)
2609 g_malloc0(sizeof(ZigbeeZdoDevControlNodeDescriptorReq_t));
2612 req->node_id = in_req->node_id;
2615 zdodev_control_request_data = (gpointer)req;
2619 case ZBLIB_ZDO_DEV_CONTROL_OPS_POWER_DESC_REQ: {
2620 ZigbeeZdoDevControlPowerDescriptorReq_t *in_req;
2621 ZigbeeZdoDevControlPowerDescriptorReq_t *req = NULL;
2623 in_req = (ZigbeeZdoDevControlPowerDescriptorReq_t *)request_data;
2624 if (NULL != in_req) {
2625 /* Allocate memory */
2626 req = (ZigbeeZdoDevControlPowerDescriptorReq_t *)
2627 g_malloc0(sizeof(ZigbeeZdoDevControlPowerDescriptorReq_t));
2630 req->node_id = in_req->node_id;
2633 zdodev_control_request_data = (gpointer)req;
2637 case ZBLIB_ZDO_DEV_CONTROL_OPS_COMPLEX_DESC_REQ: {
2638 ZigbeeZdoDevControlComplexDescriptorReq_t *in_req;
2639 ZigbeeZdoDevControlComplexDescriptorReq_t *req = NULL;
2641 in_req = (ZigbeeZdoDevControlComplexDescriptorReq_t *)request_data;
2642 if (NULL != in_req) {
2643 /* Allocate memory */
2644 req = (ZigbeeZdoDevControlComplexDescriptorReq_t *)
2645 g_malloc0(sizeof(ZigbeeZdoDevControlComplexDescriptorReq_t));
2648 req->node_id = in_req->node_id;
2651 zdodev_control_request_data = (gpointer)req;
2655 case ZBLIB_ZDO_DEV_CONTROL_OPS_USER_DESC_REQ: {
2656 ZigbeeZdoDevControlUserDescriptorReq_t *in_req;
2657 ZigbeeZdoDevControlUserDescriptorReq_t *req = NULL;
2659 in_req = (ZigbeeZdoDevControlUserDescriptorReq_t *)request_data;
2660 if (NULL != in_req) {
2661 /* Allocate memory */
2662 req = (ZigbeeZdoDevControlUserDescriptorReq_t *)
2663 g_malloc0(sizeof(ZigbeeZdoDevControlUserDescriptorReq_t));
2666 req->node_id = in_req->node_id;
2669 zdodev_control_request_data = (gpointer)req;
2673 case ZBLIB_ZDO_DEV_CONTROL_OPS_USER_DESC_SET_REQ: {
2674 ZigbeeZdoDevControlUserDescriptorSetReq_t *in_req;
2675 ZigbeeZdoDevControlUserDescriptorSetReq_t *req = NULL;
2677 in_req = (ZigbeeZdoDevControlUserDescriptorSetReq_t *)request_data;
2678 if (NULL != in_req) {
2679 /* Allocate memory */
2680 req = (ZigbeeZdoDevControlUserDescriptorSetReq_t *)
2681 g_malloc0(sizeof(ZigbeeZdoDevControlUserDescriptorSetReq_t));
2684 req->node_id = in_req->node_id;
2685 req->user_descriptor_len = in_req->user_descriptor_len;
2686 memcpy(req->user_descriptor,
2687 in_req->user_descriptor, in_req->user_descriptor_len);
2690 zdodev_control_request_data = (gpointer)req;
2694 case ZBLIB_ZDO_DEV_CONTROL_OPS_DEVICE_ANNOUNCE: {
2695 ZigbeeZdoDevControlDeviceAnnounce_t *in_req;
2696 ZigbeeZdoDevControlDeviceAnnounce_t *req = NULL;
2698 in_req = (ZigbeeZdoDevControlDeviceAnnounce_t *)request_data;
2699 if (NULL != in_req) {
2700 /* Allocate memory */
2701 req = (ZigbeeZdoDevControlDeviceAnnounce_t *)
2702 g_malloc0(sizeof(ZigbeeZdoDevControlDeviceAnnounce_t));
2705 req->node_id = in_req->node_id;
2706 memcpy(req->mac_addr, in_req->mac_addr, ZIGBEE_EUI64_SIZE);
2707 req->capability = in_req->capability;
2710 zdodev_control_request_data = (gpointer)req;
2714 case ZBLIB_ZDO_DEV_CONTROL_OPS_SIMPLE_DESC_REQ: {
2715 ZigbeeZdoDevControlSimpleDescriptorReq_t *in_req;
2716 ZigbeeZdoDevControlSimpleDescriptorReq_t *req = NULL;
2718 in_req = (ZigbeeZdoDevControlSimpleDescriptorReq_t *)request_data;
2719 if (NULL != in_req) {
2720 /* Allocate memory */
2721 req = (ZigbeeZdoDevControlSimpleDescriptorReq_t *)
2722 g_malloc0(sizeof(ZigbeeZdoDevControlSimpleDescriptorReq_t));
2725 req->node_id = in_req->node_id;
2726 req->endpoint = in_req->endpoint;
2729 zdodev_control_request_data = (gpointer)req;
2733 case ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_LQI_REQ: {
2734 ZigbeeZdoDevControlMgmtLqiReq_t *in_req;
2735 ZigbeeZdoDevControlMgmtLqiReq_t *req = NULL;
2737 in_req = (ZigbeeZdoDevControlMgmtLqiReq_t *)request_data;
2738 if (NULL != in_req) {
2739 /* Allocate memory */
2740 req = (ZigbeeZdoDevControlMgmtLqiReq_t *)
2741 g_malloc0(sizeof(ZigbeeZdoDevControlMgmtLqiReq_t));
2744 req->node_id = in_req->node_id;
2745 req->start_index = in_req->start_index;
2748 zdodev_control_request_data = (gpointer)req;
2752 case ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_RTG_REQ: {
2753 ZigbeeZdoDevControlMgmtRtgReq_t *in_req;
2754 ZigbeeZdoDevControlMgmtRtgReq_t *req = NULL;
2756 in_req = (ZigbeeZdoDevControlMgmtRtgReq_t *)request_data;
2757 if (NULL != in_req) {
2758 /* Allocate memory */
2759 req = (ZigbeeZdoDevControlMgmtRtgReq_t *)
2760 g_malloc0(sizeof(ZigbeeZdoDevControlMgmtRtgReq_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_BIND_REQ: {
2772 ZigbeeZdoDevControlMgmtBindReq_t *in_req;
2773 ZigbeeZdoDevControlMgmtBindReq_t *req = NULL;
2775 in_req = (ZigbeeZdoDevControlMgmtBindReq_t *)request_data;
2776 if (NULL != in_req) {
2777 /* Allocate memory */
2778 req = (ZigbeeZdoDevControlMgmtBindReq_t *)
2779 g_malloc0(sizeof(ZigbeeZdoDevControlMgmtBindReq_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_PERMIT_JOIN_REQ: {
2791 ZigbeeZdoDevControlMgmtPermitJoinReq_t *in_req;
2792 ZigbeeZdoDevControlMgmtPermitJoinReq_t *req = NULL;
2794 in_req = (ZigbeeZdoDevControlMgmtPermitJoinReq_t *)request_data;
2795 if (NULL != in_req) {
2796 /* Allocate memory */
2797 req = (ZigbeeZdoDevControlMgmtPermitJoinReq_t *)
2798 g_malloc0(sizeof(ZigbeeZdoDevControlMgmtPermitJoinReq_t));
2801 req->addr = in_req->addr;
2802 req->duration = in_req->duration;
2803 req->tc_significance = in_req->tc_significance;
2806 zdodev_control_request_data = (gpointer)req;
2810 case ZBLIB_ZDO_DEV_CONTROL_OPS_NWK_UPDATE_REQ: {
2811 ZigbeeZdoDevControlNwkUpdateReq_t *in_req;
2812 ZigbeeZdoDevControlNwkUpdateReq_t *req = NULL;
2814 in_req = (ZigbeeZdoDevControlNwkUpdateReq_t *)request_data;
2815 if (NULL != in_req) {
2816 /* Allocate memory */
2817 req = (ZigbeeZdoDevControlNwkUpdateReq_t *)
2818 g_malloc0(sizeof(ZigbeeZdoDevControlNwkUpdateReq_t));
2821 req->node_id = in_req->node_id;
2822 req->scan_channel = in_req->scan_channel;
2823 req->scan_duration = in_req->scan_duration;
2824 req->scan_count = in_req->scan_count;
2825 req->network_update_id = in_req->network_update_id;
2828 zdodev_control_request_data = (gpointer)req;
2832 case ZBLIB_ZDO_DEV_CONTROL_OPS_NWK_DISC_REQ: {
2833 ZigbeeZdoDevControlNwkDescriptorReq_t *in_req;
2834 ZigbeeZdoDevControlNwkDescriptorReq_t *req = NULL;
2836 in_req = (ZigbeeZdoDevControlNwkDescriptorReq_t *)request_data;
2837 if (NULL != in_req) {
2838 /* Allocate memory */
2839 req = (ZigbeeZdoDevControlNwkDescriptorReq_t *)
2840 g_malloc0(sizeof(ZigbeeZdoDevControlNwkDescriptorReq_t));
2843 req->node_id = in_req->node_id;
2844 req->scan_channel = in_req->scan_channel;
2845 req->scan_duration = in_req->scan_duration;
2846 req->scan_count = in_req->scan_count;
2847 req->start_index = in_req->start_index;
2850 zdodev_control_request_data = (gpointer)req;
2858 return zdodev_control_request_data;
2861 static gpointer __zblib_request_create_zdo_bind_request_data(guint request_type,
2862 gpointer request_data, guint request_data_len)
2864 gpointer zdo_bind_request_data = NULL;
2867 NOT_USED(request_data_len);
2870 ops_id = __zblib_request_get_ops_id(request_type);
2872 case ZBLIB_ZDO_BIND_OPS_BIND_REQ: {
2873 ZigbeeZdoBindBindReq_t *in_req;
2874 ZigbeeZdoBindBindReq_t *req = NULL;
2876 in_req = (ZigbeeZdoBindBindReq_t *)request_data;
2877 if (NULL != in_req) {
2878 /* Allocate memory */
2879 req = (ZigbeeZdoBindBindReq_t *)
2880 g_malloc0(sizeof(ZigbeeZdoBindBindReq_t));
2883 req->node_id = in_req->node_id;
2884 g_strlcpy(req->src_addr,
2885 in_req->src_addr, ZIGBEE_ZDO_BIND_ADDRESS_MAX_LEN + 1);
2886 req->src_ep = in_req->src_ep;
2887 req->cluster_id = in_req->cluster_id;
2888 g_strlcpy(req->dst_addr,
2889 in_req->dst_addr, ZIGBEE_ZDO_BIND_ADDRESS_MAX_LEN + 1);
2890 req->bind_type = in_req->bind_type;
2891 req->group_addr = in_req->group_addr;
2892 req->dst_ep = in_req->dst_ep;
2895 zdo_bind_request_data = (gpointer)req;
2899 case ZBLIB_ZDO_BIND_OPS_UNBIND_REQ: {
2900 ZigbeeZdoBindUnbindReq_t *in_req;
2901 ZigbeeZdoBindUnbindReq_t *req = NULL;
2903 in_req = (ZigbeeZdoBindUnbindReq_t *)request_data;
2904 if (NULL != in_req) {
2905 /* Allocate memory */
2906 req = (ZigbeeZdoBindUnbindReq_t *)
2907 g_malloc0(sizeof(ZigbeeZdoBindUnbindReq_t));
2910 req->node_id = in_req->node_id;
2911 g_strlcpy(req->src_addr,
2912 in_req->src_addr, ZIGBEE_ZDO_BIND_ADDRESS_MAX_LEN + 1);
2913 req->src_ep = in_req->src_ep;
2914 req->cluster_id = in_req->cluster_id;
2915 g_strlcpy(req->dst_addr,
2916 in_req->dst_addr, ZIGBEE_ZDO_BIND_ADDRESS_MAX_LEN + 1);
2917 req->bind_type = in_req->bind_type;
2918 req->group_addr = in_req->group_addr;
2919 req->dst_ep = in_req->dst_ep;
2922 zdo_bind_request_data = (gpointer)req;
2930 return zdo_bind_request_data;
2934 static gpointer __zblib_request_create_request_data(guint request_type,
2935 gpointer request_data, guint request_data_len)
2937 gpointer _request_data = NULL;
2938 ZblibDriverType_e driver_type;
2940 /* Fetch driver type */
2941 driver_type = __zblib_request_get_driver_type(request_type);
2942 switch (driver_type) {
2943 case ZBLIB_DRIVER_TYPE_ZCL_ALARM: {
2944 _request_data = __zblib_request_create_zcl_alarm_request_data(request_type,
2945 request_data, request_data_len);
2949 case ZBLIB_DRIVER_TYPE_CUSTOM: {
2950 _request_data = __zblib_request_create_custom_request_data(request_type,
2951 request_data, request_data_len);
2955 case ZBLIB_DRIVER_TYPE_ZCL_DOOR_LOCK: {
2956 _request_data = __zblib_request_create_zcl_door_lock_request_data(request_type,
2957 request_data, request_data_len);
2961 case ZBLIB_DRIVER_TYPE_ZCL_FAN_CONTROL: {
2962 _request_data = __zblib_request_create_zcl_fan_control_request_data(request_type,
2963 request_data, request_data_len);
2967 case ZBLIB_DRIVER_TYPE_ZCL_LEVEL_CONTROL: {
2968 _request_data = __zblib_request_create_zcl_level_control_request_data(request_type,
2969 request_data, request_data_len);
2973 case ZBLIB_DRIVER_TYPE_MFGLIB_CONTROL: {
2974 _request_data = __zblib_request_create_mfglib_control_request_data(request_type,
2975 request_data, request_data_len);
2979 case ZBLIB_DRIVER_TYPE_ZCL_ON_OFF: {
2980 _request_data = __zblib_request_create_zcl_on_off_request_data(request_type,
2981 request_data, request_data_len);
2985 case ZBLIB_DRIVER_TYPE_SERVICE: {
2986 _request_data = __zblib_request_create_service_request_data(request_type,
2987 request_data, request_data_len);
2991 case ZBLIB_DRIVER_TYPE_ZCL_THERMOSTAT: {
2992 _request_data = __zblib_request_create_zcl_thermostat_request_data(request_type,
2993 request_data, request_data_len);
2997 case ZBLIB_DRIVER_TYPE_ZCL_BASIC: {
2998 _request_data = __zblib_request_create_zcl_basic_request_data(request_type,
2999 request_data, request_data_len);
3003 case ZBLIB_DRIVER_TYPE_ZCL_GLOBAL_CONTROL: {
3004 _request_data = __zblib_request_create_zcl_global_control_request_data(request_type,
3005 request_data, request_data_len);
3009 case ZBLIB_DRIVER_TYPE_ZCL_IAS_ZONE: {
3010 _request_data = __zblib_request_create_zcl_ias_zone_request_data(request_type,
3011 request_data, request_data_len);
3015 case ZBLIB_DRIVER_TYPE_ZCL_IDENTIFY: {
3016 _request_data = __zblib_request_create_zcl_identify_request_data(request_type,
3017 request_data, request_data_len);
3021 case ZBLIB_DRIVER_TYPE_ZCL_COLOR_CONTROL: {
3022 _request_data = __zblib_request_create_zcl_color_control_request_data(request_type,
3023 request_data, request_data_len);
3027 case ZBLIB_DRIVER_TYPE_ZCL_GROUP: {
3028 _request_data = __zblib_request_create_zcl_group_request_data(request_type,
3029 request_data, request_data_len);
3033 case ZBLIB_DRIVER_TYPE_ZCL_POLL_CONTROL: {
3034 _request_data = __zblib_request_create_zcl_poll_control_request_data(request_type,
3035 request_data, request_data_len);
3039 case ZBLIB_DRIVER_TYPE_ZCL_SCENE: {
3040 _request_data = __zblib_request_create_zcl_scene_request_data(request_type,
3041 request_data, request_data_len);
3045 case ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL: {
3046 _request_data = __zblib_request_create_zdo_dev_control_request_data(request_type,
3047 request_data, request_data_len);
3051 case ZBLIB_DRIVER_TYPE_ZDO_BIND: {
3052 _request_data = __zblib_request_create_zdo_bind_request_data(request_type,
3053 request_data, request_data_len);
3057 case ZBLIB_DRIVER_TYPE_NONE: /* Fall through */
3059 Z_LOGE("Unhandled driver type: [%d]", driver_type);
3064 return _request_data;
3067 static void __zblib_request_free_zcl_alarm_request_data(ZigBeeRequest *request,
3073 ops_id = __zblib_request_get_ops_id(request_type);
3075 case ZBLIB_ZCL_ALARM_OPS_GET_ALARM_COUNT: {
3076 ZigbeeZclAlarmGetAlarmCount_t *req = NULL;
3078 req = (ZigbeeZclAlarmGetAlarmCount_t *)request->request_data;
3085 case ZBLIB_ZCL_ALARM_OPS_RESET_ALARM: {
3086 ZigbeeZclAlarmResetAlarm_t *req = NULL;
3088 req = (ZigbeeZclAlarmResetAlarm_t *)request->request_data;
3095 case ZBLIB_ZCL_ALARM_OPS_RESET_ALL_ALARM: {
3096 ZigbeeZclAlarmResetAllAlarm_t *req = NULL;
3098 req = (ZigbeeZclAlarmResetAllAlarm_t *)request->request_data;
3105 case ZBLIB_ZCL_ALARM_OPS_ALARM: {
3106 ZigbeeZclAlarmAlarm_t *req = NULL;
3108 req = (ZigbeeZclAlarmAlarm_t *)request->request_data;
3115 case ZBLIB_ZCL_ALARM_OPS_RESET_ALARM_LOG: {
3116 ZigbeeZclAlarmResetAlarmLogs_t *req = NULL;
3118 req = (ZigbeeZclAlarmResetAlarmLogs_t *)request->request_data;
3125 case ZBLIB_ZCL_ALARM_OPS_GET_ALARM: {
3134 static void __zblib_request_free_custom_request_data(ZigBeeRequest *request,
3140 ops_id = __zblib_request_get_ops_id(request_type);
3142 case ZBLIB_CUSTOM_OPS_APS_SEND: {
3143 ZigbeeCustomApsSend_t *req = NULL;
3145 req = (ZigbeeCustomApsSend_t *)request->request_data;
3152 case ZBLIB_CUSTOM_OPS_ZCL_SEND: {
3153 ZigbeeCustomZclSend_t *req = NULL;
3155 req = (ZigbeeCustomZclSend_t *)request->request_data;
3162 case ZBLIB_CUSTOM_OPS_SEND_TO_LOCAL: {
3163 ZigbeeCustomSendToLocal_t *req = NULL;
3165 req = (ZigbeeCustomSendToLocal_t *)request->request_data;
3177 static void __zblib_request_free_zcl_door_lock_request_data(ZigBeeRequest *request,
3183 ops_id = __zblib_request_get_ops_id(request_type);
3185 case ZBLIB_ZCL_DOOR_LOCK_OPS_SUBSCRIBE_LOCK_EVENT: {
3186 ZigbeeZclDoorLockSubscriberLockEvent_t *req = NULL;
3188 req = (ZigbeeZclDoorLockSubscriberLockEvent_t *)request->request_data;
3195 case ZBLIB_ZCL_DOOR_LOCK_OPS_SET_DOOR_LOCK_PIN: {
3196 ZigbeeZclDoorLockSetDoorLockPin_t *req = NULL;
3198 req = (ZigbeeZclDoorLockSetDoorLockPin_t *)request->request_data;
3205 case ZBLIB_ZCL_DOOR_LOCK_OPS_SET_DOOR_LOCK: {
3206 ZigbeeZclDoorLockSetDoorLock_t *req = NULL;
3208 req = (ZigbeeZclDoorLockSetDoorLock_t *)request->request_data;
3215 case ZBLIB_ZCL_DOOR_LOCK_OPS_GET_LOCK_STATE: {
3216 ZigbeeZclDoorLockGetDoorLock_t *req = NULL;
3218 req = (ZigbeeZclDoorLockGetDoorLock_t *)request->request_data;
3230 static void __zblib_request_free_zcl_fan_control_request_data(ZigBeeRequest *request,
3236 ops_id = __zblib_request_get_ops_id(request_type);
3238 case ZBLIB_ZCL_FAN_CONTROL_OPS_SET_FAN_MODE: {
3239 ZigbeeZclFanControlSetFanMode_t *req = NULL;
3241 req = (ZigbeeZclFanControlSetFanMode_t *)request->request_data;
3248 case ZBLIB_ZCL_FAN_CONTROL_OPS_GET_FAN_MODE: {
3249 ZigbeeZclFanControlGetFanMode_t *req = NULL;
3251 req = (ZigbeeZclFanControlGetFanMode_t *)request->request_data;
3258 case ZBLIB_ZCL_FAN_CONTROL_OPS_SET_FAN_MODE_SEQUENCE: {
3259 ZigbeeZclFanControlSetFanModeSequence_t *req = NULL;
3261 req = (ZigbeeZclFanControlSetFanModeSequence_t *)request->request_data;
3268 case ZBLIB_ZCL_FAN_CONTROL_OPS_GET_FAN_MODE_SEQUENCE: {
3269 ZigbeeZclFanControlGetFanModeSequence_t *req = NULL;
3271 req = (ZigbeeZclFanControlGetFanModeSequence_t *)request->request_data;
3283 static void __zblib_request_free_zcl_level_control_request_data(ZigBeeRequest *request,
3289 ops_id = __zblib_request_get_ops_id(request_type);
3291 case ZBLIB_ZCL_LEVEL_CONTROL_OPS_MOVE_TO_LEVEL: {
3292 ZigbeeZclLevelControlMoveToLevel_t *req = NULL;
3294 req = (ZigbeeZclLevelControlMoveToLevel_t *)request->request_data;
3301 case ZBLIB_ZCL_LEVEL_CONTROL_OPS_MOVE: {
3302 ZigbeeZclLevelControlMove_t *req = NULL;
3304 req = (ZigbeeZclLevelControlMove_t *)request->request_data;
3311 case ZBLIB_ZCL_LEVEL_CONTROL_OPS_STEP: {
3312 ZigbeeZclLevelControlStep_t *req = NULL;
3314 req = (ZigbeeZclLevelControlStep_t *)request->request_data;
3321 case ZBLIB_ZCL_LEVEL_CONTROL_OPS_MOVE_TO_LEVEL_WITH_ON_OFF: {
3322 ZigbeeZclLevelControlMoveToLevelWithOnOff_t *req = NULL;
3324 req = (ZigbeeZclLevelControlMoveToLevelWithOnOff_t *)request->request_data;
3331 case ZBLIB_ZCL_LEVEL_CONTROL_OPS_MOVE_WITH_ON_OFF: {
3332 ZigbeeZclLevelControlMoveWithOnOff_t *req = NULL;
3334 req = (ZigbeeZclLevelControlMoveWithOnOff_t *)request->request_data;
3341 case ZBLIB_ZCL_LEVEL_CONTROL_OPS_STEP_WITH_ON_OFF: {
3342 ZigbeeZclLevelControlStepWithOnOff_t *req = NULL;
3344 req = (ZigbeeZclLevelControlStepWithOnOff_t *)request->request_data;
3351 case ZBLIB_ZCL_LEVEL_CONTROL_OPS_STOP: {
3352 ZigbeeZclLevelControlStop_t *req = NULL;
3354 req = (ZigbeeZclLevelControlStop_t *)request->request_data;
3366 static void __zblib_request_free_mfglib_control_request_data(ZigBeeRequest *request,
3372 ops_id = __zblib_request_get_ops_id(request_type);
3374 case ZBLIB_MFGLIB_CONTROL_OPS_START: {
3375 ZigbeeMfglibControlStart_t *req = NULL;
3377 req = (ZigbeeMfglibControlStart_t *)request->request_data;
3384 case ZBLIB_MFGLIB_CONTROL_OPS_END: {
3385 ZigbeeMfglibControlEnd_t *req = NULL;
3387 req = (ZigbeeMfglibControlEnd_t *)request->request_data;
3394 case ZBLIB_MFGLIB_CONTROL_OPS_START_TONE: {
3395 ZigbeeMfglibControlStartTone_t *req = NULL;
3397 req = (ZigbeeMfglibControlStartTone_t *)request->request_data;
3404 case ZBLIB_MFGLIB_CONTROL_OPS_STOP_TONE: {
3405 ZigbeeMfglibControlStopTone_t *req = NULL;
3407 req = (ZigbeeMfglibControlStopTone_t *)request->request_data;
3414 case ZBLIB_MFGLIB_CONTROL_OPS_START_STREAM: {
3415 ZigbeeMfglibControlStartStream_t *req = NULL;
3417 req = (ZigbeeMfglibControlStartStream_t *)request->request_data;
3424 case ZBLIB_MFGLIB_CONTROL_OPS_STOP_STREAM: {
3425 ZigbeeMfglibControlStopStream_t *req = NULL;
3427 req = (ZigbeeMfglibControlStopStream_t *)request->request_data;
3434 case ZBLIB_MFGLIB_CONTROL_OPS_SEND_PACKET: {
3435 ZigbeeMfglibControlSendPacket_t *req = NULL;
3437 req = (ZigbeeMfglibControlSendPacket_t *)request->request_data;
3444 case ZBLIB_MFGLIB_CONTROL_OPS_SET_CHANNEL: {
3445 ZigbeeMfglibControlSetChannel_t *req = NULL;
3447 req = (ZigbeeMfglibControlSetChannel_t *)request->request_data;
3454 case ZBLIB_MFGLIB_CONTROL_OPS_GET_CHANNEL: {
3455 ZigbeeMfglibControlGetChannel_t *req = NULL;
3457 req = (ZigbeeMfglibControlGetChannel_t *)request->request_data;
3464 case ZBLIB_MFGLIB_CONTROL_OPS_SET_POWER: {
3465 ZigbeeMfglibControlSetPower_t *req = NULL;
3467 req = (ZigbeeMfglibControlSetPower_t *)request->request_data;
3474 case ZBLIB_MFGLIB_CONTROL_OPS_GET_POWER: {
3475 ZigbeeMfglibControlGetPower_t *req = NULL;
3477 req = (ZigbeeMfglibControlGetPower_t *)request->request_data;
3484 case ZBLIB_MFGLIB_CONTROL_OPS_SET_SYNOFFSET: {
3485 ZigbeeMfglibControlSetSynOffset_t *req = NULL;
3487 req = (ZigbeeMfglibControlSetSynOffset_t *)request->request_data;
3494 case ZBLIB_MFGLIB_CONTROL_OPS_GET_SYNOFFSET: {
3495 ZigbeeMfglibControlGetSynOffset_t *req = NULL;
3497 req = (ZigbeeMfglibControlGetSynOffset_t *)request->request_data;
3504 case ZBLIB_MFGLIB_CONTROL_OPS_RX_START: {
3505 ZigbeeMfglibControlRxStart_t *req = NULL;
3507 req = (ZigbeeMfglibControlRxStart_t *)request->request_data;
3514 case ZBLIB_MFGLIB_CONTROL_OPS_RX_STOP: {
3515 ZigbeeMfglibControlRxStop_t *req = NULL;
3517 req = (ZigbeeMfglibControlRxStop_t *)request->request_data;
3524 case ZBLIB_MFGLIB_CONTROL_OPS_RX_VERIFY: {
3525 ZigbeeMfglibControlRxVerify_t *req = NULL;
3527 req = (ZigbeeMfglibControlRxVerify_t *)request->request_data;
3534 case ZBLIB_MFGLIB_CONTROL_OPS_GET_RSSI: {
3535 ZigbeeMfglibControlGetRssi_t *req = NULL;
3537 req = (ZigbeeMfglibControlGetRssi_t *)request->request_data;
3549 static void __zblib_request_free_zcl_on_off_request_data(ZigBeeRequest *request,
3555 ops_id = __zblib_request_get_ops_id(request_type);
3557 case ZBLIB_ZCL_ON_OFF_OPS_SET_ON_OFF: {
3558 ZigbeeZclOnOffSetOnOff_t *req = NULL;
3560 req = (ZigbeeZclOnOffSetOnOff_t *)request->request_data;
3567 case ZBLIB_ZCL_ON_OFF_OPS_GET_ON_OFF_STATE: {
3568 ZigbeeZclOnOffGetOnOffState_t *req = NULL;
3570 req = (ZigbeeZclOnOffGetOnOffState_t *)request->request_data;
3582 static void __zblib_request_free_service_request_data(ZigBeeRequest *request,
3588 ops_id = __zblib_request_get_ops_id(request_type);
3590 case ZBLIB_SERVICE_OPS_ENABLE: {
3594 case ZBLIB_SERVICE_OPS_DISABLE: {
3598 case ZBLIB_SERVICE_OPS_ZB_HW_RESET: {
3602 case ZBLIB_SERVICE_OPS_FORM_NETWORK: {
3606 case ZBLIB_SERVICE_OPS_COEX_START: {
3607 ZigbeeServiceCoexStart_t *req = NULL;
3609 req = (ZigbeeServiceCoexStart_t *)request->request_data;
3616 case ZBLIB_SERVICE_OPS_COEX_STOP: {
3620 case ZBLIB_SERVICE_OPS_LEAVE_NETWORK: {
3624 case ZBLIB_SERVICE_OPS_GET_NETWORK_INFO: {
3628 case ZBLIB_SERVICE_OPS_PERMIT_JOIN: {
3629 ZigbeeServicePermitJoin_t *req = NULL;
3631 req = (ZigbeeServicePermitJoin_t *)request->request_data;
3638 case ZBLIB_SERVICE_OPS_LEAVE_REQUEST: {
3639 ZigbeeServiceLeaveRequest_t *req = NULL;
3641 req = (ZigbeeServiceLeaveRequest_t *)request->request_data;
3648 case ZBLIB_SERVICE_OPS_GET_DEVICE_LIST: {
3652 case ZBLIB_SERVICE_OPS_GET_MAC: {
3656 case ZBLIB_SERVICE_OPS_GET_DEVICE_INFO: {
3660 case ZBLIB_SERVICE_OPS_GET_ENDPOINT_LIST: {
3661 ZigbeeServiceGetEndpointList_t *req = NULL;
3663 req = (ZigbeeServiceGetEndpointList_t *)request->request_data;
3670 case ZBLIB_SERVICE_OPS_GET_CLUSTER_LIST: {
3671 ZigbeeServiceGetClusterList_t *req = NULL;
3673 req = (ZigbeeServiceGetClusterList_t *)request->request_data;
3680 case ZBLIB_SERVICE_OPS_GET_NODE_TYPE: {
3681 ZigbeeServiceGetNodeType_t *req = NULL;
3683 req = (ZigbeeServiceGetNodeType_t *)request->request_data;
3695 static void __zblib_request_free_zcl_thermostat_request_data(ZigBeeRequest *request,
3701 ops_id = __zblib_request_get_ops_id(request_type);
3703 case ZBLIB_ZCL_THERMOSTAT_OPS_GET_LOCAL_TEMP: {
3704 ZigbeeZclThermostatGetLocalTemp_t *req = NULL;
3706 req = (ZigbeeZclThermostatGetLocalTemp_t *)request->request_data;
3713 case ZBLIB_ZCL_THERMOSTAT_OPS_GET_WEEKLY_SCHEDULE: {
3714 ZigbeeZclThermostatGetWeeklySchedule_t *req = NULL;
3716 req = (ZigbeeZclThermostatGetWeeklySchedule_t *)request->request_data;
3723 case ZBLIB_ZCL_THERMOSTAT_OPS_SET_WEEKLY_SCHEDULE: {
3724 ZigbeeZclThermostatSetWeeklySchedule_t *req = NULL;
3726 req = (ZigbeeZclThermostatSetWeeklySchedule_t *)request->request_data;
3733 case ZBLIB_ZCL_THERMOSTAT_OPS_CLEAR_WEEKLY_SCHEDULE: {
3734 ZigbeeZclThermostatClearWeeklySchedule_t *req = NULL;
3736 req = (ZigbeeZclThermostatClearWeeklySchedule_t *)request->request_data;
3743 case ZBLIB_ZCL_THERMOSTAT_OPS_SETPOINT_RAISE_LOWER: {
3744 ZigbeeZclThermostatSetpointRaiseLower_t *req = NULL;
3746 req = (ZigbeeZclThermostatSetpointRaiseLower_t *)request->request_data;
3758 static void __zblib_request_free_zcl_basic_request_data(ZigBeeRequest *request,
3764 ops_id = __zblib_request_get_ops_id(request_type);
3766 case ZBLIB_ZCL_BASIC_OPS_RESET_FACTORY_DEFAULT: {
3767 ZigbeeZclBasicResetFactoryDefault_t *req = NULL;
3769 req = (ZigbeeZclBasicResetFactoryDefault_t *)request->request_data;
3781 static void __zblib_request_free_zcl_global_control_request_data(ZigBeeRequest *request,
3787 ops_id = __zblib_request_get_ops_id(request_type);
3789 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_READ_ATTRIBUTES_REQ: {
3790 ZigbeeZclGlobalControlReadAttributesRequest_t *req = NULL;
3792 req = (ZigbeeZclGlobalControlReadAttributesRequest_t *)request->request_data;
3794 g_free(req->attribute_id);
3800 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_REQ: {
3801 ZigbeeZclGlobalControlWriteAttributesRequest_t *req = NULL;
3803 req = (ZigbeeZclGlobalControlWriteAttributesRequest_t *)request->request_data;
3805 g_free(req->write_records);
3811 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_UNDIVIDED_REQ: {
3812 ZigbeeZclGlobalControlWriteAttributesUndividedRequest_t *req = NULL;
3814 req = (ZigbeeZclGlobalControlWriteAttributesUndividedRequest_t *)request->request_data;
3816 g_free(req->write_records);
3822 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_NO_RESP: {
3823 ZigbeeZclGlobalControlWriteAttributesNoResponse_t *req = NULL;
3825 req = (ZigbeeZclGlobalControlWriteAttributesNoResponse_t *)request->request_data;
3827 g_free(req->write_records);
3833 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_STRUCTURED: {
3834 ZigbeeZclGlobalControlWriteAttributesStructed_t *req = NULL;
3836 req = (ZigbeeZclGlobalControlWriteAttributesStructed_t *)request->request_data;
3838 g_free(req->write_records);
3844 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_READ_ATTRIBUTES_STRUCTURED: {
3845 ZigbeeZclGlobalControlReadAttributesStructed_t *req = NULL;
3847 req = (ZigbeeZclGlobalControlReadAttributesStructed_t *)request->request_data;
3849 g_free(req->read_records);
3855 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_CONFIGURE_REPORTING_REQ: {
3856 ZigbeeZclGlobalControlConfigureReportingReq_t *req = NULL;
3858 req = (ZigbeeZclGlobalControlConfigureReportingReq_t *)request->request_data;
3860 g_free(req->read_records);
3866 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_READ_CONFIGURE_REPORTING: {
3867 ZigbeeZclGlobalControlReadConfigureReporting_t *req = NULL;
3869 req = (ZigbeeZclGlobalControlReadConfigureReporting_t *)request->request_data;
3871 g_free(req->read_records);
3877 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_DISCOVER_ATTRIBUTES: {
3878 ZigbeeZclGlobalControlDiscoverAttributes_t *req = NULL;
3880 req = (ZigbeeZclGlobalControlDiscoverAttributes_t *)request->request_data;
3887 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_DISCOVER_ATTRIBUTES_EXTENDED: {
3888 ZigbeeZclGlobalControlDiscoverAttributesExtended_t *req = NULL;
3890 req = (ZigbeeZclGlobalControlDiscoverAttributesExtended_t *)request->request_data;
3897 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_DISCOVER_COMMANDS_RECEIVED: {
3898 ZigbeeZclGlobalControlDiscoverCommandsReceived_t *req = NULL;
3900 req = (ZigbeeZclGlobalControlDiscoverCommandsReceived_t *)request->request_data;
3907 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_DISCOVER_COMMANDS_GENERATED: {
3908 ZigbeeZclGlobalControlDiscoverCommandsGenerated_t *req = NULL;
3910 req = (ZigbeeZclGlobalControlDiscoverCommandsGenerated_t *)request->request_data;
3922 static void __zblib_request_free_zcl_ias_zone_request_data(ZigBeeRequest *request,
3928 ops_id = __zblib_request_get_ops_id(request_type);
3930 case ZBLIB_ZCL_IAS_ZONE_OPS_ENROLL_RESPONSE: {
3931 ZigbeeZclIasZoneEnrollResponse_t *req = NULL;
3933 req = (ZigbeeZclIasZoneEnrollResponse_t *)request->request_data;
3945 static void __zblib_request_free_zcl_identify_request_data(ZigBeeRequest *request,
3951 ops_id = __zblib_request_get_ops_id(request_type);
3953 case ZBLIB_ZCL_IDENTIFY_OPS_IDENTIFY: {
3954 ZigbeeZclIdentifyIdentify_t *req = NULL;
3956 req = (ZigbeeZclIdentifyIdentify_t *)request->request_data;
3963 case ZBLIB_ZCL_IDENTIFY_OPS_QUERY: {
3964 ZigbeeZclIdentifyQuery_t *req = NULL;
3966 req = (ZigbeeZclIdentifyQuery_t *)request->request_data;
3978 static void __zblib_request_free_zcl_color_control_request_data(ZigBeeRequest *request,
3984 ops_id = __zblib_request_get_ops_id(request_type);
3986 case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_TO_HUE: {
3987 ZigbeeZclColorControlMoveToHue_t *req = NULL;
3989 req = (ZigbeeZclColorControlMoveToHue_t *)request->request_data;
3996 case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_HUE: {
3997 ZigbeeZclColorControlMoveHue_t *req = NULL;
3999 req = (ZigbeeZclColorControlMoveHue_t *)request->request_data;
4006 case ZBLIB_ZCL_COLOR_CONTROL_OPS_STEP_HUE: {
4007 ZigbeeZclColorControlStepHue_t *req = NULL;
4009 req = (ZigbeeZclColorControlStepHue_t *)request->request_data;
4016 case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_TO_STAURATION: {
4017 ZigbeeZclColorControlMoveToSaturation_t *req = NULL;
4019 req = (ZigbeeZclColorControlMoveToSaturation_t *)request->request_data;
4026 case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_STAURATION: {
4027 ZigbeeZclColorControlMoveSaturation_t *req = NULL;
4029 req = (ZigbeeZclColorControlMoveSaturation_t *)request->request_data;
4036 case ZBLIB_ZCL_COLOR_CONTROL_OPS_STEP_STAURATION: {
4037 ZigbeeZclColorControlStepSaturation_t *req = NULL;
4039 req = (ZigbeeZclColorControlStepSaturation_t *)request->request_data;
4046 case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_TO_HUE_AND_SATURATION: {
4047 ZigbeeZclColorControlMoveToHueAndSaturation_t *req = NULL;
4049 req = (ZigbeeZclColorControlMoveToHueAndSaturation_t *)request->request_data;
4056 case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_TO_COLOR: {
4057 ZigbeeZclColorControlMoveToColor_t *req = NULL;
4059 req = (ZigbeeZclColorControlMoveToColor_t *)request->request_data;
4066 case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_COLOR: {
4067 ZigbeeZclColorControlMoveColor_t *req = NULL;
4069 req = (ZigbeeZclColorControlMoveColor_t *)request->request_data;
4076 case ZBLIB_ZCL_COLOR_CONTROL_OPS_STEP_COLOR: {
4077 ZigbeeZclColorControlStepColor_t *req = NULL;
4079 req = (ZigbeeZclColorControlStepColor_t *)request->request_data;
4086 case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_COLOR_TEMPERATURE: {
4087 ZigbeeZclColorControlMoveColorTemperature_t *req = NULL;
4089 req = (ZigbeeZclColorControlMoveColorTemperature_t *)request->request_data;
4101 static void __zblib_request_free_zcl_group_request_data(ZigBeeRequest *request,
4107 ops_id = __zblib_request_get_ops_id(request_type);
4109 case ZBLIB_ZCL_GROUP_OPS_ADD_GROUP: {
4110 ZigbeeZclGroupAddGroup_t *req = NULL;
4112 req = (ZigbeeZclGroupAddGroup_t *)request->request_data;
4119 case ZBLIB_ZCL_GROUP_OPS_VIEW_GROUP: {
4120 ZigbeeZclGroupViewGroup_t *req = NULL;
4122 req = (ZigbeeZclGroupViewGroup_t *)request->request_data;
4129 case ZBLIB_ZCL_GROUP_OPS_GET_GROUP_MEMBERSHIP: {
4130 ZigbeeZclGroupGetGroupMembership_t *req = NULL;
4132 req = (ZigbeeZclGroupGetGroupMembership_t *)request->request_data;
4134 g_free(req->group_list);
4140 case ZBLIB_ZCL_GROUP_OPS_REMOVE_GROUP: {
4141 ZigbeeZclGroupRemoveGroup_t *req = NULL;
4143 req = (ZigbeeZclGroupRemoveGroup_t *)request->request_data;
4150 case ZBLIB_ZCL_GROUP_OPS_REMOVE_ALL_GROUP: {
4151 ZigbeeZclGroupRemoveAllGroup_t *req = NULL;
4153 req = (ZigbeeZclGroupRemoveAllGroup_t *)request->request_data;
4160 case ZBLIB_ZCL_GROUP_OPS_ADD_GROUP_IF_IDENTIFYING: {
4161 ZigbeeZclGroupAddGroupIfIdentifying_t *req = NULL;
4163 req = (ZigbeeZclGroupAddGroupIfIdentifying_t *)request->request_data;
4175 static void __zblib_request_free_zcl_poll_control_request_data(ZigBeeRequest *request,
4181 ops_id = __zblib_request_get_ops_id(request_type);
4183 case ZBLIB_ZCL_POLL_CONTROL_OPS_CHECK_IN_RESPONSE: {
4184 ZigbeeZclPollControlCheckInResponse_t *req = NULL;
4186 req = (ZigbeeZclPollControlCheckInResponse_t *)request->request_data;
4193 case ZBLIB_ZCL_POLL_CONTROL_OPS_FAST_POLL_STOP: {
4194 ZigbeeZclPollControlFastPollStop_t *req = NULL;
4196 req = (ZigbeeZclPollControlFastPollStop_t *)request->request_data;
4203 case ZBLIB_ZCL_POLL_CONTROL_OPS_SET_LONG_POLL_INTERVAL: {
4204 ZigbeeZclPollControlSetLongPollInterval_t *req = NULL;
4206 req = (ZigbeeZclPollControlSetLongPollInterval_t *)request->request_data;
4213 case ZBLIB_ZCL_POLL_CONTROL_OPS_SET_SHORT_POLL_INTERVAL: {
4214 ZigbeeZclPollControlSetShortPollInterval_t *req = NULL;
4216 req = (ZigbeeZclPollControlSetShortPollInterval_t *)request->request_data;
4228 static void __zblib_request_free_zcl_scene_request_data(ZigBeeRequest *request,
4234 ops_id = __zblib_request_get_ops_id(request_type);
4236 case ZBLIB_ZCL_SCENE_OPS_ADD_SCENE: {
4237 ZigbeeZclSceneAddScene_t *req = NULL;
4239 req = (ZigbeeZclSceneAddScene_t *)request->request_data;
4241 g_free(req->ext_field_set);
4247 case ZBLIB_ZCL_SCENE_OPS_VIEW_SCENE: {
4248 ZigbeeZclSceneViewScene_t *req = NULL;
4250 req = (ZigbeeZclSceneViewScene_t *)request->request_data;
4257 case ZBLIB_ZCL_SCENE_OPS_REMOVE_SCENE: {
4258 ZigbeeZclSceneRemoveScene_t *req = NULL;
4260 req = (ZigbeeZclSceneRemoveScene_t *)request->request_data;
4267 case ZBLIB_ZCL_SCENE_OPS_STORE_SCENE: {
4268 ZigbeeZclSceneStoreScene_t *req = NULL;
4270 req = (ZigbeeZclSceneStoreScene_t *)request->request_data;
4277 case ZBLIB_ZCL_SCENE_OPS_RECALL_SCENE: {
4278 ZigbeeZclSceneRecallScene_t *req = NULL;
4280 req = (ZigbeeZclSceneRecallScene_t *)request->request_data;
4287 case ZBLIB_ZCL_SCENE_OPS_REMOVE_ALL_SCENE: {
4288 ZigbeeZclSceneRemoveAllScene_t *req = NULL;
4290 req = (ZigbeeZclSceneRemoveAllScene_t *)request->request_data;
4297 case ZBLIB_ZCL_SCENE_OPS_GET_SCENE_MEMBERSHIP: {
4298 ZigbeeZclSceneGetSceneMembership_t *req = NULL;
4300 req = (ZigbeeZclSceneGetSceneMembership_t *)request->request_data;
4312 static void __zblib_request_free_zdo_dev_control_request_data(ZigBeeRequest *request,
4318 ops_id = __zblib_request_get_ops_id(request_type);
4320 case ZBLIB_ZDO_DEV_CONTROL_OPS_NWK_ADDR_REQ: {
4321 ZigbeeZdoDevControlNwkAddrReq_t *req = NULL;
4323 req = (ZigbeeZdoDevControlNwkAddrReq_t *)request->request_data;
4330 case ZBLIB_ZDO_DEV_CONTROL_OPS_MATCHED_DESCRIPTOR_REQ: {
4331 ZigbeeZdoDevControlMatchedDescriptorReq_t *req = NULL;
4333 req = (ZigbeeZdoDevControlMatchedDescriptorReq_t *)request->request_data;
4336 g_free(req->out_cl);
4342 case ZBLIB_ZDO_DEV_CONTROL_OPS_IEEE_ADDR_REQ: {
4343 ZigbeeZdoDevControlIeeeAddrReq_t *req = NULL;
4345 req = (ZigbeeZdoDevControlIeeeAddrReq_t *)request->request_data;
4352 case ZBLIB_ZDO_DEV_CONTROL_OPS_ACTIVE_EP_REQ: {
4353 ZigbeeZdoDevControlActiveEpReq_t *req = NULL;
4355 req = (ZigbeeZdoDevControlActiveEpReq_t *)request->request_data;
4362 case ZBLIB_ZDO_DEV_CONTROL_OPS_NODE_DESC_REQ: {
4363 ZigbeeZdoDevControlNodeDescriptorReq_t *req = NULL;
4365 req = (ZigbeeZdoDevControlNodeDescriptorReq_t *)request->request_data;
4372 case ZBLIB_ZDO_DEV_CONTROL_OPS_POWER_DESC_REQ: {
4373 ZigbeeZdoDevControlPowerDescriptorReq_t *req = NULL;
4375 req = (ZigbeeZdoDevControlPowerDescriptorReq_t *)request->request_data;
4382 case ZBLIB_ZDO_DEV_CONTROL_OPS_COMPLEX_DESC_REQ: {
4383 ZigbeeZdoDevControlComplexDescriptorReq_t *req = NULL;
4385 req = (ZigbeeZdoDevControlComplexDescriptorReq_t *)request->request_data;
4392 case ZBLIB_ZDO_DEV_CONTROL_OPS_USER_DESC_REQ: {
4393 ZigbeeZdoDevControlUserDescriptorReq_t *req = NULL;
4395 req = (ZigbeeZdoDevControlUserDescriptorReq_t *)request->request_data;
4402 case ZBLIB_ZDO_DEV_CONTROL_OPS_USER_DESC_SET_REQ: {
4403 ZigbeeZdoDevControlUserDescriptorSetReq_t *req = NULL;
4405 req = (ZigbeeZdoDevControlUserDescriptorSetReq_t *)request->request_data;
4412 case ZBLIB_ZDO_DEV_CONTROL_OPS_DEVICE_ANNOUNCE: {
4413 ZigbeeZdoDevControlDeviceAnnounce_t *req = NULL;
4415 req = (ZigbeeZdoDevControlDeviceAnnounce_t *)request->request_data;
4422 case ZBLIB_ZDO_DEV_CONTROL_OPS_SIMPLE_DESC_REQ: {
4423 ZigbeeZdoDevControlSimpleDescriptorReq_t *req = NULL;
4425 req = (ZigbeeZdoDevControlSimpleDescriptorReq_t *)request->request_data;
4432 case ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_LQI_REQ: {
4433 ZigbeeZdoDevControlMgmtLqiReq_t *req = NULL;
4435 req = (ZigbeeZdoDevControlMgmtLqiReq_t *)request->request_data;
4442 case ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_RTG_REQ: {
4443 ZigbeeZdoDevControlMgmtRtgReq_t *req = NULL;
4445 req = (ZigbeeZdoDevControlMgmtRtgReq_t *)request->request_data;
4452 case ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_BIND_REQ: {
4453 ZigbeeZdoDevControlMgmtBindReq_t *req = NULL;
4455 req = (ZigbeeZdoDevControlMgmtBindReq_t *)request->request_data;
4462 case ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_PERMIT_JOIN_REQ: {
4463 ZigbeeZdoDevControlMgmtPermitJoinReq_t *req = NULL;
4465 req = (ZigbeeZdoDevControlMgmtPermitJoinReq_t *)request->request_data;
4472 case ZBLIB_ZDO_DEV_CONTROL_OPS_NWK_UPDATE_REQ: {
4473 ZigbeeZdoDevControlNwkUpdateReq_t *req = NULL;
4475 req = (ZigbeeZdoDevControlNwkUpdateReq_t *)request->request_data;
4482 case ZBLIB_ZDO_DEV_CONTROL_OPS_NWK_DISC_REQ: {
4483 ZigbeeZdoDevControlNwkDescriptorReq_t *req = NULL;
4485 req = (ZigbeeZdoDevControlNwkDescriptorReq_t *)request->request_data;
4497 static void __zblib_request_free_zdo_bind_request_data(ZigBeeRequest *request,
4503 ops_id = __zblib_request_get_ops_id(request_type);
4505 case ZBLIB_ZDO_BIND_OPS_BIND_REQ: {
4506 ZigbeeZdoBindBindReq_t *req = NULL;
4508 req = (ZigbeeZdoBindBindReq_t *)request->request_data;
4515 case ZBLIB_ZDO_BIND_OPS_UNBIND_REQ: {
4516 ZigbeeZdoBindUnbindReq_t *req = NULL;
4518 req = (ZigbeeZdoBindUnbindReq_t *)request->request_data;
4530 static void __zblib_request_free_request_data(ZigBeeRequest *request)
4533 ZblibDriverType_e driver_type;
4535 zblib_check_null_ret("request", request);
4537 request_type = request->request_type;
4539 /* Fetch driver type */
4540 driver_type = __zblib_request_get_driver_type(request_type);
4541 switch (driver_type) {
4542 case ZBLIB_DRIVER_TYPE_ZCL_ALARM: {
4543 __zblib_request_free_zcl_alarm_request_data(request, request_type);
4547 case ZBLIB_DRIVER_TYPE_CUSTOM: {
4548 __zblib_request_free_custom_request_data(request, request_type);
4552 case ZBLIB_DRIVER_TYPE_ZCL_DOOR_LOCK: {
4553 __zblib_request_free_zcl_door_lock_request_data(request, request_type);
4557 case ZBLIB_DRIVER_TYPE_ZCL_FAN_CONTROL: {
4558 __zblib_request_free_zcl_fan_control_request_data(request, request_type);
4562 case ZBLIB_DRIVER_TYPE_ZCL_LEVEL_CONTROL: {
4563 __zblib_request_free_zcl_level_control_request_data(request, request_type);
4567 case ZBLIB_DRIVER_TYPE_MFGLIB_CONTROL: {
4568 __zblib_request_free_mfglib_control_request_data(request, request_type);
4572 case ZBLIB_DRIVER_TYPE_ZCL_ON_OFF: {
4573 __zblib_request_free_zcl_on_off_request_data(request, request_type);
4577 case ZBLIB_DRIVER_TYPE_SERVICE: {
4578 __zblib_request_free_service_request_data(request, request_type);
4582 case ZBLIB_DRIVER_TYPE_ZCL_THERMOSTAT: {
4583 __zblib_request_free_zcl_thermostat_request_data(request, request_type);
4587 case ZBLIB_DRIVER_TYPE_ZCL_BASIC: {
4588 __zblib_request_free_zcl_basic_request_data(request, request_type);
4592 case ZBLIB_DRIVER_TYPE_ZCL_GLOBAL_CONTROL: {
4593 __zblib_request_free_zcl_global_control_request_data(request, request_type);
4597 case ZBLIB_DRIVER_TYPE_ZCL_IAS_ZONE: {
4598 __zblib_request_free_zcl_ias_zone_request_data(request, request_type);
4602 case ZBLIB_DRIVER_TYPE_ZCL_IDENTIFY: {
4603 __zblib_request_free_zcl_identify_request_data(request, request_type);
4607 case ZBLIB_DRIVER_TYPE_ZCL_COLOR_CONTROL: {
4608 __zblib_request_free_zcl_color_control_request_data(request, request_type);
4612 case ZBLIB_DRIVER_TYPE_ZCL_GROUP: {
4613 __zblib_request_free_zcl_group_request_data(request, request_type);
4617 case ZBLIB_DRIVER_TYPE_ZCL_POLL_CONTROL: {
4618 __zblib_request_free_zcl_poll_control_request_data(request, request_type);
4622 case ZBLIB_DRIVER_TYPE_ZCL_SCENE: {
4623 __zblib_request_free_zcl_scene_request_data(request, request_type);
4627 case ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL: {
4628 __zblib_request_free_zdo_dev_control_request_data(request, request_type);
4632 case ZBLIB_DRIVER_TYPE_ZDO_BIND: {
4633 __zblib_request_free_zdo_bind_request_data(request, request_type);
4637 case ZBLIB_DRIVER_TYPE_NONE: /* Fall through */
4639 Z_LOGE("Unhandled driver type: [%d]", driver_type);
4645 gint zblib_request_new(ZigBeeServiceInterface *service_interface,
4646 guint request_type, gpointer request_data, guint request_data_len)
4648 ZigBeeService *service = NULL;
4649 ZigBeeRequest *request = NULL;
4650 GHashTable *request_table = NULL;
4652 zblib_check_null_ret_error("service_interface", service_interface, ZIGBEE_REQUEST_INVALID_REQUEST_ID);
4654 service = zblib_service_interface_ref_service(service_interface);
4655 zblib_check_null_ret_error("service", service, ZIGBEE_REQUEST_INVALID_REQUEST_ID);
4657 /* Allocate ZigBee request memory */
4658 request = g_malloc0(sizeof(ZigBeeRequest));
4660 /* Update request */
4661 request->service_interface = service_interface;
4662 request->ref_count = 1; /* Initialize reference count to '1' for new request */
4664 /* Update request data for specific request */
4665 request->request_data = __zblib_request_create_request_data(request_type,
4666 request_data, request_data_len);
4667 request->request_type = request_type;
4669 /* Generate request ID */
4670 request->request_id = zblib_service_generate_request_id(service);
4671 if (ZIGBEE_REQUEST_INVALID_REQUEST_ID == request->request_id) {
4672 Z_LOGE("zblib_service_genrate_request_id failed!");
4674 /* Free resources */
4675 __zblib_request_free_request_data(request);
4678 return ZIGBEE_REQUEST_INVALID_REQUEST_ID;
4681 /* Fetch request table from service */
4682 request_table = zblib_service_ref_request_hash_table(service);
4683 if (NULL == request_table) {
4684 Z_LOGE("zblib_service_ref_request_hash_table failed!");
4686 /* Free resources */
4687 __zblib_request_free_request_data(request);
4690 return ZIGBEE_REQUEST_INVALID_REQUEST_ID;
4693 /* Insert request to request table */
4694 g_hash_table_insert(request_table, (gpointer)(request->request_id), request);
4696 return request->request_id;
4699 void zblib_request_free(ZigBeeServiceInterface *service_interface,
4702 ZigBeeService *service = NULL;
4703 ZigBeeRequest *request = NULL;
4705 zblib_check_null_ret("service_interface", service_interface);
4708 service = zblib_service_interface_ref_service(service_interface);
4709 zblib_check_null_ret("service", service);
4711 /* Fetch request based on request_id */
4712 request = __zblib_request_ref_request_by_request_id(service, request_id);
4713 zblib_check_null_ret("request", request);
4715 /* Free resources */
4716 __zblib_request_free_request_data(request);
4720 gboolean zblib_request_set_response_cb(ZigBeeServiceInterface *service_interface,
4722 gpointer resp_cb, gpointer resp_cb_data)
4724 ZigBeeService *service = NULL;
4725 ZigBeeRequest *request = NULL;
4727 zblib_check_null_ret_error("service_interface", service_interface, FALSE);
4730 service = zblib_service_interface_ref_service(service_interface);
4731 zblib_check_null_ret_error("service", service, FALSE);
4733 /* Fetch request based on request_id */
4734 request = __zblib_request_ref_request_by_by_request_id(service, request_id);
4735 if (NULL == request) {
4736 Z_LOGE("No request available for request_id: [%d]", request_id);
4740 /* Update response callback and response callback data */
4741 request->resp_cb = resp_cb;
4742 request->resp_cb_data = resp_cb_data;
4747 gpointer zblib_request_ref_response_cb(ZigBeeServiceInterface *service_interface,
4748 guint request_id, gpointer *resp_cb_data)
4750 ZigBeeService *service = NULL;
4751 ZigBeeRequest *request = NULL;
4753 zblib_check_null_ret_error("request", request, NULL);
4756 service = zblib_service_interface_ref_service(service_interface);
4757 zblib_check_null_ret_error("service", service, NULL);
4759 /* Fetch request based on request_id */
4760 request = __zblib_request_ref_request_by_by_request_id(service, request_id);
4761 if (NULL == request) {
4762 Z_LOGE("No request available for request_id: [%d]", request_id);
4766 /* Response callback data */
4767 *resp_cb_data = request->resp_cb_data;
4769 /* Return response callback */
4770 return request->resp_cb;
4773 ZigBeeRequest *zblib_request_ref(ZigBeeRequest *request)
4775 zblib_check_null_ret_error("request", request, NULL);
4777 request->ref_count++;
4782 void zblib_request_unref(ZigBeeRequest *request)
4784 zblib_check_null_ret("request", request);
4786 request->ref_count--;
4787 if (0 == request->ref_count) {
4788 Z_LOGD("Reference count is ZERO!");
4790 /* Free 'request' */
4791 __zblib_request_free_request_data(request);
4796 guint zblib_request_ref_request_type(ZigBeeRequest *request)
4798 zblib_check_null_ret_error("request", request, 0);
4800 return request->request_type;
4803 ZigBeeServiceInterface *zblib_request_ref_service_interface(ZigBeeService *service,
4806 ZigBeeRequest *request = NULL;
4808 zblib_check_null_ret_error("service", service, NULL);
4810 /* Fetch request based on request_id */
4811 request = __zblib_request_ref_request_by_by_request_id(service, request_id);
4812 if (NULL == request) {
4813 Z_LOGE("No request available for request_id: [%d]", request_id);
4817 return request->service_interface;
4820 gpointer zblib_request_ref_request_data(ZigBeeRequest *request)
4822 zblib_check_null_ret_error("request", request, NULL);
4824 return request->request_data;
4827 gpointer zblib_request_ref_request_data_by_id(ZigBeeService *service,
4830 ZigBeeRequest *request = NULL;
4832 /* Fetch request based on request_id */
4833 request = __zblib_request_ref_request_by_by_request_id(service, request_id);
4834 if (NULL == request) {
4835 Z_LOGE("No request available for request_id: [%d]", request_id);
4839 return request->request_data;
4842 guint zblib_request_generate_request_type(ZblibDriverType_e driver_type,
4848 * request_type consists of driver_type and ops_id
4849 * request_type = driver_type | 0x00 | 0x00 | ops_id
4851 request_type = (driver_type << 24) | (ops_id);
4853 return request_type;
4856 gint zblib_request_ref_request_type_by_request_id(ZigBeeService *service,
4859 return __zblib_request_ref_request_type_by_request_id(service, request_id);
4862 ZblibDriverType_e zblib_request_get_driver_type(guint request_type)
4864 return __zblib_request_get_driver_type(request_type);
4867 guint zblib_request_get_ops_id(guint request_type)
4869 return __zblib_request_get_ops_id(request_type);