| OLD | NEW |
|---|
| (Empty) | |
| 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 } __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 bitrat
e (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 le
ngth %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 } __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 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,35)) |
| 1094 memcpy(mclist.addr[i++], ha->addr, ETH_ALEN); |
| 1095 #else |
| 1096 memcpy(mclist.addr[i++], ha->dmi_addr, ETH_ALEN); |
| 1097 #endif |
| 1098 } |
| 1099 |
| 1100 err = hw->ops->write_ltv(hw, USER_BAP, |
| 1101 HERMES_RID_CNFGROUPADDRESSES, |
| 1102 HERMES_BYTES_TO_RECLEN(mc_count * ETH_ALEN), |
| 1103 &mclist); |
| 1104 if (err) |
| 1105 printk(KERN_ERR "%s: Error %d setting multicast list.\n"
, |
| 1106 priv->ndev->name, err); |
| 1107 else |
| 1108 priv->mc_count = mc_count; |
| 1109 } |
| 1110 return err; |
| 1111 } |
| 1112 |
| 1113 /* Return : < 0 -> error code ; >= 0 -> length */ |
| 1114 int orinoco_hw_get_essid(struct orinoco_private *priv, int *active, |
| 1115 char buf[IW_ESSID_MAX_SIZE+1]) |
| 1116 { |
| 1117 hermes_t *hw = &priv->hw; |
| 1118 int err = 0; |
| 1119 struct hermes_idstring essidbuf; |
| 1120 char *p = (char *)(&essidbuf.val); |
| 1121 int len; |
| 1122 unsigned long flags; |
| 1123 |
| 1124 if (orinoco_lock(priv, &flags) != 0) |
| 1125 return -EBUSY; |
| 1126 |
| 1127 if (strlen(priv->desired_essid) > 0) { |
| 1128 /* We read the desired SSID from the hardware rather |
| 1129 than from priv->desired_essid, just in case the |
| 1130 firmware is allowed to change it on us. I'm not |
| 1131 sure about this */ |
| 1132 /* My guess is that the OWNSSID should always be whatever |
| 1133 * we set to the card, whereas CURRENT_SSID is the one that |
| 1134 * may change... - Jean II */ |
| 1135 u16 rid; |
| 1136 |
| 1137 *active = 1; |
| 1138 |
| 1139 rid = (priv->port_type == 3) ? HERMES_RID_CNFOWNSSID : |
| 1140 HERMES_RID_CNFDESIREDSSID; |
| 1141 |
| 1142 err = hw->ops->read_ltv(hw, USER_BAP, rid, sizeof(essidbuf), |
| 1143 NULL, &essidbuf); |
| 1144 if (err) |
| 1145 goto fail_unlock; |
| 1146 } else { |
| 1147 *active = 0; |
| 1148 |
| 1149 err = hw->ops->read_ltv(hw, USER_BAP, HERMES_RID_CURRENTSSID, |
| 1150 sizeof(essidbuf), NULL, &essidbuf); |
| 1151 if (err) |
| 1152 goto fail_unlock; |
| 1153 } |
| 1154 |
| 1155 len = le16_to_cpu(essidbuf.len); |
| 1156 BUG_ON(len > IW_ESSID_MAX_SIZE); |
| 1157 |
| 1158 memset(buf, 0, IW_ESSID_MAX_SIZE); |
| 1159 memcpy(buf, p, len); |
| 1160 err = len; |
| 1161 |
| 1162 fail_unlock: |
| 1163 orinoco_unlock(priv, &flags); |
| 1164 |
| 1165 return err; |
| 1166 } |
| 1167 |
| 1168 int orinoco_hw_get_freq(struct orinoco_private *priv) |
| 1169 { |
| 1170 hermes_t *hw = &priv->hw; |
| 1171 int err = 0; |
| 1172 u16 channel; |
| 1173 int freq = 0; |
| 1174 unsigned long flags; |
| 1175 |
| 1176 if (orinoco_lock(priv, &flags) != 0) |
| 1177 return -EBUSY; |
| 1178 |
| 1179 err = hermes_read_wordrec(hw, USER_BAP, HERMES_RID_CURRENTCHANNEL, |
| 1180 &channel); |
| 1181 if (err) |
| 1182 goto out; |
| 1183 |
| 1184 /* Intersil firmware 1.3.5 returns 0 when the interface is down */ |
| 1185 if (channel == 0) { |
| 1186 err = -EBUSY; |
| 1187 goto out; |
| 1188 } |
| 1189 |
| 1190 if ((channel < 1) || (channel > NUM_CHANNELS)) { |
| 1191 printk(KERN_WARNING "%s: Channel out of range (%d)!\n", |
| 1192 priv->ndev->name, channel); |
| 1193 err = -EBUSY; |
| 1194 goto out; |
| 1195 |
| 1196 } |
| 1197 freq = ieee80211_dsss_chan_to_freq(channel); |
| 1198 |
| 1199 out: |
| 1200 orinoco_unlock(priv, &flags); |
| 1201 |
| 1202 if (err > 0) |
| 1203 err = -EBUSY; |
| 1204 return err ? err : freq; |
| 1205 } |
| 1206 |
| 1207 int orinoco_hw_get_bitratelist(struct orinoco_private *priv, |
| 1208 int *numrates, s32 *rates, int max) |
| 1209 { |
| 1210 hermes_t *hw = &priv->hw; |
| 1211 struct hermes_idstring list; |
| 1212 unsigned char *p = (unsigned char *)&list.val; |
| 1213 int err = 0; |
| 1214 int num; |
| 1215 int i; |
| 1216 unsigned long flags; |
| 1217 |
| 1218 if (orinoco_lock(priv, &flags) != 0) |
| 1219 return -EBUSY; |
| 1220 |
| 1221 err = hw->ops->read_ltv(hw, USER_BAP, HERMES_RID_SUPPORTEDDATARATES, |
| 1222 sizeof(list), NULL, &list); |
| 1223 orinoco_unlock(priv, &flags); |
| 1224 |
| 1225 if (err) |
| 1226 return err; |
| 1227 |
| 1228 num = le16_to_cpu(list.len); |
| 1229 *numrates = num; |
| 1230 num = min(num, max); |
| 1231 |
| 1232 for (i = 0; i < num; i++) |
| 1233 rates[i] = (p[i] & 0x7f) * 500000; /* convert to bps */ |
| 1234 |
| 1235 return 0; |
| 1236 } |
| 1237 |
| 1238 int orinoco_hw_trigger_scan(struct orinoco_private *priv, |
| 1239 const struct cfg80211_ssid *ssid) |
| 1240 { |
| 1241 struct net_device *dev = priv->ndev; |
| 1242 hermes_t *hw = &priv->hw; |
| 1243 unsigned long flags; |
| 1244 int err = 0; |
| 1245 |
| 1246 if (orinoco_lock(priv, &flags) != 0) |
| 1247 return -EBUSY; |
| 1248 |
| 1249 /* Scanning with port 0 disabled would fail */ |
| 1250 if (!netif_running(dev)) { |
| 1251 err = -ENETDOWN; |
| 1252 goto out; |
| 1253 } |
| 1254 |
| 1255 /* In monitor mode, the scan results are always empty. |
| 1256 * Probe responses are passed to the driver as received |
| 1257 * frames and could be processed in software. */ |
| 1258 if (priv->iw_mode == NL80211_IFTYPE_MONITOR) { |
| 1259 err = -EOPNOTSUPP; |
| 1260 goto out; |
| 1261 } |
| 1262 |
| 1263 if (priv->has_hostscan) { |
| 1264 switch (priv->firmware_type) { |
| 1265 case FIRMWARE_TYPE_SYMBOL: |
| 1266 err = hermes_write_wordrec(hw, USER_BAP, |
| 1267 HERMES_RID_CNFHOSTSCAN_SYMBOL, |
| 1268 HERMES_HOSTSCAN_SYMBOL_ONCE | |
| 1269 HERMES_HOSTSCAN_SYMBOL_BCAST); |
| 1270 break; |
| 1271 case FIRMWARE_TYPE_INTERSIL: { |
| 1272 __le16 req[3]; |
| 1273 |
| 1274 req[0] = cpu_to_le16(0x3fff); /* All channels */ |
| 1275 req[1] = cpu_to_le16(0x0001); /* rate 1 Mbps */ |
| 1276 req[2] = 0; /* Any ESSID */ |
| 1277 err = HERMES_WRITE_RECORD(hw, USER_BAP, |
| 1278 HERMES_RID_CNFHOSTSCAN, &req); |
| 1279 break; |
| 1280 } |
| 1281 case FIRMWARE_TYPE_AGERE: |
| 1282 if (ssid->ssid_len > 0) { |
| 1283 struct hermes_idstring idbuf; |
| 1284 size_t len = ssid->ssid_len; |
| 1285 |
| 1286 idbuf.len = cpu_to_le16(len); |
| 1287 memcpy(idbuf.val, ssid->ssid, len); |
| 1288 |
| 1289 err = hw->ops->write_ltv(hw, USER_BAP, |
| 1290 HERMES_RID_CNFSCANSSID_AGERE, |
| 1291 HERMES_BYTES_TO_RECLEN(len + 2), |
| 1292 &idbuf); |
| 1293 } else |
| 1294 err = hermes_write_wordrec(hw, USER_BAP, |
| 1295 HERMES_RID_CNFSCANSSID_AGERE, |
| 1296 0); /* Any ESSID */ |
| 1297 if (err) |
| 1298 break; |
| 1299 |
| 1300 if (priv->has_ext_scan) { |
| 1301 err = hermes_write_wordrec(hw, USER_BAP, |
| 1302 HERMES_RID_CNFSCANCHANNELS2GHZ, |
| 1303 0x7FFF); |
| 1304 if (err) |
| 1305 goto out; |
| 1306 |
| 1307 err = hermes_inquire(hw, |
| 1308 HERMES_INQ_CHANNELINFO); |
| 1309 } else |
| 1310 err = hermes_inquire(hw, HERMES_INQ_SCAN); |
| 1311 |
| 1312 break; |
| 1313 } |
| 1314 } else |
| 1315 err = hermes_inquire(hw, HERMES_INQ_SCAN); |
| 1316 |
| 1317 out: |
| 1318 orinoco_unlock(priv, &flags); |
| 1319 |
| 1320 return err; |
| 1321 } |
| 1322 |
| 1323 /* Disassociate from node with BSSID addr */ |
| 1324 int orinoco_hw_disassociate(struct orinoco_private *priv, |
| 1325 u8 *addr, u16 reason_code) |
| 1326 { |
| 1327 hermes_t *hw = &priv->hw; |
| 1328 int err; |
| 1329 |
| 1330 struct { |
| 1331 u8 addr[ETH_ALEN]; |
| 1332 __le16 reason_code; |
| 1333 } __packed buf; |
| 1334 |
| 1335 /* Currently only supported by WPA enabled Agere fw */ |
| 1336 if (!priv->has_wpa) |
| 1337 return -EOPNOTSUPP; |
| 1338 |
| 1339 memcpy(buf.addr, addr, ETH_ALEN); |
| 1340 buf.reason_code = cpu_to_le16(reason_code); |
| 1341 err = HERMES_WRITE_RECORD(hw, USER_BAP, |
| 1342 HERMES_RID_CNFDISASSOCIATE, |
| 1343 &buf); |
| 1344 return err; |
| 1345 } |
| 1346 |
| 1347 int orinoco_hw_get_current_bssid(struct orinoco_private *priv, |
| 1348 u8 *addr) |
| 1349 { |
| 1350 hermes_t *hw = &priv->hw; |
| 1351 int err; |
| 1352 |
| 1353 err = hw->ops->read_ltv(hw, USER_BAP, HERMES_RID_CURRENTBSSID, |
| 1354 ETH_ALEN, NULL, addr); |
| 1355 |
| 1356 return err; |
| 1357 } |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 5326002:
Update compat-wireless to 2.6.36-5-spn (Closed)
Base URL: http://git.chromium.org/git/kernel.git@master