drivers/net/ethernet/toshiba/ps3_gelic_wireless.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  *  PS3 gelic network driver.
   4  *
   5  * Copyright (C) 2007 Sony Computer Entertainment Inc.
   6  * Copyright 2007 Sony Corporation
   7  */
   8 #undef DEBUG
   9
  10 #include <linux/kernel.h>
  11 #include <linux/module.h>
  12 #include <linux/slab.h>
  13
  14 #include <linux/etherdevice.h>
  15 #include <linux/ethtool.h>
  16 #include <linux/if_vlan.h>
  17
  18 #include <linux/in.h>
  19 #include <linux/ip.h>
  20 #include <linux/tcp.h>
  21 #include <linux/wireless.h>
  22 #include <linux/ieee80211.h>
  23 #include <linux/if_arp.h>
  24 #include <linux/ctype.h>
  25 #include <linux/string.h>
  26 #include <net/iw_handler.h>
  27
  28 #include <linux/dma-mapping.h>
  29 #include <net/checksum.h>
  30 #include <asm/firmware.h>
  31 #include <asm/ps3.h>
  32 #include <asm/lv1call.h>
  33
  34 #include "ps3_gelic_net.h"
  35 #include "ps3_gelic_wireless.h"
  36
  37
  38 static int gelic_wl_start_scan(struct gelic_wl_info *wl, int always_scan,
  39                                u8 *essid, size_t essid_len);
  40 static int gelic_wl_try_associate(struct net_device *netdev);
  41
  42 /*
  43  * tables
  44  */
  45
  46 /* 802.11b/g channel to freq in MHz */
  47 static const int channel_freq[] = {
  48         2412, 2417, 2422, 2427, 2432,
  49         2437, 2442, 2447, 2452, 2457,
  50         2462, 2467, 2472, 2484
  51 };
  52 #define NUM_CHANNELS ARRAY_SIZE(channel_freq)
  53
  54 /* in bps */
  55 static const int bitrate_list[] = {
  56           1000000,
  57           2000000,
  58           5500000,
  59          11000000,
  60           6000000,
  61           9000000,
  62          12000000,
  63          18000000,
  64          24000000,
  65          36000000,
  66          48000000,
  67          54000000
  68 };
  69 #define NUM_BITRATES ARRAY_SIZE(bitrate_list)
  70
  71 /*
  72  * wpa2 support requires the hypervisor version 2.0 or later
  73  */
  74 static inline int wpa2_capable(void)
  75 {
  76         return 0 <= ps3_compare_firmware_version(2, 0, 0);
  77 }
  78
  79 static inline int precise_ie(void)
  80 {
  81         return 0 <= ps3_compare_firmware_version(2, 2, 0);
  82 }
  83 /*
  84  * post_eurus_cmd helpers
  85  */
  86 struct eurus_cmd_arg_info {
  87         int pre_arg; /* command requires arg1, arg2 at POST COMMAND */
  88         int post_arg; /* command requires arg1, arg2 at GET_RESULT */
  89 };
  90
  91 static const struct eurus_cmd_arg_info cmd_info[GELIC_EURUS_CMD_MAX_INDEX] = {
  92         [GELIC_EURUS_CMD_SET_COMMON_CFG] = { .pre_arg = 1},
  93         [GELIC_EURUS_CMD_SET_WEP_CFG]    = { .pre_arg = 1},
  94         [GELIC_EURUS_CMD_SET_WPA_CFG]    = { .pre_arg = 1},
  95         [GELIC_EURUS_CMD_GET_COMMON_CFG] = { .post_arg = 1},
  96         [GELIC_EURUS_CMD_GET_WEP_CFG]    = { .post_arg = 1},
  97         [GELIC_EURUS_CMD_GET_WPA_CFG]    = { .post_arg = 1},
  98         [GELIC_EURUS_CMD_GET_RSSI_CFG]   = { .post_arg = 1},
  99         [GELIC_EURUS_CMD_START_SCAN]     = { .pre_arg = 1},
 100         [GELIC_EURUS_CMD_GET_SCAN]       = { .post_arg = 1},
 101 };
 102
 103 #ifdef DEBUG
 104 static const char *cmdstr(enum gelic_eurus_command ix)
 105 {
 106         switch (ix) {
 107         case GELIC_EURUS_CMD_ASSOC:
 108                 return "ASSOC";
 109         case GELIC_EURUS_CMD_DISASSOC:
 110                 return "DISASSOC";
 111         case GELIC_EURUS_CMD_START_SCAN:
 112                 return "SCAN";
 113         case GELIC_EURUS_CMD_GET_SCAN:
 114                 return "GET SCAN";
 115         case GELIC_EURUS_CMD_SET_COMMON_CFG:
 116                 return "SET_COMMON_CFG";
 117         case GELIC_EURUS_CMD_GET_COMMON_CFG:
 118                 return "GET_COMMON_CFG";
 119         case GELIC_EURUS_CMD_SET_WEP_CFG:
 120                 return "SET_WEP_CFG";
 121         case GELIC_EURUS_CMD_GET_WEP_CFG:
 122                 return "GET_WEP_CFG";
 123         case GELIC_EURUS_CMD_SET_WPA_CFG:
 124                 return "SET_WPA_CFG";
 125         case GELIC_EURUS_CMD_GET_WPA_CFG:
 126                 return "GET_WPA_CFG";
 127         case GELIC_EURUS_CMD_GET_RSSI_CFG:
 128                 return "GET_RSSI";
 129         default:
 130                 break;
 131         }
 132         return "";
 133 };
 134 #else
 135 static inline const char *cmdstr(enum gelic_eurus_command ix)
 136 {
 137         return "";
 138 }
 139 #endif
 140
 141 /* synchronously do eurus commands */
 142 static void gelic_eurus_sync_cmd_worker(struct work_struct *work)
 143 {
 144         struct gelic_eurus_cmd *cmd;
 145         struct gelic_card *card;
 146         struct gelic_wl_info *wl;
 147
 148         u64 arg1, arg2;
 149
 150         pr_debug("%s: <-\n", __func__);
 151         cmd = container_of(work, struct gelic_eurus_cmd, work);
 152         BUG_ON(cmd_info[cmd->cmd].pre_arg &&
 153                cmd_info[cmd->cmd].post_arg);
 154         wl = cmd->wl;
 155         card = port_to_card(wl_port(wl));
 156
 157         if (cmd_info[cmd->cmd].pre_arg) {
 158                 arg1 = (cmd->buffer) ?
 159                         ps3_mm_phys_to_lpar(__pa(cmd->buffer)) :
 160                         0;
 161                 arg2 = cmd->buf_size;
 162         } else {
 163                 arg1 = 0;
 164                 arg2 = 0;
 165         }
 166         init_completion(&wl->cmd_done_intr);
 167         pr_debug("%s: cmd='%s' start\n", __func__, cmdstr(cmd->cmd));
 168         cmd->status = lv1_net_control(bus_id(card), dev_id(card),
 169                                       GELIC_LV1_POST_WLAN_CMD,
 170                                       cmd->cmd, arg1, arg2,
 171                                       &cmd->tag, &cmd->size);
 172         if (cmd->status) {
 173                 complete(&cmd->done);
 174                 pr_info("%s: cmd issue failed\n", __func__);
 175                 return;
 176         }
 177
 178         wait_for_completion(&wl->cmd_done_intr);
 179
 180         if (cmd_info[cmd->cmd].post_arg) {
 181                 arg1 = ps3_mm_phys_to_lpar(__pa(cmd->buffer));
 182                 arg2 = cmd->buf_size;
 183         } else {
 184                 arg1 = 0;
 185                 arg2 = 0;
 186         }
 187
 188         cmd->status = lv1_net_control(bus_id(card), dev_id(card),
 189                                       GELIC_LV1_GET_WLAN_CMD_RESULT,
 190                                       cmd->tag, arg1, arg2,
 191                                       &cmd->cmd_status, &cmd->size);
 192 #ifdef DEBUG
 193         if (cmd->status || cmd->cmd_status) {
 194         pr_debug("%s: cmd done tag=%#lx arg1=%#lx, arg2=%#lx\n", __func__,
 195                  cmd->tag, arg1, arg2);
 196         pr_debug("%s: cmd done status=%#x cmd_status=%#lx size=%#lx\n",
 197                  __func__, cmd->status, cmd->cmd_status, cmd->size);
 198         }
 199 #endif
 200         complete(&cmd->done);
 201         pr_debug("%s: cmd='%s' done\n", __func__, cmdstr(cmd->cmd));
 202 }
 203
 204 static struct gelic_eurus_cmd *gelic_eurus_sync_cmd(struct gelic_wl_info *wl,
 205                                                     unsigned int eurus_cmd,
 206                                                     void *buffer,
 207                                                     unsigned int buf_size)
 208 {
 209         struct gelic_eurus_cmd *cmd;
 210
 211         /* allocate cmd */
 212         cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
 213         if (!cmd)
 214                 return NULL;
 215
 216         /* initialize members */
 217         cmd->cmd = eurus_cmd;
 218         cmd->buffer = buffer;
 219         cmd->buf_size = buf_size;
 220         cmd->wl = wl;
 221         INIT_WORK(&cmd->work, gelic_eurus_sync_cmd_worker);
 222         init_completion(&cmd->done);
 223         queue_work(wl->eurus_cmd_queue, &cmd->work);
 224
 225         /* wait for command completion */
 226         wait_for_completion(&cmd->done);
 227
 228         return cmd;
 229 }
 230
 231 static u32 gelic_wl_get_link(struct net_device *netdev)
 232 {
 233         struct gelic_wl_info *wl = port_wl(netdev_port(netdev));
 234         u32 ret;
 235
 236         pr_debug("%s: <-\n", __func__);
 237         mutex_lock(&wl->assoc_stat_lock);
 238         if (wl->assoc_stat == GELIC_WL_ASSOC_STAT_ASSOCIATED)
 239                 ret = 1;
 240         else
 241                 ret = 0;
 242         mutex_unlock(&wl->assoc_stat_lock);
 243         pr_debug("%s: ->\n", __func__);
 244         return ret;
 245 }
 246
 247 static void gelic_wl_send_iwap_event(struct gelic_wl_info *wl, u8 *bssid)
 248 {
 249         union iwreq_data data;
 250
 251         memset(&data, 0, sizeof(data));
 252         if (bssid)
 253                 memcpy(data.ap_addr.sa_data, bssid, ETH_ALEN);
 254         data.ap_addr.sa_family = ARPHRD_ETHER;
 255         wireless_send_event(port_to_netdev(wl_port(wl)), SIOCGIWAP,
 256                             &data, NULL);
 257 }
 258
 259 /*
 260  * wireless extension handlers and helpers
 261  */
 262
 263 /* SIOGIWNAME */
 264 static int gelic_wl_get_name(struct net_device *dev,
 265                              struct iw_request_info *info,
 266                              union iwreq_data *iwreq, char *extra)
 267 {
 268         strcpy(iwreq->name, "IEEE 802.11bg");
 269         return 0;
 270 }
 271
 272 static void gelic_wl_get_ch_info(struct gelic_wl_info *wl)
 273 {
 274         struct gelic_card *card = port_to_card(wl_port(wl));
 275         u64 ch_info_raw, tmp;
 276         int status;
 277
 278         if (!test_and_set_bit(GELIC_WL_STAT_CH_INFO, &wl->stat)) {
 279                 status = lv1_net_control(bus_id(card), dev_id(card),
 280                                          GELIC_LV1_GET_CHANNEL, 0, 0, 0,
 281                                          &ch_info_raw,
 282                                          &tmp);
 283                 /* some fw versions may return error */
 284                 if (status) {
 285                         if (status != LV1_NO_ENTRY)
 286                                 pr_info("%s: available ch unknown\n", __func__);
 287                         wl->ch_info = 0x07ff;/* 11 ch */
 288                 } else
 289                         /* 16 bits of MSB has available channels */
 290                         wl->ch_info = ch_info_raw >> 48;
 291         }
 292 }
 293
 294 /* SIOGIWRANGE */
 295 static int gelic_wl_get_range(struct net_device *netdev,
 296                               struct iw_request_info *info,
 297                               union iwreq_data *iwreq, char *extra)
 298 {
 299         struct iw_point *point = &iwreq->data;
 300         struct iw_range *range = (struct iw_range *)extra;
 301         struct gelic_wl_info *wl = port_wl(netdev_port(netdev));
 302         unsigned int i, chs;
 303
 304         pr_debug("%s: <-\n", __func__);
 305         point->length = sizeof(struct iw_range);
 306         memset(range, 0, sizeof(struct iw_range));
 307
 308         range->we_version_compiled = WIRELESS_EXT;
 309         range->we_version_source = 22;
 310
 311         /* available channels and frequencies */
 312         gelic_wl_get_ch_info(wl);
 313
 314         for (i = 0, chs = 0;
 315              i < NUM_CHANNELS && chs < IW_MAX_FREQUENCIES; i++)
 316                 if (wl->ch_info & (1 << i)) {
 317                         range->freq[chs].i = i + 1;
 318                         range->freq[chs].m = channel_freq[i];
 319                         range->freq[chs].e = 6;
 320                         chs++;
 321                 }
 322         range->num_frequency = chs;
 323         range->old_num_frequency = chs;
 324         range->num_channels = chs;
 325         range->old_num_channels = chs;
 326
 327         /* bitrates */
 328         for (i = 0; i < NUM_BITRATES; i++)
 329                 range->bitrate[i] = bitrate_list[i];
 330         range->num_bitrates = i;
 331
 332         /* signal levels */
 333         range->max_qual.qual = 100; /* relative value */
 334         range->max_qual.level = 100;
 335         range->avg_qual.qual = 50;
 336         range->avg_qual.level = 50;
 337         range->sensitivity = 0;
 338
 339         /* Event capability */
 340         IW_EVENT_CAPA_SET_KERNEL(range->event_capa);
 341         IW_EVENT_CAPA_SET(range->event_capa, SIOCGIWAP);
 342         IW_EVENT_CAPA_SET(range->event_capa, SIOCGIWSCAN);
 343
 344         /* encryption capability */
 345         range->enc_capa = IW_ENC_CAPA_WPA |
 346                 IW_ENC_CAPA_CIPHER_TKIP | IW_ENC_CAPA_CIPHER_CCMP |
 347                 IW_ENC_CAPA_4WAY_HANDSHAKE;
 348         if (wpa2_capable())
 349                 range->enc_capa |= IW_ENC_CAPA_WPA2;
 350         range->encoding_size[0] = 5;    /* 40bit WEP */
 351         range->encoding_size[1] = 13;   /* 104bit WEP */
 352         range->encoding_size[2] = 32;   /* WPA-PSK */
 353         range->num_encoding_sizes = 3;
 354         range->max_encoding_tokens = GELIC_WEP_KEYS;
 355
 356         /* scan capability */
 357         range->scan_capa = IW_SCAN_CAPA_ESSID;
 358
 359         pr_debug("%s: ->\n", __func__);
 360         return 0;
 361
 362 }
 363
 364 /* SIOC{G,S}IWSCAN */
 365 static int gelic_wl_set_scan(struct net_device *netdev,
 366                            struct iw_request_info *info,
 367                            union iwreq_data *wrqu, char *extra)
 368 {
 369         struct gelic_wl_info *wl = port_wl(netdev_priv(netdev));
 370         struct iw_scan_req *req;
 371         u8 *essid = NULL;
 372         size_t essid_len = 0;
 373
 374         if (wrqu->data.length == sizeof(struct iw_scan_req) &&
 375             wrqu->data.flags & IW_SCAN_THIS_ESSID) {
 376                 req = (struct iw_scan_req*)extra;
 377                 essid = req->essid;
 378                 essid_len = req->essid_len;
 379                 pr_debug("%s: ESSID scan =%s\n", __func__, essid);
 380         }
 381         return gelic_wl_start_scan(wl, 1, essid, essid_len);
 382 }
 383
 384 #define OUI_LEN 3
 385 static const u8 rsn_oui[OUI_LEN] = { 0x00, 0x0f, 0xac };
 386 static const u8 wpa_oui[OUI_LEN] = { 0x00, 0x50, 0xf2 };
 387
 388 /*
 389  * synthesize WPA/RSN IE data
 390  * See WiFi WPA specification and IEEE 802.11-2007 7.3.2.25
 391  * for the format
 392  */
 393 static size_t gelic_wl_synthesize_ie(u8 *buf,
 394                                      struct gelic_eurus_scan_info *scan)
 395 {
 396
 397         const u8 *oui_header;
 398         u8 *start = buf;
 399         int rsn;
 400         int ccmp;
 401
 402         pr_debug("%s: <- sec=%16x\n", __func__, scan->security);
 403         switch (be16_to_cpu(scan->security) & GELIC_EURUS_SCAN_SEC_MASK) {
 404         case GELIC_EURUS_SCAN_SEC_WPA:
 405                 rsn = 0;
 406                 break;
 407         case GELIC_EURUS_SCAN_SEC_WPA2:
 408                 rsn = 1;
 409                 break;
 410         default:
 411                 /* WEP or none.  No IE returned */
 412                 return 0;
 413         }
 414
 415         switch (be16_to_cpu(scan->security) & GELIC_EURUS_SCAN_SEC_WPA_MASK) {
 416         case GELIC_EURUS_SCAN_SEC_WPA_TKIP:
 417                 ccmp = 0;
 418                 break;
 419         case GELIC_EURUS_SCAN_SEC_WPA_AES:
 420                 ccmp = 1;
 421                 break;
 422         default:
 423                 if (rsn) {
 424                         ccmp = 1;
 425                         pr_info("%s: no cipher info. defaulted to CCMP\n",
 426                                 __func__);
 427                 } else {
 428                         ccmp = 0;
 429                         pr_info("%s: no cipher info. defaulted to TKIP\n",
 430                                 __func__);
 431                 }
 432         }
 433
 434         if (rsn)
 435                 oui_header = rsn_oui;
 436         else
 437                 oui_header = wpa_oui;
 438
 439         /* element id */
 440         if (rsn)
 441                 *buf++ = WLAN_EID_RSN;
 442         else
 443                 *buf++ = WLAN_EID_VENDOR_SPECIFIC;
 444
 445         /* length filed; set later */
 446         buf++;
 447
 448         /* wpa special header */
 449         if (!rsn) {
 450                 memcpy(buf, wpa_oui, OUI_LEN);
 451                 buf += OUI_LEN;
 452                 *buf++ = 0x01;
 453         }
 454
 455         /* version */
 456         *buf++ = 0x01; /* version 1.0 */
 457         *buf++ = 0x00;
 458
 459         /* group cipher */
 460         memcpy(buf, oui_header, OUI_LEN);
 461         buf += OUI_LEN;
 462
 463         if (ccmp)
 464                 *buf++ = 0x04; /* CCMP */
 465         else
 466                 *buf++ = 0x02; /* TKIP */
 467
 468         /* pairwise key count always 1 */
 469         *buf++ = 0x01;
 470         *buf++ = 0x00;
 471
 472         /* pairwise key suit */
 473         memcpy(buf, oui_header, OUI_LEN);
 474         buf += OUI_LEN;
 475         if (ccmp)
 476                 *buf++ = 0x04; /* CCMP */
 477         else
 478                 *buf++ = 0x02; /* TKIP */
 479
 480         /* AKM count is 1 */
 481         *buf++ = 0x01;
 482         *buf++ = 0x00;
 483
 484         /* AKM suite is assumed as PSK*/
 485         memcpy(buf, oui_header, OUI_LEN);
 486         buf += OUI_LEN;
 487         *buf++ = 0x02; /* PSK */
 488
 489         /* RSN capabilities is 0 */
 490         *buf++ = 0x00;
 491         *buf++ = 0x00;
 492
 493         /* set length field */
 494         start[1] = (buf - start - 2);
 495
 496         pr_debug("%s: ->\n", __func__);
 497         return buf - start;
 498 }
 499
 500 struct ie_item {
 501         u8 *data;
 502         u8 len;
 503 };
 504
 505 struct ie_info {
 506         struct ie_item wpa;
 507         struct ie_item rsn;
 508 };
 509
 510 static void gelic_wl_parse_ie(u8 *data, size_t len,
 511                               struct ie_info *ie_info)
 512 {
 513         size_t data_left = len;
 514         u8 *pos = data;
 515         u8 item_len;
 516         u8 item_id;
 517
 518         pr_debug("%s: data=%p len=%ld\n", __func__,
 519                  data, len);
 520         memset(ie_info, 0, sizeof(struct ie_info));
 521
 522         while (2 <= data_left) {
 523                 item_id = *pos++;
 524                 item_len = *pos++;
 525                 data_left -= 2;
 526
 527                 if (data_left < item_len)
 528                         break;
 529
 530                 switch (item_id) {
 531                 case WLAN_EID_VENDOR_SPECIFIC:
 532                         if ((OUI_LEN + 1 <= item_len) &&
 533                             !memcmp(pos, wpa_oui, OUI_LEN) &&
 534                             pos[OUI_LEN] == 0x01) {
 535                                 ie_info->wpa.data = pos - 2;
 536                                 ie_info->wpa.len = item_len + 2;
 537                         }
 538                         break;
 539                 case WLAN_EID_RSN:
 540                         ie_info->rsn.data = pos - 2;
 541                         /* length includes the header */
 542                         ie_info->rsn.len = item_len + 2;
 543                         break;
 544                 default:
 545                         pr_debug("%s: ignore %#x,%d\n", __func__,
 546                                  item_id, item_len);
 547                         break;
 548                 }
 549                 pos += item_len;
 550                 data_left -= item_len;
 551         }
 552         pr_debug("%s: wpa=%p,%d wpa2=%p,%d\n", __func__,
 553                  ie_info->wpa.data, ie_info->wpa.len,
 554                  ie_info->rsn.data, ie_info->rsn.len);
 555 }
 556
 557
 558 /*
 559  * translate the scan informations from hypervisor to a
 560  * independent format
 561  */
 562 static char *gelic_wl_translate_scan(struct net_device *netdev,
 563                                      struct iw_request_info *info,
 564                                      char *ev,
 565                                      char *stop,
 566                                      struct gelic_wl_scan_info *network)
 567 {
 568         struct iw_event iwe;
 569         struct gelic_eurus_scan_info *scan = network->hwinfo;
 570         char *tmp;
 571         u8 rate;
 572         unsigned int i, j, len;
 573         u8 buf[64]; /* arbitrary size large enough */
 574
 575         pr_debug("%s: <-\n", __func__);
 576
 577         /* first entry should be AP's mac address */
 578         iwe.cmd = SIOCGIWAP;
 579         iwe.u.ap_addr.sa_family = ARPHRD_ETHER;
 580         memcpy(iwe.u.ap_addr.sa_data, &scan->bssid[2], ETH_ALEN);
 581         ev = iwe_stream_add_event(info, ev, stop, &iwe, IW_EV_ADDR_LEN);
 582
 583         /* ESSID */
 584         iwe.cmd = SIOCGIWESSID;
 585         iwe.u.data.flags = 1;
 586         iwe.u.data.length = strnlen(scan->essid, 32);
 587         ev = iwe_stream_add_point(info, ev, stop, &iwe, scan->essid);
 588
 589         /* FREQUENCY */
 590         iwe.cmd = SIOCGIWFREQ;
 591         iwe.u.freq.m = be16_to_cpu(scan->channel);
 592         iwe.u.freq.e = 0; /* table value in MHz */
 593         iwe.u.freq.i = 0;
 594         ev = iwe_stream_add_event(info, ev, stop, &iwe, IW_EV_FREQ_LEN);
 595
 596         /* RATES */
 597         iwe.cmd = SIOCGIWRATE;
 598         iwe.u.bitrate.fixed = iwe.u.bitrate.disabled = 0;
 599         /* to stuff multiple values in one event */
 600         tmp = ev + iwe_stream_lcp_len(info);
 601         /* put them in ascendant order (older is first) */
 602         i = 0;
 603         j = 0;
 604         pr_debug("%s: rates=%d rate=%d\n", __func__,
 605                  network->rate_len, network->rate_ext_len);
 606         while (i < network->rate_len) {
 607                 if (j < network->rate_ext_len &&
 608                     ((scan->ext_rate[j] & 0x7f) < (scan->rate[i] & 0x7f)))
 609                     rate = scan->ext_rate[j++] & 0x7f;
 610                 else
 611                     rate = scan->rate[i++] & 0x7f;
 612                 iwe.u.bitrate.value = rate * 500000; /* 500kbps unit */
 613                 tmp = iwe_stream_add_value(info, ev, tmp, stop, &iwe,
 614                                            IW_EV_PARAM_LEN);
 615         }
 616         while (j < network->rate_ext_len) {
 617                 iwe.u.bitrate.value = (scan->ext_rate[j++] & 0x7f) * 500000;
 618                 tmp = iwe_stream_add_value(info, ev, tmp, stop, &iwe,
 619                                            IW_EV_PARAM_LEN);
 620         }
 621         /* Check if we added any rate */
 622         if (iwe_stream_lcp_len(info) < (tmp - ev))
 623                 ev = tmp;
 624
 625         /* ENCODE */
 626         iwe.cmd = SIOCGIWENCODE;
 627         if (be16_to_cpu(scan->capability) & WLAN_CAPABILITY_PRIVACY)
 628                 iwe.u.data.flags = IW_ENCODE_ENABLED | IW_ENCODE_NOKEY;
 629         else
 630                 iwe.u.data.flags = IW_ENCODE_DISABLED;
 631         iwe.u.data.length = 0;
 632         ev = iwe_stream_add_point(info, ev, stop, &iwe, scan->essid);
 633
 634         /* MODE */
 635         iwe.cmd = SIOCGIWMODE;
 636         if (be16_to_cpu(scan->capability) &
 637             (WLAN_CAPABILITY_ESS | WLAN_CAPABILITY_IBSS)) {
 638                 if (be16_to_cpu(scan->capability) & WLAN_CAPABILITY_ESS)
 639                         iwe.u.mode = IW_MODE_MASTER;
 640                 else
 641                         iwe.u.mode = IW_MODE_ADHOC;
 642                 ev = iwe_stream_add_event(info, ev, stop, &iwe, IW_EV_UINT_LEN);
 643         }
 644
 645         /* QUAL */
 646         iwe.cmd = IWEVQUAL;
 647         iwe.u.qual.updated  = IW_QUAL_ALL_UPDATED |
 648                         IW_QUAL_QUAL_INVALID | IW_QUAL_NOISE_INVALID;
 649         iwe.u.qual.level = be16_to_cpu(scan->rssi);
 650         iwe.u.qual.qual = be16_to_cpu(scan->rssi);
 651         iwe.u.qual.noise = 0;
 652         ev  = iwe_stream_add_event(info, ev, stop, &iwe, IW_EV_QUAL_LEN);
 653
 654         /* RSN */
 655         memset(&iwe, 0, sizeof(iwe));
 656         if (be16_to_cpu(scan->size) <= sizeof(*scan)) {
 657                 /* If wpa[2] capable station, synthesize IE and put it */
 658                 len = gelic_wl_synthesize_ie(buf, scan);
 659                 if (len) {
 660                         iwe.cmd = IWEVGENIE;
 661                         iwe.u.data.length = len;
 662                         ev = iwe_stream_add_point(info, ev, stop, &iwe, buf);
 663                 }
 664         } else {
 665                 /* this scan info has IE data */
 666                 struct ie_info ie_info;
 667                 size_t data_len;
 668
 669                 data_len = be16_to_cpu(scan->size) - sizeof(*scan);
 670
 671                 gelic_wl_parse_ie(scan->elements, data_len, &ie_info);
 672
 673                 if (ie_info.wpa.len && (ie_info.wpa.len <= sizeof(buf))) {
 674                         memcpy(buf, ie_info.wpa.data, ie_info.wpa.len);
 675                         iwe.cmd = IWEVGENIE;
 676                         iwe.u.data.length = ie_info.wpa.len;
 677                         ev = iwe_stream_add_point(info, ev, stop, &iwe, buf);
 678                 }
 679
 680                 if (ie_info.rsn.len && (ie_info.rsn.len <= sizeof(buf))) {
 681                         memset(&iwe, 0, sizeof(iwe));
 682                         memcpy(buf, ie_info.rsn.data, ie_info.rsn.len);
 683                         iwe.cmd = IWEVGENIE;
 684                         iwe.u.data.length = ie_info.rsn.len;
 685                         ev = iwe_stream_add_point(info, ev, stop, &iwe, buf);
 686                 }
 687         }
 688
 689         pr_debug("%s: ->\n", __func__);
 690         return ev;
 691 }
 692
 693
 694 static int gelic_wl_get_scan(struct net_device *netdev,
 695                              struct iw_request_info *info,
 696                              union iwreq_data *wrqu, char *extra)
 697 {
 698         struct gelic_wl_info *wl = port_wl(netdev_priv(netdev));
 699         struct gelic_wl_scan_info *scan_info;
 700         char *ev = extra;
 701         char *stop = ev + wrqu->data.length;
 702         int ret = 0;
 703         unsigned long this_time = jiffies;
 704
 705         pr_debug("%s: <-\n", __func__);
 706         if (mutex_lock_interruptible(&wl->scan_lock))
 707                 return -EAGAIN;
 708
 709         switch (wl->scan_stat) {
 710         case GELIC_WL_SCAN_STAT_SCANNING:
 711                 /* If a scan in progress, caller should call me again */
 712                 ret = -EAGAIN;
 713                 goto out;
 714         case GELIC_WL_SCAN_STAT_INIT:
 715                 /* last scan request failed or never issued */
 716                 ret = -ENODEV;
 717                 goto out;
 718         case GELIC_WL_SCAN_STAT_GOT_LIST:
 719                 /* ok, use current list */
 720                 break;
 721         }
 722
 723         list_for_each_entry(scan_info, &wl->network_list, list) {
 724                 if (wl->scan_age == 0 ||
 725                     time_after(scan_info->last_scanned + wl->scan_age,
 726                                this_time))
 727                         ev = gelic_wl_translate_scan(netdev, info,
 728                                                      ev, stop,
 729                                                      scan_info);
 730                 else
 731                         pr_debug("%s:entry too old\n", __func__);
 732
 733                 if (stop - ev <= IW_EV_ADDR_LEN) {
 734                         ret = -E2BIG;
 735                         goto out;
 736                 }
 737         }
 738
 739         wrqu->data.length = ev - extra;
 740         wrqu->data.flags = 0;
 741 out:
 742         mutex_unlock(&wl->scan_lock);
 743         pr_debug("%s: -> %d %d\n", __func__, ret, wrqu->data.length);
 744         return ret;
 745 }
 746
 747 #ifdef DEBUG
 748 static void scan_list_dump(struct gelic_wl_info *wl)
 749 {
 750         struct gelic_wl_scan_info *scan_info;
 751         int i;
 752
 753         i = 0;
 754         list_for_each_entry(scan_info, &wl->network_list, list) {
 755                 pr_debug("%s: item %d\n", __func__, i++);
 756                 pr_debug("valid=%d eurusindex=%d last=%lx\n",
 757                          scan_info->valid, scan_info->eurus_index,
 758                          scan_info->last_scanned);
 759                 pr_debug("r_len=%d r_ext_len=%d essid_len=%d\n",
 760                          scan_info->rate_len, scan_info->rate_ext_len,
 761                          scan_info->essid_len);
 762                 /* -- */
 763                 pr_debug("bssid=%pM\n", &scan_info->hwinfo->bssid[2]);
 764                 pr_debug("essid=%s\n", scan_info->hwinfo->essid);
 765         }
 766 }
 767 #endif
 768
 769 static int gelic_wl_set_auth(struct net_device *netdev,
 770                              struct iw_request_info *info,
 771                              union iwreq_data *data, char *extra)
 772 {
 773         struct iw_param *param = &data->param;
 774         struct gelic_wl_info *wl = port_wl(netdev_port(netdev));
 775         unsigned long irqflag;
 776         int ret = 0;
 777
 778         pr_debug("%s: <- %d\n", __func__, param->flags & IW_AUTH_INDEX);
 779         spin_lock_irqsave(&wl->lock, irqflag);
 780         switch (param->flags & IW_AUTH_INDEX) {
 781         case IW_AUTH_WPA_VERSION:
 782                 if (param->value & IW_AUTH_WPA_VERSION_DISABLED) {
 783                         pr_debug("%s: NO WPA selected\n", __func__);
 784                         wl->wpa_level = GELIC_WL_WPA_LEVEL_NONE;
 785                         wl->group_cipher_method = GELIC_WL_CIPHER_WEP;
 786                         wl->pairwise_cipher_method = GELIC_WL_CIPHER_WEP;
 787                 }
 788                 if (param->value & IW_AUTH_WPA_VERSION_WPA) {
 789                         pr_debug("%s: WPA version 1 selected\n", __func__);
 790                         wl->wpa_level = GELIC_WL_WPA_LEVEL_WPA;
 791                         wl->group_cipher_method = GELIC_WL_CIPHER_TKIP;
 792                         wl->pairwise_cipher_method = GELIC_WL_CIPHER_TKIP;
 793                         wl->auth_method = GELIC_EURUS_AUTH_OPEN;
 794                 }
 795                 if (param->value & IW_AUTH_WPA_VERSION_WPA2) {
 796                         /*
 797                          * As the hypervisor may not tell the cipher
 798                          * information of the AP if it is WPA2,
 799                          * you will not decide suitable cipher from
 800                          * its beacon.
 801                          * You should have knowledge about the AP's
 802                          * cipher information in other method prior to
 803                          * the association.
 804                          */
 805                         if (!precise_ie())
 806                                 pr_info("%s: WPA2 may not work\n", __func__);
 807                         if (wpa2_capable()) {
 808                                 wl->wpa_level = GELIC_WL_WPA_LEVEL_WPA2;
 809                                 wl->group_cipher_method = GELIC_WL_CIPHER_AES;
 810                                 wl->pairwise_cipher_method =
 811                                         GELIC_WL_CIPHER_AES;
 812                                 wl->auth_method = GELIC_EURUS_AUTH_OPEN;
 813                         } else
 814                                 ret = -EINVAL;
 815                 }
 816                 break;
 817
 818         case IW_AUTH_CIPHER_PAIRWISE:
 819                 if (param->value &
 820                     (IW_AUTH_CIPHER_WEP104 | IW_AUTH_CIPHER_WEP40)) {
 821                         pr_debug("%s: WEP selected\n", __func__);
 822                         wl->pairwise_cipher_method = GELIC_WL_CIPHER_WEP;
 823                 }
 824                 if (param->value & IW_AUTH_CIPHER_TKIP) {
 825                         pr_debug("%s: TKIP selected\n", __func__);
 826                         wl->pairwise_cipher_method = GELIC_WL_CIPHER_TKIP;
 827                 }
 828                 if (param->value & IW_AUTH_CIPHER_CCMP) {
 829                         pr_debug("%s: CCMP selected\n", __func__);
 830                         wl->pairwise_cipher_method = GELIC_WL_CIPHER_AES;
 831                 }
 832                 if (param->value & IW_AUTH_CIPHER_NONE) {
 833                         pr_debug("%s: no auth selected\n", __func__);
 834                         wl->pairwise_cipher_method = GELIC_WL_CIPHER_NONE;
 835                 }
 836                 break;
 837         case IW_AUTH_CIPHER_GROUP:
 838                 if (param->value &
 839                     (IW_AUTH_CIPHER_WEP104 | IW_AUTH_CIPHER_WEP40)) {
 840                         pr_debug("%s: WEP selected\n", __func__);
 841                         wl->group_cipher_method = GELIC_WL_CIPHER_WEP;
 842                 }
 843                 if (param->value & IW_AUTH_CIPHER_TKIP) {
 844                         pr_debug("%s: TKIP selected\n", __func__);
 845                         wl->group_cipher_method = GELIC_WL_CIPHER_TKIP;
 846                 }
 847                 if (param->value & IW_AUTH_CIPHER_CCMP) {
 848                         pr_debug("%s: CCMP selected\n", __func__);
 849                         wl->group_cipher_method = GELIC_WL_CIPHER_AES;
 850                 }
 851                 if (param->value & IW_AUTH_CIPHER_NONE) {
 852                         pr_debug("%s: no auth selected\n", __func__);
 853                         wl->group_cipher_method = GELIC_WL_CIPHER_NONE;
 854                 }
 855                 break;
 856         case IW_AUTH_80211_AUTH_ALG:
 857                 if (param->value & IW_AUTH_ALG_SHARED_KEY) {
 858                         pr_debug("%s: shared key specified\n", __func__);
 859                         wl->auth_method = GELIC_EURUS_AUTH_SHARED;
 860                 } else if (param->value & IW_AUTH_ALG_OPEN_SYSTEM) {
 861                         pr_debug("%s: open system specified\n", __func__);
 862                         wl->auth_method = GELIC_EURUS_AUTH_OPEN;
 863                 } else
 864                         ret = -EINVAL;
 865                 break;
 866
 867         case IW_AUTH_WPA_ENABLED:
 868                 if (param->value) {
 869                         pr_debug("%s: WPA enabled\n", __func__);
 870                         wl->wpa_level = GELIC_WL_WPA_LEVEL_WPA;
 871                 } else {
 872                         pr_debug("%s: WPA disabled\n", __func__);
 873                         wl->wpa_level = GELIC_WL_WPA_LEVEL_NONE;
 874                 }
 875                 break;
 876
 877         case IW_AUTH_KEY_MGMT:
 878                 if (param->value & IW_AUTH_KEY_MGMT_PSK)
 879                         break;
 880                 /* intentionally fall through */
 881         default:
 882                 ret = -EOPNOTSUPP;
 883                 break;
 884         }
 885
 886         if (!ret)
 887                 set_bit(GELIC_WL_STAT_CONFIGURED, &wl->stat);
 888
 889         spin_unlock_irqrestore(&wl->lock, irqflag);
 890         pr_debug("%s: -> %d\n", __func__, ret);
 891         return ret;
 892 }
 893
 894 static int gelic_wl_get_auth(struct net_device *netdev,
 895                              struct iw_request_info *info,
 896                              union iwreq_data *iwreq, char *extra)
 897 {
 898         struct iw_param *param = &iwreq->param;
 899         struct gelic_wl_info *wl = port_wl(netdev_port(netdev));
 900         unsigned long irqflag;
 901         int ret = 0;
 902
 903         pr_debug("%s: <- %d\n", __func__, param->flags & IW_AUTH_INDEX);
 904         spin_lock_irqsave(&wl->lock, irqflag);
 905         switch (param->flags & IW_AUTH_INDEX) {
 906         case IW_AUTH_WPA_VERSION:
 907                 switch (wl->wpa_level) {
 908                 case GELIC_WL_WPA_LEVEL_WPA:
 909                         param->value |= IW_AUTH_WPA_VERSION_WPA;
 910                         break;
 911                 case GELIC_WL_WPA_LEVEL_WPA2:
 912                         param->value |= IW_AUTH_WPA_VERSION_WPA2;
 913                         break;
 914                 default:
 915                         param->value |= IW_AUTH_WPA_VERSION_DISABLED;
 916                 }
 917                 break;
 918
 919         case IW_AUTH_80211_AUTH_ALG:
 920                 if (wl->auth_method == GELIC_EURUS_AUTH_SHARED)
 921                         param->value = IW_AUTH_ALG_SHARED_KEY;
 922                 else if (wl->auth_method == GELIC_EURUS_AUTH_OPEN)
 923                         param->value = IW_AUTH_ALG_OPEN_SYSTEM;
 924                 break;
 925
 926         case IW_AUTH_WPA_ENABLED:
 927                 switch (wl->wpa_level) {
 928                 case GELIC_WL_WPA_LEVEL_WPA:
 929                 case GELIC_WL_WPA_LEVEL_WPA2:
 930                         param->value = 1;
 931                         break;
 932                 default:
 933                         param->value = 0;
 934                         break;
 935                 }
 936                 break;
 937         default:
 938                 ret = -EOPNOTSUPP;
 939         }
 940
 941         spin_unlock_irqrestore(&wl->lock, irqflag);
 942         pr_debug("%s: -> %d\n", __func__, ret);
 943         return ret;
 944 }
 945
 946 /* SIOC{S,G}IWESSID */
 947 static int gelic_wl_set_essid(struct net_device *netdev,
 948                               struct iw_request_info *info,
 949                               union iwreq_data *data, char *extra)
 950 {
 951         struct gelic_wl_info *wl = port_wl(netdev_priv(netdev));
 952         unsigned long irqflag;
 953
 954         pr_debug("%s: <- l=%d f=%d\n", __func__,
 955                  data->essid.length, data->essid.flags);
 956         if (IW_ESSID_MAX_SIZE < data->essid.length)
 957                 return -EINVAL;
 958
 959         spin_lock_irqsave(&wl->lock, irqflag);
 960         if (data->essid.flags) {
 961                 wl->essid_len = data->essid.length;
 962                 memcpy(wl->essid, extra, wl->essid_len);
 963                 pr_debug("%s: essid = '%s'\n", __func__, extra);
 964                 set_bit(GELIC_WL_STAT_ESSID_SET, &wl->stat);
 965         } else {
 966                 pr_debug("%s: ESSID any\n", __func__);
 967                 clear_bit(GELIC_WL_STAT_ESSID_SET, &wl->stat);
 968         }
 969         set_bit(GELIC_WL_STAT_CONFIGURED, &wl->stat);
 970         spin_unlock_irqrestore(&wl->lock, irqflag);
 971
 972
 973         gelic_wl_try_associate(netdev); /* FIXME */
 974         pr_debug("%s: ->\n", __func__);
 975         return 0;
 976 }
 977
 978 static int gelic_wl_get_essid(struct net_device *netdev,
 979                               struct iw_request_info *info,
 980                               union iwreq_data *data, char *extra)
 981 {
 982         struct gelic_wl_info *wl = port_wl(netdev_priv(netdev));
 983         unsigned long irqflag;
 984
 985         pr_debug("%s: <-\n", __func__);
 986         mutex_lock(&wl->assoc_stat_lock);
 987         spin_lock_irqsave(&wl->lock, irqflag);
 988         if (test_bit(GELIC_WL_STAT_ESSID_SET, &wl->stat) ||
 989             wl->assoc_stat == GELIC_WL_ASSOC_STAT_ASSOCIATED) {
 990                 memcpy(extra, wl->essid, wl->essid_len);
 991                 data->essid.length = wl->essid_len;
 992                 data->essid.flags = 1;
 993         } else
 994                 data->essid.flags = 0;
 995
 996         mutex_unlock(&wl->assoc_stat_lock);
 997         spin_unlock_irqrestore(&wl->lock, irqflag);
 998         pr_debug("%s: -> len=%d\n", __func__, data->essid.length);
 999
1000         return 0;
1001 }
1002
1003 /* SIO{S,G}IWENCODE */
1004 static int gelic_wl_set_encode(struct net_device *netdev,
1005                                struct iw_request_info *info,
1006                                union iwreq_data *data, char *extra)
1007 {
1008         struct gelic_wl_info *wl = port_wl(netdev_priv(netdev));
1009         struct iw_point *enc = &data->encoding;
1010         __u16 flags;
1011         unsigned long irqflag;
1012         int key_index, index_specified;
1013         int ret = 0;
1014
1015         pr_debug("%s: <-\n", __func__);
1016         flags = enc->flags & IW_ENCODE_FLAGS;
1017         key_index = enc->flags & IW_ENCODE_INDEX;
1018
1019         pr_debug("%s: key_index = %d\n", __func__, key_index);
1020         pr_debug("%s: key_len = %d\n", __func__, enc->length);
1021         pr_debug("%s: flag=%x\n", __func__, enc->flags & IW_ENCODE_FLAGS);
1022
1023         if (GELIC_WEP_KEYS < key_index)
1024                 return -EINVAL;
1025
1026         spin_lock_irqsave(&wl->lock, irqflag);
1027         if (key_index) {
1028                 index_specified = 1;
1029                 key_index--;
1030         } else {
1031                 index_specified = 0;
1032                 key_index = wl->current_key;
1033         }
1034
1035         if (flags & IW_ENCODE_NOKEY) {
1036                 /* if just IW_ENCODE_NOKEY, change current key index */
1037                 if (!flags && index_specified) {
1038                         wl->current_key = key_index;
1039                         goto done;
1040                 }
1041
1042                 if (flags & IW_ENCODE_DISABLED) {
1043                         if (!index_specified) {
1044                                 /* disable encryption */
1045                                 wl->group_cipher_method = GELIC_WL_CIPHER_NONE;
1046                                 wl->pairwise_cipher_method =
1047                                         GELIC_WL_CIPHER_NONE;
1048                                 /* invalidate all key */
1049                                 wl->key_enabled = 0;
1050                         } else
1051                                 clear_bit(key_index, &wl->key_enabled);
1052                 }
1053
1054                 if (flags & IW_ENCODE_OPEN)
1055                         wl->auth_method = GELIC_EURUS_AUTH_OPEN;
1056                 if (flags & IW_ENCODE_RESTRICTED) {
1057                         pr_info("%s: shared key mode enabled\n", __func__);
1058                         wl->auth_method = GELIC_EURUS_AUTH_SHARED;
1059                 }
1060         } else {
1061                 if (IW_ENCODING_TOKEN_MAX < enc->length) {
1062                         ret = -EINVAL;
1063                         goto done;
1064                 }
1065                 wl->key_len[key_index] = enc->length;
1066                 memcpy(wl->key[key_index], extra, enc->length);
1067                 set_bit(key_index, &wl->key_enabled);
1068                 wl->pairwise_cipher_method = GELIC_WL_CIPHER_WEP;
1069                 wl->group_cipher_method = GELIC_WL_CIPHER_WEP;
1070         }
1071         set_bit(GELIC_WL_STAT_CONFIGURED, &wl->stat);
1072 done:
1073         spin_unlock_irqrestore(&wl->lock, irqflag);
1074         pr_debug("%s: ->\n", __func__);
1075         return ret;
1076 }
1077
1078 static int gelic_wl_get_encode(struct net_device *netdev,
1079                                struct iw_request_info *info,
1080                                union iwreq_data *data, char *extra)
1081 {
1082         struct gelic_wl_info *wl = port_wl(netdev_priv(netdev));
1083         struct iw_point *enc = &data->encoding;
1084         unsigned long irqflag;
1085         unsigned int key_index;
1086         int ret = 0;
1087
1088         pr_debug("%s: <-\n", __func__);
1089         key_index = enc->flags & IW_ENCODE_INDEX;
1090         pr_debug("%s: flag=%#x point=%p len=%d extra=%p\n", __func__,
1091                  enc->flags, enc->pointer, enc->length, extra);
1092         if (GELIC_WEP_KEYS < key_index)
1093                 return -EINVAL;
1094
1095         spin_lock_irqsave(&wl->lock, irqflag);
1096         if (key_index)
1097                 key_index--;
1098         else
1099                 key_index = wl->current_key;
1100
1101         if (wl->group_cipher_method == GELIC_WL_CIPHER_WEP) {
1102                 switch (wl->auth_method) {
1103                 case GELIC_EURUS_AUTH_OPEN:
1104                         enc->flags = IW_ENCODE_OPEN;
1105                         break;
1106                 case GELIC_EURUS_AUTH_SHARED:
1107                         enc->flags = IW_ENCODE_RESTRICTED;
1108                         break;
1109                 }
1110         } else
1111                 enc->flags = IW_ENCODE_DISABLED;
1112
1113         if (test_bit(key_index, &wl->key_enabled)) {
1114                 if (enc->length < wl->key_len[key_index]) {
1115                         ret = -EINVAL;
1116                         goto done;
1117                 }
1118                 enc->length = wl->key_len[key_index];
1119                 memcpy(extra, wl->key[key_index], wl->key_len[key_index]);
1120         } else {
1121                 enc->length = 0;
1122                 enc->flags |= IW_ENCODE_NOKEY;
1123         }
1124         enc->flags |= key_index + 1;
1125         pr_debug("%s: -> flag=%x len=%d\n", __func__,
1126                  enc->flags, enc->length);
1127
1128 done:
1129         spin_unlock_irqrestore(&wl->lock, irqflag);
1130         return ret;
1131 }
1132
1133 /* SIOC{S,G}IWAP */
1134 static int gelic_wl_set_ap(struct net_device *netdev,
1135                            struct iw_request_info *info,
1136                            union iwreq_data *data, char *extra)
1137 {
1138         struct gelic_wl_info *wl = port_wl(netdev_priv(netdev));
1139         unsigned long irqflag;
1140
1141         pr_debug("%s: <-\n", __func__);
1142         if (data->ap_addr.sa_family != ARPHRD_ETHER)
1143                 return -EINVAL;
1144
1145         spin_lock_irqsave(&wl->lock, irqflag);
1146         if (is_valid_ether_addr(data->ap_addr.sa_data)) {
1147                 memcpy(wl->bssid, data->ap_addr.sa_data,
1148                        ETH_ALEN);
1149                 set_bit(GELIC_WL_STAT_BSSID_SET, &wl->stat);
1150                 set_bit(GELIC_WL_STAT_CONFIGURED, &wl->stat);
1151                 pr_debug("%s: bss=%pM\n", __func__, wl->bssid);
1152         } else {
1153                 pr_debug("%s: clear bssid\n", __func__);
1154                 clear_bit(GELIC_WL_STAT_BSSID_SET, &wl->stat);
1155                 eth_zero_addr(wl->bssid);
1156         }
1157         spin_unlock_irqrestore(&wl->lock, irqflag);
1158         pr_debug("%s: ->\n", __func__);
1159         return 0;
1160 }
1161
1162 static int gelic_wl_get_ap(struct net_device *netdev,
1163                            struct iw_request_info *info,
1164                            union iwreq_data *data, char *extra)
1165 {
1166         struct gelic_wl_info *wl = port_wl(netdev_priv(netdev));
1167         unsigned long irqflag;
1168
1169         pr_debug("%s: <-\n", __func__);
1170         mutex_lock(&wl->assoc_stat_lock);
1171         spin_lock_irqsave(&wl->lock, irqflag);
1172         if (wl->assoc_stat == GELIC_WL_ASSOC_STAT_ASSOCIATED) {
1173                 data->ap_addr.sa_family = ARPHRD_ETHER;
1174                 memcpy(data->ap_addr.sa_data, wl->active_bssid,
1175                        ETH_ALEN);
1176         } else
1177                 eth_zero_addr(data->ap_addr.sa_data);
1178
1179         spin_unlock_irqrestore(&wl->lock, irqflag);
1180         mutex_unlock(&wl->assoc_stat_lock);
1181         pr_debug("%s: ->\n", __func__);
1182         return 0;
1183 }
1184
1185 /* SIOC{S,G}IWENCODEEXT */
1186 static int gelic_wl_set_encodeext(struct net_device *netdev,
1187                                   struct iw_request_info *info,
1188                                   union iwreq_data *data, char *extra)
1189 {
1190         struct gelic_wl_info *wl = port_wl(netdev_priv(netdev));
1191         struct iw_point *enc = &data->encoding;
1192         struct iw_encode_ext *ext = (struct iw_encode_ext *)extra;
1193         __u16 alg;
1194         __u16 flags;
1195         unsigned long irqflag;
1196         int key_index;
1197         int ret = 0;
1198
1199         pr_debug("%s: <-\n", __func__);
1200         flags = enc->flags & IW_ENCODE_FLAGS;
1201         alg = ext->alg;
1202         key_index = enc->flags & IW_ENCODE_INDEX;
1203
1204         pr_debug("%s: key_index = %d\n", __func__, key_index);
1205         pr_debug("%s: key_len = %d\n", __func__, enc->length);
1206         pr_debug("%s: flag=%x\n", __func__, enc->flags & IW_ENCODE_FLAGS);
1207         pr_debug("%s: ext_flag=%x\n", __func__, ext->ext_flags);
1208         pr_debug("%s: ext_key_len=%x\n", __func__, ext->key_len);
1209
1210         if (GELIC_WEP_KEYS < key_index)
1211                 return -EINVAL;
1212
1213         spin_lock_irqsave(&wl->lock, irqflag);
1214         if (key_index)
1215                 key_index--;
1216         else
1217                 key_index = wl->current_key;
1218
1219         if (!enc->length && (ext->ext_flags & IW_ENCODE_EXT_SET_TX_KEY)) {
1220                 /* reques to change default key index */
1221                 pr_debug("%s: request to change default key to %d\n",
1222                          __func__, key_index);
1223                 wl->current_key = key_index;
1224                 goto done;
1225         }
1226
1227         if (alg == IW_ENCODE_ALG_NONE || (flags & IW_ENCODE_DISABLED)) {
1228                 pr_debug("%s: alg disabled\n", __func__);
1229                 wl->wpa_level = GELIC_WL_WPA_LEVEL_NONE;
1230                 wl->group_cipher_method = GELIC_WL_CIPHER_NONE;
1231                 wl->pairwise_cipher_method = GELIC_WL_CIPHER_NONE;
1232                 wl->auth_method = GELIC_EURUS_AUTH_OPEN; /* should be open */
1233         } else if (alg == IW_ENCODE_ALG_WEP) {
1234                 pr_debug("%s: WEP requested\n", __func__);
1235                 if (flags & IW_ENCODE_OPEN) {
1236                         pr_debug("%s: open key mode\n", __func__);
1237                         wl->auth_method = GELIC_EURUS_AUTH_OPEN;
1238                 }
1239                 if (flags & IW_ENCODE_RESTRICTED) {
1240                         pr_debug("%s: shared key mode\n", __func__);
1241                         wl->auth_method = GELIC_EURUS_AUTH_SHARED;
1242                 }
1243                 if (IW_ENCODING_TOKEN_MAX < ext->key_len) {
1244                         pr_info("%s: key is too long %d\n", __func__,
1245                                 ext->key_len);
1246                         ret = -EINVAL;
1247                         goto done;
1248                 }
1249                 /* OK, update the key */
1250                 wl->key_len[key_index] = ext->key_len;
1251                 memset(wl->key[key_index], 0, IW_ENCODING_TOKEN_MAX);
1252                 memcpy(wl->key[key_index], ext->key, ext->key_len);
1253                 set_bit(key_index, &wl->key_enabled);
1254                 /* remember wep info changed */
1255                 set_bit(GELIC_WL_STAT_CONFIGURED, &wl->stat);
1256         } else if (alg == IW_ENCODE_ALG_PMK) {
1257                 if (ext->key_len != WPA_PSK_LEN) {
1258                         pr_err("%s: PSK length wrong %d\n", __func__,
1259                                ext->key_len);
1260                         ret = -EINVAL;
1261                         goto done;
1262                 }
1263                 memset(wl->psk, 0, sizeof(wl->psk));
1264                 memcpy(wl->psk, ext->key, ext->key_len);
1265                 wl->psk_len = ext->key_len;
1266                 wl->psk_type = GELIC_EURUS_WPA_PSK_BIN;
1267                 /* remember PSK configured */
1268                 set_bit(GELIC_WL_STAT_WPA_PSK_SET, &wl->stat);
1269         }
1270 done:
1271         spin_unlock_irqrestore(&wl->lock, irqflag);
1272         pr_debug("%s: ->\n", __func__);
1273         return ret;
1274 }
1275
1276 static int gelic_wl_get_encodeext(struct net_device *netdev,
1277                                   struct iw_request_info *info,
1278                                   union iwreq_data *data, char *extra)
1279 {
1280         struct gelic_wl_info *wl = port_wl(netdev_priv(netdev));
1281         struct iw_point *enc = &data->encoding;
1282         struct iw_encode_ext *ext = (struct iw_encode_ext *)extra;
1283         unsigned long irqflag;
1284         int key_index;
1285         int ret = 0;
1286         int max_key_len;
1287
1288         pr_debug("%s: <-\n", __func__);
1289
1290         max_key_len = enc->length - sizeof(struct iw_encode_ext);
1291         if (max_key_len < 0)
1292                 return -EINVAL;
1293         key_index = enc->flags & IW_ENCODE_INDEX;
1294
1295         pr_debug("%s: key_index = %d\n", __func__, key_index);
1296         pr_debug("%s: key_len = %d\n", __func__, enc->length);
1297         pr_debug("%s: flag=%x\n", __func__, enc->flags & IW_ENCODE_FLAGS);
1298
1299         if (GELIC_WEP_KEYS < key_index)
1300                 return -EINVAL;
1301
1302         spin_lock_irqsave(&wl->lock, irqflag);
1303         if (key_index)
1304                 key_index--;
1305         else
1306                 key_index = wl->current_key;
1307
1308         memset(ext, 0, sizeof(struct iw_encode_ext));
1309         switch (wl->group_cipher_method) {
1310         case GELIC_WL_CIPHER_WEP:
1311                 ext->alg = IW_ENCODE_ALG_WEP;
1312                 enc->flags |= IW_ENCODE_ENABLED;
1313                 break;
1314         case GELIC_WL_CIPHER_TKIP:
1315                 ext->alg = IW_ENCODE_ALG_TKIP;
1316                 enc->flags |= IW_ENCODE_ENABLED;
1317                 break;
1318         case GELIC_WL_CIPHER_AES:
1319                 ext->alg = IW_ENCODE_ALG_CCMP;
1320                 enc->flags |= IW_ENCODE_ENABLED;
1321                 break;
1322         case GELIC_WL_CIPHER_NONE:
1323         default:
1324                 ext->alg = IW_ENCODE_ALG_NONE;
1325                 enc->flags |= IW_ENCODE_NOKEY;
1326                 break;
1327         }
1328
1329         if (!(enc->flags & IW_ENCODE_NOKEY)) {
1330                 if (max_key_len < wl->key_len[key_index]) {
1331                         ret = -E2BIG;
1332                         goto out;
1333                 }
1334                 if (test_bit(key_index, &wl->key_enabled))
1335                         memcpy(ext->key, wl->key[key_index],
1336                                wl->key_len[key_index]);
1337                 else
1338                         pr_debug("%s: disabled key requested ix=%d\n",
1339                                  __func__, key_index);
1340         }
1341 out:
1342         spin_unlock_irqrestore(&wl->lock, irqflag);
1343         pr_debug("%s: ->\n", __func__);
1344         return ret;
1345 }
1346 /* SIOC{S,G}IWMODE */
1347 static int gelic_wl_set_mode(struct net_device *netdev,
1348                              struct iw_request_info *info,
1349                              union iwreq_data *data, char *extra)
1350 {
1351         __u32 mode = data->mode;
1352         int ret;
1353
1354         pr_debug("%s: <-\n", __func__);
1355         if (mode == IW_MODE_INFRA)
1356                 ret = 0;
1357         else
1358                 ret = -EOPNOTSUPP;
1359         pr_debug("%s: -> %d\n", __func__, ret);
1360         return ret;
1361 }
1362
1363 static int gelic_wl_get_mode(struct net_device *netdev,
1364                              struct iw_request_info *info,
1365                              union iwreq_data *data, char *extra)
1366 {
1367         __u32 *mode = &data->mode;
1368         pr_debug("%s: <-\n", __func__);
1369         *mode = IW_MODE_INFRA;
1370         pr_debug("%s: ->\n", __func__);
1371         return 0;
1372 }
1373
1374 /* SIOCGIWNICKN */
1375 static int gelic_wl_get_nick(struct net_device *net_dev,
1376                                   struct iw_request_info *info,
1377                                   union iwreq_data *data, char *extra)
1378 {
1379         strcpy(extra, "gelic_wl");
1380         data->data.length = strlen(extra);
1381         data->data.flags = 1;
1382         return 0;
1383 }
1384
1385
1386 /* --- */
1387
1388 static struct iw_statistics *gelic_wl_get_wireless_stats(
1389         struct net_device *netdev)
1390 {
1391
1392         struct gelic_wl_info *wl = port_wl(netdev_priv(netdev));
1393         struct gelic_eurus_cmd *cmd;
1394         struct iw_statistics *is;
1395         struct gelic_eurus_rssi_info *rssi;
1396         void *buf;
1397
1398         pr_debug("%s: <-\n", __func__);
1399
1400         buf = (void *)__get_free_page(GFP_KERNEL);
1401         if (!buf)
1402                 return NULL;
1403
1404         is = &wl->iwstat;
1405         memset(is, 0, sizeof(*is));
1406         cmd = gelic_eurus_sync_cmd(wl, GELIC_EURUS_CMD_GET_RSSI_CFG,
1407                                    buf, sizeof(*rssi));
1408         if (cmd && !cmd->status && !cmd->cmd_status) {
1409                 rssi = buf;
1410                 is->qual.level = be16_to_cpu(rssi->rssi);
1411                 is->qual.updated = IW_QUAL_LEVEL_UPDATED |
1412                         IW_QUAL_QUAL_INVALID | IW_QUAL_NOISE_INVALID;
1413         } else
1414                 /* not associated */
1415                 is->qual.updated = IW_QUAL_ALL_INVALID;
1416
1417         kfree(cmd);
1418         free_page((unsigned long)buf);
1419         pr_debug("%s: ->\n", __func__);
1420         return is;
1421 }
1422
1423 /*
1424  *  scanning helpers
1425  */
1426 static int gelic_wl_start_scan(struct gelic_wl_info *wl, int always_scan,
1427                                u8 *essid, size_t essid_len)
1428 {
1429         struct gelic_eurus_cmd *cmd;
1430         int ret = 0;
1431         void *buf = NULL;
1432         size_t len;
1433
1434         pr_debug("%s: <- always=%d\n", __func__, always_scan);
1435         if (mutex_lock_interruptible(&wl->scan_lock))
1436                 return -ERESTARTSYS;
1437
1438         /*
1439          * If already a scan in progress, do not trigger more
1440          */
1441         if (wl->scan_stat == GELIC_WL_SCAN_STAT_SCANNING) {
1442                 pr_debug("%s: scanning now\n", __func__);
1443                 goto out;
1444         }
1445
1446         init_completion(&wl->scan_done);
1447         /*
1448          * If we have already a bss list, don't try to get new
1449          * unless we are doing an ESSID scan
1450          */
1451         if ((!essid_len && !always_scan)
1452             && wl->scan_stat == GELIC_WL_SCAN_STAT_GOT_LIST) {
1453                 pr_debug("%s: already has the list\n", __func__);
1454                 complete(&wl->scan_done);
1455                 goto out;
1456         }
1457
1458         /* ESSID scan ? */
1459         if (essid_len && essid) {
1460                 buf = (void *)__get_free_page(GFP_KERNEL);
1461                 if (!buf) {
1462                         ret = -ENOMEM;
1463                         goto out;
1464                 }
1465                 len = IW_ESSID_MAX_SIZE; /* hypervisor always requires 32 */
1466                 memset(buf, 0, len);
1467                 memcpy(buf, essid, essid_len);
1468                 pr_debug("%s: essid scan='%s'\n", __func__, (char *)buf);
1469         } else
1470                 len = 0;
1471
1472         /*
1473          * issue start scan request
1474          */
1475         wl->scan_stat = GELIC_WL_SCAN_STAT_SCANNING;
1476         cmd = gelic_eurus_sync_cmd(wl, GELIC_EURUS_CMD_START_SCAN,
1477                                    buf, len);
1478         if (!cmd || cmd->status || cmd->cmd_status) {
1479                 wl->scan_stat = GELIC_WL_SCAN_STAT_INIT;
1480                 complete(&wl->scan_done);
1481                 ret = -ENOMEM;
1482                 goto out;
1483         }
1484         kfree(cmd);
1485 out:
1486         free_page((unsigned long)buf);
1487         mutex_unlock(&wl->scan_lock);
1488         pr_debug("%s: ->\n", __func__);
1489         return ret;
1490 }
1491
1492 /*
1493  * retrieve scan result from the chip (hypervisor)
1494  * this function is invoked by schedule work.
1495  */
1496 static void gelic_wl_scan_complete_event(struct gelic_wl_info *wl)
1497 {
1498         struct gelic_eurus_cmd *cmd = NULL;
1499         struct gelic_wl_scan_info *target, *tmp;
1500         struct gelic_wl_scan_info *oldest = NULL;
1501         struct gelic_eurus_scan_info *scan_info;
1502         unsigned int scan_info_size;
1503         union iwreq_data data;
1504         unsigned long this_time = jiffies;
1505         unsigned int data_len, i, found, r;
1506         void *buf;
1507
1508         pr_debug("%s:start\n", __func__);
1509         mutex_lock(&wl->scan_lock);
1510
1511         buf = (void *)__get_free_page(GFP_KERNEL);
1512         if (!buf) {
1513                 pr_info("%s: scan buffer alloc failed\n", __func__);
1514                 goto out;
1515         }
1516
1517         if (wl->scan_stat != GELIC_WL_SCAN_STAT_SCANNING) {
1518                 /*
1519                  * stop() may be called while scanning, ignore result
1520                  */
1521                 pr_debug("%s: scan complete when stat != scanning(%d)\n",
1522                          __func__, wl->scan_stat);
1523                 goto out;
1524         }
1525
1526         cmd = gelic_eurus_sync_cmd(wl, GELIC_EURUS_CMD_GET_SCAN,
1527                                    buf, PAGE_SIZE);
1528         if (!cmd || cmd->status || cmd->cmd_status) {
1529                 wl->scan_stat = GELIC_WL_SCAN_STAT_INIT;
1530                 pr_info("%s:cmd failed\n", __func__);
1531                 kfree(cmd);
1532                 goto out;
1533         }
1534         data_len = cmd->size;
1535         pr_debug("%s: data_len = %d\n", __func__, data_len);
1536         kfree(cmd);
1537
1538         /* OK, bss list retrieved */
1539         wl->scan_stat = GELIC_WL_SCAN_STAT_GOT_LIST;
1540
1541         /* mark all entries are old */
1542         list_for_each_entry_safe(target, tmp, &wl->network_list, list) {
1543                 target->valid = 0;
1544                 /* expire too old entries */
1545                 if (time_before(target->last_scanned + wl->scan_age,
1546                                 this_time)) {
1547                         kfree(target->hwinfo);
1548                         target->hwinfo = NULL;
1549                         list_move_tail(&target->list, &wl->network_free_list);
1550                 }
1551         }
1552
1553         /* put them in the network_list */
1554         for (i = 0, scan_info_size = 0, scan_info = buf;
1555              scan_info_size < data_len;
1556              i++, scan_info_size += be16_to_cpu(scan_info->size),
1557              scan_info = (void *)scan_info + be16_to_cpu(scan_info->size)) {
1558                 pr_debug("%s:size=%d bssid=%pM scan_info=%p\n", __func__,
1559                          be16_to_cpu(scan_info->size),
1560                          &scan_info->bssid[2], scan_info);
1561
1562                 /*
1563                  * The wireless firmware may return invalid channel 0 and/or
1564                  * invalid rate if the AP emits zero length SSID ie. As this
1565                  * scan information is useless, ignore it
1566                  */
1567                 if (!be16_to_cpu(scan_info->channel) || !scan_info->rate[0]) {
1568                         pr_debug("%s: invalid scan info\n", __func__);
1569                         continue;
1570                 }
1571
1572                 found = 0;
1573                 oldest = NULL;
1574                 list_for_each_entry(target, &wl->network_list, list) {
1575                         if (ether_addr_equal(&target->hwinfo->bssid[2],
1576                                              &scan_info->bssid[2])) {
1577                                 found = 1;
1578                                 pr_debug("%s: same BBS found scanned list\n",
1579                                          __func__);
1580                                 break;
1581                         }
1582                         if (!oldest ||
1583                             (target->last_scanned < oldest->last_scanned))
1584                                 oldest = target;
1585                 }
1586
1587                 if (!found) {
1588                         /* not found in the list */
1589                         if (list_empty(&wl->network_free_list)) {
1590                                 /* expire oldest */
1591                                 target = oldest;
1592                         } else {
1593                                 target = list_entry(wl->network_free_list.next,
1594                                                     struct gelic_wl_scan_info,
1595                                                     list);
1596                         }
1597                 }
1598
1599                 /* update the item */
1600                 target->last_scanned = this_time;
1601                 target->valid = 1;
1602                 target->eurus_index = i;
1603                 kfree(target->hwinfo);
1604                 target->hwinfo = kmemdup(scan_info,
1605                                          be16_to_cpu(scan_info->size),
1606                                          GFP_KERNEL);
1607                 if (!target->hwinfo)
1608                         continue;
1609
1610                 /* copy hw scan info */
1611                 target->essid_len = strnlen(scan_info->essid,
1612                                             sizeof(scan_info->essid));
1613                 target->rate_len = 0;
1614                 for (r = 0; r < 12; r++)
1615                         if (scan_info->rate[r])
1616                                 target->rate_len++;
1617                 if (8 < target->rate_len)
1618                         pr_info("%s: AP returns %d rates\n", __func__,
1619                                 target->rate_len);
1620                 target->rate_ext_len = 0;
1621                 for (r = 0; r < 16; r++)
1622                         if (scan_info->ext_rate[r])
1623                                 target->rate_ext_len++;
1624                 list_move_tail(&target->list, &wl->network_list);
1625         }
1626         memset(&data, 0, sizeof(data));
1627         wireless_send_event(port_to_netdev(wl_port(wl)), SIOCGIWSCAN, &data,
1628                             NULL);
1629 out:
1630         free_page((unsigned long)buf);
1631         complete(&wl->scan_done);
1632         mutex_unlock(&wl->scan_lock);
1633         pr_debug("%s:end\n", __func__);
1634 }
1635
1636 /*
1637  * Select an appropriate bss from current scan list regarding
1638  * current settings from userspace.
1639  * The caller must hold wl->scan_lock,
1640  * and on the state of wl->scan_state == GELIC_WL_SCAN_GOT_LIST
1641  */
1642 static void update_best(struct gelic_wl_scan_info **best,
1643                         struct gelic_wl_scan_info *candid,
1644                         int *best_weight,
1645                         int *weight)
1646 {
1647         if (*best_weight < ++(*weight)) {
1648                 *best_weight = *weight;
1649                 *best = candid;
1650         }
1651 }
1652
1653 static
1654 struct gelic_wl_scan_info *gelic_wl_find_best_bss(struct gelic_wl_info *wl)
1655 {
1656         struct gelic_wl_scan_info *scan_info;
1657         struct gelic_wl_scan_info *best_bss;
1658         int weight, best_weight;
1659         u16 security;
1660
1661         pr_debug("%s: <-\n", __func__);
1662
1663         best_bss = NULL;
1664         best_weight = 0;
1665
1666         list_for_each_entry(scan_info, &wl->network_list, list) {
1667                 pr_debug("%s: station %p\n", __func__, scan_info);
1668
1669                 if (!scan_info->valid) {
1670                         pr_debug("%s: station invalid\n", __func__);
1671                         continue;
1672                 }
1673
1674                 /* If bss specified, check it only */
1675                 if (test_bit(GELIC_WL_STAT_BSSID_SET, &wl->stat)) {
1676                         if (ether_addr_equal(&scan_info->hwinfo->bssid[2],
1677                                              wl->bssid)) {
1678                                 best_bss = scan_info;
1679                                 pr_debug("%s: bssid matched\n", __func__);
1680                                 break;
1681                         } else {
1682                                 pr_debug("%s: bssid unmatched\n", __func__);
1683                                 continue;
1684                         }
1685                 }
1686
1687                 weight = 0;
1688
1689                 /* security */
1690                 security = be16_to_cpu(scan_info->hwinfo->security) &
1691                         GELIC_EURUS_SCAN_SEC_MASK;
1692                 if (wl->wpa_level == GELIC_WL_WPA_LEVEL_WPA2) {
1693                         if (security == GELIC_EURUS_SCAN_SEC_WPA2)
1694                                 update_best(&best_bss, scan_info,
1695                                             &best_weight, &weight);
1696                         else
1697                                 continue;
1698                 } else if (wl->wpa_level == GELIC_WL_WPA_LEVEL_WPA) {
1699                         if (security == GELIC_EURUS_SCAN_SEC_WPA)
1700                                 update_best(&best_bss, scan_info,
1701                                             &best_weight, &weight);
1702                         else
1703                                 continue;
1704                 } else if (wl->wpa_level == GELIC_WL_WPA_LEVEL_NONE &&
1705                            wl->group_cipher_method == GELIC_WL_CIPHER_WEP) {
1706                         if (security == GELIC_EURUS_SCAN_SEC_WEP)
1707                                 update_best(&best_bss, scan_info,
1708                                             &best_weight, &weight);
1709                         else
1710                                 continue;
1711                 }
1712
1713                 /* If ESSID is set, check it */
1714                 if (test_bit(GELIC_WL_STAT_ESSID_SET, &wl->stat)) {
1715                         if ((scan_info->essid_len == wl->essid_len) &&
1716                             !strncmp(wl->essid,
1717                                      scan_info->hwinfo->essid,
1718                                      scan_info->essid_len))
1719                                 update_best(&best_bss, scan_info,
1720                                             &best_weight, &weight);
1721                         else
1722                                 continue;
1723                 }
1724         }
1725
1726 #ifdef DEBUG
1727         pr_debug("%s: -> bss=%p\n", __func__, best_bss);
1728         if (best_bss) {
1729                 pr_debug("%s:addr=%pM\n", __func__,
1730                          &best_bss->hwinfo->bssid[2]);
1731         }
1732 #endif
1733         return best_bss;
1734 }
1735
1736 /*
1737  * Setup WEP configuration to the chip
1738  * The caller must hold wl->scan_lock,
1739  * and on the state of wl->scan_state == GELIC_WL_SCAN_GOT_LIST
1740  */
1741 static int gelic_wl_do_wep_setup(struct gelic_wl_info *wl)
1742 {
1743         unsigned int i;
1744         struct gelic_eurus_wep_cfg *wep;
1745         struct gelic_eurus_cmd *cmd;
1746         int wep104 = 0;
1747         int have_key = 0;
1748         int ret = 0;
1749
1750         pr_debug("%s: <-\n", __func__);
1751         /* we can assume no one should uses the buffer */
1752         wep = (struct gelic_eurus_wep_cfg *)__get_free_page(GFP_KERNEL);
1753         if (!wep)
1754                 return -ENOMEM;
1755
1756         memset(wep, 0, sizeof(*wep));
1757
1758         if (wl->group_cipher_method == GELIC_WL_CIPHER_WEP) {
1759                 pr_debug("%s: WEP mode\n", __func__);
1760                 for (i = 0; i < GELIC_WEP_KEYS; i++) {
1761                         if (!test_bit(i, &wl->key_enabled))
1762                                 continue;
1763
1764                         pr_debug("%s: key#%d enabled\n", __func__, i);
1765                         have_key = 1;
1766                         if (wl->key_len[i] == 13)
1767                                 wep104 = 1;
1768                         else if (wl->key_len[i] != 5) {
1769                                 pr_info("%s: wrong wep key[%d]=%d\n",
1770                                         __func__, i, wl->key_len[i]);
1771                                 ret = -EINVAL;
1772                                 goto out;
1773                         }
1774                         memcpy(wep->key[i], wl->key[i], wl->key_len[i]);
1775                 }
1776
1777                 if (!have_key) {
1778                         pr_info("%s: all wep key disabled\n", __func__);
1779                         ret = -EINVAL;
1780                         goto out;
1781                 }
1782
1783                 if (wep104) {
1784                         pr_debug("%s: 104bit key\n", __func__);
1785                         wep->security = cpu_to_be16(GELIC_EURUS_WEP_SEC_104BIT);
1786                 } else {
1787                         pr_debug("%s: 40bit key\n", __func__);
1788                         wep->security = cpu_to_be16(GELIC_EURUS_WEP_SEC_40BIT);
1789                 }
1790         } else {
1791                 pr_debug("%s: NO encryption\n", __func__);
1792                 wep->security = cpu_to_be16(GELIC_EURUS_WEP_SEC_NONE);
1793         }
1794
1795         /* issue wep setup */
1796         cmd = gelic_eurus_sync_cmd(wl, GELIC_EURUS_CMD_SET_WEP_CFG,
1797                                    wep, sizeof(*wep));
1798         if (!cmd)
1799                 ret = -ENOMEM;
1800         else if (cmd->status || cmd->cmd_status)
1801                 ret = -ENXIO;
1802
1803         kfree(cmd);
1804 out:
1805         free_page((unsigned long)wep);
1806         pr_debug("%s: ->\n", __func__);
1807         return ret;
1808 }
1809
1810 #ifdef DEBUG
1811 static const char *wpasecstr(enum gelic_eurus_wpa_security sec)
1812 {
1813         switch (sec) {
1814         case GELIC_EURUS_WPA_SEC_NONE:
1815                 return "NONE";
1816         case GELIC_EURUS_WPA_SEC_WPA_TKIP_TKIP:
1817                 return "WPA_TKIP_TKIP";
1818         case GELIC_EURUS_WPA_SEC_WPA_TKIP_AES:
1819                 return "WPA_TKIP_AES";
1820         case GELIC_EURUS_WPA_SEC_WPA_AES_AES:
1821                 return "WPA_AES_AES";
1822         case GELIC_EURUS_WPA_SEC_WPA2_TKIP_TKIP:
1823                 return "WPA2_TKIP_TKIP";
1824         case GELIC_EURUS_WPA_SEC_WPA2_TKIP_AES:
1825                 return "WPA2_TKIP_AES";
1826         case GELIC_EURUS_WPA_SEC_WPA2_AES_AES:
1827                 return "WPA2_AES_AES";
1828         }
1829         return "";
1830 };
1831 #endif
1832
1833 static int gelic_wl_do_wpa_setup(struct gelic_wl_info *wl)
1834 {
1835         struct gelic_eurus_wpa_cfg *wpa;
1836         struct gelic_eurus_cmd *cmd;
1837         u16 security;
1838         int ret = 0;
1839
1840         pr_debug("%s: <-\n", __func__);
1841         /* we can assume no one should uses the buffer */
1842         wpa = (struct gelic_eurus_wpa_cfg *)__get_free_page(GFP_KERNEL);
1843         if (!wpa)
1844                 return -ENOMEM;
1845
1846         memset(wpa, 0, sizeof(*wpa));
1847
1848         if (!test_bit(GELIC_WL_STAT_WPA_PSK_SET, &wl->stat))
1849                 pr_info("%s: PSK not configured yet\n", __func__);
1850
1851         /* copy key */
1852         memcpy(wpa->psk, wl->psk, wl->psk_len);
1853
1854         /* set security level */
1855         if (wl->wpa_level == GELIC_WL_WPA_LEVEL_WPA2) {
1856                 if (wl->group_cipher_method == GELIC_WL_CIPHER_AES) {
1857                         security = GELIC_EURUS_WPA_SEC_WPA2_AES_AES;
1858                 } else {
1859                         if (wl->pairwise_cipher_method == GELIC_WL_CIPHER_AES &&
1860                             precise_ie())
1861                                 security = GELIC_EURUS_WPA_SEC_WPA2_TKIP_AES;
1862                         else
1863                                 security = GELIC_EURUS_WPA_SEC_WPA2_TKIP_TKIP;
1864                 }
1865         } else {
1866                 if (wl->group_cipher_method == GELIC_WL_CIPHER_AES) {
1867                         security = GELIC_EURUS_WPA_SEC_WPA_AES_AES;
1868                 } else {
1869                         if (wl->pairwise_cipher_method == GELIC_WL_CIPHER_AES &&
1870                             precise_ie())
1871                                 security = GELIC_EURUS_WPA_SEC_WPA_TKIP_AES;
1872                         else
1873                                 security = GELIC_EURUS_WPA_SEC_WPA_TKIP_TKIP;
1874                 }
1875         }
1876         wpa->security = cpu_to_be16(security);
1877
1878         /* PSK type */
1879         wpa->psk_type = cpu_to_be16(wl->psk_type);
1880 #ifdef DEBUG
1881         pr_debug("%s: sec=%s psktype=%s\n", __func__,
1882                  wpasecstr(wpa->security),
1883                  (wpa->psk_type == GELIC_EURUS_WPA_PSK_BIN) ?
1884                  "BIN" : "passphrase");
1885 #if 0
1886         /*
1887          * don't enable here if you plan to submit
1888          * the debug log because this dumps your precious
1889          * passphrase/key.
1890          */
1891         pr_debug("%s: psk=%s\n", __func__,
1892                  (wpa->psk_type == GELIC_EURUS_WPA_PSK_BIN) ?
1893                  "N/A" : wpa->psk);
1894 #endif
1895 #endif
1896         /* issue wpa setup */
1897         cmd = gelic_eurus_sync_cmd(wl, GELIC_EURUS_CMD_SET_WPA_CFG,
1898                                    wpa, sizeof(*wpa));
1899         if (!cmd)
1900                 ret = -ENOMEM;
1901         else if (cmd->status || cmd->cmd_status)
1902                 ret = -ENXIO;
1903         kfree(cmd);
1904         free_page((unsigned long)wpa);
1905         pr_debug("%s: --> %d\n", __func__, ret);
1906         return ret;
1907 }
1908
1909 /*
1910  * Start association. caller must hold assoc_stat_lock
1911  */
1912 static int gelic_wl_associate_bss(struct gelic_wl_info *wl,
1913                                   struct gelic_wl_scan_info *bss)
1914 {
1915         struct gelic_eurus_cmd *cmd;
1916         struct gelic_eurus_common_cfg *common;
1917         int ret = 0;
1918         unsigned long rc;
1919
1920         pr_debug("%s: <-\n", __func__);
1921
1922         /* do common config */
1923         common = (struct gelic_eurus_common_cfg *)__get_free_page(GFP_KERNEL);
1924         if (!common)
1925                 return -ENOMEM;
1926
1927         memset(common, 0, sizeof(*common));
1928         common->bss_type = cpu_to_be16(GELIC_EURUS_BSS_INFRA);
1929         common->op_mode = cpu_to_be16(GELIC_EURUS_OPMODE_11BG);
1930
1931         common->scan_index = cpu_to_be16(bss->eurus_index);
1932         switch (wl->auth_method) {
1933         case GELIC_EURUS_AUTH_OPEN:
1934                 common->auth_method = cpu_to_be16(GELIC_EURUS_AUTH_OPEN);
1935                 break;
1936         case GELIC_EURUS_AUTH_SHARED:
1937                 common->auth_method = cpu_to_be16(GELIC_EURUS_AUTH_SHARED);
1938                 break;
1939         }
1940
1941 #ifdef DEBUG
1942         scan_list_dump(wl);
1943 #endif
1944         pr_debug("%s: common cfg index=%d bsstype=%d auth=%d\n", __func__,
1945                  be16_to_cpu(common->scan_index),
1946                  be16_to_cpu(common->bss_type),
1947                  be16_to_cpu(common->auth_method));
1948
1949         cmd = gelic_eurus_sync_cmd(wl, GELIC_EURUS_CMD_SET_COMMON_CFG,
1950                                    common, sizeof(*common));
1951         if (!cmd || cmd->status || cmd->cmd_status) {
1952                 ret = -ENOMEM;
1953                 kfree(cmd);
1954                 goto out;
1955         }
1956         kfree(cmd);
1957
1958         /* WEP/WPA */
1959         switch (wl->wpa_level) {
1960         case GELIC_WL_WPA_LEVEL_NONE:
1961                 /* If WEP or no security, setup WEP config */
1962                 ret = gelic_wl_do_wep_setup(wl);
1963                 break;
1964         case GELIC_WL_WPA_LEVEL_WPA:
1965         case GELIC_WL_WPA_LEVEL_WPA2:
1966                 ret = gelic_wl_do_wpa_setup(wl);
1967                 break;
1968         }
1969
1970         if (ret) {
1971                 pr_debug("%s: WEP/WPA setup failed %d\n", __func__,
1972                          ret);
1973                 ret = -EPERM;
1974                 gelic_wl_send_iwap_event(wl, NULL);
1975                 goto out;
1976         }
1977
1978         /* start association */
1979         init_completion(&wl->assoc_done);
1980         wl->assoc_stat = GELIC_WL_ASSOC_STAT_ASSOCIATING;
1981         cmd = gelic_eurus_sync_cmd(wl, GELIC_EURUS_CMD_ASSOC,
1982                                    NULL, 0);
1983         if (!cmd || cmd->status || cmd->cmd_status) {
1984                 pr_debug("%s: assoc request failed\n", __func__);
1985                 wl->assoc_stat = GELIC_WL_ASSOC_STAT_DISCONN;
1986                 kfree(cmd);
1987                 ret = -ENOMEM;
1988                 gelic_wl_send_iwap_event(wl, NULL);
1989                 goto out;
1990         }
1991         kfree(cmd);
1992
1993         /* wait for connected event */
1994         rc = wait_for_completion_timeout(&wl->assoc_done, HZ * 4);/*FIXME*/
1995
1996         if (!rc) {
1997                 /* timeouted.  Maybe key or cyrpt mode is wrong */
1998                 pr_info("%s: connect timeout\n", __func__);
1999                 cmd = gelic_eurus_sync_cmd(wl, GELIC_EURUS_CMD_DISASSOC,
2000                                            NULL, 0);
2001                 kfree(cmd);
2002                 wl->assoc_stat = GELIC_WL_ASSOC_STAT_DISCONN;
2003                 gelic_wl_send_iwap_event(wl, NULL);
2004                 ret = -ENXIO;
2005         } else {
2006                 wl->assoc_stat = GELIC_WL_ASSOC_STAT_ASSOCIATED;
2007                 /* copy bssid */
2008                 memcpy(wl->active_bssid, &bss->hwinfo->bssid[2], ETH_ALEN);
2009
2010                 /* send connect event */
2011                 gelic_wl_send_iwap_event(wl, wl->active_bssid);
2012                 pr_info("%s: connected\n", __func__);
2013         }
2014 out:
2015         free_page((unsigned long)common);
2016         pr_debug("%s: ->\n", __func__);
2017         return ret;
2018 }
2019
2020 /*
2021  * connected event
2022  */
2023 static void gelic_wl_connected_event(struct gelic_wl_info *wl,
2024                                      u64 event)
2025 {
2026         u64 desired_event = 0;
2027
2028         switch (wl->wpa_level) {
2029         case GELIC_WL_WPA_LEVEL_NONE:
2030                 desired_event = GELIC_LV1_WL_EVENT_CONNECTED;
2031                 break;
2032         case GELIC_WL_WPA_LEVEL_WPA:
2033         case GELIC_WL_WPA_LEVEL_WPA2:
2034                 desired_event = GELIC_LV1_WL_EVENT_WPA_CONNECTED;
2035                 break;
2036         }
2037
2038         if (desired_event == event) {
2039                 pr_debug("%s: completed\n", __func__);
2040                 complete(&wl->assoc_done);
2041                 netif_carrier_on(port_to_netdev(wl_port(wl)));
2042         } else
2043                 pr_debug("%s: event %#llx under wpa\n",
2044                                  __func__, event);
2045 }
2046
2047 /*
2048  * disconnect event
2049  */
2050 static void gelic_wl_disconnect_event(struct gelic_wl_info *wl,
2051                                       u64 event)
2052 {
2053         struct gelic_eurus_cmd *cmd;
2054         int lock;
2055
2056         /*
2057          * If we fall here in the middle of association,
2058          * associate_bss() should be waiting for complation of
2059          * wl->assoc_done.
2060          * As it waits with timeout, just leave assoc_done
2061          * uncompleted, then it terminates with timeout
2062          */
2063         if (!mutex_trylock(&wl->assoc_stat_lock)) {
2064                 pr_debug("%s: already locked\n", __func__);
2065                 lock = 0;
2066         } else {
2067                 pr_debug("%s: obtain lock\n", __func__);
2068                 lock = 1;
2069         }
2070
2071         cmd = gelic_eurus_sync_cmd(wl, GELIC_EURUS_CMD_DISASSOC, NULL, 0);
2072         kfree(cmd);
2073
2074         /* send disconnected event to the supplicant */
2075         if (wl->assoc_stat == GELIC_WL_ASSOC_STAT_ASSOCIATED)
2076                 gelic_wl_send_iwap_event(wl, NULL);
2077
2078         wl->assoc_stat = GELIC_WL_ASSOC_STAT_DISCONN;
2079         netif_carrier_off(port_to_netdev(wl_port(wl)));
2080
2081         if (lock)
2082                 mutex_unlock(&wl->assoc_stat_lock);
2083 }
2084 /*
2085  * event worker
2086  */
2087 #ifdef DEBUG
2088 static const char *eventstr(enum gelic_lv1_wl_event event)
2089 {
2090         static char buf[32];
2091         char *ret;
2092         if (event & GELIC_LV1_WL_EVENT_DEVICE_READY)
2093                 ret = "EURUS_READY";
2094         else if (event & GELIC_LV1_WL_EVENT_SCAN_COMPLETED)
2095                 ret = "SCAN_COMPLETED";
2096         else if (event & GELIC_LV1_WL_EVENT_DEAUTH)
2097                 ret = "DEAUTH";
2098         else if (event & GELIC_LV1_WL_EVENT_BEACON_LOST)
2099                 ret = "BEACON_LOST";
2100         else if (event & GELIC_LV1_WL_EVENT_CONNECTED)
2101                 ret = "CONNECTED";
2102         else if (event & GELIC_LV1_WL_EVENT_WPA_CONNECTED)
2103                 ret = "WPA_CONNECTED";
2104         else if (event & GELIC_LV1_WL_EVENT_WPA_ERROR)
2105                 ret = "WPA_ERROR";
2106         else {
2107                 sprintf(buf, "Unknown(%#x)", event);
2108                 ret = buf;
2109         }
2110         return ret;
2111 }
2112 #else
2113 static const char *eventstr(enum gelic_lv1_wl_event event)
2114 {
2115         return NULL;
2116 }
2117 #endif
2118 static void gelic_wl_event_worker(struct work_struct *work)
2119 {
2120         struct gelic_wl_info *wl;
2121         struct gelic_port *port;
2122         u64 event, tmp;
2123         int status;
2124
2125         pr_debug("%s:start\n", __func__);
2126         wl = container_of(work, struct gelic_wl_info, event_work.work);
2127         port = wl_port(wl);
2128         while (1) {
2129                 status = lv1_net_control(bus_id(port->card), dev_id(port->card),
2130                                          GELIC_LV1_GET_WLAN_EVENT, 0, 0, 0,
2131                                          &event, &tmp);
2132                 if (status) {
2133                         if (status != LV1_NO_ENTRY)
2134                                 pr_debug("%s:wlan event failed %d\n",
2135                                          __func__, status);
2136                         /* got all events */
2137                         pr_debug("%s:end\n", __func__);
2138                         return;
2139                 }
2140                 pr_debug("%s: event=%s\n", __func__, eventstr(event));
2141                 switch (event) {
2142                 case GELIC_LV1_WL_EVENT_SCAN_COMPLETED:
2143                         gelic_wl_scan_complete_event(wl);
2144                         break;
2145                 case GELIC_LV1_WL_EVENT_BEACON_LOST:
2146                 case GELIC_LV1_WL_EVENT_DEAUTH:
2147                         gelic_wl_disconnect_event(wl, event);
2148                         break;
2149                 case GELIC_LV1_WL_EVENT_CONNECTED:
2150                 case GELIC_LV1_WL_EVENT_WPA_CONNECTED:
2151                         gelic_wl_connected_event(wl, event);
2152                         break;
2153                 default:
2154                         break;
2155                 }
2156         } /* while */
2157 }
2158 /*
2159  * association worker
2160  */
2161 static void gelic_wl_assoc_worker(struct work_struct *work)
2162 {
2163         struct gelic_wl_info *wl;
2164
2165         struct gelic_wl_scan_info *best_bss;
2166         int ret;
2167         unsigned long irqflag;
2168         u8 *essid;
2169         size_t essid_len;
2170
2171         wl = container_of(work, struct gelic_wl_info, assoc_work.work);
2172
2173         mutex_lock(&wl->assoc_stat_lock);
2174
2175         if (wl->assoc_stat != GELIC_WL_ASSOC_STAT_DISCONN)
2176                 goto out;
2177
2178         spin_lock_irqsave(&wl->lock, irqflag);
2179         if (test_bit(GELIC_WL_STAT_ESSID_SET, &wl->stat)) {
2180                 pr_debug("%s: assoc ESSID configured %s\n", __func__,
2181                          wl->essid);
2182                 essid = wl->essid;
2183                 essid_len = wl->essid_len;
2184         } else {
2185                 essid = NULL;
2186                 essid_len = 0;
2187         }
2188         spin_unlock_irqrestore(&wl->lock, irqflag);
2189
2190         ret = gelic_wl_start_scan(wl, 0, essid, essid_len);
2191         if (ret == -ERESTARTSYS) {
2192                 pr_debug("%s: scan start failed association\n", __func__);
2193                 schedule_delayed_work(&wl->assoc_work, HZ/10); /*FIXME*/
2194                 goto out;
2195         } else if (ret) {
2196                 pr_info("%s: scan prerequisite failed\n", __func__);
2197                 goto out;
2198         }
2199
2200         /*
2201          * Wait for bss scan completion
2202          * If we have scan list already, gelic_wl_start_scan()
2203          * returns OK and raises the complete.  Thus,
2204          * it's ok to wait unconditionally here
2205          */
2206         wait_for_completion(&wl->scan_done);
2207
2208         pr_debug("%s: scan done\n", __func__);
2209         mutex_lock(&wl->scan_lock);
2210         if (wl->scan_stat != GELIC_WL_SCAN_STAT_GOT_LIST) {
2211                 gelic_wl_send_iwap_event(wl, NULL);
2212                 pr_info("%s: no scan list. association failed\n", __func__);
2213                 goto scan_lock_out;
2214         }
2215
2216         /* find best matching bss */
2217         best_bss = gelic_wl_find_best_bss(wl);
2218         if (!best_bss) {
2219                 gelic_wl_send_iwap_event(wl, NULL);
2220                 pr_info("%s: no bss matched. association failed\n", __func__);
2221                 goto scan_lock_out;
2222         }
2223
2224         /* ok, do association */
2225         ret = gelic_wl_associate_bss(wl, best_bss);
2226         if (ret)
2227                 pr_info("%s: association failed %d\n", __func__, ret);
2228 scan_lock_out:
2229         mutex_unlock(&wl->scan_lock);
2230 out:
2231         mutex_unlock(&wl->assoc_stat_lock);
2232 }
2233 /*
2234  * Interrupt handler
2235  * Called from the ethernet interrupt handler
2236  * Processes wireless specific virtual interrupts only
2237  */
2238 void gelic_wl_interrupt(struct net_device *netdev, u64 status)
2239 {
2240         struct gelic_wl_info *wl = port_wl(netdev_priv(netdev));
2241
2242         if (status & GELIC_CARD_WLAN_COMMAND_COMPLETED) {
2243                 pr_debug("%s:cmd complete\n", __func__);
2244                 complete(&wl->cmd_done_intr);
2245         }
2246
2247         if (status & GELIC_CARD_WLAN_EVENT_RECEIVED) {
2248                 pr_debug("%s:event received\n", __func__);
2249                 queue_delayed_work(wl->event_queue, &wl->event_work, 0);
2250         }
2251 }
2252
2253 /*
2254  * driver helpers
2255  */
2256 static const iw_handler gelic_wl_wext_handler[] =
2257 {
2258         IW_HANDLER(SIOCGIWNAME, gelic_wl_get_name),
2259         IW_HANDLER(SIOCGIWRANGE, gelic_wl_get_range),
2260         IW_HANDLER(SIOCSIWSCAN, gelic_wl_set_scan),
2261         IW_HANDLER(SIOCGIWSCAN, gelic_wl_get_scan),
2262         IW_HANDLER(SIOCSIWAUTH, gelic_wl_set_auth),
2263         IW_HANDLER(SIOCGIWAUTH, gelic_wl_get_auth),
2264         IW_HANDLER(SIOCSIWESSID, gelic_wl_set_essid),
2265         IW_HANDLER(SIOCGIWESSID, gelic_wl_get_essid),
2266         IW_HANDLER(SIOCSIWENCODE, gelic_wl_set_encode),
2267         IW_HANDLER(SIOCGIWENCODE, gelic_wl_get_encode),
2268         IW_HANDLER(SIOCSIWAP, gelic_wl_set_ap),
2269         IW_HANDLER(SIOCGIWAP, gelic_wl_get_ap),
2270         IW_HANDLER(SIOCSIWENCODEEXT, gelic_wl_set_encodeext),
2271         IW_HANDLER(SIOCGIWENCODEEXT, gelic_wl_get_encodeext),
2272         IW_HANDLER(SIOCSIWMODE, gelic_wl_set_mode),
2273         IW_HANDLER(SIOCGIWMODE, gelic_wl_get_mode),
2274         IW_HANDLER(SIOCGIWNICKN, gelic_wl_get_nick),
2275 };
2276
2277 static const struct iw_handler_def gelic_wl_wext_handler_def = {
2278         .num_standard           = ARRAY_SIZE(gelic_wl_wext_handler),
2279         .standard               = gelic_wl_wext_handler,
2280         .get_wireless_stats     = gelic_wl_get_wireless_stats,
2281 };
2282
2283 static struct net_device *gelic_wl_alloc(struct gelic_card *card)
2284 {
2285         struct net_device *netdev;
2286         struct gelic_port *port;
2287         struct gelic_wl_info *wl;
2288         unsigned int i;
2289
2290         pr_debug("%s:start\n", __func__);
2291         netdev = alloc_etherdev(sizeof(struct gelic_port) +
2292                                 sizeof(struct gelic_wl_info));
2293         pr_debug("%s: netdev =%p card=%p\n", __func__, netdev, card);
2294         if (!netdev)
2295                 return NULL;
2296
2297         strcpy(netdev->name, "wlan%d");
2298
2299         port = netdev_priv(netdev);
2300         port->netdev = netdev;
2301         port->card = card;
2302         port->type = GELIC_PORT_WIRELESS;
2303
2304         wl = port_wl(port);
2305         pr_debug("%s: wl=%p port=%p\n", __func__, wl, port);
2306
2307         /* allocate scan list */
2308         wl->networks = kcalloc(GELIC_WL_BSS_MAX_ENT,
2309                                sizeof(struct gelic_wl_scan_info),
2310                                GFP_KERNEL);
2311
2312         if (!wl->networks)
2313                 goto fail_bss;
2314
2315         wl->eurus_cmd_queue = create_singlethread_workqueue("gelic_cmd");
2316         if (!wl->eurus_cmd_queue)
2317                 goto fail_cmd_workqueue;
2318
2319         wl->event_queue = create_singlethread_workqueue("gelic_event");
2320         if (!wl->event_queue)
2321                 goto fail_event_workqueue;
2322
2323         INIT_LIST_HEAD(&wl->network_free_list);
2324         INIT_LIST_HEAD(&wl->network_list);
2325         for (i = 0; i < GELIC_WL_BSS_MAX_ENT; i++)
2326                 list_add_tail(&wl->networks[i].list,
2327                               &wl->network_free_list);
2328         init_completion(&wl->cmd_done_intr);
2329
2330         INIT_DELAYED_WORK(&wl->event_work, gelic_wl_event_worker);
2331         INIT_DELAYED_WORK(&wl->assoc_work, gelic_wl_assoc_worker);
2332         mutex_init(&wl->scan_lock);
2333         mutex_init(&wl->assoc_stat_lock);
2334
2335         init_completion(&wl->scan_done);
2336         /* for the case that no scan request is issued and stop() is called */
2337         complete(&wl->scan_done);
2338
2339         spin_lock_init(&wl->lock);
2340
2341         wl->scan_age = 5*HZ; /* FIXME */
2342
2343         /* buffer for receiving scanned list etc */
2344         BUILD_BUG_ON(PAGE_SIZE <
2345                      sizeof(struct gelic_eurus_scan_info) *
2346                      GELIC_EURUS_MAX_SCAN);
2347         pr_debug("%s:end\n", __func__);
2348         return netdev;
2349
2350 fail_event_workqueue:
2351         destroy_workqueue(wl->eurus_cmd_queue);
2352 fail_cmd_workqueue:
2353         kfree(wl->networks);
2354 fail_bss:
2355         free_netdev(netdev);
2356         pr_debug("%s:end error\n", __func__);
2357         return NULL;
2358
2359 }
2360
2361 static void gelic_wl_free(struct gelic_wl_info *wl)
2362 {
2363         struct gelic_wl_scan_info *scan_info;
2364         unsigned int i;
2365
2366         pr_debug("%s: <-\n", __func__);
2367
2368         pr_debug("%s: destroy queues\n", __func__);
2369         destroy_workqueue(wl->eurus_cmd_queue);
2370         destroy_workqueue(wl->event_queue);
2371
2372         scan_info = wl->networks;
2373         for (i = 0; i < GELIC_WL_BSS_MAX_ENT; i++, scan_info++)
2374                 kfree(scan_info->hwinfo);
2375         kfree(wl->networks);
2376
2377         free_netdev(port_to_netdev(wl_port(wl)));
2378
2379         pr_debug("%s: ->\n", __func__);
2380 }
2381
2382 static int gelic_wl_try_associate(struct net_device *netdev)
2383 {
2384         struct gelic_wl_info *wl = port_wl(netdev_priv(netdev));
2385         int ret = -1;
2386         unsigned int i;
2387
2388         pr_debug("%s: <-\n", __func__);
2389
2390         /* check constraits for start association */
2391         /* for no access restriction AP */
2392         if (wl->group_cipher_method == GELIC_WL_CIPHER_NONE) {
2393                 if (test_bit(GELIC_WL_STAT_CONFIGURED,
2394                              &wl->stat))
2395                         goto do_associate;
2396                 else {
2397                         pr_debug("%s: no wep, not configured\n", __func__);
2398                         return ret;
2399                 }
2400         }
2401
2402         /* for WEP, one of four keys should be set */
2403         if (wl->group_cipher_method == GELIC_WL_CIPHER_WEP) {
2404                 /* one of keys set */
2405                 for (i = 0; i < GELIC_WEP_KEYS; i++) {
2406                         if (test_bit(i, &wl->key_enabled))
2407                             goto do_associate;
2408                 }
2409                 pr_debug("%s: WEP, but no key specified\n", __func__);
2410                 return ret;
2411         }
2412
2413         /* for WPA[2], psk should be set */
2414         if ((wl->group_cipher_method == GELIC_WL_CIPHER_TKIP) ||
2415             (wl->group_cipher_method == GELIC_WL_CIPHER_AES)) {
2416                 if (test_bit(GELIC_WL_STAT_WPA_PSK_SET,
2417                              &wl->stat))
2418                         goto do_associate;
2419                 else {
2420                         pr_debug("%s: AES/TKIP, but PSK not configured\n",
2421                                  __func__);
2422                         return ret;
2423                 }
2424         }
2425
2426 do_associate:
2427         ret = schedule_delayed_work(&wl->assoc_work, 0);
2428         pr_debug("%s: start association work %d\n", __func__, ret);
2429         return ret;
2430 }
2431
2432 /*
2433  * netdev handlers
2434  */
2435 static int gelic_wl_open(struct net_device *netdev)
2436 {
2437         struct gelic_card *card = netdev_card(netdev);
2438
2439         pr_debug("%s:->%p\n", __func__, netdev);
2440
2441         gelic_card_up(card);
2442
2443         /* try to associate */
2444         gelic_wl_try_associate(netdev);
2445
2446         netif_start_queue(netdev);
2447
2448         pr_debug("%s:<-\n", __func__);
2449         return 0;
2450 }
2451
2452 /*
2453  * reset state machine
2454  */
2455 static int gelic_wl_reset_state(struct gelic_wl_info *wl)
2456 {
2457         struct gelic_wl_scan_info *target;
2458         struct gelic_wl_scan_info *tmp;
2459
2460         /* empty scan list */
2461         list_for_each_entry_safe(target, tmp, &wl->network_list, list) {
2462                 list_move_tail(&target->list, &wl->network_free_list);
2463         }
2464         wl->scan_stat = GELIC_WL_SCAN_STAT_INIT;
2465
2466         /* clear configuration */
2467         wl->auth_method = GELIC_EURUS_AUTH_OPEN;
2468         wl->group_cipher_method = GELIC_WL_CIPHER_NONE;
2469         wl->pairwise_cipher_method = GELIC_WL_CIPHER_NONE;
2470         wl->wpa_level = GELIC_WL_WPA_LEVEL_NONE;
2471
2472         wl->key_enabled = 0;
2473         wl->current_key = 0;
2474
2475         wl->psk_type = GELIC_EURUS_WPA_PSK_PASSPHRASE;
2476         wl->psk_len = 0;
2477
2478         wl->essid_len = 0;
2479         memset(wl->essid, 0, sizeof(wl->essid));
2480         memset(wl->bssid, 0, sizeof(wl->bssid));
2481         memset(wl->active_bssid, 0, sizeof(wl->active_bssid));
2482
2483         wl->assoc_stat = GELIC_WL_ASSOC_STAT_DISCONN;
2484
2485         memset(&wl->iwstat, 0, sizeof(wl->iwstat));
2486         /* all status bit clear */
2487         wl->stat = 0;
2488         return 0;
2489 }
2490
2491 /*
2492  * Tell eurus to terminate association
2493  */
2494 static void gelic_wl_disconnect(struct net_device *netdev)
2495 {
2496         struct gelic_port *port = netdev_priv(netdev);
2497         struct gelic_wl_info *wl = port_wl(port);
2498         struct gelic_eurus_cmd *cmd;
2499
2500         /*
2501          * If scann process is running on chip,
2502          * further requests will be rejected
2503          */
2504         if (wl->scan_stat == GELIC_WL_SCAN_STAT_SCANNING)
2505                 wait_for_completion_timeout(&wl->scan_done, HZ);
2506
2507         cmd = gelic_eurus_sync_cmd(wl, GELIC_EURUS_CMD_DISASSOC, NULL, 0);
2508         kfree(cmd);
2509         gelic_wl_send_iwap_event(wl, NULL);
2510 };
2511
2512 static int gelic_wl_stop(struct net_device *netdev)
2513 {
2514         struct gelic_port *port = netdev_priv(netdev);
2515         struct gelic_wl_info *wl = port_wl(port);
2516         struct gelic_card *card = netdev_card(netdev);
2517
2518         pr_debug("%s:<-\n", __func__);
2519
2520         /*
2521          * Cancel pending association work.
2522          * event work can run after netdev down
2523          */
2524         cancel_delayed_work(&wl->assoc_work);
2525
2526         if (wl->assoc_stat == GELIC_WL_ASSOC_STAT_ASSOCIATED)
2527                 gelic_wl_disconnect(netdev);
2528
2529         /* reset our state machine */
2530         gelic_wl_reset_state(wl);
2531
2532         netif_stop_queue(netdev);
2533
2534         gelic_card_down(card);
2535
2536         pr_debug("%s:->\n", __func__);
2537         return 0;
2538 }
2539
2540 /* -- */
2541
2542 static const struct net_device_ops gelic_wl_netdevice_ops = {
2543         .ndo_open = gelic_wl_open,
2544         .ndo_stop = gelic_wl_stop,
2545         .ndo_start_xmit = gelic_net_xmit,
2546         .ndo_set_rx_mode = gelic_net_set_multi,
2547         .ndo_tx_timeout = gelic_net_tx_timeout,
2548         .ndo_set_mac_address = eth_mac_addr,
2549         .ndo_validate_addr = eth_validate_addr,
2550 #ifdef CONFIG_NET_POLL_CONTROLLER
2551         .ndo_poll_controller = gelic_net_poll_controller,
2552 #endif
2553 };
2554
2555 static const struct ethtool_ops gelic_wl_ethtool_ops = {
2556         .get_drvinfo    = gelic_net_get_drvinfo,
2557         .get_link       = gelic_wl_get_link,
2558 };
2559
2560 static void gelic_wl_setup_netdev_ops(struct net_device *netdev)
2561 {
2562         struct gelic_wl_info *wl;
2563         wl = port_wl(netdev_priv(netdev));
2564         BUG_ON(!wl);
2565         netdev->watchdog_timeo = GELIC_NET_WATCHDOG_TIMEOUT;
2566
2567         netdev->ethtool_ops = &gelic_wl_ethtool_ops;
2568         netdev->netdev_ops = &gelic_wl_netdevice_ops;
2569         netdev->wireless_data = &wl->wireless_data;
2570         netdev->wireless_handlers = &gelic_wl_wext_handler_def;
2571 }
2572
2573 /*
2574  * driver probe/remove
2575  */
2576 int gelic_wl_driver_probe(struct gelic_card *card)
2577 {
2578         int ret;
2579         struct net_device *netdev;
2580
2581         pr_debug("%s:start\n", __func__);
2582
2583         if (ps3_compare_firmware_version(1, 6, 0) < 0)
2584                 return 0;
2585         if (!card->vlan[GELIC_PORT_WIRELESS].tx)
2586                 return 0;
2587
2588         /* alloc netdevice for wireless */
2589         netdev = gelic_wl_alloc(card);
2590         if (!netdev)
2591                 return -ENOMEM;
2592
2593         /* setup net_device structure */
2594         SET_NETDEV_DEV(netdev, &card->dev->core);
2595         gelic_wl_setup_netdev_ops(netdev);
2596
2597         /* setup some of net_device and register it */
2598         ret = gelic_net_setup_netdev(netdev, card);
2599         if (ret)
2600                 goto fail_setup;
2601         card->netdev[GELIC_PORT_WIRELESS] = netdev;
2602
2603         /* add enable wireless interrupt */
2604         card->irq_mask |= GELIC_CARD_WLAN_EVENT_RECEIVED |
2605                 GELIC_CARD_WLAN_COMMAND_COMPLETED;
2606         /* to allow wireless commands while both interfaces are down */
2607         gelic_card_set_irq_mask(card, GELIC_CARD_WLAN_EVENT_RECEIVED |
2608                                 GELIC_CARD_WLAN_COMMAND_COMPLETED);
2609         pr_debug("%s:end\n", __func__);
2610         return 0;
2611
2612 fail_setup:
2613         gelic_wl_free(port_wl(netdev_port(netdev)));
2614
2615         return ret;
2616 }
2617
2618 int gelic_wl_driver_remove(struct gelic_card *card)
2619 {
2620         struct gelic_wl_info *wl;
2621         struct net_device *netdev;
2622
2623         pr_debug("%s:start\n", __func__);
2624
2625         if (ps3_compare_firmware_version(1, 6, 0) < 0)
2626                 return 0;
2627         if (!card->vlan[GELIC_PORT_WIRELESS].tx)
2628                 return 0;
2629
2630         netdev = card->netdev[GELIC_PORT_WIRELESS];
2631         wl = port_wl(netdev_priv(netdev));
2632
2633         /* if the interface was not up, but associated */
2634         if (wl->assoc_stat == GELIC_WL_ASSOC_STAT_ASSOCIATED)
2635                 gelic_wl_disconnect(netdev);
2636
2637         complete(&wl->cmd_done_intr);
2638
2639         /* cancel all work queue */
2640         cancel_delayed_work(&wl->assoc_work);
2641         cancel_delayed_work(&wl->event_work);
2642         flush_workqueue(wl->eurus_cmd_queue);
2643         flush_workqueue(wl->event_queue);
2644
2645         unregister_netdev(netdev);
2646
2647         /* disable wireless interrupt */
2648         pr_debug("%s: disable intr\n", __func__);
2649         card->irq_mask &= ~(GELIC_CARD_WLAN_EVENT_RECEIVED |
2650                             GELIC_CARD_WLAN_COMMAND_COMPLETED);
2651         /* free bss list, netdev*/
2652         gelic_wl_free(wl);
2653         pr_debug("%s:end\n", __func__);
2654         return 0;
2655 }