?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Clear the whole structure instead the size of a pointer
[wave300.git] / wireless / driver / linux / mtlk_df_user.c
blobf7b51096cf33791d8c3665b5af13ad2fc43143c2
1 /******************************************************************************
2
3 Copyright (c) 2012
4 Lantiq Deutschland GmbH
5
6 For licensing information, see the file 'LICENSE' in the root folder of
7 this software module.
8
9 ******************************************************************************/
10 /*
11 * $Id$
12 *
13 *
14 *
15 * Driver framework implementation for Linux
16 *
17 */
18
19 #include "mtlkinc.h"
20 #include "mtlk_clipboard.h"
21 #include "mtlk_coreui.h"
22 #include "mtlk_df_priv.h"
23 #include "core.h"
24 #include "mtlk_snprintf.h"
25 #include "wpa.h"
26 #include "mtlk_df.h"
27 #include "mtlk_df_nbuf.h"
28
29 #include <linux/wireless.h>
30 #include <linux/if_arp.h>
31 #include <net/iw_handler.h>
32 #include <asm/unaligned.h>
33
34 #ifdef MTLK_HAVE_PPA
35 #if defined(CONFIG_IFX_PPA_API_DIRECTPATH)
36 /* UGW 5.4 and older */
37 #include <net/ifx_ppa_api.h>
38 #include <net/ifx_ppa_hook.h>
39 #include <switch_api/ifx_ethsw_kernel_api.h>
40 #include <switch_api/ifx_ethsw_api.h>
41
42 #define PPA_SUCCESS IFX_SUCCESS
43 #define LTQ_ETHSW_API_HANDLE IFX_ETHSW_HANDLE
44 #define ltq_ethsw_api_kopen(x) ifx_ethsw_kopen(x)
45 #define ltq_ethsw_api_kioctl(x, y, z) ifx_ethsw_kioctl(x, y, z)
46 #define ltq_ethsw_api_kclose(x) ifx_ethsw_kclose(x)
47 #elif defined(CONFIG_LTQ_PPA_API_DIRECTPATH)
48 /* UGW 6.1 and newer */
49 #include <net/ppa_api.h>
50 #include <net/ppa_hook.h>
51 #include <asm/mach-lantiq/xway/switch-api/lantiq_ethsw_api.h>
52 #else
53 #error Invalid PPA configuration
54 #endif
55 #endif /* MTLK_HAVE_PPA */
56
57 #include "dataex.h"
58 #ifdef MTCFG_IRB_DEBUG
59 #include "mtlk_irb_pinger.h"
60 #endif
61
62 #include "mtlkaux.h"
63 #include "mtlkwlanirbdefs.h"
64
65 #include "mtlk_ps.h"
66
67 #define LOG_LOCAL_GID GID_DFUSER
68 #define LOG_LOCAL_FID 1
69
70 #define _DF_STAT_POLL_PERIOD (125)
71 #define _DF_RTS_THRESHOLD_MIN 100
72 #define _DF_WAIT_FW_ASSERT 2000
73
74 #define DF_USER_DEFAULT_IWPRIV_LIM_VALUE (-1)
75
76 #define MTLK_NIP6(addr) \
77 ntohs((addr).s6_addr16[0]), \
78 ntohs((addr).s6_addr16[1]), \
79 ntohs((addr).s6_addr16[2]), \
80 ntohs((addr).s6_addr16[3]), \
81 ntohs((addr).s6_addr16[4]), \
82 ntohs((addr).s6_addr16[5]), \
83 ntohs((addr).s6_addr16[6]), \
84 ntohs((addr).s6_addr16[7])
85
86 #define MTLK_NIP6_FMT "%04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x"
87
88 #define MTLK_NIPQUAD(addr) \
89 ((unsigned char *)&addr)[0], \
90 ((unsigned char *)&addr)[1], \
91 ((unsigned char *)&addr)[2], \
92 ((unsigned char *)&addr)[3]
93
94 #define MTLK_NIPQUAD_FMT "%u.%u.%u.%u"
95
96 static const IEEE_ADDR EMPTY_MAC_MASK = { {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF} };
97
98
99 /********************************************************************
100 * IW driver IOCTL descriptor table
101 ********************************************************************/
102 extern const struct iw_handler_def mtlk_linux_handler_def;
103
104
105 /*
106 * These magic numbers we got from WEB team.
107 * Should be replaced by meaningful protocol names.
108 */
109 enum {
110 NETWORK_MODE_11AN = 14,
111 NETWORK_MODE_11A = 10,
112 NETWORK_MODE_11N5 = 12,
113 NETWORK_MODE_11BGN = 23,
114 NETWORK_MODE_11BG = 19,
115 NETWORK_MODE_11B = 17,
116 NETWORK_MODE_11G = 18,
117 NETWORK_MODE_11N2 = 20,
118 NETWORK_MODE_11GN = 22,
119 NETWORK_MODE_11ABGN = 30,
120 NETWORK_MODE_11ABG = 0,
121 };
122
123 #define MAX_DF_UI_STAT_NAME_LENGTH 256
124 #define UM_DATA_BASE 0x80000000
125 #define UM_DATA_SIZE 0x0003fd00
126 #define AHBUM_DATA_BASE 0x80000000
127 #define AHBUM_DATA_SIZE 0x00100000
128 #define LM_DATA_BASE 0x80080000
129 #define LM_DATA_SIZE 0x00018000
130 #define SHRAM_DATA_BASE 0xa6000000
131 #define SHRAM_DATA_SIZE 0x00020000
132
133 /* slow context of DF user */
134 struct _mtlk_df_ui_slow_ctx_t
135 {
136 /* Core status & statistic */
137 mtlk_core_general_stats_t core_general_stats;
138
139 struct iw_statistics iw_stats;
140 /* Network device statistics */
141 struct net_device_stats linux_stats;
142
143 /**** BCL data *****/
144 uint32 *dbg_general_pkt_cnts;
145 uint32 dbg_general_pkt_cnts_num;
146 IEEE_ADDR *dbg_general_pkt_addr;
147 uint32 dbg_general_pkt_addr_num;
148 uint32 *dbg_rr_cnts;
149 uint32 dbg_rr_cnts_num;
150 IEEE_ADDR *dbg_rr_addr;
151 uint32 dbg_rr_addr_num;
152 /*******************/
153
154 mtlk_osal_timer_t stat_timer;
155
156 mtlk_df_proc_fs_node_t *proc_df_node;
157 mtlk_df_proc_fs_node_t *proc_df_debug_node;
158
159 #ifdef MTCFG_IRB_DEBUG
160 mtlk_irb_pinger_t pinger;
161 #endif
162 };
163
164 #ifdef MTLK_HAVE_PPA
165 typedef struct _mtlk_df_user_ppa_stats_t
166 {
167 uint32 tx_processed;
168 uint32 rx_accepted;
169 uint32 rx_rejected;
170 } mtlk_df_user_ppa_stats_t;
171
172 typedef struct _mtlk_df_user_ppa_t
173 {
174 PPA_DIRECTPATH_CB clb;
175 uint32 if_id;
176 mtlk_df_user_ppa_stats_t stats;
177 volatile BOOL is_active; /** store internal PPA registration state. */
178 } mtlk_df_user_ppa_t;
179 #endif /* MTLK_HAVE_PPA */
180
181 struct _mtlk_df_user_t
182 {
183 struct _mtlk_df_t *df;
184 struct net_device *dev;
185
186 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,29)
187 struct net_device_ops dev_ops;
188 #endif
189
190 struct _mtlk_df_ui_slow_ctx_t *slow_ctx;
191
192 #ifdef MTLK_HAVE_PPA
193 mtlk_df_user_ppa_t ppa;
194 #endif
195 mtlk_osal_event_t fw_hang_evts[NUM_OF_MIPS];
196
197
198 MTLK_DECLARE_INIT_LOOP(FW_HANG_EVTs);
199 MTLK_DECLARE_INIT_LOOP(PROC_INIT);
200 MTLK_DECLARE_INIT_LOOP(PROC_CARD_INIT);
201 MTLK_DECLARE_INIT_STATUS;
202 MTLK_DECLARE_START_STATUS;
203 };
204
205 /********************************************************************
206 * Tools API definitions
207 ********************************************************************/
208 static uint8 __MTLK_IFUNC
209 _net_mode_ingress_filter (uint8 ingress_net_mode);
210 static uint8 __MTLK_IFUNC
211 _net_mode_egress_filter (uint8 egress_net_mode);
212
213 static void
214 mtlk_df_debug_bcl_cleanup(mtlk_df_user_t *df_user);
215 static int
216 mtlk_df_debug_bcl_init(mtlk_df_user_t *df_user);
217
218 /*****************************************************************************
219 *****************************************************************************/
220 static int
221 _mtlk_df_user_fill_ether_address(IEEE_ADDR *mac_addr, struct sockaddr *sa);
222
223 /*****************************************************************************
224 **
225 ** NAME mtlk_df_traffic_classifier_register / mtlk_df_traffic_classifier_unregister
226 **
227 ** DESCRIPTION This functions are used for registration of External Metalink's
228 ** traffic classifier module
229 **
230 ******************************************************************************/
231 int mtlk_df_traffic_classifier_register(void * classify_fn);
232 void mtlk_df_traffic_classifier_unregister(void);
233 EXPORT_SYMBOL(mtlk_df_traffic_classifier_register);
234 EXPORT_SYMBOL(mtlk_df_traffic_classifier_unregister);
235
236 int mtlk_df_traffic_classifier_register (void * classify_fn)
237 {
238 mtlk_qos_classifier_register((mtlk_qos_do_classify_f)classify_fn);
239 return 0; /*mtlk_err_to_linux_err(res)*/
240 }
241
242
243 void mtlk_df_traffic_classifier_unregister (void)
244 {
245 mtlk_qos_classifier_unregister();
246 }
247
248 /*****************************************************************************
249 *****************************************************************************/
250 static __INLINE uint32
251 _mtlk_df_user_get_core_slave_vap_index_by_iwpriv_param (uint32 iwpriv_slave_vap_index)
252 {
253 /* DF iwpriv commands use 0-based VAP index for Slave VAPs, while Core
254 * uses 0-based numeration for *all* the VAPs, including the Master.
255 * This function translates the DFs Slave VAP Index to a Cores one.
256 */
257 return (iwpriv_slave_vap_index + 1);
258 }
259
260 static int
261 _mtlk_df_mtlk_to_linux_error_code(int mtlk_res)
262 {
263 int linux_res;
264
265 switch (mtlk_res) {
266
267 case MTLK_ERR_OK:
268 linux_res = 0;
269 break;
270
271 case MTLK_ERR_PARAMS:
272 case MTLK_ERR_VALUE:
273 linux_res = -EINVAL;
274 break;
275
276 case MTLK_ERR_NO_MEM:
277 linux_res = -ENOMEM;
278 break;
279
280 case MTLK_ERR_PENDING:
281 linux_res = -EINPROGRESS;
282 break;
283
284 case MTLK_ERR_BUSY:
285 linux_res = -EBUSY;
286 break;
287
288 case MTLK_ERR_EEPROM:
289 case MTLK_ERR_HW:
290 case MTLK_ERR_FW:
291 case MTLK_ERR_UMI:
292 case MTLK_ERR_MAC:
293 linux_res = -EFAULT;
294 break;
295
296 case MTLK_ERR_TIMEOUT:
297 linux_res = -ETIME;
298 break;
299
300 case MTLK_ERR_NOT_READY:
301 linux_res = -EAGAIN;
302 break;
303
304 case MTLK_ERR_NOT_SUPPORTED:
305 linux_res = -EOPNOTSUPP;
306 break;
307
308 case MTLK_ERR_NOT_IN_USE:
309 case MTLK_ERR_NO_RESOURCES:
310 case MTLK_ERR_WRONG_CONTEXT:
311 case MTLK_ERR_SCAN_FAILED:
312 case MTLK_ERR_AOCS_FAILED:
313 case MTLK_ERR_PROHIB:
314 case MTLK_ERR_BUF_TOO_SMALL:
315 case MTLK_ERR_PKT_DROPPED:
316 case MTLK_ERR_FILEOP:
317 case MTLK_ERR_CANCELED:
318 case MTLK_ERR_NOT_HANDLED:
319 case MTLK_ERR_UNKNOWN:
320 linux_res = -EFAULT;
321 break;
322
323 case MTLK_ERR_DATA_TOO_BIG:
324 linux_res = -E2BIG;
325 break;
326
327 default :
328 linux_res = -EFAULT;
329 break;
330 }
331
332 return linux_res;
333 }
334
335 /* User-friendly interface/device name */
336 const char*
337 mtlk_df_user_get_name(mtlk_df_user_t *df_user)
338 {
339 MTLK_ASSERT(NULL != df_user);
340 return df_user->dev->name;
341 }
342
343 const uint32
344 mtlk_df_user_get_flags(mtlk_df_user_t *df_user)
345 {
346 MTLK_ASSERT(NULL != df_user);
347 MTLK_ASSERT(NULL != df_user->dev);
348
349 return df_user->dev->flags;
350 }
351
352 int
353 mtlk_df_user_set_flags(mtlk_df_user_t *df_user, uint32 newflags)
354 {
355 int res = MTLK_ERR_OK;
356 MTLK_ASSERT(NULL != df_user);
357 MTLK_ASSERT(NULL != df_user->dev);
358
359 rtnl_lock();
360 res = dev_change_flags(df_user->dev, newflags);
361 rtnl_unlock();
362
363 return res;
364 }
365
366 /* Layer-2 subsystem access */
367 void __MTLK_IFUNC
368 mtlk_df_ui_set_mac_addr(mtlk_df_t *df, const uint8* mac_addr)
369 {
370 MTLK_ASSERT(NULL != df);
371 MTLK_ASSERT(NULL != mac_addr);
372
373 mtlk_osal_copy_eth_addresses(mtlk_df_get_user(df)->dev->dev_addr, mac_addr);
374 }
375
376 const uint8* __MTLK_IFUNC
377 mtlk_df_ui_get_mac_addr(mtlk_df_t* df)
378 {
379 MTLK_ASSERT(NULL != df);
380
381 return mtlk_df_get_user(df)->dev->dev_addr;
382 }
383
384 BOOL __MTLK_IFUNC
385 mtlk_df_ui_is_promiscuous(mtlk_df_t *df)
386 {
387 MTLK_ASSERT(NULL != df);
388 return mtlk_df_get_user(df)->dev->promiscuity ? TRUE : FALSE;
389 }
390
391 void __MTLK_IFUNC
392 mtlk_df_ui_notify_tx_start(mtlk_df_t *df)
393 {
394 MTLK_ASSERT(NULL != df);
395 mtlk_df_get_user(df)->dev->trans_start = jiffies;
396 }
397
398 MTLK_INIT_STEPS_LIST_BEGIN(df_user)
399 MTLK_INIT_STEPS_LIST_ENTRY(df_user, ALLOC_SLOW_CTX)
400 MTLK_INIT_STEPS_LIST_ENTRY(df_user, DEBUG_BCL)
401 MTLK_INIT_STEPS_LIST_ENTRY(df_user, ALLOC_NAME)
402 MTLK_INIT_STEPS_LIST_ENTRY(df_user, CREATE_CARD_DIR)
403 MTLK_INIT_STEPS_LIST_ENTRY(df_user, CREATE_DEBUG_DIR)
404 MTLK_INIT_STEPS_LIST_ENTRY(df_user, STAT_TIMER)
405 #ifdef MTCFG_IRB_DEBUG
406 MTLK_INIT_STEPS_LIST_ENTRY(df_user, IRB_PINGER_INIT)
407 #endif
408 MTLK_INIT_STEPS_LIST_ENTRY(df_user, PROC_INIT)
409 MTLK_INIT_STEPS_LIST_ENTRY(df_user, PROC_CARD_INIT)
410 MTLK_INIT_STEPS_LIST_ENTRY(df_user, FW_HANG_EVTs)
411 MTLK_INIT_INNER_STEPS_BEGIN(df_user)
412 MTLK_INIT_STEPS_LIST_END(df_user);
413
414 static int
415 _mtlk_df_user_start_tx(struct sk_buff *skb, struct net_device *dev)
416 {
417 mtlk_df_user_t* df_user = (mtlk_df_user_t*) netdev_priv(skb->dev);
418
419 MTLK_UNREFERENCED_PARAM(dev);
420 MTLK_ASSERT(NULL != skb);
421 MTLK_ASSERT(NULL != df_user);
422
423 mtlk_nbuf_priv_init(mtlk_nbuf_priv(skb));
424
425 mtlk_nbuf_start_tracking(skb);
426 mtlk_core_handle_tx_data(mtlk_df_get_vap_handle(df_user->df), skb);
427 return NETDEV_TX_OK;
428 }
429
430 /********************************************************************
431 * PPA supprting functionality BEGIN
432 ********************************************************************/
433 #ifdef MTLK_HAVE_PPA
434
435 uint32 _mtlk_df_user_ppa_tx_sent_up = 0;
436 uint32 _mtlk_df_user_ppa_tx_dropped = 0;
437
438 static int
439 _mtlk_df_user_ppa_start_xmit (struct net_device *rx_dev,
440 struct net_device *tx_dev,
441 struct sk_buff *skb,
442 int len)
443
444 {
445 if (tx_dev != NULL) {
446 mtlk_df_user_t* df_user = (mtlk_df_user_t*) netdev_priv(skb->dev);
447
448 ++df_user->ppa.stats.tx_processed;
449
450 skb->dev = tx_dev;
451 _mtlk_df_user_start_tx(skb, tx_dev);
452 }
453 else if (rx_dev != NULL)
454 {
455 MTLK_ASSERT(NULL != skb->dev);
456 /* as usual shift the eth header with skb->data */
457 skb->protocol = eth_type_trans(skb, skb->dev);
458 /* push up to protocol stacks */
459 netif_rx(skb);
460 ++_mtlk_df_user_ppa_tx_sent_up;
461 }
462 else {
463 dev_kfree_skb_any(skb);
464 ++_mtlk_df_user_ppa_tx_dropped;
465 }
466
467 return 0;
468 }
469
470 BOOL __MTLK_IFUNC
471 _mtlk_df_user_ppa_is_available (void)
472 {
473 return (ppa_hook_directpath_register_dev_fn != NULL);
474 }
475
476 BOOL __MTLK_IFUNC
477 _mtlk_df_user_ppa_is_registered (mtlk_df_user_t* df_user)
478 {
479 MTLK_ASSERT(df_user != NULL);
480
481 return (NULL != df_user->ppa.clb.rx_fn);
482 }
483
484 int __MTLK_IFUNC
485 _mtlk_df_user_ppa_register (mtlk_df_user_t* df_user)
486 {
487 int res = MTLK_ERR_UNKNOWN;
488 uint32 ppa_res;
489
490 MTLK_ASSERT(df_user != NULL);
491 MTLK_ASSERT(_mtlk_df_user_ppa_is_registered(df_user) == FALSE);
492
493 if (_mtlk_df_user_ppa_is_available() == FALSE) {
494 res = MTLK_ERR_NOT_SUPPORTED;
495 goto end;
496 }
497
498 memset(&df_user->ppa.clb, 0, sizeof(df_user->ppa.clb));
499
500 df_user->ppa.clb.rx_fn = _mtlk_df_user_ppa_start_xmit;
501
502 ppa_res =
503 ppa_hook_directpath_register_dev_fn(&df_user->ppa.if_id,
504 df_user->dev, &df_user->ppa.clb,
505 PPA_F_DIRECTPATH_REGISTER | PPA_F_DIRECTPATH_ETH_IF);
506
507 if (ppa_res != PPA_SUCCESS)
508 {
509 df_user->ppa.clb.rx_fn = NULL;
510 ELOG_D("Can't register PPA device function (err=%d)", ppa_res);
511 res = MTLK_ERR_UNKNOWN;
512 goto end;
513 }
514
515 /* At this point we can send packets via PPA */
516 df_user->ppa.is_active = TRUE;
517
518 ILOG0_D("PPA device function is registered (id=%d)", df_user->ppa.if_id);
519 res = MTLK_ERR_OK;
520
521 end:
522 return res;
523 }
524
525 void __MTLK_IFUNC
526 _mtlk_df_user_ppa_unregister (mtlk_df_user_t* df_user)
527 {
528 uint32 ppa_res;
529
530 MTLK_ASSERT(df_user != NULL);
531 MTLK_ASSERT(_mtlk_df_user_ppa_is_registered(df_user) == TRUE);
532
533 /* Stop sending packets before unregistration */
534 df_user->ppa.is_active = FALSE;
535
536 ppa_res =
537 ppa_hook_directpath_register_dev_fn(&df_user->ppa.if_id,
538 df_user->dev, NULL,
539 0/*PPA_F_DIRECTPATH_DEREGISTER*/);
540
541
542 if (ppa_res == PPA_SUCCESS) {
543 ILOG0_D("PPA device function is unregistered (id=%d)", df_user->ppa.if_id);
544 df_user->ppa.clb.rx_fn = NULL;
545 df_user->ppa.if_id = 0;
546 }
547 else {
548 ELOG_D("Can't unregister PPA device function (err=%d)", ppa_res);
549
550 /** \tocheck: PPA should not return error during unregistration.
551 * The PPA error have no sense for us during that state.
552 * Anyway we trying to keep the right internal state. */
553 df_user->ppa.is_active = TRUE;
554 }
555 }
556
557 void __MTLK_IFUNC
558 _mtlk_df_user_ppa_get_stats (mtlk_df_user_t* df_user,
559 mtlk_df_user_ppa_stats_t *stats)
560 {
561 MTLK_ASSERT(df_user != NULL);
562 MTLK_ASSERT(stats != NULL);
563
564 memcpy(stats, &df_user->ppa.stats, sizeof(df_user->ppa.stats));
565 }
566
567 void __MTLK_IFUNC
568 _mtlk_df_user_ppa_zero_stats (mtlk_df_user_t* df_user)
569 {
570 MTLK_ASSERT(df_user != NULL);
571 memset(&df_user->ppa.stats, 0, sizeof(df_user->ppa.stats));
572 }
573 #endif /* MTLK_HAVE_PPA */
574
575
576 static void
577 _mtlk_df_priv_xface_start (mtlk_df_user_t* df_user)
578 {
579 #ifdef MTLK_HAVE_PPA
580 _mtlk_df_user_ppa_register(df_user);
581 #endif /* MTLK_HAVE_PPA */
582 }
583
584 static void
585 _mtlk_df_priv_xface_stop (mtlk_df_user_t* df_user)
586 {
587 #ifdef MTLK_HAVE_PPA
588 if (_mtlk_df_user_ppa_is_registered(df_user)) {
589 _mtlk_df_user_ppa_unregister(df_user);
590 }
591 #endif /* MTLK_HAVE_PPA */
592 }
593
594 /********************************************************************
595 * PPA supprting functionality END
596 ********************************************************************/
597
598 static int
599 _mtlk_df_user_iface_open(struct net_device *dev)
600 {
601 mtlk_df_user_t* df_user = (mtlk_df_user_t*) netdev_priv(dev);
602 mtlk_clpb_t *clpb = NULL;
603 int res;
604
605 MTLK_ASSERT(NULL != df_user);
606
607 res = _mtlk_df_user_invoke_core(df_user->df, MTLK_CORE_REQ_ACTIVATE_OPEN, &clpb, NULL, 0);
608 res = _mtlk_df_user_process_core_retval(res, clpb, MTLK_CORE_REQ_ACTIVATE_OPEN, TRUE);
609
610 return (MTLK_ERR_OK == res) ? 0 : -EAGAIN;
611 }
612
613 static int
614 _mtlk_df_user_iface_stop(struct net_device *dev)
615 {
616 mtlk_df_user_t* df_user = (mtlk_df_user_t*) netdev_priv(dev);
617 mtlk_clpb_t *clpb = NULL;
618 int res;
619
620 MTLK_ASSERT(NULL != df_user);
621
622 ILOG1_S("%s: stop the interface", mtlk_df_user_get_name(df_user));
623
624 /*
625 The following loop was implemented since the OS might not
626 interpret an -EAGAIN error code correctly and hence will not
627 repeat calling _mtlk_df_user_iface_stop - in case retry is
628 needed.
629 */
630
631 do {
632 res = _mtlk_df_user_invoke_core(df_user->df, MTLK_CORE_REQ_DEACTIVATE, &clpb, NULL, 0);
633 res = _mtlk_df_user_process_core_retval(res, clpb, MTLK_CORE_REQ_DEACTIVATE, TRUE);
634 mtlk_osal_msleep(100);
635 } while ((MTLK_ERR_OK != res) && (MTLK_ERR_FW != res));
636
637 return 0;
638 }
639
640 int __MTLK_IFUNC
641 mtlk_df_ui_linux_ioctl_setap (struct net_device *dev,
642 struct iw_request_info *info,
643 struct sockaddr *sa,
644 char *extra)
645 {
646 mtlk_df_user_t* df_user = (mtlk_df_user_t*) netdev_priv(dev);
647 mtlk_clpb_t *clpb = NULL;
648 int res = MTLK_ERR_NOT_SUPPORTED;
649
650 ILOG3_SSD("%s: Invoked from %s (%i)", dev->name, current->comm, current->pid);
651
652 if (!netif_running(dev)) {
653 ILOG0_V("You should bring interface up first");
654 goto finish;
655 }
656
657 if (is_broadcast_ether_addr(sa->sa_data)) goto finish;
658
659 if (is_zero_ether_addr(sa->sa_data)) {
660 res = MTLK_ERR_OK;
661 goto finish;
662 }
663
664 ILOG1_SY("%s: Handle request: connect to %Y", dev->name, sa->sa_data);
665
666 res = _mtlk_df_user_invoke_core(df_user->df, MTLK_CORE_REQ_CONNECT_STA,
667 &clpb, &sa->sa_data, sizeof(sa->sa_data));
668 res = _mtlk_df_user_process_core_retval_void(res, clpb, MTLK_CORE_REQ_CONNECT_STA, TRUE);
669
670 finish:
671 return _mtlk_df_mtlk_to_linux_error_code(res);
672 }
673
674 int __MTLK_IFUNC
675 mtlk_df_ui_linux_ioctl_setmlme (struct net_device *dev,
676 struct iw_request_info *info,
677 struct iw_point *data,
678 char *extra)
679 {
680 int res = MTLK_ERR_NOT_SUPPORTED;
681 mtlk_df_user_t* df_user = (mtlk_df_user_t*) netdev_priv(dev);
682 mtlk_clpb_t *clpb = NULL;
683 struct iw_mlme *mlme = (struct iw_mlme *) extra;
684 mtlk_core_ui_mlme_cfg_t mlme_cfg;
685
686 ILOG3_SSD("%s: Invoked from %s (%i)", dev->name, current->comm, current->pid);
687
688 if (NULL == mlme) {
689 res = MTLK_ERR_PARAMS;
690 goto finish;
691 }
692
693 if (!netif_running(dev)) {
694 if(mtlk_osal_eth_is_broadcast(mlme->addr.sa_data)){
695 if((mlme->cmd == IW_MLME_DEAUTH) || (mlme->cmd == IW_MLME_DISASSOC)){
696 res = MTLK_ERR_OK;
697 goto finish;
698 }
699 }
700
701 ILOG0_V("You should bring interface up first");
702 goto finish;
703 }
704
705 memset(&mlme_cfg, 0, sizeof(mlme_cfg));
706
707 mlme_cfg.cmd = mlme->cmd;
708 mlme_cfg.reason_code = mlme->reason_code;
709 res = _mtlk_df_user_fill_ether_address(&mlme_cfg.sta_addr, &mlme->addr);
710 if (MTLK_ERR_OK != res) {
711 WLOG_SY("%s: Invalid address (%Y)", dev->name, mlme->addr.sa_data);
712 goto finish;
713 }
714
715 ILOG2_DD("MLME cmd %i reason_code %i", mlme->cmd, mlme->reason_code);
716
717 switch (mlme->cmd) {
718 case IW_MLME_DEAUTH:
719 case IW_MLME_DISASSOC:
720 ILOG1_SY("%s: Got MLME Disconnect/Disassociate ioctl (%Y)", dev->name, mlme->addr.sa_data);
721 if (!mtlk_df_is_ap(df_user->df)) {
722 res = _mtlk_df_user_invoke_core(df_user->df, MTLK_CORE_REQ_DISCONNECT_STA,
723 &clpb, (char*)&mlme_cfg, sizeof(mlme_cfg));
724 res = _mtlk_df_user_process_core_retval_void(res, clpb, MTLK_CORE_REQ_DISCONNECT_STA, TRUE);
725 }
726 else if(mtlk_osal_eth_is_broadcast(mlme->addr.sa_data)) {
727 res = _mtlk_df_user_invoke_core(df_user->df, MTLK_CORE_REQ_AP_DISCONNECT_ALL,
728 &clpb, (char*)&mlme_cfg, sizeof(mlme_cfg));
729 res = _mtlk_df_user_process_core_retval_void(res, clpb, MTLK_CORE_REQ_AP_DISCONNECT_ALL, TRUE);
730 }
731 else if(!mtlk_osal_is_valid_ether_addr(mlme->addr.sa_data)) {
732 ILOG1_SY("%s: Invalid MAC address (%Y)!", dev->name, mlme->addr.sa_data);
733 res = MTLK_ERR_PARAMS;
734 goto finish;
735 }
736 else {
737 res = _mtlk_df_user_invoke_core(df_user->df, MTLK_CORE_REQ_AP_DISCONNECT_STA,
738 &clpb, (char*)&mlme_cfg, sizeof(mlme_cfg));
739 res = _mtlk_df_user_process_core_retval_void(res, clpb, MTLK_CORE_REQ_AP_DISCONNECT_STA, TRUE);
740 }
741 break;
742 default:
743 res = MTLK_ERR_NOT_SUPPORTED;
744 goto finish;
745 }
746
747
748 finish:
749 return _mtlk_df_mtlk_to_linux_error_code(res);
750 }
751
752 /*!
753 \fn mtlk_df_ui_linux_ioctl_set_scan()
754 \param net_device Network device for scan to be performed on
755 \param extra Scan options (if any) starting from WE18
756 \return Zero on success, negative error code on failure
757 \brief Handle 'start scan' request
758
759 Handler for SIOCSIWSCAN - request for scan schedule. Process scan
760 options (if any), and schedule scan. If scan already running - return
761 zero, to avoid 'setscan-getscan' infinite loops in user applications.
762 If scheduling succeed - return zero. If scan can't be started - return
763 -EAGAIN
764 */
765 int __MTLK_IFUNC
766 mtlk_df_ui_linux_ioctl_set_scan (struct net_device *dev,
767 struct iw_request_info *info,
768 union iwreq_data *wrqu,
769 char *extra)
770 {
771 int res = MTLK_ERR_NOT_SUPPORTED;
772 mtlk_df_user_t* df_user = (mtlk_df_user_t*) netdev_priv(dev);
773 mtlk_clpb_t *clpb = NULL;
774 char *essid = NULL;
775 size_t essid_size = 0;
776
777 ILOG3_SSD("%s: Invoked from %s (%i)", dev->name, current->comm, current->pid);
778
779 #if WIRELESS_EXT >= 18
780 /* iwlist wlan0 scan <ESSID> */
781 if (extra && wrqu->data.pointer) {
782 struct iw_scan_req *scanopt = (struct iw_scan_req*)extra;
783 if (wrqu->data.flags & IW_SCAN_THIS_ESSID) {
784 ILOG2_SS("%s: Set ESSID pattern to (%s)", dev->name, scanopt->essid);
785 essid = scanopt->essid;
786 essid_size = sizeof(scanopt->essid);
787 }
788 }
789 #endif
790
791 res = _mtlk_df_user_invoke_core(df_user->df, MTLK_CORE_REQ_START_SCANNING,
792 &clpb, essid, essid_size);
793 res = _mtlk_df_user_process_core_retval_void(res, clpb, MTLK_CORE_REQ_START_SCANNING, TRUE);
794
795 return _mtlk_df_mtlk_to_linux_error_code(res);
796 }
797
798 static uint8
799 _mtlk_df_ui_calc_signal_strength(int8 RSSI)
800 {
801 uint8 sig_strength = 1;
802
803 if (RSSI > -65)
804 sig_strength = 5;
805 else if (RSSI > -71)
806 sig_strength = 4;
807 else if (RSSI > -77)
808 sig_strength = 3;
809 else if (RSSI > -83)
810 sig_strength = 2;
811
812 return sig_strength;
813 }
814
815 /*!
816 \fn mtlk_df_ui_linux_ioctl_get_scan_results()
817 \return Zero and scan results on success, negative error code on failure
818 \brief Handle 'get scan results' request
819
820 Handler for SIOCGIWSCAN - request for scan results. If scan running -
821 return -EAGAIN and required buffer size. If not enough memory to store
822 all scan results - return -E2BIG. On success return zero and cached
823 scan results
824 */
825 int __MTLK_IFUNC
826 mtlk_df_ui_linux_ioctl_get_scan_results (struct net_device *dev,
827 struct iw_request_info *info,
828 union iwreq_data *wrqu,
829 char *extra)
830 {
831 int res = MTLK_ERR_NOT_SUPPORTED;
832 mtlk_df_user_t *df_user = (mtlk_df_user_t*) netdev_priv(dev);
833 mtlk_clpb_t *clpb = NULL;
834
835 bss_data_t *bss_found;
836 struct iw_event iwe;
837 char *stream;
838 char *border;
839 size_t size;
840 char *work_str;
841 char buf[32]; /* used for 3 RSSI string: "-xxx:-xxx:-xxx dBm" */
842
843 ILOG3_SSD("%s: Invoked from %s (%i)", dev->name, current->comm, current->pid);
844
845 res = _mtlk_df_user_invoke_core(df_user->df, MTLK_CORE_REQ_GET_SCANNING_RES,
846 &clpb, NULL, 0);
847 res = _mtlk_df_user_process_core_retval_void(res, clpb, MTLK_CORE_REQ_GET_SCANNING_RES, FALSE);
848 if (MTLK_ERR_OK != res) {
849 goto finish;
850 }
851
852 memset(extra, 0, wrqu->data.length);
853 stream = extra;
854 border = extra + wrqu->data.length;
855 size = 0;
856
857 /* Process scanning results */
858 while(NULL != (bss_found = mtlk_clpb_enum_get_next(clpb, NULL))) {
859
860 ILOG1_SYD("\"%-32s\" %Y %3i", bss_found->essid, bss_found->bssid, bss_found->channel);
861
862 iwe.cmd = SIOCGIWAP;
863 memcpy(iwe.u.ap_addr.sa_data, bss_found->bssid, ETH_ALEN);
864 iwe.u.ap_addr.sa_family = ARPHRD_IEEE80211;
865 size += IW_EV_ADDR_LEN;
866 stream = mtlk_iwe_stream_add_event(info, stream, border, &iwe, IW_EV_ADDR_LEN);
867
868 iwe.cmd = SIOCGIWESSID;
869 iwe.u.data.length = strnlen(bss_found->essid, IW_ESSID_MAX_SIZE);
870 iwe.u.data.flags = 1;
871 size += IW_EV_POINT_LEN + iwe.u.data.length;
872 stream = mtlk_iwe_stream_add_point(info, stream, border, &iwe, bss_found->essid);
873
874 iwe.cmd = SIOCGIWFREQ;
875 iwe.u.freq.m = bss_found->channel;
876 iwe.u.freq.e = 0;
877 size += IW_EV_FREQ_LEN;
878 stream = mtlk_iwe_stream_add_event(info, stream, border, &iwe, IW_EV_FREQ_LEN);
879
880 if (RSN_IE_SIZE(bss_found)) {
881 iwe.cmd = IWEVGENIE;
882 iwe.u.data.length = RSN_IE_SIZE(bss_found) + sizeof(ie_t);
883 size += IW_EV_POINT_LEN + iwe.u.data.length;
884 stream = mtlk_iwe_stream_add_point(info, stream, border, &iwe, RSN_IE(bss_found));
885 }
886
887 if (WPA_IE_SIZE(bss_found)) {
888 iwe.cmd = IWEVGENIE;
889 iwe.u.data.length = WPA_IE_SIZE(bss_found) + sizeof(ie_t);
890 size += IW_EV_POINT_LEN + iwe.u.data.length;
891 stream = mtlk_iwe_stream_add_point(info, stream, border, &iwe, WPA_IE(bss_found));
892 }
893
894 if (WPS_IE_SIZE(bss_found)) {
895 iwe.cmd = IWEVGENIE;
896 iwe.u.data.length = WPS_IE_SIZE(bss_found) + sizeof(ie_t);
897 size += IW_EV_POINT_LEN + iwe.u.data.length;
898 stream = mtlk_iwe_stream_add_point(info, stream, border, &iwe, WPS_IE(bss_found));
899 }
900
901 iwe.cmd = SIOCGIWENCODE;
902 iwe.u.data.flags = BSS_IS_WEP_ENABLED(bss_found)? IW_ENCODE_ENABLED:IW_ENCODE_DISABLED;
903 iwe.u.data.length = 0;
904 size += IW_EV_POINT_LEN;
905 stream = mtlk_iwe_stream_add_point(info, stream, border, &iwe, NULL);
906
907 iwe.cmd = IWEVQUAL;
908 iwe.u.qual.updated = IW_QUAL_ALL_UPDATED | IW_QUAL_DBM;
909 iwe.u.qual.qual = _mtlk_df_ui_calc_signal_strength(MTLK_NORMALIZED_RSSI(bss_found->max_rssi));
910 iwe.u.qual.level = bss_found->max_rssi;
911 iwe.u.qual.noise = bss_found->noise;
912 size += IW_EV_QUAL_LEN;
913 stream = mtlk_iwe_stream_add_event(info, stream, border, &iwe, IW_EV_QUAL_LEN);
914
915 iwe.cmd = IWEVCUSTOM;
916 work_str = (bss_found->is_2_4)? "2.4 band":"5.2 band";
917 iwe.u.data.length = strlen(work_str);
918 size += IW_EV_POINT_LEN + iwe.u.data.length;
919 stream = mtlk_iwe_stream_add_point(info, stream, border, &iwe, work_str);
920
921 iwe.cmd = IWEVCUSTOM;
922 work_str = (bss_found->is_ht)? "HT":"not HT";
923 iwe.u.data.length = strlen(work_str);
924 size += IW_EV_POINT_LEN + iwe.u.data.length;
925 stream = mtlk_iwe_stream_add_point(info, stream, border, &iwe, work_str);
926
927 iwe.cmd = IWEVCUSTOM;
928 work_str = (bss_found->spectrum == SPECTRUM_40MHZ)? "40 MHz":"20 MHz";
929 iwe.u.data.length = strlen(work_str);
930 size += IW_EV_POINT_LEN + iwe.u.data.length;
931 stream = mtlk_iwe_stream_add_point(info, stream, border, &iwe, work_str);
932
933 iwe.cmd = IWEVCUSTOM;
934 work_str = WPS_IE_FOUND(bss_found)? "WPS":"not WPS";
935 iwe.u.data.length = strlen(work_str);
936 size += IW_EV_POINT_LEN + iwe.u.data.length;
937 stream = mtlk_iwe_stream_add_point(info, stream, border, &iwe, work_str);
938
939 iwe.cmd = IWEVCUSTOM;
940 sprintf(buf, "%d:%d:%d dBm",
941 MTLK_NORMALIZED_RSSI(bss_found->all_rssi[0]),
942 MTLK_NORMALIZED_RSSI(bss_found->all_rssi[1]),
943 MTLK_NORMALIZED_RSSI(bss_found->all_rssi[2]));
944 work_str = buf;
945 iwe.u.data.length = strlen(work_str);
946 size += IW_EV_POINT_LEN + iwe.u.data.length;
947 stream = mtlk_iwe_stream_add_point(info, stream, border, &iwe, work_str);
948 }
949
950 wrqu->data.length = size;
951 if (stream - extra < size) {
952 ILOG1_S("%s: Can't get scan results - buffer is not big enough", dev->name);
953 res = MTLK_ERR_DATA_TOO_BIG;
954 }
955
956 mtlk_clpb_delete(clpb);
957 finish:
958 return _mtlk_df_mtlk_to_linux_error_code(res);
959 }
960
961
962 static int
963 _mtlk_df_user_set_mac_addr_internal (struct net_device *dev,
964 struct sockaddr *addr)
965 {
966 mtlk_df_user_t* df_user = (mtlk_df_user_t*) netdev_priv(dev);
967 mtlk_clpb_t *clpb = NULL;
968 int res = MTLK_ERR_BUSY;
969
970 MTLK_ASSERT(NULL != df_user);
971
972 /* Allow to set MAC address only if !IFF_UP */
973 if (dev->flags & IFF_UP) {
974 WLOG_S("%s: Can't set MAC address with IFF_UP set", dev->name);
975 goto finish;
976 }
977
978 /* Validate address family */
979 if ((addr->sa_family != ARPHRD_IEEE80211) && (addr->sa_family != ARPHRD_ETHER)) {
980 WLOG_S("%s: Can't set MAC address - invalid sa_family", dev->name);
981 res = MTLK_ERR_PARAMS;
982 goto finish;
983 }
984
985 res = _mtlk_df_user_invoke_core(df_user->df, MTLK_CORE_REQ_SET_MAC_ADDR,
986 &clpb, addr->sa_data, sizeof(addr->sa_data));
987 res = _mtlk_df_user_process_core_retval_void(res, clpb, MTLK_CORE_REQ_SET_MAC_ADDR, TRUE);
988
989 if(MTLK_ERR_OK == res)
990 {
991 mtlk_osal_copy_eth_addresses(dev->dev_addr, addr->sa_data);
992 }
993
994 finish:
995 return _mtlk_df_mtlk_to_linux_error_code(res);
996 }
997
998 static int
999 _mtlk_df_user_set_mac_addr (struct net_device *dev, void* p)
1000 {
1001 return _mtlk_df_user_set_mac_addr_internal(dev, (struct sockaddr *)p);
1002 }
1003
1004 int __MTLK_IFUNC
1005 mtlk_df_ui_linux_ioctl_set_mac_addr (struct net_device *dev,
1006 struct iw_request_info *info,
1007 union iwreq_data *wrqu,
1008 char *extra)
1009 {
1010 return _mtlk_df_user_set_mac_addr_internal(dev, &wrqu->addr);
1011 }
1012
1013 int __MTLK_IFUNC
1014 mtlk_df_ui_linux_ioctl_get_mac_addr (struct net_device *dev,
1015 struct iw_request_info *info,
1016 union iwreq_data *wrqu,
1017 char *extra)
1018 {
1019 mtlk_df_user_t *df_user = (mtlk_df_user_t*)netdev_priv(dev);
1020 mtlk_clpb_t *clpb;
1021 int res = MTLK_ERR_PARAMS;
1022 res = _mtlk_df_user_invoke_core(df_user->df, MTLK_CORE_REQ_GET_MAC_ADDR,
1023 &clpb, NULL, 0);
1024 res = _mtlk_df_user_process_core_retval_void(res, clpb, MTLK_CORE_REQ_GET_MAC_ADDR, FALSE);
1025 if(MTLK_ERR_OK == res)
1026 {
1027 int mac_addr_size;
1028 void* mac_addr = mtlk_clpb_enum_get_next(clpb, &mac_addr_size);
1029 MTLK_ASSERT(ETH_ALEN == mac_addr_size);
1030
1031 mtlk_osal_copy_eth_addresses(wrqu->addr.sa_data, mac_addr);
1032 wrqu->addr.sa_family = ARPHRD_IEEE80211;
1033
1034 mtlk_clpb_delete(clpb);
1035 }
1036
1037 return _mtlk_df_mtlk_to_linux_error_code(res);
1038 }
1039
1040 #define _DF_USER_GET_PARAM_MAP_START(df_user, param_id_var, int_res) \
1041 { \
1042 uint32 __get_param_macro_mix_guard__ = 0; \
1043 uint32 __req_data_length_in_map; \
1044 mtlk_df_user_t* __df_user_in_map = df_user; \
1045 int* __result_in_map = &int_res; \
1046 mtlk_handle_t __hreq_data_in_map = MTLK_INVALID_HANDLE; \
1047 *__result_in_map = MTLK_ERR_UNKNOWN; \
1048 switch(param_id_var) { \
1049 default: { { \
1050 MTLK_ASSERT(!"Unknown parameter id in get request"); \
1051 {
1052
1053 #define _DF_USER_GET_PARAM_MAP_END() \
1054 } \
1055 } \
1056 if(MTLK_INVALID_HANDLE != __hreq_data_in_map) \
1057 { \
1058 _mtlk_df_user_free_core_data(__df_user_in_map->df, __hreq_data_in_map); \
1059 } \
1060 } \
1061 } \
1062 MTLK_UNREFERENCED_PARAM(__get_param_macro_mix_guard__); \
1063 }
1064
1065 #define _DF_USER_GET_ON_PARAM(param_id, core_req_id, is_void_request, cfg_struct_type, cfg_struct_name) \
1066 } \
1067 } \
1068 if(MTLK_INVALID_HANDLE != __hreq_data_in_map) \
1069 { \
1070 _mtlk_df_user_free_core_data(__df_user_in_map->df, __hreq_data_in_map); \
1071 } \
1072 MTLK_UNREFERENCED_PARAM(__get_param_macro_mix_guard__); \
1073 break; \
1074 } \
1075 case (param_id): { \
1076 cfg_struct_type *cfg_struct_name; \
1077 *__result_in_map = _mtlk_df_user_pull_core_data(__df_user_in_map->df, (core_req_id), (is_void_request), (void**) &cfg_struct_name, &__req_data_length_in_map, &__hreq_data_in_map); \
1078 if(MTLK_ERR_OK == *__result_in_map) \
1079 { \
1080 MTLK_ASSERT(sizeof(cfg_struct_type) == __req_data_length_in_map); \
1081 {
1082
1083 #define _DF_USER_SET_PARAM_MAP_START(df_user, param_id_var, int_res) \
1084 { \
1085 uint32 __set_param_macro_mix_guard__ = 0; \
1086 mtlk_df_user_t* __df_user_in_map = df_user; \
1087 int* __result_in_map = &int_res; \
1088 void* __core_data_in_map = NULL; \
1089 uint32 __core_data_size_in_map = 0; \
1090 uint32 __core_req_id_in_map = 0; \
1091 uint32 __is_void_request_in_map = FALSE; \
1092 *__result_in_map = MTLK_ERR_OK; \
1093 switch(param_id_var) { \
1094 default: { \
1095 { \
1096 MTLK_ASSERT(!"Unknown parameter id in set request");
1097
1098 #define _DF_USER_SET_PARAM_MAP_END() \
1099 } \
1100 if((NULL != __core_data_in_map))\
1101 { \
1102 if(MTLK_ERR_OK == *__result_in_map) { \
1103 *__result_in_map = _mtlk_df_user_push_core_data(__df_user_in_map->df, __core_req_id_in_map, __is_void_request_in_map, __core_data_in_map, __core_data_size_in_map); \
1104 } else { \
1105 mtlk_osal_mem_free(__core_data_in_map); \
1106 } \
1107 } \
1108 } \
1109 } \
1110 MTLK_UNREFERENCED_PARAM(__set_param_macro_mix_guard__); \
1111 }
1112
1113 #define _DF_USER_SET_ON_PARAM(param_id, core_req_id, is_void_request, cfg_struct_type, cfg_struct_name) \
1114 } \
1115 if((NULL != __core_data_in_map))\
1116 { \
1117 if(MTLK_ERR_OK == *__result_in_map) { \
1118 *__result_in_map = _mtlk_df_user_push_core_data(__df_user_in_map->df, __core_req_id_in_map, __is_void_request_in_map, __core_data_in_map, __core_data_size_in_map); \
1119 } else { \
1120 mtlk_osal_mem_free(__core_data_in_map); \
1121 } \
1122 } \
1123 } \
1124 MTLK_UNREFERENCED_PARAM(__set_param_macro_mix_guard__); \
1125 break; \
1126 case (param_id): { \
1127 cfg_struct_type *cfg_struct_name = _mtlk_df_user_alloc_core_data(__df_user_in_map->df, sizeof(cfg_struct_type)); \
1128 __core_data_size_in_map = sizeof(cfg_struct_type); \
1129 __core_data_in_map = cfg_struct_name; \
1130 __core_req_id_in_map = core_req_id; \
1131 __is_void_request_in_map = is_void_request; \
1132 if(NULL == __core_data_in_map) { \
1133 *__result_in_map = MTLK_ERR_NO_MEM; \
1134 } else {
1135
1136 static int
1137 _mtlk_df_user_print_msdu_ac(char *buffer, size_t len, mtlk_aocs_ac_t *ac)
1138 {
1139 return mtlk_snprintf(buffer, len,
1140 "\nBE %d BK %d VI %d VO %d",
1141 ac->ac[AC_BE], ac->ac[AC_BK],
1142 ac->ac[AC_VI], ac->ac[AC_VO]);
1143 }
1144
1145 static int
1146 _mtlk_df_user_print_restricted_ch(char *buffer, size_t len, uint8 *restricted_channels)
1147 {
1148 uint32 i, length=0;
1149
1150 length += mtlk_snprintf(buffer+length, len-length, "\n");
1151 for (i=0; i<MAX_CHANNELS; i++) {
1152 if (MTLK_CHANNEL_NOT_USED == restricted_channels[i]) {
1153 break;
1154 }
1155 length += mtlk_snprintf(buffer+length, len-length, "%d ", restricted_channels[i]);
1156 }
1157
1158 if (length ==0) {
1159 /* no retricted channels */
1160 length = mtlk_snprintf(buffer, len, "\nAll channels allowed");
1161 }
1162
1163 return (int) length;
1164 }
1165
1166 static BOOL
1167 _mtlk_df_user_get_ac_by_name (char *buffer, uint8 *ac)
1168 {
1169 int i;
1170 BOOL found = FALSE;
1171 static const char *aocs_msdu_ac_name[NTS_PRIORITIES] = {"BE", "BK", "VI", "VO"};
1172
1173 for (i = 0; i < NTS_PRIORITIES; i++)
1174 if (!strcmp(buffer, aocs_msdu_ac_name[i])) {
1175 found = TRUE;
1176 *ac = i;
1177 break;
1178 }
1179 return found;
1180 }
1181
1182 static int
1183 _mtlk_df_user_fill_ac_values(char *buffer, mtlk_aocs_ac_t *ac)
1184 {
1185 char buf[16];
1186 char *next_token;
1187 uint8 ac_num;
1188 int v, result = MTLK_ERR_OK;
1189
1190 if (buffer[0] == '\0') {
1191 goto FINISH;
1192 }
1193
1194 for (v = 0; v < NTS_PRIORITIES; v++) {
1195 ac->ac[v] = AC_NOT_USED;
1196 }
1197
1198 next_token = mtlk_get_token(buffer, buf, ARRAY_SIZE(buf), ' ');
1199
1200 if (!(next_token || (buf[0] != '\0'))) {
1201 result = MTLK_ERR_UNKNOWN;
1202 goto FINISH;
1203 }
1204
1205 while (next_token || (buf[0] != '\0')) {
1206
1207 /* here comes AC */
1208 ILOG4_S("ac_num = %s", buf);
1209 if (!_mtlk_df_user_get_ac_by_name(buf, &ac_num)) {
1210 ELOG_S("Wrong access category %s", buf);
1211 result = MTLK_ERR_UNKNOWN;
1212 goto FINISH;
1213 }
1214
1215 /* here comes the value */
1216 next_token = mtlk_get_token(next_token, buf, ARRAY_SIZE(buf), ' ');
1217 if (buf[0] == '\0') {
1218 ELOG_V("Value is missed");
1219 result = MTLK_ERR_UNKNOWN;
1220 goto FINISH;
1221 }
1222
1223 ILOG4_S("value %s", buf);
1224 v = mtlk_osal_str_atol(buf);
1225 if (0 == v) {
1226 ac->ac[ac_num] = AC_DISABLED;
1227 }
1228 else if (1 == v) {
1229 ac->ac[ac_num] = AC_ENABLED;
1230 }
1231 else {
1232 ELOG_V("Wrong value for ac");
1233 result = MTLK_ERR_UNKNOWN;
1234 goto FINISH;
1235 }
1236 next_token = mtlk_get_token(next_token, buf, ARRAY_SIZE(buf), ' ');
1237 }
1238
1239 FINISH:
1240 return result;
1241 }
1242
1243 static int
1244 _mtlk_df_user_fill_restricted_ch(char *buffer, uint8 *out_chnl)
1245 {
1246 uint16 channel;
1247 const uint8 max_channel_num = (uint8)-1;
1248 char buf[8];
1249 char *next_token;
1250 uint32 i=0;
1251
1252 memset(out_chnl,(uint8)MTLK_CHANNEL_NOT_USED,MAX_CHANNELS);
1253 if (buffer[0] == '\0') {
1254 /* reset restricted channels */
1255 ILOG4_V("Reset restricted channels - allow all");
1256 }
1257 else {
1258 next_token = mtlk_get_token(buffer, buf, ARRAY_SIZE(buf), ' ');
1259 while (next_token || (buf[0] != '\0')) {
1260 channel = mtlk_osal_str_atol(buf);
1261 if (channel > max_channel_num) {
1262 return MTLK_ERR_UNKNOWN;
1263 }
1264
1265 out_chnl[i] = channel;
1266
1267 /* find next channel */
1268 next_token = mtlk_get_token(next_token, buf, ARRAY_SIZE(buf), ' ');
1269 if (MAX_CHANNELS == ++i) {
1270 break;
1271 }
1272 }
1273 }
1274 return MTLK_ERR_OK;
1275 }
1276
1277 /*
1278 Parse string data for DELBA request
1279
1280 \param delba_req - pointer to storage of DELBA configuration
1281 \param data - string representation of DELBA configuration
1282
1283 \return
1284 MTLK_ERR_PARAMS - incorrect format detected in string configuration
1285 MTLK_ERR_OK - success
1286
1287 \remark
1288 available data format:
1289 "<MAC> <TID>" - send DELBA request for special TID
1290 "<MAC>" - send DELBA request for all TIDs
1291 */
1292 static int
1293 _mtlk_df_user_fill_delba_req(char const *data, mtlk_delba_req_t *delba_req)
1294 {
1295 if (NULL == data)
1296 return MTLK_ERR_PARAMS;
1297
1298 if (MTLK_ERR_OK != mtlk_str_to_mac(data, delba_req->sDA.au8Addr))
1299 {
1300 ELOG_V("Wrong value for MAC");
1301 return MTLK_ERR_PARAMS;
1302 }
1303
1304 data = strchr(data, ' ');
1305
1306 if (NULL != data)
1307 {
1308 delba_req->tid = mtlk_osal_str_atol(data);
1309
1310 if ((delba_req->tid < 0) && (delba_req->tid >= NTS_TIDS))
1311 {
1312 ELOG_D("Wrong value for tid [%d]", delba_req->tid);
1313 return MTLK_ERR_PARAMS;
1314 }
1315 }
1316 else
1317 {
1318 delba_req->tid = -1;
1319 }
1320
1321 return MTLK_ERR_OK;
1322 }
1323
1324 static int
1325 _mtlk_df_user_fill_ether_address(IEEE_ADDR *mac_addr, struct sockaddr *sa)
1326 {
1327 if (sa->sa_family != ARPHRD_ETHER) {
1328 return MTLK_ERR_PARAMS;
1329 }
1330
1331 MTLK_ASSERT(ETH_ALEN == IEEE_ADDR_LEN);
1332 memcpy(mac_addr->au8Addr, sa->sa_data, ETH_ALEN);
1333
1334 return MTLK_ERR_OK;
1335 }
1336
1337 static int
1338 _mtlk_df_user_translate_network_mode(uint8 df_network_more, uint8 *core_network_mode)
1339 {
1340 *core_network_mode = _net_mode_ingress_filter(df_network_more);
1341 return (*core_network_mode != NETWORK_NONE) ? MTLK_ERR_OK : MTLK_ERR_PARAMS;
1342 }
1343
1344 static int
1345 _mtlk_df_user_parse_bitrate_str(const char *rate,
1346 mtlk_core_rate_cfg_t *rate_cfg)
1347 {
1348 int tmp_int;
1349 int tmp_fractional;
1350
1351 /*
1352 * Check whether requested value is bare index or mpbs.
1353 * We can distinguish with sscanf() return value (number of tokens read)
1354 */
1355 if (2 == sscanf(rate, "%i.%i", &tmp_int, &tmp_fractional)) {
1356 MTLK_CFG_SET_ITEM(rate_cfg, int_rate, tmp_int)
1357 MTLK_CFG_SET_ITEM(rate_cfg, frac_rate, tmp_fractional)
1358 }
1359 else if ((1 == sscanf(rate, "%i", &tmp_int))) {
1360 MTLK_CFG_SET_ITEM(rate_cfg, array_idx, (uint16)tmp_int)
1361 }
1362 else if (!strcmp(rate, "auto")) {
1363 MTLK_CFG_SET_ITEM(rate_cfg, int_rate, MTLK_CORE_BITRATE_AUTO)
1364 MTLK_CFG_SET_ITEM(rate_cfg, frac_rate, MTLK_CORE_BITRATE_AUTO)
1365 }
1366 else {
1367 return MTLK_ERR_PARAMS;
1368 }
1369 return MTLK_ERR_OK;
1370 }
1371
1372 static int
1373 _mtlk_df_user_bitrate_to_str(mtlk_core_rate_cfg_t *rate_cfg,
1374 char *res,
1375 uint32 length)
1376 {
1377 if ((MTLK_CORE_BITRATE_AUTO == rate_cfg->int_rate) &&
1378 (MTLK_CORE_BITRATE_AUTO == rate_cfg->frac_rate)) {
1379 snprintf(res, length, "auto");
1380 }
1381 else {
1382 snprintf(res, length, "%i.%i mbps", rate_cfg->int_rate, rate_cfg->frac_rate);
1383 }
1384 return MTLK_ERR_OK;
1385 }
1386
1387 static int
1388 _mtlk_df_user_countries_supported_to_str(mtlk_gen_core_country_name_t *country,
1389 char *res,
1390 int32 length)
1391 {
1392 uint32 i;
1393 int32 printed_len = 0;
1394
1395 for(i=0; i<MAX_COUNTRIES; i++) {
1396 /* stop if no more countries left */
1397 /* we got a zero-filled memory here */
1398 if(0 == *country[i].name) {
1399 break;
1400 }
1401
1402 /* no more iwpriv buffer left */
1403 if((length-printed_len) < 0) {
1404 break;
1405 }
1406
1407 /* newline each 8 elements */
1408 if(0 == i%8) {
1409 printed_len += snprintf(res+printed_len, length-printed_len, "\n");
1410 }
1411
1412 printed_len += snprintf(res+printed_len, length-printed_len, "%s ", country[i].name);
1413 }
1414 return MTLK_ERR_OK;
1415 }
1416
1417 static int
1418 _mtlk_df_user_fill_hw_cfg(mtlk_hw_cfg_t *cfg, char *str)
1419 {
1420 char buf[30];
1421 char *next_token = str;
1422 int res = MTLK_ERR_PARAMS;
1423
1424 memset(cfg, 0, sizeof(*cfg));
1425
1426 next_token = mtlk_get_token(next_token, buf, sizeof(buf), ',');
1427 if (next_token) {
1428 strncpy(cfg->buf, buf, sizeof(cfg->buf)-1);
1429 } else goto end;
1430
1431 next_token = mtlk_get_token(next_token, buf, sizeof(buf), ',');
1432 if (next_token) {
1433 cfg->field_01 = (uint16)mtlk_osal_str_atol(buf);
1434 } else goto end;
1435
1436 next_token = mtlk_get_token(next_token, buf, sizeof(buf), ',');
1437 if (next_token) {
1438 cfg->field_02 = mtlk_osal_str_atol(buf);
1439 } else goto end;
1440
1441 mtlk_get_token(next_token, buf, sizeof(buf), ',');
1442 cfg->field_03 = (int16)mtlk_osal_str_atol(buf);
1443
1444 res = MTLK_ERR_OK;
1445
1446 end:
1447 return res;
1448 }
1449
1450 static int
1451 _mtlk_df_user_fill_ant_cfg(mtlk_ant_cfg_t *cfg, char *str)
1452 {
1453 char buf[30];
1454 char *next_token = str;
1455 int res = MTLK_ERR_PARAMS;
1456
1457 next_token = mtlk_get_token(next_token, buf, sizeof(buf), ',');
1458 if (next_token) {
1459 cfg->field_01 = mtlk_osal_str_atol(buf);
1460 } else goto end;
1461
1462 mtlk_get_token(next_token, buf, sizeof(buf), ',');
1463 cfg->field_02 = mtlk_osal_str_atol(buf);
1464
1465 res = MTLK_ERR_OK;
1466
1467 end:
1468 return res;
1469 }
1470
1471 static int
1472 _mtlk_df_user_fill_power_limit_cfg_by_int_vec(mtlk_tx_power_limit_cfg_t *cfg, uint16 intvec_length, int32 *intvec)
1473 {
1474 int res = MTLK_ERR_PARAMS;
1475
1476 memset(cfg, 0, sizeof(mtlk_tx_power_limit_cfg_t));
1477
1478 if (intvec_length != 3) {
1479 ELOG_V("Incorrect number of input values. Expected [11B boost] [BPSK boost] [auto-response boost]");
1480 return res;
1481 }
1482
1483 if ((intvec[0] < MIN_INT8) || (intvec[0] > MAX_INT8) || (intvec[1] < MIN_INT8) ||
1484 (intvec[1] > MAX_INT8) || (intvec[2] < MIN_INT8) || (intvec[2] > MAX_INT8)) {
1485
1486 ELOG_V("Incorrect input value");
1487 return res;
1488 }
1489
1490 cfg->field_01 = intvec[0];
1491 cfg->field_02 = intvec[1];
1492 cfg->field_03 = intvec[2];
1493
1494 return MTLK_ERR_OK;
1495 }
1496
1497 static int
1498 _mtlk_df_user_fill_peer_ap_key_idx (uint8 *peer_ap_key_idx, uint32 data)
1499 {
1500
1501 if (data > MIB_WEP_N_DEFAULT_KEYS)
1502 {
1503 ELOG_DD("Wrong key index %d. Usage: <[1-%d]|0> (0 means Open)", data, MIB_WEP_N_DEFAULT_KEYS);
1504 return MTLK_ERR_VALUE;
1505 }
1506
1507 *peer_ap_key_idx = (uint8)data;
1508
1509 return MTLK_ERR_OK;
1510 }
1511
1512 static uint32
1513 _mtlk_df_user_print_eeprom(mtlk_eeprom_data_cfg_t *eeprom, char *buffer, uint32 buf_len)
1514 {
1515 uint8 *buf;
1516 uint32 used_len = 0;
1517 uint32 max_len = MTLK_MAX_EEPROM_SIZE;
1518
1519 buf = mtlk_osal_mem_alloc(max_len, MTLK_MEM_TAG_EEPROM);
1520
1521 if (NULL == buf) {
1522 goto nomem;
1523 }
1524
1525 memset(buf, 0, max_len);
1526
1527 used_len += mtlk_snprintf(buf+used_len, max_len-used_len,
1528 "\nEEPROM version: %i.%i\n", eeprom->eeprom_version/0x100, eeprom->eeprom_version%0x100);
1529 MTLK_ASSERT(used_len < max_len);
1530
1531 used_len += mtlk_snprintf(buf+used_len, max_len-used_len,
1532 "EEPROM MAC : " MAC_PRINTF_FMT "\n", MAC_PRINTF_ARG(eeprom->mac_address));
1533 MTLK_ASSERT(used_len < max_len);
1534
1535 used_len += mtlk_snprintf(buf+used_len, max_len-used_len,
1536 "EEPROM country: %s\n", country_code_to_country(eeprom->country_code));
1537 MTLK_ASSERT(used_len < max_len);
1538
1539 used_len += mtlk_snprintf(buf+used_len, max_len-used_len,
1540 "HW type : 0x%02X\n", eeprom->type);
1541 MTLK_ASSERT(used_len < max_len);
1542
1543 used_len += mtlk_snprintf(buf+used_len, max_len-used_len,
1544 "HW revision : 0x%02X (%c)\n", eeprom->revision, eeprom->revision);
1545 MTLK_ASSERT(used_len < max_len);
1546
1547 used_len += mtlk_snprintf(buf+used_len, max_len-used_len, "HW ID : 0x%x,0x%x,0x%x,0x%x\n",
1548 eeprom->vendor_id, eeprom->device_id,
1549 eeprom->sub_vendor_id, eeprom->sub_device_id);
1550 MTLK_ASSERT(used_len < max_len);
1551
1552 used_len += mtlk_snprintf(buf+used_len, max_len-used_len, "Serial number : %02x%02x%02x\n",
1553 eeprom->sn[2], eeprom->sn[1], eeprom->sn[0]);
1554 MTLK_ASSERT(used_len < max_len);
1555
1556 used_len += mtlk_snprintf(buf+used_len, max_len-used_len, "Week/Year : %02d/%02d\n",
1557 eeprom->production_week, eeprom->production_year);
1558 MTLK_ASSERT(used_len < max_len);
1559 MTLK_ASSERT(strlen(buf) == used_len);
1560
1561 if (used_len <= buf_len) {
1562 strncpy(buffer, buf, used_len);
1563 }
1564 else {
1565 used_len = 0;
1566 }
1567
1568 mtlk_osal_mem_free(buf);
1569 nomem:
1570 return used_len;
1571 }
1572
1573 static uint32
1574 _mtlk_df_user_print_raw_eeprom(uint8 *raw_eeprom, uint32 size_raw_eeprom, char *buffer, uint32 buf_len)
1575 {
1576 uint8 *buf;
1577 uint32 used_len = 0;
1578 uint32 max_len = MTLK_MAX_EEPROM_SIZE;
1579
1580 MTLK_ASSERT(max_len <= buf_len);
1581 MTLK_UNREFERENCED_PARAM(size_raw_eeprom);
1582
1583 buf = mtlk_osal_mem_alloc(max_len, MTLK_MEM_TAG_EEPROM);
1584 if (NULL == buf) {
1585 goto nomem;
1586 }
1587
1588 memset(buf, 0, max_len);
1589
1590 used_len += mtlk_snprintf(buf+used_len, max_len-used_len, "\nEEPROM header binary dump:\n");
1591 MTLK_ASSERT(used_len < max_len);
1592
1593 MTLK_ASSERT(size_raw_eeprom >= mtlk_eeprom_get_size());
1594 MTLK_ASSERT((max_len-used_len) >= mtlk_eeprom_get_size());
1595 used_len += mtlk_shexdump(buf+used_len, raw_eeprom, mtlk_eeprom_get_size());
1596
1597 if (used_len <= buf_len) {
1598 strncpy(buffer, buf, used_len);
1599 }
1600 else {
1601 used_len = 0;
1602 }
1603
1604 mtlk_osal_mem_free(buf);
1605 nomem:
1606 return used_len;
1607 }
1608
1609 #ifdef MTCFG_IRB_DEBUG
1610
1611 static uint32
1612 _mtlk_df_user_print_irb_pinger_stats(char *buf, uint32 len, struct mtlk_irb_pinger_stats *stats)
1613 {
1614 uint64 avg_delay = 0;
1615
1616 if (stats->nof_recvd_pongs) {
1617 /* NOTE: 64-bit division is not supported by default in linux kernel space =>
1618 * we should use the do_div() ASM macro here.
1619 */
1620 avg_delay = stats->all_delay;
1621 do_div(avg_delay, stats->nof_recvd_pongs); /* the result is stored in avg_delay */
1622 }
1623
1624 return mtlk_snprintf(buf, len, "NofPongs=%u NofMissed=%u NofOOO=%u AllDly=%llu AvgDly=%llu PeakDly=%llu\n",
1625 stats->nof_recvd_pongs,
1626 stats->nof_missed_pongs,
1627 stats->nof_ooo_pongs,
1628 stats->all_delay,
1629 avg_delay,
1630 stats->peak_delay);
1631 }
1632
1633 static int __MTLK_IFUNC
1634 _mtlk_df_user_irb_pinger_int_get_cfg(mtlk_df_user_t* df_user, uint32 subcmd, char* data, uint16* length)
1635 {
1636 struct mtlk_irb_pinger_stats stats;
1637
1638 switch (subcmd) {
1639 case PRM_ID_IRB_PINGER_ENABLED:
1640 *(uint32*)data = mtlk_irb_pinger_get_ping_period_ms(&df_user->slow_ctx->pinger);
1641 return MTLK_ERR_OK;
1642 case PRM_ID_IRB_PINGER_STATS:
1643 mtlk_irb_pinger_get_stats(&df_user->slow_ctx->pinger, &stats);
1644 *length = _mtlk_df_user_print_irb_pinger_stats(data, TEXT_SIZE, &stats);
1645 return MTLK_ERR_OK;
1646 default:
1647 return MTLK_ERR_NOT_HANDLED;
1648 }
1649 }
1650
1651 static int __MTLK_IFUNC
1652 _mtlk_df_user_irb_pinger_int_set_cfg(mtlk_df_user_t* df_user, uint32 subcmd, char* data, uint16* length)
1653 {
1654 switch (subcmd) {
1655 case PRM_ID_IRB_PINGER_ENABLED:
1656 return mtlk_irb_pinger_restart(&df_user->slow_ctx->pinger, *(uint32*)data);
1657 case PRM_ID_IRB_PINGER_STATS:
1658 mtlk_irb_pinger_zero_stats(&df_user->slow_ctx->pinger);
1659 return MTLK_ERR_OK;
1660 default:
1661 return MTLK_ERR_NOT_HANDLED;
1662 }
1663 }
1664
1665 #endif /* MTCFG_IRB_DEBUG */
1666
1667 #ifdef MTLK_HAVE_PPA
1668 static int __MTLK_IFUNC
1669 _mtlk_df_user_ppa_directpath_int_get_cfg(mtlk_df_user_t* df_user, uint32 subcmd, char* data, uint16* length)
1670 {
1671 if(PRM_ID_PPA_API_DIRECTPATH == subcmd) {
1672 if (!_mtlk_df_user_ppa_is_available()) {
1673 return MTLK_ERR_NOT_SUPPORTED;
1674 } else {
1675 *(uint32*)data = _mtlk_df_user_ppa_is_registered(df_user);
1676 return MTLK_ERR_OK;
1677 }
1678 } else {
1679 return MTLK_ERR_NOT_HANDLED;
1680 }
1681 }
1682
1683 static int __MTLK_IFUNC
1684 _mtlk_df_user_ppa_directpath_int_set_cfg(mtlk_df_user_t* df_user, uint32 subcmd, char* data, uint16* length)
1685 {
1686 uint32 value = *(uint32*)data;
1687
1688 if (PRM_ID_PPA_API_DIRECTPATH == subcmd) {
1689 if (!_mtlk_df_user_ppa_is_available()) {
1690 return MTLK_ERR_NOT_SUPPORTED;
1691 } else if (!value && _mtlk_df_user_ppa_is_registered(df_user)) {
1692 _mtlk_df_user_ppa_unregister(df_user);
1693 return MTLK_ERR_OK;
1694 } else if (value && !_mtlk_df_user_ppa_is_registered(df_user)) {
1695 return _mtlk_df_user_ppa_register(df_user);
1696 } else {
1697 return MTLK_ERR_OK;
1698 }
1699 } else {
1700 return MTLK_ERR_NOT_HANDLED;
1701 }
1702 }
1703 #endif
1704
1705 #ifdef MTCFG_USE_GENL
1706 /* Exported by mtlkroot */
1707 extern int mtlk_genl_family_id;
1708
1709 static int __MTLK_IFUNC
1710 _mtlk_df_user_genl_int_get_cfg(mtlk_df_user_t* df_user, uint32 subcmd, char* data, uint16* length)
1711 {
1712 if(PRM_ID_GENL_FAMILY_ID == subcmd) {
1713 *(uint32*)data = mtlk_genl_family_id;
1714 return MTLK_ERR_OK;
1715 } else {
1716 return MTLK_ERR_NOT_HANDLED;
1717 }
1718 }
1719 #endif
1720
1721 static void
1722 _mtlk_df_set_vap_limits_cfg (mtlk_mbss_cfg_t *mbss_cfg, uint32 low, uint32 up)
1723 {
1724 mbss_cfg->vap_limits.lower_limit = low;
1725 mbss_cfg->vap_limits.upper_limit = up;
1726 }
1727
1728 static void
1729 _mtlk_df_get_vap_limits_cfg (mtlk_mbss_cfg_t *mbss_cfg, uint32 *low, uint32 *up)
1730 {
1731 *low = mbss_cfg->vap_limits.lower_limit;
1732 *up = mbss_cfg->vap_limits.upper_limit;
1733 }
1734
1735 static int
1736 _mtlk_df_user_get_interfdet_req_scantimes_by_intvec (const uint32 *intvec, uint16 intvec_length, mtlk_interfdet_req_scantimes_t *req_params)
1737 {
1738 int res = MTLK_ERR_OK;
1739 int i;
1740
1741 if (2 != intvec_length) {
1742 ELOG_D("Incorrect vector length. length(%u), expected 2", intvec_length);
1743 res = MTLK_ERR_PARAMS;
1744 } else for (i = 0; i < 2; i++) {
1745 if ((int32)intvec[i] < 0) {
1746 ELOG_DD("Incorrect parameter %d (%d)", i, intvec[i]);
1747 res = MTLK_ERR_PARAMS;
1748 break;
1749 }
1750 }
1751
1752 if (MTLK_ERR_PARAMS == res) {
1753 ELOG_V("Expected parameters: <short_scan_max_time> <long_scan_max_time>");
1754 return res;
1755 }
1756
1757 req_params->short_scan_max_time = intvec[0];
1758 req_params->long_scan_max_time = intvec[1];
1759 return res;
1760 }
1761
1762 static int
1763 _mtlk_df_user_get_interfdet_req_timeouts_by_intvec (const uint32 *intvec, uint16 intvec_length, mtlk_interfdet_req_timeouts_t *req_params)
1764 {
1765 int res = MTLK_ERR_OK;
1766
1767 if (6 != intvec_length) {
1768 ELOG_D("Incorrect vector length. length(%u), expected 6", intvec_length);
1769 res = MTLK_ERR_PARAMS;
1770 }
1771
1772 if (MTLK_ERR_PARAMS == res) {
1773 ELOG_V("Expected parameters: <active_polling_timeout> <short_scan_polling_timeout> <long_scan_polling_timeout> "\
1774 "<active_notification_timeout> <short_scan_notification_timeout> <long_scan_notification_timeout>");
1775 return res;
1776 }
1777
1778 req_params->active_polling_timeout = intvec[0];
1779 req_params->short_scan_polling_timeout = intvec[1];
1780 req_params->long_scan_polling_timeout = intvec[2];
1781 req_params->active_notification_timeout = intvec[3];
1782 req_params->short_scan_notification_timeout = intvec[4];
1783 req_params->long_scan_notification_timeout = intvec[5];
1784
1785 return res;
1786 }
1787
1788 static int
1789 _mtlk_df_user_get_interfdet_req_thresh_by_intvec (const uint32 *intvec, uint16 intvec_length, mtlk_interfdet_req_thresh_t *req_params)
1790 {
1791
1792 #define INTERF_THR_PARAMS_DET_20 0
1793 #define INTERF_THR_PARAMS_NOTIF_20 1
1794 #define INTERF_THR_PARAMS_DET_40 2
1795 #define INTERF_THR_PARAMS_NOTIF_40 3
1796 #define INTERF_THR_PARAMS_SN_THR 4 /* Scan Noise Threshold */
1797 #define INTERF_THR_PARAMS_SN_MIN 5 /* Scan Minimum Noise */
1798 #define INTERF_THR_PARAMS_NUM 6
1799
1800 int res = MTLK_ERR_OK;
1801 int i;
1802
1803 if (INTERF_THR_PARAMS_NUM != intvec_length) {
1804 ELOG_DD("Incorrect vector length. length(%u), expected %d", intvec_length, INTERF_THR_PARAMS_NUM);
1805 res = MTLK_ERR_PARAMS;
1806 } else for (i = 0; i < INTERF_THR_PARAMS_NUM; i++) {
1807 /* All, but 4, parameters are in dB */
1808 if ((i != INTERF_THR_PARAMS_SN_THR) && (((int32)intvec[i] < MIN_INT8) || ((int32)intvec[i] > 0))) {
1809 ELOG_DD("Incorrect parameter %d (%d), must be in range [0..-128]", i + 1, intvec[i]);
1810 res = MTLK_ERR_PARAMS;
1811 break;
1812 }
1813 }
1814
1815 if ((MTLK_ERR_OK == res) && ((int32)intvec[INTERF_THR_PARAMS_SN_THR] > MAX_INT8)) {
1816 ELOG_DD("Incorrect parameter %d (%d), must be in range [0..127]", INTERF_THR_PARAMS_SN_THR, intvec[INTERF_THR_PARAMS_SN_THR]);
1817 res = MTLK_ERR_PARAMS;
1818 }
1819
1820 if (MTLK_ERR_PARAMS == res) {
1821 ELOG_V("Expected parameters: <detection_threshold_20mhz> <notification_threshold_20mhz> <detection_threshold_40mhz>"\
1822 "<notification_threshold_40mhz> <scan_noise_threshold> <scan_minimum_noise>");
1823 return res;
1824 }
1825
1826 req_params->detection_threshold_20mhz = intvec[INTERF_THR_PARAMS_DET_20 ];
1827 req_params->notification_threshold_20mhz = intvec[INTERF_THR_PARAMS_NOTIF_20];
1828 req_params->detection_threshold_40mhz = intvec[INTERF_THR_PARAMS_DET_40 ];
1829 req_params->notification_threshold_40mhz = intvec[INTERF_THR_PARAMS_NOTIF_40];
1830 req_params->scan_noise_threshold = intvec[INTERF_THR_PARAMS_SN_THR ];
1831 req_params->scan_minimum_noise = intvec[INTERF_THR_PARAMS_SN_MIN ];
1832
1833 return res;
1834 }
1835
1836
1837 static void
1838 _mtlk_df_user_get_intvec_by_fw_gpio_cfg (uint32 *intvec, uint16 *intvec_lenth, const mtlk_fw_led_gpio_cfg_t *gpio_cfg)
1839 {
1840 intvec[0] = gpio_cfg->disable_testbus;
1841 intvec[1] = gpio_cfg->active_gpios;
1842 intvec[2] = gpio_cfg->led_polatity;
1843
1844 *intvec_lenth = 3;
1845 }
1846
1847 static void
1848 _mtlk_df_user_intvec_by_11b_antsel (uint32 *intvec, uint16 *intvec_length, const mtlk_11b_antsel_t *antsel)
1849 {
1850 intvec[0] = antsel->txAnt;
1851 intvec[1] = antsel->rxAnt;
1852 intvec[2] = antsel->rate;
1853
1854 *intvec_length = 3;
1855 }
1856
1857 static int
1858 _mtlk_df_user_get_fw_gpio_cfg_by_intvec (const uint32 *intvec, uint16 intvec_lenth, mtlk_fw_led_gpio_cfg_t *gpio_cfg)
1859 {
1860 int res = MTLK_ERR_PARAMS;
1861
1862 if (3 != intvec_lenth) {
1863 ELOG_D("Incorrect vector length. length(%u)", intvec_lenth);
1864 }
1865 else if (intvec[0] >= MAX_UINT8 || intvec[1] >= MAX_UINT8 || intvec[2] >= MAX_UINT8) {
1866 ELOG_DDD("Incorrect value (%u %u %u)", intvec[0], intvec[1], intvec[2]);
1867 }
1868 else {
1869 gpio_cfg->disable_testbus = (uint8)intvec[0];
1870 gpio_cfg->active_gpios = (uint8)intvec[1];
1871 gpio_cfg->led_polatity = (uint8)intvec[2];
1872 res = MTLK_ERR_OK;
1873 }
1874
1875 return res;
1876 }
1877
1878 static int
1879 _mtlk_df_user_get_fw_led_state_by_intvec (const uint32 *intvec, uint16 intvec_lenth, mtlk_fw_led_state_t *led_state)
1880 {
1881 int res = MTLK_ERR_PARAMS;
1882
1883 if (2 != intvec_lenth) {
1884 ELOG_D("Incorrect vector length. length(%u)", intvec_lenth);
1885 }
1886 else if (intvec[0] >= MAX_UINT8 || intvec[1] >= MAX_UINT8) {
1887 ELOG_DD("Incorrect value (%u %u)", intvec[0], intvec[1]);
1888 }
1889 else {
1890 led_state->baseb_led = (uint8)intvec[0];
1891 led_state->led_state = (uint8)intvec[1];
1892 res = MTLK_ERR_OK;
1893 }
1894
1895 return res;
1896 }
1897
1898 static void
1899 _mtlk_df_user_get_intvec_by_auto_params (uint32 *intvec, uint16 *intvec_lenth, const mtlk_coc_auto_cfg_t *auto_params)
1900 {
1901 intvec[0] = auto_params->interval_1x1;
1902 intvec[1] = auto_params->interval_2x2;
1903 intvec[2] = auto_params->interval_3x3;
1904 intvec[3] = auto_params->high_limit_1x1;
1905 intvec[4] = auto_params->low_limit_2x2;
1906 intvec[5] = auto_params->high_limit_2x2;
1907 intvec[6] = auto_params->low_limit_3x3;
1908
1909 *intvec_lenth = 7;
1910 }
1911
1912 static void
1913 _mtlk_df_user_get_intvec_by_antenna_params (uint32 *intvec, uint16 *intvec_lenth, const mtlk_coc_antenna_cfg_t *antenna_params)
1914 {
1915 intvec[1] = antenna_params->num_tx_antennas;
1916 intvec[2] = antenna_params->num_rx_antennas;
1917
1918 *intvec_lenth = 3;
1919 }
1920
1921 static void
1922 _mtlk_df_user_get_intvec_by_n_rate_bo (int32 *intvec, uint16 *intvec_lenth, const mtlk_core_n_rate_bo_t *n_rate_bo)
1923 {
1924 intvec[0] = n_rate_bo->qam16;
1925 intvec[1] = n_rate_bo->qam64_2_3;
1926 intvec[2] = n_rate_bo->qam64_3_4;
1927 intvec[3] = n_rate_bo->qam64_5_6;
1928
1929 *intvec_lenth = 4;
1930 }
1931
1932 static void
1933 _mtlk_df_user_get_intvec_by_interf_params (int32 *intvec, uint16 *intvec_lenth, const mtlk_interf_t *interf_cfg)
1934 {
1935 intvec[0] = interf_cfg->is_enabled;
1936 intvec[1] = interf_cfg->threshold;
1937 intvec[2] = interf_cfg->threshold_rssi;
1938
1939 *intvec_lenth = 3;
1940 }
1941
1942 #ifdef MTCFG_PMCU_SUPPORT
1943
1944 static void
1945 _mtlk_df_user_get_intvec_by_pcoc_params (uint32 *intvec, uint16 *intvec_lenth, const mtlk_pcoc_params_t *params)
1946 {
1947 intvec[0] = params->interval;
1948 intvec[1] = params->limit_lower;
1949 intvec[2] = params->limit_upper;
1950
1951 *intvec_lenth = 3;
1952 }
1953
1954 #endif
1955
1956 static void
1957 _mtlk_df_user_intvec_by_11b_thresholds (uint32 *intvec, uint16 *intvec_length, const mtlk_enhanced11b_th_t *thresholds)
1958 {
1959 intvec[0] = thresholds->Consecutive11nTH;
1960 intvec[1] = thresholds->Consecutive11bTH;
1961
1962 *intvec_length = 2;
1963 }
1964
1965 static void
1966 _mtlk_df_user_intvec_by_recovery (uint32 *intvec, uint16 *intvec_length, const rcvry_cfg_t *recovery)
1967 {
1968 intvec[0] = recovery->fast_rcvry_num;
1969 intvec[1] = recovery->full_rcvry_num;
1970 intvec[2] = recovery->complete_rcvry;
1971 intvec[3] = recovery->fail_time_interval;
1972 intvec[4] = recovery->fw_dump;
1973
1974 *intvec_length = 5;
1975 }
1976
1977 static int
1978 _mtlk_df_user_get_coc_antenna_params_by_intvec (const uint32 *intvec, uint16 intvec_length, mtlk_coc_antenna_cfg_t *antenna_params)
1979 {
1980 int res = MTLK_ERR_PARAMS;
1981
1982 memset(antenna_params, 0, sizeof(mtlk_coc_antenna_cfg_t));
1983
1984 if (((intvec[0] == 1) && (intvec_length != 1)) ||
1985 ((intvec[0] == 0) && (intvec_length != 3))) {
1986 ELOG_DD("Incorrect vector configuration: <enable mode %u> and length %u", intvec[0], intvec_length);
1987 }
1988 else if ((intvec[0] != 1) && (intvec[0] != 0)) {
1989 ELOG_D("Incorrect vector configuration: <enable mode %u>", intvec[0]);
1990 }
1991 else {
1992 antenna_params->num_tx_antennas = intvec[1];
1993 antenna_params->num_rx_antennas = intvec[2];
1994
1995 res = MTLK_ERR_OK;
1996 }
1997
1998 return res;
1999 }
2000
2001 static int
2002 _mtlk_df_user_get_coc_auto_params_by_intvec (const uint32 *intvec, uint16 intvec_length, mtlk_coc_auto_cfg_t *auto_params)
2003 {
2004 int res = MTLK_ERR_PARAMS;
2005
2006 memset(auto_params, 0, sizeof(mtlk_coc_auto_cfg_t));
2007
2008 if (intvec_length != 7) {
2009 ELOG_D("Incorrect vector length. length(%u)", intvec_length);
2010 }
2011 else {
2012 auto_params->interval_1x1 = intvec[0];
2013 auto_params->interval_2x2 = intvec[1];
2014 auto_params->interval_3x3 = intvec[2];
2015 auto_params->high_limit_1x1 = intvec[3];
2016 auto_params->low_limit_2x2 = intvec[4];
2017 auto_params->high_limit_2x2 = intvec[5];
2018 auto_params->low_limit_3x3 = intvec[6];
2019
2020 res = MTLK_ERR_OK;
2021 }
2022
2023 return res;
2024 }
2025
2026 static int
2027 _mtlk_df_user_get_interf_params_by_intvec (const int32 *intvec, uint16 intvec_length, mtlk_interf_t *interf_cfg)
2028 {
2029 int res = MTLK_ERR_PARAMS;
2030
2031 memset(interf_cfg, 0, sizeof(mtlk_interf_t));
2032
2033 if (!!intvec[0]) {
2034 if (intvec_length != 3) {
2035 ELOG_D("Incorrect vector length. length(%u)", intvec_length);
2036 return res;
2037 }
2038 else {
2039 if ((intvec[1] > 100) || (intvec[1] < 0)) {
2040 ELOG_D("Incorrect channel load threshold value (%d)", intvec[1]);
2041 return res;
2042 }
2043
2044 if ((intvec[2] < -128) || (intvec[2] > 0)) {
2045 ELOG_D("Incorrect RSSI threshold value (%d)", intvec[2]);
2046 return res;
2047 }
2048 }
2049 }
2050
2051 MTLK_CFG_SET_ITEM(interf_cfg, is_enabled, !!intvec[0]);
2052 if (!!intvec[0]) {
2053 MTLK_CFG_SET_ITEM(interf_cfg, threshold, intvec[1]);
2054 MTLK_CFG_SET_ITEM(interf_cfg, threshold_rssi, intvec[2]);
2055 }
2056
2057 res = MTLK_ERR_OK;
2058
2059 return res;
2060 }
2061
2062 #ifdef MTCFG_PMCU_SUPPORT
2063
2064 static int
2065 _mtlk_df_user_get_pcoc_params_by_intvec (const uint32 *intvec, uint16 intvec_length, mtlk_pcoc_params_t *params)
2066 {
2067 int res = MTLK_ERR_PARAMS;
2068
2069 memset(params, 0, sizeof(mtlk_pcoc_params_t));
2070
2071 if (intvec_length != 3) {
2072 ELOG_D("Incorrect vector length. length(%u)", intvec_length);
2073 }
2074 else {
2075 params->interval = intvec[0];
2076 params->limit_lower = intvec[1];
2077 params->limit_upper = intvec[2];
2078
2079 res = MTLK_ERR_OK;
2080 }
2081
2082 return res;
2083 }
2084
2085 #endif
2086
2087 static int
2088 _mtlk_df_user_get_11b_thresholds_by_intvec (const uint32 *intvec, uint16 intvec_length, mtlk_enhanced11b_th_t *thresholds)
2089 {
2090 int res = MTLK_ERR_PARAMS;
2091
2092 memset(thresholds, 0, sizeof(*thresholds));
2093
2094 if (intvec_length != 2) {
2095 ELOG_D("Incorrect vector length (%u)", intvec_length);
2096 }
2097 else {
2098 thresholds->Consecutive11nTH = intvec[0];
2099 thresholds->Consecutive11bTH = intvec[1];
2100
2101 res = MTLK_ERR_OK;
2102 }
2103
2104 return res;
2105 }
2106
2107 static int
2108 _mtlk_df_user_get_11b_antsel_by_intvec (const uint32 *intvec, uint16 intvec_length, mtlk_11b_antsel_t *antsel)
2109 {
2110 int res = MTLK_ERR_PARAMS;
2111
2112 memset(antsel, 0, sizeof(*antsel));
2113
2114 if (intvec_length != 3) {
2115 ELOG_D("Incorrect vector length (%u)", intvec_length);
2116 }
2117 else {
2118 antsel->txAnt = intvec[0];
2119 antsel->rxAnt = intvec[1];
2120 antsel->rate = intvec[2];
2121
2122 res = MTLK_ERR_OK;
2123 }
2124
2125 return res;
2126 }
2127
2128 static int
2129 _mtlk_df_user_get_recovery_by_intvec (const uint32 *intvec, uint16 intvec_length, rcvry_cfg_t *recovery)
2130 {
2131 int res = MTLK_ERR_PARAMS;
2132
2133 if (intvec_length != 5) {
2134 ELOG_D("Incorrect vector length (%u)", intvec_length);
2135 }
2136 else {
2137 recovery->fast_rcvry_num = intvec[0];
2138 recovery->full_rcvry_num = intvec[1];
2139 recovery->complete_rcvry = intvec[2];
2140 recovery->fail_time_interval = intvec[3];
2141 recovery->fw_dump = intvec[4];
2142
2143 res = MTLK_ERR_OK;
2144 }
2145
2146 return res;
2147 }
2148
2149 static void
2150 _mtlk_df_user_intvec_by_agg_rate_limit (uint32 *intvec, uint16 *intvec_length, const mtlk_agg_rate_limit_t *limit)
2151 {
2152 intvec[0] = limit->mode;
2153 intvec[1] = limit->maxRate;
2154
2155 *intvec_length = 2;
2156 }
2157
2158 /* Parameters:
2159 mode 0/1 Feature Enable/Disable
2160 maxRate 0 ... BITRATE_LAST, use 0 if is not specified
2161 */
2162 static int
2163 _mtlk_df_user_set_agg_rate_limit_by_intvec (const uint32 *intvec, uint16 intvec_length, mtlk_agg_rate_limit_t *limit)
2164 {
2165 int res = MTLK_ERR_OK;
2166 uint32 mode, rate;
2167
2168 memset(limit, 0, sizeof(*limit));
2169
2170 if (0 == intvec_length) {
2171 ELOG_V("Value is missed");
2172 res = MTLK_ERR_PARAMS;
2173 }
2174 else {
2175 mode = intvec[0];
2176 rate = (1 == intvec_length) ? 0 : intvec[1];
2177
2178 /* check parameter 'mode' only */
2179 if (mode > 1) {
2180 ELOG_D("Wrong values for mode: %d (0/1 expected)\n", mode);
2181 res = MTLK_ERR_PARAMS;
2182 } else {
2183 limit->mode = mode;
2184 limit->maxRate = rate;
2185 /* res = MTLK_ERR_OK; */
2186 }
2187 }
2188
2189 return res;
2190 }
2191
2192 /* Parameters:
2193 onTime 0 ... 32767
2194 offTime 0 ... 32767
2195 */
2196 static int
2197 _mtlk_df_user_set_rx_duty_cycle_by_intvec (const uint32 *intvec, uint16 intvec_length, mtlk_rx_duty_cycle_t *rx_duty_cycle)
2198 {
2199 int res = MTLK_ERR_OK;
2200 uint32 onTime, offTime;
2201
2202 memset(rx_duty_cycle, 0, sizeof(*rx_duty_cycle));
2203
2204 if (2 != intvec_length) {
2205 ELOG_V("Wrong parameter count (expected: 2)");
2206 res = MTLK_ERR_PARAMS;
2207 }
2208 else {
2209 onTime = intvec[0];
2210 offTime = intvec[1];
2211
2212 /* check parameters */
2213 if (onTime > 32767 || offTime > 32767) {
2214 ELOG_DD("Wrong values: %d %d (0...32767 expected)", onTime, offTime);
2215 res = MTLK_ERR_PARAMS;
2216 } else {
2217 rx_duty_cycle->onTime = onTime;
2218 rx_duty_cycle->offTime = offTime;
2219 /* res = MTLK_ERR_OK; */
2220 }
2221 }
2222
2223 return res;
2224 }
2225
2226 static void
2227 _mtlk_df_user_intvec_by_rx_duty_cycle (uint32 *intvec, uint16 *intvec_length, const mtlk_rx_duty_cycle_t *rx_duty_cycle)
2228 {
2229 intvec[0] = rx_duty_cycle->onTime;
2230 intvec[1] = rx_duty_cycle->offTime;
2231
2232 *intvec_length = 2;
2233 }
2234
2235
2236 static int
2237 _mtlk_df_user_set_lna_gain_by_intvec (const int32 *intvec, uint16 intvec_length, mtlk_lna_gain_t *lna_gains)
2238 {
2239 int res = MTLK_ERR_OK;
2240
2241 memset(lna_gains, 0, sizeof(mtlk_lna_gain_t));
2242
2243 if (2 != intvec_length) {
2244 ELOG_V("Incorrect input vector length. Expected parameters [extLnaGainBypass] [extLnaGainHigh]");
2245 return MTLK_ERR_PARAMS;
2246 }
2247
2248 if ((intvec[0] < MIN_INT8) || (intvec[0] > MAX_INT8) || (intvec[1] < MIN_INT8) || (intvec[1] > MAX_INT8)) {
2249 ELOG_DD("Incorrect input value (%u %u)", intvec[0], intvec[1]);
2250 return MTLK_ERR_PARAMS;
2251 }
2252
2253 lna_gains->lna_gain_bypass = (int8)intvec[0];
2254 lna_gains->lna_gain_high = (int8)intvec[1];
2255
2256 return res;
2257 }
2258
2259 static void
2260 _mtlk_df_user_intvec_by_lna_gain (int32 *intvec, uint16 *intvec_length, const mtlk_lna_gain_t *lna_gains)
2261 {
2262 intvec[0] = lna_gains->lna_gain_bypass;
2263 intvec[1] = lna_gains->lna_gain_high;
2264
2265 *intvec_length = 2;
2266 }
2267
2268 static int
2269 _mtlk_df_user_get_n_rate_bo_by_intvec (const int32 *intvec, uint16 intvec_length, mtlk_core_n_rate_bo_t *n_rate_bo)
2270 {
2271 int res = MTLK_ERR_PARAMS;
2272
2273 if (intvec_length != 4) {
2274 ELOG_D("Incorrect vector length (%u)", intvec_length);
2275 }
2276 else {
2277 n_rate_bo->qam16 = intvec[0];
2278 n_rate_bo->qam64_2_3 = intvec[1];
2279 n_rate_bo->qam64_3_4 = intvec[2];
2280 n_rate_bo->qam64_5_6 = intvec[3];
2281
2282 res = MTLK_ERR_OK;
2283 }
2284
2285 return res;
2286 }
2287
2288 static int
2289 _mtlk_df_user_do_simple_cli (const uint32 *intvec, uint16 intvec_length, UmiDbgCliReq_t *DbgCliReq)
2290 {
2291 int res = MTLK_ERR_PARAMS;
2292
2293 if ((1 > intvec_length) || (4 < intvec_length)) {
2294 ELOG_D("Incorrect vector length. length(%u)", intvec_length);
2295 } else {
2296 memset(DbgCliReq, 0, sizeof(UmiDbgCliReq_t));
2297 DbgCliReq->numOfArgumets = intvec_length - 1;
2298 DbgCliReq->action = intvec[0];
2299 switch(intvec_length)
2300 {
2301 case 4:
2302 DbgCliReq->data3 = intvec[3];
2303 case 3:
2304 DbgCliReq->data2 = intvec[2];
2305 case 2:
2306 DbgCliReq->data1 = intvec[1];
2307 default:
2308 break;
2309 }
2310 res = MTLK_ERR_OK;
2311 }
2312
2313 return res;
2314 }
2315
2316 static int
2317 _mtlk_df_user_do_fw_debug (const uint32 *intvec, uint16 intvec_length, UMI_FW_DBG_REQ *FWDebugReq)
2318 {
2319 int res = MTLK_ERR_PARAMS;
2320
2321 if ((1 > intvec_length) || (2 < intvec_length)) {
2322 ELOG_D("Incorrect vector length. length(%u)", intvec_length);
2323 } else {
2324 memset(FWDebugReq, 0, sizeof(UMI_FW_DBG_REQ));
2325 /* For some reason, first argument is ignored */
2326 if(2 == intvec_length) {
2327 FWDebugReq->debugType = intvec[1];
2328 }
2329 res = MTLK_ERR_OK;
2330 }
2331
2332 return res;
2333 }
2334
2335 static void
2336 _mtlk_df_user_addr_vect_to_text (char *buf, mtlk_clpb_t *addr_vect_clpb, uint16 *length, uint32 max_len)
2337 {
2338 uint32 used_len, out_cnt;
2339 uint32 addr_size;
2340 IEEE_ADDR *addr;
2341
2342 ASSERT(buf != NULL);
2343 ASSERT(addr_vect_clpb != NULL);
2344
2345 used_len = 0;
2346 out_cnt = 0;
2347
2348 while(1)
2349 {
2350 addr = mtlk_clpb_enum_get_next(addr_vect_clpb, &addr_size);
2351 if (NULL == addr) break;
2352
2353 MTLK_ASSERT(addr_size == sizeof(IEEE_ADDR));
2354 used_len += mtlk_snprintf(buf+used_len, max_len-used_len,
2355 "\n " MAC_PRINTF_FMT,
2356 MAC_PRINTF_ARG(addr->au8Addr));
2357
2358 out_cnt++;
2359 }
2360
2361 if (out_cnt == 0)
2362 {
2363 used_len = mtlk_snprintf(buf, max_len, " No any address");
2364 }
2365
2366 used_len += mtlk_snprintf(buf+used_len, max_len-used_len, "\n");
2367
2368 *length = used_len;
2369 return;
2370 }
2371
2372 static int
2373 _mtlk_df_user_print_ta_debug_info(char *buffer, size_t len, mtlk_ta_debug_info_cfg_t *debug_info)
2374 {
2375 uint32 i;
2376 uint32 length=0;
2377 uint32 nof_crits;
2378 uint32 nof_stas;
2379
2380 nof_crits = debug_info->nof_crit;
2381 length += mtlk_snprintf(buffer+length, len-length, "\n");
2382 length += mtlk_snprintf(buffer+length, len-length, "==============================================================================\n");
2383 length += mtlk_snprintf(buffer+length, len-length, " CRITERIA (%d)\n", nof_crits);
2384 length += mtlk_snprintf(buffer+length, len-length, "------------------------------------------------------------------------------\n");
2385 length += mtlk_snprintf(buffer+length, len-length, " ID | Signature | FCN | Callback | Context | Count | Period \n");
2386 length += mtlk_snprintf(buffer+length, len-length, "------------------------------------------------------------------------------\n");
2387 for (i=0; i < nof_crits; ++i) {
2388 mtlk_ta_crit_t *crit = &debug_info->crit[i];
2389 length += mtlk_snprintf(buffer+length, len-length, " %02u %10X %10X %10X %10X %4u %8u \n",
2390 crit->id, crit->signature, (uint32)crit->fcn, (uint32)crit->clb,
2391 (uint32)crit->clb_ctx, crit->tmr_cnt, crit->tmr_period);
2392 }
2393
2394 nof_stas = debug_info->nof_sta_wss;
2395 length += mtlk_snprintf(buffer+length, len-length, "==============================================================================\n");
2396 length += mtlk_snprintf(buffer+length, len-length, " STA WSS (%d)\n", nof_stas);
2397 length += mtlk_snprintf(buffer+length, len-length, "------------------------------------------------------------------------------\n");
2398 length += mtlk_snprintf(buffer+length, len-length, " | | | RX | TX \n");
2399 length += mtlk_snprintf(buffer+length, len-length, " STA | VAP | Valid | Prev | Delta | Prev | Delta \n");
2400 length += mtlk_snprintf(buffer+length, len-length, "------------------------------------------------------------------------------\n");
2401 for (i=0; i < nof_stas; ++i) {
2402 mtlk_ta_sta_wss_t *wss = &debug_info->sta_wss[i];
2403 mtlk_ta_wss_counter_t *rx = &wss->coc_rx_bytes;
2404 mtlk_ta_wss_counter_t *tx = &wss->coc_tx_bytes;
2405 length += mtlk_snprintf(buffer+length, len-length, "%10X %3X %c %10u %10u %10u %10u\n",
2406 (uint32)wss->sta_entry, (uint32)mtlk_vap_get_id(((sta_entry*)wss->sta_entry)->vap_handle),
2407 wss->coc_wss_valid?'Y':'N',
2408 rx->prev, rx->delta,
2409 tx->prev, tx->delta);
2410 }
2411 length += mtlk_snprintf(buffer+length, len-length, "==============================================================================\n");
2412
2413 return length;
2414 }
2415
2416 static BOOL
2417 _mtlk_df_user_card_type_is_g35(mtlk_df_user_t *df_user)
2418 {
2419 mtlk_card_type_t card_type = MTLK_CARD_UNKNOWN;
2420 mtlk_vap_handle_t vap;
2421 BOOL is_type_ok = FALSE;
2422 int res;
2423
2424 vap = mtlk_df_get_vap_handle(df_user->df);
2425 res = mtlk_vap_get_hw_vft(vap)->get_prop(vap, MTLK_HW_PROP_CARD_TYPE,
2426 &card_type, sizeof(&card_type));
2427 MTLK_ASSERT(MTLK_ERR_OK == res);
2428 CARD_SELECTOR_START(card_type)
2429 IF_CARD_G3 (
2430 /* nothing */
2431 );
2432 IF_CARD_AHBG35 (
2433 is_type_ok = TRUE;
2434 );
2435 CARD_SELECTOR_END();
2436
2437 return is_type_ok;
2438 }
2439
2440 static BOOL
2441 _mtlk_df_user_check_master_vap_on_g35(mtlk_df_user_t *df_user)
2442 {
2443 return mtlk_vap_is_master(mtlk_df_get_vap_handle(df_user->df)) &&
2444 _mtlk_df_user_card_type_is_g35(df_user);
2445 }
2446
2447 static int
2448 __set_item_value_int8 (int32 value, int8 *item)
2449 {
2450 int res = MTLK_ERR_OK;
2451
2452 if (MIN_INT8 <= value && value <= MAX_INT8) {
2453 *item = value;
2454 } else {
2455 ELOG_V("Wrong value (expected: -128...127)");
2456 res = MTLK_ERR_PARAMS;
2457 }
2458
2459 return res;
2460 }
2461
2462 static int __MTLK_IFUNC
2463 _mtlk_df_user_iwpriv_get_core_param(mtlk_df_user_t* df_user, uint32 param_id, char* data, uint16* length)
2464 {
2465 int res;
2466
2467 _DF_USER_GET_PARAM_MAP_START(df_user, param_id, res)
2468
2469 _DF_USER_GET_ON_PARAM(PRM_ID_BE_BAUSE, MTLK_CORE_REQ_GET_ADDBA_CFG, FALSE, mtlk_addba_cfg_entity_t, addba_cfg)
2470 MTLK_CFG_GET_ITEM(&addba_cfg->tid[0], use_aggr, *(uint32*)data);
2471
2472 _DF_USER_GET_ON_PARAM(PRM_ID_BK_BAUSE, MTLK_CORE_REQ_GET_ADDBA_CFG, FALSE, mtlk_addba_cfg_entity_t, addba_cfg)
2473 MTLK_CFG_GET_ITEM(&addba_cfg->tid[1], use_aggr, *(uint32*)data);
2474
2475 _DF_USER_GET_ON_PARAM(PRM_ID_VI_BAUSE, MTLK_CORE_REQ_GET_ADDBA_CFG, FALSE, mtlk_addba_cfg_entity_t, addba_cfg)
2476 MTLK_CFG_GET_ITEM(&addba_cfg->tid[5], use_aggr, *(uint32*)data);
2477
2478 _DF_USER_GET_ON_PARAM(PRM_ID_VO_BAUSE, MTLK_CORE_REQ_GET_ADDBA_CFG, FALSE, mtlk_addba_cfg_entity_t, addba_cfg)
2479 MTLK_CFG_GET_ITEM(&addba_cfg->tid[6], use_aggr, *(uint32*)data);
2480
2481 _DF_USER_GET_ON_PARAM(PRM_ID_BE_BAACCEPT, MTLK_CORE_REQ_GET_ADDBA_CFG, FALSE, mtlk_addba_cfg_entity_t, addba_cfg)
2482 MTLK_CFG_GET_ITEM(&addba_cfg->tid[3], accept_aggr, *(uint32*)data);
2483
2484 _DF_USER_GET_ON_PARAM(PRM_ID_BK_BAACCEPT, MTLK_CORE_REQ_GET_ADDBA_CFG, FALSE, mtlk_addba_cfg_entity_t, addba_cfg)
2485 MTLK_CFG_GET_ITEM(&addba_cfg->tid[2], accept_aggr, *(uint32*)data);
2486
2487 _DF_USER_GET_ON_PARAM(PRM_ID_VI_BAACCEPT, MTLK_CORE_REQ_GET_ADDBA_CFG, FALSE, mtlk_addba_cfg_entity_t, addba_cfg)
2488 MTLK_CFG_GET_ITEM(&addba_cfg->tid[5], accept_aggr, *(uint32*)data);
2489
2490 _DF_USER_GET_ON_PARAM(PRM_ID_VO_BAACCEPT, MTLK_CORE_REQ_GET_ADDBA_CFG, FALSE, mtlk_addba_cfg_entity_t, addba_cfg)
2491 MTLK_CFG_GET_ITEM(&addba_cfg->tid[7], accept_aggr, *(uint32*)data);
2492
2493 _DF_USER_GET_ON_PARAM(PRM_ID_BE_BATIMEOUT, MTLK_CORE_REQ_GET_ADDBA_CFG, FALSE, mtlk_addba_cfg_entity_t, addba_cfg)
2494 MTLK_CFG_GET_ITEM(&addba_cfg->tid[0], addba_timeout, *(uint32*)data);
2495
2496 _DF_USER_GET_ON_PARAM(PRM_ID_BK_BATIMEOUT, MTLK_CORE_REQ_GET_ADDBA_CFG, FALSE, mtlk_addba_cfg_entity_t, addba_cfg)
2497 MTLK_CFG_GET_ITEM(&addba_cfg->tid[1], addba_timeout, *(uint32*)data);
2498
2499 _DF_USER_GET_ON_PARAM(PRM_ID_VI_BATIMEOUT, MTLK_CORE_REQ_GET_ADDBA_CFG, FALSE, mtlk_addba_cfg_entity_t, addba_cfg)
2500 MTLK_CFG_GET_ITEM(&addba_cfg->tid[5], addba_timeout, *(uint32*)data);
2501
2502 _DF_USER_GET_ON_PARAM(PRM_ID_VO_BATIMEOUT, MTLK_CORE_REQ_GET_ADDBA_CFG, FALSE, mtlk_addba_cfg_entity_t, addba_cfg)
2503 MTLK_CFG_GET_ITEM(&addba_cfg->tid[6], addba_timeout, *(uint32*)data);
2504
2505 _DF_USER_GET_ON_PARAM(PRM_ID_BE_BAWINSIZE, MTLK_CORE_REQ_GET_ADDBA_CFG, FALSE, mtlk_addba_cfg_entity_t, addba_cfg)
2506 MTLK_CFG_GET_ITEM(&addba_cfg->tid[0], aggr_win_size, *(uint32*)data);
2507
2508 _DF_USER_GET_ON_PARAM(PRM_ID_BK_BAWINSIZE, MTLK_CORE_REQ_GET_ADDBA_CFG, FALSE, mtlk_addba_cfg_entity_t, addba_cfg)
2509 MTLK_CFG_GET_ITEM(&addba_cfg->tid[1], aggr_win_size, *(uint32*)data);
2510
2511 _DF_USER_GET_ON_PARAM(PRM_ID_VI_BAWINSIZE, MTLK_CORE_REQ_GET_ADDBA_CFG, FALSE, mtlk_addba_cfg_entity_t, addba_cfg)
2512 MTLK_CFG_GET_ITEM(&addba_cfg->tid[5], aggr_win_size, *(uint32*)data);
2513
2514 _DF_USER_GET_ON_PARAM(PRM_ID_VO_BAWINSIZE, MTLK_CORE_REQ_GET_ADDBA_CFG, FALSE, mtlk_addba_cfg_entity_t, addba_cfg)
2515 MTLK_CFG_GET_ITEM(&addba_cfg->tid[6], aggr_win_size, *(uint32*)data);
2516
2517 _DF_USER_GET_ON_PARAM(PRM_ID_BE_AGGRMAXBTS, MTLK_CORE_REQ_GET_ADDBA_CFG, FALSE, mtlk_addba_cfg_entity_t, addba_cfg)
2518 MTLK_CFG_GET_ITEM(&addba_cfg->tid[0], max_nof_bytes, *(uint32*)data);
2519
2520 _DF_USER_GET_ON_PARAM(PRM_ID_BK_AGGRMAXBTS, MTLK_CORE_REQ_GET_ADDBA_CFG, FALSE, mtlk_addba_cfg_entity_t, addba_cfg)
2521 MTLK_CFG_GET_ITEM(&addba_cfg->tid[1], max_nof_bytes, *(uint32*)data);
2522
2523 _DF_USER_GET_ON_PARAM(PRM_ID_VI_AGGRMAXBTS, MTLK_CORE_REQ_GET_ADDBA_CFG, FALSE, mtlk_addba_cfg_entity_t, addba_cfg)
2524 MTLK_CFG_GET_ITEM(&addba_cfg->tid[5], max_nof_bytes, *(uint32*)data);
2525
2526 _DF_USER_GET_ON_PARAM(PRM_ID_VO_AGGRMAXBTS, MTLK_CORE_REQ_GET_ADDBA_CFG, FALSE, mtlk_addba_cfg_entity_t, addba_cfg)
2527 MTLK_CFG_GET_ITEM(&addba_cfg->tid[6], max_nof_bytes, *(uint32*)data);
2528
2529 _DF_USER_GET_ON_PARAM(PRM_ID_BE_AGGRMAXPKTS, MTLK_CORE_REQ_GET_ADDBA_CFG, FALSE, mtlk_addba_cfg_entity_t, addba_cfg)
2530 MTLK_CFG_GET_ITEM(&addba_cfg->tid[0], max_nof_packets, *(uint32*)data);
2531
2532 _DF_USER_GET_ON_PARAM(PRM_ID_BK_AGGRMAXPKTS, MTLK_CORE_REQ_GET_ADDBA_CFG, FALSE, mtlk_addba_cfg_entity_t, addba_cfg)
2533 MTLK_CFG_GET_ITEM(&addba_cfg->tid[1], max_nof_packets, *(uint32*)data);
2534
2535 _DF_USER_GET_ON_PARAM(PRM_ID_VI_AGGRMAXPKTS, MTLK_CORE_REQ_GET_ADDBA_CFG, FALSE, mtlk_addba_cfg_entity_t, addba_cfg)
2536 MTLK_CFG_GET_ITEM(&addba_cfg->tid[5], max_nof_packets, *(uint32*)data);
2537
2538 _DF_USER_GET_ON_PARAM(PRM_ID_VO_AGGRMAXPKTS, MTLK_CORE_REQ_GET_ADDBA_CFG, FALSE, mtlk_addba_cfg_entity_t, addba_cfg)
2539 MTLK_CFG_GET_ITEM(&addba_cfg->tid[6], max_nof_packets, *(uint32*)data);
2540
2541 _DF_USER_GET_ON_PARAM(PRM_ID_BE_AGGRMINPTSZ, MTLK_CORE_REQ_GET_ADDBA_CFG, FALSE, mtlk_addba_cfg_entity_t, addba_cfg)
2542 MTLK_CFG_GET_ITEM(&addba_cfg->tid[0], min_packet_size_in_aggr, *(uint32*)data);
2543
2544 _DF_USER_GET_ON_PARAM(PRM_ID_BK_AGGRMINPTSZ, MTLK_CORE_REQ_GET_ADDBA_CFG, FALSE, mtlk_addba_cfg_entity_t, addba_cfg)
2545 MTLK_CFG_GET_ITEM(&addba_cfg->tid[1], min_packet_size_in_aggr, *(uint32*)data);
2546
2547 _DF_USER_GET_ON_PARAM(PRM_ID_VI_AGGRMINPTSZ, MTLK_CORE_REQ_GET_ADDBA_CFG, FALSE, mtlk_addba_cfg_entity_t, addba_cfg)
2548 MTLK_CFG_GET_ITEM(&addba_cfg->tid[5], min_packet_size_in_aggr, *(uint32*)data);
2549
2550 _DF_USER_GET_ON_PARAM(PRM_ID_VO_AGGRMINPTSZ, MTLK_CORE_REQ_GET_ADDBA_CFG, FALSE, mtlk_addba_cfg_entity_t, addba_cfg)
2551 MTLK_CFG_GET_ITEM(&addba_cfg->tid[6], min_packet_size_in_aggr, *(uint32*)data);
2552
2553 _DF_USER_GET_ON_PARAM(PRM_ID_BE_AGGRTIMEOUT, MTLK_CORE_REQ_GET_ADDBA_CFG, FALSE, mtlk_addba_cfg_entity_t, addba_cfg)
2554 MTLK_CFG_GET_ITEM(&addba_cfg->tid[0], timeout_interval, *(uint32*)data);
2555
2556 _DF_USER_GET_ON_PARAM(PRM_ID_BK_AGGRTIMEOUT, MTLK_CORE_REQ_GET_ADDBA_CFG, FALSE, mtlk_addba_cfg_entity_t, addba_cfg)
2557 MTLK_CFG_GET_ITEM(&addba_cfg->tid[1], timeout_interval, *(uint32*)data);
2558
2559 _DF_USER_GET_ON_PARAM(PRM_ID_VI_AGGRTIMEOUT, MTLK_CORE_REQ_GET_ADDBA_CFG, FALSE, mtlk_addba_cfg_entity_t, addba_cfg)
2560 MTLK_CFG_GET_ITEM(&addba_cfg->tid[5], timeout_interval, *(uint32*)data);
2561
2562 _DF_USER_GET_ON_PARAM(PRM_ID_VO_AGGRTIMEOUT, MTLK_CORE_REQ_GET_ADDBA_CFG, FALSE, mtlk_addba_cfg_entity_t, addba_cfg)
2563 MTLK_CFG_GET_ITEM(&addba_cfg->tid[6], timeout_interval, *(uint32*)data);
2564
2565 _DF_USER_GET_ON_PARAM(PRM_ID_BE_AIFSN, MTLK_CORE_REQ_GET_WME_BSS_CFG, FALSE, mtlk_wme_cfg_entity_t, wme_bss_cfg)
2566 MTLK_CFG_GET_ITEM(&wme_bss_cfg->wme_class[0], aifsn, *(uint32*)data);
2567
2568 _DF_USER_GET_ON_PARAM(PRM_ID_BK_AIFSN, MTLK_CORE_REQ_GET_WME_BSS_CFG, FALSE, mtlk_wme_cfg_entity_t, wme_bss_cfg)
2569 MTLK_CFG_GET_ITEM(&wme_bss_cfg->wme_class[1], aifsn, *(uint32*)data);
2570
2571 _DF_USER_GET_ON_PARAM(PRM_ID_VI_AIFSN, MTLK_CORE_REQ_GET_WME_BSS_CFG, FALSE, mtlk_wme_cfg_entity_t, wme_bss_cfg)
2572 MTLK_CFG_GET_ITEM(&wme_bss_cfg->wme_class[2], aifsn, *(uint32*)data);
2573
2574 _DF_USER_GET_ON_PARAM(PRM_ID_VO_AIFSN, MTLK_CORE_REQ_GET_WME_BSS_CFG, FALSE, mtlk_wme_cfg_entity_t, wme_bss_cfg)
2575 MTLK_CFG_GET_ITEM(&wme_bss_cfg->wme_class[3], aifsn, *(uint32*)data);
2576
2577 _DF_USER_GET_ON_PARAM(PRM_ID_BE_CWMAX, MTLK_CORE_REQ_GET_WME_BSS_CFG, FALSE, mtlk_wme_cfg_entity_t, wme_bss_cfg)
2578 MTLK_CFG_GET_ITEM(&wme_bss_cfg->wme_class[0], cwmax, *(uint32*)data);
2579
2580 _DF_USER_GET_ON_PARAM(PRM_ID_BK_CWMAX, MTLK_CORE_REQ_GET_WME_BSS_CFG, FALSE, mtlk_wme_cfg_entity_t, wme_bss_cfg)
2581 MTLK_CFG_GET_ITEM(&wme_bss_cfg->wme_class[1], cwmax, *(uint32*)data);
2582
2583 _DF_USER_GET_ON_PARAM(PRM_ID_VI_CWMAX, MTLK_CORE_REQ_GET_WME_BSS_CFG, FALSE, mtlk_wme_cfg_entity_t, wme_bss_cfg)
2584 MTLK_CFG_GET_ITEM(&wme_bss_cfg->wme_class[2], cwmax, *(uint32*)data);
2585
2586 _DF_USER_GET_ON_PARAM(PRM_ID_VO_CWMAX, MTLK_CORE_REQ_GET_WME_BSS_CFG, FALSE, mtlk_wme_cfg_entity_t, wme_bss_cfg)
2587 MTLK_CFG_GET_ITEM(&wme_bss_cfg->wme_class[3], cwmax, *(uint32*)data);
2588
2589 _DF_USER_GET_ON_PARAM(PRM_ID_BE_CWMIN, MTLK_CORE_REQ_GET_WME_BSS_CFG, FALSE, mtlk_wme_cfg_entity_t, wme_bss_cfg)
2590 MTLK_CFG_GET_ITEM(&wme_bss_cfg->wme_class[0], cwmin, *(uint32*)data);
2591
2592 _DF_USER_GET_ON_PARAM(PRM_ID_BK_CWMIN, MTLK_CORE_REQ_GET_WME_BSS_CFG, FALSE, mtlk_wme_cfg_entity_t, wme_bss_cfg)
2593 MTLK_CFG_GET_ITEM(&wme_bss_cfg->wme_class[1], cwmin, *(uint32*)data);
2594
2595 _DF_USER_GET_ON_PARAM(PRM_ID_VI_CWMIN, MTLK_CORE_REQ_GET_WME_BSS_CFG, FALSE, mtlk_wme_cfg_entity_t, wme_bss_cfg)
2596 MTLK_CFG_GET_ITEM(&wme_bss_cfg->wme_class[2], cwmin, *(uint32*)data);
2597
2598 _DF_USER_GET_ON_PARAM(PRM_ID_VO_CWMIN, MTLK_CORE_REQ_GET_WME_BSS_CFG, FALSE, mtlk_wme_cfg_entity_t, wme_bss_cfg)
2599 MTLK_CFG_GET_ITEM(&wme_bss_cfg->wme_class[3], cwmin, *(uint32*)data);
2600
2601 _DF_USER_GET_ON_PARAM(PRM_ID_BE_TXOP, MTLK_CORE_REQ_GET_WME_BSS_CFG, FALSE, mtlk_wme_cfg_entity_t, wme_bss_cfg)
2602 MTLK_CFG_GET_ITEM(&wme_bss_cfg->wme_class[0], txop, *(uint32*)data);
2603
2604 _DF_USER_GET_ON_PARAM(PRM_ID_BK_TXOP, MTLK_CORE_REQ_GET_WME_BSS_CFG, FALSE, mtlk_wme_cfg_entity_t, wme_bss_cfg)
2605 MTLK_CFG_GET_ITEM(&wme_bss_cfg->wme_class[1], txop, *(uint32*)data);
2606
2607 _DF_USER_GET_ON_PARAM(PRM_ID_VI_TXOP, MTLK_CORE_REQ_GET_WME_BSS_CFG, FALSE, mtlk_wme_cfg_entity_t, wme_bss_cfg)
2608 MTLK_CFG_GET_ITEM(&wme_bss_cfg->wme_class[2], txop, *(uint32*)data);
2609
2610 _DF_USER_GET_ON_PARAM(PRM_ID_VO_TXOP, MTLK_CORE_REQ_GET_WME_BSS_CFG, FALSE, mtlk_wme_cfg_entity_t, wme_bss_cfg)
2611 MTLK_CFG_GET_ITEM(&wme_bss_cfg->wme_class[3], txop, *(uint32*)data);
2612
2613 _DF_USER_GET_ON_PARAM(PRM_ID_BE_AIFSNAP, MTLK_CORE_REQ_GET_WME_AP_CFG, FALSE, mtlk_wme_cfg_entity_t, wme_ap_cfg)
2614 MTLK_CFG_GET_ITEM(&wme_ap_cfg->wme_class[0], aifsn, *(uint32*)data);
2615
2616 _DF_USER_GET_ON_PARAM(PRM_ID_BK_AIFSNAP, MTLK_CORE_REQ_GET_WME_AP_CFG, FALSE, mtlk_wme_cfg_entity_t, wme_ap_cfg)
2617 MTLK_CFG_GET_ITEM(&wme_ap_cfg->wme_class[1], aifsn, *(uint32*)data);
2618
2619 _DF_USER_GET_ON_PARAM(PRM_ID_VI_AIFSNAP, MTLK_CORE_REQ_GET_WME_AP_CFG, FALSE, mtlk_wme_cfg_entity_t, wme_ap_cfg)
2620 MTLK_CFG_GET_ITEM(&wme_ap_cfg->wme_class[2], aifsn, *(uint32*)data);
2621
2622 _DF_USER_GET_ON_PARAM(PRM_ID_VO_AIFSNAP, MTLK_CORE_REQ_GET_WME_AP_CFG, FALSE, mtlk_wme_cfg_entity_t, wme_ap_cfg)
2623 MTLK_CFG_GET_ITEM(&wme_ap_cfg->wme_class[3], aifsn, *(uint32*)data);
2624
2625 _DF_USER_GET_ON_PARAM(PRM_ID_BE_CWMAXAP, MTLK_CORE_REQ_GET_WME_AP_CFG, FALSE, mtlk_wme_cfg_entity_t, wme_ap_cfg)
2626 MTLK_CFG_GET_ITEM(&wme_ap_cfg->wme_class[0], cwmax, *(uint32*)data);
2627
2628 _DF_USER_GET_ON_PARAM(PRM_ID_BK_CWMAXAP, MTLK_CORE_REQ_GET_WME_AP_CFG, FALSE, mtlk_wme_cfg_entity_t, wme_ap_cfg)
2629 MTLK_CFG_GET_ITEM(&wme_ap_cfg->wme_class[1], cwmax, *(uint32*)data);
2630
2631 _DF_USER_GET_ON_PARAM(PRM_ID_VI_CWMAXAP, MTLK_CORE_REQ_GET_WME_AP_CFG, FALSE, mtlk_wme_cfg_entity_t, wme_ap_cfg)
2632 MTLK_CFG_GET_ITEM(&wme_ap_cfg->wme_class[2], cwmax, *(uint32*)data);
2633
2634 _DF_USER_GET_ON_PARAM(PRM_ID_VO_CWMAXAP, MTLK_CORE_REQ_GET_WME_AP_CFG, FALSE, mtlk_wme_cfg_entity_t, wme_ap_cfg)
2635 MTLK_CFG_GET_ITEM(&wme_ap_cfg->wme_class[3], cwmax, *(uint32*)data);
2636
2637 _DF_USER_GET_ON_PARAM(PRM_ID_BE_CWMINAP, MTLK_CORE_REQ_GET_WME_AP_CFG, FALSE, mtlk_wme_cfg_entity_t, wme_ap_cfg)
2638 MTLK_CFG_GET_ITEM(&wme_ap_cfg->wme_class[0], cwmin, *(uint32*)data);
2639
2640 _DF_USER_GET_ON_PARAM(PRM_ID_BK_CWMINAP, MTLK_CORE_REQ_GET_WME_AP_CFG, FALSE, mtlk_wme_cfg_entity_t, wme_ap_cfg)
2641 MTLK_CFG_GET_ITEM(&wme_ap_cfg->wme_class[1], cwmin, *(uint32*)data);
2642
2643 _DF_USER_GET_ON_PARAM(PRM_ID_VI_CWMINAP, MTLK_CORE_REQ_GET_WME_AP_CFG, FALSE, mtlk_wme_cfg_entity_t, wme_ap_cfg)
2644 MTLK_CFG_GET_ITEM(&wme_ap_cfg->wme_class[2], cwmin, *(uint32*)data);
2645
2646 _DF_USER_GET_ON_PARAM(PRM_ID_VO_CWMINAP, MTLK_CORE_REQ_GET_WME_AP_CFG, FALSE, mtlk_wme_cfg_entity_t, wme_ap_cfg)
2647 MTLK_CFG_GET_ITEM(&wme_ap_cfg->wme_class[3], cwmin, *(uint32*)data);
2648
2649 _DF_USER_GET_ON_PARAM(PRM_ID_BE_TXOPAP, MTLK_CORE_REQ_GET_WME_AP_CFG, FALSE, mtlk_wme_cfg_entity_t, wme_ap_cfg)
2650 MTLK_CFG_GET_ITEM(&wme_ap_cfg->wme_class[0], txop, *(uint32*)data);
2651
2652 _DF_USER_GET_ON_PARAM(PRM_ID_BK_TXOPAP, MTLK_CORE_REQ_GET_WME_AP_CFG, FALSE, mtlk_wme_cfg_entity_t, wme_ap_cfg)
2653 MTLK_CFG_GET_ITEM(&wme_ap_cfg->wme_class[1], txop, *(uint32*)data);
2654
2655 _DF_USER_GET_ON_PARAM(PRM_ID_VI_TXOPAP, MTLK_CORE_REQ_GET_WME_AP_CFG, FALSE, mtlk_wme_cfg_entity_t, wme_ap_cfg)
2656 MTLK_CFG_GET_ITEM(&wme_ap_cfg->wme_class[2], txop, *(uint32*)data);
2657
2658 _DF_USER_GET_ON_PARAM(PRM_ID_VO_TXOPAP, MTLK_CORE_REQ_GET_WME_AP_CFG, FALSE, mtlk_wme_cfg_entity_t, wme_ap_cfg)
2659 MTLK_CFG_GET_ITEM(&wme_ap_cfg->wme_class[3], txop, *(uint32*)data);
2660
2661 _DF_USER_GET_ON_PARAM(PRM_ID_AOCS_WEIGHT_CL, MTLK_CORE_REQ_GET_AOCS_CFG, FALSE, mtlk_aocs_cfg_t, aocs_cfg)
2662 MTLK_CFG_GET_ITEM(aocs_cfg, weight_ch_load, *(uint32*)data);
2663
2664 _DF_USER_GET_ON_PARAM(PRM_ID_AOCS_WEIGHT_TX, MTLK_CORE_REQ_GET_AOCS_CFG, FALSE, mtlk_aocs_cfg_t, aocs_cfg)
2665 MTLK_CFG_GET_ITEM(aocs_cfg, weight_tx_power, *(uint32*)data);
2666
2667 _DF_USER_GET_ON_PARAM(PRM_ID_AOCS_WEIGHT_BSS, MTLK_CORE_REQ_GET_AOCS_CFG, FALSE, mtlk_aocs_cfg_t, aocs_cfg)
2668 MTLK_CFG_GET_ITEM(aocs_cfg, weight_nof_bss, *(uint32*)data);
2669
2670 _DF_USER_GET_ON_PARAM(PRM_ID_AOCS_WEIGHT_SM, MTLK_CORE_REQ_GET_AOCS_CFG, FALSE, mtlk_aocs_cfg_t, aocs_cfg)
2671 MTLK_CFG_GET_ITEM(aocs_cfg, weight_sm_required, *(uint32*)data);
2672
2673 _DF_USER_GET_ON_PARAM(PRM_ID_AOCS_SCAN_AGING, MTLK_CORE_REQ_GET_AOCS_CFG, FALSE, mtlk_aocs_cfg_t, aocs_cfg)
2674 MTLK_CFG_GET_ITEM(aocs_cfg, scan_aging_ms, *(uint32*)data);
2675
2676 _DF_USER_GET_ON_PARAM(PRM_ID_AOCS_CONFIRM_RANK_AGING, MTLK_CORE_REQ_GET_AOCS_CFG, FALSE, mtlk_aocs_cfg_t, aocs_cfg)
2677 MTLK_CFG_GET_ITEM(aocs_cfg, confirm_rank_aging_ms, *(uint32*)data);
2678
2679 _DF_USER_GET_ON_PARAM(PRM_ID_AOCS_CFM_RANK_SW_THRESHOLD, MTLK_CORE_REQ_GET_AOCS_CFG, FALSE, mtlk_aocs_cfg_t, aocs_cfg)
2680 MTLK_CFG_GET_ITEM(aocs_cfg, cfm_rank_sw_threshold, *(uint32*)data);
2681
2682 _DF_USER_GET_ON_PARAM(PRM_ID_AOCS_AFILTER, MTLK_CORE_REQ_GET_AOCS_CFG, FALSE, mtlk_aocs_cfg_t, aocs_cfg)
2683 MTLK_CFG_GET_ITEM(aocs_cfg, alpha_filter_coefficient, *(uint32*)data);
2684
2685 _DF_USER_GET_ON_PARAM(PRM_ID_AOCS_BONDING, MTLK_CORE_REQ_GET_AOCS_CFG, FALSE, mtlk_aocs_cfg_t, aocs_cfg)
2686 MTLK_CFG_GET_ITEM(aocs_cfg, bonding, *(uint32*)data);
2687
2688 _DF_USER_GET_ON_PARAM(PRM_ID_AOCS_EN_PENALTIES, MTLK_CORE_REQ_GET_AOCS_CFG, FALSE, mtlk_aocs_cfg_t, aocs_cfg)
2689 MTLK_CFG_GET_ITEM(aocs_cfg, use_tx_penalties, *(uint32*)data);
2690
2691 _DF_USER_GET_ON_PARAM(PRM_ID_AOCS_WIN_TIME, MTLK_CORE_REQ_GET_AOCS_CFG, FALSE, mtlk_aocs_cfg_t, aocs_cfg)
2692 MTLK_CFG_GET_ITEM(aocs_cfg, udp_aocs_window_time_ms, *(uint32*)data);
2693
2694 _DF_USER_GET_ON_PARAM(PRM_ID_AOCS_LOWER_THRESHOLD, MTLK_CORE_REQ_GET_AOCS_CFG, FALSE, mtlk_aocs_cfg_t, aocs_cfg)
2695 MTLK_CFG_GET_ITEM(aocs_cfg, udp_lower_threshold, *(uint32*)data);
2696
2697 _DF_USER_GET_ON_PARAM(PRM_ID_AOCS_THRESHOLD_WINDOW, MTLK_CORE_REQ_GET_AOCS_CFG, FALSE, mtlk_aocs_cfg_t, aocs_cfg)
2698 MTLK_CFG_GET_ITEM(aocs_cfg, udp_threshold_window, *(uint32*)data);
2699
2700 _DF_USER_GET_ON_PARAM(PRM_ID_AOCS_MSDU_DEBUG_ENABLED, MTLK_CORE_REQ_GET_AOCS_CFG, FALSE, mtlk_aocs_cfg_t, aocs_cfg)
2701 MTLK_CFG_GET_ITEM(aocs_cfg, udp_msdu_debug_enabled, *(uint32*)data);
2702
2703 _DF_USER_GET_ON_PARAM(PRM_ID_AOCS_IS_ENABLED, MTLK_CORE_REQ_GET_AOCS_CFG, FALSE, mtlk_aocs_cfg_t, aocs_cfg)
2704 MTLK_CFG_GET_ITEM(aocs_cfg, type, *(uint32*)data);
2705
2706 _DF_USER_GET_ON_PARAM(PRM_ID_AOCS_MSDU_PER_WIN_THRESHOLD, MTLK_CORE_REQ_GET_AOCS_CFG, FALSE, mtlk_aocs_cfg_t, aocs_cfg)
2707 MTLK_CFG_GET_ITEM(aocs_cfg, udp_msdu_per_window_threshold, *(uint32*)data);
2708
2709 _DF_USER_GET_ON_PARAM(PRM_ID_AOCS_MSDU_THRESHOLD, MTLK_CORE_REQ_GET_AOCS_CFG, FALSE, mtlk_aocs_cfg_t, aocs_cfg)
2710 MTLK_CFG_GET_ITEM(aocs_cfg, udp_msdu_threshold_aocs, *(uint32*)data);
2711
2712 _DF_USER_GET_ON_PARAM(PRM_ID_AOCS_MEASUREMENT_WINDOW, MTLK_CORE_REQ_GET_AOCS_CFG, FALSE, mtlk_aocs_cfg_t, aocs_cfg)
2713 MTLK_CFG_GET_ITEM(aocs_cfg, tcp_measurement_window, *(uint32*)data);
2714
2715 _DF_USER_GET_ON_PARAM(PRM_ID_AOCS_THROUGHPUT_THRESHOLD, MTLK_CORE_REQ_GET_AOCS_CFG, FALSE, mtlk_aocs_cfg_t, aocs_cfg)
2716 MTLK_CFG_GET_ITEM(aocs_cfg, tcp_throughput_threshold, *(uint32*)data);
2717
2718 _DF_USER_GET_ON_PARAM(PRM_ID_AOCS_NON_OCCUPANCY_PERIOD, MTLK_CORE_REQ_GET_AOCS_CFG, FALSE, mtlk_aocs_cfg_t, aocs_cfg)
2719 MTLK_CFG_GET_ITEM(aocs_cfg, dbg_non_occupied_period, *(uint32*)data);
2720
2721 _DF_USER_GET_ON_PARAM(PRM_ID_AOCS_RESTRICT_MODE, MTLK_CORE_REQ_GET_AOCS_CFG, FALSE, mtlk_aocs_cfg_t, aocs_cfg)
2722 MTLK_CFG_GET_ITEM(aocs_cfg, restrict_mode, *(uint32*)data);
2723
2724 _DF_USER_GET_ON_PARAM(PRM_ID_AOCS_RESTRICTED_CHANNELS, MTLK_CORE_REQ_GET_AOCS_CFG, FALSE, mtlk_aocs_cfg_t, aocs_cfg)
2725 MTLK_CFG_GET_ITEM_BY_FUNC(aocs_cfg, restricted_channels, _mtlk_df_user_print_restricted_ch,
2726 (data, TEXT_SIZE, aocs_cfg->restricted_channels), *length);
2727
2728 _DF_USER_GET_ON_PARAM(PRM_ID_AOCS_MSDU_TX_AC, MTLK_CORE_REQ_GET_AOCS_CFG, FALSE, mtlk_aocs_cfg_t, aocs_cfg)
2729 MTLK_CFG_GET_ITEM_BY_FUNC(aocs_cfg, msdu_tx_ac, _mtlk_df_user_print_msdu_ac,
2730 (data, TEXT_SIZE, &aocs_cfg->msdu_tx_ac), *length);
2731
2732 _DF_USER_GET_ON_PARAM(PRM_ID_AOCS_MSDU_RX_AC, MTLK_CORE_REQ_GET_AOCS_CFG, FALSE, mtlk_aocs_cfg_t, aocs_cfg)
2733 MTLK_CFG_GET_ITEM_BY_FUNC(aocs_cfg, msdu_rx_ac, _mtlk_df_user_print_msdu_ac,
2734 (data, TEXT_SIZE, &aocs_cfg->msdu_rx_ac), *length);
2735
2736 _DF_USER_GET_ON_PARAM(PRM_ID_AOCS_NON_WIFI_NOISE, MTLK_CORE_REQ_GET_AOCS_CFG, FALSE, mtlk_aocs_cfg_t, aocs_cfg)
2737 MTLK_CFG_GET_ITEM_BY_FUNC_VOID(aocs_cfg, non_wifi_interf, _mtlk_df_user_get_intvec_by_interf_params,
2738 ((int32*)data, length, &aocs_cfg->non_wifi_interf));
2739
2740 _DF_USER_GET_ON_PARAM(PRM_ID_11H_RADAR_DETECTION, MTLK_CORE_REQ_GET_DOT11H_CFG, FALSE, mtlk_11h_cfg_t, dot11h_cfg)
2741 MTLK_CFG_GET_ITEM(dot11h_cfg, radar_detect, *(uint32*)data);
2742
2743 _DF_USER_GET_ON_PARAM(PRM_ID_11H_STATUS, MTLK_CORE_REQ_GET_DOT11H_CFG, FALSE, mtlk_11h_cfg_t, dot11h_cfg)
2744 MTLK_CFG_GET_ITEM_BY_FUNC_VOID(dot11h_cfg, status, strcpy, (data, dot11h_cfg->status));
2745 *length = strlen(dot11h_cfg->status);
2746
2747 _DF_USER_GET_ON_PARAM(PRM_ID_11H_BEACON_COUNT, MTLK_CORE_REQ_GET_DOT11H_AP_CFG, FALSE, mtlk_11h_ap_cfg_t, dot11h_cfg)
2748 MTLK_CFG_GET_ITEM(dot11h_cfg, debugChannelSwitchCount, *(uint32*)data);
2749
2750 _DF_USER_GET_ON_PARAM(PRM_ID_11H_CHANNEL_AVAILABILITY_CHECK_TIME, MTLK_CORE_REQ_GET_DOT11H_AP_CFG, FALSE, mtlk_11h_ap_cfg_t, dot11h_cfg)
2751 MTLK_CFG_GET_ITEM(dot11h_cfg, debugChannelAvailabilityCheckTime, *(uint32*)data);
2752
2753 _DF_USER_GET_ON_PARAM(PRM_ID_11H_ENABLE_SM_CHANNELS, MTLK_CORE_REQ_GET_DOT11H_AP_CFG, FALSE, mtlk_11h_ap_cfg_t, dot11h_cfg)
2754 MTLK_CFG_GET_ITEM(dot11h_cfg, enable_sm_required, *(uint32*)data);
2755
2756 _DF_USER_GET_ON_PARAM(PRM_ID_11H_NEXT_CHANNEL, MTLK_CORE_REQ_GET_DOT11H_AP_CFG, FALSE, mtlk_11h_ap_cfg_t, dot11h_cfg)
2757 MTLK_CFG_GET_ITEM(dot11h_cfg, next_channel, *(uint32*)data);
2758
2759 _DF_USER_GET_ON_PARAM(MIB_ACL_MODE, MTLK_CORE_REQ_GET_MIBS_CFG, FALSE, mtlk_mibs_cfg_t, mibs_cfg)
2760 MTLK_CFG_GET_ITEM(mibs_cfg, acl_mode, *(uint32*)data);
2761
2762 _DF_USER_GET_ON_PARAM(PRM_ID_VAP_STA_LIMS, MTLK_CORE_REQ_MBSS_GET_VARS, FALSE, mtlk_mbss_cfg_t, mbss_cfg)
2763 MTLK_CFG_GET_ITEM_BY_FUNC_VOID(mbss_cfg, vap_limits, _mtlk_df_get_vap_limits_cfg,
2764 (mbss_cfg, &((uint32*)data)[0], &((uint32*)data)[1]));
2765 *length = VAP_LIMIT_SET_SIZE;
2766
2767 _DF_USER_GET_ON_PARAM(MIB_CALIBRATION_ALGO_MASK, MTLK_CORE_REQ_GET_MIBS_CFG, FALSE, mtlk_mibs_cfg_t, mibs_cfg)
2768 MTLK_CFG_GET_ITEM(mibs_cfg, calibr_algo_mask, *(uint32*)data);
2769
2770 _DF_USER_GET_ON_PARAM(PRM_USE_SHORT_CYCLIC_PREFIX_RX, MTLK_CORE_REQ_GET_MIBS_CFG, FALSE, mtlk_mibs_cfg_t, mibs_cfg)
2771 MTLK_CFG_GET_ITEM(mibs_cfg, short_cyclic_prefix_rx, *(uint32*)data);
2772
2773 _DF_USER_GET_ON_PARAM(PRM_USE_SHORT_CYCLIC_PREFIX_TX, MTLK_CORE_REQ_GET_MIBS_CFG, FALSE, mtlk_mibs_cfg_t, mibs_cfg)
2774 MTLK_CFG_GET_ITEM(mibs_cfg, short_cyclic_prefix_tx, *(uint32*)data);
2775
2776 _DF_USER_GET_ON_PARAM(PRM_USE_SHORT_CYCLIC_PREFIX_RATE31, MTLK_CORE_REQ_GET_MIBS_CFG, FALSE, mtlk_mibs_cfg_t, mibs_cfg)
2777 MTLK_CFG_GET_ITEM(mibs_cfg, short_cyclic_prefix_rate31, *(uint32*)data);
2778
2779 _DF_USER_GET_ON_PARAM(PRM_ID_SHORT_PREAMBLE_OPTION_IMPLEMENTED, MTLK_CORE_REQ_GET_MIBS_CFG, FALSE, mtlk_mibs_cfg_t, mibs_cfg)
2780 MTLK_CFG_GET_ITEM(mibs_cfg, short_preamble_option, *(uint32*)data);
2781
2782 _DF_USER_GET_ON_PARAM(PRM_ID_SHORT_SLOT_TIME_OPTION_ENABLED_11G, MTLK_CORE_REQ_GET_MIBS_CFG, FALSE, mtlk_mibs_cfg_t, mibs_cfg)
2783 MTLK_CFG_GET_ITEM(mibs_cfg, short_slot_time_option, *(uint32*)data);
2784
2785 _DF_USER_GET_ON_PARAM(MIB_SHORT_RETRY_LIMIT, MTLK_CORE_REQ_GET_MIBS_CFG, FALSE, mtlk_mibs_cfg_t, mibs_cfg)
2786 MTLK_CFG_GET_ITEM(mibs_cfg, short_retry_limit, *(uint32*)data);
2787
2788 _DF_USER_GET_ON_PARAM(MIB_LONG_RETRY_LIMIT, MTLK_CORE_REQ_GET_MIBS_CFG, FALSE, mtlk_mibs_cfg_t, mibs_cfg)
2789 MTLK_CFG_GET_ITEM(mibs_cfg, long_retry_limit, *(uint32*)data);
2790
2791 _DF_USER_GET_ON_PARAM(MIB_TX_MSDU_LIFETIME, MTLK_CORE_REQ_GET_MIBS_CFG, FALSE, mtlk_mibs_cfg_t, mibs_cfg)
2792 MTLK_CFG_GET_ITEM(mibs_cfg, tx_msdu_lifetime, *(uint32*)data);
2793
2794 _DF_USER_GET_ON_PARAM(MIB_CURRENT_TX_ANTENNA, MTLK_CORE_REQ_GET_MIBS_CFG, FALSE, mtlk_mibs_cfg_t, mibs_cfg)
2795 MTLK_CFG_GET_ITEM(mibs_cfg, current_tx_antenna, *(uint32*)data);
2796
2797 _DF_USER_GET_ON_PARAM(MIB_BEACON_PERIOD, MTLK_CORE_REQ_GET_MIBS_CFG, FALSE, mtlk_mibs_cfg_t, mibs_cfg)
2798 MTLK_CFG_GET_ITEM(mibs_cfg, beacon_period, *(uint32*)data);
2799
2800 _DF_USER_GET_ON_PARAM(MIB_DISCONNECT_ON_NACKS_WEIGHT, MTLK_CORE_REQ_GET_MIBS_CFG, FALSE, mtlk_mibs_cfg_t, mibs_cfg)
2801 MTLK_CFG_GET_ITEM(mibs_cfg, disconnect_on_nacks_weight, *(uint32*)data);
2802
2803 _DF_USER_GET_ON_PARAM(MIB_SM_ENABLE, MTLK_CORE_REQ_GET_MIBS_CFG, FALSE, mtlk_mibs_cfg_t, mibs_cfg)
2804 MTLK_CFG_GET_ITEM(mibs_cfg, sm_enable, *(uint32*)data);
2805
2806 _DF_USER_GET_ON_PARAM(MIB_ADVANCED_CODING_SUPPORTED, MTLK_CORE_REQ_GET_MIBS_CFG, FALSE, mtlk_mibs_cfg_t, mibs_cfg)
2807 MTLK_CFG_GET_ITEM(mibs_cfg, advanced_coding_supported, *(uint32*)data);
2808
2809 _DF_USER_GET_ON_PARAM(MIB_OVERLAPPING_PROTECTION_ENABLE, MTLK_CORE_REQ_GET_MIBS_CFG, FALSE, mtlk_mibs_cfg_t, mibs_cfg)
2810 MTLK_CFG_GET_ITEM(mibs_cfg, overlapping_protect_enabled, *(uint32*)data);
2811
2812 _DF_USER_GET_ON_PARAM(MIB_OFDM_PROTECTION_METHOD, MTLK_CORE_REQ_GET_MIBS_CFG, FALSE, mtlk_mibs_cfg_t, mibs_cfg)
2813 MTLK_CFG_GET_ITEM(mibs_cfg, ofdm_protect_method, *(uint32*)data);
2814
2815 _DF_USER_GET_ON_PARAM(MIB_HT_PROTECTION_METHOD, MTLK_CORE_REQ_GET_MIBS_CFG, FALSE, mtlk_mibs_cfg_t, mibs_cfg)
2816 MTLK_CFG_GET_ITEM(mibs_cfg, ht_method, *(uint32*)data);
2817
2818 _DF_USER_GET_ON_PARAM(MIB_DTIM_PERIOD, MTLK_CORE_REQ_GET_MIBS_CFG, FALSE, mtlk_mibs_cfg_t, mibs_cfg)
2819 MTLK_CFG_GET_ITEM(mibs_cfg, dtim_period, *(uint32*)data);
2820
2821 _DF_USER_GET_ON_PARAM(MIB_RECEIVE_AMPDU_MAX_LENGTH, MTLK_CORE_REQ_GET_MIBS_CFG, FALSE, mtlk_mibs_cfg_t, mibs_cfg)
2822 MTLK_CFG_GET_ITEM(mibs_cfg, receive_ampdu_max_len, *(uint32*)data);
2823
2824 _DF_USER_GET_ON_PARAM(MIB_CB_DATABINS_PER_SYMBOL, MTLK_CORE_REQ_GET_MIBS_CFG, FALSE, mtlk_mibs_cfg_t, mibs_cfg)
2825 MTLK_CFG_GET_ITEM(mibs_cfg, cb_databins_per_symbol, *(uint32*)data);
2826
2827 _DF_USER_GET_ON_PARAM(MIB_USE_LONG_PREAMBLE_FOR_MULTICAST, MTLK_CORE_REQ_GET_MIBS_CFG, FALSE, mtlk_mibs_cfg_t, mibs_cfg)
2828 MTLK_CFG_GET_ITEM(mibs_cfg, use_long_preamble_for_multicast, *(uint32*)data);
2829
2830 _DF_USER_GET_ON_PARAM(MIB_USE_SPACE_TIME_BLOCK_CODE, MTLK_CORE_REQ_GET_MIBS_CFG, FALSE, mtlk_mibs_cfg_t, mibs_cfg)
2831 MTLK_CFG_GET_ITEM(mibs_cfg, use_space_time_block_code, *(uint32*)data);
2832
2833 _DF_USER_GET_ON_PARAM(MIB_TWO_ANTENNA_TRANSMISSION_ENABLE, MTLK_CORE_REQ_GET_MIBS_CFG, FALSE, mtlk_mibs_cfg_t, mibs_cfg)
2834 if (mtlk_vap_is_master(mtlk_df_get_vap_handle(df_user->df))) {
2835 MTLK_CFG_GET_ITEM(mibs_cfg, two_antenna_tx_enable, *(uint32*)data);
2836 } else {
2837 res = MTLK_ERR_NOT_SUPPORTED;
2838 }
2839
2840 _DF_USER_GET_ON_PARAM(MIB_ONLINE_CALIBRATION_ALGO_MASK, MTLK_CORE_REQ_GET_MIBS_CFG, FALSE, mtlk_mibs_cfg_t, mibs_cfg)
2841 MTLK_CFG_GET_ITEM(mibs_cfg, online_calibr_algo_mask, *(uint32*)data);
2842
2843 _DF_USER_GET_ON_PARAM(MIB_DISCONNECT_ON_NACKS_ENABLE, MTLK_CORE_REQ_GET_MIBS_CFG, FALSE, mtlk_mibs_cfg_t, mibs_cfg)
2844 MTLK_CFG_GET_ITEM(mibs_cfg, disconnect_on_nacks_enable, *(uint32*)data);
2845
2846 _DF_USER_GET_ON_PARAM(MIB_RTS_THRESHOLD, MTLK_CORE_REQ_GET_MIBS_CFG, FALSE, mtlk_mibs_cfg_t, mibs_cfg)
2847 MTLK_CFG_GET_ITEM(mibs_cfg, rts_threshold, *(uint32*)data);
2848
2849 _DF_USER_GET_ON_PARAM(MIB_TX_POWER, MTLK_CORE_REQ_GET_MIBS_CFG, FALSE, mtlk_mibs_cfg_t, mibs_cfg)
2850 MTLK_CFG_GET_ITEM(mibs_cfg, tx_power, *(uint32*)data);
2851
2852 _DF_USER_GET_ON_PARAM(MIB_SUPPORTED_TX_ANTENNAS, MTLK_CORE_REQ_GET_MIBS_CFG, FALSE, mtlk_mibs_cfg_t, mibs_cfg)
2853 MTLK_CFG_GET_ITEM_BY_FUNC_VOID(mibs_cfg, tx_antennas, strncpy,
2854 (data, mibs_cfg->tx_antennas, MTLK_NUM_ANTENNAS_BUFSIZE));
2855 *length = MTLK_NUM_ANTENNAS_BUFSIZE;
2856
2857 _DF_USER_GET_ON_PARAM(MIB_SUPPORTED_RX_ANTENNAS, MTLK_CORE_REQ_GET_MIBS_CFG, FALSE, mtlk_mibs_cfg_t, mibs_cfg)
2858 MTLK_CFG_GET_ITEM_BY_FUNC_VOID(mibs_cfg, rx_antennas, strncpy,
2859 (data, mibs_cfg->rx_antennas, MTLK_NUM_ANTENNAS_BUFSIZE));
2860 *length = MTLK_NUM_ANTENNAS_BUFSIZE;
2861
2862 _DF_USER_GET_ON_PARAM(PRM_ID_HIDDEN_SSID, MTLK_CORE_REQ_GET_CORE_CFG, FALSE, mtlk_gen_core_cfg_t, core_cfg)
2863 MTLK_CFG_GET_ITEM(core_cfg, is_hidden_ssid, *(uint32*)data);
2864
2865 _DF_USER_GET_ON_PARAM(MIB_COUNTRY, MTLK_CORE_REQ_GET_COUNTRY_CFG, FALSE, mtlk_country_cfg_t, country_cfg)
2866 MTLK_CFG_GET_ITEM_BY_FUNC_VOID(country_cfg, country, strncpy,
2867 (data, country_cfg->country, MTLK_CHNLS_COUNTRY_BUFSIZE));
2868 *length = MTLK_CHNLS_COUNTRY_BUFSIZE;
2869
2870 _DF_USER_GET_ON_PARAM(PRM_ID_L2NAT_AGING_TIMEOUT, MTLK_CORE_REQ_GET_L2NAT_CFG, FALSE, mtlk_l2nat_cfg_t, l2nat_cfg)
2871 MTLK_CFG_GET_ITEM(l2nat_cfg, aging_timeout, *(uint32*)data);
2872
2873 _DF_USER_GET_ON_PARAM(PRM_ID_L2NAT_DEFAULT_HOST, MTLK_CORE_REQ_GET_L2NAT_CFG, FALSE, mtlk_l2nat_cfg_t, l2nat_cfg)
2874 MTLK_CFG_GET_ITEM_BY_FUNC_VOID(l2nat_cfg, address, memcpy, ((*(struct sockaddr*)data).sa_data, l2nat_cfg->address.au8Addr, ETH_ALEN));
2875
2876 _DF_USER_GET_ON_PARAM(PRM_ID_PEERAP_KEY_IDX, MTLK_CORE_REQ_GET_WDS_CFG, FALSE, mtlk_wds_cfg_t, wds_cfg)
2877 MTLK_CFG_GET_ITEM(wds_cfg, peer_ap_key_idx, *(uint32*)data);
2878
2879 _DF_USER_GET_ON_PARAM(PRM_ID_PEERAP_LIST, MTLK_CORE_REQ_GET_WDS_PEERAP, FALSE, mtlk_wds_cfg_t, wds_cfg)
2880 MTLK_CFG_GET_ITEM_BY_FUNC_VOID(wds_cfg, peer_ap_vect, _mtlk_df_user_addr_vect_to_text, (data, wds_cfg->peer_ap_vect, length, TEXT_SIZE));
2881 mtlk_clpb_delete(wds_cfg->peer_ap_vect);
2882 wds_cfg->peer_ap_vect = NULL;
2883
2884 _DF_USER_GET_ON_PARAM(PRM_ID_11D, MTLK_CORE_REQ_GET_DOT11D_CFG, FALSE, mtlk_dot11d_cfg_t, dot11d_cfg)
2885 MTLK_CFG_GET_ITEM(dot11d_cfg, is_dot11d, *(uint32*)data);
2886
2887 _DF_USER_GET_ON_PARAM(PRM_ID_MAC_WATCHDOG_TIMEOUT_MS, MTLK_CORE_REQ_GET_MAC_WATCHDOG_CFG, FALSE, mtlk_mac_wdog_cfg_t, mac_wdog_cfg)
2888 MTLK_CFG_GET_ITEM(mac_wdog_cfg, mac_watchdog_timeout_ms, *(uint32*)data);
2889
2890 _DF_USER_GET_ON_PARAM(PRM_ID_MAC_WATCHDOG_PERIOD_MS, MTLK_CORE_REQ_GET_MAC_WATCHDOG_CFG, FALSE, mtlk_mac_wdog_cfg_t, mac_wdog_cfg)
2891 MTLK_CFG_GET_ITEM(mac_wdog_cfg, mac_watchdog_period_ms, *(uint32*)data);
2892
2893 _DF_USER_GET_ON_PARAM(PRM_ID_STA_KEEPALIVE_TIMEOUT, MTLK_CORE_REQ_GET_STADB_CFG, FALSE, mtlk_stadb_cfg_t, stadb_cfg)
2894 MTLK_CFG_GET_ITEM(stadb_cfg, sta_keepalive_timeout, *(uint32*)data);
2895
2896 _DF_USER_GET_ON_PARAM(PRM_ID_STA_KEEPALIVE_INTERVAL, MTLK_CORE_REQ_GET_STADB_CFG, FALSE, mtlk_stadb_cfg_t, stadb_cfg)
2897 MTLK_CFG_GET_ITEM(stadb_cfg, keepalive_interval, *(uint32*)data);
2898
2899 _DF_USER_GET_ON_PARAM(PRM_ID_AGGR_OPEN_THRESHOLD, MTLK_CORE_REQ_GET_STADB_CFG, FALSE, mtlk_stadb_cfg_t, stadb_cfg)
2900 MTLK_CFG_GET_ITEM(stadb_cfg, aggr_open_threshold, *(uint32*)data);
2901
2902 _DF_USER_GET_ON_PARAM(PRM_ID_BRIDGE_MODE, MTLK_CORE_REQ_GET_CORE_CFG, FALSE, mtlk_gen_core_cfg_t, core_cfg)
2903 MTLK_CFG_GET_ITEM(core_cfg, bridge_mode, *(uint32*)data);
2904
2905 _DF_USER_GET_ON_PARAM(PRM_ID_DBG_SW_WD_ENABLE, MTLK_CORE_REQ_GET_CORE_CFG, FALSE, mtlk_gen_core_cfg_t, core_cfg)
2906 MTLK_CFG_GET_ITEM(core_cfg, dbg_sw_wd_enable, *(uint32*)data);
2907
2908 _DF_USER_GET_ON_PARAM(PRM_ID_RELIABLE_MULTICAST, MTLK_CORE_REQ_GET_CORE_CFG, FALSE, mtlk_gen_core_cfg_t, core_cfg)
2909 MTLK_CFG_GET_ITEM(core_cfg, reliable_multicast, *(uint32*)data);
2910
2911 _DF_USER_GET_ON_PARAM(PRM_ID_UP_RESCAN_EXEMPTION_TIME, MTLK_CORE_REQ_GET_CORE_CFG, FALSE, mtlk_gen_core_cfg_t, core_cfg)
2912 MTLK_CFG_GET_ITEM(core_cfg, up_rescan_exemption_time, *(uint32*)data);
2913
2914 _DF_USER_GET_ON_PARAM(PRM_ID_AP_FORWARDING, MTLK_CORE_REQ_GET_CORE_CFG, FALSE, mtlk_gen_core_cfg_t, core_cfg)
2915 MTLK_CFG_GET_ITEM(core_cfg, ap_forwarding, *(uint32*)data);
2916
2917 _DF_USER_GET_ON_PARAM(PRM_ID_SPECTRUM_MODE, MTLK_CORE_REQ_GET_CORE_CFG, FALSE, mtlk_gen_core_cfg_t, core_cfg)
2918 MTLK_CFG_GET_ITEM(core_cfg, spectrum_mode, *(uint32*)data);
2919
2920 _DF_USER_GET_ON_PARAM(PRM_ID_NETWORK_MODE, MTLK_CORE_REQ_GET_CORE_CFG, FALSE, mtlk_gen_core_cfg_t, core_cfg)
2921 MTLK_CFG_GET_ITEM(core_cfg, net_mode, *(uint32*)data);
2922 *(uint32*)data = _net_mode_egress_filter(*(uint32*)data);
2923
2924 _DF_USER_GET_ON_PARAM(PRM_ID_BSS_BASIC_RATE_SET, MTLK_CORE_REQ_GET_CORE_CFG, FALSE, mtlk_gen_core_cfg_t, core_cfg)
2925 MTLK_CFG_GET_ITEM(core_cfg, basic_rates, *(uint32*)data);
2926
2927 _DF_USER_GET_ON_PARAM(PRM_ID_BSS_SUPPORTED_RATE_SET, MTLK_CORE_REQ_GET_CORE_CFG, FALSE, mtlk_gen_core_cfg_t, core_cfg)
2928 MTLK_CFG_GET_ITEM(core_cfg, supported_rates, *(uint32*)data);
2929
2930 _DF_USER_GET_ON_PARAM(PRM_ID_BSS_EXTENDED_RATE_SET, MTLK_CORE_REQ_GET_CORE_CFG, FALSE, mtlk_gen_core_cfg_t, core_cfg)
2931 MTLK_CFG_GET_ITEM(core_cfg, extended_rates, *(uint32*)data);
2932
2933 _DF_USER_GET_ON_PARAM(PRM_ID_CHANNEL, MTLK_CORE_REQ_GET_CORE_CFG, FALSE, mtlk_gen_core_cfg_t, core_cfg)
2934 MTLK_CFG_GET_ITEM(core_cfg, channel, *(uint32*)data);
2935
2936 _DF_USER_GET_ON_PARAM(PRM_ID_POWER_SELECTION, MTLK_CORE_REQ_GET_MASTER_CFG, FALSE, mtlk_master_core_cfg_t, master_cfg)
2937 MTLK_CFG_GET_ITEM(master_cfg, power_selection, *(uint32*)data);
2938
2939 _DF_USER_GET_ON_PARAM(PRM_ID_RX_HIGH_THRESHOLD, MTLK_CORE_REQ_GET_MASTER_CFG, FALSE, mtlk_master_core_cfg_t, master_cfg)
2940 MTLK_CFG_GET_ITEM(master_cfg, rx_high_threshold, *(uint32*)data);
2941
2942 _DF_USER_GET_ON_PARAM(PRM_ID_CCA_THRESHOLD, MTLK_CORE_REQ_GET_MASTER_CFG, FALSE, mtlk_master_core_cfg_t, master_cfg)
2943 MTLK_CFG_GET_ITEM(master_cfg, cca_threshold, *(uint32*)data);
2944
2945 _DF_USER_GET_ON_PARAM(PRM_ID_RA_PROTECTION, MTLK_CORE_REQ_GET_MASTER_CFG, FALSE, mtlk_master_core_cfg_t, master_cfg)
2946 MTLK_CFG_GET_ITEM(master_cfg, ra_protection, *(uint32*)data);
2947
2948 _DF_USER_GET_ON_PARAM(PRM_ID_FORCE_NCB, MTLK_CORE_REQ_GET_MASTER_CFG, FALSE, mtlk_master_core_cfg_t, master_cfg)
2949 MTLK_CFG_GET_ITEM(master_cfg, force_ncb, *(uint32*)data);
2950
2951 _DF_USER_GET_ON_PARAM(PRM_ID_N_RATES_BOS, MTLK_CORE_REQ_GET_MASTER_CFG, FALSE, mtlk_master_core_cfg_t, master_cfg)
2952 MTLK_CFG_GET_ITEM_BY_FUNC_VOID(master_cfg, n_rate_bo,
2953 _mtlk_df_user_get_intvec_by_n_rate_bo, ((int32*)data, length, &master_cfg->n_rate_bo));
2954
2955 _DF_USER_GET_ON_PARAM(PRM_ID_DEBUG_TPC, MTLK_CORE_REQ_GET_MASTER_CFG, FALSE, mtlk_master_core_cfg_t, master_cfg)
2956 MTLK_CFG_GET_ITEM(master_cfg, debug_tpc, *(uint32*)data);
2957
2958 _DF_USER_GET_ON_PARAM(PRM_ID_VAP_LNA_GAINS, MTLK_CORE_REQ_GET_MASTER_CFG, FALSE, mtlk_master_core_cfg_t, master_cfg)
2959 MTLK_CFG_GET_ITEM_BY_FUNC_VOID(master_cfg, lna_gain, _mtlk_df_user_intvec_by_lna_gain,
2960 ((uint32*)data, length, &master_cfg->lna_gain));
2961
2962 _DF_USER_GET_ON_PARAM(PRM_ID_CORE_COUNTRIES_SUPPORTED, MTLK_CORE_REQ_GET_CORE_CFG, FALSE, mtlk_gen_core_cfg_t, core_cfg)
2963 MTLK_CFG_GET_ITEM_BY_FUNC_VOID(core_cfg, countries_supported,
2964 _mtlk_df_user_countries_supported_to_str, (core_cfg->countries_supported, data, TEXT_SIZE));
2965 *length = TEXT_SIZE;
2966
2967 _DF_USER_GET_ON_PARAM(PRM_ID_NICK_NAME, MTLK_CORE_REQ_GET_CORE_CFG, FALSE, mtlk_gen_core_cfg_t, core_cfg)
2968 MTLK_CFG_GET_ITEM_BY_FUNC_VOID(core_cfg, nickname,
2969 memcpy, (data, core_cfg->nickname, IW_ESSID_MAX_SIZE));
2970 *length = strnlen(data, IW_ESSID_MAX_SIZE);
2971
2972 _DF_USER_GET_ON_PARAM(PRM_ID_ESSID, MTLK_CORE_REQ_GET_CORE_CFG, FALSE, mtlk_gen_core_cfg_t, core_cfg)
2973 MTLK_CFG_GET_ITEM_BY_FUNC_VOID(core_cfg, essid,
2974 memcpy, (data, core_cfg->essid, IW_ESSID_MAX_SIZE));
2975 *length = strnlen(data, IW_ESSID_MAX_SIZE);
2976
2977 _DF_USER_GET_ON_PARAM(PRM_ID_BSSID, MTLK_CORE_REQ_GET_CORE_CFG, FALSE, mtlk_gen_core_cfg_t, core_cfg)
2978 MTLK_CFG_GET_ITEM_BY_FUNC_VOID(core_cfg, bssid, memcpy,
2979 (data, core_cfg->bssid, ETH_ALEN));
2980 *length = ETH_ALEN;
2981
2982 _DF_USER_GET_ON_PARAM(PRM_ID_LEGACY_FORCE_RATE, MTLK_CORE_REQ_GET_MASTER_CFG, FALSE, mtlk_master_core_cfg_t, master_cfg)
2983 MTLK_CFG_GET_ITEM_BY_FUNC_VOID(master_cfg, legacy_force_rate, _mtlk_df_user_bitrate_to_str,
2984 (&master_cfg->legacy_force_rate, data, TEXT_SIZE));
2985 *length = TEXT_SIZE;
2986
2987 _DF_USER_GET_ON_PARAM(PRM_ID_HT_FORCE_RATE, MTLK_CORE_REQ_GET_MASTER_CFG, FALSE, mtlk_master_core_cfg_t, master_cfg)
2988 MTLK_CFG_GET_ITEM_BY_FUNC_VOID(master_cfg, ht_force_rate, _mtlk_df_user_bitrate_to_str,
2989 (&master_cfg->ht_force_rate, data, TEXT_SIZE));
2990 *length = TEXT_SIZE;
2991
2992 _DF_USER_GET_ON_PARAM(PRM_ID_AGG_RATE_LIMIT, MTLK_CORE_REQ_GET_MASTER_CFG, FALSE, mtlk_master_core_cfg_t, master_cfg)
2993 MTLK_CFG_GET_ITEM_BY_FUNC_VOID(master_cfg, agg_rate_limit, _mtlk_df_user_intvec_by_agg_rate_limit,
2994 ((uint32*)data, length, &master_cfg->agg_rate_limit));
2995
2996 _DF_USER_GET_ON_PARAM(PRM_ID_RX_DUTY_CYCLE, MTLK_CORE_REQ_GET_MASTER_CFG, FALSE, mtlk_master_core_cfg_t, master_cfg)
2997 MTLK_CFG_GET_ITEM_BY_FUNC_VOID(master_cfg, rx_duty_cycle, _mtlk_df_user_intvec_by_rx_duty_cycle,
2998 ((uint32*)data, length, &master_cfg->rx_duty_cycle));
2999
3000 _DF_USER_GET_ON_PARAM(PRM_ID_ACL, MTLK_CORE_REQ_GET_CORE_CFG, FALSE, mtlk_gen_core_cfg_t, core_cfg)
3001 int i;
3002 MTLK_CFG_GET_ITEM(core_cfg, num_macs_to_set, *length);
3003 MTLK_ASSERT(*length <= MAX_ADDRESSES_IN_ACL);
3004 for (i=0; i<*length; i++) {
3005 MTLK_CFG_GET_ITEM_BY_FUNC_VOID(core_cfg, macs_to_set, memcpy,
3006 (((struct sockaddr*)data)[i].sa_data, core_cfg->macs_to_set[i].au8Addr,sizeof(core_cfg->macs_to_set[i].au8Addr)))
3007 }
3008
3009 _DF_USER_GET_ON_PARAM(PRM_ID_ACL_RANGE, MTLK_CORE_REQ_GET_CORE_CFG, FALSE, mtlk_gen_core_cfg_t, core_cfg)
3010 int i, num_ranges;
3011 MTLK_CFG_GET_ITEM(core_cfg, num_macs_to_set, *length);
3012 MTLK_ASSERT(*length <= MAX_ADDRESSES_IN_ACL);
3013 for (i=0, num_ranges=0; i<*length; i++) {
3014 if (mtlk_osal_compare_eth_addresses(EMPTY_MAC_MASK.au8Addr, core_cfg->mac_mask[i].au8Addr)) {
3015 MTLK_CFG_GET_ITEM_BY_FUNC_VOID(core_cfg, macs_to_set, memcpy,
3016 (((struct sockaddr*)data)[num_ranges << 1].sa_data, core_cfg->macs_to_set[i].au8Addr,sizeof(core_cfg->macs_to_set[i].au8Addr)))
3017 MTLK_CFG_GET_ITEM_BY_FUNC_VOID(core_cfg, macs_to_set, memcpy,
3018 (((struct sockaddr*)data)[(num_ranges << 1) + 1].sa_data, core_cfg->mac_mask[i].au8Addr,sizeof(core_cfg->mac_mask[i].au8Addr)))
3019 num_ranges++;
3020 }
3021 }
3022 *length = num_ranges << 1;
3023
3024 _DF_USER_GET_ON_PARAM(PRM_ID_ACTIVE_SCAN_SSID, MTLK_CORE_REQ_GET_SCAN_CFG, FALSE, mtlk_scan_cfg_t, scan_cfg)
3025 MTLK_CFG_GET_ITEM_BY_FUNC_VOID(scan_cfg, essid, strncpy,
3026 (data, scan_cfg->essid, MIB_ESSID_LENGTH + 1));
3027 *length = MIB_ESSID_LENGTH + 1;
3028
3029 _DF_USER_GET_ON_PARAM(PRM_ID_EEPROM, MTLK_CORE_REQ_GET_EEPROM_CFG, FALSE, mtlk_eeprom_cfg_t, eeprom_cfg)
3030 /* TODO: incorrect implementation, is_if_stopped flag must be dropped in favor of abilities or internal core logic */
3031 BOOL is_if_stopped = FALSE;
3032 MTLK_CFG_GET_ITEM(eeprom_cfg, is_if_stopped, is_if_stopped);
3033
3034 if (is_if_stopped) {
3035 int used_len = 0;
3036 *length = 0;
3037 MTLK_CFG_GET_ITEM_BY_FUNC(eeprom_cfg, eeprom_data, _mtlk_df_user_print_eeprom,
3038 (&eeprom_cfg->eeprom_data, data, TEXT_SIZE), used_len);
3039 *length += used_len;
3040 MTLK_ASSERT(*length <= TEXT_SIZE);
3041
3042 MTLK_CFG_GET_ITEM_BY_FUNC(eeprom_cfg, eeprom_raw_data, _mtlk_df_user_print_raw_eeprom,
3043 (eeprom_cfg->eeprom_raw_data, sizeof(eeprom_cfg->eeprom_raw_data), data+*length, TEXT_SIZE-*length), used_len);
3044 *length += used_len;
3045 MTLK_ASSERT(*length <= TEXT_SIZE);
3046 }
3047 else {
3048 *length = mtlk_snprintf(data, TEXT_SIZE, "EE data is not available since IF is up\n");
3049 }
3050
3051 _DF_USER_GET_ON_PARAM(PRM_ID_TX_POWER_LIMIT, MTLK_CORE_REQ_GET_TX_POWER_LIMIT, FALSE,
3052 mtlk_tx_power_limit_cfg_t, tx_power_limit_cfg)
3053 MTLK_CFG_GET_ITEM(tx_power_limit_cfg, field_01, ((int32*)data)[0]);
3054 MTLK_CFG_GET_ITEM(tx_power_limit_cfg, field_02, ((int32*)data)[1]);
3055 MTLK_CFG_GET_ITEM(tx_power_limit_cfg, field_03, ((int32*)data)[2]);
3056 *length = 3;
3057
3058 _DF_USER_GET_ON_PARAM(PRM_ID_WDS_HOST_TIMEOUT, MTLK_CORE_REQ_GET_HSTDB_CFG, FALSE, mtlk_hstdb_cfg_t, hstdb_cfg)
3059 MTLK_CFG_GET_ITEM(hstdb_cfg, wds_host_timeout, *(uint32*)data);
3060
3061 _DF_USER_GET_ON_PARAM(PRM_ID_HSTDB_LOCAL_MAC, MTLK_CORE_REQ_GET_HSTDB_CFG, FALSE, mtlk_hstdb_cfg_t, hstdb_cfg)
3062 MTLK_CFG_GET_ITEM_BY_FUNC_VOID(hstdb_cfg, address, memcpy,
3063 (((struct sockaddr*)data)->sa_data, hstdb_cfg->address.au8Addr, ETH_ALEN));
3064
3065 _DF_USER_GET_ON_PARAM(PRM_ID_SCAN_CACHE_LIFETIME, MTLK_CORE_REQ_GET_SCAN_CFG, FALSE, mtlk_scan_cfg_t, scan_cfg)
3066 MTLK_CFG_GET_ITEM(scan_cfg, cache_expire, *(uint32*)data);
3067
3068 _DF_USER_GET_ON_PARAM(PRM_ID_BG_SCAN_CH_LIMIT, MTLK_CORE_REQ_GET_SCAN_CFG, FALSE, mtlk_scan_cfg_t, scan_cfg)
3069 MTLK_CFG_GET_ITEM(scan_cfg, channels_per_chunk_limit, *(uint32*)data);
3070
3071 _DF_USER_GET_ON_PARAM(PRM_ID_BG_SCAN_PAUSE, MTLK_CORE_REQ_GET_SCAN_CFG, FALSE, mtlk_scan_cfg_t, scan_cfg)
3072 MTLK_CFG_GET_ITEM(scan_cfg, pause_between_chunks, *(uint32*)data);
3073
3074 _DF_USER_GET_ON_PARAM(PRM_ID_IS_BACKGROUND_SCAN, MTLK_CORE_REQ_GET_SCAN_CFG, FALSE, mtlk_scan_cfg_t, scan_cfg)
3075 MTLK_CFG_GET_ITEM(scan_cfg, is_background_scan, *(uint32*)data);
3076
3077 _DF_USER_GET_ON_PARAM(PRM_ID_USE_8021Q, MTLK_CORE_REQ_GET_QOS_CFG, FALSE, mtlk_qos_cfg_t, qos_cfg)
3078 MTLK_CFG_GET_ITEM(qos_cfg, map, *(uint32*)data);
3079
3080 _DF_USER_GET_ON_PARAM(PRM_ID_COC_POWER_MODE, MTLK_CORE_REQ_GET_COC_CFG, FALSE, mtlk_coc_mode_cfg_t, coc_cfg)
3081 MTLK_CFG_GET_ITEM(coc_cfg, is_auto_mode, *(uint32*)data);
3082 MTLK_CFG_GET_ITEM_BY_FUNC_VOID(coc_cfg, antenna_params,
3083 _mtlk_df_user_get_intvec_by_antenna_params, ((uint32*)data, length, &coc_cfg->antenna_params));
3084
3085 _DF_USER_GET_ON_PARAM(PRM_ID_COC_AUTO_PARAMS, MTLK_CORE_REQ_GET_COC_CFG, FALSE, mtlk_coc_mode_cfg_t, coc_cfg)
3086 MTLK_CFG_GET_ITEM_BY_FUNC_VOID(coc_cfg, auto_params,
3087 _mtlk_df_user_get_intvec_by_auto_params, ((uint32*)data, length, &coc_cfg->auto_params));
3088
3089 #ifdef MTCFG_PMCU_SUPPORT
3090 _DF_USER_GET_ON_PARAM(PRM_ID_PCOC_POWER_MODE, MTLK_CORE_REQ_GET_PCOC_CFG, FALSE, mtlk_pcoc_mode_cfg_t, pcoc_cfg)
3091 MTLK_CFG_GET_ITEM(pcoc_cfg, is_enabled, ((uint32*)data)[0]);
3092 MTLK_CFG_GET_ITEM(pcoc_cfg, is_active, ((uint32*)data)[1]);
3093 MTLK_CFG_GET_ITEM(pcoc_cfg, traffic_state, ((uint32*)data)[2]);
3094 *length = 3;
3095
3096 _DF_USER_GET_ON_PARAM(PRM_ID_PCOC_AUTO_PARAMS, MTLK_CORE_REQ_GET_PCOC_CFG, FALSE, mtlk_pcoc_mode_cfg_t, pcoc_cfg)
3097 MTLK_CFG_GET_ITEM_BY_FUNC_VOID(pcoc_cfg, params,
3098 _mtlk_df_user_get_intvec_by_pcoc_params, ((uint32*)data, length, &pcoc_cfg->params));
3099 #endif
3100
3101 _DF_USER_GET_ON_PARAM(PRM_ID_SQ_LIMITS, MTLK_CORE_REQ_GET_SQ_CFG, FALSE, mtlk_sq_cfg_t, sq_cfg)
3102 MTLK_CFG_GET_ARRAY_ITEM(sq_cfg, sq_limit, (int32*)data, NTS_PRIORITIES);
3103 *length = NTS_PRIORITIES;
3104
3105 _DF_USER_GET_ON_PARAM(PRM_ID_SQ_PEER_LIMITS, MTLK_CORE_REQ_GET_SQ_CFG, FALSE, mtlk_sq_cfg_t, sq_cfg)
3106 MTLK_CFG_GET_ARRAY_ITEM(sq_cfg, peer_queue_limit, (int32*)data, NTS_PRIORITIES);
3107 *length = NTS_PRIORITIES;
3108
3109 /* 20/40 coexistence */
3110
3111 _DF_USER_GET_ON_PARAM(PRM_ID_COEX_MODE, MTLK_CORE_REQ_GET_COEX_20_40_MODE_CFG, FALSE, mtlk_coex_20_40_mode_cfg_t, coex20_40_cfg)
3112 MTLK_CFG_GET_ITEM(coex20_40_cfg, coexistence_mode, *(uint32*)data);
3113
3114 _DF_USER_GET_ON_PARAM(PRM_ID_COEX_THRESHOLD, MTLK_CORE_REQ_GET_COEX_20_40_RSSI_THR_CFG, FALSE, mtlk_coex_20_40_mode_cfg_t, coex20_40_cfg)
3115 MTLK_CFG_GET_ITEM(coex20_40_cfg, rssi_threshold, *(int32*)data);
3116
3117 _DF_USER_GET_ON_PARAM(PRM_ID_INTOLERANCE_MODE, MTLK_CORE_REQ_GET_COEX_20_40_MODE_CFG, FALSE, mtlk_coex_20_40_mode_cfg_t, coex20_40_cfg)
3118 MTLK_CFG_GET_ITEM(coex20_40_cfg, intolerance_mode, *(uint32*)data);
3119
3120 _DF_USER_GET_ON_PARAM(PRM_ID_SCAN_AP_FORCE_SCAN_PARAMS_ON_ASSOC_STA, MTLK_CORE_REQ_GET_COEX_20_40_AP_FORCE_PARAMS_CFG, FALSE, mtlk_coex_20_40_ap_force_params_cfg_t, coex20_40_cfg)
3121 MTLK_CFG_GET_ITEM(coex20_40_cfg, ap_force_scan_params_on_assoc_sta, *(uint32*)data);
3122
3123 _DF_USER_GET_ON_PARAM(PRM_ID_SCAN_AP_WAIT_FOR_SCAN_RESULTS_INTERVAL, MTLK_CORE_REQ_GET_COEX_20_40_AP_FORCE_PARAMS_CFG, FALSE, mtlk_coex_20_40_ap_force_params_cfg_t, coex20_40_cfg)
3124 MTLK_CFG_GET_ITEM(coex20_40_cfg, wait_for_scan_results_interval, *(uint32*)data);
3125
3126 _DF_USER_GET_ON_PARAM(PRM_ID_EXEMPTION_REQ, MTLK_CORE_REQ_GET_COEX_20_40_STA_EXEMPTION_REQ_CFG, FALSE, mtlk_coex_20_40_exm_req_cfg_t, coex20_40_cfg)
3127 MTLK_CFG_GET_ITEM(coex20_40_cfg, exemption_req, *(uint32*)data);
3128
3129 _DF_USER_GET_ON_PARAM(PRM_ID_MIN_NON_EXEMPTED_STA, MTLK_CORE_REQ_GET_COEX_20_40_AP_MIN_NUM_OF_EXM_STA_CFG, FALSE, mtlk_coex_20_40_min_num_exm_sta_cfg_t, coex20_40_cfg)
3130 MTLK_CFG_GET_ITEM(coex20_40_cfg, min_non_exempted_sta, *(uint32*)data);
3131
3132 _DF_USER_GET_ON_PARAM(PRM_ID_DELAY_FACTOR, MTLK_CORE_REQ_GET_COEX_20_40_TIMES_CFG, FALSE, mtlk_coex_20_40_times_cfg_t, coex20_40_cfg)
3133 MTLK_CFG_GET_ITEM(coex20_40_cfg, delay_factor, *(uint32*)data);
3134
3135 _DF_USER_GET_ON_PARAM(PRM_ID_OBSS_SCAN_INTERVAL, MTLK_CORE_REQ_GET_COEX_20_40_TIMES_CFG, FALSE, mtlk_coex_20_40_times_cfg_t, coex20_40_cfg)
3136 MTLK_CFG_GET_ITEM(coex20_40_cfg, obss_scan_interval, *(uint32*)data);
3137
3138 _DF_USER_GET_ON_PARAM(PRM_ID_SCAN_ACTIVITY_THRESHOLD, MTLK_CORE_REQ_GET_COEX_20_40_TIMES_CFG, FALSE, mtlk_coex_20_40_times_cfg_t, coex20_40_cfg)
3139 MTLK_CFG_GET_ITEM(coex20_40_cfg, scan_activity_threshold, *(uint32*)data);
3140
3141 _DF_USER_GET_ON_PARAM(PRM_ID_SCAN_PASSIVE_DWELL, MTLK_CORE_REQ_GET_COEX_20_40_TIMES_CFG, FALSE, mtlk_coex_20_40_times_cfg_t, coex20_40_cfg)
3142 MTLK_CFG_GET_ITEM(coex20_40_cfg, scan_passive_dwell, *(uint32*)data);
3143
3144 _DF_USER_GET_ON_PARAM(PRM_ID_SCAN_ACTIVE_DWELL, MTLK_CORE_REQ_GET_COEX_20_40_TIMES_CFG, FALSE, mtlk_coex_20_40_times_cfg_t, coex20_40_cfg)
3145 MTLK_CFG_GET_ITEM(coex20_40_cfg, scan_active_dwell, *(uint32*)data);
3146
3147 _DF_USER_GET_ON_PARAM(PRM_ID_SCAN_PASSIVE_TOTAL_PER_CHANNEL, MTLK_CORE_REQ_GET_COEX_20_40_TIMES_CFG, FALSE, mtlk_coex_20_40_times_cfg_t, coex20_40_cfg)
3148 MTLK_CFG_GET_ITEM(coex20_40_cfg, scan_passive_total_per_channel, *(uint32*)data);
3149
3150 _DF_USER_GET_ON_PARAM(PRM_ID_SCAN_ACTIVE_TOTAL_PER_CHANNEL, MTLK_CORE_REQ_GET_COEX_20_40_TIMES_CFG, FALSE, mtlk_coex_20_40_times_cfg_t, coex20_40_cfg)
3151 MTLK_CFG_GET_ITEM(coex20_40_cfg, scan_active_total_per_channel, *(uint32*)data);
3152
3153 /* Interference Detection */
3154 _DF_USER_GET_ON_PARAM(PRM_ID_INTERFERENCE_MODE, MTLK_CORE_REQ_GET_INTERFDET_MODE_CFG, TRUE, mtlk_interfdet_mode_cfg_t, interfdet_mode_cfg)
3155 MTLK_CFG_GET_ITEM(interfdet_mode_cfg, interfdet_mode, *(uint32*)data);
3156
3157 /* Card Capabilities */
3158 _DF_USER_GET_ON_PARAM(PRM_ID_AP_CAPABILITIES_MAX_STAs, MTLK_CORE_REQ_GET_AP_CAPABILITIES, TRUE, mtlk_card_capabilities_t, card_capabilities)
3159 MTLK_CFG_GET_ITEM(card_capabilities, max_stas_supported, *(uint32*)data);
3160 _DF_USER_GET_ON_PARAM(PRM_ID_AP_CAPABILITIES_MAX_VAPs, MTLK_CORE_REQ_GET_AP_CAPABILITIES, TRUE, mtlk_card_capabilities_t, card_capabilities)
3161 MTLK_CFG_GET_ITEM(card_capabilities, max_vaps_supported, *(uint32*)data);
3162 _DF_USER_GET_ON_PARAM(PRM_ID_AP_CAPABILITIES_MAX_ACLs, MTLK_CORE_REQ_GET_AP_CAPABILITIES, TRUE, mtlk_card_capabilities_t, card_capabilities)
3163 MTLK_CFG_GET_ITEM(card_capabilities, max_acls_supported, *(uint32*)data);
3164
3165 /* FW GPIO LED */
3166 _DF_USER_GET_ON_PARAM(PRM_ID_CFG_LED_GPIO, MTLK_CORE_REQ_GET_FW_LED_CFG, FALSE, mtlk_fw_led_cfg_t, led_gpio_cfg)
3167 MTLK_CFG_GET_ITEM_BY_FUNC_VOID(led_gpio_cfg, gpio_cfg,
3168 _mtlk_df_user_get_intvec_by_fw_gpio_cfg, ((uint32*)data, length, &led_gpio_cfg->gpio_cfg));
3169
3170 _DF_USER_GET_ON_PARAM(PRM_ID_TA_TIMER_RESOLUTION, MTLK_CORE_REQ_GET_TA_CFG, FALSE, mtlk_ta_cfg_t, mtlk_ta_cfg)
3171 MTLK_CFG_GET_ITEM(mtlk_ta_cfg, timer_resolution, *(uint32*)data);
3172
3173 _DF_USER_GET_ON_PARAM(PRM_ID_TA_DBG, MTLK_CORE_REQ_GET_TA_CFG, FALSE, mtlk_ta_cfg_t, mtlk_ta_cfg)
3174 MTLK_CFG_GET_ITEM_BY_FUNC(mtlk_ta_cfg, debug_info, _mtlk_df_user_print_ta_debug_info,
3175 (data, TEXT_SIZE, &mtlk_ta_cfg->debug_info), *length);
3176
3177 _DF_USER_GET_ON_PARAM(PRM_ID_ENHANCED11B_TH, MTLK_CORE_REQ_GET_ENHANCED11B_CFG, FALSE, mtlk_enhanced11b_cfg_t, mtlk_enhanced11b_cfg)
3178 MTLK_CFG_SET_ITEM_BY_FUNC_VOID(mtlk_enhanced11b_cfg, thresholds,
3179 _mtlk_df_user_intvec_by_11b_thresholds, ((uint32*)data, length, &mtlk_enhanced11b_cfg->thresholds));
3180
3181 _DF_USER_GET_ON_PARAM(PRM_ID_FW_RECOVERY, MTLK_CORE_REQ_GET_RECOVERY_CFG, FALSE, mtlk_rcvry_cfg_t, fw_rcvry_cfg)
3182 MTLK_CFG_SET_ITEM_BY_FUNC_VOID(fw_rcvry_cfg, recovery_cfg,
3183 _mtlk_df_user_intvec_by_recovery, ((uint32*)data, length, &fw_rcvry_cfg->recovery_cfg));
3184
3185 _DF_USER_GET_ON_PARAM(PRM_ID_11B_ANTENNA_SELECTION, MTLK_CORE_REQ_GET_11B_CFG, FALSE, mtlk_11b_cfg_t, mtlk_11b_cfg)
3186 MTLK_CFG_SET_ITEM_BY_FUNC_VOID(mtlk_11b_cfg, antsel,
3187 _mtlk_df_user_intvec_by_11b_antsel, ((uint32*)data, length, &mtlk_11b_cfg->antsel));
3188
3189 /* 802.11w begin */
3190 _DF_USER_GET_ON_PARAM(PRM_ID_PMF_ACTIVATED, MTLK_CORE_REQ_GET_DOT11W_CFG, FALSE, mtlk_dot11w_cfg_t, mtlk_dot11w_cfg)
3191 MTLK_CFG_GET_ITEM(mtlk_dot11w_cfg, pmf_activated, *(uint32*)data);
3192 _DF_USER_GET_ON_PARAM(PRM_ID_PMF_REQUIRED, MTLK_CORE_REQ_GET_DOT11W_CFG, FALSE, mtlk_dot11w_cfg_t, mtlk_dot11w_cfg)
3193 MTLK_CFG_GET_ITEM(mtlk_dot11w_cfg, pmf_required, *(uint32*)data);
3194 _DF_USER_GET_ON_PARAM(PRM_ID_SAQ_RETR_TMOUT, MTLK_CORE_REQ_GET_DOT11W_CFG, FALSE, mtlk_dot11w_cfg_t, mtlk_dot11w_cfg)
3195 MTLK_CFG_GET_ITEM(mtlk_dot11w_cfg, saq_retr_tmout, *(uint32*)data);
3196 _DF_USER_GET_ON_PARAM(PRM_ID_SAQ_MAX_TMOUT, MTLK_CORE_REQ_GET_DOT11W_CFG, FALSE, mtlk_dot11w_cfg_t, mtlk_dot11w_cfg)
3197 MTLK_CFG_GET_ITEM(mtlk_dot11w_cfg, saq_max_tmout, *(uint32*)data);
3198 /* 802.11w end */
3199
3200 _DF_USER_GET_ON_PARAM(PRM_ID_MC_PS_SIZE, MTLK_CORE_REQ_GET_MC_PS_SIZE_CFG, FALSE, mtlk_mc_ps_size_cfg_t, mc_ps_size_cfg)
3201 MTLK_CFG_GET_ITEM(mc_ps_size_cfg, maxNumberOfFsdus, *(uint32*)data);
3202
3203 /* U-APSD mode */
3204 _DF_USER_GET_ON_PARAM(PRM_ID_UAPSD_MODE, MTLK_CORE_REQ_GET_UAPSD_MODE, FALSE, mtlk_uapsd_mode_cfg_t, uapsd_mode_cfg)
3205 MTLK_CFG_GET_ITEM(uapsd_mode_cfg, uapsd_enabled, *(uint32*)data);
3206
3207 _DF_USER_GET_ON_PARAM(PRM_ID_UAPSD_MAX_SP, MTLK_CORE_REQ_GET_UAPSD_CFG, FALSE, mtlk_uapsd_cfg_t, uapsd_cfg)
3208 MTLK_CFG_GET_ITEM(uapsd_cfg, uapsd_max_sp, *(uint32*)data);
3209
3210 _DF_USER_GET_PARAM_MAP_END()
3211
3212 return res;
3213 }
3214
3215 static int __MTLK_IFUNC
3216 _mtlk_df_user_iwpriv_set_core_param(mtlk_df_user_t* df_user, uint32 param_id, char* data, uint16* length)
3217 {
3218 int res;
3219
3220 _DF_USER_SET_PARAM_MAP_START(df_user, param_id, res)
3221 _DF_USER_SET_ON_PARAM(PRM_ID_DELBA_REQ, MTLK_CORE_REQ_SET_DELBA_REQ, FALSE, mtlk_delba_cfg_entity_t, delba_cfg)
3222 MTLK_CFG_SET_ITEM_BY_FUNC(delba_cfg, delba_req, _mtlk_df_user_fill_delba_req,
3223 ((char*)data, &delba_cfg->delba_req), res);
3224
3225 _DF_USER_SET_ON_PARAM(PRM_ID_BE_BAUSE, MTLK_CORE_REQ_SET_ADDBA_CFG, FALSE, mtlk_addba_cfg_entity_t, addba_cfg)
3226 MTLK_CFG_SET_ITEM(&addba_cfg->tid[0], use_aggr, !!*(uint32*)data);
3227
3228 _DF_USER_SET_ON_PARAM(PRM_ID_BK_BAUSE, MTLK_CORE_REQ_SET_ADDBA_CFG, FALSE, mtlk_addba_cfg_entity_t, addba_cfg)
3229 MTLK_CFG_SET_ITEM(&addba_cfg->tid[1], use_aggr, !!*(uint32*)data);
3230
3231 _DF_USER_SET_ON_PARAM(PRM_ID_VI_BAUSE, MTLK_CORE_REQ_SET_ADDBA_CFG, FALSE, mtlk_addba_cfg_entity_t, addba_cfg)
3232 MTLK_CFG_SET_ITEM(&addba_cfg->tid[5], use_aggr, !!*(uint32*)data);
3233
3234 _DF_USER_SET_ON_PARAM(PRM_ID_VO_BAUSE, MTLK_CORE_REQ_SET_ADDBA_CFG, FALSE, mtlk_addba_cfg_entity_t, addba_cfg)
3235 MTLK_CFG_SET_ITEM(&addba_cfg->tid[6], use_aggr, !!*(uint32*)data);
3236
3237 _DF_USER_SET_ON_PARAM(PRM_ID_BE_BAACCEPT, MTLK_CORE_REQ_SET_ADDBA_CFG, FALSE, mtlk_addba_cfg_entity_t, addba_cfg)
3238 MTLK_CFG_SET_ITEM(&addba_cfg->tid[0], accept_aggr, !!*(uint32*)data);
3239 MTLK_CFG_SET_ITEM(&addba_cfg->tid[3], accept_aggr, !!*(uint32*)data);
3240
3241 _DF_USER_SET_ON_PARAM(PRM_ID_BK_BAACCEPT, MTLK_CORE_REQ_SET_ADDBA_CFG, FALSE, mtlk_addba_cfg_entity_t, addba_cfg)
3242 MTLK_CFG_SET_ITEM(&addba_cfg->tid[1], accept_aggr, !!*(uint32*)data);
3243 MTLK_CFG_SET_ITEM(&addba_cfg->tid[2], accept_aggr, !!*(uint32*)data);
3244
3245 _DF_USER_SET_ON_PARAM(PRM_ID_VI_BAACCEPT, MTLK_CORE_REQ_SET_ADDBA_CFG, FALSE, mtlk_addba_cfg_entity_t, addba_cfg)
3246 MTLK_CFG_SET_ITEM(&addba_cfg->tid[5], accept_aggr, !!*(uint32*)data);
3247 MTLK_CFG_SET_ITEM(&addba_cfg->tid[4], accept_aggr, !!*(uint32*)data);
3248
3249 _DF_USER_SET_ON_PARAM(PRM_ID_VO_BAACCEPT, MTLK_CORE_REQ_SET_ADDBA_CFG, FALSE, mtlk_addba_cfg_entity_t, addba_cfg)
3250 MTLK_CFG_SET_ITEM(&addba_cfg->tid[6], accept_aggr, !!*(uint32*)data);
3251 MTLK_CFG_SET_ITEM(&addba_cfg->tid[7], accept_aggr, !!*(uint32*)data);
3252
3253 _DF_USER_SET_ON_PARAM(PRM_ID_BE_BATIMEOUT, MTLK_CORE_REQ_SET_ADDBA_CFG, FALSE, mtlk_addba_cfg_entity_t, addba_cfg)
3254 MTLK_CFG_SET_ITEM(&addba_cfg->tid[0], addba_timeout, *(uint32*)data);
3255
3256 _DF_USER_SET_ON_PARAM(PRM_ID_BK_BATIMEOUT, MTLK_CORE_REQ_SET_ADDBA_CFG, FALSE, mtlk_addba_cfg_entity_t, addba_cfg)
3257 MTLK_CFG_SET_ITEM(&addba_cfg->tid[1], addba_timeout, *(uint32*)data);
3258
3259 _DF_USER_SET_ON_PARAM(PRM_ID_VI_BATIMEOUT, MTLK_CORE_REQ_SET_ADDBA_CFG, FALSE, mtlk_addba_cfg_entity_t, addba_cfg)
3260 MTLK_CFG_SET_ITEM(&addba_cfg->tid[5], addba_timeout, *(uint32*)data);
3261
3262 _DF_USER_SET_ON_PARAM(PRM_ID_VO_BATIMEOUT, MTLK_CORE_REQ_SET_ADDBA_CFG, FALSE, mtlk_addba_cfg_entity_t, addba_cfg)
3263 MTLK_CFG_SET_ITEM(&addba_cfg->tid[6], addba_timeout, *(uint32*)data);
3264
3265 _DF_USER_SET_ON_PARAM(PRM_ID_BE_BAWINSIZE, MTLK_CORE_REQ_SET_ADDBA_CFG, FALSE, mtlk_addba_cfg_entity_t, addba_cfg)
3266 MTLK_CFG_SET_ITEM(&addba_cfg->tid[0], aggr_win_size, *(uint32*)data);
3267
3268 _DF_USER_SET_ON_PARAM(PRM_ID_BK_BAWINSIZE, MTLK_CORE_REQ_SET_ADDBA_CFG, FALSE, mtlk_addba_cfg_entity_t, addba_cfg)
3269 MTLK_CFG_SET_ITEM(&addba_cfg->tid[1], aggr_win_size, *(uint32*)data);
3270
3271 _DF_USER_SET_ON_PARAM(PRM_ID_VI_BAWINSIZE, MTLK_CORE_REQ_SET_ADDBA_CFG, FALSE, mtlk_addba_cfg_entity_t, addba_cfg)
3272 MTLK_CFG_SET_ITEM(&addba_cfg->tid[5], aggr_win_size, *(uint32*)data);
3273
3274 _DF_USER_SET_ON_PARAM(PRM_ID_VO_BAWINSIZE, MTLK_CORE_REQ_SET_ADDBA_CFG, FALSE, mtlk_addba_cfg_entity_t, addba_cfg)
3275 MTLK_CFG_SET_ITEM(&addba_cfg->tid[6], aggr_win_size, *(uint32*)data);
3276
3277 _DF_USER_SET_ON_PARAM(PRM_ID_BE_AGGRMAXBTS, MTLK_CORE_REQ_SET_ADDBA_CFG, FALSE, mtlk_addba_cfg_entity_t, addba_cfg)
3278 MTLK_CFG_SET_ITEM(&addba_cfg->tid[0], max_nof_bytes, *(uint32*)data);
3279
3280 _DF_USER_SET_ON_PARAM(PRM_ID_BK_AGGRMAXBTS, MTLK_CORE_REQ_SET_ADDBA_CFG, FALSE, mtlk_addba_cfg_entity_t, addba_cfg)
3281 MTLK_CFG_SET_ITEM(&addba_cfg->tid[1], max_nof_bytes, *(uint32*)data);
3282
3283 _DF_USER_SET_ON_PARAM(PRM_ID_VI_AGGRMAXBTS, MTLK_CORE_REQ_SET_ADDBA_CFG, FALSE, mtlk_addba_cfg_entity_t, addba_cfg)
3284 MTLK_CFG_SET_ITEM(&addba_cfg->tid[5], max_nof_bytes, *(uint32*)data);
3285
3286 _DF_USER_SET_ON_PARAM(PRM_ID_VO_AGGRMAXBTS, MTLK_CORE_REQ_SET_ADDBA_CFG, FALSE, mtlk_addba_cfg_entity_t, addba_cfg)
3287 MTLK_CFG_SET_ITEM(&addba_cfg->tid[6], max_nof_bytes, *(uint32*)data);
3288
3289 _DF_USER_SET_ON_PARAM(PRM_ID_BE_AGGRMAXPKTS, MTLK_CORE_REQ_SET_ADDBA_CFG, FALSE, mtlk_addba_cfg_entity_t, addba_cfg)
3290 MTLK_CFG_SET_ITEM(&addba_cfg->tid[0], max_nof_packets, *(uint32*)data);
3291
3292 _DF_USER_SET_ON_PARAM(PRM_ID_BK_AGGRMAXPKTS, MTLK_CORE_REQ_SET_ADDBA_CFG, FALSE, mtlk_addba_cfg_entity_t, addba_cfg)
3293 MTLK_CFG_SET_ITEM(&addba_cfg->tid[1], max_nof_packets, *(uint32*)data);
3294
3295 _DF_USER_SET_ON_PARAM(PRM_ID_VI_AGGRMAXPKTS, MTLK_CORE_REQ_SET_ADDBA_CFG, FALSE, mtlk_addba_cfg_entity_t, addba_cfg)
3296 MTLK_CFG_SET_ITEM(&addba_cfg->tid[5], max_nof_packets, *(uint32*)data);
3297
3298 _DF_USER_SET_ON_PARAM(PRM_ID_VO_AGGRMAXPKTS, MTLK_CORE_REQ_SET_ADDBA_CFG, FALSE, mtlk_addba_cfg_entity_t, addba_cfg)
3299 MTLK_CFG_SET_ITEM(&addba_cfg->tid[6], max_nof_packets, *(uint32*)data);
3300
3301 _DF_USER_SET_ON_PARAM(PRM_ID_BE_AGGRMINPTSZ, MTLK_CORE_REQ_SET_ADDBA_CFG, FALSE, mtlk_addba_cfg_entity_t, addba_cfg)
3302 MTLK_CFG_SET_ITEM(&addba_cfg->tid[0], min_packet_size_in_aggr, *(uint32*)data);
3303
3304 _DF_USER_SET_ON_PARAM(PRM_ID_BK_AGGRMINPTSZ, MTLK_CORE_REQ_SET_ADDBA_CFG, FALSE, mtlk_addba_cfg_entity_t, addba_cfg)
3305 MTLK_CFG_SET_ITEM(&addba_cfg->tid[1], min_packet_size_in_aggr, *(uint32*)data);
3306
3307 _DF_USER_SET_ON_PARAM(PRM_ID_VI_AGGRMINPTSZ, MTLK_CORE_REQ_SET_ADDBA_CFG, FALSE, mtlk_addba_cfg_entity_t, addba_cfg)
3308 MTLK_CFG_SET_ITEM(&addba_cfg->tid[5], min_packet_size_in_aggr, *(uint32*)data);
3309
3310 _DF_USER_SET_ON_PARAM(PRM_ID_VO_AGGRMINPTSZ, MTLK_CORE_REQ_SET_ADDBA_CFG, FALSE, mtlk_addba_cfg_entity_t, addba_cfg)
3311 MTLK_CFG_SET_ITEM(&addba_cfg->tid[6], min_packet_size_in_aggr, *(uint32*)data);
3312
3313 _DF_USER_SET_ON_PARAM(PRM_ID_BE_AGGRTIMEOUT, MTLK_CORE_REQ_SET_ADDBA_CFG, FALSE, mtlk_addba_cfg_entity_t, addba_cfg)
3314 MTLK_CFG_SET_ITEM(&addba_cfg->tid[0], timeout_interval, *(uint32*)data);
3315
3316 _DF_USER_SET_ON_PARAM(PRM_ID_BK_AGGRTIMEOUT, MTLK_CORE_REQ_SET_ADDBA_CFG, FALSE, mtlk_addba_cfg_entity_t, addba_cfg)
3317 MTLK_CFG_SET_ITEM(&addba_cfg->tid[1], timeout_interval, *(uint32*)data);
3318
3319 _DF_USER_SET_ON_PARAM(PRM_ID_VI_AGGRTIMEOUT, MTLK_CORE_REQ_SET_ADDBA_CFG, FALSE, mtlk_addba_cfg_entity_t, addba_cfg)
3320 MTLK_CFG_SET_ITEM(&addba_cfg->tid[5], timeout_interval, *(uint32*)data);
3321
3322 _DF_USER_SET_ON_PARAM(PRM_ID_VO_AGGRTIMEOUT, MTLK_CORE_REQ_SET_ADDBA_CFG, FALSE, mtlk_addba_cfg_entity_t, addba_cfg)
3323 MTLK_CFG_SET_ITEM(&addba_cfg->tid[6], timeout_interval, *(uint32*)data);
3324
3325 _DF_USER_SET_ON_PARAM(PRM_ID_BE_AIFSN, MTLK_CORE_REQ_SET_WME_BSS_CFG, FALSE, mtlk_wme_cfg_entity_t, wme_bss_cfg)
3326 MTLK_CFG_SET_ITEM(&wme_bss_cfg->wme_class[0], aifsn, *(uint32*)data);
3327
3328 _DF_USER_SET_ON_PARAM(PRM_ID_BK_AIFSN, MTLK_CORE_REQ_SET_WME_BSS_CFG, FALSE, mtlk_wme_cfg_entity_t, wme_bss_cfg)
3329 MTLK_CFG_SET_ITEM(&wme_bss_cfg->wme_class[1], aifsn, *(uint32*)data);
3330
3331 _DF_USER_SET_ON_PARAM(PRM_ID_VI_AIFSN, MTLK_CORE_REQ_SET_WME_BSS_CFG, FALSE, mtlk_wme_cfg_entity_t, wme_bss_cfg)
3332 MTLK_CFG_SET_ITEM(&wme_bss_cfg->wme_class[2], aifsn, *(uint32*)data);
3333
3334 _DF_USER_SET_ON_PARAM(PRM_ID_VO_AIFSN, MTLK_CORE_REQ_SET_WME_BSS_CFG, FALSE, mtlk_wme_cfg_entity_t, wme_bss_cfg)
3335 MTLK_CFG_SET_ITEM(&wme_bss_cfg->wme_class[3], aifsn, *(uint32*)data);
3336
3337 _DF_USER_SET_ON_PARAM(PRM_ID_BE_CWMAX, MTLK_CORE_REQ_SET_WME_BSS_CFG, FALSE, mtlk_wme_cfg_entity_t, wme_bss_cfg)
3338 MTLK_CFG_SET_ITEM(&wme_bss_cfg->wme_class[0], cwmax, *(uint32*)data);
3339
3340 _DF_USER_SET_ON_PARAM(PRM_ID_BK_CWMAX, MTLK_CORE_REQ_SET_WME_BSS_CFG, FALSE, mtlk_wme_cfg_entity_t, wme_bss_cfg)
3341 MTLK_CFG_SET_ITEM(&wme_bss_cfg->wme_class[1], cwmax, *(uint32*)data);
3342
3343 _DF_USER_SET_ON_PARAM(PRM_ID_VI_CWMAX, MTLK_CORE_REQ_SET_WME_BSS_CFG, FALSE, mtlk_wme_cfg_entity_t, wme_bss_cfg)
3344 MTLK_CFG_SET_ITEM(&wme_bss_cfg->wme_class[2], cwmax, *(uint32*)data);
3345
3346 _DF_USER_SET_ON_PARAM(PRM_ID_VO_CWMAX, MTLK_CORE_REQ_SET_WME_BSS_CFG, FALSE, mtlk_wme_cfg_entity_t, wme_bss_cfg)
3347 MTLK_CFG_SET_ITEM(&wme_bss_cfg->wme_class[3], cwmax, *(uint32*)data);
3348
3349 _DF_USER_SET_ON_PARAM(PRM_ID_BE_CWMIN, MTLK_CORE_REQ_SET_WME_BSS_CFG, FALSE, mtlk_wme_cfg_entity_t, wme_bss_cfg)
3350 MTLK_CFG_SET_ITEM(&wme_bss_cfg->wme_class[0], cwmin, *(uint32*)data);
3351
3352 _DF_USER_SET_ON_PARAM(PRM_ID_BK_CWMIN, MTLK_CORE_REQ_SET_WME_BSS_CFG, FALSE, mtlk_wme_cfg_entity_t, wme_bss_cfg)
3353 MTLK_CFG_SET_ITEM(&wme_bss_cfg->wme_class[1], cwmin, *(uint32*)data);
3354
3355 _DF_USER_SET_ON_PARAM(PRM_ID_VI_CWMIN, MTLK_CORE_REQ_SET_WME_BSS_CFG, FALSE, mtlk_wme_cfg_entity_t, wme_bss_cfg)
3356 MTLK_CFG_SET_ITEM(&wme_bss_cfg->wme_class[2], cwmin, *(uint32*)data);
3357
3358 _DF_USER_SET_ON_PARAM(PRM_ID_VO_CWMIN, MTLK_CORE_REQ_SET_WME_BSS_CFG, FALSE, mtlk_wme_cfg_entity_t, wme_bss_cfg)
3359 MTLK_CFG_SET_ITEM(&wme_bss_cfg->wme_class[3], cwmin, *(uint32*)data);
3360
3361 _DF_USER_SET_ON_PARAM(PRM_ID_BE_TXOP, MTLK_CORE_REQ_SET_WME_BSS_CFG, FALSE, mtlk_wme_cfg_entity_t, wme_bss_cfg)
3362 MTLK_CFG_SET_ITEM(&wme_bss_cfg->wme_class[0], txop, *(uint32*)data);
3363
3364 _DF_USER_SET_ON_PARAM(PRM_ID_BK_TXOP, MTLK_CORE_REQ_SET_WME_BSS_CFG, FALSE, mtlk_wme_cfg_entity_t, wme_bss_cfg)
3365 MTLK_CFG_SET_ITEM(&wme_bss_cfg->wme_class[1], txop, *(uint32*)data);
3366
3367 _DF_USER_SET_ON_PARAM(PRM_ID_VI_TXOP, MTLK_CORE_REQ_SET_WME_BSS_CFG, FALSE, mtlk_wme_cfg_entity_t, wme_bss_cfg)
3368 MTLK_CFG_SET_ITEM(&wme_bss_cfg->wme_class[2], txop, *(uint32*)data);
3369
3370 _DF_USER_SET_ON_PARAM(PRM_ID_VO_TXOP, MTLK_CORE_REQ_SET_WME_BSS_CFG, FALSE, mtlk_wme_cfg_entity_t, wme_bss_cfg)
3371 MTLK_CFG_SET_ITEM(&wme_bss_cfg->wme_class[3], txop, *(uint32*)data);
3372
3373 _DF_USER_SET_ON_PARAM(PRM_ID_BE_AIFSNAP, MTLK_CORE_REQ_SET_WME_AP_CFG, FALSE, mtlk_wme_cfg_entity_t, wme_ap_cfg)
3374 MTLK_CFG_SET_ITEM(&wme_ap_cfg->wme_class[0], aifsn, *(uint32*)data);
3375
3376 _DF_USER_SET_ON_PARAM(PRM_ID_BK_AIFSNAP, MTLK_CORE_REQ_SET_WME_AP_CFG, FALSE, mtlk_wme_cfg_entity_t, wme_ap_cfg)
3377 MTLK_CFG_SET_ITEM(&wme_ap_cfg->wme_class[1], aifsn, *(uint32*)data);
3378
3379 _DF_USER_SET_ON_PARAM(PRM_ID_VI_AIFSNAP, MTLK_CORE_REQ_SET_WME_AP_CFG, FALSE, mtlk_wme_cfg_entity_t, wme_ap_cfg)
3380 MTLK_CFG_SET_ITEM(&wme_ap_cfg->wme_class[2], aifsn, *(uint32*)data);
3381
3382 _DF_USER_SET_ON_PARAM(PRM_ID_VO_AIFSNAP, MTLK_CORE_REQ_SET_WME_AP_CFG, FALSE, mtlk_wme_cfg_entity_t, wme_ap_cfg)
3383 MTLK_CFG_SET_ITEM(&wme_ap_cfg->wme_class[3], aifsn, *(uint32*)data);
3384
3385 _DF_USER_SET_ON_PARAM(PRM_ID_BE_CWMAXAP, MTLK_CORE_REQ_SET_WME_AP_CFG, FALSE, mtlk_wme_cfg_entity_t, wme_ap_cfg)
3386 MTLK_CFG_SET_ITEM(&wme_ap_cfg->wme_class[0], cwmax, *(uint32*)data);
3387
3388 _DF_USER_SET_ON_PARAM(PRM_ID_BK_CWMAXAP, MTLK_CORE_REQ_SET_WME_AP_CFG, FALSE, mtlk_wme_cfg_entity_t, wme_ap_cfg)
3389 MTLK_CFG_SET_ITEM(&wme_ap_cfg->wme_class[1], cwmax, *(uint32*)data);
3390
3391 _DF_USER_SET_ON_PARAM(PRM_ID_VI_CWMAXAP, MTLK_CORE_REQ_SET_WME_AP_CFG, FALSE, mtlk_wme_cfg_entity_t, wme_ap_cfg)
3392 MTLK_CFG_SET_ITEM(&wme_ap_cfg->wme_class[2], cwmax, *(uint32*)data);
3393
3394 _DF_USER_SET_ON_PARAM(PRM_ID_VO_CWMAXAP, MTLK_CORE_REQ_SET_WME_AP_CFG, FALSE, mtlk_wme_cfg_entity_t, wme_ap_cfg)
3395 MTLK_CFG_SET_ITEM(&wme_ap_cfg->wme_class[3], cwmax, *(uint32*)data);
3396
3397 _DF_USER_SET_ON_PARAM(PRM_ID_BE_CWMINAP, MTLK_CORE_REQ_SET_WME_AP_CFG, FALSE, mtlk_wme_cfg_entity_t, wme_ap_cfg)
3398 MTLK_CFG_SET_ITEM(&wme_ap_cfg->wme_class[0], cwmin, *(uint32*)data);
3399
3400 _DF_USER_SET_ON_PARAM(PRM_ID_BK_CWMINAP, MTLK_CORE_REQ_SET_WME_AP_CFG, FALSE, mtlk_wme_cfg_entity_t, wme_ap_cfg)
3401 MTLK_CFG_SET_ITEM(&wme_ap_cfg->wme_class[1], cwmin, *(uint32*)data);
3402
3403 _DF_USER_SET_ON_PARAM(PRM_ID_VI_CWMINAP, MTLK_CORE_REQ_SET_WME_AP_CFG, FALSE, mtlk_wme_cfg_entity_t, wme_ap_cfg)
3404 MTLK_CFG_SET_ITEM(&wme_ap_cfg->wme_class[2], cwmin, *(uint32*)data);
3405
3406 _DF_USER_SET_ON_PARAM(PRM_ID_VO_CWMINAP, MTLK_CORE_REQ_SET_WME_AP_CFG, FALSE, mtlk_wme_cfg_entity_t, wme_ap_cfg)
3407 MTLK_CFG_SET_ITEM(&wme_ap_cfg->wme_class[3], cwmin, *(uint32*)data);
3408
3409 _DF_USER_SET_ON_PARAM(PRM_ID_BE_TXOPAP, MTLK_CORE_REQ_SET_WME_AP_CFG, FALSE, mtlk_wme_cfg_entity_t, wme_ap_cfg)
3410 MTLK_CFG_SET_ITEM(&wme_ap_cfg->wme_class[0], txop, *(uint32*)data);
3411
3412 _DF_USER_SET_ON_PARAM(PRM_ID_BK_TXOPAP, MTLK_CORE_REQ_SET_WME_AP_CFG, FALSE, mtlk_wme_cfg_entity_t, wme_ap_cfg)
3413 MTLK_CFG_SET_ITEM(&wme_ap_cfg->wme_class[1], txop, *(uint32*)data);
3414
3415 _DF_USER_SET_ON_PARAM(PRM_ID_VI_TXOPAP, MTLK_CORE_REQ_SET_WME_AP_CFG, FALSE, mtlk_wme_cfg_entity_t, wme_ap_cfg)
3416 MTLK_CFG_SET_ITEM(&wme_ap_cfg->wme_class[2], txop, *(uint32*)data);
3417
3418 _DF_USER_SET_ON_PARAM(PRM_ID_VO_TXOPAP, MTLK_CORE_REQ_SET_WME_AP_CFG, FALSE, mtlk_wme_cfg_entity_t, wme_ap_cfg)
3419 MTLK_CFG_SET_ITEM(&wme_ap_cfg->wme_class[3], txop, *(uint32*)data);
3420
3421 _DF_USER_SET_ON_PARAM(PRM_ID_AOCS_WEIGHT_CL, MTLK_CORE_REQ_SET_AOCS_CFG, FALSE, mtlk_aocs_cfg_t, aocs_cfg)
3422 MTLK_CFG_SET_ITEM(aocs_cfg, weight_ch_load, *(uint32*)data);
3423
3424 _DF_USER_SET_ON_PARAM(PRM_ID_AOCS_WEIGHT_TX, MTLK_CORE_REQ_SET_AOCS_CFG, FALSE, mtlk_aocs_cfg_t, aocs_cfg)
3425 MTLK_CFG_SET_ITEM(aocs_cfg, weight_tx_power, *(uint32*)data);
3426
3427 _DF_USER_SET_ON_PARAM(PRM_ID_AOCS_WEIGHT_BSS, MTLK_CORE_REQ_SET_AOCS_CFG, FALSE, mtlk_aocs_cfg_t, aocs_cfg)
3428 MTLK_CFG_SET_ITEM(aocs_cfg, weight_nof_bss, *(uint32*)data);
3429
3430 _DF_USER_SET_ON_PARAM(PRM_ID_AOCS_WEIGHT_SM, MTLK_CORE_REQ_SET_AOCS_CFG, FALSE, mtlk_aocs_cfg_t, aocs_cfg)
3431 MTLK_CFG_SET_ITEM(aocs_cfg, weight_sm_required, *(uint32*)data);
3432
3433 _DF_USER_SET_ON_PARAM(PRM_ID_AOCS_CFM_RANK_SW_THRESHOLD, MTLK_CORE_REQ_SET_AOCS_CFG, FALSE, mtlk_aocs_cfg_t, aocs_cfg)
3434 MTLK_CFG_SET_ITEM(aocs_cfg, cfm_rank_sw_threshold, *(uint32*)data);
3435
3436 _DF_USER_SET_ON_PARAM(PRM_ID_AOCS_SCAN_AGING, MTLK_CORE_REQ_SET_AOCS_CFG, FALSE, mtlk_aocs_cfg_t, aocs_cfg)
3437 MTLK_CFG_SET_ITEM(aocs_cfg, scan_aging_ms, *(uint32*)data);
3438
3439 _DF_USER_SET_ON_PARAM(PRM_ID_AOCS_CONFIRM_RANK_AGING, MTLK_CORE_REQ_SET_AOCS_CFG, FALSE, mtlk_aocs_cfg_t, aocs_cfg)
3440 MTLK_CFG_SET_ITEM(aocs_cfg, confirm_rank_aging_ms, *(uint32*)data);
3441
3442 _DF_USER_SET_ON_PARAM(PRM_ID_AOCS_AFILTER, MTLK_CORE_REQ_SET_AOCS_CFG, FALSE, mtlk_aocs_cfg_t, aocs_cfg)
3443 MTLK_CFG_SET_ITEM(aocs_cfg, alpha_filter_coefficient, *(uint32*)data);
3444
3445 _DF_USER_SET_ON_PARAM(PRM_ID_AOCS_BONDING, MTLK_CORE_REQ_SET_AOCS_CFG, FALSE, mtlk_aocs_cfg_t, aocs_cfg)
3446 MTLK_CFG_SET_ITEM(aocs_cfg, bonding, *(uint32*)data);
3447
3448 _DF_USER_SET_ON_PARAM(PRM_ID_AOCS_EN_PENALTIES, MTLK_CORE_REQ_SET_AOCS_CFG, FALSE, mtlk_aocs_cfg_t, aocs_cfg)
3449 MTLK_CFG_SET_ITEM(aocs_cfg, use_tx_penalties, *(uint32*)data);
3450
3451 _DF_USER_SET_ON_PARAM(PRM_ID_AOCS_WIN_TIME, MTLK_CORE_REQ_SET_AOCS_CFG, FALSE, mtlk_aocs_cfg_t, aocs_cfg)
3452 MTLK_CFG_SET_ITEM(aocs_cfg, udp_aocs_window_time_ms, *(uint32*)data);
3453
3454 _DF_USER_SET_ON_PARAM(PRM_ID_AOCS_LOWER_THRESHOLD, MTLK_CORE_REQ_SET_AOCS_CFG, FALSE, mtlk_aocs_cfg_t, aocs_cfg)
3455 MTLK_CFG_SET_ITEM(aocs_cfg, udp_lower_threshold, *(uint32*)data);
3456
3457 _DF_USER_SET_ON_PARAM(PRM_ID_AOCS_THRESHOLD_WINDOW, MTLK_CORE_REQ_SET_AOCS_CFG, FALSE, mtlk_aocs_cfg_t, aocs_cfg)
3458 MTLK_CFG_SET_ITEM(aocs_cfg, udp_threshold_window, *(uint32*)data);
3459
3460 _DF_USER_SET_ON_PARAM(PRM_ID_AOCS_MSDU_DEBUG_ENABLED, MTLK_CORE_REQ_SET_AOCS_CFG, FALSE, mtlk_aocs_cfg_t, aocs_cfg)
3461 MTLK_CFG_SET_ITEM(aocs_cfg, udp_msdu_debug_enabled, *(uint32*)data);
3462
3463 _DF_USER_SET_ON_PARAM(PRM_ID_AOCS_IS_ENABLED, MTLK_CORE_REQ_SET_AOCS_CFG, FALSE, mtlk_aocs_cfg_t, aocs_cfg)
3464 MTLK_CFG_SET_ITEM(aocs_cfg, type, *(uint32*)data);
3465
3466 _DF_USER_SET_ON_PARAM(PRM_ID_AOCS_MSDU_PER_WIN_THRESHOLD, MTLK_CORE_REQ_SET_AOCS_CFG, FALSE, mtlk_aocs_cfg_t, aocs_cfg)
3467 MTLK_CFG_SET_ITEM(aocs_cfg, udp_msdu_per_window_threshold, *(uint32*)data);
3468
3469 _DF_USER_SET_ON_PARAM(PRM_ID_AOCS_MSDU_THRESHOLD, MTLK_CORE_REQ_SET_AOCS_CFG, FALSE, mtlk_aocs_cfg_t, aocs_cfg)
3470 MTLK_CFG_SET_ITEM(aocs_cfg, udp_msdu_threshold_aocs, *(uint32*)data);
3471
3472 _DF_USER_SET_ON_PARAM(PRM_ID_AOCS_MEASUREMENT_WINDOW, MTLK_CORE_REQ_SET_AOCS_CFG, FALSE, mtlk_aocs_cfg_t, aocs_cfg)
3473 MTLK_CFG_SET_ITEM(aocs_cfg, tcp_measurement_window, *(uint32*)data);
3474
3475 _DF_USER_SET_ON_PARAM(PRM_ID_AOCS_THROUGHPUT_THRESHOLD, MTLK_CORE_REQ_SET_AOCS_CFG, FALSE, mtlk_aocs_cfg_t, aocs_cfg)
3476 MTLK_CFG_SET_ITEM(aocs_cfg, tcp_throughput_threshold, *(uint32*)data);
3477
3478 _DF_USER_SET_ON_PARAM(PRM_ID_AOCS_NON_OCCUPANCY_PERIOD, MTLK_CORE_REQ_SET_AOCS_CFG, FALSE, mtlk_aocs_cfg_t, aocs_cfg)
3479 MTLK_CFG_SET_ITEM(aocs_cfg, dbg_non_occupied_period, *(uint32*)data);
3480
3481 _DF_USER_SET_ON_PARAM(PRM_ID_AOCS_RESTRICT_MODE, MTLK_CORE_REQ_SET_AOCS_CFG, FALSE, mtlk_aocs_cfg_t, aocs_cfg)
3482 {
3483 if (*(uint32*)data >= AOCS_RESTRICT_CHAN_MODE_LAST) {
3484 res = MTLK_ERR_PARAMS;
3485 } else {
3486 MTLK_CFG_SET_ITEM(aocs_cfg, restrict_mode, *(uint32*)data);
3487 }
3488 }
3489
3490 _DF_USER_SET_ON_PARAM(PRM_ID_AOCS_NON_WIFI_NOISE, MTLK_CORE_REQ_SET_AOCS_CFG, FALSE, mtlk_aocs_cfg_t, aocs_cfg)
3491 MTLK_CFG_SET_ITEM_BY_FUNC(aocs_cfg, non_wifi_interf,
3492 _mtlk_df_user_get_interf_params_by_intvec, ((int32*)data, *length, &aocs_cfg->non_wifi_interf), res);
3493
3494 _DF_USER_SET_ON_PARAM(PRM_ID_11H_RADAR_DETECTION, MTLK_CORE_REQ_SET_DOT11H_CFG, FALSE, mtlk_11h_cfg_t, dot11h_cfg)
3495 MTLK_CFG_SET_ITEM(dot11h_cfg, radar_detect, *(uint32*)data);
3496
3497 _DF_USER_SET_ON_PARAM(PRM_ID_11H_EMULATE_RADAR_DETECTION, MTLK_CORE_REQ_SET_DOT11H_AP_CFG, FALSE, mtlk_11h_ap_cfg_t, dot11h_cfg)
3498 MTLK_CFG_SET_ITEM(dot11h_cfg, channel_emu, *(uint32*)data);
3499
3500 _DF_USER_SET_ON_PARAM(PRM_ID_11H_SWITCH_CHANNEL, MTLK_CORE_REQ_SET_DOT11H_AP_CFG, FALSE, mtlk_11h_ap_cfg_t, dot11h_cfg)
3501 MTLK_CFG_SET_ITEM(dot11h_cfg, channel_switch, *(uint32*)data);
3502
3503 _DF_USER_SET_ON_PARAM(PRM_ID_11H_ENABLE_SM_CHANNELS, MTLK_CORE_REQ_SET_DOT11H_AP_CFG, FALSE, mtlk_11h_ap_cfg_t, dot11h_cfg)
3504 MTLK_CFG_SET_ITEM(dot11h_cfg, enable_sm_required, *(uint32*)data);
3505
3506 _DF_USER_SET_ON_PARAM(PRM_ID_11H_BEACON_COUNT, MTLK_CORE_REQ_SET_DOT11H_AP_CFG, FALSE, mtlk_11h_ap_cfg_t, dot11h_cfg)
3507 MTLK_CFG_SET_ITEM(dot11h_cfg, debugChannelSwitchCount, *(uint32*)data);
3508
3509 _DF_USER_SET_ON_PARAM(PRM_ID_11H_CHANNEL_AVAILABILITY_CHECK_TIME, MTLK_CORE_REQ_SET_DOT11H_AP_CFG, FALSE, mtlk_11h_ap_cfg_t, dot11h_cfg)
3510 MTLK_CFG_SET_ITEM(dot11h_cfg, debugChannelAvailabilityCheckTime, *(uint32*)data);
3511
3512 _DF_USER_SET_ON_PARAM(PRM_ID_11H_NEXT_CHANNEL, MTLK_CORE_REQ_SET_DOT11H_AP_CFG, FALSE, mtlk_11h_ap_cfg_t, dot11h_cfg)
3513 MTLK_CFG_SET_ITEM(dot11h_cfg, next_channel, *(uint32*)data);
3514
3515 _DF_USER_SET_ON_PARAM(MIB_ACL_MODE, MTLK_CORE_REQ_SET_MIBS_CFG, FALSE, mtlk_mibs_cfg_t, mibs_cfg)
3516 if (*(uint32*)data > 2) {
3517 ELOG_V("Usage: 0 - OFF, 1 - white list, 2 - black list");
3518 res = MTLK_ERR_PARAMS;
3519 } else if (!mtlk_df_is_ap(df_user->df)) {
3520 ELOG_V("The command is supported only in AP mode");
3521 res = MTLK_ERR_PARAMS;
3522 } else {
3523 MTLK_CFG_SET_ITEM(mibs_cfg, acl_mode, *(uint32*)data);
3524 }
3525
3526 _DF_USER_SET_ON_PARAM(PRM_ID_VAP_STA_LIMS, MTLK_CORE_REQ_MBSS_SET_VARS, FALSE, mtlk_mbss_cfg_t, mbss_cfg)
3527 int i;
3528 uint32 *value = (uint32*)data;
3529 if (*length != VAP_LIMIT_SET_SIZE) {
3530 ELOG_V("Needs a set of two parameters");
3531 res = MTLK_ERR_PARAMS;
3532 } else {
3533 for (i = 0; i < VAP_LIMIT_SET_SIZE; i ++) {
3534 if (value[i] == (uint32)DF_USER_DEFAULT_IWPRIV_LIM_VALUE) {
3535 value[i] = MTLK_MBSS_VAP_LIMIT_DEFAULT;
3536 }
3537 else if (((int32)value[i]) < 0) {
3538 ELOG_V("invalid parameter");
3539 res = MTLK_ERR_PARAMS;
3540 }
3541 }
3542 if(MTLK_ERR_OK == res) {
3543 MTLK_CFG_SET_ITEM_BY_FUNC_VOID(mbss_cfg, vap_limits, _mtlk_df_set_vap_limits_cfg, (mbss_cfg, value[0], value[1]));
3544 }
3545 }
3546
3547 _DF_USER_SET_ON_PARAM(PRM_ID_VAP_ADD, MTLK_CORE_REQ_MBSS_ADD_VAP, FALSE, mtlk_mbss_cfg_t, mbss_cfg)
3548 MTLK_CFG_SET_ITEM(mbss_cfg, added_vap_index, _mtlk_df_user_get_core_slave_vap_index_by_iwpriv_param (*(uint32*)data));
3549
3550 _DF_USER_SET_ON_PARAM(PRM_ID_VAP_DEL, MTLK_CORE_REQ_MBSS_DEL_VAP, FALSE, mtlk_mbss_cfg_t, mbss_cfg)
3551 MTLK_CFG_SET_ITEM(mbss_cfg, deleted_vap_index, _mtlk_df_user_get_core_slave_vap_index_by_iwpriv_param (*(uint32*)data));
3552
3553 _DF_USER_SET_ON_PARAM(MIB_CALIBRATION_ALGO_MASK, MTLK_CORE_REQ_SET_MIBS_CFG, FALSE, mtlk_mibs_cfg_t, mibs_cfg)
3554 MTLK_CFG_SET_ITEM(mibs_cfg, calibr_algo_mask, *(uint32*)data);
3555
3556 _DF_USER_SET_ON_PARAM(PRM_USE_SHORT_CYCLIC_PREFIX_RX, MTLK_CORE_REQ_SET_MIBS_CFG, FALSE, mtlk_mibs_cfg_t, mibs_cfg)
3557 MTLK_CFG_SET_ITEM(mibs_cfg, short_cyclic_prefix_rx, !!(*(uint32*)data));
3558
3559 _DF_USER_SET_ON_PARAM(PRM_USE_SHORT_CYCLIC_PREFIX_TX, MTLK_CORE_REQ_SET_MIBS_CFG, FALSE, mtlk_mibs_cfg_t, mibs_cfg)
3560 MTLK_CFG_SET_ITEM(mibs_cfg, short_cyclic_prefix_tx, !!(*(uint32*)data));
3561
3562 _DF_USER_SET_ON_PARAM(PRM_USE_SHORT_CYCLIC_PREFIX_RATE31, MTLK_CORE_REQ_SET_MIBS_CFG, FALSE, mtlk_mibs_cfg_t, mibs_cfg)
3563 MTLK_CFG_SET_ITEM(mibs_cfg, short_cyclic_prefix_rate31, !!(*(uint32*)data));
3564
3565 _DF_USER_SET_ON_PARAM(PRM_ID_SHORT_PREAMBLE_OPTION_IMPLEMENTED, MTLK_CORE_REQ_SET_MIBS_CFG, FALSE, mtlk_mibs_cfg_t, mibs_cfg)
3566 MTLK_CFG_SET_ITEM(mibs_cfg, short_preamble_option, *(uint32*)data);
3567
3568 _DF_USER_SET_ON_PARAM(PRM_ID_SHORT_SLOT_TIME_OPTION_ENABLED_11G, MTLK_CORE_REQ_SET_MIBS_CFG, FALSE, mtlk_mibs_cfg_t, mibs_cfg)
3569 MTLK_CFG_SET_ITEM(mibs_cfg, short_slot_time_option, *(uint32*)data);
3570
3571 _DF_USER_SET_ON_PARAM(MIB_SHORT_RETRY_LIMIT, MTLK_CORE_REQ_SET_MIBS_CFG, FALSE, mtlk_mibs_cfg_t, mibs_cfg)
3572 MTLK_CFG_SET_ITEM(mibs_cfg, short_retry_limit, *(uint32*)data);
3573
3574 _DF_USER_SET_ON_PARAM(MIB_LONG_RETRY_LIMIT, MTLK_CORE_REQ_SET_MIBS_CFG, FALSE, mtlk_mibs_cfg_t, mibs_cfg)
3575 MTLK_CFG_SET_ITEM(mibs_cfg, long_retry_limit, *(uint32*)data);
3576
3577 _DF_USER_SET_ON_PARAM(MIB_TX_MSDU_LIFETIME, MTLK_CORE_REQ_SET_MIBS_CFG, FALSE, mtlk_mibs_cfg_t, mibs_cfg)
3578 MTLK_CFG_SET_ITEM(mibs_cfg, tx_msdu_lifetime, *(uint32*)data);
3579
3580 _DF_USER_SET_ON_PARAM(MIB_CURRENT_TX_ANTENNA, MTLK_CORE_REQ_SET_MIBS_CFG, FALSE, mtlk_mibs_cfg_t, mibs_cfg)
3581 MTLK_CFG_SET_ITEM(mibs_cfg, current_tx_antenna, *(uint32*)data);
3582
3583 _DF_USER_SET_ON_PARAM(MIB_BEACON_PERIOD, MTLK_CORE_REQ_SET_MIBS_CFG, FALSE, mtlk_mibs_cfg_t, mibs_cfg)
3584 MTLK_CFG_SET_ITEM(mibs_cfg, beacon_period, *(uint32*)data);
3585
3586 _DF_USER_SET_ON_PARAM(MIB_DISCONNECT_ON_NACKS_WEIGHT, MTLK_CORE_REQ_SET_MIBS_CFG, FALSE, mtlk_mibs_cfg_t, mibs_cfg)
3587 MTLK_CFG_SET_ITEM(mibs_cfg, disconnect_on_nacks_weight, *(uint32*)data);
3588
3589 _DF_USER_SET_ON_PARAM(MIB_SM_ENABLE, MTLK_CORE_REQ_SET_MIBS_CFG, FALSE, mtlk_mibs_cfg_t, mibs_cfg)
3590 MTLK_CFG_SET_ITEM(mibs_cfg, sm_enable, *(uint32*)data);
3591
3592 _DF_USER_SET_ON_PARAM(MIB_ADVANCED_CODING_SUPPORTED, MTLK_CORE_REQ_SET_MIBS_CFG, FALSE, mtlk_mibs_cfg_t, mibs_cfg)
3593 MTLK_CFG_SET_ITEM(mibs_cfg, advanced_coding_supported, *(uint32*)data);
3594
3595 _DF_USER_SET_ON_PARAM(MIB_OVERLAPPING_PROTECTION_ENABLE, MTLK_CORE_REQ_SET_MIBS_CFG, FALSE, mtlk_mibs_cfg_t, mibs_cfg)
3596 MTLK_CFG_SET_ITEM(mibs_cfg, overlapping_protect_enabled, *(uint32*)data);
3597
3598 _DF_USER_SET_ON_PARAM(MIB_OFDM_PROTECTION_METHOD, MTLK_CORE_REQ_SET_MIBS_CFG, FALSE, mtlk_mibs_cfg_t, mibs_cfg)
3599 MTLK_CFG_SET_ITEM(mibs_cfg, ofdm_protect_method, *(uint32*)data);
3600
3601 _DF_USER_SET_ON_PARAM(MIB_HT_PROTECTION_METHOD, MTLK_CORE_REQ_SET_MIBS_CFG, FALSE, mtlk_mibs_cfg_t, mibs_cfg)
3602 MTLK_CFG_SET_ITEM(mibs_cfg, ht_method, *(uint32*)data);
3603
3604 _DF_USER_SET_ON_PARAM(MIB_DTIM_PERIOD, MTLK_CORE_REQ_SET_MIBS_CFG, FALSE, mtlk_mibs_cfg_t, mibs_cfg)
3605 MTLK_CFG_SET_ITEM(mibs_cfg, dtim_period, *(uint32*)data);
3606
3607 _DF_USER_SET_ON_PARAM(MIB_RECEIVE_AMPDU_MAX_LENGTH, MTLK_CORE_REQ_SET_MIBS_CFG, FALSE, mtlk_mibs_cfg_t, mibs_cfg)
3608 MTLK_CFG_SET_ITEM(mibs_cfg, receive_ampdu_max_len, *(uint32*)data);
3609
3610 _DF_USER_SET_ON_PARAM(MIB_CB_DATABINS_PER_SYMBOL, MTLK_CORE_REQ_SET_MIBS_CFG, FALSE, mtlk_mibs_cfg_t, mibs_cfg)
3611 MTLK_CFG_SET_ITEM(mibs_cfg, cb_databins_per_symbol, *(uint32*)data);
3612
3613 _DF_USER_SET_ON_PARAM(MIB_USE_LONG_PREAMBLE_FOR_MULTICAST, MTLK_CORE_REQ_SET_MIBS_CFG, FALSE, mtlk_mibs_cfg_t, mibs_cfg)
3614 MTLK_CFG_SET_ITEM(mibs_cfg, use_long_preamble_for_multicast, *(uint32*)data);
3615
3616 _DF_USER_SET_ON_PARAM(MIB_USE_SPACE_TIME_BLOCK_CODE, MTLK_CORE_REQ_SET_MIBS_CFG, FALSE, mtlk_mibs_cfg_t, mibs_cfg)
3617 MTLK_CFG_SET_ITEM(mibs_cfg, use_space_time_block_code, *(uint32*)data);
3618
3619 _DF_USER_SET_ON_PARAM(MIB_TWO_ANTENNA_TRANSMISSION_ENABLE, MTLK_CORE_REQ_SET_MIBS_CFG, FALSE, mtlk_mibs_cfg_t, mibs_cfg)
3620 if (_mtlk_df_user_check_master_vap_on_g35(df_user)) {
3621 MTLK_CFG_SET_ITEM(mibs_cfg, two_antenna_tx_enable, *(uint32*)data);
3622 } else {
3623 res = MTLK_ERR_NOT_SUPPORTED;
3624 }
3625
3626 _DF_USER_SET_ON_PARAM(MIB_ONLINE_CALIBRATION_ALGO_MASK, MTLK_CORE_REQ_SET_MIBS_CFG, FALSE, mtlk_mibs_cfg_t, mibs_cfg)
3627 MTLK_CFG_SET_ITEM(mibs_cfg, online_calibr_algo_mask, *(uint32*)data);
3628
3629 _DF_USER_SET_ON_PARAM(MIB_DISCONNECT_ON_NACKS_ENABLE, MTLK_CORE_REQ_SET_MIBS_CFG, FALSE, mtlk_mibs_cfg_t, mibs_cfg)
3630 MTLK_CFG_SET_ITEM(mibs_cfg, disconnect_on_nacks_enable, *(uint32*)data);
3631
3632 _DF_USER_SET_ON_PARAM(MIB_RTS_THRESHOLD, MTLK_CORE_REQ_SET_MIBS_CFG, FALSE, mtlk_mibs_cfg_t, mibs_cfg)
3633 MTLK_CFG_SET_ITEM(mibs_cfg, rts_threshold, *(uint32*)data);
3634
3635 _DF_USER_SET_ON_PARAM(MIB_TX_POWER, MTLK_CORE_REQ_SET_MIBS_CFG, FALSE, mtlk_mibs_cfg_t, mibs_cfg)
3636 MTLK_CFG_SET_ITEM(mibs_cfg, tx_power, *(uint32*)data);
3637
3638 _DF_USER_SET_ON_PARAM(MIB_SUPPORTED_TX_ANTENNAS, MTLK_CORE_REQ_SET_MIBS_CFG, FALSE, mtlk_mibs_cfg_t, mibs_cfg)
3639 MTLK_CFG_SET_ARRAY_ITEM_BY_FUNC_VOID(mibs_cfg, tx_antennas, strncpy,
3640 (mibs_cfg->tx_antennas, data, MTLK_NUM_ANTENNAS_BUFSIZE));
3641
3642 _DF_USER_SET_ON_PARAM(MIB_SUPPORTED_RX_ANTENNAS, MTLK_CORE_REQ_SET_MIBS_CFG, FALSE, mtlk_mibs_cfg_t, mibs_cfg)
3643 MTLK_CFG_SET_ARRAY_ITEM_BY_FUNC_VOID(mibs_cfg, rx_antennas, strncpy,
3644 (mibs_cfg->rx_antennas, data, MTLK_NUM_ANTENNAS_BUFSIZE));
3645
3646 _DF_USER_SET_ON_PARAM(PRM_ID_HIDDEN_SSID, MTLK_CORE_REQ_SET_CORE_CFG, FALSE, mtlk_gen_core_cfg_t, core_cfg)
3647 MTLK_CFG_SET_ITEM(core_cfg, is_hidden_ssid, (*(uint32*)data)?TRUE:FALSE);
3648
3649 _DF_USER_SET_ON_PARAM(MIB_COUNTRY, MTLK_CORE_REQ_SET_COUNTRY_CFG, FALSE, mtlk_country_cfg_t, country_cfg)
3650 MTLK_CFG_SET_ARRAY_ITEM_BY_FUNC_VOID(country_cfg, country, strncpy,
3651 (country_cfg->country, data, MTLK_CHNLS_COUNTRY_BUFSIZE));
3652
3653 _DF_USER_SET_ON_PARAM(PRM_ID_AOCS_RESTRICTED_CHANNELS, MTLK_CORE_REQ_SET_AOCS_CFG, FALSE, mtlk_aocs_cfg_t, aocs_cfg)
3654 MTLK_CFG_SET_ARRAY_ITEM_BY_FUNC(aocs_cfg, restricted_channels, _mtlk_df_user_fill_restricted_ch,
3655 (data, aocs_cfg->restricted_channels), res);
3656
3657 _DF_USER_SET_ON_PARAM(PRM_ID_AOCS_MSDU_TX_AC, MTLK_CORE_REQ_SET_AOCS_CFG, FALSE, mtlk_aocs_cfg_t, aocs_cfg)
3658 MTLK_CFG_SET_ARRAY_ITEM_BY_FUNC(aocs_cfg, msdu_tx_ac, _mtlk_df_user_fill_ac_values,
3659 (data, &aocs_cfg->msdu_tx_ac), res);
3660
3661 _DF_USER_SET_ON_PARAM(PRM_ID_AOCS_MSDU_RX_AC, MTLK_CORE_REQ_SET_AOCS_CFG, FALSE, mtlk_aocs_cfg_t, aocs_cfg)
3662 MTLK_CFG_SET_ARRAY_ITEM_BY_FUNC(aocs_cfg, msdu_rx_ac, _mtlk_df_user_fill_ac_values,
3663 (data, &aocs_cfg->msdu_rx_ac), res);
3664
3665 _DF_USER_SET_ON_PARAM(PRM_ID_AOCS_PENALTIES, MTLK_CORE_REQ_SET_AOCS_CFG, FALSE, mtlk_aocs_cfg_t, aocs_cfg)
3666 MTLK_CFG_SET_ARRAY_ITEM(aocs_cfg, penalties, (int32*)data, *length, res);
3667
3668 _DF_USER_SET_ON_PARAM(PRM_ID_L2NAT_AGING_TIMEOUT, MTLK_CORE_REQ_SET_L2NAT_CFG, FALSE, mtlk_l2nat_cfg_t, l2nat_cfg)
3669 MTLK_CFG_SET_ITEM(l2nat_cfg, aging_timeout, *(uint32*)data);
3670
3671 _DF_USER_SET_ON_PARAM(PRM_ID_L2NAT_DEFAULT_HOST, MTLK_CORE_REQ_SET_L2NAT_CFG, FALSE, mtlk_l2nat_cfg_t, l2nat_cfg)
3672 MTLK_CFG_SET_ITEM_BY_FUNC(l2nat_cfg, address, _mtlk_df_user_fill_ether_address,
3673 (&l2nat_cfg->address, (struct sockaddr*)data), res);
3674
3675 _DF_USER_SET_ON_PARAM(PRM_ID_PEERAP_DBG, MTLK_CORE_REQ_SET_WDS_DBG, FALSE, mtlk_wds_dbg_t, wds_dbg)
3676 MTLK_CFG_SET_ITEM(wds_dbg, dummy, *(uint32*)data);
3677
3678 _DF_USER_SET_ON_PARAM(PRM_ID_ADD_PEERAP, MTLK_CORE_REQ_SET_WDS_CFG, FALSE, mtlk_wds_cfg_t, wds_cfg)
3679 MTLK_CFG_SET_ITEM_BY_FUNC(wds_cfg, peer_ap_addr_add, _mtlk_df_user_fill_ether_address,
3680 (&wds_cfg->peer_ap_addr_add, (struct sockaddr*)data), res);
3681
3682 _DF_USER_SET_ON_PARAM(PRM_ID_DEL_PEERAP, MTLK_CORE_REQ_SET_WDS_CFG, FALSE, mtlk_wds_cfg_t, wds_cfg)
3683 MTLK_CFG_SET_ITEM_BY_FUNC(wds_cfg, peer_ap_addr_del, _mtlk_df_user_fill_ether_address,
3684 (&wds_cfg->peer_ap_addr_del, (struct sockaddr*)data), res);
3685
3686 _DF_USER_SET_ON_PARAM(PRM_ID_PEERAP_KEY_IDX, MTLK_CORE_REQ_SET_WDS_CFG, FALSE, mtlk_wds_cfg_t, wds_cfg)
3687 MTLK_CFG_SET_ITEM_BY_FUNC(wds_cfg, peer_ap_key_idx, _mtlk_df_user_fill_peer_ap_key_idx,
3688 (&wds_cfg->peer_ap_key_idx, *(uint32*)data), res);
3689
3690 _DF_USER_SET_ON_PARAM(PRM_ID_11D, MTLK_CORE_REQ_SET_DOT11D_CFG, FALSE, mtlk_dot11d_cfg_t, dot11d_cfg)
3691 MTLK_CFG_SET_ITEM(dot11d_cfg, is_dot11d, *(uint32*)data);
3692
3693 _DF_USER_SET_ON_PARAM(PRM_ID_11D_RESTORE_DEFAULTS, MTLK_CORE_REQ_SET_DOT11D_CFG, FALSE, mtlk_dot11d_cfg_t, dot11d_cfg)
3694 MTLK_CFG_SET_ITEM(dot11d_cfg, should_reset_tx_limits, *(uint32*)data);
3695
3696 _DF_USER_SET_ON_PARAM(PRM_ID_MAC_WATCHDOG_TIMEOUT_MS, MTLK_CORE_REQ_SET_MAC_WATCHDOG_CFG, FALSE, mtlk_mac_wdog_cfg_t, mac_wdog_cfg)
3697 MTLK_CFG_SET_ITEM(mac_wdog_cfg, mac_watchdog_timeout_ms, *(uint32*)data);
3698
3699 _DF_USER_SET_ON_PARAM(PRM_ID_MAC_WATCHDOG_PERIOD_MS, MTLK_CORE_REQ_SET_MAC_WATCHDOG_CFG, FALSE, mtlk_mac_wdog_cfg_t, mac_wdog_cfg)
3700 MTLK_CFG_SET_ITEM(mac_wdog_cfg, mac_watchdog_period_ms, *(uint32*)data);
3701
3702 _DF_USER_SET_ON_PARAM(PRM_ID_STA_KEEPALIVE_TIMEOUT, MTLK_CORE_REQ_SET_STADB_CFG, FALSE, mtlk_stadb_cfg_t, stadb_cfg)
3703 MTLK_CFG_SET_ITEM(stadb_cfg, sta_keepalive_timeout, *(uint32*)data);
3704
3705 _DF_USER_SET_ON_PARAM(PRM_ID_STA_KEEPALIVE_INTERVAL, MTLK_CORE_REQ_SET_STADB_CFG, FALSE, mtlk_stadb_cfg_t, stadb_cfg)
3706 MTLK_CFG_SET_ITEM(stadb_cfg, keepalive_interval, *(uint32*)data);
3707
3708 _DF_USER_SET_ON_PARAM(PRM_ID_AGGR_OPEN_THRESHOLD, MTLK_CORE_REQ_SET_STADB_CFG, FALSE, mtlk_stadb_cfg_t, stadb_cfg)
3709 MTLK_CFG_SET_ITEM(stadb_cfg, aggr_open_threshold, *(uint32*)data);
3710
3711 _DF_USER_SET_ON_PARAM(PRM_ID_BRIDGE_MODE, MTLK_CORE_REQ_SET_CORE_CFG, FALSE, mtlk_gen_core_cfg_t, pcore_cfg)
3712 MTLK_CFG_SET_ITEM(pcore_cfg, bridge_mode, *(uint32*)data);
3713
3714 _DF_USER_SET_ON_PARAM(PRM_ID_DBG_SW_WD_ENABLE, MTLK_CORE_REQ_SET_CORE_CFG, FALSE, mtlk_gen_core_cfg_t, pcore_cfg)
3715 MTLK_CFG_SET_ITEM(pcore_cfg, dbg_sw_wd_enable, *(uint32*)data);
3716
3717 _DF_USER_SET_ON_PARAM(PRM_ID_RELIABLE_MULTICAST, MTLK_CORE_REQ_SET_CORE_CFG, FALSE, mtlk_gen_core_cfg_t, pcore_cfg)
3718 MTLK_CFG_SET_ITEM(pcore_cfg, reliable_multicast, *(uint32*)data);
3719
3720 _DF_USER_SET_ON_PARAM(PRM_ID_UP_RESCAN_EXEMPTION_TIME, MTLK_CORE_REQ_SET_CORE_CFG, FALSE, mtlk_gen_core_cfg_t, pcore_cfg)
3721 MTLK_CFG_SET_ITEM(pcore_cfg, up_rescan_exemption_time, *(uint32*)data);
3722
3723 _DF_USER_SET_ON_PARAM(PRM_ID_AP_FORWARDING, MTLK_CORE_REQ_SET_CORE_CFG, FALSE, mtlk_gen_core_cfg_t, pcore_cfg)
3724 MTLK_CFG_SET_ITEM(pcore_cfg, ap_forwarding, *(uint32*)data);
3725
3726 _DF_USER_SET_ON_PARAM(PRM_ID_SPECTRUM_MODE, MTLK_CORE_REQ_SET_CORE_CFG, FALSE, mtlk_gen_core_cfg_t, pcore_cfg)
3727 MTLK_CFG_SET_ITEM(pcore_cfg, spectrum_mode, *(uint32*)data);
3728
3729 _DF_USER_SET_ON_PARAM(PRM_ID_NETWORK_MODE, MTLK_CORE_REQ_SET_CORE_CFG, FALSE, mtlk_gen_core_cfg_t, pcore_cfg)
3730 MTLK_CFG_SET_ITEM_BY_FUNC(pcore_cfg, net_mode, _mtlk_df_user_translate_network_mode,
3731 (*(uint32*)data, &pcore_cfg->net_mode), res)
3732
3733 _DF_USER_SET_ON_PARAM(PRM_ID_BSS_BASIC_RATE_SET, MTLK_CORE_REQ_SET_CORE_CFG, FALSE, mtlk_gen_core_cfg_t, pcore_cfg)
3734 MTLK_CFG_SET_ITEM(pcore_cfg, basic_rates, *(uint32*)data);
3735
3736 _DF_USER_SET_ON_PARAM(PRM_ID_BSS_SUPPORTED_RATE_SET, MTLK_CORE_REQ_SET_CORE_CFG, FALSE, mtlk_gen_core_cfg_t, pcore_cfg)
3737 MTLK_CFG_SET_ITEM(pcore_cfg, supported_rates, *(uint32*)data);
3738
3739 _DF_USER_SET_ON_PARAM(PRM_ID_BSS_EXTENDED_RATE_SET, MTLK_CORE_REQ_SET_CORE_CFG, FALSE, mtlk_gen_core_cfg_t, pcore_cfg)
3740 MTLK_CFG_SET_ITEM(pcore_cfg, extended_rates, *(uint32*)data);
3741
3742 _DF_USER_SET_ON_PARAM(PRM_ID_CHANNEL, MTLK_CORE_REQ_SET_CORE_CFG, FALSE, mtlk_gen_core_cfg_t, pcore_cfg)
3743 MTLK_CFG_SET_ITEM(pcore_cfg, channel, *(uint32*)data);
3744
3745 _DF_USER_SET_ON_PARAM(PRM_ID_POWER_SELECTION, MTLK_CORE_REQ_SET_MASTER_CFG, FALSE, mtlk_master_core_cfg_t, master_core_cfg)
3746 MTLK_CFG_SET_ITEM(master_core_cfg, power_selection, *(uint32*)data);
3747
3748
3749 _DF_USER_SET_ON_PARAM(PRM_ID_RX_HIGH_THRESHOLD, MTLK_CORE_REQ_SET_MASTER_CFG, FALSE, mtlk_master_core_cfg_t, master_core_cfg)
3750 MTLK_CFG_SET_ITEM_BY_FUNC(master_core_cfg, rx_high_threshold, __set_item_value_int8,
3751 (*(int32*)data, &master_core_cfg->rx_high_threshold), res);
3752
3753 _DF_USER_SET_ON_PARAM(PRM_ID_CCA_THRESHOLD, MTLK_CORE_REQ_SET_MASTER_CFG, FALSE, mtlk_master_core_cfg_t, master_core_cfg)
3754 MTLK_CFG_SET_ITEM_BY_FUNC(master_core_cfg, cca_threshold, __set_item_value_int8,
3755 (*(int32*)data, &master_core_cfg->cca_threshold), res);
3756
3757 _DF_USER_SET_ON_PARAM(PRM_ID_RA_PROTECTION, MTLK_CORE_REQ_SET_MASTER_CFG, FALSE, mtlk_master_core_cfg_t, master_core_cfg)
3758 MTLK_CFG_SET_ITEM(master_core_cfg, ra_protection, !!(*(uint32*)data));
3759
3760 _DF_USER_SET_ON_PARAM(PRM_ID_FORCE_NCB, MTLK_CORE_REQ_SET_MASTER_CFG, FALSE, mtlk_master_core_cfg_t, master_core_cfg)
3761 MTLK_CFG_SET_ITEM(master_core_cfg, force_ncb, !!(*(uint32*)data));
3762
3763 _DF_USER_SET_ON_PARAM(PRM_ID_N_RATES_BOS, MTLK_CORE_REQ_SET_MASTER_CFG, FALSE, mtlk_master_core_cfg_t, pmaster_cfg)
3764 MTLK_CFG_SET_ITEM_BY_FUNC(pmaster_cfg, n_rate_bo,
3765 _mtlk_df_user_get_n_rate_bo_by_intvec, ((int32*)data, *length, &pmaster_cfg->n_rate_bo), res);
3766
3767 _DF_USER_SET_ON_PARAM(PRM_ID_DEBUG_TPC, MTLK_CORE_REQ_SET_MASTER_CFG, FALSE, mtlk_master_core_cfg_t, master_core_cfg)
3768 MTLK_CFG_SET_ITEM(master_core_cfg, debug_tpc, *(uint32*)data);
3769
3770 _DF_USER_SET_ON_PARAM(PRM_ID_VAP_LNA_GAINS, MTLK_CORE_REQ_SET_MASTER_CFG, FALSE, mtlk_master_core_cfg_t, master_core_cfg)
3771 MTLK_CFG_SET_ITEM_BY_FUNC(master_core_cfg, lna_gain, _mtlk_df_user_set_lna_gain_by_intvec,
3772 ((uint32*)data, *length, &master_core_cfg->lna_gain), res);
3773
3774 _DF_USER_SET_ON_PARAM(PRM_ID_NICK_NAME, MTLK_CORE_REQ_SET_CORE_CFG, FALSE, mtlk_gen_core_cfg_t, pcore_cfg)
3775 MTLK_ASSERT(sizeof(pcore_cfg->nickname) >= *length);
3776 MTLK_CFG_SET_ARRAY_ITEM_BY_FUNC_VOID(pcore_cfg, nickname, memcpy,
3777 (pcore_cfg->nickname, data, *length));
3778
3779 _DF_USER_SET_ON_PARAM(PRM_ID_ESSID, MTLK_CORE_REQ_SET_CORE_CFG, FALSE, mtlk_gen_core_cfg_t, pcore_cfg)
3780 MTLK_ASSERT(sizeof(pcore_cfg->essid) >= *length);
3781 MTLK_CFG_SET_ARRAY_ITEM_BY_FUNC_VOID(pcore_cfg, essid, memcpy,
3782 (pcore_cfg->essid, data, *length));
3783
3784 _DF_USER_SET_ON_PARAM(PRM_ID_LEGACY_FORCE_RATE, MTLK_CORE_REQ_SET_MASTER_CFG, FALSE, mtlk_master_core_cfg_t, pmaster_cfg)
3785 data[*length - 1] = '\0'; /* force string null-termination */
3786 MTLK_CFG_SET_ITEM_BY_FUNC(pmaster_cfg, legacy_force_rate, _mtlk_df_user_parse_bitrate_str,
3787 (data, &pmaster_cfg->legacy_force_rate), res);
3788
3789 _DF_USER_SET_ON_PARAM(PRM_ID_HT_FORCE_RATE, MTLK_CORE_REQ_SET_MASTER_CFG, FALSE, mtlk_master_core_cfg_t, pmaster_cfg)
3790 data[*length - 1] = '\0'; /* force string null-termination */
3791 MTLK_CFG_SET_ITEM_BY_FUNC(pmaster_cfg, ht_force_rate, _mtlk_df_user_parse_bitrate_str,
3792 (data, &pmaster_cfg->ht_force_rate), res);
3793
3794 _DF_USER_SET_ON_PARAM(PRM_ID_AGG_RATE_LIMIT, MTLK_CORE_REQ_SET_MASTER_CFG, FALSE, mtlk_master_core_cfg_t, pmaster_cfg)
3795 MTLK_CFG_SET_ITEM_BY_FUNC(pmaster_cfg, agg_rate_limit, _mtlk_df_user_set_agg_rate_limit_by_intvec,
3796 ((uint32*)data, *length, &pmaster_cfg->agg_rate_limit), res);
3797
3798 _DF_USER_SET_ON_PARAM(PRM_ID_RX_DUTY_CYCLE, MTLK_CORE_REQ_SET_MASTER_CFG, FALSE, mtlk_master_core_cfg_t, pmaster_cfg)
3799 MTLK_CFG_SET_ITEM_BY_FUNC(pmaster_cfg, rx_duty_cycle, _mtlk_df_user_set_rx_duty_cycle_by_intvec,
3800 ((uint32*)data, *length, &pmaster_cfg->rx_duty_cycle), res);
3801
3802 _DF_USER_SET_ON_PARAM(PRM_ID_ACL, MTLK_CORE_REQ_SET_CORE_CFG, FALSE, mtlk_gen_core_cfg_t, pcore_cfg)
3803 int i;
3804 MTLK_CFG_SET_ITEM(pcore_cfg, num_macs_to_set, *length);
3805 for (i = 0; (i < pcore_cfg->num_macs_to_set) && (i < MAX_ADDRESSES_IN_ACL); i++) {
3806 MTLK_CFG_SET_ITEM_BY_FUNC_VOID(pcore_cfg, macs_to_set, memcpy,
3807 (pcore_cfg->macs_to_set[i].au8Addr, ((struct sockaddr*)data)[i].sa_data, sizeof(pcore_cfg->macs_to_set[i].au8Addr)));
3808 }
3809
3810 _DF_USER_SET_ON_PARAM(PRM_ID_ACL_RANGE, MTLK_CORE_REQ_SET_CORE_CFG, FALSE, mtlk_gen_core_cfg_t, pcore_cfg)
3811 int i;
3812
3813 if (0 != (*length % 2)) {
3814 ELOG_D("Address vector length should be even. length(%u)", *length);
3815 res = MTLK_ERR_PARAMS;
3816 } else if ((*length >> 1) > MAX_ADDRESSES_IN_ACL) {
3817 ELOG_D("Address vector length should be not more than %u address/mask pairs", MAX_ADDRESSES_IN_ACL);
3818 res = MTLK_ERR_PARAMS;
3819 } else {
3820 MTLK_CFG_SET_ITEM(pcore_cfg, num_macs_to_set, (*length) >> 1);
3821 for (i = 0; i < pcore_cfg->num_macs_to_set; i++) {
3822 MTLK_CFG_SET_ITEM_BY_FUNC_VOID(pcore_cfg, macs_to_set, memcpy,
3823 (pcore_cfg->macs_to_set[i].au8Addr, ((struct sockaddr*)data)[i << 1].sa_data, sizeof(pcore_cfg->macs_to_set[i].au8Addr)));
3824 MTLK_CFG_SET_ITEM_BY_FUNC_VOID(pcore_cfg, mac_mask, memcpy,
3825 (pcore_cfg->mac_mask[i].au8Addr, ((struct sockaddr*)data)[(i << 1) + 1].sa_data, sizeof(pcore_cfg->mac_mask[i].au8Addr)));
3826 }
3827 }
3828
3829 _DF_USER_SET_ON_PARAM(PRM_ID_ACL_DEL, MTLK_CORE_REQ_SET_CORE_CFG, FALSE, mtlk_gen_core_cfg_t, pcore_cfg)
3830 int i;
3831 MTLK_CFG_SET_ITEM(pcore_cfg, num_macs_to_del, *length);
3832 for (i = 0; (i < pcore_cfg->num_macs_to_del) && (i < MAX_ADDRESSES_IN_ACL); i++) {
3833 MTLK_CFG_SET_ITEM_BY_FUNC_VOID(pcore_cfg, macs_to_del, memcpy,
3834 (pcore_cfg->macs_to_del[i].au8Addr, ((struct sockaddr*)data)[i].sa_data, sizeof(pcore_cfg->macs_to_del[i].au8Addr)));
3835 }
3836
3837 _DF_USER_SET_ON_PARAM(PRM_ID_ACTIVE_SCAN_SSID, MTLK_CORE_REQ_SET_SCAN_CFG, FALSE, mtlk_scan_cfg_t, scan_cfg)
3838 data[*length - 1] = '\0'; /* force string null-termination */
3839 MTLK_CFG_SET_ITEM_BY_FUNC_VOID(scan_cfg, essid, strncpy,
3840 (scan_cfg->essid, data, MIB_ESSID_LENGTH + 1));
3841 scan_cfg->essid[MIB_ESSID_LENGTH] = '\0';
3842
3843 _DF_USER_SET_ON_PARAM(PRM_ID_HW_LIMITS, MTLK_CORE_REQ_SET_HW_DATA_CFG, FALSE, mtlk_hw_data_cfg_t, hw_data_cfg)
3844 data[*length - 1] = '\0';
3845 MTLK_CFG_SET_ITEM_BY_FUNC(hw_data_cfg, hw_cfg, _mtlk_df_user_fill_hw_cfg,
3846 (&hw_data_cfg->hw_cfg, data), res);
3847
3848 _DF_USER_SET_ON_PARAM(PRM_ID_ANT_GAIN, MTLK_CORE_REQ_SET_HW_DATA_CFG, FALSE, mtlk_hw_data_cfg_t, hw_data_cfg)
3849 data[*length - 1] = '\0';
3850 MTLK_CFG_SET_ITEM_BY_FUNC(hw_data_cfg, ant, _mtlk_df_user_fill_ant_cfg,
3851 (&hw_data_cfg->ant, data), res);
3852
3853 _DF_USER_SET_ON_PARAM(PRM_ID_TX_POWER_LIMIT, MTLK_CORE_REQ_SET_HW_DATA_CFG, FALSE, mtlk_hw_data_cfg_t, hw_data_cfg)
3854 MTLK_CFG_SET_ITEM_BY_FUNC(hw_data_cfg, power_limit, _mtlk_df_user_fill_power_limit_cfg_by_int_vec,
3855 (&hw_data_cfg->power_limit, *length, (int32*)data), res);
3856
3857 _DF_USER_SET_ON_PARAM(PRM_ID_WDS_HOST_TIMEOUT, MTLK_CORE_REQ_SET_HSTDB_CFG, FALSE, mtlk_hstdb_cfg_t, hstdb_cfg)
3858 MTLK_CFG_SET_ITEM(hstdb_cfg, wds_host_timeout, *(uint32*)data);
3859
3860 _DF_USER_SET_ON_PARAM(PRM_ID_HSTDB_LOCAL_MAC, MTLK_CORE_REQ_SET_HSTDB_CFG, FALSE, mtlk_hstdb_cfg_t, hstdb_cfg)
3861 MTLK_CFG_SET_ITEM_BY_FUNC(hstdb_cfg, address, _mtlk_df_user_fill_ether_address, (&hstdb_cfg->address, (struct sockaddr*)data), res);
3862
3863 _DF_USER_SET_ON_PARAM(PRM_ID_SCAN_CACHE_LIFETIME, MTLK_CORE_REQ_SET_SCAN_CFG, FALSE, mtlk_scan_cfg_t, scan_cfg)
3864 MTLK_CFG_SET_ITEM(scan_cfg, cache_expire, *(uint32*)data);
3865
3866 _DF_USER_SET_ON_PARAM(PRM_ID_BG_SCAN_CH_LIMIT, MTLK_CORE_REQ_SET_SCAN_CFG, FALSE, mtlk_scan_cfg_t, scan_cfg)
3867 MTLK_CFG_SET_ITEM(scan_cfg, channels_per_chunk_limit, *(uint32*)data);
3868
3869 _DF_USER_SET_ON_PARAM(PRM_ID_BG_SCAN_PAUSE, MTLK_CORE_REQ_SET_SCAN_CFG, FALSE, mtlk_scan_cfg_t, scan_cfg)
3870 MTLK_CFG_SET_ITEM(scan_cfg, pause_between_chunks, *(uint32*)data);
3871
3872 _DF_USER_SET_ON_PARAM(PRM_ID_IS_BACKGROUND_SCAN, MTLK_CORE_REQ_SET_SCAN_CFG, FALSE, mtlk_scan_cfg_t, scan_cfg)
3873 MTLK_CFG_SET_ITEM(scan_cfg, is_background_scan, *(uint32*)data);
3874
3875 _DF_USER_SET_ON_PARAM(PRM_ID_USE_8021Q, MTLK_CORE_REQ_SET_QOS_CFG, FALSE, mtlk_qos_cfg_t, qos_cfg)
3876 MTLK_CFG_SET_ITEM(qos_cfg, map, *(uint32*)data);
3877
3878 _DF_USER_SET_ON_PARAM(PRM_ID_COC_POWER_MODE, MTLK_CORE_REQ_SET_COC_CFG, FALSE, mtlk_coc_mode_cfg_t, coc_cfg)
3879 MTLK_CFG_SET_ITEM(coc_cfg, is_auto_mode, *(uint32*)data);
3880 MTLK_CFG_SET_ITEM_BY_FUNC(coc_cfg, antenna_params,
3881 _mtlk_df_user_get_coc_antenna_params_by_intvec, ((uint32*)data, *length, &coc_cfg->antenna_params), res);
3882
3883 _DF_USER_SET_ON_PARAM(PRM_ID_COC_AUTO_PARAMS, MTLK_CORE_REQ_SET_COC_CFG, FALSE, mtlk_coc_mode_cfg_t, coc_cfg)
3884 MTLK_CFG_SET_ITEM_BY_FUNC(coc_cfg, auto_params,
3885 _mtlk_df_user_get_coc_auto_params_by_intvec, ((uint32*)data, *length, &coc_cfg->auto_params), res);
3886
3887 #ifdef MTCFG_PMCU_SUPPORT
3888 _DF_USER_SET_ON_PARAM(PRM_ID_PCOC_POWER_MODE, MTLK_CORE_REQ_SET_PCOC_CFG, FALSE, mtlk_pcoc_mode_cfg_t, pcoc_cfg)
3889 MTLK_CFG_SET_ITEM(pcoc_cfg, is_enabled, *(uint32*)data);
3890
3891 _DF_USER_SET_ON_PARAM(PRM_ID_PCOC_AUTO_PARAMS, MTLK_CORE_REQ_SET_PCOC_CFG, FALSE, mtlk_pcoc_mode_cfg_t, pcoc_cfg)
3892 MTLK_CFG_SET_ITEM_BY_FUNC(pcoc_cfg, params,
3893 _mtlk_df_user_get_pcoc_params_by_intvec, ((uint32*)data, *length, &pcoc_cfg->params), res);
3894
3895 _DF_USER_SET_ON_PARAM(PRM_ID_PCOC_PMCU_DEBUG, MTLK_CORE_REQ_SET_PCOC_CFG, FALSE, mtlk_pcoc_mode_cfg_t, pcoc_cfg)
3896 MTLK_CFG_SET_ITEM(pcoc_cfg, pmcu_debug, *(uint32*)data);
3897 #endif
3898
3899 _DF_USER_SET_ON_PARAM(PRM_ID_SQ_LIMITS, MTLK_CORE_REQ_SET_SQ_CFG, FALSE, mtlk_sq_cfg_t, sq_cfg)
3900 MTLK_CFG_SET_ARRAY_ITEM(sq_cfg, sq_limit, (int32*)data, *length, res);
3901
3902 _DF_USER_SET_ON_PARAM(PRM_ID_SQ_PEER_LIMITS, MTLK_CORE_REQ_SET_SQ_CFG, FALSE, mtlk_sq_cfg_t, sq_cfg)
3903 MTLK_CFG_SET_ARRAY_ITEM(sq_cfg, peer_queue_limit, (int32*)data, *length, res);
3904
3905 /* 20/40 coexistence */
3906
3907 _DF_USER_SET_ON_PARAM(PRM_ID_COEX_MODE, MTLK_CORE_REQ_SET_COEX_20_40_MODE_CFG, FALSE, mtlk_coex_20_40_mode_cfg_t, coex20_40_cfg)
3908 MTLK_CFG_SET_ITEM(coex20_40_cfg, coexistence_mode, *(uint32*)data);
3909 /*ILOG0_D("FUNCTION Value in core = %d\n", *(uint32*)data);*/
3910
3911 _DF_USER_SET_ON_PARAM(PRM_ID_COEX_THRESHOLD, MTLK_CORE_REQ_SET_COEX_20_40_RSSI_THR_CFG, FALSE, mtlk_coex_20_40_mode_cfg_t, coex20_40_cfg)
3912 MTLK_CFG_SET_ITEM(coex20_40_cfg, rssi_threshold, *(int32*)data);
3913
3914 _DF_USER_SET_ON_PARAM(PRM_ID_INTOLERANCE_MODE, MTLK_CORE_REQ_SET_COEX_20_40_MODE_CFG, FALSE, mtlk_coex_20_40_mode_cfg_t, coex20_40_cfg)
3915 MTLK_CFG_SET_ITEM(coex20_40_cfg, intolerance_mode, *(uint32*)data);
3916 /*ILOG0_D("FUNCTION Value in core = %d\n", *(uint32*)data);*/
3917
3918 _DF_USER_SET_ON_PARAM(PRM_ID_SCAN_AP_FORCE_SCAN_PARAMS_ON_ASSOC_STA, MTLK_CORE_REQ_SET_COEX_20_40_AP_FORCE_PARAMS_CFG, FALSE, mtlk_coex_20_40_ap_force_params_cfg_t, coex20_40_cfg)
3919 MTLK_CFG_SET_ITEM(coex20_40_cfg, ap_force_scan_params_on_assoc_sta, *(uint32*)data);
3920 /*ILOG0_D("FUNCTION Value in core = %d\n", *(uint32*)data);*/
3921
3922 _DF_USER_SET_ON_PARAM(PRM_ID_SCAN_AP_WAIT_FOR_SCAN_RESULTS_INTERVAL, MTLK_CORE_REQ_SET_COEX_20_40_AP_FORCE_PARAMS_CFG, FALSE, mtlk_coex_20_40_ap_force_params_cfg_t, coex20_40_cfg)
3923 MTLK_CFG_SET_ITEM(coex20_40_cfg, wait_for_scan_results_interval, *(uint32*)data);
3924 /*ILOG0_D("FUNCTION Value in core = %d\n", *(uint32*)data);*/
3925
3926 _DF_USER_SET_ON_PARAM(PRM_ID_EXEMPTION_REQ, MTLK_CORE_REQ_SET_COEX_20_40_STA_EXEMPTION_REQ_CFG, FALSE, mtlk_coex_20_40_exm_req_cfg_t, coex20_40_cfg)
3927 MTLK_CFG_SET_ITEM(coex20_40_cfg, exemption_req, *(uint32*)data);
3928 /*ILOG0_D("FUNCTION Value in core = %d\n", *(uint32*)data);*/
3929
3930 _DF_USER_SET_ON_PARAM(PRM_ID_MIN_NON_EXEMPTED_STA, MTLK_CORE_REQ_SET_COEX_20_40_AP_MIN_NUM_OF_EXM_STA_CFG, FALSE, mtlk_coex_20_40_min_num_exm_sta_cfg_t, coex20_40_cfg)
3931 MTLK_CFG_SET_ITEM(coex20_40_cfg, min_non_exempted_sta, *(uint32*)data);
3932 /*ILOG0_D("FUNCTION Value in core = %d\n", *(uint32*)data);*/
3933
3934 _DF_USER_SET_ON_PARAM(PRM_ID_DELAY_FACTOR, MTLK_CORE_REQ_SET_COEX_20_40_TIMES_CFG, FALSE, mtlk_coex_20_40_times_cfg_t, coex20_40_cfg)
3935 MTLK_CFG_SET_ITEM(coex20_40_cfg, delay_factor, *(uint32*)data);
3936 /*ILOG0_D("FUNCTION Value in core = %d\n", *(uint32*)data);*/
3937
3938 _DF_USER_SET_ON_PARAM(PRM_ID_OBSS_SCAN_INTERVAL, MTLK_CORE_REQ_SET_COEX_20_40_TIMES_CFG, FALSE, mtlk_coex_20_40_times_cfg_t, coex20_40_cfg)
3939 MTLK_CFG_SET_ITEM(coex20_40_cfg, obss_scan_interval, *(uint32*)data);
3940 /*ILOG0_D("FUNCTION Value in core = %d\n", *(uint32*)data);*/
3941
3942 _DF_USER_SET_ON_PARAM(PRM_ID_SCAN_ACTIVITY_THRESHOLD, MTLK_CORE_REQ_SET_COEX_20_40_TIMES_CFG, FALSE, mtlk_coex_20_40_times_cfg_t, coex20_40_cfg)
3943 MTLK_CFG_SET_ITEM(coex20_40_cfg, scan_activity_threshold, *(uint32*)data);
3944 /*ILOG0_D("FUNCTION Value in core = %d\n", *(uint32*)data);*/
3945
3946 _DF_USER_SET_ON_PARAM(PRM_ID_SCAN_PASSIVE_DWELL, MTLK_CORE_REQ_SET_COEX_20_40_TIMES_CFG, FALSE, mtlk_coex_20_40_times_cfg_t, coex20_40_cfg)
3947 MTLK_CFG_SET_ITEM(coex20_40_cfg, scan_passive_dwell, *(uint32*)data);
3948 /*ILOG0_D("FUNCTION Value in core = %d\n", *(uint32*)data);*/
3949
3950 _DF_USER_SET_ON_PARAM(PRM_ID_SCAN_ACTIVE_DWELL, MTLK_CORE_REQ_SET_COEX_20_40_TIMES_CFG, FALSE, mtlk_coex_20_40_times_cfg_t, coex20_40_cfg)
3951 MTLK_CFG_SET_ITEM(coex20_40_cfg, scan_active_dwell, *(uint32*)data);
3952 /*ILOG0_D("FUNCTION Value in core = %d\n", *(uint32*)data);*/
3953
3954 _DF_USER_SET_ON_PARAM(PRM_ID_SCAN_PASSIVE_TOTAL_PER_CHANNEL, MTLK_CORE_REQ_SET_COEX_20_40_TIMES_CFG, FALSE, mtlk_coex_20_40_times_cfg_t, coex20_40_cfg)
3955 MTLK_CFG_SET_ITEM(coex20_40_cfg, scan_passive_total_per_channel, *(uint32*)data);
3956 /*ILOG0_D("FUNCTION Value in core = %d\n", *(uint32*)data);*/
3957
3958 _DF_USER_SET_ON_PARAM(PRM_ID_SCAN_ACTIVE_TOTAL_PER_CHANNEL, MTLK_CORE_REQ_SET_COEX_20_40_TIMES_CFG, FALSE, mtlk_coex_20_40_times_cfg_t, coex20_40_cfg)
3959 MTLK_CFG_SET_ITEM(coex20_40_cfg, scan_active_total_per_channel, *(uint32*)data);
3960 /*ILOG0_D("FUNCTION Value in core = %d\n", *(uint32*)data);*/
3961
3962 /* Interference Detection */
3963 _DF_USER_SET_ON_PARAM(PRM_ID_INTERFER_TIMEOUTS, MTLK_CORE_REQ_SET_INTERFDET_PARAMS_CFG, FALSE, mtlk_interfdet_cfg_t, interfdet_cfg)
3964 MTLK_CFG_SET_ITEM_BY_FUNC(interfdet_cfg, req_timeouts,
3965 _mtlk_df_user_get_interfdet_req_timeouts_by_intvec, ((uint32*)data, *length, &interfdet_cfg->req_timeouts), res);
3966
3967 _DF_USER_SET_ON_PARAM(PRM_ID_INTERFER_THRESH, MTLK_CORE_REQ_SET_INTERFDET_PARAMS_CFG, FALSE, mtlk_interfdet_cfg_t, interfdet_cfg)
3968 MTLK_CFG_SET_ITEM_BY_FUNC(interfdet_cfg, req_thresh,
3969 _mtlk_df_user_get_interfdet_req_thresh_by_intvec, ((uint32*)data, *length, &interfdet_cfg->req_thresh), res);
3970
3971 _DF_USER_SET_ON_PARAM(PRM_ID_INTERFER_SCANTIMES, MTLK_CORE_REQ_SET_INTERFDET_PARAMS_CFG, FALSE, mtlk_interfdet_cfg_t, interfdet_cfg)
3972 MTLK_CFG_SET_ITEM_BY_FUNC(interfdet_cfg, req_scantimes,
3973 _mtlk_df_user_get_interfdet_req_scantimes_by_intvec, ((uint32*)data, *length, &interfdet_cfg->req_scantimes), res);
3974
3975 _DF_USER_SET_ON_PARAM(PRM_ID_CFG_LED_GPIO, MTLK_CORE_REQ_SET_FW_LED_CFG, FALSE, mtlk_fw_led_cfg_t, fw_led_cfg)
3976 MTLK_CFG_SET_ITEM_BY_FUNC(fw_led_cfg, gpio_cfg,
3977 _mtlk_df_user_get_fw_gpio_cfg_by_intvec, ((uint32*)data, *length, &fw_led_cfg->gpio_cfg), res);
3978
3979 _DF_USER_SET_ON_PARAM(PRM_ID_CFG_LED_STATE, MTLK_CORE_REQ_SET_FW_LED_CFG, FALSE, mtlk_fw_led_cfg_t, fw_led_cfg)
3980 MTLK_CFG_SET_ITEM_BY_FUNC(fw_led_cfg, led_state,
3981 _mtlk_df_user_get_fw_led_state_by_intvec, ((uint32*)data, *length, &fw_led_cfg->led_state), res);
3982
3983 _DF_USER_SET_ON_PARAM(PRM_ID_DBG_CLI, MTLK_CORE_REQ_SET_DBG_CLI, FALSE, mtlk_dbg_cli_cfg_t, dbg_cli_cfg)
3984 MTLK_CFG_SET_ITEM_BY_FUNC(dbg_cli_cfg, DbgCliReq,
3985 _mtlk_df_user_do_simple_cli, ((uint32*)data, *length, &dbg_cli_cfg->DbgCliReq), res);
3986
3987 _DF_USER_SET_ON_PARAM(PRM_ID_FW_DEBUG, MTLK_CORE_REQ_SET_FW_DEBUG, FALSE, mtlk_fw_debug_cfg_t, fw_debug_cfg)
3988 MTLK_CFG_SET_ITEM_BY_FUNC(fw_debug_cfg, FWDebugReq,
3989 _mtlk_df_user_do_fw_debug, ((uint32*)data, *length, &fw_debug_cfg->FWDebugReq), res);
3990
3991 _DF_USER_SET_ON_PARAM(PRM_ID_FW_LOG_SEVERITY, MTLK_CORE_REQ_SET_FW_LOG_SEVERITY, FALSE, mtlk_fw_log_severity_t, fw_log_severity)
3992 if (2 != (*length)) {
3993 ELOG_D("Need exactly 2 arguments (length=%u)", *length);
3994 res = MTLK_ERR_PARAMS;
3995 } else {
3996 MTLK_CFG_SET_ITEM(fw_log_severity, newLevel, ((uint32*)data)[0]);
3997 MTLK_CFG_SET_ITEM(fw_log_severity, targetCPU, ((uint32*)data)[1]);
3998 /* ILOG0_DD("FUNCTION Values in core = %d, %d\n", ((uint32*)data)[0], ((uint32*)data)[1]); */
3999 }
4000
4001 _DF_USER_SET_ON_PARAM(PRM_ID_TA_TIMER_RESOLUTION, MTLK_CORE_REQ_SET_TA_CFG, FALSE, mtlk_ta_cfg_t, mtlk_ta_cfg)
4002 MTLK_CFG_SET_ITEM(mtlk_ta_cfg, timer_resolution, *(uint32*)data);
4003
4004 _DF_USER_SET_ON_PARAM(PRM_ID_ENHANCED11B_TH, MTLK_CORE_REQ_SET_ENHANCED11B_CFG, FALSE, mtlk_enhanced11b_cfg_t, mtlk_enhanced11b_cfg)
4005 MTLK_CFG_SET_ITEM_BY_FUNC(mtlk_enhanced11b_cfg, thresholds,
4006 _mtlk_df_user_get_11b_thresholds_by_intvec, ((uint32*)data, *length, &mtlk_enhanced11b_cfg->thresholds), res);
4007
4008 _DF_USER_SET_ON_PARAM(PRM_ID_11B_ANTENNA_SELECTION, MTLK_CORE_REQ_SET_11B_CFG, FALSE, mtlk_11b_cfg_t, mtlk_11b_cfg)
4009 MTLK_CFG_SET_ITEM_BY_FUNC(mtlk_11b_cfg, antsel,
4010 _mtlk_df_user_get_11b_antsel_by_intvec, ((uint32*)data, *length, &mtlk_11b_cfg->antsel), res);
4011
4012 /* 802.11w parameters begin */
4013 _DF_USER_SET_ON_PARAM(PRM_ID_PMF_ACTIVATED, MTLK_CORE_REQ_SET_DOT11W_CFG, FALSE, mtlk_dot11w_cfg_t, mtlk_dot11w_cfg)
4014 MTLK_CFG_SET_ITEM(mtlk_dot11w_cfg, pmf_activated, *(uint32*)data);
4015
4016 _DF_USER_SET_ON_PARAM(PRM_ID_PMF_REQUIRED, MTLK_CORE_REQ_SET_DOT11W_CFG, FALSE, mtlk_dot11w_cfg_t, mtlk_dot11w_cfg)
4017 MTLK_CFG_SET_ITEM(mtlk_dot11w_cfg, pmf_required, *(uint32*)data);
4018
4019 _DF_USER_SET_ON_PARAM(PRM_ID_SAQ_RETR_TMOUT, MTLK_CORE_REQ_SET_DOT11W_CFG, FALSE, mtlk_dot11w_cfg_t, mtlk_dot11w_cfg)
4020 MTLK_CFG_SET_ITEM(mtlk_dot11w_cfg, saq_retr_tmout, *(uint32*)data);
4021
4022 _DF_USER_SET_ON_PARAM(PRM_ID_SAQ_MAX_TMOUT, MTLK_CORE_REQ_SET_DOT11W_CFG, FALSE, mtlk_dot11w_cfg_t, mtlk_dot11w_cfg)
4023 MTLK_CFG_SET_ITEM(mtlk_dot11w_cfg, saq_max_tmout, *(uint32*)data);
4024 /* 802.11w parameters end */
4025
4026 _DF_USER_SET_ON_PARAM(PRM_ID_FW_RECOVERY, MTLK_CORE_REQ_SET_RECOVERY_CFG, FALSE, mtlk_rcvry_cfg_t, fw_rcvry_cfg)
4027 MTLK_CFG_SET_ITEM_BY_FUNC(fw_rcvry_cfg, recovery_cfg,
4028 _mtlk_df_user_get_recovery_by_intvec, ((uint32*)data, *length, &fw_rcvry_cfg->recovery_cfg), res);
4029
4030 _DF_USER_SET_ON_PARAM(PRM_ID_MC_PS_SIZE, MTLK_CORE_REQ_SET_MC_PS_SIZE_CFG, FALSE, mtlk_mc_ps_size_cfg_t, mc_ps_size_cfg)
4031 MTLK_CFG_SET_ITEM(mc_ps_size_cfg, maxNumberOfFsdus, *(uint32*)data);
4032
4033 /* U-APSD mode */
4034 _DF_USER_SET_ON_PARAM(PRM_ID_UAPSD_MODE, MTLK_CORE_REQ_SET_UAPSD_MODE, FALSE, mtlk_uapsd_mode_cfg_t, uapsd_mode_cfg)
4035 MTLK_CFG_SET_ITEM(uapsd_mode_cfg, uapsd_enabled, *(uint32*)data);
4036
4037 _DF_USER_SET_ON_PARAM(PRM_ID_UAPSD_MAX_SP, MTLK_CORE_REQ_SET_UAPSD_CFG, FALSE, mtlk_uapsd_cfg_t, uapsd_cfg)
4038 MTLK_CFG_SET_ITEM(uapsd_cfg, uapsd_max_sp, *(uint32*)data);
4039
4040 _DF_USER_SET_PARAM_MAP_END()
4041
4042 return res;
4043 }
4044
4045 static int
4046 _mtlk_ioctl_drv_gen_data_exchange (mtlk_df_user_t* df_user, struct ifreq *ifr)
4047 {
4048 int res = MTLK_ERR_OK;
4049 mtlk_core_ui_gen_data_t req;
4050 WE_GEN_DATAEX_RESPONSE resp;
4051 mtlk_clpb_t *clpb = NULL;
4052
4053 WE_GEN_DATAEX_DEVICE_STATUS *dev_status = NULL;
4054 WE_GEN_DATAEX_CONNECTION_STATUS *con_status = NULL;
4055 WE_GEN_DATAEX_STATUS *status = NULL;
4056 WE_GEN_DATAEX_RESPONSE *core_resp = NULL;
4057 uint32 core_resp_size = 0;
4058
4059 /* response, should be placed first to user buffer */
4060 void *out = ifr->ifr_data + sizeof(WE_GEN_DATAEX_RESPONSE);
4061 const char *reason = "system error";
4062
4063 /* Make sure no fields will be left uninitialized by command handler */
4064 memset(&req, 0, sizeof(req));
4065 memset(&resp, 0, sizeof(resp));
4066
4067 if (0 != copy_from_user(&req.request, ifr->ifr_data, sizeof(req.request))) {
4068 res = MTLK_ERR_PARAMS;
4069 goto finish;
4070 }
4071
4072 /* error case - copy response with error status and needed protocol version to user space */
4073 if (WE_GEN_DATAEX_PROTO_VER != req.request.ver) {
4074 uint32 proto_ver = WE_GEN_DATAEX_PROTO_VER;
4075
4076 WLOG_DD("Data exchange protocol version mismatch (version is %u, expected %u)",
4077 req.request.ver,
4078 WE_GEN_DATAEX_PROTO_VER);
4079
4080 resp.status = WE_GEN_DATAEX_PROTO_MISMATCH;
4081 resp.datalen = sizeof(uint32);
4082
4083 if (0 != copy_to_user(out, &proto_ver, sizeof(uint32))) {
4084 res = MTLK_ERR_PARAMS;
4085 }
4086 goto finish;
4087 }
4088
4089 /* in case of MAC leds additional parameters are needed from userspace */
4090 if (WE_GEN_DATAEX_CMD_LEDS_MAC == req.request.cmd_id) {
4091 if (0 != copy_from_user(&req.leds_status,
4092 ifr->ifr_data + sizeof(WE_GEN_DATAEX_REQUEST),
4093 sizeof(req.leds_status))) {
4094 res = MTLK_ERR_PARAMS;
4095 goto finish;
4096 }
4097 }
4098
4099 res = _mtlk_df_user_invoke_core(df_user->df,
4100 MTLK_CORE_REQ_GEN_DATA_EXCHANGE,
4101 &clpb, &req, sizeof(req));
4102 res = _mtlk_df_user_process_core_retval_void(res, clpb, MTLK_CORE_REQ_GEN_DATA_EXCHANGE, FALSE);
4103
4104 if (MTLK_ERR_OK != res) {
4105 goto finish;
4106 }
4107
4108 switch (req.request.cmd_id) {
4109 case WE_GEN_DATAEX_CMD_CONNECTION_STATS:
4110 {
4111 /* step - WE_GEN_DATAEX_CONNECTION_STATUS should be copied first
4112 * to userspace */
4113 void *tmp_out = out;
4114 out += sizeof(WE_GEN_DATAEX_CONNECTION_STATUS);
4115
4116 MTLK_ASSERT(sizeof(WE_GEN_DATAEX_DEVICE_STATUS) !=
4117 sizeof(WE_GEN_DATAEX_CONNECTION_STATUS));
4118
4119 MTLK_ASSERT(sizeof(WE_GEN_DATAEX_DEVICE_STATUS) !=
4120 sizeof(WE_GEN_DATAEX_RESPONSE));
4121
4122 MTLK_ASSERT(sizeof(WE_GEN_DATAEX_CONNECTION_STATUS) !=
4123 sizeof(WE_GEN_DATAEX_RESPONSE));
4124
4125 /* retrieve several WE_GEN_DATAEX_DEVICE_STATUS from clipboard
4126 * and copy them to userspace, these structures may be not present
4127 * in clipboard in case of no STA connected to AP */
4128 dev_status = mtlk_clpb_enum_get_next(clpb, &core_resp_size);
4129
4130 while (sizeof(WE_GEN_DATAEX_DEVICE_STATUS) == core_resp_size) {
4131 if (0 != copy_to_user(out, dev_status, core_resp_size)) {
4132 res = MTLK_ERR_VALUE;
4133 goto process_res;
4134 }
4135 out += sizeof(WE_GEN_DATAEX_DEVICE_STATUS);
4136 dev_status = mtlk_clpb_enum_get_next(clpb, &core_resp_size);
4137 }
4138
4139 MTLK_ASSERT(core_resp_size != sizeof(WE_GEN_DATAEX_RESPONSE));
4140 MTLK_ASSERT(core_resp_size == sizeof(WE_GEN_DATAEX_CONNECTION_STATUS));
4141
4142 /* WE_GEN_DATAEX_CONNECTION_STATUS must be placed after WE_GEN_DATAEX_DEVICE_STATUS
4143 * in clipboard, copy it to userspace using previously stored pointer tmp_out! */
4144 con_status = (WE_GEN_DATAEX_CONNECTION_STATUS*)dev_status;
4145
4146 MTLK_ASSERT(NULL != con_status);
4147
4148 if (0 != copy_to_user(tmp_out, con_status, core_resp_size)) {
4149 res = MTLK_ERR_VALUE;
4150 goto process_res;
4151 }
4152
4153 /* retrieve WE_GEN_DATAEX_RESPONSE from clipboard
4154 * it will be copied to userspace at the end of function */
4155 core_resp = mtlk_clpb_enum_get_next(clpb, &core_resp_size);
4156
4157 MTLK_ASSERT(NULL != core_resp);
4158 MTLK_ASSERT(sizeof(*core_resp) == core_resp_size);
4159
4160 resp = *core_resp;
4161 }
4162 break;
4163 case WE_GEN_DATAEX_CMD_STATUS:
4164 {
4165 /* retrieve several WE_GEN_DATAEX_STATUS from clipboard
4166 * and copy them to userspace */
4167 status = mtlk_clpb_enum_get_next(clpb, &core_resp_size);
4168
4169 MTLK_ASSERT(NULL != status);
4170 MTLK_ASSERT(sizeof(*status) == core_resp_size);
4171
4172 if (0 != copy_to_user(out, status, core_resp_size)) {
4173 res = MTLK_ERR_VALUE;
4174 goto process_res;
4175 }
4176
4177 /* retrieve WE_GEN_DATAEX_RESPONSE from clipboard
4178 * it will be copied to userspace at the end of function */
4179 core_resp = mtlk_clpb_enum_get_next(clpb, &core_resp_size);
4180
4181 MTLK_ASSERT(NULL != core_resp);
4182 MTLK_ASSERT(sizeof(*core_resp) == core_resp_size);
4183
4184 resp = *core_resp;
4185 }
4186 break;
4187 case WE_GEN_DATAEX_CMD_LEDS_MAC:
4188 {
4189 /* retrieve WE_GEN_DATAEX_RESPONSE from clipboard
4190 * it will be copied to userspace at the end of function */
4191 core_resp = mtlk_clpb_enum_get_next(clpb, &core_resp_size);
4192
4193 MTLK_ASSERT(NULL != core_resp);
4194 MTLK_ASSERT(sizeof(*core_resp) == core_resp_size);
4195
4196 resp = *core_resp;
4197 }
4198 break;
4199 default:
4200 WLOG_D("Data exchange protocol: unknown command %u", req.request.cmd_id);
4201 resp.status = WE_GEN_DATAEX_UNKNOWN_CMD;
4202 resp.datalen = 0;
4203 break;
4204 }
4205
4206 if (resp.status == WE_GEN_DATAEX_FAIL) {
4207 /* Return failure reason */
4208 size_t reason_sz = strlen(reason) + 1;
4209 if (req.request.datalen >= reason_sz) {
4210 if (0 != copy_to_user(ifr->ifr_data + sizeof(WE_GEN_DATAEX_RESPONSE), reason, reason_sz)) {
4211 res = MTLK_ERR_VALUE;
4212 goto process_res;
4213 }
4214 resp.datalen = reason_sz;
4215 }
4216 else {
4217 resp.datalen = 0; /* error string does not fit */
4218 }
4219 }
4220
4221 /* copy previously filled WE_GEN_DATAEX_RESPONSE */
4222 if (copy_to_user(ifr->ifr_data, &resp, sizeof(resp)) != 0) {
4223 res = MTLK_ERR_VALUE;
4224 }
4225
4226 process_res:
4227 mtlk_clpb_delete(clpb);
4228
4229 finish:
4230 if (MTLK_ERR_OK != res) {
4231 ELOG_D("Error#%d during data exchange request", res);
4232 }
4233
4234 return _mtlk_df_mtlk_to_linux_error_code(res);
4235 }
4236
4237 static int
4238 mtlk_df_do_command (struct net_device *dev, struct ifreq *ifr, int cmd)
4239 {
4240 mtlk_df_user_t* df_user = (mtlk_df_user_t*)netdev_priv(dev);
4241 int res = -EOPNOTSUPP;
4242
4243 ILOG3_SSDD("%s: Invoked from %s (%i), cmd is 0x%04x", dev->name, current->comm, current->pid, cmd);
4244
4245 /* we only support private ioctls */
4246 if ((cmd < MTLK_IOCTL_FIRST) || (cmd > MTLK_IOCTL_LAST)) {
4247 goto FINISH;
4248 }
4249
4250 switch (cmd) {
4251 case MTLK_IOCTL_DATAEX:
4252 res = _mtlk_ioctl_drv_gen_data_exchange(df_user, ifr);
4253 break;
4254 default:
4255 ELOG_D("ioctl not supported: 0x%04x", cmd);
4256 break;
4257 }
4258
4259 FINISH:
4260 return res;
4261 }
4262
4263 static void
4264 _df_user_copy_linux_stats(struct net_device_stats* linux_stats,
4265 mtlk_core_general_stats_t* core_status)
4266 {
4267 linux_stats->rx_packets = core_status->rx_packets;
4268 linux_stats->tx_packets = core_status->tx_packets - core_status->core_priv_stats.fwd_tx_packets;
4269 linux_stats->rx_bytes = core_status->rx_bytes;
4270 linux_stats->tx_bytes = core_status->tx_bytes - core_status->core_priv_stats.fwd_tx_bytes;
4271 linux_stats->tx_dropped = core_status->mac_stat.stat[STAT_TX_FAIL]; /* total tx packets dropped */
4272 linux_stats->collisions = core_status->mac_stat.stat[STAT_TX_RETRY]; /* total tx retries */
4273 linux_stats->rx_fifo_errors = core_status->mac_stat.stat[STAT_OUT_OF_RX_MSDUS]; /* total rx queue overruns */
4274 linux_stats->tx_fifo_errors = core_status->core_priv_stats.tx_overruns;
4275 }
4276
4277 static struct net_device_stats *
4278 _mtlk_df_user_get_stats(struct net_device *dev)
4279 {
4280 mtlk_df_user_t* df_user = (mtlk_df_user_t*) netdev_priv(dev);
4281 return &df_user->slow_ctx->linux_stats;
4282 }
4283
4284 static void __MTLK_IFUNC
4285 _mtlk_df_poll_stats_clb(mtlk_handle_t user_context,
4286 int processing_result,
4287 mtlk_clpb_t *pclpb)
4288 {
4289 int res;
4290 mtlk_df_user_t* df_user = (mtlk_df_user_t*) user_context;
4291
4292 res = _mtlk_df_user_process_core_retval_void(processing_result, pclpb, MTLK_CORE_REQ_GET_STATUS, FALSE);
4293
4294 if(MTLK_ERR_OK == res)
4295 {
4296 uint32 size;
4297
4298 mtlk_core_general_stats_t* core_status =
4299 (mtlk_core_general_stats_t*) mtlk_clpb_enum_get_next(pclpb, &size);
4300
4301 MTLK_ASSERT(NULL != core_status);
4302 MTLK_ASSERT(sizeof(*core_status) == size);
4303
4304 df_user->slow_ctx->core_general_stats = *core_status;
4305
4306 _df_user_copy_linux_stats(&df_user->slow_ctx->linux_stats, core_status);
4307 }
4308 else
4309 {
4310 memset(&df_user->slow_ctx->linux_stats, 0,
4311 sizeof(df_user->slow_ctx->linux_stats));
4312 }
4313
4314 if (!mtlk_osal_timer_is_cancelled(&df_user->slow_ctx->stat_timer)) {
4315 /* if timer has been already canceled, don't start it again,
4316 thus this callback can be performed from serializer later after timer stop */
4317 mtlk_osal_timer_set(&df_user->slow_ctx->stat_timer, _DF_STAT_POLL_PERIOD);
4318 }
4319 }
4320
4321 static uint32
4322 _mtlk_df_poll_stats (mtlk_osal_timer_t *timer, mtlk_handle_t data)
4323 {
4324 mtlk_df_user_t* df_user = (mtlk_df_user_t*) data;
4325
4326 _mtlk_df_user_invoke_core_async(df_user->df, MTLK_CORE_REQ_GET_STATUS,
4327 NULL, 0, _mtlk_df_poll_stats_clb, HANDLE_T(df_user));
4328
4329 return 0;
4330 }
4331
4332 static int
4333 _mtlk_df_user_prevent_change_mtu(struct net_device *dev, int new_mtu)
4334 {
4335 return -EFAULT;
4336 }
4337
4338 static void _mtlk_df_user_fill_callbacks(mtlk_df_user_t *df_user)
4339 {
4340 df_user->dev->wireless_handlers = (struct iw_handler_def *)&mtlk_linux_handler_def;
4341
4342 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,29)
4343 df_user->dev->hard_start_xmit = _mtlk_df_user_start_tx;
4344 df_user->dev->open = _mtlk_df_user_iface_open;
4345 df_user->dev->stop = _mtlk_df_user_iface_stop;
4346 df_user->dev->set_mac_address = _mtlk_df_user_set_mac_addr;
4347 df_user->dev->get_stats = _mtlk_df_user_get_stats;
4348
4349 df_user->dev->tx_timeout = NULL;
4350 df_user->dev->change_mtu = _mtlk_df_user_prevent_change_mtu;
4351
4352 df_user->dev->do_ioctl = mtlk_df_do_command;
4353 #else
4354 df_user->dev_ops.ndo_start_xmit = _mtlk_df_user_start_tx;
4355 df_user->dev_ops.ndo_open = _mtlk_df_user_iface_open;
4356 df_user->dev_ops.ndo_stop = _mtlk_df_user_iface_stop;
4357 df_user->dev_ops.ndo_set_mac_address = _mtlk_df_user_set_mac_addr;
4358 df_user->dev_ops.ndo_get_stats = _mtlk_df_user_get_stats;
4359
4360 df_user->dev_ops.ndo_tx_timeout = NULL;
4361 df_user->dev_ops.ndo_change_mtu = _mtlk_df_user_prevent_change_mtu;
4362
4363 df_user->dev_ops.ndo_do_ioctl = mtlk_df_do_command;
4364
4365 df_user->dev->netdev_ops = &df_user->dev_ops;
4366 #endif
4367 }
4368
4369 static int _mtlk_df_ui_create_card_dir(mtlk_df_user_t* df_user)
4370 {
4371 MTLK_ASSERT(NULL != df_user);
4372
4373 df_user->slow_ctx->proc_df_node =
4374 mtlk_df_proc_node_create(mtlk_df_user_get_name(df_user), mtlk_dfg_get_drv_proc_node());
4375
4376 if (NULL == df_user->slow_ctx->proc_df_node) {
4377 return MTLK_ERR_NO_MEM;
4378 }
4379 return MTLK_ERR_OK;
4380 }
4381
4382 static int _mtlk_df_ui_create_debug_dir(mtlk_df_user_t* df_user)
4383 {
4384 MTLK_ASSERT(NULL != df_user);
4385
4386 df_user->slow_ctx->proc_df_debug_node =
4387 mtlk_df_proc_node_create("Debug", df_user->slow_ctx->proc_df_node);
4388
4389 if (NULL == df_user->slow_ctx->proc_df_debug_node) {
4390 return MTLK_ERR_NO_MEM;
4391 }
4392 return MTLK_ERR_OK;
4393 }
4394
4395 static void _mtlk_df_ui_delete_card_dir(mtlk_df_user_t* df_user)
4396 {
4397 mtlk_df_proc_node_delete(df_user->slow_ctx->proc_df_node);
4398 df_user->slow_ctx->proc_df_node = NULL;
4399 }
4400
4401 static void _mtlk_df_ui_delete_debug_dir(mtlk_df_user_t* df_user)
4402 {
4403 mtlk_df_proc_node_delete(df_user->slow_ctx->proc_df_debug_node);
4404 df_user->slow_ctx->proc_df_debug_node = NULL;
4405 }
4406
4407 static void
4408 _mtlk_df_user_unregister_ndev(mtlk_df_user_t *df_user, mtlk_vap_manager_interface_e intf)
4409 {
4410 switch(intf) {
4411 case MTLK_VAP_MASTER_INTERFACE:
4412 /* master interface can be removed only in case of driver remove (rmmod),
4413 * so no need to check is slave or not here
4414 * this call holds rtnl_lock() */
4415 unregister_netdev(df_user->dev);
4416 break;
4417
4418 case MTLK_VAP_SLAVE_INTERFACE:
4419 /* we cannot call free_netdev() directly, because unregistration will be complete only when we exit ioctl
4420 * On ioctl exit rtnl_unlock() is called, which in turn calls netdev_run_todo() function
4421 * - it completes unregistration of network device.
4422 * We MUST NOT call rtnl_unlock() from within ioctl */
4423 df_user->dev->destructor = free_netdev;
4424
4425 /* doesn't hold rtnl_lock(), it's already held, because we are in ioctl now */
4426 unregister_netdevice(df_user->dev);
4427 break;
4428
4429 default:
4430 MTLK_ASSERT(0);
4431 }
4432 }
4433
4434 static int
4435 _mtlk_df_user_register_ndev(mtlk_df_user_t *df_user, mtlk_vap_manager_interface_e intf)
4436 {
4437 int res = -EINVAL;
4438 switch(intf) {
4439 case MTLK_VAP_MASTER_INTERFACE:
4440 /* master interface can be removed only in case of driver remove (rmmod),
4441 * so no need to check is slave or not here
4442 * this call holds rtnl_lock() */
4443 res = register_netdev(df_user->dev);
4444 break;
4445
4446 case MTLK_VAP_SLAVE_INTERFACE:
4447 /* doesn't hold rtnl_lock(), it's already held, because we are in ioctl now */
4448 res = register_netdevice(df_user->dev);
4449
4450 /* we don't need to play rtnl_lock/rtnl_unlock here -
4451 * there is no "todo's" scheduled in kernel on Network Device registration
4452 */
4453 break;
4454 default:
4455 MTLK_ASSERT(0);
4456 }
4457
4458 return (0 == res) ? MTLK_ERR_OK : MTLK_ERR_UNKNOWN;
4459 }
4460
4461 MTLK_START_STEPS_LIST_BEGIN(df_user)
4462 MTLK_START_STEPS_LIST_ENTRY(df_user, REGISTER_DEVICE)
4463 MTLK_START_STEPS_LIST_ENTRY(df_user, STAT_POLL)
4464 MTLK_START_STEPS_LIST_ENTRY(df_user, PPA_XFACE)
4465 MTLK_START_INNER_STEPS_BEGIN(df_user)
4466 MTLK_START_STEPS_LIST_END(df_user);
4467
4468 void
4469 mtlk_df_user_stop(mtlk_df_user_t *df_user, mtlk_vap_manager_interface_e intf)
4470 {
4471 #ifdef MTCFG_IRB_DEBUG
4472 if (mtlk_irb_pinger_is_started(&df_user->slow_ctx->pinger)) {
4473 mtlk_irb_pinger_stop(&df_user->slow_ctx->pinger);
4474 }
4475 #endif /* MTCFG_IRB_DEBUG */
4476
4477 MTLK_STOP_BEGIN(df_user, MTLK_OBJ_PTR(df_user))
4478 MTLK_STOP_STEP(df_user, PPA_XFACE, MTLK_OBJ_PTR(df_user),
4479 _mtlk_df_priv_xface_stop, (df_user));
4480 MTLK_STOP_STEP(df_user, STAT_POLL, MTLK_OBJ_PTR(df_user),
4481 mtlk_osal_timer_cancel_sync, (&df_user->slow_ctx->stat_timer));
4482 MTLK_STOP_STEP(df_user, REGISTER_DEVICE, MTLK_OBJ_PTR(df_user),
4483 _mtlk_df_user_unregister_ndev, (df_user, intf));
4484 MTLK_STOP_END(df_user, MTLK_OBJ_PTR(df_user));
4485 }
4486
4487 int
4488 mtlk_df_user_start(mtlk_df_t *df, mtlk_df_user_t *df_user, mtlk_vap_manager_interface_e intf)
4489 {
4490 /* From time we've allocated device name till time we register netdevice
4491 * we should hold rtnl lock to prohibit someone else from registering same netdevice name.
4492 * We can't use register_netdev, because we've splitted netdevice registration into 2 phases:
4493 * 1) allocate name
4494 * ... driver internal initialization
4495 * 2) register.
4496 * We need this because:
4497 * 1) initialization (registration of proc entries) requires knowledge of netdevice name
4498 * 2) we can't register netdevice before we have initialized the driver (we might crash on
4499 * request from the OS)
4500 *
4501 * NEW APPROACH: Now the Net Device name is allocated on DF UI initialization in assumption
4502 * that no one else will register the same device name.
4503 * - DF infrastructure has been created already on DF UI initialization.
4504 * - register_netdev() API can used here from now
4505 * - It is not needed to take rtnl_lock manually
4506 * This approach allows Core to register abilities correctly before Net Device registration.
4507 */
4508
4509 MTLK_START_TRY(df_user, MTLK_OBJ_PTR(df_user))
4510 MTLK_START_STEP(df_user, REGISTER_DEVICE, MTLK_OBJ_PTR(df_user),
4511 _mtlk_df_user_register_ndev, (df_user, intf));
4512
4513 MTLK_START_STEP(df_user, STAT_POLL, MTLK_OBJ_PTR(df_user),
4514 mtlk_osal_timer_set,
4515 (&df_user->slow_ctx->stat_timer, _DF_STAT_POLL_PERIOD));
4516
4517 MTLK_START_STEP_VOID_IF(mtlk_vap_is_master(mtlk_df_get_vap_handle(df_user->df)),
4518 df_user, PPA_XFACE, MTLK_OBJ_PTR(df_user),
4519 _mtlk_df_priv_xface_start, (df_user));
4520
4521 MTLK_START_FINALLY(df_user, MTLK_OBJ_PTR(df_user))
4522 MTLK_START_RETURN(df_user, MTLK_OBJ_PTR(df_user), mtlk_df_user_stop, (df_user, intf))
4523 }
4524
4525 int __MTLK_IFUNC
4526 mtlk_df_ui_indicate_rx_data(mtlk_df_t *df, mtlk_nbuf_t *nbuf)
4527 {
4528 int res;
4529 mtlk_df_user_t *df_user;
4530
4531 MTLK_ASSERT(NULL != df);
4532 MTLK_ASSERT(NULL != nbuf);
4533
4534 df_user = mtlk_df_get_user(df);
4535
4536 mtlk_nbuf_stop_tracking(nbuf);
4537 mtlk_nbuf_priv_cleanup(mtlk_nbuf_priv(nbuf));
4538
4539 /* set pointer to dev, nbuf->protocol for PPA case will be set within PPA RX call back */
4540 nbuf->dev = df_user->dev;
4541
4542 #ifdef MTLK_HAVE_PPA
4543 if (ppa_hook_directpath_send_fn && _mtlk_df_user_ppa_is_registered(df_user) && df_user->ppa.is_active) {
4544 /* set raw pointer for proper work if directpath is disabled */
4545 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,22)
4546 skb_reset_mac_header(nbuf);
4547 #else
4548 nbuf->mac.raw = nbuf->data;
4549 #endif
4550
4551 /* send packets to the ppa */
4552 if (ppa_hook_directpath_send_fn(df_user->ppa.if_id,
4553 nbuf, nbuf->len, 0) == PPA_SUCCESS) {
4554 ++df_user->ppa.stats.rx_accepted;
4555 return MTLK_ERR_OK;
4556 }
4557
4558 ++df_user->ppa.stats.rx_rejected;
4559
4560 /** \note: In PPA mode we should not cleanup packet on sending failure.
4561 * Also frame can not be transferred in to the IP stack.
4562 * Otherwise packet will corrupt per CPU queue with NULL pointer access during dequeue.
4563 * \tocheck: Can be a PPA problem or not a problem at all. */
4564 return MTLK_ERR_UNKNOWN;
4565 }
4566 #endif /* MTLK_HAVE_PPA */
4567
4568 nbuf->protocol = eth_type_trans(nbuf, nbuf->dev);
4569 res = netif_rx(nbuf);
4570 df_user->dev->last_rx = jiffies;
4571
4572 if(NET_RX_SUCCESS != res)
4573 {
4574 ILOG2_D("netif_rx failed: %d", res);
4575 return MTLK_ERR_UNKNOWN;
4576 }
4577
4578 return MTLK_ERR_OK;
4579 }
4580
4581 BOOL __MTLK_IFUNC mtlk_df_ui_check_is_mc_group_member(mtlk_df_t *df,
4582 const uint8* group_addr)
4583 {
4584 mtlk_df_user_t *df_user;
4585
4586 MTLK_ASSERT(NULL != df);
4587 MTLK_ASSERT(NULL != group_addr);
4588
4589 df_user = mtlk_df_get_user(df);
4590
4591 //check if we subscribed to all multicast
4592 if (df_user->dev->allmulti)
4593 return TRUE;
4594
4595 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,35)
4596 {
4597 struct dev_mc_list* mc_list_entry;
4598 //check if we subscribed to that group
4599 for (mc_list_entry = df_user->dev->mc_list;
4600 mc_list_entry != NULL;
4601 mc_list_entry = mc_list_entry->next) {
4602 if (0 == mtlk_osal_compare_eth_addresses(mc_list_entry->dmi_addr, group_addr))
4603 return TRUE;
4604 }
4605 }
4606 #else /* LINUX_VERSION_CODE < KERNEL_VERSION(2,6,35) */
4607 {
4608 struct netdev_hw_addr *ha;
4609 netdev_for_each_mc_addr(ha, df_user->dev) {
4610 if (!mtlk_osal_compare_eth_addresses(ha->addr, group_addr))
4611 return TRUE;
4612 }
4613 }
4614 #endif /* LINUX_VERSION_CODE < KERNEL_VERSION(2,6,35) */
4615
4616 return FALSE;
4617 }
4618
4619 static void
4620 _mtlk_df_user_notify_mac_addr_event( mtlk_df_user_t *df_user,
4621 int event_id,
4622 const uint8 *mac )
4623 {
4624 union iwreq_data req_data;
4625
4626 MTLK_ASSERT(NULL != df_user);
4627 MTLK_ASSERT(NULL != mac);
4628
4629 req_data.ap_addr.sa_family = ARPHRD_ETHER;
4630 mtlk_osal_copy_eth_addresses(req_data.ap_addr.sa_data, mac);
4631
4632 wireless_send_event(df_user->dev, event_id, &req_data, NULL);
4633 }
4634
4635 void __MTLK_IFUNC
4636 mtlk_df_ui_notify_association( mtlk_df_t *df,
4637 const uint8 *mac )
4638 {
4639 _mtlk_df_user_notify_mac_addr_event(mtlk_df_get_user(df), SIOCGIWAP, mac);
4640 }
4641
4642 void __MTLK_IFUNC
4643 mtlk_df_ui_notify_disassociation(mtlk_df_t *df)
4644 {
4645 static const uint8 mac[ETH_ALEN] = {0};
4646 _mtlk_df_user_notify_mac_addr_event(mtlk_df_get_user(df), SIOCGIWAP, mac);
4647 }
4648
4649 void __MTLK_IFUNC
4650 mtlk_df_ui_notify_node_connect(mtlk_df_t *df, const uint8 *node_addr)
4651 {
4652 _mtlk_df_user_notify_mac_addr_event(mtlk_df_get_user(df), IWEVREGISTERED, node_addr);
4653 }
4654
4655 void __MTLK_IFUNC
4656 mtlk_df_ui_notify_node_disconect(mtlk_df_t *df, const uint8 *node_addr)
4657 {
4658 _mtlk_df_user_notify_mac_addr_event(mtlk_df_get_user(df), IWEVEXPIRED, node_addr);
4659 }
4660
4661 void __MTLK_IFUNC
4662 mtlk_df_ui_notify_secure_node_connect(mtlk_df_t *df,
4663 const uint8 *node_addr,
4664 const uint8 *rsnie,
4665 size_t rsnie_len)
4666 {
4667 union iwreq_data wrqu;
4668 uint8 buf[IW_CUSTOM_MAX] = {0};
4669 uint8 *p=buf;
4670 size_t i;
4671
4672 MTLK_ASSERT(NULL != df);
4673
4674 p += sprintf(p, "NEWSTA " MAC_PRINTF_FMT ", RSNIE_LEN %i : ",
4675 MAC_PRINTF_ARG(node_addr), rsnie_len);
4676
4677 MTLK_ASSERT(p - buf + rsnie_len*2 < IW_CUSTOM_MAX);
4678
4679 for (i = 0; i < rsnie_len; i++)
4680 p += sprintf(p, "%02x", rsnie[i]);
4681
4682 wrqu.data.length = p - buf +1;
4683
4684 wireless_send_event(mtlk_df_get_user(df)->dev, IWEVCUSTOM, &wrqu, buf);
4685 }
4686
4687 void __MTLK_IFUNC
4688 mtlk_df_ui_notify_mic_failure(mtlk_df_t *df,
4689 const uint8 *src_mac,
4690 mtlk_df_ui_mic_fail_type_t fail_type)
4691 {
4692 union iwreq_data wrqu;
4693 struct iw_michaelmicfailure mic = {0};
4694
4695 MTLK_ASSERT(NULL != df);
4696 MTLK_ASSERT(NULL != src_mac);
4697
4698 wrqu.data.length = sizeof(struct iw_michaelmicfailure);
4699
4700 mic.src_addr.sa_family = ARPHRD_ETHER;
4701 mtlk_osal_copy_eth_addresses(mic.src_addr.sa_data, src_mac);
4702
4703 switch(fail_type)
4704 {
4705 case MIC_FAIL_PAIRWISE:
4706 mic.flags |= IW_MICFAILURE_PAIRWISE;
4707 break;
4708 case MIC_FAIL_GROUP:
4709 mic.flags |= IW_MICFAILURE_GROUP;
4710 break;
4711 default:
4712 MTLK_ASSERT(!"Unknown MIC failure type");
4713 }
4714
4715 wireless_send_event(mtlk_df_get_user(df)->dev, IWEVMICHAELMICFAILURE, &wrqu, (char*)&mic);
4716 }
4717
4718 void __MTLK_IFUNC
4719 mtlk_df_ui_notify_scan_complete(mtlk_df_t *df)
4720 {
4721 union iwreq_data wrqu;
4722
4723 MTLK_ASSERT(NULL != df);
4724
4725 wrqu.data.length = 0;
4726 wrqu.data.flags = 0;
4727
4728 wireless_send_event(mtlk_df_get_user(df)->dev, SIOCGIWSCAN, &wrqu, NULL);
4729 }
4730
4731 static const mtlk_guid_t IRBE_RMMOD = MTLK_IRB_GUID_RMMOD;
4732
4733 void __MTLK_IFUNC
4734 mtlk_df_ui_notify_notify_rmmod (const char *wlanitrf)
4735 {
4736 mtlk_irbd_notify_app(mtlk_irbd_get_root(), &IRBE_RMMOD, (char *) wlanitrf, IFNAMSIZ);
4737 }
4738
4739 void __MTLK_IFUNC
4740 mtlk_df_ui_notify_notify_fw_hang(mtlk_df_t *df, uint32 fw_cpu, uint32 sw_watchdog_data)
4741 {
4742 MTLK_ASSERT(df != NULL);
4743 MTLK_ASSERT(fw_cpu < ARRAY_SIZE(mtlk_df_get_user(df)->fw_hang_evts));
4744
4745 mtlk_osal_event_set(&mtlk_df_get_user(df)->fw_hang_evts[fw_cpu]);
4746 WLOG_DD("CID-%04x: FW CPU#%d hang detected", mtlk_vap_get_oid(mtlk_df_get_vap_handle(df)), fw_cpu);
4747 }
4748
4749 void __MTLK_IFUNC
4750 mtlk_df_on_rcvry_isol (mtlk_df_t *df)
4751 {
4752 MTLK_ASSERT(df != NULL);
4753
4754 /* Stop stat timer */
4755 mtlk_osal_timer_cancel_sync(&mtlk_df_get_user(df)->slow_ctx->stat_timer);
4756
4757 /* Unlock waiting events */
4758 mtlk_osal_event_set(&mtlk_df_get_user(df)->fw_hang_evts[UMIPS]);
4759 mtlk_osal_event_set(&mtlk_df_get_user(df)->fw_hang_evts[LMIPS]);
4760 }
4761
4762 void __MTLK_IFUNC
4763 mtlk_df_on_rcvry_restore (mtlk_df_t *df)
4764 {
4765 MTLK_ASSERT(df != NULL);
4766
4767 mtlk_osal_event_reset(&mtlk_df_get_user(df)->fw_hang_evts[UMIPS]);
4768 mtlk_osal_event_reset(&mtlk_df_get_user(df)->fw_hang_evts[LMIPS]);
4769
4770 /* Start stat timer */
4771 mtlk_osal_timer_set(&mtlk_df_get_user(df)->slow_ctx->stat_timer, _DF_STAT_POLL_PERIOD);
4772 }
4773
4774 /**************************************************************
4775 * Transactions with Core
4776 **************************************************************/
4777 static int mtlk_df_ui_addba_status(mtlk_seq_entry_t *s, void *data)
4778 {
4779 mtlk_df_t *df = mtlk_df_proc_seq_entry_get_df(s);
4780 mtlk_addba_peer_state_t *peer = NULL;
4781 mtlk_clpb_t *clpb = NULL;
4782 uint32 size;
4783 int i, res;
4784
4785 MTLK_ASSERT(NULL != df);
4786
4787 res = _mtlk_df_user_invoke_core(df, MTLK_CORE_REQ_GET_ADDBA_STATE, &clpb, NULL, 0);
4788 res = _mtlk_df_user_process_core_retval_void(res, clpb, MTLK_CORE_REQ_GET_ADDBA_STATE, FALSE);
4789
4790 if (MTLK_ERR_OK != res) {
4791 goto err_ret;
4792 }
4793
4794 while(NULL != (peer = mtlk_clpb_enum_get_next(clpb, &size)))
4795 {
4796 MTLK_ASSERT(size == sizeof(*peer));
4797
4798 mtlk_aux_seq_printf(s, MAC_PRINTF_FMT ":%s\n",
4799 MAC_PRINTF_ARG(peer->addr.au8Addr),
4800 peer->is_active ? "active" : "disabled");
4801
4802 mtlk_aux_seq_printf(s, " TX %4s %5s %9s %9s %s\n",
4803 "TID",
4804 "state",
4805 "req_cfmd",
4806 "req_dlgt",
4807 "res_rejects");
4808 for (i = 0; i < ARRAY_SIZE(peer->tid); i++)
4809 {
4810 mtlk_aux_seq_printf(s, " %4d %5d %9u %9u %u\n",
4811 i,
4812 peer->tid[i].tx.state,
4813 peer->tid[i].tx.addba_req_cfmd_time,
4814 peer->tid[i].tx.addba_req_dlgt,
4815 peer->tid[i].tx.addba_res_rejects);
4816 }
4817
4818 mtlk_aux_seq_printf(s, " RX %4s %5s %10s %10s %s\n",
4819 "TID",
4820 "state",
4821 "del_tstamp",
4822 "req_tstamp",
4823 "add_res_result_code");
4824 for (i = 0; i < ARRAY_SIZE(peer->tid); i++)
4825 {
4826 mtlk_aux_seq_printf(s, " %4d %5d %10u %10u %u\n",
4827 i,
4828 peer->tid[i].rx.state,
4829 peer->tid[i].rx.delba_timeout,
4830 peer->tid[i].rx.req_tstamp,
4831 MAC_TO_HOST16(peer->tid[i].rx.addba_res.u16ResultCode)
4832 );
4833 }
4834 }
4835
4836 mtlk_clpb_delete(clpb);
4837
4838 err_ret:
4839 return _mtlk_df_mtlk_to_linux_error_code(res);
4840 }
4841
4842 static int mtlk_df_ui_aocs_history(mtlk_seq_entry_t *s, void *data)
4843 {
4844 int res = MTLK_ERR_NOT_SUPPORTED;
4845 mtlk_clpb_t *clpb = NULL;
4846 mtlk_aocs_history_stat_entry_t *stat_entry;
4847 mtlk_df_t *df = mtlk_df_proc_seq_entry_get_df(s);
4848
4849 res = _mtlk_df_user_invoke_core(df, MTLK_CORE_REQ_GET_AOCS_HISTORY,
4850 &clpb, NULL, 0);
4851 res = _mtlk_df_user_process_core_retval_void(res, clpb, MTLK_CORE_REQ_GET_AOCS_HISTORY, FALSE);
4852
4853 if (MTLK_ERR_OK != res) {
4854 goto err_ret;
4855 }
4856
4857 mtlk_aux_seq_printf(s,"Channel switch history:\n"
4858 "Time (ago) Ch (2nd)"
4859 " Switch reason Selection criteria\n");
4860
4861 while(NULL != (stat_entry = mtlk_clpb_enum_get_next(clpb, NULL))) {
4862 mtlk_aux_seq_printf(s,"%04dh %02dm %02d.%03ds %3d (%3d) %17s %26s\n"
4863 , stat_entry->hour_ago
4864 , stat_entry->min_ago
4865 , stat_entry->sec_ago
4866 , stat_entry->msec_ago
4867 , stat_entry->primary_channel
4868 , stat_entry->secondary_channel
4869 , stat_entry->reason_text
4870 , stat_entry->criteria_text);
4871 }
4872
4873 mtlk_clpb_delete(clpb);
4874 err_ret:
4875 return _mtlk_df_mtlk_to_linux_error_code(res);
4876 }
4877
4878 static int mtlk_df_ui_aocs_table(mtlk_seq_entry_t *s, void *data)
4879 {
4880 int res = MTLK_ERR_NOT_SUPPORTED;
4881 mtlk_clpb_t *clpb = NULL;
4882 mtlk_aocs_table_stat_entry_t *stat_entry;
4883 mtlk_df_t *df = mtlk_df_proc_seq_entry_get_df(s);
4884
4885 res = _mtlk_df_user_invoke_core(df, MTLK_CORE_REQ_GET_AOCS_TBL, &clpb, NULL, 0);
4886 res = _mtlk_df_user_process_core_retval_void(res, clpb, MTLK_CORE_REQ_GET_AOCS_TBL, FALSE);
4887
4888 if (MTLK_ERR_OK != res) {
4889 goto err_ret;
4890 }
4891
4892 mtlk_aux_seq_printf(s,"AOCS table:\n"
4893 " Ch (2nd) SRnk CRnk BSSinR CL Tx SM Rad NOc"
4894 " ClrChk !use Excl Noisy Rdr TxPenalty Tx11d Fl.noise BT_excl\n");
4895
4896 while(NULL != (stat_entry = mtlk_clpb_enum_get_next(clpb, NULL))) {
4897 mtlk_aux_seq_printf(s,"%3d (%3d) %4d %4d %6d %3d %3d.%03d %2d %3d %3d %10u %4d %4d %5d %3d %3d.%03d %d.%03d %8d %7d\n",
4898 stat_entry->channel_primary,
4899 stat_entry->channel_secondary,
4900 stat_entry->scan_rank,
4901 stat_entry->confirm_rank,
4902 stat_entry->nof_bss_in_range,
4903 stat_entry->channel_load,
4904 stat_entry->tx_power / 8,
4905 (stat_entry->tx_power % 8) * 125,
4906 stat_entry->sm,
4907 stat_entry->radar_detected,
4908 stat_entry->time_ms_non_occupied_period / 60000,
4909 stat_entry->time_ms_last_clear_check,
4910 stat_entry->dont_use,
4911 stat_entry->exclude,
4912 stat_entry->is_noisy,
4913 stat_entry->is_in_radar_timeout,
4914 stat_entry->tx_power_penalty / 8,
4915 (stat_entry->tx_power_penalty % 8) * 125,
4916 stat_entry->max_tx_power / 8,
4917 (stat_entry->max_tx_power % 8) * 125,
4918 stat_entry->floor_noise_metric,
4919 stat_entry->bt_acs_excl_reason);
4920 }
4921
4922 mtlk_clpb_delete(clpb);
4923 err_ret:
4924 return _mtlk_df_mtlk_to_linux_error_code(res);
4925 }
4926
4927 static int mtlk_df_ui_aocs_channels(mtlk_seq_entry_t *s, void *data)
4928 {
4929 int res = MTLK_ERR_NOT_SUPPORTED;
4930 mtlk_clpb_t *clpb = NULL;
4931 mtlk_aocs_channels_stat_t *stat;
4932 mtlk_df_t *df = mtlk_df_proc_seq_entry_get_df(s);
4933
4934 res = _mtlk_df_user_invoke_core(df, MTLK_CORE_REQ_GET_AOCS_CHANNELS_TBL,
4935 &clpb, NULL, 0);
4936 res = _mtlk_df_user_process_core_retval_void(res, clpb, MTLK_CORE_REQ_GET_AOCS_CHANNELS_TBL, FALSE);
4937
4938 if (MTLK_ERR_OK != res) {
4939 goto err_ret;
4940 }
4941
4942 mtlk_aux_seq_printf(s,"AOCS channels:\n Ch SM CL n20 n40up n40lw Intol Affected DrIf FwIf Fl.noise\n");
4943
4944 while(NULL != (stat = mtlk_clpb_enum_get_next(clpb, NULL))) {
4945 mtlk_aux_seq_printf(s," %3d %2d %3d %3d %5d %5d %5d %8d %4d %4d %8d\n",
4946 stat->channel,
4947 stat->sm_required,
4948 stat->channel_load,
4949 stat->num_20mhz_bss,
4950 stat->num_40mhz_up_bss,
4951 stat->num_40mhz_lw_bss,
4952 stat->forty_mhz_intolerant,
4953 stat->forty_mhz_int_affected,
4954 stat->DrIf,
4955 stat->FwIf,
4956 stat->fl_noise_metric);
4957 }
4958
4959 mtlk_clpb_delete(clpb);
4960 err_ret:
4961 return _mtlk_df_mtlk_to_linux_error_code(res);
4962 }
4963
4964 #ifdef BT_ACS_DEBUG
4965 static int mtlk_df_ui_aocs_channels_dbg(struct file *file, const char __user *buffer,
4966 unsigned long count, void *data)
4967 {
4968 int res = MTLK_ERR_OK;
4969 mtlk_clpb_t *clpb = NULL;
4970 mtlk_df_t *df = (mtlk_df_t*) data;
4971 int num=0, bss20=0, bss40up=0, bss40lo=0, intol=0, noise=MIN_INT8;
4972 mtlk_aocs_channel_data_t entry;
4973
4974 memset(&entry.stat, 0, sizeof(entry.stat));
4975
4976 sscanf(buffer, "%d %d %d %d %d %d", &num, &bss20, &bss40up, &bss40lo, &intol, &noise);
4977 entry.stat.channel = num;
4978
4979 if (num) {
4980 entry.stat.num_20mhz_bss = bss20;
4981 entry.stat.num_40mhz_up_bss = bss40up;
4982 entry.stat.num_40mhz_lw_bss = bss40lo;
4983 entry.stat.forty_mhz_intolerant = intol;
4984 entry.stat.fl_noise_metric = noise;
4985 }
4986
4987 ILOG1_DDDDDD("Adding AOCS Channels Entry {channel=%d, bss20=%d, bss40up=%d, bss40lo=%d, intol=%d, noise=%d}", num, bss20, bss40up, bss40lo, intol, noise);
4988
4989 res = _mtlk_df_user_invoke_core(df, MTLK_CORE_REQ_SET_AOCS_CHANNELS_TBL_DBG, &clpb, &entry, sizeof(entry));
4990 res = _mtlk_df_user_process_core_retval_void(res, clpb, MTLK_CORE_REQ_SET_AOCS_CHANNELS_TBL_DBG, TRUE);
4991
4992 return count;
4993 }
4994 #endif /* BT_ACS_DEBUG */
4995
4996 static int mtlk_df_ui_aocs_penalties(mtlk_seq_entry_t *s, void *data)
4997 {
4998 int res = MTLK_ERR_NOT_SUPPORTED;
4999 mtlk_clpb_t *clpb = NULL;
5000 mtlk_aocs_penalties_stat_entry_t *stat_entry;
5001 mtlk_df_t *df = mtlk_df_proc_seq_entry_get_df(s);
5002
5003 res = _mtlk_df_user_invoke_core(df, MTLK_CORE_REQ_GET_AOCS_PENALTIES,
5004 &clpb, NULL, 0);
5005 res = _mtlk_df_user_process_core_retval_void(res, clpb, MTLK_CORE_REQ_GET_AOCS_PENALTIES, FALSE);
5006
5007 if (MTLK_ERR_OK != res) {
5008 goto err_ret;
5009 }
5010
5011 mtlk_aux_seq_printf(s,"AOCS TxPowerPenalties:\nFreq Penalty\n");
5012
5013 while(NULL != (stat_entry = mtlk_clpb_enum_get_next(clpb, NULL))) {
5014 mtlk_aux_seq_printf(s,"%4d %d.%03d\n",
5015 stat_entry->freq,
5016 stat_entry->penalty / 8,
5017 (stat_entry->penalty % 8) * 125);
5018 }
5019
5020 mtlk_clpb_delete(clpb);
5021 err_ret:
5022 return _mtlk_df_mtlk_to_linux_error_code(res);
5023 }
5024
5025 static int mtlk_df_ui_hw_limits(mtlk_seq_entry_t *s, void *data)
5026 {
5027 int res = MTLK_ERR_OK;
5028 mtlk_clpb_t *clpb = NULL;
5029 mtlk_hw_limits_stat_entry_t *stat_entry;
5030 mtlk_df_t *df = mtlk_df_proc_seq_entry_get_df(s);
5031
5032 res = _mtlk_df_user_invoke_core(df, MTLK_CORE_REQ_GET_HW_LIMITS, &clpb, NULL, 0);
5033 res = _mtlk_df_user_process_core_retval_void(res, clpb, MTLK_CORE_REQ_GET_HW_LIMITS, FALSE);
5034
5035 if (MTLK_ERR_OK != res) {
5036 goto err_ret;
5037 }
5038
5039 mtlk_aux_seq_printf(s,"HW specific limits:\nFreq Spectrum Limit Domain\n");
5040
5041 while(NULL != (stat_entry = mtlk_clpb_enum_get_next(clpb, NULL))) {
5042 mtlk_aux_seq_printf(s,"%4d %8d %5d 0x%x\n",
5043 stat_entry->freq,
5044 stat_entry->spectrum,
5045 stat_entry->tx_lim,
5046 stat_entry->reg_domain);
5047 }
5048
5049 mtlk_clpb_delete(clpb);
5050 err_ret:
5051 return _mtlk_df_mtlk_to_linux_error_code(res);
5052 }
5053
5054 static int mtlk_df_ui_reg_limits(mtlk_seq_entry_t *s, void *data)
5055 {
5056 int res = MTLK_ERR_OK;
5057 mtlk_clpb_t *clpb = NULL;
5058 mtlk_reg_limits_stat_entry_t *stat_entry;
5059 mtlk_df_t *df = mtlk_df_proc_seq_entry_get_df(s);
5060
5061 res = _mtlk_df_user_invoke_core(df, MTLK_CORE_REQ_GET_REG_LIMITS, &clpb, NULL, 0);
5062 res = _mtlk_df_user_process_core_retval_void(res, clpb, MTLK_CORE_REQ_GET_REG_LIMITS, FALSE);
5063
5064 if (MTLK_ERR_OK != res) {
5065 goto err_ret;
5066 }
5067
5068 mtlk_aux_seq_printf(s,"Regulatory domain limits:\n");
5069
5070 while(NULL != (stat_entry = mtlk_clpb_enum_get_next(clpb, NULL))) {
5071 mtlk_aux_seq_printf(s,"domain: 0x%x, class: %d, spacing: %d, channel: %d,%d,%d\n",
5072 stat_entry->reg_domain,
5073 stat_entry->reg_class,
5074 stat_entry->spectrum,
5075 stat_entry->channel,
5076 stat_entry->tx_lim,
5077 stat_entry->mitigation);
5078 }
5079
5080 mtlk_clpb_delete(clpb);
5081 err_ret:
5082 return _mtlk_df_mtlk_to_linux_error_code(res);
5083 }
5084
5085 static int mtlk_df_ui_ant_gain(mtlk_seq_entry_t *s, void *data)
5086 {
5087 int res = MTLK_ERR_OK;
5088 mtlk_clpb_t *clpb = NULL;
5089 mtlk_ant_gain_stat_entry_t *stat_entry;
5090 mtlk_df_t *df = mtlk_df_proc_seq_entry_get_df(s);
5091
5092 res = _mtlk_df_user_invoke_core(df, MTLK_CORE_REQ_GET_ANTENNA_GAIN, &clpb, NULL, 0);
5093 res = _mtlk_df_user_process_core_retval_void(res, clpb, MTLK_CORE_REQ_GET_ANTENNA_GAIN, FALSE);
5094
5095 if (MTLK_ERR_OK != res) {
5096 goto err_ret;
5097 }
5098
5099 mtlk_aux_seq_printf(s,"Antenna gain table:\nFreq Gain\n");
5100
5101 while(NULL != (stat_entry = mtlk_clpb_enum_get_next(clpb, NULL))) {
5102 mtlk_aux_seq_printf(s,"%4d %4d\n",
5103 stat_entry->freq,
5104 stat_entry->gain);
5105 }
5106
5107 mtlk_clpb_delete(clpb);
5108 err_ret:
5109 return _mtlk_df_mtlk_to_linux_error_code(res);
5110 }
5111
5112 static int mtlk_df_ui_serializer_dump(mtlk_seq_entry_t *s, void *data)
5113 {
5114 int res = MTLK_ERR_OK;
5115 mtlk_clpb_t *clpb = NULL;
5116 mtlk_serializer_command_info_t *cmd_info;
5117 mtlk_df_t *df = mtlk_df_proc_seq_entry_get_df(s);
5118
5119 res = _mtlk_df_user_invoke_core(df, MTLK_CORE_REQ_GET_SERIALIZER_INFO, &clpb, NULL, 0);
5120 res = _mtlk_df_user_process_core_retval_void(res, clpb, MTLK_CORE_REQ_GET_SERIALIZER_INFO, FALSE);
5121
5122 if (MTLK_ERR_OK != res) {
5123 goto err_ret;
5124 }
5125
5126 mtlk_aux_seq_printf(s,"Serialized Commands:\nCurr Prio GID FID LID\n");
5127
5128 while(NULL != (cmd_info = mtlk_clpb_enum_get_next(clpb, NULL))) {
5129 mtlk_aux_seq_printf(s,"%4u %4u %3u %3u %3u\n",
5130 cmd_info->is_current,
5131 cmd_info->priority,
5132 mtlk_slid_get_gid(cmd_info->issuer_slid),
5133 mtlk_slid_get_fid(cmd_info->issuer_slid),
5134 mtlk_slid_get_lid(cmd_info->issuer_slid));
5135 }
5136
5137 mtlk_clpb_delete(clpb);
5138 err_ret:
5139 return _mtlk_df_mtlk_to_linux_error_code(res);
5140 }
5141
5142 static void
5143 _mtlk_df_ui_print_driver_stats(mtlk_seq_entry_t *s, mtlk_core_general_stats_t *general_stats)
5144 {
5145 struct priv_stats *pstats;
5146 mtlk_mac_stats_t *mac_stat;
5147
5148 char buf[MAX_DF_UI_STAT_NAME_LENGTH];
5149 uint32 i;
5150 const char *uint_fmt = "%10u %s\n";
5151
5152 mac_stat = &general_stats->mac_stat;
5153
5154 pstats = &general_stats->core_priv_stats;
5155
5156 mtlk_aux_seq_printf(s, uint_fmt, general_stats->rx_dat_frames, "data frames received");
5157 mtlk_aux_seq_printf(s, uint_fmt, general_stats->rx_ctl_frames, "control frames received");
5158 mtlk_aux_seq_printf(s, uint_fmt, general_stats->rx_man_frames, "management frames received");
5159 mtlk_aux_seq_printf(s, uint_fmt, mac_stat->stat[STAT_TX_FAIL], "TX packets dropped");
5160 mtlk_aux_seq_printf(s, uint_fmt, pstats->tx_max_cons_drop, "TX maximum consecutive dropped packets");
5161
5162 for (i = 0; i < NTS_PRIORITIES; i++) {
5163 sprintf(buf, "MSDUs received, QoS priority %d", i);
5164 mtlk_aux_seq_printf(s, uint_fmt, pstats->ac_rx_counter[i], buf);
5165 }
5166
5167 for (i = 0; i < NTS_PRIORITIES; i++) {
5168 sprintf(buf, "MSDUs transmitted, QoS priority %d", i);
5169 mtlk_aux_seq_printf(s, uint_fmt, pstats->ac_tx_counter[i], buf);
5170 }
5171
5172 for (i = 0; i < NTS_PRIORITIES; i++) {
5173 sprintf(buf, "MSDUs dropped, QoS priority %d", i);
5174 mtlk_aux_seq_printf(s, uint_fmt, pstats->ac_dropped_counter[i], buf);
5175 }
5176
5177 for (i = 0; i < NTS_PRIORITIES; i++) {
5178 sprintf(buf, "MSDUs used, QoS priority %d", i);
5179 mtlk_aux_seq_printf(s, uint_fmt, pstats->ac_used_counter[i], buf);
5180 }
5181
5182 mtlk_aux_seq_printf(s, uint_fmt, general_stats->tx_msdus_free, "TX MSDUs free");
5183 mtlk_aux_seq_printf(s, uint_fmt, general_stats->tx_msdus_usage_peak, "TX MSDUs usage peak");
5184
5185 mtlk_aux_seq_printf(s, uint_fmt, general_stats->fwd_rx_packets, "packets received that should be forwarded to one or more STAs");
5186 mtlk_aux_seq_printf(s, uint_fmt, general_stats->fwd_rx_bytes, "bytes received that should be forwarded to one or more STAs");
5187 mtlk_aux_seq_printf(s, uint_fmt, pstats->fwd_tx_packets, "packets transmitted for forwarded data");
5188 mtlk_aux_seq_printf(s, uint_fmt, pstats->fwd_tx_bytes, "bytes transmitted for forwarded data");
5189 mtlk_aux_seq_printf(s, uint_fmt, pstats->fwd_dropped, "forwarding (transmission) failures");
5190 mtlk_aux_seq_printf(s, uint_fmt, pstats->rmcast_dropped, "reliable multicast (transmission) failures");
5191 mtlk_aux_seq_printf(s, uint_fmt, general_stats->unicast_replayed_packets + general_stats->multicast_replayed_packets, "packets replayed");
5192 mtlk_aux_seq_printf(s, uint_fmt, pstats->bars_cnt, "BAR frames received");
5193
5194 mtlk_aux_seq_printf(s, uint_fmt, general_stats->bist_check_passed, "BIST check passed");
5195
5196 mtlk_aux_seq_printf(s, uint_fmt, general_stats->txmm_sent, "MAN Messages sent");
5197 mtlk_aux_seq_printf(s, uint_fmt, general_stats->txmm_cfmd, "MAN Messages confirmed");
5198 mtlk_aux_seq_printf(s, uint_fmt, general_stats->txmm_peak, "MAN Messages in peak");
5199 mtlk_aux_seq_printf(s, uint_fmt, general_stats->txdm_sent, "DBG Messages sent");
5200 mtlk_aux_seq_printf(s, uint_fmt, general_stats->txdm_cfmd, "DBG Messages confirmed");
5201 mtlk_aux_seq_printf(s, uint_fmt, general_stats->txdm_peak, "DBG Messages in peak");
5202 mtlk_aux_seq_printf(s, uint_fmt, general_stats->fw_logger_packets_processed, "FW logger packets processed");
5203 mtlk_aux_seq_printf(s, uint_fmt, general_stats->fw_logger_packets_dropped, "FW logger packets dropped");
5204 }
5205
5206 static int mtlk_df_ui_debug_general(mtlk_seq_entry_t *s, void *data)
5207 {
5208 int res = MTLK_ERR_NOT_SUPPORTED;
5209 mtlk_clpb_t *clpb = NULL;
5210 mtlk_stadb_stat_t *stadb_stat;
5211 uint32 size;
5212 unsigned long total_rx_packets;
5213 unsigned long total_tx_packets;
5214 unsigned long total_rx_dropped;
5215 mtlk_df_t *df = mtlk_df_proc_seq_entry_get_df(s);
5216 mtlk_df_user_t *df_user = mtlk_df_get_user(df);
5217 mtlk_core_ui_get_stadb_status_req_t get_stadb_status_req;
5218
5219 /* Get Core general information from DF buffer and don't call Core */
5220
5221 get_stadb_status_req.get_hostdb = TRUE;
5222 get_stadb_status_req.use_cipher = FALSE;
5223 res = _mtlk_df_user_invoke_core(df, MTLK_CORE_REQ_GET_STADB_STATUS, &clpb,
5224 &get_stadb_status_req, sizeof(get_stadb_status_req));
5225 res = _mtlk_df_user_process_core_retval_void(res, clpb, MTLK_CORE_REQ_GET_STADB_STATUS, FALSE);
5226 if (MTLK_ERR_OK != res) {
5227 goto err_ret;
5228 }
5229
5230 mtlk_aux_seq_printf(s, "\n"
5231 "Driver Statistics\n"
5232 "\n"
5233 "------------------+------------------+--------------------------------------\n"
5234 "MAC | Packets received | Packets sent | Rx packets dropped\n"
5235 "------------------+------------------+--------------------------------------\n");
5236
5237 total_rx_packets = 0;
5238 total_tx_packets = 0;
5239 total_rx_dropped = 0;
5240
5241 /* enumerate sta entries */
5242 while(NULL != (stadb_stat = mtlk_clpb_enum_get_next(clpb, &size))) {
5243 if (sizeof(*stadb_stat) != size) {
5244 res = MTLK_ERR_UNKNOWN;
5245 goto delete_clpb;
5246 }
5247
5248 if (STAT_ID_STADB == stadb_stat->type) {
5249
5250 total_rx_packets += stadb_stat->u.general_stat.sta_rx_packets;
5251 total_tx_packets += stadb_stat->u.general_stat.sta_tx_packets;
5252 total_rx_dropped += stadb_stat->u.general_stat.sta_rx_dropped;
5253
5254 mtlk_aux_seq_printf(s, MAC_PRINTF_FMT " | %-16u | %-16u | %-16u\n",
5255 MAC_PRINTF_ARG(stadb_stat->u.general_stat.addr.au8Addr),
5256 stadb_stat->u.general_stat.sta_rx_packets,
5257 stadb_stat->u.general_stat.sta_tx_packets,
5258 stadb_stat->u.general_stat.sta_rx_dropped);
5259 }
5260 else if (STAT_ID_HSTDB == stadb_stat->type) {
5261 if (mtlk_df_is_ap(df)) {
5262 mtlk_aux_seq_printf(s, " STA's WDS hosts:\n");
5263 }
5264 else {
5265 mtlk_aux_seq_printf(s, " All WDS hosts connected to this STA\n");
5266 }
5267
5268 mtlk_aux_seq_printf(s, MAC_PRINTF_FMT "\n", MAC_PRINTF_ARG(stadb_stat->u.hstdb_stat.addr.au8Addr));
5269 } else {
5270 res = MTLK_ERR_UNKNOWN;
5271 goto delete_clpb;
5272 }
5273 }
5274
5275 mtlk_aux_seq_printf(s,
5276 "------------------+------------------+--------------------------------------\n"
5277 "Total | %-16lu | %-16lu | %lu\n"
5278 "------------------+------------------+--------------------------------------\n"
5279 "Broadcast/non-reliable multicast | %-16lu |\n"
5280 "------------------+------------------+--------------------------------------\n"
5281 "\n",
5282 total_rx_packets, total_tx_packets, total_rx_dropped,
5283 (unsigned long)df_user->slow_ctx->core_general_stats.core_priv_stats.tx_bcast_nrmcast);
5284
5285 _mtlk_df_ui_print_driver_stats(s, &df_user->slow_ctx->core_general_stats);
5286
5287 delete_clpb:
5288 mtlk_clpb_delete(clpb);
5289 err_ret:
5290 return _mtlk_df_mtlk_to_linux_error_code(res);
5291 }
5292
5293 static int mtlk_df_ui_debug_mac_stats(mtlk_seq_entry_t *s, void *data)
5294 {
5295 int idx;
5296 int res = MTLK_ERR_OK;
5297 mtlk_df_t *df = mtlk_df_proc_seq_entry_get_df(s);
5298 mtlk_df_user_t *df_user = mtlk_df_get_user(df);
5299
5300 mtlk_aux_seq_printf(s, "\nMAC Statistics\n\n");
5301
5302 for (idx = 0; idx < mtlk_df_get_stat_info_len(); idx++) {
5303 mtlk_aux_seq_printf(s, "%10u %s\n",
5304 df_user->slow_ctx->core_general_stats.mac_stat.stat[mtlk_df_get_stat_info_idx(idx)],
5305 mtlk_df_get_stat_info_name(idx));
5306 }
5307
5308 return _mtlk_df_mtlk_to_linux_error_code(res);
5309 }
5310
5311 static int mtlk_df_ui_reordering_stats(mtlk_seq_entry_t *s, void *data)
5312 {
5313 int res = MTLK_ERR_NOT_SUPPORTED;
5314 mtlk_clpb_t *clpb = NULL;
5315 uint32 size;
5316 mtlk_stadb_stat_t *stadb_stat;
5317 uint8 tid;
5318 mtlk_df_t *df = mtlk_df_proc_seq_entry_get_df(s);
5319 mtlk_core_ui_get_stadb_status_req_t get_stadb_status_req;
5320
5321 get_stadb_status_req.get_hostdb = FALSE;
5322 get_stadb_status_req.use_cipher = FALSE;
5323 res = _mtlk_df_user_invoke_core(df, MTLK_CORE_REQ_GET_STADB_STATUS, &clpb,
5324 &get_stadb_status_req, sizeof(get_stadb_status_req));
5325 res = _mtlk_df_user_process_core_retval_void(res, clpb, MTLK_CORE_REQ_GET_STADB_STATUS, FALSE);
5326 if (MTLK_ERR_OK != res) {
5327 goto err_ret;
5328 }
5329
5330 mtlk_aux_seq_printf(s, "\n"
5331 "\n"
5332 "Reordering Statistics\n"
5333 "\n"
5334 "------------------+----+------------+------------+------------+------------+------------\n"
5335 "MAC | ID | Too old | Duplicate | Queued | Overflows | Lost \n"
5336 "------------------+----+------------+------------+------------+------------+------------\n");
5337
5338 while(NULL != (stadb_stat = mtlk_clpb_enum_get_next(clpb, &size))) {
5339 if ((sizeof(*stadb_stat) != size) || (STAT_ID_STADB != stadb_stat->type)) {
5340 res = MTLK_ERR_UNKNOWN;
5341 goto delete_clpb;
5342 }
5343
5344 for (tid = 0; tid < ARRAY_SIZE(stadb_stat->u.general_stat.reordering_stats); tid++ )
5345 {
5346 if (stadb_stat->u.general_stat.reordering_stats[tid].used) {
5347 mtlk_aux_seq_printf(s, MAC_PRINTF_FMT " | %-2d | %-10u | %-10u | %-10u | %-10u | %-10u\n",
5348 MAC_PRINTF_ARG(stadb_stat->u.general_stat.addr.au8Addr),
5349 tid,
5350 stadb_stat->u.general_stat.reordering_stats[tid].reord_stat.too_old,
5351 stadb_stat->u.general_stat.reordering_stats[tid].reord_stat.duplicate,
5352 stadb_stat->u.general_stat.reordering_stats[tid].reord_stat.queued,
5353 stadb_stat->u.general_stat.reordering_stats[tid].reord_stat.overflows,
5354 stadb_stat->u.general_stat.reordering_stats[tid].reord_stat.lost);
5355 } else {
5356 mtlk_aux_seq_printf(s, MAC_PRINTF_FMT " | %-2d | Not Used\n",
5357 MAC_PRINTF_ARG(stadb_stat->u.general_stat.addr.au8Addr),
5358 tid);
5359 }
5360 }
5361 }
5362
5363 mtlk_aux_seq_printf(s,
5364 "------------------+----+------------+------------+------------+------------+------------\n");
5365
5366 delete_clpb:
5367 mtlk_clpb_delete(clpb);
5368 err_ret:
5369 return _mtlk_df_mtlk_to_linux_error_code(res);
5370 }
5371
5372 static int mtlk_df_ui_debug_l2nat(mtlk_seq_entry_t *s, void *data)
5373 {
5374 int res = MTLK_ERR_NOT_SUPPORTED;
5375 mtlk_clpb_t *clpb = NULL;
5376 mtlk_df_t *df = mtlk_df_proc_seq_entry_get_df(s);
5377 struct l2nat_hash_entry_stats *hash_entry_stats;
5378 struct l2nat_buckets_stats *buckets_stats;
5379 int idx;
5380
5381 res = _mtlk_df_user_invoke_core(df, MTLK_CORE_REQ_GET_L2NAT_STATS, &clpb, NULL, 0);
5382 res = _mtlk_df_user_process_core_retval_void(res, clpb, MTLK_CORE_REQ_GET_L2NAT_STATS, FALSE);
5383
5384 if (MTLK_ERR_OK != res) {
5385 goto err_ret;
5386 }
5387
5388 buckets_stats = mtlk_clpb_enum_get_next(clpb, NULL);
5389 if (NULL == buckets_stats) {
5390 res = MTLK_ERR_UNKNOWN;
5391 goto err_get_stat;
5392 }
5393
5394 mtlk_aux_seq_printf(s, "\nL2NAT Statistics\n\n"
5395 "IP MAC Inactive (ms) Age(secs) Pkts from\n"
5396 "----------------------------------------------------------------------------\n");
5397
5398 while(NULL != (hash_entry_stats = mtlk_clpb_enum_get_next(clpb, NULL))) {
5399 mtlk_aux_seq_printf(s, MTLK_NIPQUAD_FMT "\t" MAC_PRINTF_FMT "%15lu %15lu %10u\n",
5400 MTLK_NIPQUAD(hash_entry_stats->ip),
5401 MAC_PRINTF_ARG(hash_entry_stats->mac),
5402 hash_entry_stats->last_pkt_timestamp,
5403 hash_entry_stats->first_pkt_timestamp,
5404 hash_entry_stats->pkts_from);
5405 }
5406
5407 mtlk_aux_seq_printf(s,
5408 "----------------------------------------------------------------------------\n");
5409
5410 mtlk_aux_seq_printf(s, "\n\nHash table statistics\n\n"
5411 "Bucket length :");
5412
5413 for (idx = 0; idx < ARRAY_SIZE(buckets_stats->blens) - 1; idx++) {
5414 mtlk_aux_seq_printf(s, " %3d", idx);
5415 }
5416
5417 mtlk_aux_seq_printf(s, " >%2d\n", (int)(ARRAY_SIZE(buckets_stats->blens) - 2));
5418 mtlk_aux_seq_printf(s, "Number of buckets :");
5419
5420 for (idx = 0; idx < ARRAY_SIZE(buckets_stats->blens) ; idx++) {
5421 mtlk_aux_seq_printf(s, " %3d", buckets_stats->blens[idx]);
5422 }
5423
5424 mtlk_aux_seq_printf(s, "\n\n");
5425
5426 err_get_stat:
5427 mtlk_clpb_delete(clpb);
5428 err_ret:
5429 return _mtlk_df_mtlk_to_linux_error_code(res);
5430 }
5431
5432 static int mtlk_df_ui_debug_send_queue(mtlk_seq_entry_t *s, void *data)
5433 {
5434 int res = MTLK_ERR_NOT_SUPPORTED;
5435 mtlk_clpb_t *clpb = NULL;
5436 mtlk_df_t *df = mtlk_df_proc_seq_entry_get_df(s);
5437 mtlk_sq_status_t *status;
5438 mtlk_sq_peer_status_t *peer_status;
5439 int idx;
5440
5441 res = _mtlk_df_user_invoke_core(df, MTLK_CORE_REQ_GET_SQ_STATUS, &clpb, NULL, 0);
5442 res = _mtlk_df_user_process_core_retval_void(res, clpb, MTLK_CORE_REQ_GET_SQ_STATUS, FALSE);
5443
5444 if (MTLK_ERR_OK != res) {
5445 goto err_ret;
5446 }
5447
5448 status = mtlk_clpb_enum_get_next(clpb, NULL);
5449 if (NULL == status) {
5450 res = MTLK_ERR_UNKNOWN;
5451 goto err_get_stat;
5452 }
5453
5454 /* iterate with format string */
5455 #define ITF(head_str, ...) \
5456 mtlk_aux_seq_printf(s, head_str); \
5457 for (idx = 0; idx < NTS_PRIORITIES; idx++) \
5458 mtlk_aux_seq_printf(s, __VA_ARGS__ ); \
5459 mtlk_aux_seq_printf(s,"\n");
5460
5461 ITF("--------------------------", "%s", "-------------");
5462 ITF("Name |", "%11s |", mtlk_qos_get_ac_name(idx));
5463 ITF("--------------------------", "%s", "-------------");
5464
5465 ITF("packets pushed |", "%11d |", status->stats.pkts_pushed[idx]);
5466 ITF("packets sent to UM |", "%11d |", status->stats.pkts_sent_to_um[idx]);
5467 ITF("global queue limits |", "%11d |", status->limits.global_queue_limit[idx]);
5468 ITF("peer queue limits |", "%11d |", status->limits.peer_queue_limit[idx]);
5469 ITF("current sizes |", "%11d |", status->qsizes.qsize[idx]);
5470 ITF("packets dropped (limit) |", "%11d |", status->stats.pkts_limit_dropped[idx]);
5471
5472 ITF("--------------------------", "%s", "-------------");
5473
5474 while(NULL != (peer_status = mtlk_clpb_enum_get_next(clpb, NULL))) {
5475 BOOL uapsd_any = FALSE;
5476
5477 /* Check if we have UAPSD enabled for any of the categories */
5478 for (idx = 0; idx < NTS_PRIORITIES; idx++) {
5479 if (peer_status->uapsd_enabled[idx]) {
5480 uapsd_any = TRUE;
5481 break;
5482 }
5483 }
5484
5485 if (NULL == peer_status->vap_handle) { /* STA */
5486 mtlk_aux_seq_printf(s, "\nSTA MAC:" MAC_PRINTF_FMT, MAC_PRINTF_ARG(peer_status->mac_addr.au8Addr));
5487 } else { /* VAP */
5488 mtlk_aux_seq_printf(s, "\nVAP ID: %u", mtlk_vap_get_id(peer_status->vap_handle));
5489 }
5490 if (!peer_status->ps_mode_enabled || !uapsd_any) {
5491 mtlk_aux_seq_printf(s, "\nLimit: %10u\nUsed: %11u\n", peer_status->limit, peer_status->used);
5492 } else {
5493 const char *acs[] = {"BE","BK","VI","VO"};
5494 uint32 used;
5495 BOOL first;
5496
5497 mtlk_aux_seq_printf(s, "\nLimits: Legacy(");
5498 for (first = TRUE, idx = 0; idx < NTS_PRIORITIES; idx++) {
5499 if (!peer_status->uapsd_enabled[idx]) {
5500 if (first) {
5501 first = FALSE;
5502 } else {
5503 mtlk_aux_seq_printf(s, ",");
5504 }
5505 mtlk_aux_seq_printf(s, "%s", acs[idx]);
5506 }
5507 }
5508 mtlk_aux_seq_printf(s, "):%02u", peer_status->limit);
5509
5510 mtlk_aux_seq_printf(s, " U-APSD(");
5511 for (first = TRUE, idx = 0; idx < NTS_PRIORITIES; idx++) {
5512 if (peer_status->uapsd_enabled[idx]) {
5513 if (first) {
5514 first = FALSE;
5515 } else {
5516 mtlk_aux_seq_printf(s, ",");
5517 }
5518 mtlk_aux_seq_printf(s, "%s", acs[idx]);
5519 }
5520 }
5521 if (first) {
5522 mtlk_aux_seq_printf(s, ")");
5523 } else {
5524 mtlk_aux_seq_printf(s, "):%02u", peer_status->limit_uapsd);
5525 }
5526 mtlk_aux_seq_printf(s, "\nUsed: Legacy(");
5527 for (first = TRUE, used = 0, idx = 0; idx < NTS_PRIORITIES; idx++) {
5528 if (!peer_status->uapsd_enabled[idx]) {
5529 if (first) {
5530 first = FALSE;
5531 } else {
5532 mtlk_aux_seq_printf(s, ",");
5533 }
5534 mtlk_aux_seq_printf(s, "%s", acs[idx]);
5535 used += peer_status->used_per_ac[idx];
5536 }
5537 }
5538 mtlk_aux_seq_printf(s, "):%02u", used);
5539
5540 mtlk_aux_seq_printf(s, " U-APSD(");
5541 for (first = TRUE, idx = 0; idx < NTS_PRIORITIES; idx++) {
5542 if (peer_status->uapsd_enabled[idx]) {
5543 if (first) {
5544 first = FALSE;
5545 } else {
5546 mtlk_aux_seq_printf(s, ",");
5547 }
5548 mtlk_aux_seq_printf(s, "%s:%02u", acs[idx], peer_status->used_per_ac[idx]);
5549 }
5550 }
5551 mtlk_aux_seq_printf(s, ")");
5552 mtlk_aux_seq_printf(s, "\n");
5553 }
5554
5555 ITF(" --------------------------", "%s", "-------------");
5556 ITF(" Name |", " %s |", mtlk_qos_get_ac_name(idx));
5557 ITF(" --------------------------", "%s", "-------------");
5558 ITF(" packets pushed |", "%11d |", peer_status->stats.pkts_pushed[idx]);
5559 ITF(" packets sent to UM |", "%11d |", peer_status->stats.pkts_sent_to_um[idx]);
5560 ITF(" current sizes |", "%11d |", peer_status->current_size[idx]);
5561 ITF(" packets dropped (limit) |", "%11d |", peer_status->stats.pkts_limit_dropped[idx]);
5562 ITF(" --------------------------", "%s", "-------------");
5563 }
5564
5565 err_get_stat:
5566 mtlk_clpb_delete(clpb);
5567 err_ret:
5568 return _mtlk_df_mtlk_to_linux_error_code(res);
5569 }
5570
5571 static int mtlk_df_ui_debug_power_save(mtlk_seq_entry_t *s, void *data)
5572 {
5573 int res = MTLK_ERR_NOT_SUPPORTED;
5574 mtlk_clpb_t *clpb = NULL;
5575 mtlk_df_t *df = mtlk_df_proc_seq_entry_get_df(s);
5576 mtlk_ps_status_t *status;
5577 mtlk_ps_peer_status_t *peer_status;
5578 int idx;
5579 uint32 num_of_elements;
5580 int elem;
5581
5582 res = _mtlk_df_user_invoke_core(df, MTLK_CORE_REQ_GET_PS_STATUS, &clpb, NULL, 0);
5583 res = _mtlk_df_user_process_core_retval_void(res, clpb, MTLK_CORE_REQ_GET_PS_STATUS, FALSE);
5584
5585 if (MTLK_ERR_OK != res) {
5586 goto err_ret;
5587 }
5588
5589 /* iterate with format string */
5590 #define ITF(head_str, ...) \
5591 mtlk_aux_seq_printf(s, head_str); \
5592 for (idx = 0; idx < NTS_PRIORITIES; idx++) \
5593 mtlk_aux_seq_printf(s, __VA_ARGS__ ); \
5594 mtlk_aux_seq_printf(s,"\n");
5595
5596 mtlk_aux_seq_printf(s,"\n");
5597
5598 ITF(" --------------------------", "%s", "-------------");
5599 ITF(" Station |", " %s |", mtlk_qos_get_ac_name(idx));
5600 ITF(" --------------------------", "%s", "-------------");
5601
5602 num_of_elements = mtlk_clpb_get_num_of_elements(clpb);
5603
5604 for (elem = 0; elem < num_of_elements-1; ++elem) {
5605
5606 peer_status = mtlk_clpb_enum_get_next(clpb, NULL);
5607 if (NULL == peer_status) {
5608 res = MTLK_ERR_UNKNOWN;
5609 goto err_get_stat;
5610 }
5611
5612 mtlk_aux_seq_printf(s, " " MAC_PRINTF_FMT, MAC_PRINTF_ARG(peer_status->mac_addr.au8Addr));
5613 if (peer_status->ps_mode_enabled) {
5614 mtlk_aux_seq_printf(s, " (PS) |");
5615 } else {
5616 mtlk_aux_seq_printf(s, " |");
5617 }
5618 for (idx = 0; idx < NTS_PRIORITIES; idx++) {
5619 mtlk_aux_seq_printf(s, " %02d:%c:%02d |", peer_status->used_per_ac[idx],
5620 peer_status->uapsd_enabled[idx]?'U':'L', peer_status->limit_per_ac[idx]);
5621 }
5622 mtlk_aux_seq_printf(s,"\n");
5623 }
5624
5625 ITF(" --------------------------", "%s", "-------------");
5626 mtlk_aux_seq_printf(s, " Notes: <used>:<[U]-APSD|[L]egacy>:<limit>\n");
5627
5628
5629 status = mtlk_clpb_enum_get_next(clpb, NULL);
5630 if (NULL == status) {
5631 res = MTLK_ERR_UNKNOWN;
5632 goto err_get_stat;
5633 }
5634
5635 mtlk_aux_seq_printf(s, "\nU-APSD enabled station(s): %2u", status->uapsd_enabled_stas);
5636 mtlk_aux_seq_printf(s, "\nDelivery enabled AC(s): %2u\n", status->delivery_enabled_acs);
5637
5638 err_get_stat:
5639 mtlk_clpb_delete(clpb);
5640 err_ret:
5641 return _mtlk_df_mtlk_to_linux_error_code(res);
5642 }
5643
5644 static int
5645 mtlk_df_do_debug_assert_write (struct file *file, const char *buf,
5646 unsigned long count, void *data)
5647 {
5648 int res = MTLK_ERR_PARAMS;
5649 char str[MAX_PROC_STR_LEN];
5650 mtlk_df_t *df = (mtlk_df_t *)data;
5651 mtlk_clpb_t *clpb = NULL;
5652 int arg_num;
5653 int arg_assert_type;
5654
5655 if (count > MAX_PROC_STR_LEN) {
5656 goto end;
5657 }
5658
5659 memset(str, 0, sizeof(str));
5660 if (copy_from_user(str, buf, count)) {
5661 ELOG0_D("CID-%04x: copy_from_user error", mtlk_vap_get_oid(mtlk_df_get_vap_handle(df)));
5662 goto end;
5663 }
5664
5665 arg_num = sscanf(str, "%d", &arg_assert_type);
5666 if (arg_num < 1) {
5667 goto end;
5668 }
5669
5670 if (arg_num >= 1) {
5671 if (arg_assert_type < 0 || arg_assert_type >= MTLK_CORE_UI_ASSERT_TYPE_LAST) {
5672 ELOG_DD("CID-%04x: Unsupported assert type: %d", mtlk_vap_get_oid(mtlk_df_get_vap_handle(df)), arg_assert_type);
5673 goto end;
5674 }
5675 }
5676
5677 switch (arg_assert_type)
5678 {
5679 case MTLK_CORE_UI_ASSERT_TYPE_FW_LMIPS:
5680 /* Check whether the LMIPS has already been asserted. If so - doesn't call the Core */
5681 res = mtlk_osal_event_wait(&mtlk_df_get_user(df)->fw_hang_evts[LMIPS], 0);
5682 if (res == MTLK_ERR_OK) {
5683 ILOG0_D("CID-%04x: LMIPS already asserted", mtlk_vap_get_oid(mtlk_df_get_vap_handle(df)));
5684 goto end;
5685 }
5686 break;
5687 case MTLK_CORE_UI_ASSERT_TYPE_FW_UMIPS:
5688 /* Check whether the UMIPS has already been asserted. If so - doesn't call the Core */
5689 res = mtlk_osal_event_wait(&mtlk_df_get_user(df)->fw_hang_evts[UMIPS], 0);
5690 if (res == MTLK_ERR_OK) {
5691 ILOG0_D("CID-%04x: UMIPS already asserted", mtlk_vap_get_oid(mtlk_df_get_vap_handle(df)));
5692 goto end;
5693 }
5694 default:
5695 break;
5696 }
5697
5698 res = _mtlk_df_user_invoke_core(df, MTLK_CORE_REQ_SET_MAC_ASSERT, &clpb,
5699 &arg_assert_type, sizeof(arg_assert_type));
5700 _mtlk_df_user_process_core_retval_void(res, clpb, MTLK_CORE_REQ_SET_MAC_ASSERT, TRUE);
5701
5702 if (res == MTLK_ERR_NOT_READY) {
5703 ILOG0_D("CID-%04x: Already asserted", mtlk_vap_get_oid(mtlk_df_get_vap_handle(df)));
5704 goto end;
5705 }
5706
5707 switch (arg_assert_type)
5708 {
5709 case MTLK_CORE_UI_ASSERT_TYPE_FW_LMIPS:
5710 /* Wait for LMIPS to detect ASSERTION */
5711 res = mtlk_osal_event_wait(&mtlk_df_get_user(df)->fw_hang_evts[LMIPS], _DF_WAIT_FW_ASSERT);
5712 if (res != MTLK_ERR_OK) {
5713 WLOG_DD("CID-%04x: LMIPS assertion failed (res=%d)", mtlk_vap_get_oid(mtlk_df_get_vap_handle(df)), res);
5714 }
5715 else {
5716 ILOG0_D("CID-%04x: LMIPS asserted", mtlk_vap_get_oid(mtlk_df_get_vap_handle(df)));
5717 }
5718 break;
5719 case MTLK_CORE_UI_ASSERT_TYPE_FW_UMIPS:
5720 /* Wait for UMIPS to detect ASSERTION */
5721 res = mtlk_osal_event_wait(&mtlk_df_get_user(df)->fw_hang_evts[UMIPS], _DF_WAIT_FW_ASSERT);
5722 if (res != MTLK_ERR_OK) {
5723 WLOG_DD("CID-%04x: UMIPS assertion failed (res=%d)", mtlk_vap_get_oid(mtlk_df_get_vap_handle(df)), res);
5724 }
5725 else {
5726 ILOG0_D("CID-%04x: UMIPS asserted", mtlk_vap_get_oid(mtlk_df_get_vap_handle(df)));
5727 }
5728 case MTLK_CORE_UI_ASSERT_TYPE_LAST:
5729 default:
5730 break;
5731 }
5732
5733 end:
5734 /* need to return counter, not result in this type of proc */
5735 return count;
5736 }
5737
5738 static int
5739 _mtlk_df_ui_proc_bcl_read (char *page, char **start, off_t off, int count, int *eof,
5740 void *data, int io_base, int io_size)
5741 {
5742 int res = MTLK_ERR_NOT_SUPPORTED;
5743 mtlk_df_t *df = (mtlk_df_t *)data;
5744 mtlk_clpb_t *clpb = NULL;
5745 UMI_BCL_REQUEST req;
5746 UMI_BCL_REQUEST *req_result;
5747
5748 /* Calculate io offset */
5749 if (off >= io_size) {
5750 *eof = 1;
5751 return 0;
5752 }
5753
5754 if ((off & (sizeof(req.Data) - 1)) || (count < sizeof(req.Data)))
5755 return -EIO;
5756
5757 count = 0;
5758
5759 /* Fill get BCL request */
5760 /* We mast inform core in some way that it should not convert result data words in host format
5761 * when BCL read operation has been requested from Proc (memory dump). So, add BCL_UNIT_MAX to
5762 * Unit field and check&subtract it in core */
5763 req.Unit = BCL_UNIT_INT_RAM + BCL_UNIT_MAX;
5764 req.Size = sizeof(req.Data);
5765 req.Address = io_base + off;
5766 memset(req.Data, 0x5c, sizeof(req.Data)); /* poison */
5767
5768 /* Send request to core */
5769 res = _mtlk_df_user_invoke_core(df, MTLK_CORE_REQ_GET_BCL_MAC_DATA, &clpb, &req, sizeof(req));
5770 res = _mtlk_df_user_process_core_retval_void(res, clpb, MTLK_CORE_REQ_GET_BCL_MAC_DATA, FALSE);
5771 if (MTLK_ERR_OK != res) {
5772 goto err_ret;
5773 }
5774
5775 /* Handle result */
5776 req_result = mtlk_clpb_enum_get_next(clpb, NULL);
5777
5778 if (NULL != req_result) {
5779 count = sizeof(req_result->Data);
5780 memcpy(page, req_result->Data, count);
5781 *start = (char*)sizeof(req_result->Data);
5782 }
5783
5784 mtlk_clpb_delete(clpb);
5785 err_ret:
5786 return count;
5787 }
5788
5789 #ifdef MTCFG_BUS_PCI_PCIE
5790 static int mtlk_df_ui_lm(char *page, char **start, off_t off,
5791 int count, int *eof, void *data)
5792 {
5793 return _mtlk_df_ui_proc_bcl_read(page, start, off, count, eof, data, LM_DATA_BASE, LM_DATA_SIZE);
5794 }
5795
5796 static int mtlk_df_ui_um(char *page, char **start, off_t off,
5797 int count, int *eof, void *data)
5798 {
5799 return _mtlk_df_ui_proc_bcl_read(page, start, off, count, eof, data, UM_DATA_BASE, UM_DATA_SIZE);
5800 }
5801 #endif /* MTCFG_BUS_PCI_PCIE */
5802
5803 static int mtlk_df_ui_shram(char *page, char **start, off_t off,
5804 int count, int *eof, void *data)
5805 {
5806 return _mtlk_df_ui_proc_bcl_read(page, start, off, count, eof, data, SHRAM_DATA_BASE, SHRAM_DATA_SIZE);
5807 }
5808
5809 #ifdef MTCFG_BUS_AHB
5810 static int mtlk_df_ui_ahbum(char *page, char **start, off_t off,
5811 int count, int *eof, void *data)
5812 {
5813 return _mtlk_df_ui_proc_bcl_read(page, start, off, count, eof, data, AHBUM_DATA_BASE, AHBUM_DATA_SIZE);
5814 }
5815 #endif /* MTCFG_BUS_AHB */
5816
5817 static int
5818 _mtlk_df_ui_ee_caps(mtlk_seq_entry_t *s, void *data)
5819 {
5820 int res = MTLK_ERR_NOT_SUPPORTED;
5821 mtlk_df_t *df = mtlk_df_proc_seq_entry_get_df(s);
5822 mtlk_eeprom_data_stat_entry_t *pstat;
5823 mtlk_handle_t hdata;
5824
5825 res = _mtlk_df_user_pull_core_data(df, MTLK_CORE_REQ_GET_EE_CAPS, TRUE, (void**) &pstat, NULL, &hdata);
5826 if (MTLK_ERR_OK != res) {
5827 goto err_ret;
5828 }
5829
5830 mtlk_aux_seq_printf(s, "AP disabled: %i\nDFS channels disabled: %i\n",
5831 pstat->ap_disabled, pstat->disable_sm_channels);
5832
5833 _mtlk_df_user_free_core_data(df, hdata);
5834
5835 err_ret:
5836 return _mtlk_df_mtlk_to_linux_error_code(res);
5837 }
5838
5839 static int
5840 _mtlk_df_ui_debug_igmp_read(mtlk_seq_entry_t *s, void *data)
5841 {
5842 int res = MTLK_ERR_NOT_SUPPORTED;
5843 mtlk_df_t *df = mtlk_df_proc_seq_entry_get_df(s);
5844 mtlk_clpb_t *clpb = NULL;
5845 mtlk_mc_igmp_tbl_item_t *igmp_tbl_item;
5846
5847 res = _mtlk_df_user_invoke_core(df, MTLK_CORE_REQ_GET_MC_IGMP_TBL, &clpb, NULL, 0);
5848 res = _mtlk_df_user_process_core_retval_void(res, clpb, MTLK_CORE_REQ_GET_MC_IGMP_TBL, FALSE);
5849 if (MTLK_ERR_OK != res) {
5850 goto err_ret;
5851 }
5852
5853 while (NULL != (igmp_tbl_item = mtlk_clpb_enum_get_next(clpb, NULL))) {
5854
5855 switch (igmp_tbl_item->type) {
5856 case MTLK_MC_IPV4_ADDR:
5857 mtlk_aux_seq_printf(s, "IPv4 mcast group " MTLK_NIPQUAD_FMT "\n",
5858 MTLK_NIPQUAD( ((mtlk_mc_igmp_tbl_ipv4_item_t*)igmp_tbl_item)->addr.s_addr ));
5859 break;
5860 case MTLK_MC_IPV6_ADDR:
5861 mtlk_aux_seq_printf(s, "IPv6 mcast group " MTLK_NIP6_FMT "\n",
5862 MTLK_NIP6( ((mtlk_mc_igmp_tbl_ipv6_item_t*)igmp_tbl_item)->addr ));
5863 break;
5864 case MTLK_MC_MAC_ADDR:
5865 mtlk_aux_seq_printf(s, " " MAC_PRINTF_FMT "\n",
5866 MAC_PRINTF_ARG( ((mtlk_mc_igmp_tbl_mac_item_t*)igmp_tbl_item)->addr.au8Addr ));
5867 break;
5868 default:
5869 MTLK_ASSERT(FALSE);
5870 }
5871 }
5872
5873 mtlk_clpb_delete(clpb);
5874 err_ret:
5875 return _mtlk_df_mtlk_to_linux_error_code(res);
5876 }
5877
5878 static int
5879 mtlk_df_ui_reset_stats(mtlk_df_t* df)
5880 {
5881 mtlk_clpb_t *clpb = NULL;
5882 int res;
5883
5884 res = _mtlk_df_user_invoke_core(df, MTLK_CORE_REQ_RESET_STATS, &clpb, NULL, 0);
5885 res = _mtlk_df_user_process_core_retval(res, clpb, MTLK_CORE_REQ_RESET_STATS, TRUE);
5886
5887 return res;
5888 }
5889
5890 int _mtlk_df_ui_reset_stats_proc(struct file *file, const char __user *buffer,
5891 unsigned long count, void *data)
5892 {
5893 mtlk_df_ui_reset_stats((mtlk_df_t*)data);
5894 return count;
5895 }
5896
5897 static int _mtlk_df_ui_l2nat_clear_table(struct file *file, const char __user *buffer,
5898 unsigned long count, void *data)
5899 {
5900 mtlk_clpb_t *clpb = NULL;
5901 mtlk_df_t *df = (mtlk_df_t*) data;
5902
5903 int res = _mtlk_df_user_invoke_core(df, MTLK_CORE_REQ_L2NAT_CLEAR_TABLE, &clpb, NULL, 0);
5904 _mtlk_df_user_process_core_retval_void(res, clpb, MTLK_CORE_REQ_L2NAT_CLEAR_TABLE, TRUE);
5905
5906 return count;
5907 }
5908
5909 #ifdef AOCS_DEBUG
5910 static int mtlk_df_ui_aocs_proc_cl(struct file *file, const char __user *buffer,
5911 unsigned long count, void *data)
5912 {
5913 int res = MTLK_ERR_OK;
5914 mtlk_clpb_t *clpb = NULL;
5915 uint32 cl;
5916 mtlk_df_t *df = (mtlk_df_t*) data;
5917
5918 if (1 != sscanf(buffer, "%u", &cl)) {
5919 return count;
5920 }
5921
5922 res = _mtlk_df_user_invoke_core(df, MTLK_CORE_REQ_SET_AOCS_CL, &clpb, &cl, sizeof(cl));
5923 res = _mtlk_df_user_process_core_retval_void(res, clpb, MTLK_CORE_REQ_SET_AOCS_CL, TRUE);
5924
5925 return count;
5926 }
5927 #endif
5928
5929 static int _mtlk_df_version_dump(mtlk_seq_entry_t *s, void *v)
5930 {
5931 int res = MTLK_ERR_OK;
5932 mtlk_df_t *df = mtlk_df_proc_seq_entry_get_df(s);
5933 mtlk_vap_handle_t vap = mtlk_df_get_vap_handle(df);
5934 char *buffer;
5935
5936 buffer = mtlk_osal_mem_alloc(MTLK_HW_VERSION_PRINTOUT_LEN, MTLK_MEM_TAG_VERSION_PRINTOUT);
5937
5938 if(!buffer)
5939 {
5940 ELOG_V("Cannot allocate memory for version printout");
5941 res = MTLK_ERR_NO_MEM;
5942 goto finish;
5943 }
5944
5945 res = mtlk_vap_get_hw_vft(vap)->get_prop(vap, MTLK_HW_VERSION_PRINTOUT,
5946 buffer, MTLK_HW_VERSION_PRINTOUT_LEN);
5947
5948 if(res != MTLK_ERR_OK)
5949 {
5950 ELOG_V("Cannot perform version printout");
5951 goto free_buffer;
5952 }
5953
5954 mtlk_aux_seq_printf(s, "%s", buffer);
5955
5956 free_buffer:
5957 mtlk_osal_mem_free(buffer);
5958
5959 finish:
5960 return _mtlk_df_mtlk_to_linux_error_code(res);
5961 }
5962
5963 /**************************************************************
5964 * Register handlers
5965 **************************************************************/
5966
5967 #define PROC_NODE_ADDBA_STATUS "addba_status"
5968
5969 static int mtlk_df_ui_reg_addba_status(mtlk_df_user_t* df_user)
5970 {
5971 return mtlk_df_proc_node_add_seq_entry(
5972 PROC_NODE_ADDBA_STATUS, df_user->slow_ctx->proc_df_debug_node, df_user->df, mtlk_df_ui_addba_status);
5973 }
5974
5975 static void mtlk_df_ui_unreg_addba_status(mtlk_df_user_t* df_user)
5976 {
5977 mtlk_df_proc_node_remove_entry(PROC_NODE_ADDBA_STATUS, df_user->slow_ctx->proc_df_debug_node);
5978 }
5979
5980 static int mtlk_df_ui_reg_aocs_history(mtlk_df_user_t* df_user)
5981 {
5982 return mtlk_df_proc_node_add_seq_entry(
5983 "aocs_history", df_user->slow_ctx->proc_df_node, df_user->df, mtlk_df_ui_aocs_history);
5984 }
5985
5986 static int mtlk_df_ui_reg_aocs_table(mtlk_df_user_t* df_user)
5987 {
5988 return mtlk_df_proc_node_add_seq_entry(
5989 "aocs_table", df_user->slow_ctx->proc_df_node, df_user->df, mtlk_df_ui_aocs_table);
5990 }
5991
5992 static int mtlk_df_ui_reg_aocs_channels(mtlk_df_user_t* df_user)
5993 {
5994 return mtlk_df_proc_node_add_seq_entry(
5995 "aocs_channels", df_user->slow_ctx->proc_df_node, df_user->df, mtlk_df_ui_aocs_channels);
5996 }
5997
5998 #ifdef BT_ACS_DEBUG
5999 static int mtlk_df_ui_reg_aocs_channels_dbg(mtlk_df_user_t* df_user)
6000 {
6001 return mtlk_df_proc_node_add_wo_entry(
6002 "aocs_channels_dbg", df_user->slow_ctx->proc_df_node, df_user->df, mtlk_df_ui_aocs_channels_dbg);
6003 }
6004 #endif /* BT_ACS_DEBUG */
6005
6006 static int mtlk_df_ui_reg_aocs_penalties(mtlk_df_user_t* df_user)
6007 {
6008 return mtlk_df_proc_node_add_seq_entry(
6009 "aocs_penalties", df_user->slow_ctx->proc_df_node, df_user->df, mtlk_df_ui_aocs_penalties);
6010 }
6011
6012 static int mtlk_df_ui_reg_hw_limits(mtlk_df_user_t* df_user)
6013 {
6014 return mtlk_df_proc_node_add_seq_entry(
6015 "hw_limits", df_user->slow_ctx->proc_df_node, df_user->df, mtlk_df_ui_hw_limits);
6016 }
6017
6018 static int mtlk_df_ui_reg_reg_limits(mtlk_df_user_t* df_user)
6019 {
6020 return mtlk_df_proc_node_add_seq_entry(
6021 "reg_limits", df_user->slow_ctx->proc_df_node, df_user->df, mtlk_df_ui_reg_limits);
6022 }
6023
6024 static int mtlk_df_ui_reg_ant_gain(mtlk_df_user_t* df_user)
6025 {
6026 return mtlk_df_proc_node_add_seq_entry(
6027 "antenna_gain", df_user->slow_ctx->proc_df_node, df_user->df, mtlk_df_ui_ant_gain);
6028 }
6029
6030 static void mtlk_df_ui_unreg_serializer_dump(mtlk_df_user_t* df_user)
6031 {
6032 mtlk_df_proc_node_remove_entry("serializer_dump", df_user->slow_ctx->proc_df_debug_node);
6033 }
6034
6035 static int mtlk_df_ui_reg_serializer_dump(mtlk_df_user_t* df_user)
6036 {
6037 return mtlk_df_proc_node_add_seq_entry(
6038 "serializer_dump", df_user->slow_ctx->proc_df_debug_node, df_user->df, mtlk_df_ui_serializer_dump);
6039 }
6040
6041 static void mtlk_df_ui_unreg_core_status(mtlk_df_user_t* df_user)
6042 {
6043 mtlk_df_proc_node_remove_entry("General", df_user->slow_ctx->proc_df_debug_node);
6044 mtlk_df_proc_node_remove_entry("MACStats", df_user->slow_ctx->proc_df_debug_node);
6045 }
6046
6047 static int mtlk_df_ui_reg_core_status(mtlk_df_user_t* df_user)
6048 {
6049 int res;
6050 res = mtlk_df_proc_node_add_seq_entry(
6051 "General", df_user->slow_ctx->proc_df_debug_node, df_user->df, mtlk_df_ui_debug_general);
6052
6053 if (MTLK_ERR_OK == res) {
6054 res = mtlk_df_proc_node_add_seq_entry(
6055 "MACStats",
6056 df_user->slow_ctx->proc_df_debug_node,
6057 df_user->df,
6058 mtlk_df_ui_debug_mac_stats);
6059 }
6060
6061 if (MTLK_ERR_OK != res) {
6062 mtlk_df_ui_unreg_core_status(df_user);
6063 }
6064
6065 return res;
6066 }
6067
6068 static int mtlk_df_ui_reg_debug_reordering_stats(mtlk_df_user_t* df_user)
6069 {
6070 return mtlk_df_proc_node_add_seq_entry(
6071 "ReorderingStats",
6072 df_user->slow_ctx->proc_df_debug_node,
6073 df_user->df,
6074 mtlk_df_ui_reordering_stats);
6075 }
6076
6077 static int mtlk_df_ui_reg_debug_l2nat(mtlk_df_user_t* df_user)
6078 {
6079 return mtlk_df_proc_node_add_seq_entry(
6080 "L2NAT", df_user->slow_ctx->proc_df_debug_node, df_user->df, mtlk_df_ui_debug_l2nat);
6081 }
6082
6083 static int mtlk_df_ui_reg_debug_send_queue(mtlk_df_user_t* df_user)
6084 {
6085 return mtlk_df_proc_node_add_seq_entry(
6086 "SendQueue", df_user->slow_ctx->proc_df_debug_node, df_user->df, mtlk_df_ui_debug_send_queue);
6087 }
6088
6089 static int mtlk_df_ui_reg_debug_power_save(mtlk_df_user_t* df_user)
6090 {
6091 return mtlk_df_proc_node_add_seq_entry(
6092 "PS", df_user->slow_ctx->proc_df_debug_node, df_user->df, mtlk_df_ui_debug_power_save);
6093 }
6094
6095 static int mtlk_df_ui_reg_debug_mac_assert(mtlk_df_user_t* df_user)
6096 {
6097 return mtlk_df_proc_node_add_wo_entry(
6098 "do_debug_assert", df_user->slow_ctx->proc_df_node, df_user->df, mtlk_df_do_debug_assert_write);
6099 }
6100
6101 #ifdef MTCFG_BUS_PCI_PCIE
6102 static int mtlk_df_ui_reg_bcl_read_lm(mtlk_df_user_t* df_user)
6103 {
6104 return mtlk_df_proc_node_add_ro_entry(
6105 "lm", df_user->slow_ctx->proc_df_node, df_user->df, mtlk_df_ui_lm);
6106 }
6107
6108 static int mtlk_df_ui_reg_bcl_read_um(mtlk_df_user_t* df_user)
6109 {
6110 return mtlk_df_proc_node_add_ro_entry(
6111 "um", df_user->slow_ctx->proc_df_node, df_user->df, mtlk_df_ui_um);
6112 }
6113 #endif /* MTCFG_BUS_PCI_PCIE */
6114
6115 static int mtlk_df_ui_reg_bcl_read_shram(mtlk_df_user_t* df_user)
6116 {
6117 return mtlk_df_proc_node_add_ro_entry(
6118 "shram", df_user->slow_ctx->proc_df_node, df_user->df, mtlk_df_ui_shram);
6119 }
6120
6121 #ifdef MTCFG_BUS_AHB
6122 static int mtlk_df_ui_reg_bcl_read_ahbum(mtlk_df_user_t* df_user)
6123 {
6124 return mtlk_df_proc_node_add_ro_entry(
6125 "um", df_user->slow_ctx->proc_df_node, df_user->df, mtlk_df_ui_ahbum);
6126 }
6127 #endif /* MTCFG_BUS_AHB */
6128
6129 static int mtlk_df_ui_reg_ee_caps(mtlk_df_user_t* df_user)
6130 {
6131 return mtlk_df_proc_node_add_seq_entry(
6132 "EECaps", df_user->slow_ctx->proc_df_node, df_user->df, _mtlk_df_ui_ee_caps);
6133 }
6134
6135 static int mtlk_df_ui_reg_debug_igmp_read(mtlk_df_user_t* df_user)
6136 {
6137 return mtlk_df_proc_node_add_seq_entry(
6138 "igmp", df_user->slow_ctx->proc_df_node, df_user->df, _mtlk_df_ui_debug_igmp_read);
6139 }
6140
6141 static int mtlk_df_ui_reg_reset_stats(mtlk_df_user_t* df_user)
6142 {
6143 return mtlk_df_proc_node_add_wo_entry(
6144 "ResetStats",
6145 df_user->slow_ctx->proc_df_debug_node,
6146 df_user->df,
6147 _mtlk_df_ui_reset_stats_proc);
6148 }
6149
6150 static int mtlk_df_ui_reg_l2nat_clear_table(mtlk_df_user_t* df_user)
6151 {
6152 return mtlk_df_proc_node_add_wo_entry(
6153 "L2NAT_ClearTable",
6154 df_user->slow_ctx->proc_df_debug_node,
6155 df_user->df,
6156 _mtlk_df_ui_l2nat_clear_table);
6157 }
6158
6159 #ifdef AOCS_DEBUG
6160 static int mtlk_df_ui_reg_aocs_proc_cl(mtlk_df_user_t* df_user)
6161 {
6162 return mtlk_df_proc_node_add_wo_entry(
6163 "aocs_cl", df_user->slow_ctx->proc_df_debug_node, df_user->df, mtlk_df_ui_aocs_proc_cl);
6164 }
6165 #endif
6166
6167 static int mtlk_df_ui_reg_version(mtlk_df_user_t* df_user)
6168 {
6169 return mtlk_df_proc_node_add_seq_entry(
6170 "version", df_user->slow_ctx->proc_df_node, df_user->df, _mtlk_df_version_dump);
6171 }
6172
6173 /**************************************************************
6174 * Unregister handlers
6175 **************************************************************/
6176 static void mtlk_df_ui_unreg_aocs_history(mtlk_df_user_t* df_user)
6177 {
6178 mtlk_df_proc_node_remove_entry("aocs_history", df_user->slow_ctx->proc_df_node);
6179 }
6180
6181 static void mtlk_df_ui_unreg_aocs_table(mtlk_df_user_t* df_user)
6182 {
6183 mtlk_df_proc_node_remove_entry("aocs_table", df_user->slow_ctx->proc_df_node);
6184 }
6185
6186 static void mtlk_df_ui_unreg_aocs_channels(mtlk_df_user_t* df_user)
6187 {
6188 mtlk_df_proc_node_remove_entry("aocs_channels", df_user->slow_ctx->proc_df_node);
6189 }
6190
6191 #ifdef BT_ACS_DEBUG
6192 static void mtlk_df_ui_unreg_aocs_channels_dbg(mtlk_df_user_t* df_user)
6193 {
6194 mtlk_df_proc_node_remove_entry("aocs_channels_dbg", df_user->slow_ctx->proc_df_node);
6195 }
6196 #endif /* BT_ACS_DEBUG */
6197
6198 static void mtlk_df_ui_unreg_aocs_penalties(mtlk_df_user_t* df_user)
6199 {
6200 mtlk_df_proc_node_remove_entry("aocs_penalties", df_user->slow_ctx->proc_df_node);
6201 }
6202
6203 static void mtlk_df_ui_unreg_hw_limits(mtlk_df_user_t* df_user)
6204 {
6205 mtlk_df_proc_node_remove_entry("hw_limits", df_user->slow_ctx->proc_df_node);
6206 }
6207
6208 static void mtlk_df_ui_unreg_reg_limits(mtlk_df_user_t* df_user)
6209 {
6210 mtlk_df_proc_node_remove_entry("reg_limits", df_user->slow_ctx->proc_df_node);
6211 }
6212
6213 static void mtlk_df_ui_unreg_ant_gain(mtlk_df_user_t* df_user)
6214 {
6215 mtlk_df_proc_node_remove_entry("antenna_gain", df_user->slow_ctx->proc_df_node);
6216 }
6217
6218 static void mtlk_df_ui_unreg_debug_reordering_stats(mtlk_df_user_t* df_user)
6219 {
6220 mtlk_df_proc_node_remove_entry("ReorderingStats", df_user->slow_ctx->proc_df_debug_node);
6221 }
6222
6223 static void mtlk_df_ui_unreg_debug_l2nat(mtlk_df_user_t* df_user)
6224 {
6225 mtlk_df_proc_node_remove_entry("L2NAT", df_user->slow_ctx->proc_df_debug_node);
6226 }
6227
6228 static void mtlk_df_ui_unreg_debug_send_queue(mtlk_df_user_t* df_user)
6229 {
6230 mtlk_df_proc_node_remove_entry("SendQueue", df_user->slow_ctx->proc_df_debug_node);
6231 }
6232
6233 static void mtlk_df_ui_unreg_debug_power_save(mtlk_df_user_t* df_user)
6234 {
6235 mtlk_df_proc_node_remove_entry("PS", df_user->slow_ctx->proc_df_debug_node);
6236 }
6237
6238 static void mtlk_df_ui_unreg_debug_mac_assert(mtlk_df_user_t* df_user)
6239 {
6240 mtlk_df_proc_node_remove_entry("do_debug_assert", df_user->slow_ctx->proc_df_node);
6241 }
6242
6243 #ifdef MTCFG_BUS_PCI_PCIE
6244 static void mtlk_df_ui_unreg_bcl_read_lm(mtlk_df_user_t* df_user)
6245 {
6246 mtlk_df_proc_node_remove_entry("lm", df_user->slow_ctx->proc_df_node);
6247 }
6248
6249 static void mtlk_df_ui_unreg_bcl_read_um(mtlk_df_user_t* df_user)
6250 {
6251 mtlk_df_proc_node_remove_entry("um", df_user->slow_ctx->proc_df_node);
6252 }
6253 #endif /* MTCFG_BUS_PCI_PCIE */
6254
6255 static void mtlk_df_ui_unreg_bcl_read_shram(mtlk_df_user_t* df_user)
6256 {
6257 mtlk_df_proc_node_remove_entry("shram", df_user->slow_ctx->proc_df_node);
6258 }
6259
6260 #ifdef MTCFG_BUS_AHB
6261 static void mtlk_df_ui_unreg_bcl_read_ahbum(mtlk_df_user_t* df_user)
6262 {
6263 mtlk_df_proc_node_remove_entry("um", df_user->slow_ctx->proc_df_node);
6264 }
6265 #endif /* MTCFG_BUS_AHB */
6266
6267 static void mtlk_df_ui_unreg_ee_caps(mtlk_df_user_t* df_user)
6268 {
6269 mtlk_df_proc_node_remove_entry("EECaps", df_user->slow_ctx->proc_df_node);
6270 }
6271
6272 static void mtlk_df_ui_unreg_debug_igmp_read(mtlk_df_user_t* df_user)
6273 {
6274 mtlk_df_proc_node_remove_entry("igmp", df_user->slow_ctx->proc_df_node);
6275 }
6276
6277 static void mtlk_df_ui_unreg_reset_stats(mtlk_df_user_t* df_user)
6278 {
6279 mtlk_df_proc_node_remove_entry("ResetStats", df_user->slow_ctx->proc_df_debug_node);
6280 }
6281
6282 static void mtlk_df_ui_unreg_l2nat_clear_table(mtlk_df_user_t* df_user)
6283 {
6284 mtlk_df_proc_node_remove_entry("L2NAT_ClearTable", df_user->slow_ctx->proc_df_debug_node);
6285 }
6286
6287 #ifdef AOCS_DEBUG
6288 static void mtlk_df_ui_unreg_aocs_proc_cl(mtlk_df_user_t* df_user)
6289 {
6290 mtlk_df_proc_node_remove_entry("aocs_cl", df_user->slow_ctx->proc_df_debug_node);
6291 }
6292 #endif
6293
6294 static void mtlk_df_ui_unreg_version(mtlk_df_user_t* df_user)
6295 {
6296 mtlk_df_proc_node_remove_entry("version", df_user->slow_ctx->proc_df_node);
6297 }
6298
6299 #ifdef EEPROM_DATA_VALIDATION
6300
6301 #define PROC_EEPROM "eeprom"
6302
6303 static int
6304 _mtlk_df_ui_eeprom(mtlk_seq_entry_t *s, void *data)
6305 {
6306 int res = MTLK_ERR_NOT_SUPPORTED;
6307 uint32 req_data_length; \
6308 mtlk_df_t *df = mtlk_df_proc_seq_entry_get_df(s);
6309 mtlk_eeprom_cfg_t *eeprom_cfg;
6310 mtlk_handle_t hdata;
6311
6312 MTLK_UNREFERENCED_PARAM(data);
6313
6314 res = _mtlk_df_user_pull_core_data(df, MTLK_CORE_REQ_GET_EEPROM_CFG, FALSE,
6315 (void**) &eeprom_cfg, &req_data_length,
6316 &hdata);
6317 if(MTLK_ERR_OK == res)
6318 {
6319 MTLK_ASSERT(sizeof(mtlk_eeprom_cfg_t) == req_data_length);
6320
6321 res = mtlk_aux_seq_write(s, eeprom_cfg->eeprom_raw_data, sizeof(eeprom_cfg->eeprom_raw_data));
6322 }
6323
6324 if(MTLK_INVALID_HANDLE != hdata)
6325 {
6326 _mtlk_df_user_free_core_data(df, hdata);
6327 }
6328
6329 return _mtlk_df_mtlk_to_linux_error_code(res);
6330 }
6331
6332 static int mtlk_df_ui_reg_eeprom_proc_cl(mtlk_df_user_t* df_user)
6333 {
6334 return mtlk_df_proc_node_add_seq_entry(PROC_EEPROM,
6335 df_user->slow_ctx->proc_df_node, df_user->df, _mtlk_df_ui_eeprom);
6336 }
6337
6338 static void mtlk_df_ui_unreg_eeprom_proc_cl(mtlk_df_user_t* df_user)
6339 {
6340 mtlk_df_proc_node_remove_entry(PROC_EEPROM, df_user->slow_ctx->proc_df_node);
6341 }
6342
6343 #define PROC_EEPROMFW "eeprom_fw"
6344
6345 static int
6346 _mtlk_df_ui_eepromfw(mtlk_seq_entry_t *s, void *data)
6347 {
6348 int res = MTLK_ERR_NOT_SUPPORTED;
6349 uint32 req_data_length; \
6350 mtlk_df_t *df = mtlk_df_proc_seq_entry_get_df(s);
6351 mtlk_eeprom_cfg_t *eeprom_cfg;
6352 mtlk_handle_t hdata;
6353
6354 MTLK_UNREFERENCED_PARAM(data);
6355
6356 res = _mtlk_df_user_pull_core_data(df, MTLK_CORE_REQ_GET_EEPROM_FW, FALSE,
6357 (void**) &eeprom_cfg, &req_data_length,
6358 &hdata);
6359
6360 if(MTLK_ERR_OK == res)
6361 {
6362 MTLK_ASSERT(sizeof(mtlk_eeprom_cfg_t) == req_data_length);
6363
6364 res = mtlk_aux_seq_write(s, eeprom_cfg->eeprom_raw_data, sizeof(eeprom_cfg->eeprom_raw_data));
6365 }
6366
6367 if(MTLK_INVALID_HANDLE != hdata)
6368 {
6369 _mtlk_df_user_free_core_data(df, hdata);
6370 }
6371
6372 return _mtlk_df_mtlk_to_linux_error_code(res);
6373 }
6374
6375 static int mtlk_df_ui_reg_eepromfw_proc_cl(mtlk_df_user_t* df_user)
6376 {
6377 return mtlk_df_proc_node_add_seq_entry(PROC_EEPROMFW,
6378 df_user->slow_ctx->proc_df_node, df_user->df, _mtlk_df_ui_eepromfw);
6379 }
6380
6381 static void mtlk_df_ui_unreg_eepromfw_proc_cl(mtlk_df_user_t* df_user)
6382 {
6383 mtlk_df_proc_node_remove_entry(PROC_EEPROMFW, df_user->slow_ctx->proc_df_node);
6384 }
6385 #endif /* EEPROM_DATA_VALIDATION */
6386
6387 struct _proc_management_handlers_t
6388 {
6389 int (*on_register) (mtlk_df_user_t* df_user);
6390 void (*on_unregister)(mtlk_df_user_t* df_user);
6391 };
6392
6393 static const struct _proc_management_handlers_t
6394 _proc_management_handlers[] =
6395 {
6396 { mtlk_df_ui_reg_hw_limits, mtlk_df_ui_unreg_hw_limits },
6397 { mtlk_df_ui_reg_reg_limits, mtlk_df_ui_unreg_reg_limits },
6398 { mtlk_df_ui_reg_ant_gain, mtlk_df_ui_unreg_ant_gain },
6399 { mtlk_df_ui_reg_debug_mac_assert, mtlk_df_ui_unreg_debug_mac_assert },
6400 { mtlk_df_ui_reg_bcl_read_shram, mtlk_df_ui_unreg_bcl_read_shram },
6401 { mtlk_df_ui_reg_core_status, mtlk_df_ui_unreg_core_status },
6402 { mtlk_df_ui_reg_debug_igmp_read, mtlk_df_ui_unreg_debug_igmp_read },
6403 { mtlk_df_ui_reg_reset_stats, mtlk_df_ui_unreg_reset_stats },
6404 { mtlk_df_ui_reg_aocs_history, mtlk_df_ui_unreg_aocs_history },
6405 { mtlk_df_ui_reg_addba_status, mtlk_df_ui_unreg_addba_status},
6406 { mtlk_df_ui_reg_aocs_table, mtlk_df_ui_unreg_aocs_table },
6407 { mtlk_df_ui_reg_aocs_channels, mtlk_df_ui_unreg_aocs_channels },
6408 #ifdef BT_ACS_DEBUG
6409 { mtlk_df_ui_reg_aocs_channels_dbg, mtlk_df_ui_unreg_aocs_channels_dbg },
6410 #endif /* BT_ACS_DEBUG */
6411 { mtlk_df_ui_reg_aocs_penalties, mtlk_df_ui_unreg_aocs_penalties },
6412 #ifdef AOCS_DEBUG
6413 { mtlk_df_ui_reg_aocs_proc_cl, mtlk_df_ui_unreg_aocs_proc_cl },
6414 #endif
6415 { mtlk_df_ui_reg_debug_l2nat, mtlk_df_ui_unreg_debug_l2nat },
6416 { mtlk_df_ui_reg_l2nat_clear_table, mtlk_df_ui_unreg_l2nat_clear_table },
6417 { mtlk_df_ui_reg_debug_reordering_stats, mtlk_df_ui_unreg_debug_reordering_stats },
6418 { mtlk_df_ui_reg_ee_caps, mtlk_df_ui_unreg_ee_caps },
6419 { mtlk_df_ui_reg_debug_send_queue, mtlk_df_ui_unreg_debug_send_queue },
6420 { mtlk_df_ui_reg_debug_power_save, mtlk_df_ui_unreg_debug_power_save },
6421 { mtlk_df_ui_reg_serializer_dump, mtlk_df_ui_unreg_serializer_dump },
6422 #ifdef EEPROM_DATA_VALIDATION
6423 { mtlk_df_ui_reg_eeprom_proc_cl, mtlk_df_ui_unreg_eeprom_proc_cl },
6424 { mtlk_df_ui_reg_eepromfw_proc_cl, mtlk_df_ui_unreg_eepromfw_proc_cl },
6425 #endif /* EEPROM_DATA_VALIDATION */
6426 { mtlk_df_ui_reg_version, mtlk_df_ui_unreg_version },
6427 };
6428
6429 #ifdef MTCFG_BUS_PCI_PCIE
6430 static const struct _proc_management_handlers_t
6431 _proc_management_pci_pcie_handlers[] =
6432 {
6433 { mtlk_df_ui_reg_bcl_read_lm, mtlk_df_ui_unreg_bcl_read_lm },
6434 { mtlk_df_ui_reg_bcl_read_um, mtlk_df_ui_unreg_bcl_read_um }
6435 };
6436 #endif /* MTCFG_BUS_PCI_PCIE */
6437
6438 #ifdef MTCFG_BUS_AHB
6439 static const struct _proc_management_handlers_t
6440 _proc_management_ahb_handlers[] =
6441 {
6442 { mtlk_df_ui_reg_bcl_read_ahbum, mtlk_df_ui_unreg_bcl_read_ahbum }
6443 };
6444 #endif /* MTCFG_BUS_AHB */
6445
6446 int __MTLK_IFUNC
6447 mtlk_df_ui_iw_bcl_mac_data_get (struct net_device *dev,
6448 struct iw_request_info *info,
6449 union iwreq_data *wrqu, char *extra)
6450 {
6451 int res = 0;
6452 UMI_BCL_REQUEST req;
6453 UMI_BCL_REQUEST *req_result;
6454 mtlk_df_user_t* df_user = (mtlk_df_user_t*) netdev_priv(dev);
6455 mtlk_clpb_t *clpb = NULL;
6456
6457 ILOG3_SSD("%s: Invoked from %s (%i)", dev->name, current->comm, current->pid);
6458
6459 if (copy_from_user(&req, wrqu->data.pointer, sizeof(req)) != 0) {
6460 res = MTLK_ERR_PARAMS;
6461 goto finish;
6462 }
6463
6464 /* Send request to core */
6465 res = _mtlk_df_user_invoke_core(df_user->df, MTLK_CORE_REQ_GET_BCL_MAC_DATA,
6466 &clpb, &req, sizeof(req));
6467 res = _mtlk_df_user_process_core_retval_void(res, clpb, MTLK_CORE_REQ_GET_BCL_MAC_DATA, FALSE);
6468 if (MTLK_ERR_OK != res) {
6469 goto finish;
6470 }
6471
6472 /* Handle result */
6473 req_result = mtlk_clpb_enum_get_next(clpb, NULL);
6474
6475 if (NULL == req_result) {
6476 res = MTLK_ERR_UNKNOWN;
6477 } else if (copy_to_user(wrqu->data.pointer, req_result, sizeof(*req_result)) != 0) {
6478 res = MTLK_ERR_UNKNOWN;
6479 }
6480
6481 mtlk_clpb_delete(clpb);
6482 finish:
6483 return _mtlk_df_mtlk_to_linux_error_code(res);
6484 }
6485
6486 int __MTLK_IFUNC
6487 mtlk_df_ui_iw_bcl_mac_data_set (struct net_device *dev,
6488 struct iw_request_info *info,
6489 union iwreq_data *wrqu, char *extra)
6490 {
6491 int res = 0;
6492 UMI_BCL_REQUEST req;
6493 mtlk_df_user_t* df_user = (mtlk_df_user_t*) netdev_priv(dev);
6494 mtlk_clpb_t *clpb = NULL;
6495
6496 ILOG3_SSD("%s: Invoked from %s (%i)", dev->name, current->comm, current->pid);
6497
6498 if (copy_from_user(&req, wrqu->data.pointer, sizeof(req)) != 0) {
6499 res = MTLK_ERR_PARAMS;
6500 goto finish;
6501 }
6502
6503 /* Send request to core */
6504 res = _mtlk_df_user_invoke_core(df_user->df, MTLK_CORE_REQ_SET_BCL_MAC_DATA,
6505 &clpb, &req, sizeof(req));
6506 res = _mtlk_df_user_process_core_retval_void(res, clpb, MTLK_CORE_REQ_SET_BCL_MAC_DATA, TRUE);
6507
6508 finish:
6509 return _mtlk_df_mtlk_to_linux_error_code(res);
6510 }
6511
6512 int __MTLK_IFUNC
6513 mtlk_df_ui_linux_ioctl_stop_lower_mac (struct net_device *dev,
6514 struct iw_request_info *info,
6515 union iwreq_data *wrqu,
6516 char *extra)
6517 {
6518 int res = 0;
6519 mtlk_clpb_t *clpb = NULL;
6520 mtlk_df_user_t* df_user = (mtlk_df_user_t*) netdev_priv(dev);
6521
6522 ILOG3_SSD("%s: Invoked from %s (%i)", dev->name, current->comm, current->pid);
6523
6524 res = _mtlk_df_user_invoke_core(df_user->df, MTLK_CORE_REQ_STOP_LM, &clpb, NULL, 0);
6525 res = _mtlk_df_user_process_core_retval_void(res, clpb, MTLK_CORE_REQ_STOP_LM, TRUE);
6526
6527 return _mtlk_df_mtlk_to_linux_error_code(res);
6528 }
6529
6530 int __MTLK_IFUNC
6531 mtlk_df_ui_linux_ioctl_mac_calibrate (struct net_device *dev,
6532 struct iw_request_info *info,
6533 union iwreq_data *wrqu,
6534 char *extra)
6535 {
6536 int res = 0;
6537 mtlk_clpb_t *clpb = NULL;
6538 mtlk_df_user_t* df_user = (mtlk_df_user_t*) netdev_priv(dev);
6539
6540 ILOG3_SSD("%s: Invoked from %s (%i)", dev->name, current->comm, current->pid);
6541
6542 res = _mtlk_df_user_invoke_core(df_user->df, MTLK_CORE_REQ_MAC_CALIBRATE, &clpb, NULL, 0);
6543 res = _mtlk_df_user_process_core_retval_void(res, clpb, MTLK_CORE_REQ_MAC_CALIBRATE, TRUE);
6544
6545 return _mtlk_df_mtlk_to_linux_error_code(res);
6546 }
6547
6548 int __MTLK_IFUNC
6549 mtlk_df_ui_linux_ioctl_iw_generic (struct net_device *dev,
6550 struct iw_request_info *info,
6551 union iwreq_data *wrqu, char *extra)
6552 {
6553 int res = MTLK_ERR_OK;
6554 UMI_GENERIC_MAC_REQUEST req;
6555 UMI_GENERIC_MAC_REQUEST *preq = NULL;
6556 uint32 preq_size = 0;
6557 mtlk_df_user_t* df_user = (mtlk_df_user_t*) netdev_priv(dev);
6558 mtlk_clpb_t *clpb = NULL;
6559
6560 ILOG3_SSD("%s: Invoked from %s (%i)", dev->name, current->comm, current->pid);
6561
6562 if (0 != copy_from_user(&req, wrqu->data.pointer, sizeof(req))) {
6563 res = MTLK_ERR_PARAMS;
6564 goto finish;
6565 }
6566
6567 res = _mtlk_df_user_invoke_core(df_user->df, MTLK_CORE_REQ_GET_IW_GENERIC,
6568 &clpb, &req, sizeof(req));
6569 res = _mtlk_df_user_process_core_retval_void(res, clpb, MTLK_CORE_REQ_GET_IW_GENERIC, FALSE);
6570
6571 if (MTLK_ERR_OK != res) {
6572 goto finish;
6573 }
6574
6575 preq = mtlk_clpb_enum_get_next(clpb, &preq_size);
6576
6577 MTLK_ASSERT(NULL != preq);
6578 MTLK_ASSERT(sizeof(*preq) == preq_size);
6579
6580 ILOG2_DDDDDD("Generic opcode %ux, %ud dwords, action 0x%ux results 0x%ux 0x%ux 0x%ux\n",
6581 (unsigned int)preq->opcode,
6582 (unsigned int)preq->size,
6583 (unsigned int)preq->action,
6584 (unsigned int)preq->res0,
6585 (unsigned int)preq->res1,
6586 (unsigned int)preq->res2);
6587
6588 if (0 != copy_to_user(wrqu->data.pointer, preq, sizeof(*preq))) {
6589 ELOG_V("Unable to copy iw generic data");
6590 res = MTLK_ERR_PARAMS;
6591 }
6592
6593 mtlk_clpb_delete(clpb);
6594 finish:
6595 return _mtlk_df_mtlk_to_linux_error_code(res);
6596 }
6597
6598 int __MTLK_IFUNC
6599 mtlk_df_ui_linux_ioctl_ctrl_mac_gpio (struct net_device *dev,
6600 struct iw_request_info *info,
6601 union iwreq_data *wrqu,
6602 char *extra)
6603 {
6604 int res = 0;
6605 mtlk_df_user_t* df_user = (mtlk_df_user_t*) netdev_priv(dev);
6606 mtlk_clpb_t *clpb = NULL;
6607 int *ptr_extra = (int *)extra;
6608 UMI_SET_LED leds_status;
6609
6610 ILOG3_SSD("%s: Invoked from %s (%i)", dev->name, current->comm, current->pid);
6611 ILOG3_DD("ptr_extra = 0x%x, ptr_extra1 = 0x%x", ptr_extra[0], ptr_extra[1]);
6612
6613 memset(&leds_status, 0, sizeof(leds_status));
6614
6615 leds_status.u8BasebLed = (uint8)(ptr_extra[0] & 0xFF);
6616 leds_status.u8LedStatus = (uint8)(ptr_extra[1] & 0xFF);
6617
6618 res = _mtlk_df_user_invoke_core(df_user->df, MTLK_CORE_REQ_CTRL_MAC_GPIO,
6619 &clpb, &leds_status, sizeof(leds_status));
6620 res = _mtlk_df_user_process_core_retval_void(res, clpb, MTLK_CORE_REQ_CTRL_MAC_GPIO, TRUE);
6621
6622 return _mtlk_df_mtlk_to_linux_error_code(res);
6623 }
6624
6625 /*
6626 * Due to lack of synchronization between fw-to-driver and driver-to-user
6627 * Network Mode should be converted on driver-to-user border.
6628 */
6629 uint8 __MTLK_IFUNC
6630 _net_mode_ingress_filter (uint8 ingress_net_mode)
6631 {
6632 switch (ingress_net_mode) {
6633 case NETWORK_MODE_11A:
6634 return NETWORK_11A_ONLY;
6635 case NETWORK_MODE_11ABG:
6636 return NETWORK_11ABG_MIXED;
6637 case NETWORK_MODE_11ABGN:
6638 return NETWORK_11ABGN_MIXED;
6639 case NETWORK_MODE_11AN:
6640 return NETWORK_11AN_MIXED;
6641 case NETWORK_MODE_11B:
6642 return NETWORK_11B_ONLY;
6643 case NETWORK_MODE_11BG:
6644 return NETWORK_11BG_MIXED;
6645 case NETWORK_MODE_11BGN:
6646 return NETWORK_11BGN_MIXED;
6647 case NETWORK_MODE_11GN:
6648 return NETWORK_11GN_MIXED;
6649 case NETWORK_MODE_11G:
6650 return NETWORK_11G_ONLY;
6651 case NETWORK_MODE_11N2:
6652 return NETWORK_11N_2_4_ONLY;
6653 case NETWORK_MODE_11N5:
6654 return NETWORK_11N_5_ONLY;
6655 default:
6656 break;
6657 }
6658
6659 return NETWORK_NONE;
6660 }
6661
6662 uint8 __MTLK_IFUNC
6663 _net_mode_egress_filter (uint8 egress_net_mode)
6664 {
6665 switch (egress_net_mode) {
6666 case NETWORK_11ABG_MIXED:
6667 return NETWORK_MODE_11ABG;
6668 case NETWORK_11ABGN_MIXED:
6669 return NETWORK_MODE_11ABGN;
6670 case NETWORK_11B_ONLY:
6671 return NETWORK_MODE_11B;
6672 case NETWORK_11G_ONLY:
6673 return NETWORK_MODE_11G;
6674 case NETWORK_11N_2_4_ONLY:
6675 return NETWORK_MODE_11N2;
6676 case NETWORK_11BG_MIXED:
6677 return NETWORK_MODE_11BG;
6678 case NETWORK_11GN_MIXED:
6679 return NETWORK_MODE_11GN;
6680 case NETWORK_11BGN_MIXED:
6681 return NETWORK_MODE_11BGN;
6682 case NETWORK_11A_ONLY:
6683 return NETWORK_MODE_11A;
6684 case NETWORK_11N_5_ONLY:
6685 return NETWORK_MODE_11N5;
6686 case NETWORK_11AN_MIXED:
6687 return NETWORK_MODE_11AN;
6688 default:
6689 break;
6690 }
6691
6692 ASSERT(0);
6693
6694 return 0; /* just fake cc */
6695 }
6696
6697 int __MTLK_IFUNC
6698 mtlk_df_ui_linux_ioctl_getname (struct net_device *dev,
6699 struct iw_request_info *info,
6700 char *name,
6701 char *extra)
6702 {
6703 uint32 net_mode = NUM_OF_NETWORK_MODES;
6704 int res = MTLK_ERR_NOT_HANDLED;
6705 mtlk_df_user_t *df_user = (mtlk_df_user_t*)netdev_priv(dev);
6706
6707 ILOG3_SSD("%s: Invoked from %s (%i)", dev->name, current->comm, current->pid);
6708
6709 res = _mtlk_df_user_iwpriv_get_core_param(df_user, PRM_ID_NETWORK_MODE, (char*)&net_mode, NULL);
6710 if (MTLK_ERR_OK == res) {
6711 strcpy(name, net_mode_to_string(_net_mode_ingress_filter(net_mode)));
6712 }
6713
6714 return _mtlk_df_mtlk_to_linux_error_code(res);
6715 }
6716
6717 int __MTLK_IFUNC
6718 mtlk_df_ui_linux_ioctl_getmode (struct net_device *dev,
6719 struct iw_request_info *info,
6720 u32 *mode,
6721 char *extra)
6722 {
6723 mtlk_df_user_t* df_user = (mtlk_df_user_t*)netdev_priv(dev);
6724
6725 ILOG3_SSD("%s: Invoked from %s (%i)", dev->name, current->comm, current->pid);
6726
6727 if (mtlk_df_is_ap(df_user->df))
6728 *mode = IW_MODE_MASTER;
6729 else
6730 *mode = IW_MODE_INFRA;
6731
6732 return 0;
6733 }
6734
6735 int __MTLK_IFUNC
6736 mtlk_df_ui_linux_ioctl_setnick (struct net_device *dev,
6737 struct iw_request_info *info,
6738 union iwreq_data *wrqu,
6739 char *extra)
6740 {
6741 int res = MTLK_ERR_OK;
6742 mtlk_df_user_t *df_user = (mtlk_df_user_t*)netdev_priv(dev);
6743
6744 ILOG3_SSD("%s: Invoked from %s (%i)", dev->name, current->comm, current->pid);
6745
6746 if (0 == wrqu->essid.length) {
6747 goto finish;
6748 }
6749
6750 if (MTLK_ESSID_MAX_SIZE < wrqu->essid.length) {
6751 res = MTLK_ERR_PARAMS;
6752 goto finish;
6753 }
6754
6755 /* WARNING: Take care about kernel and WE version compatibility:
6756 * the NickName can be passed without null terminated character*/
6757 res = _mtlk_df_user_iwpriv_set_core_param(df_user, PRM_ID_NICK_NAME, extra, &wrqu->essid.length);
6758
6759 finish:
6760 return _mtlk_df_mtlk_to_linux_error_code(res);
6761 }
6762
6763 int __MTLK_IFUNC
6764 mtlk_df_ui_linux_ioctl_getnick (struct net_device *dev,
6765 struct iw_request_info *info,
6766 union iwreq_data *wrqu,
6767 char *extra)
6768 {
6769 int res = MTLK_ERR_PARAMS;
6770 mtlk_df_user_t *df_user = (mtlk_df_user_t*)netdev_priv(dev);
6771
6772 ILOG3_SSD("%s: Invoked from %s (%i)", dev->name, current->comm, current->pid);
6773
6774 if ((NULL == extra) || (0 == wrqu->essid.length)) {
6775 goto finish;
6776 }
6777
6778 res = _mtlk_df_user_iwpriv_get_core_param(df_user, PRM_ID_NICK_NAME, extra, &wrqu->essid.length);
6779
6780 finish:
6781 return _mtlk_df_mtlk_to_linux_error_code(res);
6782 }
6783
6784 int __MTLK_IFUNC
6785 mtlk_df_ui_linux_ioctl_setessid (struct net_device *dev,
6786 struct iw_request_info *info,
6787 union iwreq_data *wrqu,
6788 char *extra)
6789 {
6790 int res = MTLK_ERR_OK;
6791 mtlk_df_user_t *df_user = (mtlk_df_user_t*)netdev_priv(dev);
6792
6793 ILOG3_SSD("%s: Invoked from %s (%i)", dev->name, current->comm, current->pid);
6794
6795 if (0 == wrqu->essid.length) {
6796 goto finish;
6797 }
6798
6799 if (MTLK_ESSID_MAX_SIZE < wrqu->essid.length) {
6800 res = MTLK_ERR_PARAMS;
6801 goto finish;
6802 }
6803
6804 /* WARNING: Take care about kernel and WE version compatibility:
6805 * the ESSID can be passed without null terminated character*/
6806 res = _mtlk_df_user_iwpriv_set_core_param(df_user, PRM_ID_ESSID, extra, &wrqu->essid.length);
6807
6808 finish:
6809 return _mtlk_df_mtlk_to_linux_error_code(res);
6810 }
6811
6812 int __MTLK_IFUNC
6813 mtlk_df_ui_linux_ioctl_getessid (struct net_device *dev,
6814 struct iw_request_info *info,
6815 union iwreq_data *wrqu,
6816 char *extra)
6817 {
6818 int res = MTLK_ERR_PARAMS;
6819 mtlk_df_user_t *df_user = (mtlk_df_user_t*)netdev_priv(dev);
6820
6821 ILOG3_SSD("%s: Invoked from %s (%i)", dev->name, current->comm, current->pid);
6822
6823 if ((NULL == extra) || (0 == wrqu->essid.length)) {
6824 goto finish;
6825 }
6826
6827 res = _mtlk_df_user_iwpriv_get_core_param(df_user, PRM_ID_ESSID, extra, &wrqu->essid.length);
6828
6829 if (MTLK_ERR_OK == res) {
6830 wrqu->data.flags = 1;
6831 }
6832
6833 finish:
6834 return _mtlk_df_mtlk_to_linux_error_code(res);
6835 }
6836
6837 int __MTLK_IFUNC
6838 mtlk_df_ui_linux_ioctl_getap (struct net_device *dev,
6839 struct iw_request_info *info,
6840 union iwreq_data *wrqu,
6841 char *extra)
6842 {
6843 int res = MTLK_ERR_PARAMS;
6844 mtlk_df_user_t *df_user = (mtlk_df_user_t*)netdev_priv(dev);
6845
6846 ILOG3_SSD("%s: Invoked from %s (%i)", dev->name, current->comm, current->pid);
6847
6848 if (NULL == wrqu) {
6849 goto finish;
6850 }
6851
6852 if (mtlk_df_is_ap(df_user->df)) {
6853 res = mtlk_df_ui_linux_ioctl_get_mac_addr(dev, info, wrqu, extra);
6854 } else {
6855 /* STA: Return connected BSSID */
6856 uint16 len;
6857 res = _mtlk_df_user_iwpriv_get_core_param(df_user, PRM_ID_BSSID, wrqu->addr.sa_data, &len);
6858 MTLK_ASSERT(ETH_ALEN == len);
6859 }
6860
6861 if (MTLK_ERR_OK == res) {
6862 wrqu->addr.sa_family = ARPHRD_ETHER;
6863 }
6864
6865 finish:
6866 return _mtlk_df_mtlk_to_linux_error_code(res);
6867 }
6868
6869 int __MTLK_IFUNC
6870 mtlk_df_ui_linux_ioctl_getfreq (struct net_device *dev,
6871 struct iw_request_info *info,
6872 union iwreq_data *wrqu,
6873 char *extra)
6874 {
6875 int res = MTLK_ERR_NOT_HANDLED;
6876 uint32 channel = 0;
6877 mtlk_df_user_t *df_user = (mtlk_df_user_t*)netdev_priv(dev);
6878
6879 ILOG3_SSD("%s: Invoked from %s (%i)", dev->name, current->comm, current->pid);
6880
6881 res = _mtlk_df_user_iwpriv_get_core_param(df_user, PRM_ID_CHANNEL, (char*)&channel, NULL);
6882 if (MTLK_ERR_OK != res) {
6883 res = MTLK_ERR_UNKNOWN;
6884 goto finish;
6885 }
6886
6887 if (0 == channel) {
6888 ILOG2_S("%s: Channel autoselection enabled", dev->name);
6889 wrqu->freq.e = 0;
6890 wrqu->freq.m = 0;
6891 wrqu->freq.i = 0;
6892 #if WIRELESS_EXT >= 17
6893 wrqu->freq.flags = IW_FREQ_AUTO;
6894 #endif
6895 } else {
6896 ILOG2_SD("%s: Value of channel is %i", dev->name, channel);
6897 wrqu->freq.e = 0;
6898 wrqu->freq.m = channel;
6899 wrqu->freq.i = 0;
6900 #if WIRELESS_EXT >= 17
6901 wrqu->freq.flags = IW_FREQ_FIXED;
6902 #endif
6903 }
6904
6905 finish:
6906 return _mtlk_df_mtlk_to_linux_error_code(res);
6907 }
6908
6909 int __MTLK_IFUNC
6910 mtlk_df_ui_linux_ioctl_setfreq (struct net_device *dev,
6911 struct iw_request_info *info,
6912 union iwreq_data *wrqu,
6913 char *extra)
6914 {
6915 int res = MTLK_ERR_PARAMS;
6916 uint32 channel = 0;
6917 mtlk_df_user_t *df_user = (mtlk_df_user_t*)netdev_priv(dev);
6918
6919 ILOG3_SSD("%s: Invoked from %s (%i)", dev->name, current->comm, current->pid);
6920
6921 if (!mtlk_df_is_ap(df_user->df)) {
6922 ILOG2_S("%s: Channel selection unsupported on STA.", dev->name);
6923 res = MTLK_ERR_NOT_SUPPORTED;
6924 goto finish;
6925 }
6926
6927 /*
6928 * To enable AOCS
6929 * with WE < 17 use 'iwconfig <IF> channel 0'
6930 * with WE >= 17 also can use 'iwconfig <IF> channel auto'
6931 */
6932
6933 #if WIRELESS_EXT < 17
6934 if ((wrqu->freq.e == 0) && (wrqu->freq.m == 0)) {
6935 #else
6936 if ( ((wrqu->freq.e == 0) && (wrqu->freq.m == 0)) ||
6937 ((IW_FREQ_FIXED & wrqu->freq.flags) == 0) ) {
6938 #endif /* WIRELESS_EXT < 17 */
6939 channel = 0;
6940
6941 } else if (wrqu->freq.e == 0) {
6942 channel = wrqu->freq.m;
6943
6944 } else {
6945 res = MTLK_ERR_PARAMS;
6946 goto finish;
6947 }
6948
6949 res = _mtlk_df_user_iwpriv_set_core_param(df_user, PRM_ID_CHANNEL, (char*)&channel, NULL);
6950
6951 finish:
6952 return _mtlk_df_mtlk_to_linux_error_code(res);
6953 }
6954
6955 int __MTLK_IFUNC
6956 mtlk_df_ui_linux_ioctl_setrtsthr (struct net_device *dev,
6957 struct iw_request_info *info,
6958 union iwreq_data *wrqu,
6959 char *extra)
6960 {
6961 int res = MTLK_ERR_PARAMS;
6962 int32 value;
6963 mtlk_df_user_t *df_user = (mtlk_df_user_t*)netdev_priv(dev);
6964
6965 ILOG3_SSD("%s: Invoked from %s (%i)", dev->name, current->comm, current->pid);
6966
6967 if (wrqu->rts.value < 0) {
6968 res = MTLK_ERR_PARAMS;
6969 goto finish;
6970 }
6971
6972 value = (wrqu->rts.value < _DF_RTS_THRESHOLD_MIN ? _DF_RTS_THRESHOLD_MIN : wrqu->rts.value);
6973 ILOG2_D("Set RTS/CTS threshold to value %i", value);
6974
6975 res = _mtlk_df_user_iwpriv_set_core_param(df_user, MIB_RTS_THRESHOLD, (char*)&value, NULL);
6976
6977 finish:
6978 return _mtlk_df_mtlk_to_linux_error_code(res);
6979 }
6980
6981 int __MTLK_IFUNC
6982 mtlk_df_ui_linux_ioctl_getrtsthr (struct net_device *dev,
6983 struct iw_request_info *info,
6984 union iwreq_data *wrqu,
6985 char *extra)
6986 {
6987 int res = MTLK_ERR_PARAMS;
6988 int32 value;
6989 mtlk_df_user_t *df_user = (mtlk_df_user_t*)netdev_priv(dev);
6990
6991 ILOG3_SSD("%s: Invoked from %s (%i)", dev->name, current->comm, current->pid);
6992
6993 res = _mtlk_df_user_iwpriv_get_core_param(df_user, MIB_RTS_THRESHOLD, (char*)&value, NULL);
6994 if (MTLK_ERR_OK == res) {
6995 wrqu->rts.value = value;
6996 wrqu->rts.fixed = 1;
6997 wrqu->rts.disabled = 0;
6998 wrqu->rts.flags = 0;
6999 }
7000
7001 return _mtlk_df_mtlk_to_linux_error_code(res);
7002 }
7003
7004 int __MTLK_IFUNC
7005 mtlk_df_ui_linux_ioctl_settxpower (struct net_device *dev,
7006 struct iw_request_info *info,
7007 union iwreq_data *wrqu,
7008 char *extra)
7009 {
7010 int res = MTLK_ERR_PARAMS;
7011 int32 value;
7012 mtlk_df_user_t *df_user = (mtlk_df_user_t*)netdev_priv(dev);
7013
7014 ILOG3_SSD("%s: Invoked from %s (%i)", dev->name, current->comm, current->pid);
7015
7016 if (wrqu->txpower.value > 0) {
7017 ILOG2_D("Set TxPower to specified value %i mW", wrqu->txpower.value);
7018 value = wrqu->txpower.value;
7019 } else {
7020 ILOG2_V("Enable TxPower auto-calculation");
7021 value = 0; /* Auto */
7022 }
7023
7024 res = _mtlk_df_user_iwpriv_set_core_param(df_user, MIB_TX_POWER, (char*)&value, NULL);
7025
7026 return _mtlk_df_mtlk_to_linux_error_code(res);
7027 }
7028
7029 int __MTLK_IFUNC
7030 mtlk_df_ui_linux_ioctl_gettxpower (struct net_device *dev,
7031 struct iw_request_info *info,
7032 union iwreq_data *wrqu,
7033 char *extra)
7034 {
7035
7036 int res = MTLK_ERR_OK;
7037 int32 value;
7038 mtlk_df_user_t *df_user = (mtlk_df_user_t*)netdev_priv(dev);
7039
7040 ILOG3_SSD("%s: Invoked from %s (%i)", dev->name, current->comm, current->pid);
7041
7042 if (netif_running(dev)) {
7043
7044 res = _mtlk_df_user_iwpriv_get_core_param(df_user, MIB_TX_POWER, (char*)&value, NULL);
7045 if (MTLK_ERR_OK == res) {
7046
7047 wrqu->txpower.value = value;
7048 wrqu->txpower.fixed = 1;
7049 wrqu->txpower.flags = IW_TXPOW_DBM;
7050 wrqu->txpower.disabled = 0;
7051 }
7052 }
7053 else{
7054
7055 wrqu->txpower.disabled = 1;
7056 }
7057
7058 return _mtlk_df_mtlk_to_linux_error_code(res);
7059 }
7060
7061 int __MTLK_IFUNC
7062 mtlk_df_ui_linux_ioctl_setretry (struct net_device *dev,
7063 struct iw_request_info *info,
7064 union iwreq_data *wrqu,
7065 char *extra)
7066 {
7067 int res = MTLK_ERR_PARAMS;
7068 int32 value;
7069 uint16 obj_id;
7070 mtlk_df_user_t *df_user = (mtlk_df_user_t*)netdev_priv(dev);
7071
7072 ILOG3_SSD("%s: Invoked from %s (%i)", dev->name, current->comm, current->pid);
7073
7074 value = wrqu->retry.value;
7075
7076 /* Determine requested parameter */
7077 switch (wrqu->retry.flags) {
7078 case IW_RETRY_LIMIT:
7079 case IW_RETRY_LIMIT | IW_RETRY_MIN:
7080 obj_id = MIB_SHORT_RETRY_LIMIT;
7081 break;
7082 case IW_RETRY_LIMIT | IW_RETRY_MAX:
7083 obj_id = MIB_LONG_RETRY_LIMIT;
7084 break;
7085 case IW_RETRY_LIFETIME:
7086 case IW_RETRY_LIFETIME | IW_RETRY_MIN:
7087 case IW_RETRY_LIFETIME | IW_RETRY_MAX:
7088 /* WT send to us value in microseconds, but MAC accepts miliseconds */
7089 if (value < 1000) {
7090 goto finish;
7091 }
7092 obj_id = MIB_TX_MSDU_LIFETIME;
7093 value = value/1000;
7094 break;
7095 default:
7096 WLOG_D("Unknown parameter type: 0x%04x", wrqu->retry.flags);
7097 goto finish;
7098 }
7099
7100 if (value >= 0) {
7101 ILOG2_DD("Set Retry limits (lifetime) to value %i %i ", value, wrqu->retry.value);
7102 res = _mtlk_df_user_iwpriv_set_core_param(df_user, obj_id, (char*)&value, NULL);
7103 }
7104
7105 finish:
7106 return _mtlk_df_mtlk_to_linux_error_code(res);
7107 }
7108
7109 int __MTLK_IFUNC
7110 mtlk_df_ui_linux_ioctl_getretry (struct net_device *dev,
7111 struct iw_request_info *info,
7112 union iwreq_data *wrqu,
7113 char *extra)
7114 {
7115 int res = MTLK_ERR_PARAMS;
7116 uint16 obj_id;
7117 int scale = 1;
7118 int32 value;
7119 mtlk_df_user_t *df_user = (mtlk_df_user_t*)netdev_priv(dev);
7120
7121 ILOG3_SSD("%s: Invoked from %s (%i)", dev->name, current->comm, current->pid);
7122
7123 /* Determine requested parameter */
7124 switch (wrqu->retry.flags) {
7125 case 0:
7126 case IW_RETRY_LIFETIME:
7127 case IW_RETRY_LIFETIME | IW_RETRY_MIN:
7128 case IW_RETRY_LIFETIME | IW_RETRY_MAX:
7129 obj_id = MIB_TX_MSDU_LIFETIME;
7130 /* WT expects value in microseconds, but MAC work with miliseconds */
7131 scale = 1000;
7132 wrqu->retry.flags = IW_RETRY_LIFETIME;
7133 break;
7134 case IW_RETRY_LIMIT:
7135 case IW_RETRY_LIMIT | IW_RETRY_MIN:
7136 obj_id = MIB_SHORT_RETRY_LIMIT;
7137 wrqu->retry.flags = IW_RETRY_LIMIT | IW_RETRY_MIN;
7138 break;
7139 case IW_RETRY_LIMIT | IW_RETRY_MAX:
7140 obj_id = MIB_LONG_RETRY_LIMIT;
7141 wrqu->retry.flags = IW_RETRY_LIMIT | IW_RETRY_MAX;
7142 break;
7143 default:
7144 WLOG_D("Unknown parameter type: 0x%04x", wrqu->retry.flags);
7145 goto finish;
7146 }
7147
7148 res = _mtlk_df_user_iwpriv_get_core_param(df_user, obj_id, (char*)&value, NULL);
7149 if (MTLK_ERR_OK == res) {
7150 wrqu->retry.value = scale*value;
7151 wrqu->retry.fixed = 1;
7152 wrqu->retry.disabled = 0;
7153 }
7154
7155 finish:
7156 return _mtlk_df_mtlk_to_linux_error_code(res);
7157 }
7158
7159 int __MTLK_IFUNC
7160 mtlk_df_ui_linux_ioctl_getrange (struct net_device *dev,
7161 struct iw_request_info *info,
7162 union iwreq_data *wrqu,
7163 char *extra)
7164 {
7165 int res = MTLK_ERR_NOT_HANDLED;
7166 mtlk_df_user_t* df_user = (mtlk_df_user_t*)netdev_priv(dev);
7167 mtlk_core_ui_range_info_t *range_info = NULL;
7168 mtlk_handle_t hcore_data;
7169 struct iw_range *range = (struct iw_range *) extra;
7170 int idx;
7171
7172 ILOG3_SSD("%s: Invoked from %s (%i)", dev->name, current->comm, current->pid);
7173
7174 res= _mtlk_df_user_pull_core_data(df_user->df, MTLK_CORE_REQ_GET_RANGE_INFO, TRUE, (void**) &range_info, NULL, &hcore_data);
7175
7176 if(MTLK_ERR_OK != res) {
7177 goto finish;
7178 }
7179
7180 /** Fill output data **/
7181 wrqu->data.length = sizeof(struct iw_range);
7182 /* In kernes < 2.6.22 range is not zeroed */
7183 memset(range, 0, sizeof(struct iw_range));
7184
7185 range->we_version_compiled = WIRELESS_EXT;
7186
7187 /* kernel MUST be patched up to this version if security is needed */
7188 if (WIRELESS_EXT < 18)
7189 range->we_version_compiled = 18;
7190
7191 range->we_version_source = 18; /* what version we support */
7192
7193 /* WEP stuff */
7194 range->num_encoding_sizes = 2;
7195 range->encoding_size[0] = 5; /* 40 bit */
7196 range->encoding_size[1] = 13; /* 104 bit */
7197 range->max_encoding_tokens = 4;
7198
7199 /* TxPower stuff */
7200 range->txpower_capa = IW_TXPOW_DBM;
7201
7202 /* Maximum quality */
7203 range->max_qual.qual = 5;
7204
7205 /** Fill output bitrates data **/
7206 range->num_bitrates = 0;
7207 if (IW_MAX_BITRATES < range_info->num_bitrates) {
7208 res = MTLK_ERR_UNKNOWN;
7209 goto error_delete_data;
7210 } else if (0 < range_info->num_bitrates) {
7211 range->num_bitrates = range_info->num_bitrates;
7212 /* Array of bitrates is sorted and consist of only unique elements */
7213 for (idx = 0; idx <= range_info->num_bitrates; idx++) {
7214 range->bitrate[idx] = range_info->bitrates[idx];
7215 }
7216 }
7217
7218 /* Fill output channels and frequencies data */
7219 range->num_frequency = 0;
7220 range->num_channels = 0;
7221
7222 if (0 < range_info->num_channels) {
7223 if (IW_MAX_FREQUENCIES < range_info->num_channels) {
7224 range_info->num_channels = IW_MAX_FREQUENCIES;
7225 }
7226
7227 for(idx = 0; idx < range_info->num_channels; idx++) {
7228 range->freq[idx].i = range_info->channels[idx];
7229 range->freq[idx].m = channel_to_frequency(range_info->channels[idx]);
7230 range->freq[idx].e = 6;
7231 //range->freq[i].flags = 0; /* fixed/auto (not used by iwlist currently)*/
7232 range->num_frequency++;
7233 }
7234 }
7235
7236 range->num_channels = range->num_frequency;
7237
7238 error_delete_data:
7239 _mtlk_df_user_free_core_data(df_user->df, hcore_data);
7240 finish:
7241 return _mtlk_df_mtlk_to_linux_error_code(res);
7242 }
7243
7244 int __MTLK_IFUNC
7245 mtlk_df_ui_linux_ioctl_getaplist (struct net_device *dev,
7246 struct iw_request_info *info,
7247 union iwreq_data *wrqu,
7248 char *extra)
7249 {
7250 int res = MTLK_ERR_NOT_HANDLED;
7251 mtlk_df_user_t *df_user = (mtlk_df_user_t*)netdev_priv(dev);
7252 mtlk_clpb_t *clpb = NULL;
7253 struct sockaddr *list = (struct sockaddr*)extra;
7254 int idx = 0;
7255 uint32 size;
7256 mtlk_stadb_stat_t *stadb_stat;
7257 mtlk_core_ui_get_stadb_status_req_t get_stadb_status_req;
7258
7259 ILOG3_SSD("%s: Invoked from %s (%i)", dev->name, current->comm, current->pid);
7260
7261 if (!mtlk_df_is_ap(df_user->df)) {
7262 /* This is STA - do not print anything */
7263 res = MTLK_ERR_NOT_SUPPORTED;
7264 wrqu->data.length = 0;
7265 goto err_ret;
7266 }
7267
7268 get_stadb_status_req.get_hostdb = FALSE;
7269 get_stadb_status_req.use_cipher = TRUE;
7270 res = _mtlk_df_user_invoke_core(df_user->df, MTLK_CORE_REQ_GET_STADB_STATUS,
7271 &clpb, &get_stadb_status_req, sizeof(get_stadb_status_req));
7272 res = _mtlk_df_user_process_core_retval_void(res, clpb, MTLK_CORE_REQ_GET_STADB_STATUS, FALSE);
7273 if(MTLK_ERR_OK != res) {
7274 goto err_ret;
7275 }
7276
7277 /* Print list of connected STAs */
7278 while (NULL != (stadb_stat = mtlk_clpb_enum_get_next(clpb, &size))) {
7279 if ((sizeof(*stadb_stat) != size) || (STAT_ID_STADB != stadb_stat->type)) {
7280 res = MTLK_ERR_UNKNOWN;
7281 goto delete_clpb;
7282 }
7283
7284 if (idx == wrqu->data.length) break;
7285
7286 list[idx].sa_family = ARPHRD_ETHER;
7287 memcpy(list[idx].sa_data, stadb_stat->u.general_stat.addr.au8Addr, ETH_ALEN);
7288 idx++;
7289 }
7290
7291 wrqu->data.length = idx;
7292
7293 delete_clpb:
7294 mtlk_clpb_delete(clpb);
7295 err_ret:
7296 return _mtlk_df_mtlk_to_linux_error_code(res);
7297 }
7298
7299 int __MTLK_IFUNC
7300 mtlk_df_ui_linux_ioctl_get_connection_info (struct net_device *dev,
7301 struct iw_request_info *info,
7302 union iwreq_data *wrqu,
7303 char *extra)
7304 {
7305 int res = MTLK_ERR_NOT_HANDLED;
7306 mtlk_df_user_t *df_user = (mtlk_df_user_t*)netdev_priv(dev);
7307 mtlk_stadb_stat_t *stadb_stat = NULL;
7308 mtlk_gen_core_cfg_t *core_cfg = NULL;
7309 uint32 size;
7310 char *str = extra;
7311 unsigned len = 0;
7312
7313 ILOG3_SSD("%s: Invoked from %s (%i)", dev->name, current->comm, current->pid);
7314
7315 /* in case we don't add anything to the string we want an empty string */
7316 *str = '\0';
7317
7318 if (!mtlk_df_is_ap(df_user->df)) {
7319 /* This is STA */
7320 uint16 channel = 0;
7321 uint8 bonding = 0;
7322 uint8 frequency_band_cur = 0;
7323 uint8 spectrum_mode = 0;
7324 mtlk_handle_t hcore_data;
7325
7326 res = _mtlk_df_user_pull_core_data(df_user->df, MTLK_CORE_REQ_GET_CORE_CFG, FALSE, (void**) &core_cfg, NULL, &hcore_data);
7327
7328 MTLK_CFG_GET_ITEM(core_cfg, channel, channel);
7329 MTLK_CFG_GET_ITEM(core_cfg, bonding, bonding);
7330 MTLK_CFG_GET_ITEM(core_cfg, frequency_band_cur, frequency_band_cur);
7331 MTLK_CFG_GET_ITEM(core_cfg, spectrum_mode, spectrum_mode);
7332
7333 len += snprintf(str, TEXT_SIZE, "%sGHz,%d,%dMHz",
7334 MTLK_HW_BAND_5_2_GHZ == frequency_band_cur ? "5.2" : "2.4",
7335 channel,
7336 spectrum_mode == SPECTRUM_20MHZ ? 20 : 40);
7337
7338 if (spectrum_mode == SPECTRUM_40MHZ)
7339 len += snprintf(str + len, TEXT_SIZE - len, ALTERNATE_LOWER == bonding ? ",Lower" : ",Upper");
7340
7341 _mtlk_df_user_free_core_data(df_user->df, hcore_data);
7342 } else { /* This is AP */
7343 mtlk_clpb_t *clpb = NULL;
7344 mtlk_core_ui_get_stadb_status_req_t get_stadb_status_req;
7345
7346 get_stadb_status_req.get_hostdb = FALSE;
7347 get_stadb_status_req.use_cipher = TRUE;
7348 res = _mtlk_df_user_invoke_core(df_user->df, MTLK_CORE_REQ_GET_STADB_STATUS, &clpb,
7349 &get_stadb_status_req, sizeof(get_stadb_status_req));
7350 res = _mtlk_df_user_process_core_retval_void(res, clpb, MTLK_CORE_REQ_GET_STADB_STATUS, FALSE);
7351 if(MTLK_ERR_OK != res) {
7352 goto err_ret;
7353 }
7354
7355 while (NULL != (stadb_stat = mtlk_clpb_enum_get_next(clpb, &size))) {
7356 if ((sizeof(*stadb_stat) != size) || (STAT_ID_STADB != stadb_stat->type)) {
7357 res = MTLK_ERR_UNKNOWN;
7358 mtlk_clpb_delete(clpb);
7359 goto err_ret;
7360 } else {
7361 /* With 64 stas the total string may exceed 2046 bytes, so don't output too much here */
7362 len += snprintf(str + len, TEXT_SIZE - len, "\n" MAC_PRINTF_FMT, MAC_PRINTF_ARG(stadb_stat->u.general_stat.addr.au8Addr));
7363
7364 if (len >= TEXT_SIZE)
7365 {
7366 WLOG_V("Connection information truncated");
7367 len = TEXT_SIZE - 1;
7368 break;
7369 }
7370 }
7371 }
7372
7373 mtlk_clpb_delete(clpb);
7374 }
7375
7376 wrqu->data.length = len;
7377
7378 err_ret:
7379 return _mtlk_df_mtlk_to_linux_error_code(res);
7380 }
7381
7382 /* Driver support only 40 bit and 104 bit length WEP keys.
7383 * Also, according to IEEE standard packet transmission
7384 * with zero-filled WEP key is not supported.
7385 */
7386 static int
7387 mtlk_df_ui_validate_wep_key (uint8 *key, size_t length) {
7388 int i;
7389 ASSERT(key);
7390
7391 /* Check key length */
7392 if ((length != MIB_WEP_KEY_WEP1_LENGTH) && /* 40 bit */
7393 (length != MIB_WEP_KEY_WEP2_LENGTH)) { /* 104 bit */
7394 return MTLK_ERR_PARAMS;
7395 }
7396
7397 /* Validate key's value. All-zero key value is invalid. */
7398 for (i = 0; i < length; i++)
7399 if (key[i])
7400 return MTLK_ERR_OK;
7401
7402 return MTLK_ERR_PARAMS;
7403 }
7404
7405 int __MTLK_IFUNC
7406 mtlk_df_ui_linux_ioctl_setenc (struct net_device *dev,
7407 struct iw_request_info *info,
7408 union iwreq_data *wrqu,
7409 char *extra)
7410 {
7411 int res = MTLK_ERR_NOT_HANDLED;
7412 mtlk_df_user_t *df_user = (mtlk_df_user_t*)netdev_priv(dev);
7413 mtlk_clpb_t *clpb = NULL;
7414 mtlk_core_ui_enc_cfg_t enc_cfg;
7415 uint8 key_id;
7416
7417 ILOG3_SSD("%s: Invoked from %s (%i)", dev->name, current->comm, current->pid);
7418
7419 memset(&enc_cfg, 0, sizeof(enc_cfg));
7420
7421 /* Mark values as not specified */
7422 enc_cfg.wep_enabled = MAX_UINT8;
7423 enc_cfg.authentication = MAX_UINT8;
7424 enc_cfg.key_id = MAX_UINT8;
7425
7426 if (wrqu->data.flags & IW_ENCODE_DISABLED) {
7427 /* Disable WEP encryption */
7428 enc_cfg.wep_enabled = FALSE;
7429 enc_cfg.authentication = MIB_AUTHENTICATION_OPEN_SYSTEM;
7430
7431 } else if (wrqu->data.flags & IW_ENCODE_OPEN) {
7432 /* Open mode */
7433 enc_cfg.wep_enabled = TRUE;
7434 enc_cfg.authentication = MIB_AUTHENTICATION_OPEN_SYSTEM;
7435
7436 } else if ((wrqu->data.flags & IW_ENCODE_OPEN) &&
7437 (wrqu->data.flags & IW_ENCODE_RESTRICTED)) {
7438 /* auto mode (on STA) */
7439 enc_cfg.wep_enabled = TRUE;
7440 enc_cfg.authentication = MIB_AUTHENTICATION_AUTO;
7441
7442 } else if (wrqu->data.flags & IW_ENCODE_RESTRICTED) {
7443 /* Restricted mode */
7444 enc_cfg.wep_enabled = TRUE;
7445 enc_cfg.authentication = MIB_AUTHENTICATION_SHARED_KEY;
7446 }
7447
7448 /* Validate and adjust key index
7449 Up to 4 WEP keys supported. WE enumerate WEP keys from 1
7450 to N, and 0 means key not specified, current TX key will be used instead. */
7451 key_id = (uint8)(wrqu->data.flags & IW_ENCODE_INDEX);
7452 if (key_id != 0){
7453 if (MIB_WEP_N_DEFAULT_KEYS < key_id ) {
7454 WLOG_S("%s: Unsupported WEP key index", dev->name);
7455 res = MTLK_ERR_PARAMS;
7456 goto finish;
7457 }
7458 enc_cfg.key_id = key_id - 1;
7459 }
7460
7461 /* Set WEP key */
7462 /* Validate key first */
7463 if (0 != wrqu->data.length){
7464 if (mtlk_df_ui_validate_wep_key(extra, wrqu->data.length) != MTLK_ERR_OK) {
7465 WLOG_S("%s: Bad WEP key", dev->name);
7466 res = MTLK_ERR_PARAMS;
7467 goto finish; /* res = -EINVAL */
7468 }
7469 /* Only one key might be passed from OS. So, slot 0 is used */
7470 enc_cfg.wep_keys.sKey[0].u8KeyLength = wrqu->data.length;
7471 memcpy(enc_cfg.wep_keys.sKey[0].au8KeyData, extra, wrqu->data.length);
7472 }
7473
7474 res = _mtlk_df_user_invoke_core(df_user->df, MTLK_CORE_REQ_SET_WEP_ENC_CFG,
7475 &clpb, (char*)&enc_cfg, sizeof(enc_cfg));
7476 res = _mtlk_df_user_process_core_retval_void(res, clpb, MTLK_CORE_REQ_SET_WEP_ENC_CFG, TRUE);
7477 if(MTLK_ERR_OK != res) {
7478 goto finish;
7479 }
7480
7481 finish:
7482 return _mtlk_df_mtlk_to_linux_error_code(res);
7483 }
7484
7485 int __MTLK_IFUNC
7486 mtlk_df_ui_linux_ioctl_getenc (struct net_device *dev,
7487 struct iw_request_info *info,
7488 union iwreq_data *wrqu,
7489 char *extra)
7490 {
7491 int res = MTLK_ERR_NOT_HANDLED;
7492 mtlk_df_user_t *df_user = (mtlk_df_user_t*)netdev_priv(dev);
7493 mtlk_clpb_t *clpb = NULL;
7494 mtlk_core_ui_enc_cfg_t *enc_cfg_res;
7495 uint32 size;
7496 uint8 key_index;
7497
7498 ILOG3_SSD("%s: Invoked from %s (%i)", dev->name, current->comm, current->pid);
7499
7500 res = _mtlk_df_user_invoke_core(df_user->df, MTLK_CORE_REQ_GET_WEP_ENC_CFG, &clpb, NULL, 0);
7501 res = _mtlk_df_user_process_core_retval_void(res, clpb, MTLK_CORE_REQ_GET_WEP_ENC_CFG, FALSE);
7502 if(MTLK_ERR_OK != res) {
7503 goto finish;
7504 }
7505
7506 enc_cfg_res = mtlk_clpb_enum_get_next(clpb, &size);
7507 if ( (NULL == enc_cfg_res) || (sizeof(*enc_cfg_res) != size) ) {
7508 res = MTLK_ERR_UNKNOWN;
7509 goto delete_clpb;
7510 }
7511
7512 /* Validate key index */
7513 key_index = (uint8)(wrqu->data.flags & IW_ENCODE_INDEX);
7514 if (MIB_WEP_N_DEFAULT_KEYS < key_index ) {
7515 WLOG_S("%s: Unsupported WEP key index", dev->name);
7516 res = MTLK_ERR_PARAMS;
7517 goto delete_clpb;
7518 }
7519
7520 if (key_index != 0) {
7521 /* Report key only if key index is specified */
7522 key_index--;
7523
7524 }else {
7525 /* Key index == 0 report current WEP configuration */
7526 wrqu->data.flags = 0;
7527
7528 if (enc_cfg_res->wep_enabled) {
7529 wrqu->data.flags |= IW_ENCODE_ENABLED;
7530 /* Report access policy */
7531 if (MIB_AUTHENTICATION_SHARED_KEY == enc_cfg_res->authentication) {
7532 wrqu->data.flags |= IW_ENCODE_RESTRICTED;
7533 } else if (MIB_AUTHENTICATION_OPEN_SYSTEM == enc_cfg_res->authentication) {
7534 wrqu->data.flags |= IW_ENCODE_OPEN;
7535 } else if (MIB_AUTHENTICATION_AUTO == enc_cfg_res->authentication) {
7536 wrqu->data.flags |= IW_ENCODE_OPEN|IW_ENCODE_RESTRICTED;
7537 }
7538 }else{
7539 wrqu->data.flags |= IW_ENCODE_DISABLED;
7540 }
7541
7542 wrqu->data.flags |= ((uint16)(enc_cfg_res->key_id + 1) & IW_ENCODE_INDEX);
7543 key_index = enc_cfg_res->key_id;
7544 }
7545
7546 /* Get requested key */
7547 wrqu->data.length = enc_cfg_res->wep_keys.sKey[key_index].u8KeyLength;
7548 memcpy(extra, enc_cfg_res->wep_keys.sKey[key_index].au8KeyData, wrqu->data.length);
7549
7550 delete_clpb:
7551 mtlk_clpb_delete(clpb);
7552 finish:
7553 return _mtlk_df_mtlk_to_linux_error_code(res);
7554 }
7555
7556 int __MTLK_IFUNC
7557 mtlk_df_ui_linux_ioctl_setauth (struct net_device *dev,
7558 struct iw_request_info *info,
7559 union iwreq_data *wrqu,
7560 char *extra)
7561 {
7562 int res = MTLK_ERR_OK;
7563 mtlk_df_user_t *df_user = (mtlk_df_user_t*)netdev_priv(dev);
7564 mtlk_clpb_t *clpb = NULL;
7565 mtlk_core_ui_auth_cfg_t auth_cfg;
7566
7567 ILOG3_SSD("%s: Invoked from %s (%i)", dev->name, current->comm, current->pid);
7568
7569 memset(&auth_cfg, 0, sizeof(auth_cfg));
7570 auth_cfg.wep_enabled = -1;
7571 auth_cfg.rsn_enabled = -1;
7572 auth_cfg.authentication = -1;
7573
7574 ILOG2_SDD("%s: flags %i, value %i", dev->name, wrqu->param.flags, wrqu->param.value);
7575
7576 switch (wrqu->param.flags & IW_AUTH_INDEX) {
7577 case IW_AUTH_WPA_VERSION:
7578 if ((wrqu->param.value & IW_AUTH_WPA_VERSION_WPA) ||
7579 (wrqu->param.value & IW_AUTH_WPA_VERSION_WPA2)) {
7580 auth_cfg.rsn_enabled = 1;
7581 }
7582 break;
7583
7584 case IW_AUTH_CIPHER_PAIRWISE:
7585 case IW_AUTH_CIPHER_GROUP:
7586 if (wrqu->param.value & (IW_AUTH_CIPHER_WEP40|IW_AUTH_CIPHER_WEP104)) {
7587 auth_cfg.wep_enabled = 1;
7588 } else {
7589 auth_cfg.wep_enabled = 0;
7590 }
7591 break;
7592
7593
7594 case IW_AUTH_80211_AUTH_ALG:
7595 if ((wrqu->param.value & IW_AUTH_ALG_OPEN_SYSTEM) &&
7596 (wrqu->param.value & IW_AUTH_ALG_SHARED_KEY)) { /* automatic mode */
7597 auth_cfg.authentication = MIB_AUTHENTICATION_AUTO;
7598 } else if (wrqu->param.value & IW_AUTH_ALG_SHARED_KEY) {
7599 auth_cfg.authentication = MIB_AUTHENTICATION_SHARED_KEY;
7600 } else if (wrqu->param.value & IW_AUTH_ALG_OPEN_SYSTEM) {
7601 auth_cfg.authentication = MIB_AUTHENTICATION_OPEN_SYSTEM;
7602 } else {
7603 res = MTLK_ERR_PARAMS;
7604 }
7605 break;
7606
7607 case IW_AUTH_KEY_MGMT:
7608 case IW_AUTH_PRIVACY_INVOKED:
7609 case IW_AUTH_RX_UNENCRYPTED_EAPOL:
7610 case IW_AUTH_DROP_UNENCRYPTED:
7611 case IW_AUTH_TKIP_COUNTERMEASURES:
7612 case IW_AUTH_WPA_ENABLED:
7613 res = MTLK_ERR_NOT_HANDLED;
7614 break;
7615
7616 default:
7617 res = MTLK_ERR_NOT_SUPPORTED;
7618 }
7619
7620 if (MTLK_ERR_NOT_SUPPORTED == res) {
7621 res = MTLK_ERR_OK;
7622 goto finish;
7623 } else if (MTLK_ERR_OK == res) {
7624 res = _mtlk_df_user_invoke_core(df_user->df, MTLK_CORE_REQ_SET_AUTH_CFG,
7625 &clpb, (char*)&auth_cfg, sizeof(auth_cfg));
7626 res = _mtlk_df_user_process_core_retval_void(res, clpb, MTLK_CORE_REQ_SET_AUTH_CFG, TRUE);
7627 }
7628
7629 finish:
7630 return _mtlk_df_mtlk_to_linux_error_code(res);
7631 }
7632
7633 static int
7634 mtlk_df_ui_iw_cipher_encode2auth(int enc_cipher)
7635 {
7636 switch (enc_cipher) {
7637 case IW_ENCODE_ALG_NONE:
7638 return IW_AUTH_CIPHER_NONE;
7639 case IW_ENCODE_ALG_WEP:
7640 return IW_AUTH_CIPHER_WEP40;
7641 case IW_ENCODE_ALG_TKIP:
7642 return IW_AUTH_CIPHER_TKIP;
7643 case IW_ENCODE_ALG_CCMP:
7644 return IW_AUTH_CIPHER_CCMP;
7645 default:
7646 return 0;
7647 }
7648 }
7649
7650 int __MTLK_IFUNC
7651 mtlk_df_ui_linux_ioctl_getauth (struct net_device *dev,
7652 struct iw_request_info *info,
7653 struct iw_param *param,
7654 char *extra)
7655 {
7656 int res = MTLK_ERR_NOT_HANDLED;
7657 mtlk_df_user_t *df_user = (mtlk_df_user_t*)netdev_priv(dev);
7658 mtlk_clpb_t *clpb = NULL;
7659 mtlk_core_ui_auth_state_t *auth_state;
7660 uint32 size;
7661
7662 ILOG3_SSD("%s: Invoked from %s (%i)", dev->name, current->comm, current->pid);
7663
7664 ILOG2_SDD("%s: flags %i, value %i", dev->name, param->flags, param->value);
7665
7666 res = _mtlk_df_user_invoke_core(df_user->df, MTLK_CORE_REQ_GET_AUTH_CFG, &clpb, NULL, 0);
7667 res = _mtlk_df_user_process_core_retval_void(res, clpb, MTLK_CORE_REQ_GET_AUTH_CFG, FALSE);
7668 if (MTLK_ERR_OK != res) {
7669 goto finish;
7670 }
7671
7672 auth_state = mtlk_clpb_enum_get_next(clpb, &size);
7673 if ( (NULL == auth_state) || (sizeof(*auth_state) != size) ) {
7674 res = MTLK_ERR_UNKNOWN;
7675 goto delete_clpb;
7676 }
7677
7678 /* Fill result */
7679
7680 param->value = 0;
7681 switch (param->flags & IW_AUTH_INDEX) {
7682 case IW_AUTH_WPA_VERSION:
7683 if (!auth_state->rsnie.au8RsnIe[0]) {
7684 res = MTLK_ERR_PARAMS;
7685 } else if (auth_state->rsnie.au8RsnIe[0] == RSN_INFO_ELEM) {
7686 param->value = IW_AUTH_WPA_VERSION_WPA2;
7687 } else if (auth_state->rsnie.au8RsnIe[0] == GENERIC_INFO_ELEM) {
7688 param->value = IW_AUTH_WPA_VERSION_WPA;
7689 }
7690 break;
7691
7692 case IW_AUTH_CIPHER_PAIRWISE:
7693 if (0 > auth_state->cipher_pairwise) {
7694 res = MTLK_ERR_NOT_SUPPORTED;
7695 } else {
7696 param->value = mtlk_df_ui_iw_cipher_encode2auth(auth_state->cipher_pairwise);
7697 }
7698 break;
7699
7700 case IW_AUTH_CIPHER_GROUP:
7701 if (!auth_state->group_cipher) {
7702 res = MTLK_ERR_PARAMS;
7703 } else {
7704 param->value = mtlk_df_ui_iw_cipher_encode2auth(auth_state->group_cipher);
7705 }
7706 break;
7707
7708 default:
7709 res = MTLK_ERR_NOT_SUPPORTED;
7710 }
7711
7712 delete_clpb:
7713 mtlk_clpb_delete(clpb);
7714 finish:
7715 return _mtlk_df_mtlk_to_linux_error_code(res);
7716 }
7717
7718 int __MTLK_IFUNC
7719 mtlk_df_ui_linux_ioctl_setgenie (struct net_device *dev,
7720 struct iw_request_info *info,
7721 struct iw_point *data,
7722 char *extra)
7723 {
7724 int res = MTLK_ERR_PARAMS;
7725 mtlk_df_user_t *df_user = (mtlk_df_user_t*)netdev_priv(dev);
7726 mtlk_clpb_t *clpb = NULL;
7727 mtlk_core_ui_genie_cfg_t genie_cfg;
7728 u8 *ie = (u8 *)extra;
7729 u8 *oui = ie +2;
7730 u8 wpa_oui[] = {0x00, 0x50, 0xf2, 0x01};
7731 u8 wps_oui[] = {0x00, 0x50, 0xf2, 0x04};
7732 int ie_len = data->length;
7733
7734 ILOG3_SSD("%s: Invoked from %s (%i)", dev->name, current->comm, current->pid);
7735
7736 memset(&genie_cfg, 0, sizeof(genie_cfg));
7737 ILOG2_SDD("%s: IE %i, length %i", dev->name, ie ? ie[0] : 0, ie_len);
7738
7739 if ((0 != ie_len) && (NULL == ie)) {
7740 goto finish;
7741 }
7742
7743 if ( (NULL != ie) && (0 != ie_len) && (GENERIC_INFO_ELEM == ie[0]) &&
7744 (0 != memcmp(oui, wpa_oui, sizeof(wpa_oui)) ) ) {
7745 ILOG2_D("WPS IE, type %i", data->flags);
7746 mtlk_dump(3, ie, ie_len, "dump of WPS IE:");
7747 // Set wps_in_progress flag. In AP mode parse WPS IE
7748 // and check Selected Registrar attribute. In STA mode
7749 // it is enough to check that WPS IE is not zero.
7750 if (mtlk_df_is_ap(df_user->df)) { /* AP */
7751 /* Parse WPS IE and */
7752 u8 *p = ie;
7753 /* Go to WPS OUI */
7754 while (memcmp(oui, wps_oui, sizeof(wps_oui)) != 0) {
7755 p += p[1] + 2;
7756 if (p >= ie+ie_len) {
7757 WLOG_V("WPS OUI was not found");
7758 goto finish;
7759 }
7760 oui = p + 2;
7761 }
7762 p = oui + sizeof(wps_oui);
7763 MTLK_CFG_SET_ITEM(&genie_cfg, wps_in_progress, 0);
7764
7765 while (p < ie+ie_len) {
7766 ILOG2_D("WPS IE, attr %04x", ntohs(*(uint16*)p));
7767 if (ntohs(get_unaligned((uint16*)p)) == 0x1041) { // Selected Registrar
7768 if (p[4] == 1) {
7769 MTLK_CFG_SET_ITEM(&genie_cfg, wps_in_progress, 1);
7770 }
7771 break;
7772 }
7773 p += 4 + ntohs(get_unaligned((uint16*)(p+2))); // Go to next attribute
7774 }
7775 } else { /* STA */
7776 MTLK_CFG_SET_ITEM(&genie_cfg, rsnie_reset, 1);
7777 MTLK_CFG_SET_ITEM(&genie_cfg, wps_in_progress, 1);
7778 }
7779
7780 if (sizeof(genie_cfg.gen_ie) < ie_len) {
7781 WLOG_V("WPS gen ie invalid length");
7782 goto finish;
7783 }
7784
7785 MTLK_CFG_SET_ITEM(&genie_cfg, gen_ie_set, 1);
7786 MTLK_CFG_SET_ITEM(&genie_cfg, gen_ie_type, data->flags);
7787 MTLK_CFG_SET_ITEM(&genie_cfg, gen_ie_len, ie_len);
7788 MTLK_CFG_SET_ITEM_BY_FUNC_VOID(&genie_cfg, gen_ie, memcpy,
7789 (genie_cfg.gen_ie, ie, ie_len));
7790
7791 goto configure;
7792 }
7793
7794 if (sizeof(UMI_RSN_IE) < ie_len ) {
7795 WLOG_DD("invalid RSN IE length (%i > %i)", ie_len, (int)sizeof(UMI_RSN_IE));
7796 goto finish;
7797 }
7798
7799 MTLK_CFG_SET_ITEM(&genie_cfg, rsn_enabled, 0);
7800
7801 if (ie_len) {
7802 MTLK_CFG_SET_ITEM_BY_FUNC_VOID(&genie_cfg, rsnie, memcpy, (&genie_cfg.rsnie, ie, ie_len));
7803 mtlk_dump(2, ie, ie_len, "dump of rsnie:");
7804
7805 if (mtlk_df_is_ap(df_user->df) &&
7806 (ie[0] == GENERIC_INFO_ELEM || ie[0] == RSN_INFO_ELEM)) {
7807 MTLK_CFG_SET_ITEM(&genie_cfg, rsn_enabled, 1);
7808 }
7809
7810 } else { /* reset WPS IE case */
7811
7812 // Note: in WPS mode data->flags represents the type of
7813 // WPS IE (for beacons, probe responces or probe reqs).
7814 // In STA mode flags == 1 (probe reqs type). So we
7815 // check it to avoid collisions with WPA IE reset.
7816
7817 MTLK_CFG_SET_ITEM(&genie_cfg, rsnie_reset, 1);
7818 #ifdef MTCFG_HOSTAP_06
7819 if (!mtlk_df_is_ap(df_user->df))
7820 #else
7821 if (!mtlk_df_is_ap(df_user->df) && data->flags)
7822 #endif
7823 {
7824 MTLK_CFG_SET_ITEM(&genie_cfg, wps_in_progress, 0);
7825 }
7826
7827 MTLK_CFG_SET_ITEM(&genie_cfg, gen_ie_set, 1);
7828 MTLK_CFG_SET_ITEM(&genie_cfg, gen_ie_type, data->flags);
7829 MTLK_CFG_SET_ITEM(&genie_cfg, gen_ie_len, ie_len);
7830 MTLK_CFG_SET_ITEM_BY_FUNC_VOID(&genie_cfg, gen_ie, memcpy,
7831 (genie_cfg.gen_ie, ie, ie_len));
7832 }
7833
7834 configure:
7835 res = _mtlk_df_user_invoke_core(df_user->df, MTLK_CORE_REQ_SET_GENIE_CFG,
7836 &clpb, (char*)&genie_cfg, sizeof(genie_cfg));
7837 res = _mtlk_df_user_process_core_retval_void(res, clpb, MTLK_CORE_REQ_SET_GENIE_CFG, TRUE);
7838
7839 finish:
7840 return _mtlk_df_mtlk_to_linux_error_code(res);
7841 }
7842
7843
7844 int __MTLK_IFUNC
7845 mtlk_df_ui_linux_ioctl_getencext (struct net_device *dev,
7846 struct iw_request_info *info,
7847 struct iw_point *encoding,
7848 char *extra)
7849 {
7850
7851 int res = MTLK_ERR_PARAMS;
7852 mtlk_df_user_t *df_user = (mtlk_df_user_t*)netdev_priv(dev);
7853 mtlk_clpb_t *clpb = NULL;
7854 uint32 size;
7855 UMI_GROUP_PN *umi_gpn;
7856 struct iw_encode_ext *ext = NULL;
7857
7858 ILOG3_SSD("%s: Invoked from %s (%i)", dev->name, current->comm, current->pid);
7859
7860 ext = (struct iw_encode_ext *)extra;
7861 if (ext == NULL)
7862 goto finish;
7863
7864 res = _mtlk_df_user_invoke_core(df_user->df, MTLK_CORE_REQ_GET_ENCEXT_CFG, &clpb, NULL, 0);
7865 res = _mtlk_df_user_process_core_retval_void(res, clpb, MTLK_CORE_REQ_GET_ENCEXT_CFG, FALSE);
7866 if (MTLK_ERR_OK != res) {
7867 goto finish;
7868 }
7869
7870 umi_gpn = mtlk_clpb_enum_get_next(clpb, &size);
7871 if ( (NULL == umi_gpn) || (sizeof(*umi_gpn) != size) ) {
7872 res = MTLK_ERR_UNKNOWN;
7873 goto delete_clpb;
7874 }
7875
7876 /* Set kernel's iwp->length here in order to prevent it to be equal to max_tokens,
7877 which leads to the errornous situation after this handler is called.
7878 TODO: check all other getters implementation. */
7879 encoding->length= sizeof(*ext);
7880
7881 memcpy(ext->rx_seq, umi_gpn->au8TxSeqNum, 6);
7882 ILOG2_DDDDDD("RSC: %02x%02x%02x%02x%02x%02x",
7883 ext->rx_seq[0], ext->rx_seq[1], ext->rx_seq[2],
7884 ext->rx_seq[3], ext->rx_seq[4], ext->rx_seq[5]);
7885
7886 delete_clpb:
7887 mtlk_clpb_delete(clpb);
7888 finish:
7889 return _mtlk_df_mtlk_to_linux_error_code(res);
7890 }
7891
7892 int __MTLK_IFUNC
7893 mtlk_df_ui_linux_ioctl_setencext (struct net_device *dev,
7894 struct iw_request_info *info,
7895 struct iw_point *encoding,
7896 char *extra)
7897 {
7898 int res = MTLK_ERR_PARAMS;
7899 mtlk_df_user_t *df_user = (mtlk_df_user_t*)netdev_priv(dev);
7900 mtlk_clpb_t *clpb = NULL;
7901 struct iw_encode_ext *ext = NULL;
7902 mtlk_core_ui_encext_cfg_t encext_cfg;
7903 uint16 key_idx, key_len;
7904
7905 ILOG3_SSD("%s: Invoked from %s (%i)", dev->name, current->comm, current->pid);
7906
7907 ext = (struct iw_encode_ext *)extra;
7908 if (ext == NULL) {
7909 WLOG_S("%s: extra parameter expected", dev->name);
7910 goto finish;
7911 }
7912
7913 memset(&encext_cfg, 0, sizeof(encext_cfg));
7914 ILOG2_DDD("alg %04x, enc flags %04x, ext flags %08x", ext->alg, encoding->flags, ext->ext_flags);
7915
7916 /* Determine and validate the encoding algorithm */
7917 if (encoding->flags & IW_ENCODE_DISABLED)
7918 ext->alg = IW_ENCODE_ALG_NONE;
7919 switch (ext->alg) {
7920 case IW_ENCODE_ALG_NONE:
7921 /* IW_ENCODE_ALG_NONE - reset keys */
7922 MTLK_CFG_SET_ITEM(&encext_cfg, wep_enabled, 0);
7923 break;
7924 case IW_ENCODE_ALG_WEP:
7925 MTLK_CFG_SET_ITEM(&encext_cfg, wep_enabled, 1);
7926 break;
7927 case IW_ENCODE_ALG_TKIP:
7928 break;
7929 case IW_ENCODE_ALG_CCMP:
7930 break;
7931 case IW_ENCODE_ALG_AES_CMAC:
7932 break;
7933 default:
7934 WLOG_SD("%s: Unsupported encoding algorithm type (%u)", dev->name, ext->alg);
7935 res = MTLK_ERR_NOT_SUPPORTED;
7936 goto finish;
7937 }
7938 ILOG2_D("alg: type (%u)", ext->alg);
7939 MTLK_CFG_SET_ITEM(&encext_cfg, alg_type, ext->alg);
7940
7941 /* Determine and validate the key index */
7942 key_idx = (encoding->flags & IW_ENCODE_INDEX);
7943 if (ext->alg == IW_ENCODE_ALG_NONE) {
7944 #ifndef MTCFG_SUPORT_IW_ENCODE_ALG_NONE
7945 /* Because FW not support IW_ENCODE_ALG_NONE, just return MTLK_ERR_OK.*/
7946 res = MTLK_ERR_OK;
7947 goto finish;
7948 #else
7949 /* Clear keys */
7950 if ((UMI_RSN_IGTK_GM_KEY_INDEX != key_idx) &&
7951 (UMI_RSN_IGTK_GN_KEY_INDEX != key_idx) &&
7952 (MIB_WEP_N_DEFAULT_KEYS < key_idx )) {
7953 WLOG_SD("%s: Invalid key index (%u)", dev->name, key_idx);
7954 goto finish;
7955 }
7956 #endif
7957 } else if (ext->alg == IW_ENCODE_ALG_AES_CMAC) {
7958 /* Set IGTK keys */
7959 if(key_idx != UMI_RSN_IGTK_GM_KEY_INDEX &&
7960 key_idx != UMI_RSN_IGTK_GN_KEY_INDEX) {
7961 WLOG_SD("%s: Invalid IGTK key index (%u)", dev->name, key_idx);
7962 goto finish;
7963 }
7964 } else {
7965 /* Set normal keys */
7966 if (MIB_WEP_N_DEFAULT_KEYS < key_idx ) {
7967 WLOG_SD("%s: Invalid WEP key index (%u)", dev->name, key_idx);
7968 goto finish;
7969 }
7970 }
7971 if (0 != key_idx) {
7972 key_idx--;
7973 }
7974 ILOG2_D("key: key_idx (%u)", key_idx);
7975 MTLK_CFG_SET_ITEM(&encext_cfg, key_idx, key_idx);
7976
7977 /* Set default key index unless setting PMF IGTK key (index 4, 5) */
7978 if ((ext->ext_flags & IW_ENCODE_EXT_SET_TX_KEY) && (key_idx < MIB_WEP_N_DEFAULT_KEYS)) {
7979 MTLK_CFG_SET_ITEM(&encext_cfg, default_key_idx, key_idx);
7980 ILOG2_D("key: default_key_idx (%u)", key_idx);
7981 }
7982
7983 /* Determine and validate the STA ether address */
7984 MTLK_CFG_SET_ITEM_BY_FUNC(&encext_cfg, sta_addr,
7985 _mtlk_df_user_fill_ether_address, (&encext_cfg.sta_addr, &ext->addr), res);
7986 if (MTLK_ERR_OK != res) {
7987 WLOG_SY("%s: Invalid address (%Y)", dev->name, ext->addr.sa_data);
7988 goto finish;
7989 }
7990 ILOG2_Y("%Y", ext->addr.sa_data);
7991
7992 /* Determine and validate the key length */
7993 key_len = 0;
7994 if (ext->ext_flags & (IW_ENCODE_EXT_SET_TX_KEY|IW_ENCODE_EXT_GROUP_KEY)) {
7995 key_len = ext->key_len;
7996
7997 if ( (IW_ENCODE_ALG_WEP == ext->alg) || (IW_ENCODE_ALG_NONE == ext->alg) )
7998 {
7999 if ((0 < key_len) && (key_len != MIB_WEP_KEY_WEP1_LENGTH) && (key_len != MIB_WEP_KEY_WEP2_LENGTH)) {
8000 WLOG_SD("%s: Invalid WEP key length (%u)", dev->name, key_len);
8001 res = MTLK_ERR_PARAMS;
8002 goto finish;
8003 }
8004
8005 /* Prevent setting all-zero WEP key */
8006 if ((IW_ENCODE_ALG_WEP == ext->alg) &&
8007 (0 < key_len) &&
8008 (mtlk_df_ui_validate_wep_key(ext->key, key_len) != MTLK_ERR_OK)) {
8009 WLOG_S("%s: Invalid WEP key", dev->name);
8010 res = MTLK_ERR_PARAMS;
8011 goto finish;
8012 }
8013 }
8014
8015 if ((UMI_RSN_TK1_LEN + UMI_RSN_TK2_LEN) < key_len) {
8016 WLOG_SD("%s: Invalid key length (%u)", dev->name, key_len);
8017 key_len = UMI_RSN_TK1_LEN + UMI_RSN_TK2_LEN;
8018 }
8019 }
8020 MTLK_CFG_SET_ITEM(&encext_cfg, key_len, key_len);
8021 ILOG2_D("key: key_len (%u)", key_len);
8022
8023 /* Determine and validate the key */
8024 if (key_len) {
8025 MTLK_CFG_SET_ITEM_BY_FUNC_VOID(&encext_cfg, key, memcpy,
8026 (encext_cfg.key, ext->key, key_len));
8027 mtlk_dump(2, ext->key, key_len, "KEY:");
8028 }
8029
8030 /* Determine and validate the RX seq */
8031 if (ext->ext_flags & IW_ENCODE_EXT_RX_SEQ_VALID) {
8032 MTLK_CFG_SET_ITEM_BY_FUNC_VOID(&encext_cfg, rx_seq, memcpy,
8033 (encext_cfg.rx_seq, ext->rx_seq, 6));
8034 mtlk_dump(2, ext->rx_seq, 6, "group RSC");
8035 }
8036
8037 res = _mtlk_df_user_invoke_core(df_user->df, MTLK_CORE_REQ_SET_ENCEXT_CFG,
8038 &clpb, (char*)&encext_cfg, sizeof(encext_cfg));
8039 res = _mtlk_df_user_process_core_retval_void(res, clpb, MTLK_CORE_REQ_SET_ENCEXT_CFG, TRUE);
8040
8041 finish:
8042 return _mtlk_df_mtlk_to_linux_error_code(res);
8043 }
8044
8045 struct iw_statistics* __MTLK_IFUNC
8046 mtlk_df_ui_linux_ioctl_get_iw_stats (struct net_device *dev)
8047 {
8048 mtlk_df_user_t *df_user = (mtlk_df_user_t*)netdev_priv(dev);
8049 mtlk_core_general_stats_t *general_stats;
8050
8051 ILOG3_SSD("%s: Invoked from %s (%i)", dev->name, current->comm, current->pid);
8052
8053 /* Get Core general information from DF buffer and don't call Core */
8054 general_stats = &df_user->slow_ctx->core_general_stats;
8055
8056 df_user->slow_ctx->iw_stats.status = general_stats->net_state;
8057 df_user->slow_ctx->iw_stats.discard.nwid = general_stats->core_priv_stats.discard_nwi;
8058 df_user->slow_ctx->iw_stats.miss.beacon = general_stats->core_priv_stats.missed_beacon;
8059
8060 if (!mtlk_df_is_ap(df_user->df) && (mtlk_core_net_state_is_connected(general_stats->net_state))) {
8061
8062 df_user->slow_ctx->iw_stats.qual.updated = IW_QUAL_ALL_UPDATED | IW_QUAL_DBM;
8063 df_user->slow_ctx->iw_stats.qual.noise = general_stats->noise;
8064 df_user->slow_ctx->iw_stats.qual.level = general_stats->max_rssi;
8065 df_user->slow_ctx->iw_stats.qual.qual =
8066 _mtlk_df_ui_calc_signal_strength(MTLK_NORMALIZED_RSSI(general_stats->max_rssi));
8067 }
8068
8069 df_user->slow_ctx->iw_stats.discard.fragment = general_stats->mac_stat.stat[STAT_FRAGMENT_FAILED];
8070 df_user->slow_ctx->iw_stats.discard.retries = general_stats->mac_stat.stat[STAT_TX_MAX_RETRY];
8071 df_user->slow_ctx->iw_stats.discard.code =
8072 + general_stats->mac_stat.stat[STAT_WEP_UNDECRYPTABLE]
8073 + general_stats->mac_stat.stat[STAT_WEP_ICV_ERROR]
8074 + general_stats->mac_stat.stat[STAT_WEP_EXCLUDED]
8075 + general_stats->mac_stat.stat[STAT_DECRYPTION_FAILED];
8076 df_user->slow_ctx->iw_stats.discard.misc =
8077 + general_stats->mac_stat.stat[STAT_RX_DISCARD]
8078 + general_stats->mac_stat.stat[STAT_TX_FAIL]
8079 - df_user->slow_ctx->iw_stats.discard.code
8080 - df_user->slow_ctx->iw_stats.discard.retries;
8081
8082 return &df_user->slow_ctx->iw_stats;
8083
8084 }
8085
8086 typedef int (*mtlk_df_ui_cfg_handler_f)(mtlk_df_user_t* df_user, uint32 subcmd, char* data, uint16* length);
8087
8088 static int
8089 _mtlk_df_ui_execute_cfg_handler(mtlk_df_ui_cfg_handler_f *cfg_handlers_tbl,
8090 mtlk_df_user_t* df_user,
8091 uint32 subcmd_id,
8092 char* value,
8093 uint16* length)
8094 {
8095 int result = MTLK_ERR_NOT_HANDLED;
8096 ILOG2_D("IWPRIV #0x%04x being processed", subcmd_id);
8097
8098 while ((NULL != *cfg_handlers_tbl) && (MTLK_ERR_NOT_HANDLED == result)) {
8099 result = (*cfg_handlers_tbl++)(df_user, subcmd_id, value, length);
8100 }
8101
8102 MTLK_ASSERT(MTLK_ERR_NOT_HANDLED != result);
8103 ILOG2_D("IWPRIV #0x%04x processing done", subcmd_id);
8104
8105 return result;
8106 }
8107
8108 static mtlk_df_ui_cfg_handler_f _mtlk_df_ui_cfg_getters_tbl[] =
8109 {
8110 #ifdef MTCFG_IRB_DEBUG
8111 _mtlk_df_user_irb_pinger_int_get_cfg,
8112 #endif
8113 #ifdef MTLK_HAVE_PPA
8114 _mtlk_df_user_ppa_directpath_int_get_cfg,
8115 #endif
8116 #ifdef MTCFG_USE_GENL
8117 _mtlk_df_user_genl_int_get_cfg,
8118 #endif
8119 _mtlk_df_user_iwpriv_get_core_param,
8120 NULL
8121 };
8122
8123 static mtlk_df_ui_cfg_handler_f _mtlk_df_ui_cfg_setters_tbl[] =
8124 {
8125 #ifdef MTCFG_IRB_DEBUG
8126 _mtlk_df_user_irb_pinger_int_set_cfg,
8127 #endif
8128 #ifdef MTLK_HAVE_PPA
8129 _mtlk_df_user_ppa_directpath_int_set_cfg,
8130 #endif
8131 _mtlk_df_user_iwpriv_set_core_param,
8132 NULL,
8133 };
8134
8135
8136 int __MTLK_IFUNC
8137 mtlk_df_ui_linux_ioctl_get_int (struct net_device *dev,
8138 struct iw_request_info *info,
8139 union iwreq_data *wrqu,
8140 char *extra)
8141 {
8142 mtlk_df_user_t *df_user = (mtlk_df_user_t*)netdev_priv(dev);
8143 int res = _mtlk_df_ui_execute_cfg_handler(_mtlk_df_ui_cfg_getters_tbl,
8144 df_user, wrqu->mode, extra, NULL);
8145 return _mtlk_df_mtlk_to_linux_error_code(res);
8146 }
8147
8148 int __MTLK_IFUNC
8149 mtlk_df_ui_linux_ioctl_set_int (struct net_device *dev,
8150 struct iw_request_info *info,
8151 union iwreq_data *wrqu,
8152 char *extra)
8153 {
8154 mtlk_df_user_t *df_user = (mtlk_df_user_t*)netdev_priv(dev);
8155 int res = _mtlk_df_ui_execute_cfg_handler(_mtlk_df_ui_cfg_setters_tbl,
8156 df_user, wrqu->mode, extra + sizeof(uint32), NULL);
8157 return _mtlk_df_mtlk_to_linux_error_code(res);
8158 }
8159
8160 int __MTLK_IFUNC
8161 mtlk_df_ui_linux_ioctl_get_text (struct net_device *dev,
8162 struct iw_request_info *info,
8163 union iwreq_data *wrqu,
8164 char *extra)
8165 {
8166 mtlk_df_user_t *df_user = (mtlk_df_user_t*)netdev_priv(dev);
8167 int res = _mtlk_df_ui_execute_cfg_handler(_mtlk_df_ui_cfg_getters_tbl,
8168 df_user, wrqu->data.flags, extra, &wrqu->data.length);
8169 return _mtlk_df_mtlk_to_linux_error_code(res);
8170 }
8171
8172 int __MTLK_IFUNC
8173 mtlk_df_ui_linux_ioctl_set_text (struct net_device *dev,
8174 struct iw_request_info *info,
8175 union iwreq_data *wrqu,
8176 char *extra)
8177 {
8178 mtlk_df_user_t *df_user = (mtlk_df_user_t*)netdev_priv(dev);
8179 int res = _mtlk_df_ui_execute_cfg_handler(_mtlk_df_ui_cfg_setters_tbl,
8180 df_user, wrqu->data.flags, extra, &wrqu->data.length);
8181 return _mtlk_df_mtlk_to_linux_error_code(res);
8182 }
8183
8184 int __MTLK_IFUNC
8185 mtlk_df_ui_linux_ioctl_get_intvec (struct net_device *dev,
8186 struct iw_request_info *info,
8187 union iwreq_data *wrqu,
8188 char *extra)
8189 {
8190 mtlk_df_user_t *df_user = (mtlk_df_user_t*)netdev_priv(dev);
8191 int res = _mtlk_df_ui_execute_cfg_handler(_mtlk_df_ui_cfg_getters_tbl,
8192 df_user, wrqu->data.flags, extra, &wrqu->data.length);
8193 return _mtlk_df_mtlk_to_linux_error_code(res);
8194 }
8195
8196 int __MTLK_IFUNC
8197 mtlk_df_ui_linux_ioctl_set_intvec (struct net_device *dev,
8198 struct iw_request_info *info,
8199 union iwreq_data *wrqu,
8200 char *extra)
8201 {
8202 mtlk_df_user_t *df_user = (mtlk_df_user_t*)netdev_priv(dev);
8203 int res = _mtlk_df_ui_execute_cfg_handler(_mtlk_df_ui_cfg_setters_tbl,
8204 df_user, wrqu->data.flags, extra, &wrqu->data.length);
8205 return _mtlk_df_mtlk_to_linux_error_code(res);
8206 }
8207
8208 int __MTLK_IFUNC
8209 mtlk_df_ui_linux_ioctl_get_addr (struct net_device *dev,
8210 struct iw_request_info *info,
8211 union iwreq_data *wrqu,
8212 char *extra)
8213 {
8214 mtlk_df_user_t *df_user = (mtlk_df_user_t*)netdev_priv(dev);
8215 int res = _mtlk_df_ui_execute_cfg_handler(_mtlk_df_ui_cfg_getters_tbl,
8216 df_user, wrqu->mode, extra, NULL);
8217 return _mtlk_df_mtlk_to_linux_error_code(res);
8218 }
8219
8220 int __MTLK_IFUNC
8221 mtlk_df_ui_linux_ioctl_set_addr (struct net_device *dev,
8222 struct iw_request_info *info,
8223 union iwreq_data *wrqu,
8224 char *extra)
8225 {
8226 mtlk_df_user_t *df_user = (mtlk_df_user_t*)netdev_priv(dev);
8227 int res = _mtlk_df_ui_execute_cfg_handler(_mtlk_df_ui_cfg_setters_tbl,
8228 df_user, wrqu->data.flags, extra, NULL);
8229 return _mtlk_df_mtlk_to_linux_error_code(res);
8230 }
8231
8232 int __MTLK_IFUNC
8233 mtlk_df_ui_linux_ioctl_get_addrvec (struct net_device *dev,
8234 struct iw_request_info *info,
8235 union iwreq_data *wrqu,
8236 char *extra)
8237 {
8238 mtlk_df_user_t *df_user = (mtlk_df_user_t*)netdev_priv(dev);
8239 int res = _mtlk_df_ui_execute_cfg_handler(_mtlk_df_ui_cfg_getters_tbl,
8240 df_user, wrqu->data.flags, extra, &wrqu->data.length);
8241 return _mtlk_df_mtlk_to_linux_error_code(res);
8242 }
8243
8244 int __MTLK_IFUNC
8245 mtlk_df_ui_linux_ioctl_set_addrvec (struct net_device *dev,
8246 struct iw_request_info *info,
8247 union iwreq_data *wrqu,
8248 char *extra)
8249 {
8250 int res;
8251
8252 mtlk_df_user_t *df_user = (mtlk_df_user_t*)netdev_priv(dev);
8253
8254 res = _mtlk_df_ui_execute_cfg_handler(_mtlk_df_ui_cfg_setters_tbl,
8255 df_user, wrqu->data.flags, extra, &wrqu->data.length);
8256 return _mtlk_df_mtlk_to_linux_error_code(res);
8257 }
8258
8259 static void
8260 _mtlk_df_user_cleanup(mtlk_df_user_t *df_user)
8261 {
8262 int i;
8263 int res = 0;
8264 mtlk_card_type_t card_type = MTLK_CARD_UNKNOWN;
8265 mtlk_vap_handle_t vap;
8266
8267 MTLK_CLEANUP_BEGIN(df_user, MTLK_OBJ_PTR(df_user))
8268 for (i = 0; MTLK_CLEANUP_ITERATONS_LEFT(MTLK_OBJ_PTR(df_user), FW_HANG_EVTs) > 0; i++) {
8269 MTLK_CLEANUP_STEP_LOOP(df_user, FW_HANG_EVTs, MTLK_OBJ_PTR(df_user),
8270 mtlk_osal_event_cleanup, (&df_user->fw_hang_evts[i]));
8271 }
8272
8273 vap = mtlk_df_get_vap_handle(df_user->df);
8274 res = mtlk_vap_get_hw_vft(vap)->get_prop(vap, MTLK_HW_PROP_CARD_TYPE,
8275 &card_type, sizeof(&card_type));
8276 MTLK_ASSERT(MTLK_ERR_OK == res);
8277 CARD_SELECTOR_START(card_type)
8278 IF_CARD_G3 (
8279 for (i = 0; MTLK_CLEANUP_ITERATONS_LEFT(MTLK_OBJ_PTR(df_user), PROC_CARD_INIT) > 0; i++) {
8280 MTLK_CLEANUP_STEP_LOOP(df_user, PROC_CARD_INIT, MTLK_OBJ_PTR(df_user),
8281 _proc_management_pci_pcie_handlers[i].on_unregister, (df_user));
8282 }
8283 );
8284 IF_CARD_AHBG35 (
8285 for (i = 0; MTLK_CLEANUP_ITERATONS_LEFT(MTLK_OBJ_PTR(df_user), PROC_CARD_INIT) > 0; i++) {
8286 MTLK_CLEANUP_STEP_LOOP(df_user, PROC_CARD_INIT, MTLK_OBJ_PTR(df_user),
8287 _proc_management_ahb_handlers[i].on_unregister, (df_user));
8288 }
8289 );
8290 CARD_SELECTOR_END();
8291
8292 for (i = 0; MTLK_CLEANUP_ITERATONS_LEFT(MTLK_OBJ_PTR(df_user), PROC_INIT) > 0; i++)
8293 {
8294 MTLK_CLEANUP_STEP_LOOP(df_user, PROC_INIT, MTLK_OBJ_PTR(df_user),
8295 _proc_management_handlers[i].on_unregister, (df_user));
8296 }
8297 #ifdef MTCFG_IRB_DEBUG
8298 MTLK_CLEANUP_STEP(df_user, IRB_PINGER_INIT, MTLK_OBJ_PTR(df_user),
8299 mtlk_irb_pinger_cleanup,
8300 (&df_user->slow_ctx->pinger));
8301 #endif /* MTCFG_IRB_DEBUG */
8302
8303 MTLK_CLEANUP_STEP(df_user, STAT_TIMER, MTLK_OBJ_PTR(df_user),
8304 mtlk_osal_timer_cleanup, (&df_user->slow_ctx->stat_timer));
8305 MTLK_CLEANUP_STEP(df_user, CREATE_DEBUG_DIR, MTLK_OBJ_PTR(df_user),
8306 _mtlk_df_ui_delete_debug_dir, (df_user));
8307 MTLK_CLEANUP_STEP(df_user, CREATE_CARD_DIR, MTLK_OBJ_PTR(df_user),
8308 _mtlk_df_ui_delete_card_dir, (df_user));
8309 MTLK_CLEANUP_STEP(df_user, ALLOC_NAME, MTLK_OBJ_PTR(df_user),
8310 MTLK_NOACTION, ());
8311 MTLK_CLEANUP_STEP(df_user, DEBUG_BCL, MTLK_OBJ_PTR(df_user),
8312 mtlk_df_debug_bcl_cleanup, (df_user));
8313 MTLK_CLEANUP_STEP(df_user, ALLOC_SLOW_CTX, MTLK_OBJ_PTR(df_user),
8314 mtlk_osal_mem_free, (df_user->slow_ctx));
8315 MTLK_CLEANUP_END(df_user, MTLK_OBJ_PTR(df_user));
8316 }
8317
8318 static int
8319 _mtlk_df_user_alloc_devname(mtlk_df_user_t *df_user)
8320 {
8321 int res;
8322 char ndev_name_pattern[IFNAMSIZ];
8323
8324 if (mtlk_df_is_slave(df_user->df)) {
8325 mtlk_df_t *master_df = mtlk_vap_manager_get_master_df(
8326 mtlk_df_get_vap_manager(df_user->df));
8327
8328 MTLK_ASSERT(master_df != NULL);
8329 sprintf(ndev_name_pattern, "%s.%d", mtlk_df_user_get_name(mtlk_df_get_user(master_df)), mtlk_vap_get_id(mtlk_df_get_vap_handle(df_user->df))-1);
8330 }
8331 else {
8332 strcpy(ndev_name_pattern, MTLK_NDEV_NAME "%d");
8333 }
8334
8335 ILOG0_S("NDEV Name pattern: %s", ndev_name_pattern);
8336
8337 if (mtlk_df_is_slave(df_user->df)) {
8338 res = dev_alloc_name(df_user->dev, ndev_name_pattern);
8339 } else {
8340 rtnl_lock();
8341 res = dev_alloc_name(df_user->dev, ndev_name_pattern);
8342 rtnl_unlock();
8343 }
8344 if (res < 0) {
8345 res = MTLK_ERR_NO_RESOURCES;
8346 }
8347 else {
8348 res = MTLK_ERR_OK;
8349 }
8350
8351 return res;
8352 }
8353
8354 static int
8355 _mtlk_df_user_init(mtlk_df_user_t *df_user,
8356 mtlk_df_t *df,
8357 struct net_device *dev)
8358 {
8359 /* NEW APPROACH: Now the Net Device name is allocated on DF UI initialization in assumption
8360 * that no one else will register the same device name.
8361 * - DF infrastructure (proc_fs dirrectories) has been created here.
8362 * This approach allows Core to register abilities correctly before Net Device registration.
8363 */
8364 int i;
8365 int res = 0;
8366 mtlk_card_type_t card_type = MTLK_CARD_UNKNOWN;
8367 mtlk_vap_handle_t vap;
8368
8369 MTLK_INIT_TRY(df_user, MTLK_OBJ_PTR(df_user))
8370 df_user->df = df;
8371 df_user->dev = dev;
8372 MTLK_INIT_STEP_EX(df_user, ALLOC_SLOW_CTX, MTLK_OBJ_PTR(df_user),
8373 mtlk_osal_mem_alloc, (sizeof(*df_user->slow_ctx), MTLK_MEM_TAG_DF_SLOW),
8374 df_user->slow_ctx, NULL != df_user->slow_ctx, MTLK_ERR_NO_MEM);
8375
8376 memset(&df_user->slow_ctx->linux_stats, 0,
8377 sizeof(df_user->slow_ctx->linux_stats));
8378 memset(&df_user->slow_ctx->iw_stats, 0,
8379 sizeof(df_user->slow_ctx->iw_stats));
8380 memset(&df_user->slow_ctx->core_general_stats, 0,
8381 sizeof(df_user->slow_ctx->core_general_stats));
8382
8383 MTLK_INIT_STEP(df_user, DEBUG_BCL, MTLK_OBJ_PTR(df_user), mtlk_df_debug_bcl_init, (df_user));
8384
8385 MTLK_INIT_STEP(df_user, ALLOC_NAME, MTLK_OBJ_PTR(df_user), _mtlk_df_user_alloc_devname, (df_user));
8386
8387 MTLK_INIT_STEP(df_user, CREATE_CARD_DIR, MTLK_OBJ_PTR(df_user),
8388 _mtlk_df_ui_create_card_dir, (df_user));
8389
8390 MTLK_INIT_STEP(df_user, CREATE_DEBUG_DIR, MTLK_OBJ_PTR(df_user),
8391 _mtlk_df_ui_create_debug_dir, (df_user));
8392
8393 MTLK_INIT_STEP(df_user, STAT_TIMER, MTLK_OBJ_PTR(df_user),
8394 mtlk_osal_timer_init,
8395 (&df_user->slow_ctx->stat_timer, _mtlk_df_poll_stats, HANDLE_T(df_user)));
8396
8397 _mtlk_df_user_fill_callbacks(df_user);
8398
8399 #ifdef MTCFG_IRB_DEBUG
8400 /* TODO: GS: It's used ROOT IRB ??? Allow it only for MASTER??*/
8401 MTLK_INIT_STEP(df_user, IRB_PINGER_INIT, MTLK_OBJ_PTR(df_user),
8402 mtlk_irb_pinger_init,
8403 (&df_user->slow_ctx->pinger, mtlk_irbd_get_root()));
8404 #endif /*MTCFG_IRB_DEBUG*/
8405
8406 for (i = 0; i < ARRAY_SIZE(_proc_management_handlers); i++) {
8407 MTLK_INIT_STEP_LOOP(df_user, PROC_INIT, MTLK_OBJ_PTR(df_user),
8408 _proc_management_handlers[i].on_register, (df_user));
8409 }
8410
8411 vap = mtlk_df_get_vap_handle(df_user->df);
8412 res = mtlk_vap_get_hw_vft(vap)->get_prop(vap, MTLK_HW_PROP_CARD_TYPE,
8413 &card_type, sizeof(&card_type));
8414
8415 MTLK_ASSERT(MTLK_ERR_OK == res);
8416 CARD_SELECTOR_START(card_type)
8417 IF_CARD_G3 (
8418 for (i = 0; i < ARRAY_SIZE(_proc_management_pci_pcie_handlers); i++) {
8419 MTLK_INIT_STEP_LOOP(df_user, PROC_CARD_INIT, MTLK_OBJ_PTR(df_user),
8420 _proc_management_pci_pcie_handlers[i].on_register, (df_user));
8421 }
8422 );
8423 IF_CARD_AHBG35 (
8424 for (i = 0; i < ARRAY_SIZE(_proc_management_ahb_handlers); i++) {
8425 MTLK_INIT_STEP_LOOP(df_user, PROC_CARD_INIT, MTLK_OBJ_PTR(df_user),
8426 _proc_management_ahb_handlers[i].on_register, (df_user));
8427 }
8428 );
8429 CARD_SELECTOR_END();
8430
8431 for (i = 0; i < ARRAY_SIZE(df_user->fw_hang_evts); i++) {
8432 MTLK_INIT_STEP_LOOP(df_user, FW_HANG_EVTs, MTLK_OBJ_PTR(df_user),
8433 mtlk_osal_event_init, (&df_user->fw_hang_evts[i]));
8434 }
8435
8436 MTLK_INIT_FINALLY(df_user, MTLK_OBJ_PTR(df_user))
8437 MTLK_INIT_RETURN(df_user, MTLK_OBJ_PTR(df_user), _mtlk_df_user_cleanup, (df_user))
8438 }
8439
8440 mtlk_df_user_t*
8441 mtlk_df_user_create(mtlk_df_t *df)
8442 {
8443 struct net_device *dev = alloc_etherdev(sizeof(mtlk_df_user_t));
8444 mtlk_df_user_t* df_user;
8445
8446 if(NULL == dev)
8447 {
8448 ELOG_V("Failed to allocate network device");
8449 return NULL;
8450 }
8451
8452 df_user = netdev_priv(dev);
8453
8454 if(MTLK_ERR_OK != _mtlk_df_user_init(df_user, df, dev))
8455 {
8456 free_netdev(dev);
8457 return NULL;
8458 }
8459
8460 return df_user;
8461 }
8462
8463 void
8464 mtlk_df_user_delete(mtlk_df_user_t* df_user)
8465 {
8466 struct net_device* dev = df_user->dev;
8467
8468 _mtlk_df_user_cleanup(df_user);
8469 if (dev && !dev->destructor) {
8470 free_netdev(dev);
8471 }
8472 }
8473
8474 /******************************************************************************************
8475 * BCL debugging interface implementation
8476 ******************************************************************************************/
8477 /* TODO: add packing
8478 * Do not change this structure (synchronized with BCLSockServer) */
8479 typedef struct _BCL_DRV_DATA_EX_REQUEST
8480 {
8481 uint32 mode;
8482 uint32 category;
8483 uint32 index;
8484 uint32 datalen;
8485 } BCL_DRV_DATA_EX_REQUEST;
8486
8487 /* BCL Driver message modes
8488 * Do not change these numbers (synchronized with BCLSockServer) */
8489 typedef enum
8490 {
8491 BclDrvModeCatInit = 1,
8492 BclDrvModeCatFree = 2,
8493 BclDrvModeNameGet = 3,
8494 BclDrvModeValGet = 4,
8495 BclDrvModeValSet = 5
8496 } BCL_DRV_DATA_EX_MODE;
8497
8498 /* BCL Driver message categories for DRV_* commands */
8499 /* Do not change these values (synchronized with BBStudio) */
8500 #define DRVCAT_DBG_API_RESET 1
8501 #define DRVCAT_DBG_API_GENERAL_PKT 2
8502 #define DRVCAT_DBG_API_GENERAL 3
8503 #define DRVCAT_DBG_API_MAC_STATS 4
8504 #define DRVCAT_DBG_API_RR_STATS 5
8505
8506 /* Subcommand indices for DRVCAT_DBG_API_RESET: */
8507 /* Do not change these values (synchronized with BBStudio) */
8508 #define IDX_DBG_API_RESET_ALL 1
8509
8510 /***** DRVCAT_DBG_API_RR_STATS categories definitions */
8511 /**
8512 * The header string should be returned on get_text with 0 index value.
8513 **/
8514 const char bcl_rr_counters_hdr[] = "MAC|ID|Too old|Duplicate|Queued|Overflows|Lost";
8515 const int bcl_rr_counters_num_cnts = 5;
8516
8517 /***** DRVCAT_DBG_API_GENERAL_PKT categories definitions */
8518 /**
8519 * The header string should be returned on get_text with 0 index value.
8520 * The footer string should be returned on get_text with last index value.
8521 **/
8522 const char bcl_pkt_counters_hdr[] = "MAC|Packets received|Packets sent";
8523 const int bcl_pkt_counters_num_cnts = 2;
8524 const char bcl_pkt_counters_ftr[] = "Total";
8525
8526 /***** DRVCAT_DBG_API_GENERAL categories definitions */
8527 #define MAX_STAT_NAME_LENGTH 256
8528
8529 #define FETCH_NAME 1
8530 #define FETCH_VAL 2
8531
8532 /* General statistic data processing structures */
8533 struct bcl_general_count_stat_params_t
8534 {
8535 int num_stats;
8536 };
8537
8538 struct bcl_general_fetch_stat_params_t
8539 {
8540 int index_search;
8541 int index_cur;
8542 int what;
8543 char name[MAX_STAT_NAME_LENGTH];
8544 unsigned long val;
8545 };
8546
8547 /***********************************************************
8548 * BCL function implementation
8549 ***********************************************************/
8550 static int
8551 mtlk_df_debug_bcl_category_free(mtlk_df_user_t *df_user, uint32 category);
8552
8553 void
8554 mtlk_df_debug_bcl_cleanup(mtlk_df_user_t *df_user)
8555 {
8556 mtlk_df_debug_bcl_category_free(df_user, DRVCAT_DBG_API_GENERAL);
8557 mtlk_df_debug_bcl_category_free(df_user, DRVCAT_DBG_API_GENERAL_PKT);
8558 mtlk_df_debug_bcl_category_free(df_user, DRVCAT_DBG_API_RR_STATS);
8559 mtlk_df_debug_bcl_category_free(df_user, DRVCAT_DBG_API_MAC_STATS);
8560 }
8561
8562 int
8563 mtlk_df_debug_bcl_init(mtlk_df_user_t *df_user)
8564 {
8565 df_user->slow_ctx->dbg_rr_addr = NULL;
8566 df_user->slow_ctx->dbg_rr_addr_num = 0;
8567 df_user->slow_ctx->dbg_rr_cnts = NULL;
8568 df_user->slow_ctx->dbg_rr_cnts_num = 0;
8569
8570 df_user->slow_ctx->dbg_general_pkt_addr = NULL;
8571 df_user->slow_ctx->dbg_general_pkt_addr_num = 0;
8572 df_user->slow_ctx->dbg_general_pkt_cnts = NULL;
8573 df_user->slow_ctx->dbg_general_pkt_cnts_num = 0;
8574 return MTLK_ERR_OK;
8575 }
8576
8577 static int
8578 mtlk_df_debug_bcl_debug_mac_stats_init(mtlk_df_user_t *df_user, uint32 *pcnt)
8579 {
8580 int res = MTLK_ERR_OK;
8581
8582 ILOG2_S("%s: Create mac_stats_init", mtlk_df_user_get_name(df_user));
8583
8584 /* Get MAC statistic from DF buffer and don't call Core */
8585
8586 *pcnt = mtlk_df_get_stat_info_len();
8587
8588 return res;
8589 }
8590
8591 static int
8592 mtlk_df_debug_bcl_debug_rr_counters_init(mtlk_df_user_t *df_user, uint32 *pcnt)
8593 {
8594 int res = MTLK_ERR_NOT_SUPPORTED;
8595 mtlk_clpb_t *clpb = NULL;
8596 uint32 size;
8597 mtlk_stadb_stat_t *stadb_stat;
8598 mtlk_core_ui_get_stadb_status_req_t get_stadb_status_req;
8599 uint8 tid;
8600
8601 uint32 num_sta_connected = 0;
8602 uint32 addr_num_entries_max = 0;
8603 uint32 cnt_num_entries_max = 0;
8604 uint32 *dbg_rr_cnts = NULL;
8605 IEEE_ADDR *dbg_rr_addr = NULL;
8606
8607 uint32 addr_cur_entry = 0;
8608 uint32 cnts_cur_entry = 0;
8609
8610 ILOG2_S("%s: Create rr_counters", mtlk_df_user_get_name(df_user));
8611
8612 ASSERT(df_user->slow_ctx->dbg_rr_addr == NULL);
8613 ASSERT(df_user->slow_ctx->dbg_rr_cnts == NULL);
8614
8615 *pcnt = 0;
8616
8617 get_stadb_status_req.get_hostdb = FALSE;
8618 get_stadb_status_req.use_cipher = FALSE;
8619 res = _mtlk_df_user_invoke_core(df_user->df, MTLK_CORE_REQ_GET_STADB_STATUS,
8620 &clpb, &get_stadb_status_req, sizeof(get_stadb_status_req));
8621 res = _mtlk_df_user_process_core_retval_void(res, clpb, MTLK_CORE_REQ_GET_STADB_STATUS, FALSE);
8622 if (MTLK_ERR_OK != res) {
8623 goto finish;
8624 }
8625
8626 num_sta_connected = mtlk_clpb_get_num_of_elements(clpb);
8627 if (0 == num_sta_connected) {
8628 goto delete_clpb;
8629 }
8630
8631 addr_num_entries_max = num_sta_connected * NTS_TIDS;
8632 cnt_num_entries_max = num_sta_connected * NTS_TIDS * (bcl_rr_counters_num_cnts + 1/*+TID*/);
8633
8634 dbg_rr_addr = mtlk_osal_mem_alloc(addr_num_entries_max * sizeof(IEEE_ADDR), MTLK_MEM_TAG_DEBUG_DATA);
8635 if (NULL == dbg_rr_addr) {
8636 ELOG_V("Out of memory");
8637 res = MTLK_ERR_NO_MEM;
8638 goto delete_clpb;
8639 }
8640 memset(dbg_rr_addr, 0, addr_num_entries_max * sizeof(IEEE_ADDR));
8641
8642 dbg_rr_cnts = mtlk_osal_mem_alloc(cnt_num_entries_max * sizeof(uint32), MTLK_MEM_TAG_DEBUG_DATA);
8643 if (NULL == dbg_rr_cnts) {
8644 ELOG_V("Out of memory");
8645 res = MTLK_ERR_NO_MEM;
8646 goto delete_dbg_rr_addr;
8647 }
8648 memset(dbg_rr_cnts, 0, cnt_num_entries_max * sizeof(uint32));
8649
8650 addr_cur_entry = 0;
8651 cnts_cur_entry = 0;
8652
8653 while(NULL != (stadb_stat = mtlk_clpb_enum_get_next(clpb, &size))) {
8654 if ((sizeof(*stadb_stat) != size) || (STAT_ID_STADB != stadb_stat->type)) {
8655 res = MTLK_ERR_UNKNOWN;
8656 goto delete_dbg_rr_cnts;
8657 }
8658
8659 for (tid = 0; tid < ARRAY_SIZE(stadb_stat->u.general_stat.reordering_stats); tid++ )
8660 {
8661 if (stadb_stat->u.general_stat.reordering_stats[tid].used) {
8662 ASSERT(addr_cur_entry < addr_num_entries_max);
8663 dbg_rr_addr[addr_cur_entry++] = stadb_stat->u.general_stat.addr;
8664
8665 ASSERT(cnts_cur_entry < cnt_num_entries_max);
8666 dbg_rr_cnts[cnts_cur_entry++] = tid;
8667
8668 ASSERT(cnts_cur_entry < cnt_num_entries_max);
8669 dbg_rr_cnts[cnts_cur_entry++] =
8670 stadb_stat->u.general_stat.reordering_stats[tid].reord_stat.too_old;
8671
8672 ASSERT(cnts_cur_entry < cnt_num_entries_max);
8673 dbg_rr_cnts[cnts_cur_entry++] =
8674 stadb_stat->u.general_stat.reordering_stats[tid].reord_stat.duplicate;
8675
8676 ASSERT(cnts_cur_entry < cnt_num_entries_max);
8677 dbg_rr_cnts[cnts_cur_entry++] =
8678 stadb_stat->u.general_stat.reordering_stats[tid].reord_stat.queued;
8679
8680 ASSERT(cnts_cur_entry < cnt_num_entries_max);
8681 dbg_rr_cnts[cnts_cur_entry++] =
8682 stadb_stat->u.general_stat.reordering_stats[tid].reord_stat.overflows;
8683
8684 ASSERT(cnts_cur_entry < cnt_num_entries_max);
8685 dbg_rr_cnts[cnts_cur_entry++] =
8686 stadb_stat->u.general_stat.reordering_stats[tid].reord_stat.lost;
8687 }
8688 }
8689 }
8690
8691 df_user->slow_ctx->dbg_rr_addr = dbg_rr_addr;
8692 df_user->slow_ctx->dbg_rr_addr_num = addr_cur_entry;
8693 df_user->slow_ctx->dbg_rr_cnts = dbg_rr_cnts;
8694 df_user->slow_ctx->dbg_rr_cnts_num = cnts_cur_entry;
8695
8696 ILOG2_DDDDD("Created "
8697 "num_sta_connected (%d), "
8698 "addr_num (%d), cnts_num (%d), "
8699 "addr_num_entries_max (%d), cnt_num_entries_max (%d)",
8700 num_sta_connected,
8701 addr_cur_entry, cnts_cur_entry,
8702 addr_num_entries_max, cnt_num_entries_max);
8703
8704 *pcnt = addr_cur_entry;
8705
8706 if (0 == addr_cur_entry) {
8707 /* Not TIDs used */
8708 goto delete_dbg_rr_cnts;
8709 }
8710
8711 goto delete_clpb;
8712
8713 delete_dbg_rr_cnts:
8714 mtlk_osal_mem_free(dbg_rr_cnts);
8715 delete_dbg_rr_addr:
8716 mtlk_osal_mem_free(dbg_rr_addr);
8717 delete_clpb:
8718 mtlk_clpb_delete(clpb);
8719 finish:
8720 return res;
8721 }
8722
8723 static int
8724 mtlk_df_debug_bcl_debug_pkt_counters_init(mtlk_df_user_t *df_user, uint32 *pcnt)
8725 {
8726 int res = MTLK_ERR_NOT_SUPPORTED;
8727 mtlk_clpb_t *clpb = NULL;
8728 uint32 size;
8729
8730 uint32 num_sta_connected;
8731 uint32 addr_num_entries_max;
8732 uint32 cnt_num_entries_max;
8733 uint32 *dbg_general_pkt_cnts = NULL;
8734 IEEE_ADDR *dbg_general_pkt_addr = NULL;
8735 uint32 addr_cur_entry = 0;
8736 uint32 cnts_cur_entry = 0;
8737 uint32 total_rx_packets = 0;
8738 uint32 total_tx_packets = 0;
8739
8740 ILOG2_S("%s: Create pkt_counters", mtlk_df_user_get_name(df_user));
8741
8742 ASSERT(df_user->slow_ctx->dbg_general_pkt_cnts == NULL);
8743 ASSERT(df_user->slow_ctx->dbg_general_pkt_addr == NULL);
8744
8745 *pcnt = 0;
8746
8747 if (mtlk_df_is_ap(df_user->df)) { /*AP*/
8748 mtlk_stadb_stat_t *stadb_stat;
8749 mtlk_core_ui_get_stadb_status_req_t get_stadb_status_req;
8750
8751 get_stadb_status_req.get_hostdb = FALSE;
8752 get_stadb_status_req.use_cipher = FALSE;
8753 res = _mtlk_df_user_invoke_core(df_user->df, MTLK_CORE_REQ_GET_STADB_STATUS,
8754 &clpb, &get_stadb_status_req, sizeof(get_stadb_status_req));
8755 res = _mtlk_df_user_process_core_retval_void(res, clpb, MTLK_CORE_REQ_GET_STADB_STATUS, FALSE);
8756 if (MTLK_ERR_OK != res) {
8757 goto finish;
8758 }
8759
8760 num_sta_connected = mtlk_clpb_get_num_of_elements(clpb);
8761 if (0 == num_sta_connected) {
8762 goto delete_clpb;
8763 }
8764
8765 addr_num_entries_max = num_sta_connected;
8766 cnt_num_entries_max = (num_sta_connected + 1 /*Total*/) * bcl_pkt_counters_num_cnts;
8767
8768 dbg_general_pkt_addr = mtlk_osal_mem_alloc(addr_num_entries_max * sizeof(IEEE_ADDR), MTLK_MEM_TAG_DEBUG_DATA);
8769 if (NULL == dbg_general_pkt_addr) {
8770 ELOG_V("Out of memory");
8771 res = MTLK_ERR_NO_MEM;
8772 goto delete_clpb;
8773 }
8774 memset(dbg_general_pkt_addr, 0, addr_num_entries_max * sizeof(IEEE_ADDR));
8775
8776 dbg_general_pkt_cnts = mtlk_osal_mem_alloc(cnt_num_entries_max * sizeof(uint32), MTLK_MEM_TAG_DEBUG_DATA);
8777 if (NULL == dbg_general_pkt_cnts) {
8778 ELOG_V("Out of memory");
8779 res = MTLK_ERR_NO_MEM;
8780 goto delete_dbg_general_pkt_addr;
8781 }
8782 memset(dbg_general_pkt_cnts, 0, cnt_num_entries_max * sizeof(uint32));
8783
8784 while(NULL != (stadb_stat = mtlk_clpb_enum_get_next(clpb, &size))) {
8785 if ((sizeof(*stadb_stat) != size) || (STAT_ID_STADB != stadb_stat->type)) {
8786 res = MTLK_ERR_UNKNOWN;
8787 goto delete_dbg_general_pkt_cnts;
8788 }
8789
8790 ASSERT(addr_cur_entry < addr_num_entries_max);
8791 dbg_general_pkt_addr[addr_cur_entry++] = stadb_stat->u.general_stat.addr;
8792
8793 total_rx_packets += stadb_stat->u.general_stat.sta_rx_packets;
8794 total_tx_packets += stadb_stat->u.general_stat.sta_tx_packets;
8795
8796 ASSERT(cnts_cur_entry < cnt_num_entries_max);
8797 dbg_general_pkt_cnts[cnts_cur_entry++] = stadb_stat->u.general_stat.sta_rx_packets;
8798
8799 ASSERT(cnts_cur_entry < cnt_num_entries_max);
8800 dbg_general_pkt_cnts[cnts_cur_entry++] = stadb_stat->u.general_stat.sta_tx_packets;
8801 }
8802 } else { /*STA*/
8803 mtlk_core_general_stats_t *general_stats;
8804
8805 /* Get Core general information from DF buffer and don't call Core */
8806 general_stats = &df_user->slow_ctx->core_general_stats;
8807
8808 if (!mtlk_core_net_state_is_connected(general_stats->net_state)) {
8809 res = MTLK_ERR_NOT_READY;
8810 goto finish;
8811 }
8812
8813 num_sta_connected = 1;
8814 addr_num_entries_max = num_sta_connected;
8815 cnt_num_entries_max = (num_sta_connected + 1 /*Total*/) * bcl_pkt_counters_num_cnts;
8816
8817 dbg_general_pkt_addr =
8818 mtlk_osal_mem_alloc(addr_num_entries_max * sizeof(IEEE_ADDR), MTLK_MEM_TAG_DEBUG_DATA);
8819 if (NULL == dbg_general_pkt_addr) {
8820 ELOG_V("Out of memory");
8821 res = MTLK_ERR_NO_MEM;
8822 goto finish;
8823 }
8824 memset(dbg_general_pkt_addr, 0, addr_num_entries_max * sizeof(IEEE_ADDR));
8825
8826 dbg_general_pkt_cnts =
8827 mtlk_osal_mem_alloc(cnt_num_entries_max * sizeof(uint32), MTLK_MEM_TAG_DEBUG_DATA);
8828 if (NULL == dbg_general_pkt_cnts) {
8829 ELOG_V("Out of memory");
8830 res = MTLK_ERR_NO_MEM;
8831 mtlk_osal_mem_free(dbg_general_pkt_addr);
8832 goto finish;
8833 }
8834 memset(dbg_general_pkt_cnts, 0, cnt_num_entries_max * sizeof(uint32));
8835
8836 memcpy(&dbg_general_pkt_addr[addr_cur_entry++], general_stats->bssid, sizeof(IEEE_ADDR));
8837
8838 total_rx_packets = general_stats->core_priv_stats.sta_session_rx_packets;
8839 total_tx_packets = general_stats->core_priv_stats.sta_session_tx_packets;
8840
8841 dbg_general_pkt_cnts[cnts_cur_entry++] = total_rx_packets;
8842 dbg_general_pkt_cnts[cnts_cur_entry++] = total_tx_packets;
8843 }
8844
8845 ASSERT(cnts_cur_entry < cnt_num_entries_max);
8846 dbg_general_pkt_cnts[cnts_cur_entry++] = total_rx_packets;
8847
8848 ASSERT(cnts_cur_entry < cnt_num_entries_max);
8849 dbg_general_pkt_cnts[cnts_cur_entry++] = total_tx_packets;
8850
8851 df_user->slow_ctx->dbg_general_pkt_addr = dbg_general_pkt_addr;
8852 df_user->slow_ctx->dbg_general_pkt_addr_num = addr_cur_entry;
8853 df_user->slow_ctx->dbg_general_pkt_cnts = dbg_general_pkt_cnts;
8854 df_user->slow_ctx->dbg_general_pkt_cnts_num = cnts_cur_entry;
8855
8856 ILOG2_DDDDD("Created "
8857 "num_sta_connected (%d), "
8858 "addr_num (%d), cnts_num (%d), "
8859 "addr_num_entries_max (%d), cnt_num_entries_max (%d)",
8860 num_sta_connected,
8861 addr_cur_entry, cnts_cur_entry,
8862 addr_num_entries_max, cnt_num_entries_max);
8863
8864 *pcnt = addr_cur_entry + 1 /*Total*/;
8865
8866 if (0 == addr_cur_entry) {
8867 /* Not TIDs used */
8868 goto delete_dbg_general_pkt_cnts;
8869 }
8870
8871 goto delete_clpb;
8872
8873 delete_dbg_general_pkt_cnts:
8874 mtlk_osal_mem_free(dbg_general_pkt_cnts);
8875 delete_dbg_general_pkt_addr:
8876 mtlk_osal_mem_free(dbg_general_pkt_addr);
8877 delete_clpb:
8878 mtlk_clpb_delete(clpb);
8879 finish:
8880 return res;
8881 }
8882
8883 static int mtlk_df_debug_bcl_debug_general_iterate(mtlk_df_user_t *df_user,
8884 int (* fn)(void *params, unsigned long val, const char* str), void *params)
8885 {
8886 int i;
8887 char buf[MAX_STAT_NAME_LENGTH];
8888
8889 if (MTLK_ERR_OK != fn(params, df_user->slow_ctx->core_general_stats.rx_dat_frames,
8890 "data frames received"))
8891 return MTLK_ERR_PARAMS;
8892 if (MTLK_ERR_OK != fn(params, df_user->slow_ctx->core_general_stats.rx_ctl_frames,
8893 "control frames received"))
8894 return MTLK_ERR_PARAMS;
8895 if (MTLK_ERR_OK != fn(params, df_user->slow_ctx->core_general_stats.rx_man_frames,
8896 "management frames received"))
8897 return MTLK_ERR_PARAMS;
8898 if (MTLK_ERR_OK != fn(params, df_user->slow_ctx->core_general_stats.mac_stat.stat[STAT_TX_FAIL],
8899 "TX packets dropped"))
8900 return MTLK_ERR_PARAMS;
8901 if (MTLK_ERR_OK != fn(params, df_user->slow_ctx->core_general_stats.core_priv_stats.tx_max_cons_drop,
8902 "TX maximum consecutive dropped packets"))
8903 return MTLK_ERR_PARAMS;
8904
8905 for (i = 0; i < NTS_PRIORITIES; i++) {
8906 sprintf(buf, "MSDUs received, QoS priority %d", i);
8907 if (MTLK_ERR_OK != fn(params, df_user->slow_ctx->core_general_stats.core_priv_stats.ac_rx_counter[i], buf))
8908 return MTLK_ERR_PARAMS;
8909 }
8910
8911 for (i = 0; i < NTS_PRIORITIES; i++) {
8912 sprintf(buf, "MSDUs transmitted, QoS priority %d", i);
8913 if (MTLK_ERR_OK != fn(params, df_user->slow_ctx->core_general_stats.core_priv_stats.ac_tx_counter[i], buf))
8914 return MTLK_ERR_PARAMS;
8915 }
8916
8917 for (i = 0; i < NTS_PRIORITIES; i++) {
8918 sprintf(buf, "MSDUs dropped, QoS priority %d", i);
8919 if (MTLK_ERR_OK != fn(params, df_user->slow_ctx->core_general_stats.core_priv_stats.ac_dropped_counter[i], buf))
8920 return MTLK_ERR_PARAMS;
8921 }
8922
8923 for (i = 0; i < NTS_PRIORITIES; i++) {
8924 sprintf(buf, "MSDUs used, QoS priority %d", i);
8925 if (MTLK_ERR_OK != fn(params, df_user->slow_ctx->core_general_stats.core_priv_stats.ac_used_counter[i], buf))
8926 return MTLK_ERR_PARAMS;
8927 }
8928
8929 if (MTLK_ERR_OK != fn(params, df_user->slow_ctx->core_general_stats.tx_msdus_free, "TX MSDUs free"))
8930 return MTLK_ERR_PARAMS;
8931 if (MTLK_ERR_OK != fn(params, df_user->slow_ctx->core_general_stats.tx_msdus_usage_peak, "TX MSDUs usage peak"))
8932 return MTLK_ERR_PARAMS;
8933 if (MTLK_ERR_OK != fn(params, df_user->slow_ctx->core_general_stats.fwd_rx_packets,
8934 "packets received that should be forwarded to one or more STAs"))
8935 return MTLK_ERR_PARAMS;
8936 if (MTLK_ERR_OK !=fn(params, df_user->slow_ctx->core_general_stats.fwd_rx_bytes,
8937 "bytes received that should be forwarded to one or more STAs"))
8938 return MTLK_ERR_PARAMS;
8939 if (MTLK_ERR_OK !=fn(params, df_user->slow_ctx->core_general_stats.core_priv_stats.fwd_tx_packets,
8940 "packets transmitted for forwarded data"))
8941 return MTLK_ERR_PARAMS;
8942 if (MTLK_ERR_OK !=fn(params, df_user->slow_ctx->core_general_stats.core_priv_stats.fwd_tx_bytes,
8943 "bytes transmitted for forwarded data"))
8944 return MTLK_ERR_PARAMS;
8945 if (MTLK_ERR_OK !=fn(params, df_user->slow_ctx->core_general_stats.core_priv_stats.fwd_dropped,
8946 "forwarding (transmission) failures"))
8947 return MTLK_ERR_PARAMS;
8948 if (MTLK_ERR_OK !=fn(params, df_user->slow_ctx->core_general_stats.core_priv_stats.rmcast_dropped,
8949 "reliable multicast (transmission) failures"))
8950 return MTLK_ERR_PARAMS;
8951 if (MTLK_ERR_OK !=fn(params, df_user->slow_ctx->core_general_stats.unicast_replayed_packets+df_user->slow_ctx->core_general_stats.multicast_replayed_packets,
8952 "packets replayed"))
8953 return MTLK_ERR_PARAMS;
8954 if (MTLK_ERR_OK !=fn(params, df_user->slow_ctx->core_general_stats.core_priv_stats.bars_cnt,
8955 "BAR frames received"))
8956 return MTLK_ERR_PARAMS;
8957
8958 #ifdef MTLK_HAVE_PPA
8959 {
8960 mtlk_df_user_ppa_stats_t ppa_stats;
8961
8962 _mtlk_df_user_ppa_get_stats(df_user, &ppa_stats);
8963
8964 if (MTLK_ERR_OK !=fn(params, ppa_stats.tx_processed, "TX Frames processed from PPA"))
8965 return MTLK_ERR_PARAMS;
8966 if (MTLK_ERR_OK !=fn(params, _mtlk_df_user_ppa_tx_sent_up, "TX Frames sent up from PPA"))
8967 return MTLK_ERR_PARAMS;
8968 if (MTLK_ERR_OK !=fn(params, _mtlk_df_user_ppa_tx_dropped, "TX Frames dropped from PPA"))
8969 return MTLK_ERR_PARAMS;
8970 if (MTLK_ERR_OK !=fn(params, ppa_stats.rx_accepted, "RX Frames accepted by PPA"))
8971 return MTLK_ERR_PARAMS;
8972 if (MTLK_ERR_OK !=fn(params, ppa_stats.rx_rejected, "RX Frames rejected by PPA"))
8973 return MTLK_ERR_PARAMS;
8974 }
8975 #endif
8976
8977 if (MTLK_ERR_OK !=fn(params, df_user->slow_ctx->core_general_stats.bist_check_passed, "BIST check passed"))
8978 return MTLK_ERR_PARAMS;
8979
8980 return MTLK_ERR_OK;
8981 }
8982
8983 static int mtlk_df_debug_bcl_debug_general_count_stat(void *params, unsigned long val, const char* str)
8984 {
8985 struct bcl_general_count_stat_params_t *pcsp = (struct bcl_general_count_stat_params_t *) params;
8986 ++pcsp->num_stats;
8987 return MTLK_ERR_OK;
8988 }
8989
8990 static int mtlk_df_debug_bcl_debug_general_fetch_stat(void *params, unsigned long val, const char *str)
8991 {
8992 struct bcl_general_fetch_stat_params_t *pfsp = (struct bcl_general_fetch_stat_params_t*) params;
8993 int res = MTLK_ERR_OK;
8994
8995 if (pfsp->index_cur == pfsp->index_search) {
8996 if (pfsp->what == FETCH_VAL)
8997 pfsp->val = val;
8998
8999 else if (pfsp->what == FETCH_NAME) {
9000 int rslt = snprintf(pfsp->name, MAX_STAT_NAME_LENGTH, "%s", str);
9001 if (rslt < 0 || rslt >= MAX_STAT_NAME_LENGTH)
9002 res = MTLK_ERR_PARAMS;
9003
9004 } else {
9005 res = MTLK_ERR_PARAMS;
9006 }
9007 }
9008 ++pfsp->index_cur;
9009 return res;
9010 }
9011
9012 static int
9013 mtlk_df_debug_bcl_debug_general_init(mtlk_df_user_t *df_user, uint32 *pcnt)
9014 {
9015 int res = MTLK_ERR_OK;
9016 struct bcl_general_count_stat_params_t csp;
9017
9018 ILOG2_S("%s: Create general", mtlk_df_user_get_name(df_user));
9019
9020 /* Get Core general information from DF buffer and don't call Core */
9021 *pcnt = 0;
9022
9023 csp.num_stats = 0;
9024 res = mtlk_df_debug_bcl_debug_general_iterate(
9025 df_user, &mtlk_df_debug_bcl_debug_general_count_stat, &csp);
9026 if (MTLK_ERR_OK != res) {
9027 ELOG_V("Error while iterating driver statistics");
9028 goto finish;
9029 }
9030
9031 *pcnt = csp.num_stats;
9032
9033 finish:
9034 return res;
9035 }
9036
9037 static int
9038 mtlk_df_debug_bcl_category_init(mtlk_df_user_t *df_user, uint32 category, uint32 *cnt)
9039 {
9040 int res = MTLK_ERR_PARAMS;
9041
9042 mtlk_df_debug_bcl_category_free(df_user, category);
9043
9044 switch (category)
9045 {
9046 case DRVCAT_DBG_API_GENERAL:
9047 res = mtlk_df_debug_bcl_debug_general_init(df_user, cnt);
9048 break;
9049 case DRVCAT_DBG_API_GENERAL_PKT:
9050 res = mtlk_df_debug_bcl_debug_pkt_counters_init(df_user, cnt);
9051 break;
9052 case DRVCAT_DBG_API_RR_STATS:
9053 res = mtlk_df_debug_bcl_debug_rr_counters_init(df_user, cnt);
9054 break;
9055 case DRVCAT_DBG_API_MAC_STATS:
9056 res = mtlk_df_debug_bcl_debug_mac_stats_init(df_user, cnt);
9057 break;
9058 default:
9059 ELOG_D("Unsupported data category (%u) requested", category);
9060 break;
9061 }
9062 return res;
9063 }
9064
9065 static int
9066 mtlk_df_debug_bcl_debug_mac_stats_category_free(mtlk_df_user_t *df_user)
9067 {
9068 ILOG2_S("%s: Free mac_stats_category_free", mtlk_df_user_get_name(df_user));
9069
9070 return MTLK_ERR_OK;
9071 }
9072
9073 static int
9074 mtlk_df_debug_bcl_debug_rr_counters_category_free(mtlk_df_user_t *df_user)
9075 {
9076 ILOG2_S("%s: Free rr_counters", mtlk_df_user_get_name(df_user));
9077
9078 if (NULL != df_user->slow_ctx->dbg_rr_addr) {
9079 mtlk_osal_mem_free(df_user->slow_ctx->dbg_rr_addr);
9080 df_user->slow_ctx->dbg_rr_addr = NULL;
9081 }
9082 df_user->slow_ctx->dbg_rr_addr_num = 0;
9083
9084 if (NULL != df_user->slow_ctx->dbg_rr_cnts) {
9085 mtlk_osal_mem_free(df_user->slow_ctx->dbg_rr_cnts);
9086 df_user->slow_ctx->dbg_rr_cnts = NULL;
9087 }
9088 df_user->slow_ctx->dbg_rr_cnts_num = 0;
9089 return MTLK_ERR_OK;
9090 }
9091
9092 static int
9093 mtlk_df_debug_bcl_debug_pkt_counters_category_free(mtlk_df_user_t *df_user)
9094 {
9095 ILOG2_S("%s: Free pkt_counters", mtlk_df_user_get_name(df_user));
9096
9097 if (NULL != df_user->slow_ctx->dbg_general_pkt_addr) {
9098 mtlk_osal_mem_free(df_user->slow_ctx->dbg_general_pkt_addr);
9099 df_user->slow_ctx->dbg_general_pkt_addr = NULL;
9100 }
9101 df_user->slow_ctx->dbg_general_pkt_addr_num = 0;
9102
9103 if (NULL != df_user->slow_ctx->dbg_general_pkt_cnts) {
9104 mtlk_osal_mem_free(df_user->slow_ctx->dbg_general_pkt_cnts);
9105 df_user->slow_ctx->dbg_general_pkt_cnts = NULL;
9106 }
9107 df_user->slow_ctx->dbg_general_pkt_cnts_num = 0;
9108 return MTLK_ERR_OK;
9109 }
9110
9111 static int
9112 mtlk_df_debug_bcl_debug_general_category_free(mtlk_df_user_t *df_user)
9113 {
9114 ILOG2_S("%s: Free core_general_stats", mtlk_df_user_get_name(df_user));
9115
9116 return MTLK_ERR_OK;
9117 }
9118
9119 int
9120 mtlk_df_debug_bcl_category_free(mtlk_df_user_t *df_user, uint32 category)
9121 {
9122 int res = MTLK_ERR_PARAMS;
9123
9124 switch (category)
9125 {
9126 case DRVCAT_DBG_API_GENERAL:
9127 res = mtlk_df_debug_bcl_debug_general_category_free(df_user);
9128 break;
9129 case DRVCAT_DBG_API_GENERAL_PKT:
9130 res = mtlk_df_debug_bcl_debug_pkt_counters_category_free(df_user);
9131 break;
9132 case DRVCAT_DBG_API_RR_STATS:
9133 res = mtlk_df_debug_bcl_debug_rr_counters_category_free(df_user);
9134 break;
9135 case DRVCAT_DBG_API_MAC_STATS:
9136 res = mtlk_df_debug_bcl_debug_mac_stats_category_free(df_user);
9137 break;
9138 default:
9139 ELOG_D("Unsupported data category (%u) requested", category);
9140 break;
9141 }
9142 return res;
9143 }
9144
9145 static int
9146 mtlk_df_debug_bcl_debug_mac_stats_name_get(uint32 index, char *pdata, uint32 datalen)
9147 {
9148 int rslt;
9149 if (index >= mtlk_df_get_stat_info_len()) {
9150 ELOG_D("Index out of bounds (index %u)", index);
9151 return MTLK_ERR_PARAMS;
9152 }
9153 rslt = snprintf(pdata, datalen, "%s", mtlk_df_get_stat_info_name(index));
9154 if (rslt < 0 || rslt >= datalen) {
9155 WLOG_DD("Buffer size (%u) too small: string truncated (index %u)", datalen, index);
9156 }
9157
9158 return MTLK_ERR_OK;
9159 }
9160
9161 static int
9162 mtlk_df_debug_bcl_debug_rr_counters_name_get(
9163 mtlk_df_user_t *df_user, uint32 index, char *pdata, uint32 datalen)
9164 {
9165 int res = MTLK_ERR_OK;
9166 int rslt = 0;
9167
9168 if (index >= (df_user->slow_ctx->dbg_rr_addr_num + 1)) { /* +1 for header */
9169 ELOG_D("Index out of bounds (index %u)", index);
9170 res = MTLK_ERR_PARAMS;
9171
9172 } else if (0 == index) {
9173 rslt = snprintf(pdata, datalen, "%s", bcl_rr_counters_hdr);
9174
9175 } else if (NULL == df_user->slow_ctx->dbg_rr_addr) {
9176 res = MTLK_ERR_NOT_READY;
9177
9178 } else {
9179 rslt = snprintf(pdata, datalen, MAC_PRINTF_FMT,
9180 MAC_PRINTF_ARG(df_user->slow_ctx->dbg_rr_addr[index - 1].au8Addr));
9181 }
9182
9183 if (rslt < 0 || rslt >= datalen) {
9184 WLOG_DD("Buffer size (%u) too small: string truncated (index %u)", datalen, index);
9185 }
9186
9187 return res;
9188 }
9189
9190 static int
9191 mtlk_df_debug_bcl_debug_pkt_counters_name_get(
9192 mtlk_df_user_t *df_user, uint32 index, char *pdata, uint32 datalen)
9193 {
9194 int res = MTLK_ERR_OK;
9195 int rslt = 0;
9196
9197 if (index >= (df_user->slow_ctx->dbg_general_pkt_addr_num + 2)) { /* +1 for header +1 footer*/
9198 ELOG_D("Index out of bounds (index %u)", index);
9199 res = MTLK_ERR_PARAMS;
9200
9201 } else if (0 == index) {
9202 rslt = snprintf(pdata, datalen, "%s", bcl_pkt_counters_hdr);
9203
9204 } else if ((df_user->slow_ctx->dbg_general_pkt_addr_num + 1) == index) {
9205 rslt = snprintf(pdata, datalen, "%s", bcl_pkt_counters_ftr);
9206
9207 } else if (NULL == df_user->slow_ctx->dbg_general_pkt_addr) {
9208 res = MTLK_ERR_NOT_READY;
9209
9210 } else {
9211 rslt = snprintf(pdata, datalen, MAC_PRINTF_FMT,
9212 MAC_PRINTF_ARG(df_user->slow_ctx->dbg_general_pkt_addr[index - 1].au8Addr));
9213 }
9214
9215 if (rslt < 0 || rslt >= datalen) {
9216 WLOG_DD("Buffer size (%u) too small: string truncated (index %u)", datalen, index);
9217 }
9218
9219 return res;
9220 }
9221
9222 static int
9223 mtlk_df_debug_bcl_debug_general_name_get(
9224 mtlk_df_user_t *df_user, uint32 index, char *pdata, uint32 datalen)
9225 {
9226 int res = MTLK_ERR_OK;
9227 int rslt = 0;
9228 struct bcl_general_fetch_stat_params_t fsp;
9229
9230 fsp.index_cur = 0;
9231 fsp.index_search = index;
9232 fsp.what = FETCH_NAME;
9233
9234 res = mtlk_df_debug_bcl_debug_general_iterate(df_user, &mtlk_df_debug_bcl_debug_general_fetch_stat, &fsp);
9235 if (MTLK_ERR_OK != res) {
9236 ELOG_V("Error while iterating driver statistics");
9237 } else {
9238 rslt = snprintf(pdata, datalen, "%s", fsp.name);
9239 if (rslt < 0 || rslt >= datalen) {
9240 WLOG_DD("Buffer size (%u) too small: string truncated (index %u)", datalen, index);
9241 }
9242 }
9243
9244 return res;
9245 }
9246
9247 static int
9248 mtlk_df_debug_bcl_name_get(mtlk_df_user_t *df_user, uint32 category,
9249 uint32 index, char *pdata, uint32 datalen)
9250 {
9251 int res = MTLK_ERR_PARAMS;
9252
9253 switch (category)
9254 {
9255 case DRVCAT_DBG_API_GENERAL:
9256 res = mtlk_df_debug_bcl_debug_general_name_get(df_user, index, pdata, datalen);
9257 break;
9258 case DRVCAT_DBG_API_GENERAL_PKT:
9259 res = mtlk_df_debug_bcl_debug_pkt_counters_name_get(df_user, index, pdata, datalen);
9260 break;
9261 case DRVCAT_DBG_API_RR_STATS:
9262 res = mtlk_df_debug_bcl_debug_rr_counters_name_get(df_user, index, pdata, datalen);
9263 break;
9264 case DRVCAT_DBG_API_MAC_STATS:
9265 res = mtlk_df_debug_bcl_debug_mac_stats_name_get(index, pdata, datalen);
9266 break;
9267 default:
9268 ELOG_D("Unsupported data category (%u) requested", category);
9269 break;
9270 }
9271 return res;
9272 }
9273
9274 static int
9275 mtlk_df_debug_bcl_debug_mac_stats_val_get(mtlk_df_user_t *df_user, uint32 index, uint32 *pval)
9276 {
9277 int res = MTLK_ERR_OK;
9278
9279 if (index >= mtlk_df_get_stat_info_len()) {
9280 ELOG_D("Index out of bounds (index %u)", index);
9281 res = MTLK_ERR_PARAMS;
9282 } else {
9283 *pval = df_user->slow_ctx->core_general_stats.mac_stat.stat[mtlk_df_get_stat_info_idx(index)];
9284 }
9285
9286 return res;
9287 }
9288
9289 static int
9290 mtlk_df_debug_bcl_debug_rr_counters_val_get(mtlk_df_user_t *df_user, uint32 index, uint32 *pval)
9291 {
9292 int res = MTLK_ERR_OK;
9293
9294 if (NULL == df_user->slow_ctx->dbg_rr_cnts) {
9295 res = MTLK_ERR_NOT_READY;
9296 } else if (index >= df_user->slow_ctx->dbg_rr_cnts_num) {
9297 ELOG_D("Index out of bounds (index %u)", index);
9298 res = MTLK_ERR_PARAMS;
9299 } else {
9300 *pval = df_user->slow_ctx->dbg_rr_cnts[index];
9301 }
9302
9303 return res;
9304 }
9305
9306 static int
9307 mtlk_df_debug_bcl_debug_pkt_counters_val_get(mtlk_df_user_t *df_user, uint32 index, uint32 *pval)
9308 {
9309 int res = MTLK_ERR_OK;
9310
9311 if (NULL == df_user->slow_ctx->dbg_general_pkt_cnts) {
9312 res = MTLK_ERR_NOT_READY;
9313 } else if (index >= df_user->slow_ctx->dbg_general_pkt_cnts_num) {
9314 ELOG_D("Index out of bounds (index %u)", index);
9315 res = MTLK_ERR_PARAMS;
9316 } else {
9317 *pval = df_user->slow_ctx->dbg_general_pkt_cnts[index];
9318 }
9319
9320 return res;
9321 }
9322
9323 static int
9324 mtlk_df_debug_bcl_debug_general_val_get(mtlk_df_user_t *df_user, uint32 index, uint32 *pval)
9325 {
9326 int res = MTLK_ERR_OK;
9327 struct bcl_general_fetch_stat_params_t fsp;
9328
9329 fsp.index_cur = 0;
9330 fsp.index_search = index;
9331 fsp.what = FETCH_VAL;
9332
9333 res = mtlk_df_debug_bcl_debug_general_iterate(df_user, &mtlk_df_debug_bcl_debug_general_fetch_stat, &fsp);
9334 if (MTLK_ERR_OK != res) {
9335 ELOG_V("Error while iterating driver statistics");
9336 } else {
9337 *pval = fsp.val;
9338 }
9339
9340 return res;
9341 }
9342
9343 static int
9344 mtlk_df_debug_bcl_val_get(mtlk_df_user_t *df_user, uint32 category, uint32 index, uint32 *pval)
9345 {
9346 int res = MTLK_ERR_PARAMS;
9347
9348 switch (category)
9349 {
9350 case DRVCAT_DBG_API_GENERAL:
9351 res = mtlk_df_debug_bcl_debug_general_val_get(df_user, index, pval);
9352 break;
9353 case DRVCAT_DBG_API_GENERAL_PKT:
9354 res = mtlk_df_debug_bcl_debug_pkt_counters_val_get(df_user, index, pval);
9355 break;
9356 case DRVCAT_DBG_API_RR_STATS:
9357 res = mtlk_df_debug_bcl_debug_rr_counters_val_get(df_user, index, pval);
9358 break;
9359 case DRVCAT_DBG_API_MAC_STATS:
9360 res = mtlk_df_debug_bcl_debug_mac_stats_val_get(df_user, index, pval);
9361 break;
9362 default:
9363 ELOG_D("Unsupported data category (%u) requested", category);
9364 break;
9365 }
9366 return res;
9367 }
9368
9369 static int
9370 mtlk_df_debug_bcl_reset(mtlk_df_user_t *df_user, uint32 index, uint32 val)
9371 {
9372 int res = MTLK_ERR_PARAMS;
9373
9374 switch (index) {
9375 case IDX_DBG_API_RESET_ALL:
9376 res = mtlk_df_ui_reset_stats(df_user->df);
9377 #ifdef MTLK_HAVE_PPA
9378 _mtlk_df_user_ppa_zero_stats(df_user);
9379 #endif
9380 break;
9381 default:
9382 ELOG_D("Index out of bounds (index %u)", index);
9383 }
9384
9385 return res;
9386 }
9387
9388 static int
9389 mtlk_df_debug_bcl_val_put(mtlk_df_user_t *df_user, uint32 category, uint32 index, uint32 val)
9390 {
9391 int res = MTLK_ERR_PARAMS;
9392
9393 switch (category)
9394 {
9395 case DRVCAT_DBG_API_RESET:
9396 res = mtlk_df_debug_bcl_reset(df_user, index, val);
9397 break;
9398 default:
9399 ELOG_D("Unsupported data category (%u) requested", category);
9400 break;
9401 }
9402
9403 return res;
9404 }
9405
9406 int __MTLK_IFUNC
9407 mtlk_df_ui_linux_ioctl_bcl_drv_data_exchange (struct net_device *dev,
9408 struct iw_request_info *info,
9409 union iwreq_data *wrqu, char *extra)
9410 {
9411 mtlk_df_user_t *df_user = (mtlk_df_user_t*)netdev_priv(dev);
9412 BCL_DRV_DATA_EX_REQUEST preq;
9413 char *pdata = NULL;
9414 int res = MTLK_ERR_OK;
9415 uint32 value;
9416
9417 ILOG3_SSD("%s: Invoked from %s (%i)", dev->name, current->comm, current->pid);
9418
9419 if (mtlk_df_is_slave(df_user->df)) {
9420 res = MTLK_ERR_NOT_SUPPORTED;
9421 goto cleanup;
9422 }
9423
9424 if (0 != copy_from_user(&preq, wrqu->data.pointer, sizeof(preq))) {
9425 res = MTLK_ERR_VALUE;
9426 goto cleanup;
9427 }
9428
9429 switch (preq.mode) {
9430 case BclDrvModeCatInit:
9431 /* Make sure there's enough space to fit the counter: */
9432 if (sizeof(uint32) != preq.datalen) {
9433 res = MTLK_ERR_PARAMS;
9434 } else {
9435 /* Return category items counter to BCLSockServer: */
9436 res = mtlk_df_debug_bcl_category_init(df_user, preq.category, /* out */ &value);
9437 if (MTLK_ERR_OK == res) {
9438 if (0 != copy_to_user(wrqu->data.pointer + sizeof(preq), &value, sizeof(uint32))) {
9439 res = MTLK_ERR_VALUE;
9440 }
9441 }
9442 }
9443 break;
9444 case BclDrvModeCatFree:
9445 res = mtlk_df_debug_bcl_category_free(df_user, preq.category);
9446 break;
9447 case BclDrvModeNameGet:
9448 pdata = mtlk_osal_mem_alloc(preq.datalen * sizeof(char), MTLK_MEM_TAG_IOCTL);
9449 if (NULL == pdata) {
9450 res = MTLK_ERR_NO_MEM;
9451 } else {
9452 res = mtlk_df_debug_bcl_name_get(df_user, preq.category, preq.index, pdata, preq.datalen);
9453 if (MTLK_ERR_OK == res) {
9454 if (0 != copy_to_user(wrqu->data.pointer + sizeof(preq), pdata, strlen(pdata) + 1)) {
9455 res = MTLK_ERR_VALUE;
9456 }
9457 }
9458 mtlk_osal_mem_free(pdata);
9459 }
9460 break;
9461 case BclDrvModeValGet:
9462 /* Make sure there's enough space to store the value: */
9463 if (sizeof(uint32) != preq.datalen) {
9464 res = MTLK_ERR_PARAMS;
9465 } else {
9466 /* Return the value to BCLSockServer: */
9467 res = mtlk_df_debug_bcl_val_get(df_user, preq.category, preq.index, /* out */ &value);
9468 if (MTLK_ERR_OK == res) {
9469 if (0 != copy_to_user(wrqu->data.pointer + sizeof(preq), &value, sizeof(uint32))) {
9470 res = MTLK_ERR_VALUE;
9471 }
9472 }
9473 }
9474 break;
9475 case BclDrvModeValSet:
9476 /* Make sure the value is present: */
9477 if (sizeof(uint32) != preq.datalen) {
9478 res = MTLK_ERR_PARAMS;
9479 } else {
9480 /* Process the value: */
9481 if (0 != copy_from_user(&value, wrqu->data.pointer + sizeof(preq), sizeof(uint32))) {
9482 res = MTLK_ERR_VALUE;
9483 } else {
9484 res = mtlk_df_debug_bcl_val_put(df_user, preq.category, preq.index, value);
9485 }
9486 }
9487 break;
9488 default:
9489 ELOG_D("Unknown data exchange mode (%u)", preq.mode);
9490 res = MTLK_ERR_PARAMS;
9491 }
9492
9493 cleanup:
9494 return _mtlk_df_mtlk_to_linux_error_code(res);
9495 }
9496
9497 /* Remove MAC address from switch MAC table by ifx_ethsw_kioctl
9498 1. QUERY: search MAC address in switch table.
9499 The bFound will be set to 1 if MAC address found.
9500 2. REMOVE: remove MAC address if found.
9501 Note: It is should be done independently of whether PPA is active or not.
9502 */
9503 void __MTLK_IFUNC
9504 mtlk_df_user_ppa_remove_mac_addr(mtlk_df_t *df, const uint8 *mac_addr)
9505 {
9506 #ifdef MTLK_HAVE_PPA
9507
9508 LTQ_ETHSW_API_HANDLE handle;
9509 IFX_ETHSW_MAC_tableQuery_t MAC_tableQuery;
9510 IFX_ETHSW_MAC_tableRemove_t MAC_tableRemove;
9511
9512 MTLK_ASSERT(NULL != df);
9513 MTLK_ASSERT(NULL != mac_addr);
9514
9515 /* ifx_ethsw_kopen returns a zero in case the device does not exist or is blocked */
9516 handle = ltq_ethsw_api_kopen("/dev/switch/0");
9517
9518 if (0 != handle) {
9519
9520 /* 1. Search MAC address in switch table */
9521 memset(&MAC_tableQuery, 0x00, sizeof(MAC_tableQuery));
9522 MAC_tableQuery.nFId = 0;
9523 memcpy(MAC_tableQuery.nMAC, mac_addr, IEEE_ADDR_LEN);
9524 ltq_ethsw_api_kioctl(handle, IFX_ETHSW_MAC_TABLE_ENTRY_QUERY, (unsigned int)&MAC_tableQuery);
9525
9526 ILOG3_YDD("MAC %Y switch query: bFound %d, nPortId %d",
9527 mac_addr, (int)MAC_tableQuery.bFound, (int)MAC_tableQuery.nPortId);
9528
9529 /* 2. Remove MAC address if found */
9530 if (MAC_tableQuery.bFound) {
9531 memset(&MAC_tableRemove, 0x00, sizeof(MAC_tableRemove));
9532 MAC_tableRemove.nFId = 0;
9533 memcpy(MAC_tableRemove.nMAC, mac_addr, IEEE_ADDR_LEN);
9534 ltq_ethsw_api_kioctl(handle, IFX_ETHSW_MAC_TABLE_ENTRY_REMOVE, (unsigned int)&MAC_tableRemove);
9535
9536 ILOG3_Y("MAC %Y removed from switch MAC table", mac_addr);
9537 }
9538
9539 ltq_ethsw_api_kclose(handle);
9540 }
9541 #endif /* MTLK_HAVE_PPA */
9542 }
Continuation of wave300 driver source codes