1 /* 2 * Copyright (c) 2011,2017-2019 The Linux Foundation. All rights reserved. 3 * 4 * 5 * Permission to use, copy, modify, and/or distribute this software for 6 * any purpose with or without fee is hereby granted, provided that the 7 * above copyright notice and this permission notice appear in all 8 * copies. 9 * 10 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL 11 * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED 12 * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE 13 * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL 14 * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR 15 * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER 16 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR 17 * PERFORMANCE OF THIS SOFTWARE. 18 */ 19 20 #include <osdep.h> 21 #include <wlan_tgt_def_config.h> 22 #include <hif.h> 23 #include <hif_hw_version.h> 24 #include <wmi_unified_api.h> 25 #include <target_if_spectral.h> 26 #include <wlan_lmac_if_def.h> 27 #include <wlan_osif_priv.h> 28 #include <reg_services_public_struct.h> 29 30 void 31 target_if_spectral_create_samp_msg(struct target_if_spectral *spectral, 32 struct target_if_samp_msg_params *params) 33 { 34 /* 35 * XXX : Non-Rentrant. Will be an issue with dual concurrent 36 * operation on multi-processor system 37 */ 38 39 struct spectral_samp_msg *spec_samp_msg = NULL; 40 41 uint8_t *bin_pwr_data = NULL; 42 struct spectral_classifier_params *cp = NULL; 43 struct spectral_classifier_params *pcp = NULL; 44 struct target_if_spectral_ops *p_sops = NULL; 45 uint32_t *binptr_32 = NULL; 46 uint16_t *binptr_16 = NULL; 47 int idx = 0; 48 struct spectral_samp_data *samp_data; 49 static int samp_msg_index; 50 size_t pwr_count = 0; 51 size_t pwr_count_sec80 = 0; 52 enum spectral_msg_type msg_type; 53 QDF_STATUS ret; 54 55 ret = target_if_get_spectral_msg_type(params->smode, &msg_type); 56 if (QDF_IS_STATUS_ERROR(ret)) 57 return; 58 59 if ((params->smode == SPECTRAL_SCAN_MODE_AGILE) || 60 is_primaryseg_rx_inprog(spectral)) { 61 spec_samp_msg = (struct spectral_samp_msg *) 62 spectral->nl_cb.get_sbuff(spectral->pdev_obj, 63 msg_type, 64 SPECTRAL_MSG_BUF_NEW); 65 66 if (!spec_samp_msg) 67 return; 68 69 samp_data = &spec_samp_msg->samp_data; 70 p_sops = GET_TARGET_IF_SPECTRAL_OPS(spectral); 71 bin_pwr_data = params->bin_pwr_data; 72 73 spec_samp_msg->signature = SPECTRAL_SIGNATURE; 74 spec_samp_msg->freq = params->freq; 75 if (params->smode == SPECTRAL_SCAN_MODE_AGILE) 76 spec_samp_msg->agile_freq = params->agile_freq; 77 spec_samp_msg->freq_loading = params->freq_loading; 78 samp_data->spectral_mode = params->smode; 79 samp_data->spectral_data_len = params->datalen; 80 samp_data->spectral_rssi = params->rssi; 81 samp_data->ch_width = spectral->ch_width; 82 samp_data->spectral_agc_total_gain = params->agc_total_gain; 83 samp_data->spectral_gainchange = params->gainchange; 84 samp_data->spectral_pri80ind = params->pri80ind; 85 86 samp_data->spectral_combined_rssi = 87 (uint8_t)params->rssi; 88 samp_data->spectral_upper_rssi = params->upper_rssi; 89 samp_data->spectral_lower_rssi = params->lower_rssi; 90 91 qdf_mem_copy(samp_data->spectral_chain_ctl_rssi, 92 params->chain_ctl_rssi, 93 sizeof(params->chain_ctl_rssi)); 94 qdf_mem_copy(samp_data->spectral_chain_ext_rssi, 95 params->chain_ext_rssi, 96 sizeof(params->chain_ext_rssi)); 97 98 samp_data->spectral_bwinfo = params->bwinfo; 99 samp_data->spectral_tstamp = params->tstamp; 100 samp_data->spectral_max_index = params->max_index; 101 102 /* Classifier in user space needs access to these */ 103 samp_data->spectral_lower_max_index = 104 params->max_lower_index; 105 samp_data->spectral_upper_max_index = 106 params->max_upper_index; 107 samp_data->spectral_nb_lower = params->nb_lower; 108 samp_data->spectral_nb_upper = params->nb_upper; 109 samp_data->spectral_last_tstamp = params->last_tstamp; 110 samp_data->spectral_max_mag = params->max_mag; 111 112 /* 113 * Currently, we compute pwr_count considering the size of the 114 * samp_data->bin_pwr array rather than the number of elements 115 * in this array. The reasons are that 116 * SPECTRAL_MESSAGE_COPY_CHAR_ARRAY() where pwr_count will be 117 * used maps directly to OS_MEMCPY() on little endian platforms, 118 * and that samp_data->bin_pwr is an array of u_int8_t elements 119 * due to which the number of elements in the array == the size 120 * of the array. In case FFT bin size is increased from 8 bits 121 * in the future, this code would have to be changed along with 122 * rest of framework on which it depends. 123 */ 124 pwr_count = qdf_min((size_t)params->pwr_count, 125 sizeof(samp_data->bin_pwr)); 126 127 samp_data->bin_pwr_count = pwr_count; 128 samp_data->lb_edge_extrabins = 129 spectral->lb_edge_extrabins; 130 samp_data->rb_edge_extrabins = 131 spectral->rb_edge_extrabins; 132 samp_data->spectral_combined_rssi = params->rssi; 133 samp_data->spectral_max_scale = params->max_exp; 134 135 samp_data->noise_floor = params->noise_floor; 136 137 /* Classifier in user space needs access to these */ 138 cp = &samp_data->classifier_params; 139 pcp = ¶ms->classifier_params; 140 141 qdf_mem_copy(cp, pcp, 142 sizeof(struct spectral_classifier_params)); 143 144 if (spectral->fftbin_size_war == 145 SPECTRAL_FFTBIN_SIZE_WAR_4BYTE_TO_1BYTE) { 146 binptr_32 = (uint32_t *)bin_pwr_data; 147 for (idx = 0; idx < pwr_count; idx++) 148 samp_data->bin_pwr[idx] = *(binptr_32++); 149 } else if (spectral->fftbin_size_war == 150 SPECTRAL_FFTBIN_SIZE_WAR_2BYTE_TO_1BYTE) { 151 binptr_16 = (uint16_t *)bin_pwr_data; 152 for (idx = 0; idx < pwr_count; idx++) 153 samp_data->bin_pwr[idx] = *(binptr_16++); 154 } else { 155 SPECTRAL_MESSAGE_COPY_CHAR_ARRAY( 156 &samp_data->bin_pwr[0], bin_pwr_data, 157 pwr_count); 158 } 159 160 p_sops->get_mac_address(spectral, spec_samp_msg->macaddr); 161 } 162 163 if (is_secondaryseg_rx_inprog(spectral)) { 164 spec_samp_msg = (struct spectral_samp_msg *) 165 spectral->nl_cb.get_sbuff(spectral->pdev_obj, 166 msg_type, 167 SPECTRAL_MSG_BUF_SAVED); 168 169 if (!spec_samp_msg) { 170 spectral_err("Spectral SAMP message is NULL"); 171 return; 172 } 173 174 samp_data = &spec_samp_msg->samp_data; 175 spec_samp_msg->vhtop_ch_freq_seg1 = params->vhtop_ch_freq_seg1; 176 spec_samp_msg->vhtop_ch_freq_seg2 = params->vhtop_ch_freq_seg2; 177 samp_data->spectral_rssi_sec80 = 178 params->rssi_sec80; 179 samp_data->noise_floor_sec80 = 180 params->noise_floor_sec80; 181 spec_samp_msg->samp_data.spectral_agc_total_gain_sec80 = 182 params->agc_total_gain_sec80; 183 spec_samp_msg->samp_data.spectral_gainchange_sec80 = 184 params->gainchange_sec80; 185 spec_samp_msg->samp_data.spectral_pri80ind_sec80 = 186 params->pri80ind_sec80; 187 188 samp_data->spectral_data_len_sec80 = 189 params->datalen_sec80; 190 samp_data->spectral_max_index_sec80 = 191 params->max_index_sec80; 192 samp_data->spectral_max_mag_sec80 = 193 params->max_mag_sec80; 194 195 /* 196 * Currently, we compute pwr_count_sec80 considering the size of 197 * the samp_data->bin_pwr_sec80 array rather than the number of 198 * elements in this array. The reasons are that 199 * SPECTRAL_MESSAGE_COPY_CHAR_ARRAY() where pwr_count_sec80 will 200 * be used maps directly to OS_MEMCPY() on little endian 201 * platforms, and that samp_data->bin_pwr_sec80 is an array of 202 * u_int8_t elements due to which the number of elements in the 203 * array == the size of the array. In case FFT bin size is 204 * increased from 8 bits in the future, this code would have to 205 * be changed along with rest of framework on which it depends. 206 */ 207 pwr_count_sec80 = qdf_min((size_t)params->pwr_count_sec80, 208 sizeof(samp_data->bin_pwr_sec80)); 209 210 samp_data->bin_pwr_count_sec80 = pwr_count_sec80; 211 212 bin_pwr_data = params->bin_pwr_data_sec80; 213 if (spectral->fftbin_size_war == 214 SPECTRAL_FFTBIN_SIZE_WAR_4BYTE_TO_1BYTE) { 215 binptr_32 = (uint32_t *)bin_pwr_data; 216 for (idx = 0; idx < pwr_count_sec80; idx++) 217 samp_data->bin_pwr_sec80[idx] = *(binptr_32++); 218 } else if (spectral->fftbin_size_war == 219 SPECTRAL_FFTBIN_SIZE_WAR_2BYTE_TO_1BYTE) { 220 binptr_16 = (uint16_t *)bin_pwr_data; 221 for (idx = 0; idx < pwr_count_sec80; idx++) 222 samp_data->bin_pwr_sec80[idx] = *(binptr_16++); 223 } else { 224 SPECTRAL_MESSAGE_COPY_CHAR_ARRAY( 225 &samp_data->bin_pwr_sec80[0], 226 params->bin_pwr_data_sec80, 227 pwr_count_sec80); 228 } 229 } 230 231 if ((spectral->ch_width != CH_WIDTH_160MHZ) || 232 (params->smode == SPECTRAL_SCAN_MODE_AGILE) || 233 is_secondaryseg_rx_inprog(spectral)) { 234 if (spectral->send_phy_data(spectral->pdev_obj, 235 msg_type) == 0) 236 spectral->spectral_sent_msg++; 237 samp_msg_index++; 238 } 239 240 /* Take care of state transitions for 160MHz/ 80p80 */ 241 if ((spectral->spectral_gen == SPECTRAL_GEN3) && 242 (params->smode != SPECTRAL_SCAN_MODE_AGILE)) 243 target_if_160mhz_delivery_state_change( 244 spectral, 245 SPECTRAL_DETECTOR_INVALID); 246 } 247