| /* |
| * Copyright (c) 2013-2015 The Linux Foundation. All rights reserved. |
| * |
| * Previously licensed under the ISC license by Qualcomm Atheros, Inc. |
| * |
| * |
| * Permission to use, copy, modify, and/or distribute this software for |
| * any purpose with or without fee is hereby granted, provided that the |
| * above copyright notice and this permission notice appear in all |
| * copies. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL |
| * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED |
| * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE |
| * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL |
| * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR |
| * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER |
| * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR |
| * PERFORMANCE OF THIS SOFTWARE. |
| */ |
| |
| /* |
| * This file was originally distributed by Qualcomm Atheros, Inc. |
| * under proprietary terms before Copyright ownership was assigned |
| * to the Linux Foundation. |
| */ |
| |
| /* wmi_tlv_platform.c file will be different for different components like Pronto firmware, Pronto windows host driver, |
| Pronto LA host driver because their memory management functions are different */ |
| #include "wmi_tlv_platform.c" |
| #include "wmi_tlv_defs.h" |
| #include "wmi_version.h" |
| |
| #define WMITLV_GET_ATTRIB_NUM_TLVS 0xFFFFFFFF |
| |
| #define WMITLV_GET_CMDID(val) (val & 0x00FFFFFF) |
| #define WMITLV_GET_NUM_TLVS(val) ((val >> 24) & 0xFF) |
| |
| #define WMITLV_GET_TAGID(val) (val & 0x00000FFF) |
| #define WMITLV_GET_TAG_STRUCT_SIZE(val) ((val >> 12) & 0x000001FF) |
| #define WMITLV_GET_TAG_ARRAY_SIZE(val) ((val >> 21) & 0x000001FF) |
| #define WMITLV_GET_TAG_VARIED(val) ((val >> 30) & 0x00000001) |
| |
| #define WMITLV_SET_ATTRB0(id) ((WMITLV_GET_TAG_NUM_TLV_ATTRIB(id) << 24) | (id & 0x00FFFFFF)) |
| #define WMITLV_SET_ATTRB1(tagID, tagStructSize, tagArraySize, tagVaried) (((tagVaried&0x1)<<30) | ((tagArraySize&0x1FF)<<21) | ((tagStructSize&0x1FF)<<12) | (tagID&0xFFF)) |
| |
| #define WMITLV_OP_SET_TLV_ATTRIB_macro(param_ptr, param_len, wmi_cmd_event_id, elem_tlv_tag, elem_struc_type, elem_name, var_len, arr_size) \ |
| WMITLV_SET_ATTRB1(elem_tlv_tag, sizeof(elem_struc_type), arr_size, var_len), |
| |
| #define WMITLV_GET_CMD_EVT_ATTRB_LIST(id) \ |
| WMITLV_SET_ATTRB0(id), \ |
| WMITLV_TABLE(id,SET_TLV_ATTRIB,NULL,0) |
| |
| A_UINT32 cmd_attr_list[] = { |
| WMITLV_ALL_CMD_LIST(WMITLV_GET_CMD_EVT_ATTRB_LIST) |
| }; |
| |
| A_UINT32 evt_attr_list[] = { |
| WMITLV_ALL_EVT_LIST(WMITLV_GET_CMD_EVT_ATTRB_LIST) |
| }; |
| |
| #ifdef NO_DYNAMIC_MEM_ALLOC |
| static wmitlv_cmd_param_info *g_wmi_static_cmd_param_info_buf = NULL; |
| A_UINT32 g_wmi_static_max_cmd_param_tlvs = 0; |
| #endif |
| |
| /* TLV helper routines */ |
| |
| /* |
| * WMI TLV Helper function to set the static cmd_param_tlv structure and number of TLVs that can be |
| * accomodated in the structure. This function should be used when dynamic memory allocation is not |
| * supported. |
| * |
| * When dynamic memory allocation is not supported by any component then NO_DYNAMIC_MEMALLOC |
| * macro has to be defined in respective tlv_platform.c file. And respective component has to allocate |
| * cmd_param_tlv structure buffer to accomodate whatever number of TLV's. Both the buffer address |
| * and number of TLV's that can be accomodated in the buffer should be sent as arguments to this function. |
| * |
| * Return None |
| */ |
| void |
| wmitlv_set_static_param_tlv_buf(void *param_tlv_buf, |
| A_UINT32 max_tlvs_accomodated) |
| { |
| #ifdef NO_DYNAMIC_MEM_ALLOC |
| g_wmi_static_cmd_param_info_buf = param_tlv_buf; |
| g_wmi_static_max_cmd_param_tlvs = max_tlvs_accomodated; |
| #endif |
| } |
| |
| /* |
| * WMI TLV Helper functions to find the attributes of the Command/Event TLVs. |
| * Return 0 if success. Return >=1 if failure. |
| */ |
| A_UINT32 wmitlv_get_attributes(A_UINT32 is_cmd_id, A_UINT32 cmd_event_id, |
| A_UINT32 curr_tlv_order, |
| wmitlv_attributes_struc *tlv_attr_ptr) |
| { |
| A_UINT32 i, base_index, num_tlvs, num_entries; |
| A_UINT32 *pAttrArrayList; |
| |
| if (is_cmd_id) { |
| pAttrArrayList = &cmd_attr_list[0]; |
| num_entries = CDF_ARRAY_SIZE(cmd_attr_list); |
| } else { |
| pAttrArrayList = &evt_attr_list[0]; |
| num_entries = CDF_ARRAY_SIZE(evt_attr_list); |
| } |
| |
| for (i = 0; i < num_entries; i++) { |
| num_tlvs = WMITLV_GET_NUM_TLVS(pAttrArrayList[i]); |
| if (WMITLV_GET_CMDID(cmd_event_id) == |
| WMITLV_GET_CMDID(pAttrArrayList[i])) { |
| tlv_attr_ptr->cmd_num_tlv = num_tlvs; |
| /* Return success from here when only number of TLVS for this command/event is required */ |
| if (curr_tlv_order == WMITLV_GET_ATTRIB_NUM_TLVS) { |
| wmi_tlv_print_verbose |
| ("%s: WMI TLV attribute definitions for %s:0x%x found; num_of_tlvs:%d\n", |
| __func__, (is_cmd_id ? "Cmd" : "Evt"), |
| cmd_event_id, num_tlvs); |
| return 0; |
| } |
| |
| /* Return failure if tlv_order is more than the expected number of TLVs */ |
| if (curr_tlv_order >= num_tlvs) { |
| wmi_tlv_print_error |
| ("%s: ERROR: TLV order %d greater than num_of_tlvs:%d for %s:0x%x\n", |
| __func__, curr_tlv_order, num_tlvs, |
| (is_cmd_id ? "Cmd" : "Evt"), cmd_event_id); |
| return 1; |
| } |
| |
| base_index = i + 1; /* index to first TLV attributes */ |
| wmi_tlv_print_verbose |
| ("%s: WMI TLV attributes for %s:0x%x tlv[%d]:0x%x\n", |
| __func__, (is_cmd_id ? "Cmd" : "Evt"), |
| cmd_event_id, curr_tlv_order, |
| pAttrArrayList[(base_index + curr_tlv_order)]); |
| tlv_attr_ptr->tag_order = curr_tlv_order; |
| tlv_attr_ptr->tag_id = |
| WMITLV_GET_TAGID(pAttrArrayList |
| [(base_index + curr_tlv_order)]); |
| tlv_attr_ptr->tag_struct_size = |
| WMITLV_GET_TAG_STRUCT_SIZE(pAttrArrayList |
| [(base_index + |
| curr_tlv_order)]); |
| tlv_attr_ptr->tag_varied_size = |
| WMITLV_GET_TAG_VARIED(pAttrArrayList |
| [(base_index + |
| curr_tlv_order)]); |
| tlv_attr_ptr->tag_array_size = |
| WMITLV_GET_TAG_ARRAY_SIZE(pAttrArrayList |
| [(base_index + |
| curr_tlv_order)]); |
| return 0; |
| } |
| i += num_tlvs; |
| } |
| |
| wmi_tlv_print_error |
| ("%s: ERROR: Didn't found WMI TLV attribute definitions for %s:0x%x\n", |
| __func__, (is_cmd_id ? "Cmd" : "Evt"), cmd_event_id); |
| return 1; |
| } |
| |
| /* |
| * Helper Function to vaidate the prepared TLV's for an WMI event/command to be sent |
| * Return 0 if success. |
| * <0 if failure. |
| */ |
| static int |
| wmitlv_check_tlv_params(void *os_handle, void *param_struc_ptr, |
| A_UINT32 param_buf_len, A_UINT32 is_cmd_id, |
| A_UINT32 wmi_cmd_event_id) |
| { |
| wmitlv_attributes_struc attr_struct_ptr; |
| A_UINT32 buf_idx = 0; |
| A_UINT32 tlv_index = 0; |
| A_UINT8 *buf_ptr = (unsigned char *)param_struc_ptr; |
| A_UINT32 expected_num_tlvs, expected_tlv_len; |
| |
| /* Get the number of TLVs for this command/event */ |
| if (wmitlv_get_attributes |
| (is_cmd_id, wmi_cmd_event_id, WMITLV_GET_ATTRIB_NUM_TLVS, |
| &attr_struct_ptr) != 0) { |
| wmi_tlv_print_error |
| ("%s: ERROR: Couldn't get expected number of TLVs for Cmd=%d\n", |
| __func__, wmi_cmd_event_id); |
| goto Error_wmitlv_check_tlv_params; |
| } |
| |
| /* NOTE: the returned number of TLVs is in "attr_struct_ptr.cmd_num_tlv" */ |
| |
| expected_num_tlvs = attr_struct_ptr.cmd_num_tlv; |
| |
| while ((buf_idx + WMI_TLV_HDR_SIZE) <= param_buf_len) { |
| A_UINT32 curr_tlv_tag = |
| WMITLV_GET_TLVTAG(WMITLV_GET_HDR(buf_ptr)); |
| A_UINT32 curr_tlv_len = |
| WMITLV_GET_TLVLEN(WMITLV_GET_HDR(buf_ptr)); |
| |
| if ((buf_idx + WMI_TLV_HDR_SIZE + curr_tlv_len) > param_buf_len) { |
| wmi_tlv_print_error |
| ("%s: ERROR: Invalid TLV length for Cmd=%d Tag_order=%d buf_idx=%d Tag:%d Len:%d TotalLen:%d\n", |
| __func__, wmi_cmd_event_id, tlv_index, buf_idx, |
| curr_tlv_tag, curr_tlv_len, param_buf_len); |
| goto Error_wmitlv_check_tlv_params; |
| } |
| |
| /* Get the attributes of the TLV with the given order in "tlv_index" */ |
| wmi_tlv_OS_MEMZERO(&attr_struct_ptr, |
| sizeof(wmitlv_attributes_struc)); |
| if (wmitlv_get_attributes |
| (is_cmd_id, wmi_cmd_event_id, tlv_index, |
| &attr_struct_ptr) != 0) { |
| wmi_tlv_print_error |
| ("%s: ERROR: No TLV attributes found for Cmd=%d Tag_order=%d\n", |
| __func__, wmi_cmd_event_id, tlv_index); |
| goto Error_wmitlv_check_tlv_params; |
| } |
| |
| /* Found the TLV that we wanted */ |
| wmi_tlv_print_verbose("%s: [tlv %d]: tag=%d, len=%d\n", |
| __func__, tlv_index, curr_tlv_tag, |
| curr_tlv_len); |
| |
| /* Validating Tag ID order */ |
| if (curr_tlv_tag != attr_struct_ptr.tag_id) { |
| wmi_tlv_print_error |
| ("%s: ERROR: TLV has wrong tag in order for Cmd=0x%x. Given=%d, Expected=%d.\n", |
| __func__, wmi_cmd_event_id, curr_tlv_tag, |
| attr_struct_ptr.tag_id); |
| goto Error_wmitlv_check_tlv_params; |
| } |
| |
| /* Validate Tag length */ |
| /* Array TLVs length checking needs special handling */ |
| if ((curr_tlv_tag >= WMITLV_TAG_FIRST_ARRAY_ENUM) |
| && (curr_tlv_tag <= WMITLV_TAG_LAST_ARRAY_ENUM)) { |
| if (attr_struct_ptr.tag_varied_size == WMITLV_SIZE_FIX) { |
| /* Array size can't be invalid for fixed size Array TLV */ |
| if (WMITLV_ARR_SIZE_INVALID == |
| attr_struct_ptr.tag_array_size) { |
| wmi_tlv_print_error |
| ("%s: ERROR: array_size can't be invalid for Array TLV Cmd=0x%x Tag=%d\n", |
| __func__, wmi_cmd_event_id, |
| curr_tlv_tag); |
| goto Error_wmitlv_check_tlv_params; |
| } |
| |
| expected_tlv_len = |
| attr_struct_ptr.tag_array_size * |
| attr_struct_ptr.tag_struct_size; |
| /* Paddding is only required for Byte array Tlvs all other array tlv's should be aligned to 4 bytes during their definition */ |
| if (WMITLV_TAG_ARRAY_BYTE == |
| attr_struct_ptr.tag_id) { |
| expected_tlv_len = |
| roundup(expected_tlv_len, |
| sizeof(A_UINT32)); |
| } |
| |
| if (curr_tlv_len != expected_tlv_len) { |
| wmi_tlv_print_error |
| ("%s: ERROR: TLV has wrong length for Cmd=0x%x. Tag_order=%d Tag=%d, Given_Len:%d Expected_Len=%d.\n", |
| __func__, wmi_cmd_event_id, |
| tlv_index, curr_tlv_tag, |
| curr_tlv_len, expected_tlv_len); |
| goto Error_wmitlv_check_tlv_params; |
| } |
| } else { |
| /* Array size should be invalid for variable size Array TLV */ |
| if (WMITLV_ARR_SIZE_INVALID != |
| attr_struct_ptr.tag_array_size) { |
| wmi_tlv_print_error |
| ("%s: ERROR: array_size should be invalid for Array TLV Cmd=0x%x Tag=%d\n", |
| __func__, wmi_cmd_event_id, |
| curr_tlv_tag); |
| goto Error_wmitlv_check_tlv_params; |
| } |
| |
| /* Incase of variable length TLV's, there is no expectation on the length field so do whatever checking |
| you can depending on the TLV tag if TLV length is non-zero */ |
| if (curr_tlv_len != 0) { |
| /* Verify TLV length is aligned to the size of structure */ |
| if ((curr_tlv_len % |
| attr_struct_ptr.tag_struct_size) != |
| 0) { |
| wmi_tlv_print_error |
| ("%s: ERROR: TLV length %d for Cmd=0x%x is not aligned to size of structure(%d bytes)\n", |
| __func__, curr_tlv_len, |
| wmi_cmd_event_id, |
| attr_struct_ptr. |
| tag_struct_size); |
| goto Error_wmitlv_check_tlv_params; |
| } |
| |
| if (curr_tlv_tag == |
| WMITLV_TAG_ARRAY_STRUC) { |
| A_UINT8 *tlv_buf_ptr = NULL; |
| A_UINT32 in_tlv_len; |
| A_UINT32 idx; |
| A_UINT32 num_of_elems; |
| |
| /* Verify length of inner TLVs */ |
| |
| num_of_elems = |
| curr_tlv_len / |
| attr_struct_ptr. |
| tag_struct_size; |
| /* Set tlv_buf_ptr to the first inner TLV address */ |
| tlv_buf_ptr = |
| buf_ptr + WMI_TLV_HDR_SIZE; |
| for (idx = 0; |
| idx < num_of_elems; |
| idx++) { |
| in_tlv_len = |
| WMITLV_GET_TLVLEN |
| (WMITLV_GET_HDR |
| (tlv_buf_ptr)); |
| if ((in_tlv_len + |
| WMI_TLV_HDR_SIZE) |
| != |
| attr_struct_ptr. |
| tag_struct_size) { |
| wmi_tlv_print_error |
| ("%s: ERROR: TLV has wrong length for Cmd=0x%x. Tag_order=%d Tag=%d, Given_Len:%zu Expected_Len=%d.\n", |
| __func__, |
| wmi_cmd_event_id, |
| tlv_index, |
| curr_tlv_tag, |
| (in_tlv_len |
| + |
| WMI_TLV_HDR_SIZE), |
| attr_struct_ptr. |
| tag_struct_size); |
| goto Error_wmitlv_check_tlv_params; |
| } |
| tlv_buf_ptr += |
| in_tlv_len + |
| WMI_TLV_HDR_SIZE; |
| } |
| } else |
| if ((curr_tlv_tag == |
| WMITLV_TAG_ARRAY_UINT32) |
| || (curr_tlv_tag == |
| WMITLV_TAG_ARRAY_BYTE) |
| || (curr_tlv_tag == |
| WMITLV_TAG_ARRAY_FIXED_STRUC)) |
| { |
| /* Nothing to verify here */ |
| } else { |
| wmi_tlv_print_error |
| ("%s ERROR Need to handle the Array tlv %d for variable length for Cmd=0x%x\n", |
| __func__, |
| attr_struct_ptr.tag_id, |
| wmi_cmd_event_id); |
| goto Error_wmitlv_check_tlv_params; |
| } |
| } |
| } |
| } else { |
| /* Non-array TLV. */ |
| |
| if ((curr_tlv_len + WMI_TLV_HDR_SIZE) != |
| attr_struct_ptr.tag_struct_size) { |
| wmi_tlv_print_error |
| ("%s: ERROR: TLV has wrong length for Cmd=0x%x. Given=%zu, Expected=%d.\n", |
| __func__, wmi_cmd_event_id, |
| (curr_tlv_len + WMI_TLV_HDR_SIZE), |
| attr_struct_ptr.tag_struct_size); |
| goto Error_wmitlv_check_tlv_params; |
| } |
| } |
| |
| /* Check TLV length is aligned to 4 bytes or not */ |
| if ((curr_tlv_len % sizeof(A_UINT32)) != 0) { |
| wmi_tlv_print_error |
| ("%s: ERROR: TLV length %d for Cmd=0x%x is not aligned to %zu bytes\n", |
| __func__, curr_tlv_len, wmi_cmd_event_id, |
| sizeof(A_UINT32)); |
| goto Error_wmitlv_check_tlv_params; |
| } |
| |
| tlv_index++; |
| buf_ptr += curr_tlv_len + WMI_TLV_HDR_SIZE; |
| buf_idx += curr_tlv_len + WMI_TLV_HDR_SIZE; |
| } |
| |
| if (tlv_index != expected_num_tlvs) { |
| wmi_tlv_print_verbose |
| ("%s: INFO: Less number of TLVs filled for Cmd=0x%x Filled %d Expected=%d\n", |
| __func__, wmi_cmd_event_id, tlv_index, expected_num_tlvs); |
| } |
| |
| return (0); |
| Error_wmitlv_check_tlv_params: |
| return (-1); |
| } |
| |
| /* |
| * Helper Function to vaidate the prepared TLV's for an WMI event to be sent |
| * Return 0 if success. |
| * <0 if failure. |
| */ |
| int |
| wmitlv_check_event_tlv_params(void *os_handle, void *param_struc_ptr, |
| A_UINT32 param_buf_len, A_UINT32 wmi_cmd_event_id) |
| { |
| A_UINT32 is_cmd_id = 0; |
| return (wmitlv_check_tlv_params |
| (os_handle, param_struc_ptr, param_buf_len, is_cmd_id, |
| wmi_cmd_event_id)); |
| } |
| |
| /* |
| * Helper Function to vaidate the prepared TLV's for an WMI command to be sent |
| * Return 0 if success. |
| * <0 if failure. |
| */ |
| int |
| wmitlv_check_command_tlv_params(void *os_handle, void *param_struc_ptr, |
| A_UINT32 param_buf_len, |
| A_UINT32 wmi_cmd_event_id) |
| { |
| A_UINT32 is_cmd_id = 1; |
| return (wmitlv_check_tlv_params |
| (os_handle, param_struc_ptr, param_buf_len, is_cmd_id, |
| wmi_cmd_event_id)); |
| } |
| |
| /* |
| * Helper Function to vaidate the TLV's coming for an event/command and also pads data to TLV's if necessary |
| * Return 0 if success. |
| <0 if failure. |
| */ |
| static int |
| wmitlv_check_and_pad_tlvs(void *os_handle, void *param_struc_ptr, |
| A_UINT32 param_buf_len, A_UINT32 is_cmd_id, |
| A_UINT32 wmi_cmd_event_id, void **wmi_cmd_struct_ptr) |
| { |
| wmitlv_attributes_struc attr_struct_ptr; |
| A_UINT32 buf_idx = 0; |
| A_UINT32 tlv_index = 0; |
| A_UINT32 num_of_elems = 0; |
| int tlv_size_diff = 0; |
| A_UINT8 *buf_ptr = (unsigned char *)param_struc_ptr; |
| wmitlv_cmd_param_info *cmd_param_tlvs_ptr = NULL; |
| A_UINT32 remaining_expected_tlvs = 0xFFFFFFFF; |
| A_UINT32 len_wmi_cmd_struct_buf; |
| |
| /* Get the number of TLVs for this command/event */ |
| if (wmitlv_get_attributes |
| (is_cmd_id, wmi_cmd_event_id, WMITLV_GET_ATTRIB_NUM_TLVS, |
| &attr_struct_ptr) != 0) { |
| wmi_tlv_print_error |
| ("%s: ERROR: Couldn't get expected number of TLVs for Cmd=%d\n", |
| __func__, wmi_cmd_event_id); |
| return -1; |
| } |
| /* NOTE: the returned number of TLVs is in "attr_struct_ptr.cmd_num_tlv" */ |
| |
| /* Create base structure of format wmi_cmd_event_id##_param_tlvs */ |
| len_wmi_cmd_struct_buf = |
| attr_struct_ptr.cmd_num_tlv * sizeof(wmitlv_cmd_param_info); |
| #ifndef NO_DYNAMIC_MEM_ALLOC |
| /* Dynamic memory allocation supported */ |
| wmi_tlv_os_mem_alloc(os_handle, *wmi_cmd_struct_ptr, |
| len_wmi_cmd_struct_buf); |
| #else |
| /* Dynamic memory allocation is not supported. Use the buffer g_wmi_static_cmd_param_info_buf, which should be set using wmi_tlv_set_static_param_tlv_buf(), |
| for base structure of format wmi_cmd_event_id##_param_tlvs */ |
| *wmi_cmd_struct_ptr = g_wmi_static_cmd_param_info_buf; |
| if (attr_struct_ptr.cmd_num_tlv > g_wmi_static_max_cmd_param_tlvs) { |
| /* Error: Expecting more TLVs that accomodated for static structure */ |
| wmi_tlv_print_error |
| ("%s: Error: Expecting more TLVs that accomodated for static structure. Expected:%d Accomodated:%d\n", |
| __func__, attr_struct_ptr.cmd_num_tlv, |
| g_wmi_static_max_cmd_param_tlvs); |
| return -1; |
| } |
| #endif |
| if (*wmi_cmd_struct_ptr == NULL) { |
| /* Error: unable to alloc memory */ |
| wmi_tlv_print_error |
| ("%s: Error: unable to alloc memory (size=%d) for TLV\n", |
| __func__, len_wmi_cmd_struct_buf); |
| return -1; |
| } |
| |
| cmd_param_tlvs_ptr = (wmitlv_cmd_param_info *) *wmi_cmd_struct_ptr; |
| wmi_tlv_OS_MEMZERO(cmd_param_tlvs_ptr, len_wmi_cmd_struct_buf); |
| remaining_expected_tlvs = attr_struct_ptr.cmd_num_tlv; |
| |
| while (((buf_idx + WMI_TLV_HDR_SIZE) <= param_buf_len) |
| && (remaining_expected_tlvs)) { |
| A_UINT32 curr_tlv_tag = |
| WMITLV_GET_TLVTAG(WMITLV_GET_HDR(buf_ptr)); |
| A_UINT32 curr_tlv_len = |
| WMITLV_GET_TLVLEN(WMITLV_GET_HDR(buf_ptr)); |
| int num_padding_bytes = 0; |
| |
| /* Get the attributes of the TLV with the given order in "tlv_index" */ |
| wmi_tlv_OS_MEMZERO(&attr_struct_ptr, |
| sizeof(wmitlv_attributes_struc)); |
| if (wmitlv_get_attributes |
| (is_cmd_id, wmi_cmd_event_id, tlv_index, |
| &attr_struct_ptr) != 0) { |
| wmi_tlv_print_error |
| ("%s: ERROR: No TLV attributes found for Cmd=%d Tag_order=%d\n", |
| __func__, wmi_cmd_event_id, tlv_index); |
| goto Error_wmitlv_check_and_pad_tlvs; |
| } |
| |
| /* Found the TLV that we wanted */ |
| wmi_tlv_print_verbose("%s: [tlv %d]: tag=%d, len=%d\n", |
| __func__, tlv_index, curr_tlv_tag, |
| curr_tlv_len); |
| |
| /* Validating Tag order */ |
| if (curr_tlv_tag != attr_struct_ptr.tag_id) { |
| wmi_tlv_print_error |
| ("%s: ERROR: TLV has wrong tag in order for Cmd=0x%x. Given=%d, Expected=%d.\n", |
| __func__, wmi_cmd_event_id, curr_tlv_tag, |
| attr_struct_ptr.tag_id); |
| goto Error_wmitlv_check_and_pad_tlvs; |
| } |
| |
| if ((curr_tlv_tag >= WMITLV_TAG_FIRST_ARRAY_ENUM) |
| && (curr_tlv_tag <= WMITLV_TAG_LAST_ARRAY_ENUM)) { |
| /* Current Tag is an array of some kind. */ |
| /* Skip the TLV header of this array */ |
| buf_ptr += WMI_TLV_HDR_SIZE; |
| buf_idx += WMI_TLV_HDR_SIZE; |
| } else { |
| /* Non-array TLV. */ |
| curr_tlv_len += WMI_TLV_HDR_SIZE; |
| } |
| |
| if (attr_struct_ptr.tag_varied_size == WMITLV_SIZE_FIX) { |
| /* This TLV is fixed length */ |
| if (WMITLV_ARR_SIZE_INVALID == |
| attr_struct_ptr.tag_array_size) { |
| tlv_size_diff = |
| curr_tlv_len - |
| attr_struct_ptr.tag_struct_size; |
| num_of_elems = |
| (curr_tlv_len > WMI_TLV_HDR_SIZE) ? 1 : 0; |
| } else { |
| tlv_size_diff = |
| curr_tlv_len - |
| (attr_struct_ptr.tag_struct_size * |
| attr_struct_ptr.tag_array_size); |
| num_of_elems = attr_struct_ptr.tag_array_size; |
| } |
| } else { |
| /* This TLV has a variable number of elements */ |
| if (WMITLV_TAG_ARRAY_STRUC == attr_struct_ptr.tag_id) { |
| A_UINT32 in_tlv_len = 0; |
| |
| if (curr_tlv_len != 0) { |
| in_tlv_len = |
| WMITLV_GET_TLVLEN(WMITLV_GET_HDR |
| (buf_ptr)); |
| in_tlv_len += WMI_TLV_HDR_SIZE; |
| tlv_size_diff = |
| in_tlv_len - |
| attr_struct_ptr.tag_struct_size; |
| num_of_elems = |
| curr_tlv_len / in_tlv_len; |
| wmi_tlv_print_verbose |
| ("%s: WARN: TLV array of structures in_tlv_len=%d struct_size:%d diff:%d num_of_elems=%d \n", |
| __func__, in_tlv_len, |
| attr_struct_ptr.tag_struct_size, |
| tlv_size_diff, num_of_elems); |
| } else { |
| tlv_size_diff = 0; |
| num_of_elems = 0; |
| } |
| } else |
| if ((WMITLV_TAG_ARRAY_UINT32 == |
| attr_struct_ptr.tag_id) |
| || (WMITLV_TAG_ARRAY_BYTE == |
| attr_struct_ptr.tag_id) |
| || (WMITLV_TAG_ARRAY_FIXED_STRUC == |
| attr_struct_ptr.tag_id)) { |
| tlv_size_diff = 0; |
| num_of_elems = |
| curr_tlv_len / |
| attr_struct_ptr.tag_struct_size; |
| } else { |
| wmi_tlv_print_error |
| ("%s ERROR Need to handle this tag ID for variable length %d\n", |
| __func__, attr_struct_ptr.tag_id); |
| goto Error_wmitlv_check_and_pad_tlvs; |
| } |
| } |
| |
| if ((WMITLV_TAG_ARRAY_STRUC == attr_struct_ptr.tag_id) && |
| (tlv_size_diff != 0)) { |
| void *new_tlv_buf = NULL; |
| A_UINT8 *tlv_buf_ptr = NULL; |
| A_UINT32 in_tlv_len; |
| A_UINT32 i; |
| |
| if (attr_struct_ptr.tag_varied_size == WMITLV_SIZE_FIX) { |
| /* This is not allowed. The tag WMITLV_TAG_ARRAY_STRUC can only be used with variable-length structure array |
| should not have a fixed number of elements (contradicting). Use WMITLV_TAG_ARRAY_FIXED_STRUC tag for |
| fixed size structure array(where structure never change without breaking compatibility) */ |
| wmi_tlv_print_error |
| ("%s: ERROR: TLV (tag=%d) should be variable-length and not fixed length\n", |
| __func__, curr_tlv_tag); |
| goto Error_wmitlv_check_and_pad_tlvs; |
| } |
| |
| /* Warning: Needs to allocate a larger structure and pad with zeros */ |
| wmi_tlv_print_error |
| ("%s: WARN: TLV array of structures needs padding. tlv_size_diff=%d\n", |
| __func__, tlv_size_diff); |
| |
| /* incoming structure length */ |
| in_tlv_len = |
| WMITLV_GET_TLVLEN(WMITLV_GET_HDR(buf_ptr)) + |
| WMI_TLV_HDR_SIZE; |
| #ifndef NO_DYNAMIC_MEM_ALLOC |
| wmi_tlv_os_mem_alloc(os_handle, new_tlv_buf, |
| (num_of_elems * |
| attr_struct_ptr.tag_struct_size)); |
| if (new_tlv_buf == NULL) { |
| /* Error: unable to alloc memory */ |
| wmi_tlv_print_error |
| ("%s: Error: unable to alloc memory (size=%d) for padding the TLV array %d\n", |
| __func__, |
| (num_of_elems * |
| attr_struct_ptr.tag_struct_size), |
| curr_tlv_tag); |
| goto Error_wmitlv_check_and_pad_tlvs; |
| } |
| |
| wmi_tlv_OS_MEMZERO(new_tlv_buf, |
| (num_of_elems * |
| attr_struct_ptr.tag_struct_size)); |
| tlv_buf_ptr = (A_UINT8 *) new_tlv_buf; |
| for (i = 0; i < num_of_elems; i++) { |
| if (tlv_size_diff > 0) { |
| /* Incoming structure size is greater than expected structure size. |
| so copy the number of bytes equal to expected structure size */ |
| wmi_tlv_OS_MEMCPY(tlv_buf_ptr, |
| (void *)(buf_ptr + |
| i * |
| in_tlv_len), |
| attr_struct_ptr. |
| tag_struct_size); |
| } else { |
| /* Incoming structure size is smaller than expected structure size. |
| so copy the number of bytes equal to incoming structure size |
| (other bytes would be zeroes) */ |
| wmi_tlv_OS_MEMCPY(tlv_buf_ptr, |
| (void *)(buf_ptr + |
| i * |
| in_tlv_len), |
| in_tlv_len); |
| } |
| tlv_buf_ptr += attr_struct_ptr.tag_struct_size; |
| } |
| #else |
| { |
| A_UINT8 *src_addr; |
| A_UINT8 *dst_addr; |
| A_UINT32 buf_mov_len; |
| |
| if (tlv_size_diff < 0) { |
| /* Incoming structure size is smaller than expected size then this needs padding for each element in the array */ |
| |
| /* Find amount of bytes to be padded for one element */ |
| num_padding_bytes = tlv_size_diff * -1; |
| |
| /* Move subsequent TLVs by number of bytes to be padded for all elements */ |
| if (param_buf_len > |
| (buf_idx + curr_tlv_len)) { |
| src_addr = |
| buf_ptr + curr_tlv_len; |
| dst_addr = |
| buf_ptr + curr_tlv_len + |
| (num_padding_bytes * |
| num_of_elems); |
| buf_mov_len = |
| param_buf_len - (buf_idx + |
| curr_tlv_len); |
| |
| wmi_tlv_OS_MEMMOVE(dst_addr, |
| src_addr, |
| buf_mov_len); |
| } |
| |
| /* Move subsequent elements of array down by number of bytes to be padded for one element and alse set padding bytes to zero */ |
| tlv_buf_ptr = buf_ptr; |
| for (i = 0; i < num_of_elems; i++) { |
| src_addr = |
| tlv_buf_ptr + in_tlv_len; |
| if (i != (num_of_elems - 1)) { |
| /* Need not move anything for last element in the array */ |
| dst_addr = |
| tlv_buf_ptr + |
| in_tlv_len + |
| num_padding_bytes; |
| buf_mov_len = |
| curr_tlv_len - |
| ((i + |
| 1) * in_tlv_len); |
| |
| wmi_tlv_OS_MEMMOVE |
| (dst_addr, src_addr, |
| buf_mov_len); |
| } |
| |
| /* Set the padding bytes to zeroes */ |
| wmi_tlv_OS_MEMZERO(src_addr, |
| num_padding_bytes); |
| |
| tlv_buf_ptr += |
| attr_struct_ptr. |
| tag_struct_size; |
| } |
| |
| /* Update the number of padding bytes to total number of bytes padded for all elements in the array */ |
| num_padding_bytes = |
| num_padding_bytes * num_of_elems; |
| |
| new_tlv_buf = buf_ptr; |
| } else { |
| /* Incoming structure size is greater than expected size then this needs shrinking for each element in the array */ |
| |
| /* Find amount of bytes to be shrinked for one element */ |
| num_padding_bytes = tlv_size_diff * -1; |
| |
| /* Move subsequent elements of array up by number of bytes to be shrinked for one element */ |
| tlv_buf_ptr = buf_ptr; |
| for (i = 0; i < (num_of_elems - 1); i++) { |
| src_addr = |
| tlv_buf_ptr + in_tlv_len; |
| dst_addr = |
| tlv_buf_ptr + in_tlv_len + |
| num_padding_bytes; |
| buf_mov_len = |
| curr_tlv_len - |
| ((i + 1) * in_tlv_len); |
| |
| wmi_tlv_OS_MEMMOVE(dst_addr, |
| src_addr, |
| buf_mov_len); |
| |
| tlv_buf_ptr += |
| attr_struct_ptr. |
| tag_struct_size; |
| } |
| |
| /* Move subsequent TLVs by number of bytes to be shrinked for all elements */ |
| if (param_buf_len > |
| (buf_idx + curr_tlv_len)) { |
| src_addr = |
| buf_ptr + curr_tlv_len; |
| dst_addr = |
| buf_ptr + curr_tlv_len + |
| (num_padding_bytes * |
| num_of_elems); |
| buf_mov_len = |
| param_buf_len - (buf_idx + |
| curr_tlv_len); |
| |
| wmi_tlv_OS_MEMMOVE(dst_addr, |
| src_addr, |
| buf_mov_len); |
| } |
| |
| /* Update the number of padding bytes to total number of bytes shrinked for all elements in the array */ |
| num_padding_bytes = |
| num_padding_bytes * num_of_elems; |
| |
| new_tlv_buf = buf_ptr; |
| } |
| } |
| #endif |
| cmd_param_tlvs_ptr[tlv_index].tlv_ptr = new_tlv_buf; |
| cmd_param_tlvs_ptr[tlv_index].num_elements = |
| num_of_elems; |
| cmd_param_tlvs_ptr[tlv_index].buf_is_allocated = 1; /* Indicates that buffer is allocated */ |
| |
| } else if (tlv_size_diff >= 0) { |
| /* Warning: some parameter truncation */ |
| if (tlv_size_diff > 0) { |
| wmi_tlv_print_verbose |
| ("%s: WARN: TLV truncated. tlv_size_diff=%d, curr_tlv_len=%d\n", |
| __func__, tlv_size_diff, curr_tlv_len); |
| } |
| /* TODO: this next line needs more comments and explanation */ |
| cmd_param_tlvs_ptr[tlv_index].tlv_ptr = |
| (attr_struct_ptr.tag_varied_size |
| && !curr_tlv_len) ? NULL : (void *)buf_ptr; |
| cmd_param_tlvs_ptr[tlv_index].num_elements = |
| num_of_elems; |
| cmd_param_tlvs_ptr[tlv_index].buf_is_allocated = 0; /* Indicates that buffer is not allocated */ |
| } else { |
| void *new_tlv_buf = NULL; |
| |
| /* Warning: Needs to allocate a larger structure and pad with zeros */ |
| wmi_tlv_print_verbose |
| ("%s: WARN: TLV needs padding. tlv_size_diff=%d\n", |
| __func__, tlv_size_diff); |
| #ifndef NO_DYNAMIC_MEM_ALLOC |
| /* Dynamic memory allocation is supported */ |
| wmi_tlv_os_mem_alloc(os_handle, new_tlv_buf, |
| (curr_tlv_len - tlv_size_diff)); |
| if (new_tlv_buf == NULL) { |
| /* Error: unable to alloc memory */ |
| wmi_tlv_print_error |
| ("%s: Error: unable to alloc memory (size=%d) for padding the TLV %d\n", |
| __func__, (curr_tlv_len - tlv_size_diff), |
| curr_tlv_tag); |
| goto Error_wmitlv_check_and_pad_tlvs; |
| } |
| |
| wmi_tlv_OS_MEMZERO(new_tlv_buf, |
| (curr_tlv_len - tlv_size_diff)); |
| wmi_tlv_OS_MEMCPY(new_tlv_buf, (void *)buf_ptr, |
| curr_tlv_len); |
| #else |
| /* Dynamic memory allocation is not supported. Padding has to be done with in the existing buffer assuming we have enough space |
| to grow */ |
| { |
| /* Note: tlv_size_diff is a value less than zero */ |
| /* Move the Subsequent TLVs by amount of bytes needs to be padded */ |
| A_UINT8 *src_addr; |
| A_UINT8 *dst_addr; |
| A_UINT32 src_len; |
| |
| num_padding_bytes = (tlv_size_diff * -1); |
| |
| src_addr = buf_ptr + curr_tlv_len; |
| dst_addr = |
| buf_ptr + curr_tlv_len + num_padding_bytes; |
| src_len = |
| param_buf_len - (buf_idx + curr_tlv_len); |
| |
| wmi_tlv_OS_MEMMOVE(dst_addr, src_addr, src_len); |
| |
| /* Set the padding bytes to zeroes */ |
| wmi_tlv_OS_MEMZERO(src_addr, num_padding_bytes); |
| |
| new_tlv_buf = buf_ptr; |
| } |
| #endif |
| cmd_param_tlvs_ptr[tlv_index].tlv_ptr = new_tlv_buf; |
| cmd_param_tlvs_ptr[tlv_index].num_elements = |
| num_of_elems; |
| cmd_param_tlvs_ptr[tlv_index].buf_is_allocated = 1; /* Indicates that buffer is allocated */ |
| } |
| |
| tlv_index++; |
| remaining_expected_tlvs--; |
| buf_ptr += curr_tlv_len + num_padding_bytes; |
| buf_idx += curr_tlv_len + num_padding_bytes; |
| } |
| |
| return (0); |
| Error_wmitlv_check_and_pad_tlvs: |
| if (is_cmd_id) { |
| wmitlv_free_allocated_command_tlvs(wmi_cmd_event_id, |
| wmi_cmd_struct_ptr); |
| } else { |
| wmitlv_free_allocated_event_tlvs(wmi_cmd_event_id, |
| wmi_cmd_struct_ptr); |
| } |
| *wmi_cmd_struct_ptr = NULL; |
| return (-1); |
| } |
| |
| /* |
| * Helper Function to validate and pad(if necessary) for incoming WMI Event TLVs |
| * Return 0 if success. |
| <0 if failure. |
| */ |
| int |
| wmitlv_check_and_pad_event_tlvs(void *os_handle, void *param_struc_ptr, |
| A_UINT32 param_buf_len, |
| A_UINT32 wmi_cmd_event_id, |
| void **wmi_cmd_struct_ptr) |
| { |
| A_UINT32 is_cmd_id = 0; |
| return (wmitlv_check_and_pad_tlvs |
| (os_handle, param_struc_ptr, param_buf_len, is_cmd_id, |
| wmi_cmd_event_id, wmi_cmd_struct_ptr)); |
| } |
| |
| /* |
| * Helper Function to validate and pad(if necessary) for incoming WMI Command TLVs |
| * Return 0 if success. |
| <0 if failure. |
| */ |
| int |
| wmitlv_check_and_pad_command_tlvs(void *os_handle, void *param_struc_ptr, |
| A_UINT32 param_buf_len, |
| A_UINT32 wmi_cmd_event_id, |
| void **wmi_cmd_struct_ptr) |
| { |
| A_UINT32 is_cmd_id = 1; |
| return (wmitlv_check_and_pad_tlvs |
| (os_handle, param_struc_ptr, param_buf_len, is_cmd_id, |
| wmi_cmd_event_id, wmi_cmd_struct_ptr)); |
| } |
| |
| /* |
| * Helper Function to free any allocated buffers for WMI Event/Command TLV processing |
| * Return None |
| */ |
| static void wmitlv_free_allocated_tlvs(A_UINT32 is_cmd_id, |
| A_UINT32 cmd_event_id, |
| void **wmi_cmd_struct_ptr) |
| { |
| void *ptr = *wmi_cmd_struct_ptr; |
| |
| if (!ptr) { |
| wmi_tlv_print_error("%s: Nothing to free for CMD/Event 0x%x\n", |
| __func__, cmd_event_id); |
| return; |
| } |
| #ifndef NO_DYNAMIC_MEM_ALLOC |
| |
| /* macro to free that previously allocated memory for this TLV. When (op==FREE_TLV_ELEM). */ |
| #define WMITLV_OP_FREE_TLV_ELEM_macro(param_ptr, param_len, wmi_cmd_event_id, elem_tlv_tag, elem_struc_type, elem_name, var_len, arr_size) \ |
| if ((((WMITLV_TYPEDEF_STRUCT_PARAMS_TLVS(wmi_cmd_event_id) *)ptr)->WMITLV_FIELD_BUF_IS_ALLOCATED(elem_name)) && \ |
| (((WMITLV_TYPEDEF_STRUCT_PARAMS_TLVS(wmi_cmd_event_id) *)ptr)->elem_name != NULL)) \ |
| { \ |
| wmi_tlv_os_mem_free(((WMITLV_TYPEDEF_STRUCT_PARAMS_TLVS(wmi_cmd_event_id) *)ptr)->elem_name); \ |
| } |
| |
| #define WMITLV_FREE_TLV_ELEMS(id) \ |
| case id: \ |
| { \ |
| WMITLV_TABLE(id, FREE_TLV_ELEM, NULL, 0) \ |
| } \ |
| break; |
| |
| if (is_cmd_id) { |
| switch (cmd_event_id) { |
| WMITLV_ALL_CMD_LIST(WMITLV_FREE_TLV_ELEMS); |
| default: |
| wmi_tlv_print_error |
| ("%s: ERROR: Cannot find the TLVs attributes for Cmd=0x%x, %d\n", |
| __func__, cmd_event_id, cmd_event_id); |
| } |
| } else { |
| switch (cmd_event_id) { |
| WMITLV_ALL_EVT_LIST(WMITLV_FREE_TLV_ELEMS); |
| default: |
| wmi_tlv_print_error |
| ("%s: ERROR: Cannot find the TLVs attributes for Cmd=0x%x, %d\n", |
| __func__, cmd_event_id, cmd_event_id); |
| } |
| } |
| |
| wmi_tlv_os_mem_free(*wmi_cmd_struct_ptr); |
| *wmi_cmd_struct_ptr = NULL; |
| #endif |
| |
| return; |
| } |
| |
| /* |
| * Helper Function to free any allocated buffers for WMI Command TLV processing |
| * Return None |
| */ |
| void wmitlv_free_allocated_command_tlvs(A_UINT32 cmd_event_id, |
| void **wmi_cmd_struct_ptr) |
| { |
| wmitlv_free_allocated_tlvs(1, cmd_event_id, wmi_cmd_struct_ptr); |
| } |
| |
| /* |
| * Helper Function to free any allocated buffers for WMI Event TLV processing |
| * Return None |
| */ |
| void wmitlv_free_allocated_event_tlvs(A_UINT32 cmd_event_id, |
| void **wmi_cmd_struct_ptr) |
| { |
| wmitlv_free_allocated_tlvs(0, cmd_event_id, wmi_cmd_struct_ptr); |
| } |
| |
| /* |
| * Returns 1 if the two given versions are compatible. |
| * Else return 0 if Incompatible. |
| */ |
| int |
| wmi_versions_are_compatible(wmi_abi_version *vers1, wmi_abi_version *vers2) |
| { |
| if ((vers1->abi_version_ns_0 != vers2->abi_version_ns_0) || |
| (vers1->abi_version_ns_1 != vers2->abi_version_ns_1) || |
| (vers1->abi_version_ns_2 != vers2->abi_version_ns_2) || |
| (vers1->abi_version_ns_3 != vers2->abi_version_ns_3)) { |
| /* The namespaces are different. Incompatible. */ |
| return 0; |
| } |
| |
| if (vers1->abi_version_0 != vers2->abi_version_0) { |
| /* The major or minor versions are different. Incompatible */ |
| return 0; |
| } |
| /* We ignore the build version */ |
| return 1; |
| } |
| |
| /* |
| * Returns 1 if the two given versions are compatible. |
| * Else return 0 if Incompatible. |
| */ |
| int |
| wmi_versions_can_downgrade(int num_whitelist, |
| wmi_whitelist_version_info *version_whitelist_table, |
| wmi_abi_version *my_vers, |
| wmi_abi_version *opp_vers, |
| wmi_abi_version *out_vers) |
| { |
| A_UINT8 can_try_to_downgrade; |
| A_UINT32 my_major_vers = WMI_VER_GET_MAJOR(my_vers->abi_version_0); |
| A_UINT32 my_minor_vers = WMI_VER_GET_MINOR(my_vers->abi_version_0); |
| A_UINT32 opp_major_vers = WMI_VER_GET_MAJOR(opp_vers->abi_version_0); |
| A_UINT32 opp_minor_vers = WMI_VER_GET_MINOR(opp_vers->abi_version_0); |
| A_UINT32 downgraded_minor_vers; |
| |
| if ((my_vers->abi_version_ns_0 != opp_vers->abi_version_ns_0) || |
| (my_vers->abi_version_ns_1 != opp_vers->abi_version_ns_1) || |
| (my_vers->abi_version_ns_2 != opp_vers->abi_version_ns_2) || |
| (my_vers->abi_version_ns_3 != opp_vers->abi_version_ns_3)) { |
| /* The namespaces are different. Incompatible. */ |
| can_try_to_downgrade = false; |
| } else if (my_major_vers != opp_major_vers) { |
| /* Major version is different. Incompatible and cannot downgrade. */ |
| can_try_to_downgrade = false; |
| } else { |
| /* Same major version. */ |
| |
| if (my_minor_vers < opp_minor_vers) { |
| /* Opposite party is newer. Incompatible and cannot downgrade. */ |
| can_try_to_downgrade = false; |
| } else if (my_minor_vers > opp_minor_vers) { |
| /* Opposite party is older. Check whitelist if we can downgrade */ |
| can_try_to_downgrade = true; |
| } else { |
| /* Same version */ |
| wmi_tlv_OS_MEMCPY(out_vers, my_vers, |
| sizeof(wmi_abi_version)); |
| return 1; |
| } |
| } |
| |
| if (!can_try_to_downgrade) { |
| wmi_tlv_print_error("%s: Warning: incompatible WMI version.\n", |
| __func__); |
| wmi_tlv_OS_MEMCPY(out_vers, my_vers, sizeof(wmi_abi_version)); |
| return 0; |
| } |
| /* Try to see we can downgrade the supported version */ |
| downgraded_minor_vers = my_minor_vers; |
| while (downgraded_minor_vers > opp_minor_vers) { |
| A_UINT8 downgraded = false; |
| int i; |
| |
| for (i = 0; i < num_whitelist; i++) { |
| if (version_whitelist_table[i].major != my_major_vers) { |
| continue; /* skip */ |
| } |
| if ((version_whitelist_table[i].namespace_0 != |
| my_vers->abi_version_ns_0) |
| || (version_whitelist_table[i].namespace_1 != |
| my_vers->abi_version_ns_1) |
| || (version_whitelist_table[i].namespace_2 != |
| my_vers->abi_version_ns_2) |
| || (version_whitelist_table[i].namespace_3 != |
| my_vers->abi_version_ns_3)) { |
| continue; /* skip */ |
| } |
| if (version_whitelist_table[i].minor == |
| downgraded_minor_vers) { |
| /* Found the next version that I can downgrade */ |
| wmi_tlv_print_error |
| ("%s: Note: found a whitelist entry to downgrade. wh. list ver: %d,%d,0x%x 0x%x 0x%x 0x%x\n", |
| __func__, version_whitelist_table[i].major, |
| version_whitelist_table[i].minor, |
| version_whitelist_table[i].namespace_0, |
| version_whitelist_table[i].namespace_1, |
| version_whitelist_table[i].namespace_2, |
| version_whitelist_table[i].namespace_3); |
| downgraded_minor_vers--; |
| downgraded = true; |
| break; |
| } |
| } |
| if (!downgraded) { |
| break; /* Done since we did not find any whitelist to downgrade version */ |
| } |
| } |
| wmi_tlv_OS_MEMCPY(out_vers, my_vers, sizeof(wmi_abi_version)); |
| out_vers->abi_version_0 = |
| WMI_VER_GET_VERSION_0(my_major_vers, downgraded_minor_vers); |
| if (downgraded_minor_vers != opp_minor_vers) { |
| wmi_tlv_print_error |
| ("%s: Warning: incompatible WMI version and cannot downgrade.\n", |
| __func__); |
| return 0; /* Incompatible */ |
| } else { |
| return 1; /* Compatible */ |
| } |
| } |
| |
| /* |
| * This routine will compare and set the WMI ABI version. |
| * First, compare my version with the opposite side's version. |
| * If incompatible, then check the whitelist to see if our side can downgrade. |
| * Finally, fill in the final ABI version into the output, out_vers. |
| * Return 0 if the output version is compatible . |
| * Else return 1 if the output version is incompatible. . |
| */ |
| int |
| wmi_cmp_and_set_abi_version(int num_whitelist, |
| wmi_whitelist_version_info * |
| version_whitelist_table, |
| struct _wmi_abi_version *my_vers, |
| struct _wmi_abi_version *opp_vers, |
| struct _wmi_abi_version *out_vers) |
| { |
| wmi_tlv_print_verbose |
| ("%s: Our WMI Version: Mj=%d, Mn=%d, bd=%d, ns0=0x%x ns1:0x%x ns2:0x%x ns3:0x%x\n", |
| __func__, WMI_VER_GET_MAJOR(my_vers->abi_version_0), |
| WMI_VER_GET_MINOR(my_vers->abi_version_0), my_vers->abi_version_1, |
| my_vers->abi_version_ns_0, my_vers->abi_version_ns_1, |
| my_vers->abi_version_ns_2, my_vers->abi_version_ns_3); |
| |
| wmi_tlv_print_verbose |
| ("%s: Opposite side WMI Version: Mj=%d, Mn=%d, bd=%d, ns0=0x%x ns1:0x%x ns2:0x%x ns3:0x%x\n", |
| __func__, WMI_VER_GET_MAJOR(opp_vers->abi_version_0), |
| WMI_VER_GET_MINOR(opp_vers->abi_version_0), |
| opp_vers->abi_version_1, opp_vers->abi_version_ns_0, |
| opp_vers->abi_version_ns_1, opp_vers->abi_version_ns_2, |
| opp_vers->abi_version_ns_3); |
| |
| /* By default, the output version is our version. */ |
| wmi_tlv_OS_MEMCPY(out_vers, my_vers, sizeof(wmi_abi_version)); |
| if (!wmi_versions_are_compatible(my_vers, opp_vers)) { |
| /* Our host version and the given firmware version are incompatible. */ |
| if (wmi_versions_can_downgrade |
| (num_whitelist, version_whitelist_table, my_vers, opp_vers, |
| out_vers)) { |
| /* We can downgrade our host versions to match firmware. */ |
| wmi_tlv_print_error |
| ("%s: Host downgraded WMI Versions to match fw. Ret version: Mj=%d, Mn=%d, bd=%d, ns0=0x%x ns1:0x%x ns2:0x%x ns3:0x%x\n", |
| __func__, |
| WMI_VER_GET_MAJOR(out_vers->abi_version_0), |
| WMI_VER_GET_MINOR(out_vers->abi_version_0), |
| out_vers->abi_version_1, |
| out_vers->abi_version_ns_0, |
| out_vers->abi_version_ns_1, |
| out_vers->abi_version_ns_2, |
| out_vers->abi_version_ns_3); |
| return 0; /* Compatible */ |
| } else { |
| /* Warn: We cannot downgrade our host versions to match firmware. */ |
| wmi_tlv_print_error |
| ("%s: WARN: Host WMI Versions mismatch with fw. Ret version: Mj=%d, Mn=%d, bd=%d, ns0=0x%x ns1:0x%x ns2:0x%x ns3:0x%x\n", |
| __func__, |
| WMI_VER_GET_MAJOR(out_vers->abi_version_0), |
| WMI_VER_GET_MINOR(out_vers->abi_version_0), |
| out_vers->abi_version_1, |
| out_vers->abi_version_ns_0, |
| out_vers->abi_version_ns_1, |
| out_vers->abi_version_ns_2, |
| out_vers->abi_version_ns_3); |
| |
| return 1; /* Incompatible */ |
| } |
| } else { |
| /* We are compatible. Our host version is the output version */ |
| wmi_tlv_print_verbose |
| ("%s: Host and FW Compatible WMI Versions. Ret version: Mj=%d, Mn=%d, bd=%d, ns0=0x%x ns1:0x%x ns2:0x%x ns3:0x%x\n", |
| __func__, WMI_VER_GET_MAJOR(out_vers->abi_version_0), |
| WMI_VER_GET_MINOR(out_vers->abi_version_0), |
| out_vers->abi_version_1, out_vers->abi_version_ns_0, |
| out_vers->abi_version_ns_1, out_vers->abi_version_ns_2, |
| out_vers->abi_version_ns_3); |
| return 0; /* Compatible */ |
| } |
| } |