2 * Copyright (c) 2016 Samsung Electronics Co., Ltd. All rights reserved.
4 * Contact: Suresh Kumar N (suresh.n@samsung.com)
6 * Licensed under the Apache License, Version 2.0 (the "License");
7 * you may not use this file except in compliance with the License.
8 * You may obtain a copy of the License at
10 * http://www.apache.org/licenses/LICENSE-2.0
12 * Unless required by applicable law or agreed to in writing, software
13 * distributed under the License is distributed on an "AS IS" BASIS,
14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 * See the License for the specific language governing permissions and
16 * limitations under the License.
20 #include <zblib_request.h>
21 #include <zblib_service.h>
22 #include <zblib_service_interface.h>
24 #include <zblib_driver.h>
25 #include <zblib_driver_custom.h>
26 #include <zblib_driver_mfglib_control.h>
27 #include <zblib_driver_service.h>
28 #include <zblib_driver_zcl_alarm.h>
29 #include <zblib_driver_zcl_basic.h>
30 #include <zblib_driver_zcl_color_control.h>
31 #include <zblib_driver_zcl_door_lock.h>
32 #include <zblib_driver_zcl_fan_control.h>
33 #include <zblib_driver_zcl_global_control.h>
34 #include <zblib_driver_zcl_group.h>
35 #include <zblib_driver_zcl_ias_zone.h>
36 #include <zblib_driver_zcl_identify.h>
37 #include <zblib_driver_zcl_level_control.h>
38 #include <zblib_driver_zcl_on_off.h>
39 #include <zblib_driver_zcl_poll_control.h>
40 #include <zblib_driver_zcl_scene.h>
41 #include <zblib_driver_zcl_thermostat.h>
42 #include <zblib_driver_zdo_bind.h>
43 #include <zblib_driver_zdo_dev_control.h>
45 /**< ZigBee Request object */
46 struct zblib_request_type {
47 gint request_id; /**< Request ID */
48 guint request_type; /**< Request type */
49 guint ref_count; /* Reference count */
51 gpointer request_data; /**< Request data */
52 gpointer resp_cb; /**< Response callback */
53 gpointer resp_cb_data; /**< Response callback data */
55 ZigBeeServiceInterface *service_interface; /* Service interface */
58 static ZblibDriverType_e __zblib_request_get_driver_type(guint request_type)
60 ZblibDriverType_e driver_type;
62 driver_type = ((request_type & 0xFF000000) >> 24);
67 static ZblibDriverType_e __zblib_request_get_ops_id(guint request_type)
71 ops_id = (request_type & 0x000000FF);
76 static ZigBeeRequest *__zblib_request_ref_request_by_by_request_id(ZigBeeService *service,
79 ZigBeeRequest *request = NULL;
80 GHashTable *request_table = NULL;
82 /* Fetch request table from service */
83 request_table = zblib_service_ref_request_hash_table(service);
84 if (NULL == request_table) {
85 Z_LOGE("zblib_service_ref_request_hash_table failed!");
89 /* Look-up requets_id in request hash table */
90 request = (ZigBeeRequest *)g_hash_table_lookup(request_table, (gconstpointer)request_id);
91 if (NULL == request) {
92 Z_LOGE("No request available for request_id: [%d]", request_id);
99 static gint __zblib_request_ref_request_type_by_request_id(ZigBeeService *service,
102 ZigBeeRequest *request = NULL;
104 /* Fetch request based on request_id */
105 request = __zblib_request_ref_request_by_by_request_id(service, request_id);
106 if (NULL == request) {
107 Z_LOGE("No request available for request_id: [%d]", request_id);
111 return (gint)(request->request_type);
114 static ZigBeeRequest *__zblib_request_ref_request_by_request_id(ZigBeeService *service,
117 ZigBeeRequest *request = NULL;
118 GHashTable *request_table = NULL;
120 /* Fetch request table from service */
121 request_table = zblib_service_ref_request_hash_table(service);
122 if (NULL == request_table) {
123 Z_LOGE("zblib_service_ref_request_hash_table failed!");
127 /* Look-up requets_id in request hash table */
128 request = (ZigBeeRequest *)g_hash_table_lookup(request_table, (gconstpointer)request_id);
129 if (NULL == request_table) {
130 Z_LOGE("No request available for request_id: [%d]", request_id);
137 static gpointer __zblib_request_create_zcl_alarm_request_data(guint request_type,
138 gpointer request_data, guint request_data_len)
140 gpointer alarm_request_data = NULL;
143 NOT_USED(request_data_len);
146 ops_id = __zblib_request_get_ops_id(request_type);
148 case ZBLIB_ZCL_ALARM_OPS_GET_ALARM_COUNT: {
149 ZigbeeZclAlarmGetAlarmCount_t *in_req;
150 ZigbeeZclAlarmGetAlarmCount_t *req = NULL;
152 in_req = (ZigbeeZclAlarmGetAlarmCount_t *)request_data;
153 if (NULL != in_req) {
154 /* Allocate memory */
155 req = (ZigbeeZclAlarmGetAlarmCount_t *)
156 g_malloc0(sizeof(ZigbeeZclAlarmGetAlarmCount_t));
159 memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
160 req->endpoint = in_req->endpoint;
163 alarm_request_data = (gpointer)req;
167 case ZBLIB_ZCL_ALARM_OPS_RESET_ALARM: {
168 ZigbeeZclAlarmResetAlarm_t *in_req;
169 ZigbeeZclAlarmResetAlarm_t *req = NULL;
171 in_req = (ZigbeeZclAlarmResetAlarm_t *)request_data;
172 if (NULL != in_req) {
173 /* Allocate memory */
174 req = (ZigbeeZclAlarmResetAlarm_t *)
175 g_malloc0(sizeof(ZigbeeZclAlarmResetAlarm_t));
178 req->node_id = in_req->node_id;
179 req->endpoint = in_req->endpoint;
180 req->alarm_code = in_req->alarm_code;
181 req->cluster_id = in_req->cluster_id;
184 alarm_request_data = (gpointer)req;
188 case ZBLIB_ZCL_ALARM_OPS_RESET_ALL_ALARM: {
189 ZigbeeZclAlarmResetAllAlarm_t *in_req;
190 ZigbeeZclAlarmResetAllAlarm_t *req = NULL;
192 in_req = (ZigbeeZclAlarmResetAllAlarm_t *)request_data;
194 /* Allocate memory */
195 req = (ZigbeeZclAlarmResetAllAlarm_t *)
196 g_malloc0(sizeof(ZigbeeZclAlarmResetAllAlarm_t));
199 req->node_id = in_req->node_id;
200 req->endpoint = in_req->endpoint;
203 alarm_request_data = (gpointer)req;
207 case ZBLIB_ZCL_ALARM_OPS_ALARM: {
208 ZigbeeZclAlarmAlarm_t *in_req;
209 ZigbeeZclAlarmAlarm_t *req = NULL;
211 in_req = (ZigbeeZclAlarmAlarm_t *)request_data;
213 /* Allocate memory */
214 req = (ZigbeeZclAlarmAlarm_t *)
215 g_malloc0(sizeof(ZigbeeZclAlarmAlarm_t));
218 memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
219 req->endpoint = in_req->endpoint;
220 req->alarm_code = in_req->alarm_code;
221 req->cluster_id = in_req->cluster_id;
224 alarm_request_data = (gpointer)req;
228 case ZBLIB_ZCL_ALARM_OPS_RESET_ALARM_LOG: {
229 ZigbeeZclAlarmResetAlarmLogs_t *in_req;
230 ZigbeeZclAlarmResetAlarmLogs_t *req = NULL;
232 in_req = (ZigbeeZclAlarmResetAlarmLogs_t *)request_data;
234 /* Allocate memory */
235 req = (ZigbeeZclAlarmResetAlarmLogs_t *)
236 g_malloc0(sizeof(ZigbeeZclAlarmResetAlarmLogs_t));
239 req->node_id = in_req->node_id;
240 req->endpoint = in_req->endpoint;
243 alarm_request_data = (gpointer)req;
247 case ZBLIB_ZCL_ALARM_OPS_GET_ALARM: {
248 ZigbeeZclAlarmGetAlarm_t *in_req;
249 ZigbeeZclAlarmGetAlarm_t *req = NULL;
251 in_req = (ZigbeeZclAlarmGetAlarm_t *)request_data;
253 /* Allocate memory */
254 req = (ZigbeeZclAlarmGetAlarm_t *)
255 g_malloc0(sizeof(ZigbeeZclAlarmGetAlarm_t));
258 req->node_id = in_req->node_id;
259 req->endpoint = in_req->endpoint;
262 alarm_request_data = (gpointer)req;
270 return alarm_request_data;
273 static gpointer __zblib_request_create_custom_request_data(guint request_type,
274 gpointer request_data, guint request_data_len)
276 gpointer custom_request_data = NULL;
279 NOT_USED(request_data_len);
282 ops_id = __zblib_request_get_ops_id(request_type);
284 case ZBLIB_CUSTOM_OPS_APS_SEND: {
285 ZigbeeCustomApsSend_t *in_req;
286 ZigbeeCustomApsSend_t *req = NULL;
288 in_req = (ZigbeeCustomApsSend_t *)request_data;
290 /* Allocate memory */
291 req = (ZigbeeCustomApsSend_t *)
292 g_malloc0(sizeof(ZigbeeCustomApsSend_t));
295 req->node_id = in_req->node_id;
296 req->aps_frame_ctrl = in_req->aps_frame_ctrl;
297 req->src_ep = in_req->src_ep;
298 req->dest_ep = in_req->dest_ep;
299 req->cluster_id = in_req->cluster_id;
300 req->profile_id = in_req->profile_id;
301 req->zcl_frame_ctrl = in_req->zcl_frame_ctrl;
302 req->mfg_code = in_req->mfg_code;
304 in_req->payload, ZIGBEE_CUSTOM_SEND_PAYLOAD_LEN);
307 custom_request_data = (gpointer)req;
311 case ZBLIB_CUSTOM_OPS_ZCL_SEND: {
312 ZigbeeCustomZclSend_t *in_req;
313 ZigbeeCustomZclSend_t *req = NULL;
315 in_req = (ZigbeeCustomZclSend_t *)request_data;
317 /* Allocate memory */
318 req = (ZigbeeCustomZclSend_t *)
319 g_malloc0(sizeof(ZigbeeCustomZclSend_t));
322 req->node_id = in_req->node_id;
323 req->src_ep = in_req->src_ep;
324 req->dest_ep = in_req->dest_ep;
325 req->cluster_id = in_req->cluster_id;
326 req->zcl_frame_ctrl = in_req->zcl_frame_ctrl;
327 req->cmd_id = in_req->cmd_id;
329 in_req->payload, ZIGBEE_CUSTOM_SEND_PAYLOAD_LEN);
332 custom_request_data = (gpointer)req;
336 case ZBLIB_CUSTOM_OPS_SEND_TO_LOCAL: {
337 ZigbeeCustomSendToLocal_t *in_req;
338 ZigbeeCustomSendToLocal_t *req = NULL;
340 in_req = (ZigbeeCustomSendToLocal_t *)request_data;
342 /* Allocate memory */
343 req = (ZigbeeCustomSendToLocal_t *)
344 g_malloc0(sizeof(ZigbeeCustomSendToLocal_t));
348 in_req->data, ZIGBEE_CUSTOM_SEND_PAYLOAD_LEN);
351 custom_request_data = (gpointer)req;
359 return custom_request_data;
362 static gpointer __zblib_request_create_zcl_door_lock_request_data(guint request_type,
363 gpointer request_data, guint request_data_len)
365 gpointer door_lock_request_data = NULL;
368 NOT_USED(request_data_len);
371 ops_id = __zblib_request_get_ops_id(request_type);
373 case ZBLIB_ZCL_DOOR_LOCK_OPS_SUBSCRIBE_LOCK_EVENT: {
374 ZigbeeZclDoorLockSubscriberLockEvent_t *in_req;
375 ZigbeeZclDoorLockSubscriberLockEvent_t *req = NULL;
377 in_req = (ZigbeeZclDoorLockSubscriberLockEvent_t *)request_data;
379 /* Allocate memory */
380 req = (ZigbeeZclDoorLockSubscriberLockEvent_t *)
381 g_malloc0(sizeof(ZigbeeZclDoorLockSubscriberLockEvent_t));
385 in_req->eui64, ZIGBEE_EUI64_SIZE);
386 req->endpoint = in_req->endpoint;
389 door_lock_request_data = (gpointer)req;
393 case ZBLIB_ZCL_DOOR_LOCK_OPS_SET_DOOR_LOCK_PIN: {
394 ZigbeeZclDoorLockSetDoorLockPin_t *in_req;
395 ZigbeeZclDoorLockSetDoorLockPin_t *req = NULL;
397 in_req = (ZigbeeZclDoorLockSetDoorLockPin_t *)request_data;
399 /* Allocate memory */
400 req = (ZigbeeZclDoorLockSetDoorLockPin_t *)
401 g_malloc0(sizeof(ZigbeeZclDoorLockSetDoorLockPin_t));
404 req->uid = in_req->uid;
405 req->ustatus = in_req->ustatus;
406 req->utype = in_req->utype;
408 in_req->eui64, ZIGBEE_EUI64_SIZE);
409 req->endpoint = in_req->endpoint;
411 in_req->pin, ZIGBEE_DOOR_LOCK_MAX_PIN_LEN);
414 door_lock_request_data = (gpointer)req;
418 case ZBLIB_ZCL_DOOR_LOCK_OPS_SET_DOOR_LOCK: {
419 ZigbeeZclDoorLockSetDoorLock_t *in_req;
420 ZigbeeZclDoorLockSetDoorLock_t *req = NULL;
422 in_req = (ZigbeeZclDoorLockSetDoorLock_t *)request_data;
424 /* Allocate memory */
425 req = (ZigbeeZclDoorLockSetDoorLock_t *)
426 g_malloc0(sizeof(ZigbeeZclDoorLockSetDoorLock_t));
430 in_req->eui64, ZIGBEE_EUI64_SIZE);
431 req->endpoint = in_req->endpoint;
433 in_req->pin, ZIGBEE_DOOR_LOCK_MAX_PIN_LEN);
434 req->lock_unlock_type = in_req->lock_unlock_type;
437 door_lock_request_data = (gpointer)req;
441 case ZBLIB_ZCL_DOOR_LOCK_OPS_GET_LOCK_STATE: {
442 ZigbeeZclDoorLockGetDoorLock_t *in_req;
443 ZigbeeZclDoorLockGetDoorLock_t *req = NULL;
445 in_req = (ZigbeeZclDoorLockGetDoorLock_t *)request_data;
447 /* Allocate memory */
448 req = (ZigbeeZclDoorLockGetDoorLock_t *)
449 g_malloc0(sizeof(ZigbeeZclDoorLockGetDoorLock_t));
453 in_req->eui64, ZIGBEE_EUI64_SIZE);
454 req->endpoint = in_req->endpoint;
457 door_lock_request_data = (gpointer)req;
465 return door_lock_request_data;
468 static gpointer __zblib_request_create_zcl_fan_control_request_data(guint request_type,
469 gpointer request_data, guint request_data_len)
471 gpointer fan_control_request_data = NULL;
474 NOT_USED(request_data_len);
477 ops_id = __zblib_request_get_ops_id(request_type);
479 case ZBLIB_ZCL_FAN_CONTROL_OPS_SET_FAN_MODE: {
480 ZigbeeZclFanControlSetFanMode_t *in_req;
481 ZigbeeZclFanControlSetFanMode_t *req = NULL;
483 in_req = (ZigbeeZclFanControlSetFanMode_t *)request_data;
485 /* Allocate memory */
486 req = (ZigbeeZclFanControlSetFanMode_t *)
487 g_malloc0(sizeof(ZigbeeZclFanControlSetFanMode_t));
491 in_req->eui64, ZIGBEE_EUI64_SIZE);
492 req->endpoint = in_req->endpoint;
495 fan_control_request_data = (gpointer)req;
499 case ZBLIB_ZCL_FAN_CONTROL_OPS_GET_FAN_MODE: {
500 ZigbeeZclFanControlGetFanMode_t *in_req;
501 ZigbeeZclFanControlGetFanMode_t *req = NULL;
503 in_req = (ZigbeeZclFanControlGetFanMode_t *)request_data;
505 /* Allocate memory */
506 req = (ZigbeeZclFanControlGetFanMode_t *)
507 g_malloc0(sizeof(ZigbeeZclFanControlGetFanMode_t));
511 in_req->eui64, ZIGBEE_EUI64_SIZE);
512 req->endpoint = in_req->endpoint;
515 fan_control_request_data = (gpointer)req;
519 case ZBLIB_ZCL_FAN_CONTROL_OPS_SET_FAN_MODE_SEQUENCE: {
520 ZigbeeZclFanControlSetFanModeSequence_t *in_req;
521 ZigbeeZclFanControlSetFanModeSequence_t *req = NULL;
523 in_req = (ZigbeeZclFanControlSetFanModeSequence_t *)request_data;
525 /* Allocate memory */
526 req = (ZigbeeZclFanControlSetFanModeSequence_t *)
527 g_malloc0(sizeof(ZigbeeZclFanControlSetFanModeSequence_t));
531 in_req->eui64, ZIGBEE_EUI64_SIZE);
532 req->endpoint = in_req->endpoint;
535 fan_control_request_data = (gpointer)req;
539 case ZBLIB_ZCL_FAN_CONTROL_OPS_GET_FAN_MODE_SEQUENCE: {
540 ZigbeeZclFanControlGetFanModeSequence_t *in_req;
541 ZigbeeZclFanControlGetFanModeSequence_t *req = NULL;
543 in_req = (ZigbeeZclFanControlGetFanModeSequence_t *)request_data;
545 /* Allocate memory */
546 req = (ZigbeeZclFanControlGetFanModeSequence_t *)
547 g_malloc0(sizeof(ZigbeeZclFanControlGetFanModeSequence_t));
551 in_req->eui64, ZIGBEE_EUI64_SIZE);
552 req->endpoint = in_req->endpoint;
555 fan_control_request_data = (gpointer)req;
563 return fan_control_request_data;
566 static gpointer __zblib_request_create_zcl_level_control_request_data(guint request_type,
567 gpointer request_data, guint request_data_len)
569 gpointer level_control_request_data = NULL;
572 NOT_USED(request_data_len);
575 ops_id = __zblib_request_get_ops_id(request_type);
577 case ZBLIB_ZCL_LEVEL_CONTROL_OPS_MOVE_TO_LEVEL: {
578 ZigbeeZclLevelControlMoveToLevel_t *in_req;
579 ZigbeeZclLevelControlMoveToLevel_t *req = NULL;
581 in_req = (ZigbeeZclLevelControlMoveToLevel_t *)request_data;
583 /* Allocate memory */
584 req = (ZigbeeZclLevelControlMoveToLevel_t *)
585 g_malloc0(sizeof(ZigbeeZclLevelControlMoveToLevel_t));
588 req->node_id = in_req->node_id;
589 req->endpoint = in_req->endpoint;
590 req->level = in_req->level;
591 req->transition = in_req->transition;
594 level_control_request_data = (gpointer)req;
598 case ZBLIB_ZCL_LEVEL_CONTROL_OPS_MOVE: {
599 ZigbeeZclLevelControlMove_t *in_req;
600 ZigbeeZclLevelControlMove_t *req = NULL;
602 in_req = (ZigbeeZclLevelControlMove_t *)request_data;
604 /* Allocate memory */
605 req = (ZigbeeZclLevelControlMove_t *)
606 g_malloc0(sizeof(ZigbeeZclLevelControlMove_t));
609 req->node_id = in_req->node_id;
610 req->endpoint = in_req->endpoint;
611 req->move_mode = in_req->move_mode;
612 req->rate = in_req->rate;
615 level_control_request_data = (gpointer)req;
619 case ZBLIB_ZCL_LEVEL_CONTROL_OPS_STEP: {
620 ZigbeeZclLevelControlStep_t *in_req;
621 ZigbeeZclLevelControlStep_t *req = NULL;
623 in_req = (ZigbeeZclLevelControlStep_t *)request_data;
625 /* Allocate memory */
626 req = (ZigbeeZclLevelControlStep_t *)
627 g_malloc0(sizeof(ZigbeeZclLevelControlStep_t));
630 req->node_id = in_req->node_id;
631 req->endpoint = in_req->endpoint;
632 req->step_mode = in_req->step_mode;
633 req->step_size = in_req->step_size;
634 req->transition_time = in_req->transition_time;
637 level_control_request_data = (gpointer)req;
641 case ZBLIB_ZCL_LEVEL_CONTROL_OPS_MOVE_TO_LEVEL_WITH_ON_OFF: {
642 ZigbeeZclLevelControlMoveToLevelWithOnOff_t *in_req;
643 ZigbeeZclLevelControlMoveToLevelWithOnOff_t *req = NULL;
645 in_req = (ZigbeeZclLevelControlMoveToLevelWithOnOff_t *)request_data;
647 /* Allocate memory */
648 req = (ZigbeeZclLevelControlMoveToLevelWithOnOff_t *)
649 g_malloc0(sizeof(ZigbeeZclLevelControlMoveToLevelWithOnOff_t));
652 req->node_id = in_req->node_id;
653 req->endpoint = in_req->endpoint;
654 req->level = in_req->level;
655 req->transition = in_req->transition;
658 level_control_request_data = (gpointer)req;
662 case ZBLIB_ZCL_LEVEL_CONTROL_OPS_MOVE_WITH_ON_OFF: {
663 ZigbeeZclLevelControlMoveWithOnOff_t *in_req;
664 ZigbeeZclLevelControlMoveWithOnOff_t *req = NULL;
666 in_req = (ZigbeeZclLevelControlMoveWithOnOff_t *)request_data;
668 /* Allocate memory */
669 req = (ZigbeeZclLevelControlMoveWithOnOff_t *)
670 g_malloc0(sizeof(ZigbeeZclLevelControlMoveWithOnOff_t));
673 req->node_id = in_req->node_id;
674 req->endpoint = in_req->endpoint;
675 req->move_mode = in_req->move_mode;
676 req->rate = in_req->rate;
679 level_control_request_data = (gpointer)req;
683 case ZBLIB_ZCL_LEVEL_CONTROL_OPS_STEP_WITH_ON_OFF: {
684 ZigbeeZclLevelControlStepWithOnOff_t *in_req;
685 ZigbeeZclLevelControlStepWithOnOff_t *req = NULL;
687 in_req = (ZigbeeZclLevelControlStepWithOnOff_t *)request_data;
689 /* Allocate memory */
690 req = (ZigbeeZclLevelControlStepWithOnOff_t *)
691 g_malloc0(sizeof(ZigbeeZclLevelControlStepWithOnOff_t));
694 req->node_id = in_req->node_id;
695 req->endpoint = in_req->endpoint;
696 req->step_mode = in_req->step_mode;
697 req->step_size = in_req->step_size;
698 req->transition_time = in_req->transition_time;
701 level_control_request_data = (gpointer)req;
705 case ZBLIB_ZCL_LEVEL_CONTROL_OPS_STOP: {
706 ZigbeeZclLevelControlStop_t *in_req;
707 ZigbeeZclLevelControlStop_t *req = NULL;
709 in_req = (ZigbeeZclLevelControlStop_t *)request_data;
711 /* Allocate memory */
712 req = (ZigbeeZclLevelControlStop_t *)
713 g_malloc0(sizeof(ZigbeeZclLevelControlStop_t));
716 req->node_id = in_req->node_id;
717 req->endpoint = in_req->endpoint;
720 level_control_request_data = (gpointer)req;
728 return level_control_request_data;
731 static gpointer __zblib_request_create_mfglib_control_request_data(guint request_type,
732 gpointer request_data, guint request_data_len)
734 gpointer mfglib_control_request_data = NULL;
737 NOT_USED(request_data_len);
740 ops_id = __zblib_request_get_ops_id(request_type);
742 case ZBLIB_MFGLIB_CONTROL_OPS_START: {
743 ZigbeeMfglibControlStart_t *in_req;
744 ZigbeeMfglibControlStart_t *req = NULL;
746 in_req = (ZigbeeMfglibControlStart_t *)request_data;
747 if (NULL != in_req) {
748 /* Allocate memory */
749 req = (ZigbeeMfglibControlStart_t *)
750 g_malloc0(sizeof(ZigbeeMfglibControlStart_t));
753 memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
754 req->mfglib_start = in_req->mfglib_start;
757 mfglib_control_request_data = (gpointer)req;
761 case ZBLIB_MFGLIB_CONTROL_OPS_END: {
762 ZigbeeMfglibControlEnd_t *in_req;
763 ZigbeeMfglibControlEnd_t *req = NULL;
765 in_req = (ZigbeeMfglibControlEnd_t *)request_data;
766 if (NULL != in_req) {
767 /* Allocate memory */
768 req = (ZigbeeMfglibControlEnd_t *)
769 g_malloc0(sizeof(ZigbeeMfglibControlEnd_t));
772 memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
775 mfglib_control_request_data = (gpointer)req;
779 case ZBLIB_MFGLIB_CONTROL_OPS_START_TONE: {
780 ZigbeeMfglibControlStartTone_t *in_req;
781 ZigbeeMfglibControlStartTone_t *req = NULL;
783 in_req = (ZigbeeMfglibControlStartTone_t *)request_data;
784 if (NULL != in_req) {
785 /* Allocate memory */
786 req = (ZigbeeMfglibControlStartTone_t *)
787 g_malloc0(sizeof(ZigbeeMfglibControlStartTone_t));
790 memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
793 mfglib_control_request_data = (gpointer)req;
797 case ZBLIB_MFGLIB_CONTROL_OPS_STOP_TONE: {
798 ZigbeeMfglibControlStopTone_t *in_req;
799 ZigbeeMfglibControlStopTone_t *req = NULL;
801 in_req = (ZigbeeMfglibControlStopTone_t *)request_data;
802 if (NULL != in_req) {
803 /* Allocate memory */
804 req = (ZigbeeMfglibControlStopTone_t *)
805 g_malloc0(sizeof(ZigbeeMfglibControlStopTone_t));
808 memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
811 mfglib_control_request_data = (gpointer)req;
815 case ZBLIB_MFGLIB_CONTROL_OPS_START_STREAM: {
816 ZigbeeMfglibControlStartStream_t *in_req;
817 ZigbeeMfglibControlStartStream_t *req = NULL;
819 in_req = (ZigbeeMfglibControlStartStream_t *)request_data;
820 if (NULL != in_req) {
821 /* Allocate memory */
822 req = (ZigbeeMfglibControlStartStream_t *)
823 g_malloc0(sizeof(ZigbeeMfglibControlStartStream_t));
826 memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
829 mfglib_control_request_data = (gpointer)req;
833 case ZBLIB_MFGLIB_CONTROL_OPS_STOP_STREAM: {
834 ZigbeeMfglibControlStopStream_t *in_req;
835 ZigbeeMfglibControlStopStream_t *req = NULL;
837 in_req = (ZigbeeMfglibControlStopStream_t *)request_data;
838 if (NULL != in_req) {
839 /* Allocate memory */
840 req = (ZigbeeMfglibControlStopStream_t *)
841 g_malloc0(sizeof(ZigbeeMfglibControlStopStream_t));
844 memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
847 mfglib_control_request_data = (gpointer)req;
851 case ZBLIB_MFGLIB_CONTROL_OPS_SEND_PACKET: {
852 ZigbeeMfglibControlSendPacket_t *in_req;
853 ZigbeeMfglibControlSendPacket_t *req = NULL;
855 in_req = (ZigbeeMfglibControlSendPacket_t *)request_data;
856 if (NULL != in_req) {
857 /* Allocate memory */
858 req = (ZigbeeMfglibControlSendPacket_t *)
859 g_malloc0(sizeof(ZigbeeMfglibControlSendPacket_t));
862 memcpy(req->packet_content,
863 in_req->packet_content,
864 ZIGBEE_MFGLIB_CONTROL_PACKET_CONTENT_LEN);
865 req->packet_length = in_req->packet_length;
868 mfglib_control_request_data = (gpointer)req;
872 case ZBLIB_MFGLIB_CONTROL_OPS_SET_CHANNEL: {
873 ZigbeeMfglibControlSetChannel_t *in_req;
874 ZigbeeMfglibControlSetChannel_t *req = NULL;
876 in_req = (ZigbeeMfglibControlSetChannel_t *)request_data;
877 if (NULL != in_req) {
878 /* Allocate memory */
879 req = (ZigbeeMfglibControlSetChannel_t *)
880 g_malloc0(sizeof(ZigbeeMfglibControlSetChannel_t));
883 memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
884 req->channel = in_req->channel;
887 mfglib_control_request_data = (gpointer)req;
891 case ZBLIB_MFGLIB_CONTROL_OPS_GET_CHANNEL: {
892 ZigbeeMfglibControlGetChannel_t *in_req;
893 ZigbeeMfglibControlGetChannel_t *req = NULL;
895 in_req = (ZigbeeMfglibControlGetChannel_t *)request_data;
896 if (NULL != in_req) {
897 /* Allocate memory */
898 req = (ZigbeeMfglibControlGetChannel_t *)
899 g_malloc0(sizeof(ZigbeeMfglibControlGetChannel_t));
902 memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
905 mfglib_control_request_data = (gpointer)req;
909 case ZBLIB_MFGLIB_CONTROL_OPS_SET_POWER: {
910 ZigbeeMfglibControlSetPower_t *in_req;
911 ZigbeeMfglibControlSetPower_t *req = NULL;
913 in_req = (ZigbeeMfglibControlSetPower_t *)request_data;
914 if (NULL != in_req) {
915 /* Allocate memory */
916 req = (ZigbeeMfglibControlSetPower_t *)
917 g_malloc0(sizeof(ZigbeeMfglibControlSetPower_t));
920 memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
921 req->tx_power_mode = in_req->tx_power_mode;
922 req->power = in_req->power;
925 mfglib_control_request_data = (gpointer)req;
929 case ZBLIB_MFGLIB_CONTROL_OPS_GET_POWER: {
930 ZigbeeMfglibControlGetPower_t *in_req;
931 ZigbeeMfglibControlGetPower_t *req = NULL;
933 in_req = (ZigbeeMfglibControlGetPower_t *)request_data;
934 if (NULL != in_req) {
935 /* Allocate memory */
936 req = (ZigbeeMfglibControlGetPower_t *)
937 g_malloc0(sizeof(ZigbeeMfglibControlGetPower_t));
940 memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
943 mfglib_control_request_data = (gpointer)req;
947 case ZBLIB_MFGLIB_CONTROL_OPS_SET_SYNOFFSET: {
948 ZigbeeMfglibControlSetSynOffset_t *in_req;
949 ZigbeeMfglibControlSetSynOffset_t *req = NULL;
951 in_req = (ZigbeeMfglibControlSetSynOffset_t *)request_data;
952 if (NULL != in_req) {
953 /* Allocate memory */
954 req = (ZigbeeMfglibControlSetSynOffset_t *)
955 g_malloc0(sizeof(ZigbeeMfglibControlSetSynOffset_t));
958 memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
959 req->channel = in_req->channel;
962 mfglib_control_request_data = (gpointer)req;
966 case ZBLIB_MFGLIB_CONTROL_OPS_GET_SYNOFFSET: {
967 ZigbeeMfglibControlGetSynOffset_t *in_req;
968 ZigbeeMfglibControlGetSynOffset_t *req = NULL;
970 in_req = (ZigbeeMfglibControlGetSynOffset_t *)request_data;
971 if (NULL != in_req) {
972 /* Allocate memory */
973 req = (ZigbeeMfglibControlGetSynOffset_t *)
974 g_malloc0(sizeof(ZigbeeMfglibControlGetSynOffset_t));
979 ZIGBEE_MFGLIB_CONTROL_PACKET_CONTENT_LEN);
980 req->packet_length = in_req->packet_length;
981 req->link_quality = in_req->link_quality;
982 req->rssi = in_req->rssi;
985 mfglib_control_request_data = (gpointer)req;
989 case ZBLIB_MFGLIB_CONTROL_OPS_RX_START: {
990 ZigbeeMfglibControlRxStart_t *in_req;
991 ZigbeeMfglibControlRxStart_t *req = NULL;
993 in_req = (ZigbeeMfglibControlRxStart_t *)request_data;
994 if (NULL != in_req) {
995 /* Allocate memory */
996 req = (ZigbeeMfglibControlRxStart_t *)
997 g_malloc0(sizeof(ZigbeeMfglibControlRxStart_t));
1000 memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
1003 mfglib_control_request_data = (gpointer)req;
1007 case ZBLIB_MFGLIB_CONTROL_OPS_RX_STOP: {
1008 ZigbeeMfglibControlRxStop_t *in_req;
1009 ZigbeeMfglibControlRxStop_t *req = NULL;
1011 in_req = (ZigbeeMfglibControlRxStop_t *)request_data;
1012 if (NULL != in_req) {
1013 /* Allocate memory */
1014 req = (ZigbeeMfglibControlRxStop_t *)
1015 g_malloc0(sizeof(ZigbeeMfglibControlRxStop_t));
1018 memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
1021 mfglib_control_request_data = (gpointer)req;
1025 case ZBLIB_MFGLIB_CONTROL_OPS_RX_VERIFY: {
1026 ZigbeeMfglibControlRxVerify_t *in_req;
1027 ZigbeeMfglibControlRxVerify_t *req = NULL;
1029 in_req = (ZigbeeMfglibControlRxVerify_t *)request_data;
1030 if (NULL != in_req) {
1031 /* Allocate memory */
1032 req = (ZigbeeMfglibControlRxVerify_t *)
1033 g_malloc0(sizeof(ZigbeeMfglibControlRxVerify_t));
1036 memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
1039 mfglib_control_request_data = (gpointer)req;
1043 case ZBLIB_MFGLIB_CONTROL_OPS_GET_RSSI: {
1044 ZigbeeMfglibControlGetRssi_t *in_req;
1045 ZigbeeMfglibControlGetRssi_t *req = NULL;
1047 in_req = (ZigbeeMfglibControlGetRssi_t *)request_data;
1048 if (NULL != in_req) {
1049 /* Allocate memory */
1050 req = (ZigbeeMfglibControlGetRssi_t *)
1051 g_malloc0(sizeof(ZigbeeMfglibControlGetRssi_t));
1054 memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
1057 mfglib_control_request_data = (gpointer)req;
1065 return mfglib_control_request_data;
1068 static gpointer __zblib_request_create_zcl_on_off_request_data(guint request_type,
1069 gpointer request_data, guint request_data_len)
1071 gpointer on_off_request_data = NULL;
1074 NOT_USED(request_data_len);
1077 ops_id = __zblib_request_get_ops_id(request_type);
1079 case ZBLIB_ZCL_ON_OFF_OPS_SET_ON_OFF: {
1080 ZigbeeZclOnOffSetOnOff_t *in_req;
1081 ZigbeeZclOnOffSetOnOff_t *req = NULL;
1083 in_req = (ZigbeeZclOnOffSetOnOff_t *)request_data;
1084 if (NULL != in_req) {
1085 /* Allocate memory */
1086 req = (ZigbeeZclOnOffSetOnOff_t *)
1087 g_malloc0(sizeof(ZigbeeZclOnOffSetOnOff_t));
1090 req->node_id = in_req->node_id;
1091 req->endpoint = in_req->endpoint;
1092 req->on_off_type = in_req->on_off_type;
1095 on_off_request_data = (gpointer)req;
1099 case ZBLIB_ZCL_ON_OFF_OPS_GET_ON_OFF_STATE: {
1100 ZigbeeZclOnOffGetOnOffState_t *in_req;
1101 ZigbeeZclOnOffGetOnOffState_t *req = NULL;
1103 in_req = (ZigbeeZclOnOffGetOnOffState_t *)request_data;
1104 if (NULL != in_req) {
1105 /* Allocate memory */
1106 req = (ZigbeeZclOnOffGetOnOffState_t *)
1107 g_malloc0(sizeof(ZigbeeZclOnOffGetOnOffState_t));
1110 req->node_id = in_req->node_id;
1111 req->endpoint = in_req->endpoint;
1114 on_off_request_data = (gpointer)req;
1122 return on_off_request_data;
1125 static gpointer __zblib_request_create_service_request_data(guint request_type,
1126 gpointer request_data, guint request_data_len)
1128 gpointer service_request_data = NULL;
1131 NOT_USED(request_data_len);
1134 ops_id = __zblib_request_get_ops_id(request_type);
1136 case ZBLIB_SERVICE_OPS_ENABLE: {
1137 service_request_data = NULL;
1141 case ZBLIB_SERVICE_OPS_DISABLE: {
1142 service_request_data = NULL;
1146 case ZBLIB_SERVICE_OPS_ZB_HW_RESET: {
1147 service_request_data = NULL;
1151 case ZBLIB_SERVICE_OPS_FORM_NETWORK: {
1152 service_request_data = NULL;
1156 case ZBLIB_SERVICE_OPS_COEX_START: {
1157 ZigbeeServiceCoexStart_t *in_req;
1158 ZigbeeServiceCoexStart_t *req = NULL;
1160 in_req = (ZigbeeServiceCoexStart_t *)request_data;
1161 if (NULL != in_req) {
1162 /* Allocate memory */
1163 req = (ZigbeeServiceCoexStart_t *)
1164 g_malloc0(sizeof(ZigbeeServiceCoexStart_t));
1167 req->channel = in_req->channel;
1170 service_request_data = (gpointer)req;
1174 case ZBLIB_SERVICE_OPS_COEX_STOP: {
1175 service_request_data = NULL;
1179 case ZBLIB_SERVICE_OPS_LEAVE_NETWORK: {
1180 service_request_data = NULL;
1184 case ZBLIB_SERVICE_OPS_GET_NETWORK_INFO: {
1185 service_request_data = NULL;
1189 case ZBLIB_SERVICE_OPS_PERMIT_JOIN: {
1190 ZigbeeServicePermitJoin_t *in_req;
1191 ZigbeeServicePermitJoin_t *req = NULL;
1193 in_req = (ZigbeeServicePermitJoin_t *)request_data;
1194 if (NULL != in_req) {
1195 /* Allocate memory */
1196 req = (ZigbeeServicePermitJoin_t *)
1197 g_malloc0(sizeof(ZigbeeServicePermitJoin_t));
1200 req->permit_join = in_req->permit_join;
1201 req->duration = in_req->duration;
1204 service_request_data = (gpointer)req;
1208 case ZBLIB_SERVICE_OPS_LEAVE_REQUEST: {
1209 ZigbeeServiceLeaveRequest_t *in_req;
1210 ZigbeeServiceLeaveRequest_t *req = NULL;
1212 in_req = (ZigbeeServiceLeaveRequest_t *)request_data;
1213 if (NULL != in_req) {
1214 /* Allocate memory */
1215 req = (ZigbeeServiceLeaveRequest_t *)
1216 g_malloc0(sizeof(ZigbeeServiceLeaveRequest_t));
1219 memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
1220 req->remove_child = in_req->remove_child;
1221 req->rejoin = in_req->rejoin;
1224 service_request_data = (gpointer)req;
1228 case ZBLIB_SERVICE_OPS_GET_DEVICE_LIST: {
1229 service_request_data = NULL;
1233 case ZBLIB_SERVICE_OPS_GET_MAC: {
1234 service_request_data = NULL;
1238 case ZBLIB_SERVICE_OPS_GET_DEVICE_INFO: {
1239 service_request_data = NULL;
1243 case ZBLIB_SERVICE_OPS_GET_ENDPOINT_LIST: {
1244 ZigbeeServiceGetEndpointList_t *in_req;
1245 ZigbeeServiceGetEndpointList_t *req = NULL;
1247 in_req = (ZigbeeServiceGetEndpointList_t *)request_data;
1248 if (NULL != in_req) {
1249 /* Allocate memory */
1250 req = (ZigbeeServiceGetEndpointList_t *)
1251 g_malloc0(sizeof(ZigbeeServiceGetEndpointList_t));
1254 memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
1257 service_request_data = (gpointer)req;
1261 case ZBLIB_SERVICE_OPS_GET_CLUSTER_LIST: {
1262 ZigbeeServiceGetClusterList_t *in_req;
1263 ZigbeeServiceGetClusterList_t *req = NULL;
1265 in_req = (ZigbeeServiceGetClusterList_t *)request_data;
1266 if (NULL != in_req) {
1267 /* Allocate memory */
1268 req = (ZigbeeServiceGetClusterList_t *)
1269 g_malloc0(sizeof(ZigbeeServiceGetClusterList_t));
1272 memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
1273 req->endpoint = in_req->endpoint;
1276 service_request_data = (gpointer)req;
1280 case ZBLIB_SERVICE_OPS_GET_NODE_TYPE: {
1281 ZigbeeServiceGetNodeType_t *in_req;
1282 ZigbeeServiceGetNodeType_t *req = NULL;
1284 in_req = (ZigbeeServiceGetNodeType_t *)request_data;
1285 if (NULL != in_req) {
1286 /* Allocate memory */
1287 req = (ZigbeeServiceGetNodeType_t *)
1288 g_malloc0(sizeof(ZigbeeServiceGetNodeType_t));
1291 memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
1294 service_request_data = (gpointer)req;
1299 Z_LOGE("Unexpected operation [%x]", ops_id);
1303 return service_request_data;
1306 static gpointer __zblib_request_create_zcl_thermostat_request_data(guint request_type,
1307 gpointer request_data, guint request_data_len)
1309 gpointer thermostat_request_data = NULL;
1312 NOT_USED(request_data_len);
1315 ops_id = __zblib_request_get_ops_id(request_type);
1317 case ZBLIB_ZCL_THERMOSTAT_OPS_GET_LOCAL_TEMP: {
1318 ZigbeeZclThermostatGetLocalTemp_t *in_req;
1319 ZigbeeZclThermostatGetLocalTemp_t *req = NULL;
1321 in_req = (ZigbeeZclThermostatGetLocalTemp_t *)request_data;
1322 if (NULL != in_req) {
1323 /* Allocate memory */
1324 req = (ZigbeeZclThermostatGetLocalTemp_t *)
1325 g_malloc0(sizeof(ZigbeeZclThermostatGetLocalTemp_t));
1328 memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
1329 req->endpoint = in_req->endpoint;
1332 thermostat_request_data = (gpointer)req;
1336 case ZBLIB_ZCL_THERMOSTAT_OPS_GET_WEEKLY_SCHEDULE: {
1337 ZigbeeZclThermostatGetWeeklySchedule_t *in_req;
1338 ZigbeeZclThermostatGetWeeklySchedule_t *req = NULL;
1340 in_req = (ZigbeeZclThermostatGetWeeklySchedule_t *)request_data;
1341 if (NULL != in_req) {
1342 /* Allocate memory */
1343 req = (ZigbeeZclThermostatGetWeeklySchedule_t *)
1344 g_malloc0(sizeof(ZigbeeZclThermostatGetWeeklySchedule_t));
1347 memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
1348 req->endpoint = in_req->endpoint;
1349 req->num_of_days = in_req->num_of_days;
1350 req->mode = in_req->mode;
1353 thermostat_request_data = (gpointer)req;
1357 case ZBLIB_ZCL_THERMOSTAT_OPS_SET_WEEKLY_SCHEDULE: {
1358 ZigbeeZclThermostatSetWeeklySchedule_t *in_req;
1359 ZigbeeZclThermostatSetWeeklySchedule_t *req = NULL;
1361 in_req = (ZigbeeZclThermostatSetWeeklySchedule_t *)request_data;
1362 if (NULL != in_req) {
1363 /* Allocate memory */
1364 req = (ZigbeeZclThermostatSetWeeklySchedule_t *)
1365 g_malloc0(sizeof(ZigbeeZclThermostatSetWeeklySchedule_t));
1368 memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
1369 req->endpoint = in_req->endpoint;
1370 req->no_of_transitions = in_req->no_of_transitions;
1371 req->num_of_days = in_req->num_of_days;
1372 req->mode = in_req->mode;
1373 memcpy(req->payload,
1374 in_req->payload, ZIGBEE_THERMSTAT_PAYLOAD_MAX_LEN);
1375 req->payload_len = in_req->payload_len;
1378 thermostat_request_data = (gpointer)req;
1382 case ZBLIB_ZCL_THERMOSTAT_OPS_CLEAR_WEEKLY_SCHEDULE: {
1383 ZigbeeZclThermostatClearWeeklySchedule_t *in_req;
1384 ZigbeeZclThermostatClearWeeklySchedule_t *req = NULL;
1386 in_req = (ZigbeeZclThermostatClearWeeklySchedule_t *)request_data;
1387 if (NULL != in_req) {
1388 /* Allocate memory */
1389 req = (ZigbeeZclThermostatClearWeeklySchedule_t *)
1390 g_malloc0(sizeof(ZigbeeZclThermostatClearWeeklySchedule_t));
1393 memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
1394 req->endpoint = in_req->endpoint;
1397 thermostat_request_data = (gpointer)req;
1401 case ZBLIB_ZCL_THERMOSTAT_OPS_SETPOINT_RAISE_LOWER: {
1402 ZigbeeZclThermostatSetpointRaiseLower_t *in_req;
1403 ZigbeeZclThermostatSetpointRaiseLower_t *req = NULL;
1405 in_req = (ZigbeeZclThermostatSetpointRaiseLower_t *)request_data;
1406 if (NULL != in_req) {
1407 /* Allocate memory */
1408 req = (ZigbeeZclThermostatSetpointRaiseLower_t *)
1409 g_malloc0(sizeof(ZigbeeZclThermostatSetpointRaiseLower_t));
1412 req->node_id = in_req->node_id;
1413 req->endpoint = in_req->endpoint;
1414 req->mode = in_req->mode;
1415 req->amount = in_req->amount;
1418 thermostat_request_data = (gpointer)req;
1426 return thermostat_request_data;
1429 static gpointer __zblib_request_create_zcl_basic_request_data(guint request_type,
1430 gpointer request_data, guint request_data_len)
1432 gpointer zclbasic_control_request_data = NULL;
1435 NOT_USED(request_data_len);
1438 ops_id = __zblib_request_get_ops_id(request_type);
1440 case ZBLIB_ZCL_BASIC_OPS_RESET_FACTORY_DEFAULT: {
1441 ZigbeeZclBasicResetFactoryDefault_t *in_req;
1442 ZigbeeZclBasicResetFactoryDefault_t *req = NULL;
1444 in_req = (ZigbeeZclBasicResetFactoryDefault_t *)request_data;
1445 if (NULL != in_req) {
1446 /* Allocate memory */
1447 req = (ZigbeeZclBasicResetFactoryDefault_t *)
1448 g_malloc0(sizeof(ZigbeeZclBasicResetFactoryDefault_t));
1451 req->node_id = in_req->node_id;
1452 req->dest_ep = in_req->dest_ep;
1455 zclbasic_control_request_data = (gpointer)req;
1463 return zclbasic_control_request_data;
1466 static gpointer __zblib_request_create_zcl_global_control_request_data(guint request_type,
1467 gpointer request_data, guint request_data_len)
1469 gpointer zclglobal_control_request_data = NULL;
1472 NOT_USED(request_data_len);
1475 ops_id = __zblib_request_get_ops_id(request_type);
1477 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_READ_ATTRIBUTES_REQ: {
1478 ZigbeeZclGlobalControlReadAttributesRequest_t *in_req;
1479 ZigbeeZclGlobalControlReadAttributesRequest_t *req = NULL;
1481 in_req = (ZigbeeZclGlobalControlReadAttributesRequest_t *)request_data;
1482 if (NULL != in_req) {
1483 /* Allocate memory */
1484 req = (ZigbeeZclGlobalControlReadAttributesRequest_t *)
1485 g_malloc0(sizeof(ZigbeeZclGlobalControlReadAttributesRequest_t));
1488 req->attribute_id = g_strdup(in_req->attribute_id);
1489 req->attribute_id_len = in_req->attribute_id_len;
1490 req->node_id = in_req->node_id;
1491 req->cluster_id = in_req->cluster_id;
1492 req->zcl_frame_ctrl = in_req->zcl_frame_ctrl;
1493 req->dest_ep = in_req->dest_ep;
1496 zclglobal_control_request_data = (gpointer)req;
1500 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_REQ: {
1501 ZigbeeZclGlobalControlWriteAttributesRequest_t *in_req;
1502 ZigbeeZclGlobalControlWriteAttributesRequest_t *req = NULL;
1504 in_req = (ZigbeeZclGlobalControlWriteAttributesRequest_t *)request_data;
1505 if (NULL != in_req) {
1506 /* Allocate memory */
1507 req = (ZigbeeZclGlobalControlWriteAttributesRequest_t *)
1508 g_malloc0(sizeof(ZigbeeZclGlobalControlWriteAttributesRequest_t));
1511 req->write_records = g_strdup(in_req->write_records);
1512 req->records_len = in_req->records_len;
1513 req->node_id = in_req->node_id;
1514 req->cluster_id = in_req->cluster_id;
1515 req->zcl_frame_ctrl = in_req->zcl_frame_ctrl;
1516 req->src_ep = in_req->src_ep;
1517 req->dest_ep = in_req->dest_ep;
1520 zclglobal_control_request_data = (gpointer)req;
1524 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_UNDIVIDED_REQ: {
1525 ZigbeeZclGlobalControlWriteAttributesUndividedRequest_t *in_req;
1526 ZigbeeZclGlobalControlWriteAttributesUndividedRequest_t *req = NULL;
1528 in_req = (ZigbeeZclGlobalControlWriteAttributesUndividedRequest_t *)request_data;
1529 if (NULL != in_req) {
1530 /* Allocate memory */
1531 req = (ZigbeeZclGlobalControlWriteAttributesUndividedRequest_t *)
1532 g_malloc0(sizeof(ZigbeeZclGlobalControlWriteAttributesUndividedRequest_t));
1535 req->write_records = g_strdup(in_req->write_records);
1536 req->records_len = in_req->records_len;
1537 req->node_id = in_req->node_id;
1538 req->cluster_id = in_req->cluster_id;
1539 req->zcl_frame_ctrl = in_req->zcl_frame_ctrl;
1540 req->src_ep = in_req->src_ep;
1541 req->dest_ep = in_req->dest_ep;
1544 zclglobal_control_request_data = (gpointer)req;
1548 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_NO_RESP: {
1549 ZigbeeZclGlobalControlWriteAttributesNoResponse_t *in_req;
1550 ZigbeeZclGlobalControlWriteAttributesNoResponse_t *req = NULL;
1552 in_req = (ZigbeeZclGlobalControlWriteAttributesNoResponse_t *)request_data;
1553 if (NULL != in_req) {
1554 /* Allocate memory */
1555 req = (ZigbeeZclGlobalControlWriteAttributesNoResponse_t *)
1556 g_malloc0(sizeof(ZigbeeZclGlobalControlWriteAttributesNoResponse_t));
1559 req->write_records = g_strdup(in_req->write_records);
1560 req->records_len = in_req->records_len;
1561 req->node_id = in_req->node_id;
1562 req->cluster_id = in_req->cluster_id;
1563 req->zcl_frame_ctrl = in_req->zcl_frame_ctrl;
1564 req->src_ep = in_req->src_ep;
1565 req->dest_ep = in_req->dest_ep;
1568 zclglobal_control_request_data = (gpointer)req;
1572 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_STRUCTURED: {
1573 ZigbeeZclGlobalControlWriteAttributesStructed_t *in_req;
1574 ZigbeeZclGlobalControlWriteAttributesStructed_t *req = NULL;
1576 in_req = (ZigbeeZclGlobalControlWriteAttributesStructed_t *)request_data;
1577 if (NULL != in_req) {
1578 /* Allocate memory */
1579 req = (ZigbeeZclGlobalControlWriteAttributesStructed_t *)
1580 g_malloc0(sizeof(ZigbeeZclGlobalControlWriteAttributesStructed_t));
1583 req->write_records = g_strdup(in_req->write_records);
1584 req->records_len = in_req->records_len;
1585 req->node_id = in_req->node_id;
1586 req->cluster_id = in_req->cluster_id;
1587 req->zcl_frame_ctrl = in_req->zcl_frame_ctrl;
1588 req->src_ep = in_req->src_ep;
1589 req->dest_ep = in_req->dest_ep;
1592 zclglobal_control_request_data = (gpointer)req;
1596 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_READ_ATTRIBUTES_STRUCTURED: {
1597 ZigbeeZclGlobalControlReadAttributesStructed_t *in_req;
1598 ZigbeeZclGlobalControlReadAttributesStructed_t *req = NULL;
1600 in_req = (ZigbeeZclGlobalControlReadAttributesStructed_t *)request_data;
1601 if (NULL != in_req) {
1602 /* Allocate memory */
1603 req = (ZigbeeZclGlobalControlReadAttributesStructed_t *)
1604 g_malloc0(sizeof(ZigbeeZclGlobalControlReadAttributesStructed_t));
1607 req->read_records = g_strdup(in_req->read_records);
1608 req->records_len = in_req->records_len;
1609 req->node_id = in_req->node_id;
1610 req->cluster_id = in_req->cluster_id;
1611 req->zcl_frame_ctrl = in_req->zcl_frame_ctrl;
1612 req->src_ep = in_req->src_ep;
1613 req->dest_ep = in_req->dest_ep;
1616 zclglobal_control_request_data = (gpointer)req;
1620 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_CONFIGURE_REPORTING_REQ: {
1621 ZigbeeZclGlobalControlConfigureReportingReq_t *in_req;
1622 ZigbeeZclGlobalControlConfigureReportingReq_t *req = NULL;
1624 in_req = (ZigbeeZclGlobalControlConfigureReportingReq_t *)request_data;
1625 if (NULL != in_req) {
1626 /* Allocate memory */
1627 req = (ZigbeeZclGlobalControlConfigureReportingReq_t *)
1628 g_malloc0(sizeof(ZigbeeZclGlobalControlConfigureReportingReq_t));
1631 req->read_records = g_strdup(in_req->read_records);
1632 req->records_len = in_req->records_len;
1633 req->node_id = in_req->node_id;
1634 req->cluster_id = in_req->cluster_id;
1635 req->zcl_frame_ctrl = in_req->zcl_frame_ctrl;
1636 req->src_ep = in_req->src_ep;
1637 req->dest_ep = in_req->dest_ep;
1640 zclglobal_control_request_data = (gpointer)req;
1644 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_READ_CONFIGURE_REPORTING: {
1645 ZigbeeZclGlobalControlReadConfigureReporting_t *in_req;
1646 ZigbeeZclGlobalControlReadConfigureReporting_t *req = NULL;
1648 in_req = (ZigbeeZclGlobalControlReadConfigureReporting_t *)request_data;
1649 if (NULL != in_req) {
1650 /* Allocate memory */
1651 req = (ZigbeeZclGlobalControlReadConfigureReporting_t *)
1652 g_malloc0(sizeof(ZigbeeZclGlobalControlReadConfigureReporting_t));
1655 req->read_records = g_strdup(in_req->read_records);
1656 req->records_len = in_req->records_len;
1657 req->node_id = in_req->node_id;
1658 req->cluster_id = in_req->cluster_id;
1659 req->zcl_frame_ctrl = in_req->zcl_frame_ctrl;
1660 req->src_ep = in_req->src_ep;
1661 req->dest_ep = in_req->dest_ep;
1664 zclglobal_control_request_data = (gpointer)req;
1668 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_DISCOVER_ATTRIBUTES: {
1669 ZigbeeZclGlobalControlDiscoverAttributes_t *in_req;
1670 ZigbeeZclGlobalControlDiscoverAttributes_t *req = NULL;
1672 in_req = (ZigbeeZclGlobalControlDiscoverAttributes_t *)request_data;
1673 if (NULL != in_req) {
1674 /* Allocate memory */
1675 req = (ZigbeeZclGlobalControlDiscoverAttributes_t *)
1676 g_malloc0(sizeof(ZigbeeZclGlobalControlDiscoverAttributes_t));
1679 req->node_id = in_req->node_id;
1680 req->dest_ep = in_req->dest_ep;
1681 req->zcl_frame_ctrl = in_req->zcl_frame_ctrl;
1682 req->cluster_id = in_req->cluster_id;
1683 req->start_attribute = in_req->start_attribute;
1684 req->max = in_req->max;
1687 zclglobal_control_request_data = (gpointer)req;
1691 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_DISCOVER_ATTRIBUTES_EXTENDED: {
1692 ZigbeeZclGlobalControlDiscoverAttributesExtended_t *in_req;
1693 ZigbeeZclGlobalControlDiscoverAttributesExtended_t *req = NULL;
1695 in_req = (ZigbeeZclGlobalControlDiscoverAttributesExtended_t *)request_data;
1696 if (NULL != in_req) {
1697 /* Allocate memory */
1698 req = (ZigbeeZclGlobalControlDiscoverAttributesExtended_t *)
1699 g_malloc0(sizeof(ZigbeeZclGlobalControlDiscoverAttributesExtended_t));
1702 req->node_id = in_req->node_id;
1703 req->dest_ep = in_req->dest_ep;
1704 req->zcl_frame_ctrl = in_req->zcl_frame_ctrl;
1705 req->cluster_id = in_req->cluster_id;
1706 req->start_attribute = in_req->start_attribute;
1707 req->max = in_req->max;
1710 zclglobal_control_request_data = (gpointer)req;
1714 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_DISCOVER_COMMANDS_RECEIVED: {
1715 ZigbeeZclGlobalControlDiscoverCommandsReceived_t *in_req;
1716 ZigbeeZclGlobalControlDiscoverCommandsReceived_t *req = NULL;
1718 in_req = (ZigbeeZclGlobalControlDiscoverCommandsReceived_t *)request_data;
1719 if (NULL != in_req) {
1720 /* Allocate memory */
1721 req = (ZigbeeZclGlobalControlDiscoverCommandsReceived_t *)
1722 g_malloc0(sizeof(ZigbeeZclGlobalControlDiscoverCommandsReceived_t));
1725 req->node_id = in_req->node_id;
1726 req->dest_ep = in_req->dest_ep;
1727 req->zcl_frame_ctrl = in_req->zcl_frame_ctrl;
1728 req->cluster_id = in_req->cluster_id;
1729 req->start_attribute = in_req->start_attribute;
1730 req->max = in_req->max;
1733 zclglobal_control_request_data = (gpointer)req;
1737 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_DISCOVER_COMMANDS_GENERATED: {
1738 ZigbeeZclGlobalControlDiscoverCommandsGenerated_t *in_req;
1739 ZigbeeZclGlobalControlDiscoverCommandsGenerated_t *req = NULL;
1741 in_req = (ZigbeeZclGlobalControlDiscoverCommandsGenerated_t *)request_data;
1742 if (NULL != in_req) {
1743 /* Allocate memory */
1744 req = (ZigbeeZclGlobalControlDiscoverCommandsGenerated_t *)
1745 g_malloc0(sizeof(ZigbeeZclGlobalControlDiscoverCommandsGenerated_t));
1748 req->node_id = in_req->node_id;
1749 req->dest_ep = in_req->dest_ep;
1750 req->zcl_frame_ctrl = in_req->zcl_frame_ctrl;
1751 req->cluster_id = in_req->cluster_id;
1752 req->start_attribute = in_req->start_attribute;
1753 req->max = in_req->max;
1756 zclglobal_control_request_data = (gpointer)req;
1764 return zclglobal_control_request_data;
1767 static gpointer __zblib_request_create_zcl_ias_zone_request_data(guint request_type,
1768 gpointer request_data, guint request_data_len)
1770 gpointer zclias_control_request_data = NULL;
1773 NOT_USED(request_data_len);
1776 ops_id = __zblib_request_get_ops_id(request_type);
1778 case ZBLIB_ZCL_IAS_ZONE_OPS_ENROLL_RESPONSE: {
1779 ZigbeeZclIasZoneEnrollResponse_t *in_req;
1780 ZigbeeZclIasZoneEnrollResponse_t *req = NULL;
1782 in_req = (ZigbeeZclIasZoneEnrollResponse_t *)request_data;
1783 if (NULL != in_req) {
1784 /* Allocate memory */
1785 req = (ZigbeeZclIasZoneEnrollResponse_t *)
1786 g_malloc0(sizeof(ZigbeeZclIasZoneEnrollResponse_t));
1789 req->node_id = in_req->node_id;
1790 req->dest_ep = in_req->dest_ep;
1791 req->enroll_code = in_req->enroll_code;
1792 req->zone_id = in_req->zone_id;
1795 zclias_control_request_data = (gpointer)req;
1803 return zclias_control_request_data;
1806 static gpointer __zblib_request_create_zcl_identify_request_data(guint request_type,
1807 gpointer request_data, guint request_data_len)
1809 gpointer zclidentify_control_request_data = NULL;
1812 NOT_USED(request_data_len);
1815 ops_id = __zblib_request_get_ops_id(request_type);
1817 case ZBLIB_ZCL_IDENTIFY_OPS_IDENTIFY: {
1818 ZigbeeZclIdentifyIdentify_t *in_req;
1819 ZigbeeZclIdentifyIdentify_t *req = NULL;
1821 in_req = (ZigbeeZclIdentifyIdentify_t *)request_data;
1822 if (NULL != in_req) {
1823 /* Allocate memory */
1824 req = (ZigbeeZclIdentifyIdentify_t *)
1825 g_malloc0(sizeof(ZigbeeZclIdentifyIdentify_t));
1828 req->node_id = in_req->node_id;
1829 req->dest_ep = in_req->dest_ep;
1830 req->identify_time = in_req->identify_time;
1833 zclidentify_control_request_data = (gpointer)req;
1837 case ZBLIB_ZCL_IDENTIFY_OPS_QUERY: {
1838 ZigbeeZclIdentifyQuery_t *in_req;
1839 ZigbeeZclIdentifyQuery_t *req = NULL;
1841 in_req = (ZigbeeZclIdentifyQuery_t *)request_data;
1842 if (NULL != in_req) {
1843 /* Allocate memory */
1844 req = (ZigbeeZclIdentifyQuery_t *)
1845 g_malloc0(sizeof(ZigbeeZclIdentifyQuery_t));
1848 req->node_id = in_req->node_id;
1851 zclidentify_control_request_data = (gpointer)req;
1859 return zclidentify_control_request_data;
1862 static gpointer __zblib_request_create_zcl_color_control_request_data(guint request_type,
1863 gpointer request_data, guint request_data_len)
1865 gpointer zcl_color_request_data = NULL;
1868 NOT_USED(request_data_len);
1871 ops_id = __zblib_request_get_ops_id(request_type);
1873 case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_TO_HUE: {
1874 ZigbeeZclColorControlMoveToHue_t *in_req;
1875 ZigbeeZclColorControlMoveToHue_t *req = NULL;
1877 in_req = (ZigbeeZclColorControlMoveToHue_t *)request_data;
1878 if (NULL != in_req) {
1879 /* Allocate memory */
1880 req = (ZigbeeZclColorControlMoveToHue_t *)
1881 g_malloc0(sizeof(ZigbeeZclColorControlMoveToHue_t));
1884 req->node_id = in_req->node_id;
1885 req->dest_ep = in_req->dest_ep;
1886 req->hue = in_req->hue;
1887 req->direction = in_req->direction;
1888 req->transition_time = in_req->transition_time;
1891 zcl_color_request_data = (gpointer)req;
1895 case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_HUE: {
1896 ZigbeeZclColorControlMoveHue_t *in_req;
1897 ZigbeeZclColorControlMoveHue_t *req = NULL;
1899 in_req = (ZigbeeZclColorControlMoveHue_t *)request_data;
1900 if (NULL != in_req) {
1901 /* Allocate memory */
1902 req = (ZigbeeZclColorControlMoveHue_t *)
1903 g_malloc0(sizeof(ZigbeeZclColorControlMoveHue_t));
1906 req->node_id = in_req->node_id;
1907 req->dest_ep = in_req->dest_ep;
1908 req->move_mode = in_req->move_mode;
1909 req->rate = in_req->rate;
1912 zcl_color_request_data = (gpointer)req;
1916 case ZBLIB_ZCL_COLOR_CONTROL_OPS_STEP_HUE: {
1917 ZigbeeZclColorControlStepHue_t *in_req;
1918 ZigbeeZclColorControlStepHue_t *req = NULL;
1920 in_req = (ZigbeeZclColorControlStepHue_t *)request_data;
1921 if (NULL != in_req) {
1922 /* Allocate memory */
1923 req = (ZigbeeZclColorControlStepHue_t *)
1924 g_malloc0(sizeof(ZigbeeZclColorControlStepHue_t));
1927 req->node_id = in_req->node_id;
1928 req->dest_ep = in_req->dest_ep;
1929 req->step_mode = in_req->step_mode;
1930 req->step_size = in_req->step_size;
1931 req->transition_time = in_req->transition_time;
1934 zcl_color_request_data = (gpointer)req;
1938 case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_TO_STAURATION: {
1939 ZigbeeZclColorControlMoveToSaturation_t *in_req;
1940 ZigbeeZclColorControlMoveToSaturation_t *req = NULL;
1942 in_req = (ZigbeeZclColorControlMoveToSaturation_t *)request_data;
1943 if (NULL != in_req) {
1944 /* Allocate memory */
1945 req = (ZigbeeZclColorControlMoveToSaturation_t *)
1946 g_malloc0(sizeof(ZigbeeZclColorControlMoveToSaturation_t));
1949 req->node_id = in_req->node_id;
1950 req->dest_ep = in_req->dest_ep;
1951 req->saturation = in_req->saturation;
1952 req->transition_time = in_req->transition_time;
1955 zcl_color_request_data = (gpointer)req;
1959 case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_STAURATION: {
1960 ZigbeeZclColorControlMoveSaturation_t *in_req;
1961 ZigbeeZclColorControlMoveSaturation_t *req = NULL;
1963 in_req = (ZigbeeZclColorControlMoveSaturation_t *)request_data;
1964 if (NULL != in_req) {
1965 /* Allocate memory */
1966 req = (ZigbeeZclColorControlMoveSaturation_t *)
1967 g_malloc0(sizeof(ZigbeeZclColorControlMoveSaturation_t));
1970 req->node_id = in_req->node_id;
1971 req->dest_ep = in_req->dest_ep;
1972 req->move_mode = in_req->move_mode;
1973 req->rate = in_req->rate;
1976 zcl_color_request_data = (gpointer)req;
1980 case ZBLIB_ZCL_COLOR_CONTROL_OPS_STEP_STAURATION: {
1981 ZigbeeZclColorControlStepSaturation_t *in_req;
1982 ZigbeeZclColorControlStepSaturation_t *req = NULL;
1984 in_req = (ZigbeeZclColorControlStepSaturation_t *)request_data;
1985 if (NULL != in_req) {
1986 /* Allocate memory */
1987 req = (ZigbeeZclColorControlStepSaturation_t *)
1988 g_malloc0(sizeof(ZigbeeZclColorControlStepSaturation_t));
1991 req->node_id = in_req->node_id;
1992 req->dest_ep = in_req->dest_ep;
1993 req->step_mode = in_req->step_mode;
1994 req->step_size = in_req->step_size;
1995 req->transition_time = in_req->transition_time;
1998 zcl_color_request_data = (gpointer)req;
2002 case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_TO_HUE_AND_SATURATION: {
2003 ZigbeeZclColorControlMoveToHueAndSaturation_t *in_req;
2004 ZigbeeZclColorControlMoveToHueAndSaturation_t *req = NULL;
2006 in_req = (ZigbeeZclColorControlMoveToHueAndSaturation_t *)request_data;
2007 if (NULL != in_req) {
2008 /* Allocate memory */
2009 req = (ZigbeeZclColorControlMoveToHueAndSaturation_t *)
2010 g_malloc0(sizeof(ZigbeeZclColorControlMoveToHueAndSaturation_t));
2013 req->node_id = in_req->node_id;
2014 req->dest_ep = in_req->dest_ep;
2015 req->hue = in_req->hue;
2016 req->saturation = in_req->saturation;
2017 req->transition_time = in_req->transition_time;
2020 zcl_color_request_data = (gpointer)req;
2024 case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_TO_COLOR: {
2025 ZigbeeZclColorControlMoveToColor_t *in_req;
2026 ZigbeeZclColorControlMoveToColor_t *req = NULL;
2028 in_req = (ZigbeeZclColorControlMoveToColor_t *)request_data;
2029 if (NULL != in_req) {
2030 /* Allocate memory */
2031 req = (ZigbeeZclColorControlMoveToColor_t *)
2032 g_malloc0(sizeof(ZigbeeZclColorControlMoveToColor_t));
2035 req->node_id = in_req->node_id;
2036 req->dest_ep = in_req->dest_ep;
2037 req->color_x = in_req->color_x;
2038 req->color_y = in_req->color_y;
2039 req->transition_time = in_req->transition_time;
2042 zcl_color_request_data = (gpointer)req;
2046 case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_COLOR: {
2047 ZigbeeZclColorControlMoveColor_t *in_req;
2048 ZigbeeZclColorControlMoveColor_t *req = NULL;
2050 in_req = (ZigbeeZclColorControlMoveColor_t *)request_data;
2051 if (NULL != in_req) {
2052 /* Allocate memory */
2053 req = (ZigbeeZclColorControlMoveColor_t *)
2054 g_malloc0(sizeof(ZigbeeZclColorControlMoveColor_t));
2057 req->node_id = in_req->node_id;
2058 req->dest_ep = in_req->dest_ep;
2059 req->rate_x = in_req->rate_x;
2060 req->rate_y = in_req->rate_y;
2063 zcl_color_request_data = (gpointer)req;
2067 case ZBLIB_ZCL_COLOR_CONTROL_OPS_STEP_COLOR: {
2068 ZigbeeZclColorControlStepColor_t *in_req;
2069 ZigbeeZclColorControlStepColor_t *req = NULL;
2071 in_req = (ZigbeeZclColorControlStepColor_t *)request_data;
2072 if (NULL != in_req) {
2073 /* Allocate memory */
2074 req = (ZigbeeZclColorControlStepColor_t *)
2075 g_malloc0(sizeof(ZigbeeZclColorControlStepColor_t));
2078 req->node_id = in_req->node_id;
2079 req->dest_ep = in_req->dest_ep;
2080 req->step_x = in_req->step_x;
2081 req->step_y = in_req->step_y;
2082 req->transition_time = in_req->transition_time;
2085 zcl_color_request_data = (gpointer)req;
2089 case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_COLOR_TEMPERATURE: {
2090 ZigbeeZclColorControlMoveColorTemperature_t *in_req;
2091 ZigbeeZclColorControlMoveColorTemperature_t *req = NULL;
2093 in_req = (ZigbeeZclColorControlMoveColorTemperature_t *)request_data;
2094 if (NULL != in_req) {
2095 /* Allocate memory */
2096 req = (ZigbeeZclColorControlMoveColorTemperature_t *)
2097 g_malloc0(sizeof(ZigbeeZclColorControlMoveColorTemperature_t));
2100 req->node_id = in_req->node_id;
2101 req->dest_ep = in_req->dest_ep;
2102 req->color_temperature = in_req->color_temperature;
2103 req->transition_time = in_req->transition_time;
2106 zcl_color_request_data = (gpointer)req;
2114 return zcl_color_request_data;
2117 static gpointer __zblib_request_create_zcl_group_request_data(guint request_type,
2118 gpointer request_data, guint request_data_len)
2120 gpointer zcl_group_request_data = NULL;
2123 NOT_USED(request_data_len);
2126 ops_id = __zblib_request_get_ops_id(request_type);
2128 case ZBLIB_ZCL_GROUP_OPS_ADD_GROUP: {
2129 ZigbeeZclGroupAddGroup_t *in_req;
2130 ZigbeeZclGroupAddGroup_t *req = NULL;
2132 in_req = (ZigbeeZclGroupAddGroup_t *)request_data;
2133 if (NULL != in_req) {
2134 /* Allocate memory */
2135 req = (ZigbeeZclGroupAddGroup_t *)
2136 g_malloc0(sizeof(ZigbeeZclGroupAddGroup_t));
2139 req->node_id = in_req->node_id;
2140 req->dest_ep = in_req->dest_ep;
2141 req->group_id = in_req->group_id;
2142 g_strlcpy(req->group_name,
2143 in_req->group_name, ZIGBEE_ZCL_GROUP_NAME_MAX_LEN + 1);
2146 zcl_group_request_data = (gpointer)req;
2150 case ZBLIB_ZCL_GROUP_OPS_VIEW_GROUP: {
2151 ZigbeeZclGroupViewGroup_t *in_req;
2152 ZigbeeZclGroupViewGroup_t *req = NULL;
2154 in_req = (ZigbeeZclGroupViewGroup_t *)request_data;
2155 if (NULL != in_req) {
2156 /* Allocate memory */
2157 req = (ZigbeeZclGroupViewGroup_t *)
2158 g_malloc0(sizeof(ZigbeeZclGroupViewGroup_t));
2161 req->node_id = in_req->node_id;
2162 req->dest_ep = in_req->dest_ep;
2165 zcl_group_request_data = (gpointer)req;
2169 case ZBLIB_ZCL_GROUP_OPS_GET_GROUP_MEMBERSHIP: {
2170 ZigbeeZclGroupGetGroupMembership_t *in_req;
2171 ZigbeeZclGroupGetGroupMembership_t *req = NULL;
2173 in_req = (ZigbeeZclGroupGetGroupMembership_t *)request_data;
2174 if (NULL != in_req) {
2175 /* Allocate memory */
2176 req = (ZigbeeZclGroupGetGroupMembership_t *)
2177 g_malloc0(sizeof(ZigbeeZclGroupGetGroupMembership_t));
2180 req->node_id = in_req->node_id;
2181 req->dest_ep = in_req->dest_ep;
2182 req->group_count = in_req->group_count;
2183 req->group_list = (gshort *)g_memdup(in_req->group_list,
2184 in_req->group_count);
2187 zcl_group_request_data = (gpointer)req;
2191 case ZBLIB_ZCL_GROUP_OPS_REMOVE_GROUP: {
2192 ZigbeeZclGroupRemoveGroup_t *in_req;
2193 ZigbeeZclGroupRemoveGroup_t *req = NULL;
2195 in_req = (ZigbeeZclGroupRemoveGroup_t *)request_data;
2196 if (NULL != in_req) {
2197 /* Allocate memory */
2198 req = (ZigbeeZclGroupRemoveGroup_t *)
2199 g_malloc0(sizeof(ZigbeeZclGroupRemoveGroup_t));
2202 req->node_id = in_req->node_id;
2203 req->dest_ep = in_req->dest_ep;
2204 req->group_id = in_req->group_id;
2207 zcl_group_request_data = (gpointer)req;
2211 case ZBLIB_ZCL_GROUP_OPS_REMOVE_ALL_GROUP: {
2212 ZigbeeZclGroupRemoveAllGroup_t *in_req;
2213 ZigbeeZclGroupRemoveAllGroup_t *req = NULL;
2215 in_req = (ZigbeeZclGroupRemoveAllGroup_t *)request_data;
2216 if (NULL != in_req) {
2217 /* Allocate memory */
2218 req = (ZigbeeZclGroupRemoveAllGroup_t *)
2219 g_malloc0(sizeof(ZigbeeZclGroupRemoveAllGroup_t));
2222 req->node_id = in_req->node_id;
2223 req->dest_ep = in_req->dest_ep;
2226 zcl_group_request_data = (gpointer)req;
2230 case ZBLIB_ZCL_GROUP_OPS_ADD_GROUP_IF_IDENTIFYING: {
2231 ZigbeeZclGroupAddGroupIfIdentifying_t *in_req;
2232 ZigbeeZclGroupAddGroupIfIdentifying_t *req = NULL;
2234 in_req = (ZigbeeZclGroupAddGroupIfIdentifying_t *)request_data;
2235 if (NULL != in_req) {
2236 /* Allocate memory */
2237 req = (ZigbeeZclGroupAddGroupIfIdentifying_t *)
2238 g_malloc0(sizeof(ZigbeeZclGroupAddGroupIfIdentifying_t));
2241 req->node_id = in_req->node_id;
2242 req->dest_ep = in_req->dest_ep;
2243 req->group_id = in_req->group_id;
2244 g_strlcpy(req->group_name,
2245 in_req->group_name, ZIGBEE_ZCL_GROUP_NAME_MAX_LEN + 1);
2248 zcl_group_request_data = (gpointer)req;
2256 return zcl_group_request_data;
2259 static gpointer __zblib_request_create_zcl_poll_control_request_data(guint request_type,
2260 gpointer request_data, guint request_data_len)
2262 gpointer zcl_poll_control_request_data = NULL;
2265 NOT_USED(request_data_len);
2268 ops_id = __zblib_request_get_ops_id(request_type);
2270 case ZBLIB_ZCL_POLL_CONTROL_OPS_CHECK_IN_RESPONSE: {
2271 ZigbeeZclPollControlCheckInResponse_t *in_req;
2272 ZigbeeZclPollControlCheckInResponse_t *req = NULL;
2274 in_req = (ZigbeeZclPollControlCheckInResponse_t *)request_data;
2275 if (NULL != in_req) {
2276 /* Allocate memory */
2277 req = (ZigbeeZclPollControlCheckInResponse_t *)
2278 g_malloc0(sizeof(ZigbeeZclPollControlCheckInResponse_t));
2281 req->node_id = in_req->node_id;
2282 req->dest_ep = in_req->dest_ep;
2283 req->start_fast_polling = in_req->start_fast_polling;
2284 req->fast_poll_timeout = in_req->fast_poll_timeout;
2287 zcl_poll_control_request_data = (gpointer)req;
2291 case ZBLIB_ZCL_POLL_CONTROL_OPS_FAST_POLL_STOP: {
2292 ZigbeeZclPollControlFastPollStop_t *in_req;
2293 ZigbeeZclPollControlFastPollStop_t *req = NULL;
2295 in_req = (ZigbeeZclPollControlFastPollStop_t *)request_data;
2296 if (NULL != in_req) {
2297 /* Allocate memory */
2298 req = (ZigbeeZclPollControlFastPollStop_t *)
2299 g_malloc0(sizeof(ZigbeeZclPollControlFastPollStop_t));
2302 req->node_id = in_req->node_id;
2303 req->dest_ep = in_req->dest_ep;
2306 zcl_poll_control_request_data = (gpointer)req;
2310 case ZBLIB_ZCL_POLL_CONTROL_OPS_SET_LONG_POLL_INTERVAL: {
2311 ZigbeeZclPollControlSetLongPollInterval_t *in_req;
2312 ZigbeeZclPollControlSetLongPollInterval_t *req = NULL;
2314 in_req = (ZigbeeZclPollControlSetLongPollInterval_t *)request_data;
2315 if (NULL != in_req) {
2316 /* Allocate memory */
2317 req = (ZigbeeZclPollControlSetLongPollInterval_t *)
2318 g_malloc0(sizeof(ZigbeeZclPollControlSetLongPollInterval_t));
2321 req->node_id = in_req->node_id;
2322 req->dest_ep = in_req->dest_ep;
2323 req->new_long_poll_interval = in_req->new_long_poll_interval;
2326 zcl_poll_control_request_data = (gpointer)req;
2330 case ZBLIB_ZCL_POLL_CONTROL_OPS_SET_SHORT_POLL_INTERVAL: {
2331 ZigbeeZclPollControlSetShortPollInterval_t *in_req;
2332 ZigbeeZclPollControlSetShortPollInterval_t *req = NULL;
2334 in_req = (ZigbeeZclPollControlSetShortPollInterval_t *)request_data;
2335 if (NULL != in_req) {
2336 /* Allocate memory */
2337 req = (ZigbeeZclPollControlSetShortPollInterval_t *)
2338 g_malloc0(sizeof(ZigbeeZclPollControlSetShortPollInterval_t));
2341 req->node_id = in_req->node_id;
2342 req->dest_ep = in_req->dest_ep;
2343 req->new_short_poll_interval = in_req->new_short_poll_interval;
2346 zcl_poll_control_request_data = (gpointer)req;
2354 return zcl_poll_control_request_data;
2357 static gpointer __zblib_request_create_zcl_scene_request_data(guint request_type,
2358 gpointer request_data, guint request_data_len)
2360 gpointer zcl_scene_request_data = NULL;
2363 NOT_USED(request_data_len);
2366 ops_id = __zblib_request_get_ops_id(request_type);
2368 case ZBLIB_ZCL_SCENE_OPS_ADD_SCENE: {
2369 ZigbeeZclSceneAddScene_t *in_req;
2370 ZigbeeZclSceneAddScene_t *req = NULL;
2372 in_req = (ZigbeeZclSceneAddScene_t *)request_data;
2373 if (NULL != in_req) {
2374 /* Allocate memory */
2375 req = (ZigbeeZclSceneAddScene_t *)
2376 g_malloc0(sizeof(ZigbeeZclSceneAddScene_t));
2379 req->node_id = in_req->node_id;
2380 req->dest_ep = in_req->dest_ep;
2381 req->group_id = in_req->group_id;
2382 req->scene_id = in_req->scene_id;
2383 req->transition_time = in_req->transition_time;
2384 g_strlcpy(req->scene_name,
2385 in_req->scene_name, ZIGBEE_ZCL_SCENE_NAME_MAX_LEN + 1);
2386 req->ext_field_set_len = in_req->ext_field_set_len;
2387 req->ext_field_set = (gshort *)g_memdup(in_req->ext_field_set,
2388 in_req->ext_field_set_len);
2391 zcl_scene_request_data = (gpointer)req;
2395 case ZBLIB_ZCL_SCENE_OPS_VIEW_SCENE: {
2396 ZigbeeZclSceneViewScene_t *in_req;
2397 ZigbeeZclSceneViewScene_t *req = NULL;
2399 in_req = (ZigbeeZclSceneViewScene_t *)request_data;
2400 if (NULL != in_req) {
2401 /* Allocate memory */
2402 req = (ZigbeeZclSceneViewScene_t *)
2403 g_malloc0(sizeof(ZigbeeZclSceneViewScene_t));
2406 req->node_id = in_req->node_id;
2407 req->dest_ep = in_req->dest_ep;
2408 req->group_id = in_req->group_id;
2409 req->scene_id = in_req->scene_id;
2412 zcl_scene_request_data = (gpointer)req;
2416 case ZBLIB_ZCL_SCENE_OPS_REMOVE_SCENE: {
2417 ZigbeeZclSceneRemoveScene_t *in_req;
2418 ZigbeeZclSceneRemoveScene_t *req = NULL;
2420 in_req = (ZigbeeZclSceneRemoveScene_t *)request_data;
2421 if (NULL != in_req) {
2422 /* Allocate memory */
2423 req = (ZigbeeZclSceneRemoveScene_t *)
2424 g_malloc0(sizeof(ZigbeeZclSceneRemoveScene_t));
2427 req->node_id = in_req->node_id;
2428 req->dest_ep = in_req->dest_ep;
2429 req->group_id = in_req->group_id;
2430 req->scene_id = in_req->scene_id;
2433 zcl_scene_request_data = (gpointer)req;
2437 case ZBLIB_ZCL_SCENE_OPS_STORE_SCENE: {
2438 ZigbeeZclSceneStoreScene_t *in_req;
2439 ZigbeeZclSceneStoreScene_t *req = NULL;
2441 in_req = (ZigbeeZclSceneStoreScene_t *)request_data;
2442 if (NULL != in_req) {
2443 /* Allocate memory */
2444 req = (ZigbeeZclSceneStoreScene_t *)
2445 g_malloc0(sizeof(ZigbeeZclSceneStoreScene_t));
2448 req->node_id = in_req->node_id;
2449 req->dest_ep = in_req->dest_ep;
2450 req->group_id = in_req->group_id;
2451 req->scene_id = in_req->scene_id;
2454 zcl_scene_request_data = (gpointer)req;
2458 case ZBLIB_ZCL_SCENE_OPS_RECALL_SCENE: {
2459 ZigbeeZclSceneRecallScene_t *in_req;
2460 ZigbeeZclSceneRecallScene_t *req = NULL;
2462 in_req = (ZigbeeZclSceneRecallScene_t *)request_data;
2463 if (NULL != in_req) {
2464 /* Allocate memory */
2465 req = (ZigbeeZclSceneRecallScene_t *)
2466 g_malloc0(sizeof(ZigbeeZclSceneRecallScene_t));
2469 req->node_id = in_req->node_id;
2470 req->dest_ep = in_req->dest_ep;
2471 req->group_id = in_req->group_id;
2472 req->scene_id = in_req->scene_id;
2475 zcl_scene_request_data = (gpointer)req;
2479 case ZBLIB_ZCL_SCENE_OPS_REMOVE_ALL_SCENE: {
2480 ZigbeeZclSceneRemoveAllScene_t *in_req;
2481 ZigbeeZclSceneRemoveAllScene_t *req = NULL;
2483 in_req = (ZigbeeZclSceneRemoveAllScene_t *)request_data;
2484 if (NULL != in_req) {
2485 /* Allocate memory */
2486 req = (ZigbeeZclSceneRemoveAllScene_t *)
2487 g_malloc0(sizeof(ZigbeeZclSceneRemoveAllScene_t));
2490 req->node_id = in_req->node_id;
2491 req->dest_ep = in_req->dest_ep;
2492 req->group_id = in_req->group_id;
2495 zcl_scene_request_data = (gpointer)req;
2499 case ZBLIB_ZCL_SCENE_OPS_GET_SCENE_MEMBERSHIP: {
2500 ZigbeeZclSceneGetSceneMembership_t *in_req;
2501 ZigbeeZclSceneGetSceneMembership_t *req = NULL;
2503 in_req = (ZigbeeZclSceneGetSceneMembership_t *)request_data;
2504 if (NULL != in_req) {
2505 /* Allocate memory */
2506 req = (ZigbeeZclSceneGetSceneMembership_t *)
2507 g_malloc0(sizeof(ZigbeeZclSceneGetSceneMembership_t));
2510 req->node_id = in_req->node_id;
2511 req->dest_ep = in_req->dest_ep;
2512 req->group_id = in_req->group_id;
2515 zcl_scene_request_data = (gpointer)req;
2523 return zcl_scene_request_data;
2526 static gpointer __zblib_request_create_zdo_dev_control_request_data(guint request_type,
2527 gpointer request_data, guint request_data_len)
2529 gpointer zdodev_control_request_data = NULL;
2532 NOT_USED(request_data_len);
2535 ops_id = __zblib_request_get_ops_id(request_type);
2537 case ZBLIB_ZDO_DEV_CONTROL_OPS_NWK_ADDR_REQ: {
2538 ZigbeeZdoDevControlNwkAddrReq_t *in_req;
2539 ZigbeeZdoDevControlNwkAddrReq_t *req = NULL;
2541 in_req = (ZigbeeZdoDevControlNwkAddrReq_t *)request_data;
2542 if (NULL != in_req) {
2543 /* Allocate memory */
2544 req = (ZigbeeZdoDevControlNwkAddrReq_t *)
2545 g_malloc0(sizeof(ZigbeeZdoDevControlNwkAddrReq_t));
2548 memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
2549 req->request_type = in_req->request_type;
2550 req->start_index = in_req->start_index;
2553 zdodev_control_request_data = (gpointer)req;
2557 case ZBLIB_ZDO_DEV_CONTROL_OPS_MATCHED_DESCRIPTOR_REQ: {
2558 ZigbeeZdoDevControlMatchedDescriptorReq_t *in_req;
2559 ZigbeeZdoDevControlMatchedDescriptorReq_t *req = NULL;
2561 in_req = (ZigbeeZdoDevControlMatchedDescriptorReq_t *)request_data;
2562 if (NULL != in_req) {
2563 /* Allocate memory */
2564 req = (ZigbeeZdoDevControlMatchedDescriptorReq_t *)
2565 g_malloc0(sizeof(ZigbeeZdoDevControlMatchedDescriptorReq_t));
2568 req->node_id = in_req->node_id;
2569 req->profile_id = in_req->profile_id;
2570 req->num_in_cl = in_req->num_in_cl;
2571 req->in_cl = g_strdup(in_req->in_cl);
2572 req->num_out_cl = in_req->num_out_cl;
2573 req->out_cl = g_strdup(in_req->out_cl);
2576 zdodev_control_request_data = (gpointer)req;
2580 case ZBLIB_ZDO_DEV_CONTROL_OPS_IEEE_ADDR_REQ: {
2581 ZigbeeZdoDevControlIeeeAddrReq_t *in_req;
2582 ZigbeeZdoDevControlIeeeAddrReq_t *req = NULL;
2584 in_req = (ZigbeeZdoDevControlIeeeAddrReq_t *)request_data;
2585 if (NULL != in_req) {
2586 /* Allocate memory */
2587 req = (ZigbeeZdoDevControlIeeeAddrReq_t *)
2588 g_malloc0(sizeof(ZigbeeZdoDevControlIeeeAddrReq_t));
2591 req->node_id = in_req->node_id;
2594 zdodev_control_request_data = (gpointer)req;
2598 case ZBLIB_ZDO_DEV_CONTROL_OPS_ACTIVE_EP_REQ: {
2599 ZigbeeZdoDevControlActiveEpReq_t *in_req;
2600 ZigbeeZdoDevControlActiveEpReq_t *req = NULL;
2602 in_req = (ZigbeeZdoDevControlActiveEpReq_t *)request_data;
2603 if (NULL != in_req) {
2604 /* Allocate memory */
2605 req = (ZigbeeZdoDevControlActiveEpReq_t *)
2606 g_malloc0(sizeof(ZigbeeZdoDevControlActiveEpReq_t));
2609 req->node_id = in_req->node_id;
2612 zdodev_control_request_data = (gpointer)req;
2616 case ZBLIB_ZDO_DEV_CONTROL_OPS_NODE_DESC_REQ: {
2617 ZigbeeZdoDevControlNodeDescriptorReq_t *in_req;
2618 ZigbeeZdoDevControlNodeDescriptorReq_t *req = NULL;
2620 in_req = (ZigbeeZdoDevControlNodeDescriptorReq_t *)request_data;
2621 if (NULL != in_req) {
2622 /* Allocate memory */
2623 req = (ZigbeeZdoDevControlNodeDescriptorReq_t *)
2624 g_malloc0(sizeof(ZigbeeZdoDevControlNodeDescriptorReq_t));
2627 req->node_id = in_req->node_id;
2630 zdodev_control_request_data = (gpointer)req;
2634 case ZBLIB_ZDO_DEV_CONTROL_OPS_POWER_DESC_REQ: {
2635 ZigbeeZdoDevControlPowerDescriptorReq_t *in_req;
2636 ZigbeeZdoDevControlPowerDescriptorReq_t *req = NULL;
2638 in_req = (ZigbeeZdoDevControlPowerDescriptorReq_t *)request_data;
2639 if (NULL != in_req) {
2640 /* Allocate memory */
2641 req = (ZigbeeZdoDevControlPowerDescriptorReq_t *)
2642 g_malloc0(sizeof(ZigbeeZdoDevControlPowerDescriptorReq_t));
2645 req->node_id = in_req->node_id;
2648 zdodev_control_request_data = (gpointer)req;
2652 case ZBLIB_ZDO_DEV_CONTROL_OPS_COMPLEX_DESC_REQ: {
2653 ZigbeeZdoDevControlComplexDescriptorReq_t *in_req;
2654 ZigbeeZdoDevControlComplexDescriptorReq_t *req = NULL;
2656 in_req = (ZigbeeZdoDevControlComplexDescriptorReq_t *)request_data;
2657 if (NULL != in_req) {
2658 /* Allocate memory */
2659 req = (ZigbeeZdoDevControlComplexDescriptorReq_t *)
2660 g_malloc0(sizeof(ZigbeeZdoDevControlComplexDescriptorReq_t));
2663 req->node_id = in_req->node_id;
2666 zdodev_control_request_data = (gpointer)req;
2670 case ZBLIB_ZDO_DEV_CONTROL_OPS_USER_DESC_REQ: {
2671 ZigbeeZdoDevControlUserDescriptorReq_t *in_req;
2672 ZigbeeZdoDevControlUserDescriptorReq_t *req = NULL;
2674 in_req = (ZigbeeZdoDevControlUserDescriptorReq_t *)request_data;
2675 if (NULL != in_req) {
2676 /* Allocate memory */
2677 req = (ZigbeeZdoDevControlUserDescriptorReq_t *)
2678 g_malloc0(sizeof(ZigbeeZdoDevControlUserDescriptorReq_t));
2681 req->node_id = in_req->node_id;
2684 zdodev_control_request_data = (gpointer)req;
2688 case ZBLIB_ZDO_DEV_CONTROL_OPS_USER_DESC_SET_REQ: {
2689 ZigbeeZdoDevControlUserDescriptorSetReq_t *in_req;
2690 ZigbeeZdoDevControlUserDescriptorSetReq_t *req = NULL;
2692 in_req = (ZigbeeZdoDevControlUserDescriptorSetReq_t *)request_data;
2693 if (NULL != in_req) {
2694 /* Allocate memory */
2695 req = (ZigbeeZdoDevControlUserDescriptorSetReq_t *)
2696 g_malloc0(sizeof(ZigbeeZdoDevControlUserDescriptorSetReq_t));
2699 req->node_id = in_req->node_id;
2700 req->user_descriptor_len = in_req->user_descriptor_len;
2701 memcpy(req->user_descriptor,
2702 in_req->user_descriptor, in_req->user_descriptor_len);
2705 zdodev_control_request_data = (gpointer)req;
2709 case ZBLIB_ZDO_DEV_CONTROL_OPS_DEVICE_ANNOUNCE: {
2710 ZigbeeZdoDevControlDeviceAnnounce_t *in_req;
2711 ZigbeeZdoDevControlDeviceAnnounce_t *req = NULL;
2713 in_req = (ZigbeeZdoDevControlDeviceAnnounce_t *)request_data;
2714 if (NULL != in_req) {
2715 /* Allocate memory */
2716 req = (ZigbeeZdoDevControlDeviceAnnounce_t *)
2717 g_malloc0(sizeof(ZigbeeZdoDevControlDeviceAnnounce_t));
2720 req->node_id = in_req->node_id;
2721 memcpy(req->mac_addr, in_req->mac_addr, ZIGBEE_EUI64_SIZE);
2722 req->capability = in_req->capability;
2725 zdodev_control_request_data = (gpointer)req;
2729 case ZBLIB_ZDO_DEV_CONTROL_OPS_SIMPLE_DESC_REQ: {
2730 ZigbeeZdoDevControlSimpleDescriptorReq_t *in_req;
2731 ZigbeeZdoDevControlSimpleDescriptorReq_t *req = NULL;
2733 in_req = (ZigbeeZdoDevControlSimpleDescriptorReq_t *)request_data;
2734 if (NULL != in_req) {
2735 /* Allocate memory */
2736 req = (ZigbeeZdoDevControlSimpleDescriptorReq_t *)
2737 g_malloc0(sizeof(ZigbeeZdoDevControlSimpleDescriptorReq_t));
2740 req->node_id = in_req->node_id;
2741 req->endpoint = in_req->endpoint;
2744 zdodev_control_request_data = (gpointer)req;
2748 case ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_LQI_REQ: {
2749 ZigbeeZdoDevControlMgmtLqiReq_t *in_req;
2750 ZigbeeZdoDevControlMgmtLqiReq_t *req = NULL;
2752 in_req = (ZigbeeZdoDevControlMgmtLqiReq_t *)request_data;
2753 if (NULL != in_req) {
2754 /* Allocate memory */
2755 req = (ZigbeeZdoDevControlMgmtLqiReq_t *)
2756 g_malloc0(sizeof(ZigbeeZdoDevControlMgmtLqiReq_t));
2759 req->node_id = in_req->node_id;
2760 req->start_index = in_req->start_index;
2763 zdodev_control_request_data = (gpointer)req;
2767 case ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_RTG_REQ: {
2768 ZigbeeZdoDevControlMgmtRtgReq_t *in_req;
2769 ZigbeeZdoDevControlMgmtRtgReq_t *req = NULL;
2771 in_req = (ZigbeeZdoDevControlMgmtRtgReq_t *)request_data;
2772 if (NULL != in_req) {
2773 /* Allocate memory */
2774 req = (ZigbeeZdoDevControlMgmtRtgReq_t *)
2775 g_malloc0(sizeof(ZigbeeZdoDevControlMgmtRtgReq_t));
2778 req->node_id = in_req->node_id;
2779 req->start_index = in_req->start_index;
2782 zdodev_control_request_data = (gpointer)req;
2786 case ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_BIND_REQ: {
2787 ZigbeeZdoDevControlMgmtBindReq_t *in_req;
2788 ZigbeeZdoDevControlMgmtBindReq_t *req = NULL;
2790 in_req = (ZigbeeZdoDevControlMgmtBindReq_t *)request_data;
2791 if (NULL != in_req) {
2792 /* Allocate memory */
2793 req = (ZigbeeZdoDevControlMgmtBindReq_t *)
2794 g_malloc0(sizeof(ZigbeeZdoDevControlMgmtBindReq_t));
2797 req->node_id = in_req->node_id;
2798 req->start_index = in_req->start_index;
2801 zdodev_control_request_data = (gpointer)req;
2805 case ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_PERMIT_JOIN_REQ: {
2806 ZigbeeZdoDevControlMgmtPermitJoinReq_t *in_req;
2807 ZigbeeZdoDevControlMgmtPermitJoinReq_t *req = NULL;
2809 in_req = (ZigbeeZdoDevControlMgmtPermitJoinReq_t *)request_data;
2810 if (NULL != in_req) {
2811 /* Allocate memory */
2812 req = (ZigbeeZdoDevControlMgmtPermitJoinReq_t *)
2813 g_malloc0(sizeof(ZigbeeZdoDevControlMgmtPermitJoinReq_t));
2816 req->addr = in_req->addr;
2817 req->duration = in_req->duration;
2818 req->tc_significance = in_req->tc_significance;
2821 zdodev_control_request_data = (gpointer)req;
2825 case ZBLIB_ZDO_DEV_CONTROL_OPS_NWK_UPDATE_REQ: {
2826 ZigbeeZdoDevControlNwkUpdateReq_t *in_req;
2827 ZigbeeZdoDevControlNwkUpdateReq_t *req = NULL;
2829 in_req = (ZigbeeZdoDevControlNwkUpdateReq_t *)request_data;
2830 if (NULL != in_req) {
2831 /* Allocate memory */
2832 req = (ZigbeeZdoDevControlNwkUpdateReq_t *)
2833 g_malloc0(sizeof(ZigbeeZdoDevControlNwkUpdateReq_t));
2836 req->node_id = in_req->node_id;
2837 req->scan_channel = in_req->scan_channel;
2838 req->scan_duration = in_req->scan_duration;
2839 req->scan_count = in_req->scan_count;
2840 req->network_update_id = in_req->network_update_id;
2843 zdodev_control_request_data = (gpointer)req;
2847 case ZBLIB_ZDO_DEV_CONTROL_OPS_NWK_DISC_REQ: {
2848 ZigbeeZdoDevControlNwkDescriptorReq_t *in_req;
2849 ZigbeeZdoDevControlNwkDescriptorReq_t *req = NULL;
2851 in_req = (ZigbeeZdoDevControlNwkDescriptorReq_t *)request_data;
2852 if (NULL != in_req) {
2853 /* Allocate memory */
2854 req = (ZigbeeZdoDevControlNwkDescriptorReq_t *)
2855 g_malloc0(sizeof(ZigbeeZdoDevControlNwkDescriptorReq_t));
2858 req->node_id = in_req->node_id;
2859 req->scan_channel = in_req->scan_channel;
2860 req->scan_duration = in_req->scan_duration;
2861 req->scan_count = in_req->scan_count;
2862 req->start_index = in_req->start_index;
2865 zdodev_control_request_data = (gpointer)req;
2873 return zdodev_control_request_data;
2876 static gpointer __zblib_request_create_zdo_bind_request_data(guint request_type,
2877 gpointer request_data, guint request_data_len)
2879 gpointer zdo_bind_request_data = NULL;
2882 NOT_USED(request_data_len);
2885 ops_id = __zblib_request_get_ops_id(request_type);
2887 case ZBLIB_ZDO_BIND_OPS_BIND_REQ: {
2888 ZigbeeZdoBindBindReq_t *in_req;
2889 ZigbeeZdoBindBindReq_t *req = NULL;
2891 in_req = (ZigbeeZdoBindBindReq_t *)request_data;
2892 if (NULL != in_req) {
2893 /* Allocate memory */
2894 req = (ZigbeeZdoBindBindReq_t *)
2895 g_malloc0(sizeof(ZigbeeZdoBindBindReq_t));
2898 req->node_id = in_req->node_id;
2899 g_strlcpy(req->src_addr,
2900 in_req->src_addr, ZIGBEE_ZDO_BIND_ADDRESS_MAX_LEN + 1);
2901 req->src_ep = in_req->src_ep;
2902 req->cluster_id = in_req->cluster_id;
2903 g_strlcpy(req->dst_addr,
2904 in_req->dst_addr, ZIGBEE_ZDO_BIND_ADDRESS_MAX_LEN + 1);
2905 req->bind_type = in_req->bind_type;
2906 req->group_addr = in_req->group_addr;
2907 req->dst_ep = in_req->dst_ep;
2910 zdo_bind_request_data = (gpointer)req;
2914 case ZBLIB_ZDO_BIND_OPS_UNBIND_REQ: {
2915 ZigbeeZdoBindUnbindReq_t *in_req;
2916 ZigbeeZdoBindUnbindReq_t *req = NULL;
2918 in_req = (ZigbeeZdoBindUnbindReq_t *)request_data;
2919 if (NULL != in_req) {
2920 /* Allocate memory */
2921 req = (ZigbeeZdoBindUnbindReq_t *)
2922 g_malloc0(sizeof(ZigbeeZdoBindUnbindReq_t));
2925 req->node_id = in_req->node_id;
2926 g_strlcpy(req->src_addr,
2927 in_req->src_addr, ZIGBEE_ZDO_BIND_ADDRESS_MAX_LEN + 1);
2928 req->src_ep = in_req->src_ep;
2929 req->cluster_id = in_req->cluster_id;
2930 g_strlcpy(req->dst_addr,
2931 in_req->dst_addr, ZIGBEE_ZDO_BIND_ADDRESS_MAX_LEN + 1);
2932 req->bind_type = in_req->bind_type;
2933 req->group_addr = in_req->group_addr;
2934 req->dst_ep = in_req->dst_ep;
2937 zdo_bind_request_data = (gpointer)req;
2945 return zdo_bind_request_data;
2949 static gpointer __zblib_request_create_request_data(guint request_type,
2950 gpointer request_data, guint request_data_len)
2952 gpointer _request_data = NULL;
2953 ZblibDriverType_e driver_type;
2955 /* Fetch driver type */
2956 driver_type = __zblib_request_get_driver_type(request_type);
2957 switch (driver_type) {
2958 case ZBLIB_DRIVER_TYPE_ZCL_ALARM: {
2959 _request_data = __zblib_request_create_zcl_alarm_request_data(request_type,
2960 request_data, request_data_len);
2964 case ZBLIB_DRIVER_TYPE_CUSTOM: {
2965 _request_data = __zblib_request_create_custom_request_data(request_type,
2966 request_data, request_data_len);
2970 case ZBLIB_DRIVER_TYPE_ZCL_DOOR_LOCK: {
2971 _request_data = __zblib_request_create_zcl_door_lock_request_data(request_type,
2972 request_data, request_data_len);
2976 case ZBLIB_DRIVER_TYPE_ZCL_FAN_CONTROL: {
2977 _request_data = __zblib_request_create_zcl_fan_control_request_data(request_type,
2978 request_data, request_data_len);
2982 case ZBLIB_DRIVER_TYPE_ZCL_LEVEL_CONTROL: {
2983 _request_data = __zblib_request_create_zcl_level_control_request_data(request_type,
2984 request_data, request_data_len);
2988 case ZBLIB_DRIVER_TYPE_MFGLIB_CONTROL: {
2989 _request_data = __zblib_request_create_mfglib_control_request_data(request_type,
2990 request_data, request_data_len);
2994 case ZBLIB_DRIVER_TYPE_ZCL_ON_OFF: {
2995 _request_data = __zblib_request_create_zcl_on_off_request_data(request_type,
2996 request_data, request_data_len);
3000 case ZBLIB_DRIVER_TYPE_SERVICE: {
3001 _request_data = __zblib_request_create_service_request_data(request_type,
3002 request_data, request_data_len);
3006 case ZBLIB_DRIVER_TYPE_ZCL_THERMOSTAT: {
3007 _request_data = __zblib_request_create_zcl_thermostat_request_data(request_type,
3008 request_data, request_data_len);
3012 case ZBLIB_DRIVER_TYPE_ZCL_BASIC: {
3013 _request_data = __zblib_request_create_zcl_basic_request_data(request_type,
3014 request_data, request_data_len);
3018 case ZBLIB_DRIVER_TYPE_ZCL_GLOBAL_CONTROL: {
3019 _request_data = __zblib_request_create_zcl_global_control_request_data(request_type,
3020 request_data, request_data_len);
3024 case ZBLIB_DRIVER_TYPE_ZCL_IAS_ZONE: {
3025 _request_data = __zblib_request_create_zcl_ias_zone_request_data(request_type,
3026 request_data, request_data_len);
3030 case ZBLIB_DRIVER_TYPE_ZCL_IDENTIFY: {
3031 _request_data = __zblib_request_create_zcl_identify_request_data(request_type,
3032 request_data, request_data_len);
3036 case ZBLIB_DRIVER_TYPE_ZCL_COLOR_CONTROL: {
3037 _request_data = __zblib_request_create_zcl_color_control_request_data(request_type,
3038 request_data, request_data_len);
3042 case ZBLIB_DRIVER_TYPE_ZCL_GROUP: {
3043 _request_data = __zblib_request_create_zcl_group_request_data(request_type,
3044 request_data, request_data_len);
3048 case ZBLIB_DRIVER_TYPE_ZCL_POLL_CONTROL: {
3049 _request_data = __zblib_request_create_zcl_poll_control_request_data(request_type,
3050 request_data, request_data_len);
3054 case ZBLIB_DRIVER_TYPE_ZCL_SCENE: {
3055 _request_data = __zblib_request_create_zcl_scene_request_data(request_type,
3056 request_data, request_data_len);
3060 case ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL: {
3061 _request_data = __zblib_request_create_zdo_dev_control_request_data(request_type,
3062 request_data, request_data_len);
3066 case ZBLIB_DRIVER_TYPE_ZDO_BIND: {
3067 _request_data = __zblib_request_create_zdo_bind_request_data(request_type,
3068 request_data, request_data_len);
3072 case ZBLIB_DRIVER_TYPE_NONE: /* Fall through */
3074 Z_LOGE("Unhandled driver type: [%d]", driver_type);
3079 return _request_data;
3082 static void __zblib_request_free_zcl_alarm_request_data(ZigBeeRequest *request,
3088 ops_id = __zblib_request_get_ops_id(request_type);
3090 case ZBLIB_ZCL_ALARM_OPS_GET_ALARM_COUNT: {
3091 ZigbeeZclAlarmGetAlarmCount_t *req = NULL;
3093 req = (ZigbeeZclAlarmGetAlarmCount_t *)request->request_data;
3100 case ZBLIB_ZCL_ALARM_OPS_RESET_ALARM: {
3101 ZigbeeZclAlarmResetAlarm_t *req = NULL;
3103 req = (ZigbeeZclAlarmResetAlarm_t *)request->request_data;
3110 case ZBLIB_ZCL_ALARM_OPS_RESET_ALL_ALARM: {
3111 ZigbeeZclAlarmResetAllAlarm_t *req = NULL;
3113 req = (ZigbeeZclAlarmResetAllAlarm_t *)request->request_data;
3120 case ZBLIB_ZCL_ALARM_OPS_ALARM: {
3121 ZigbeeZclAlarmAlarm_t *req = NULL;
3123 req = (ZigbeeZclAlarmAlarm_t *)request->request_data;
3130 case ZBLIB_ZCL_ALARM_OPS_RESET_ALARM_LOG: {
3131 ZigbeeZclAlarmResetAlarmLogs_t *req = NULL;
3133 req = (ZigbeeZclAlarmResetAlarmLogs_t *)request->request_data;
3140 case ZBLIB_ZCL_ALARM_OPS_GET_ALARM: {
3149 static void __zblib_request_free_custom_request_data(ZigBeeRequest *request,
3155 ops_id = __zblib_request_get_ops_id(request_type);
3157 case ZBLIB_CUSTOM_OPS_APS_SEND: {
3158 ZigbeeCustomApsSend_t *req = NULL;
3160 req = (ZigbeeCustomApsSend_t *)request->request_data;
3167 case ZBLIB_CUSTOM_OPS_ZCL_SEND: {
3168 ZigbeeCustomZclSend_t *req = NULL;
3170 req = (ZigbeeCustomZclSend_t *)request->request_data;
3177 case ZBLIB_CUSTOM_OPS_SEND_TO_LOCAL: {
3178 ZigbeeCustomSendToLocal_t *req = NULL;
3180 req = (ZigbeeCustomSendToLocal_t *)request->request_data;
3192 static void __zblib_request_free_zcl_door_lock_request_data(ZigBeeRequest *request,
3198 ops_id = __zblib_request_get_ops_id(request_type);
3200 case ZBLIB_ZCL_DOOR_LOCK_OPS_SUBSCRIBE_LOCK_EVENT: {
3201 ZigbeeZclDoorLockSubscriberLockEvent_t *req = NULL;
3203 req = (ZigbeeZclDoorLockSubscriberLockEvent_t *)request->request_data;
3210 case ZBLIB_ZCL_DOOR_LOCK_OPS_SET_DOOR_LOCK_PIN: {
3211 ZigbeeZclDoorLockSetDoorLockPin_t *req = NULL;
3213 req = (ZigbeeZclDoorLockSetDoorLockPin_t *)request->request_data;
3220 case ZBLIB_ZCL_DOOR_LOCK_OPS_SET_DOOR_LOCK: {
3221 ZigbeeZclDoorLockSetDoorLock_t *req = NULL;
3223 req = (ZigbeeZclDoorLockSetDoorLock_t *)request->request_data;
3230 case ZBLIB_ZCL_DOOR_LOCK_OPS_GET_LOCK_STATE: {
3231 ZigbeeZclDoorLockGetDoorLock_t *req = NULL;
3233 req = (ZigbeeZclDoorLockGetDoorLock_t *)request->request_data;
3245 static void __zblib_request_free_zcl_fan_control_request_data(ZigBeeRequest *request,
3251 ops_id = __zblib_request_get_ops_id(request_type);
3253 case ZBLIB_ZCL_FAN_CONTROL_OPS_SET_FAN_MODE: {
3254 ZigbeeZclFanControlSetFanMode_t *req = NULL;
3256 req = (ZigbeeZclFanControlSetFanMode_t *)request->request_data;
3263 case ZBLIB_ZCL_FAN_CONTROL_OPS_GET_FAN_MODE: {
3264 ZigbeeZclFanControlGetFanMode_t *req = NULL;
3266 req = (ZigbeeZclFanControlGetFanMode_t *)request->request_data;
3273 case ZBLIB_ZCL_FAN_CONTROL_OPS_SET_FAN_MODE_SEQUENCE: {
3274 ZigbeeZclFanControlSetFanModeSequence_t *req = NULL;
3276 req = (ZigbeeZclFanControlSetFanModeSequence_t *)request->request_data;
3283 case ZBLIB_ZCL_FAN_CONTROL_OPS_GET_FAN_MODE_SEQUENCE: {
3284 ZigbeeZclFanControlGetFanModeSequence_t *req = NULL;
3286 req = (ZigbeeZclFanControlGetFanModeSequence_t *)request->request_data;
3298 static void __zblib_request_free_zcl_level_control_request_data(ZigBeeRequest *request,
3304 ops_id = __zblib_request_get_ops_id(request_type);
3306 case ZBLIB_ZCL_LEVEL_CONTROL_OPS_MOVE_TO_LEVEL: {
3307 ZigbeeZclLevelControlMoveToLevel_t *req = NULL;
3309 req = (ZigbeeZclLevelControlMoveToLevel_t *)request->request_data;
3316 case ZBLIB_ZCL_LEVEL_CONTROL_OPS_MOVE: {
3317 ZigbeeZclLevelControlMove_t *req = NULL;
3319 req = (ZigbeeZclLevelControlMove_t *)request->request_data;
3326 case ZBLIB_ZCL_LEVEL_CONTROL_OPS_STEP: {
3327 ZigbeeZclLevelControlStep_t *req = NULL;
3329 req = (ZigbeeZclLevelControlStep_t *)request->request_data;
3336 case ZBLIB_ZCL_LEVEL_CONTROL_OPS_MOVE_TO_LEVEL_WITH_ON_OFF: {
3337 ZigbeeZclLevelControlMoveToLevelWithOnOff_t *req = NULL;
3339 req = (ZigbeeZclLevelControlMoveToLevelWithOnOff_t *)request->request_data;
3346 case ZBLIB_ZCL_LEVEL_CONTROL_OPS_MOVE_WITH_ON_OFF: {
3347 ZigbeeZclLevelControlMoveWithOnOff_t *req = NULL;
3349 req = (ZigbeeZclLevelControlMoveWithOnOff_t *)request->request_data;
3356 case ZBLIB_ZCL_LEVEL_CONTROL_OPS_STEP_WITH_ON_OFF: {
3357 ZigbeeZclLevelControlStepWithOnOff_t *req = NULL;
3359 req = (ZigbeeZclLevelControlStepWithOnOff_t *)request->request_data;
3366 case ZBLIB_ZCL_LEVEL_CONTROL_OPS_STOP: {
3367 ZigbeeZclLevelControlStop_t *req = NULL;
3369 req = (ZigbeeZclLevelControlStop_t *)request->request_data;
3381 static void __zblib_request_free_mfglib_control_request_data(ZigBeeRequest *request,
3387 ops_id = __zblib_request_get_ops_id(request_type);
3389 case ZBLIB_MFGLIB_CONTROL_OPS_START: {
3390 ZigbeeMfglibControlStart_t *req = NULL;
3392 req = (ZigbeeMfglibControlStart_t *)request->request_data;
3399 case ZBLIB_MFGLIB_CONTROL_OPS_END: {
3400 ZigbeeMfglibControlEnd_t *req = NULL;
3402 req = (ZigbeeMfglibControlEnd_t *)request->request_data;
3409 case ZBLIB_MFGLIB_CONTROL_OPS_START_TONE: {
3410 ZigbeeMfglibControlStartTone_t *req = NULL;
3412 req = (ZigbeeMfglibControlStartTone_t *)request->request_data;
3419 case ZBLIB_MFGLIB_CONTROL_OPS_STOP_TONE: {
3420 ZigbeeMfglibControlStopTone_t *req = NULL;
3422 req = (ZigbeeMfglibControlStopTone_t *)request->request_data;
3429 case ZBLIB_MFGLIB_CONTROL_OPS_START_STREAM: {
3430 ZigbeeMfglibControlStartStream_t *req = NULL;
3432 req = (ZigbeeMfglibControlStartStream_t *)request->request_data;
3439 case ZBLIB_MFGLIB_CONTROL_OPS_STOP_STREAM: {
3440 ZigbeeMfglibControlStopStream_t *req = NULL;
3442 req = (ZigbeeMfglibControlStopStream_t *)request->request_data;
3449 case ZBLIB_MFGLIB_CONTROL_OPS_SEND_PACKET: {
3450 ZigbeeMfglibControlSendPacket_t *req = NULL;
3452 req = (ZigbeeMfglibControlSendPacket_t *)request->request_data;
3459 case ZBLIB_MFGLIB_CONTROL_OPS_SET_CHANNEL: {
3460 ZigbeeMfglibControlSetChannel_t *req = NULL;
3462 req = (ZigbeeMfglibControlSetChannel_t *)request->request_data;
3469 case ZBLIB_MFGLIB_CONTROL_OPS_GET_CHANNEL: {
3470 ZigbeeMfglibControlGetChannel_t *req = NULL;
3472 req = (ZigbeeMfglibControlGetChannel_t *)request->request_data;
3479 case ZBLIB_MFGLIB_CONTROL_OPS_SET_POWER: {
3480 ZigbeeMfglibControlSetPower_t *req = NULL;
3482 req = (ZigbeeMfglibControlSetPower_t *)request->request_data;
3489 case ZBLIB_MFGLIB_CONTROL_OPS_GET_POWER: {
3490 ZigbeeMfglibControlGetPower_t *req = NULL;
3492 req = (ZigbeeMfglibControlGetPower_t *)request->request_data;
3499 case ZBLIB_MFGLIB_CONTROL_OPS_SET_SYNOFFSET: {
3500 ZigbeeMfglibControlSetSynOffset_t *req = NULL;
3502 req = (ZigbeeMfglibControlSetSynOffset_t *)request->request_data;
3509 case ZBLIB_MFGLIB_CONTROL_OPS_GET_SYNOFFSET: {
3510 ZigbeeMfglibControlGetSynOffset_t *req = NULL;
3512 req = (ZigbeeMfglibControlGetSynOffset_t *)request->request_data;
3519 case ZBLIB_MFGLIB_CONTROL_OPS_RX_START: {
3520 ZigbeeMfglibControlRxStart_t *req = NULL;
3522 req = (ZigbeeMfglibControlRxStart_t *)request->request_data;
3529 case ZBLIB_MFGLIB_CONTROL_OPS_RX_STOP: {
3530 ZigbeeMfglibControlRxStop_t *req = NULL;
3532 req = (ZigbeeMfglibControlRxStop_t *)request->request_data;
3539 case ZBLIB_MFGLIB_CONTROL_OPS_RX_VERIFY: {
3540 ZigbeeMfglibControlRxVerify_t *req = NULL;
3542 req = (ZigbeeMfglibControlRxVerify_t *)request->request_data;
3549 case ZBLIB_MFGLIB_CONTROL_OPS_GET_RSSI: {
3550 ZigbeeMfglibControlGetRssi_t *req = NULL;
3552 req = (ZigbeeMfglibControlGetRssi_t *)request->request_data;
3564 static void __zblib_request_free_zcl_on_off_request_data(ZigBeeRequest *request,
3570 ops_id = __zblib_request_get_ops_id(request_type);
3572 case ZBLIB_ZCL_ON_OFF_OPS_SET_ON_OFF: {
3573 ZigbeeZclOnOffSetOnOff_t *req = NULL;
3575 req = (ZigbeeZclOnOffSetOnOff_t *)request->request_data;
3582 case ZBLIB_ZCL_ON_OFF_OPS_GET_ON_OFF_STATE: {
3583 ZigbeeZclOnOffGetOnOffState_t *req = NULL;
3585 req = (ZigbeeZclOnOffGetOnOffState_t *)request->request_data;
3597 static void __zblib_request_free_service_request_data(ZigBeeRequest *request,
3603 ops_id = __zblib_request_get_ops_id(request_type);
3605 case ZBLIB_SERVICE_OPS_ENABLE: {
3609 case ZBLIB_SERVICE_OPS_DISABLE: {
3613 case ZBLIB_SERVICE_OPS_ZB_HW_RESET: {
3617 case ZBLIB_SERVICE_OPS_FORM_NETWORK: {
3621 case ZBLIB_SERVICE_OPS_COEX_START: {
3622 ZigbeeServiceCoexStart_t *req = NULL;
3624 req = (ZigbeeServiceCoexStart_t *)request->request_data;
3631 case ZBLIB_SERVICE_OPS_COEX_STOP: {
3635 case ZBLIB_SERVICE_OPS_LEAVE_NETWORK: {
3639 case ZBLIB_SERVICE_OPS_GET_NETWORK_INFO: {
3643 case ZBLIB_SERVICE_OPS_PERMIT_JOIN: {
3644 ZigbeeServicePermitJoin_t *req = NULL;
3646 req = (ZigbeeServicePermitJoin_t *)request->request_data;
3653 case ZBLIB_SERVICE_OPS_LEAVE_REQUEST: {
3654 ZigbeeServiceLeaveRequest_t *req = NULL;
3656 req = (ZigbeeServiceLeaveRequest_t *)request->request_data;
3663 case ZBLIB_SERVICE_OPS_GET_DEVICE_LIST: {
3667 case ZBLIB_SERVICE_OPS_GET_MAC: {
3671 case ZBLIB_SERVICE_OPS_GET_DEVICE_INFO: {
3675 case ZBLIB_SERVICE_OPS_GET_ENDPOINT_LIST: {
3676 ZigbeeServiceGetEndpointList_t *req = NULL;
3678 req = (ZigbeeServiceGetEndpointList_t *)request->request_data;
3685 case ZBLIB_SERVICE_OPS_GET_CLUSTER_LIST: {
3686 ZigbeeServiceGetClusterList_t *req = NULL;
3688 req = (ZigbeeServiceGetClusterList_t *)request->request_data;
3695 case ZBLIB_SERVICE_OPS_GET_NODE_TYPE: {
3696 ZigbeeServiceGetNodeType_t *req = NULL;
3698 req = (ZigbeeServiceGetNodeType_t *)request->request_data;
3710 static void __zblib_request_free_zcl_thermostat_request_data(ZigBeeRequest *request,
3716 ops_id = __zblib_request_get_ops_id(request_type);
3718 case ZBLIB_ZCL_THERMOSTAT_OPS_GET_LOCAL_TEMP: {
3719 ZigbeeZclThermostatGetLocalTemp_t *req = NULL;
3721 req = (ZigbeeZclThermostatGetLocalTemp_t *)request->request_data;
3728 case ZBLIB_ZCL_THERMOSTAT_OPS_GET_WEEKLY_SCHEDULE: {
3729 ZigbeeZclThermostatGetWeeklySchedule_t *req = NULL;
3731 req = (ZigbeeZclThermostatGetWeeklySchedule_t *)request->request_data;
3738 case ZBLIB_ZCL_THERMOSTAT_OPS_SET_WEEKLY_SCHEDULE: {
3739 ZigbeeZclThermostatSetWeeklySchedule_t *req = NULL;
3741 req = (ZigbeeZclThermostatSetWeeklySchedule_t *)request->request_data;
3748 case ZBLIB_ZCL_THERMOSTAT_OPS_CLEAR_WEEKLY_SCHEDULE: {
3749 ZigbeeZclThermostatClearWeeklySchedule_t *req = NULL;
3751 req = (ZigbeeZclThermostatClearWeeklySchedule_t *)request->request_data;
3758 case ZBLIB_ZCL_THERMOSTAT_OPS_SETPOINT_RAISE_LOWER: {
3759 ZigbeeZclThermostatSetpointRaiseLower_t *req = NULL;
3761 req = (ZigbeeZclThermostatSetpointRaiseLower_t *)request->request_data;
3773 static void __zblib_request_free_zcl_basic_request_data(ZigBeeRequest *request,
3779 ops_id = __zblib_request_get_ops_id(request_type);
3781 case ZBLIB_ZCL_BASIC_OPS_RESET_FACTORY_DEFAULT: {
3782 ZigbeeZclBasicResetFactoryDefault_t *req = NULL;
3784 req = (ZigbeeZclBasicResetFactoryDefault_t *)request->request_data;
3796 static void __zblib_request_free_zcl_global_control_request_data(ZigBeeRequest *request,
3802 ops_id = __zblib_request_get_ops_id(request_type);
3804 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_READ_ATTRIBUTES_REQ: {
3805 ZigbeeZclGlobalControlReadAttributesRequest_t *req = NULL;
3807 req = (ZigbeeZclGlobalControlReadAttributesRequest_t *)request->request_data;
3809 g_free(req->attribute_id);
3815 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_REQ: {
3816 ZigbeeZclGlobalControlWriteAttributesRequest_t *req = NULL;
3818 req = (ZigbeeZclGlobalControlWriteAttributesRequest_t *)request->request_data;
3820 g_free(req->write_records);
3826 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_UNDIVIDED_REQ: {
3827 ZigbeeZclGlobalControlWriteAttributesUndividedRequest_t *req = NULL;
3829 req = (ZigbeeZclGlobalControlWriteAttributesUndividedRequest_t *)request->request_data;
3831 g_free(req->write_records);
3837 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_NO_RESP: {
3838 ZigbeeZclGlobalControlWriteAttributesNoResponse_t *req = NULL;
3840 req = (ZigbeeZclGlobalControlWriteAttributesNoResponse_t *)request->request_data;
3842 g_free(req->write_records);
3848 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_STRUCTURED: {
3849 ZigbeeZclGlobalControlWriteAttributesStructed_t *req = NULL;
3851 req = (ZigbeeZclGlobalControlWriteAttributesStructed_t *)request->request_data;
3853 g_free(req->write_records);
3859 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_READ_ATTRIBUTES_STRUCTURED: {
3860 ZigbeeZclGlobalControlReadAttributesStructed_t *req = NULL;
3862 req = (ZigbeeZclGlobalControlReadAttributesStructed_t *)request->request_data;
3864 g_free(req->read_records);
3870 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_CONFIGURE_REPORTING_REQ: {
3871 ZigbeeZclGlobalControlConfigureReportingReq_t *req = NULL;
3873 req = (ZigbeeZclGlobalControlConfigureReportingReq_t *)request->request_data;
3875 g_free(req->read_records);
3881 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_READ_CONFIGURE_REPORTING: {
3882 ZigbeeZclGlobalControlReadConfigureReporting_t *req = NULL;
3884 req = (ZigbeeZclGlobalControlReadConfigureReporting_t *)request->request_data;
3886 g_free(req->read_records);
3892 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_DISCOVER_ATTRIBUTES: {
3893 ZigbeeZclGlobalControlDiscoverAttributes_t *req = NULL;
3895 req = (ZigbeeZclGlobalControlDiscoverAttributes_t *)request->request_data;
3902 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_DISCOVER_ATTRIBUTES_EXTENDED: {
3903 ZigbeeZclGlobalControlDiscoverAttributesExtended_t *req = NULL;
3905 req = (ZigbeeZclGlobalControlDiscoverAttributesExtended_t *)request->request_data;
3912 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_DISCOVER_COMMANDS_RECEIVED: {
3913 ZigbeeZclGlobalControlDiscoverCommandsReceived_t *req = NULL;
3915 req = (ZigbeeZclGlobalControlDiscoverCommandsReceived_t *)request->request_data;
3922 case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_DISCOVER_COMMANDS_GENERATED: {
3923 ZigbeeZclGlobalControlDiscoverCommandsGenerated_t *req = NULL;
3925 req = (ZigbeeZclGlobalControlDiscoverCommandsGenerated_t *)request->request_data;
3937 static void __zblib_request_free_zcl_ias_zone_request_data(ZigBeeRequest *request,
3943 ops_id = __zblib_request_get_ops_id(request_type);
3945 case ZBLIB_ZCL_IAS_ZONE_OPS_ENROLL_RESPONSE: {
3946 ZigbeeZclIasZoneEnrollResponse_t *req = NULL;
3948 req = (ZigbeeZclIasZoneEnrollResponse_t *)request->request_data;
3960 static void __zblib_request_free_zcl_identify_request_data(ZigBeeRequest *request,
3966 ops_id = __zblib_request_get_ops_id(request_type);
3968 case ZBLIB_ZCL_IDENTIFY_OPS_IDENTIFY: {
3969 ZigbeeZclIdentifyIdentify_t *req = NULL;
3971 req = (ZigbeeZclIdentifyIdentify_t *)request->request_data;
3978 case ZBLIB_ZCL_IDENTIFY_OPS_QUERY: {
3979 ZigbeeZclIdentifyQuery_t *req = NULL;
3981 req = (ZigbeeZclIdentifyQuery_t *)request->request_data;
3993 static void __zblib_request_free_zcl_color_control_request_data(ZigBeeRequest *request,
3999 ops_id = __zblib_request_get_ops_id(request_type);
4001 case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_TO_HUE: {
4002 ZigbeeZclColorControlMoveToHue_t *req = NULL;
4004 req = (ZigbeeZclColorControlMoveToHue_t *)request->request_data;
4011 case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_HUE: {
4012 ZigbeeZclColorControlMoveHue_t *req = NULL;
4014 req = (ZigbeeZclColorControlMoveHue_t *)request->request_data;
4021 case ZBLIB_ZCL_COLOR_CONTROL_OPS_STEP_HUE: {
4022 ZigbeeZclColorControlStepHue_t *req = NULL;
4024 req = (ZigbeeZclColorControlStepHue_t *)request->request_data;
4031 case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_TO_STAURATION: {
4032 ZigbeeZclColorControlMoveToSaturation_t *req = NULL;
4034 req = (ZigbeeZclColorControlMoveToSaturation_t *)request->request_data;
4041 case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_STAURATION: {
4042 ZigbeeZclColorControlMoveSaturation_t *req = NULL;
4044 req = (ZigbeeZclColorControlMoveSaturation_t *)request->request_data;
4051 case ZBLIB_ZCL_COLOR_CONTROL_OPS_STEP_STAURATION: {
4052 ZigbeeZclColorControlStepSaturation_t *req = NULL;
4054 req = (ZigbeeZclColorControlStepSaturation_t *)request->request_data;
4061 case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_TO_HUE_AND_SATURATION: {
4062 ZigbeeZclColorControlMoveToHueAndSaturation_t *req = NULL;
4064 req = (ZigbeeZclColorControlMoveToHueAndSaturation_t *)request->request_data;
4071 case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_TO_COLOR: {
4072 ZigbeeZclColorControlMoveToColor_t *req = NULL;
4074 req = (ZigbeeZclColorControlMoveToColor_t *)request->request_data;
4081 case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_COLOR: {
4082 ZigbeeZclColorControlMoveColor_t *req = NULL;
4084 req = (ZigbeeZclColorControlMoveColor_t *)request->request_data;
4091 case ZBLIB_ZCL_COLOR_CONTROL_OPS_STEP_COLOR: {
4092 ZigbeeZclColorControlStepColor_t *req = NULL;
4094 req = (ZigbeeZclColorControlStepColor_t *)request->request_data;
4101 case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_COLOR_TEMPERATURE: {
4102 ZigbeeZclColorControlMoveColorTemperature_t *req = NULL;
4104 req = (ZigbeeZclColorControlMoveColorTemperature_t *)request->request_data;
4116 static void __zblib_request_free_zcl_group_request_data(ZigBeeRequest *request,
4122 ops_id = __zblib_request_get_ops_id(request_type);
4124 case ZBLIB_ZCL_GROUP_OPS_ADD_GROUP: {
4125 ZigbeeZclGroupAddGroup_t *req = NULL;
4127 req = (ZigbeeZclGroupAddGroup_t *)request->request_data;
4134 case ZBLIB_ZCL_GROUP_OPS_VIEW_GROUP: {
4135 ZigbeeZclGroupViewGroup_t *req = NULL;
4137 req = (ZigbeeZclGroupViewGroup_t *)request->request_data;
4144 case ZBLIB_ZCL_GROUP_OPS_GET_GROUP_MEMBERSHIP: {
4145 ZigbeeZclGroupGetGroupMembership_t *req = NULL;
4147 req = (ZigbeeZclGroupGetGroupMembership_t *)request->request_data;
4149 g_free(req->group_list);
4155 case ZBLIB_ZCL_GROUP_OPS_REMOVE_GROUP: {
4156 ZigbeeZclGroupRemoveGroup_t *req = NULL;
4158 req = (ZigbeeZclGroupRemoveGroup_t *)request->request_data;
4165 case ZBLIB_ZCL_GROUP_OPS_REMOVE_ALL_GROUP: {
4166 ZigbeeZclGroupRemoveAllGroup_t *req = NULL;
4168 req = (ZigbeeZclGroupRemoveAllGroup_t *)request->request_data;
4175 case ZBLIB_ZCL_GROUP_OPS_ADD_GROUP_IF_IDENTIFYING: {
4176 ZigbeeZclGroupAddGroupIfIdentifying_t *req = NULL;
4178 req = (ZigbeeZclGroupAddGroupIfIdentifying_t *)request->request_data;
4190 static void __zblib_request_free_zcl_poll_control_request_data(ZigBeeRequest *request,
4196 ops_id = __zblib_request_get_ops_id(request_type);
4198 case ZBLIB_ZCL_POLL_CONTROL_OPS_CHECK_IN_RESPONSE: {
4199 ZigbeeZclPollControlCheckInResponse_t *req = NULL;
4201 req = (ZigbeeZclPollControlCheckInResponse_t *)request->request_data;
4208 case ZBLIB_ZCL_POLL_CONTROL_OPS_FAST_POLL_STOP: {
4209 ZigbeeZclPollControlFastPollStop_t *req = NULL;
4211 req = (ZigbeeZclPollControlFastPollStop_t *)request->request_data;
4218 case ZBLIB_ZCL_POLL_CONTROL_OPS_SET_LONG_POLL_INTERVAL: {
4219 ZigbeeZclPollControlSetLongPollInterval_t *req = NULL;
4221 req = (ZigbeeZclPollControlSetLongPollInterval_t *)request->request_data;
4228 case ZBLIB_ZCL_POLL_CONTROL_OPS_SET_SHORT_POLL_INTERVAL: {
4229 ZigbeeZclPollControlSetShortPollInterval_t *req = NULL;
4231 req = (ZigbeeZclPollControlSetShortPollInterval_t *)request->request_data;
4243 static void __zblib_request_free_zcl_scene_request_data(ZigBeeRequest *request,
4249 ops_id = __zblib_request_get_ops_id(request_type);
4251 case ZBLIB_ZCL_SCENE_OPS_ADD_SCENE: {
4252 ZigbeeZclSceneAddScene_t *req = NULL;
4254 req = (ZigbeeZclSceneAddScene_t *)request->request_data;
4256 g_free(req->ext_field_set);
4262 case ZBLIB_ZCL_SCENE_OPS_VIEW_SCENE: {
4263 ZigbeeZclSceneViewScene_t *req = NULL;
4265 req = (ZigbeeZclSceneViewScene_t *)request->request_data;
4272 case ZBLIB_ZCL_SCENE_OPS_REMOVE_SCENE: {
4273 ZigbeeZclSceneRemoveScene_t *req = NULL;
4275 req = (ZigbeeZclSceneRemoveScene_t *)request->request_data;
4282 case ZBLIB_ZCL_SCENE_OPS_STORE_SCENE: {
4283 ZigbeeZclSceneStoreScene_t *req = NULL;
4285 req = (ZigbeeZclSceneStoreScene_t *)request->request_data;
4292 case ZBLIB_ZCL_SCENE_OPS_RECALL_SCENE: {
4293 ZigbeeZclSceneRecallScene_t *req = NULL;
4295 req = (ZigbeeZclSceneRecallScene_t *)request->request_data;
4302 case ZBLIB_ZCL_SCENE_OPS_REMOVE_ALL_SCENE: {
4303 ZigbeeZclSceneRemoveAllScene_t *req = NULL;
4305 req = (ZigbeeZclSceneRemoveAllScene_t *)request->request_data;
4312 case ZBLIB_ZCL_SCENE_OPS_GET_SCENE_MEMBERSHIP: {
4313 ZigbeeZclSceneGetSceneMembership_t *req = NULL;
4315 req = (ZigbeeZclSceneGetSceneMembership_t *)request->request_data;
4327 static void __zblib_request_free_zdo_dev_control_request_data(ZigBeeRequest *request,
4333 ops_id = __zblib_request_get_ops_id(request_type);
4335 case ZBLIB_ZDO_DEV_CONTROL_OPS_NWK_ADDR_REQ: {
4336 ZigbeeZdoDevControlNwkAddrReq_t *req = NULL;
4338 req = (ZigbeeZdoDevControlNwkAddrReq_t *)request->request_data;
4345 case ZBLIB_ZDO_DEV_CONTROL_OPS_MATCHED_DESCRIPTOR_REQ: {
4346 ZigbeeZdoDevControlMatchedDescriptorReq_t *req = NULL;
4348 req = (ZigbeeZdoDevControlMatchedDescriptorReq_t *)request->request_data;
4351 g_free(req->out_cl);
4357 case ZBLIB_ZDO_DEV_CONTROL_OPS_IEEE_ADDR_REQ: {
4358 ZigbeeZdoDevControlIeeeAddrReq_t *req = NULL;
4360 req = (ZigbeeZdoDevControlIeeeAddrReq_t *)request->request_data;
4367 case ZBLIB_ZDO_DEV_CONTROL_OPS_ACTIVE_EP_REQ: {
4368 ZigbeeZdoDevControlActiveEpReq_t *req = NULL;
4370 req = (ZigbeeZdoDevControlActiveEpReq_t *)request->request_data;
4377 case ZBLIB_ZDO_DEV_CONTROL_OPS_NODE_DESC_REQ: {
4378 ZigbeeZdoDevControlNodeDescriptorReq_t *req = NULL;
4380 req = (ZigbeeZdoDevControlNodeDescriptorReq_t *)request->request_data;
4387 case ZBLIB_ZDO_DEV_CONTROL_OPS_POWER_DESC_REQ: {
4388 ZigbeeZdoDevControlPowerDescriptorReq_t *req = NULL;
4390 req = (ZigbeeZdoDevControlPowerDescriptorReq_t *)request->request_data;
4397 case ZBLIB_ZDO_DEV_CONTROL_OPS_COMPLEX_DESC_REQ: {
4398 ZigbeeZdoDevControlComplexDescriptorReq_t *req = NULL;
4400 req = (ZigbeeZdoDevControlComplexDescriptorReq_t *)request->request_data;
4407 case ZBLIB_ZDO_DEV_CONTROL_OPS_USER_DESC_REQ: {
4408 ZigbeeZdoDevControlUserDescriptorReq_t *req = NULL;
4410 req = (ZigbeeZdoDevControlUserDescriptorReq_t *)request->request_data;
4417 case ZBLIB_ZDO_DEV_CONTROL_OPS_USER_DESC_SET_REQ: {
4418 ZigbeeZdoDevControlUserDescriptorSetReq_t *req = NULL;
4420 req = (ZigbeeZdoDevControlUserDescriptorSetReq_t *)request->request_data;
4427 case ZBLIB_ZDO_DEV_CONTROL_OPS_DEVICE_ANNOUNCE: {
4428 ZigbeeZdoDevControlDeviceAnnounce_t *req = NULL;
4430 req = (ZigbeeZdoDevControlDeviceAnnounce_t *)request->request_data;
4437 case ZBLIB_ZDO_DEV_CONTROL_OPS_SIMPLE_DESC_REQ: {
4438 ZigbeeZdoDevControlSimpleDescriptorReq_t *req = NULL;
4440 req = (ZigbeeZdoDevControlSimpleDescriptorReq_t *)request->request_data;
4447 case ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_LQI_REQ: {
4448 ZigbeeZdoDevControlMgmtLqiReq_t *req = NULL;
4450 req = (ZigbeeZdoDevControlMgmtLqiReq_t *)request->request_data;
4457 case ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_RTG_REQ: {
4458 ZigbeeZdoDevControlMgmtRtgReq_t *req = NULL;
4460 req = (ZigbeeZdoDevControlMgmtRtgReq_t *)request->request_data;
4467 case ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_BIND_REQ: {
4468 ZigbeeZdoDevControlMgmtBindReq_t *req = NULL;
4470 req = (ZigbeeZdoDevControlMgmtBindReq_t *)request->request_data;
4477 case ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_PERMIT_JOIN_REQ: {
4478 ZigbeeZdoDevControlMgmtPermitJoinReq_t *req = NULL;
4480 req = (ZigbeeZdoDevControlMgmtPermitJoinReq_t *)request->request_data;
4487 case ZBLIB_ZDO_DEV_CONTROL_OPS_NWK_UPDATE_REQ: {
4488 ZigbeeZdoDevControlNwkUpdateReq_t *req = NULL;
4490 req = (ZigbeeZdoDevControlNwkUpdateReq_t *)request->request_data;
4497 case ZBLIB_ZDO_DEV_CONTROL_OPS_NWK_DISC_REQ: {
4498 ZigbeeZdoDevControlNwkDescriptorReq_t *req = NULL;
4500 req = (ZigbeeZdoDevControlNwkDescriptorReq_t *)request->request_data;
4512 static void __zblib_request_free_zdo_bind_request_data(ZigBeeRequest *request,
4518 ops_id = __zblib_request_get_ops_id(request_type);
4520 case ZBLIB_ZDO_BIND_OPS_BIND_REQ: {
4521 ZigbeeZdoBindBindReq_t *req = NULL;
4523 req = (ZigbeeZdoBindBindReq_t *)request->request_data;
4530 case ZBLIB_ZDO_BIND_OPS_UNBIND_REQ: {
4531 ZigbeeZdoBindUnbindReq_t *req = NULL;
4533 req = (ZigbeeZdoBindUnbindReq_t *)request->request_data;
4545 static void __zblib_request_free_request_data(ZigBeeRequest *request)
4548 ZblibDriverType_e driver_type;
4550 zblib_check_null_ret("request", request);
4552 request_type = request->request_type;
4554 /* Fetch driver type */
4555 driver_type = __zblib_request_get_driver_type(request_type);
4556 switch (driver_type) {
4557 case ZBLIB_DRIVER_TYPE_ZCL_ALARM: {
4558 __zblib_request_free_zcl_alarm_request_data(request, request_type);
4562 case ZBLIB_DRIVER_TYPE_CUSTOM: {
4563 __zblib_request_free_custom_request_data(request, request_type);
4567 case ZBLIB_DRIVER_TYPE_ZCL_DOOR_LOCK: {
4568 __zblib_request_free_zcl_door_lock_request_data(request, request_type);
4572 case ZBLIB_DRIVER_TYPE_ZCL_FAN_CONTROL: {
4573 __zblib_request_free_zcl_fan_control_request_data(request, request_type);
4577 case ZBLIB_DRIVER_TYPE_ZCL_LEVEL_CONTROL: {
4578 __zblib_request_free_zcl_level_control_request_data(request, request_type);
4582 case ZBLIB_DRIVER_TYPE_MFGLIB_CONTROL: {
4583 __zblib_request_free_mfglib_control_request_data(request, request_type);
4587 case ZBLIB_DRIVER_TYPE_ZCL_ON_OFF: {
4588 __zblib_request_free_zcl_on_off_request_data(request, request_type);
4592 case ZBLIB_DRIVER_TYPE_SERVICE: {
4593 __zblib_request_free_service_request_data(request, request_type);
4597 case ZBLIB_DRIVER_TYPE_ZCL_THERMOSTAT: {
4598 __zblib_request_free_zcl_thermostat_request_data(request, request_type);
4602 case ZBLIB_DRIVER_TYPE_ZCL_BASIC: {
4603 __zblib_request_free_zcl_basic_request_data(request, request_type);
4607 case ZBLIB_DRIVER_TYPE_ZCL_GLOBAL_CONTROL: {
4608 __zblib_request_free_zcl_global_control_request_data(request, request_type);
4612 case ZBLIB_DRIVER_TYPE_ZCL_IAS_ZONE: {
4613 __zblib_request_free_zcl_ias_zone_request_data(request, request_type);
4617 case ZBLIB_DRIVER_TYPE_ZCL_IDENTIFY: {
4618 __zblib_request_free_zcl_identify_request_data(request, request_type);
4622 case ZBLIB_DRIVER_TYPE_ZCL_COLOR_CONTROL: {
4623 __zblib_request_free_zcl_color_control_request_data(request, request_type);
4627 case ZBLIB_DRIVER_TYPE_ZCL_GROUP: {
4628 __zblib_request_free_zcl_group_request_data(request, request_type);
4632 case ZBLIB_DRIVER_TYPE_ZCL_POLL_CONTROL: {
4633 __zblib_request_free_zcl_poll_control_request_data(request, request_type);
4637 case ZBLIB_DRIVER_TYPE_ZCL_SCENE: {
4638 __zblib_request_free_zcl_scene_request_data(request, request_type);
4642 case ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL: {
4643 __zblib_request_free_zdo_dev_control_request_data(request, request_type);
4647 case ZBLIB_DRIVER_TYPE_ZDO_BIND: {
4648 __zblib_request_free_zdo_bind_request_data(request, request_type);
4652 case ZBLIB_DRIVER_TYPE_NONE: /* Fall through */
4654 Z_LOGE("Unhandled driver type: [%d]", driver_type);
4660 gint zblib_request_new(ZigBeeServiceInterface *service_interface,
4661 guint request_type, gpointer request_data, guint request_data_len)
4663 ZigBeeService *service = NULL;
4664 ZigBeeRequest *request = NULL;
4665 GHashTable *request_table = NULL;
4667 zblib_check_null_ret_error("service_interface", service_interface, ZIGBEE_REQUEST_INVALID_REQUEST_ID);
4669 service = zblib_service_interface_ref_service(service_interface);
4670 zblib_check_null_ret_error("service", service, ZIGBEE_REQUEST_INVALID_REQUEST_ID);
4672 /* Allocate ZigBee request memory */
4673 request = g_malloc0(sizeof(ZigBeeRequest));
4675 /* Update request */
4676 request->service_interface = service_interface;
4677 request->ref_count = 1; /* Initialize reference count to '1' for new request */
4679 /* Update request data for specific request */
4680 request->request_data = __zblib_request_create_request_data(request_type,
4681 request_data, request_data_len);
4682 request->request_type = request_type;
4684 /* Generate request ID */
4685 request->request_id = zblib_service_generate_request_id(service);
4686 if (ZIGBEE_REQUEST_INVALID_REQUEST_ID == request->request_id) {
4687 Z_LOGE("zblib_service_genrate_request_id failed!");
4689 /* Free resources */
4690 __zblib_request_free_request_data(request);
4693 return ZIGBEE_REQUEST_INVALID_REQUEST_ID;
4696 /* Fetch request table from service */
4697 request_table = zblib_service_ref_request_hash_table(service);
4698 if (NULL == request_table) {
4699 Z_LOGE("zblib_service_ref_request_hash_table failed!");
4701 /* Free resources */
4702 __zblib_request_free_request_data(request);
4705 return ZIGBEE_REQUEST_INVALID_REQUEST_ID;
4708 /* Insert request to request table */
4709 g_hash_table_insert(request_table, (gpointer)(request->request_id), request);
4711 return request->request_id;
4714 void zblib_request_free(ZigBeeServiceInterface *service_interface,
4717 ZigBeeService *service = NULL;
4718 ZigBeeRequest *request = NULL;
4720 zblib_check_null_ret("service_interface", service_interface);
4723 service = zblib_service_interface_ref_service(service_interface);
4724 zblib_check_null_ret("service", service);
4726 /* Fetch request based on request_id */
4727 request = __zblib_request_ref_request_by_request_id(service, request_id);
4728 zblib_check_null_ret("request", request);
4730 /* Free resources */
4731 __zblib_request_free_request_data(request);
4735 gboolean zblib_request_set_response_cb(ZigBeeServiceInterface *service_interface,
4737 gpointer resp_cb, gpointer resp_cb_data)
4739 ZigBeeService *service = NULL;
4740 ZigBeeRequest *request = NULL;
4742 zblib_check_null_ret_error("service_interface", service_interface, FALSE);
4745 service = zblib_service_interface_ref_service(service_interface);
4746 zblib_check_null_ret_error("service", service, FALSE);
4748 /* Fetch request based on request_id */
4749 request = __zblib_request_ref_request_by_by_request_id(service, request_id);
4750 if (NULL == request) {
4751 Z_LOGE("No request available for request_id: [%d]", request_id);
4755 /* Update response callback and response callback data */
4756 request->resp_cb = resp_cb;
4757 request->resp_cb_data = resp_cb_data;
4762 gpointer zblib_request_ref_response_cb(ZigBeeServiceInterface *service_interface,
4763 guint request_id, gpointer *resp_cb_data)
4765 ZigBeeService *service = NULL;
4766 ZigBeeRequest *request = NULL;
4768 zblib_check_null_ret_error("service_interface", service_interface, NULL);
4771 service = zblib_service_interface_ref_service(service_interface);
4772 zblib_check_null_ret_error("service", service, NULL);
4774 /* Fetch request based on request_id */
4775 request = __zblib_request_ref_request_by_by_request_id(service, request_id);
4776 if (NULL == request) {
4777 Z_LOGE("No request available for request_id: [%d]", request_id);
4781 /* Response callback data */
4782 *resp_cb_data = request->resp_cb_data;
4784 /* Return response callback */
4785 return request->resp_cb;
4788 ZigBeeRequest *zblib_request_ref(ZigBeeRequest *request)
4790 zblib_check_null_ret_error("request", request, NULL);
4792 request->ref_count++;
4797 void zblib_request_unref(ZigBeeRequest *request)
4799 zblib_check_null_ret("request", request);
4801 request->ref_count--;
4802 if (0 == request->ref_count) {
4803 Z_LOGD("Reference count is ZERO!");
4805 /* Free 'request' */
4806 __zblib_request_free_request_data(request);
4811 guint zblib_request_ref_request_type(ZigBeeRequest *request)
4813 zblib_check_null_ret_error("request", request, 0);
4815 return request->request_type;
4818 ZigBeeServiceInterface *zblib_request_ref_service_interface(ZigBeeService *service,
4821 ZigBeeRequest *request = NULL;
4823 zblib_check_null_ret_error("service", service, NULL);
4825 /* Fetch request based on request_id */
4826 request = __zblib_request_ref_request_by_by_request_id(service, request_id);
4827 if (NULL == request) {
4828 Z_LOGE("No request available for request_id: [%d]", request_id);
4832 return request->service_interface;
4835 gpointer zblib_request_ref_request_data(ZigBeeRequest *request)
4837 zblib_check_null_ret_error("request", request, NULL);
4839 return request->request_data;
4842 gpointer zblib_request_ref_request_data_by_id(ZigBeeService *service,
4845 ZigBeeRequest *request = NULL;
4847 /* Fetch request based on request_id */
4848 request = __zblib_request_ref_request_by_by_request_id(service, request_id);
4849 if (NULL == request) {
4850 Z_LOGE("No request available for request_id: [%d]", request_id);
4854 return request->request_data;
4857 guint zblib_request_generate_request_type(ZblibDriverType_e driver_type,
4863 * request_type consists of driver_type and ops_id
4864 * request_type = driver_type | 0x00 | 0x00 | ops_id
4866 request_type = (driver_type << 24) | (ops_id);
4868 return request_type;
4871 gint zblib_request_ref_request_type_by_request_id(ZigBeeService *service,
4874 return __zblib_request_ref_request_type_by_request_id(service, request_id);
4877 ZblibDriverType_e zblib_request_get_driver_type(guint request_type)
4879 return __zblib_request_get_driver_type(request_type);
4882 guint zblib_request_get_ops_id(guint request_type)
4884 return __zblib_request_get_ops_id(request_type);