3 * @file coreconfigurator.c
6 * @sa coreconfigurator.h
12 /*****************************************************************************/
14 /*****************************************************************************/
16 #include "coreconfigurator.h"
17 /*****************************************************************************/
19 /*****************************************************************************/
20 #define INLINE static __inline
22 #define MAX_CFG_PKTLEN 1450
23 #define MSG_HEADER_LEN 4
24 #define QUERY_MSG_TYPE 'Q'
25 #define WRITE_MSG_TYPE 'W'
26 #define RESP_MSG_TYPE 'R'
27 #define WRITE_RESP_SUCCESS 1
29 #define MAC_ADDR_LEN 6
30 #define TAG_PARAM_OFFSET (MAC_HDR_LEN + TIME_STAMP_LEN + \
31 BEACON_INTERVAL_LEN + CAP_INFO_LEN)
33 /*****************************************************************************/
35 /*****************************************************************************/
38 /*****************************************************************************/
39 /* Type Definitions */
40 /*****************************************************************************/
42 /* Basic Frame Type Codes (2-bit) */
44 FRAME_TYPE_CONTROL = 0x04,
45 FRAME_TYPE_DATA = 0x08,
46 FRAME_TYPE_MANAGEMENT = 0x00,
47 FRAME_TYPE_RESERVED = 0x0C,
48 FRAME_TYPE_FORCE_32BIT = 0xFFFFFFFF
51 /* Frame Type and Subtype Codes (6-bit) */
82 QOS_DATA_POLL_ACK = 0xB8,
83 QOS_NULL_FRAME = 0xC8,
85 QOS_CFPOLL_ACK = 0xF8,
88 FRAME_SUBTYPE_FORCE_32BIT = 0xFFFFFFFF
91 /* Basic Frame Classes */
93 CLASS1_FRAME_TYPE = 0x00,
94 CLASS2_FRAME_TYPE = 0x01,
95 CLASS3_FRAME_TYPE = 0x02,
96 FRAME_CLASS_FORCE_32BIT = 0xFFFFFFFF
99 /* Element ID of various Information Elements */
101 ISSID = 0, /* Service Set Identifier */
102 ISUPRATES = 1, /* Supported Rates */
103 IFHPARMS = 2, /* FH parameter set */
104 IDSPARMS = 3, /* DS parameter set */
105 ICFPARMS = 4, /* CF parameter set */
106 ITIM = 5, /* Traffic Information Map */
107 IIBPARMS = 6, /* IBSS parameter set */
108 ICOUNTRY = 7, /* Country element */
109 IEDCAPARAMS = 12, /* EDCA parameter set */
110 ITSPEC = 13, /* Traffic Specification */
111 ITCLAS = 14, /* Traffic Classification */
112 ISCHED = 15, /* Schedule */
113 ICTEXT = 16, /* Challenge Text */
114 IPOWERCONSTRAINT = 32, /* Power Constraint */
115 IPOWERCAPABILITY = 33, /* Power Capability */
116 ITPCREQUEST = 34, /* TPC Request */
117 ITPCREPORT = 35, /* TPC Report */
118 ISUPCHANNEL = 36, /* Supported channel list */
119 ICHSWANNOUNC = 37, /* Channel Switch Announcement */
120 IMEASUREMENTREQUEST = 38, /* Measurement request */
121 IMEASUREMENTREPORT = 39, /* Measurement report */
122 IQUIET = 40, /* Quiet element Info */
123 IIBSSDFS = 41, /* IBSS DFS */
124 IERPINFO = 42, /* ERP Information */
125 ITSDELAY = 43, /* TS Delay */
126 ITCLASPROCESS = 44, /* TCLAS Processing */
127 IHTCAP = 45, /* HT Capabilities */
128 IQOSCAP = 46, /* QoS Capability */
129 IRSNELEMENT = 48, /* RSN Information Element */
130 IEXSUPRATES = 50, /* Extended Supported Rates */
131 IEXCHSWANNOUNC = 60, /* Extended Ch Switch Announcement*/
132 IHTOPERATION = 61, /* HT Information */
133 ISECCHOFF = 62, /* Secondary Channel Offeset */
134 I2040COEX = 72, /* 20/40 Coexistence IE */
135 I2040INTOLCHREPORT = 73, /* 20/40 Intolerant channel report*/
136 IOBSSSCAN = 74, /* OBSS Scan parameters */
137 IEXTCAP = 127, /* Extended capability */
138 IWMM = 221, /* WMM parameters */
139 IWPAELEMENT = 221, /* WPA Information Element */
140 INFOELEM_ID_FORCE_32BIT = 0xFFFFFFFF
145 WILC_Char *pcRespBuffer;
146 WILC_Sint32 s32MaxRespBuffLen;
147 WILC_Sint32 s32BytesRead;
148 WILC_Bool bRespRequired;
153 /*****************************************************************************/
154 /* Extern Variable Declarations */
155 /*****************************************************************************/
158 /*****************************************************************************/
159 /* Extern Function Declarations */
160 /*****************************************************************************/
161 extern WILC_Sint32 SendRawPacket(WILC_Sint8 *ps8Packet, WILC_Sint32 s32PacketLen);
162 extern void NetworkInfoReceived(u8 *pu8Buffer, u32 u32Length);
163 extern void GnrlAsyncInfoReceived(u8 *pu8Buffer, u32 u32Length);
164 extern void host_int_ScanCompleteReceived(u8 *pu8Buffer, u32 u32Length);
165 /*****************************************************************************/
166 /* Global Variables */
167 /*****************************************************************************/
168 static struct semaphore SemHandleSendPkt;
169 static struct semaphore SemHandlePktResp;
171 static WILC_Sint8 *gps8ConfigPacket;
173 static tstrConfigPktInfo gstrConfigPktInfo;
177 static WILC_Sint16 g_wid_num = -1;
181 static u8 g_oper_mode = SET_CFG;
184 static tstrWID gastrWIDs[] = {
185 {WID_FIRMWARE_VERSION, WID_STR},
186 {WID_PHY_VERSION, WID_STR},
187 {WID_HARDWARE_VERSION, WID_STR},
188 {WID_BSS_TYPE, WID_CHAR},
189 {WID_QOS_ENABLE, WID_CHAR},
190 {WID_11I_MODE, WID_CHAR},
191 {WID_CURRENT_TX_RATE, WID_CHAR},
192 {WID_LINKSPEED, WID_CHAR},
193 {WID_RTS_THRESHOLD, WID_SHORT},
194 {WID_FRAG_THRESHOLD, WID_SHORT},
196 {WID_BSSID, WID_ADR},
197 {WID_BEACON_INTERVAL, WID_SHORT},
198 {WID_POWER_MANAGEMENT, WID_CHAR},
199 {WID_LISTEN_INTERVAL, WID_CHAR},
200 {WID_DTIM_PERIOD, WID_CHAR},
201 {WID_CURRENT_CHANNEL, WID_CHAR},
202 {WID_TX_POWER_LEVEL_11A, WID_CHAR},
203 {WID_TX_POWER_LEVEL_11B, WID_CHAR},
204 {WID_PREAMBLE, WID_CHAR},
205 {WID_11G_OPERATING_MODE, WID_CHAR},
206 {WID_MAC_ADDR, WID_ADR},
207 {WID_IP_ADDRESS, WID_ADR},
208 {WID_ACK_POLICY, WID_CHAR},
209 {WID_PHY_ACTIVE_REG, WID_CHAR},
210 {WID_AUTH_TYPE, WID_CHAR},
211 {WID_REKEY_POLICY, WID_CHAR},
212 {WID_REKEY_PERIOD, WID_INT},
213 {WID_REKEY_PACKET_COUNT, WID_INT},
215 {WID_WEP_KEY_VALUE0, WID_STR},
217 {WID_11I_PSK, WID_STR},
218 {WID_1X_KEY, WID_STR},
219 {WID_1X_SERV_ADDR, WID_IP},
220 {WID_SUPP_USERNAME, WID_STR},
221 {WID_SUPP_PASSWORD, WID_STR},
222 {WID_USER_CONTROL_ON_TX_POWER, WID_CHAR},
223 {WID_MEMORY_ADDRESS, WID_INT},
224 {WID_MEMORY_ACCESS_32BIT, WID_INT},
225 {WID_MEMORY_ACCESS_16BIT, WID_SHORT},
226 {WID_MEMORY_ACCESS_8BIT, WID_CHAR},
227 {WID_SITE_SURVEY_RESULTS, WID_STR},
228 {WID_PMKID_INFO, WID_STR},
229 {WID_ASSOC_RES_INFO, WID_STR},
230 {WID_MANUFACTURER, WID_STR}, /* 4 Wids added for the CAPI tool*/
231 {WID_MODEL_NAME, WID_STR},
232 {WID_MODEL_NUM, WID_STR},
233 {WID_DEVICE_NAME, WID_STR},
234 {WID_SSID_PROBE_REQ, WID_STR},
237 {WID_11N_ENABLE, WID_CHAR},
238 {WID_11N_CURRENT_TX_MCS, WID_CHAR},
239 {WID_TX_POWER_LEVEL_11N, WID_CHAR},
240 {WID_11N_OPERATING_MODE, WID_CHAR},
241 {WID_11N_SMPS_MODE, WID_CHAR},
242 {WID_11N_PROT_MECH, WID_CHAR},
243 {WID_11N_ERP_PROT_TYPE, WID_CHAR},
244 {WID_11N_HT_PROT_TYPE, WID_CHAR},
245 {WID_11N_PHY_ACTIVE_REG_VAL, WID_INT},
246 {WID_11N_PRINT_STATS, WID_CHAR},
247 {WID_11N_AUTORATE_TABLE, WID_BIN_DATA},
248 {WID_HOST_CONFIG_IF_TYPE, WID_CHAR},
249 {WID_HOST_DATA_IF_TYPE, WID_CHAR},
250 {WID_11N_SIG_QUAL_VAL, WID_SHORT},
251 {WID_11N_IMMEDIATE_BA_ENABLED, WID_CHAR},
252 {WID_11N_TXOP_PROT_DISABLE, WID_CHAR},
253 {WID_11N_SHORT_GI_20MHZ_ENABLE, WID_CHAR},
254 {WID_SHORT_SLOT_ALLOWED, WID_CHAR},
255 {WID_11W_ENABLE, WID_CHAR},
256 {WID_11W_MGMT_PROT_REQ, WID_CHAR},
257 {WID_2040_ENABLE, WID_CHAR},
258 {WID_2040_COEXISTENCE, WID_CHAR},
259 {WID_USER_SEC_CHANNEL_OFFSET, WID_CHAR},
260 {WID_2040_CURR_CHANNEL_OFFSET, WID_CHAR},
261 {WID_2040_40MHZ_INTOLERANT, WID_CHAR},
262 {WID_HUT_RESTART, WID_CHAR},
263 {WID_HUT_NUM_TX_PKTS, WID_INT},
264 {WID_HUT_FRAME_LEN, WID_SHORT},
265 {WID_HUT_TX_FORMAT, WID_CHAR},
266 {WID_HUT_BANDWIDTH, WID_CHAR},
267 {WID_HUT_OP_BAND, WID_CHAR},
268 {WID_HUT_STBC, WID_CHAR},
269 {WID_HUT_ESS, WID_CHAR},
270 {WID_HUT_ANTSET, WID_CHAR},
271 {WID_HUT_HT_OP_MODE, WID_CHAR},
272 {WID_HUT_RIFS_MODE, WID_CHAR},
273 {WID_HUT_SMOOTHING_REC, WID_CHAR},
274 {WID_HUT_SOUNDING_PKT, WID_CHAR},
275 {WID_HUT_HT_CODING, WID_CHAR},
276 {WID_HUT_TEST_DIR, WID_CHAR},
277 {WID_HUT_TXOP_LIMIT, WID_SHORT},
278 {WID_HUT_DEST_ADDR, WID_ADR},
279 {WID_HUT_TX_PATTERN, WID_BIN_DATA},
280 {WID_HUT_TX_TIME_TAKEN, WID_INT},
281 {WID_HUT_PHY_TEST_MODE, WID_CHAR},
282 {WID_HUT_PHY_TEST_RATE_HI, WID_CHAR},
283 {WID_HUT_PHY_TEST_RATE_LO, WID_CHAR},
284 {WID_HUT_TX_TEST_TIME, WID_INT},
285 {WID_HUT_LOG_INTERVAL, WID_INT},
286 {WID_HUT_DISABLE_RXQ_REPLENISH, WID_CHAR},
287 {WID_HUT_TEST_ID, WID_STR},
288 {WID_HUT_KEY_ORIGIN, WID_CHAR},
289 {WID_HUT_BCST_PERCENT, WID_CHAR},
290 {WID_HUT_GROUP_CIPHER_TYPE, WID_CHAR},
291 {WID_HUT_STATS, WID_BIN_DATA},
292 {WID_HUT_TSF_TEST_MODE, WID_CHAR},
293 {WID_HUT_SIG_QUAL_AVG, WID_SHORT},
294 {WID_HUT_SIG_QUAL_AVG_CNT, WID_SHORT},
295 {WID_HUT_TSSI_VALUE, WID_CHAR},
296 {WID_HUT_MGMT_PERCENT, WID_CHAR},
297 {WID_HUT_MGMT_BCST_PERCENT, WID_CHAR},
298 {WID_HUT_MGMT_ALLOW_HT, WID_CHAR},
299 {WID_HUT_UC_MGMT_TYPE, WID_CHAR},
300 {WID_HUT_BC_MGMT_TYPE, WID_CHAR},
301 {WID_HUT_UC_MGMT_FRAME_LEN, WID_SHORT},
302 {WID_HUT_BC_MGMT_FRAME_LEN, WID_SHORT},
303 {WID_HUT_11W_MFP_REQUIRED_TX, WID_CHAR},
304 {WID_HUT_11W_MFP_PEER_CAPABLE, WID_CHAR},
305 {WID_HUT_11W_TX_IGTK_ID, WID_CHAR},
306 {WID_HUT_FC_TXOP_MOD, WID_CHAR},
307 {WID_HUT_FC_PROT_TYPE, WID_CHAR},
308 {WID_HUT_SEC_CCA_ASSERT, WID_CHAR},
309 #endif /* MAC_802_11N */
312 u16 g_num_total_switches = (sizeof(gastrWIDs) / sizeof(tstrWID));
313 /*****************************************************************************/
314 /* Static Function Declarations */
315 /*****************************************************************************/
319 /*****************************************************************************/
321 /*****************************************************************************/
322 INLINE u8 ascii_hex_to_dec(u8 num)
324 if ((num >= '0') && (num <= '9'))
326 else if ((num >= 'A') && (num <= 'F'))
327 return (10 + (num - 'A'));
328 else if ((num >= 'a') && (num <= 'f'))
329 return (10 + (num - 'a'));
334 INLINE u8 get_hex_char(u8 inp)
336 u8 *d2htab = "0123456789ABCDEF";
338 return d2htab[inp & 0xF];
341 /* This function extracts the MAC address held in a string in standard format */
342 /* into another buffer as integers. */
343 INLINE u16 extract_mac_addr(WILC_Char *str, u8 *buff)
346 while (*str != '\0') {
347 if ((*str == ':') || (*str == '-'))
350 *buff = (*buff << 4) + ascii_hex_to_dec(*str);
358 /* This function creates MAC address in standard format from a buffer of */
360 INLINE void create_mac_addr(u8 *str, u8 *buff)
365 for (i = 0; i < MAC_ADDR_LEN; i++) {
366 str[j++] = get_hex_char((u8)((buff[i] >> 4) & 0x0F));
367 str[j++] = get_hex_char((u8)(buff[i] & 0x0F));
373 /* This function converts the IP address string in dotted decimal format to */
374 /* unsigned integer. This functionality is similar to the library function */
375 /* inet_addr() but is reimplemented here since I could not confirm that */
376 /* inet_addr is platform independent. */
377 /* ips=>IP Address String in dotted decimal format */
378 /* ipn=>Pointer to IP Address in integer format */
379 INLINE u8 conv_ip_to_int(u8 *ips, u32 *ipn)
384 /* Integer to string for each component */
385 while (ips[i] != '\0') {
387 *ipn = ((*ipn) << 8) | ipb;
390 ipb = ipb * 10 + ascii_hex_to_dec(ips[i]);
396 /* The last byte of the IP address is read in here */
397 *ipn = ((*ipn) << 8) | ipb;
402 /* This function converts the IP address from integer format to dotted */
403 /* decimal string format. Alternative to std library fn inet_ntoa(). */
404 /* ips=>Buffer to hold IP Address String dotted decimal format (Min 17B) */
405 /* ipn=>IP Address in integer format */
406 INLINE u8 conv_int_to_ip(u8 *ips, u32 ipn)
413 for (cnt = 4; cnt > 0; cnt--) {
414 ipb = (ipn >> (8 * (cnt - 1))) & 0xFF;
425 ips[i++] = get_hex_char(ipb / 100);
429 ips[i++] = get_hex_char(ipb / 10);
433 ips[i++] = get_hex_char(ipb);
445 INLINE tenuWIDtype get_wid_type(u32 wid_num)
447 /* Check for iconfig specific WID types first */
448 if ((wid_num == WID_BSSID) ||
449 (wid_num == WID_MAC_ADDR) ||
450 (wid_num == WID_IP_ADDRESS) ||
451 (wid_num == WID_HUT_DEST_ADDR)) {
455 if ((WID_1X_SERV_ADDR == wid_num) ||
456 (WID_STACK_IP_ADDR == wid_num) ||
457 (WID_STACK_NETMASK_ADDR == wid_num)) {
461 /* Next check for standard WID types */
462 if (wid_num < 0x1000)
464 else if (wid_num < 0x2000)
466 else if (wid_num < 0x3000)
468 else if (wid_num < 0x4000)
470 else if (wid_num < 0x5000)
477 /* This function extracts the beacon period field from the beacon or probe */
478 /* response frame. */
479 INLINE u16 get_beacon_period(u8 *data)
484 bcn_per |= (data[1] << 8);
489 INLINE u32 get_beacon_timestamp_lo(u8 *data)
492 u32 index = MAC_HDR_LEN;
494 time_stamp |= data[index++];
495 time_stamp |= (data[index++] << 8);
496 time_stamp |= (data[index++] << 16);
497 time_stamp |= (data[index] << 24);
502 INLINE u32 get_beacon_timestamp_hi(u8 *data)
505 u32 index = (MAC_HDR_LEN + 4);
507 time_stamp |= data[index++];
508 time_stamp |= (data[index++] << 8);
509 time_stamp |= (data[index++] << 16);
510 time_stamp |= (data[index] << 24);
515 /* This function extracts the 'frame type' bits from the MAC header of the */
517 /* Returns the value in the LSB of the returned value. */
518 INLINE tenuBasicFrmType get_type(u8 *header)
520 return ((tenuBasicFrmType)(header[0] & 0x0C));
523 /* This function extracts the 'frame type and sub type' bits from the MAC */
524 /* header of the input frame. */
525 /* Returns the value in the LSB of the returned value. */
526 INLINE tenuFrmSubtype get_sub_type(u8 *header)
528 return ((tenuFrmSubtype)(header[0] & 0xFC));
531 /* This function extracts the 'to ds' bit from the MAC header of the input */
533 /* Returns the value in the LSB of the returned value. */
534 INLINE u8 get_to_ds(u8 *header)
536 return (header[1] & 0x01);
539 /* This function extracts the 'from ds' bit from the MAC header of the input */
541 /* Returns the value in the LSB of the returned value. */
542 INLINE u8 get_from_ds(u8 *header)
544 return ((header[1] & 0x02) >> 1);
547 /* This function extracts the MAC Address in 'address1' field of the MAC */
548 /* header and updates the MAC Address in the allocated 'addr' variable. */
549 INLINE void get_address1(u8 *pu8msa, u8 *addr)
551 WILC_memcpy(addr, pu8msa + 4, 6);
554 /* This function extracts the MAC Address in 'address2' field of the MAC */
555 /* header and updates the MAC Address in the allocated 'addr' variable. */
556 INLINE void get_address2(u8 *pu8msa, u8 *addr)
558 WILC_memcpy(addr, pu8msa + 10, 6);
561 /* This function extracts the MAC Address in 'address3' field of the MAC */
562 /* header and updates the MAC Address in the allocated 'addr' variable. */
563 INLINE void get_address3(u8 *pu8msa, u8 *addr)
565 WILC_memcpy(addr, pu8msa + 16, 6);
568 /* This function extracts the BSSID from the incoming WLAN packet based on */
569 /* the 'from ds' bit, and updates the MAC Address in the allocated 'addr' */
571 INLINE void get_BSSID(u8 *data, u8 *bssid)
573 if (get_from_ds(data) == 1)
574 get_address2(data, bssid);
575 else if (get_to_ds(data) == 1)
576 get_address1(data, bssid);
578 get_address3(data, bssid);
581 /* This function extracts the SSID from a beacon/probe response frame */
582 INLINE void get_ssid(u8 *data, u8 *ssid, u8 *p_ssid_len)
588 len = data[MAC_HDR_LEN + TIME_STAMP_LEN + BEACON_INTERVAL_LEN +
590 j = MAC_HDR_LEN + TIME_STAMP_LEN + BEACON_INTERVAL_LEN +
593 /* If the SSID length field is set wrongly to a value greater than the */
594 /* allowed maximum SSID length limit, reset the length to 0 */
595 if (len >= MAX_SSID_LEN)
598 for (i = 0; i < len; i++, j++)
606 /* This function extracts the capability info field from the beacon or probe */
607 /* response frame. */
608 INLINE u16 get_cap_info(u8 *data)
611 u16 index = MAC_HDR_LEN;
612 tenuFrmSubtype st = BEACON;
614 st = get_sub_type(data);
616 /* Location of the Capability field is different for Beacon and */
617 /* Association frames. */
618 if ((st == BEACON) || (st == PROBE_RSP))
619 index += TIME_STAMP_LEN + BEACON_INTERVAL_LEN;
621 cap_info = data[index];
622 cap_info |= (data[index + 1] << 8);
627 /* This function extracts the capability info field from the Association */
628 /* response frame. */
629 INLINE u16 get_assoc_resp_cap_info(u8 *data)
634 cap_info |= (data[1] << 8);
639 /* This funcion extracts the association status code from the incoming */
640 /* association response frame and returns association status code */
641 INLINE u16 get_asoc_status(u8 *data)
645 asoc_status = data[3];
646 asoc_status = (asoc_status << 8) | data[2];
651 /* This function extracts association ID from the incoming association */
653 INLINE u16 get_asoc_id(u8 *data)
658 asoc_id |= (data[5] << 8);
664 * @brief initializes the Core Configurator
666 * @return Error code indicating success/failure
673 WILC_Sint32 CoreConfiguratorInit(void)
675 WILC_Sint32 s32Error = WILC_SUCCESS;
676 PRINT_D(CORECONFIG_DBG, "CoreConfiguratorInit()\n");
678 sema_init(&SemHandleSendPkt, 1);
679 sema_init(&SemHandlePktResp, 0);
681 gps8ConfigPacket = (WILC_Sint8 *)WILC_MALLOC(MAX_PACKET_BUFF_SIZE);
682 if (gps8ConfigPacket == NULL) {
683 PRINT_ER("failed in gps8ConfigPacket allocation\n");
684 s32Error = WILC_NO_MEM;
688 WILC_memset((void *)gps8ConfigPacket, 0, MAX_PACKET_BUFF_SIZE);
690 WILC_memset((void *)(&gstrConfigPktInfo), 0, sizeof(tstrConfigPktInfo));
695 u8 *get_tim_elm(u8 *pu8msa, u16 u16RxLen, u16 u16TagParamOffset)
699 /*************************************************************************/
700 /* Beacon Frame - Frame Body */
701 /* --------------------------------------------------------------------- */
702 /* |Timestamp |BeaconInt |CapInfo |SSID |SupRates |DSParSet |TIM elm | */
703 /* --------------------------------------------------------------------- */
704 /* |8 |2 |2 |2-34 |3-10 |3 |4-256 | */
705 /* --------------------------------------------------------------------- */
707 /*************************************************************************/
709 u16index = u16TagParamOffset;
711 /* Search for the TIM Element Field and return if the element is found */
712 while (u16index < (u16RxLen - FCS_LEN)) {
713 if (pu8msa[u16index] == ITIM) {
714 return &pu8msa[u16index];
716 u16index += (IE_HDR_LEN + pu8msa[u16index + 1]);
723 /* This function gets the current channel information from
724 * the 802.11n beacon/probe response frame */
725 u8 get_current_channel_802_11n(u8 *pu8msa, u16 u16RxLen)
729 index = TAG_PARAM_OFFSET;
730 while (index < (u16RxLen - FCS_LEN)) {
731 if (pu8msa[index] == IDSPARMS)
732 return pu8msa[index + 2];
734 /* Increment index by length information and header */
735 index += pu8msa[index + 1] + IE_HDR_LEN;
738 /* Return current channel information from the MIB, if beacon/probe */
739 /* response frame does not contain the DS parameter set IE */
740 /* return (mget_CurrentChannel() + 1); */
741 return 0; /* no MIB here */
744 u8 get_current_channel(u8 *pu8msa, u16 u16RxLen)
748 /* Get the current channel as its not set in */
749 /* 802.11a beacons/probe response */
750 return (get_rf_channel() + 1);
751 #else /* FIVE_GHZ_BAND */
752 /* Extract current channel information from */
753 /* the beacon/probe response frame */
754 return get_current_channel_802_11n(pu8msa, u16RxLen);
755 #endif /* FIVE_GHZ_BAND */
758 #endif /* PHY_802_11n */
762 * @brief parses the received 'N' message
764 * @param[in] pu8MsgBuffer The message to be parsed
765 * @param[out] ppstrNetworkInfo pointer to pointer to the structure containing the parsed Network Info
766 * @return Error code indicating success/failure
772 WILC_Sint32 ParseNetworkInfo(u8 *pu8MsgBuffer, tstrNetworkInfo **ppstrNetworkInfo)
774 WILC_Sint32 s32Error = WILC_SUCCESS;
775 tstrNetworkInfo *pstrNetworkInfo = NULL;
780 u16 u16WidID = (u16)WID_NIL;
784 u8MsgType = pu8MsgBuffer[0];
786 /* Check whether the received message type is 'N' */
787 if ('N' != u8MsgType) {
788 PRINT_ER("Received Message format incorrect.\n");
789 WILC_ERRORREPORT(s32Error, WILC_FAIL);
792 /* Extract message ID */
793 u8MsgID = pu8MsgBuffer[1];
795 /* Extract message Length */
796 u16MsgLen = MAKE_WORD16(pu8MsgBuffer[2], pu8MsgBuffer[3]);
799 u16WidID = MAKE_WORD16(pu8MsgBuffer[4], pu8MsgBuffer[5]);
801 /* Extract WID Length */
802 u16WidLen = MAKE_WORD16(pu8MsgBuffer[6], pu8MsgBuffer[7]);
804 /* Assign a pointer to the WID value */
805 pu8WidVal = &pu8MsgBuffer[8];
807 /* parse the WID value of the WID "WID_NEWORK_INFO" */
818 pstrNetworkInfo = (tstrNetworkInfo *)WILC_MALLOC(sizeof(tstrNetworkInfo));
819 WILC_memset((void *)(pstrNetworkInfo), 0, sizeof(tstrNetworkInfo));
821 pstrNetworkInfo->s8rssi = pu8WidVal[0];
823 /* Assign a pointer to msa "Mac Header Start Address" */
824 pu8msa = &pu8WidVal[1];
826 u16RxLen = u16WidLen - 1;
830 /* Get the cap_info */
831 pstrNetworkInfo->u16CapInfo = get_cap_info(pu8msa);
833 /* Get time-stamp [Low only 32 bit] */
834 pstrNetworkInfo->u32Tsf = get_beacon_timestamp_lo(pu8msa);
835 PRINT_D(CORECONFIG_DBG, "TSF :%x\n", pstrNetworkInfo->u32Tsf);
838 /* Get full time-stamp [Low and High 64 bit] */
839 u32Tsf_Lo = get_beacon_timestamp_lo(pu8msa);
840 u32Tsf_Hi = get_beacon_timestamp_hi(pu8msa);
842 pstrNetworkInfo->u64Tsf = u32Tsf_Lo | ((WILC_Uint64)u32Tsf_Hi << 32);
845 get_ssid(pu8msa, pstrNetworkInfo->au8ssid, &(pstrNetworkInfo->u8SsidLen));
848 get_BSSID(pu8msa, pstrNetworkInfo->au8bssid);
850 /* Get the current channel */
851 pstrNetworkInfo->u8channel = get_current_channel(pu8msa, (u16RxLen + FCS_LEN));
853 /* Get beacon period */
854 u8index = (MAC_HDR_LEN + TIME_STAMP_LEN);
856 pstrNetworkInfo->u16BeaconPeriod = get_beacon_period(pu8msa + u8index);
858 u8index += BEACON_INTERVAL_LEN + CAP_INFO_LEN;
860 /* Get DTIM Period */
861 pu8TimElm = get_tim_elm(pu8msa, (u16RxLen + FCS_LEN), u8index);
862 if (pu8TimElm != 0) {
863 pstrNetworkInfo->u8DtimPeriod = pu8TimElm[3];
865 pu8IEs = &pu8msa[MAC_HDR_LEN + TIME_STAMP_LEN + BEACON_INTERVAL_LEN + CAP_INFO_LEN];
866 u16IEsLen = u16RxLen - (MAC_HDR_LEN + TIME_STAMP_LEN + BEACON_INTERVAL_LEN + CAP_INFO_LEN);
869 pstrNetworkInfo->pu8IEs = (u8 *)WILC_MALLOC(u16IEsLen);
870 WILC_memset((void *)(pstrNetworkInfo->pu8IEs), 0, u16IEsLen);
872 WILC_memcpy(pstrNetworkInfo->pu8IEs, pu8IEs, u16IEsLen);
874 pstrNetworkInfo->u16IEsLen = u16IEsLen;
878 *ppstrNetworkInfo = pstrNetworkInfo;
885 * @brief Deallocates the parsed Network Info
887 * @param[in] pstrNetworkInfo Network Info to be deallocated
888 * @return Error code indicating success/failure
894 WILC_Sint32 DeallocateNetworkInfo(tstrNetworkInfo *pstrNetworkInfo)
896 WILC_Sint32 s32Error = WILC_SUCCESS;
898 if (pstrNetworkInfo != NULL) {
899 if (pstrNetworkInfo->pu8IEs != NULL) {
900 WILC_FREE(pstrNetworkInfo->pu8IEs);
901 pstrNetworkInfo->pu8IEs = NULL;
903 s32Error = WILC_FAIL;
906 WILC_FREE(pstrNetworkInfo);
907 pstrNetworkInfo = NULL;
910 s32Error = WILC_FAIL;
917 * @brief parses the received Association Response frame
919 * @param[in] pu8Buffer The Association Response frame to be parsed
920 * @param[out] ppstrConnectRespInfo pointer to pointer to the structure containing the parsed Association Response Info
921 * @return Error code indicating success/failure
927 WILC_Sint32 ParseAssocRespInfo(u8 *pu8Buffer, u32 u32BufferLen,
928 tstrConnectRespInfo **ppstrConnectRespInfo)
930 WILC_Sint32 s32Error = WILC_SUCCESS;
931 tstrConnectRespInfo *pstrConnectRespInfo = NULL;
932 u16 u16AssocRespLen = 0;
936 pstrConnectRespInfo = (tstrConnectRespInfo *)WILC_MALLOC(sizeof(tstrConnectRespInfo));
937 WILC_memset((void *)(pstrConnectRespInfo), 0, sizeof(tstrConnectRespInfo));
939 /* u16AssocRespLen = pu8Buffer[0]; */
940 u16AssocRespLen = (u16)u32BufferLen;
942 /* get the status code */
943 pstrConnectRespInfo->u16ConnectStatus = get_asoc_status(pu8Buffer);
944 if (pstrConnectRespInfo->u16ConnectStatus == SUCCESSFUL_STATUSCODE) {
946 /* get the capability */
947 pstrConnectRespInfo->u16capability = get_assoc_resp_cap_info(pu8Buffer);
949 /* get the Association ID */
950 pstrConnectRespInfo->u16AssocID = get_asoc_id(pu8Buffer);
952 /* get the Information Elements */
953 pu8IEs = &pu8Buffer[CAP_INFO_LEN + STATUS_CODE_LEN + AID_LEN];
954 u16IEsLen = u16AssocRespLen - (CAP_INFO_LEN + STATUS_CODE_LEN + AID_LEN);
956 pstrConnectRespInfo->pu8RespIEs = (u8 *)WILC_MALLOC(u16IEsLen);
957 WILC_memset((void *)(pstrConnectRespInfo->pu8RespIEs), 0, u16IEsLen);
959 WILC_memcpy(pstrConnectRespInfo->pu8RespIEs, pu8IEs, u16IEsLen);
960 pstrConnectRespInfo->u16RespIEsLen = u16IEsLen;
963 *ppstrConnectRespInfo = pstrConnectRespInfo;
970 * @brief Deallocates the parsed Association Response Info
972 * @param[in] pstrNetworkInfo Network Info to be deallocated
973 * @return Error code indicating success/failure
979 WILC_Sint32 DeallocateAssocRespInfo(tstrConnectRespInfo *pstrConnectRespInfo)
981 WILC_Sint32 s32Error = WILC_SUCCESS;
983 if (pstrConnectRespInfo != NULL) {
984 if (pstrConnectRespInfo->pu8RespIEs != NULL) {
985 WILC_FREE(pstrConnectRespInfo->pu8RespIEs);
986 pstrConnectRespInfo->pu8RespIEs = NULL;
988 s32Error = WILC_FAIL;
991 WILC_FREE(pstrConnectRespInfo);
992 pstrConnectRespInfo = NULL;
995 s32Error = WILC_FAIL;
1001 #ifndef CONNECT_DIRECT
1002 WILC_Sint32 ParseSurveyResults(u8 ppu8RcvdSiteSurveyResults[][MAX_SURVEY_RESULT_FRAG_SIZE],
1003 wid_site_survey_reslts_s **ppstrSurveyResults,
1004 u32 *pu32SurveyResultsCount)
1006 WILC_Sint32 s32Error = WILC_SUCCESS;
1007 wid_site_survey_reslts_s *pstrSurveyResults = NULL;
1008 u32 u32SurveyResultsCount = 0;
1009 u32 u32SurveyBytesLength = 0;
1011 u32 u32RcvdSurveyResultsNum = 2;
1012 u8 u8ReadSurveyResFragNum;
1016 for (i = 0; i < u32RcvdSurveyResultsNum; i++) {
1017 u32SurveyBytesLength = ppu8RcvdSiteSurveyResults[i][0];
1020 for (j = 0; j < u32SurveyBytesLength; j += SURVEY_RESULT_LENGTH) {
1021 u32SurveyResultsCount++;
1025 pstrSurveyResults = (wid_site_survey_reslts_s *)WILC_MALLOC(u32SurveyResultsCount * sizeof(wid_site_survey_reslts_s));
1026 if (pstrSurveyResults == NULL) {
1027 u32SurveyResultsCount = 0;
1028 WILC_ERRORREPORT(s32Error, WILC_NO_MEM);
1031 WILC_memset((void *)(pstrSurveyResults), 0, u32SurveyResultsCount * sizeof(wid_site_survey_reslts_s));
1033 u32SurveyResultsCount = 0;
1035 for (i = 0; i < u32RcvdSurveyResultsNum; i++) {
1036 pu8BufferPtr = ppu8RcvdSiteSurveyResults[i];
1038 u32SurveyBytesLength = pu8BufferPtr[0];
1040 /* TODO: mostafa: pu8BufferPtr[1] contains the fragment num */
1041 u8ReadSurveyResFragNum = pu8BufferPtr[1];
1045 for (j = 0; j < u32SurveyBytesLength; j += SURVEY_RESULT_LENGTH) {
1046 WILC_memcpy(&pstrSurveyResults[u32SurveyResultsCount], pu8BufferPtr, SURVEY_RESULT_LENGTH);
1047 pu8BufferPtr += SURVEY_RESULT_LENGTH;
1048 u32SurveyResultsCount++;
1053 *ppstrSurveyResults = pstrSurveyResults;
1054 *pu32SurveyResultsCount = u32SurveyResultsCount;
1060 WILC_Sint32 DeallocateSurveyResults(wid_site_survey_reslts_s *pstrSurveyResults)
1062 WILC_Sint32 s32Error = WILC_SUCCESS;
1064 if (pstrSurveyResults != NULL) {
1065 WILC_FREE(pstrSurveyResults);
1072 /*****************************************************************************/
1074 /* Function Name : ProcessCharWid */
1076 /* Description : This function processes a WID of type WID_CHAR and */
1077 /* updates the cfg packet with the supplied value. */
1079 /* Inputs : 1) Pointer to WID cfg structure */
1080 /* 2) Value to set */
1086 /* Outputs : None */
1088 /* Returns : None */
1092 /* Revision History: */
1094 /* DD MM YYYY Author(s) Changes (Describe the changes made) */
1095 /* 08 01 2008 Ittiam Draft */
1097 /*****************************************************************************/
1099 void ProcessCharWid(WILC_Char *pcPacket, WILC_Sint32 *ps32PktLen,
1100 tstrWID *pstrWID, WILC_Sint8 *ps8WidVal)
1102 u8 *pu8val = (u8 *)ps8WidVal;
1104 WILC_Sint32 s32PktLen = *ps32PktLen;
1105 if (pstrWID == NULL) {
1106 PRINT_WRN(CORECONFIG_DBG, "Can't set CHAR val 0x%x ,NULL structure\n", u8val);
1111 pcPacket[s32PktLen++] = (u8)(pstrWID->u16WIDid & 0xFF);
1112 pcPacket[s32PktLen++] = (u8)(pstrWID->u16WIDid >> 8) & 0xFF;
1113 if (g_oper_mode == SET_CFG) {
1117 pcPacket[s32PktLen++] = sizeof(u8);
1121 pcPacket[s32PktLen++] = u8val;
1123 *ps32PktLen = s32PktLen;
1126 /*****************************************************************************/
1128 /* Function Name : ProcessShortWid */
1130 /* Description : This function processes a WID of type WID_SHORT and */
1131 /* updates the cfg packet with the supplied value. */
1133 /* Inputs : 1) Pointer to WID cfg structure */
1134 /* 2) Value to set */
1140 /* Outputs : None */
1142 /* Returns : None */
1146 /* Revision History: */
1148 /* DD MM YYYY Author(s) Changes (Describe the changes made) */
1149 /* 08 01 2008 Ittiam Draft */
1151 /*****************************************************************************/
1153 void ProcessShortWid(WILC_Char *pcPacket, WILC_Sint32 *ps32PktLen,
1154 tstrWID *pstrWID, WILC_Sint8 *ps8WidVal)
1156 u16 *pu16val = (u16 *)ps8WidVal;
1158 WILC_Sint32 s32PktLen = *ps32PktLen;
1159 if (pstrWID == NULL) {
1160 PRINT_WRN(CORECONFIG_DBG, "Can't set SHORT val 0x%x ,NULL structure\n", u16val);
1165 pcPacket[s32PktLen++] = (u8)(pstrWID->u16WIDid & 0xFF);
1166 pcPacket[s32PktLen++] = (u8)((pstrWID->u16WIDid >> 8) & 0xFF);
1168 if (g_oper_mode == SET_CFG) {
1172 pcPacket[s32PktLen++] = sizeof(u16);
1175 pcPacket[s32PktLen++] = (u8)(u16val & 0xFF);
1176 pcPacket[s32PktLen++] = (u8)((u16val >> 8) & 0xFF);
1178 *ps32PktLen = s32PktLen;
1181 /*****************************************************************************/
1183 /* Function Name : ProcessIntWid */
1185 /* Description : This function processes a WID of type WID_INT and */
1186 /* updates the cfg packet with the supplied value. */
1188 /* Inputs : 1) Pointer to WID cfg structure */
1189 /* 2) Value to set */
1195 /* Outputs : None */
1197 /* Returns : None */
1201 /* Revision History: */
1203 /* DD MM YYYY Author(s) Changes (Describe the changes made) */
1204 /* 08 01 2008 Ittiam Draft */
1206 /*****************************************************************************/
1208 void ProcessIntWid(WILC_Char *pcPacket, WILC_Sint32 *ps32PktLen,
1209 tstrWID *pstrWID, WILC_Sint8 *ps8WidVal)
1211 u32 *pu32val = (u32 *)ps8WidVal;
1213 WILC_Sint32 s32PktLen = *ps32PktLen;
1214 if (pstrWID == NULL) {
1215 PRINT_WRN(CORECONFIG_DBG, "Can't set INT val 0x%x , NULL structure\n", u32val);
1220 pcPacket[s32PktLen++] = (u8)(pstrWID->u16WIDid & 0xFF);
1221 pcPacket[s32PktLen++] = (u8)((pstrWID->u16WIDid >> 8) & 0xFF);
1223 if (g_oper_mode == SET_CFG) {
1227 pcPacket[s32PktLen++] = sizeof(u32);
1230 pcPacket[s32PktLen++] = (u8)(u32val & 0xFF);
1231 pcPacket[s32PktLen++] = (u8)((u32val >> 8) & 0xFF);
1232 pcPacket[s32PktLen++] = (u8)((u32val >> 16) & 0xFF);
1233 pcPacket[s32PktLen++] = (u8)((u32val >> 24) & 0xFF);
1235 *ps32PktLen = s32PktLen;
1238 /*****************************************************************************/
1240 /* Function Name : ProcessIPwid */
1242 /* Description : This function processes a WID of type WID_IP and */
1243 /* updates the cfg packet with the supplied value. */
1245 /* Inputs : 1) Pointer to WID cfg structure */
1246 /* 2) Value to set */
1253 /* Outputs : None */
1255 /* Returns : None */
1259 /* Revision History: */
1261 /* DD MM YYYY Author(s) Changes (Describe the changes made) */
1262 /* 08 01 2008 Ittiam Draft */
1264 /*****************************************************************************/
1266 void ProcessIPwid(WILC_Char *pcPacket, WILC_Sint32 *ps32PktLen,
1267 tstrWID *pstrWID, u8 *pu8ip)
1270 WILC_Sint32 s32PktLen = *ps32PktLen;
1272 if (pstrWID == NULL) {
1273 PRINT_WRN(CORECONFIG_DBG, "Can't set IP Addr , NULL structure\n");
1278 pcPacket[s32PktLen++] = (u8)(pstrWID->u16WIDid & 0xFF);
1279 pcPacket[s32PktLen++] = (u8)((pstrWID->u16WIDid >> 8) & 0xFF);
1281 if (g_oper_mode == SET_CFG) {
1283 pcPacket[s32PktLen++] = sizeof(u32);
1285 /* Convert the IP Address String to Integer */
1286 conv_ip_to_int(pu8ip, &u32val);
1289 pcPacket[s32PktLen++] = (u8)(u32val & 0xFF);
1290 pcPacket[s32PktLen++] = (u8)((u32val >> 8) & 0xFF);
1291 pcPacket[s32PktLen++] = (u8)((u32val >> 16) & 0xFF);
1292 pcPacket[s32PktLen++] = (u8)((u32val >> 24) & 0xFF);
1294 *ps32PktLen = s32PktLen;
1297 /*****************************************************************************/
1299 /* Function Name : ProcessStrWid */
1301 /* Description : This function processes a WID of type WID_STR and */
1302 /* updates the cfg packet with the supplied value. */
1304 /* Inputs : 1) Pointer to WID cfg structure */
1305 /* 2) Value to set */
1311 /* Outputs : None */
1313 /* Returns : None */
1317 /* Revision History: */
1319 /* DD MM YYYY Author(s) Changes (Describe the changes made) */
1320 /* 08 01 2008 Ittiam Draft */
1322 /*****************************************************************************/
1324 void ProcessStrWid(WILC_Char *pcPacket, WILC_Sint32 *ps32PktLen,
1325 tstrWID *pstrWID, u8 *pu8val, WILC_Sint32 s32ValueSize)
1329 WILC_Sint32 s32PktLen = *ps32PktLen;
1330 if (pstrWID == NULL) {
1331 PRINT_WRN(CORECONFIG_DBG, "Can't set STR val, NULL structure\n");
1336 pcPacket[s32PktLen++] = (u8)(pstrWID->u16WIDid & 0xFF);
1337 pcPacket[s32PktLen++] = (u8)((pstrWID->u16WIDid >> 8) & 0xFF);
1339 if (g_oper_mode == SET_CFG) {
1340 /* Message Length */
1341 /* u16MsgLen = WILC_strlen(pu8val); */
1342 u16MsgLen = (u16)s32ValueSize;
1345 pcPacket[s32PktLen++] = (u8)u16MsgLen;
1348 for (idx = 0; idx < u16MsgLen; idx++)
1349 pcPacket[s32PktLen++] = pu8val[idx];
1351 *ps32PktLen = s32PktLen;
1354 /*****************************************************************************/
1356 /* Function Name : ProcessAdrWid */
1358 /* Description : This function processes a WID of type WID_ADR and */
1359 /* updates the cfg packet with the supplied value. */
1361 /* Inputs : 1) Pointer to WID cfg structure */
1362 /* 2) Value to set */
1368 /* Outputs : None */
1370 /* Returns : None */
1374 /* Revision History: */
1376 /* DD MM YYYY Author(s) Changes (Describe the changes made) */
1377 /* 08 01 2008 Ittiam Draft */
1379 /*****************************************************************************/
1381 void ProcessAdrWid(WILC_Char *pcPacket, WILC_Sint32 *ps32PktLen,
1382 tstrWID *pstrWID, u8 *pu8val)
1385 WILC_Sint32 s32PktLen = *ps32PktLen;
1387 if (pstrWID == NULL) {
1388 PRINT_WRN(CORECONFIG_DBG, "Can't set Addr WID, NULL structure\n");
1393 pcPacket[s32PktLen++] = (u8)(pstrWID->u16WIDid & 0xFF);
1394 pcPacket[s32PktLen++] = (u8)((pstrWID->u16WIDid >> 8) & 0xFF);
1396 if (g_oper_mode == SET_CFG) {
1397 /* Message Length */
1398 u16MsgLen = MAC_ADDR_LEN;
1401 pcPacket[s32PktLen++] = (u8)u16MsgLen;
1404 extract_mac_addr(pu8val, pcPacket + s32PktLen);
1405 s32PktLen += u16MsgLen;
1407 *ps32PktLen = s32PktLen;
1410 /*****************************************************************************/
1412 /* Function Name : ProcessBinWid */
1414 /* Description : This function processes a WID of type WID_BIN_DATA and */
1415 /* updates the cfg packet with the supplied value. */
1417 /* Inputs : 1) Pointer to WID cfg structure */
1418 /* 2) Name of file containing the binary data in text mode */
1422 /* Processing : The binary data is expected to be supplied through a */
1423 /* file in text mode. This file is expected to be in the */
1424 /* finject format. It is parsed, converted to binary format */
1425 /* and copied into g_cfg_pkt for further processing. This */
1426 /* is obviously a round-about way of processing involving */
1427 /* multiple (re)conversions between bin & ascii formats. */
1428 /* But it is done nevertheless to retain uniformity and for */
1429 /* ease of debugging. */
1431 /* Outputs : None */
1433 /* Returns : None */
1438 /* Revision History: */
1440 /* DD MM YYYY Author(s) Changes (Describe the changes made) */
1441 /* 08 01 2008 Ittiam Draft */
1443 /*****************************************************************************/
1445 void ProcessBinWid(WILC_Char *pcPacket, WILC_Sint32 *ps32PktLen,
1446 tstrWID *pstrWID, u8 *pu8val, WILC_Sint32 s32ValueSize)
1448 /* WILC_ERROR("processing Binary WIDs is not supported\n"); */
1452 WILC_Sint32 s32PktLen = *ps32PktLen;
1455 if (pstrWID == NULL) {
1456 PRINT_WRN(CORECONFIG_DBG, "Can't set BIN val, NULL structure\n");
1461 pcPacket[s32PktLen++] = (u8)(pstrWID->u16WIDid & 0xFF);
1462 pcPacket[s32PktLen++] = (u8)((pstrWID->u16WIDid >> 8) & 0xFF);
1464 if (g_oper_mode == SET_CFG) {
1465 /* Message Length */
1466 u16MsgLen = (u16)s32ValueSize;
1469 /* pcPacket[s32PktLen++] = (u8)u16MsgLen; */
1470 pcPacket[s32PktLen++] = (u8)(u16MsgLen & 0xFF);
1471 pcPacket[s32PktLen++] = (u8)((u16MsgLen >> 8) & 0xFF);
1474 for (idx = 0; idx < u16MsgLen; idx++)
1475 pcPacket[s32PktLen++] = pu8val[idx];
1478 for (idx = 0; idx < u16MsgLen; idx++)
1479 u8checksum += pcPacket[MSG_HEADER_LEN + idx + 4];
1481 pcPacket[s32PktLen++] = u8checksum;
1483 *ps32PktLen = s32PktLen;
1487 /*****************************************************************************/
1489 /* Function Name : further_process_response */
1491 /* Description : This function parses the response frame got from the */
1494 /* Inputs : 1) The received response frame */
1497 /* 4) Output file handle */
1498 /* 5) Process Wid Number(i.e wid from --widn switch) */
1499 /* 6) Index the array in the Global Wid Structure. */
1501 /* Globals : g_wid_num, gastrWIDs */
1503 /* Processing : This function parses the response of the device depending*/
1504 /* WID type and writes it to the output file in Hex or */
1505 /* decimal notation depending on the --getx or --get switch.*/
1507 /* Outputs : None */
1509 /* Returns : 0 on Success & -2 on Failure */
1513 /* Revision History: */
1515 /* DD MM YYYY Author(s) Changes (Describe the changes made) */
1516 /* 08 01 2009 Ittiam Draft */
1518 /*****************************************************************************/
1520 WILC_Sint32 further_process_response(u8 *resp,
1523 WILC_Bool process_wid_num,
1525 tstrWID *pstrWIDresult)
1532 u8 cfg_str[256] = {0};
1533 tenuWIDtype enuWIDtype = WID_UNDEF;
1535 if (process_wid_num) {
1536 enuWIDtype = get_wid_type(g_wid_num);
1538 enuWIDtype = gastrWIDs[cnt].enuWIDtype;
1542 switch (enuWIDtype) {
1544 cfg_chr = resp[idx];
1545 /*Set local copy of WID*/
1546 *(pstrWIDresult->ps8WidVal) = cfg_chr;
1551 u16 *pu16val = (u16 *)(pstrWIDresult->ps8WidVal);
1552 cfg_sht = MAKE_WORD16(resp[idx], resp[idx + 1]);
1553 /*Set local copy of WID*/
1554 /* pstrWIDresult->ps8WidVal = (WILC_Sint8*)(WILC_Sint32)cfg_sht; */
1561 u32 *pu32val = (u32 *)(pstrWIDresult->ps8WidVal);
1562 cfg_int = MAKE_WORD32(
1563 MAKE_WORD16(resp[idx], resp[idx + 1]),
1564 MAKE_WORD16(resp[idx + 2], resp[idx + 3])
1566 /*Set local copy of WID*/
1567 /* pstrWIDresult->ps8WidVal = (WILC_Sint8*)cfg_int; */
1573 WILC_memcpy(cfg_str, resp + idx, cfg_len);
1574 /* cfg_str[cfg_len] = '\0'; //mostafa: no need currently for NULL termination */
1575 if (process_wid_num) {
1576 /*fprintf(out_file,"0x%4.4x = %s\n",g_wid_num,
1579 /*fprintf(out_file,"%s = %s\n",gastrWIDs[cnt].cfg_switch,
1583 if (pstrWIDresult->s32ValueSize >= cfg_len) {
1584 WILC_memcpy(pstrWIDresult->ps8WidVal, cfg_str, cfg_len); /* mostafa: no need currently for the extra NULL byte */
1585 pstrWIDresult->s32ValueSize = cfg_len;
1587 PRINT_ER("allocated WID buffer length is smaller than the received WID Length\n");
1594 create_mac_addr(cfg_str, resp + idx);
1596 WILC_strncpy(pstrWIDresult->ps8WidVal, cfg_str, WILC_strlen(cfg_str));
1597 pstrWIDresult->ps8WidVal[WILC_strlen(cfg_str)] = '\0';
1598 if (process_wid_num) {
1599 /*fprintf(out_file,"0x%4.4x = %s\n",g_wid_num,
1602 /*fprintf(out_file,"%s = %s\n",gastrWIDs[cnt].cfg_switch,
1608 cfg_int = MAKE_WORD32(
1609 MAKE_WORD16(resp[idx], resp[idx + 1]),
1610 MAKE_WORD16(resp[idx + 2], resp[idx + 3])
1612 conv_int_to_ip(cfg_str, cfg_int);
1613 if (process_wid_num) {
1614 /*fprintf(out_file,"0x%4.4x = %s\n",g_wid_num,
1617 /*fprintf(out_file,"%s = %s\n",gastrWIDs[cnt].cfg_switch,
1624 /* FILE *fp_bin = NULL; */
1625 u8 first_bin_wid = 1;
1626 if (first_bin_wid) {
1627 /* fp_bin = fopen("wid_response.bin","wb"); */
1630 /* fp_bin = fopen("wid_response.bin","ab"); */
1633 if (/*fp_bin == NULL*/ 0) {
1634 PRINT_ER("Error: Could not open wid_response.bin for write\n");
1638 /* fwrite(resp + idx, cfg_len, 1, fp_bin); */
1640 /* fclose(fp_bin); */
1643 if (pstrWIDresult->s32ValueSize >= cfg_len) {
1644 WILC_memcpy(pstrWIDresult->ps8WidVal, resp + idx, cfg_len);
1645 pstrWIDresult->s32ValueSize = cfg_len;
1647 PRINT_ER("Allocated WID buffer length is smaller than the received WID Length Err(%d)\n", retval);
1653 PRINT_ER("ERROR: Check config database: Error(%d)\n", retval);
1661 /*****************************************************************************/
1663 /* Function Name : ParseResponse */
1665 /* Description : This function parses the command-line options and */
1666 /* creates the config packets which can be sent to the WLAN */
1669 /* Inputs : 1) The received response frame */
1671 /* Globals : g_opt_list, gastrWIDs */
1673 /* Processing : This function parses the options and creates different */
1674 /* types of packets depending upon the WID-type */
1675 /* corresponding to the option. */
1677 /* Outputs : None */
1679 /* Returns : 0 on Success & -1 on Failure */
1683 /* Revision History: */
1685 /* DD MM YYYY Author(s) Changes (Describe the changes made) */
1686 /* 08 01 2008 Ittiam Draft */
1688 /*****************************************************************************/
1690 WILC_Sint32 ParseResponse(u8 *resp, tstrWID *pstrWIDcfgResult)
1695 tenuWIDtype enuWIDtype = WID_UNDEF;
1696 WILC_Bool num_wid_processed = WILC_FALSE;
1700 /* Check whether the received frame is a valid response */
1701 if (RESP_MSG_TYPE != resp[0]) {
1702 PRINT_INFO(CORECONFIG_DBG, "Received Message format incorrect.\n");
1706 /* Extract Response Length */
1707 u16RespLen = MAKE_WORD16(resp[2], resp[3]);
1708 Res_Len = u16RespLen;
1710 for (idx = MSG_HEADER_LEN; idx < u16RespLen; ) {
1711 u16WIDid = MAKE_WORD16(resp[idx], resp[idx + 1]);
1712 cfg_len = resp[idx + 2];
1713 /* Incase of Bin Type Wid, the length is given by two byte field */
1714 enuWIDtype = get_wid_type(u16WIDid);
1715 if (WID_BIN_DATA == enuWIDtype) {
1716 cfg_len |= ((u16)resp[idx + 3] << 8) & 0xFF00;
1720 if ((u16WIDid == g_wid_num) && (num_wid_processed == WILC_FALSE)) {
1721 num_wid_processed = WILC_TRUE;
1723 if (-2 == further_process_response(&resp[idx], u16WIDid, cfg_len, WILC_TRUE, 0, &pstrWIDcfgResult[ResCnt])) {
1728 for (cnt = 0; cnt < g_num_total_switches; cnt++) {
1729 if (gastrWIDs[cnt].u16WIDid == u16WIDid) {
1730 if (-2 == further_process_response(&resp[idx], u16WIDid, cfg_len, WILC_FALSE, cnt,
1731 &pstrWIDcfgResult[ResCnt])) {
1739 /* In case if BIN type Wid, The last byte of the Cfg packet is the */
1740 /* Checksum. The WID Length field does not accounts for the checksum. */
1741 /* The Checksum is discarded. */
1742 if (WID_BIN_DATA == enuWIDtype) {
1751 * @brief parses the write response [just detects its status: success or failure]
1753 * @param[in] pu8RespBuffer The Response to be parsed
1754 * @return Error code indicating Write Operation status:
1755 * WRITE_RESP_SUCCESS (1) => Write Success.
1756 * WILC_FAIL (-100) => Write Failure.
1763 WILC_Sint32 ParseWriteResponse(u8 *pu8RespBuffer)
1765 WILC_Sint32 s32Error = WILC_FAIL;
1767 u16 u16WIDtype = (u16)WID_NIL;
1769 /* Check whether the received frame is a valid response */
1770 if (RESP_MSG_TYPE != pu8RespBuffer[0]) {
1771 PRINT_ER("Received Message format incorrect.\n");
1775 /* Extract Response Length */
1776 u16RespLen = MAKE_WORD16(pu8RespBuffer[2], pu8RespBuffer[3]);
1778 u16WIDtype = MAKE_WORD16(pu8RespBuffer[4], pu8RespBuffer[5]);
1780 /* Check for WID_STATUS ID and then check the length and status value */
1781 if ((u16WIDtype == WID_STATUS) &&
1782 (pu8RespBuffer[6] == 1) &&
1783 (pu8RespBuffer[7] == WRITE_RESP_SUCCESS)) {
1784 s32Error = WRITE_RESP_SUCCESS;
1788 /* If the length or status are not as expected return failure */
1789 s32Error = WILC_FAIL;
1795 * @brief creates the header of the Configuration Packet
1797 * @param[in,out] pcpacket The Configuration Packet
1798 * @param[in,out] ps32PacketLength Length of the Configuration Packet
1799 * @return Error code indicating success/failure
1806 WILC_Sint32 CreatePacketHeader(WILC_Char *pcpacket, WILC_Sint32 *ps32PacketLength)
1808 WILC_Sint32 s32Error = WILC_SUCCESS;
1809 u16 u16MsgLen = (u16)(*ps32PacketLength);
1812 /* The format of the message is: */
1813 /* +-------------------------------------------------------------------+ */
1814 /* | Message Type | Message ID | Message Length |Message body | */
1815 /* +-------------------------------------------------------------------+ */
1816 /* | 1 Byte | 1 Byte | 2 Bytes | Message Length - 4 | */
1817 /* +-------------------------------------------------------------------+ */
1819 /* The format of a message body of a message type 'W' is: */
1820 /* +-------------------------------------------------------------------+ */
1821 /* | WID0 | WID0 Length | WID0 Value | ......................... | */
1822 /* +-------------------------------------------------------------------+ */
1823 /* | 2 Bytes | 1 Byte | WID0 Length | ......................... | */
1824 /* +-------------------------------------------------------------------+ */
1829 if (g_oper_mode == SET_CFG)
1830 pcpacket[u16MsgInd++] = WRITE_MSG_TYPE;
1832 pcpacket[u16MsgInd++] = QUERY_MSG_TYPE;
1834 /* Sequence Number */
1835 pcpacket[u16MsgInd++] = g_seqno++;
1837 /* Message Length */
1838 pcpacket[u16MsgInd++] = (u8)(u16MsgLen & 0xFF);
1839 pcpacket[u16MsgInd++] = (u8)((u16MsgLen >> 8) & 0xFF);
1841 *ps32PacketLength = u16MsgLen;
1847 * @brief creates Configuration packet based on the Input WIDs
1849 * @param[in] pstrWIDs WIDs to be sent in the configuration packet
1850 * @param[in] u32WIDsCount number of WIDs to be sent in the configuration packet
1851 * @param[out] ps8packet The created Configuration Packet
1852 * @param[out] ps32PacketLength Length of the created Configuration Packet
1853 * @return Error code indicating success/failure
1860 WILC_Sint32 CreateConfigPacket(WILC_Sint8 *ps8packet, WILC_Sint32 *ps32PacketLength,
1861 tstrWID *pstrWIDs, u32 u32WIDsCount)
1863 WILC_Sint32 s32Error = WILC_SUCCESS;
1865 *ps32PacketLength = MSG_HEADER_LEN;
1866 for (u32idx = 0; u32idx < u32WIDsCount; u32idx++) {
1867 switch (pstrWIDs[u32idx].enuWIDtype) {
1869 ProcessCharWid(ps8packet, ps32PacketLength, &pstrWIDs[u32idx],
1870 pstrWIDs[u32idx].ps8WidVal);
1874 ProcessShortWid(ps8packet, ps32PacketLength, &pstrWIDs[u32idx],
1875 pstrWIDs[u32idx].ps8WidVal);
1879 ProcessIntWid(ps8packet, ps32PacketLength, &pstrWIDs[u32idx],
1880 pstrWIDs[u32idx].ps8WidVal);
1884 ProcessStrWid(ps8packet, ps32PacketLength, &pstrWIDs[u32idx],
1885 pstrWIDs[u32idx].ps8WidVal, pstrWIDs[u32idx].s32ValueSize);
1890 ProcessAdrWid(ps8packet, ps32PacketLength, &pstrWIDs[u32idx],
1891 pstrWIDs[u32idx].ps8WidVal);
1896 ProcessIPwid(ps8packet, ps32PacketLength, &pstrWIDs[u32idx],
1897 pstrWIDs[u32idx].ps8WidVal);
1901 ProcessBinWid(ps8packet, ps32PacketLength, &pstrWIDs[u32idx],
1902 pstrWIDs[u32idx].ps8WidVal, pstrWIDs[u32idx].s32ValueSize);
1906 PRINT_ER("ERROR: Check Config database\n");
1910 CreatePacketHeader(ps8packet, ps32PacketLength);
1915 WILC_Sint32 ConfigWaitResponse(WILC_Char *pcRespBuffer, WILC_Sint32 s32MaxRespBuffLen, WILC_Sint32 *ps32BytesRead,
1916 WILC_Bool bRespRequired)
1918 WILC_Sint32 s32Error = WILC_SUCCESS;
1920 /*removed to caller function*/
1921 /*gstrConfigPktInfo.pcRespBuffer = pcRespBuffer;
1922 * gstrConfigPktInfo.s32MaxRespBuffLen = s32MaxRespBuffLen;
1923 * gstrConfigPktInfo.bRespRequired = bRespRequired;*/
1926 if (gstrConfigPktInfo.bRespRequired == WILC_TRUE) {
1927 down(&SemHandlePktResp);
1929 *ps32BytesRead = gstrConfigPktInfo.s32BytesRead;
1932 WILC_memset((void *)(&gstrConfigPktInfo), 0, sizeof(tstrConfigPktInfo));
1938 * @brief sends certain Configuration Packet based on the input WIDs pstrWIDs
1939 * and retrieves the packet response pu8RxResp
1941 * @param[in] pstrWIDs WIDs to be sent in the configuration packet
1942 * @param[in] u32WIDsCount number of WIDs to be sent in the configuration packet
1943 * @param[out] pu8RxResp The received Packet Response
1944 * @param[out] ps32RxRespLen Length of the received Packet Response
1945 * @return Error code indicating success/failure
1952 WILC_Sint32 SendConfigPkt(u8 u8Mode, tstrWID *pstrWIDs,
1953 u32 u32WIDsCount, WILC_Bool bRespRequired, u32 drvHandler)
1955 WILC_Sint32 s32Error = WILC_SUCCESS;
1956 WILC_Sint32 err = WILC_SUCCESS;
1957 WILC_Sint32 s32ConfigPacketLen = 0;
1958 WILC_Sint32 s32RcvdRespLen = 0;
1960 down(&SemHandleSendPkt);
1962 /*set the packet mode*/
1963 g_oper_mode = u8Mode;
1965 WILC_memset((void *)gps8ConfigPacket, 0, MAX_PACKET_BUFF_SIZE);
1967 if (CreateConfigPacket(gps8ConfigPacket, &s32ConfigPacketLen, pstrWIDs, u32WIDsCount) != WILC_SUCCESS) {
1968 s32Error = WILC_FAIL;
1972 gstrConfigPktInfo.pcRespBuffer = gps8ConfigPacket;
1973 gstrConfigPktInfo.s32MaxRespBuffLen = MAX_PACKET_BUFF_SIZE;
1974 PRINT_INFO(CORECONFIG_DBG, "GLOBAL =bRespRequired =%d\n", bRespRequired);
1975 gstrConfigPktInfo.bRespRequired = bRespRequired;
1977 s32Error = SendRawPacket(gps8ConfigPacket, s32ConfigPacketLen);
1978 if (s32Error != WILC_SUCCESS) {
1982 WILC_memset((void *)gps8ConfigPacket, 0, MAX_PACKET_BUFF_SIZE);
1984 ConfigWaitResponse(gps8ConfigPacket, MAX_PACKET_BUFF_SIZE, &s32RcvdRespLen, bRespRequired);
1987 if (bRespRequired == WILC_TRUE) {
1988 /* If the operating Mode is GET, then we expect a response frame from */
1989 /* the driver. Hence start listening to the port for response */
1990 if (g_oper_mode == GET_CFG) {
1992 err = ParseResponse(gps8ConfigPacket, pstrWIDs);
1994 s32Error = WILC_FAIL;
1997 s32Error = WILC_SUCCESS;
2001 err = ParseWriteResponse(gps8ConfigPacket);
2002 if (err != WRITE_RESP_SUCCESS) {
2003 s32Error = WILC_FAIL;
2006 s32Error = WILC_SUCCESS;
2015 up(&SemHandleSendPkt);
2020 WILC_Sint32 ConfigProvideResponse(WILC_Char *pcRespBuffer, WILC_Sint32 s32RespLen)
2022 WILC_Sint32 s32Error = WILC_SUCCESS;
2024 if (gstrConfigPktInfo.bRespRequired == WILC_TRUE) {
2025 if (s32RespLen <= gstrConfigPktInfo.s32MaxRespBuffLen) {
2026 WILC_memcpy(gstrConfigPktInfo.pcRespBuffer, pcRespBuffer, s32RespLen);
2027 gstrConfigPktInfo.s32BytesRead = s32RespLen;
2029 WILC_memcpy(gstrConfigPktInfo.pcRespBuffer, pcRespBuffer, gstrConfigPktInfo.s32MaxRespBuffLen);
2030 gstrConfigPktInfo.s32BytesRead = gstrConfigPktInfo.s32MaxRespBuffLen;
2031 PRINT_ER("BusProvideResponse() Response greater than the prepared Buffer Size\n");
2034 up(&SemHandlePktResp);
2041 * @brief writes the received packet pu8RxPacket in the global Rx FIFO buffer
2043 * @param[in] pu8RxPacket The received packet
2044 * @param[in] s32RxPacketLen Length of the received packet
2045 * @return Error code indicating success/failure
2053 WILC_Sint32 ConfigPktReceived(u8 *pu8RxPacket, WILC_Sint32 s32RxPacketLen)
2055 WILC_Sint32 s32Error = WILC_SUCCESS;
2058 u8MsgType = pu8RxPacket[0];
2060 switch (u8MsgType) {
2062 ConfigProvideResponse(pu8RxPacket, s32RxPacketLen);
2067 PRINT_INFO(CORECONFIG_DBG, "NetworkInfo packet received\n");
2068 NetworkInfoReceived(pu8RxPacket, s32RxPacketLen);
2072 GnrlAsyncInfoReceived(pu8RxPacket, s32RxPacketLen);
2076 host_int_ScanCompleteReceived(pu8RxPacket, s32RxPacketLen);
2080 PRINT_ER("ConfigPktReceived(): invalid received msg type at the Core Configurator\n");
2088 * @brief Deinitializes the Core Configurator
2090 * @return Error code indicating success/failure
2097 WILC_Sint32 CoreConfiguratorDeInit(void)
2099 WILC_Sint32 s32Error = WILC_SUCCESS;
2101 PRINT_D(CORECONFIG_DBG, "CoreConfiguratorDeInit()\n");
2103 if (gps8ConfigPacket != NULL) {
2105 WILC_FREE(gps8ConfigPacket);
2106 gps8ConfigPacket = NULL;
2114 /*Using the global handle of the driver*/
2115 extern wilc_wlan_oup_t *gpstrWlanOps;
2117 * @brief sends certain Configuration Packet based on the input WIDs pstrWIDs
2118 * using driver config layer
2121 * @param[in] pstrWIDs WIDs to be sent in the configuration packet
2122 * @param[in] u32WIDsCount number of WIDs to be sent in the configuration packet
2123 * @param[out] pu8RxResp The received Packet Response
2124 * @param[out] ps32RxRespLen Length of the received Packet Response
2125 * @return Error code indicating success/failure
2131 WILC_Sint32 SendConfigPkt(u8 u8Mode, tstrWID *pstrWIDs,
2132 u32 u32WIDsCount, WILC_Bool bRespRequired, u32 drvHandler)
2134 WILC_Sint32 counter = 0, ret = 0;
2135 if (gpstrWlanOps == NULL) {
2136 PRINT_D(CORECONFIG_DBG, "Net Dev is still not initialized\n");
2139 PRINT_D(CORECONFIG_DBG, "Net Dev is initialized\n");
2141 if (gpstrWlanOps->wlan_cfg_set == NULL ||
2142 gpstrWlanOps->wlan_cfg_get == NULL) {
2143 PRINT_D(CORECONFIG_DBG, "Set and Get is still not initialized\n");
2146 PRINT_D(CORECONFIG_DBG, "SET is initialized\n");
2148 if (u8Mode == GET_CFG) {
2149 for (counter = 0; counter < u32WIDsCount; counter++) {
2150 PRINT_INFO(CORECONFIG_DBG, "Sending CFG packet [%d][%d]\n", !counter,
2151 (counter == u32WIDsCount - 1));
2152 if (!gpstrWlanOps->wlan_cfg_get(!counter,
2153 pstrWIDs[counter].u16WIDid,
2154 (counter == u32WIDsCount - 1), drvHandler)) {
2156 printk("[Sendconfigpkt]Get Timed out\n");
2163 /* WILC_Sleep(1000); */
2165 for (counter = 0; counter < u32WIDsCount; counter++) {
2166 pstrWIDs[counter].s32ValueSize = gpstrWlanOps->wlan_cfg_get_value(
2167 pstrWIDs[counter].u16WIDid,
2168 pstrWIDs[counter].ps8WidVal, pstrWIDs[counter].s32ValueSize);
2171 } else if (u8Mode == SET_CFG) {
2172 for (counter = 0; counter < u32WIDsCount; counter++) {
2173 PRINT_D(CORECONFIG_DBG, "Sending config SET PACKET WID:%x\n", pstrWIDs[counter].u16WIDid);
2174 if (!gpstrWlanOps->wlan_cfg_set(!counter,
2175 pstrWIDs[counter].u16WIDid, pstrWIDs[counter].ps8WidVal,
2176 pstrWIDs[counter].s32ValueSize,
2177 (counter == u32WIDsCount - 1), drvHandler)) {
2179 printk("[Sendconfigpkt]Set Timed out\n");