projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
staging: wilc1000: remove unused codes of gps8ConfigPacket
[deliverable/linux.git] / drivers / staging / wilc1000 / coreconfigurator.c
1
2 /*!
3 * @file coreconfigurator.c
4 * @brief
5 * @author
6 * @sa coreconfigurator.h
7 * @date 1 Mar 2012
8 * @version 1.0
9 */
10
11
12 /*****************************************************************************/
13 /* File Includes */
14 /*****************************************************************************/
15 #include "coreconfigurator.h"
16 /*****************************************************************************/
17 /* Constants */
18 /*****************************************************************************/
19 #define INLINE static __inline
20 #define PHY_802_11n
21 #define MAX_CFG_PKTLEN 1450
22 #define MSG_HEADER_LEN 4
23 #define QUERY_MSG_TYPE 'Q'
24 #define WRITE_MSG_TYPE 'W'
25 #define RESP_MSG_TYPE 'R'
26 #define WRITE_RESP_SUCCESS 1
27 #define INVALID 255
28 #define MAC_ADDR_LEN 6
29 #define TAG_PARAM_OFFSET (MAC_HDR_LEN + TIME_STAMP_LEN + \
30 BEACON_INTERVAL_LEN + CAP_INFO_LEN)
31
32 /*****************************************************************************/
33 /* Function Macros */
34 /*****************************************************************************/
35
36
37 /*****************************************************************************/
38 /* Type Definitions */
39 /*****************************************************************************/
40
41 /* Basic Frame Type Codes (2-bit) */
42 typedef enum {
43 FRAME_TYPE_CONTROL = 0x04,
44 FRAME_TYPE_DATA = 0x08,
45 FRAME_TYPE_MANAGEMENT = 0x00,
46 FRAME_TYPE_RESERVED = 0x0C,
47 FRAME_TYPE_FORCE_32BIT = 0xFFFFFFFF
48 } tenuBasicFrmType;
49
50 /* Frame Type and Subtype Codes (6-bit) */
51 typedef enum {
52 ASSOC_REQ = 0x00,
53 ASSOC_RSP = 0x10,
54 REASSOC_REQ = 0x20,
55 REASSOC_RSP = 0x30,
56 PROBE_REQ = 0x40,
57 PROBE_RSP = 0x50,
58 BEACON = 0x80,
59 ATIM = 0x90,
60 DISASOC = 0xA0,
61 AUTH = 0xB0,
62 DEAUTH = 0xC0,
63 ACTION = 0xD0,
64 PS_POLL = 0xA4,
65 RTS = 0xB4,
66 CTS = 0xC4,
67 ACK = 0xD4,
68 CFEND = 0xE4,
69 CFEND_ACK = 0xF4,
70 DATA = 0x08,
71 DATA_ACK = 0x18,
72 DATA_POLL = 0x28,
73 DATA_POLL_ACK = 0x38,
74 NULL_FRAME = 0x48,
75 CFACK = 0x58,
76 CFPOLL = 0x68,
77 CFPOLL_ACK = 0x78,
78 QOS_DATA = 0x88,
79 QOS_DATA_ACK = 0x98,
80 QOS_DATA_POLL = 0xA8,
81 QOS_DATA_POLL_ACK = 0xB8,
82 QOS_NULL_FRAME = 0xC8,
83 QOS_CFPOLL = 0xE8,
84 QOS_CFPOLL_ACK = 0xF8,
85 BLOCKACK_REQ = 0x84,
86 BLOCKACK = 0x94,
87 FRAME_SUBTYPE_FORCE_32BIT = 0xFFFFFFFF
88 } tenuFrmSubtype;
89
90 /* Basic Frame Classes */
91 typedef enum {
92 CLASS1_FRAME_TYPE = 0x00,
93 CLASS2_FRAME_TYPE = 0x01,
94 CLASS3_FRAME_TYPE = 0x02,
95 FRAME_CLASS_FORCE_32BIT = 0xFFFFFFFF
96 } tenuFrameClass;
97
98 /* Element ID of various Information Elements */
99 typedef enum {
100 ISSID = 0, /* Service Set Identifier */
101 ISUPRATES = 1, /* Supported Rates */
102 IFHPARMS = 2, /* FH parameter set */
103 IDSPARMS = 3, /* DS parameter set */
104 ICFPARMS = 4, /* CF parameter set */
105 ITIM = 5, /* Traffic Information Map */
106 IIBPARMS = 6, /* IBSS parameter set */
107 ICOUNTRY = 7, /* Country element */
108 IEDCAPARAMS = 12, /* EDCA parameter set */
109 ITSPEC = 13, /* Traffic Specification */
110 ITCLAS = 14, /* Traffic Classification */
111 ISCHED = 15, /* Schedule */
112 ICTEXT = 16, /* Challenge Text */
113 IPOWERCONSTRAINT = 32, /* Power Constraint */
114 IPOWERCAPABILITY = 33, /* Power Capability */
115 ITPCREQUEST = 34, /* TPC Request */
116 ITPCREPORT = 35, /* TPC Report */
117 ISUPCHANNEL = 36, /* Supported channel list */
118 ICHSWANNOUNC = 37, /* Channel Switch Announcement */
119 IMEASUREMENTREQUEST = 38, /* Measurement request */
120 IMEASUREMENTREPORT = 39, /* Measurement report */
121 IQUIET = 40, /* Quiet element Info */
122 IIBSSDFS = 41, /* IBSS DFS */
123 IERPINFO = 42, /* ERP Information */
124 ITSDELAY = 43, /* TS Delay */
125 ITCLASPROCESS = 44, /* TCLAS Processing */
126 IHTCAP = 45, /* HT Capabilities */
127 IQOSCAP = 46, /* QoS Capability */
128 IRSNELEMENT = 48, /* RSN Information Element */
129 IEXSUPRATES = 50, /* Extended Supported Rates */
130 IEXCHSWANNOUNC = 60, /* Extended Ch Switch Announcement*/
131 IHTOPERATION = 61, /* HT Information */
132 ISECCHOFF = 62, /* Secondary Channel Offeset */
133 I2040COEX = 72, /* 20/40 Coexistence IE */
134 I2040INTOLCHREPORT = 73, /* 20/40 Intolerant channel report*/
135 IOBSSSCAN = 74, /* OBSS Scan parameters */
136 IEXTCAP = 127, /* Extended capability */
137 IWMM = 221, /* WMM parameters */
138 IWPAELEMENT = 221, /* WPA Information Element */
139 INFOELEM_ID_FORCE_32BIT = 0xFFFFFFFF
140 } tenuInfoElemID;
141
142
143 typedef struct {
144 char *pcRespBuffer;
145 s32 s32MaxRespBuffLen;
146 s32 s32BytesRead;
147 bool bRespRequired;
148 } tstrConfigPktInfo;
149
150
151
152 /*****************************************************************************/
153 /* Extern Variable Declarations */
154 /*****************************************************************************/
155
156
157 /*****************************************************************************/
158 /* Extern Function Declarations */
159 /*****************************************************************************/
160 extern s32 SendRawPacket(s8 *ps8Packet, s32 s32PacketLen);
161 extern void NetworkInfoReceived(u8 *pu8Buffer, u32 u32Length);
162 extern void GnrlAsyncInfoReceived(u8 *pu8Buffer, u32 u32Length);
163 extern void host_int_ScanCompleteReceived(u8 *pu8Buffer, u32 u32Length);
164 /*****************************************************************************/
165 /* Global Variables */
166 /*****************************************************************************/
167 static struct semaphore SemHandleSendPkt;
168 static struct semaphore SemHandlePktResp;
169
170
171 static tstrConfigPktInfo gstrConfigPktInfo;
172
173 static u8 g_seqno;
174
175 static s16 g_wid_num = -1;
176
177 static u16 Res_Len;
178
179 static u8 g_oper_mode = SET_CFG;
180
181 /* WID Switches */
182 static tstrWID gastrWIDs[] = {
183 {WID_FIRMWARE_VERSION, WID_STR},
184 {WID_PHY_VERSION, WID_STR},
185 {WID_HARDWARE_VERSION, WID_STR},
186 {WID_BSS_TYPE, WID_CHAR},
187 {WID_QOS_ENABLE, WID_CHAR},
188 {WID_11I_MODE, WID_CHAR},
189 {WID_CURRENT_TX_RATE, WID_CHAR},
190 {WID_LINKSPEED, WID_CHAR},
191 {WID_RTS_THRESHOLD, WID_SHORT},
192 {WID_FRAG_THRESHOLD, WID_SHORT},
193 {WID_SSID, WID_STR},
194 {WID_BSSID, WID_ADR},
195 {WID_BEACON_INTERVAL, WID_SHORT},
196 {WID_POWER_MANAGEMENT, WID_CHAR},
197 {WID_LISTEN_INTERVAL, WID_CHAR},
198 {WID_DTIM_PERIOD, WID_CHAR},
199 {WID_CURRENT_CHANNEL, WID_CHAR},
200 {WID_TX_POWER_LEVEL_11A, WID_CHAR},
201 {WID_TX_POWER_LEVEL_11B, WID_CHAR},
202 {WID_PREAMBLE, WID_CHAR},
203 {WID_11G_OPERATING_MODE, WID_CHAR},
204 {WID_MAC_ADDR, WID_ADR},
205 {WID_IP_ADDRESS, WID_ADR},
206 {WID_ACK_POLICY, WID_CHAR},
207 {WID_PHY_ACTIVE_REG, WID_CHAR},
208 {WID_AUTH_TYPE, WID_CHAR},
209 {WID_REKEY_POLICY, WID_CHAR},
210 {WID_REKEY_PERIOD, WID_INT},
211 {WID_REKEY_PACKET_COUNT, WID_INT},
212 {WID_11I_PSK, WID_STR},
213 {WID_1X_KEY, WID_STR},
214 {WID_1X_SERV_ADDR, WID_IP},
215 {WID_SUPP_USERNAME, WID_STR},
216 {WID_SUPP_PASSWORD, WID_STR},
217 {WID_USER_CONTROL_ON_TX_POWER, WID_CHAR},
218 {WID_MEMORY_ADDRESS, WID_INT},
219 {WID_MEMORY_ACCESS_32BIT, WID_INT},
220 {WID_MEMORY_ACCESS_16BIT, WID_SHORT},
221 {WID_MEMORY_ACCESS_8BIT, WID_CHAR},
222 {WID_SITE_SURVEY_RESULTS, WID_STR},
223 {WID_PMKID_INFO, WID_STR},
224 {WID_ASSOC_RES_INFO, WID_STR},
225 {WID_MANUFACTURER, WID_STR}, /* 4 Wids added for the CAPI tool*/
226 {WID_MODEL_NAME, WID_STR},
227 {WID_MODEL_NUM, WID_STR},
228 {WID_DEVICE_NAME, WID_STR},
229 {WID_SSID_PROBE_REQ, WID_STR},
230
231 #ifdef MAC_802_11N
232 {WID_11N_ENABLE, WID_CHAR},
233 {WID_11N_CURRENT_TX_MCS, WID_CHAR},
234 {WID_TX_POWER_LEVEL_11N, WID_CHAR},
235 {WID_11N_OPERATING_MODE, WID_CHAR},
236 {WID_11N_SMPS_MODE, WID_CHAR},
237 {WID_11N_PROT_MECH, WID_CHAR},
238 {WID_11N_ERP_PROT_TYPE, WID_CHAR},
239 {WID_11N_HT_PROT_TYPE, WID_CHAR},
240 {WID_11N_PHY_ACTIVE_REG_VAL, WID_INT},
241 {WID_11N_PRINT_STATS, WID_CHAR},
242 {WID_11N_AUTORATE_TABLE, WID_BIN_DATA},
243 {WID_HOST_CONFIG_IF_TYPE, WID_CHAR},
244 {WID_HOST_DATA_IF_TYPE, WID_CHAR},
245 {WID_11N_SIG_QUAL_VAL, WID_SHORT},
246 {WID_11N_IMMEDIATE_BA_ENABLED, WID_CHAR},
247 {WID_11N_TXOP_PROT_DISABLE, WID_CHAR},
248 {WID_11N_SHORT_GI_20MHZ_ENABLE, WID_CHAR},
249 {WID_SHORT_SLOT_ALLOWED, WID_CHAR},
250 {WID_11W_ENABLE, WID_CHAR},
251 {WID_11W_MGMT_PROT_REQ, WID_CHAR},
252 {WID_2040_ENABLE, WID_CHAR},
253 {WID_2040_COEXISTENCE, WID_CHAR},
254 {WID_USER_SEC_CHANNEL_OFFSET, WID_CHAR},
255 {WID_2040_CURR_CHANNEL_OFFSET, WID_CHAR},
256 {WID_2040_40MHZ_INTOLERANT, WID_CHAR},
257 {WID_HUT_RESTART, WID_CHAR},
258 {WID_HUT_NUM_TX_PKTS, WID_INT},
259 {WID_HUT_FRAME_LEN, WID_SHORT},
260 {WID_HUT_TX_FORMAT, WID_CHAR},
261 {WID_HUT_BANDWIDTH, WID_CHAR},
262 {WID_HUT_OP_BAND, WID_CHAR},
263 {WID_HUT_STBC, WID_CHAR},
264 {WID_HUT_ESS, WID_CHAR},
265 {WID_HUT_ANTSET, WID_CHAR},
266 {WID_HUT_HT_OP_MODE, WID_CHAR},
267 {WID_HUT_RIFS_MODE, WID_CHAR},
268 {WID_HUT_SMOOTHING_REC, WID_CHAR},
269 {WID_HUT_SOUNDING_PKT, WID_CHAR},
270 {WID_HUT_HT_CODING, WID_CHAR},
271 {WID_HUT_TEST_DIR, WID_CHAR},
272 {WID_HUT_TXOP_LIMIT, WID_SHORT},
273 {WID_HUT_DEST_ADDR, WID_ADR},
274 {WID_HUT_TX_PATTERN, WID_BIN_DATA},
275 {WID_HUT_TX_TIME_TAKEN, WID_INT},
276 {WID_HUT_PHY_TEST_MODE, WID_CHAR},
277 {WID_HUT_PHY_TEST_RATE_HI, WID_CHAR},
278 {WID_HUT_PHY_TEST_RATE_LO, WID_CHAR},
279 {WID_HUT_TX_TEST_TIME, WID_INT},
280 {WID_HUT_LOG_INTERVAL, WID_INT},
281 {WID_HUT_DISABLE_RXQ_REPLENISH, WID_CHAR},
282 {WID_HUT_TEST_ID, WID_STR},
283 {WID_HUT_KEY_ORIGIN, WID_CHAR},
284 {WID_HUT_BCST_PERCENT, WID_CHAR},
285 {WID_HUT_GROUP_CIPHER_TYPE, WID_CHAR},
286 {WID_HUT_STATS, WID_BIN_DATA},
287 {WID_HUT_TSF_TEST_MODE, WID_CHAR},
288 {WID_HUT_SIG_QUAL_AVG, WID_SHORT},
289 {WID_HUT_SIG_QUAL_AVG_CNT, WID_SHORT},
290 {WID_HUT_TSSI_VALUE, WID_CHAR},
291 {WID_HUT_MGMT_PERCENT, WID_CHAR},
292 {WID_HUT_MGMT_BCST_PERCENT, WID_CHAR},
293 {WID_HUT_MGMT_ALLOW_HT, WID_CHAR},
294 {WID_HUT_UC_MGMT_TYPE, WID_CHAR},
295 {WID_HUT_BC_MGMT_TYPE, WID_CHAR},
296 {WID_HUT_UC_MGMT_FRAME_LEN, WID_SHORT},
297 {WID_HUT_BC_MGMT_FRAME_LEN, WID_SHORT},
298 {WID_HUT_11W_MFP_REQUIRED_TX, WID_CHAR},
299 {WID_HUT_11W_MFP_PEER_CAPABLE, WID_CHAR},
300 {WID_HUT_11W_TX_IGTK_ID, WID_CHAR},
301 {WID_HUT_FC_TXOP_MOD, WID_CHAR},
302 {WID_HUT_FC_PROT_TYPE, WID_CHAR},
303 {WID_HUT_SEC_CCA_ASSERT, WID_CHAR},
304 #endif /* MAC_802_11N */
305 };
306
307 u16 g_num_total_switches = (sizeof(gastrWIDs) / sizeof(tstrWID));
308 /*****************************************************************************/
309 /* Static Function Declarations */
310 /*****************************************************************************/
311
312
313
314 /*****************************************************************************/
315 /* Functions */
316 /*****************************************************************************/
317 INLINE u8 ascii_hex_to_dec(u8 num)
318 {
319 if ((num >= '0') && (num <= '9'))
320 return (num - '0');
321 else if ((num >= 'A') && (num <= 'F'))
322 return (10 + (num - 'A'));
323 else if ((num >= 'a') && (num <= 'f'))
324 return (10 + (num - 'a'));
325
326 return INVALID;
327 }
328
329 INLINE u8 get_hex_char(u8 inp)
330 {
331 u8 *d2htab = "0123456789ABCDEF";
332
333 return d2htab[inp & 0xF];
334 }
335
336 /* This function extracts the MAC address held in a string in standard format */
337 /* into another buffer as integers. */
338 INLINE u16 extract_mac_addr(char *str, u8 *buff)
339 {
340 *buff = 0;
341 while (*str != '\0') {
342 if ((*str == ':') || (*str == '-'))
343 *(++buff) = 0;
344 else
345 *buff = (*buff << 4) + ascii_hex_to_dec(*str);
346
347 str++;
348 }
349
350 return MAC_ADDR_LEN;
351 }
352
353 /* This function creates MAC address in standard format from a buffer of */
354 /* integers. */
355 INLINE void create_mac_addr(u8 *str, u8 *buff)
356 {
357 u32 i = 0;
358 u32 j = 0;
359
360 for (i = 0; i < MAC_ADDR_LEN; i++) {
361 str[j++] = get_hex_char((u8)((buff[i] >> 4) & 0x0F));
362 str[j++] = get_hex_char((u8)(buff[i] & 0x0F));
363 str[j++] = ':';
364 }
365 str[--j] = '\0';
366 }
367
368 /* This function converts the IP address string in dotted decimal format to */
369 /* unsigned integer. This functionality is similar to the library function */
370 /* inet_addr() but is reimplemented here since I could not confirm that */
371 /* inet_addr is platform independent. */
372 /* ips=>IP Address String in dotted decimal format */
373 /* ipn=>Pointer to IP Address in integer format */
374 INLINE u8 conv_ip_to_int(u8 *ips, u32 *ipn)
375 {
376 u8 i = 0;
377 u8 ipb = 0;
378 *ipn = 0;
379 /* Integer to string for each component */
380 while (ips[i] != '\0') {
381 if (ips[i] == '.') {
382 *ipn = ((*ipn) << 8) | ipb;
383 ipb = 0;
384 } else {
385 ipb = ipb * 10 + ascii_hex_to_dec(ips[i]);
386 }
387
388 i++;
389 }
390
391 /* The last byte of the IP address is read in here */
392 *ipn = ((*ipn) << 8) | ipb;
393
394 return 0;
395 }
396
397 /* This function converts the IP address from integer format to dotted */
398 /* decimal string format. Alternative to std library fn inet_ntoa(). */
399 /* ips=>Buffer to hold IP Address String dotted decimal format (Min 17B) */
400 /* ipn=>IP Address in integer format */
401 INLINE u8 conv_int_to_ip(u8 *ips, u32 ipn)
402 {
403 u8 i = 0;
404 u8 ipb = 0;
405 u8 cnt = 0;
406 u8 ipbsize = 0;
407
408 for (cnt = 4; cnt > 0; cnt--) {
409 ipb = (ipn >> (8 * (cnt - 1))) & 0xFF;
410
411 if (ipb >= 100)
412 ipbsize = 2;
413 else if (ipb >= 10)
414 ipbsize = 1;
415 else
416 ipbsize = 0;
417
418 switch (ipbsize) {
419 case 2:
420 ips[i++] = get_hex_char(ipb / 100);
421 ipb %= 100;
422
423 case 1:
424 ips[i++] = get_hex_char(ipb / 10);
425 ipb %= 10;
426
427 default:
428 ips[i++] = get_hex_char(ipb);
429 }
430
431 if (cnt > 1)
432 ips[i++] = '.';
433 }
434
435 ips[i] = '\0';
436
437 return i;
438 }
439
440 INLINE tenuWIDtype get_wid_type(u32 wid_num)
441 {
442 /* Check for iconfig specific WID types first */
443 if ((wid_num == WID_BSSID) ||
444 (wid_num == WID_MAC_ADDR) ||
445 (wid_num == WID_IP_ADDRESS) ||
446 (wid_num == WID_HUT_DEST_ADDR)) {
447 return WID_ADR;
448 }
449
450 if ((WID_1X_SERV_ADDR == wid_num) ||
451 (WID_STACK_IP_ADDR == wid_num) ||
452 (WID_STACK_NETMASK_ADDR == wid_num)) {
453 return WID_IP;
454 }
455
456 /* Next check for standard WID types */
457 if (wid_num < 0x1000)
458 return WID_CHAR;
459 else if (wid_num < 0x2000)
460 return WID_SHORT;
461 else if (wid_num < 0x3000)
462 return WID_INT;
463 else if (wid_num < 0x4000)
464 return WID_STR;
465 else if (wid_num < 0x5000)
466 return WID_BIN_DATA;
467
468 return WID_UNDEF;
469 }
470
471
472 /* This function extracts the beacon period field from the beacon or probe */
473 /* response frame. */
474 INLINE u16 get_beacon_period(u8 *data)
475 {
476 u16 bcn_per = 0;
477
478 bcn_per = data[0];
479 bcn_per |= (data[1] << 8);
480
481 return bcn_per;
482 }
483
484 INLINE u32 get_beacon_timestamp_lo(u8 *data)
485 {
486 u32 time_stamp = 0;
487 u32 index = MAC_HDR_LEN;
488
489 time_stamp |= data[index++];
490 time_stamp |= (data[index++] << 8);
491 time_stamp |= (data[index++] << 16);
492 time_stamp |= (data[index] << 24);
493
494 return time_stamp;
495 }
496
497 INLINE u32 get_beacon_timestamp_hi(u8 *data)
498 {
499 u32 time_stamp = 0;
500 u32 index = (MAC_HDR_LEN + 4);
501
502 time_stamp |= data[index++];
503 time_stamp |= (data[index++] << 8);
504 time_stamp |= (data[index++] << 16);
505 time_stamp |= (data[index] << 24);
506
507 return time_stamp;
508 }
509
510 /* This function extracts the 'frame type' bits from the MAC header of the */
511 /* input frame. */
512 /* Returns the value in the LSB of the returned value. */
513 INLINE tenuBasicFrmType get_type(u8 *header)
514 {
515 return ((tenuBasicFrmType)(header[0] & 0x0C));
516 }
517
518 /* This function extracts the 'frame type and sub type' bits from the MAC */
519 /* header of the input frame. */
520 /* Returns the value in the LSB of the returned value. */
521 INLINE tenuFrmSubtype get_sub_type(u8 *header)
522 {
523 return ((tenuFrmSubtype)(header[0] & 0xFC));
524 }
525
526 /* This function extracts the 'to ds' bit from the MAC header of the input */
527 /* frame. */
528 /* Returns the value in the LSB of the returned value. */
529 INLINE u8 get_to_ds(u8 *header)
530 {
531 return (header[1] & 0x01);
532 }
533
534 /* This function extracts the 'from ds' bit from the MAC header of the input */
535 /* frame. */
536 /* Returns the value in the LSB of the returned value. */
537 INLINE u8 get_from_ds(u8 *header)
538 {
539 return ((header[1] & 0x02) >> 1);
540 }
541
542 /* This function extracts the MAC Address in 'address1' field of the MAC */
543 /* header and updates the MAC Address in the allocated 'addr' variable. */
544 INLINE void get_address1(u8 *pu8msa, u8 *addr)
545 {
546 memcpy(addr, pu8msa + 4, 6);
547 }
548
549 /* This function extracts the MAC Address in 'address2' field of the MAC */
550 /* header and updates the MAC Address in the allocated 'addr' variable. */
551 INLINE void get_address2(u8 *pu8msa, u8 *addr)
552 {
553 memcpy(addr, pu8msa + 10, 6);
554 }
555
556 /* This function extracts the MAC Address in 'address3' field of the MAC */
557 /* header and updates the MAC Address in the allocated 'addr' variable. */
558 INLINE void get_address3(u8 *pu8msa, u8 *addr)
559 {
560 memcpy(addr, pu8msa + 16, 6);
561 }
562
563 /* This function extracts the BSSID from the incoming WLAN packet based on */
564 /* the 'from ds' bit, and updates the MAC Address in the allocated 'addr' */
565 /* variable. */
566 INLINE void get_BSSID(u8 *data, u8 *bssid)
567 {
568 if (get_from_ds(data) == 1)
569 get_address2(data, bssid);
570 else if (get_to_ds(data) == 1)
571 get_address1(data, bssid);
572 else
573 get_address3(data, bssid);
574 }
575
576 /* This function extracts the SSID from a beacon/probe response frame */
577 INLINE void get_ssid(u8 *data, u8 *ssid, u8 *p_ssid_len)
578 {
579 u8 len = 0;
580 u8 i = 0;
581 u8 j = 0;
582
583 len = data[MAC_HDR_LEN + TIME_STAMP_LEN + BEACON_INTERVAL_LEN +
584 CAP_INFO_LEN + 1];
585 j = MAC_HDR_LEN + TIME_STAMP_LEN + BEACON_INTERVAL_LEN +
586 CAP_INFO_LEN + 2;
587
588 /* If the SSID length field is set wrongly to a value greater than the */
589 /* allowed maximum SSID length limit, reset the length to 0 */
590 if (len >= MAX_SSID_LEN)
591 len = 0;
592
593 for (i = 0; i < len; i++, j++)
594 ssid[i] = data[j];
595
596 ssid[len] = '\0';
597
598 *p_ssid_len = len;
599 }
600
601 /* This function extracts the capability info field from the beacon or probe */
602 /* response frame. */
603 INLINE u16 get_cap_info(u8 *data)
604 {
605 u16 cap_info = 0;
606 u16 index = MAC_HDR_LEN;
607 tenuFrmSubtype st;
608
609 st = get_sub_type(data);
610
611 /* Location of the Capability field is different for Beacon and */
612 /* Association frames. */
613 if ((st == BEACON) || (st == PROBE_RSP))
614 index += TIME_STAMP_LEN + BEACON_INTERVAL_LEN;
615
616 cap_info = data[index];
617 cap_info |= (data[index + 1] << 8);
618
619 return cap_info;
620 }
621
622 /* This function extracts the capability info field from the Association */
623 /* response frame. */
624 INLINE u16 get_assoc_resp_cap_info(u8 *data)
625 {
626 u16 cap_info = 0;
627
628 cap_info = data[0];
629 cap_info |= (data[1] << 8);
630
631 return cap_info;
632 }
633
634 /* This funcion extracts the association status code from the incoming */
635 /* association response frame and returns association status code */
636 INLINE u16 get_asoc_status(u8 *data)
637 {
638 u16 asoc_status = 0;
639
640 asoc_status = data[3];
641 asoc_status = (asoc_status << 8) | data[2];
642
643 return asoc_status;
644 }
645
646 /* This function extracts association ID from the incoming association */
647 /* response frame */
648 INLINE u16 get_asoc_id(u8 *data)
649 {
650 u16 asoc_id = 0;
651
652 asoc_id = data[4];
653 asoc_id |= (data[5] << 8);
654
655 return asoc_id;
656 }
657
658 /**
659 * @brief initializes the Core Configurator
660 * @details
661 * @return Error code indicating success/failure
662 * @note
663 * @author mabubakr
664 * @date 1 Mar 2012
665 * @version 1.0
666 */
667
668 s32 CoreConfiguratorInit(void)
669 {
670 s32 s32Error = WILC_SUCCESS;
671 PRINT_D(CORECONFIG_DBG, "CoreConfiguratorInit()\n");
672
673 sema_init(&SemHandleSendPkt, 1);
674 sema_init(&SemHandlePktResp, 0);
675
676
677 memset((void *)(&gstrConfigPktInfo), 0, sizeof(tstrConfigPktInfo));
678 return s32Error;
679 }
680
681 u8 *get_tim_elm(u8 *pu8msa, u16 u16RxLen, u16 u16TagParamOffset)
682 {
683 u16 u16index = 0;
684
685 /*************************************************************************/
686 /* Beacon Frame - Frame Body */
687 /* --------------------------------------------------------------------- */
688 /* |Timestamp |BeaconInt |CapInfo |SSID |SupRates |DSParSet |TIM elm | */
689 /* --------------------------------------------------------------------- */
690 /* |8 |2 |2 |2-34 |3-10 |3 |4-256 | */
691 /* --------------------------------------------------------------------- */
692 /* */
693 /*************************************************************************/
694
695 u16index = u16TagParamOffset;
696
697 /* Search for the TIM Element Field and return if the element is found */
698 while (u16index < (u16RxLen - FCS_LEN)) {
699 if (pu8msa[u16index] == ITIM)
700 return &pu8msa[u16index];
701 else
702 u16index += (IE_HDR_LEN + pu8msa[u16index + 1]);
703 }
704
705 return 0;
706 }
707
708 /* This function gets the current channel information from
709 * the 802.11n beacon/probe response frame */
710 u8 get_current_channel_802_11n(u8 *pu8msa, u16 u16RxLen)
711 {
712 u16 index;
713
714 index = TAG_PARAM_OFFSET;
715 while (index < (u16RxLen - FCS_LEN)) {
716 if (pu8msa[index] == IDSPARMS)
717 return pu8msa[index + 2];
718 else
719 /* Increment index by length information and header */
720 index += pu8msa[index + 1] + IE_HDR_LEN;
721 }
722
723 /* Return current channel information from the MIB, if beacon/probe */
724 /* response frame does not contain the DS parameter set IE */
725 /* return (mget_CurrentChannel() + 1); */
726 return 0; /* no MIB here */
727 }
728
729 u8 get_current_channel(u8 *pu8msa, u16 u16RxLen)
730 {
731 #ifdef PHY_802_11n
732 #ifdef FIVE_GHZ_BAND
733 /* Get the current channel as its not set in */
734 /* 802.11a beacons/probe response */
735 return (get_rf_channel() + 1);
736 #else /* FIVE_GHZ_BAND */
737 /* Extract current channel information from */
738 /* the beacon/probe response frame */
739 return get_current_channel_802_11n(pu8msa, u16RxLen);
740 #endif /* FIVE_GHZ_BAND */
741 #else
742 return 0;
743 #endif /* PHY_802_11n */
744 }
745
746 /**
747 * @brief parses the received 'N' message
748 * @details
749 * @param[in] pu8MsgBuffer The message to be parsed
750 * @param[out] ppstrNetworkInfo pointer to pointer to the structure containing the parsed Network Info
751 * @return Error code indicating success/failure
752 * @note
753 * @author mabubakr
754 * @date 1 Mar 2012
755 * @version 1.0
756 */
757 s32 ParseNetworkInfo(u8 *pu8MsgBuffer, tstrNetworkInfo **ppstrNetworkInfo)
758 {
759 s32 s32Error = WILC_SUCCESS;
760 tstrNetworkInfo *pstrNetworkInfo = NULL;
761 u8 u8MsgType = 0;
762 u8 u8MsgID = 0;
763 u16 u16MsgLen = 0;
764
765 u16 u16WidID = (u16)WID_NIL;
766 u16 u16WidLen = 0;
767 u8 *pu8WidVal = 0;
768
769 u8MsgType = pu8MsgBuffer[0];
770
771 /* Check whether the received message type is 'N' */
772 if ('N' != u8MsgType) {
773 PRINT_ER("Received Message format incorrect.\n");
774 WILC_ERRORREPORT(s32Error, WILC_FAIL);
775 }
776
777 /* Extract message ID */
778 u8MsgID = pu8MsgBuffer[1];
779
780 /* Extract message Length */
781 u16MsgLen = MAKE_WORD16(pu8MsgBuffer[2], pu8MsgBuffer[3]);
782
783 /* Extract WID ID */
784 u16WidID = MAKE_WORD16(pu8MsgBuffer[4], pu8MsgBuffer[5]);
785
786 /* Extract WID Length */
787 u16WidLen = MAKE_WORD16(pu8MsgBuffer[6], pu8MsgBuffer[7]);
788
789 /* Assign a pointer to the WID value */
790 pu8WidVal = &pu8MsgBuffer[8];
791
792 /* parse the WID value of the WID "WID_NEWORK_INFO" */
793 {
794 u8 *pu8msa = 0;
795 u16 u16RxLen = 0;
796 u8 *pu8TimElm = 0;
797 u8 *pu8IEs = 0;
798 u16 u16IEsLen = 0;
799 u8 u8index = 0;
800 u32 u32Tsf_Lo;
801 u32 u32Tsf_Hi;
802
803 pstrNetworkInfo = WILC_MALLOC(sizeof(tstrNetworkInfo));
804 memset((void *)(pstrNetworkInfo), 0, sizeof(tstrNetworkInfo));
805
806 pstrNetworkInfo->s8rssi = pu8WidVal[0];
807
808 /* Assign a pointer to msa "Mac Header Start Address" */
809 pu8msa = &pu8WidVal[1];
810
811 u16RxLen = u16WidLen - 1;
812
813 /* parse msa*/
814
815 /* Get the cap_info */
816 pstrNetworkInfo->u16CapInfo = get_cap_info(pu8msa);
817 #ifdef WILC_P2P
818 /* Get time-stamp [Low only 32 bit] */
819 pstrNetworkInfo->u32Tsf = get_beacon_timestamp_lo(pu8msa);
820 PRINT_D(CORECONFIG_DBG, "TSF :%x\n", pstrNetworkInfo->u32Tsf);
821 #endif
822
823 /* Get full time-stamp [Low and High 64 bit] */
824 u32Tsf_Lo = get_beacon_timestamp_lo(pu8msa);
825 u32Tsf_Hi = get_beacon_timestamp_hi(pu8msa);
826
827 pstrNetworkInfo->u64Tsf = u32Tsf_Lo | ((u64)u32Tsf_Hi << 32);
828
829 /* Get SSID */
830 get_ssid(pu8msa, pstrNetworkInfo->au8ssid, &(pstrNetworkInfo->u8SsidLen));
831
832 /* Get BSSID */
833 get_BSSID(pu8msa, pstrNetworkInfo->au8bssid);
834
835 /* Get the current channel */
836 pstrNetworkInfo->u8channel = get_current_channel(pu8msa, (u16RxLen + FCS_LEN));
837
838 /* Get beacon period */
839 u8index = (MAC_HDR_LEN + TIME_STAMP_LEN);
840
841 pstrNetworkInfo->u16BeaconPeriod = get_beacon_period(pu8msa + u8index);
842
843 u8index += BEACON_INTERVAL_LEN + CAP_INFO_LEN;
844
845 /* Get DTIM Period */
846 pu8TimElm = get_tim_elm(pu8msa, (u16RxLen + FCS_LEN), u8index);
847 if (pu8TimElm != 0)
848 pstrNetworkInfo->u8DtimPeriod = pu8TimElm[3];
849 pu8IEs = &pu8msa[MAC_HDR_LEN + TIME_STAMP_LEN + BEACON_INTERVAL_LEN + CAP_INFO_LEN];
850 u16IEsLen = u16RxLen - (MAC_HDR_LEN + TIME_STAMP_LEN + BEACON_INTERVAL_LEN + CAP_INFO_LEN);
851
852 if (u16IEsLen > 0) {
853 pstrNetworkInfo->pu8IEs = WILC_MALLOC(u16IEsLen);
854 memset((void *)(pstrNetworkInfo->pu8IEs), 0, u16IEsLen);
855
856 memcpy(pstrNetworkInfo->pu8IEs, pu8IEs, u16IEsLen);
857 }
858 pstrNetworkInfo->u16IEsLen = u16IEsLen;
859
860 }
861
862 *ppstrNetworkInfo = pstrNetworkInfo;
863
864 ERRORHANDLER:
865 return s32Error;
866 }
867
868 /**
869 * @brief Deallocates the parsed Network Info
870 * @details
871 * @param[in] pstrNetworkInfo Network Info to be deallocated
872 * @return Error code indicating success/failure
873 * @note
874 * @author mabubakr
875 * @date 1 Mar 2012
876 * @version 1.0
877 */
878 s32 DeallocateNetworkInfo(tstrNetworkInfo *pstrNetworkInfo)
879 {
880 s32 s32Error = WILC_SUCCESS;
881
882 if (pstrNetworkInfo != NULL) {
883 if (pstrNetworkInfo->pu8IEs != NULL) {
884 kfree(pstrNetworkInfo->pu8IEs);
885 pstrNetworkInfo->pu8IEs = NULL;
886 } else {
887 s32Error = WILC_FAIL;
888 }
889
890 kfree(pstrNetworkInfo);
891 pstrNetworkInfo = NULL;
892
893 } else {
894 s32Error = WILC_FAIL;
895 }
896
897 return s32Error;
898 }
899
900 /**
901 * @brief parses the received Association Response frame
902 * @details
903 * @param[in] pu8Buffer The Association Response frame to be parsed
904 * @param[out] ppstrConnectRespInfo pointer to pointer to the structure containing the parsed Association Response Info
905 * @return Error code indicating success/failure
906 * @note
907 * @author mabubakr
908 * @date 2 Apr 2012
909 * @version 1.0
910 */
911 s32 ParseAssocRespInfo(u8 *pu8Buffer, u32 u32BufferLen,
912 tstrConnectRespInfo **ppstrConnectRespInfo)
913 {
914 s32 s32Error = WILC_SUCCESS;
915 tstrConnectRespInfo *pstrConnectRespInfo = NULL;
916 u16 u16AssocRespLen = 0;
917 u8 *pu8IEs = 0;
918 u16 u16IEsLen = 0;
919
920 pstrConnectRespInfo = WILC_MALLOC(sizeof(tstrConnectRespInfo));
921 memset((void *)(pstrConnectRespInfo), 0, sizeof(tstrConnectRespInfo));
922
923 /* u16AssocRespLen = pu8Buffer[0]; */
924 u16AssocRespLen = (u16)u32BufferLen;
925
926 /* get the status code */
927 pstrConnectRespInfo->u16ConnectStatus = get_asoc_status(pu8Buffer);
928 if (pstrConnectRespInfo->u16ConnectStatus == SUCCESSFUL_STATUSCODE) {
929
930 /* get the capability */
931 pstrConnectRespInfo->u16capability = get_assoc_resp_cap_info(pu8Buffer);
932
933 /* get the Association ID */
934 pstrConnectRespInfo->u16AssocID = get_asoc_id(pu8Buffer);
935
936 /* get the Information Elements */
937 pu8IEs = &pu8Buffer[CAP_INFO_LEN + STATUS_CODE_LEN + AID_LEN];
938 u16IEsLen = u16AssocRespLen - (CAP_INFO_LEN + STATUS_CODE_LEN + AID_LEN);
939
940 pstrConnectRespInfo->pu8RespIEs = WILC_MALLOC(u16IEsLen);
941 memset((void *)(pstrConnectRespInfo->pu8RespIEs), 0, u16IEsLen);
942
943 memcpy(pstrConnectRespInfo->pu8RespIEs, pu8IEs, u16IEsLen);
944 pstrConnectRespInfo->u16RespIEsLen = u16IEsLen;
945 }
946
947 *ppstrConnectRespInfo = pstrConnectRespInfo;
948
949
950 return s32Error;
951 }
952
953 /**
954 * @brief Deallocates the parsed Association Response Info
955 * @details
956 * @param[in] pstrNetworkInfo Network Info to be deallocated
957 * @return Error code indicating success/failure
958 * @note
959 * @author mabubakr
960 * @date 2 Apr 2012
961 * @version 1.0
962 */
963 s32 DeallocateAssocRespInfo(tstrConnectRespInfo *pstrConnectRespInfo)
964 {
965 s32 s32Error = WILC_SUCCESS;
966
967 if (pstrConnectRespInfo != NULL) {
968 if (pstrConnectRespInfo->pu8RespIEs != NULL) {
969 kfree(pstrConnectRespInfo->pu8RespIEs);
970 pstrConnectRespInfo->pu8RespIEs = NULL;
971 } else {
972 s32Error = WILC_FAIL;
973 }
974
975 kfree(pstrConnectRespInfo);
976 pstrConnectRespInfo = NULL;
977
978 } else {
979 s32Error = WILC_FAIL;
980 }
981
982 return s32Error;
983 }
984
985 #ifndef CONNECT_DIRECT
986 s32 ParseSurveyResults(u8 ppu8RcvdSiteSurveyResults[][MAX_SURVEY_RESULT_FRAG_SIZE],
987 wid_site_survey_reslts_s **ppstrSurveyResults,
988 u32 *pu32SurveyResultsCount)
989 {
990 s32 s32Error = WILC_SUCCESS;
991 wid_site_survey_reslts_s *pstrSurveyResults = NULL;
992 u32 u32SurveyResultsCount = 0;
993 u32 u32SurveyBytesLength = 0;
994 u8 *pu8BufferPtr;
995 u32 u32RcvdSurveyResultsNum = 2;
996 u8 u8ReadSurveyResFragNum;
997 u32 i;
998 u32 j;
999
1000 for (i = 0; i < u32RcvdSurveyResultsNum; i++) {
1001 u32SurveyBytesLength = ppu8RcvdSiteSurveyResults[i][0];
1002
1003
1004 for (j = 0; j < u32SurveyBytesLength; j += SURVEY_RESULT_LENGTH) {
1005 u32SurveyResultsCount++;
1006 }
1007 }
1008
1009 pstrSurveyResults = WILC_MALLOC(u32SurveyResultsCount * sizeof(wid_site_survey_reslts_s));
1010 if (pstrSurveyResults == NULL) {
1011 u32SurveyResultsCount = 0;
1012 WILC_ERRORREPORT(s32Error, WILC_NO_MEM);
1013 }
1014
1015 memset((void *)(pstrSurveyResults), 0, u32SurveyResultsCount * sizeof(wid_site_survey_reslts_s));
1016
1017 u32SurveyResultsCount = 0;
1018
1019 for (i = 0; i < u32RcvdSurveyResultsNum; i++) {
1020 pu8BufferPtr = ppu8RcvdSiteSurveyResults[i];
1021
1022 u32SurveyBytesLength = pu8BufferPtr[0];
1023
1024 /* TODO: mostafa: pu8BufferPtr[1] contains the fragment num */
1025 u8ReadSurveyResFragNum = pu8BufferPtr[1];
1026
1027 pu8BufferPtr += 2;
1028
1029 for (j = 0; j < u32SurveyBytesLength; j += SURVEY_RESULT_LENGTH) {
1030 memcpy(&pstrSurveyResults[u32SurveyResultsCount], pu8BufferPtr, SURVEY_RESULT_LENGTH);
1031 pu8BufferPtr += SURVEY_RESULT_LENGTH;
1032 u32SurveyResultsCount++;
1033 }
1034 }
1035
1036 ERRORHANDLER:
1037 *ppstrSurveyResults = pstrSurveyResults;
1038 *pu32SurveyResultsCount = u32SurveyResultsCount;
1039
1040 return s32Error;
1041 }
1042
1043
1044 s32 DeallocateSurveyResults(wid_site_survey_reslts_s *pstrSurveyResults)
1045 {
1046 s32 s32Error = WILC_SUCCESS;
1047
1048 if (pstrSurveyResults != NULL) {
1049 kfree(pstrSurveyResults);
1050 }
1051
1052 return s32Error;
1053 }
1054 #endif
1055
1056 /*****************************************************************************/
1057 /* */
1058 /* Function Name : ProcessCharWid */
1059 /* */
1060 /* Description : This function processes a WID of type WID_CHAR and */
1061 /* updates the cfg packet with the supplied value. */
1062 /* */
1063 /* Inputs : 1) Pointer to WID cfg structure */
1064 /* 2) Value to set */
1065 /* */
1066 /* Globals : */
1067 /* */
1068 /* Processing : */
1069 /* */
1070 /* Outputs : None */
1071 /* */
1072 /* Returns : None */
1073 /* */
1074 /* Issues : None */
1075 /* */
1076 /* Revision History: */
1077 /* */
1078 /* DD MM YYYY Author(s) Changes (Describe the changes made) */
1079 /* 08 01 2008 Ittiam Draft */
1080 /* */
1081 /*****************************************************************************/
1082
1083 void ProcessCharWid(char *pcPacket, s32 *ps32PktLen,
1084 tstrWID *pstrWID, s8 *ps8WidVal)
1085 {
1086 u8 *pu8val = (u8 *)ps8WidVal;
1087 u8 u8val = 0;
1088 s32 s32PktLen = *ps32PktLen;
1089 if (pstrWID == NULL) {
1090 PRINT_WRN(CORECONFIG_DBG, "Can't set CHAR val 0x%x ,NULL structure\n", u8val);
1091 return;
1092 }
1093
1094 /* WID */
1095 pcPacket[s32PktLen++] = (u8)(pstrWID->u16WIDid & 0xFF);
1096 pcPacket[s32PktLen++] = (u8)(pstrWID->u16WIDid >> 8) & 0xFF;
1097 if (g_oper_mode == SET_CFG) {
1098 u8val = *pu8val;
1099
1100 /* Length */
1101 pcPacket[s32PktLen++] = sizeof(u8);
1102
1103
1104 /* Value */
1105 pcPacket[s32PktLen++] = u8val;
1106 }
1107 *ps32PktLen = s32PktLen;
1108 }
1109
1110 /*****************************************************************************/
1111 /* */
1112 /* Function Name : ProcessShortWid */
1113 /* */
1114 /* Description : This function processes a WID of type WID_SHORT and */
1115 /* updates the cfg packet with the supplied value. */
1116 /* */
1117 /* Inputs : 1) Pointer to WID cfg structure */
1118 /* 2) Value to set */
1119 /* */
1120 /* Globals : */
1121 /* */
1122 /* Processing : */
1123 /* */
1124 /* Outputs : None */
1125 /* */
1126 /* Returns : None */
1127 /* */
1128 /* Issues : None */
1129 /* */
1130 /* Revision History: */
1131 /* */
1132 /* DD MM YYYY Author(s) Changes (Describe the changes made) */
1133 /* 08 01 2008 Ittiam Draft */
1134 /* */
1135 /*****************************************************************************/
1136
1137 void ProcessShortWid(char *pcPacket, s32 *ps32PktLen,
1138 tstrWID *pstrWID, s8 *ps8WidVal)
1139 {
1140 u16 *pu16val = (u16 *)ps8WidVal;
1141 u16 u16val = 0;
1142 s32 s32PktLen = *ps32PktLen;
1143 if (pstrWID == NULL) {
1144 PRINT_WRN(CORECONFIG_DBG, "Can't set SHORT val 0x%x ,NULL structure\n", u16val);
1145 return;
1146 }
1147
1148 /* WID */
1149 pcPacket[s32PktLen++] = (u8)(pstrWID->u16WIDid & 0xFF);
1150 pcPacket[s32PktLen++] = (u8)((pstrWID->u16WIDid >> 8) & 0xFF);
1151
1152 if (g_oper_mode == SET_CFG) {
1153 u16val = *pu16val;
1154
1155 /* Length */
1156 pcPacket[s32PktLen++] = sizeof(u16);
1157
1158 /* Value */
1159 pcPacket[s32PktLen++] = (u8)(u16val & 0xFF);
1160 pcPacket[s32PktLen++] = (u8)((u16val >> 8) & 0xFF);
1161 }
1162 *ps32PktLen = s32PktLen;
1163 }
1164
1165 /*****************************************************************************/
1166 /* */
1167 /* Function Name : ProcessIntWid */
1168 /* */
1169 /* Description : This function processes a WID of type WID_INT and */
1170 /* updates the cfg packet with the supplied value. */
1171 /* */
1172 /* Inputs : 1) Pointer to WID cfg structure */
1173 /* 2) Value to set */
1174 /* */
1175 /* Globals : */
1176 /* */
1177 /* Processing : */
1178 /* */
1179 /* Outputs : None */
1180 /* */
1181 /* Returns : None */
1182 /* */
1183 /* Issues : None */
1184 /* */
1185 /* Revision History: */
1186 /* */
1187 /* DD MM YYYY Author(s) Changes (Describe the changes made) */
1188 /* 08 01 2008 Ittiam Draft */
1189 /* */
1190 /*****************************************************************************/
1191
1192 void ProcessIntWid(char *pcPacket, s32 *ps32PktLen,
1193 tstrWID *pstrWID, s8 *ps8WidVal)
1194 {
1195 u32 *pu32val = (u32 *)ps8WidVal;
1196 u32 u32val = 0;
1197 s32 s32PktLen = *ps32PktLen;
1198 if (pstrWID == NULL) {
1199 PRINT_WRN(CORECONFIG_DBG, "Can't set INT val 0x%x , NULL structure\n", u32val);
1200 return;
1201 }
1202
1203 /* WID */
1204 pcPacket[s32PktLen++] = (u8)(pstrWID->u16WIDid & 0xFF);
1205 pcPacket[s32PktLen++] = (u8)((pstrWID->u16WIDid >> 8) & 0xFF);
1206
1207 if (g_oper_mode == SET_CFG) {
1208 u32val = *pu32val;
1209
1210 /* Length */
1211 pcPacket[s32PktLen++] = sizeof(u32);
1212
1213 /* Value */
1214 pcPacket[s32PktLen++] = (u8)(u32val & 0xFF);
1215 pcPacket[s32PktLen++] = (u8)((u32val >> 8) & 0xFF);
1216 pcPacket[s32PktLen++] = (u8)((u32val >> 16) & 0xFF);
1217 pcPacket[s32PktLen++] = (u8)((u32val >> 24) & 0xFF);
1218 }
1219 *ps32PktLen = s32PktLen;
1220 }
1221
1222 /*****************************************************************************/
1223 /* */
1224 /* Function Name : ProcessIPwid */
1225 /* */
1226 /* Description : This function processes a WID of type WID_IP and */
1227 /* updates the cfg packet with the supplied value. */
1228 /* */
1229 /* Inputs : 1) Pointer to WID cfg structure */
1230 /* 2) Value to set */
1231 /* */
1232 /* Globals : */
1233 /* */
1234 /* */
1235 /* Processing : */
1236 /* */
1237 /* Outputs : None */
1238 /* */
1239 /* Returns : None */
1240 /* */
1241 /* Issues : None */
1242 /* */
1243 /* Revision History: */
1244 /* */
1245 /* DD MM YYYY Author(s) Changes (Describe the changes made) */
1246 /* 08 01 2008 Ittiam Draft */
1247 /* */
1248 /*****************************************************************************/
1249
1250 void ProcessIPwid(char *pcPacket, s32 *ps32PktLen,
1251 tstrWID *pstrWID, u8 *pu8ip)
1252 {
1253 u32 u32val = 0;
1254 s32 s32PktLen = *ps32PktLen;
1255
1256 if (pstrWID == NULL) {
1257 PRINT_WRN(CORECONFIG_DBG, "Can't set IP Addr , NULL structure\n");
1258 return;
1259 }
1260
1261 /* WID */
1262 pcPacket[s32PktLen++] = (u8)(pstrWID->u16WIDid & 0xFF);
1263 pcPacket[s32PktLen++] = (u8)((pstrWID->u16WIDid >> 8) & 0xFF);
1264
1265 if (g_oper_mode == SET_CFG) {
1266 /* Length */
1267 pcPacket[s32PktLen++] = sizeof(u32);
1268
1269 /* Convert the IP Address String to Integer */
1270 conv_ip_to_int(pu8ip, &u32val);
1271
1272 /* Value */
1273 pcPacket[s32PktLen++] = (u8)(u32val & 0xFF);
1274 pcPacket[s32PktLen++] = (u8)((u32val >> 8) & 0xFF);
1275 pcPacket[s32PktLen++] = (u8)((u32val >> 16) & 0xFF);
1276 pcPacket[s32PktLen++] = (u8)((u32val >> 24) & 0xFF);
1277 }
1278 *ps32PktLen = s32PktLen;
1279 }
1280
1281 /*****************************************************************************/
1282 /* */
1283 /* Function Name : ProcessStrWid */
1284 /* */
1285 /* Description : This function processes a WID of type WID_STR and */
1286 /* updates the cfg packet with the supplied value. */
1287 /* */
1288 /* Inputs : 1) Pointer to WID cfg structure */
1289 /* 2) Value to set */
1290 /* */
1291 /* Globals : */
1292 /* */
1293 /* Processing : */
1294 /* */
1295 /* Outputs : None */
1296 /* */
1297 /* Returns : None */
1298 /* */
1299 /* Issues : None */
1300 /* */
1301 /* Revision History: */
1302 /* */
1303 /* DD MM YYYY Author(s) Changes (Describe the changes made) */
1304 /* 08 01 2008 Ittiam Draft */
1305 /* */
1306 /*****************************************************************************/
1307
1308 void ProcessStrWid(char *pcPacket, s32 *ps32PktLen,
1309 tstrWID *pstrWID, u8 *pu8val, s32 s32ValueSize)
1310 {
1311 u16 u16MsgLen = 0;
1312 u16 idx = 0;
1313 s32 s32PktLen = *ps32PktLen;
1314 if (pstrWID == NULL) {
1315 PRINT_WRN(CORECONFIG_DBG, "Can't set STR val, NULL structure\n");
1316 return;
1317 }
1318
1319 /* WID */
1320 pcPacket[s32PktLen++] = (u8)(pstrWID->u16WIDid & 0xFF);
1321 pcPacket[s32PktLen++] = (u8)((pstrWID->u16WIDid >> 8) & 0xFF);
1322
1323 if (g_oper_mode == SET_CFG) {
1324 /* Message Length */
1325 u16MsgLen = (u16)s32ValueSize;
1326
1327 /* Length */
1328 pcPacket[s32PktLen++] = (u8)u16MsgLen;
1329
1330 /* Value */
1331 for (idx = 0; idx < u16MsgLen; idx++)
1332 pcPacket[s32PktLen++] = pu8val[idx];
1333 }
1334 *ps32PktLen = s32PktLen;
1335 }
1336
1337 /*****************************************************************************/
1338 /* */
1339 /* Function Name : ProcessAdrWid */
1340 /* */
1341 /* Description : This function processes a WID of type WID_ADR and */
1342 /* updates the cfg packet with the supplied value. */
1343 /* */
1344 /* Inputs : 1) Pointer to WID cfg structure */
1345 /* 2) Value to set */
1346 /* */
1347 /* Globals : */
1348 /* */
1349 /* Processing : */
1350 /* */
1351 /* Outputs : None */
1352 /* */
1353 /* Returns : None */
1354 /* */
1355 /* Issues : None */
1356 /* */
1357 /* Revision History: */
1358 /* */
1359 /* DD MM YYYY Author(s) Changes (Describe the changes made) */
1360 /* 08 01 2008 Ittiam Draft */
1361 /* */
1362 /*****************************************************************************/
1363
1364 void ProcessAdrWid(char *pcPacket, s32 *ps32PktLen,
1365 tstrWID *pstrWID, u8 *pu8val)
1366 {
1367 u16 u16MsgLen = 0;
1368 s32 s32PktLen = *ps32PktLen;
1369
1370 if (pstrWID == NULL) {
1371 PRINT_WRN(CORECONFIG_DBG, "Can't set Addr WID, NULL structure\n");
1372 return;
1373 }
1374
1375 /* WID */
1376 pcPacket[s32PktLen++] = (u8)(pstrWID->u16WIDid & 0xFF);
1377 pcPacket[s32PktLen++] = (u8)((pstrWID->u16WIDid >> 8) & 0xFF);
1378
1379 if (g_oper_mode == SET_CFG) {
1380 /* Message Length */
1381 u16MsgLen = MAC_ADDR_LEN;
1382
1383 /* Length */
1384 pcPacket[s32PktLen++] = (u8)u16MsgLen;
1385
1386 /* Value */
1387 extract_mac_addr(pu8val, pcPacket + s32PktLen);
1388 s32PktLen += u16MsgLen;
1389 }
1390 *ps32PktLen = s32PktLen;
1391 }
1392
1393 /*****************************************************************************/
1394 /* */
1395 /* Function Name : ProcessBinWid */
1396 /* */
1397 /* Description : This function processes a WID of type WID_BIN_DATA and */
1398 /* updates the cfg packet with the supplied value. */
1399 /* */
1400 /* Inputs : 1) Pointer to WID cfg structure */
1401 /* 2) Name of file containing the binary data in text mode */
1402 /* */
1403 /* Globals : */
1404 /* */
1405 /* Processing : The binary data is expected to be supplied through a */
1406 /* file in text mode. This file is expected to be in the */
1407 /* finject format. It is parsed, converted to binary format */
1408 /* and copied into g_cfg_pkt for further processing. This */
1409 /* is obviously a round-about way of processing involving */
1410 /* multiple (re)conversions between bin & ascii formats. */
1411 /* But it is done nevertheless to retain uniformity and for */
1412 /* ease of debugging. */
1413 /* */
1414 /* Outputs : None */
1415 /* */
1416 /* Returns : None */
1417 /* */
1418
1419 /* Issues : None */
1420 /* */
1421 /* Revision History: */
1422 /* */
1423 /* DD MM YYYY Author(s) Changes (Describe the changes made) */
1424 /* 08 01 2008 Ittiam Draft */
1425 /* */
1426 /*****************************************************************************/
1427
1428 void ProcessBinWid(char *pcPacket, s32 *ps32PktLen,
1429 tstrWID *pstrWID, u8 *pu8val, s32 s32ValueSize)
1430 {
1431 u16 u16MsgLen = 0;
1432 u16 idx = 0;
1433 s32 s32PktLen = *ps32PktLen;
1434 u8 u8checksum = 0;
1435
1436 if (pstrWID == NULL) {
1437 PRINT_WRN(CORECONFIG_DBG, "Can't set BIN val, NULL structure\n");
1438 return;
1439 }
1440
1441 /* WID */
1442 pcPacket[s32PktLen++] = (u8)(pstrWID->u16WIDid & 0xFF);
1443 pcPacket[s32PktLen++] = (u8)((pstrWID->u16WIDid >> 8) & 0xFF);
1444
1445 if (g_oper_mode == SET_CFG) {
1446 /* Message Length */
1447 u16MsgLen = (u16)s32ValueSize;
1448
1449 /* Length */
1450 /* pcPacket[s32PktLen++] = (u8)u16MsgLen; */
1451 pcPacket[s32PktLen++] = (u8)(u16MsgLen & 0xFF);
1452 pcPacket[s32PktLen++] = (u8)((u16MsgLen >> 8) & 0xFF);
1453
1454 /* Value */
1455 for (idx = 0; idx < u16MsgLen; idx++)
1456 pcPacket[s32PktLen++] = pu8val[idx];
1457
1458 /* checksum */
1459 for (idx = 0; idx < u16MsgLen; idx++)
1460 u8checksum += pcPacket[MSG_HEADER_LEN + idx + 4];
1461
1462 pcPacket[s32PktLen++] = u8checksum;
1463 }
1464 *ps32PktLen = s32PktLen;
1465 }
1466
1467
1468 /*****************************************************************************/
1469 /* */
1470 /* Function Name : further_process_response */
1471 /* */
1472 /* Description : This function parses the response frame got from the */
1473 /* device. */
1474 /* */
1475 /* Inputs : 1) The received response frame */
1476 /* 2) WID */
1477 /* 3) WID Length */
1478 /* 4) Output file handle */
1479 /* 5) Process Wid Number(i.e wid from --widn switch) */
1480 /* 6) Index the array in the Global Wid Structure. */
1481 /* */
1482 /* Globals : g_wid_num, gastrWIDs */
1483 /* */
1484 /* Processing : This function parses the response of the device depending*/
1485 /* WID type and writes it to the output file in Hex or */
1486 /* decimal notation depending on the --getx or --get switch.*/
1487 /* */
1488 /* Outputs : None */
1489 /* */
1490 /* Returns : 0 on Success & -2 on Failure */
1491 /* */
1492 /* Issues : None */
1493 /* */
1494 /* Revision History: */
1495 /* */
1496 /* DD MM YYYY Author(s) Changes (Describe the changes made) */
1497 /* 08 01 2009 Ittiam Draft */
1498 /* */
1499 /*****************************************************************************/
1500
1501 s32 further_process_response(u8 *resp,
1502 u16 u16WIDid,
1503 u16 cfg_len,
1504 bool process_wid_num,
1505 u32 cnt,
1506 tstrWID *pstrWIDresult)
1507 {
1508 u32 retval = 0;
1509 u32 idx = 0;
1510 u8 cfg_chr = 0;
1511 u16 cfg_sht = 0;
1512 u32 cfg_int = 0;
1513 u8 cfg_str[256] = {0};
1514 tenuWIDtype enuWIDtype = WID_UNDEF;
1515
1516 if (process_wid_num)
1517 enuWIDtype = get_wid_type(g_wid_num);
1518 else
1519 enuWIDtype = gastrWIDs[cnt].enuWIDtype;
1520
1521
1522 switch (enuWIDtype) {
1523 case WID_CHAR:
1524 cfg_chr = resp[idx];
1525 /*Set local copy of WID*/
1526 *(pstrWIDresult->ps8WidVal) = cfg_chr;
1527 break;
1528
1529 case WID_SHORT:
1530 {
1531 u16 *pu16val = (u16 *)(pstrWIDresult->ps8WidVal);
1532 cfg_sht = MAKE_WORD16(resp[idx], resp[idx + 1]);
1533 /*Set local copy of WID*/
1534 /* pstrWIDresult->ps8WidVal = (s8*)(s32)cfg_sht; */
1535 *pu16val = cfg_sht;
1536 break;
1537 }
1538
1539 case WID_INT:
1540 {
1541 u32 *pu32val = (u32 *)(pstrWIDresult->ps8WidVal);
1542 cfg_int = MAKE_WORD32(
1543 MAKE_WORD16(resp[idx], resp[idx + 1]),
1544 MAKE_WORD16(resp[idx + 2], resp[idx + 3])
1545 );
1546 /*Set local copy of WID*/
1547 /* pstrWIDresult->ps8WidVal = (s8*)cfg_int; */
1548 *pu32val = cfg_int;
1549 break;
1550 }
1551
1552 case WID_STR:
1553 memcpy(cfg_str, resp + idx, cfg_len);
1554 /* cfg_str[cfg_len] = '\0'; //mostafa: no need currently for NULL termination */
1555 if (pstrWIDresult->s32ValueSize >= cfg_len) {
1556 memcpy(pstrWIDresult->ps8WidVal, cfg_str, cfg_len); /* mostafa: no need currently for the extra NULL byte */
1557 pstrWIDresult->s32ValueSize = cfg_len;
1558 } else {
1559 PRINT_ER("allocated WID buffer length is smaller than the received WID Length\n");
1560 retval = -2;
1561 }
1562
1563 break;
1564
1565 case WID_ADR:
1566 create_mac_addr(cfg_str, resp + idx);
1567
1568 strncpy(pstrWIDresult->ps8WidVal, cfg_str, strlen(cfg_str));
1569 pstrWIDresult->ps8WidVal[strlen(cfg_str)] = '\0';
1570 break;
1571
1572 case WID_IP:
1573 cfg_int = MAKE_WORD32(
1574 MAKE_WORD16(resp[idx], resp[idx + 1]),
1575 MAKE_WORD16(resp[idx + 2], resp[idx + 3])
1576 );
1577 conv_int_to_ip(cfg_str, cfg_int);
1578 break;
1579
1580 case WID_BIN_DATA:
1581 if (pstrWIDresult->s32ValueSize >= cfg_len) {
1582 memcpy(pstrWIDresult->ps8WidVal, resp + idx, cfg_len);
1583 pstrWIDresult->s32ValueSize = cfg_len;
1584 } else {
1585 PRINT_ER("Allocated WID buffer length is smaller than the received WID Length Err(%d)\n", retval);
1586 retval = -2;
1587 }
1588 break;
1589
1590 default:
1591 PRINT_ER("ERROR: Check config database: Error(%d)\n", retval);
1592 retval = -2;
1593 break;
1594 }
1595
1596 return retval;
1597 }
1598
1599 /*****************************************************************************/
1600 /* */
1601 /* Function Name : ParseResponse */
1602 /* */
1603 /* Description : This function parses the command-line options and */
1604 /* creates the config packets which can be sent to the WLAN */
1605 /* station. */
1606 /* */
1607 /* Inputs : 1) The received response frame */
1608 /* */
1609 /* Globals : g_opt_list, gastrWIDs */
1610 /* */
1611 /* Processing : This function parses the options and creates different */
1612 /* types of packets depending upon the WID-type */
1613 /* corresponding to the option. */
1614 /* */
1615 /* Outputs : None */
1616 /* */
1617 /* Returns : 0 on Success & -1 on Failure */
1618 /* */
1619 /* Issues : None */
1620 /* */
1621 /* Revision History: */
1622 /* */
1623 /* DD MM YYYY Author(s) Changes (Describe the changes made) */
1624 /* 08 01 2008 Ittiam Draft */
1625 /* */
1626 /*****************************************************************************/
1627
1628 s32 ParseResponse(u8 *resp, tstrWID *pstrWIDcfgResult)
1629 {
1630 u16 u16RespLen = 0;
1631 u16 u16WIDid = 0;
1632 u16 cfg_len = 0;
1633 tenuWIDtype enuWIDtype = WID_UNDEF;
1634 bool num_wid_processed = false;
1635 u32 cnt = 0;
1636 u32 idx = 0;
1637 u32 ResCnt = 0;
1638 /* Check whether the received frame is a valid response */
1639 if (RESP_MSG_TYPE != resp[0]) {
1640 PRINT_INFO(CORECONFIG_DBG, "Received Message format incorrect.\n");
1641 return -1;
1642 }
1643
1644 /* Extract Response Length */
1645 u16RespLen = MAKE_WORD16(resp[2], resp[3]);
1646 Res_Len = u16RespLen;
1647
1648 for (idx = MSG_HEADER_LEN; idx < u16RespLen; ) {
1649 u16WIDid = MAKE_WORD16(resp[idx], resp[idx + 1]);
1650 cfg_len = resp[idx + 2];
1651 /* Incase of Bin Type Wid, the length is given by two byte field */
1652 enuWIDtype = get_wid_type(u16WIDid);
1653 if (WID_BIN_DATA == enuWIDtype) {
1654 cfg_len |= ((u16)resp[idx + 3] << 8) & 0xFF00;
1655 idx++;
1656 }
1657 idx += 3;
1658 if ((u16WIDid == g_wid_num) && (!num_wid_processed)) {
1659 num_wid_processed = true;
1660
1661 if (-2 == further_process_response(&resp[idx], u16WIDid, cfg_len, true, 0, &pstrWIDcfgResult[ResCnt])) {
1662 return -2;
1663 }
1664 ResCnt++;
1665 } else {
1666 for (cnt = 0; cnt < g_num_total_switches; cnt++) {
1667 if (gastrWIDs[cnt].u16WIDid == u16WIDid) {
1668 if (-2 == further_process_response(&resp[idx], u16WIDid, cfg_len, false, cnt,
1669 &pstrWIDcfgResult[ResCnt])) {
1670 return -2;
1671 }
1672 ResCnt++;
1673 }
1674 }
1675 }
1676 idx += cfg_len;
1677 /* In case if BIN type Wid, The last byte of the Cfg packet is the */
1678 /* Checksum. The WID Length field does not accounts for the checksum. */
1679 /* The Checksum is discarded. */
1680 if (WID_BIN_DATA == enuWIDtype) {
1681 idx++;
1682 }
1683 }
1684
1685 return 0;
1686 }
1687
1688 /**
1689 * @brief parses the write response [just detects its status: success or failure]
1690 * @details
1691 * @param[in] pu8RespBuffer The Response to be parsed
1692 * @return Error code indicating Write Operation status:
1693 * WRITE_RESP_SUCCESS (1) => Write Success.
1694 * WILC_FAIL (-100) => Write Failure.
1695 * @note
1696 * @author Ittiam
1697 * @date 11 Aug 2009
1698 * @version 1.0
1699 */
1700
1701 s32 ParseWriteResponse(u8 *pu8RespBuffer)
1702 {
1703 s32 s32Error = WILC_FAIL;
1704 u16 u16WIDtype = (u16)WID_NIL;
1705
1706 /* Check whether the received frame is a valid response */
1707 if (RESP_MSG_TYPE != pu8RespBuffer[0]) {
1708 PRINT_ER("Received Message format incorrect.\n");
1709 return WILC_FAIL;
1710 }
1711
1712 u16WIDtype = MAKE_WORD16(pu8RespBuffer[4], pu8RespBuffer[5]);
1713
1714 /* Check for WID_STATUS ID and then check the length and status value */
1715 if ((u16WIDtype == WID_STATUS) &&
1716 (pu8RespBuffer[6] == 1) &&
1717 (pu8RespBuffer[7] == WRITE_RESP_SUCCESS)) {
1718 s32Error = WRITE_RESP_SUCCESS;
1719 return s32Error;
1720 }
1721
1722 /* If the length or status are not as expected return failure */
1723 s32Error = WILC_FAIL;
1724 return s32Error;
1725
1726 }
1727
1728 /**
1729 * @brief creates the header of the Configuration Packet
1730 * @details
1731 * @param[in,out] pcpacket The Configuration Packet
1732 * @param[in,out] ps32PacketLength Length of the Configuration Packet
1733 * @return Error code indicating success/failure
1734 * @note
1735 * @author aismail
1736 * @date 18 Feb 2012
1737 * @version 1.0
1738 */
1739
1740 s32 CreatePacketHeader(char *pcpacket, s32 *ps32PacketLength)
1741 {
1742 s32 s32Error = WILC_SUCCESS;
1743 u16 u16MsgLen = (u16)(*ps32PacketLength);
1744 u16 u16MsgInd = 0;
1745
1746 /* The format of the message is: */
1747 /* +-------------------------------------------------------------------+ */
1748 /* | Message Type | Message ID | Message Length |Message body | */
1749 /* +-------------------------------------------------------------------+ */
1750 /* | 1 Byte | 1 Byte | 2 Bytes | Message Length - 4 | */
1751 /* +-------------------------------------------------------------------+ */
1752
1753 /* The format of a message body of a message type 'W' is: */
1754 /* +-------------------------------------------------------------------+ */
1755 /* | WID0 | WID0 Length | WID0 Value | ......................... | */
1756 /* +-------------------------------------------------------------------+ */
1757 /* | 2 Bytes | 1 Byte | WID0 Length | ......................... | */
1758 /* +-------------------------------------------------------------------+ */
1759
1760
1761
1762 /* Message Type */
1763 if (g_oper_mode == SET_CFG)
1764 pcpacket[u16MsgInd++] = WRITE_MSG_TYPE;
1765 else
1766 pcpacket[u16MsgInd++] = QUERY_MSG_TYPE;
1767
1768 /* Sequence Number */
1769 pcpacket[u16MsgInd++] = g_seqno++;
1770
1771 /* Message Length */
1772 pcpacket[u16MsgInd++] = (u8)(u16MsgLen & 0xFF);
1773 pcpacket[u16MsgInd++] = (u8)((u16MsgLen >> 8) & 0xFF);
1774
1775 *ps32PacketLength = u16MsgLen;
1776
1777 return s32Error;
1778 }
1779
1780 /**
1781 * @brief creates Configuration packet based on the Input WIDs
1782 * @details
1783 * @param[in] pstrWIDs WIDs to be sent in the configuration packet
1784 * @param[in] u32WIDsCount number of WIDs to be sent in the configuration packet
1785 * @param[out] ps8packet The created Configuration Packet
1786 * @param[out] ps32PacketLength Length of the created Configuration Packet
1787 * @return Error code indicating success/failure
1788 * @note
1789 * @author
1790 * @date 1 Mar 2012
1791 * @version 1.0
1792 */
1793
1794 s32 CreateConfigPacket(s8 *ps8packet, s32 *ps32PacketLength,
1795 tstrWID *pstrWIDs, u32 u32WIDsCount)
1796 {
1797 s32 s32Error = WILC_SUCCESS;
1798 u32 u32idx = 0;
1799 *ps32PacketLength = MSG_HEADER_LEN;
1800 for (u32idx = 0; u32idx < u32WIDsCount; u32idx++) {
1801 switch (pstrWIDs[u32idx].enuWIDtype) {
1802 case WID_CHAR:
1803 ProcessCharWid(ps8packet, ps32PacketLength, &pstrWIDs[u32idx],
1804 pstrWIDs[u32idx].ps8WidVal);
1805 break;
1806
1807 case WID_SHORT:
1808 ProcessShortWid(ps8packet, ps32PacketLength, &pstrWIDs[u32idx],
1809 pstrWIDs[u32idx].ps8WidVal);
1810 break;
1811
1812 case WID_INT:
1813 ProcessIntWid(ps8packet, ps32PacketLength, &pstrWIDs[u32idx],
1814 pstrWIDs[u32idx].ps8WidVal);
1815 break;
1816
1817 case WID_STR:
1818 ProcessStrWid(ps8packet, ps32PacketLength, &pstrWIDs[u32idx],
1819 pstrWIDs[u32idx].ps8WidVal, pstrWIDs[u32idx].s32ValueSize);
1820 break;
1821
1822 case WID_IP:
1823 ProcessIPwid(ps8packet, ps32PacketLength, &pstrWIDs[u32idx],
1824 pstrWIDs[u32idx].ps8WidVal);
1825 break;
1826
1827 case WID_BIN_DATA:
1828 ProcessBinWid(ps8packet, ps32PacketLength, &pstrWIDs[u32idx],
1829 pstrWIDs[u32idx].ps8WidVal, pstrWIDs[u32idx].s32ValueSize);
1830 break;
1831
1832 default:
1833 PRINT_ER("ERROR: Check Config database\n");
1834 }
1835 }
1836
1837 CreatePacketHeader(ps8packet, ps32PacketLength);
1838
1839 return s32Error;
1840 }
1841
1842 s32 ConfigWaitResponse(char *pcRespBuffer, s32 s32MaxRespBuffLen, s32 *ps32BytesRead,
1843 bool bRespRequired)
1844 {
1845 s32 s32Error = WILC_SUCCESS;
1846 /*bug 3878*/
1847 /*removed to caller function*/
1848 /*gstrConfigPktInfo.pcRespBuffer = pcRespBuffer;
1849 * gstrConfigPktInfo.s32MaxRespBuffLen = s32MaxRespBuffLen;
1850 * gstrConfigPktInfo.bRespRequired = bRespRequired;*/
1851
1852
1853 if (gstrConfigPktInfo.bRespRequired) {
1854 down(&SemHandlePktResp);
1855
1856 *ps32BytesRead = gstrConfigPktInfo.s32BytesRead;
1857 }
1858
1859 memset((void *)(&gstrConfigPktInfo), 0, sizeof(tstrConfigPktInfo));
1860
1861 return s32Error;
1862 }
1863
1864 s32 ConfigProvideResponse(char *pcRespBuffer, s32 s32RespLen)
1865 {
1866 s32 s32Error = WILC_SUCCESS;
1867
1868 if (gstrConfigPktInfo.bRespRequired) {
1869 if (s32RespLen <= gstrConfigPktInfo.s32MaxRespBuffLen) {
1870 memcpy(gstrConfigPktInfo.pcRespBuffer, pcRespBuffer, s32RespLen);
1871 gstrConfigPktInfo.s32BytesRead = s32RespLen;
1872 } else {
1873 memcpy(gstrConfigPktInfo.pcRespBuffer, pcRespBuffer, gstrConfigPktInfo.s32MaxRespBuffLen);
1874 gstrConfigPktInfo.s32BytesRead = gstrConfigPktInfo.s32MaxRespBuffLen;
1875 PRINT_ER("BusProvideResponse() Response greater than the prepared Buffer Size\n");
1876 }
1877
1878 up(&SemHandlePktResp);
1879 }
1880
1881 return s32Error;
1882 }
1883
1884 /**
1885 * @brief writes the received packet pu8RxPacket in the global Rx FIFO buffer
1886 * @details
1887 * @param[in] pu8RxPacket The received packet
1888 * @param[in] s32RxPacketLen Length of the received packet
1889 * @return Error code indicating success/failure
1890 * @note
1891 *
1892 * @author mabubakr
1893 * @date 1 Mar 2012
1894 * @version 1.0
1895 */
1896
1897 s32 ConfigPktReceived(u8 *pu8RxPacket, s32 s32RxPacketLen)
1898 {
1899 s32 s32Error = WILC_SUCCESS;
1900 u8 u8MsgType = 0;
1901
1902 u8MsgType = pu8RxPacket[0];
1903
1904 switch (u8MsgType) {
1905 case 'R':
1906 ConfigProvideResponse(pu8RxPacket, s32RxPacketLen);
1907
1908 break;
1909
1910 case 'N':
1911 PRINT_INFO(CORECONFIG_DBG, "NetworkInfo packet received\n");
1912 NetworkInfoReceived(pu8RxPacket, s32RxPacketLen);
1913 break;
1914
1915 case 'I':
1916 GnrlAsyncInfoReceived(pu8RxPacket, s32RxPacketLen);
1917 break;
1918
1919 case 'S':
1920 host_int_ScanCompleteReceived(pu8RxPacket, s32RxPacketLen);
1921 break;
1922
1923 default:
1924 PRINT_ER("ConfigPktReceived(): invalid received msg type at the Core Configurator\n");
1925 break;
1926 }
1927
1928 return s32Error;
1929 }
1930
1931 /**
1932 * @brief Deinitializes the Core Configurator
1933 * @details
1934 * @return Error code indicating success/failure
1935 * @note
1936 * @author mabubakr
1937 * @date 1 Mar 2012
1938 * @version 1.0
1939 */
1940
1941 s32 CoreConfiguratorDeInit(void)
1942 {
1943 s32 s32Error = WILC_SUCCESS;
1944
1945 PRINT_D(CORECONFIG_DBG, "CoreConfiguratorDeInit()\n");
1946
1947
1948 return s32Error;
1949 }
1950
1951 /*Using the global handle of the driver*/
1952 extern wilc_wlan_oup_t *gpstrWlanOps;
1953 /**
1954 * @brief sends certain Configuration Packet based on the input WIDs pstrWIDs
1955 * using driver config layer
1956 *
1957 * @details
1958 * @param[in] pstrWIDs WIDs to be sent in the configuration packet
1959 * @param[in] u32WIDsCount number of WIDs to be sent in the configuration packet
1960 * @param[out] pu8RxResp The received Packet Response
1961 * @param[out] ps32RxRespLen Length of the received Packet Response
1962 * @return Error code indicating success/failure
1963 * @note
1964 * @author mabubakr
1965 * @date 1 Mar 2012
1966 * @version 1.0
1967 */
1968 s32 SendConfigPkt(u8 u8Mode, tstrWID *pstrWIDs,
1969 u32 u32WIDsCount, bool bRespRequired, u32 drvHandler)
1970 {
1971 s32 counter = 0, ret = 0;
1972 if (gpstrWlanOps == NULL) {
1973 PRINT_D(CORECONFIG_DBG, "Net Dev is still not initialized\n");
1974 return 1;
1975 } else {
1976 PRINT_D(CORECONFIG_DBG, "Net Dev is initialized\n");
1977 }
1978 if (gpstrWlanOps->wlan_cfg_set == NULL ||
1979 gpstrWlanOps->wlan_cfg_get == NULL) {
1980 PRINT_D(CORECONFIG_DBG, "Set and Get is still not initialized\n");
1981 return 1;
1982 } else {
1983 PRINT_D(CORECONFIG_DBG, "SET is initialized\n");
1984 }
1985 if (u8Mode == GET_CFG) {
1986 for (counter = 0; counter < u32WIDsCount; counter++) {
1987 PRINT_INFO(CORECONFIG_DBG, "Sending CFG packet [%d][%d]\n", !counter,
1988 (counter == u32WIDsCount - 1));
1989 if (!gpstrWlanOps->wlan_cfg_get(!counter,
1990 pstrWIDs[counter].u16WIDid,
1991 (counter == u32WIDsCount - 1), drvHandler)) {
1992 ret = -1;
1993 printk("[Sendconfigpkt]Get Timed out\n");
1994 break;
1995 }
1996 }
1997 /**
1998 * get the value
1999 **/
2000 counter = 0;
2001 for (counter = 0; counter < u32WIDsCount; counter++) {
2002 pstrWIDs[counter].s32ValueSize = gpstrWlanOps->wlan_cfg_get_value(
2003 pstrWIDs[counter].u16WIDid,
2004 pstrWIDs[counter].ps8WidVal, pstrWIDs[counter].s32ValueSize);
2005
2006 }
2007 } else if (u8Mode == SET_CFG) {
2008 for (counter = 0; counter < u32WIDsCount; counter++) {
2009 PRINT_D(CORECONFIG_DBG, "Sending config SET PACKET WID:%x\n", pstrWIDs[counter].u16WIDid);
2010 if (!gpstrWlanOps->wlan_cfg_set(!counter,
2011 pstrWIDs[counter].u16WIDid, pstrWIDs[counter].ps8WidVal,
2012 pstrWIDs[counter].s32ValueSize,
2013 (counter == u32WIDsCount - 1), drvHandler)) {
2014 ret = -1;
2015 printk("[Sendconfigpkt]Set Timed out\n");
2016 break;
2017 }
2018 }
2019 }
2020
2021 return ret;
2022 }
Linux kernel - Deliverables
This page took 0.073951 seconds and 6 git commands to generate.