2 * WPA Supplicant - Driver interaction with Atmel Wireless LAN drivers
3 * Copyright (c) 2000-2005, ATMEL Corporation
4 * Copyright (c) 2004-2007, Jouni Malinen <j@w1.fi>
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 as
8 * published by the Free Software Foundation.
10 * Alternatively, this software may be distributed under the terms of BSD
13 * See README and COPYING for more details.
16 /******************************************************************************
17 Copyright 2000-2001 ATMEL Corporation.
19 WPA Supplicant - driver interaction with Atmel Wireless lan drivers.
21 This is free software; you can redistribute it and/or modify
22 it under the terms of the GNU General Public License as published by
23 the Free Software Foundation; either version 2 of the License, or
24 (at your option) any later version.
26 This program is distributed in the hope that it will be useful,
27 but WITHOUT ANY WARRANTY; without even the implied warranty of
28 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
29 GNU General Public License for more details.
31 You should have received a copy of the GNU General Public License
32 along with Atmel wireless lan drivers; if not, write to the Free Software
33 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
35 ******************************************************************************/
38 * Alternatively, this software may be distributed under the terms of BSD
43 #include <sys/ioctl.h>
45 #include "wireless_copy.h"
48 #include "driver_wext.h"
50 struct wpa_driver_atmel_data {
51 void *wext; /* private data for driver_wext */
53 char ifname[IFNAMSIZ + 1];
58 #define ATMEL_WPA_IOCTL (SIOCIWFIRSTPRIV + 2)
59 #define ATMEL_WPA_IOCTL_PARAM (SIOCIWFIRSTPRIV + 3)
60 #define ATMEL_WPA_IOCTL_GET_PARAM (SIOCIWFIRSTPRIV + 4)
63 /* ATMEL_WPA_IOCTL ioctl() cmd: */
65 SET_WPA_ENCRYPTION = 1,
66 SET_CIPHER_SUITES = 2,
71 /* ATMEL_WPA_IOCTL_PARAM ioctl() cmd: */
74 ATMEL_PARAM_PRIVACY_INVOKED = 2,
75 ATMEL_PARAM_WPA_TYPE = 3
78 #define MAX_KEY_LENGTH 40
81 unsigned char sta_addr[6];
89 u8 key[MAX_KEY_LENGTH];
101 static int atmel_ioctl(struct wpa_driver_atmel_data *drv,
102 struct atmel_param *param,
103 int len, int show_err)
107 os_memset(&iwr, 0, sizeof(iwr));
108 os_strlcpy(iwr.ifr_name, drv->ifname, IFNAMSIZ);
109 iwr.u.data.pointer = (caddr_t) param;
110 iwr.u.data.length = len;
112 if (ioctl(drv->sock, ATMEL_WPA_IOCTL, &iwr) < 0) {
116 perror("ioctl[ATMEL_WPA_IOCTL]");
124 static int atmel2param(struct wpa_driver_atmel_data *drv, int param, int value)
129 os_memset(&iwr, 0, sizeof(iwr));
130 os_strlcpy(iwr.ifr_name, drv->ifname, IFNAMSIZ);
131 i = (int *) iwr.u.name;
135 if (ioctl(drv->sock, ATMEL_WPA_IOCTL_PARAM, &iwr) < 0) {
136 perror("ioctl[ATMEL_WPA_IOCTL_PARAM]");
144 static int wpa_driver_atmel_set_wpa_ie(struct wpa_driver_atmel_data *drv,
145 const char *wpa_ie, size_t wpa_ie_len)
147 struct atmel_param *param;
149 size_t blen = ATMEL_GENERIC_ELEMENT_HDR_LEN + wpa_ie_len;
150 if (blen < sizeof(*param))
151 blen = sizeof(*param);
153 param = os_zalloc(blen);
157 param->cmd = ATMEL_SET_GENERIC_ELEMENT;
158 param->u.generic_elem.len = wpa_ie_len;
159 os_memcpy(param->u.generic_elem.data, wpa_ie, wpa_ie_len);
160 res = atmel_ioctl(drv, param, blen, 1);
169 static int wpa_driver_atmel_set_wpa(void *priv, int enabled)
171 struct wpa_driver_atmel_data *drv = priv;
174 printf("wpa_driver_atmel_set_wpa %s\n", drv->ifname);
176 wpa_printf(MSG_DEBUG, "%s: enabled=%d", __FUNCTION__, enabled);
179 if (!enabled && wpa_driver_atmel_set_wpa_ie(drv, NULL, 0) < 0)
182 if (atmel2param(drv, ATMEL_PARAM_PRIVACY_INVOKED, enabled) < 0)
184 if (atmel2param(drv, ATMEL_PARAM_WPA, enabled) < 0)
191 static int wpa_driver_atmel_set_key(const char *ifname, void *priv,
192 enum wpa_alg alg, const u8 *addr,
193 int key_idx, int set_tx,
194 const u8 *seq, size_t seq_len,
195 const u8 *key, size_t key_len)
197 struct wpa_driver_atmel_data *drv = priv;
199 struct atmel_param *param;
227 wpa_printf(MSG_DEBUG, "%s: alg=%s key_idx=%d set_tx=%d seq_len=%lu "
228 "key_len=%lu", __FUNCTION__, alg_name, key_idx, set_tx,
229 (unsigned long) seq_len, (unsigned long) key_len);
234 blen = sizeof(*param) + key_len;
235 buf = os_zalloc(blen);
239 param = (struct atmel_param *) buf;
241 param->cmd = SET_WPA_ENCRYPTION;
244 os_memset(param->sta_addr, 0xff, ETH_ALEN);
246 os_memcpy(param->sta_addr, addr, ETH_ALEN);
248 param->alg = alg_type;
249 param->key_idx = key_idx;
250 param->set_tx = set_tx;
252 os_memcpy(param->seq, seq, seq_len);
253 param->seq_len = seq_len;
254 param->key_len = key_len;
255 os_memcpy((u8 *)param->key, key, key_len);
257 if (atmel_ioctl(drv, param, blen, 1)) {
258 wpa_printf(MSG_WARNING, "Failed to set encryption.");
259 /* TODO: show key error*/
268 static int wpa_driver_atmel_set_countermeasures(void *priv,
272 printf("wpa_driver_atmel_set_countermeasures - not yet "
278 static int wpa_driver_atmel_mlme(void *priv, const u8 *addr, int cmd,
281 struct wpa_driver_atmel_data *drv = priv;
282 struct atmel_param param;
284 int mgmt_error = 0xaa;
286 os_memset(¶m, 0, sizeof(param));
287 os_memcpy(param.sta_addr, addr, ETH_ALEN);
289 param.mlme.reason_code = reason_code;
290 param.mlme.state = mgmt_error;
291 ret = atmel_ioctl(drv, ¶m, sizeof(param), 1);
297 static int wpa_driver_atmel_set_suites(struct wpa_driver_atmel_data *drv,
298 u8 pairwise_suite, u8 group_suite,
301 struct atmel_param param;
304 os_memset(¶m, 0, sizeof(param));
305 param.cmd = SET_CIPHER_SUITES;
306 param.pairwise_suite = pairwise_suite;
307 param.group_suite = group_suite;
308 param.key_mgmt_suite = key_mgmt_suite;
310 ret = atmel_ioctl(drv, ¶m, sizeof(param), 1);
316 static int wpa_driver_atmel_deauthenticate(void *priv, const u8 *addr,
319 struct wpa_driver_atmel_data *drv = priv;
320 printf("wpa_driver_atmel_deauthenticate\n");
321 wpa_printf(MSG_DEBUG, "%s", __FUNCTION__);
322 return wpa_driver_atmel_mlme(drv, addr, MLME_STA_DEAUTH,
328 static int wpa_driver_atmel_disassociate(void *priv, const u8 *addr,
331 struct wpa_driver_atmel_data *drv = priv;
332 printf("wpa_driver_atmel_disassociate\n");
333 wpa_printf(MSG_DEBUG, "%s", __FUNCTION__);
334 return wpa_driver_atmel_mlme(drv, addr, MLME_STA_DISASSOC,
341 /* Atmel driver uses specific values for each cipher suite */
342 static int convertSuiteToDriver(enum wpa_cipher suite)
372 wpa_driver_atmel_associate(void *priv,
373 struct wpa_driver_associate_params *params)
375 struct wpa_driver_atmel_data *drv = priv;
378 u8 pairwise_suite_driver;
379 u8 group_suite_driver;
380 u8 key_mgmt_suite_driver;
382 pairwise_suite_driver = convertSuiteToDriver(params->pairwise_suite);
383 group_suite_driver = convertSuiteToDriver(params->group_suite);
384 key_mgmt_suite_driver = convertSuiteToDriver(params->key_mgmt_suite);
386 if (wpa_driver_atmel_set_suites(drv, pairwise_suite_driver,
388 key_mgmt_suite_driver) < 0){
389 printf("wpa_driver_atmel_set_suites.\n");
392 if (wpa_driver_wext_set_freq(drv->wext, params->freq) < 0) {
393 printf("wpa_driver_atmel_set_freq.\n");
397 if (wpa_driver_wext_set_ssid(drv->wext, params->ssid, params->ssid_len)
399 printf("FAILED : wpa_driver_atmel_set_ssid.\n");
402 if (wpa_driver_wext_set_bssid(drv->wext, params->bssid) < 0) {
403 printf("FAILED : wpa_driver_atmel_set_bssid.\n");
411 static int wpa_driver_atmel_get_bssid(void *priv, u8 *bssid)
413 struct wpa_driver_atmel_data *drv = priv;
414 return wpa_driver_wext_get_bssid(drv->wext, bssid);
418 static int wpa_driver_atmel_get_ssid(void *priv, u8 *ssid)
420 struct wpa_driver_atmel_data *drv = priv;
421 return wpa_driver_wext_get_ssid(drv->wext, ssid);
425 static int wpa_driver_atmel_scan(void *priv,
426 struct wpa_driver_scan_params *params)
428 struct wpa_driver_atmel_data *drv = priv;
429 return wpa_driver_wext_scan(drv->wext, params);
433 static struct wpa_scan_results * wpa_driver_atmel_get_scan_results(void *priv)
435 struct wpa_driver_atmel_data *drv = priv;
436 return wpa_driver_wext_get_scan_results(drv->wext);
440 static int wpa_driver_atmel_set_operstate(void *priv, int state)
442 struct wpa_driver_atmel_data *drv = priv;
443 return wpa_driver_wext_set_operstate(drv->wext, state);
447 static void * wpa_driver_atmel_init(void *ctx, const char *ifname)
449 struct wpa_driver_atmel_data *drv;
451 drv = os_zalloc(sizeof(*drv));
454 drv->wext = wpa_driver_wext_init(ctx, ifname);
455 if (drv->wext == NULL) {
461 os_strlcpy(drv->ifname, ifname, sizeof(drv->ifname));
462 drv->sock = socket(PF_INET, SOCK_DGRAM, 0);
464 wpa_driver_wext_deinit(drv->wext);
469 wpa_driver_atmel_set_wpa(drv, 1);
475 static void wpa_driver_atmel_deinit(void *priv)
477 struct wpa_driver_atmel_data *drv = priv;
478 wpa_driver_atmel_set_wpa(drv, 0);
479 wpa_driver_wext_deinit(drv->wext);
485 const struct wpa_driver_ops wpa_driver_atmel_ops = {
487 .desc = "ATMEL AT76C5XXx (USB, PCMCIA)",
488 .get_bssid = wpa_driver_atmel_get_bssid,
489 .get_ssid = wpa_driver_atmel_get_ssid,
490 .set_key = wpa_driver_atmel_set_key,
491 .init = wpa_driver_atmel_init,
492 .deinit = wpa_driver_atmel_deinit,
493 .set_countermeasures = wpa_driver_atmel_set_countermeasures,
494 .scan2 = wpa_driver_atmel_scan,
495 .get_scan_results2 = wpa_driver_atmel_get_scan_results,
496 .deauthenticate = wpa_driver_atmel_deauthenticate,
497 .disassociate = wpa_driver_atmel_disassociate,
498 .associate = wpa_driver_atmel_associate,
499 .set_operstate = wpa_driver_atmel_set_operstate,