drivers/net/wireless/orinoco/hw.c

   1 /* Encapsulate basic setting changes and retrieval on Hermes hardware
   2  *
   3  * See copyright notice in main.c
   4  */
   5 #include <linux/kernel.h>
   6 #include <linux/device.h>
   7 #include <linux/if_arp.h>
   8 #include <linux/ieee80211.h>
   9 #include <linux/wireless.h>
  10 #include <net/cfg80211.h>
  11 #include "hermes.h"
  12 #include "hermes_rid.h"
  13 #include "orinoco.h"
  14
  15 #include "hw.h"
  16
  17 #define SYMBOL_MAX_VER_LEN      (14)
  18
  19 /* Symbol firmware has a bug allocating buffers larger than this */
  20 #define TX_NICBUF_SIZE_BUG      1585
  21
  22 /********************************************************************/
  23 /* Data tables                                                      */
  24 /********************************************************************/
  25
  26 /* This tables gives the actual meanings of the bitrate IDs returned
  27  * by the firmware. */
  28 static const struct {
  29         int bitrate; /* in 100s of kilobits */
  30         int automatic;
  31         u16 agere_txratectrl;
  32         u16 intersil_txratectrl;
  33 } bitrate_table[] = {
  34         {110, 1,  3, 15}, /* Entry 0 is the default */
  35         {10,  0,  1,  1},
  36         {10,  1,  1,  1},
  37         {20,  0,  2,  2},
  38         {20,  1,  6,  3},
  39         {55,  0,  4,  4},
  40         {55,  1,  7,  7},
  41         {110, 0,  5,  8},
  42 };
  43 #define BITRATE_TABLE_SIZE ARRAY_SIZE(bitrate_table)
  44
  45 /* Firmware version encoding */
  46 struct comp_id {
  47         u16 id, variant, major, minor;
  48 } __attribute__ ((packed));
  49
  50 static inline fwtype_t determine_firmware_type(struct comp_id *nic_id)
  51 {
  52         if (nic_id->id < 0x8000)
  53                 return FIRMWARE_TYPE_AGERE;
  54         else if (nic_id->id == 0x8000 && nic_id->major == 0)
  55                 return FIRMWARE_TYPE_SYMBOL;
  56         else
  57                 return FIRMWARE_TYPE_INTERSIL;
  58 }
  59
  60 /* Set priv->firmware type, determine firmware properties
  61  * This function can be called before we have registerred with netdev,
  62  * so all errors go out with dev_* rather than printk
  63  *
  64  * If non-NULL stores a firmware description in fw_name.
  65  * If non-NULL stores a HW version in hw_ver
  66  *
  67  * These are output via generic cfg80211 ethtool support.
  68  */
  69 int determine_fw_capabilities(struct orinoco_private *priv,
  70                               char *fw_name, size_t fw_name_len,
  71                               u32 *hw_ver)
  72 {
  73         struct device *dev = priv->dev;
  74         hermes_t *hw = &priv->hw;
  75         int err;
  76         struct comp_id nic_id, sta_id;
  77         unsigned int firmver;
  78         char tmp[SYMBOL_MAX_VER_LEN+1] __attribute__((aligned(2)));
  79
  80         /* Get the hardware version */
  81         err = HERMES_READ_RECORD(hw, USER_BAP, HERMES_RID_NICID, &nic_id);
  82         if (err) {
  83                 dev_err(dev, "Cannot read hardware identity: error %d\n",
  84                         err);
  85                 return err;
  86         }
  87
  88         le16_to_cpus(&nic_id.id);
  89         le16_to_cpus(&nic_id.variant);
  90         le16_to_cpus(&nic_id.major);
  91         le16_to_cpus(&nic_id.minor);
  92         dev_info(dev, "Hardware identity %04x:%04x:%04x:%04x\n",
  93                  nic_id.id, nic_id.variant, nic_id.major, nic_id.minor);
  94
  95         if (hw_ver)
  96                 *hw_ver = (((nic_id.id & 0xff) << 24) |
  97                            ((nic_id.variant & 0xff) << 16) |
  98                            ((nic_id.major & 0xff) << 8) |
  99                            (nic_id.minor & 0xff));
 100
 101         priv->firmware_type = determine_firmware_type(&nic_id);
 102
 103         /* Get the firmware version */
 104         err = HERMES_READ_RECORD(hw, USER_BAP, HERMES_RID_STAID, &sta_id);
 105         if (err) {
 106                 dev_err(dev, "Cannot read station identity: error %d\n",
 107                         err);
 108                 return err;
 109         }
 110
 111         le16_to_cpus(&sta_id.id);
 112         le16_to_cpus(&sta_id.variant);
 113         le16_to_cpus(&sta_id.major);
 114         le16_to_cpus(&sta_id.minor);
 115         dev_info(dev, "Station identity  %04x:%04x:%04x:%04x\n",
 116                  sta_id.id, sta_id.variant, sta_id.major, sta_id.minor);
 117
 118         switch (sta_id.id) {
 119         case 0x15:
 120                 dev_err(dev, "Primary firmware is active\n");
 121                 return -ENODEV;
 122         case 0x14b:
 123                 dev_err(dev, "Tertiary firmware is active\n");
 124                 return -ENODEV;
 125         case 0x1f:      /* Intersil, Agere, Symbol Spectrum24 */
 126         case 0x21:      /* Symbol Spectrum24 Trilogy */
 127                 break;
 128         default:
 129                 dev_notice(dev, "Unknown station ID, please report\n");
 130                 break;
 131         }
 132
 133         /* Default capabilities */
 134         priv->has_sensitivity = 1;
 135         priv->has_mwo = 0;
 136         priv->has_preamble = 0;
 137         priv->has_port3 = 1;
 138         priv->has_ibss = 1;
 139         priv->has_wep = 0;
 140         priv->has_big_wep = 0;
 141         priv->has_alt_txcntl = 0;
 142         priv->has_ext_scan = 0;
 143         priv->has_wpa = 0;
 144         priv->do_fw_download = 0;
 145
 146         /* Determine capabilities from the firmware version */
 147         switch (priv->firmware_type) {
 148         case FIRMWARE_TYPE_AGERE:
 149                 /* Lucent Wavelan IEEE, Lucent Orinoco, Cabletron RoamAbout,
 150                    ELSA, Melco, HP, IBM, Dell 1150, Compaq 110/210 */
 151                 if (fw_name)
 152                         snprintf(fw_name, fw_name_len, "Lucent/Agere %d.%02d",
 153                                  sta_id.major, sta_id.minor);
 154
 155                 firmver = ((unsigned long)sta_id.major << 16) | sta_id.minor;
 156
 157                 priv->has_ibss = (firmver >= 0x60006);
 158                 priv->has_wep = (firmver >= 0x40020);
 159                 priv->has_big_wep = 1; /* FIXME: this is wrong - how do we tell
 160                                           Gold cards from the others? */
 161                 priv->has_mwo = (firmver >= 0x60000);
 162                 priv->has_pm = (firmver >= 0x40020); /* Don't work in 7.52 ? */
 163                 priv->ibss_port = 1;
 164                 priv->has_hostscan = (firmver >= 0x8000a);
 165                 priv->do_fw_download = 1;
 166                 priv->broken_monitor = (firmver >= 0x80000);
 167                 priv->has_alt_txcntl = (firmver >= 0x90000); /* All 9.x ? */
 168                 priv->has_ext_scan = (firmver >= 0x90000); /* All 9.x ? */
 169                 priv->has_wpa = (firmver >= 0x9002a);
 170                 /* Tested with Agere firmware :
 171                  *      1.16 ; 4.08 ; 4.52 ; 6.04 ; 6.16 ; 7.28 => Jean II
 172                  * Tested CableTron firmware : 4.32 => Anton */
 173                 break;
 174         case FIRMWARE_TYPE_SYMBOL:
 175                 /* Symbol , 3Com AirConnect, Intel, Ericsson WLAN */
 176                 /* Intel MAC : 00:02:B3:* */
 177                 /* 3Com MAC : 00:50:DA:* */
 178                 memset(tmp, 0, sizeof(tmp));
 179                 /* Get the Symbol firmware version */
 180                 err = hw->ops->read_ltv(hw, USER_BAP,
 181                                         HERMES_RID_SECONDARYVERSION_SYMBOL,
 182                                         SYMBOL_MAX_VER_LEN, NULL, &tmp);
 183                 if (err) {
 184                         dev_warn(dev, "Error %d reading Symbol firmware info. "
 185                                  "Wildly guessing capabilities...\n", err);
 186                         firmver = 0;
 187                         tmp[0] = '\0';
 188                 } else {
 189                         /* The firmware revision is a string, the format is
 190                          * something like : "V2.20-01".
 191                          * Quick and dirty parsing... - Jean II
 192                          */
 193                         firmver = ((tmp[1] - '0') << 16)
 194                                 | ((tmp[3] - '0') << 12)
 195                                 | ((tmp[4] - '0') << 8)
 196                                 | ((tmp[6] - '0') << 4)
 197                                 | (tmp[7] - '0');
 198
 199                         tmp[SYMBOL_MAX_VER_LEN] = '\0';
 200                 }
 201
 202                 if (fw_name)
 203                         snprintf(fw_name, fw_name_len, "Symbol %s", tmp);
 204
 205                 priv->has_ibss = (firmver >= 0x20000);
 206                 priv->has_wep = (firmver >= 0x15012);
 207                 priv->has_big_wep = (firmver >= 0x20000);
 208                 priv->has_pm = (firmver >= 0x20000 && firmver < 0x22000) ||
 209                                (firmver >= 0x29000 && firmver < 0x30000) ||
 210                                firmver >= 0x31000;
 211                 priv->has_preamble = (firmver >= 0x20000);
 212                 priv->ibss_port = 4;
 213
 214                 /* Symbol firmware is found on various cards, but
 215                  * there has been no attempt to check firmware
 216                  * download on non-spectrum_cs based cards.
 217                  *
 218                  * Given that the Agere firmware download works
 219                  * differently, we should avoid doing a firmware
 220                  * download with the Symbol algorithm on non-spectrum
 221                  * cards.
 222                  *
 223                  * For now we can identify a spectrum_cs based card
 224                  * because it has a firmware reset function.
 225                  */
 226                 priv->do_fw_download = (priv->stop_fw != NULL);
 227
 228                 priv->broken_disableport = (firmver == 0x25013) ||
 229                                 (firmver >= 0x30000 && firmver <= 0x31000);
 230                 priv->has_hostscan = (firmver >= 0x31001) ||
 231                                      (firmver >= 0x29057 && firmver < 0x30000);
 232                 /* Tested with Intel firmware : 0x20015 => Jean II */
 233                 /* Tested with 3Com firmware : 0x15012 & 0x22001 => Jean II */
 234                 break;
 235         case FIRMWARE_TYPE_INTERSIL:
 236                 /* D-Link, Linksys, Adtron, ZoomAir, and many others...
 237                  * Samsung, Compaq 100/200 and Proxim are slightly
 238                  * different and less well tested */
 239                 /* D-Link MAC : 00:40:05:* */
 240                 /* Addtron MAC : 00:90:D1:* */
 241                 if (fw_name)
 242                         snprintf(fw_name, fw_name_len, "Intersil %d.%d.%d",
 243                                  sta_id.major, sta_id.minor, sta_id.variant);
 244
 245                 firmver = ((unsigned long)sta_id.major << 16) |
 246                         ((unsigned long)sta_id.minor << 8) | sta_id.variant;
 247
 248                 priv->has_ibss = (firmver >= 0x000700); /* FIXME */
 249                 priv->has_big_wep = priv->has_wep = (firmver >= 0x000800);
 250                 priv->has_pm = (firmver >= 0x000700);
 251                 priv->has_hostscan = (firmver >= 0x010301);
 252
 253                 if (firmver >= 0x000800)
 254                         priv->ibss_port = 0;
 255                 else {
 256                         dev_notice(dev, "Intersil firmware earlier than v0.8.x"
 257                                    " - several features not supported\n");
 258                         priv->ibss_port = 1;
 259                 }
 260                 break;
 261         }
 262         if (fw_name)
 263                 dev_info(dev, "Firmware determined as %s\n", fw_name);
 264
 265 #ifndef CONFIG_HERMES_PRISM
 266         if (priv->firmware_type == FIRMWARE_TYPE_INTERSIL) {
 267                 dev_err(dev, "Support for Prism chipset is not enabled\n");
 268                 return -ENODEV;
 269         }
 270 #endif
 271
 272         return 0;
 273 }
 274
 275 /* Read settings from EEPROM into our private structure.
 276  * MAC address gets dropped into callers buffer
 277  * Can be called before netdev registration.
 278  */
 279 int orinoco_hw_read_card_settings(struct orinoco_private *priv, u8 *dev_addr)
 280 {
 281         struct device *dev = priv->dev;
 282         struct hermes_idstring nickbuf;
 283         hermes_t *hw = &priv->hw;
 284         int len;
 285         int err;
 286         u16 reclen;
 287
 288         /* Get the MAC address */
 289         err = hw->ops->read_ltv(hw, USER_BAP, HERMES_RID_CNFOWNMACADDR,
 290                                 ETH_ALEN, NULL, dev_addr);
 291         if (err) {
 292                 dev_warn(dev, "Failed to read MAC address!\n");
 293                 goto out;
 294         }
 295
 296         dev_dbg(dev, "MAC address %pM\n", dev_addr);
 297
 298         /* Get the station name */
 299         err = hw->ops->read_ltv(hw, USER_BAP, HERMES_RID_CNFOWNNAME,
 300                                 sizeof(nickbuf), &reclen, &nickbuf);
 301         if (err) {
 302                 dev_err(dev, "failed to read station name\n");
 303                 goto out;
 304         }
 305         if (nickbuf.len)
 306                 len = min(IW_ESSID_MAX_SIZE, (int)le16_to_cpu(nickbuf.len));
 307         else
 308                 len = min(IW_ESSID_MAX_SIZE, 2 * reclen);
 309         memcpy(priv->nick, &nickbuf.val, len);
 310         priv->nick[len] = '\0';
 311
 312         dev_dbg(dev, "Station name \"%s\"\n", priv->nick);
 313
 314         /* Get allowed channels */
 315         err = hermes_read_wordrec(hw, USER_BAP, HERMES_RID_CHANNELLIST,
 316                                   &priv->channel_mask);
 317         if (err) {
 318                 dev_err(dev, "Failed to read channel list!\n");
 319                 goto out;
 320         }
 321
 322         /* Get initial AP density */
 323         err = hermes_read_wordrec(hw, USER_BAP, HERMES_RID_CNFSYSTEMSCALE,
 324                                   &priv->ap_density);
 325         if (err || priv->ap_density < 1 || priv->ap_density > 3)
 326                 priv->has_sensitivity = 0;
 327
 328         /* Get initial RTS threshold */
 329         err = hermes_read_wordrec(hw, USER_BAP, HERMES_RID_CNFRTSTHRESHOLD,
 330                                   &priv->rts_thresh);
 331         if (err) {
 332                 dev_err(dev, "Failed to read RTS threshold!\n");
 333                 goto out;
 334         }
 335
 336         /* Get initial fragmentation settings */
 337         if (priv->has_mwo)
 338                 err = hermes_read_wordrec(hw, USER_BAP,
 339                                           HERMES_RID_CNFMWOROBUST_AGERE,
 340                                           &priv->mwo_robust);
 341         else
 342                 err = hermes_read_wordrec(hw, USER_BAP,
 343                                           HERMES_RID_CNFFRAGMENTATIONTHRESHOLD,
 344                                           &priv->frag_thresh);
 345         if (err) {
 346                 dev_err(dev, "Failed to read fragmentation settings!\n");
 347                 goto out;
 348         }
 349
 350         /* Power management setup */
 351         if (priv->has_pm) {
 352                 priv->pm_on = 0;
 353                 priv->pm_mcast = 1;
 354                 err = hermes_read_wordrec(hw, USER_BAP,
 355                                           HERMES_RID_CNFMAXSLEEPDURATION,
 356                                           &priv->pm_period);
 357                 if (err) {
 358                         dev_err(dev, "Failed to read power management "
 359                                 "period!\n");
 360                         goto out;
 361                 }
 362                 err = hermes_read_wordrec(hw, USER_BAP,
 363                                           HERMES_RID_CNFPMHOLDOVERDURATION,
 364                                           &priv->pm_timeout);
 365                 if (err) {
 366                         dev_err(dev, "Failed to read power management "
 367                                 "timeout!\n");
 368                         goto out;
 369                 }
 370         }
 371
 372         /* Preamble setup */
 373         if (priv->has_preamble) {
 374                 err = hermes_read_wordrec(hw, USER_BAP,
 375                                           HERMES_RID_CNFPREAMBLE_SYMBOL,
 376                                           &priv->preamble);
 377                 if (err) {
 378                         dev_err(dev, "Failed to read preamble setup\n");
 379                         goto out;
 380                 }
 381         }
 382
 383         /* Retry settings */
 384         err = hermes_read_wordrec(hw, USER_BAP, HERMES_RID_SHORTRETRYLIMIT,
 385                                   &priv->short_retry_limit);
 386         if (err) {
 387                 dev_err(dev, "Failed to read short retry limit\n");
 388                 goto out;
 389         }
 390
 391         err = hermes_read_wordrec(hw, USER_BAP, HERMES_RID_LONGRETRYLIMIT,
 392                                   &priv->long_retry_limit);
 393         if (err) {
 394                 dev_err(dev, "Failed to read long retry limit\n");
 395                 goto out;
 396         }
 397
 398         err = hermes_read_wordrec(hw, USER_BAP, HERMES_RID_MAXTRANSMITLIFETIME,
 399                                   &priv->retry_lifetime);
 400         if (err) {
 401                 dev_err(dev, "Failed to read max retry lifetime\n");
 402                 goto out;
 403         }
 404
 405 out:
 406         return err;
 407 }
 408
 409 /* Can be called before netdev registration */
 410 int orinoco_hw_allocate_fid(struct orinoco_private *priv)
 411 {
 412         struct device *dev = priv->dev;
 413         struct hermes *hw = &priv->hw;
 414         int err;
 415
 416         err = hw->ops->allocate(hw, priv->nicbuf_size, &priv->txfid);
 417         if (err == -EIO && priv->nicbuf_size > TX_NICBUF_SIZE_BUG) {
 418                 /* Try workaround for old Symbol firmware bug */
 419                 priv->nicbuf_size = TX_NICBUF_SIZE_BUG;
 420                 err = hw->ops->allocate(hw, priv->nicbuf_size, &priv->txfid);
 421
 422                 dev_warn(dev, "Firmware ALLOC bug detected "
 423                          "(old Symbol firmware?). Work around %s\n",
 424                          err ? "failed!" : "ok.");
 425         }
 426
 427         return err;
 428 }
 429
 430 int orinoco_get_bitratemode(int bitrate, int automatic)
 431 {
 432         int ratemode = -1;
 433         int i;
 434
 435         if ((bitrate != 10) && (bitrate != 20) &&
 436             (bitrate != 55) && (bitrate != 110))
 437                 return ratemode;
 438
 439         for (i = 0; i < BITRATE_TABLE_SIZE; i++) {
 440                 if ((bitrate_table[i].bitrate == bitrate) &&
 441                     (bitrate_table[i].automatic == automatic)) {
 442                         ratemode = i;
 443                         break;
 444                 }
 445         }
 446         return ratemode;
 447 }
 448
 449 void orinoco_get_ratemode_cfg(int ratemode, int *bitrate, int *automatic)
 450 {
 451         BUG_ON((ratemode < 0) || (ratemode >= BITRATE_TABLE_SIZE));
 452
 453         *bitrate = bitrate_table[ratemode].bitrate * 100000;
 454         *automatic = bitrate_table[ratemode].automatic;
 455 }
 456
 457 int orinoco_hw_program_rids(struct orinoco_private *priv)
 458 {
 459         struct net_device *dev = priv->ndev;
 460         struct wireless_dev *wdev = netdev_priv(dev);
 461         hermes_t *hw = &priv->hw;
 462         int err;
 463         struct hermes_idstring idbuf;
 464
 465         /* Set the MAC address */
 466         err = hw->ops->write_ltv(hw, USER_BAP, HERMES_RID_CNFOWNMACADDR,
 467                                  HERMES_BYTES_TO_RECLEN(ETH_ALEN),
 468                                  dev->dev_addr);
 469         if (err) {
 470                 printk(KERN_ERR "%s: Error %d setting MAC address\n",
 471                        dev->name, err);
 472                 return err;
 473         }
 474
 475         /* Set up the link mode */
 476         err = hermes_write_wordrec(hw, USER_BAP, HERMES_RID_CNFPORTTYPE,
 477                                    priv->port_type);
 478         if (err) {
 479                 printk(KERN_ERR "%s: Error %d setting port type\n",
 480                        dev->name, err);
 481                 return err;
 482         }
 483         /* Set the channel/frequency */
 484         if (priv->channel != 0 && priv->iw_mode != NL80211_IFTYPE_STATION) {
 485                 err = hermes_write_wordrec(hw, USER_BAP,
 486                                            HERMES_RID_CNFOWNCHANNEL,
 487                                            priv->channel);
 488                 if (err) {
 489                         printk(KERN_ERR "%s: Error %d setting channel %d\n",
 490                                dev->name, err, priv->channel);
 491                         return err;
 492                 }
 493         }
 494
 495         if (priv->has_ibss) {
 496                 u16 createibss;
 497
 498                 if ((strlen(priv->desired_essid) == 0) && (priv->createibss)) {
 499                         printk(KERN_WARNING "%s: This firmware requires an "
 500                                "ESSID in IBSS-Ad-Hoc mode.\n", dev->name);
 501                         /* With wvlan_cs, in this case, we would crash.
 502                          * hopefully, this driver will behave better...
 503                          * Jean II */
 504                         createibss = 0;
 505                 } else {
 506                         createibss = priv->createibss;
 507                 }
 508
 509                 err = hermes_write_wordrec(hw, USER_BAP,
 510                                            HERMES_RID_CNFCREATEIBSS,
 511                                            createibss);
 512                 if (err) {
 513                         printk(KERN_ERR "%s: Error %d setting CREATEIBSS\n",
 514                                dev->name, err);
 515                         return err;
 516                 }
 517         }
 518
 519         /* Set the desired BSSID */
 520         err = __orinoco_hw_set_wap(priv);
 521         if (err) {
 522                 printk(KERN_ERR "%s: Error %d setting AP address\n",
 523                        dev->name, err);
 524                 return err;
 525         }
 526
 527         /* Set the desired ESSID */
 528         idbuf.len = cpu_to_le16(strlen(priv->desired_essid));
 529         memcpy(&idbuf.val, priv->desired_essid, sizeof(idbuf.val));
 530         /* WinXP wants partner to configure OWNSSID even in IBSS mode. (jimc) */
 531         err = hw->ops->write_ltv(hw, USER_BAP, HERMES_RID_CNFOWNSSID,
 532                         HERMES_BYTES_TO_RECLEN(strlen(priv->desired_essid)+2),
 533                         &idbuf);
 534         if (err) {
 535                 printk(KERN_ERR "%s: Error %d setting OWNSSID\n",
 536                        dev->name, err);
 537                 return err;
 538         }
 539         err = hw->ops->write_ltv(hw, USER_BAP, HERMES_RID_CNFDESIREDSSID,
 540                         HERMES_BYTES_TO_RECLEN(strlen(priv->desired_essid)+2),
 541                         &idbuf);
 542         if (err) {
 543                 printk(KERN_ERR "%s: Error %d setting DESIREDSSID\n",
 544                        dev->name, err);
 545                 return err;
 546         }
 547
 548         /* Set the station name */
 549         idbuf.len = cpu_to_le16(strlen(priv->nick));
 550         memcpy(&idbuf.val, priv->nick, sizeof(idbuf.val));
 551         err = hw->ops->write_ltv(hw, USER_BAP, HERMES_RID_CNFOWNNAME,
 552                                  HERMES_BYTES_TO_RECLEN(strlen(priv->nick)+2),
 553                                  &idbuf);
 554         if (err) {
 555                 printk(KERN_ERR "%s: Error %d setting nickname\n",
 556                        dev->name, err);
 557                 return err;
 558         }
 559
 560         /* Set AP density */
 561         if (priv->has_sensitivity) {
 562                 err = hermes_write_wordrec(hw, USER_BAP,
 563                                            HERMES_RID_CNFSYSTEMSCALE,
 564                                            priv->ap_density);
 565                 if (err) {
 566                         printk(KERN_WARNING "%s: Error %d setting SYSTEMSCALE. "
 567                                "Disabling sensitivity control\n",
 568                                dev->name, err);
 569
 570                         priv->has_sensitivity = 0;
 571                 }
 572         }
 573
 574         /* Set RTS threshold */
 575         err = hermes_write_wordrec(hw, USER_BAP, HERMES_RID_CNFRTSTHRESHOLD,
 576                                    priv->rts_thresh);
 577         if (err) {
 578                 printk(KERN_ERR "%s: Error %d setting RTS threshold\n",
 579                        dev->name, err);
 580                 return err;
 581         }
 582
 583         /* Set fragmentation threshold or MWO robustness */
 584         if (priv->has_mwo)
 585                 err = hermes_write_wordrec(hw, USER_BAP,
 586                                            HERMES_RID_CNFMWOROBUST_AGERE,
 587                                            priv->mwo_robust);
 588         else
 589                 err = hermes_write_wordrec(hw, USER_BAP,
 590                                            HERMES_RID_CNFFRAGMENTATIONTHRESHOLD,
 591                                            priv->frag_thresh);
 592         if (err) {
 593                 printk(KERN_ERR "%s: Error %d setting fragmentation\n",
 594                        dev->name, err);
 595                 return err;
 596         }
 597
 598         /* Set bitrate */
 599         err = __orinoco_hw_set_bitrate(priv);
 600         if (err) {
 601                 printk(KERN_ERR "%s: Error %d setting bitrate\n",
 602                        dev->name, err);
 603                 return err;
 604         }
 605
 606         /* Set power management */
 607         if (priv->has_pm) {
 608                 err = hermes_write_wordrec(hw, USER_BAP,
 609                                            HERMES_RID_CNFPMENABLED,
 610                                            priv->pm_on);
 611                 if (err) {
 612                         printk(KERN_ERR "%s: Error %d setting up PM\n",
 613                                dev->name, err);
 614                         return err;
 615                 }
 616
 617                 err = hermes_write_wordrec(hw, USER_BAP,
 618                                            HERMES_RID_CNFMULTICASTRECEIVE,
 619                                            priv->pm_mcast);
 620                 if (err) {
 621                         printk(KERN_ERR "%s: Error %d setting up PM\n",
 622                                dev->name, err);
 623                         return err;
 624                 }
 625                 err = hermes_write_wordrec(hw, USER_BAP,
 626                                            HERMES_RID_CNFMAXSLEEPDURATION,
 627                                            priv->pm_period);
 628                 if (err) {
 629                         printk(KERN_ERR "%s: Error %d setting up PM\n",
 630                                dev->name, err);
 631                         return err;
 632                 }
 633                 err = hermes_write_wordrec(hw, USER_BAP,
 634                                            HERMES_RID_CNFPMHOLDOVERDURATION,
 635                                            priv->pm_timeout);
 636                 if (err) {
 637                         printk(KERN_ERR "%s: Error %d setting up PM\n",
 638                                dev->name, err);
 639                         return err;
 640                 }
 641         }
 642
 643         /* Set preamble - only for Symbol so far... */
 644         if (priv->has_preamble) {
 645                 err = hermes_write_wordrec(hw, USER_BAP,
 646                                            HERMES_RID_CNFPREAMBLE_SYMBOL,
 647                                            priv->preamble);
 648                 if (err) {
 649                         printk(KERN_ERR "%s: Error %d setting preamble\n",
 650                                dev->name, err);
 651                         return err;
 652                 }
 653         }
 654
 655         /* Set up encryption */
 656         if (priv->has_wep || priv->has_wpa) {
 657                 err = __orinoco_hw_setup_enc(priv);
 658                 if (err) {
 659                         printk(KERN_ERR "%s: Error %d activating encryption\n",
 660                                dev->name, err);
 661                         return err;
 662                 }
 663         }
 664
 665         if (priv->iw_mode == NL80211_IFTYPE_MONITOR) {
 666                 /* Enable monitor mode */
 667                 dev->type = ARPHRD_IEEE80211;
 668                 err = hw->ops->cmd_wait(hw, HERMES_CMD_TEST |
 669                                             HERMES_TEST_MONITOR, 0, NULL);
 670         } else {
 671                 /* Disable monitor mode */
 672                 dev->type = ARPHRD_ETHER;
 673                 err = hw->ops->cmd_wait(hw, HERMES_CMD_TEST |
 674                                             HERMES_TEST_STOP, 0, NULL);
 675         }
 676         if (err)
 677                 return err;
 678
 679         /* Reset promiscuity / multicast*/
 680         priv->promiscuous = 0;
 681         priv->mc_count = 0;
 682
 683         /* Record mode change */
 684         wdev->iftype = priv->iw_mode;
 685
 686         return 0;
 687 }
 688
 689 /* Get tsc from the firmware */
 690 int orinoco_hw_get_tkip_iv(struct orinoco_private *priv, int key, u8 *tsc)
 691 {
 692         hermes_t *hw = &priv->hw;
 693         int err = 0;
 694         u8 tsc_arr[4][ORINOCO_SEQ_LEN];
 695
 696         if ((key < 0) || (key >= 4))
 697                 return -EINVAL;
 698
 699         err = hw->ops->read_ltv(hw, USER_BAP, HERMES_RID_CURRENT_TKIP_IV,
 700                                 sizeof(tsc_arr), NULL, &tsc_arr);
 701         if (!err)
 702                 memcpy(tsc, &tsc_arr[key][0], sizeof(tsc_arr[0]));
 703
 704         return err;
 705 }
 706
 707 int __orinoco_hw_set_bitrate(struct orinoco_private *priv)
 708 {
 709         hermes_t *hw = &priv->hw;
 710         int ratemode = priv->bitratemode;
 711         int err = 0;
 712
 713         if (ratemode >= BITRATE_TABLE_SIZE) {
 714                 printk(KERN_ERR "%s: BUG: Invalid bitrate mode %d\n",
 715                        priv->ndev->name, ratemode);
 716                 return -EINVAL;
 717         }
 718
 719         switch (priv->firmware_type) {
 720         case FIRMWARE_TYPE_AGERE:
 721                 err = hermes_write_wordrec(hw, USER_BAP,
 722                                 HERMES_RID_CNFTXRATECONTROL,
 723                                 bitrate_table[ratemode].agere_txratectrl);
 724                 break;
 725         case FIRMWARE_TYPE_INTERSIL:
 726         case FIRMWARE_TYPE_SYMBOL:
 727                 err = hermes_write_wordrec(hw, USER_BAP,
 728                                 HERMES_RID_CNFTXRATECONTROL,
 729                                 bitrate_table[ratemode].intersil_txratectrl);
 730                 break;
 731         default:
 732                 BUG();
 733         }
 734
 735         return err;
 736 }
 737
 738 int orinoco_hw_get_act_bitrate(struct orinoco_private *priv, int *bitrate)
 739 {
 740         hermes_t *hw = &priv->hw;
 741         int i;
 742         int err = 0;
 743         u16 val;
 744
 745         err = hermes_read_wordrec(hw, USER_BAP,
 746                                   HERMES_RID_CURRENTTXRATE, &val);
 747         if (err)
 748                 return err;
 749
 750         switch (priv->firmware_type) {
 751         case FIRMWARE_TYPE_AGERE: /* Lucent style rate */
 752                 /* Note : in Lucent firmware, the return value of
 753                  * HERMES_RID_CURRENTTXRATE is the bitrate in Mb/s,
 754                  * and therefore is totally different from the
 755                  * encoding of HERMES_RID_CNFTXRATECONTROL.
 756                  * Don't forget that 6Mb/s is really 5.5Mb/s */
 757                 if (val == 6)
 758                         *bitrate = 5500000;
 759                 else
 760                         *bitrate = val * 1000000;
 761                 break;
 762         case FIRMWARE_TYPE_INTERSIL: /* Intersil style rate */
 763         case FIRMWARE_TYPE_SYMBOL: /* Symbol style rate */
 764                 for (i = 0; i < BITRATE_TABLE_SIZE; i++)
 765                         if (bitrate_table[i].intersil_txratectrl == val)
 766                                 break;
 767
 768                 if (i >= BITRATE_TABLE_SIZE)
 769                         printk(KERN_INFO "%s: Unable to determine current bitrate (0x%04hx)\n",
 770                                priv->ndev->name, val);
 771
 772                 *bitrate = bitrate_table[i].bitrate * 100000;
 773                 break;
 774         default:
 775                 BUG();
 776         }
 777
 778         return err;
 779 }
 780
 781 /* Set fixed AP address */
 782 int __orinoco_hw_set_wap(struct orinoco_private *priv)
 783 {
 784         int roaming_flag;
 785         int err = 0;
 786         hermes_t *hw = &priv->hw;
 787
 788         switch (priv->firmware_type) {
 789         case FIRMWARE_TYPE_AGERE:
 790                 /* not supported */
 791                 break;
 792         case FIRMWARE_TYPE_INTERSIL:
 793                 if (priv->bssid_fixed)
 794                         roaming_flag = 2;
 795                 else
 796                         roaming_flag = 1;
 797
 798                 err = hermes_write_wordrec(hw, USER_BAP,
 799                                            HERMES_RID_CNFROAMINGMODE,
 800                                            roaming_flag);
 801                 break;
 802         case FIRMWARE_TYPE_SYMBOL:
 803                 err = HERMES_WRITE_RECORD(hw, USER_BAP,
 804                                           HERMES_RID_CNFMANDATORYBSSID_SYMBOL,
 805                                           &priv->desired_bssid);
 806                 break;
 807         }
 808         return err;
 809 }
 810
 811 /* Change the WEP keys and/or the current keys.  Can be called
 812  * either from __orinoco_hw_setup_enc() or directly from
 813  * orinoco_ioctl_setiwencode().  In the later case the association
 814  * with the AP is not broken (if the firmware can handle it),
 815  * which is needed for 802.1x implementations. */
 816 int __orinoco_hw_setup_wepkeys(struct orinoco_private *priv)
 817 {
 818         hermes_t *hw = &priv->hw;
 819         int err = 0;
 820         int i;
 821
 822         switch (priv->firmware_type) {
 823         case FIRMWARE_TYPE_AGERE:
 824         {
 825                 struct orinoco_key keys[ORINOCO_MAX_KEYS];
 826
 827                 memset(&keys, 0, sizeof(keys));
 828                 for (i = 0; i < ORINOCO_MAX_KEYS; i++) {
 829                         int len = min(priv->keys[i].key_len,
 830                                       ORINOCO_MAX_KEY_SIZE);
 831                         memcpy(&keys[i].data, priv->keys[i].key, len);
 832                         if (len > SMALL_KEY_SIZE)
 833                                 keys[i].len = cpu_to_le16(LARGE_KEY_SIZE);
 834                         else if (len > 0)
 835                                 keys[i].len = cpu_to_le16(SMALL_KEY_SIZE);
 836                         else
 837                                 keys[i].len = cpu_to_le16(0);
 838                 }
 839
 840                 err = HERMES_WRITE_RECORD(hw, USER_BAP,
 841                                           HERMES_RID_CNFWEPKEYS_AGERE,
 842                                           &keys);
 843                 if (err)
 844                         return err;
 845                 err = hermes_write_wordrec(hw, USER_BAP,
 846                                            HERMES_RID_CNFTXKEY_AGERE,
 847                                            priv->tx_key);
 848                 if (err)
 849                         return err;
 850                 break;
 851         }
 852         case FIRMWARE_TYPE_INTERSIL:
 853         case FIRMWARE_TYPE_SYMBOL:
 854                 {
 855                         int keylen;
 856
 857                         /* Force uniform key length to work around
 858                          * firmware bugs */
 859                         keylen = priv->keys[priv->tx_key].key_len;
 860
 861                         if (keylen > LARGE_KEY_SIZE) {
 862                                 printk(KERN_ERR "%s: BUG: Key %d has oversize length %d.\n",
 863                                        priv->ndev->name, priv->tx_key, keylen);
 864                                 return -E2BIG;
 865                         } else if (keylen > SMALL_KEY_SIZE)
 866                                 keylen = LARGE_KEY_SIZE;
 867                         else if (keylen > 0)
 868                                 keylen = SMALL_KEY_SIZE;
 869                         else
 870                                 keylen = 0;
 871
 872                         /* Write all 4 keys */
 873                         for (i = 0; i < ORINOCO_MAX_KEYS; i++) {
 874                                 u8 key[LARGE_KEY_SIZE] = { 0 };
 875
 876                                 memcpy(key, priv->keys[i].key,
 877                                        priv->keys[i].key_len);
 878
 879                                 err = hw->ops->write_ltv(hw, USER_BAP,
 880                                                 HERMES_RID_CNFDEFAULTKEY0 + i,
 881                                                 HERMES_BYTES_TO_RECLEN(keylen),
 882                                                 key);
 883                                 if (err)
 884                                         return err;
 885                         }
 886
 887                         /* Write the index of the key used in transmission */
 888                         err = hermes_write_wordrec(hw, USER_BAP,
 889                                                 HERMES_RID_CNFWEPDEFAULTKEYID,
 890                                                 priv->tx_key);
 891                         if (err)
 892                                 return err;
 893                 }
 894                 break;
 895         }
 896
 897         return 0;
 898 }
 899
 900 int __orinoco_hw_setup_enc(struct orinoco_private *priv)
 901 {
 902         hermes_t *hw = &priv->hw;
 903         int err = 0;
 904         int master_wep_flag;
 905         int auth_flag;
 906         int enc_flag;
 907
 908         /* Setup WEP keys */
 909         if (priv->encode_alg == ORINOCO_ALG_WEP)
 910                 __orinoco_hw_setup_wepkeys(priv);
 911
 912         if (priv->wep_restrict)
 913                 auth_flag = HERMES_AUTH_SHARED_KEY;
 914         else
 915                 auth_flag = HERMES_AUTH_OPEN;
 916
 917         if (priv->wpa_enabled)
 918                 enc_flag = 2;
 919         else if (priv->encode_alg == ORINOCO_ALG_WEP)
 920                 enc_flag = 1;
 921         else
 922                 enc_flag = 0;
 923
 924         switch (priv->firmware_type) {
 925         case FIRMWARE_TYPE_AGERE: /* Agere style WEP */
 926                 if (priv->encode_alg == ORINOCO_ALG_WEP) {
 927                         /* Enable the shared-key authentication. */
 928                         err = hermes_write_wordrec(hw, USER_BAP,
 929                                         HERMES_RID_CNFAUTHENTICATION_AGERE,
 930                                         auth_flag);
 931                 }
 932                 err = hermes_write_wordrec(hw, USER_BAP,
 933                                            HERMES_RID_CNFWEPENABLED_AGERE,
 934                                            enc_flag);
 935                 if (err)
 936                         return err;
 937
 938                 if (priv->has_wpa) {
 939                         /* Set WPA key management */
 940                         err = hermes_write_wordrec(hw, USER_BAP,
 941                                   HERMES_RID_CNFSETWPAAUTHMGMTSUITE_AGERE,
 942                                   priv->key_mgmt);
 943                         if (err)
 944                                 return err;
 945                 }
 946
 947                 break;
 948
 949         case FIRMWARE_TYPE_INTERSIL: /* Intersil style WEP */
 950         case FIRMWARE_TYPE_SYMBOL: /* Symbol style WEP */
 951                 if (priv->encode_alg == ORINOCO_ALG_WEP) {
 952                         if (priv->wep_restrict ||
 953                             (priv->firmware_type == FIRMWARE_TYPE_SYMBOL))
 954                                 master_wep_flag = HERMES_WEP_PRIVACY_INVOKED |
 955                                                   HERMES_WEP_EXCL_UNENCRYPTED;
 956                         else
 957                                 master_wep_flag = HERMES_WEP_PRIVACY_INVOKED;
 958
 959                         err = hermes_write_wordrec(hw, USER_BAP,
 960                                                    HERMES_RID_CNFAUTHENTICATION,
 961                                                    auth_flag);
 962                         if (err)
 963                                 return err;
 964                 } else
 965                         master_wep_flag = 0;
 966
 967                 if (priv->iw_mode == NL80211_IFTYPE_MONITOR)
 968                         master_wep_flag |= HERMES_WEP_HOST_DECRYPT;
 969
 970                 /* Master WEP setting : on/off */
 971                 err = hermes_write_wordrec(hw, USER_BAP,
 972                                            HERMES_RID_CNFWEPFLAGS_INTERSIL,
 973                                            master_wep_flag);
 974                 if (err)
 975                         return err;
 976
 977                 break;
 978         }
 979
 980         return 0;
 981 }
 982
 983 /* key must be 32 bytes, including the tx and rx MIC keys.
 984  * rsc must be NULL or up to 8 bytes
 985  * tsc must be NULL or up to 8 bytes
 986  */
 987 int __orinoco_hw_set_tkip_key(struct orinoco_private *priv, int key_idx,
 988                               int set_tx, u8 *key, u8 *rsc, size_t rsc_len,
 989                               u8 *tsc, size_t tsc_len)
 990 {
 991         struct {
 992                 __le16 idx;
 993                 u8 rsc[ORINOCO_SEQ_LEN];
 994                 u8 key[TKIP_KEYLEN];
 995                 u8 tx_mic[MIC_KEYLEN];
 996                 u8 rx_mic[MIC_KEYLEN];
 997                 u8 tsc[ORINOCO_SEQ_LEN];
 998         } __attribute__ ((packed)) buf;
 999         hermes_t *hw = &priv->hw;
1000         int ret;
1001         int err;
1002         int k;
1003         u16 xmitting;
1004
1005         key_idx &= 0x3;
1006
1007         if (set_tx)
1008                 key_idx |= 0x8000;
1009
1010         buf.idx = cpu_to_le16(key_idx);
1011         memcpy(buf.key, key,
1012                sizeof(buf.key) + sizeof(buf.tx_mic) + sizeof(buf.rx_mic));
1013
1014         if (rsc_len > sizeof(buf.rsc))
1015                 rsc_len = sizeof(buf.rsc);
1016
1017         if (tsc_len > sizeof(buf.tsc))
1018                 tsc_len = sizeof(buf.tsc);
1019
1020         memset(buf.rsc, 0, sizeof(buf.rsc));
1021         memset(buf.tsc, 0, sizeof(buf.tsc));
1022
1023         if (rsc != NULL)
1024                 memcpy(buf.rsc, rsc, rsc_len);
1025
1026         if (tsc != NULL)
1027                 memcpy(buf.tsc, tsc, tsc_len);
1028         else
1029                 buf.tsc[4] = 0x10;
1030
1031         /* Wait upto 100ms for tx queue to empty */
1032         for (k = 100; k > 0; k--) {
1033                 udelay(1000);
1034                 ret = hermes_read_wordrec(hw, USER_BAP, HERMES_RID_TXQUEUEEMPTY,
1035                                           &xmitting);
1036                 if (ret || !xmitting)
1037                         break;
1038         }
1039
1040         if (k == 0)
1041                 ret = -ETIMEDOUT;
1042
1043         err = HERMES_WRITE_RECORD(hw, USER_BAP,
1044                                   HERMES_RID_CNFADDDEFAULTTKIPKEY_AGERE,
1045                                   &buf);
1046
1047         return ret ? ret : err;
1048 }
1049
1050 int orinoco_clear_tkip_key(struct orinoco_private *priv, int key_idx)
1051 {
1052         hermes_t *hw = &priv->hw;
1053         int err;
1054
1055         err = hermes_write_wordrec(hw, USER_BAP,
1056                                    HERMES_RID_CNFREMDEFAULTTKIPKEY_AGERE,
1057                                    key_idx);
1058         if (err)
1059                 printk(KERN_WARNING "%s: Error %d clearing TKIP key %d\n",
1060                        priv->ndev->name, err, key_idx);
1061         return err;
1062 }
1063
1064 int __orinoco_hw_set_multicast_list(struct orinoco_private *priv,
1065                                     struct net_device *dev,
1066                                     int mc_count, int promisc)
1067 {
1068         hermes_t *hw = &priv->hw;
1069         int err = 0;
1070
1071         if (promisc != priv->promiscuous) {
1072                 err = hermes_write_wordrec(hw, USER_BAP,
1073                                            HERMES_RID_CNFPROMISCUOUSMODE,
1074                                            promisc);
1075                 if (err) {
1076                         printk(KERN_ERR "%s: Error %d setting PROMISCUOUSMODE to 1.\n",
1077                                priv->ndev->name, err);
1078                 } else
1079                         priv->promiscuous = promisc;
1080         }
1081
1082         /* If we're not in promiscuous mode, then we need to set the
1083          * group address if either we want to multicast, or if we were
1084          * multicasting and want to stop */
1085         if (!promisc && (mc_count || priv->mc_count)) {
1086                 struct netdev_hw_addr *ha;
1087                 struct hermes_multicast mclist;
1088                 int i = 0;
1089
1090                 netdev_for_each_mc_addr(ha, dev) {
1091                         if (i == mc_count)
1092                                 break;
1093                         memcpy(mclist.addr[i++], ha->addr, ETH_ALEN);
1094                 }
1095
1096                 err = hw->ops->write_ltv(hw, USER_BAP,
1097                                    HERMES_RID_CNFGROUPADDRESSES,
1098                                    HERMES_BYTES_TO_RECLEN(mc_count * ETH_ALEN),
1099                                    &mclist);
1100                 if (err)
1101                         printk(KERN_ERR "%s: Error %d setting multicast list.\n",
1102                                priv->ndev->name, err);
1103                 else
1104                         priv->mc_count = mc_count;
1105         }
1106         return err;
1107 }
1108
1109 /* Return : < 0 -> error code ; >= 0 -> length */
1110 int orinoco_hw_get_essid(struct orinoco_private *priv, int *active,
1111                          char buf[IW_ESSID_MAX_SIZE+1])
1112 {
1113         hermes_t *hw = &priv->hw;
1114         int err = 0;
1115         struct hermes_idstring essidbuf;
1116         char *p = (char *)(&essidbuf.val);
1117         int len;
1118         unsigned long flags;
1119
1120         if (orinoco_lock(priv, &flags) != 0)
1121                 return -EBUSY;
1122
1123         if (strlen(priv->desired_essid) > 0) {
1124                 /* We read the desired SSID from the hardware rather
1125                    than from priv->desired_essid, just in case the
1126                    firmware is allowed to change it on us. I'm not
1127                    sure about this */
1128                 /* My guess is that the OWNSSID should always be whatever
1129                  * we set to the card, whereas CURRENT_SSID is the one that
1130                  * may change... - Jean II */
1131                 u16 rid;
1132
1133                 *active = 1;
1134
1135                 rid = (priv->port_type == 3) ? HERMES_RID_CNFOWNSSID :
1136                         HERMES_RID_CNFDESIREDSSID;
1137
1138                 err = hw->ops->read_ltv(hw, USER_BAP, rid, sizeof(essidbuf),
1139                                         NULL, &essidbuf);
1140                 if (err)
1141                         goto fail_unlock;
1142         } else {
1143                 *active = 0;
1144
1145                 err = hw->ops->read_ltv(hw, USER_BAP, HERMES_RID_CURRENTSSID,
1146                                         sizeof(essidbuf), NULL, &essidbuf);
1147                 if (err)
1148                         goto fail_unlock;
1149         }
1150
1151         len = le16_to_cpu(essidbuf.len);
1152         BUG_ON(len > IW_ESSID_MAX_SIZE);
1153
1154         memset(buf, 0, IW_ESSID_MAX_SIZE);
1155         memcpy(buf, p, len);
1156         err = len;
1157
1158  fail_unlock:
1159         orinoco_unlock(priv, &flags);
1160
1161         return err;
1162 }
1163
1164 int orinoco_hw_get_freq(struct orinoco_private *priv)
1165 {
1166         hermes_t *hw = &priv->hw;
1167         int err = 0;
1168         u16 channel;
1169         int freq = 0;
1170         unsigned long flags;
1171
1172         if (orinoco_lock(priv, &flags) != 0)
1173                 return -EBUSY;
1174
1175         err = hermes_read_wordrec(hw, USER_BAP, HERMES_RID_CURRENTCHANNEL,
1176                                   &channel);
1177         if (err)
1178                 goto out;
1179
1180         /* Intersil firmware 1.3.5 returns 0 when the interface is down */
1181         if (channel == 0) {
1182                 err = -EBUSY;
1183                 goto out;
1184         }
1185
1186         if ((channel < 1) || (channel > NUM_CHANNELS)) {
1187                 printk(KERN_WARNING "%s: Channel out of range (%d)!\n",
1188                        priv->ndev->name, channel);
1189                 err = -EBUSY;
1190                 goto out;
1191
1192         }
1193         freq = ieee80211_dsss_chan_to_freq(channel);
1194
1195  out:
1196         orinoco_unlock(priv, &flags);
1197
1198         if (err > 0)
1199                 err = -EBUSY;
1200         return err ? err : freq;
1201 }
1202
1203 int orinoco_hw_get_bitratelist(struct orinoco_private *priv,
1204                                int *numrates, s32 *rates, int max)
1205 {
1206         hermes_t *hw = &priv->hw;
1207         struct hermes_idstring list;
1208         unsigned char *p = (unsigned char *)&list.val;
1209         int err = 0;
1210         int num;
1211         int i;
1212         unsigned long flags;
1213
1214         if (orinoco_lock(priv, &flags) != 0)
1215                 return -EBUSY;
1216
1217         err = hw->ops->read_ltv(hw, USER_BAP, HERMES_RID_SUPPORTEDDATARATES,
1218                                 sizeof(list), NULL, &list);
1219         orinoco_unlock(priv, &flags);
1220
1221         if (err)
1222                 return err;
1223
1224         num = le16_to_cpu(list.len);
1225         *numrates = num;
1226         num = min(num, max);
1227
1228         for (i = 0; i < num; i++)
1229                 rates[i] = (p[i] & 0x7f) * 500000; /* convert to bps */
1230
1231         return 0;
1232 }
1233
1234 int orinoco_hw_trigger_scan(struct orinoco_private *priv,
1235                             const struct cfg80211_ssid *ssid)
1236 {
1237         struct net_device *dev = priv->ndev;
1238         hermes_t *hw = &priv->hw;
1239         unsigned long flags;
1240         int err = 0;
1241
1242         if (orinoco_lock(priv, &flags) != 0)
1243                 return -EBUSY;
1244
1245         /* Scanning with port 0 disabled would fail */
1246         if (!netif_running(dev)) {
1247                 err = -ENETDOWN;
1248                 goto out;
1249         }
1250
1251         /* In monitor mode, the scan results are always empty.
1252          * Probe responses are passed to the driver as received
1253          * frames and could be processed in software. */
1254         if (priv->iw_mode == NL80211_IFTYPE_MONITOR) {
1255                 err = -EOPNOTSUPP;
1256                 goto out;
1257         }
1258
1259         if (priv->has_hostscan) {
1260                 switch (priv->firmware_type) {
1261                 case FIRMWARE_TYPE_SYMBOL:
1262                         err = hermes_write_wordrec(hw, USER_BAP,
1263                                                 HERMES_RID_CNFHOSTSCAN_SYMBOL,
1264                                                 HERMES_HOSTSCAN_SYMBOL_ONCE |
1265                                                 HERMES_HOSTSCAN_SYMBOL_BCAST);
1266                         break;
1267                 case FIRMWARE_TYPE_INTERSIL: {
1268                         __le16 req[3];
1269
1270                         req[0] = cpu_to_le16(0x3fff);   /* All channels */
1271                         req[1] = cpu_to_le16(0x0001);   /* rate 1 Mbps */
1272                         req[2] = 0;                     /* Any ESSID */
1273                         err = HERMES_WRITE_RECORD(hw, USER_BAP,
1274                                                   HERMES_RID_CNFHOSTSCAN, &req);
1275                         break;
1276                 }
1277                 case FIRMWARE_TYPE_AGERE:
1278                         if (ssid->ssid_len > 0) {
1279                                 struct hermes_idstring idbuf;
1280                                 size_t len = ssid->ssid_len;
1281
1282                                 idbuf.len = cpu_to_le16(len);
1283                                 memcpy(idbuf.val, ssid->ssid, len);
1284
1285                                 err = hw->ops->write_ltv(hw, USER_BAP,
1286                                                HERMES_RID_CNFSCANSSID_AGERE,
1287                                                HERMES_BYTES_TO_RECLEN(len + 2),
1288                                                &idbuf);
1289                         } else
1290                                 err = hermes_write_wordrec(hw, USER_BAP,
1291                                                    HERMES_RID_CNFSCANSSID_AGERE,
1292                                                    0);  /* Any ESSID */
1293                         if (err)
1294                                 break;
1295
1296                         if (priv->has_ext_scan) {
1297                                 err = hermes_write_wordrec(hw, USER_BAP,
1298                                                 HERMES_RID_CNFSCANCHANNELS2GHZ,
1299                                                 0x7FFF);
1300                                 if (err)
1301                                         goto out;
1302
1303                                 err = hermes_inquire(hw,
1304                                                      HERMES_INQ_CHANNELINFO);
1305                         } else
1306                                 err = hermes_inquire(hw, HERMES_INQ_SCAN);
1307
1308                         break;
1309                 }
1310         } else
1311                 err = hermes_inquire(hw, HERMES_INQ_SCAN);
1312
1313  out:
1314         orinoco_unlock(priv, &flags);
1315
1316         return err;
1317 }
1318
1319 /* Disassociate from node with BSSID addr */
1320 int orinoco_hw_disassociate(struct orinoco_private *priv,
1321                             u8 *addr, u16 reason_code)
1322 {
1323         hermes_t *hw = &priv->hw;
1324         int err;
1325
1326         struct {
1327                 u8 addr[ETH_ALEN];
1328                 __le16 reason_code;
1329         } __attribute__ ((packed)) buf;
1330
1331         /* Currently only supported by WPA enabled Agere fw */
1332         if (!priv->has_wpa)
1333                 return -EOPNOTSUPP;
1334
1335         memcpy(buf.addr, addr, ETH_ALEN);
1336         buf.reason_code = cpu_to_le16(reason_code);
1337         err = HERMES_WRITE_RECORD(hw, USER_BAP,
1338                                   HERMES_RID_CNFDISASSOCIATE,
1339                                   &buf);
1340         return err;
1341 }
1342
1343 int orinoco_hw_get_current_bssid(struct orinoco_private *priv,
1344                                  u8 *addr)
1345 {
1346         hermes_t *hw = &priv->hw;
1347         int err;
1348
1349         err = hw->ops->read_ltv(hw, USER_BAP, HERMES_RID_CURRENTBSSID,
1350                                 ETH_ALEN, NULL, addr);
1351
1352         return err;
1353 }