lib/zbl-zcl-global-cmd.c

   1 /*
   2  * Copyright (c) 2016 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 #include "zbl.h"
  17 #include "zbl-dbus.h"
  18 #include "zb-common.h"
  19
  20 /* For test */
  21 #define ZIGBEE_SUPPORT_ORDERED_SEQUENCE_DATA 0
  22
  23 API int zb_zcl_global_attr_read(zb_zigbee_h handle, zb_nwk_addr addr16,
  24         unsigned char src_ep, unsigned char dst_ep, unsigned char zcl_fc,
  25         unsigned short clusterid, unsigned short *attribute_ids, int attribute_ids_len,
  26         zb_zcl_global_attr_read_cb cb, void *user_data)
  27 {
  28         int ret;
  29         CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
  30         RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
  31         RETV_IF(NULL == zbl_dbus_get_object(), ZIGBEE_ERROR_IO_ERROR);
  32         RETV_IF(0 == addr16, ZIGBEE_ERROR_INVALID_ADDRESS);
  33         RETV_IF(0 == src_ep || 0 == dst_ep, ZIGBEE_ERROR_INVALID_ENDPOINT);
  34         RETV_IF(NULL == attribute_ids, ZIGBEE_ERROR_INVALID_PARAMETER);
  35         RETV_IF(0 == attribute_ids_len, ZIGBEE_ERROR_INVALID_PARAMETER);
  36         ret = zbl_read_attr_req(handle, addr16, dst_ep, zcl_fc, clusterid,
  37                         attribute_ids, attribute_ids_len, cb, user_data);
  38         return ret;
  39 }
  40
  41 API int zb_zcl_global_attr_read_structured(zb_zigbee_h handle, zb_nwk_addr addr16,
  42         unsigned char src_ep, unsigned char dst_ep, unsigned char zcl_fc,
  43         unsigned short clusterid, zb_zcl_read_structured_attr_record_h *records,
  44         int count, zb_zcl_global_attr_read_cb cb, void *user_data)
  45 {
  46 #if (0 == ZIGBEE_SUPPORT_ORDERED_SEQUENCE_DATA)
  47         return ZIGBEE_ERROR_NOT_SUPPORTED;
  48 #endif
  49         CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
  50         RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
  51         RETV_IF(NULL == zbl_dbus_get_object(), ZIGBEE_ERROR_IO_ERROR);
  52         RETV_IF(0 == addr16, ZIGBEE_ERROR_INVALID_ADDRESS);
  53         RETV_IF(0 == src_ep || 0 == dst_ep, ZIGBEE_ERROR_INVALID_ENDPOINT);
  54         RETV_IF(NULL == records, ZIGBEE_ERROR_INVALID_PARAMETER);
  55         RETV_IF(0 == count, ZIGBEE_ERROR_INVALID_PARAMETER);
  56
  57         return ZIGBEE_ERROR_NONE;
  58 }
  59
  60 API int zb_zcl_global_attr_write(zb_zigbee_h handle, zb_nwk_addr addr16,
  61         unsigned char src_ep, unsigned char dst_ep, unsigned char zcl_fc,
  62         unsigned short clusterid, zb_zcl_write_attr_record_h *records, int count,
  63         zb_zcl_global_attr_write_cb cb, void *user_data)
  64 {
  65         int ret;
  66         CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
  67         RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
  68         RETV_IF(NULL == zbl_dbus_get_object(), ZIGBEE_ERROR_IO_ERROR);
  69         RETV_IF(0 == addr16, ZIGBEE_ERROR_INVALID_ADDRESS);
  70         RETV_IF(0 == src_ep || 0 == dst_ep, ZIGBEE_ERROR_INVALID_ENDPOINT);
  71         RETV_IF(NULL == records, ZIGBEE_ERROR_INVALID_PARAMETER);
  72         RETV_IF(0 == count, ZIGBEE_ERROR_INVALID_PARAMETER);
  73         ret = zbl_write_attr_req(handle, addr16, src_ep, dst_ep, zcl_fc,
  74                         clusterid, records, count, cb, user_data);
  75         return ret;
  76 }
  77
  78 API int zb_zcl_global_attr_write_undivided(zb_zigbee_h handle,
  79         zb_nwk_addr addr16, unsigned char src_ep, unsigned char dst_ep,
  80         unsigned char zcl_fc, unsigned short clusterid,
  81         zb_zcl_write_attr_record_h *records, int count,
  82         zb_zcl_global_attr_write_cb cb, void *user_data)
  83 {
  84         int ret;
  85         CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
  86         RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
  87         RETV_IF(NULL == zbl_dbus_get_object(), ZIGBEE_ERROR_IO_ERROR);
  88         RETV_IF(0 == addr16, ZIGBEE_ERROR_INVALID_ADDRESS);
  89         RETV_IF(0 == src_ep || 0 == dst_ep, ZIGBEE_ERROR_INVALID_ENDPOINT);
  90         RETV_IF(NULL == records, ZIGBEE_ERROR_INVALID_PARAMETER);
  91         RETV_IF(0 == count, ZIGBEE_ERROR_INVALID_PARAMETER);
  92         ret = zbl_wattr_undivided_req(handle, addr16, src_ep, dst_ep, zcl_fc,
  93                         clusterid, records, count, cb, user_data);
  94         return ret;
  95 }
  96
  97 API int zb_zcl_global_attr_write_structured(zb_zigbee_h handle, zb_nwk_addr addr16,
  98         unsigned char src_ep, unsigned char dst_ep, unsigned char zcl_fc,
  99         unsigned short clusterid, zb_zcl_write_attr_structured_record_h *records,
 100         int count, zb_zcl_global_attr_write_cb cb, void *user_data)
 101 {
 102 #if (0 == ZIGBEE_SUPPORT_ORDERED_SEQUENCE_DATA)
 103         return ZIGBEE_ERROR_NOT_SUPPORTED;
 104 #endif
 105         CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
 106         RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
 107         RETV_IF(NULL == zbl_dbus_get_object(), ZIGBEE_ERROR_IO_ERROR);
 108         RETV_IF(0 == addr16, ZIGBEE_ERROR_INVALID_ADDRESS);
 109         RETV_IF(0 == src_ep || 0 == dst_ep, ZIGBEE_ERROR_INVALID_ENDPOINT);
 110         RETV_IF(NULL == records, ZIGBEE_ERROR_INVALID_PARAMETER);
 111         RETV_IF(0 == count, ZIGBEE_ERROR_INVALID_PARAMETER);
 112
 113         return ZIGBEE_ERROR_NONE;
 114 }
 115
 116 API int zb_zcl_global_attr_write_no_rsp(zb_zigbee_h handle, zb_nwk_addr addr16,
 117         unsigned char src_ep, unsigned char dst_ep, unsigned char zcl_fc,
 118         unsigned short clusterid, zb_zcl_write_attr_record_h *records, int count)
 119 {
 120         int ret;
 121         CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
 122         RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
 123         RETV_IF(NULL == zbl_dbus_get_object(), ZIGBEE_ERROR_IO_ERROR);
 124         RETV_IF(0 == addr16, ZIGBEE_ERROR_INVALID_ADDRESS);
 125         RETV_IF(0 == src_ep || 0 == dst_ep, ZIGBEE_ERROR_INVALID_ENDPOINT);
 126         RETV_IF(NULL == records, ZIGBEE_ERROR_INVALID_PARAMETER);
 127         RETV_IF(0 == count, ZIGBEE_ERROR_INVALID_PARAMETER);
 128         ret = zbl_wattr_req_no_cb(handle, addr16, src_ep, dst_ep, zcl_fc,
 129                         clusterid, records, count);
 130         return ret;
 131 }
 132
 133 API int zb_zcl_global_config_report_write(zb_zigbee_h handle, zb_nwk_addr addr16,
 134         unsigned char src_ep, unsigned char dst_ep, unsigned char zcl_fc,
 135         unsigned short clusterid, zb_zcl_reporting_config_record_h *records, int count,
 136         zb_zcl_global_config_report_write_cb cb, void *user_data)
 137 {
 138         int ret;
 139         CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
 140         RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
 141         RETV_IF(NULL == zbl_dbus_get_object(), ZIGBEE_ERROR_IO_ERROR);
 142         RETV_IF(0 == addr16, ZIGBEE_ERROR_INVALID_ADDRESS);
 143         RETV_IF(0 == src_ep || 0 == dst_ep, ZIGBEE_ERROR_INVALID_ENDPOINT);
 144         RETV_IF(NULL == records, ZIGBEE_ERROR_INVALID_PARAMETER);
 145         RETV_IF(0 == count, ZIGBEE_ERROR_INVALID_PARAMETER);
 146         ret = zbl_write_config_report(handle, addr16, src_ep, dst_ep, zcl_fc,
 147                         clusterid, records, count, cb, user_data);
 148         return ret;
 149 }
 150
 151 API int zb_zcl_global_config_report_read(zb_zigbee_h handle, zb_nwk_addr addr16,
 152         unsigned char src_ep, unsigned char dst_ep, unsigned char zcl_fc,
 153         unsigned short clusterid, zb_zcl_read_report_config_record_h *records,
 154         int count, zb_zcl_global_config_report_read_cb cb, void *user_data)
 155 {
 156         int ret;
 157         CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
 158         RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
 159         RETV_IF(NULL == zbl_dbus_get_object(), ZIGBEE_ERROR_IO_ERROR);
 160         RETV_IF(0 == addr16, ZIGBEE_ERROR_INVALID_ADDRESS);
 161         RETV_IF(0 == src_ep || 0 == dst_ep, ZIGBEE_ERROR_INVALID_ENDPOINT);
 162         RETV_IF(NULL == records, ZIGBEE_ERROR_INVALID_PARAMETER);
 163         RETV_IF(0 == count, ZIGBEE_ERROR_INVALID_PARAMETER);
 164         ret = zbl_read_config_report(handle, addr16, src_ep, dst_ep, zcl_fc,
 165                         clusterid, records, count, cb, user_data);
 166         return ret;
 167 }
 168
 169 API int zb_zcl_global_attr_discover(zb_zigbee_h handle, zb_nwk_addr addr16,
 170         unsigned char src_ep, unsigned char dst_ep, unsigned char zcl_fc,
 171         unsigned short clusterid, unsigned short start_id, unsigned char max_attribute_ids,
 172         zb_zcl_global_attr_discover_cb cb, void *user_data)
 173 {
 174         int ret;
 175         CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
 176         RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
 177         RETV_IF(NULL == zbl_dbus_get_object(), ZIGBEE_ERROR_IO_ERROR);
 178         RETV_IF(0 == addr16, ZIGBEE_ERROR_INVALID_ADDRESS);
 179         RETV_IF(0 == src_ep || 0 == dst_ep, ZIGBEE_ERROR_INVALID_ENDPOINT);
 180         ret = zbl_discover_attr_req(handle, addr16, src_ep, dst_ep, zcl_fc,
 181                         clusterid, start_id, max_attribute_ids, cb, user_data);
 182         return ret;
 183 }
 184
 185 API int zb_zcl_global_discover_cmds_received(zb_zigbee_h handle,
 186         zb_nwk_addr addr16, unsigned char src_ep, unsigned char dst_ep,
 187         unsigned char zcl_fc, unsigned short clusterid, unsigned char start_command_id,
 188         unsigned char max_command_ids, zb_zcl_global_discover_cmds_cb cb, void *user_data)
 189 {
 190         int ret;
 191         CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
 192         RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
 193         RETV_IF(NULL == zbl_dbus_get_object(), ZIGBEE_ERROR_IO_ERROR);
 194         RETV_IF(0 == addr16, ZIGBEE_ERROR_INVALID_ADDRESS);
 195         RETV_IF(0 == src_ep || 0 == dst_ep, ZIGBEE_ERROR_INVALID_ENDPOINT);
 196         ret = zbl_discover_cmds_recv(handle, addr16, src_ep, dst_ep, zcl_fc,
 197                         clusterid, start_command_id, max_command_ids, cb, user_data);
 198         return ret;
 199 }
 200
 201 API int zb_zcl_global_discover_cmds_generated(zb_zigbee_h handle,
 202         zb_nwk_addr addr16, unsigned char src_ep, unsigned char dst_ep,
 203         unsigned char zcl_fc, unsigned short clusterid, unsigned char start_command_id,
 204         unsigned char max_command_ids, zb_zcl_global_discover_cmds_cb cb, void *user_data)
 205 {
 206         int ret;
 207         CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
 208         RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
 209         RETV_IF(NULL == zbl_dbus_get_object(), ZIGBEE_ERROR_IO_ERROR);
 210         RETV_IF(0 == addr16, ZIGBEE_ERROR_INVALID_ADDRESS);
 211         RETV_IF(0 == src_ep || 0 == dst_ep, ZIGBEE_ERROR_INVALID_ENDPOINT);
 212         ret = zbl_discover_cmds_gen(handle, addr16, src_ep, dst_ep, zcl_fc,
 213                         clusterid, start_command_id, max_command_ids, cb, user_data);
 214         return ret;
 215 }
 216
 217 API int zb_zcl_global_attr_extended_discover(zb_zigbee_h handle,
 218         zb_nwk_addr addr16, unsigned char src_ep, unsigned char dst_ep,
 219         unsigned char zcl_fc, unsigned short clusterid, unsigned short start_id,
 220         unsigned char max_attribute_ids, zb_zcl_global_attr_extended_discover_cb cb,
 221         void *user_data)
 222 {
 223         int ret;
 224         CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
 225         RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
 226         RETV_IF(NULL == zbl_dbus_get_object(), ZIGBEE_ERROR_IO_ERROR);
 227         RETV_IF(0 == addr16, ZIGBEE_ERROR_INVALID_ADDRESS);
 228         RETV_IF(0 == src_ep || 0 == dst_ep, ZIGBEE_ERROR_INVALID_ENDPOINT);
 229         ret = zbl_discover_attr_ext(handle, addr16, src_ep, dst_ep, zcl_fc,
 230                         clusterid, start_id, max_attribute_ids, cb, user_data);
 231         return ret;
 232 }