2 * PS3 gelic network driver.
4 * Copyright (C) 2007 Sony Computer Entertainment Inc.
5 * Copyright 2007 Sony Corporation
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2
9 * as published by the Free Software Foundation.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22 #include <linux/kernel.h>
23 #include <linux/module.h>
24 #include <linux/slab.h>
26 #include <linux/etherdevice.h>
27 #include <linux/ethtool.h>
28 #include <linux/if_vlan.h>
32 #include <linux/tcp.h>
33 #include <linux/wireless.h>
34 #include <linux/ieee80211.h>
35 #include <linux/if_arp.h>
36 #include <linux/ctype.h>
37 #include <linux/string.h>
38 #include <net/iw_handler.h>
40 #include <linux/dma-mapping.h>
41 #include <net/checksum.h>
42 #include <asm/firmware.h>
44 #include <asm/lv1call.h>
46 #include "ps3_gelic_net.h"
47 #include "ps3_gelic_wireless.h"
50 static int gelic_wl_start_scan(struct gelic_wl_info
*wl
, int always_scan
,
51 u8
*essid
, size_t essid_len
);
52 static int gelic_wl_try_associate(struct net_device
*netdev
);
58 /* 802.11b/g channel to freq in MHz */
59 static const int channel_freq
[] = {
60 2412, 2417, 2422, 2427, 2432,
61 2437, 2442, 2447, 2452, 2457,
62 2462, 2467, 2472, 2484
64 #define NUM_CHANNELS ARRAY_SIZE(channel_freq)
67 static const int bitrate_list
[] = {
81 #define NUM_BITRATES ARRAY_SIZE(bitrate_list)
84 * wpa2 support requires the hypervisor version 2.0 or later
86 static inline int wpa2_capable(void)
88 return 0 <= ps3_compare_firmware_version(2, 0, 0);
91 static inline int precise_ie(void)
93 return 0 <= ps3_compare_firmware_version(2, 2, 0);
96 * post_eurus_cmd helpers
98 struct eurus_cmd_arg_info
{
99 int pre_arg
; /* command requires arg1, arg2 at POST COMMAND */
100 int post_arg
; /* command requires arg1, arg2 at GET_RESULT */
103 static const struct eurus_cmd_arg_info cmd_info
[GELIC_EURUS_CMD_MAX_INDEX
] = {
104 [GELIC_EURUS_CMD_SET_COMMON_CFG
] = { .pre_arg
= 1},
105 [GELIC_EURUS_CMD_SET_WEP_CFG
] = { .pre_arg
= 1},
106 [GELIC_EURUS_CMD_SET_WPA_CFG
] = { .pre_arg
= 1},
107 [GELIC_EURUS_CMD_GET_COMMON_CFG
] = { .post_arg
= 1},
108 [GELIC_EURUS_CMD_GET_WEP_CFG
] = { .post_arg
= 1},
109 [GELIC_EURUS_CMD_GET_WPA_CFG
] = { .post_arg
= 1},
110 [GELIC_EURUS_CMD_GET_RSSI_CFG
] = { .post_arg
= 1},
111 [GELIC_EURUS_CMD_START_SCAN
] = { .pre_arg
= 1},
112 [GELIC_EURUS_CMD_GET_SCAN
] = { .post_arg
= 1},
116 static const char *cmdstr(enum gelic_eurus_command ix
)
119 case GELIC_EURUS_CMD_ASSOC
:
121 case GELIC_EURUS_CMD_DISASSOC
:
123 case GELIC_EURUS_CMD_START_SCAN
:
125 case GELIC_EURUS_CMD_GET_SCAN
:
127 case GELIC_EURUS_CMD_SET_COMMON_CFG
:
128 return "SET_COMMON_CFG";
129 case GELIC_EURUS_CMD_GET_COMMON_CFG
:
130 return "GET_COMMON_CFG";
131 case GELIC_EURUS_CMD_SET_WEP_CFG
:
132 return "SET_WEP_CFG";
133 case GELIC_EURUS_CMD_GET_WEP_CFG
:
134 return "GET_WEP_CFG";
135 case GELIC_EURUS_CMD_SET_WPA_CFG
:
136 return "SET_WPA_CFG";
137 case GELIC_EURUS_CMD_GET_WPA_CFG
:
138 return "GET_WPA_CFG";
139 case GELIC_EURUS_CMD_GET_RSSI_CFG
:
147 static inline const char *cmdstr(enum gelic_eurus_command ix
)
153 /* synchronously do eurus commands */
154 static void gelic_eurus_sync_cmd_worker(struct work_struct
*work
)
156 struct gelic_eurus_cmd
*cmd
;
157 struct gelic_card
*card
;
158 struct gelic_wl_info
*wl
;
162 pr_debug("%s: <-\n", __func__
);
163 cmd
= container_of(work
, struct gelic_eurus_cmd
, work
);
164 BUG_ON(cmd_info
[cmd
->cmd
].pre_arg
&&
165 cmd_info
[cmd
->cmd
].post_arg
);
167 card
= port_to_card(wl_port(wl
));
169 if (cmd_info
[cmd
->cmd
].pre_arg
) {
170 arg1
= (cmd
->buffer
) ?
171 ps3_mm_phys_to_lpar(__pa(cmd
->buffer
)) :
173 arg2
= cmd
->buf_size
;
178 init_completion(&wl
->cmd_done_intr
);
179 pr_debug("%s: cmd='%s' start\n", __func__
, cmdstr(cmd
->cmd
));
180 cmd
->status
= lv1_net_control(bus_id(card
), dev_id(card
),
181 GELIC_LV1_POST_WLAN_CMD
,
182 cmd
->cmd
, arg1
, arg2
,
183 &cmd
->tag
, &cmd
->size
);
185 complete(&cmd
->done
);
186 pr_info("%s: cmd issue failed\n", __func__
);
190 wait_for_completion(&wl
->cmd_done_intr
);
192 if (cmd_info
[cmd
->cmd
].post_arg
) {
193 arg1
= ps3_mm_phys_to_lpar(__pa(cmd
->buffer
));
194 arg2
= cmd
->buf_size
;
200 cmd
->status
= lv1_net_control(bus_id(card
), dev_id(card
),
201 GELIC_LV1_GET_WLAN_CMD_RESULT
,
202 cmd
->tag
, arg1
, arg2
,
203 &cmd
->cmd_status
, &cmd
->size
);
205 if (cmd
->status
|| cmd
->cmd_status
) {
206 pr_debug("%s: cmd done tag=%#lx arg1=%#lx, arg2=%#lx\n", __func__
,
207 cmd
->tag
, arg1
, arg2
);
208 pr_debug("%s: cmd done status=%#x cmd_status=%#lx size=%#lx\n",
209 __func__
, cmd
->status
, cmd
->cmd_status
, cmd
->size
);
212 complete(&cmd
->done
);
213 pr_debug("%s: cmd='%s' done\n", __func__
, cmdstr(cmd
->cmd
));
216 static struct gelic_eurus_cmd
*gelic_eurus_sync_cmd(struct gelic_wl_info
*wl
,
217 unsigned int eurus_cmd
,
219 unsigned int buf_size
)
221 struct gelic_eurus_cmd
*cmd
;
224 cmd
= kzalloc(sizeof(*cmd
), GFP_KERNEL
);
228 /* initialize members */
229 cmd
->cmd
= eurus_cmd
;
230 cmd
->buffer
= buffer
;
231 cmd
->buf_size
= buf_size
;
233 INIT_WORK(&cmd
->work
, gelic_eurus_sync_cmd_worker
);
234 init_completion(&cmd
->done
);
235 queue_work(wl
->eurus_cmd_queue
, &cmd
->work
);
237 /* wait for command completion */
238 wait_for_completion(&cmd
->done
);
243 static u32
gelic_wl_get_link(struct net_device
*netdev
)
245 struct gelic_wl_info
*wl
= port_wl(netdev_port(netdev
));
248 pr_debug("%s: <-\n", __func__
);
249 mutex_lock(&wl
->assoc_stat_lock
);
250 if (wl
->assoc_stat
== GELIC_WL_ASSOC_STAT_ASSOCIATED
)
254 mutex_unlock(&wl
->assoc_stat_lock
);
255 pr_debug("%s: ->\n", __func__
);
259 static void gelic_wl_send_iwap_event(struct gelic_wl_info
*wl
, u8
*bssid
)
261 union iwreq_data data
;
263 memset(&data
, 0, sizeof(data
));
265 memcpy(data
.ap_addr
.sa_data
, bssid
, ETH_ALEN
);
266 data
.ap_addr
.sa_family
= ARPHRD_ETHER
;
267 wireless_send_event(port_to_netdev(wl_port(wl
)), SIOCGIWAP
,
272 * wireless extension handlers and helpers
276 static int gelic_wl_get_name(struct net_device
*dev
,
277 struct iw_request_info
*info
,
278 union iwreq_data
*iwreq
, char *extra
)
280 strcpy(iwreq
->name
, "IEEE 802.11bg");
284 static void gelic_wl_get_ch_info(struct gelic_wl_info
*wl
)
286 struct gelic_card
*card
= port_to_card(wl_port(wl
));
287 u64 ch_info_raw
, tmp
;
290 if (!test_and_set_bit(GELIC_WL_STAT_CH_INFO
, &wl
->stat
)) {
291 status
= lv1_net_control(bus_id(card
), dev_id(card
),
292 GELIC_LV1_GET_CHANNEL
, 0, 0, 0,
295 /* some fw versions may return error */
297 if (status
!= LV1_NO_ENTRY
)
298 pr_info("%s: available ch unknown\n", __func__
);
299 wl
->ch_info
= 0x07ff;/* 11 ch */
301 /* 16 bits of MSB has available channels */
302 wl
->ch_info
= ch_info_raw
>> 48;
307 static int gelic_wl_get_range(struct net_device
*netdev
,
308 struct iw_request_info
*info
,
309 union iwreq_data
*iwreq
, char *extra
)
311 struct iw_point
*point
= &iwreq
->data
;
312 struct iw_range
*range
= (struct iw_range
*)extra
;
313 struct gelic_wl_info
*wl
= port_wl(netdev_port(netdev
));
316 pr_debug("%s: <-\n", __func__
);
317 point
->length
= sizeof(struct iw_range
);
318 memset(range
, 0, sizeof(struct iw_range
));
320 range
->we_version_compiled
= WIRELESS_EXT
;
321 range
->we_version_source
= 22;
323 /* available channels and frequencies */
324 gelic_wl_get_ch_info(wl
);
327 i
< NUM_CHANNELS
&& chs
< IW_MAX_FREQUENCIES
; i
++)
328 if (wl
->ch_info
& (1 << i
)) {
329 range
->freq
[chs
].i
= i
+ 1;
330 range
->freq
[chs
].m
= channel_freq
[i
];
331 range
->freq
[chs
].e
= 6;
334 range
->num_frequency
= chs
;
335 range
->old_num_frequency
= chs
;
336 range
->num_channels
= chs
;
337 range
->old_num_channels
= chs
;
340 for (i
= 0; i
< NUM_BITRATES
; i
++)
341 range
->bitrate
[i
] = bitrate_list
[i
];
342 range
->num_bitrates
= i
;
345 range
->max_qual
.qual
= 100; /* relative value */
346 range
->max_qual
.level
= 100;
347 range
->avg_qual
.qual
= 50;
348 range
->avg_qual
.level
= 50;
349 range
->sensitivity
= 0;
351 /* Event capability */
352 IW_EVENT_CAPA_SET_KERNEL(range
->event_capa
);
353 IW_EVENT_CAPA_SET(range
->event_capa
, SIOCGIWAP
);
354 IW_EVENT_CAPA_SET(range
->event_capa
, SIOCGIWSCAN
);
356 /* encryption capability */
357 range
->enc_capa
= IW_ENC_CAPA_WPA
|
358 IW_ENC_CAPA_CIPHER_TKIP
| IW_ENC_CAPA_CIPHER_CCMP
|
359 IW_ENC_CAPA_4WAY_HANDSHAKE
;
361 range
->enc_capa
|= IW_ENC_CAPA_WPA2
;
362 range
->encoding_size
[0] = 5; /* 40bit WEP */
363 range
->encoding_size
[1] = 13; /* 104bit WEP */
364 range
->encoding_size
[2] = 32; /* WPA-PSK */
365 range
->num_encoding_sizes
= 3;
366 range
->max_encoding_tokens
= GELIC_WEP_KEYS
;
368 /* scan capability */
369 range
->scan_capa
= IW_SCAN_CAPA_ESSID
;
371 pr_debug("%s: ->\n", __func__
);
376 /* SIOC{G,S}IWSCAN */
377 static int gelic_wl_set_scan(struct net_device
*netdev
,
378 struct iw_request_info
*info
,
379 union iwreq_data
*wrqu
, char *extra
)
381 struct gelic_wl_info
*wl
= port_wl(netdev_priv(netdev
));
382 struct iw_scan_req
*req
;
384 size_t essid_len
= 0;
386 if (wrqu
->data
.length
== sizeof(struct iw_scan_req
) &&
387 wrqu
->data
.flags
& IW_SCAN_THIS_ESSID
) {
388 req
= (struct iw_scan_req
*)extra
;
390 essid_len
= req
->essid_len
;
391 pr_debug("%s: ESSID scan =%s\n", __func__
, essid
);
393 return gelic_wl_start_scan(wl
, 1, essid
, essid_len
);
397 static const u8 rsn_oui
[OUI_LEN
] = { 0x00, 0x0f, 0xac };
398 static const u8 wpa_oui
[OUI_LEN
] = { 0x00, 0x50, 0xf2 };
401 * synthesize WPA/RSN IE data
402 * See WiFi WPA specification and IEEE 802.11-2007 7.3.2.25
405 static size_t gelic_wl_synthesize_ie(u8
*buf
,
406 struct gelic_eurus_scan_info
*scan
)
409 const u8
*oui_header
;
414 pr_debug("%s: <- sec=%16x\n", __func__
, scan
->security
);
415 switch (be16_to_cpu(scan
->security
) & GELIC_EURUS_SCAN_SEC_MASK
) {
416 case GELIC_EURUS_SCAN_SEC_WPA
:
419 case GELIC_EURUS_SCAN_SEC_WPA2
:
423 /* WEP or none. No IE returned */
427 switch (be16_to_cpu(scan
->security
) & GELIC_EURUS_SCAN_SEC_WPA_MASK
) {
428 case GELIC_EURUS_SCAN_SEC_WPA_TKIP
:
431 case GELIC_EURUS_SCAN_SEC_WPA_AES
:
437 pr_info("%s: no cipher info. defaulted to CCMP\n",
441 pr_info("%s: no cipher info. defaulted to TKIP\n",
447 oui_header
= rsn_oui
;
449 oui_header
= wpa_oui
;
453 *buf
++ = WLAN_EID_RSN
;
455 *buf
++ = WLAN_EID_GENERIC
;
457 /* length filed; set later */
460 /* wpa special header */
462 memcpy(buf
, wpa_oui
, OUI_LEN
);
468 *buf
++ = 0x01; /* version 1.0 */
472 memcpy(buf
, oui_header
, OUI_LEN
);
476 *buf
++ = 0x04; /* CCMP */
478 *buf
++ = 0x02; /* TKIP */
480 /* pairwise key count always 1 */
484 /* pairwise key suit */
485 memcpy(buf
, oui_header
, OUI_LEN
);
488 *buf
++ = 0x04; /* CCMP */
490 *buf
++ = 0x02; /* TKIP */
496 /* AKM suite is assumed as PSK*/
497 memcpy(buf
, oui_header
, OUI_LEN
);
499 *buf
++ = 0x02; /* PSK */
501 /* RSN capabilities is 0 */
505 /* set length field */
506 start
[1] = (buf
- start
- 2);
508 pr_debug("%s: ->\n", __func__
);
522 static void gelic_wl_parse_ie(u8
*data
, size_t len
,
523 struct ie_info
*ie_info
)
525 size_t data_left
= len
;
530 pr_debug("%s: data=%p len=%ld\n", __func__
,
532 memset(ie_info
, 0, sizeof(struct ie_info
));
534 while (2 <= data_left
) {
539 if (data_left
< item_len
)
543 case WLAN_EID_GENERIC
:
544 if ((OUI_LEN
+ 1 <= item_len
) &&
545 !memcmp(pos
, wpa_oui
, OUI_LEN
) &&
546 pos
[OUI_LEN
] == 0x01) {
547 ie_info
->wpa
.data
= pos
- 2;
548 ie_info
->wpa
.len
= item_len
+ 2;
552 ie_info
->rsn
.data
= pos
- 2;
553 /* length includes the header */
554 ie_info
->rsn
.len
= item_len
+ 2;
557 pr_debug("%s: ignore %#x,%d\n", __func__
,
562 data_left
-= item_len
;
564 pr_debug("%s: wpa=%p,%d wpa2=%p,%d\n", __func__
,
565 ie_info
->wpa
.data
, ie_info
->wpa
.len
,
566 ie_info
->rsn
.data
, ie_info
->rsn
.len
);
571 * translate the scan informations from hypervisor to a
574 static char *gelic_wl_translate_scan(struct net_device
*netdev
,
575 struct iw_request_info
*info
,
578 struct gelic_wl_scan_info
*network
)
581 struct gelic_eurus_scan_info
*scan
= network
->hwinfo
;
584 unsigned int i
, j
, len
;
585 u8 buf
[64]; /* arbitrary size large enough */
587 pr_debug("%s: <-\n", __func__
);
589 /* first entry should be AP's mac address */
591 iwe
.u
.ap_addr
.sa_family
= ARPHRD_ETHER
;
592 memcpy(iwe
.u
.ap_addr
.sa_data
, &scan
->bssid
[2], ETH_ALEN
);
593 ev
= iwe_stream_add_event(info
, ev
, stop
, &iwe
, IW_EV_ADDR_LEN
);
596 iwe
.cmd
= SIOCGIWESSID
;
597 iwe
.u
.data
.flags
= 1;
598 iwe
.u
.data
.length
= strnlen(scan
->essid
, 32);
599 ev
= iwe_stream_add_point(info
, ev
, stop
, &iwe
, scan
->essid
);
602 iwe
.cmd
= SIOCGIWFREQ
;
603 iwe
.u
.freq
.m
= be16_to_cpu(scan
->channel
);
604 iwe
.u
.freq
.e
= 0; /* table value in MHz */
606 ev
= iwe_stream_add_event(info
, ev
, stop
, &iwe
, IW_EV_FREQ_LEN
);
609 iwe
.cmd
= SIOCGIWRATE
;
610 iwe
.u
.bitrate
.fixed
= iwe
.u
.bitrate
.disabled
= 0;
611 /* to stuff multiple values in one event */
612 tmp
= ev
+ iwe_stream_lcp_len(info
);
613 /* put them in ascendant order (older is first) */
616 pr_debug("%s: rates=%d rate=%d\n", __func__
,
617 network
->rate_len
, network
->rate_ext_len
);
618 while (i
< network
->rate_len
) {
619 if (j
< network
->rate_ext_len
&&
620 ((scan
->ext_rate
[j
] & 0x7f) < (scan
->rate
[i
] & 0x7f)))
621 rate
= scan
->ext_rate
[j
++] & 0x7f;
623 rate
= scan
->rate
[i
++] & 0x7f;
624 iwe
.u
.bitrate
.value
= rate
* 500000; /* 500kbps unit */
625 tmp
= iwe_stream_add_value(info
, ev
, tmp
, stop
, &iwe
,
628 while (j
< network
->rate_ext_len
) {
629 iwe
.u
.bitrate
.value
= (scan
->ext_rate
[j
++] & 0x7f) * 500000;
630 tmp
= iwe_stream_add_value(info
, ev
, tmp
, stop
, &iwe
,
633 /* Check if we added any rate */
634 if (iwe_stream_lcp_len(info
) < (tmp
- ev
))
638 iwe
.cmd
= SIOCGIWENCODE
;
639 if (be16_to_cpu(scan
->capability
) & WLAN_CAPABILITY_PRIVACY
)
640 iwe
.u
.data
.flags
= IW_ENCODE_ENABLED
| IW_ENCODE_NOKEY
;
642 iwe
.u
.data
.flags
= IW_ENCODE_DISABLED
;
643 iwe
.u
.data
.length
= 0;
644 ev
= iwe_stream_add_point(info
, ev
, stop
, &iwe
, scan
->essid
);
647 iwe
.cmd
= SIOCGIWMODE
;
648 if (be16_to_cpu(scan
->capability
) &
649 (WLAN_CAPABILITY_ESS
| WLAN_CAPABILITY_IBSS
)) {
650 if (be16_to_cpu(scan
->capability
) & WLAN_CAPABILITY_ESS
)
651 iwe
.u
.mode
= IW_MODE_MASTER
;
653 iwe
.u
.mode
= IW_MODE_ADHOC
;
654 ev
= iwe_stream_add_event(info
, ev
, stop
, &iwe
, IW_EV_UINT_LEN
);
659 iwe
.u
.qual
.updated
= IW_QUAL_ALL_UPDATED
|
660 IW_QUAL_QUAL_INVALID
| IW_QUAL_NOISE_INVALID
;
661 iwe
.u
.qual
.level
= be16_to_cpu(scan
->rssi
);
662 iwe
.u
.qual
.qual
= be16_to_cpu(scan
->rssi
);
663 iwe
.u
.qual
.noise
= 0;
664 ev
= iwe_stream_add_event(info
, ev
, stop
, &iwe
, IW_EV_QUAL_LEN
);
667 memset(&iwe
, 0, sizeof(iwe
));
668 if (be16_to_cpu(scan
->size
) <= sizeof(*scan
)) {
669 /* If wpa[2] capable station, synthesize IE and put it */
670 len
= gelic_wl_synthesize_ie(buf
, scan
);
673 iwe
.u
.data
.length
= len
;
674 ev
= iwe_stream_add_point(info
, ev
, stop
, &iwe
, buf
);
677 /* this scan info has IE data */
678 struct ie_info ie_info
;
681 data_len
= be16_to_cpu(scan
->size
) - sizeof(*scan
);
683 gelic_wl_parse_ie(scan
->elements
, data_len
, &ie_info
);
685 if (ie_info
.wpa
.len
&& (ie_info
.wpa
.len
<= sizeof(buf
))) {
686 memcpy(buf
, ie_info
.wpa
.data
, ie_info
.wpa
.len
);
688 iwe
.u
.data
.length
= ie_info
.wpa
.len
;
689 ev
= iwe_stream_add_point(info
, ev
, stop
, &iwe
, buf
);
692 if (ie_info
.rsn
.len
&& (ie_info
.rsn
.len
<= sizeof(buf
))) {
693 memset(&iwe
, 0, sizeof(iwe
));
694 memcpy(buf
, ie_info
.rsn
.data
, ie_info
.rsn
.len
);
696 iwe
.u
.data
.length
= ie_info
.rsn
.len
;
697 ev
= iwe_stream_add_point(info
, ev
, stop
, &iwe
, buf
);
701 pr_debug("%s: ->\n", __func__
);
706 static int gelic_wl_get_scan(struct net_device
*netdev
,
707 struct iw_request_info
*info
,
708 union iwreq_data
*wrqu
, char *extra
)
710 struct gelic_wl_info
*wl
= port_wl(netdev_priv(netdev
));
711 struct gelic_wl_scan_info
*scan_info
;
713 char *stop
= ev
+ wrqu
->data
.length
;
715 unsigned long this_time
= jiffies
;
717 pr_debug("%s: <-\n", __func__
);
718 if (mutex_lock_interruptible(&wl
->scan_lock
))
721 switch (wl
->scan_stat
) {
722 case GELIC_WL_SCAN_STAT_SCANNING
:
723 /* If a scan in progress, caller should call me again */
728 case GELIC_WL_SCAN_STAT_INIT
:
729 /* last scan request failed or never issued */
733 case GELIC_WL_SCAN_STAT_GOT_LIST
:
734 /* ok, use current list */
738 list_for_each_entry(scan_info
, &wl
->network_list
, list
) {
739 if (wl
->scan_age
== 0 ||
740 time_after(scan_info
->last_scanned
+ wl
->scan_age
,
742 ev
= gelic_wl_translate_scan(netdev
, info
,
746 pr_debug("%s:entry too old\n", __func__
);
748 if (stop
- ev
<= IW_EV_ADDR_LEN
) {
754 wrqu
->data
.length
= ev
- extra
;
755 wrqu
->data
.flags
= 0;
757 mutex_unlock(&wl
->scan_lock
);
758 pr_debug("%s: -> %d %d\n", __func__
, ret
, wrqu
->data
.length
);
763 static void scan_list_dump(struct gelic_wl_info
*wl
)
765 struct gelic_wl_scan_info
*scan_info
;
769 list_for_each_entry(scan_info
, &wl
->network_list
, list
) {
770 pr_debug("%s: item %d\n", __func__
, i
++);
771 pr_debug("valid=%d eurusindex=%d last=%lx\n",
772 scan_info
->valid
, scan_info
->eurus_index
,
773 scan_info
->last_scanned
);
774 pr_debug("r_len=%d r_ext_len=%d essid_len=%d\n",
775 scan_info
->rate_len
, scan_info
->rate_ext_len
,
776 scan_info
->essid_len
);
778 pr_debug("bssid=%pM\n", &scan_info
->hwinfo
->bssid
[2]);
779 pr_debug("essid=%s\n", scan_info
->hwinfo
->essid
);
784 static int gelic_wl_set_auth(struct net_device
*netdev
,
785 struct iw_request_info
*info
,
786 union iwreq_data
*data
, char *extra
)
788 struct iw_param
*param
= &data
->param
;
789 struct gelic_wl_info
*wl
= port_wl(netdev_port(netdev
));
790 unsigned long irqflag
;
793 pr_debug("%s: <- %d\n", __func__
, param
->flags
& IW_AUTH_INDEX
);
794 spin_lock_irqsave(&wl
->lock
, irqflag
);
795 switch (param
->flags
& IW_AUTH_INDEX
) {
796 case IW_AUTH_WPA_VERSION
:
797 if (param
->value
& IW_AUTH_WPA_VERSION_DISABLED
) {
798 pr_debug("%s: NO WPA selected\n", __func__
);
799 wl
->wpa_level
= GELIC_WL_WPA_LEVEL_NONE
;
800 wl
->group_cipher_method
= GELIC_WL_CIPHER_WEP
;
801 wl
->pairwise_cipher_method
= GELIC_WL_CIPHER_WEP
;
803 if (param
->value
& IW_AUTH_WPA_VERSION_WPA
) {
804 pr_debug("%s: WPA version 1 selected\n", __func__
);
805 wl
->wpa_level
= GELIC_WL_WPA_LEVEL_WPA
;
806 wl
->group_cipher_method
= GELIC_WL_CIPHER_TKIP
;
807 wl
->pairwise_cipher_method
= GELIC_WL_CIPHER_TKIP
;
808 wl
->auth_method
= GELIC_EURUS_AUTH_OPEN
;
810 if (param
->value
& IW_AUTH_WPA_VERSION_WPA2
) {
812 * As the hypervisor may not tell the cipher
813 * information of the AP if it is WPA2,
814 * you will not decide suitable cipher from
816 * You should have knowledge about the AP's
817 * cipher information in other method prior to
821 pr_info("%s: WPA2 may not work\n", __func__
);
822 if (wpa2_capable()) {
823 wl
->wpa_level
= GELIC_WL_WPA_LEVEL_WPA2
;
824 wl
->group_cipher_method
= GELIC_WL_CIPHER_AES
;
825 wl
->pairwise_cipher_method
=
827 wl
->auth_method
= GELIC_EURUS_AUTH_OPEN
;
833 case IW_AUTH_CIPHER_PAIRWISE
:
835 (IW_AUTH_CIPHER_WEP104
| IW_AUTH_CIPHER_WEP40
)) {
836 pr_debug("%s: WEP selected\n", __func__
);
837 wl
->pairwise_cipher_method
= GELIC_WL_CIPHER_WEP
;
839 if (param
->value
& IW_AUTH_CIPHER_TKIP
) {
840 pr_debug("%s: TKIP selected\n", __func__
);
841 wl
->pairwise_cipher_method
= GELIC_WL_CIPHER_TKIP
;
843 if (param
->value
& IW_AUTH_CIPHER_CCMP
) {
844 pr_debug("%s: CCMP selected\n", __func__
);
845 wl
->pairwise_cipher_method
= GELIC_WL_CIPHER_AES
;
847 if (param
->value
& IW_AUTH_CIPHER_NONE
) {
848 pr_debug("%s: no auth selected\n", __func__
);
849 wl
->pairwise_cipher_method
= GELIC_WL_CIPHER_NONE
;
852 case IW_AUTH_CIPHER_GROUP
:
854 (IW_AUTH_CIPHER_WEP104
| IW_AUTH_CIPHER_WEP40
)) {
855 pr_debug("%s: WEP selected\n", __func__
);
856 wl
->group_cipher_method
= GELIC_WL_CIPHER_WEP
;
858 if (param
->value
& IW_AUTH_CIPHER_TKIP
) {
859 pr_debug("%s: TKIP selected\n", __func__
);
860 wl
->group_cipher_method
= GELIC_WL_CIPHER_TKIP
;
862 if (param
->value
& IW_AUTH_CIPHER_CCMP
) {
863 pr_debug("%s: CCMP selected\n", __func__
);
864 wl
->group_cipher_method
= GELIC_WL_CIPHER_AES
;
866 if (param
->value
& IW_AUTH_CIPHER_NONE
) {
867 pr_debug("%s: no auth selected\n", __func__
);
868 wl
->group_cipher_method
= GELIC_WL_CIPHER_NONE
;
871 case IW_AUTH_80211_AUTH_ALG
:
872 if (param
->value
& IW_AUTH_ALG_SHARED_KEY
) {
873 pr_debug("%s: shared key specified\n", __func__
);
874 wl
->auth_method
= GELIC_EURUS_AUTH_SHARED
;
875 } else if (param
->value
& IW_AUTH_ALG_OPEN_SYSTEM
) {
876 pr_debug("%s: open system specified\n", __func__
);
877 wl
->auth_method
= GELIC_EURUS_AUTH_OPEN
;
882 case IW_AUTH_WPA_ENABLED
:
884 pr_debug("%s: WPA enabled\n", __func__
);
885 wl
->wpa_level
= GELIC_WL_WPA_LEVEL_WPA
;
887 pr_debug("%s: WPA disabled\n", __func__
);
888 wl
->wpa_level
= GELIC_WL_WPA_LEVEL_NONE
;
892 case IW_AUTH_KEY_MGMT
:
893 if (param
->value
& IW_AUTH_KEY_MGMT_PSK
)
895 /* intentionally fall through */
902 set_bit(GELIC_WL_STAT_CONFIGURED
, &wl
->stat
);
904 spin_unlock_irqrestore(&wl
->lock
, irqflag
);
905 pr_debug("%s: -> %d\n", __func__
, ret
);
909 static int gelic_wl_get_auth(struct net_device
*netdev
,
910 struct iw_request_info
*info
,
911 union iwreq_data
*iwreq
, char *extra
)
913 struct iw_param
*param
= &iwreq
->param
;
914 struct gelic_wl_info
*wl
= port_wl(netdev_port(netdev
));
915 unsigned long irqflag
;
918 pr_debug("%s: <- %d\n", __func__
, param
->flags
& IW_AUTH_INDEX
);
919 spin_lock_irqsave(&wl
->lock
, irqflag
);
920 switch (param
->flags
& IW_AUTH_INDEX
) {
921 case IW_AUTH_WPA_VERSION
:
922 switch (wl
->wpa_level
) {
923 case GELIC_WL_WPA_LEVEL_WPA
:
924 param
->value
|= IW_AUTH_WPA_VERSION_WPA
;
926 case GELIC_WL_WPA_LEVEL_WPA2
:
927 param
->value
|= IW_AUTH_WPA_VERSION_WPA2
;
930 param
->value
|= IW_AUTH_WPA_VERSION_DISABLED
;
934 case IW_AUTH_80211_AUTH_ALG
:
935 if (wl
->auth_method
== GELIC_EURUS_AUTH_SHARED
)
936 param
->value
= IW_AUTH_ALG_SHARED_KEY
;
937 else if (wl
->auth_method
== GELIC_EURUS_AUTH_OPEN
)
938 param
->value
= IW_AUTH_ALG_OPEN_SYSTEM
;
941 case IW_AUTH_WPA_ENABLED
:
942 switch (wl
->wpa_level
) {
943 case GELIC_WL_WPA_LEVEL_WPA
:
944 case GELIC_WL_WPA_LEVEL_WPA2
:
956 spin_unlock_irqrestore(&wl
->lock
, irqflag
);
957 pr_debug("%s: -> %d\n", __func__
, ret
);
961 /* SIOC{S,G}IWESSID */
962 static int gelic_wl_set_essid(struct net_device
*netdev
,
963 struct iw_request_info
*info
,
964 union iwreq_data
*data
, char *extra
)
966 struct gelic_wl_info
*wl
= port_wl(netdev_priv(netdev
));
967 unsigned long irqflag
;
969 pr_debug("%s: <- l=%d f=%d\n", __func__
,
970 data
->essid
.length
, data
->essid
.flags
);
971 if (IW_ESSID_MAX_SIZE
< data
->essid
.length
)
974 spin_lock_irqsave(&wl
->lock
, irqflag
);
975 if (data
->essid
.flags
) {
976 wl
->essid_len
= data
->essid
.length
;
977 memcpy(wl
->essid
, extra
, wl
->essid_len
);
978 pr_debug("%s: essid = '%s'\n", __func__
, extra
);
979 set_bit(GELIC_WL_STAT_ESSID_SET
, &wl
->stat
);
981 pr_debug("%s: ESSID any\n", __func__
);
982 clear_bit(GELIC_WL_STAT_ESSID_SET
, &wl
->stat
);
984 set_bit(GELIC_WL_STAT_CONFIGURED
, &wl
->stat
);
985 spin_unlock_irqrestore(&wl
->lock
, irqflag
);
988 gelic_wl_try_associate(netdev
); /* FIXME */
989 pr_debug("%s: ->\n", __func__
);
993 static int gelic_wl_get_essid(struct net_device
*netdev
,
994 struct iw_request_info
*info
,
995 union iwreq_data
*data
, char *extra
)
997 struct gelic_wl_info
*wl
= port_wl(netdev_priv(netdev
));
998 unsigned long irqflag
;
1000 pr_debug("%s: <-\n", __func__
);
1001 mutex_lock(&wl
->assoc_stat_lock
);
1002 spin_lock_irqsave(&wl
->lock
, irqflag
);
1003 if (test_bit(GELIC_WL_STAT_ESSID_SET
, &wl
->stat
) ||
1004 wl
->assoc_stat
== GELIC_WL_ASSOC_STAT_ASSOCIATED
) {
1005 memcpy(extra
, wl
->essid
, wl
->essid_len
);
1006 data
->essid
.length
= wl
->essid_len
;
1007 data
->essid
.flags
= 1;
1009 data
->essid
.flags
= 0;
1011 mutex_unlock(&wl
->assoc_stat_lock
);
1012 spin_unlock_irqrestore(&wl
->lock
, irqflag
);
1013 pr_debug("%s: -> len=%d\n", __func__
, data
->essid
.length
);
1018 /* SIO{S,G}IWENCODE */
1019 static int gelic_wl_set_encode(struct net_device
*netdev
,
1020 struct iw_request_info
*info
,
1021 union iwreq_data
*data
, char *extra
)
1023 struct gelic_wl_info
*wl
= port_wl(netdev_priv(netdev
));
1024 struct iw_point
*enc
= &data
->encoding
;
1026 unsigned long irqflag
;
1027 int key_index
, index_specified
;
1030 pr_debug("%s: <-\n", __func__
);
1031 flags
= enc
->flags
& IW_ENCODE_FLAGS
;
1032 key_index
= enc
->flags
& IW_ENCODE_INDEX
;
1034 pr_debug("%s: key_index = %d\n", __func__
, key_index
);
1035 pr_debug("%s: key_len = %d\n", __func__
, enc
->length
);
1036 pr_debug("%s: flag=%x\n", __func__
, enc
->flags
& IW_ENCODE_FLAGS
);
1038 if (GELIC_WEP_KEYS
< key_index
)
1041 spin_lock_irqsave(&wl
->lock
, irqflag
);
1043 index_specified
= 1;
1046 index_specified
= 0;
1047 key_index
= wl
->current_key
;
1050 if (flags
& IW_ENCODE_NOKEY
) {
1051 /* if just IW_ENCODE_NOKEY, change current key index */
1052 if (!flags
&& index_specified
) {
1053 wl
->current_key
= key_index
;
1057 if (flags
& IW_ENCODE_DISABLED
) {
1058 if (!index_specified
) {
1059 /* disable encryption */
1060 wl
->group_cipher_method
= GELIC_WL_CIPHER_NONE
;
1061 wl
->pairwise_cipher_method
=
1062 GELIC_WL_CIPHER_NONE
;
1063 /* invalidate all key */
1064 wl
->key_enabled
= 0;
1066 clear_bit(key_index
, &wl
->key_enabled
);
1069 if (flags
& IW_ENCODE_OPEN
)
1070 wl
->auth_method
= GELIC_EURUS_AUTH_OPEN
;
1071 if (flags
& IW_ENCODE_RESTRICTED
) {
1072 pr_info("%s: shared key mode enabled\n", __func__
);
1073 wl
->auth_method
= GELIC_EURUS_AUTH_SHARED
;
1076 if (IW_ENCODING_TOKEN_MAX
< enc
->length
) {
1080 wl
->key_len
[key_index
] = enc
->length
;
1081 memcpy(wl
->key
[key_index
], extra
, enc
->length
);
1082 set_bit(key_index
, &wl
->key_enabled
);
1083 wl
->pairwise_cipher_method
= GELIC_WL_CIPHER_WEP
;
1084 wl
->group_cipher_method
= GELIC_WL_CIPHER_WEP
;
1086 set_bit(GELIC_WL_STAT_CONFIGURED
, &wl
->stat
);
1088 spin_unlock_irqrestore(&wl
->lock
, irqflag
);
1089 pr_debug("%s: ->\n", __func__
);
1093 static int gelic_wl_get_encode(struct net_device
*netdev
,
1094 struct iw_request_info
*info
,
1095 union iwreq_data
*data
, char *extra
)
1097 struct gelic_wl_info
*wl
= port_wl(netdev_priv(netdev
));
1098 struct iw_point
*enc
= &data
->encoding
;
1099 unsigned long irqflag
;
1100 unsigned int key_index
, index_specified
;
1103 pr_debug("%s: <-\n", __func__
);
1104 key_index
= enc
->flags
& IW_ENCODE_INDEX
;
1105 pr_debug("%s: flag=%#x point=%p len=%d extra=%p\n", __func__
,
1106 enc
->flags
, enc
->pointer
, enc
->length
, extra
);
1107 if (GELIC_WEP_KEYS
< key_index
)
1110 spin_lock_irqsave(&wl
->lock
, irqflag
);
1112 index_specified
= 1;
1115 index_specified
= 0;
1116 key_index
= wl
->current_key
;
1119 if (wl
->group_cipher_method
== GELIC_WL_CIPHER_WEP
) {
1120 switch (wl
->auth_method
) {
1121 case GELIC_EURUS_AUTH_OPEN
:
1122 enc
->flags
= IW_ENCODE_OPEN
;
1124 case GELIC_EURUS_AUTH_SHARED
:
1125 enc
->flags
= IW_ENCODE_RESTRICTED
;
1129 enc
->flags
= IW_ENCODE_DISABLED
;
1131 if (test_bit(key_index
, &wl
->key_enabled
)) {
1132 if (enc
->length
< wl
->key_len
[key_index
]) {
1136 enc
->length
= wl
->key_len
[key_index
];
1137 memcpy(extra
, wl
->key
[key_index
], wl
->key_len
[key_index
]);
1140 enc
->flags
|= IW_ENCODE_NOKEY
;
1142 enc
->flags
|= key_index
+ 1;
1143 pr_debug("%s: -> flag=%x len=%d\n", __func__
,
1144 enc
->flags
, enc
->length
);
1147 spin_unlock_irqrestore(&wl
->lock
, irqflag
);
1152 static int gelic_wl_set_ap(struct net_device
*netdev
,
1153 struct iw_request_info
*info
,
1154 union iwreq_data
*data
, char *extra
)
1156 struct gelic_wl_info
*wl
= port_wl(netdev_priv(netdev
));
1157 unsigned long irqflag
;
1159 pr_debug("%s: <-\n", __func__
);
1160 if (data
->ap_addr
.sa_family
!= ARPHRD_ETHER
)
1163 spin_lock_irqsave(&wl
->lock
, irqflag
);
1164 if (is_valid_ether_addr(data
->ap_addr
.sa_data
)) {
1165 memcpy(wl
->bssid
, data
->ap_addr
.sa_data
,
1167 set_bit(GELIC_WL_STAT_BSSID_SET
, &wl
->stat
);
1168 set_bit(GELIC_WL_STAT_CONFIGURED
, &wl
->stat
);
1169 pr_debug("%s: bss=%pM\n", __func__
, wl
->bssid
);
1171 pr_debug("%s: clear bssid\n", __func__
);
1172 clear_bit(GELIC_WL_STAT_BSSID_SET
, &wl
->stat
);
1173 memset(wl
->bssid
, 0, ETH_ALEN
);
1175 spin_unlock_irqrestore(&wl
->lock
, irqflag
);
1176 pr_debug("%s: ->\n", __func__
);
1180 static int gelic_wl_get_ap(struct net_device
*netdev
,
1181 struct iw_request_info
*info
,
1182 union iwreq_data
*data
, char *extra
)
1184 struct gelic_wl_info
*wl
= port_wl(netdev_priv(netdev
));
1185 unsigned long irqflag
;
1187 pr_debug("%s: <-\n", __func__
);
1188 mutex_lock(&wl
->assoc_stat_lock
);
1189 spin_lock_irqsave(&wl
->lock
, irqflag
);
1190 if (wl
->assoc_stat
== GELIC_WL_ASSOC_STAT_ASSOCIATED
) {
1191 data
->ap_addr
.sa_family
= ARPHRD_ETHER
;
1192 memcpy(data
->ap_addr
.sa_data
, wl
->active_bssid
,
1195 memset(data
->ap_addr
.sa_data
, 0, ETH_ALEN
);
1197 spin_unlock_irqrestore(&wl
->lock
, irqflag
);
1198 mutex_unlock(&wl
->assoc_stat_lock
);
1199 pr_debug("%s: ->\n", __func__
);
1203 /* SIOC{S,G}IWENCODEEXT */
1204 static int gelic_wl_set_encodeext(struct net_device
*netdev
,
1205 struct iw_request_info
*info
,
1206 union iwreq_data
*data
, char *extra
)
1208 struct gelic_wl_info
*wl
= port_wl(netdev_priv(netdev
));
1209 struct iw_point
*enc
= &data
->encoding
;
1210 struct iw_encode_ext
*ext
= (struct iw_encode_ext
*)extra
;
1213 unsigned long irqflag
;
1217 pr_debug("%s: <-\n", __func__
);
1218 flags
= enc
->flags
& IW_ENCODE_FLAGS
;
1220 key_index
= enc
->flags
& IW_ENCODE_INDEX
;
1222 pr_debug("%s: key_index = %d\n", __func__
, key_index
);
1223 pr_debug("%s: key_len = %d\n", __func__
, enc
->length
);
1224 pr_debug("%s: flag=%x\n", __func__
, enc
->flags
& IW_ENCODE_FLAGS
);
1225 pr_debug("%s: ext_flag=%x\n", __func__
, ext
->ext_flags
);
1226 pr_debug("%s: ext_key_len=%x\n", __func__
, ext
->key_len
);
1228 if (GELIC_WEP_KEYS
< key_index
)
1231 spin_lock_irqsave(&wl
->lock
, irqflag
);
1235 key_index
= wl
->current_key
;
1237 if (!enc
->length
&& (ext
->ext_flags
& IW_ENCODE_EXT_SET_TX_KEY
)) {
1238 /* reques to change default key index */
1239 pr_debug("%s: request to change default key to %d\n",
1240 __func__
, key_index
);
1241 wl
->current_key
= key_index
;
1245 if (alg
== IW_ENCODE_ALG_NONE
|| (flags
& IW_ENCODE_DISABLED
)) {
1246 pr_debug("%s: alg disabled\n", __func__
);
1247 wl
->wpa_level
= GELIC_WL_WPA_LEVEL_NONE
;
1248 wl
->group_cipher_method
= GELIC_WL_CIPHER_NONE
;
1249 wl
->pairwise_cipher_method
= GELIC_WL_CIPHER_NONE
;
1250 wl
->auth_method
= GELIC_EURUS_AUTH_OPEN
; /* should be open */
1251 } else if (alg
== IW_ENCODE_ALG_WEP
) {
1252 pr_debug("%s: WEP requested\n", __func__
);
1253 if (flags
& IW_ENCODE_OPEN
) {
1254 pr_debug("%s: open key mode\n", __func__
);
1255 wl
->auth_method
= GELIC_EURUS_AUTH_OPEN
;
1257 if (flags
& IW_ENCODE_RESTRICTED
) {
1258 pr_debug("%s: shared key mode\n", __func__
);
1259 wl
->auth_method
= GELIC_EURUS_AUTH_SHARED
;
1261 if (IW_ENCODING_TOKEN_MAX
< ext
->key_len
) {
1262 pr_info("%s: key is too long %d\n", __func__
,
1267 /* OK, update the key */
1268 wl
->key_len
[key_index
] = ext
->key_len
;
1269 memset(wl
->key
[key_index
], 0, IW_ENCODING_TOKEN_MAX
);
1270 memcpy(wl
->key
[key_index
], ext
->key
, ext
->key_len
);
1271 set_bit(key_index
, &wl
->key_enabled
);
1272 /* remember wep info changed */
1273 set_bit(GELIC_WL_STAT_CONFIGURED
, &wl
->stat
);
1274 } else if (alg
== IW_ENCODE_ALG_PMK
) {
1275 if (ext
->key_len
!= WPA_PSK_LEN
) {
1276 pr_err("%s: PSK length wrong %d\n", __func__
,
1281 memset(wl
->psk
, 0, sizeof(wl
->psk
));
1282 memcpy(wl
->psk
, ext
->key
, ext
->key_len
);
1283 wl
->psk_len
= ext
->key_len
;
1284 wl
->psk_type
= GELIC_EURUS_WPA_PSK_BIN
;
1285 /* remember PSK configured */
1286 set_bit(GELIC_WL_STAT_WPA_PSK_SET
, &wl
->stat
);
1289 spin_unlock_irqrestore(&wl
->lock
, irqflag
);
1290 pr_debug("%s: ->\n", __func__
);
1294 static int gelic_wl_get_encodeext(struct net_device
*netdev
,
1295 struct iw_request_info
*info
,
1296 union iwreq_data
*data
, char *extra
)
1298 struct gelic_wl_info
*wl
= port_wl(netdev_priv(netdev
));
1299 struct iw_point
*enc
= &data
->encoding
;
1300 struct iw_encode_ext
*ext
= (struct iw_encode_ext
*)extra
;
1301 unsigned long irqflag
;
1306 pr_debug("%s: <-\n", __func__
);
1308 max_key_len
= enc
->length
- sizeof(struct iw_encode_ext
);
1309 if (max_key_len
< 0)
1311 key_index
= enc
->flags
& IW_ENCODE_INDEX
;
1313 pr_debug("%s: key_index = %d\n", __func__
, key_index
);
1314 pr_debug("%s: key_len = %d\n", __func__
, enc
->length
);
1315 pr_debug("%s: flag=%x\n", __func__
, enc
->flags
& IW_ENCODE_FLAGS
);
1317 if (GELIC_WEP_KEYS
< key_index
)
1320 spin_lock_irqsave(&wl
->lock
, irqflag
);
1324 key_index
= wl
->current_key
;
1326 memset(ext
, 0, sizeof(struct iw_encode_ext
));
1327 switch (wl
->group_cipher_method
) {
1328 case GELIC_WL_CIPHER_WEP
:
1329 ext
->alg
= IW_ENCODE_ALG_WEP
;
1330 enc
->flags
|= IW_ENCODE_ENABLED
;
1332 case GELIC_WL_CIPHER_TKIP
:
1333 ext
->alg
= IW_ENCODE_ALG_TKIP
;
1334 enc
->flags
|= IW_ENCODE_ENABLED
;
1336 case GELIC_WL_CIPHER_AES
:
1337 ext
->alg
= IW_ENCODE_ALG_CCMP
;
1338 enc
->flags
|= IW_ENCODE_ENABLED
;
1340 case GELIC_WL_CIPHER_NONE
:
1342 ext
->alg
= IW_ENCODE_ALG_NONE
;
1343 enc
->flags
|= IW_ENCODE_NOKEY
;
1347 if (!(enc
->flags
& IW_ENCODE_NOKEY
)) {
1348 if (max_key_len
< wl
->key_len
[key_index
]) {
1352 if (test_bit(key_index
, &wl
->key_enabled
))
1353 memcpy(ext
->key
, wl
->key
[key_index
],
1354 wl
->key_len
[key_index
]);
1356 pr_debug("%s: disabled key requested ix=%d\n",
1357 __func__
, key_index
);
1360 spin_unlock_irqrestore(&wl
->lock
, irqflag
);
1361 pr_debug("%s: ->\n", __func__
);
1364 /* SIOC{S,G}IWMODE */
1365 static int gelic_wl_set_mode(struct net_device
*netdev
,
1366 struct iw_request_info
*info
,
1367 union iwreq_data
*data
, char *extra
)
1369 __u32 mode
= data
->mode
;
1372 pr_debug("%s: <-\n", __func__
);
1373 if (mode
== IW_MODE_INFRA
)
1377 pr_debug("%s: -> %d\n", __func__
, ret
);
1381 static int gelic_wl_get_mode(struct net_device
*netdev
,
1382 struct iw_request_info
*info
,
1383 union iwreq_data
*data
, char *extra
)
1385 __u32
*mode
= &data
->mode
;
1386 pr_debug("%s: <-\n", __func__
);
1387 *mode
= IW_MODE_INFRA
;
1388 pr_debug("%s: ->\n", __func__
);
1393 static int gelic_wl_get_nick(struct net_device
*net_dev
,
1394 struct iw_request_info
*info
,
1395 union iwreq_data
*data
, char *extra
)
1397 strcpy(extra
, "gelic_wl");
1398 data
->data
.length
= strlen(extra
);
1399 data
->data
.flags
= 1;
1406 static struct iw_statistics
*gelic_wl_get_wireless_stats(
1407 struct net_device
*netdev
)
1410 struct gelic_wl_info
*wl
= port_wl(netdev_priv(netdev
));
1411 struct gelic_eurus_cmd
*cmd
;
1412 struct iw_statistics
*is
;
1413 struct gelic_eurus_rssi_info
*rssi
;
1416 pr_debug("%s: <-\n", __func__
);
1418 buf
= (void *)__get_free_page(GFP_KERNEL
);
1423 memset(is
, 0, sizeof(*is
));
1424 cmd
= gelic_eurus_sync_cmd(wl
, GELIC_EURUS_CMD_GET_RSSI_CFG
,
1425 buf
, sizeof(*rssi
));
1426 if (cmd
&& !cmd
->status
&& !cmd
->cmd_status
) {
1428 is
->qual
.level
= be16_to_cpu(rssi
->rssi
);
1429 is
->qual
.updated
= IW_QUAL_LEVEL_UPDATED
|
1430 IW_QUAL_QUAL_INVALID
| IW_QUAL_NOISE_INVALID
;
1432 /* not associated */
1433 is
->qual
.updated
= IW_QUAL_ALL_INVALID
;
1436 free_page((unsigned long)buf
);
1437 pr_debug("%s: ->\n", __func__
);
1444 static int gelic_wl_start_scan(struct gelic_wl_info
*wl
, int always_scan
,
1445 u8
*essid
, size_t essid_len
)
1447 struct gelic_eurus_cmd
*cmd
;
1452 pr_debug("%s: <- always=%d\n", __func__
, always_scan
);
1453 if (mutex_lock_interruptible(&wl
->scan_lock
))
1454 return -ERESTARTSYS
;
1457 * If already a scan in progress, do not trigger more
1459 if (wl
->scan_stat
== GELIC_WL_SCAN_STAT_SCANNING
) {
1460 pr_debug("%s: scanning now\n", __func__
);
1464 init_completion(&wl
->scan_done
);
1466 * If we have already a bss list, don't try to get new
1467 * unless we are doing an ESSID scan
1469 if ((!essid_len
&& !always_scan
)
1470 && wl
->scan_stat
== GELIC_WL_SCAN_STAT_GOT_LIST
) {
1471 pr_debug("%s: already has the list\n", __func__
);
1472 complete(&wl
->scan_done
);
1477 if (essid_len
&& essid
) {
1478 buf
= (void *)__get_free_page(GFP_KERNEL
);
1483 len
= IW_ESSID_MAX_SIZE
; /* hypervisor always requires 32 */
1484 memset(buf
, 0, len
);
1485 memcpy(buf
, essid
, essid_len
);
1486 pr_debug("%s: essid scan='%s'\n", __func__
, (char *)buf
);
1491 * issue start scan request
1493 wl
->scan_stat
= GELIC_WL_SCAN_STAT_SCANNING
;
1494 cmd
= gelic_eurus_sync_cmd(wl
, GELIC_EURUS_CMD_START_SCAN
,
1496 if (!cmd
|| cmd
->status
|| cmd
->cmd_status
) {
1497 wl
->scan_stat
= GELIC_WL_SCAN_STAT_INIT
;
1498 complete(&wl
->scan_done
);
1504 free_page((unsigned long)buf
);
1505 mutex_unlock(&wl
->scan_lock
);
1506 pr_debug("%s: ->\n", __func__
);
1511 * retrieve scan result from the chip (hypervisor)
1512 * this function is invoked by schedule work.
1514 static void gelic_wl_scan_complete_event(struct gelic_wl_info
*wl
)
1516 struct gelic_eurus_cmd
*cmd
= NULL
;
1517 struct gelic_wl_scan_info
*target
, *tmp
;
1518 struct gelic_wl_scan_info
*oldest
= NULL
;
1519 struct gelic_eurus_scan_info
*scan_info
;
1520 unsigned int scan_info_size
;
1521 union iwreq_data data
;
1522 unsigned long this_time
= jiffies
;
1523 unsigned int data_len
, i
, found
, r
;
1526 pr_debug("%s:start\n", __func__
);
1527 mutex_lock(&wl
->scan_lock
);
1529 buf
= (void *)__get_free_page(GFP_KERNEL
);
1531 pr_info("%s: scan buffer alloc failed\n", __func__
);
1535 if (wl
->scan_stat
!= GELIC_WL_SCAN_STAT_SCANNING
) {
1537 * stop() may be called while scanning, ignore result
1539 pr_debug("%s: scan complete when stat != scanning(%d)\n",
1540 __func__
, wl
->scan_stat
);
1544 cmd
= gelic_eurus_sync_cmd(wl
, GELIC_EURUS_CMD_GET_SCAN
,
1546 if (!cmd
|| cmd
->status
|| cmd
->cmd_status
) {
1547 wl
->scan_stat
= GELIC_WL_SCAN_STAT_INIT
;
1548 pr_info("%s:cmd failed\n", __func__
);
1552 data_len
= cmd
->size
;
1553 pr_debug("%s: data_len = %d\n", __func__
, data_len
);
1556 /* OK, bss list retrieved */
1557 wl
->scan_stat
= GELIC_WL_SCAN_STAT_GOT_LIST
;
1559 /* mark all entries are old */
1560 list_for_each_entry_safe(target
, tmp
, &wl
->network_list
, list
) {
1562 /* expire too old entries */
1563 if (time_before(target
->last_scanned
+ wl
->scan_age
,
1565 kfree(target
->hwinfo
);
1566 target
->hwinfo
= NULL
;
1567 list_move_tail(&target
->list
, &wl
->network_free_list
);
1571 /* put them in the network_list */
1572 for (i
= 0, scan_info_size
= 0, scan_info
= buf
;
1573 scan_info_size
< data_len
;
1574 i
++, scan_info_size
+= be16_to_cpu(scan_info
->size
),
1575 scan_info
= (void *)scan_info
+ be16_to_cpu(scan_info
->size
)) {
1576 pr_debug("%s:size=%d bssid=%pM scan_info=%p\n", __func__
,
1577 be16_to_cpu(scan_info
->size
),
1578 &scan_info
->bssid
[2], scan_info
);
1581 * The wireless firmware may return invalid channel 0 and/or
1582 * invalid rate if the AP emits zero length SSID ie. As this
1583 * scan information is useless, ignore it
1585 if (!be16_to_cpu(scan_info
->channel
) || !scan_info
->rate
[0]) {
1586 pr_debug("%s: invalid scan info\n", __func__
);
1592 list_for_each_entry(target
, &wl
->network_list
, list
) {
1593 if (!compare_ether_addr(&target
->hwinfo
->bssid
[2],
1594 &scan_info
->bssid
[2])) {
1596 pr_debug("%s: same BBS found scanned list\n",
1601 (target
->last_scanned
< oldest
->last_scanned
))
1606 /* not found in the list */
1607 if (list_empty(&wl
->network_free_list
)) {
1611 target
= list_entry(wl
->network_free_list
.next
,
1612 struct gelic_wl_scan_info
,
1617 /* update the item */
1618 target
->last_scanned
= this_time
;
1620 target
->eurus_index
= i
;
1621 kfree(target
->hwinfo
);
1622 target
->hwinfo
= kzalloc(be16_to_cpu(scan_info
->size
),
1624 if (!target
->hwinfo
) {
1625 pr_info("%s: kzalloc failed\n", __func__
);
1628 /* copy hw scan info */
1629 memcpy(target
->hwinfo
, scan_info
, scan_info
->size
);
1630 target
->essid_len
= strnlen(scan_info
->essid
,
1631 sizeof(scan_info
->essid
));
1632 target
->rate_len
= 0;
1633 for (r
= 0; r
< 12; r
++)
1634 if (scan_info
->rate
[r
])
1636 if (8 < target
->rate_len
)
1637 pr_info("%s: AP returns %d rates\n", __func__
,
1639 target
->rate_ext_len
= 0;
1640 for (r
= 0; r
< 16; r
++)
1641 if (scan_info
->ext_rate
[r
])
1642 target
->rate_ext_len
++;
1643 list_move_tail(&target
->list
, &wl
->network_list
);
1645 memset(&data
, 0, sizeof(data
));
1646 wireless_send_event(port_to_netdev(wl_port(wl
)), SIOCGIWSCAN
, &data
,
1649 free_page((unsigned long)buf
);
1650 complete(&wl
->scan_done
);
1651 mutex_unlock(&wl
->scan_lock
);
1652 pr_debug("%s:end\n", __func__
);
1656 * Select an appropriate bss from current scan list regarding
1657 * current settings from userspace.
1658 * The caller must hold wl->scan_lock,
1659 * and on the state of wl->scan_state == GELIC_WL_SCAN_GOT_LIST
1661 static void update_best(struct gelic_wl_scan_info
**best
,
1662 struct gelic_wl_scan_info
*candid
,
1666 if (*best_weight
< ++(*weight
)) {
1667 *best_weight
= *weight
;
1673 struct gelic_wl_scan_info
*gelic_wl_find_best_bss(struct gelic_wl_info
*wl
)
1675 struct gelic_wl_scan_info
*scan_info
;
1676 struct gelic_wl_scan_info
*best_bss
;
1677 int weight
, best_weight
;
1680 pr_debug("%s: <-\n", __func__
);
1685 list_for_each_entry(scan_info
, &wl
->network_list
, list
) {
1686 pr_debug("%s: station %p\n", __func__
, scan_info
);
1688 if (!scan_info
->valid
) {
1689 pr_debug("%s: station invalid\n", __func__
);
1693 /* If bss specified, check it only */
1694 if (test_bit(GELIC_WL_STAT_BSSID_SET
, &wl
->stat
)) {
1695 if (!compare_ether_addr(&scan_info
->hwinfo
->bssid
[2],
1697 best_bss
= scan_info
;
1698 pr_debug("%s: bssid matched\n", __func__
);
1701 pr_debug("%s: bssid unmached\n", __func__
);
1709 security
= be16_to_cpu(scan_info
->hwinfo
->security
) &
1710 GELIC_EURUS_SCAN_SEC_MASK
;
1711 if (wl
->wpa_level
== GELIC_WL_WPA_LEVEL_WPA2
) {
1712 if (security
== GELIC_EURUS_SCAN_SEC_WPA2
)
1713 update_best(&best_bss
, scan_info
,
1714 &best_weight
, &weight
);
1717 } else if (wl
->wpa_level
== GELIC_WL_WPA_LEVEL_WPA
) {
1718 if (security
== GELIC_EURUS_SCAN_SEC_WPA
)
1719 update_best(&best_bss
, scan_info
,
1720 &best_weight
, &weight
);
1723 } else if (wl
->wpa_level
== GELIC_WL_WPA_LEVEL_NONE
&&
1724 wl
->group_cipher_method
== GELIC_WL_CIPHER_WEP
) {
1725 if (security
== GELIC_EURUS_SCAN_SEC_WEP
)
1726 update_best(&best_bss
, scan_info
,
1727 &best_weight
, &weight
);
1732 /* If ESSID is set, check it */
1733 if (test_bit(GELIC_WL_STAT_ESSID_SET
, &wl
->stat
)) {
1734 if ((scan_info
->essid_len
== wl
->essid_len
) &&
1736 scan_info
->hwinfo
->essid
,
1737 scan_info
->essid_len
))
1738 update_best(&best_bss
, scan_info
,
1739 &best_weight
, &weight
);
1746 pr_debug("%s: -> bss=%p\n", __func__
, best_bss
);
1748 pr_debug("%s:addr=%pM\n", __func__
,
1749 &best_bss
->hwinfo
->bssid
[2]);
1756 * Setup WEP configuration to the chip
1757 * The caller must hold wl->scan_lock,
1758 * and on the state of wl->scan_state == GELIC_WL_SCAN_GOT_LIST
1760 static int gelic_wl_do_wep_setup(struct gelic_wl_info
*wl
)
1763 struct gelic_eurus_wep_cfg
*wep
;
1764 struct gelic_eurus_cmd
*cmd
;
1769 pr_debug("%s: <-\n", __func__
);
1770 /* we can assume no one should uses the buffer */
1771 wep
= (struct gelic_eurus_wep_cfg
*)__get_free_page(GFP_KERNEL
);
1775 memset(wep
, 0, sizeof(*wep
));
1777 if (wl
->group_cipher_method
== GELIC_WL_CIPHER_WEP
) {
1778 pr_debug("%s: WEP mode\n", __func__
);
1779 for (i
= 0; i
< GELIC_WEP_KEYS
; i
++) {
1780 if (!test_bit(i
, &wl
->key_enabled
))
1783 pr_debug("%s: key#%d enabled\n", __func__
, i
);
1785 if (wl
->key_len
[i
] == 13)
1787 else if (wl
->key_len
[i
] != 5) {
1788 pr_info("%s: wrong wep key[%d]=%d\n",
1789 __func__
, i
, wl
->key_len
[i
]);
1793 memcpy(wep
->key
[i
], wl
->key
[i
], wl
->key_len
[i
]);
1797 pr_info("%s: all wep key disabled\n", __func__
);
1803 pr_debug("%s: 104bit key\n", __func__
);
1804 wep
->security
= cpu_to_be16(GELIC_EURUS_WEP_SEC_104BIT
);
1806 pr_debug("%s: 40bit key\n", __func__
);
1807 wep
->security
= cpu_to_be16(GELIC_EURUS_WEP_SEC_40BIT
);
1810 pr_debug("%s: NO encryption\n", __func__
);
1811 wep
->security
= cpu_to_be16(GELIC_EURUS_WEP_SEC_NONE
);
1814 /* issue wep setup */
1815 cmd
= gelic_eurus_sync_cmd(wl
, GELIC_EURUS_CMD_SET_WEP_CFG
,
1819 else if (cmd
->status
|| cmd
->cmd_status
)
1824 free_page((unsigned long)wep
);
1825 pr_debug("%s: ->\n", __func__
);
1830 static const char *wpasecstr(enum gelic_eurus_wpa_security sec
)
1833 case GELIC_EURUS_WPA_SEC_NONE
:
1836 case GELIC_EURUS_WPA_SEC_WPA_TKIP_TKIP
:
1837 return "WPA_TKIP_TKIP";
1839 case GELIC_EURUS_WPA_SEC_WPA_TKIP_AES
:
1840 return "WPA_TKIP_AES";
1842 case GELIC_EURUS_WPA_SEC_WPA_AES_AES
:
1843 return "WPA_AES_AES";
1845 case GELIC_EURUS_WPA_SEC_WPA2_TKIP_TKIP
:
1846 return "WPA2_TKIP_TKIP";
1848 case GELIC_EURUS_WPA_SEC_WPA2_TKIP_AES
:
1849 return "WPA2_TKIP_AES";
1851 case GELIC_EURUS_WPA_SEC_WPA2_AES_AES
:
1852 return "WPA2_AES_AES";
1859 static int gelic_wl_do_wpa_setup(struct gelic_wl_info
*wl
)
1861 struct gelic_eurus_wpa_cfg
*wpa
;
1862 struct gelic_eurus_cmd
*cmd
;
1866 pr_debug("%s: <-\n", __func__
);
1867 /* we can assume no one should uses the buffer */
1868 wpa
= (struct gelic_eurus_wpa_cfg
*)__get_free_page(GFP_KERNEL
);
1872 memset(wpa
, 0, sizeof(*wpa
));
1874 if (!test_bit(GELIC_WL_STAT_WPA_PSK_SET
, &wl
->stat
))
1875 pr_info("%s: PSK not configured yet\n", __func__
);
1878 memcpy(wpa
->psk
, wl
->psk
, wl
->psk_len
);
1880 /* set security level */
1881 if (wl
->wpa_level
== GELIC_WL_WPA_LEVEL_WPA2
) {
1882 if (wl
->group_cipher_method
== GELIC_WL_CIPHER_AES
) {
1883 security
= GELIC_EURUS_WPA_SEC_WPA2_AES_AES
;
1885 if (wl
->pairwise_cipher_method
== GELIC_WL_CIPHER_AES
&&
1887 security
= GELIC_EURUS_WPA_SEC_WPA2_TKIP_AES
;
1889 security
= GELIC_EURUS_WPA_SEC_WPA2_TKIP_TKIP
;
1892 if (wl
->group_cipher_method
== GELIC_WL_CIPHER_AES
) {
1893 security
= GELIC_EURUS_WPA_SEC_WPA_AES_AES
;
1895 if (wl
->pairwise_cipher_method
== GELIC_WL_CIPHER_AES
&&
1897 security
= GELIC_EURUS_WPA_SEC_WPA_TKIP_AES
;
1899 security
= GELIC_EURUS_WPA_SEC_WPA_TKIP_TKIP
;
1902 wpa
->security
= cpu_to_be16(security
);
1905 wpa
->psk_type
= cpu_to_be16(wl
->psk_type
);
1907 pr_debug("%s: sec=%s psktype=%s\n", __func__
,
1908 wpasecstr(wpa
->security
),
1909 (wpa
->psk_type
== GELIC_EURUS_WPA_PSK_BIN
) ?
1910 "BIN" : "passphrase");
1913 * don't enable here if you plan to submit
1914 * the debug log because this dumps your precious
1917 pr_debug("%s: psk=%s\n", __func__
,
1918 (wpa
->psk_type
== GELIC_EURUS_WPA_PSK_BIN
) ?
1922 /* issue wpa setup */
1923 cmd
= gelic_eurus_sync_cmd(wl
, GELIC_EURUS_CMD_SET_WPA_CFG
,
1927 else if (cmd
->status
|| cmd
->cmd_status
)
1930 free_page((unsigned long)wpa
);
1931 pr_debug("%s: --> %d\n", __func__
, ret
);
1936 * Start association. caller must hold assoc_stat_lock
1938 static int gelic_wl_associate_bss(struct gelic_wl_info
*wl
,
1939 struct gelic_wl_scan_info
*bss
)
1941 struct gelic_eurus_cmd
*cmd
;
1942 struct gelic_eurus_common_cfg
*common
;
1946 pr_debug("%s: <-\n", __func__
);
1948 /* do common config */
1949 common
= (struct gelic_eurus_common_cfg
*)__get_free_page(GFP_KERNEL
);
1953 memset(common
, 0, sizeof(*common
));
1954 common
->bss_type
= cpu_to_be16(GELIC_EURUS_BSS_INFRA
);
1955 common
->op_mode
= cpu_to_be16(GELIC_EURUS_OPMODE_11BG
);
1957 common
->scan_index
= cpu_to_be16(bss
->eurus_index
);
1958 switch (wl
->auth_method
) {
1959 case GELIC_EURUS_AUTH_OPEN
:
1960 common
->auth_method
= cpu_to_be16(GELIC_EURUS_AUTH_OPEN
);
1962 case GELIC_EURUS_AUTH_SHARED
:
1963 common
->auth_method
= cpu_to_be16(GELIC_EURUS_AUTH_SHARED
);
1970 pr_debug("%s: common cfg index=%d bsstype=%d auth=%d\n", __func__
,
1971 be16_to_cpu(common
->scan_index
),
1972 be16_to_cpu(common
->bss_type
),
1973 be16_to_cpu(common
->auth_method
));
1975 cmd
= gelic_eurus_sync_cmd(wl
, GELIC_EURUS_CMD_SET_COMMON_CFG
,
1976 common
, sizeof(*common
));
1977 if (!cmd
|| cmd
->status
|| cmd
->cmd_status
) {
1985 switch (wl
->wpa_level
) {
1986 case GELIC_WL_WPA_LEVEL_NONE
:
1987 /* If WEP or no security, setup WEP config */
1988 ret
= gelic_wl_do_wep_setup(wl
);
1990 case GELIC_WL_WPA_LEVEL_WPA
:
1991 case GELIC_WL_WPA_LEVEL_WPA2
:
1992 ret
= gelic_wl_do_wpa_setup(wl
);
1997 pr_debug("%s: WEP/WPA setup failed %d\n", __func__
,
2000 gelic_wl_send_iwap_event(wl
, NULL
);
2004 /* start association */
2005 init_completion(&wl
->assoc_done
);
2006 wl
->assoc_stat
= GELIC_WL_ASSOC_STAT_ASSOCIATING
;
2007 cmd
= gelic_eurus_sync_cmd(wl
, GELIC_EURUS_CMD_ASSOC
,
2009 if (!cmd
|| cmd
->status
|| cmd
->cmd_status
) {
2010 pr_debug("%s: assoc request failed\n", __func__
);
2011 wl
->assoc_stat
= GELIC_WL_ASSOC_STAT_DISCONN
;
2014 gelic_wl_send_iwap_event(wl
, NULL
);
2019 /* wait for connected event */
2020 rc
= wait_for_completion_timeout(&wl
->assoc_done
, HZ
* 4);/*FIXME*/
2023 /* timeouted. Maybe key or cyrpt mode is wrong */
2024 pr_info("%s: connect timeout\n", __func__
);
2025 cmd
= gelic_eurus_sync_cmd(wl
, GELIC_EURUS_CMD_DISASSOC
,
2028 wl
->assoc_stat
= GELIC_WL_ASSOC_STAT_DISCONN
;
2029 gelic_wl_send_iwap_event(wl
, NULL
);
2032 wl
->assoc_stat
= GELIC_WL_ASSOC_STAT_ASSOCIATED
;
2034 memcpy(wl
->active_bssid
, &bss
->hwinfo
->bssid
[2], ETH_ALEN
);
2036 /* send connect event */
2037 gelic_wl_send_iwap_event(wl
, wl
->active_bssid
);
2038 pr_info("%s: connected\n", __func__
);
2041 free_page((unsigned long)common
);
2042 pr_debug("%s: ->\n", __func__
);
2049 static void gelic_wl_connected_event(struct gelic_wl_info
*wl
,
2052 u64 desired_event
= 0;
2054 switch (wl
->wpa_level
) {
2055 case GELIC_WL_WPA_LEVEL_NONE
:
2056 desired_event
= GELIC_LV1_WL_EVENT_CONNECTED
;
2058 case GELIC_WL_WPA_LEVEL_WPA
:
2059 case GELIC_WL_WPA_LEVEL_WPA2
:
2060 desired_event
= GELIC_LV1_WL_EVENT_WPA_CONNECTED
;
2064 if (desired_event
== event
) {
2065 pr_debug("%s: completed\n", __func__
);
2066 complete(&wl
->assoc_done
);
2067 netif_carrier_on(port_to_netdev(wl_port(wl
)));
2069 pr_debug("%s: event %#llx under wpa\n",
2076 static void gelic_wl_disconnect_event(struct gelic_wl_info
*wl
,
2079 struct gelic_eurus_cmd
*cmd
;
2083 * If we fall here in the middle of association,
2084 * associate_bss() should be waiting for complation of
2086 * As it waits with timeout, just leave assoc_done
2087 * uncompleted, then it terminates with timeout
2089 if (!mutex_trylock(&wl
->assoc_stat_lock
)) {
2090 pr_debug("%s: already locked\n", __func__
);
2093 pr_debug("%s: obtain lock\n", __func__
);
2097 cmd
= gelic_eurus_sync_cmd(wl
, GELIC_EURUS_CMD_DISASSOC
, NULL
, 0);
2100 /* send disconnected event to the supplicant */
2101 if (wl
->assoc_stat
== GELIC_WL_ASSOC_STAT_ASSOCIATED
)
2102 gelic_wl_send_iwap_event(wl
, NULL
);
2104 wl
->assoc_stat
= GELIC_WL_ASSOC_STAT_DISCONN
;
2105 netif_carrier_off(port_to_netdev(wl_port(wl
)));
2108 mutex_unlock(&wl
->assoc_stat_lock
);
2114 static const char *eventstr(enum gelic_lv1_wl_event event
)
2116 static char buf
[32];
2118 if (event
& GELIC_LV1_WL_EVENT_DEVICE_READY
)
2119 ret
= "EURUS_READY";
2120 else if (event
& GELIC_LV1_WL_EVENT_SCAN_COMPLETED
)
2121 ret
= "SCAN_COMPLETED";
2122 else if (event
& GELIC_LV1_WL_EVENT_DEAUTH
)
2124 else if (event
& GELIC_LV1_WL_EVENT_BEACON_LOST
)
2125 ret
= "BEACON_LOST";
2126 else if (event
& GELIC_LV1_WL_EVENT_CONNECTED
)
2128 else if (event
& GELIC_LV1_WL_EVENT_WPA_CONNECTED
)
2129 ret
= "WPA_CONNECTED";
2130 else if (event
& GELIC_LV1_WL_EVENT_WPA_ERROR
)
2133 sprintf(buf
, "Unknown(%#x)", event
);
2139 static const char *eventstr(enum gelic_lv1_wl_event event
)
2144 static void gelic_wl_event_worker(struct work_struct
*work
)
2146 struct gelic_wl_info
*wl
;
2147 struct gelic_port
*port
;
2151 pr_debug("%s:start\n", __func__
);
2152 wl
= container_of(work
, struct gelic_wl_info
, event_work
.work
);
2155 status
= lv1_net_control(bus_id(port
->card
), dev_id(port
->card
),
2156 GELIC_LV1_GET_WLAN_EVENT
, 0, 0, 0,
2159 if (status
!= LV1_NO_ENTRY
)
2160 pr_debug("%s:wlan event failed %d\n",
2162 /* got all events */
2163 pr_debug("%s:end\n", __func__
);
2166 pr_debug("%s: event=%s\n", __func__
, eventstr(event
));
2168 case GELIC_LV1_WL_EVENT_SCAN_COMPLETED
:
2169 gelic_wl_scan_complete_event(wl
);
2171 case GELIC_LV1_WL_EVENT_BEACON_LOST
:
2172 case GELIC_LV1_WL_EVENT_DEAUTH
:
2173 gelic_wl_disconnect_event(wl
, event
);
2175 case GELIC_LV1_WL_EVENT_CONNECTED
:
2176 case GELIC_LV1_WL_EVENT_WPA_CONNECTED
:
2177 gelic_wl_connected_event(wl
, event
);
2185 * association worker
2187 static void gelic_wl_assoc_worker(struct work_struct
*work
)
2189 struct gelic_wl_info
*wl
;
2191 struct gelic_wl_scan_info
*best_bss
;
2193 unsigned long irqflag
;
2197 wl
= container_of(work
, struct gelic_wl_info
, assoc_work
.work
);
2199 mutex_lock(&wl
->assoc_stat_lock
);
2201 if (wl
->assoc_stat
!= GELIC_WL_ASSOC_STAT_DISCONN
)
2204 spin_lock_irqsave(&wl
->lock
, irqflag
);
2205 if (test_bit(GELIC_WL_STAT_ESSID_SET
, &wl
->stat
)) {
2206 pr_debug("%s: assoc ESSID configured %s\n", __func__
,
2209 essid_len
= wl
->essid_len
;
2214 spin_unlock_irqrestore(&wl
->lock
, irqflag
);
2216 ret
= gelic_wl_start_scan(wl
, 0, essid
, essid_len
);
2217 if (ret
== -ERESTARTSYS
) {
2218 pr_debug("%s: scan start failed association\n", __func__
);
2219 schedule_delayed_work(&wl
->assoc_work
, HZ
/10); /*FIXME*/
2222 pr_info("%s: scan prerequisite failed\n", __func__
);
2227 * Wait for bss scan completion
2228 * If we have scan list already, gelic_wl_start_scan()
2229 * returns OK and raises the complete. Thus,
2230 * it's ok to wait unconditionally here
2232 wait_for_completion(&wl
->scan_done
);
2234 pr_debug("%s: scan done\n", __func__
);
2235 mutex_lock(&wl
->scan_lock
);
2236 if (wl
->scan_stat
!= GELIC_WL_SCAN_STAT_GOT_LIST
) {
2237 gelic_wl_send_iwap_event(wl
, NULL
);
2238 pr_info("%s: no scan list. association failed\n", __func__
);
2242 /* find best matching bss */
2243 best_bss
= gelic_wl_find_best_bss(wl
);
2245 gelic_wl_send_iwap_event(wl
, NULL
);
2246 pr_info("%s: no bss matched. association failed\n", __func__
);
2250 /* ok, do association */
2251 ret
= gelic_wl_associate_bss(wl
, best_bss
);
2253 pr_info("%s: association failed %d\n", __func__
, ret
);
2255 mutex_unlock(&wl
->scan_lock
);
2257 mutex_unlock(&wl
->assoc_stat_lock
);
2261 * Called from the ethernet interrupt handler
2262 * Processes wireless specific virtual interrupts only
2264 void gelic_wl_interrupt(struct net_device
*netdev
, u64 status
)
2266 struct gelic_wl_info
*wl
= port_wl(netdev_priv(netdev
));
2268 if (status
& GELIC_CARD_WLAN_COMMAND_COMPLETED
) {
2269 pr_debug("%s:cmd complete\n", __func__
);
2270 complete(&wl
->cmd_done_intr
);
2273 if (status
& GELIC_CARD_WLAN_EVENT_RECEIVED
) {
2274 pr_debug("%s:event received\n", __func__
);
2275 queue_delayed_work(wl
->event_queue
, &wl
->event_work
, 0);
2282 static const iw_handler gelic_wl_wext_handler
[] =
2284 IW_HANDLER(SIOCGIWNAME
, gelic_wl_get_name
),
2285 IW_HANDLER(SIOCGIWRANGE
, gelic_wl_get_range
),
2286 IW_HANDLER(SIOCSIWSCAN
, gelic_wl_set_scan
),
2287 IW_HANDLER(SIOCGIWSCAN
, gelic_wl_get_scan
),
2288 IW_HANDLER(SIOCSIWAUTH
, gelic_wl_set_auth
),
2289 IW_HANDLER(SIOCGIWAUTH
, gelic_wl_get_auth
),
2290 IW_HANDLER(SIOCSIWESSID
, gelic_wl_set_essid
),
2291 IW_HANDLER(SIOCGIWESSID
, gelic_wl_get_essid
),
2292 IW_HANDLER(SIOCSIWENCODE
, gelic_wl_set_encode
),
2293 IW_HANDLER(SIOCGIWENCODE
, gelic_wl_get_encode
),
2294 IW_HANDLER(SIOCSIWAP
, gelic_wl_set_ap
),
2295 IW_HANDLER(SIOCGIWAP
, gelic_wl_get_ap
),
2296 IW_HANDLER(SIOCSIWENCODEEXT
, gelic_wl_set_encodeext
),
2297 IW_HANDLER(SIOCGIWENCODEEXT
, gelic_wl_get_encodeext
),
2298 IW_HANDLER(SIOCSIWMODE
, gelic_wl_set_mode
),
2299 IW_HANDLER(SIOCGIWMODE
, gelic_wl_get_mode
),
2300 IW_HANDLER(SIOCGIWNICKN
, gelic_wl_get_nick
),
2303 static const struct iw_handler_def gelic_wl_wext_handler_def
= {
2304 .num_standard
= ARRAY_SIZE(gelic_wl_wext_handler
),
2305 .standard
= gelic_wl_wext_handler
,
2306 .get_wireless_stats
= gelic_wl_get_wireless_stats
,
2309 static struct net_device
* __devinit
gelic_wl_alloc(struct gelic_card
*card
)
2311 struct net_device
*netdev
;
2312 struct gelic_port
*port
;
2313 struct gelic_wl_info
*wl
;
2316 pr_debug("%s:start\n", __func__
);
2317 netdev
= alloc_etherdev(sizeof(struct gelic_port
) +
2318 sizeof(struct gelic_wl_info
));
2319 pr_debug("%s: netdev =%p card=%p\n", __func__
, netdev
, card
);
2323 strcpy(netdev
->name
, "wlan%d");
2325 port
= netdev_priv(netdev
);
2326 port
->netdev
= netdev
;
2328 port
->type
= GELIC_PORT_WIRELESS
;
2331 pr_debug("%s: wl=%p port=%p\n", __func__
, wl
, port
);
2333 /* allocate scan list */
2334 wl
->networks
= kzalloc(sizeof(struct gelic_wl_scan_info
) *
2335 GELIC_WL_BSS_MAX_ENT
, GFP_KERNEL
);
2340 wl
->eurus_cmd_queue
= create_singlethread_workqueue("gelic_cmd");
2341 if (!wl
->eurus_cmd_queue
)
2342 goto fail_cmd_workqueue
;
2344 wl
->event_queue
= create_singlethread_workqueue("gelic_event");
2345 if (!wl
->event_queue
)
2346 goto fail_event_workqueue
;
2348 INIT_LIST_HEAD(&wl
->network_free_list
);
2349 INIT_LIST_HEAD(&wl
->network_list
);
2350 for (i
= 0; i
< GELIC_WL_BSS_MAX_ENT
; i
++)
2351 list_add_tail(&wl
->networks
[i
].list
,
2352 &wl
->network_free_list
);
2353 init_completion(&wl
->cmd_done_intr
);
2355 INIT_DELAYED_WORK(&wl
->event_work
, gelic_wl_event_worker
);
2356 INIT_DELAYED_WORK(&wl
->assoc_work
, gelic_wl_assoc_worker
);
2357 mutex_init(&wl
->scan_lock
);
2358 mutex_init(&wl
->assoc_stat_lock
);
2360 init_completion(&wl
->scan_done
);
2361 /* for the case that no scan request is issued and stop() is called */
2362 complete(&wl
->scan_done
);
2364 spin_lock_init(&wl
->lock
);
2366 wl
->scan_age
= 5*HZ
; /* FIXME */
2368 /* buffer for receiving scanned list etc */
2369 BUILD_BUG_ON(PAGE_SIZE
<
2370 sizeof(struct gelic_eurus_scan_info
) *
2371 GELIC_EURUS_MAX_SCAN
);
2372 pr_debug("%s:end\n", __func__
);
2375 fail_event_workqueue
:
2376 destroy_workqueue(wl
->eurus_cmd_queue
);
2378 kfree(wl
->networks
);
2380 free_netdev(netdev
);
2381 pr_debug("%s:end error\n", __func__
);
2386 static void gelic_wl_free(struct gelic_wl_info
*wl
)
2388 struct gelic_wl_scan_info
*scan_info
;
2391 pr_debug("%s: <-\n", __func__
);
2393 pr_debug("%s: destroy queues\n", __func__
);
2394 destroy_workqueue(wl
->eurus_cmd_queue
);
2395 destroy_workqueue(wl
->event_queue
);
2397 scan_info
= wl
->networks
;
2398 for (i
= 0; i
< GELIC_WL_BSS_MAX_ENT
; i
++, scan_info
++)
2399 kfree(scan_info
->hwinfo
);
2400 kfree(wl
->networks
);
2402 free_netdev(port_to_netdev(wl_port(wl
)));
2404 pr_debug("%s: ->\n", __func__
);
2407 static int gelic_wl_try_associate(struct net_device
*netdev
)
2409 struct gelic_wl_info
*wl
= port_wl(netdev_priv(netdev
));
2413 pr_debug("%s: <-\n", __func__
);
2415 /* check constraits for start association */
2416 /* for no access restriction AP */
2417 if (wl
->group_cipher_method
== GELIC_WL_CIPHER_NONE
) {
2418 if (test_bit(GELIC_WL_STAT_CONFIGURED
,
2422 pr_debug("%s: no wep, not configured\n", __func__
);
2427 /* for WEP, one of four keys should be set */
2428 if (wl
->group_cipher_method
== GELIC_WL_CIPHER_WEP
) {
2429 /* one of keys set */
2430 for (i
= 0; i
< GELIC_WEP_KEYS
; i
++) {
2431 if (test_bit(i
, &wl
->key_enabled
))
2434 pr_debug("%s: WEP, but no key specified\n", __func__
);
2438 /* for WPA[2], psk should be set */
2439 if ((wl
->group_cipher_method
== GELIC_WL_CIPHER_TKIP
) ||
2440 (wl
->group_cipher_method
== GELIC_WL_CIPHER_AES
)) {
2441 if (test_bit(GELIC_WL_STAT_WPA_PSK_SET
,
2445 pr_debug("%s: AES/TKIP, but PSK not configured\n",
2452 ret
= schedule_delayed_work(&wl
->assoc_work
, 0);
2453 pr_debug("%s: start association work %d\n", __func__
, ret
);
2460 static int gelic_wl_open(struct net_device
*netdev
)
2462 struct gelic_card
*card
= netdev_card(netdev
);
2464 pr_debug("%s:->%p\n", __func__
, netdev
);
2466 gelic_card_up(card
);
2468 /* try to associate */
2469 gelic_wl_try_associate(netdev
);
2471 netif_start_queue(netdev
);
2473 pr_debug("%s:<-\n", __func__
);
2478 * reset state machine
2480 static int gelic_wl_reset_state(struct gelic_wl_info
*wl
)
2482 struct gelic_wl_scan_info
*target
;
2483 struct gelic_wl_scan_info
*tmp
;
2485 /* empty scan list */
2486 list_for_each_entry_safe(target
, tmp
, &wl
->network_list
, list
) {
2487 list_move_tail(&target
->list
, &wl
->network_free_list
);
2489 wl
->scan_stat
= GELIC_WL_SCAN_STAT_INIT
;
2491 /* clear configuration */
2492 wl
->auth_method
= GELIC_EURUS_AUTH_OPEN
;
2493 wl
->group_cipher_method
= GELIC_WL_CIPHER_NONE
;
2494 wl
->pairwise_cipher_method
= GELIC_WL_CIPHER_NONE
;
2495 wl
->wpa_level
= GELIC_WL_WPA_LEVEL_NONE
;
2497 wl
->key_enabled
= 0;
2498 wl
->current_key
= 0;
2500 wl
->psk_type
= GELIC_EURUS_WPA_PSK_PASSPHRASE
;
2504 memset(wl
->essid
, 0, sizeof(wl
->essid
));
2505 memset(wl
->bssid
, 0, sizeof(wl
->bssid
));
2506 memset(wl
->active_bssid
, 0, sizeof(wl
->active_bssid
));
2508 wl
->assoc_stat
= GELIC_WL_ASSOC_STAT_DISCONN
;
2510 memset(&wl
->iwstat
, 0, sizeof(wl
->iwstat
));
2511 /* all status bit clear */
2517 * Tell eurus to terminate association
2519 static void gelic_wl_disconnect(struct net_device
*netdev
)
2521 struct gelic_port
*port
= netdev_priv(netdev
);
2522 struct gelic_wl_info
*wl
= port_wl(port
);
2523 struct gelic_eurus_cmd
*cmd
;
2526 * If scann process is running on chip,
2527 * further requests will be rejected
2529 if (wl
->scan_stat
== GELIC_WL_SCAN_STAT_SCANNING
)
2530 wait_for_completion_timeout(&wl
->scan_done
, HZ
);
2532 cmd
= gelic_eurus_sync_cmd(wl
, GELIC_EURUS_CMD_DISASSOC
, NULL
, 0);
2534 gelic_wl_send_iwap_event(wl
, NULL
);
2537 static int gelic_wl_stop(struct net_device
*netdev
)
2539 struct gelic_port
*port
= netdev_priv(netdev
);
2540 struct gelic_wl_info
*wl
= port_wl(port
);
2541 struct gelic_card
*card
= netdev_card(netdev
);
2543 pr_debug("%s:<-\n", __func__
);
2546 * Cancel pending association work.
2547 * event work can run after netdev down
2549 cancel_delayed_work(&wl
->assoc_work
);
2551 if (wl
->assoc_stat
== GELIC_WL_ASSOC_STAT_ASSOCIATED
)
2552 gelic_wl_disconnect(netdev
);
2554 /* reset our state machine */
2555 gelic_wl_reset_state(wl
);
2557 netif_stop_queue(netdev
);
2559 gelic_card_down(card
);
2561 pr_debug("%s:->\n", __func__
);
2567 static const struct net_device_ops gelic_wl_netdevice_ops
= {
2568 .ndo_open
= gelic_wl_open
,
2569 .ndo_stop
= gelic_wl_stop
,
2570 .ndo_start_xmit
= gelic_net_xmit
,
2571 .ndo_set_rx_mode
= gelic_net_set_multi
,
2572 .ndo_change_mtu
= gelic_net_change_mtu
,
2573 .ndo_tx_timeout
= gelic_net_tx_timeout
,
2574 .ndo_set_mac_address
= eth_mac_addr
,
2575 .ndo_validate_addr
= eth_validate_addr
,
2576 #ifdef CONFIG_NET_POLL_CONTROLLER
2577 .ndo_poll_controller
= gelic_net_poll_controller
,
2581 static const struct ethtool_ops gelic_wl_ethtool_ops
= {
2582 .get_drvinfo
= gelic_net_get_drvinfo
,
2583 .get_link
= gelic_wl_get_link
,
2586 static void __devinit
gelic_wl_setup_netdev_ops(struct net_device
*netdev
)
2588 struct gelic_wl_info
*wl
;
2589 wl
= port_wl(netdev_priv(netdev
));
2591 netdev
->watchdog_timeo
= GELIC_NET_WATCHDOG_TIMEOUT
;
2593 netdev
->ethtool_ops
= &gelic_wl_ethtool_ops
;
2594 netdev
->netdev_ops
= &gelic_wl_netdevice_ops
;
2595 netdev
->wireless_data
= &wl
->wireless_data
;
2596 netdev
->wireless_handlers
= &gelic_wl_wext_handler_def
;
2600 * driver probe/remove
2602 int __devinit
gelic_wl_driver_probe(struct gelic_card
*card
)
2605 struct net_device
*netdev
;
2607 pr_debug("%s:start\n", __func__
);
2609 if (ps3_compare_firmware_version(1, 6, 0) < 0)
2611 if (!card
->vlan
[GELIC_PORT_WIRELESS
].tx
)
2614 /* alloc netdevice for wireless */
2615 netdev
= gelic_wl_alloc(card
);
2619 /* setup net_device structure */
2620 SET_NETDEV_DEV(netdev
, &card
->dev
->core
);
2621 gelic_wl_setup_netdev_ops(netdev
);
2623 /* setup some of net_device and register it */
2624 ret
= gelic_net_setup_netdev(netdev
, card
);
2627 card
->netdev
[GELIC_PORT_WIRELESS
] = netdev
;
2629 /* add enable wireless interrupt */
2630 card
->irq_mask
|= GELIC_CARD_WLAN_EVENT_RECEIVED
|
2631 GELIC_CARD_WLAN_COMMAND_COMPLETED
;
2632 /* to allow wireless commands while both interfaces are down */
2633 gelic_card_set_irq_mask(card
, GELIC_CARD_WLAN_EVENT_RECEIVED
|
2634 GELIC_CARD_WLAN_COMMAND_COMPLETED
);
2635 pr_debug("%s:end\n", __func__
);
2639 gelic_wl_free(port_wl(netdev_port(netdev
)));
2644 int gelic_wl_driver_remove(struct gelic_card
*card
)
2646 struct gelic_wl_info
*wl
;
2647 struct net_device
*netdev
;
2649 pr_debug("%s:start\n", __func__
);
2651 if (ps3_compare_firmware_version(1, 6, 0) < 0)
2653 if (!card
->vlan
[GELIC_PORT_WIRELESS
].tx
)
2656 netdev
= card
->netdev
[GELIC_PORT_WIRELESS
];
2657 wl
= port_wl(netdev_priv(netdev
));
2659 /* if the interface was not up, but associated */
2660 if (wl
->assoc_stat
== GELIC_WL_ASSOC_STAT_ASSOCIATED
)
2661 gelic_wl_disconnect(netdev
);
2663 complete(&wl
->cmd_done_intr
);
2665 /* cancel all work queue */
2666 cancel_delayed_work(&wl
->assoc_work
);
2667 cancel_delayed_work(&wl
->event_work
);
2668 flush_workqueue(wl
->eurus_cmd_queue
);
2669 flush_workqueue(wl
->event_queue
);
2671 unregister_netdev(netdev
);
2673 /* disable wireless interrupt */
2674 pr_debug("%s: disable intr\n", __func__
);
2675 card
->irq_mask
&= ~(GELIC_CARD_WLAN_EVENT_RECEIVED
|
2676 GELIC_CARD_WLAN_COMMAND_COMPLETED
);
2677 /* free bss list, netdev*/
2679 pr_debug("%s:end\n", __func__
);