2 * This file contains ioctl functions
4 #include <linux/ctype.h>
5 #include <linux/delay.h>
7 #include <linux/if_arp.h>
8 #include <linux/wireless.h>
9 #include <linux/bitops.h>
11 #include <net/lib80211.h>
12 #include <net/iw_handler.h>
25 static inline void lbs_postpone_association_work(struct lbs_private
*priv
)
27 if (priv
->surpriseremoved
)
29 cancel_delayed_work(&priv
->assoc_work
);
30 queue_delayed_work(priv
->work_thread
, &priv
->assoc_work
, HZ
/ 2);
33 static inline void lbs_do_association_work(struct lbs_private
*priv
)
35 if (priv
->surpriseremoved
)
37 cancel_delayed_work(&priv
->assoc_work
);
38 queue_delayed_work(priv
->work_thread
, &priv
->assoc_work
, 0);
41 static inline void lbs_cancel_association_work(struct lbs_private
*priv
)
43 cancel_delayed_work(&priv
->assoc_work
);
44 kfree(priv
->pending_assoc_req
);
45 priv
->pending_assoc_req
= NULL
;
48 void lbs_send_disconnect_notification(struct lbs_private
*priv
)
50 union iwreq_data wrqu
;
52 memset(wrqu
.ap_addr
.sa_data
, 0x00, ETH_ALEN
);
53 wrqu
.ap_addr
.sa_family
= ARPHRD_ETHER
;
54 wireless_send_event(priv
->dev
, SIOCGIWAP
, &wrqu
, NULL
);
57 static void lbs_send_iwevcustom_event(struct lbs_private
*priv
, s8
*str
)
59 union iwreq_data iwrq
;
62 lbs_deb_enter(LBS_DEB_WEXT
);
64 memset(&iwrq
, 0, sizeof(union iwreq_data
));
65 memset(buf
, 0, sizeof(buf
));
67 snprintf(buf
, sizeof(buf
) - 1, "%s", str
);
69 iwrq
.data
.length
= strlen(buf
) + 1 + IW_EV_LCP_LEN
;
71 /* Send Event to upper layer */
72 lbs_deb_wext("event indication string %s\n", (char *)buf
);
73 lbs_deb_wext("event indication length %d\n", iwrq
.data
.length
);
74 lbs_deb_wext("sending wireless event IWEVCUSTOM for %s\n", str
);
76 wireless_send_event(priv
->dev
, IWEVCUSTOM
, &iwrq
, buf
);
78 lbs_deb_leave(LBS_DEB_WEXT
);
82 * @brief This function handles MIC failure event.
84 * @param priv A pointer to struct lbs_private structure
85 * @para event the event id
88 void lbs_send_mic_failureevent(struct lbs_private
*priv
, u32 event
)
92 lbs_deb_enter(LBS_DEB_CMD
);
93 memset(buf
, 0, sizeof(buf
));
95 sprintf(buf
, "%s", "MLME-MICHAELMICFAILURE.indication ");
97 if (event
== MACREG_INT_CODE_MIC_ERR_UNICAST
)
98 strcat(buf
, "unicast ");
100 strcat(buf
, "multicast ");
102 lbs_send_iwevcustom_event(priv
, buf
);
103 lbs_deb_leave(LBS_DEB_CMD
);
107 * @brief Find the channel frequency power info with specific channel
109 * @param priv A pointer to struct lbs_private structure
110 * @param band it can be BAND_A, BAND_G or BAND_B
111 * @param channel the channel for looking
112 * @return A pointer to struct chan_freq_power structure or NULL if not find.
114 struct chan_freq_power
*lbs_find_cfp_by_band_and_channel(
115 struct lbs_private
*priv
,
119 struct chan_freq_power
*cfp
= NULL
;
120 struct region_channel
*rc
;
123 for (j
= 0; !cfp
&& (j
< ARRAY_SIZE(priv
->region_channel
)); j
++) {
124 rc
= &priv
->region_channel
[j
];
126 if (!rc
->valid
|| !rc
->CFP
)
128 if (rc
->band
!= band
)
130 for (i
= 0; i
< rc
->nrcfp
; i
++) {
131 if (rc
->CFP
[i
].channel
== channel
) {
139 lbs_deb_wext("lbs_find_cfp_by_band_and_channel: can't find "
140 "cfp by band %d / channel %d\n", band
, channel
);
146 * @brief Find the channel frequency power info with specific frequency
148 * @param priv A pointer to struct lbs_private structure
149 * @param band it can be BAND_A, BAND_G or BAND_B
150 * @param freq the frequency for looking
151 * @return A pointer to struct chan_freq_power structure or NULL if not find.
153 static struct chan_freq_power
*find_cfp_by_band_and_freq(
154 struct lbs_private
*priv
,
158 struct chan_freq_power
*cfp
= NULL
;
159 struct region_channel
*rc
;
162 for (j
= 0; !cfp
&& (j
< ARRAY_SIZE(priv
->region_channel
)); j
++) {
163 rc
= &priv
->region_channel
[j
];
165 if (!rc
->valid
|| !rc
->CFP
)
167 if (rc
->band
!= band
)
169 for (i
= 0; i
< rc
->nrcfp
; i
++) {
170 if (rc
->CFP
[i
].freq
== freq
) {
178 lbs_deb_wext("find_cfp_by_band_and_freql: can't find cfp by "
179 "band %d / freq %d\n", band
, freq
);
185 * @brief Copy active data rates based on adapter mode and status
187 * @param priv A pointer to struct lbs_private structure
188 * @param rate The buf to return the active rates
190 static void copy_active_data_rates(struct lbs_private
*priv
, u8
*rates
)
192 lbs_deb_enter(LBS_DEB_WEXT
);
194 if ((priv
->connect_status
!= LBS_CONNECTED
) &&
195 !lbs_mesh_connected(priv
))
196 memcpy(rates
, lbs_bg_rates
, MAX_RATES
);
198 memcpy(rates
, priv
->curbssparams
.rates
, MAX_RATES
);
200 lbs_deb_leave(LBS_DEB_WEXT
);
203 static int lbs_get_name(struct net_device
*dev
, struct iw_request_info
*info
,
204 char *cwrq
, char *extra
)
207 lbs_deb_enter(LBS_DEB_WEXT
);
209 /* We could add support for 802.11n here as needed. Jean II */
210 snprintf(cwrq
, IFNAMSIZ
, "IEEE 802.11b/g");
212 lbs_deb_leave(LBS_DEB_WEXT
);
216 static int lbs_get_freq(struct net_device
*dev
, struct iw_request_info
*info
,
217 struct iw_freq
*fwrq
, char *extra
)
219 struct lbs_private
*priv
= dev
->ml_priv
;
220 struct chan_freq_power
*cfp
;
222 lbs_deb_enter(LBS_DEB_WEXT
);
224 cfp
= lbs_find_cfp_by_band_and_channel(priv
, 0,
229 lbs_deb_wext("invalid channel %d\n",
234 fwrq
->m
= (long)cfp
->freq
* 100000;
237 lbs_deb_wext("freq %u\n", fwrq
->m
);
238 lbs_deb_leave(LBS_DEB_WEXT
);
242 static int lbs_get_wap(struct net_device
*dev
, struct iw_request_info
*info
,
243 struct sockaddr
*awrq
, char *extra
)
245 struct lbs_private
*priv
= dev
->ml_priv
;
247 lbs_deb_enter(LBS_DEB_WEXT
);
249 if (priv
->connect_status
== LBS_CONNECTED
) {
250 memcpy(awrq
->sa_data
, priv
->curbssparams
.bssid
, ETH_ALEN
);
252 memset(awrq
->sa_data
, 0, ETH_ALEN
);
254 awrq
->sa_family
= ARPHRD_ETHER
;
256 lbs_deb_leave(LBS_DEB_WEXT
);
260 static int lbs_set_nick(struct net_device
*dev
, struct iw_request_info
*info
,
261 struct iw_point
*dwrq
, char *extra
)
263 struct lbs_private
*priv
= dev
->ml_priv
;
265 lbs_deb_enter(LBS_DEB_WEXT
);
268 * Check the size of the string
271 if (dwrq
->length
> 16) {
275 mutex_lock(&priv
->lock
);
276 memset(priv
->nodename
, 0, sizeof(priv
->nodename
));
277 memcpy(priv
->nodename
, extra
, dwrq
->length
);
278 mutex_unlock(&priv
->lock
);
280 lbs_deb_leave(LBS_DEB_WEXT
);
284 static int lbs_get_nick(struct net_device
*dev
, struct iw_request_info
*info
,
285 struct iw_point
*dwrq
, char *extra
)
287 struct lbs_private
*priv
= dev
->ml_priv
;
289 lbs_deb_enter(LBS_DEB_WEXT
);
291 dwrq
->length
= strlen(priv
->nodename
);
292 memcpy(extra
, priv
->nodename
, dwrq
->length
);
293 extra
[dwrq
->length
] = '\0';
295 dwrq
->flags
= 1; /* active */
297 lbs_deb_leave(LBS_DEB_WEXT
);
301 #ifdef CONFIG_LIBERTAS_MESH
302 static int mesh_get_nick(struct net_device
*dev
, struct iw_request_info
*info
,
303 struct iw_point
*dwrq
, char *extra
)
305 struct lbs_private
*priv
= dev
->ml_priv
;
307 lbs_deb_enter(LBS_DEB_WEXT
);
309 /* Use nickname to indicate that mesh is on */
311 if (lbs_mesh_connected(priv
)) {
312 strncpy(extra
, "Mesh", 12);
314 dwrq
->length
= strlen(extra
);
322 lbs_deb_leave(LBS_DEB_WEXT
);
327 static int lbs_set_rts(struct net_device
*dev
, struct iw_request_info
*info
,
328 struct iw_param
*vwrq
, char *extra
)
331 struct lbs_private
*priv
= dev
->ml_priv
;
332 u32 val
= vwrq
->value
;
334 lbs_deb_enter(LBS_DEB_WEXT
);
337 val
= MRVDRV_RTS_MAX_VALUE
;
339 if (val
> MRVDRV_RTS_MAX_VALUE
) /* min rts value is 0 */
342 ret
= lbs_set_snmp_mib(priv
, SNMP_MIB_OID_RTS_THRESHOLD
, (u16
) val
);
344 lbs_deb_leave_args(LBS_DEB_WEXT
, "ret %d", ret
);
348 static int lbs_get_rts(struct net_device
*dev
, struct iw_request_info
*info
,
349 struct iw_param
*vwrq
, char *extra
)
351 struct lbs_private
*priv
= dev
->ml_priv
;
355 lbs_deb_enter(LBS_DEB_WEXT
);
357 ret
= lbs_get_snmp_mib(priv
, SNMP_MIB_OID_RTS_THRESHOLD
, &val
);
362 vwrq
->disabled
= val
> MRVDRV_RTS_MAX_VALUE
; /* min rts value is 0 */
366 lbs_deb_leave_args(LBS_DEB_WEXT
, "ret %d", ret
);
370 static int lbs_set_frag(struct net_device
*dev
, struct iw_request_info
*info
,
371 struct iw_param
*vwrq
, char *extra
)
373 struct lbs_private
*priv
= dev
->ml_priv
;
375 u32 val
= vwrq
->value
;
377 lbs_deb_enter(LBS_DEB_WEXT
);
380 val
= MRVDRV_FRAG_MAX_VALUE
;
382 if (val
< MRVDRV_FRAG_MIN_VALUE
|| val
> MRVDRV_FRAG_MAX_VALUE
)
385 ret
= lbs_set_snmp_mib(priv
, SNMP_MIB_OID_FRAG_THRESHOLD
, (u16
) val
);
387 lbs_deb_leave_args(LBS_DEB_WEXT
, "ret %d", ret
);
391 static int lbs_get_frag(struct net_device
*dev
, struct iw_request_info
*info
,
392 struct iw_param
*vwrq
, char *extra
)
394 struct lbs_private
*priv
= dev
->ml_priv
;
398 lbs_deb_enter(LBS_DEB_WEXT
);
400 ret
= lbs_get_snmp_mib(priv
, SNMP_MIB_OID_FRAG_THRESHOLD
, &val
);
405 vwrq
->disabled
= ((val
< MRVDRV_FRAG_MIN_VALUE
)
406 || (val
> MRVDRV_FRAG_MAX_VALUE
));
410 lbs_deb_leave_args(LBS_DEB_WEXT
, "ret %d", ret
);
414 static int lbs_get_mode(struct net_device
*dev
,
415 struct iw_request_info
*info
, u32
* uwrq
, char *extra
)
417 struct lbs_private
*priv
= dev
->ml_priv
;
419 lbs_deb_enter(LBS_DEB_WEXT
);
423 lbs_deb_leave(LBS_DEB_WEXT
);
427 #ifdef CONFIG_LIBERTAS_MESH
428 static int mesh_wlan_get_mode(struct net_device
*dev
,
429 struct iw_request_info
*info
, u32
* uwrq
,
432 lbs_deb_enter(LBS_DEB_WEXT
);
434 *uwrq
= IW_MODE_REPEAT
;
436 lbs_deb_leave(LBS_DEB_WEXT
);
441 static int lbs_get_txpow(struct net_device
*dev
,
442 struct iw_request_info
*info
,
443 struct iw_param
*vwrq
, char *extra
)
445 struct lbs_private
*priv
= dev
->ml_priv
;
449 lbs_deb_enter(LBS_DEB_WEXT
);
451 if (!priv
->radio_on
) {
452 lbs_deb_wext("tx power off\n");
458 ret
= lbs_get_tx_power(priv
, &curlevel
, NULL
, NULL
);
462 lbs_deb_wext("tx power level %d dbm\n", curlevel
);
463 priv
->txpower_cur
= curlevel
;
465 vwrq
->value
= curlevel
;
468 vwrq
->flags
= IW_TXPOW_DBM
;
471 lbs_deb_leave_args(LBS_DEB_WEXT
, "ret %d", ret
);
475 static int lbs_set_retry(struct net_device
*dev
, struct iw_request_info
*info
,
476 struct iw_param
*vwrq
, char *extra
)
478 struct lbs_private
*priv
= dev
->ml_priv
;
480 u16 slimit
= 0, llimit
= 0;
482 lbs_deb_enter(LBS_DEB_WEXT
);
484 if ((vwrq
->flags
& IW_RETRY_TYPE
) != IW_RETRY_LIMIT
)
487 /* The MAC has a 4-bit Total_Tx_Count register
488 Total_Tx_Count = 1 + Tx_Retry_Count */
489 #define TX_RETRY_MIN 0
490 #define TX_RETRY_MAX 14
491 if (vwrq
->value
< TX_RETRY_MIN
|| vwrq
->value
> TX_RETRY_MAX
)
494 /* Add 1 to convert retry count to try count */
495 if (vwrq
->flags
& IW_RETRY_SHORT
)
496 slimit
= (u16
) (vwrq
->value
+ 1);
497 else if (vwrq
->flags
& IW_RETRY_LONG
)
498 llimit
= (u16
) (vwrq
->value
+ 1);
500 slimit
= llimit
= (u16
) (vwrq
->value
+ 1); /* set both */
503 ret
= lbs_set_snmp_mib(priv
, SNMP_MIB_OID_LONG_RETRY_LIMIT
,
510 /* txretrycount follows the short retry limit */
511 priv
->txretrycount
= slimit
;
512 ret
= lbs_set_snmp_mib(priv
, SNMP_MIB_OID_SHORT_RETRY_LIMIT
,
519 lbs_deb_leave_args(LBS_DEB_WEXT
, "ret %d", ret
);
523 static int lbs_get_retry(struct net_device
*dev
, struct iw_request_info
*info
,
524 struct iw_param
*vwrq
, char *extra
)
526 struct lbs_private
*priv
= dev
->ml_priv
;
530 lbs_deb_enter(LBS_DEB_WEXT
);
534 if (vwrq
->flags
& IW_RETRY_LONG
) {
535 ret
= lbs_get_snmp_mib(priv
, SNMP_MIB_OID_LONG_RETRY_LIMIT
, &val
);
539 /* Subtract 1 to convert try count to retry count */
540 vwrq
->value
= val
- 1;
541 vwrq
->flags
= IW_RETRY_LIMIT
| IW_RETRY_LONG
;
543 ret
= lbs_get_snmp_mib(priv
, SNMP_MIB_OID_SHORT_RETRY_LIMIT
, &val
);
547 /* txretry count follows the short retry limit */
548 priv
->txretrycount
= val
;
549 /* Subtract 1 to convert try count to retry count */
550 vwrq
->value
= val
- 1;
551 vwrq
->flags
= IW_RETRY_LIMIT
| IW_RETRY_SHORT
;
555 lbs_deb_leave_args(LBS_DEB_WEXT
, "ret %d", ret
);
559 static inline void sort_channels(struct iw_freq
*freq
, int num
)
564 for (i
= 0; i
< num
; i
++)
565 for (j
= i
+ 1; j
< num
; j
++)
566 if (freq
[i
].i
> freq
[j
].i
) {
570 freq
[i
].i
= freq
[j
].i
;
571 freq
[i
].m
= freq
[j
].m
;
581 Infra G(12) A(8) B(4) G(12)
582 Adhoc A+B(12) A(8) B(4) B(4)
590 * @brief Get Range Info
592 * @param dev A pointer to net_device structure
593 * @param info A pointer to iw_request_info structure
594 * @param vwrq A pointer to iw_param structure
595 * @param extra A pointer to extra data buf
596 * @return 0 --success, otherwise fail
598 static int lbs_get_range(struct net_device
*dev
, struct iw_request_info
*info
,
599 struct iw_point
*dwrq
, char *extra
)
602 struct lbs_private
*priv
= dev
->ml_priv
;
603 struct iw_range
*range
= (struct iw_range
*)extra
;
604 struct chan_freq_power
*cfp
;
605 u8 rates
[MAX_RATES
+ 1];
607 lbs_deb_enter(LBS_DEB_WEXT
);
609 dwrq
->length
= sizeof(struct iw_range
);
610 memset(range
, 0, sizeof(struct iw_range
));
615 memset(rates
, 0, sizeof(rates
));
616 copy_active_data_rates(priv
, rates
);
617 range
->num_bitrates
= strnlen(rates
, IW_MAX_BITRATES
);
618 for (i
= 0; i
< range
->num_bitrates
; i
++)
619 range
->bitrate
[i
] = rates
[i
] * 500000;
620 range
->num_bitrates
= i
;
621 lbs_deb_wext("IW_MAX_BITRATES %d, num_bitrates %d\n", IW_MAX_BITRATES
,
622 range
->num_bitrates
);
624 range
->num_frequency
= 0;
626 range
->scan_capa
= IW_SCAN_CAPA_ESSID
;
628 for (j
= 0; (range
->num_frequency
< IW_MAX_FREQUENCIES
)
629 && (j
< ARRAY_SIZE(priv
->region_channel
)); j
++) {
630 cfp
= priv
->region_channel
[j
].CFP
;
631 for (i
= 0; (range
->num_frequency
< IW_MAX_FREQUENCIES
)
632 && priv
->region_channel
[j
].valid
634 && (i
< priv
->region_channel
[j
].nrcfp
); i
++) {
635 range
->freq
[range
->num_frequency
].i
=
637 range
->freq
[range
->num_frequency
].m
=
638 (long)cfp
->freq
* 100000;
639 range
->freq
[range
->num_frequency
].e
= 1;
641 range
->num_frequency
++;
645 lbs_deb_wext("IW_MAX_FREQUENCIES %d, num_frequency %d\n",
646 IW_MAX_FREQUENCIES
, range
->num_frequency
);
648 range
->num_channels
= range
->num_frequency
;
650 sort_channels(&range
->freq
[0], range
->num_frequency
);
653 * Set an indication of the max TCP throughput in bit/s that we can
654 * expect using this interface
657 range
->throughput
= 5000 * 1000;
659 range
->throughput
= 1500 * 1000;
661 range
->min_rts
= MRVDRV_RTS_MIN_VALUE
;
662 range
->max_rts
= MRVDRV_RTS_MAX_VALUE
;
663 range
->min_frag
= MRVDRV_FRAG_MIN_VALUE
;
664 range
->max_frag
= MRVDRV_FRAG_MAX_VALUE
;
666 range
->encoding_size
[0] = 5;
667 range
->encoding_size
[1] = 13;
668 range
->num_encoding_sizes
= 2;
669 range
->max_encoding_tokens
= 4;
672 * Right now we support only "iwconfig ethX power on|off"
674 range
->pm_capa
= IW_POWER_ON
;
677 * Minimum version we recommend
679 range
->we_version_source
= 15;
682 * Version we are compiled with
684 range
->we_version_compiled
= WIRELESS_EXT
;
686 range
->retry_capa
= IW_RETRY_LIMIT
;
687 range
->retry_flags
= IW_RETRY_LIMIT
| IW_RETRY_MAX
;
689 range
->min_retry
= TX_RETRY_MIN
;
690 range
->max_retry
= TX_RETRY_MAX
;
693 * Set the qual, level and noise range values
695 range
->max_qual
.qual
= 100;
696 range
->max_qual
.level
= 0;
697 range
->max_qual
.noise
= 0;
698 range
->max_qual
.updated
= IW_QUAL_ALL_UPDATED
| IW_QUAL_DBM
;
700 range
->avg_qual
.qual
= 70;
701 /* TODO: Find real 'good' to 'bad' threshold value for RSSI */
702 range
->avg_qual
.level
= 0;
703 range
->avg_qual
.noise
= 0;
704 range
->avg_qual
.updated
= IW_QUAL_ALL_UPDATED
| IW_QUAL_DBM
;
706 range
->sensitivity
= 0;
708 /* Setup the supported power level ranges */
709 memset(range
->txpower
, 0, sizeof(range
->txpower
));
710 range
->txpower_capa
= IW_TXPOW_DBM
| IW_TXPOW_RANGE
;
711 range
->txpower
[0] = priv
->txpower_min
;
712 range
->txpower
[1] = priv
->txpower_max
;
713 range
->num_txpower
= 2;
715 range
->event_capa
[0] = (IW_EVENT_CAPA_K_0
|
716 IW_EVENT_CAPA_MASK(SIOCGIWAP
) |
717 IW_EVENT_CAPA_MASK(SIOCGIWSCAN
));
718 range
->event_capa
[1] = IW_EVENT_CAPA_K_1
;
720 if (priv
->fwcapinfo
& FW_CAPINFO_WPA
) {
721 range
->enc_capa
= IW_ENC_CAPA_WPA
723 | IW_ENC_CAPA_CIPHER_TKIP
724 | IW_ENC_CAPA_CIPHER_CCMP
;
727 lbs_deb_leave(LBS_DEB_WEXT
);
731 static int lbs_set_power(struct net_device
*dev
, struct iw_request_info
*info
,
732 struct iw_param
*vwrq
, char *extra
)
734 struct lbs_private
*priv
= dev
->ml_priv
;
737 lbs_deb_enter(LBS_DEB_WEXT
);
739 if (!(priv
->fwcapinfo
& FW_CAPINFO_PS
)) {
746 /* PS is currently supported only in Infrastructure mode
747 * Remove this check if it is to be supported in IBSS mode also
750 if (vwrq
->disabled
) {
751 priv
->psmode
= LBS802_11POWERMODECAM
;
752 if (priv
->psstate
!= PS_STATE_FULL_POWER
) {
753 lbs_ps_wakeup(priv
, CMD_OPTION_WAITFORRSP
);
759 if ((vwrq
->flags
& IW_POWER_TYPE
) == IW_POWER_TIMEOUT
) {
761 "setting power timeout is not supported\n");
763 } else if ((vwrq
->flags
& IW_POWER_TYPE
) == IW_POWER_PERIOD
) {
764 vwrq
->value
= vwrq
->value
/ 1000;
765 if (!priv
->enter_deep_sleep
) {
766 lbs_pr_err("deep sleep feature is not implemented "
767 "for this interface driver\n");
771 if (priv
->connect_status
== LBS_CONNECTED
) {
772 if ((priv
->is_auto_deep_sleep_enabled
) &&
773 (vwrq
->value
== -1000)) {
774 lbs_exit_auto_deep_sleep(priv
);
777 lbs_pr_err("can't use deep sleep cmd in "
778 "connected state\n");
783 if ((vwrq
->value
< 0) && (vwrq
->value
!= -1000)) {
784 lbs_pr_err("unknown option\n");
788 if (vwrq
->value
> 0) {
789 if (!priv
->is_auto_deep_sleep_enabled
) {
790 priv
->is_activity_detected
= 0;
791 priv
->auto_deep_sleep_timeout
= vwrq
->value
;
792 lbs_enter_auto_deep_sleep(priv
);
794 priv
->auto_deep_sleep_timeout
= vwrq
->value
;
795 lbs_deb_debugfs("auto deep sleep: "
796 "already enabled\n");
800 if (priv
->is_auto_deep_sleep_enabled
) {
801 lbs_exit_auto_deep_sleep(priv
);
802 /* Try to exit deep sleep if auto */
803 /*deep sleep disabled */
804 ret
= lbs_set_deep_sleep(priv
, 0);
806 if (vwrq
->value
== 0)
807 ret
= lbs_set_deep_sleep(priv
, 1);
808 else if (vwrq
->value
== -1000)
809 ret
= lbs_set_deep_sleep(priv
, 0);
814 if (priv
->psmode
!= LBS802_11POWERMODECAM
) {
818 priv
->psmode
= LBS802_11POWERMODEMAX_PSP
;
820 if (priv
->connect_status
== LBS_CONNECTED
) {
821 lbs_ps_sleep(priv
, CMD_OPTION_WAITFORRSP
);
824 lbs_deb_leave(LBS_DEB_WEXT
);
829 static int lbs_get_power(struct net_device
*dev
, struct iw_request_info
*info
,
830 struct iw_param
*vwrq
, char *extra
)
832 struct lbs_private
*priv
= dev
->ml_priv
;
834 lbs_deb_enter(LBS_DEB_WEXT
);
838 vwrq
->disabled
= priv
->psmode
== LBS802_11POWERMODECAM
839 || priv
->connect_status
== LBS_DISCONNECTED
;
841 lbs_deb_leave(LBS_DEB_WEXT
);
845 static struct iw_statistics
*lbs_get_wireless_stats(struct net_device
*dev
)
855 struct lbs_private
*priv
= dev
->ml_priv
;
859 int ret
, stats_valid
= 0;
862 struct cmd_ds_802_11_get_log log
;
864 lbs_deb_enter(LBS_DEB_WEXT
);
866 priv
->wstats
.status
= priv
->mode
;
868 /* If we're not associated, all quality values are meaningless */
869 if ((priv
->connect_status
!= LBS_CONNECTED
) &&
870 !lbs_mesh_connected(priv
))
873 /* Quality by RSSI */
874 priv
->wstats
.qual
.level
=
875 CAL_RSSI(priv
->SNR
[TYPE_BEACON
][TYPE_NOAVG
],
876 priv
->NF
[TYPE_BEACON
][TYPE_NOAVG
]);
878 if (priv
->NF
[TYPE_BEACON
][TYPE_NOAVG
] == 0) {
879 priv
->wstats
.qual
.noise
= MRVDRV_NF_DEFAULT_SCAN_VALUE
;
881 priv
->wstats
.qual
.noise
=
882 CAL_NF(priv
->NF
[TYPE_BEACON
][TYPE_NOAVG
]);
885 lbs_deb_wext("signal level %#x\n", priv
->wstats
.qual
.level
);
886 lbs_deb_wext("noise %#x\n", priv
->wstats
.qual
.noise
);
888 rssi
= priv
->wstats
.qual
.level
- priv
->wstats
.qual
.noise
;
890 rssi_qual
= rssi
* POOR
/ 10;
892 rssi_qual
= (rssi
- 15) * (FAIR
- POOR
) / 5 + POOR
;
894 rssi_qual
= (rssi
- 20) * (GOOD
- FAIR
) / 5 + FAIR
;
896 rssi_qual
= (rssi
- 30) * (VERY_GOOD
- GOOD
) /
899 rssi_qual
= (rssi
- 40) * (PERFECT
- VERY_GOOD
) /
903 /* Quality by TX errors */
904 priv
->wstats
.discard
.retries
= dev
->stats
.tx_errors
;
906 memset(&log
, 0, sizeof(log
));
907 log
.hdr
.size
= cpu_to_le16(sizeof(log
));
908 ret
= lbs_cmd_with_response(priv
, CMD_802_11_GET_LOG
, &log
);
912 tx_retries
= le32_to_cpu(log
.retry
);
915 tx_qual
= (90 - tx_retries
) * POOR
/ 15;
916 else if (tx_retries
> 70)
917 tx_qual
= (75 - tx_retries
) * (FAIR
- POOR
) / 5 + POOR
;
918 else if (tx_retries
> 65)
919 tx_qual
= (70 - tx_retries
) * (GOOD
- FAIR
) / 5 + FAIR
;
920 else if (tx_retries
> 50)
921 tx_qual
= (65 - tx_retries
) * (VERY_GOOD
- GOOD
) /
924 tx_qual
= (50 - tx_retries
) *
925 (PERFECT
- VERY_GOOD
) / 50 + VERY_GOOD
;
926 quality
= min(quality
, tx_qual
);
928 priv
->wstats
.discard
.code
= le32_to_cpu(log
.wepundecryptable
);
929 priv
->wstats
.discard
.retries
= tx_retries
;
930 priv
->wstats
.discard
.misc
= le32_to_cpu(log
.ackfailure
);
932 /* Calculate quality */
933 priv
->wstats
.qual
.qual
= min_t(u8
, quality
, 100);
934 priv
->wstats
.qual
.updated
= IW_QUAL_ALL_UPDATED
| IW_QUAL_DBM
;
937 /* update stats asynchronously for future calls */
938 ret
= lbs_prepare_and_send_command(priv
, CMD_802_11_RSSI
, 0,
941 lbs_pr_err("RSSI command failed\n");
944 priv
->wstats
.miss
.beacon
= 0;
945 priv
->wstats
.discard
.retries
= 0;
946 priv
->wstats
.qual
.qual
= 0;
947 priv
->wstats
.qual
.level
= 0;
948 priv
->wstats
.qual
.noise
= 0;
949 priv
->wstats
.qual
.updated
= IW_QUAL_ALL_UPDATED
;
950 priv
->wstats
.qual
.updated
|= IW_QUAL_NOISE_INVALID
|
951 IW_QUAL_QUAL_INVALID
| IW_QUAL_LEVEL_INVALID
;
954 lbs_deb_leave(LBS_DEB_WEXT
);
955 return &priv
->wstats
;
960 static int lbs_set_freq(struct net_device
*dev
, struct iw_request_info
*info
,
961 struct iw_freq
*fwrq
, char *extra
)
964 struct lbs_private
*priv
= dev
->ml_priv
;
965 struct chan_freq_power
*cfp
;
966 struct assoc_request
* assoc_req
;
968 lbs_deb_enter(LBS_DEB_WEXT
);
970 mutex_lock(&priv
->lock
);
971 assoc_req
= lbs_get_association_request(priv
);
977 /* If setting by frequency, convert to a channel */
979 long f
= fwrq
->m
/ 100000;
981 cfp
= find_cfp_by_band_and_freq(priv
, 0, f
);
983 lbs_deb_wext("invalid freq %ld\n", f
);
988 fwrq
->m
= (int) cfp
->channel
;
991 /* Setting by channel number */
992 if (fwrq
->m
> 1000 || fwrq
->e
> 0) {
996 cfp
= lbs_find_cfp_by_band_and_channel(priv
, 0, fwrq
->m
);
1001 assoc_req
->channel
= fwrq
->m
;
1006 set_bit(ASSOC_FLAG_CHANNEL
, &assoc_req
->flags
);
1007 lbs_postpone_association_work(priv
);
1009 lbs_cancel_association_work(priv
);
1011 mutex_unlock(&priv
->lock
);
1013 lbs_deb_leave_args(LBS_DEB_WEXT
, "ret %d", ret
);
1017 #ifdef CONFIG_LIBERTAS_MESH
1018 static int lbs_mesh_set_freq(struct net_device
*dev
,
1019 struct iw_request_info
*info
,
1020 struct iw_freq
*fwrq
, char *extra
)
1022 struct lbs_private
*priv
= dev
->ml_priv
;
1023 struct chan_freq_power
*cfp
;
1026 lbs_deb_enter(LBS_DEB_WEXT
);
1028 /* If setting by frequency, convert to a channel */
1030 long f
= fwrq
->m
/ 100000;
1032 cfp
= find_cfp_by_band_and_freq(priv
, 0, f
);
1034 lbs_deb_wext("invalid freq %ld\n", f
);
1039 fwrq
->m
= (int) cfp
->channel
;
1042 /* Setting by channel number */
1043 if (fwrq
->m
> 1000 || fwrq
->e
> 0) {
1047 cfp
= lbs_find_cfp_by_band_and_channel(priv
, 0, fwrq
->m
);
1052 if (fwrq
->m
!= priv
->channel
) {
1053 lbs_deb_wext("mesh channel change forces eth disconnect\n");
1054 if (priv
->mode
== IW_MODE_INFRA
)
1055 lbs_cmd_80211_deauthenticate(priv
,
1056 priv
->curbssparams
.bssid
,
1057 WLAN_REASON_DEAUTH_LEAVING
);
1058 else if (priv
->mode
== IW_MODE_ADHOC
)
1059 lbs_adhoc_stop(priv
);
1061 lbs_mesh_config(priv
, CMD_ACT_MESH_CONFIG_START
, fwrq
->m
);
1062 lbs_update_channel(priv
);
1066 lbs_deb_leave_args(LBS_DEB_WEXT
, "ret %d", ret
);
1071 static int lbs_set_rate(struct net_device
*dev
, struct iw_request_info
*info
,
1072 struct iw_param
*vwrq
, char *extra
)
1074 struct lbs_private
*priv
= dev
->ml_priv
;
1077 u8 rates
[MAX_RATES
+ 1];
1079 lbs_deb_enter(LBS_DEB_WEXT
);
1081 lbs_deb_wext("vwrq->value %d\n", vwrq
->value
);
1082 lbs_deb_wext("vwrq->fixed %d\n", vwrq
->fixed
);
1084 if (vwrq
->fixed
&& vwrq
->value
== -1)
1088 priv
->enablehwauto
= !vwrq
->fixed
;
1090 if (vwrq
->value
== -1)
1093 if (vwrq
->value
% 100000)
1096 new_rate
= vwrq
->value
/ 500000;
1097 priv
->cur_rate
= new_rate
;
1098 /* the rest is only needed for lbs_set_data_rate() */
1099 memset(rates
, 0, sizeof(rates
));
1100 copy_active_data_rates(priv
, rates
);
1101 if (!memchr(rates
, new_rate
, sizeof(rates
))) {
1102 lbs_pr_alert("fixed data rate 0x%X out of range\n",
1106 if (priv
->fwrelease
< 0x09000000) {
1107 ret
= lbs_set_power_adapt_cfg(priv
, 0,
1108 POW_ADAPT_DEFAULT_P0
,
1109 POW_ADAPT_DEFAULT_P1
,
1110 POW_ADAPT_DEFAULT_P2
);
1114 ret
= lbs_set_tpc_cfg(priv
, 0, TPC_DEFAULT_P0
, TPC_DEFAULT_P1
,
1120 /* Try the newer command first (Firmware Spec 5.1 and above) */
1121 ret
= lbs_cmd_802_11_rate_adapt_rateset(priv
, CMD_ACT_SET
);
1123 /* Fallback to older version */
1125 ret
= lbs_set_data_rate(priv
, new_rate
);
1128 lbs_deb_leave_args(LBS_DEB_WEXT
, "ret %d", ret
);
1132 static int lbs_get_rate(struct net_device
*dev
, struct iw_request_info
*info
,
1133 struct iw_param
*vwrq
, char *extra
)
1135 struct lbs_private
*priv
= dev
->ml_priv
;
1137 lbs_deb_enter(LBS_DEB_WEXT
);
1139 if (priv
->connect_status
== LBS_CONNECTED
) {
1140 vwrq
->value
= priv
->cur_rate
* 500000;
1142 if (priv
->enablehwauto
)
1152 lbs_deb_leave(LBS_DEB_WEXT
);
1156 static int lbs_set_mode(struct net_device
*dev
,
1157 struct iw_request_info
*info
, u32
* uwrq
, char *extra
)
1160 struct lbs_private
*priv
= dev
->ml_priv
;
1161 struct assoc_request
* assoc_req
;
1163 lbs_deb_enter(LBS_DEB_WEXT
);
1165 if ( (*uwrq
!= IW_MODE_ADHOC
)
1166 && (*uwrq
!= IW_MODE_INFRA
)
1167 && (*uwrq
!= IW_MODE_AUTO
)) {
1168 lbs_deb_wext("Invalid mode: 0x%x\n", *uwrq
);
1173 mutex_lock(&priv
->lock
);
1174 assoc_req
= lbs_get_association_request(priv
);
1177 lbs_cancel_association_work(priv
);
1179 assoc_req
->mode
= *uwrq
;
1180 set_bit(ASSOC_FLAG_MODE
, &assoc_req
->flags
);
1181 lbs_postpone_association_work(priv
);
1182 lbs_deb_wext("Switching to mode: 0x%x\n", *uwrq
);
1184 mutex_unlock(&priv
->lock
);
1187 lbs_deb_leave_args(LBS_DEB_WEXT
, "ret %d", ret
);
1193 * @brief Get Encryption key
1195 * @param dev A pointer to net_device structure
1196 * @param info A pointer to iw_request_info structure
1197 * @param vwrq A pointer to iw_param structure
1198 * @param extra A pointer to extra data buf
1199 * @return 0 --success, otherwise fail
1201 static int lbs_get_encode(struct net_device
*dev
,
1202 struct iw_request_info
*info
,
1203 struct iw_point
*dwrq
, u8
* extra
)
1205 struct lbs_private
*priv
= dev
->ml_priv
;
1206 int index
= (dwrq
->flags
& IW_ENCODE_INDEX
) - 1;
1208 lbs_deb_enter(LBS_DEB_WEXT
);
1210 lbs_deb_wext("flags 0x%x, index %d, length %d, wep_tx_keyidx %d\n",
1211 dwrq
->flags
, index
, dwrq
->length
, priv
->wep_tx_keyidx
);
1215 /* Authentication method */
1216 switch (priv
->secinfo
.auth_mode
) {
1217 case IW_AUTH_ALG_OPEN_SYSTEM
:
1218 dwrq
->flags
= IW_ENCODE_OPEN
;
1221 case IW_AUTH_ALG_SHARED_KEY
:
1222 case IW_AUTH_ALG_LEAP
:
1223 dwrq
->flags
= IW_ENCODE_RESTRICTED
;
1226 dwrq
->flags
= IW_ENCODE_DISABLED
| IW_ENCODE_OPEN
;
1230 memset(extra
, 0, 16);
1232 mutex_lock(&priv
->lock
);
1234 /* Default to returning current transmit key */
1236 index
= priv
->wep_tx_keyidx
;
1238 if ((priv
->wep_keys
[index
].len
) && priv
->secinfo
.wep_enabled
) {
1239 memcpy(extra
, priv
->wep_keys
[index
].key
,
1240 priv
->wep_keys
[index
].len
);
1241 dwrq
->length
= priv
->wep_keys
[index
].len
;
1243 dwrq
->flags
|= (index
+ 1);
1244 /* Return WEP enabled */
1245 dwrq
->flags
&= ~IW_ENCODE_DISABLED
;
1246 } else if ((priv
->secinfo
.WPAenabled
)
1247 || (priv
->secinfo
.WPA2enabled
)) {
1248 /* return WPA enabled */
1249 dwrq
->flags
&= ~IW_ENCODE_DISABLED
;
1250 dwrq
->flags
|= IW_ENCODE_NOKEY
;
1252 dwrq
->flags
|= IW_ENCODE_DISABLED
;
1255 mutex_unlock(&priv
->lock
);
1257 lbs_deb_wext("key: %02x:%02x:%02x:%02x:%02x:%02x, keylen %d\n",
1258 extra
[0], extra
[1], extra
[2],
1259 extra
[3], extra
[4], extra
[5], dwrq
->length
);
1261 lbs_deb_wext("return flags 0x%x\n", dwrq
->flags
);
1263 lbs_deb_leave(LBS_DEB_WEXT
);
1268 * @brief Set Encryption key (internal)
1270 * @param priv A pointer to private card structure
1271 * @param key_material A pointer to key material
1272 * @param key_length length of key material
1273 * @param index key index to set
1274 * @param set_tx_key Force set TX key (1 = yes, 0 = no)
1275 * @return 0 --success, otherwise fail
1277 static int lbs_set_wep_key(struct assoc_request
*assoc_req
,
1278 const char *key_material
,
1284 struct enc_key
*pkey
;
1286 lbs_deb_enter(LBS_DEB_WEXT
);
1288 /* Paranoid validation of key index */
1294 /* validate max key length */
1295 if (key_length
> KEY_LEN_WEP_104
) {
1300 pkey
= &assoc_req
->wep_keys
[index
];
1302 if (key_length
> 0) {
1303 memset(pkey
, 0, sizeof(struct enc_key
));
1304 pkey
->type
= KEY_TYPE_ID_WEP
;
1306 /* Standardize the key length */
1307 pkey
->len
= (key_length
> KEY_LEN_WEP_40
) ?
1308 KEY_LEN_WEP_104
: KEY_LEN_WEP_40
;
1309 memcpy(pkey
->key
, key_material
, key_length
);
1313 /* Ensure the chosen key is valid */
1315 lbs_deb_wext("key not set, so cannot enable it\n");
1319 assoc_req
->wep_tx_keyidx
= index
;
1322 assoc_req
->secinfo
.wep_enabled
= 1;
1325 lbs_deb_leave_args(LBS_DEB_WEXT
, "ret %d", ret
);
1329 static int validate_key_index(u16 def_index
, u16 raw_index
,
1330 u16
*out_index
, u16
*is_default
)
1332 if (!out_index
|| !is_default
)
1335 /* Verify index if present, otherwise use default TX key index */
1336 if (raw_index
> 0) {
1339 *out_index
= raw_index
- 1;
1341 *out_index
= def_index
;
1347 static void disable_wep(struct assoc_request
*assoc_req
)
1351 lbs_deb_enter(LBS_DEB_WEXT
);
1353 /* Set Open System auth mode */
1354 assoc_req
->secinfo
.auth_mode
= IW_AUTH_ALG_OPEN_SYSTEM
;
1356 /* Clear WEP keys and mark WEP as disabled */
1357 assoc_req
->secinfo
.wep_enabled
= 0;
1358 for (i
= 0; i
< 4; i
++)
1359 assoc_req
->wep_keys
[i
].len
= 0;
1361 set_bit(ASSOC_FLAG_SECINFO
, &assoc_req
->flags
);
1362 set_bit(ASSOC_FLAG_WEP_KEYS
, &assoc_req
->flags
);
1364 lbs_deb_leave(LBS_DEB_WEXT
);
1367 static void disable_wpa(struct assoc_request
*assoc_req
)
1369 lbs_deb_enter(LBS_DEB_WEXT
);
1371 memset(&assoc_req
->wpa_mcast_key
, 0, sizeof (struct enc_key
));
1372 assoc_req
->wpa_mcast_key
.flags
= KEY_INFO_WPA_MCAST
;
1373 set_bit(ASSOC_FLAG_WPA_MCAST_KEY
, &assoc_req
->flags
);
1375 memset(&assoc_req
->wpa_unicast_key
, 0, sizeof (struct enc_key
));
1376 assoc_req
->wpa_unicast_key
.flags
= KEY_INFO_WPA_UNICAST
;
1377 set_bit(ASSOC_FLAG_WPA_UCAST_KEY
, &assoc_req
->flags
);
1379 assoc_req
->secinfo
.WPAenabled
= 0;
1380 assoc_req
->secinfo
.WPA2enabled
= 0;
1381 set_bit(ASSOC_FLAG_SECINFO
, &assoc_req
->flags
);
1383 lbs_deb_leave(LBS_DEB_WEXT
);
1387 * @brief Set Encryption key
1389 * @param dev A pointer to net_device structure
1390 * @param info A pointer to iw_request_info structure
1391 * @param vwrq A pointer to iw_param structure
1392 * @param extra A pointer to extra data buf
1393 * @return 0 --success, otherwise fail
1395 static int lbs_set_encode(struct net_device
*dev
,
1396 struct iw_request_info
*info
,
1397 struct iw_point
*dwrq
, char *extra
)
1400 struct lbs_private
*priv
= dev
->ml_priv
;
1401 struct assoc_request
* assoc_req
;
1402 u16 is_default
= 0, index
= 0, set_tx_key
= 0;
1404 lbs_deb_enter(LBS_DEB_WEXT
);
1406 mutex_lock(&priv
->lock
);
1407 assoc_req
= lbs_get_association_request(priv
);
1413 if (dwrq
->flags
& IW_ENCODE_DISABLED
) {
1414 disable_wep (assoc_req
);
1415 disable_wpa (assoc_req
);
1419 ret
= validate_key_index(assoc_req
->wep_tx_keyidx
,
1420 (dwrq
->flags
& IW_ENCODE_INDEX
),
1421 &index
, &is_default
);
1427 /* If WEP isn't enabled, or if there is no key data but a valid
1428 * index, set the TX key.
1430 if (!assoc_req
->secinfo
.wep_enabled
|| (dwrq
->length
== 0 && !is_default
))
1433 ret
= lbs_set_wep_key(assoc_req
, extra
, dwrq
->length
, index
, set_tx_key
);
1438 set_bit(ASSOC_FLAG_WEP_KEYS
, &assoc_req
->flags
);
1440 set_bit(ASSOC_FLAG_WEP_TX_KEYIDX
, &assoc_req
->flags
);
1442 if (dwrq
->flags
& IW_ENCODE_RESTRICTED
) {
1443 assoc_req
->secinfo
.auth_mode
= IW_AUTH_ALG_SHARED_KEY
;
1444 } else if (dwrq
->flags
& IW_ENCODE_OPEN
) {
1445 assoc_req
->secinfo
.auth_mode
= IW_AUTH_ALG_OPEN_SYSTEM
;
1450 set_bit(ASSOC_FLAG_SECINFO
, &assoc_req
->flags
);
1451 lbs_postpone_association_work(priv
);
1453 lbs_cancel_association_work(priv
);
1455 mutex_unlock(&priv
->lock
);
1457 lbs_deb_leave_args(LBS_DEB_WEXT
, "ret %d", ret
);
1462 * @brief Get Extended Encryption key (WPA/802.1x and WEP)
1464 * @param dev A pointer to net_device structure
1465 * @param info A pointer to iw_request_info structure
1466 * @param vwrq A pointer to iw_param structure
1467 * @param extra A pointer to extra data buf
1468 * @return 0 on success, otherwise failure
1470 static int lbs_get_encodeext(struct net_device
*dev
,
1471 struct iw_request_info
*info
,
1472 struct iw_point
*dwrq
,
1476 struct lbs_private
*priv
= dev
->ml_priv
;
1477 struct iw_encode_ext
*ext
= (struct iw_encode_ext
*)extra
;
1478 int index
, max_key_len
;
1480 lbs_deb_enter(LBS_DEB_WEXT
);
1482 max_key_len
= dwrq
->length
- sizeof(*ext
);
1483 if (max_key_len
< 0)
1486 index
= dwrq
->flags
& IW_ENCODE_INDEX
;
1488 if (index
< 1 || index
> 4)
1492 index
= priv
->wep_tx_keyidx
;
1495 if (!(ext
->ext_flags
& IW_ENCODE_EXT_GROUP_KEY
) &&
1496 ext
->alg
!= IW_ENCODE_ALG_WEP
) {
1497 if (index
!= 0 || priv
->mode
!= IW_MODE_INFRA
)
1501 dwrq
->flags
= index
+ 1;
1502 memset(ext
, 0, sizeof(*ext
));
1504 if ( !priv
->secinfo
.wep_enabled
1505 && !priv
->secinfo
.WPAenabled
1506 && !priv
->secinfo
.WPA2enabled
) {
1507 ext
->alg
= IW_ENCODE_ALG_NONE
;
1509 dwrq
->flags
|= IW_ENCODE_DISABLED
;
1513 if ( priv
->secinfo
.wep_enabled
1514 && !priv
->secinfo
.WPAenabled
1515 && !priv
->secinfo
.WPA2enabled
) {
1517 ext
->alg
= IW_ENCODE_ALG_WEP
;
1518 ext
->key_len
= priv
->wep_keys
[index
].len
;
1519 key
= &priv
->wep_keys
[index
].key
[0];
1520 } else if ( !priv
->secinfo
.wep_enabled
1521 && (priv
->secinfo
.WPAenabled
||
1522 priv
->secinfo
.WPA2enabled
)) {
1524 struct enc_key
* pkey
= NULL
;
1526 if ( priv
->wpa_mcast_key
.len
1527 && (priv
->wpa_mcast_key
.flags
& KEY_INFO_WPA_ENABLED
))
1528 pkey
= &priv
->wpa_mcast_key
;
1529 else if ( priv
->wpa_unicast_key
.len
1530 && (priv
->wpa_unicast_key
.flags
& KEY_INFO_WPA_ENABLED
))
1531 pkey
= &priv
->wpa_unicast_key
;
1534 if (pkey
->type
== KEY_TYPE_ID_AES
) {
1535 ext
->alg
= IW_ENCODE_ALG_CCMP
;
1537 ext
->alg
= IW_ENCODE_ALG_TKIP
;
1539 ext
->key_len
= pkey
->len
;
1540 key
= &pkey
->key
[0];
1542 ext
->alg
= IW_ENCODE_ALG_TKIP
;
1549 if (ext
->key_len
> max_key_len
) {
1555 memcpy(ext
->key
, key
, ext
->key_len
);
1557 dwrq
->flags
|= IW_ENCODE_NOKEY
;
1558 dwrq
->flags
|= IW_ENCODE_ENABLED
;
1563 lbs_deb_leave_args(LBS_DEB_WEXT
, "ret %d", ret
);
1568 * @brief Set Encryption key Extended (WPA/802.1x and WEP)
1570 * @param dev A pointer to net_device structure
1571 * @param info A pointer to iw_request_info structure
1572 * @param vwrq A pointer to iw_param structure
1573 * @param extra A pointer to extra data buf
1574 * @return 0 --success, otherwise fail
1576 static int lbs_set_encodeext(struct net_device
*dev
,
1577 struct iw_request_info
*info
,
1578 struct iw_point
*dwrq
,
1582 struct lbs_private
*priv
= dev
->ml_priv
;
1583 struct iw_encode_ext
*ext
= (struct iw_encode_ext
*)extra
;
1585 struct assoc_request
* assoc_req
;
1587 lbs_deb_enter(LBS_DEB_WEXT
);
1589 mutex_lock(&priv
->lock
);
1590 assoc_req
= lbs_get_association_request(priv
);
1596 if ((alg
== IW_ENCODE_ALG_NONE
) || (dwrq
->flags
& IW_ENCODE_DISABLED
)) {
1597 disable_wep (assoc_req
);
1598 disable_wpa (assoc_req
);
1599 } else if (alg
== IW_ENCODE_ALG_WEP
) {
1600 u16 is_default
= 0, index
, set_tx_key
= 0;
1602 ret
= validate_key_index(assoc_req
->wep_tx_keyidx
,
1603 (dwrq
->flags
& IW_ENCODE_INDEX
),
1604 &index
, &is_default
);
1608 /* If WEP isn't enabled, or if there is no key data but a valid
1609 * index, or if the set-TX-key flag was passed, set the TX key.
1611 if ( !assoc_req
->secinfo
.wep_enabled
1612 || (dwrq
->length
== 0 && !is_default
)
1613 || (ext
->ext_flags
& IW_ENCODE_EXT_SET_TX_KEY
))
1616 /* Copy key to driver */
1617 ret
= lbs_set_wep_key(assoc_req
, ext
->key
, ext
->key_len
, index
,
1622 if (dwrq
->flags
& IW_ENCODE_RESTRICTED
) {
1623 assoc_req
->secinfo
.auth_mode
= IW_AUTH_ALG_SHARED_KEY
;
1624 } else if (dwrq
->flags
& IW_ENCODE_OPEN
) {
1625 assoc_req
->secinfo
.auth_mode
= IW_AUTH_ALG_OPEN_SYSTEM
;
1628 /* Mark the various WEP bits as modified */
1629 set_bit(ASSOC_FLAG_SECINFO
, &assoc_req
->flags
);
1631 set_bit(ASSOC_FLAG_WEP_KEYS
, &assoc_req
->flags
);
1633 set_bit(ASSOC_FLAG_WEP_TX_KEYIDX
, &assoc_req
->flags
);
1634 } else if ((alg
== IW_ENCODE_ALG_TKIP
) || (alg
== IW_ENCODE_ALG_CCMP
)) {
1635 struct enc_key
* pkey
;
1637 /* validate key length */
1638 if (((alg
== IW_ENCODE_ALG_TKIP
)
1639 && (ext
->key_len
!= KEY_LEN_WPA_TKIP
))
1640 || ((alg
== IW_ENCODE_ALG_CCMP
)
1641 && (ext
->key_len
!= KEY_LEN_WPA_AES
))) {
1642 lbs_deb_wext("invalid size %d for key of alg "
1650 if (ext
->ext_flags
& IW_ENCODE_EXT_GROUP_KEY
) {
1651 pkey
= &assoc_req
->wpa_mcast_key
;
1652 set_bit(ASSOC_FLAG_WPA_MCAST_KEY
, &assoc_req
->flags
);
1654 pkey
= &assoc_req
->wpa_unicast_key
;
1655 set_bit(ASSOC_FLAG_WPA_UCAST_KEY
, &assoc_req
->flags
);
1658 memset(pkey
, 0, sizeof (struct enc_key
));
1659 memcpy(pkey
->key
, ext
->key
, ext
->key_len
);
1660 pkey
->len
= ext
->key_len
;
1662 pkey
->flags
|= KEY_INFO_WPA_ENABLED
;
1664 /* Do this after zeroing key structure */
1665 if (ext
->ext_flags
& IW_ENCODE_EXT_GROUP_KEY
) {
1666 pkey
->flags
|= KEY_INFO_WPA_MCAST
;
1668 pkey
->flags
|= KEY_INFO_WPA_UNICAST
;
1671 if (alg
== IW_ENCODE_ALG_TKIP
) {
1672 pkey
->type
= KEY_TYPE_ID_TKIP
;
1673 } else if (alg
== IW_ENCODE_ALG_CCMP
) {
1674 pkey
->type
= KEY_TYPE_ID_AES
;
1677 /* If WPA isn't enabled yet, do that now */
1678 if ( assoc_req
->secinfo
.WPAenabled
== 0
1679 && assoc_req
->secinfo
.WPA2enabled
== 0) {
1680 assoc_req
->secinfo
.WPAenabled
= 1;
1681 assoc_req
->secinfo
.WPA2enabled
= 1;
1682 set_bit(ASSOC_FLAG_SECINFO
, &assoc_req
->flags
);
1685 /* Only disable wep if necessary: can't waste time here. */
1686 if (priv
->mac_control
& CMD_ACT_MAC_WEP_ENABLE
)
1687 disable_wep(assoc_req
);
1692 /* 802.1x and WPA rekeying must happen as quickly as possible,
1693 * especially during the 4-way handshake; thus if in
1694 * infrastructure mode, and either (a) 802.1x is enabled or
1695 * (b) WPA is being used, set the key right away.
1697 if (assoc_req
->mode
== IW_MODE_INFRA
&&
1698 ((assoc_req
->secinfo
.key_mgmt
& IW_AUTH_KEY_MGMT_802_1X
) ||
1699 (assoc_req
->secinfo
.key_mgmt
& IW_AUTH_KEY_MGMT_PSK
) ||
1700 assoc_req
->secinfo
.WPAenabled
||
1701 assoc_req
->secinfo
.WPA2enabled
)) {
1702 lbs_do_association_work(priv
);
1704 lbs_postpone_association_work(priv
);
1706 lbs_cancel_association_work(priv
);
1708 mutex_unlock(&priv
->lock
);
1710 lbs_deb_leave_args(LBS_DEB_WEXT
, "ret %d", ret
);
1715 static int lbs_set_genie(struct net_device
*dev
,
1716 struct iw_request_info
*info
,
1717 struct iw_point
*dwrq
,
1720 struct lbs_private
*priv
= dev
->ml_priv
;
1722 struct assoc_request
* assoc_req
;
1724 lbs_deb_enter(LBS_DEB_WEXT
);
1726 mutex_lock(&priv
->lock
);
1727 assoc_req
= lbs_get_association_request(priv
);
1733 if (dwrq
->length
> MAX_WPA_IE_LEN
||
1734 (dwrq
->length
&& extra
== NULL
)) {
1740 memcpy(&assoc_req
->wpa_ie
[0], extra
, dwrq
->length
);
1741 assoc_req
->wpa_ie_len
= dwrq
->length
;
1743 memset(&assoc_req
->wpa_ie
[0], 0, sizeof(priv
->wpa_ie
));
1744 assoc_req
->wpa_ie_len
= 0;
1749 set_bit(ASSOC_FLAG_WPA_IE
, &assoc_req
->flags
);
1750 lbs_postpone_association_work(priv
);
1752 lbs_cancel_association_work(priv
);
1754 mutex_unlock(&priv
->lock
);
1756 lbs_deb_leave_args(LBS_DEB_WEXT
, "ret %d", ret
);
1760 static int lbs_get_genie(struct net_device
*dev
,
1761 struct iw_request_info
*info
,
1762 struct iw_point
*dwrq
,
1766 struct lbs_private
*priv
= dev
->ml_priv
;
1768 lbs_deb_enter(LBS_DEB_WEXT
);
1770 if (priv
->wpa_ie_len
== 0) {
1775 if (dwrq
->length
< priv
->wpa_ie_len
) {
1780 dwrq
->length
= priv
->wpa_ie_len
;
1781 memcpy(extra
, &priv
->wpa_ie
[0], priv
->wpa_ie_len
);
1784 lbs_deb_leave_args(LBS_DEB_WEXT
, "ret %d", ret
);
1789 static int lbs_set_auth(struct net_device
*dev
,
1790 struct iw_request_info
*info
,
1791 struct iw_param
*dwrq
,
1794 struct lbs_private
*priv
= dev
->ml_priv
;
1795 struct assoc_request
* assoc_req
;
1799 lbs_deb_enter(LBS_DEB_WEXT
);
1801 mutex_lock(&priv
->lock
);
1802 assoc_req
= lbs_get_association_request(priv
);
1808 switch (dwrq
->flags
& IW_AUTH_INDEX
) {
1809 case IW_AUTH_PRIVACY_INVOKED
:
1810 case IW_AUTH_RX_UNENCRYPTED_EAPOL
:
1811 case IW_AUTH_TKIP_COUNTERMEASURES
:
1812 case IW_AUTH_CIPHER_PAIRWISE
:
1813 case IW_AUTH_CIPHER_GROUP
:
1814 case IW_AUTH_DROP_UNENCRYPTED
:
1816 * libertas does not use these parameters
1820 case IW_AUTH_KEY_MGMT
:
1821 assoc_req
->secinfo
.key_mgmt
= dwrq
->value
;
1825 case IW_AUTH_WPA_VERSION
:
1826 if (dwrq
->value
& IW_AUTH_WPA_VERSION_DISABLED
) {
1827 assoc_req
->secinfo
.WPAenabled
= 0;
1828 assoc_req
->secinfo
.WPA2enabled
= 0;
1829 disable_wpa (assoc_req
);
1831 if (dwrq
->value
& IW_AUTH_WPA_VERSION_WPA
) {
1832 assoc_req
->secinfo
.WPAenabled
= 1;
1833 assoc_req
->secinfo
.wep_enabled
= 0;
1834 assoc_req
->secinfo
.auth_mode
= IW_AUTH_ALG_OPEN_SYSTEM
;
1836 if (dwrq
->value
& IW_AUTH_WPA_VERSION_WPA2
) {
1837 assoc_req
->secinfo
.WPA2enabled
= 1;
1838 assoc_req
->secinfo
.wep_enabled
= 0;
1839 assoc_req
->secinfo
.auth_mode
= IW_AUTH_ALG_OPEN_SYSTEM
;
1844 case IW_AUTH_80211_AUTH_ALG
:
1845 if (dwrq
->value
& IW_AUTH_ALG_SHARED_KEY
) {
1846 assoc_req
->secinfo
.auth_mode
= IW_AUTH_ALG_SHARED_KEY
;
1847 } else if (dwrq
->value
& IW_AUTH_ALG_OPEN_SYSTEM
) {
1848 assoc_req
->secinfo
.auth_mode
= IW_AUTH_ALG_OPEN_SYSTEM
;
1849 } else if (dwrq
->value
& IW_AUTH_ALG_LEAP
) {
1850 assoc_req
->secinfo
.auth_mode
= IW_AUTH_ALG_LEAP
;
1857 case IW_AUTH_WPA_ENABLED
:
1859 if (!assoc_req
->secinfo
.WPAenabled
&&
1860 !assoc_req
->secinfo
.WPA2enabled
) {
1861 assoc_req
->secinfo
.WPAenabled
= 1;
1862 assoc_req
->secinfo
.WPA2enabled
= 1;
1863 assoc_req
->secinfo
.wep_enabled
= 0;
1864 assoc_req
->secinfo
.auth_mode
= IW_AUTH_ALG_OPEN_SYSTEM
;
1867 assoc_req
->secinfo
.WPAenabled
= 0;
1868 assoc_req
->secinfo
.WPA2enabled
= 0;
1869 disable_wpa (assoc_req
);
1882 set_bit(ASSOC_FLAG_SECINFO
, &assoc_req
->flags
);
1883 lbs_postpone_association_work(priv
);
1884 } else if (ret
!= -EOPNOTSUPP
) {
1885 lbs_cancel_association_work(priv
);
1887 mutex_unlock(&priv
->lock
);
1889 lbs_deb_leave_args(LBS_DEB_WEXT
, "ret %d", ret
);
1893 static int lbs_get_auth(struct net_device
*dev
,
1894 struct iw_request_info
*info
,
1895 struct iw_param
*dwrq
,
1899 struct lbs_private
*priv
= dev
->ml_priv
;
1901 lbs_deb_enter(LBS_DEB_WEXT
);
1903 switch (dwrq
->flags
& IW_AUTH_INDEX
) {
1904 case IW_AUTH_KEY_MGMT
:
1905 dwrq
->value
= priv
->secinfo
.key_mgmt
;
1908 case IW_AUTH_WPA_VERSION
:
1910 if (priv
->secinfo
.WPAenabled
)
1911 dwrq
->value
|= IW_AUTH_WPA_VERSION_WPA
;
1912 if (priv
->secinfo
.WPA2enabled
)
1913 dwrq
->value
|= IW_AUTH_WPA_VERSION_WPA2
;
1915 dwrq
->value
|= IW_AUTH_WPA_VERSION_DISABLED
;
1918 case IW_AUTH_80211_AUTH_ALG
:
1919 dwrq
->value
= priv
->secinfo
.auth_mode
;
1922 case IW_AUTH_WPA_ENABLED
:
1923 if (priv
->secinfo
.WPAenabled
&& priv
->secinfo
.WPA2enabled
)
1931 lbs_deb_leave_args(LBS_DEB_WEXT
, "ret %d", ret
);
1936 static int lbs_set_txpow(struct net_device
*dev
, struct iw_request_info
*info
,
1937 struct iw_param
*vwrq
, char *extra
)
1940 struct lbs_private
*priv
= dev
->ml_priv
;
1941 s16 dbm
= (s16
) vwrq
->value
;
1943 lbs_deb_enter(LBS_DEB_WEXT
);
1945 if (vwrq
->disabled
) {
1946 lbs_set_radio(priv
, RADIO_PREAMBLE_AUTO
, 0);
1950 if (vwrq
->fixed
== 0) {
1951 /* User requests automatic tx power control, however there are
1952 * many auto tx settings. For now use firmware defaults until
1953 * we come up with a good way to expose these to the user. */
1954 if (priv
->fwrelease
< 0x09000000) {
1955 ret
= lbs_set_power_adapt_cfg(priv
, 1,
1956 POW_ADAPT_DEFAULT_P0
,
1957 POW_ADAPT_DEFAULT_P1
,
1958 POW_ADAPT_DEFAULT_P2
);
1962 ret
= lbs_set_tpc_cfg(priv
, 0, TPC_DEFAULT_P0
, TPC_DEFAULT_P1
,
1966 dbm
= priv
->txpower_max
;
1968 /* Userspace check in iwrange if it should use dBm or mW,
1969 * therefore this should never happen... Jean II */
1970 if ((vwrq
->flags
& IW_TXPOW_TYPE
) != IW_TXPOW_DBM
) {
1975 /* Validate requested power level against firmware allowed
1977 if (priv
->txpower_min
&& (dbm
< priv
->txpower_min
)) {
1982 if (priv
->txpower_max
&& (dbm
> priv
->txpower_max
)) {
1986 if (priv
->fwrelease
< 0x09000000) {
1987 ret
= lbs_set_power_adapt_cfg(priv
, 0,
1988 POW_ADAPT_DEFAULT_P0
,
1989 POW_ADAPT_DEFAULT_P1
,
1990 POW_ADAPT_DEFAULT_P2
);
1994 ret
= lbs_set_tpc_cfg(priv
, 0, TPC_DEFAULT_P0
, TPC_DEFAULT_P1
,
2000 /* If the radio was off, turn it on */
2001 if (!priv
->radio_on
) {
2002 ret
= lbs_set_radio(priv
, RADIO_PREAMBLE_AUTO
, 1);
2007 lbs_deb_wext("txpower set %d dBm\n", dbm
);
2009 ret
= lbs_set_tx_power(priv
, dbm
);
2012 lbs_deb_leave_args(LBS_DEB_WEXT
, "ret %d", ret
);
2016 static int lbs_get_essid(struct net_device
*dev
, struct iw_request_info
*info
,
2017 struct iw_point
*dwrq
, char *extra
)
2019 struct lbs_private
*priv
= dev
->ml_priv
;
2021 lbs_deb_enter(LBS_DEB_WEXT
);
2024 * Note : if dwrq->flags != 0, we should get the relevant SSID from
2029 * Get the current SSID
2031 if (priv
->connect_status
== LBS_CONNECTED
) {
2032 memcpy(extra
, priv
->curbssparams
.ssid
,
2033 priv
->curbssparams
.ssid_len
);
2035 memset(extra
, 0, 32);
2038 * If none, we may want to get the one that was set
2041 dwrq
->length
= priv
->curbssparams
.ssid_len
;
2043 dwrq
->flags
= 1; /* active */
2045 lbs_deb_leave(LBS_DEB_WEXT
);
2049 static int lbs_set_essid(struct net_device
*dev
, struct iw_request_info
*info
,
2050 struct iw_point
*dwrq
, char *extra
)
2052 struct lbs_private
*priv
= dev
->ml_priv
;
2054 u8 ssid
[IEEE80211_MAX_SSID_LEN
];
2056 struct assoc_request
* assoc_req
;
2057 int in_ssid_len
= dwrq
->length
;
2058 DECLARE_SSID_BUF(ssid_buf
);
2060 lbs_deb_enter(LBS_DEB_WEXT
);
2062 if (!priv
->radio_on
) {
2067 /* Check the size of the string */
2068 if (in_ssid_len
> IEEE80211_MAX_SSID_LEN
) {
2073 memset(&ssid
, 0, sizeof(ssid
));
2075 if (!dwrq
->flags
|| !in_ssid_len
) {
2076 /* "any" SSID requested; leave SSID blank */
2078 /* Specific SSID requested */
2079 memcpy(&ssid
, extra
, in_ssid_len
);
2080 ssid_len
= in_ssid_len
;
2084 lbs_deb_wext("requested any SSID\n");
2086 lbs_deb_wext("requested SSID '%s'\n",
2087 print_ssid(ssid_buf
, ssid
, ssid_len
));
2091 mutex_lock(&priv
->lock
);
2093 /* Get or create the current association request */
2094 assoc_req
= lbs_get_association_request(priv
);
2098 /* Copy the SSID to the association request */
2099 memcpy(&assoc_req
->ssid
, &ssid
, IEEE80211_MAX_SSID_LEN
);
2100 assoc_req
->ssid_len
= ssid_len
;
2101 set_bit(ASSOC_FLAG_SSID
, &assoc_req
->flags
);
2102 lbs_postpone_association_work(priv
);
2106 /* Cancel the association request if there was an error */
2108 lbs_cancel_association_work(priv
);
2111 mutex_unlock(&priv
->lock
);
2113 lbs_deb_leave_args(LBS_DEB_WEXT
, "ret %d", ret
);
2117 #ifdef CONFIG_LIBERTAS_MESH
2118 static int lbs_mesh_get_essid(struct net_device
*dev
,
2119 struct iw_request_info
*info
,
2120 struct iw_point
*dwrq
, char *extra
)
2122 struct lbs_private
*priv
= dev
->ml_priv
;
2124 lbs_deb_enter(LBS_DEB_WEXT
);
2126 memcpy(extra
, priv
->mesh_ssid
, priv
->mesh_ssid_len
);
2128 dwrq
->length
= priv
->mesh_ssid_len
;
2130 dwrq
->flags
= 1; /* active */
2132 lbs_deb_leave(LBS_DEB_WEXT
);
2136 static int lbs_mesh_set_essid(struct net_device
*dev
,
2137 struct iw_request_info
*info
,
2138 struct iw_point
*dwrq
, char *extra
)
2140 struct lbs_private
*priv
= dev
->ml_priv
;
2143 lbs_deb_enter(LBS_DEB_WEXT
);
2145 if (!priv
->radio_on
) {
2150 /* Check the size of the string */
2151 if (dwrq
->length
> IEEE80211_MAX_SSID_LEN
) {
2156 if (!dwrq
->flags
|| !dwrq
->length
) {
2160 /* Specific SSID requested */
2161 memcpy(priv
->mesh_ssid
, extra
, dwrq
->length
);
2162 priv
->mesh_ssid_len
= dwrq
->length
;
2165 lbs_mesh_config(priv
, CMD_ACT_MESH_CONFIG_START
,
2168 lbs_deb_leave_args(LBS_DEB_WEXT
, "ret %d", ret
);
2174 * @brief Connect to the AP or Ad-hoc Network with specific bssid
2176 * @param dev A pointer to net_device structure
2177 * @param info A pointer to iw_request_info structure
2178 * @param awrq A pointer to iw_param structure
2179 * @param extra A pointer to extra data buf
2180 * @return 0 --success, otherwise fail
2182 static int lbs_set_wap(struct net_device
*dev
, struct iw_request_info
*info
,
2183 struct sockaddr
*awrq
, char *extra
)
2185 struct lbs_private
*priv
= dev
->ml_priv
;
2186 struct assoc_request
* assoc_req
;
2189 lbs_deb_enter(LBS_DEB_WEXT
);
2191 if (!priv
->radio_on
)
2194 if (awrq
->sa_family
!= ARPHRD_ETHER
)
2197 lbs_deb_wext("ASSOC: WAP: sa_data %pM\n", awrq
->sa_data
);
2199 mutex_lock(&priv
->lock
);
2201 /* Get or create the current association request */
2202 assoc_req
= lbs_get_association_request(priv
);
2204 lbs_cancel_association_work(priv
);
2207 /* Copy the BSSID to the association request */
2208 memcpy(&assoc_req
->bssid
, awrq
->sa_data
, ETH_ALEN
);
2209 set_bit(ASSOC_FLAG_BSSID
, &assoc_req
->flags
);
2210 lbs_postpone_association_work(priv
);
2213 mutex_unlock(&priv
->lock
);
2219 * iwconfig settable callbacks
2221 static const iw_handler lbs_handler
[] = {
2222 (iw_handler
) NULL
, /* SIOCSIWCOMMIT */
2223 (iw_handler
) lbs_get_name
, /* SIOCGIWNAME */
2224 (iw_handler
) NULL
, /* SIOCSIWNWID */
2225 (iw_handler
) NULL
, /* SIOCGIWNWID */
2226 (iw_handler
) lbs_set_freq
, /* SIOCSIWFREQ */
2227 (iw_handler
) lbs_get_freq
, /* SIOCGIWFREQ */
2228 (iw_handler
) lbs_set_mode
, /* SIOCSIWMODE */
2229 (iw_handler
) lbs_get_mode
, /* SIOCGIWMODE */
2230 (iw_handler
) NULL
, /* SIOCSIWSENS */
2231 (iw_handler
) NULL
, /* SIOCGIWSENS */
2232 (iw_handler
) NULL
, /* SIOCSIWRANGE */
2233 (iw_handler
) lbs_get_range
, /* SIOCGIWRANGE */
2234 (iw_handler
) NULL
, /* SIOCSIWPRIV */
2235 (iw_handler
) NULL
, /* SIOCGIWPRIV */
2236 (iw_handler
) NULL
, /* SIOCSIWSTATS */
2237 (iw_handler
) NULL
, /* SIOCGIWSTATS */
2238 iw_handler_set_spy
, /* SIOCSIWSPY */
2239 iw_handler_get_spy
, /* SIOCGIWSPY */
2240 iw_handler_set_thrspy
, /* SIOCSIWTHRSPY */
2241 iw_handler_get_thrspy
, /* SIOCGIWTHRSPY */
2242 (iw_handler
) lbs_set_wap
, /* SIOCSIWAP */
2243 (iw_handler
) lbs_get_wap
, /* SIOCGIWAP */
2244 (iw_handler
) NULL
, /* SIOCSIWMLME */
2245 (iw_handler
) NULL
, /* SIOCGIWAPLIST - deprecated */
2246 (iw_handler
) lbs_set_scan
, /* SIOCSIWSCAN */
2247 (iw_handler
) lbs_get_scan
, /* SIOCGIWSCAN */
2248 (iw_handler
) lbs_set_essid
, /* SIOCSIWESSID */
2249 (iw_handler
) lbs_get_essid
, /* SIOCGIWESSID */
2250 (iw_handler
) lbs_set_nick
, /* SIOCSIWNICKN */
2251 (iw_handler
) lbs_get_nick
, /* SIOCGIWNICKN */
2252 (iw_handler
) NULL
, /* -- hole -- */
2253 (iw_handler
) NULL
, /* -- hole -- */
2254 (iw_handler
) lbs_set_rate
, /* SIOCSIWRATE */
2255 (iw_handler
) lbs_get_rate
, /* SIOCGIWRATE */
2256 (iw_handler
) lbs_set_rts
, /* SIOCSIWRTS */
2257 (iw_handler
) lbs_get_rts
, /* SIOCGIWRTS */
2258 (iw_handler
) lbs_set_frag
, /* SIOCSIWFRAG */
2259 (iw_handler
) lbs_get_frag
, /* SIOCGIWFRAG */
2260 (iw_handler
) lbs_set_txpow
, /* SIOCSIWTXPOW */
2261 (iw_handler
) lbs_get_txpow
, /* SIOCGIWTXPOW */
2262 (iw_handler
) lbs_set_retry
, /* SIOCSIWRETRY */
2263 (iw_handler
) lbs_get_retry
, /* SIOCGIWRETRY */
2264 (iw_handler
) lbs_set_encode
, /* SIOCSIWENCODE */
2265 (iw_handler
) lbs_get_encode
, /* SIOCGIWENCODE */
2266 (iw_handler
) lbs_set_power
, /* SIOCSIWPOWER */
2267 (iw_handler
) lbs_get_power
, /* SIOCGIWPOWER */
2268 (iw_handler
) NULL
, /* -- hole -- */
2269 (iw_handler
) NULL
, /* -- hole -- */
2270 (iw_handler
) lbs_set_genie
, /* SIOCSIWGENIE */
2271 (iw_handler
) lbs_get_genie
, /* SIOCGIWGENIE */
2272 (iw_handler
) lbs_set_auth
, /* SIOCSIWAUTH */
2273 (iw_handler
) lbs_get_auth
, /* SIOCGIWAUTH */
2274 (iw_handler
) lbs_set_encodeext
,/* SIOCSIWENCODEEXT */
2275 (iw_handler
) lbs_get_encodeext
,/* SIOCGIWENCODEEXT */
2276 (iw_handler
) NULL
, /* SIOCSIWPMKSA */
2278 struct iw_handler_def lbs_handler_def
= {
2279 .num_standard
= ARRAY_SIZE(lbs_handler
),
2280 .standard
= (iw_handler
*) lbs_handler
,
2281 .get_wireless_stats
= lbs_get_wireless_stats
,
2284 #ifdef CONFIG_LIBERTAS_MESH
2285 static const iw_handler mesh_wlan_handler
[] = {
2286 (iw_handler
) NULL
, /* SIOCSIWCOMMIT */
2287 (iw_handler
) lbs_get_name
, /* SIOCGIWNAME */
2288 (iw_handler
) NULL
, /* SIOCSIWNWID */
2289 (iw_handler
) NULL
, /* SIOCGIWNWID */
2290 (iw_handler
) lbs_mesh_set_freq
, /* SIOCSIWFREQ */
2291 (iw_handler
) lbs_get_freq
, /* SIOCGIWFREQ */
2292 (iw_handler
) NULL
, /* SIOCSIWMODE */
2293 (iw_handler
) mesh_wlan_get_mode
, /* SIOCGIWMODE */
2294 (iw_handler
) NULL
, /* SIOCSIWSENS */
2295 (iw_handler
) NULL
, /* SIOCGIWSENS */
2296 (iw_handler
) NULL
, /* SIOCSIWRANGE */
2297 (iw_handler
) lbs_get_range
, /* SIOCGIWRANGE */
2298 (iw_handler
) NULL
, /* SIOCSIWPRIV */
2299 (iw_handler
) NULL
, /* SIOCGIWPRIV */
2300 (iw_handler
) NULL
, /* SIOCSIWSTATS */
2301 (iw_handler
) NULL
, /* SIOCGIWSTATS */
2302 iw_handler_set_spy
, /* SIOCSIWSPY */
2303 iw_handler_get_spy
, /* SIOCGIWSPY */
2304 iw_handler_set_thrspy
, /* SIOCSIWTHRSPY */
2305 iw_handler_get_thrspy
, /* SIOCGIWTHRSPY */
2306 (iw_handler
) NULL
, /* SIOCSIWAP */
2307 (iw_handler
) NULL
, /* SIOCGIWAP */
2308 (iw_handler
) NULL
, /* SIOCSIWMLME */
2309 (iw_handler
) NULL
, /* SIOCGIWAPLIST - deprecated */
2310 (iw_handler
) lbs_set_scan
, /* SIOCSIWSCAN */
2311 (iw_handler
) lbs_get_scan
, /* SIOCGIWSCAN */
2312 (iw_handler
) lbs_mesh_set_essid
,/* SIOCSIWESSID */
2313 (iw_handler
) lbs_mesh_get_essid
,/* SIOCGIWESSID */
2314 (iw_handler
) NULL
, /* SIOCSIWNICKN */
2315 (iw_handler
) mesh_get_nick
, /* SIOCGIWNICKN */
2316 (iw_handler
) NULL
, /* -- hole -- */
2317 (iw_handler
) NULL
, /* -- hole -- */
2318 (iw_handler
) lbs_set_rate
, /* SIOCSIWRATE */
2319 (iw_handler
) lbs_get_rate
, /* SIOCGIWRATE */
2320 (iw_handler
) lbs_set_rts
, /* SIOCSIWRTS */
2321 (iw_handler
) lbs_get_rts
, /* SIOCGIWRTS */
2322 (iw_handler
) lbs_set_frag
, /* SIOCSIWFRAG */
2323 (iw_handler
) lbs_get_frag
, /* SIOCGIWFRAG */
2324 (iw_handler
) lbs_set_txpow
, /* SIOCSIWTXPOW */
2325 (iw_handler
) lbs_get_txpow
, /* SIOCGIWTXPOW */
2326 (iw_handler
) lbs_set_retry
, /* SIOCSIWRETRY */
2327 (iw_handler
) lbs_get_retry
, /* SIOCGIWRETRY */
2328 (iw_handler
) lbs_set_encode
, /* SIOCSIWENCODE */
2329 (iw_handler
) lbs_get_encode
, /* SIOCGIWENCODE */
2330 (iw_handler
) lbs_set_power
, /* SIOCSIWPOWER */
2331 (iw_handler
) lbs_get_power
, /* SIOCGIWPOWER */
2332 (iw_handler
) NULL
, /* -- hole -- */
2333 (iw_handler
) NULL
, /* -- hole -- */
2334 (iw_handler
) lbs_set_genie
, /* SIOCSIWGENIE */
2335 (iw_handler
) lbs_get_genie
, /* SIOCGIWGENIE */
2336 (iw_handler
) lbs_set_auth
, /* SIOCSIWAUTH */
2337 (iw_handler
) lbs_get_auth
, /* SIOCGIWAUTH */
2338 (iw_handler
) lbs_set_encodeext
,/* SIOCSIWENCODEEXT */
2339 (iw_handler
) lbs_get_encodeext
,/* SIOCGIWENCODEEXT */
2340 (iw_handler
) NULL
, /* SIOCSIWPMKSA */
2343 struct iw_handler_def mesh_handler_def
= {
2344 .num_standard
= ARRAY_SIZE(mesh_wlan_handler
),
2345 .standard
= (iw_handler
*) mesh_wlan_handler
,
2346 .get_wireless_stats
= lbs_get_wireless_stats
,