drivers/net/wireless/libertas/ioctl.c

   1 /**
   2   * This file contains ioctl functions
   3   */
   4
   5 #include <linux/ctype.h>
   6 #include <linux/delay.h>
   7 #include <linux/if.h>
   8 #include <linux/if_arp.h>
   9 #include <linux/wireless.h>
  10
  11 #include <net/iw_handler.h>
  12 #include <net/ieee80211.h>
  13
  14 #include "host.h"
  15 #include "radiotap.h"
  16 #include "decl.h"
  17 #include "defs.h"
  18 #include "dev.h"
  19 #include "join.h"
  20 #include "wext.h"
  21
  22 #define MAX_SCAN_CELL_SIZE      (IW_EV_ADDR_LEN + \
  23                                 IW_ESSID_MAX_SIZE + \
  24                                 IW_EV_UINT_LEN + IW_EV_FREQ_LEN + \
  25                                 IW_EV_QUAL_LEN + IW_ESSID_MAX_SIZE + \
  26                                 IW_EV_PARAM_LEN + 40)   /* 40 for WPAIE */
  27
  28 #define WAIT_FOR_SCAN_RRESULT_MAX_TIME (10 * HZ)
  29
  30 static int setrxantenna(wlan_private * priv, int mode)
  31 {
  32         int ret = 0;
  33         wlan_adapter *adapter = priv->adapter;
  34
  35         if (mode != RF_ANTENNA_1 && mode != RF_ANTENNA_2
  36             && mode != RF_ANTENNA_AUTO) {
  37                 return -EINVAL;
  38         }
  39
  40         adapter->rxantennamode = mode;
  41
  42         lbs_pr_debug(1, "SET RX Antenna mode to 0x%04x\n", adapter->rxantennamode);
  43
  44         ret = libertas_prepare_and_send_command(priv, cmd_802_11_rf_antenna,
  45                                     cmd_act_set_rx,
  46                                     cmd_option_waitforrsp, 0,
  47                                     &adapter->rxantennamode);
  48         return ret;
  49 }
  50
  51 static int settxantenna(wlan_private * priv, int mode)
  52 {
  53         int ret = 0;
  54         wlan_adapter *adapter = priv->adapter;
  55
  56         if ((mode != RF_ANTENNA_1) && (mode != RF_ANTENNA_2)
  57             && (mode != RF_ANTENNA_AUTO)) {
  58                 return -EINVAL;
  59         }
  60
  61         adapter->txantennamode = mode;
  62
  63         lbs_pr_debug(1, "SET TX Antenna mode to 0x%04x\n", adapter->txantennamode);
  64
  65         ret = libertas_prepare_and_send_command(priv, cmd_802_11_rf_antenna,
  66                                     cmd_act_set_tx,
  67                                     cmd_option_waitforrsp, 0,
  68                                     &adapter->txantennamode);
  69
  70         return ret;
  71 }
  72
  73 static int getrxantenna(wlan_private * priv, char *buf)
  74 {
  75         int ret = 0;
  76         wlan_adapter *adapter = priv->adapter;
  77
  78         // clear it, so we will know if the value
  79         // returned below is correct or not.
  80         adapter->rxantennamode = 0;
  81
  82         ret = libertas_prepare_and_send_command(priv, cmd_802_11_rf_antenna,
  83                                     cmd_act_get_rx,
  84                                     cmd_option_waitforrsp, 0, NULL);
  85
  86         if (ret) {
  87                 LEAVE();
  88                 return ret;
  89         }
  90
  91         lbs_pr_debug(1, "Get Rx Antenna mode:0x%04x\n", adapter->rxantennamode);
  92
  93         return sprintf(buf, "0x%04x", adapter->rxantennamode) + 1;
  94 }
  95
  96 static int gettxantenna(wlan_private * priv, char *buf)
  97 {
  98         int ret = 0;
  99         wlan_adapter *adapter = priv->adapter;
 100
 101         // clear it, so we will know if the value
 102         // returned below is correct or not.
 103         adapter->txantennamode = 0;
 104
 105         ret = libertas_prepare_and_send_command(priv, cmd_802_11_rf_antenna,
 106                                     cmd_act_get_tx,
 107                                     cmd_option_waitforrsp, 0, NULL);
 108
 109         if (ret) {
 110                 LEAVE();
 111                 return ret;
 112         }
 113
 114         lbs_pr_debug(1, "Get Tx Antenna mode:0x%04x\n", adapter->txantennamode);
 115
 116         return sprintf(buf, "0x%04x", adapter->txantennamode) + 1;
 117 }
 118
 119 static int wlan_set_region(wlan_private * priv, u16 region_code)
 120 {
 121         int i;
 122
 123         for (i = 0; i < MRVDRV_MAX_REGION_CODE; i++) {
 124                 // use the region code to search for the index
 125                 if (region_code == libertas_region_code_to_index[i]) {
 126                         priv->adapter->regiontableindex = (u16) i;
 127                         priv->adapter->regioncode = region_code;
 128                         break;
 129                 }
 130         }
 131
 132         // if it's unidentified region code
 133         if (i >= MRVDRV_MAX_REGION_CODE) {
 134                 lbs_pr_debug(1, "region Code not identified\n");
 135                 LEAVE();
 136                 return -1;
 137         }
 138
 139         if (libertas_set_regiontable(priv, priv->adapter->regioncode, 0)) {
 140                 LEAVE();
 141                 return -EINVAL;
 142         }
 143
 144         return 0;
 145 }
 146
 147 /**
 148  *  @brief Get/Set Firmware wakeup method
 149  *
 150  *  @param priv         A pointer to wlan_private structure
 151  *  @param wrq          A pointer to user data
 152  *  @return             0--success, otherwise fail
 153  */
 154 static int wlan_txcontrol(wlan_private * priv, struct iwreq *wrq)
 155 {
 156         wlan_adapter *adapter = priv->adapter;
 157         int data;
 158         ENTER();
 159
 160         if ((int)wrq->u.data.length == 0) {
 161                 if (copy_to_user
 162                     (wrq->u.data.pointer, &adapter->pkttxctrl, sizeof(u32))) {
 163                         lbs_pr_alert("copy_to_user failed!\n");
 164                         return -EFAULT;
 165                 }
 166         } else {
 167                 if ((int)wrq->u.data.length > 1) {
 168                         lbs_pr_alert("ioctl too many args!\n");
 169                         return -EFAULT;
 170                 }
 171                 if (copy_from_user(&data, wrq->u.data.pointer, sizeof(int))) {
 172                         lbs_pr_alert("Copy from user failed\n");
 173                         return -EFAULT;
 174                 }
 175
 176                 adapter->pkttxctrl = (u32) data;
 177         }
 178
 179         wrq->u.data.length = 1;
 180
 181         LEAVE();
 182         return 0;
 183 }
 184
 185 /**
 186  *  @brief Get/Set NULL Package generation interval
 187  *
 188  *  @param priv         A pointer to wlan_private structure
 189  *  @param wrq          A pointer to user data
 190  *  @return             0--success, otherwise fail
 191  */
 192 static int wlan_null_pkt_interval(wlan_private * priv, struct iwreq *wrq)
 193 {
 194         wlan_adapter *adapter = priv->adapter;
 195         int data;
 196         ENTER();
 197
 198         if ((int)wrq->u.data.length == 0) {
 199                 data = adapter->nullpktinterval;
 200
 201                 if (copy_to_user(wrq->u.data.pointer, &data, sizeof(int))) {
 202                         lbs_pr_alert( "copy_to_user failed!\n");
 203                         return -EFAULT;
 204                 }
 205         } else {
 206                 if ((int)wrq->u.data.length > 1) {
 207                         lbs_pr_alert( "ioctl too many args!\n");
 208                         return -EFAULT;
 209                 }
 210                 if (copy_from_user(&data, wrq->u.data.pointer, sizeof(int))) {
 211                         lbs_pr_debug(1, "Copy from user failed\n");
 212                         return -EFAULT;
 213                 }
 214
 215                 adapter->nullpktinterval = data;
 216         }
 217
 218         wrq->u.data.length = 1;
 219
 220         LEAVE();
 221         return 0;
 222 }
 223
 224 static int wlan_get_rxinfo(wlan_private * priv, struct iwreq *wrq)
 225 {
 226         wlan_adapter *adapter = priv->adapter;
 227         int data[2];
 228         ENTER();
 229         data[0] = adapter->SNR[TYPE_RXPD][TYPE_NOAVG];
 230         data[1] = adapter->rxpd_rate;
 231         if (copy_to_user(wrq->u.data.pointer, data, sizeof(int) * 2)) {
 232                 lbs_pr_debug(1, "Copy to user failed\n");
 233                 return -EFAULT;
 234         }
 235         wrq->u.data.length = 2;
 236         LEAVE();
 237         return 0;
 238 }
 239
 240 static int wlan_get_snr(wlan_private * priv, struct iwreq *wrq)
 241 {
 242         int ret = 0;
 243         wlan_adapter *adapter = priv->adapter;
 244         int data[4];
 245
 246         ENTER();
 247         memset(data, 0, sizeof(data));
 248         if (wrq->u.data.length) {
 249                 if (copy_from_user(data, wrq->u.data.pointer,
 250                      min_t(size_t, wrq->u.data.length, 4) * sizeof(int)))
 251                         return -EFAULT;
 252         }
 253         if ((wrq->u.data.length == 0) || (data[0] == 0) || (data[0] == 1)) {
 254                 if (adapter->connect_status == libertas_connected) {
 255                         ret = libertas_prepare_and_send_command(priv,
 256                                                     cmd_802_11_rssi,
 257                                                     0,
 258                                                     cmd_option_waitforrsp,
 259                                                     0, NULL);
 260
 261                         if (ret) {
 262                                 LEAVE();
 263                                 return ret;
 264                         }
 265                 }
 266         }
 267
 268         if (wrq->u.data.length == 0) {
 269                 data[0] = adapter->SNR[TYPE_BEACON][TYPE_NOAVG];
 270                 data[1] = adapter->SNR[TYPE_BEACON][TYPE_AVG];
 271                 data[2] = adapter->SNR[TYPE_RXPD][TYPE_NOAVG];
 272                 data[3] = adapter->SNR[TYPE_RXPD][TYPE_AVG] / AVG_SCALE;
 273                 if (copy_to_user(wrq->u.data.pointer, data, sizeof(int) * 4))
 274                         return -EFAULT;
 275                 wrq->u.data.length = 4;
 276         } else if (data[0] == 0) {
 277                 data[0] = adapter->SNR[TYPE_BEACON][TYPE_NOAVG];
 278                 if (copy_to_user(wrq->u.data.pointer, data, sizeof(int)))
 279                         return -EFAULT;
 280                 wrq->u.data.length = 1;
 281         } else if (data[0] == 1) {
 282                 data[0] = adapter->SNR[TYPE_BEACON][TYPE_AVG];
 283                 if (copy_to_user(wrq->u.data.pointer, data, sizeof(int)))
 284                         return -EFAULT;
 285                 wrq->u.data.length = 1;
 286         } else if (data[0] == 2) {
 287                 data[0] = adapter->SNR[TYPE_RXPD][TYPE_NOAVG];
 288                 if (copy_to_user(wrq->u.data.pointer, data, sizeof(int)))
 289                         return -EFAULT;
 290                 wrq->u.data.length = 1;
 291         } else if (data[0] == 3) {
 292                 data[0] = adapter->SNR[TYPE_RXPD][TYPE_AVG] / AVG_SCALE;
 293                 if (copy_to_user(wrq->u.data.pointer, data, sizeof(int)))
 294                         return -EFAULT;
 295                 wrq->u.data.length = 1;
 296         } else
 297                 return -ENOTSUPP;
 298
 299         LEAVE();
 300         return 0;
 301 }
 302
 303 static int wlan_beacon_interval(wlan_private * priv, struct iwreq *wrq)
 304 {
 305         int data;
 306         wlan_adapter *adapter = priv->adapter;
 307
 308         if (wrq->u.data.length > 0) {
 309                 if (copy_from_user(&data, wrq->u.data.pointer, sizeof(int)))
 310                         return -EFAULT;
 311
 312                 lbs_pr_debug(1, "WLAN SET BEACON INTERVAL: %d\n", data);
 313                 if ((data > MRVDRV_MAX_BEACON_INTERVAL)
 314                     || (data < MRVDRV_MIN_BEACON_INTERVAL))
 315                         return -ENOTSUPP;
 316                 adapter->beaconperiod = data;
 317         }
 318         data = adapter->beaconperiod;
 319         if (copy_to_user(wrq->u.data.pointer, &data, sizeof(int)))
 320                 return -EFAULT;
 321
 322         wrq->u.data.length = 1;
 323
 324         return 0;
 325 }
 326
 327 static int wlan_get_rssi(wlan_private * priv, struct iwreq *wrq)
 328 {
 329         int ret = 0;
 330         wlan_adapter *adapter = priv->adapter;
 331         int temp;
 332         int data = 0;
 333         int *val;
 334
 335         ENTER();
 336         data = SUBCMD_DATA(wrq);
 337         if ((data == 0) || (data == 1)) {
 338                 ret = libertas_prepare_and_send_command(priv,
 339                                             cmd_802_11_rssi,
 340                                             0, cmd_option_waitforrsp,
 341                                             0, NULL);
 342                 if (ret) {
 343                         LEAVE();
 344                         return ret;
 345                 }
 346         }
 347
 348         switch (data) {
 349         case 0:
 350
 351                 temp = CAL_RSSI(adapter->SNR[TYPE_BEACON][TYPE_NOAVG],
 352                                 adapter->NF[TYPE_BEACON][TYPE_NOAVG]);
 353                 break;
 354         case 1:
 355                 temp = CAL_RSSI(adapter->SNR[TYPE_BEACON][TYPE_AVG],
 356                                 adapter->NF[TYPE_BEACON][TYPE_AVG]);
 357                 break;
 358         case 2:
 359                 temp = CAL_RSSI(adapter->SNR[TYPE_RXPD][TYPE_NOAVG],
 360                                 adapter->NF[TYPE_RXPD][TYPE_NOAVG]);
 361                 break;
 362         case 3:
 363                 temp = CAL_RSSI(adapter->SNR[TYPE_RXPD][TYPE_AVG] / AVG_SCALE,
 364                                 adapter->NF[TYPE_RXPD][TYPE_AVG] / AVG_SCALE);
 365                 break;
 366         default:
 367                 return -ENOTSUPP;
 368         }
 369         val = (int *)wrq->u.name;
 370         *val = temp;
 371
 372         LEAVE();
 373         return 0;
 374 }
 375
 376 static int wlan_get_nf(wlan_private * priv, struct iwreq *wrq)
 377 {
 378         int ret = 0;
 379         wlan_adapter *adapter = priv->adapter;
 380         int temp;
 381         int data = 0;
 382         int *val;
 383
 384         data = SUBCMD_DATA(wrq);
 385         if ((data == 0) || (data == 1)) {
 386                 ret = libertas_prepare_and_send_command(priv,
 387                                             cmd_802_11_rssi,
 388                                             0, cmd_option_waitforrsp,
 389                                             0, NULL);
 390
 391                 if (ret) {
 392                         LEAVE();
 393                         return ret;
 394                 }
 395         }
 396
 397         switch (data) {
 398         case 0:
 399                 temp = adapter->NF[TYPE_BEACON][TYPE_NOAVG];
 400                 break;
 401         case 1:
 402                 temp = adapter->NF[TYPE_BEACON][TYPE_AVG];
 403                 break;
 404         case 2:
 405                 temp = adapter->NF[TYPE_RXPD][TYPE_NOAVG];
 406                 break;
 407         case 3:
 408                 temp = adapter->NF[TYPE_RXPD][TYPE_AVG] / AVG_SCALE;
 409                 break;
 410         default:
 411                 return -ENOTSUPP;
 412         }
 413
 414         temp = CAL_NF(temp);
 415
 416         lbs_pr_debug(1, "%s: temp = %d\n", __FUNCTION__, temp);
 417         val = (int *)wrq->u.name;
 418         *val = temp;
 419         return 0;
 420 }
 421
 422 static int wlan_get_txrate_ioctl(wlan_private * priv, struct ifreq *req)
 423 {
 424         wlan_adapter *adapter = priv->adapter;
 425         int *pdata;
 426         struct iwreq *wrq = (struct iwreq *)req;
 427         int ret = 0;
 428         adapter->txrate = 0;
 429         lbs_pr_debug(1, "wlan_get_txrate_ioctl\n");
 430         ret = libertas_prepare_and_send_command(priv, cmd_802_11_tx_rate_query,
 431                                     cmd_act_get, cmd_option_waitforrsp,
 432                                     0, NULL);
 433         if (ret)
 434                 return ret;
 435
 436         pdata = (int *)wrq->u.name;
 437         *pdata = (int)adapter->txrate;
 438         return 0;
 439 }
 440
 441 static int wlan_get_adhoc_status_ioctl(wlan_private * priv, struct iwreq *wrq)
 442 {
 443         char status[64];
 444         wlan_adapter *adapter = priv->adapter;
 445
 446         memset(status, 0, sizeof(status));
 447
 448         switch (adapter->inframode) {
 449         case wlan802_11ibss:
 450                 if (adapter->connect_status == libertas_connected) {
 451                         if (adapter->adhoccreate)
 452                                 memcpy(&status, "AdhocStarted", sizeof(status));
 453                         else
 454                                 memcpy(&status, "AdhocJoined", sizeof(status));
 455                 } else {
 456                         memcpy(&status, "AdhocIdle", sizeof(status));
 457                 }
 458                 break;
 459         case wlan802_11infrastructure:
 460                 memcpy(&status, "Inframode", sizeof(status));
 461                 break;
 462         default:
 463                 memcpy(&status, "AutoUnknownmode", sizeof(status));
 464                 break;
 465         }
 466
 467         lbs_pr_debug(1, "status = %s\n", status);
 468         wrq->u.data.length = strlen(status) + 1;
 469
 470         if (wrq->u.data.pointer) {
 471                 if (copy_to_user(wrq->u.data.pointer,
 472                                  &status, wrq->u.data.length))
 473                         return -EFAULT;
 474         }
 475
 476         LEAVE();
 477         return 0;
 478 }
 479
 480 /**
 481  *  @brief Set/Get WPA IE
 482  *  @param priv                 A pointer to wlan_private structure
 483  *  @param req                  A pointer to ifreq structure
 484  *  @return                     0 --success, otherwise fail
 485  */
 486 static int wlan_setwpaie_ioctl(wlan_private * priv, struct ifreq *req)
 487 {
 488         struct iwreq *wrq = (struct iwreq *)req;
 489         wlan_adapter *adapter = priv->adapter;
 490         int ret = 0;
 491
 492         ENTER();
 493
 494         if (wrq->u.data.length) {
 495                 if (wrq->u.data.length > sizeof(adapter->wpa_ie)) {
 496                         lbs_pr_debug(1, "failed to copy WPA IE, too big \n");
 497                         return -EFAULT;
 498                 }
 499                 if (copy_from_user(adapter->wpa_ie, wrq->u.data.pointer,
 500                                    wrq->u.data.length)) {
 501                         lbs_pr_debug(1, "failed to copy WPA IE \n");
 502                         return -EFAULT;
 503                 }
 504                 adapter->wpa_ie_len = wrq->u.data.length;
 505                 lbs_pr_debug(1, "Set wpa_ie_len=%d IE=%#x\n", adapter->wpa_ie_len,
 506                        adapter->wpa_ie[0]);
 507                 lbs_dbg_hex("wpa_ie", adapter->wpa_ie, adapter->wpa_ie_len);
 508                 if (adapter->wpa_ie[0] == WPA_IE)
 509                         adapter->secinfo.WPAenabled = 1;
 510                 else if (adapter->wpa_ie[0] == WPA2_IE)
 511                         adapter->secinfo.WPA2enabled = 1;
 512                 else {
 513                         adapter->secinfo.WPAenabled = 0;
 514                         adapter->secinfo.WPA2enabled = 0;
 515                 }
 516         } else {
 517                 memset(adapter->wpa_ie, 0, sizeof(adapter->wpa_ie));
 518                 adapter->wpa_ie_len = wrq->u.data.length;
 519                 lbs_pr_debug(1, "Reset wpa_ie_len=%d IE=%#x\n",
 520                        adapter->wpa_ie_len, adapter->wpa_ie[0]);
 521                 adapter->secinfo.WPAenabled = 0;
 522                 adapter->secinfo.WPA2enabled = 0;
 523         }
 524
 525         // enable/disable RSN in firmware if WPA is enabled/disabled
 526         // depending on variable adapter->secinfo.WPAenabled is set or not
 527         ret = libertas_prepare_and_send_command(priv, cmd_802_11_enable_rsn,
 528                                     cmd_act_set, cmd_option_waitforrsp,
 529                                     0, NULL);
 530
 531         LEAVE();
 532         return ret;
 533 }
 534
 535 /**
 536  *  @brief Set Auto prescan
 537  *  @param priv                 A pointer to wlan_private structure
 538  *  @param wrq                  A pointer to iwreq structure
 539  *  @return                     0 --success, otherwise fail
 540  */
 541 static int wlan_subcmd_setprescan_ioctl(wlan_private * priv, struct iwreq *wrq)
 542 {
 543         int data;
 544         wlan_adapter *adapter = priv->adapter;
 545         int *val;
 546
 547         data = SUBCMD_DATA(wrq);
 548         lbs_pr_debug(1, "WLAN_SUBCMD_SET_PRESCAN %d\n", data);
 549         adapter->prescan = data;
 550
 551         val = (int *)wrq->u.name;
 552         *val = data;
 553         return 0;
 554 }
 555
 556 static int wlan_set_multiple_dtim_ioctl(wlan_private * priv, struct ifreq *req)
 557 {
 558         struct iwreq *wrq = (struct iwreq *)req;
 559         u32 mdtim;
 560         int idata;
 561         int ret = -EINVAL;
 562
 563         ENTER();
 564
 565         idata = SUBCMD_DATA(wrq);
 566         mdtim = (u32) idata;
 567         if (((mdtim >= MRVDRV_MIN_MULTIPLE_DTIM)
 568              && (mdtim <= MRVDRV_MAX_MULTIPLE_DTIM))
 569             || (mdtim == MRVDRV_IGNORE_MULTIPLE_DTIM)) {
 570                 priv->adapter->multipledtim = mdtim;
 571                 ret = 0;
 572         }
 573         if (ret)
 574                 lbs_pr_debug(1, "Invalid parameter, multipledtim not changed.\n");
 575
 576         LEAVE();
 577         return ret;
 578 }
 579
 580 /**
 581  *  @brief Set authentication mode
 582  *  @param priv                 A pointer to wlan_private structure
 583  *  @param req                  A pointer to ifreq structure
 584  *  @return                     0 --success, otherwise fail
 585  */
 586 static int wlan_setauthalg_ioctl(wlan_private * priv, struct ifreq *req)
 587 {
 588         int alg;
 589         struct iwreq *wrq = (struct iwreq *)req;
 590         wlan_adapter *adapter = priv->adapter;
 591
 592         if (wrq->u.data.flags == 0) {
 593                 //from iwpriv subcmd
 594                 alg = SUBCMD_DATA(wrq);
 595         } else {
 596                 //from wpa_supplicant subcmd
 597                 if (copy_from_user(&alg, wrq->u.data.pointer, sizeof(alg))) {
 598                         lbs_pr_debug(1, "Copy from user failed\n");
 599                         return -EFAULT;
 600                 }
 601         }
 602
 603         lbs_pr_debug(1, "auth alg is %#x\n", alg);
 604
 605         switch (alg) {
 606         case AUTH_ALG_SHARED_KEY:
 607                 adapter->secinfo.authmode = wlan802_11authmodeshared;
 608                 break;
 609         case AUTH_ALG_NETWORK_EAP:
 610                 adapter->secinfo.authmode =
 611                     wlan802_11authmodenetworkEAP;
 612                 break;
 613         case AUTH_ALG_OPEN_SYSTEM:
 614         default:
 615                 adapter->secinfo.authmode = wlan802_11authmodeopen;
 616                 break;
 617         }
 618         return 0;
 619 }
 620
 621 static int wlan_setencryptionmode_ioctl(wlan_private * priv, struct ifreq *req)
 622 {
 623         int mode;
 624         struct iwreq *wrq = (struct iwreq *)req;
 625
 626         ENTER();
 627
 628         if (wrq->u.data.flags == 0) {
 629                 //from iwpriv subcmd
 630                 mode = SUBCMD_DATA(wrq);
 631         } else {
 632                 //from wpa_supplicant subcmd
 633                 if (copy_from_user(&mode, wrq->u.data.pointer, sizeof(int))) {
 634                         lbs_pr_debug(1, "Copy from user failed\n");
 635                         return -EFAULT;
 636                 }
 637         }
 638         lbs_pr_debug(1, "encryption mode is %#x\n", mode);
 639         priv->adapter->secinfo.Encryptionmode = mode;
 640
 641         LEAVE();
 642         return 0;
 643 }
 644
 645 static void adjust_mtu(wlan_private * priv)
 646 {
 647         int mtu_increment = 0;
 648
 649         if (priv->adapter->linkmode == WLAN_LINKMODE_802_11)
 650                 mtu_increment += sizeof(struct ieee80211_hdr_4addr);
 651
 652         if (priv->adapter->radiomode == WLAN_RADIOMODE_RADIOTAP)
 653                 mtu_increment += max(sizeof(struct tx_radiotap_hdr),
 654                                      sizeof(struct rx_radiotap_hdr));
 655         priv->wlan_dev.netdev->mtu = ETH_FRAME_LEN
 656             - sizeof(struct ethhdr)
 657             + mtu_increment;
 658 }
 659
 660 /**
 661  *  @brief Set Link-Layer Layer mode
 662  *  @param priv                 A pointer to wlan_private structure
 663  *  @param req                  A pointer to ifreq structure
 664  *  @return                     0 --success, otherwise fail
 665  */
 666 static int wlan_set_linkmode_ioctl(wlan_private * priv, struct ifreq *req)
 667 {
 668         int mode;
 669
 670         mode = (int)((struct ifreq *)((u8 *) req + 4))->ifr_data;
 671
 672         switch (mode) {
 673         case WLAN_LINKMODE_802_3:
 674                 priv->adapter->linkmode = mode;
 675                 break;
 676         case WLAN_LINKMODE_802_11:
 677                 priv->adapter->linkmode = mode;
 678                 break;
 679         default:
 680                 lbs_pr_info("usb8388-5: invalid link-layer mode (%#x)\n",
 681                        mode);
 682                 return -EINVAL;
 683                 break;
 684         }
 685         lbs_pr_debug(1, "usb8388-5: link-layer mode is %#x\n", mode);
 686
 687         adjust_mtu(priv);
 688
 689         return 0;
 690 }
 691
 692 /**
 693  *  @brief Set Radio header mode
 694  *  @param priv                 A pointer to wlan_private structure
 695  *  @param req                  A pointer to ifreq structure
 696  *  @return                     0 --success, otherwise fail
 697  */
 698 static int wlan_set_radiomode_ioctl(wlan_private * priv, struct ifreq *req)
 699 {
 700         int mode;
 701
 702         mode = (int)((struct ifreq *)((u8 *) req + 4))->ifr_data;
 703
 704         switch (mode) {
 705         case WLAN_RADIOMODE_NONE:
 706                 priv->adapter->radiomode = mode;
 707                 break;
 708         case WLAN_RADIOMODE_RADIOTAP:
 709                 priv->adapter->radiomode = mode;
 710                 break;
 711         default:
 712                 lbs_pr_debug(1, "usb8388-5: invalid radio header mode (%#x)\n",
 713                        mode);
 714                 return -EINVAL;
 715         }
 716         lbs_pr_debug(1, "usb8388-5: radio-header mode is %#x\n", mode);
 717
 718         adjust_mtu(priv);
 719         return 0;
 720 }
 721
 722 /**
 723  *  @brief Set Debug header mode
 724  *  @param priv                 A pointer to wlan_private structure
 725  *  @param req                  A pointer to ifreq structure
 726  *  @return                     0 --success, otherwise fail
 727  */
 728 static int wlan_set_debugmode_ioctl(wlan_private * priv, struct ifreq *req)
 729 {
 730         priv->adapter->debugmode = (int)((struct ifreq *)
 731                                          ((u8 *) req + 4))->ifr_data;
 732         return 0;
 733 }
 734
 735 static int wlan_subcmd_getrxantenna_ioctl(wlan_private * priv,
 736                                           struct ifreq *req)
 737 {
 738         int len;
 739         char buf[8];
 740         struct iwreq *wrq = (struct iwreq *)req;
 741
 742         lbs_pr_debug(1, "WLAN_SUBCMD_GETRXANTENNA\n");
 743         len = getrxantenna(priv, buf);
 744
 745         wrq->u.data.length = len;
 746         if (wrq->u.data.pointer) {
 747                 if (copy_to_user(wrq->u.data.pointer, &buf, len)) {
 748                         lbs_pr_debug(1, "CopyToUser failed\n");
 749                         return -EFAULT;
 750                 }
 751         }
 752
 753         return 0;
 754 }
 755
 756 static int wlan_subcmd_gettxantenna_ioctl(wlan_private * priv,
 757                                           struct ifreq *req)
 758 {
 759         int len;
 760         char buf[8];
 761         struct iwreq *wrq = (struct iwreq *)req;
 762
 763         lbs_pr_debug(1, "WLAN_SUBCMD_GETTXANTENNA\n");
 764         len = gettxantenna(priv, buf);
 765
 766         wrq->u.data.length = len;
 767         if (wrq->u.data.pointer) {
 768                 if (copy_to_user(wrq->u.data.pointer, &buf, len)) {
 769                         lbs_pr_debug(1, "CopyToUser failed\n");
 770                         return -EFAULT;
 771                 }
 772         }
 773         return 0;
 774 }
 775
 776 /**
 777  *  @brief Get the MAC TSF value from the firmware
 778  *
 779  *  @param priv         A pointer to wlan_private structure
 780  *  @param wrq          A pointer to iwreq structure containing buffer
 781  *                      space to store a TSF value retrieved from the firmware
 782  *
 783  *  @return             0 if successful; IOCTL error code otherwise
 784  */
 785 static int wlan_get_tsf_ioctl(wlan_private * priv, struct iwreq *wrq)
 786 {
 787         u64 tsfval;
 788         int ret;
 789
 790         ret = libertas_prepare_and_send_command(priv,
 791                                     cmd_get_tsf,
 792                                     0, cmd_option_waitforrsp, 0, &tsfval);
 793
 794         lbs_pr_debug(1, "IOCTL: Get TSF = 0x%016llx\n", tsfval);
 795
 796         if (ret != 0) {
 797                 lbs_pr_debug(1, "IOCTL: Get TSF; command exec failed\n");
 798                 ret = -EFAULT;
 799         } else {
 800                 if (copy_to_user(wrq->u.data.pointer,
 801                                  &tsfval,
 802                                  min_t(size_t, wrq->u.data.length,
 803                                      sizeof(tsfval))) != 0) {
 804
 805                         lbs_pr_debug(1, "IOCTL: Get TSF; Copy to user failed\n");
 806                         ret = -EFAULT;
 807                 } else {
 808                         ret = 0;
 809                 }
 810         }
 811         return ret;
 812 }
 813
 814 /**
 815  *  @brief Get/Set adapt rate
 816  *  @param priv                 A pointer to wlan_private structure
 817  *  @param wrq                  A pointer to iwreq structure
 818  *  @return                     0 --success, otherwise fail
 819  */
 820 static int wlan_adapt_rateset(wlan_private * priv, struct iwreq *wrq)
 821 {
 822         int ret;
 823         wlan_adapter *adapter = priv->adapter;
 824         int data[2];
 825
 826         memset(data, 0, sizeof(data));
 827         if (!wrq->u.data.length) {
 828                 lbs_pr_debug(1, "Get ADAPT RATE SET\n");
 829                 ret = libertas_prepare_and_send_command(priv,
 830                                             cmd_802_11_rate_adapt_rateset,
 831                                             cmd_act_get,
 832                                             cmd_option_waitforrsp, 0, NULL);
 833                 data[0] = adapter->enablehwauto;
 834                 data[1] = adapter->ratebitmap;
 835                 if (copy_to_user(wrq->u.data.pointer, data, sizeof(int) * 2)) {
 836                         lbs_pr_debug(1, "Copy to user failed\n");
 837                         return -EFAULT;
 838                 }
 839 #define GET_TWO_INT     2
 840                 wrq->u.data.length = GET_TWO_INT;
 841         } else {
 842                 lbs_pr_debug(1, "Set ADAPT RATE SET\n");
 843                 if (wrq->u.data.length > 2)
 844                         return -EINVAL;
 845                 if (copy_from_user
 846                     (data, wrq->u.data.pointer,
 847                      sizeof(int) * wrq->u.data.length)) {
 848                         lbs_pr_debug(1, "Copy from user failed\n");
 849                         return -EFAULT;
 850                 }
 851
 852                 adapter->enablehwauto = data[0];
 853                 adapter->ratebitmap = data[1];
 854                 ret = libertas_prepare_and_send_command(priv,
 855                                             cmd_802_11_rate_adapt_rateset,
 856                                             cmd_act_set,
 857                                             cmd_option_waitforrsp, 0, NULL);
 858         }
 859         return ret;
 860 }
 861
 862 /**
 863  *  @brief Get/Set inactivity timeout
 864  *  @param priv                 A pointer to wlan_private structure
 865  *  @param wrq                  A pointer to iwreq structure
 866  *  @return                     0 --success, otherwise fail
 867  */
 868 static int wlan_inactivity_timeout(wlan_private * priv, struct iwreq *wrq)
 869 {
 870         int ret;
 871         int data = 0;
 872         u16 timeout = 0;
 873
 874         ENTER();
 875         if (wrq->u.data.length > 1)
 876                 return -ENOTSUPP;
 877
 878         if (wrq->u.data.length == 0) {
 879                 /* Get */
 880                 ret = libertas_prepare_and_send_command(priv,
 881                                             cmd_802_11_inactivity_timeout,
 882                                             cmd_act_get,
 883                                             cmd_option_waitforrsp, 0,
 884                                             &timeout);
 885                 data = timeout;
 886                 if (copy_to_user(wrq->u.data.pointer, &data, sizeof(int))) {
 887                         lbs_pr_debug(1, "Copy to user failed\n");
 888                         return -EFAULT;
 889                 }
 890         } else {
 891                 /* Set */
 892                 if (copy_from_user(&data, wrq->u.data.pointer, sizeof(int))) {
 893                         lbs_pr_debug(1, "Copy from user failed\n");
 894                         return -EFAULT;
 895                 }
 896
 897                 timeout = data;
 898                 ret = libertas_prepare_and_send_command(priv,
 899                                             cmd_802_11_inactivity_timeout,
 900                                             cmd_act_set,
 901                                             cmd_option_waitforrsp, 0,
 902                                             &timeout);
 903         }
 904
 905         wrq->u.data.length = 1;
 906
 907         LEAVE();
 908         return ret;
 909 }
 910
 911 static int wlan_do_getlog_ioctl(wlan_private * priv, struct iwreq *wrq)
 912 {
 913         int ret;
 914         char buf[GETLOG_BUFSIZE - 1];
 915         wlan_adapter *adapter = priv->adapter;
 916
 917         lbs_pr_debug(1, " GET STATS\n");
 918
 919         ret = libertas_prepare_and_send_command(priv, cmd_802_11_get_log,
 920                                     0, cmd_option_waitforrsp, 0, NULL);
 921
 922         if (ret) {
 923                 return ret;
 924         }
 925
 926         if (wrq->u.data.pointer) {
 927                 sprintf(buf, "\n  mcasttxframe %u failed %u retry %u "
 928                         "multiretry %u framedup %u "
 929                         "rtssuccess %u rtsfailure %u ackfailure %u\n"
 930                         "rxfrag %u mcastrxframe %u fcserror %u "
 931                         "txframe %u wepundecryptable %u ",
 932                         adapter->logmsg.mcasttxframe,
 933                         adapter->logmsg.failed,
 934                         adapter->logmsg.retry,
 935                         adapter->logmsg.multiretry,
 936                         adapter->logmsg.framedup,
 937                         adapter->logmsg.rtssuccess,
 938                         adapter->logmsg.rtsfailure,
 939                         adapter->logmsg.ackfailure,
 940                         adapter->logmsg.rxfrag,
 941                         adapter->logmsg.mcastrxframe,
 942                         adapter->logmsg.fcserror,
 943                         adapter->logmsg.txframe,
 944                         adapter->logmsg.wepundecryptable);
 945                 wrq->u.data.length = strlen(buf) + 1;
 946                 if (copy_to_user(wrq->u.data.pointer, buf, wrq->u.data.length)) {
 947                         lbs_pr_debug(1, "Copy to user failed\n");
 948                         return -EFAULT;
 949                 }
 950         }
 951
 952         return 0;
 953 }
 954
 955 static int wlan_scan_type_ioctl(wlan_private * priv, struct iwreq *wrq)
 956 {
 957         u8 buf[12];
 958         u8 *option[] = { "active", "passive", "get", };
 959         int i, max_options = (sizeof(option) / sizeof(option[0]));
 960         int ret = 0;
 961         wlan_adapter *adapter = priv->adapter;
 962
 963         if (priv->adapter->enable11d) {
 964                 lbs_pr_debug(1, "11D: Cannot set scantype when 11D enabled\n");
 965                 return -EFAULT;
 966         }
 967
 968         memset(buf, 0, sizeof(buf));
 969
 970         if (copy_from_user(buf, wrq->u.data.pointer, min_t(size_t, sizeof(buf),
 971                                                          wrq->u.data.length)))
 972                 return -EFAULT;
 973
 974         lbs_pr_debug(1, "Scan type Option = %s\n", buf);
 975
 976         buf[sizeof(buf) - 1] = '\0';
 977
 978         for (i = 0; i < max_options; i++) {
 979                 if (!strcmp(buf, option[i]))
 980                         break;
 981         }
 982
 983         switch (i) {
 984         case 0:
 985                 adapter->scantype = cmd_scan_type_active;
 986                 break;
 987         case 1:
 988                 adapter->scantype = cmd_scan_type_passive;
 989                 break;
 990         case 2:
 991                 wrq->u.data.length = strlen(option[adapter->scantype]) + 1;
 992
 993                 if (copy_to_user(wrq->u.data.pointer,
 994                                  option[adapter->scantype],
 995                                  wrq->u.data.length)) {
 996                         lbs_pr_debug(1, "Copy to user failed\n");
 997                         ret = -EFAULT;
 998                 }
 999
1000                 break;
1001         default:
1002                 lbs_pr_debug(1, "Invalid Scan type Ioctl Option\n");
1003                 ret = -EINVAL;
1004                 break;
1005         }
1006
1007         return ret;
1008 }
1009
1010 static int wlan_scan_mode_ioctl(wlan_private * priv, struct iwreq *wrq)
1011 {
1012         wlan_adapter *adapter = priv->adapter;
1013         u8 buf[12];
1014         u8 *option[] = { "bss", "ibss", "any", "get" };
1015         int i, max_options = (sizeof(option) / sizeof(option[0]));
1016         int ret = 0;
1017
1018         ENTER();
1019
1020         memset(buf, 0, sizeof(buf));
1021
1022         if (copy_from_user(buf, wrq->u.data.pointer, min_t(size_t, sizeof(buf),
1023                                                          wrq->u.data.length))) {
1024                 lbs_pr_debug(1, "Copy from user failed\n");
1025                 return -EFAULT;
1026         }
1027
1028         lbs_pr_debug(1, "Scan mode Option = %s\n", buf);
1029
1030         buf[sizeof(buf) - 1] = '\0';
1031
1032         for (i = 0; i < max_options; i++) {
1033                 if (!strcmp(buf, option[i]))
1034                         break;
1035         }
1036
1037         switch (i) {
1038
1039         case 0:
1040                 adapter->scanmode = cmd_bss_type_bss;
1041                 break;
1042         case 1:
1043                 adapter->scanmode = cmd_bss_type_ibss;
1044                 break;
1045         case 2:
1046                 adapter->scanmode = cmd_bss_type_any;
1047                 break;
1048         case 3:
1049
1050                 wrq->u.data.length = strlen(option[adapter->scanmode - 1]) + 1;
1051
1052                 lbs_pr_debug(1, "Get Scan mode Option = %s\n",
1053                        option[adapter->scanmode - 1]);
1054
1055                 lbs_pr_debug(1, "Scan mode length %d\n", wrq->u.data.length);
1056
1057                 if (copy_to_user(wrq->u.data.pointer,
1058                                  option[adapter->scanmode - 1],
1059                                  wrq->u.data.length)) {
1060                         lbs_pr_debug(1, "Copy to user failed\n");
1061                         ret = -EFAULT;
1062                 }
1063                 lbs_pr_debug(1, "GET Scan type Option after copy = %s\n",
1064                        (char *)wrq->u.data.pointer);
1065
1066                 break;
1067
1068         default:
1069                 lbs_pr_debug(1, "Invalid Scan mode Ioctl Option\n");
1070                 ret = -EINVAL;
1071                 break;
1072         }
1073
1074         LEAVE();
1075         return ret;
1076 }
1077
1078 /**
1079  *  @brief Get/Set Adhoc G Rate
1080  *
1081  *  @param priv         A pointer to wlan_private structure
1082  *  @param wrq          A pointer to user data
1083  *  @return             0--success, otherwise fail
1084  */
1085 static int wlan_do_set_grate_ioctl(wlan_private * priv, struct iwreq *wrq)
1086 {
1087         wlan_adapter *adapter = priv->adapter;
1088         int data, data1;
1089         int *val;
1090
1091         ENTER();
1092
1093         data1 = SUBCMD_DATA(wrq);
1094         switch (data1) {
1095         case 0:
1096                 adapter->adhoc_grate_enabled = 0;
1097                 break;
1098         case 1:
1099                 adapter->adhoc_grate_enabled = 1;
1100                 break;
1101         case 2:
1102                 break;
1103         default:
1104                 return -EINVAL;
1105         }
1106         data = adapter->adhoc_grate_enabled;
1107         val = (int *)wrq->u.name;
1108         *val = data;
1109         LEAVE();
1110         return 0;
1111 }
1112
1113 static inline int hex2int(char c)
1114 {
1115         if (c >= '0' && c <= '9')
1116                 return (c - '0');
1117         if (c >= 'a' && c <= 'f')
1118                 return (c - 'a' + 10);
1119         if (c >= 'A' && c <= 'F')
1120                 return (c - 'A' + 10);
1121         return -1;
1122 }
1123
1124 /* Convert a string representation of a MAC address ("xx:xx:xx:xx:xx:xx")
1125    into binary format (6 bytes).
1126
1127    This function expects that each byte is represented with 2 characters
1128    (e.g., 11:2:11:11:11:11 is invalid)
1129
1130  */
1131 static char *eth_str2addr(char *ethstr, u8 * addr)
1132 {
1133         int i, val, val2;
1134         char *pos = ethstr;
1135
1136         /* get rid of initial blanks */
1137         while (*pos == ' ' || *pos == '\t')
1138                 ++pos;
1139
1140         for (i = 0; i < 6; i++) {
1141                 val = hex2int(*pos++);
1142                 if (val < 0)
1143                         return NULL;
1144                 val2 = hex2int(*pos++);
1145                 if (val2 < 0)
1146                         return NULL;
1147                 addr[i] = (val * 16 + val2) & 0xff;
1148
1149                 if (i < 5 && *pos++ != ':')
1150                         return NULL;
1151         }
1152         return pos;
1153 }
1154
1155 /* this writes xx:xx:xx:xx:xx:xx into ethstr
1156    (ethstr must have space for 18 chars) */
1157 static int eth_addr2str(u8 * addr, char *ethstr)
1158 {
1159         int i;
1160         char *pos = ethstr;
1161
1162         for (i = 0; i < 6; i++) {
1163                 sprintf(pos, "%02x", addr[i] & 0xff);
1164                 pos += 2;
1165                 if (i < 5)
1166                         *pos++ = ':';
1167         }
1168         return 17;
1169 }
1170
1171 /**
1172  *  @brief          Add an entry to the BT table
1173  *  @param priv     A pointer to wlan_private structure
1174  *  @param req      A pointer to ifreq structure
1175  *  @return         0 --success, otherwise fail
1176  */
1177 static int wlan_bt_add_ioctl(wlan_private * priv, struct ifreq *req)
1178 {
1179         struct iwreq *wrq = (struct iwreq *)req;
1180         char ethaddrs_str[18];
1181         char *pos;
1182         u8 ethaddr[ETH_ALEN];
1183
1184         ENTER();
1185         if (copy_from_user(ethaddrs_str, wrq->u.data.pointer,
1186                            sizeof(ethaddrs_str)))
1187                 return -EFAULT;
1188
1189         if ((pos = eth_str2addr(ethaddrs_str, ethaddr)) == NULL) {
1190                 lbs_pr_info("BT_ADD: Invalid MAC address\n");
1191                 return -EINVAL;
1192         }
1193
1194         lbs_pr_debug(1, "BT: adding %s\n", ethaddrs_str);
1195         LEAVE();
1196         return (libertas_prepare_and_send_command(priv, cmd_bt_access,
1197                                       cmd_act_bt_access_add,
1198                                       cmd_option_waitforrsp, 0, ethaddr));
1199 }
1200
1201 /**
1202  *  @brief          Delete an entry from the BT table
1203  *  @param priv     A pointer to wlan_private structure
1204  *  @param req      A pointer to ifreq structure
1205  *  @return         0 --success, otherwise fail
1206  */
1207 static int wlan_bt_del_ioctl(wlan_private * priv, struct ifreq *req)
1208 {
1209         struct iwreq *wrq = (struct iwreq *)req;
1210         char ethaddrs_str[18];
1211         u8 ethaddr[ETH_ALEN];
1212         char *pos;
1213
1214         ENTER();
1215         if (copy_from_user(ethaddrs_str, wrq->u.data.pointer,
1216                            sizeof(ethaddrs_str)))
1217                 return -EFAULT;
1218
1219         if ((pos = eth_str2addr(ethaddrs_str, ethaddr)) == NULL) {
1220                 lbs_pr_info("Invalid MAC address\n");
1221                 return -EINVAL;
1222         }
1223
1224         lbs_pr_debug(1, "BT: deleting %s\n", ethaddrs_str);
1225
1226         return (libertas_prepare_and_send_command(priv,
1227                                       cmd_bt_access,
1228                                       cmd_act_bt_access_del,
1229                                       cmd_option_waitforrsp, 0, ethaddr));
1230         LEAVE();
1231         return 0;
1232 }
1233
1234 /**
1235  *  @brief          Reset all entries from the BT table
1236  *  @param priv     A pointer to wlan_private structure
1237  *  @return         0 --success, otherwise fail
1238  */
1239 static int wlan_bt_reset_ioctl(wlan_private * priv)
1240 {
1241         ENTER();
1242
1243         lbs_pr_alert( "BT: resetting\n");
1244
1245         return (libertas_prepare_and_send_command(priv,
1246                                       cmd_bt_access,
1247                                       cmd_act_bt_access_reset,
1248                                       cmd_option_waitforrsp, 0, NULL));
1249
1250         LEAVE();
1251         return 0;
1252 }
1253
1254 /**
1255  *  @brief          List an entry from the BT table
1256  *  @param priv     A pointer to wlan_private structure
1257  *  @param req      A pointer to ifreq structure
1258  *  @return         0 --success, otherwise fail
1259  */
1260 static int wlan_bt_list_ioctl(wlan_private * priv, struct ifreq *req)
1261 {
1262         int pos;
1263         char *addr1;
1264         struct iwreq *wrq = (struct iwreq *)req;
1265         /* used to pass id and store the bt entry returned by the FW */
1266         union {
1267                 int id;
1268                 char addr1addr2[2 * ETH_ALEN];
1269         } param;
1270         static char outstr[64];
1271         char *pbuf = outstr;
1272         int ret;
1273
1274         ENTER();
1275
1276         if (copy_from_user(outstr, wrq->u.data.pointer, sizeof(outstr))) {
1277                 lbs_pr_debug(1, "Copy from user failed\n");
1278                 return -1;
1279         }
1280         param.id = simple_strtoul(outstr, NULL, 10);
1281         pos = sprintf(pbuf, "%d: ", param.id);
1282         pbuf += pos;
1283
1284         ret = libertas_prepare_and_send_command(priv, cmd_bt_access,
1285                                     cmd_act_bt_access_list,
1286                                     cmd_option_waitforrsp, 0,
1287                                     (char *)&param);
1288
1289         if (ret == 0) {
1290                 addr1 = param.addr1addr2;
1291
1292                 pos = sprintf(pbuf, "ignoring traffic from ");
1293                 pbuf += pos;
1294                 pos = eth_addr2str(addr1, pbuf);
1295                 pbuf += pos;
1296         } else {
1297                 sprintf(pbuf, "(null)");
1298                 pbuf += pos;
1299         }
1300
1301         wrq->u.data.length = strlen(outstr);
1302         if (copy_to_user(wrq->u.data.pointer, (char *)outstr,
1303                          wrq->u.data.length)) {
1304                 lbs_pr_debug(1, "BT_LIST: Copy to user failed!\n");
1305                 return -EFAULT;
1306         }
1307
1308         LEAVE();
1309         return 0;
1310 }
1311
1312 /**
1313  *  @brief          Find the next parameter in an input string
1314  *  @param ptr      A pointer to the input parameter string
1315  *  @return         A pointer to the next parameter, or 0 if no parameters left.
1316  */
1317 static char * next_param(char * ptr)
1318 {
1319         if (!ptr) return NULL;
1320         while (*ptr == ' ' || *ptr == '\t') ++ptr;
1321         return (*ptr == '\0') ? NULL : ptr;
1322 }
1323
1324 /**
1325  *  @brief          Add an entry to the FWT table
1326  *  @param priv     A pointer to wlan_private structure
1327  *  @param req      A pointer to ifreq structure
1328  *  @return         0 --success, otherwise fail
1329  */
1330 static int wlan_fwt_add_ioctl(wlan_private * priv, struct ifreq *req)
1331 {
1332         struct iwreq *wrq = (struct iwreq *)req;
1333         char in_str[128];
1334         static struct cmd_ds_fwt_access fwt_access;
1335         char *ptr;
1336
1337         ENTER();
1338         if (copy_from_user(in_str, wrq->u.data.pointer, sizeof(in_str)))
1339                 return -EFAULT;
1340
1341         if ((ptr = eth_str2addr(in_str, fwt_access.da)) == NULL) {
1342                 lbs_pr_alert( "FWT_ADD: Invalid MAC address 1\n");
1343                 return -EINVAL;
1344         }
1345
1346         if ((ptr = eth_str2addr(ptr, fwt_access.ra)) == NULL) {
1347                 lbs_pr_alert( "FWT_ADD: Invalid MAC address 2\n");
1348                 return -EINVAL;
1349         }
1350
1351         if ((ptr = next_param(ptr)))
1352                 fwt_access.metric =
1353                         cpu_to_le32(simple_strtoul(ptr, &ptr, 10));
1354         else
1355                 fwt_access.metric = FWT_DEFAULT_METRIC;
1356
1357         if ((ptr = next_param(ptr)))
1358                 fwt_access.dir = (u8)simple_strtoul(ptr, &ptr, 10);
1359         else
1360                 fwt_access.dir = FWT_DEFAULT_DIR;
1361
1362         if ((ptr = next_param(ptr)))
1363                 fwt_access.ssn =
1364                         cpu_to_le32(simple_strtoul(ptr, &ptr, 10));
1365         else
1366                 fwt_access.ssn = FWT_DEFAULT_SSN;
1367
1368         if ((ptr = next_param(ptr)))
1369                 fwt_access.dsn =
1370                         cpu_to_le32(simple_strtoul(ptr, &ptr, 10));
1371         else
1372                 fwt_access.dsn = FWT_DEFAULT_DSN;
1373
1374         if ((ptr = next_param(ptr)))
1375                 fwt_access.hopcount = simple_strtoul(ptr, &ptr, 10);
1376         else
1377                 fwt_access.hopcount = FWT_DEFAULT_HOPCOUNT;
1378
1379         if ((ptr = next_param(ptr)))
1380                 fwt_access.ttl = simple_strtoul(ptr, &ptr, 10);
1381         else
1382                 fwt_access.ttl = FWT_DEFAULT_TTL;
1383
1384         if ((ptr = next_param(ptr)))
1385                 fwt_access.expiration =
1386                         cpu_to_le32(simple_strtoul(ptr, &ptr, 10));
1387         else
1388                 fwt_access.expiration = FWT_DEFAULT_EXPIRATION;
1389
1390         if ((ptr = next_param(ptr)))
1391                 fwt_access.sleepmode = (u8)simple_strtoul(ptr, &ptr, 10);
1392         else
1393                 fwt_access.sleepmode = FWT_DEFAULT_SLEEPMODE;
1394
1395         if ((ptr = next_param(ptr)))
1396                 fwt_access.snr =
1397                         cpu_to_le32(simple_strtoul(ptr, &ptr, 10));
1398         else
1399                 fwt_access.snr = FWT_DEFAULT_SNR;
1400
1401 #ifdef DEBUG
1402         {
1403                 char ethaddr1_str[18], ethaddr2_str[18];
1404                 eth_addr2str(fwt_access.da, ethaddr1_str);
1405                 eth_addr2str(fwt_access.ra, ethaddr2_str);
1406                 lbs_pr_debug(1, "FWT_ADD: adding (da:%s,%i,ra:%s)\n", ethaddr1_str,
1407                        fwt_access.dir, ethaddr2_str);
1408                 lbs_pr_debug(1, "FWT_ADD: ssn:%u dsn:%u met:%u hop:%u ttl:%u exp:%u slp:%u snr:%u\n",
1409                        fwt_access.ssn, fwt_access.dsn, fwt_access.metric,
1410                        fwt_access.hopcount, fwt_access.ttl, fwt_access.expiration,
1411                        fwt_access.sleepmode, fwt_access.snr);
1412         }
1413 #endif
1414
1415         LEAVE();
1416         return (libertas_prepare_and_send_command(priv, cmd_fwt_access,
1417                                                   cmd_act_fwt_access_add,
1418                                                   cmd_option_waitforrsp, 0,
1419                                                   (void *)&fwt_access));
1420 }
1421
1422 /**
1423  *  @brief          Delete an entry from the FWT table
1424  *  @param priv     A pointer to wlan_private structure
1425  *  @param req      A pointer to ifreq structure
1426  *  @return         0 --success, otherwise fail
1427  */
1428 static int wlan_fwt_del_ioctl(wlan_private * priv, struct ifreq *req)
1429 {
1430         struct iwreq *wrq = (struct iwreq *)req;
1431         char in_str[64];
1432         static struct cmd_ds_fwt_access fwt_access;
1433         char *ptr;
1434
1435         ENTER();
1436         if (copy_from_user(in_str, wrq->u.data.pointer, sizeof(in_str)))
1437                 return -EFAULT;
1438
1439         if ((ptr = eth_str2addr(in_str, fwt_access.da)) == NULL) {
1440                 lbs_pr_alert( "FWT_DEL: Invalid MAC address 1\n");
1441                 return -EINVAL;
1442         }
1443
1444         if ((ptr = eth_str2addr(ptr, fwt_access.ra)) == NULL) {
1445                 lbs_pr_alert( "FWT_DEL: Invalid MAC address 2\n");
1446                 return -EINVAL;
1447         }
1448
1449         if ((ptr = next_param(ptr)))
1450                 fwt_access.dir = (u8)simple_strtoul(ptr, &ptr, 10);
1451         else
1452                 fwt_access.dir = FWT_DEFAULT_DIR;
1453
1454 #ifdef DEBUG
1455         {
1456                 char ethaddr1_str[18], ethaddr2_str[18];
1457                 lbs_pr_debug(1, "FWT_DEL: line is %s\n", in_str);
1458                 eth_addr2str(fwt_access.da, ethaddr1_str);
1459                 eth_addr2str(fwt_access.ra, ethaddr2_str);
1460                 lbs_pr_debug(1, "FWT_DEL: removing (da:%s,ra:%s,dir:%d)\n", ethaddr1_str,
1461                        ethaddr2_str, fwt_access.dir);
1462         }
1463 #endif
1464
1465         LEAVE();
1466         return (libertas_prepare_and_send_command(priv,
1467                                                   cmd_fwt_access,
1468                                                   cmd_act_fwt_access_del,
1469                                                   cmd_option_waitforrsp, 0,
1470                                                   (void *)&fwt_access));
1471 }
1472
1473
1474 /**
1475  *  @brief             Print route parameters
1476  *  @param fwt_access  struct cmd_ds_fwt_access with route info
1477  *  @param buf         destination buffer for route info
1478  */
1479 static void print_route(struct cmd_ds_fwt_access fwt_access, char *buf)
1480 {
1481         buf += sprintf(buf, " ");
1482         buf += eth_addr2str(fwt_access.da, buf);
1483         buf += sprintf(buf, " ");
1484         buf += eth_addr2str(fwt_access.ra, buf);
1485         buf += sprintf(buf, " %u", le32_to_cpu(fwt_access.metric));
1486         buf += sprintf(buf, " %u", fwt_access.dir);
1487         buf += sprintf(buf, " %u", le32_to_cpu(fwt_access.ssn));
1488         buf += sprintf(buf, " %u", le32_to_cpu(fwt_access.dsn));
1489         buf += sprintf(buf, " %u", fwt_access.hopcount);
1490         buf += sprintf(buf, " %u", fwt_access.ttl);
1491         buf += sprintf(buf, " %u", le32_to_cpu(fwt_access.expiration));
1492         buf += sprintf(buf, " %u", fwt_access.sleepmode);
1493         buf += sprintf(buf, " %u", le32_to_cpu(fwt_access.snr));
1494 }
1495
1496 /**
1497  *  @brief          Lookup an entry in the FWT table
1498  *  @param priv     A pointer to wlan_private structure
1499  *  @param req      A pointer to ifreq structure
1500  *  @return         0 --success, otherwise fail
1501  */
1502 static int wlan_fwt_lookup_ioctl(wlan_private * priv, struct ifreq *req)
1503 {
1504         struct iwreq *wrq = (struct iwreq *)req;
1505         char in_str[64];
1506         char *ptr;
1507         static struct cmd_ds_fwt_access fwt_access;
1508         static char out_str[128];
1509         int ret;
1510
1511         ENTER();
1512         if (copy_from_user(in_str, wrq->u.data.pointer, sizeof(in_str)))
1513                 return -EFAULT;
1514
1515         if ((ptr = eth_str2addr(in_str, fwt_access.da)) == NULL) {
1516                 lbs_pr_alert( "FWT_LOOKUP: Invalid MAC address\n");
1517                 return -EINVAL;
1518         }
1519
1520 #ifdef DEBUG
1521         {
1522                 char ethaddr1_str[18];
1523                 lbs_pr_debug(1, "FWT_LOOKUP: line is %s\n", in_str);
1524                 eth_addr2str(fwt_access.da, ethaddr1_str);
1525                 lbs_pr_debug(1, "FWT_LOOKUP: looking for (da:%s)\n", ethaddr1_str);
1526         }
1527 #endif
1528
1529         ret = libertas_prepare_and_send_command(priv,
1530                                                 cmd_fwt_access,
1531                                                 cmd_act_fwt_access_lookup,
1532                                                 cmd_option_waitforrsp, 0,
1533                                                 (void *)&fwt_access);
1534
1535         if (ret == 0)
1536                 print_route(fwt_access, out_str);
1537         else
1538                 sprintf(out_str, "(null)");
1539
1540         wrq->u.data.length = strlen(out_str);
1541         if (copy_to_user(wrq->u.data.pointer, (char *)out_str,
1542                          wrq->u.data.length)) {
1543                 lbs_pr_debug(1, "FWT_LOOKUP: Copy to user failed!\n");
1544                 return -EFAULT;
1545         }
1546
1547         LEAVE();
1548         return 0;
1549 }
1550
1551 /**
1552  *  @brief          Reset all entries from the FWT table
1553  *  @param priv     A pointer to wlan_private structure
1554  *  @return         0 --success, otherwise fail
1555  */
1556 static int wlan_fwt_reset_ioctl(wlan_private * priv)
1557 {
1558         lbs_pr_debug(1, "FWT: resetting\n");
1559
1560         return (libertas_prepare_and_send_command(priv,
1561                                       cmd_fwt_access,
1562                                       cmd_act_fwt_access_reset,
1563                                       cmd_option_waitforrsp, 0, NULL));
1564 }
1565
1566 /**
1567  *  @brief          List an entry from the FWT table
1568  *  @param priv     A pointer to wlan_private structure
1569  *  @param req      A pointer to ifreq structure
1570  *  @return         0 --success, otherwise fail
1571  */
1572 static int wlan_fwt_list_ioctl(wlan_private * priv, struct ifreq *req)
1573 {
1574         struct iwreq *wrq = (struct iwreq *)req;
1575         char in_str[8];
1576         static struct cmd_ds_fwt_access fwt_access;
1577         char *ptr = in_str;
1578         static char out_str[128];
1579         char *pbuf = out_str;
1580         int ret;
1581
1582         ENTER();
1583         if (copy_from_user(in_str, wrq->u.data.pointer, sizeof(in_str)))
1584                 return -EFAULT;
1585
1586         fwt_access.id = cpu_to_le32(simple_strtoul(ptr, &ptr, 10));
1587
1588 #ifdef DEBUG
1589         {
1590                 lbs_pr_debug(1, "FWT_LIST: line is %s\n", in_str);
1591                 lbs_pr_debug(1, "FWT_LIST: listing id:%i\n", le32_to_cpu(fwt_access.id));
1592         }
1593 #endif
1594
1595         ret = libertas_prepare_and_send_command(priv, cmd_fwt_access,
1596                                     cmd_act_fwt_access_list,
1597                                     cmd_option_waitforrsp, 0, (void *)&fwt_access);
1598
1599         if (ret == 0)
1600                 print_route(fwt_access, pbuf);
1601         else
1602                 pbuf += sprintf(pbuf, " (null)");
1603
1604         wrq->u.data.length = strlen(out_str);
1605         if (copy_to_user(wrq->u.data.pointer, (char *)out_str,
1606                          wrq->u.data.length)) {
1607                 lbs_pr_debug(1, "FWT_LIST: Copy to user failed!\n");
1608                 return -EFAULT;
1609         }
1610
1611         LEAVE();
1612         return 0;
1613 }
1614
1615 /**
1616  *  @brief          List an entry from the FRT table
1617  *  @param priv     A pointer to wlan_private structure
1618  *  @param req      A pointer to ifreq structure
1619  *  @return         0 --success, otherwise fail
1620  */
1621 static int wlan_fwt_list_route_ioctl(wlan_private * priv, struct ifreq *req)
1622 {
1623         struct iwreq *wrq = (struct iwreq *)req;
1624         char in_str[64];
1625         static struct cmd_ds_fwt_access fwt_access;
1626         char *ptr = in_str;
1627         static char out_str[128];
1628         char *pbuf = out_str;
1629         int ret;
1630
1631         ENTER();
1632         if (copy_from_user(in_str, wrq->u.data.pointer, sizeof(in_str)))
1633                 return -EFAULT;
1634
1635         fwt_access.id = cpu_to_le32(simple_strtoul(ptr, &ptr, 10));
1636
1637 #ifdef DEBUG
1638         {
1639                 lbs_pr_debug(1, "FWT_LIST_ROUTE: line is %s\n", in_str);
1640                 lbs_pr_debug(1, "FWT_LIST_ROUTE: listing id:%i\n", le32_to_cpu(fwt_access.id));
1641         }
1642 #endif
1643
1644         ret = libertas_prepare_and_send_command(priv, cmd_fwt_access,
1645                                     cmd_act_fwt_access_list_route,
1646                                     cmd_option_waitforrsp, 0, (void *)&fwt_access);
1647
1648         if (ret == 0) {
1649                 pbuf += sprintf(pbuf, " ");
1650                 pbuf += eth_addr2str(fwt_access.da, pbuf);
1651                 pbuf += sprintf(pbuf, " %u", le32_to_cpu(fwt_access.metric));
1652                 pbuf += sprintf(pbuf, " %u", fwt_access.dir);
1653                 /* note that the firmware returns the nid in the id field */
1654                 pbuf += sprintf(pbuf, " %u", le32_to_cpu(fwt_access.id));
1655                 pbuf += sprintf(pbuf, " %u", le32_to_cpu(fwt_access.ssn));
1656                 pbuf += sprintf(pbuf, " %u", le32_to_cpu(fwt_access.dsn));
1657                 pbuf += sprintf(pbuf, "  hop %u", fwt_access.hopcount);
1658                 pbuf += sprintf(pbuf, "  ttl %u", fwt_access.ttl);
1659                 pbuf += sprintf(pbuf, " %u", le32_to_cpu(fwt_access.expiration));
1660         } else
1661                 pbuf += sprintf(pbuf, " (null)");
1662
1663         wrq->u.data.length = strlen(out_str);
1664         if (copy_to_user(wrq->u.data.pointer, (char *)out_str,
1665                          wrq->u.data.length)) {
1666                 lbs_pr_debug(1, "FWT_LIST_ROUTE: Copy to user failed!\n");
1667                 return -EFAULT;
1668         }
1669
1670         LEAVE();
1671         return 0;
1672 }
1673
1674 /**
1675  *  @brief          List an entry from the FNT table
1676  *  @param priv     A pointer to wlan_private structure
1677  *  @param req      A pointer to ifreq structure
1678  *  @return         0 --success, otherwise fail
1679  */
1680 static int wlan_fwt_list_neighbor_ioctl(wlan_private * priv, struct ifreq *req)
1681 {
1682         struct iwreq *wrq = (struct iwreq *)req;
1683         char in_str[8];
1684         static struct cmd_ds_fwt_access fwt_access;
1685         char *ptr = in_str;
1686         static char out_str[128];
1687         char *pbuf = out_str;
1688         int ret;
1689
1690         ENTER();
1691         if (copy_from_user(in_str, wrq->u.data.pointer, sizeof(in_str)))
1692                 return -EFAULT;
1693
1694         memset(&fwt_access, 0, sizeof(fwt_access));
1695         fwt_access.id = cpu_to_le32(simple_strtoul(ptr, &ptr, 10));
1696
1697 #ifdef DEBUG
1698         {
1699                 lbs_pr_debug(1, "FWT_LIST_NEIGHBOR: line is %s\n", in_str);
1700                 lbs_pr_debug(1, "FWT_LIST_NEIGHBOR: listing id:%i\n", le32_to_cpu(fwt_access.id));
1701         }
1702 #endif
1703
1704         ret = libertas_prepare_and_send_command(priv, cmd_fwt_access,
1705                                     cmd_act_fwt_access_list_neighbor,
1706                                     cmd_option_waitforrsp, 0,
1707                                     (void *)&fwt_access);
1708
1709         if (ret == 0) {
1710                 pbuf += sprintf(pbuf, " ra ");
1711                 pbuf += eth_addr2str(fwt_access.ra, pbuf);
1712                 pbuf += sprintf(pbuf, "  slp %u", fwt_access.sleepmode);
1713                 pbuf += sprintf(pbuf, "  snr %u", le32_to_cpu(fwt_access.snr));
1714                 pbuf += sprintf(pbuf, "  ref %u", le32_to_cpu(fwt_access.references));
1715         } else
1716                 pbuf += sprintf(pbuf, " (null)");
1717
1718         wrq->u.data.length = strlen(out_str);
1719         if (copy_to_user(wrq->u.data.pointer, (char *)out_str,
1720                          wrq->u.data.length)) {
1721                 lbs_pr_debug(1, "FWT_LIST_NEIGHBOR: Copy to user failed!\n");
1722                 return -EFAULT;
1723         }
1724
1725         LEAVE();
1726         return 0;
1727 }
1728
1729 /**
1730  *  @brief          Cleans up the route (FRT) and neighbor (FNT) tables
1731  *                  (Garbage Collection)
1732  *  @param priv     A pointer to wlan_private structure
1733  *  @param req      A pointer to ifreq structure
1734  *  @return         0 --success, otherwise fail
1735  */
1736 static int wlan_fwt_cleanup_ioctl(wlan_private * priv, struct ifreq *req)
1737 {
1738         static struct cmd_ds_fwt_access fwt_access;
1739         int ret;
1740
1741         ENTER();
1742
1743         lbs_pr_debug(1, "FWT: cleaning up\n");
1744
1745         memset(&fwt_access, 0, sizeof(fwt_access));
1746
1747         ret = libertas_prepare_and_send_command(priv, cmd_fwt_access,
1748                                     cmd_act_fwt_access_cleanup,
1749                                     cmd_option_waitforrsp, 0,
1750                                     (void *)&fwt_access);
1751
1752         if (ret == 0)
1753                 req->ifr_data = (char *)(le32_to_cpu(fwt_access.references));
1754         else
1755                 return -EFAULT;
1756
1757         LEAVE();
1758         return 0;
1759 }
1760
1761 /**
1762  *  @brief          Gets firmware internal time (debug purposes)
1763  *  @param priv     A pointer to wlan_private structure
1764  *  @param req      A pointer to ifreq structure
1765  *  @return         0 --success, otherwise fail
1766  */
1767 static int wlan_fwt_time_ioctl(wlan_private * priv, struct ifreq *req)
1768 {
1769         static struct cmd_ds_fwt_access fwt_access;
1770         int ret;
1771
1772         ENTER();
1773
1774         lbs_pr_debug(1, "FWT: getting time\n");
1775
1776         memset(&fwt_access, 0, sizeof(fwt_access));
1777
1778         ret = libertas_prepare_and_send_command(priv, cmd_fwt_access,
1779                                     cmd_act_fwt_access_time,
1780                                     cmd_option_waitforrsp, 0,
1781                                     (void *)&fwt_access);
1782
1783         if (ret == 0)
1784                 req->ifr_data = (char *)(le32_to_cpu(fwt_access.references));
1785         else
1786                 return -EFAULT;
1787
1788         LEAVE();
1789         return 0;
1790 }
1791
1792 /**
1793  *  @brief          Gets mesh ttl from firmware
1794  *  @param priv     A pointer to wlan_private structure
1795  *  @param req      A pointer to ifreq structure
1796  *  @return         0 --success, otherwise fail
1797  */
1798 static int wlan_mesh_get_ttl_ioctl(wlan_private * priv, struct ifreq *req)
1799 {
1800         struct cmd_ds_mesh_access mesh_access;
1801         int ret;
1802
1803         ENTER();
1804
1805         memset(&mesh_access, 0, sizeof(mesh_access));
1806
1807         ret = libertas_prepare_and_send_command(priv, cmd_mesh_access,
1808                                     cmd_act_mesh_get_ttl,
1809                                     cmd_option_waitforrsp, 0,
1810                                     (void *)&mesh_access);
1811
1812         if (ret == 0) {
1813                 req->ifr_data = (char *)(le32_to_cpu(mesh_access.data[0]));
1814         }
1815         else
1816                 return -EFAULT;
1817
1818         LEAVE();
1819         return 0;
1820 }
1821
1822 /**
1823  *  @brief          Gets mesh ttl from firmware
1824  *  @param priv     A pointer to wlan_private structure
1825  *  @param ttl      New ttl value
1826  *  @return         0 --success, otherwise fail
1827  */
1828 static int wlan_mesh_set_ttl_ioctl(wlan_private * priv, int ttl)
1829 {
1830         struct cmd_ds_mesh_access mesh_access;
1831         int ret;
1832
1833         ENTER();
1834
1835         if( (ttl > 0xff) || (ttl < 0) )
1836                 return -EINVAL;
1837
1838         memset(&mesh_access, 0, sizeof(mesh_access));
1839         mesh_access.data[0] = ttl;
1840
1841         ret = libertas_prepare_and_send_command(priv, cmd_mesh_access,
1842                                                 cmd_act_mesh_set_ttl,
1843                                                 cmd_option_waitforrsp, 0,
1844                                                 (void *)&mesh_access);
1845
1846         if (ret != 0)
1847                 ret = -EFAULT;
1848
1849         LEAVE();
1850         return ret;
1851 }
1852
1853 /**
1854  *  @brief ioctl function - entry point
1855  *
1856  *  @param dev          A pointer to net_device structure
1857  *  @param req          A pointer to ifreq structure
1858  *  @param cmd          command
1859  *  @return             0--success, otherwise fail
1860  */
1861 int libertas_do_ioctl(struct net_device *dev, struct ifreq *req, int cmd)
1862 {
1863         int subcmd = 0;
1864         int idata = 0;
1865         int *pdata;
1866         int ret = 0;
1867         wlan_private *priv = dev->priv;
1868         wlan_adapter *adapter = priv->adapter;
1869         struct iwreq *wrq = (struct iwreq *)req;
1870
1871         ENTER();
1872
1873         lbs_pr_debug(1, "libertas_do_ioctl: ioctl cmd = 0x%x\n", cmd);
1874         switch (cmd) {
1875         case WLANSCAN_TYPE:
1876                 lbs_pr_debug(1, "Scan type Ioctl\n");
1877                 ret = wlan_scan_type_ioctl(priv, wrq);
1878                 break;
1879
1880         case WLAN_SETNONE_GETNONE:      /* set WPA mode on/off ioctl #20 */
1881                 switch (wrq->u.data.flags) {
1882                 case WLANDEAUTH:
1883                         lbs_pr_debug(1, "Deauth\n");
1884                         libertas_send_deauth(priv);
1885                         break;
1886
1887                 case WLANADHOCSTOP:
1888                         lbs_pr_debug(1, "Adhoc stop\n");
1889                         ret = libertas_do_adhocstop_ioctl(priv);
1890                         break;
1891
1892                 case WLANRADIOON:
1893                         wlan_radio_ioctl(priv, 1);
1894                         break;
1895
1896                 case WLANRADIOOFF:
1897                         wlan_radio_ioctl(priv, 0);
1898                         break;
1899                 case WLANWLANIDLEON:
1900                         libertas_idle_on(priv);
1901                         break;
1902                 case WLANWLANIDLEOFF:
1903                         libertas_idle_off(priv);
1904                         break;
1905                 case WLAN_SUBCMD_BT_RESET:      /* bt_reset */
1906                         wlan_bt_reset_ioctl(priv);
1907                         break;
1908                 case WLAN_SUBCMD_FWT_RESET:     /* fwt_reset */
1909                         wlan_fwt_reset_ioctl(priv);
1910                         break;
1911                 }               /* End of switch */
1912                 break;
1913
1914         case WLANSETWPAIE:
1915                 ret = wlan_setwpaie_ioctl(priv, req);
1916                 break;
1917         case WLAN_SETINT_GETINT:
1918                 /* The first 4 bytes of req->ifr_data is sub-ioctl number
1919                  * after 4 bytes sits the payload.
1920                  */
1921                 subcmd = (int)req->ifr_data;    //from iwpriv subcmd
1922                 switch (subcmd) {
1923                 case WLANNF:
1924                         ret = wlan_get_nf(priv, wrq);
1925                         break;
1926                 case WLANRSSI:
1927                         ret = wlan_get_rssi(priv, wrq);
1928                         break;
1929                 case WLANENABLE11D:
1930                         ret = libertas_cmd_enable_11d(priv, wrq);
1931                         break;
1932                 case WLANADHOCGRATE:
1933                         ret = wlan_do_set_grate_ioctl(priv, wrq);
1934                         break;
1935                 case WLAN_SUBCMD_SET_PRESCAN:
1936                         ret = wlan_subcmd_setprescan_ioctl(priv, wrq);
1937                         break;
1938                 }
1939                 break;
1940
1941         case WLAN_SETONEINT_GETONEINT:
1942                 switch (wrq->u.data.flags) {
1943                 case WLAN_BEACON_INTERVAL:
1944                         ret = wlan_beacon_interval(priv, wrq);
1945                         break;
1946
1947                 case WLAN_LISTENINTRVL:
1948                         if (!wrq->u.data.length) {
1949                                 int data;
1950                                 lbs_pr_debug(1, "Get locallisteninterval value\n");
1951 #define GET_ONE_INT     1
1952                                 data = adapter->locallisteninterval;
1953                                 if (copy_to_user(wrq->u.data.pointer,
1954                                                  &data, sizeof(int))) {
1955                                         lbs_pr_debug(1, "Copy to user failed\n");
1956                                         return -EFAULT;
1957                                 }
1958
1959                                 wrq->u.data.length = GET_ONE_INT;
1960                         } else {
1961                                 int data;
1962                                 if (copy_from_user
1963                                     (&data, wrq->u.data.pointer, sizeof(int))) {
1964                                         lbs_pr_debug(1, "Copy from user failed\n");
1965                                         return -EFAULT;
1966                                 }
1967
1968                                 lbs_pr_debug(1, "Set locallisteninterval = %d\n",
1969                                        data);
1970 #define MAX_U16_VAL     65535
1971                                 if (data > MAX_U16_VAL) {
1972                                         lbs_pr_debug(1, "Exceeds U16 value\n");
1973                                         return -EINVAL;
1974                                 }
1975                                 adapter->locallisteninterval = data;
1976                         }
1977                         break;
1978                 case WLAN_TXCONTROL:
1979                         ret = wlan_txcontrol(priv, wrq);        //adds for txcontrol ioctl
1980                         break;
1981
1982                 case WLAN_NULLPKTINTERVAL:
1983                         ret = wlan_null_pkt_interval(priv, wrq);
1984                         break;
1985
1986                 default:
1987                         ret = -EOPNOTSUPP;
1988                         break;
1989                 }
1990                 break;
1991
1992         case WLAN_SETONEINT_GETNONE:
1993                 /* The first 4 bytes of req->ifr_data is sub-ioctl number
1994                  * after 4 bytes sits the payload.
1995                  */
1996                 subcmd = wrq->u.data.flags;     //from wpa_supplicant subcmd
1997
1998                 if (!subcmd)
1999                         subcmd = (int)req->ifr_data;    //from iwpriv subcmd
2000
2001                 switch (subcmd) {
2002                 case WLAN_SUBCMD_SETRXANTENNA:  /* SETRXANTENNA */
2003                         idata = SUBCMD_DATA(wrq);
2004                         ret = setrxantenna(priv, idata);
2005                         break;
2006                 case WLAN_SUBCMD_SETTXANTENNA:  /* SETTXANTENNA */
2007                         idata = SUBCMD_DATA(wrq);
2008                         ret = settxantenna(priv, idata);
2009                         break;
2010                 case WLAN_SET_ATIM_WINDOW:
2011                         adapter->atimwindow = SUBCMD_DATA(wrq);
2012                         adapter->atimwindow = min_t(__u16, adapter->atimwindow, 50);
2013                         break;
2014                 case WLANSETBCNAVG:
2015                         adapter->bcn_avg_factor = SUBCMD_DATA(wrq);
2016                         if (adapter->bcn_avg_factor == 0)
2017                                 adapter->bcn_avg_factor =
2018                                     DEFAULT_BCN_AVG_FACTOR;
2019                         if (adapter->bcn_avg_factor > DEFAULT_BCN_AVG_FACTOR)
2020                                 adapter->bcn_avg_factor =
2021                                     DEFAULT_BCN_AVG_FACTOR;
2022                         break;
2023                 case WLANSETDATAAVG:
2024                         adapter->data_avg_factor = SUBCMD_DATA(wrq);
2025                         if (adapter->data_avg_factor == 0)
2026                                 adapter->data_avg_factor =
2027                                     DEFAULT_DATA_AVG_FACTOR;
2028                         if (adapter->data_avg_factor > DEFAULT_DATA_AVG_FACTOR)
2029                                 adapter->data_avg_factor =
2030                                     DEFAULT_DATA_AVG_FACTOR;
2031                         break;
2032                 case WLANSETREGION:
2033                         idata = SUBCMD_DATA(wrq);
2034                         ret = wlan_set_region(priv, (u16) idata);
2035                         break;
2036
2037                 case WLAN_SET_LISTEN_INTERVAL:
2038                         idata = SUBCMD_DATA(wrq);
2039                         adapter->listeninterval = (u16) idata;
2040                         break;
2041
2042                 case WLAN_SET_MULTIPLE_DTIM:
2043                         ret = wlan_set_multiple_dtim_ioctl(priv, req);
2044                         break;
2045
2046                 case WLANSETAUTHALG:
2047                         ret = wlan_setauthalg_ioctl(priv, req);
2048                         break;
2049
2050                 case WLANSETENCRYPTIONMODE:
2051                         ret = wlan_setencryptionmode_ioctl(priv, req);
2052                         break;
2053
2054                 case WLAN_SET_LINKMODE:
2055                         ret = wlan_set_linkmode_ioctl(priv, req);
2056                         break;
2057
2058                 case WLAN_SET_RADIOMODE:
2059                         ret = wlan_set_radiomode_ioctl(priv, req);
2060                         break;
2061
2062                 case WLAN_SET_DEBUGMODE:
2063                         ret = wlan_set_debugmode_ioctl(priv, req);
2064                         break;
2065
2066                 case WLAN_SUBCMD_MESH_SET_TTL:
2067                         idata = SUBCMD_DATA(wrq);
2068                         ret = wlan_mesh_set_ttl_ioctl(priv, idata);
2069                         break;
2070
2071                 default:
2072                         ret = -EOPNOTSUPP;
2073                         break;
2074                 }
2075
2076                 break;
2077
2078         case WLAN_SETNONE_GETTWELVE_CHAR:       /* Get Antenna settings */
2079                 /*
2080                  * We've not used IW_PRIV_TYPE_FIXED so sub-ioctl number is
2081                  * in flags of iwreq structure, otherwise it will be in
2082                  * mode member of iwreq structure.
2083                  */
2084                 switch ((int)wrq->u.data.flags) {
2085                 case WLAN_SUBCMD_GETRXANTENNA:  /* Get Rx Antenna */
2086                         ret = wlan_subcmd_getrxantenna_ioctl(priv, req);
2087                         break;
2088
2089                 case WLAN_SUBCMD_GETTXANTENNA:  /* Get Tx Antenna */
2090                         ret = wlan_subcmd_gettxantenna_ioctl(priv, req);
2091                         break;
2092
2093                 case WLAN_GET_TSF:
2094                         ret = wlan_get_tsf_ioctl(priv, wrq);
2095                         break;
2096                 }
2097                 break;
2098
2099         case WLAN_SET128CHAR_GET128CHAR:
2100                 switch ((int)wrq->u.data.flags) {
2101
2102                 case WLANSCAN_MODE:
2103                         lbs_pr_debug(1, "Scan mode Ioctl\n");
2104                         ret = wlan_scan_mode_ioctl(priv, wrq);
2105                         break;
2106
2107                 case WLAN_GET_ADHOC_STATUS:
2108                         ret = wlan_get_adhoc_status_ioctl(priv, wrq);
2109                         break;
2110                 case WLAN_SUBCMD_BT_ADD:
2111                         ret = wlan_bt_add_ioctl(priv, req);
2112                         break;
2113                 case WLAN_SUBCMD_BT_DEL:
2114                         ret = wlan_bt_del_ioctl(priv, req);
2115                         break;
2116                 case WLAN_SUBCMD_BT_LIST:
2117                         ret = wlan_bt_list_ioctl(priv, req);
2118                         break;
2119                 case WLAN_SUBCMD_FWT_ADD:
2120                         ret = wlan_fwt_add_ioctl(priv, req);
2121                         break;
2122                 case WLAN_SUBCMD_FWT_DEL:
2123                         ret = wlan_fwt_del_ioctl(priv, req);
2124                         break;
2125                 case WLAN_SUBCMD_FWT_LOOKUP:
2126                         ret = wlan_fwt_lookup_ioctl(priv, req);
2127                         break;
2128                 case WLAN_SUBCMD_FWT_LIST_NEIGHBOR:
2129                         ret = wlan_fwt_list_neighbor_ioctl(priv, req);
2130                         break;
2131                 case WLAN_SUBCMD_FWT_LIST:
2132                         ret = wlan_fwt_list_ioctl(priv, req);
2133                         break;
2134                 case WLAN_SUBCMD_FWT_LIST_ROUTE:
2135                         ret = wlan_fwt_list_route_ioctl(priv, req);
2136                         break;
2137                 }
2138                 break;
2139
2140         case WLAN_SETNONE_GETONEINT:
2141                 switch ((int)req->ifr_data) {
2142                 case WLANGETBCNAVG:
2143                         pdata = (int *)wrq->u.name;
2144                         *pdata = (int)adapter->bcn_avg_factor;
2145                         break;
2146
2147                 case WLANGETREGION:
2148                         pdata = (int *)wrq->u.name;
2149                         *pdata = (int)adapter->regioncode;
2150                         break;
2151
2152                 case WLAN_GET_LISTEN_INTERVAL:
2153                         pdata = (int *)wrq->u.name;
2154                         *pdata = (int)adapter->listeninterval;
2155                         break;
2156
2157                 case WLAN_GET_LINKMODE:
2158                         req->ifr_data = (char *)((u32) adapter->linkmode);
2159                         break;
2160
2161                 case WLAN_GET_RADIOMODE:
2162                         req->ifr_data = (char *)((u32) adapter->radiomode);
2163                         break;
2164
2165                 case WLAN_GET_DEBUGMODE:
2166                         req->ifr_data = (char *)((u32) adapter->debugmode);
2167                         break;
2168
2169                 case WLAN_GET_MULTIPLE_DTIM:
2170                         pdata = (int *)wrq->u.name;
2171                         *pdata = (int)adapter->multipledtim;
2172                         break;
2173                 case WLAN_GET_TX_RATE:
2174                         ret = wlan_get_txrate_ioctl(priv, req);
2175                         break;
2176                 case WLAN_SUBCMD_FWT_CLEANUP:   /* fwt_cleanup */
2177                         ret = wlan_fwt_cleanup_ioctl(priv, req);
2178                         break;
2179
2180                 case WLAN_SUBCMD_FWT_TIME:      /* fwt_time */
2181                         ret = wlan_fwt_time_ioctl(priv, req);
2182                         break;
2183
2184                 case WLAN_SUBCMD_MESH_GET_TTL:
2185                         ret = wlan_mesh_get_ttl_ioctl(priv, req);
2186                         break;
2187
2188                 default:
2189                         ret = -EOPNOTSUPP;
2190
2191                 }
2192
2193                 break;
2194
2195         case WLANGETLOG:
2196                 ret = wlan_do_getlog_ioctl(priv, wrq);
2197                 break;
2198
2199         case WLAN_SET_GET_SIXTEEN_INT:
2200                 switch ((int)wrq->u.data.flags) {
2201                 case WLAN_TPCCFG:
2202                         {
2203                                 int data[5];
2204                                 struct cmd_ds_802_11_tpc_cfg cfg;
2205                                 memset(&cfg, 0, sizeof(cfg));
2206                                 if ((wrq->u.data.length > 1)
2207                                     && (wrq->u.data.length != 5))
2208                                         return -1;
2209
2210                                 if (wrq->u.data.length == 0) {
2211                                         cfg.action =
2212                                             cpu_to_le16
2213                                             (cmd_act_get);
2214                                 } else {
2215                                         if (copy_from_user
2216                                             (data, wrq->u.data.pointer,
2217                                              sizeof(int) * 5)) {
2218                                                 lbs_pr_debug(1,
2219                                                        "Copy from user failed\n");
2220                                                 return -EFAULT;
2221                                         }
2222
2223                                         cfg.action =
2224                                             cpu_to_le16
2225                                             (cmd_act_set);
2226                                         cfg.enable = data[0];
2227                                         cfg.usesnr = data[1];
2228                                         cfg.P0 = data[2];
2229                                         cfg.P1 = data[3];
2230                                         cfg.P2 = data[4];
2231                                 }
2232
2233                                 ret =
2234                                     libertas_prepare_and_send_command(priv,
2235                                                           cmd_802_11_tpc_cfg,
2236                                                           0,
2237                                                           cmd_option_waitforrsp,
2238                                                           0, (void *)&cfg);
2239
2240                                 data[0] = cfg.enable;
2241                                 data[1] = cfg.usesnr;
2242                                 data[2] = cfg.P0;
2243                                 data[3] = cfg.P1;
2244                                 data[4] = cfg.P2;
2245                                 if (copy_to_user
2246                                     (wrq->u.data.pointer, data,
2247                                      sizeof(int) * 5)) {
2248                                         lbs_pr_debug(1, "Copy to user failed\n");
2249                                         return -EFAULT;
2250                                 }
2251
2252                                 wrq->u.data.length = 5;
2253                         }
2254                         break;
2255
2256                 case WLAN_POWERCFG:
2257                         {
2258                                 int data[4];
2259                                 struct cmd_ds_802_11_pwr_cfg cfg;
2260                                 memset(&cfg, 0, sizeof(cfg));
2261                                 if ((wrq->u.data.length > 1)
2262                                     && (wrq->u.data.length != 4))
2263                                         return -1;
2264                                 if (wrq->u.data.length == 0) {
2265                                         cfg.action =
2266                                             cpu_to_le16
2267                                             (cmd_act_get);
2268                                 } else {
2269                                         if (copy_from_user
2270                                             (data, wrq->u.data.pointer,
2271                                              sizeof(int) * 4)) {
2272                                                 lbs_pr_debug(1,
2273                                                        "Copy from user failed\n");
2274                                                 return -EFAULT;
2275                                         }
2276
2277                                         cfg.action =
2278                                             cpu_to_le16
2279                                             (cmd_act_set);
2280                                         cfg.enable = data[0];
2281                                         cfg.PA_P0 = data[1];
2282                                         cfg.PA_P1 = data[2];
2283                                         cfg.PA_P2 = data[3];
2284                                 }
2285                                 ret =
2286                                     libertas_prepare_and_send_command(priv,
2287                                                           cmd_802_11_pwr_cfg,
2288                                                           0,
2289                                                           cmd_option_waitforrsp,
2290                                                           0, (void *)&cfg);
2291                                 data[0] = cfg.enable;
2292                                 data[1] = cfg.PA_P0;
2293                                 data[2] = cfg.PA_P1;
2294                                 data[3] = cfg.PA_P2;
2295                                 if (copy_to_user
2296                                     (wrq->u.data.pointer, data,
2297                                      sizeof(int) * 4)) {
2298                                         lbs_pr_debug(1, "Copy to user failed\n");
2299                                         return -EFAULT;
2300                                 }
2301
2302                                 wrq->u.data.length = 4;
2303                         }
2304                         break;
2305                 case WLAN_AUTO_FREQ_SET:
2306                         {
2307                                 int data[3];
2308                                 struct cmd_ds_802_11_afc afc;
2309                                 memset(&afc, 0, sizeof(afc));
2310                                 if (wrq->u.data.length != 3)
2311                                         return -1;
2312                                 if (copy_from_user
2313                                     (data, wrq->u.data.pointer,
2314                                      sizeof(int) * 3)) {
2315                                         lbs_pr_debug(1, "Copy from user failed\n");
2316                                         return -EFAULT;
2317                                 }
2318                                 afc.afc_auto = data[0];
2319
2320                                 if (afc.afc_auto != 0) {
2321                                         afc.threshold = data[1];
2322                                         afc.period = data[2];
2323                                 } else {
2324                                         afc.timing_offset = data[1];
2325                                         afc.carrier_offset = data[2];
2326                                 }
2327                                 ret =
2328                                     libertas_prepare_and_send_command(priv,
2329                                                           cmd_802_11_set_afc,
2330                                                           0,
2331                                                           cmd_option_waitforrsp,
2332                                                           0, (void *)&afc);
2333                         }
2334                         break;
2335                 case WLAN_AUTO_FREQ_GET:
2336                         {
2337                                 int data[3];
2338                                 struct cmd_ds_802_11_afc afc;
2339                                 memset(&afc, 0, sizeof(afc));
2340                                 ret =
2341                                     libertas_prepare_and_send_command(priv,
2342                                                           cmd_802_11_get_afc,
2343                                                           0,
2344                                                           cmd_option_waitforrsp,
2345                                                           0, (void *)&afc);
2346                                 data[0] = afc.afc_auto;
2347                                 data[1] = afc.timing_offset;
2348                                 data[2] = afc.carrier_offset;
2349                                 if (copy_to_user
2350                                     (wrq->u.data.pointer, data,
2351                                      sizeof(int) * 3)) {
2352                                         lbs_pr_debug(1, "Copy to user failed\n");
2353                                         return -EFAULT;
2354                                 }
2355
2356                                 wrq->u.data.length = 3;
2357                         }
2358                         break;
2359                 case WLAN_SCANPROBES:
2360                         {
2361                                 int data;
2362                                 if (wrq->u.data.length > 0) {
2363                                         if (copy_from_user
2364                                             (&data, wrq->u.data.pointer,
2365                                              sizeof(int))) {
2366                                                 lbs_pr_debug(1,
2367                                                        "Copy from user failed\n");
2368                                                 return -EFAULT;
2369                                         }
2370
2371                                         adapter->scanprobes = data;
2372                                 } else {
2373                                         data = adapter->scanprobes;
2374                                         if (copy_to_user
2375                                             (wrq->u.data.pointer, &data,
2376                                              sizeof(int))) {
2377                                                 lbs_pr_debug(1,
2378                                                        "Copy to user failed\n");
2379                                                 return -EFAULT;
2380                                         }
2381                                 }
2382                                 wrq->u.data.length = 1;
2383                         }
2384                         break;
2385                 case WLAN_LED_GPIO_CTRL:
2386                         {
2387                                 int i;
2388                                 int data[16];
2389
2390                                 struct cmd_ds_802_11_led_ctrl ctrl;
2391                                 struct mrvlietypes_ledgpio *gpio =
2392                                     (struct mrvlietypes_ledgpio *) ctrl.data;
2393
2394                                 memset(&ctrl, 0, sizeof(ctrl));
2395                                 if (wrq->u.data.length > MAX_LEDS * 2)
2396                                         return -ENOTSUPP;
2397                                 if ((wrq->u.data.length % 2) != 0)
2398                                         return -ENOTSUPP;
2399                                 if (wrq->u.data.length == 0) {
2400                                         ctrl.action =
2401                                             cpu_to_le16
2402                                             (cmd_act_get);
2403                                 } else {
2404                                         if (copy_from_user
2405                                             (data, wrq->u.data.pointer,
2406                                              sizeof(int) *
2407                                              wrq->u.data.length)) {
2408                                                 lbs_pr_debug(1,
2409                                                        "Copy from user failed\n");
2410                                                 return -EFAULT;
2411                                         }
2412
2413                                         ctrl.action =
2414                                             cpu_to_le16
2415                                             (cmd_act_set);
2416                                         ctrl.numled = cpu_to_le16(0);
2417                                         gpio->header.type =
2418                                             cpu_to_le16(TLV_TYPE_LED_GPIO);
2419                                         gpio->header.len = wrq->u.data.length;
2420                                         for (i = 0; i < wrq->u.data.length;
2421                                              i += 2) {
2422                                                 gpio->ledpin[i / 2].led =
2423                                                     data[i];
2424                                                 gpio->ledpin[i / 2].pin =
2425                                                     data[i + 1];
2426                                         }
2427                                 }
2428                                 ret =
2429                                     libertas_prepare_and_send_command(priv,
2430                                                           cmd_802_11_led_gpio_ctrl,
2431                                                           0,
2432                                                           cmd_option_waitforrsp,
2433                                                           0, (void *)&ctrl);
2434                                 for (i = 0; i < gpio->header.len; i += 2) {
2435                                         data[i] = gpio->ledpin[i / 2].led;
2436                                         data[i + 1] = gpio->ledpin[i / 2].pin;
2437                                 }
2438                                 if (copy_to_user(wrq->u.data.pointer, data,
2439                                                  sizeof(int) *
2440                                                  gpio->header.len)) {
2441                                         lbs_pr_debug(1, "Copy to user failed\n");
2442                                         return -EFAULT;
2443                                 }
2444
2445                                 wrq->u.data.length = gpio->header.len;
2446                         }
2447                         break;
2448                 case WLAN_ADAPT_RATESET:
2449                         ret = wlan_adapt_rateset(priv, wrq);
2450                         break;
2451                 case WLAN_INACTIVITY_TIMEOUT:
2452                         ret = wlan_inactivity_timeout(priv, wrq);
2453                         break;
2454                 case WLANSNR:
2455                         ret = wlan_get_snr(priv, wrq);
2456                         break;
2457                 case WLAN_GET_RXINFO:
2458                         ret = wlan_get_rxinfo(priv, wrq);
2459                 }
2460                 break;
2461
2462         default:
2463                 ret = -EINVAL;
2464                 break;
2465         }
2466         LEAVE();
2467         return ret;
2468 }
2469
2470