PageRenderTime 35ms CodeModel.GetById 23ms RepoModel.GetById 1ms app.codeStats 0ms

/drivers/net/wireless/hostap/hostap_ioctl.c

http://github.com/mirrors/linux
C | 4054 lines | 3235 code | 637 blank | 182 comment | 686 complexity | 24c14f8b79eb0d5f2851e0964efeb5a2 MD5 | raw file
Possible License(s): AGPL-1.0, GPL-2.0, LGPL-2.0
  1. /* ioctl() (mostly Linux Wireless Extensions) routines for Host AP driver */
  2. #include <linux/slab.h>
  3. #include <linux/types.h>
  4. #include <linux/sched.h>
  5. #include <linux/ethtool.h>
  6. #include <linux/if_arp.h>
  7. #include <linux/module.h>
  8. #include <linux/etherdevice.h>
  9. #include <net/lib80211.h>
  10. #include "hostap_wlan.h"
  11. #include "hostap.h"
  12. #include "hostap_ap.h"
  13. static struct iw_statistics *hostap_get_wireless_stats(struct net_device *dev)
  14. {
  15. struct hostap_interface *iface;
  16. local_info_t *local;
  17. struct iw_statistics *wstats;
  18. iface = netdev_priv(dev);
  19. local = iface->local;
  20. /* Why are we doing that ? Jean II */
  21. if (iface->type != HOSTAP_INTERFACE_MAIN)
  22. return NULL;
  23. wstats = &local->wstats;
  24. wstats->status = 0;
  25. wstats->discard.code =
  26. local->comm_tallies.rx_discards_wep_undecryptable;
  27. wstats->discard.misc =
  28. local->comm_tallies.rx_fcs_errors +
  29. local->comm_tallies.rx_discards_no_buffer +
  30. local->comm_tallies.tx_discards_wrong_sa;
  31. wstats->discard.retries =
  32. local->comm_tallies.tx_retry_limit_exceeded;
  33. wstats->discard.fragment =
  34. local->comm_tallies.rx_message_in_bad_msg_fragments;
  35. if (local->iw_mode != IW_MODE_MASTER &&
  36. local->iw_mode != IW_MODE_REPEAT) {
  37. int update = 1;
  38. #ifdef in_atomic
  39. /* RID reading might sleep and it must not be called in
  40. * interrupt context or while atomic. However, this
  41. * function seems to be called while atomic (at least in Linux
  42. * 2.5.59). Update signal quality values only if in suitable
  43. * context. Otherwise, previous values read from tick timer
  44. * will be used. */
  45. if (in_atomic())
  46. update = 0;
  47. #endif /* in_atomic */
  48. if (update && prism2_update_comms_qual(dev) == 0)
  49. wstats->qual.updated = IW_QUAL_ALL_UPDATED |
  50. IW_QUAL_DBM;
  51. wstats->qual.qual = local->comms_qual;
  52. wstats->qual.level = local->avg_signal;
  53. wstats->qual.noise = local->avg_noise;
  54. } else {
  55. wstats->qual.qual = 0;
  56. wstats->qual.level = 0;
  57. wstats->qual.noise = 0;
  58. wstats->qual.updated = IW_QUAL_ALL_INVALID;
  59. }
  60. return wstats;
  61. }
  62. static int prism2_get_datarates(struct net_device *dev, u8 *rates)
  63. {
  64. struct hostap_interface *iface;
  65. local_info_t *local;
  66. u8 buf[12];
  67. int len;
  68. u16 val;
  69. iface = netdev_priv(dev);
  70. local = iface->local;
  71. len = local->func->get_rid(dev, HFA384X_RID_SUPPORTEDDATARATES, buf,
  72. sizeof(buf), 0);
  73. if (len < 2)
  74. return 0;
  75. val = le16_to_cpu(*(__le16 *) buf); /* string length */
  76. if (len - 2 < val || val > 10)
  77. return 0;
  78. memcpy(rates, buf + 2, val);
  79. return val;
  80. }
  81. static int prism2_get_name(struct net_device *dev,
  82. struct iw_request_info *info,
  83. char *name, char *extra)
  84. {
  85. u8 rates[10];
  86. int len, i, over2 = 0;
  87. len = prism2_get_datarates(dev, rates);
  88. for (i = 0; i < len; i++) {
  89. if (rates[i] == 0x0b || rates[i] == 0x16) {
  90. over2 = 1;
  91. break;
  92. }
  93. }
  94. strcpy(name, over2 ? "IEEE 802.11b" : "IEEE 802.11-DS");
  95. return 0;
  96. }
  97. static int prism2_ioctl_siwencode(struct net_device *dev,
  98. struct iw_request_info *info,
  99. struct iw_point *erq, char *keybuf)
  100. {
  101. struct hostap_interface *iface;
  102. local_info_t *local;
  103. int i;
  104. struct lib80211_crypt_data **crypt;
  105. iface = netdev_priv(dev);
  106. local = iface->local;
  107. i = erq->flags & IW_ENCODE_INDEX;
  108. if (i < 1 || i > 4)
  109. i = local->crypt_info.tx_keyidx;
  110. else
  111. i--;
  112. if (i < 0 || i >= WEP_KEYS)
  113. return -EINVAL;
  114. crypt = &local->crypt_info.crypt[i];
  115. if (erq->flags & IW_ENCODE_DISABLED) {
  116. if (*crypt)
  117. lib80211_crypt_delayed_deinit(&local->crypt_info, crypt);
  118. goto done;
  119. }
  120. if (*crypt != NULL && (*crypt)->ops != NULL &&
  121. strcmp((*crypt)->ops->name, "WEP") != 0) {
  122. /* changing to use WEP; deinit previously used algorithm */
  123. lib80211_crypt_delayed_deinit(&local->crypt_info, crypt);
  124. }
  125. if (*crypt == NULL) {
  126. struct lib80211_crypt_data *new_crypt;
  127. /* take WEP into use */
  128. new_crypt = kzalloc(sizeof(struct lib80211_crypt_data),
  129. GFP_KERNEL);
  130. if (new_crypt == NULL)
  131. return -ENOMEM;
  132. new_crypt->ops = lib80211_get_crypto_ops("WEP");
  133. if (!new_crypt->ops) {
  134. request_module("lib80211_crypt_wep");
  135. new_crypt->ops = lib80211_get_crypto_ops("WEP");
  136. }
  137. if (new_crypt->ops && try_module_get(new_crypt->ops->owner))
  138. new_crypt->priv = new_crypt->ops->init(i);
  139. if (!new_crypt->ops || !new_crypt->priv) {
  140. kfree(new_crypt);
  141. new_crypt = NULL;
  142. printk(KERN_WARNING "%s: could not initialize WEP: "
  143. "load module hostap_crypt_wep.o\n",
  144. dev->name);
  145. return -EOPNOTSUPP;
  146. }
  147. *crypt = new_crypt;
  148. }
  149. if (erq->length > 0) {
  150. int len = erq->length <= 5 ? 5 : 13;
  151. int first = 1, j;
  152. if (len > erq->length)
  153. memset(keybuf + erq->length, 0, len - erq->length);
  154. (*crypt)->ops->set_key(keybuf, len, NULL, (*crypt)->priv);
  155. for (j = 0; j < WEP_KEYS; j++) {
  156. if (j != i && local->crypt_info.crypt[j]) {
  157. first = 0;
  158. break;
  159. }
  160. }
  161. if (first)
  162. local->crypt_info.tx_keyidx = i;
  163. } else {
  164. /* No key data - just set the default TX key index */
  165. local->crypt_info.tx_keyidx = i;
  166. }
  167. done:
  168. local->open_wep = erq->flags & IW_ENCODE_OPEN;
  169. if (hostap_set_encryption(local)) {
  170. printk(KERN_DEBUG "%s: set_encryption failed\n", dev->name);
  171. return -EINVAL;
  172. }
  173. /* Do not reset port0 if card is in Managed mode since resetting will
  174. * generate new IEEE 802.11 authentication which may end up in looping
  175. * with IEEE 802.1X. Prism2 documentation seem to require port reset
  176. * after WEP configuration. However, keys are apparently changed at
  177. * least in Managed mode. */
  178. if (local->iw_mode != IW_MODE_INFRA && local->func->reset_port(dev)) {
  179. printk(KERN_DEBUG "%s: reset_port failed\n", dev->name);
  180. return -EINVAL;
  181. }
  182. return 0;
  183. }
  184. static int prism2_ioctl_giwencode(struct net_device *dev,
  185. struct iw_request_info *info,
  186. struct iw_point *erq, char *key)
  187. {
  188. struct hostap_interface *iface;
  189. local_info_t *local;
  190. int i, len;
  191. u16 val;
  192. struct lib80211_crypt_data *crypt;
  193. iface = netdev_priv(dev);
  194. local = iface->local;
  195. i = erq->flags & IW_ENCODE_INDEX;
  196. if (i < 1 || i > 4)
  197. i = local->crypt_info.tx_keyidx;
  198. else
  199. i--;
  200. if (i < 0 || i >= WEP_KEYS)
  201. return -EINVAL;
  202. crypt = local->crypt_info.crypt[i];
  203. erq->flags = i + 1;
  204. if (crypt == NULL || crypt->ops == NULL) {
  205. erq->length = 0;
  206. erq->flags |= IW_ENCODE_DISABLED;
  207. return 0;
  208. }
  209. if (strcmp(crypt->ops->name, "WEP") != 0) {
  210. /* only WEP is supported with wireless extensions, so just
  211. * report that encryption is used */
  212. erq->length = 0;
  213. erq->flags |= IW_ENCODE_ENABLED;
  214. return 0;
  215. }
  216. /* Reads from HFA384X_RID_CNFDEFAULTKEY* return bogus values, so show
  217. * the keys from driver buffer */
  218. len = crypt->ops->get_key(key, WEP_KEY_LEN, NULL, crypt->priv);
  219. erq->length = (len >= 0 ? len : 0);
  220. if (local->func->get_rid(dev, HFA384X_RID_CNFWEPFLAGS, &val, 2, 1) < 0)
  221. {
  222. printk("CNFWEPFLAGS reading failed\n");
  223. return -EOPNOTSUPP;
  224. }
  225. le16_to_cpus(&val);
  226. if (val & HFA384X_WEPFLAGS_PRIVACYINVOKED)
  227. erq->flags |= IW_ENCODE_ENABLED;
  228. else
  229. erq->flags |= IW_ENCODE_DISABLED;
  230. if (val & HFA384X_WEPFLAGS_EXCLUDEUNENCRYPTED)
  231. erq->flags |= IW_ENCODE_RESTRICTED;
  232. else
  233. erq->flags |= IW_ENCODE_OPEN;
  234. return 0;
  235. }
  236. static int hostap_set_rate(struct net_device *dev)
  237. {
  238. struct hostap_interface *iface;
  239. local_info_t *local;
  240. int ret, basic_rates;
  241. iface = netdev_priv(dev);
  242. local = iface->local;
  243. basic_rates = local->basic_rates & local->tx_rate_control;
  244. if (!basic_rates || basic_rates != local->basic_rates) {
  245. printk(KERN_INFO "%s: updating basic rate set automatically "
  246. "to match with the new supported rate set\n",
  247. dev->name);
  248. if (!basic_rates)
  249. basic_rates = local->tx_rate_control;
  250. local->basic_rates = basic_rates;
  251. if (hostap_set_word(dev, HFA384X_RID_CNFBASICRATES,
  252. basic_rates))
  253. printk(KERN_WARNING "%s: failed to set "
  254. "cnfBasicRates\n", dev->name);
  255. }
  256. ret = (hostap_set_word(dev, HFA384X_RID_TXRATECONTROL,
  257. local->tx_rate_control) ||
  258. hostap_set_word(dev, HFA384X_RID_CNFSUPPORTEDRATES,
  259. local->tx_rate_control) ||
  260. local->func->reset_port(dev));
  261. if (ret) {
  262. printk(KERN_WARNING "%s: TXRateControl/cnfSupportedRates "
  263. "setting to 0x%x failed\n",
  264. dev->name, local->tx_rate_control);
  265. }
  266. /* Update TX rate configuration for all STAs based on new operational
  267. * rate set. */
  268. hostap_update_rates(local);
  269. return ret;
  270. }
  271. static int prism2_ioctl_siwrate(struct net_device *dev,
  272. struct iw_request_info *info,
  273. struct iw_param *rrq, char *extra)
  274. {
  275. struct hostap_interface *iface;
  276. local_info_t *local;
  277. iface = netdev_priv(dev);
  278. local = iface->local;
  279. if (rrq->fixed) {
  280. switch (rrq->value) {
  281. case 11000000:
  282. local->tx_rate_control = HFA384X_RATES_11MBPS;
  283. break;
  284. case 5500000:
  285. local->tx_rate_control = HFA384X_RATES_5MBPS;
  286. break;
  287. case 2000000:
  288. local->tx_rate_control = HFA384X_RATES_2MBPS;
  289. break;
  290. case 1000000:
  291. local->tx_rate_control = HFA384X_RATES_1MBPS;
  292. break;
  293. default:
  294. local->tx_rate_control = HFA384X_RATES_1MBPS |
  295. HFA384X_RATES_2MBPS | HFA384X_RATES_5MBPS |
  296. HFA384X_RATES_11MBPS;
  297. break;
  298. }
  299. } else {
  300. switch (rrq->value) {
  301. case 11000000:
  302. local->tx_rate_control = HFA384X_RATES_1MBPS |
  303. HFA384X_RATES_2MBPS | HFA384X_RATES_5MBPS |
  304. HFA384X_RATES_11MBPS;
  305. break;
  306. case 5500000:
  307. local->tx_rate_control = HFA384X_RATES_1MBPS |
  308. HFA384X_RATES_2MBPS | HFA384X_RATES_5MBPS;
  309. break;
  310. case 2000000:
  311. local->tx_rate_control = HFA384X_RATES_1MBPS |
  312. HFA384X_RATES_2MBPS;
  313. break;
  314. case 1000000:
  315. local->tx_rate_control = HFA384X_RATES_1MBPS;
  316. break;
  317. default:
  318. local->tx_rate_control = HFA384X_RATES_1MBPS |
  319. HFA384X_RATES_2MBPS | HFA384X_RATES_5MBPS |
  320. HFA384X_RATES_11MBPS;
  321. break;
  322. }
  323. }
  324. return hostap_set_rate(dev);
  325. }
  326. static int prism2_ioctl_giwrate(struct net_device *dev,
  327. struct iw_request_info *info,
  328. struct iw_param *rrq, char *extra)
  329. {
  330. u16 val;
  331. struct hostap_interface *iface;
  332. local_info_t *local;
  333. int ret = 0;
  334. iface = netdev_priv(dev);
  335. local = iface->local;
  336. if (local->func->get_rid(dev, HFA384X_RID_TXRATECONTROL, &val, 2, 1) <
  337. 0)
  338. return -EINVAL;
  339. if ((val & 0x1) && (val > 1))
  340. rrq->fixed = 0;
  341. else
  342. rrq->fixed = 1;
  343. if (local->iw_mode == IW_MODE_MASTER && local->ap != NULL &&
  344. !local->fw_tx_rate_control) {
  345. /* HFA384X_RID_CURRENTTXRATE seems to always be 2 Mbps in
  346. * Host AP mode, so use the recorded TX rate of the last sent
  347. * frame */
  348. rrq->value = local->ap->last_tx_rate > 0 ?
  349. local->ap->last_tx_rate * 100000 : 11000000;
  350. return 0;
  351. }
  352. if (local->func->get_rid(dev, HFA384X_RID_CURRENTTXRATE, &val, 2, 1) <
  353. 0)
  354. return -EINVAL;
  355. switch (val) {
  356. case HFA384X_RATES_1MBPS:
  357. rrq->value = 1000000;
  358. break;
  359. case HFA384X_RATES_2MBPS:
  360. rrq->value = 2000000;
  361. break;
  362. case HFA384X_RATES_5MBPS:
  363. rrq->value = 5500000;
  364. break;
  365. case HFA384X_RATES_11MBPS:
  366. rrq->value = 11000000;
  367. break;
  368. default:
  369. /* should not happen */
  370. rrq->value = 11000000;
  371. ret = -EINVAL;
  372. break;
  373. }
  374. return ret;
  375. }
  376. static int prism2_ioctl_siwsens(struct net_device *dev,
  377. struct iw_request_info *info,
  378. struct iw_param *sens, char *extra)
  379. {
  380. struct hostap_interface *iface;
  381. local_info_t *local;
  382. iface = netdev_priv(dev);
  383. local = iface->local;
  384. /* Set the desired AP density */
  385. if (sens->value < 1 || sens->value > 3)
  386. return -EINVAL;
  387. if (hostap_set_word(dev, HFA384X_RID_CNFSYSTEMSCALE, sens->value) ||
  388. local->func->reset_port(dev))
  389. return -EINVAL;
  390. return 0;
  391. }
  392. static int prism2_ioctl_giwsens(struct net_device *dev,
  393. struct iw_request_info *info,
  394. struct iw_param *sens, char *extra)
  395. {
  396. struct hostap_interface *iface;
  397. local_info_t *local;
  398. __le16 val;
  399. iface = netdev_priv(dev);
  400. local = iface->local;
  401. /* Get the current AP density */
  402. if (local->func->get_rid(dev, HFA384X_RID_CNFSYSTEMSCALE, &val, 2, 1) <
  403. 0)
  404. return -EINVAL;
  405. sens->value = le16_to_cpu(val);
  406. sens->fixed = 1;
  407. return 0;
  408. }
  409. /* Deprecated in new wireless extension API */
  410. static int prism2_ioctl_giwaplist(struct net_device *dev,
  411. struct iw_request_info *info,
  412. struct iw_point *data, char *extra)
  413. {
  414. struct hostap_interface *iface;
  415. local_info_t *local;
  416. struct sockaddr *addr;
  417. struct iw_quality *qual;
  418. iface = netdev_priv(dev);
  419. local = iface->local;
  420. if (local->iw_mode != IW_MODE_MASTER) {
  421. printk(KERN_DEBUG "SIOCGIWAPLIST is currently only supported "
  422. "in Host AP mode\n");
  423. data->length = 0;
  424. return -EOPNOTSUPP;
  425. }
  426. addr = kmalloc(sizeof(struct sockaddr) * IW_MAX_AP, GFP_KERNEL);
  427. qual = kmalloc(sizeof(struct iw_quality) * IW_MAX_AP, GFP_KERNEL);
  428. if (addr == NULL || qual == NULL) {
  429. kfree(addr);
  430. kfree(qual);
  431. data->length = 0;
  432. return -ENOMEM;
  433. }
  434. data->length = prism2_ap_get_sta_qual(local, addr, qual, IW_MAX_AP, 1);
  435. memcpy(extra, addr, sizeof(struct sockaddr) * data->length);
  436. data->flags = 1; /* has quality information */
  437. memcpy(extra + sizeof(struct sockaddr) * data->length, qual,
  438. sizeof(struct iw_quality) * data->length);
  439. kfree(addr);
  440. kfree(qual);
  441. return 0;
  442. }
  443. static int prism2_ioctl_siwrts(struct net_device *dev,
  444. struct iw_request_info *info,
  445. struct iw_param *rts, char *extra)
  446. {
  447. struct hostap_interface *iface;
  448. local_info_t *local;
  449. __le16 val;
  450. iface = netdev_priv(dev);
  451. local = iface->local;
  452. if (rts->disabled)
  453. val = cpu_to_le16(2347);
  454. else if (rts->value < 0 || rts->value > 2347)
  455. return -EINVAL;
  456. else
  457. val = cpu_to_le16(rts->value);
  458. if (local->func->set_rid(dev, HFA384X_RID_RTSTHRESHOLD, &val, 2) ||
  459. local->func->reset_port(dev))
  460. return -EINVAL;
  461. local->rts_threshold = rts->value;
  462. return 0;
  463. }
  464. static int prism2_ioctl_giwrts(struct net_device *dev,
  465. struct iw_request_info *info,
  466. struct iw_param *rts, char *extra)
  467. {
  468. struct hostap_interface *iface;
  469. local_info_t *local;
  470. __le16 val;
  471. iface = netdev_priv(dev);
  472. local = iface->local;
  473. if (local->func->get_rid(dev, HFA384X_RID_RTSTHRESHOLD, &val, 2, 1) <
  474. 0)
  475. return -EINVAL;
  476. rts->value = le16_to_cpu(val);
  477. rts->disabled = (rts->value == 2347);
  478. rts->fixed = 1;
  479. return 0;
  480. }
  481. static int prism2_ioctl_siwfrag(struct net_device *dev,
  482. struct iw_request_info *info,
  483. struct iw_param *rts, char *extra)
  484. {
  485. struct hostap_interface *iface;
  486. local_info_t *local;
  487. __le16 val;
  488. iface = netdev_priv(dev);
  489. local = iface->local;
  490. if (rts->disabled)
  491. val = cpu_to_le16(2346);
  492. else if (rts->value < 256 || rts->value > 2346)
  493. return -EINVAL;
  494. else
  495. val = cpu_to_le16(rts->value & ~0x1); /* even numbers only */
  496. local->fragm_threshold = rts->value & ~0x1;
  497. if (local->func->set_rid(dev, HFA384X_RID_FRAGMENTATIONTHRESHOLD, &val,
  498. 2)
  499. || local->func->reset_port(dev))
  500. return -EINVAL;
  501. return 0;
  502. }
  503. static int prism2_ioctl_giwfrag(struct net_device *dev,
  504. struct iw_request_info *info,
  505. struct iw_param *rts, char *extra)
  506. {
  507. struct hostap_interface *iface;
  508. local_info_t *local;
  509. __le16 val;
  510. iface = netdev_priv(dev);
  511. local = iface->local;
  512. if (local->func->get_rid(dev, HFA384X_RID_FRAGMENTATIONTHRESHOLD,
  513. &val, 2, 1) < 0)
  514. return -EINVAL;
  515. rts->value = le16_to_cpu(val);
  516. rts->disabled = (rts->value == 2346);
  517. rts->fixed = 1;
  518. return 0;
  519. }
  520. #ifndef PRISM2_NO_STATION_MODES
  521. static int hostap_join_ap(struct net_device *dev)
  522. {
  523. struct hostap_interface *iface;
  524. local_info_t *local;
  525. struct hfa384x_join_request req;
  526. unsigned long flags;
  527. int i;
  528. struct hfa384x_hostscan_result *entry;
  529. iface = netdev_priv(dev);
  530. local = iface->local;
  531. memcpy(req.bssid, local->preferred_ap, ETH_ALEN);
  532. req.channel = 0;
  533. spin_lock_irqsave(&local->lock, flags);
  534. for (i = 0; i < local->last_scan_results_count; i++) {
  535. if (!local->last_scan_results)
  536. break;
  537. entry = &local->last_scan_results[i];
  538. if (memcmp(local->preferred_ap, entry->bssid, ETH_ALEN) == 0) {
  539. req.channel = entry->chid;
  540. break;
  541. }
  542. }
  543. spin_unlock_irqrestore(&local->lock, flags);
  544. if (local->func->set_rid(dev, HFA384X_RID_JOINREQUEST, &req,
  545. sizeof(req))) {
  546. printk(KERN_DEBUG "%s: JoinRequest %pM failed\n",
  547. dev->name, local->preferred_ap);
  548. return -1;
  549. }
  550. printk(KERN_DEBUG "%s: Trying to join BSSID %pM\n",
  551. dev->name, local->preferred_ap);
  552. return 0;
  553. }
  554. #endif /* PRISM2_NO_STATION_MODES */
  555. static int prism2_ioctl_siwap(struct net_device *dev,
  556. struct iw_request_info *info,
  557. struct sockaddr *ap_addr, char *extra)
  558. {
  559. #ifdef PRISM2_NO_STATION_MODES
  560. return -EOPNOTSUPP;
  561. #else /* PRISM2_NO_STATION_MODES */
  562. struct hostap_interface *iface;
  563. local_info_t *local;
  564. iface = netdev_priv(dev);
  565. local = iface->local;
  566. memcpy(local->preferred_ap, &ap_addr->sa_data, ETH_ALEN);
  567. if (local->host_roaming == 1 && local->iw_mode == IW_MODE_INFRA) {
  568. struct hfa384x_scan_request scan_req;
  569. memset(&scan_req, 0, sizeof(scan_req));
  570. scan_req.channel_list = cpu_to_le16(0x3fff);
  571. scan_req.txrate = cpu_to_le16(HFA384X_RATES_1MBPS);
  572. if (local->func->set_rid(dev, HFA384X_RID_SCANREQUEST,
  573. &scan_req, sizeof(scan_req))) {
  574. printk(KERN_DEBUG "%s: ScanResults request failed - "
  575. "preferred AP delayed to next unsolicited "
  576. "scan\n", dev->name);
  577. }
  578. } else if (local->host_roaming == 2 &&
  579. local->iw_mode == IW_MODE_INFRA) {
  580. if (hostap_join_ap(dev))
  581. return -EINVAL;
  582. } else {
  583. printk(KERN_DEBUG "%s: Preferred AP (SIOCSIWAP) is used only "
  584. "in Managed mode when host_roaming is enabled\n",
  585. dev->name);
  586. }
  587. return 0;
  588. #endif /* PRISM2_NO_STATION_MODES */
  589. }
  590. static int prism2_ioctl_giwap(struct net_device *dev,
  591. struct iw_request_info *info,
  592. struct sockaddr *ap_addr, char *extra)
  593. {
  594. struct hostap_interface *iface;
  595. local_info_t *local;
  596. iface = netdev_priv(dev);
  597. local = iface->local;
  598. ap_addr->sa_family = ARPHRD_ETHER;
  599. switch (iface->type) {
  600. case HOSTAP_INTERFACE_AP:
  601. memcpy(&ap_addr->sa_data, dev->dev_addr, ETH_ALEN);
  602. break;
  603. case HOSTAP_INTERFACE_STA:
  604. memcpy(&ap_addr->sa_data, local->assoc_ap_addr, ETH_ALEN);
  605. break;
  606. case HOSTAP_INTERFACE_WDS:
  607. memcpy(&ap_addr->sa_data, iface->u.wds.remote_addr, ETH_ALEN);
  608. break;
  609. default:
  610. if (local->func->get_rid(dev, HFA384X_RID_CURRENTBSSID,
  611. &ap_addr->sa_data, ETH_ALEN, 1) < 0)
  612. return -EOPNOTSUPP;
  613. /* local->bssid is also updated in LinkStatus handler when in
  614. * station mode */
  615. memcpy(local->bssid, &ap_addr->sa_data, ETH_ALEN);
  616. break;
  617. }
  618. return 0;
  619. }
  620. static int prism2_ioctl_siwnickn(struct net_device *dev,
  621. struct iw_request_info *info,
  622. struct iw_point *data, char *nickname)
  623. {
  624. struct hostap_interface *iface;
  625. local_info_t *local;
  626. iface = netdev_priv(dev);
  627. local = iface->local;
  628. memset(local->name, 0, sizeof(local->name));
  629. memcpy(local->name, nickname, data->length);
  630. local->name_set = 1;
  631. if (hostap_set_string(dev, HFA384X_RID_CNFOWNNAME, local->name) ||
  632. local->func->reset_port(dev))
  633. return -EINVAL;
  634. return 0;
  635. }
  636. static int prism2_ioctl_giwnickn(struct net_device *dev,
  637. struct iw_request_info *info,
  638. struct iw_point *data, char *nickname)
  639. {
  640. struct hostap_interface *iface;
  641. local_info_t *local;
  642. int len;
  643. char name[MAX_NAME_LEN + 3];
  644. u16 val;
  645. iface = netdev_priv(dev);
  646. local = iface->local;
  647. len = local->func->get_rid(dev, HFA384X_RID_CNFOWNNAME,
  648. &name, MAX_NAME_LEN + 2, 0);
  649. val = le16_to_cpu(*(__le16 *) name);
  650. if (len > MAX_NAME_LEN + 2 || len < 0 || val > MAX_NAME_LEN)
  651. return -EOPNOTSUPP;
  652. name[val + 2] = '\0';
  653. data->length = val + 1;
  654. memcpy(nickname, name + 2, val + 1);
  655. return 0;
  656. }
  657. static int prism2_ioctl_siwfreq(struct net_device *dev,
  658. struct iw_request_info *info,
  659. struct iw_freq *freq, char *extra)
  660. {
  661. struct hostap_interface *iface;
  662. local_info_t *local;
  663. iface = netdev_priv(dev);
  664. local = iface->local;
  665. /* freq => chan. */
  666. if (freq->e == 1 &&
  667. freq->m / 100000 >= freq_list[0] &&
  668. freq->m / 100000 <= freq_list[FREQ_COUNT - 1]) {
  669. int ch;
  670. int fr = freq->m / 100000;
  671. for (ch = 0; ch < FREQ_COUNT; ch++) {
  672. if (fr == freq_list[ch]) {
  673. freq->e = 0;
  674. freq->m = ch + 1;
  675. break;
  676. }
  677. }
  678. }
  679. if (freq->e != 0 || freq->m < 1 || freq->m > FREQ_COUNT ||
  680. !(local->channel_mask & (1 << (freq->m - 1))))
  681. return -EINVAL;
  682. local->channel = freq->m; /* channel is used in prism2_setup_rids() */
  683. if (hostap_set_word(dev, HFA384X_RID_CNFOWNCHANNEL, local->channel) ||
  684. local->func->reset_port(dev))
  685. return -EINVAL;
  686. return 0;
  687. }
  688. static int prism2_ioctl_giwfreq(struct net_device *dev,
  689. struct iw_request_info *info,
  690. struct iw_freq *freq, char *extra)
  691. {
  692. struct hostap_interface *iface;
  693. local_info_t *local;
  694. u16 val;
  695. iface = netdev_priv(dev);
  696. local = iface->local;
  697. if (local->func->get_rid(dev, HFA384X_RID_CURRENTCHANNEL, &val, 2, 1) <
  698. 0)
  699. return -EINVAL;
  700. le16_to_cpus(&val);
  701. if (val < 1 || val > FREQ_COUNT)
  702. return -EINVAL;
  703. freq->m = freq_list[val - 1] * 100000;
  704. freq->e = 1;
  705. return 0;
  706. }
  707. static void hostap_monitor_set_type(local_info_t *local)
  708. {
  709. struct net_device *dev = local->ddev;
  710. if (dev == NULL)
  711. return;
  712. if (local->monitor_type == PRISM2_MONITOR_PRISM ||
  713. local->monitor_type == PRISM2_MONITOR_CAPHDR) {
  714. dev->type = ARPHRD_IEEE80211_PRISM;
  715. } else if (local->monitor_type == PRISM2_MONITOR_RADIOTAP) {
  716. dev->type = ARPHRD_IEEE80211_RADIOTAP;
  717. } else {
  718. dev->type = ARPHRD_IEEE80211;
  719. }
  720. }
  721. static int prism2_ioctl_siwessid(struct net_device *dev,
  722. struct iw_request_info *info,
  723. struct iw_point *data, char *ssid)
  724. {
  725. struct hostap_interface *iface;
  726. local_info_t *local;
  727. iface = netdev_priv(dev);
  728. local = iface->local;
  729. if (iface->type == HOSTAP_INTERFACE_WDS)
  730. return -EOPNOTSUPP;
  731. if (data->flags == 0)
  732. ssid[0] = '\0'; /* ANY */
  733. if (local->iw_mode == IW_MODE_MASTER && ssid[0] == '\0') {
  734. /* Setting SSID to empty string seems to kill the card in
  735. * Host AP mode */
  736. printk(KERN_DEBUG "%s: Host AP mode does not support "
  737. "'Any' essid\n", dev->name);
  738. return -EINVAL;
  739. }
  740. memcpy(local->essid, ssid, data->length);
  741. local->essid[data->length] = '\0';
  742. if ((!local->fw_ap &&
  743. hostap_set_string(dev, HFA384X_RID_CNFDESIREDSSID, local->essid))
  744. || hostap_set_string(dev, HFA384X_RID_CNFOWNSSID, local->essid) ||
  745. local->func->reset_port(dev))
  746. return -EINVAL;
  747. return 0;
  748. }
  749. static int prism2_ioctl_giwessid(struct net_device *dev,
  750. struct iw_request_info *info,
  751. struct iw_point *data, char *essid)
  752. {
  753. struct hostap_interface *iface;
  754. local_info_t *local;
  755. u16 val;
  756. iface = netdev_priv(dev);
  757. local = iface->local;
  758. if (iface->type == HOSTAP_INTERFACE_WDS)
  759. return -EOPNOTSUPP;
  760. data->flags = 1; /* active */
  761. if (local->iw_mode == IW_MODE_MASTER) {
  762. data->length = strlen(local->essid);
  763. memcpy(essid, local->essid, IW_ESSID_MAX_SIZE);
  764. } else {
  765. int len;
  766. char ssid[MAX_SSID_LEN + 2];
  767. memset(ssid, 0, sizeof(ssid));
  768. len = local->func->get_rid(dev, HFA384X_RID_CURRENTSSID,
  769. &ssid, MAX_SSID_LEN + 2, 0);
  770. val = le16_to_cpu(*(__le16 *) ssid);
  771. if (len > MAX_SSID_LEN + 2 || len < 0 || val > MAX_SSID_LEN) {
  772. return -EOPNOTSUPP;
  773. }
  774. data->length = val;
  775. memcpy(essid, ssid + 2, IW_ESSID_MAX_SIZE);
  776. }
  777. return 0;
  778. }
  779. static int prism2_ioctl_giwrange(struct net_device *dev,
  780. struct iw_request_info *info,
  781. struct iw_point *data, char *extra)
  782. {
  783. struct hostap_interface *iface;
  784. local_info_t *local;
  785. struct iw_range *range = (struct iw_range *) extra;
  786. u8 rates[10];
  787. u16 val;
  788. int i, len, over2;
  789. iface = netdev_priv(dev);
  790. local = iface->local;
  791. data->length = sizeof(struct iw_range);
  792. memset(range, 0, sizeof(struct iw_range));
  793. /* TODO: could fill num_txpower and txpower array with
  794. * something; however, there are 128 different values.. */
  795. range->txpower_capa = IW_TXPOW_DBM;
  796. if (local->iw_mode == IW_MODE_INFRA || local->iw_mode == IW_MODE_ADHOC)
  797. {
  798. range->min_pmp = 1 * 1024;
  799. range->max_pmp = 65535 * 1024;
  800. range->min_pmt = 1 * 1024;
  801. range->max_pmt = 1000 * 1024;
  802. range->pmp_flags = IW_POWER_PERIOD;
  803. range->pmt_flags = IW_POWER_TIMEOUT;
  804. range->pm_capa = IW_POWER_PERIOD | IW_POWER_TIMEOUT |
  805. IW_POWER_UNICAST_R | IW_POWER_ALL_R;
  806. }
  807. range->we_version_compiled = WIRELESS_EXT;
  808. range->we_version_source = 18;
  809. range->retry_capa = IW_RETRY_LIMIT;
  810. range->retry_flags = IW_RETRY_LIMIT;
  811. range->min_retry = 0;
  812. range->max_retry = 255;
  813. range->num_channels = FREQ_COUNT;
  814. val = 0;
  815. for (i = 0; i < FREQ_COUNT; i++) {
  816. if (local->channel_mask & (1 << i)) {
  817. range->freq[val].i = i + 1;
  818. range->freq[val].m = freq_list[i] * 100000;
  819. range->freq[val].e = 1;
  820. val++;
  821. }
  822. if (val == IW_MAX_FREQUENCIES)
  823. break;
  824. }
  825. range->num_frequency = val;
  826. if (local->sta_fw_ver >= PRISM2_FW_VER(1,3,1)) {
  827. range->max_qual.qual = 70; /* what is correct max? This was not
  828. * documented exactly. At least
  829. * 69 has been observed. */
  830. range->max_qual.level = 0; /* dB */
  831. range->max_qual.noise = 0; /* dB */
  832. /* What would be suitable values for "average/typical" qual? */
  833. range->avg_qual.qual = 20;
  834. range->avg_qual.level = -60;
  835. range->avg_qual.noise = -95;
  836. } else {
  837. range->max_qual.qual = 92; /* 0 .. 92 */
  838. range->max_qual.level = 154; /* 27 .. 154 */
  839. range->max_qual.noise = 154; /* 27 .. 154 */
  840. }
  841. range->sensitivity = 3;
  842. range->max_encoding_tokens = WEP_KEYS;
  843. range->num_encoding_sizes = 2;
  844. range->encoding_size[0] = 5;
  845. range->encoding_size[1] = 13;
  846. over2 = 0;
  847. len = prism2_get_datarates(dev, rates);
  848. range->num_bitrates = 0;
  849. for (i = 0; i < len; i++) {
  850. if (range->num_bitrates < IW_MAX_BITRATES) {
  851. range->bitrate[range->num_bitrates] =
  852. rates[i] * 500000;
  853. range->num_bitrates++;
  854. }
  855. if (rates[i] == 0x0b || rates[i] == 0x16)
  856. over2 = 1;
  857. }
  858. /* estimated maximum TCP throughput values (bps) */
  859. range->throughput = over2 ? 5500000 : 1500000;
  860. range->min_rts = 0;
  861. range->max_rts = 2347;
  862. range->min_frag = 256;
  863. range->max_frag = 2346;
  864. /* Event capability (kernel + driver) */
  865. range->event_capa[0] = (IW_EVENT_CAPA_K_0 |
  866. IW_EVENT_CAPA_MASK(SIOCGIWTHRSPY) |
  867. IW_EVENT_CAPA_MASK(SIOCGIWAP) |
  868. IW_EVENT_CAPA_MASK(SIOCGIWSCAN));
  869. range->event_capa[1] = IW_EVENT_CAPA_K_1;
  870. range->event_capa[4] = (IW_EVENT_CAPA_MASK(IWEVTXDROP) |
  871. IW_EVENT_CAPA_MASK(IWEVCUSTOM) |
  872. IW_EVENT_CAPA_MASK(IWEVREGISTERED) |
  873. IW_EVENT_CAPA_MASK(IWEVEXPIRED));
  874. range->enc_capa = IW_ENC_CAPA_WPA | IW_ENC_CAPA_WPA2 |
  875. IW_ENC_CAPA_CIPHER_TKIP | IW_ENC_CAPA_CIPHER_CCMP;
  876. if (local->sta_fw_ver >= PRISM2_FW_VER(1,3,1))
  877. range->scan_capa = IW_SCAN_CAPA_ESSID;
  878. return 0;
  879. }
  880. static int hostap_monitor_mode_enable(local_info_t *local)
  881. {
  882. struct net_device *dev = local->dev;
  883. printk(KERN_DEBUG "Enabling monitor mode\n");
  884. hostap_monitor_set_type(local);
  885. if (hostap_set_word(dev, HFA384X_RID_CNFPORTTYPE,
  886. HFA384X_PORTTYPE_PSEUDO_IBSS)) {
  887. printk(KERN_DEBUG "Port type setting for monitor mode "
  888. "failed\n");
  889. return -EOPNOTSUPP;
  890. }
  891. /* Host decrypt is needed to get the IV and ICV fields;
  892. * however, monitor mode seems to remove WEP flag from frame
  893. * control field */
  894. if (hostap_set_word(dev, HFA384X_RID_CNFWEPFLAGS,
  895. HFA384X_WEPFLAGS_HOSTENCRYPT |
  896. HFA384X_WEPFLAGS_HOSTDECRYPT)) {
  897. printk(KERN_DEBUG "WEP flags setting failed\n");
  898. return -EOPNOTSUPP;
  899. }
  900. if (local->func->reset_port(dev) ||
  901. local->func->cmd(dev, HFA384X_CMDCODE_TEST |
  902. (HFA384X_TEST_MONITOR << 8),
  903. 0, NULL, NULL)) {
  904. printk(KERN_DEBUG "Setting monitor mode failed\n");
  905. return -EOPNOTSUPP;
  906. }
  907. return 0;
  908. }
  909. static int hostap_monitor_mode_disable(local_info_t *local)
  910. {
  911. struct net_device *dev = local->ddev;
  912. if (dev == NULL)
  913. return -1;
  914. printk(KERN_DEBUG "%s: Disabling monitor mode\n", dev->name);
  915. dev->type = ARPHRD_ETHER;
  916. if (local->func->cmd(dev, HFA384X_CMDCODE_TEST |
  917. (HFA384X_TEST_STOP << 8),
  918. 0, NULL, NULL))
  919. return -1;
  920. return hostap_set_encryption(local);
  921. }
  922. static int prism2_ioctl_siwmode(struct net_device *dev,
  923. struct iw_request_info *info,
  924. __u32 *mode, char *extra)
  925. {
  926. struct hostap_interface *iface;
  927. local_info_t *local;
  928. int double_reset = 0;
  929. iface = netdev_priv(dev);
  930. local = iface->local;
  931. if (*mode != IW_MODE_ADHOC && *mode != IW_MODE_INFRA &&
  932. *mode != IW_MODE_MASTER && *mode != IW_MODE_REPEAT &&
  933. *mode != IW_MODE_MONITOR)
  934. return -EOPNOTSUPP;
  935. #ifdef PRISM2_NO_STATION_MODES
  936. if (*mode == IW_MODE_ADHOC || *mode == IW_MODE_INFRA)
  937. return -EOPNOTSUPP;
  938. #endif /* PRISM2_NO_STATION_MODES */
  939. if (*mode == local->iw_mode)
  940. return 0;
  941. if (*mode == IW_MODE_MASTER && local->essid[0] == '\0') {
  942. printk(KERN_WARNING "%s: empty SSID not allowed in Master "
  943. "mode\n", dev->name);
  944. return -EINVAL;
  945. }
  946. if (local->iw_mode == IW_MODE_MONITOR)
  947. hostap_monitor_mode_disable(local);
  948. if ((local->iw_mode == IW_MODE_ADHOC ||
  949. local->iw_mode == IW_MODE_MONITOR) && *mode == IW_MODE_MASTER) {
  950. /* There seems to be a firmware bug in at least STA f/w v1.5.6
  951. * that leaves beacon frames to use IBSS type when moving from
  952. * IBSS to Host AP mode. Doing double Port0 reset seems to be
  953. * enough to workaround this. */
  954. double_reset = 1;
  955. }
  956. printk(KERN_DEBUG "prism2: %s: operating mode changed "
  957. "%d -> %d\n", dev->name, local->iw_mode, *mode);
  958. local->iw_mode = *mode;
  959. if (local->iw_mode == IW_MODE_MONITOR)
  960. hostap_monitor_mode_enable(local);
  961. else if (local->iw_mode == IW_MODE_MASTER && !local->host_encrypt &&
  962. !local->fw_encrypt_ok) {
  963. printk(KERN_DEBUG "%s: defaulting to host-based encryption as "
  964. "a workaround for firmware bug in Host AP mode WEP\n",
  965. dev->name);
  966. local->host_encrypt = 1;
  967. }
  968. if (hostap_set_word(dev, HFA384X_RID_CNFPORTTYPE,
  969. hostap_get_porttype(local)))
  970. return -EOPNOTSUPP;
  971. if (local->func->reset_port(dev))
  972. return -EINVAL;
  973. if (double_reset && local->func->reset_port(dev))
  974. return -EINVAL;
  975. if (local->iw_mode != IW_MODE_INFRA && local->iw_mode != IW_MODE_ADHOC)
  976. {
  977. /* netif_carrier is used only in client modes for now, so make
  978. * sure carrier is on when moving to non-client modes. */
  979. netif_carrier_on(local->dev);
  980. netif_carrier_on(local->ddev);
  981. }
  982. return 0;
  983. }
  984. static int prism2_ioctl_giwmode(struct net_device *dev,
  985. struct iw_request_info *info,
  986. __u32 *mode, char *extra)
  987. {
  988. struct hostap_interface *iface;
  989. local_info_t *local;
  990. iface = netdev_priv(dev);
  991. local = iface->local;
  992. switch (iface->type) {
  993. case HOSTAP_INTERFACE_STA:
  994. *mode = IW_MODE_INFRA;
  995. break;
  996. case HOSTAP_INTERFACE_WDS:
  997. *mode = IW_MODE_REPEAT;
  998. break;
  999. default:
  1000. *mode = local->iw_mode;
  1001. break;
  1002. }
  1003. return 0;
  1004. }
  1005. static int prism2_ioctl_siwpower(struct net_device *dev,
  1006. struct iw_request_info *info,
  1007. struct iw_param *wrq, char *extra)
  1008. {
  1009. #ifdef PRISM2_NO_STATION_MODES
  1010. return -EOPNOTSUPP;
  1011. #else /* PRISM2_NO_STATION_MODES */
  1012. int ret = 0;
  1013. if (wrq->disabled)
  1014. return hostap_set_word(dev, HFA384X_RID_CNFPMENABLED, 0);
  1015. switch (wrq->flags & IW_POWER_MODE) {
  1016. case IW_POWER_UNICAST_R:
  1017. ret = hostap_set_word(dev, HFA384X_RID_CNFMULTICASTRECEIVE, 0);
  1018. if (ret)
  1019. return ret;
  1020. ret = hostap_set_word(dev, HFA384X_RID_CNFPMENABLED, 1);
  1021. if (ret)
  1022. return ret;
  1023. break;
  1024. case IW_POWER_ALL_R:
  1025. ret = hostap_set_word(dev, HFA384X_RID_CNFMULTICASTRECEIVE, 1);
  1026. if (ret)
  1027. return ret;
  1028. ret = hostap_set_word(dev, HFA384X_RID_CNFPMENABLED, 1);
  1029. if (ret)
  1030. return ret;
  1031. break;
  1032. case IW_POWER_ON:
  1033. break;
  1034. default:
  1035. return -EINVAL;
  1036. }
  1037. if (wrq->flags & IW_POWER_TIMEOUT) {
  1038. ret = hostap_set_word(dev, HFA384X_RID_CNFPMENABLED, 1);
  1039. if (ret)
  1040. return ret;
  1041. ret = hostap_set_word(dev, HFA384X_RID_CNFPMHOLDOVERDURATION,
  1042. wrq->value / 1024);
  1043. if (ret)
  1044. return ret;
  1045. }
  1046. if (wrq->flags & IW_POWER_PERIOD) {
  1047. ret = hostap_set_word(dev, HFA384X_RID_CNFPMENABLED, 1);
  1048. if (ret)
  1049. return ret;
  1050. ret = hostap_set_word(dev, HFA384X_RID_CNFMAXSLEEPDURATION,
  1051. wrq->value / 1024);
  1052. if (ret)
  1053. return ret;
  1054. }
  1055. return ret;
  1056. #endif /* PRISM2_NO_STATION_MODES */
  1057. }
  1058. static int prism2_ioctl_giwpower(struct net_device *dev,
  1059. struct iw_request_info *info,
  1060. struct iw_param *rrq, char *extra)
  1061. {
  1062. #ifdef PRISM2_NO_STATION_MODES
  1063. return -EOPNOTSUPP;
  1064. #else /* PRISM2_NO_STATION_MODES */
  1065. struct hostap_interface *iface;
  1066. local_info_t *local;
  1067. __le16 enable, mcast;
  1068. iface = netdev_priv(dev);
  1069. local = iface->local;
  1070. if (local->func->get_rid(dev, HFA384X_RID_CNFPMENABLED, &enable, 2, 1)
  1071. < 0)
  1072. return -EINVAL;
  1073. if (!le16_to_cpu(enable)) {
  1074. rrq->disabled = 1;
  1075. return 0;
  1076. }
  1077. rrq->disabled = 0;
  1078. if ((rrq->flags & IW_POWER_TYPE) == IW_POWER_TIMEOUT) {
  1079. __le16 timeout;
  1080. if (local->func->get_rid(dev,
  1081. HFA384X_RID_CNFPMHOLDOVERDURATION,
  1082. &timeout, 2, 1) < 0)
  1083. return -EINVAL;
  1084. rrq->flags = IW_POWER_TIMEOUT;
  1085. rrq->value = le16_to_cpu(timeout) * 1024;
  1086. } else {
  1087. __le16 period;
  1088. if (local->func->get_rid(dev, HFA384X_RID_CNFMAXSLEEPDURATION,
  1089. &period, 2, 1) < 0)
  1090. return -EINVAL;
  1091. rrq->flags = IW_POWER_PERIOD;
  1092. rrq->value = le16_to_cpu(period) * 1024;
  1093. }
  1094. if (local->func->get_rid(dev, HFA384X_RID_CNFMULTICASTRECEIVE, &mcast,
  1095. 2, 1) < 0)
  1096. return -EINVAL;
  1097. if (le16_to_cpu(mcast))
  1098. rrq->flags |= IW_POWER_ALL_R;
  1099. else
  1100. rrq->flags |= IW_POWER_UNICAST_R;
  1101. return 0;
  1102. #endif /* PRISM2_NO_STATION_MODES */
  1103. }
  1104. static int prism2_ioctl_siwretry(struct net_device *dev,
  1105. struct iw_request_info *info,
  1106. struct iw_param *rrq, char *extra)
  1107. {
  1108. struct hostap_interface *iface;
  1109. local_info_t *local;
  1110. iface = netdev_priv(dev);
  1111. local = iface->local;
  1112. if (rrq->disabled)
  1113. return -EINVAL;
  1114. /* setting retry limits is not supported with the current station
  1115. * firmware code; simulate this with alternative retry count for now */
  1116. if (rrq->flags == IW_RETRY_LIMIT) {
  1117. if (rrq->value < 0) {
  1118. /* disable manual retry count setting and use firmware
  1119. * defaults */
  1120. local->manual_retry_count = -1;
  1121. local->tx_control &= ~HFA384X_TX_CTRL_ALT_RTRY;
  1122. } else {
  1123. if (hostap_set_word(dev, HFA384X_RID_CNFALTRETRYCOUNT,
  1124. rrq->value)) {
  1125. printk(KERN_DEBUG "%s: Alternate retry count "
  1126. "setting to %d failed\n",
  1127. dev->name, rrq->value);
  1128. return -EOPNOTSUPP;
  1129. }
  1130. local->manual_retry_count = rrq->value;
  1131. local->tx_control |= HFA384X_TX_CTRL_ALT_RTRY;
  1132. }
  1133. return 0;
  1134. }
  1135. return -EOPNOTSUPP;
  1136. #if 0
  1137. /* what could be done, if firmware would support this.. */
  1138. if (rrq->flags & IW_RETRY_LIMIT) {
  1139. if (rrq->flags & IW_RETRY_LONG)
  1140. HFA384X_RID_LONGRETRYLIMIT = rrq->value;
  1141. else if (rrq->flags & IW_RETRY_SHORT)
  1142. HFA384X_RID_SHORTRETRYLIMIT = rrq->value;
  1143. else {
  1144. HFA384X_RID_LONGRETRYLIMIT = rrq->value;
  1145. HFA384X_RID_SHORTRETRYLIMIT = rrq->value;
  1146. }
  1147. }
  1148. if (rrq->flags & IW_RETRY_LIFETIME) {
  1149. HFA384X_RID_MAXTRANSMITLIFETIME = rrq->value / 1024;
  1150. }
  1151. return 0;
  1152. #endif /* 0 */
  1153. }
  1154. static int prism2_ioctl_giwretry(struct net_device *dev,
  1155. struct iw_request_info *info,
  1156. struct iw_param *rrq, char *extra)
  1157. {
  1158. struct hostap_interface *iface;
  1159. local_info_t *local;
  1160. __le16 shortretry, longretry, lifetime, altretry;
  1161. iface = netdev_priv(dev);
  1162. local = iface->local;
  1163. if (local->func->get_rid(dev, HFA384X_RID_SHORTRETRYLIMIT, &shortretry,
  1164. 2, 1) < 0 ||
  1165. local->func->get_rid(dev, HFA384X_RID_LONGRETRYLIMIT, &longretry,
  1166. 2, 1) < 0 ||
  1167. local->func->get_rid(dev, HFA384X_RID_MAXTRANSMITLIFETIME,
  1168. &lifetime, 2, 1) < 0)
  1169. return -EINVAL;
  1170. rrq->disabled = 0;
  1171. if ((rrq->flags & IW_RETRY_TYPE) == IW_RETRY_LIFETIME) {
  1172. rrq->flags = IW_RETRY_LIFETIME;
  1173. rrq->value = le16_to_cpu(lifetime) * 1024;
  1174. } else {
  1175. if (local->manual_retry_count >= 0) {
  1176. rrq->flags = IW_RETRY_LIMIT;
  1177. if (local->func->get_rid(dev,
  1178. HFA384X_RID_CNFALTRETRYCOUNT,
  1179. &altretry, 2, 1) >= 0)
  1180. rrq->value = le16_to_cpu(altretry);
  1181. else
  1182. rrq->value = local->manual_retry_count;
  1183. } else if ((rrq->flags & IW_RETRY_LONG)) {
  1184. rrq->flags = IW_RETRY_LIMIT | IW_RETRY_LONG;
  1185. rrq->value = le16_to_cpu(longretry);
  1186. } else {
  1187. rrq->flags = IW_RETRY_LIMIT;
  1188. rrq->value = le16_to_cpu(shortretry);
  1189. if (shortretry != longretry)
  1190. rrq->flags |= IW_RETRY_SHORT;
  1191. }
  1192. }
  1193. return 0;
  1194. }
  1195. /* Note! This TX power controlling is experimental and should not be used in
  1196. * production use. It just sets raw power register and does not use any kind of
  1197. * feedback information from the measured TX power (CR58). This is now
  1198. * commented out to make sure that it is not used by accident. TX power
  1199. * configuration will be enabled again after proper algorithm using feedback
  1200. * has been implemented. */
  1201. #ifdef RAW_TXPOWER_SETTING
  1202. /* Map HFA386x's CR31 to and from dBm with some sort of ad hoc mapping..
  1203. * This version assumes following mapping:
  1204. * CR31 is 7-bit value with -64 to +63 range.
  1205. * -64 is mapped into +20dBm and +63 into -43dBm.
  1206. * This is certainly not an exact mapping for every card, but at least
  1207. * increasing dBm value should correspond to increasing TX power.
  1208. */
  1209. static int prism2_txpower_hfa386x_to_dBm(u16 val)
  1210. {
  1211. signed char tmp;
  1212. if (val > 255)
  1213. val = 255;
  1214. tmp = val;
  1215. tmp >>= 2;
  1216. return -12 - tmp;
  1217. }
  1218. static u16 prism2_txpower_dBm_to_hfa386x(int val)
  1219. {
  1220. signed char tmp;
  1221. if (val > 20)
  1222. return 128;
  1223. else if (val < -43)
  1224. return 127;
  1225. tmp = val;
  1226. tmp = -12 - tmp;
  1227. tmp <<= 2;
  1228. return (unsigned char) tmp;
  1229. }
  1230. #endif /* RAW_TXPOWER_SETTING */
  1231. static int prism2_ioctl_siwtxpow(struct net_device *dev,
  1232. struct iw_request_info *info,
  1233. struct iw_param *rrq, char *extra)
  1234. {
  1235. struct hostap_interface *iface;
  1236. local_info_t *local;
  1237. #ifdef RAW_TXPOWER_SETTING
  1238. char *tmp;
  1239. #endif
  1240. u16 val;
  1241. int ret = 0;
  1242. iface = netdev_priv(dev);
  1243. local = iface->local;
  1244. if (rrq->disabled) {
  1245. if (local->txpower_type != PRISM2_TXPOWER_OFF) {
  1246. val = 0xff; /* use all standby and sleep modes */
  1247. ret = local->func->cmd(dev, HFA384X_CMDCODE_WRITEMIF,
  1248. HFA386X_CR_A_D_TEST_MODES2,
  1249. &val, NULL);
  1250. printk(KERN_DEBUG "%s: Turning radio off: %s\n",
  1251. dev->name, ret ? "failed" : "OK");
  1252. local->txpower_type = PRISM2_TXPOWER_OFF;
  1253. }
  1254. return (ret ? -EOPNOTSUPP : 0);
  1255. }
  1256. if (local->txpower_type == PRISM2_TXPOWER_OFF) {
  1257. val = 0; /* disable all standby and sleep modes */
  1258. ret = local->func->cmd(dev, HFA384X_CMDCODE_WRITEMIF,
  1259. HFA386X_CR_A_D_TEST_MODES2, &val, NULL);
  1260. printk(KERN_DEBUG "%s: Turning radio on: %s\n",
  1261. dev->name, ret ? "failed" : "OK");
  1262. local->txpower_type = PRISM2_TXPOWER_UNKNOWN;
  1263. }
  1264. #ifdef RAW_TXPOWER_SETTING
  1265. if (!rrq->fixed && local->txpower_type != PRISM2_TXPOWER_AUTO) {
  1266. printk(KERN_DEBUG "Setting ALC on\n");
  1267. val = HFA384X_TEST_CFG_BIT_ALC;
  1268. local->func->cmd(dev, HFA384X_CMDCODE_TEST |
  1269. (HFA384X_TEST_CFG_BITS << 8), 1, &val, NULL);
  1270. local->txpower_type = PRISM2_TXPOWER_AUTO;
  1271. return 0;
  1272. }
  1273. if (local->txpower_type != PRISM2_TXPOWER_FIXED) {
  1274. printk(KERN_DEBUG "Setting ALC off\n");
  1275. val = HFA384X_TEST_CFG_BIT_ALC;
  1276. local->func->cmd(dev, HFA384X_CMDCODE_TEST |
  1277. (HFA384X_TEST_CFG_BITS << 8), 0, &val, NULL);
  1278. local->txpower_type = PRISM2_TXPOWER_FIXED;
  1279. }
  1280. if (rrq->flags == IW_TXPOW_DBM)
  1281. tmp = "dBm";
  1282. else if (rrq->flags == IW_TXPOW_MWATT)
  1283. tmp = "mW";
  1284. else
  1285. tmp = "UNKNOWN";
  1286. printk(KERN_DEBUG "Setting TX power to %d %s\n", rrq->value, tmp);
  1287. if (rrq->flags != IW_TXPOW_DBM) {
  1288. printk("SIOCSIWTXPOW with mW is not supported; use dBm\n");
  1289. return -EOPNOTSUPP;
  1290. }
  1291. local->txpower = rrq->value;
  1292. val = prism2_txpower_dBm_to_hfa386x(local->txpower);
  1293. if (local->func->cmd(dev, HFA384X_CMDCODE_WRITEMIF,
  1294. HFA386X_CR_MANUAL_TX_POWER, &val, NULL))
  1295. ret = -EOPNOTSUPP;
  1296. #else /* RAW_TXPOWER_SETTING */
  1297. if (rrq->fixed)
  1298. ret = -EOPNOTSUPP;
  1299. #endif /* RAW_TXPOWER_SETTING */
  1300. return ret;
  1301. }
  1302. static int prism2_ioctl_giwtxpow(struct net_device *dev,
  1303. struct iw_request_info *info,
  1304. struct iw_param *rrq, char *extra)
  1305. {
  1306. #ifdef RAW_TXPOWER_SETTING
  1307. struct hostap_interface *iface;
  1308. local_info_t *local;
  1309. u16 resp0;
  1310. iface = netdev_priv(dev);
  1311. local = iface->local;
  1312. rrq->flags = IW_TXPOW_DBM;
  1313. rrq->disabled = 0;
  1314. rrq->fixed = 0;
  1315. if (local->txpower_type == PRISM2_TXPOWER_AUTO) {
  1316. if (local->func->cmd(dev, HFA384X_CMDCODE_READMIF,
  1317. HFA386X_CR_MANUAL_TX_POWER,
  1318. NULL, &resp0) == 0) {
  1319. rrq->value = prism2_txpower_hfa386x_to_dBm(resp0);
  1320. } else {
  1321. /* Could not get real txpower; guess 15 dBm */
  1322. rrq->value = 15;
  1323. }
  1324. } else if (local->txpower_type == PRISM2_TXPOWER_OFF) {
  1325. rrq->value = 0;
  1326. rrq->disabled = 1;
  1327. } else if (local->txpower_type == PRISM2_TXPOWER_FIXED) {
  1328. rrq->value = local->txpower;
  1329. rrq->fixed = 1;
  1330. } else {
  1331. printk("SIOCGIWTXPOW - unknown txpower_type=%d\n",
  1332. local->txpower_type);
  1333. }
  1334. return 0;
  1335. #else /* RAW_TXPOWER_SETTING */
  1336. return -EOPNOTSUPP;
  1337. #endif /* RAW_TXPOWER_SETTING */
  1338. }
  1339. #ifndef PRISM2_NO_STATION_MODES
  1340. /* HostScan request works with and without host_roaming mode. In addition, it
  1341. * does not break current association. However, it requires newer station
  1342. * firmware version (>= 1.3.1) than scan request. */
  1343. static int prism2_request_hostscan(struct net_device *dev,
  1344. u8 *ssid, u8 ssid_len)
  1345. {
  1346. struct hostap_interface *iface;
  1347. local_info_t *local;
  1348. struct hfa384x_hostscan_request scan_req;
  1349. iface = netdev_priv(dev);
  1350. local = iface->local;
  1351. memset(&scan_req, 0, sizeof(scan_req));
  1352. scan_req.channel_list = cpu_to_le16(local->channel_mask &
  1353. local->scan_channel_mask);
  1354. scan_req.txrate = cpu_to_le16(HFA384X_RATES_1MBPS);
  1355. if (ssid) {
  1356. if (ssid_len > 32)
  1357. return -EINVAL;
  1358. scan_req.target_ssid_len = cpu_to_le16(ssid_len);
  1359. memcpy(scan_req.target_ssid, ssid, ssid_len);
  1360. }
  1361. if (local->func->set_rid(dev, HFA384X_RID_HOSTSCAN, &scan_req,
  1362. sizeof(scan_req))) {
  1363. printk(KERN_DEBUG "%s: HOSTSCAN failed\n", dev->name);
  1364. return -EINVAL;
  1365. }
  1366. return 0;
  1367. }
  1368. static int prism2_request_scan(struct net_device *dev)
  1369. {
  1370. struct hostap_interface *iface;
  1371. local_info_t *local;
  1372. struct hfa384x_scan_request scan_req;
  1373. int ret = 0;
  1374. iface = netdev_priv(dev);
  1375. local = iface->local;
  1376. memset(&scan_req, 0, sizeof(scan_req));
  1377. scan_req.channel_list = cpu_to_le16(local->channel_mask &
  1378. local->scan_channel_mask);
  1379. scan_req.txrate = cpu_to_le16(HFA384X_RATES_1MBPS);
  1380. /* FIX:
  1381. * It seems to be enough to set roaming mode for a short moment to
  1382. * host-based and then setup scanrequest data and return the mode to
  1383. * firmware-based.
  1384. *
  1385. * Master mode would need to drop to Managed mode for a short while
  1386. * to make scanning work.. Or sweep through the different channels and
  1387. * use passive scan based on beacons. */
  1388. if (!local->host_roaming)
  1389. hostap_set_word(dev, HFA384X_RID_CNFROAMINGMODE,
  1390. HFA384X_ROAMING_HOST);
  1391. if (local->func->set_rid(dev, HFA384X_RID_SCANREQUEST, &scan_req,
  1392. sizeof(scan_req))) {
  1393. printk(KERN_DEBUG "SCANREQUEST failed\n");
  1394. ret = -EINVAL;
  1395. }
  1396. if (!local->host_roaming)
  1397. hostap_set_word(dev, HFA384X_RID_CNFROAMINGMODE,
  1398. HFA384X_ROAMING_FIRMWARE);
  1399. return ret;
  1400. }
  1401. #else /* !PRISM2_NO_STATION_MODES */
  1402. static inline int prism2_request_hostscan(struct net_device *dev,
  1403. u8 *ssid, u8 ssid_len)
  1404. {
  1405. return -EOPNOTSUPP;
  1406. }
  1407. static inline int prism2_request_scan(struct net_device *dev)
  1408. {
  1409. return -EOPNOTSUPP;
  1410. }
  1411. #endif /* !PRISM2_NO_STATION_MODES */
  1412. static int prism2_ioctl_siwscan(struct net_device *dev,
  1413. struct iw_request_info *info,
  1414. struct iw_point *data, char *extra)
  1415. {
  1416. struct hostap_interface *iface;
  1417. local_info_t *local;
  1418. int ret;
  1419. u8 *ssid = NULL, ssid_len = 0;
  1420. struct iw_scan_req *req = (struct iw_scan_req *) extra;
  1421. iface = netdev_priv(dev);
  1422. local = iface->local;
  1423. if (data->length < sizeof(struct iw_scan_req))
  1424. req = NULL;
  1425. if (local->iw_mode == IW_MODE_MASTER) {
  1426. /* In master mode, we just return the results of our local
  1427. * tables, so we don't need to start anything...
  1428. * Jean II */
  1429. data->length = 0;
  1430. return 0;
  1431. }
  1432. if (!local->dev_enabled)
  1433. return -ENETDOWN;
  1434. if (req && data->flags & IW_SCAN_THIS_ESSID) {
  1435. ssid = req->essid;
  1436. ssid_len = req->essid_len;
  1437. if (ssid_len &&
  1438. ((local->iw_mode != IW_MODE_INFRA &&
  1439. local->iw_mode != IW_MODE_ADHOC) ||
  1440. (local->sta_fw_ver < PRISM2_FW_VER(1,3,1))))
  1441. return -EOPNOTSUPP;
  1442. }
  1443. if (local->sta_fw_ver >= PRISM2_FW_VER(1,3,1))
  1444. ret = prism2_request_hostscan(dev, ssid, ssid_len);
  1445. else
  1446. ret = prism2_request_scan(dev);
  1447. if (ret == 0)
  1448. local->scan_timestamp = jiffies;
  1449. /* Could inquire F101, F103 or wait for SIOCGIWSCAN and read RID */
  1450. return ret;
  1451. }
  1452. #ifndef PRISM2_NO_STATION_MODES
  1453. static char * __prism2_translate_scan(local_info_t *local,
  1454. struct iw_request_info *info,
  1455. struct hfa384x_hostscan_result *scan,
  1456. struct hostap_bss_info *bss,
  1457. char *current_ev, char *end_buf)
  1458. {
  1459. int i, chan;
  1460. struct iw_event iwe;
  1461. char *current_val;
  1462. u16 capabilities;
  1463. u8 *pos;
  1464. u8 *ssid, *bssid;
  1465. size_t ssid_len;
  1466. char *buf;
  1467. if (bss) {
  1468. ssid = bss->ssid;
  1469. ssid_len = bss->ssid_len;
  1470. bssid = bss->bssid;
  1471. } else {
  1472. ssid = scan->ssid;
  1473. ssid_len = le16_to_cpu(scan->ssid_len);
  1474. bssid = scan->bssid;
  1475. }
  1476. if (ssid_len > 32)
  1477. ssid_len = 32;
  1478. /* First entry *MUST* be the AP MAC address */
  1479. memset(&iwe, 0, sizeof(iwe));
  1480. iwe.cmd = SIOCGIWAP;
  1481. iwe.u.ap_addr.sa_family = ARPHRD_ETHER;
  1482. memcpy(iwe.u.ap_addr.sa_data, bssid, ETH_ALEN);
  1483. current_ev = iwe_stream_add_event(info, current_ev, end_buf, &iwe,
  1484. IW_EV_ADDR_LEN);
  1485. /* Other entries will be displayed in the order we give them */
  1486. memset(&iwe, 0, sizeof(iwe));
  1487. iwe.cmd = SIOCGIWESSID;
  1488. iwe.u.data.length = ssid_len;
  1489. iwe.u.data.flags = 1;
  1490. current_ev = iwe_stream_add_point(info, current_ev, end_buf,
  1491. &iwe, ssid);
  1492. memset(&iwe, 0, sizeof(iwe));
  1493. iwe.cmd = SIOCGIWMODE;
  1494. if (bss) {
  1495. capabilities = bss->capab_info;
  1496. } else {
  1497. capabilities = le16_to_cpu(scan->capability);
  1498. }
  1499. if (capabilities & (WLAN_CAPABILITY_ESS |
  1500. WLAN_CAPABILITY_IBSS)) {
  1501. if (capabilities & WLAN_CAPABILITY_ESS)
  1502. iwe.u.mode = IW_MODE_MASTER;
  1503. else
  1504. iwe.u.mode = IW_MODE_ADHOC;
  1505. current_ev = iwe_stream_add_event(info, current_ev, end_buf,
  1506. &iwe, IW_EV_UINT_LEN);
  1507. }
  1508. memset(&iwe, 0, sizeof(iwe));
  1509. iwe.cmd = SIOCGIWFREQ;
  1510. if (scan) {
  1511. chan = le16_to_cpu(scan->chid);
  1512. } else if (bss) {
  1513. chan = bss->chan;
  1514. } else {
  1515. chan = 0;
  1516. }
  1517. if (chan > 0) {
  1518. iwe.u.freq.m = freq_list[chan - 1] * 100000;
  1519. iwe.u.freq.e = 1;
  1520. current_ev = iwe_stream_add_event(info, current_ev, end_buf,
  1521. &iwe, IW_EV_FREQ_LEN);
  1522. }
  1523. if (scan) {
  1524. memset(&iwe, 0, sizeof(iwe));
  1525. iwe.cmd = IWEVQUAL;
  1526. if (local->last_scan_type == PRISM2_HOSTSCAN) {
  1527. iwe.u.qual.level = le16_to_cpu(scan->sl);
  1528. iwe.u.qual.noise = le16_to_cpu(scan->anl);
  1529. } else {
  1530. iwe.u.qual.level =
  1531. HFA384X_LEVEL_TO_dBm(le16_to_cpu(scan->sl));
  1532. iwe.u.qual.noise =
  1533. HFA384X_LEVEL_TO_dBm(le16_to_cpu(scan->anl));
  1534. }
  1535. iwe.u.qual.updated = IW_QUAL_LEVEL_UPDATED
  1536. | IW_QUAL_NOISE_UPDATED
  1537. | IW_QUAL_QUAL_INVALID
  1538. | IW_QUAL_DBM;
  1539. current_ev = iwe_stream_add_event(info, current_ev, end_buf,
  1540. &iwe, IW_EV_QUAL_LEN);
  1541. }
  1542. memset(&iwe, 0, sizeof(iwe));
  1543. iwe.cmd = SIOCGIWENCODE;
  1544. if (capabilities & WLAN_CAPABILITY_PRIVACY)
  1545. iwe.u.data.flags = IW_ENCODE_ENABLED | IW_ENCODE_NOKEY;
  1546. else
  1547. iwe.u.data.flags = IW_ENCODE_DISABLED;
  1548. iwe.u.data.length = 0;
  1549. current_ev = iwe_stream_add_point(info, current_ev, end_buf, &iwe, "");
  1550. /* TODO: add SuppRates into BSS table */
  1551. if (scan) {
  1552. memset(&iwe, 0, sizeof(iwe));
  1553. iwe.cmd = SIOCGIWRATE;
  1554. current_val = current_ev + iwe_stream_lcp_len(info);
  1555. pos = scan->sup_rates;
  1556. for (i = 0; i < sizeof(scan->sup_rates); i++) {
  1557. if (pos[i] == 0)
  1558. break;
  1559. /* Bit rate given in 500 kb/s units (+ 0x80) */
  1560. iwe.u.bitrate.value = ((pos[i] & 0x7f) * 500000);
  1561. current_val = iwe_stream_add_value(
  1562. info, current_ev, current_val, end_buf, &iwe,
  1563. IW_EV_PARAM_LEN);
  1564. }
  1565. /* Check if we added any event */
  1566. if ((current_val - current_ev) > iwe_stream_lcp_len(info))
  1567. current_ev = current_val;
  1568. }
  1569. /* TODO: add BeaconInt,resp_rate,atim into BSS table */
  1570. buf = kmalloc(MAX_WPA_IE_LEN * 2 + 30, GFP_ATOMIC);
  1571. if (buf && scan) {
  1572. memset(&iwe, 0, sizeof(iwe));
  1573. iwe.cmd = IWEVCUSTOM;
  1574. sprintf(buf, "bcn_int=%d", le16_to_cpu(scan->beacon_interval));
  1575. iwe.u.data.length = strlen(buf);
  1576. current_ev = iwe_stream_add_point(info, current_ev, end_buf,
  1577. &iwe, buf);
  1578. memset(&iwe, 0, sizeof(iwe));
  1579. iwe.cmd = IWEVCUSTOM;
  1580. sprintf(buf, "resp_rate=%d", le16_to_cpu(scan->rate));
  1581. iwe.u.data.length = strlen(buf);
  1582. current_ev = iwe_stream_add_point(info, current_ev, end_buf,
  1583. &iwe, buf);
  1584. if (local->last_scan_type == PRISM2_HOSTSCAN &&
  1585. (capabilities & WLAN_CAPABILITY_IBSS)) {
  1586. memset(&iwe, 0, sizeof(iwe));
  1587. iwe.cmd = IWEVCUSTOM;
  1588. sprintf(buf, "atim=%d", le16_to_cpu(scan->atim));
  1589. iwe.u.data.length = strlen(buf);
  1590. current_ev = iwe_stream_add_point(info, current_ev,
  1591. end_buf, &iwe, buf);
  1592. }
  1593. }
  1594. kfree(buf);
  1595. if (bss && bss->wpa_ie_len > 0 && bss->wpa_ie_len <= MAX_WPA_IE_LEN) {
  1596. memset(&iwe, 0, sizeof(iwe));
  1597. iwe.cmd = IWEVGENIE;
  1598. iwe.u.data.length = bss->wpa_ie_len;
  1599. current_ev = iwe_stream_add_point(info, current_ev, end_buf,
  1600. &iwe, bss->wpa_ie);
  1601. }
  1602. if (bss && bss->rsn_ie_len > 0 && bss->rsn_ie_len <= MAX_WPA_IE_LEN) {
  1603. memset(&iwe, 0, sizeof(iwe));
  1604. iwe.cmd = IWEVGENIE;
  1605. iwe.u.data.length = bss->rsn_ie_len;
  1606. current_ev = iwe_stream_add_point(info, current_ev, end_buf,
  1607. &iwe, bss->rsn_ie);
  1608. }
  1609. return current_ev;
  1610. }
  1611. /* Translate scan data returned from the card to a card independent
  1612. * format that the Wireless Tools will understand - Jean II */
  1613. static inline int prism2_translate_scan(local_info_t *local,
  1614. struct iw_request_info *info,
  1615. char *buffer, int buflen)
  1616. {
  1617. struct hfa384x_hostscan_result *scan;
  1618. int entry, hostscan;
  1619. char *current_ev = buffer;
  1620. char *end_buf = buffer + buflen;
  1621. struct list_head *ptr;
  1622. spin_lock_bh(&local->lock);
  1623. list_for_each(ptr, &local->bss_list) {
  1624. struct hostap_bss_info *bss;
  1625. bss = list_entry(ptr, struct hostap_bss_info, list);
  1626. bss->included = 0;
  1627. }
  1628. hostscan = local->last_scan_type == PRISM2_HOSTSCAN;
  1629. for (entry = 0; entry < local->last_scan_results_count; entry++) {
  1630. int found = 0;
  1631. scan = &local->last_scan_results[entry];
  1632. /* Report every SSID if the AP is using multiple SSIDs. If no
  1633. * BSS record is found (e.g., when WPA mode is disabled),
  1634. * report the AP once. */
  1635. list_for_each(ptr, &local->bss_list) {
  1636. struct hostap_bss_info *bss;
  1637. bss = list_entry(ptr, struct hostap_bss_info, list);
  1638. if (memcmp(bss->bssid, scan->bssid, ETH_ALEN) == 0) {
  1639. bss->included = 1;
  1640. current_ev = __prism2_translate_scan(
  1641. local, info, scan, bss, current_ev,
  1642. end_buf);
  1643. found++;
  1644. }
  1645. }
  1646. if (!found) {
  1647. current_ev = __prism2_translate_scan(
  1648. local, info, scan, NULL, current_ev, end_buf);
  1649. }
  1650. /* Check if there is space for one more entry */
  1651. if ((end_buf - current_ev) <= IW_EV_ADDR_LEN) {
  1652. /* Ask user space to try again with a bigger buffer */
  1653. spin_unlock_bh(&local->lock);
  1654. return -E2BIG;
  1655. }
  1656. }
  1657. /* Prism2 firmware has limits (32 at least in some versions) for number
  1658. * of BSSes in scan results. Extend this limit by using local BSS list.
  1659. */
  1660. list_for_each(ptr, &local->bss_list) {
  1661. struct hostap_bss_info *bss;
  1662. bss = list_entry(ptr, struct hostap_bss_info, list);
  1663. if (bss->included)
  1664. continue;
  1665. current_ev = __prism2_translate_scan(local, info, NULL, bss,
  1666. current_ev, end_buf);
  1667. /* Check if there is space for one more entry */
  1668. if ((end_buf - current_ev) <= IW_EV_ADDR_LEN) {
  1669. /* Ask user space to try again with a bigger buffer */
  1670. spin_unlock_bh(&local->lock);
  1671. return -E2BIG;
  1672. }
  1673. }
  1674. spin_unlock_bh(&local->lock);
  1675. return current_ev - buffer;
  1676. }
  1677. #endif /* PRISM2_NO_STATION_MODES */
  1678. static inline int prism2_ioctl_giwscan_sta(struct net_device *dev,
  1679. struct iw_request_info *info,
  1680. struct iw_point *data, char *extra)
  1681. {
  1682. #ifdef PRISM2_NO_STATION_MODES
  1683. return -EOPNOTSUPP;
  1684. #else /* PRISM2_NO_STATION_MODES */
  1685. struct hostap_interface *iface;
  1686. local_info_t *local;
  1687. int res;
  1688. iface = netdev_priv(dev);
  1689. local = iface->local;
  1690. /* Wait until the scan is finished. We can probably do better
  1691. * than that - Jean II */
  1692. if (local->scan_timestamp &&
  1693. time_before(jiffies, local->scan_timestamp + 3 * HZ)) {
  1694. /* Important note : we don't want to block the caller
  1695. * until results are ready for various reasons.
  1696. * First, managing wait queues is complex and racy
  1697. * (there may be multiple simultaneous callers).
  1698. * Second, we grab some rtnetlink lock before coming
  1699. * here (in dev_ioctl()).
  1700. * Third, the caller can wait on the Wireless Event
  1701. * - Jean II */
  1702. return -EAGAIN;
  1703. }
  1704. local->scan_timestamp = 0;
  1705. res = prism2_translate_scan(local, info, extra, data->length);
  1706. if (res >= 0) {
  1707. data->length = res;
  1708. return 0;
  1709. } else {
  1710. data->length = 0;
  1711. return res;
  1712. }
  1713. #endif /* PRISM2_NO_STATION_MODES */
  1714. }
  1715. static int prism2_ioctl_giwscan(struct net_device *dev,
  1716. struct iw_request_info *info,
  1717. struct iw_point *data, char *extra)
  1718. {
  1719. struct hostap_interface *iface;
  1720. local_info_t *local;
  1721. int res;
  1722. iface = netdev_priv(dev);
  1723. local = iface->local;
  1724. if (local->iw_mode == IW_MODE_MASTER) {
  1725. /* In MASTER mode, it doesn't make sense to go around
  1726. * scanning the frequencies and make the stations we serve
  1727. * wait when what the user is really interested about is the
  1728. * list of stations and access points we are talking to.
  1729. * So, just extract results from our cache...
  1730. * Jean II */
  1731. /* Translate to WE format */
  1732. res = prism2_ap_translate_scan(dev, info, extra);
  1733. if (res >= 0) {
  1734. printk(KERN_DEBUG "Scan result translation succeeded "
  1735. "(length=%d)\n", res);
  1736. data->length = res;
  1737. return 0;
  1738. } else {
  1739. printk(KERN_DEBUG
  1740. "Scan result translation failed (res=%d)\n",
  1741. res);
  1742. data->length = 0;
  1743. return res;
  1744. }
  1745. } else {
  1746. /* Station mode */
  1747. return prism2_ioctl_giwscan_sta(dev, info, data, extra);
  1748. }
  1749. }
  1750. static const struct iw_priv_args prism2_priv[] = {
  1751. { PRISM2_IOCTL_MONITOR,
  1752. IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "monitor" },
  1753. { PRISM2_IOCTL_READMIF,
  1754. IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | 1,
  1755. IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | 1, "readmif" },
  1756. { PRISM2_IOCTL_WRITEMIF,
  1757. IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | 2, 0, "writemif" },
  1758. { PRISM2_IOCTL_RESET,
  1759. IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "reset" },
  1760. { PRISM2_IOCTL_INQUIRE,
  1761. IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "inquire" },
  1762. { PRISM2_IOCTL_SET_RID_WORD,
  1763. IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 2, 0, "set_rid_word" },
  1764. { PRISM2_IOCTL_MACCMD,
  1765. IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "maccmd" },
  1766. { PRISM2_IOCTL_WDS_ADD,
  1767. IW_PRIV_TYPE_ADDR | IW_PRIV_SIZE_FIXED | 1, 0, "wds_add" },
  1768. { PRISM2_IOCTL_WDS_DEL,
  1769. IW_PRIV_TYPE_ADDR | IW_PRIV_SIZE_FIXED | 1, 0, "wds_del" },
  1770. { PRISM2_IOCTL_ADDMAC,
  1771. IW_PRIV_TYPE_ADDR | IW_PRIV_SIZE_FIXED | 1, 0, "addmac" },
  1772. { PRISM2_IOCTL_DELMAC,
  1773. IW_PRIV_TYPE_ADDR | IW_PRIV_SIZE_FIXED | 1, 0, "delmac" },
  1774. { PRISM2_IOCTL_KICKMAC,
  1775. IW_PRIV_TYPE_ADDR | IW_PRIV_SIZE_FIXED | 1, 0, "kickmac" },
  1776. /* --- raw access to sub-ioctls --- */
  1777. { PRISM2_IOCTL_PRISM2_PARAM,
  1778. IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 2, 0, "prism2_param" },
  1779. { PRISM2_IOCTL_GET_PRISM2_PARAM,
  1780. IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
  1781. IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getprism2_param" },
  1782. /* --- sub-ioctls handlers --- */
  1783. { PRISM2_IOCTL_PRISM2_PARAM,
  1784. IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "" },
  1785. { PRISM2_IOCTL_GET_PRISM2_PARAM,
  1786. 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "" },
  1787. /* --- sub-ioctls definitions --- */
  1788. { PRISM2_PARAM_TXRATECTRL,
  1789. IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "txratectrl" },
  1790. { PRISM2_PARAM_TXRATECTRL,
  1791. 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "gettxratectrl" },
  1792. { PRISM2_PARAM_BEACON_INT,
  1793. IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "beacon_int" },
  1794. { PRISM2_PARAM_BEACON_INT,
  1795. 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getbeacon_int" },
  1796. #ifndef PRISM2_NO_STATION_MODES
  1797. { PRISM2_PARAM_PSEUDO_IBSS,
  1798. IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "pseudo_ibss" },
  1799. { PRISM2_PARAM_PSEUDO_IBSS,
  1800. 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getpseudo_ibss" },
  1801. #endif /* PRISM2_NO_STATION_MODES */
  1802. { PRISM2_PARAM_ALC,
  1803. IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "alc" },
  1804. { PRISM2_PARAM_ALC,
  1805. 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getalc" },
  1806. { PRISM2_PARAM_DUMP,
  1807. IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "dump" },
  1808. { PRISM2_PARAM_DUMP,
  1809. 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getdump" },
  1810. { PRISM2_PARAM_OTHER_AP_POLICY,
  1811. IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "other_ap_policy" },
  1812. { PRISM2_PARAM_OTHER_AP_POLICY,
  1813. 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getother_ap_pol" },
  1814. { PRISM2_PARAM_AP_MAX_INACTIVITY,
  1815. IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "max_inactivity" },
  1816. { PRISM2_PARAM_AP_MAX_INACTIVITY,
  1817. 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getmax_inactivi" },
  1818. { PRISM2_PARAM_AP_BRIDGE_PACKETS,
  1819. IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "bridge_packets" },
  1820. { PRISM2_PARAM_AP_BRIDGE_PACKETS,
  1821. 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getbridge_packe" },
  1822. { PRISM2_PARAM_DTIM_PERIOD,
  1823. IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "dtim_period" },
  1824. { PRISM2_PARAM_DTIM_PERIOD,
  1825. 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getdtim_period" },
  1826. { PRISM2_PARAM_AP_NULLFUNC_ACK,
  1827. IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "nullfunc_ack" },
  1828. { PRISM2_PARAM_AP_NULLFUNC_ACK,
  1829. 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getnullfunc_ack" },
  1830. { PRISM2_PARAM_MAX_WDS,
  1831. IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "max_wds" },
  1832. { PRISM2_PARAM_MAX_WDS,
  1833. 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getmax_wds" },
  1834. { PRISM2_PARAM_AP_AUTOM_AP_WDS,
  1835. IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "autom_ap_wds" },
  1836. { PRISM2_PARAM_AP_AUTOM_AP_WDS,
  1837. 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getautom_ap_wds" },
  1838. { PRISM2_PARAM_AP_AUTH_ALGS,
  1839. IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "ap_auth_algs" },
  1840. { PRISM2_PARAM_AP_AUTH_ALGS,
  1841. 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getap_auth_algs" },
  1842. { PRISM2_PARAM_MONITOR_ALLOW_FCSERR,
  1843. IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "allow_fcserr" },
  1844. { PRISM2_PARAM_MONITOR_ALLOW_FCSERR,
  1845. 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getallow_fcserr" },
  1846. { PRISM2_PARAM_HOST_ENCRYPT,
  1847. IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "host_encrypt" },
  1848. { PRISM2_PARAM_HOST_ENCRYPT,
  1849. 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "gethost_encrypt" },
  1850. { PRISM2_PARAM_HOST_DECRYPT,
  1851. IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "host_decrypt" },
  1852. { PRISM2_PARAM_HOST_DECRYPT,
  1853. 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "gethost_decrypt" },
  1854. #ifndef PRISM2_NO_STATION_MODES
  1855. { PRISM2_PARAM_HOST_ROAMING,
  1856. IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "host_roaming" },
  1857. { PRISM2_PARAM_HOST_ROAMING,
  1858. 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "gethost_roaming" },
  1859. #endif /* PRISM2_NO_STATION_MODES */
  1860. { PRISM2_PARAM_BCRX_STA_KEY,
  1861. IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "bcrx_sta_key" },
  1862. { PRISM2_PARAM_BCRX_STA_KEY,
  1863. 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getbcrx_sta_key" },
  1864. { PRISM2_PARAM_IEEE_802_1X,
  1865. IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "ieee_802_1x" },
  1866. { PRISM2_PARAM_IEEE_802_1X,
  1867. 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getieee_802_1x" },
  1868. { PRISM2_PARAM_ANTSEL_TX,
  1869. IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "antsel_tx" },
  1870. { PRISM2_PARAM_ANTSEL_TX,
  1871. 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getantsel_tx" },
  1872. { PRISM2_PARAM_ANTSEL_RX,
  1873. IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "antsel_rx" },
  1874. { PRISM2_PARAM_ANTSEL_RX,
  1875. 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getantsel_rx" },
  1876. { PRISM2_PARAM_MONITOR_TYPE,
  1877. IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "monitor_type" },
  1878. { PRISM2_PARAM_MONITOR_TYPE,
  1879. 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getmonitor_type" },
  1880. { PRISM2_PARAM_WDS_TYPE,
  1881. IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "wds_type" },
  1882. { PRISM2_PARAM_WDS_TYPE,
  1883. 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getwds_type" },
  1884. { PRISM2_PARAM_HOSTSCAN,
  1885. IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "hostscan" },
  1886. { PRISM2_PARAM_HOSTSCAN,
  1887. 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "gethostscan" },
  1888. { PRISM2_PARAM_AP_SCAN,
  1889. IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "ap_scan" },
  1890. { PRISM2_PARAM_AP_SCAN,
  1891. 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getap_scan" },
  1892. { PRISM2_PARAM_ENH_SEC,
  1893. IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "enh_sec" },
  1894. { PRISM2_PARAM_ENH_SEC,
  1895. 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getenh_sec" },
  1896. #ifdef PRISM2_IO_DEBUG
  1897. { PRISM2_PARAM_IO_DEBUG,
  1898. IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "io_debug" },
  1899. { PRISM2_PARAM_IO_DEBUG,
  1900. 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getio_debug" },
  1901. #endif /* PRISM2_IO_DEBUG */
  1902. { PRISM2_PARAM_BASIC_RATES,
  1903. IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "basic_rates" },
  1904. { PRISM2_PARAM_BASIC_RATES,
  1905. 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getbasic_rates" },
  1906. { PRISM2_PARAM_OPER_RATES,
  1907. IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "oper_rates" },
  1908. { PRISM2_PARAM_OPER_RATES,
  1909. 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getoper_rates" },
  1910. { PRISM2_PARAM_HOSTAPD,
  1911. IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "hostapd" },
  1912. { PRISM2_PARAM_HOSTAPD,
  1913. 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "gethostapd" },
  1914. { PRISM2_PARAM_HOSTAPD_STA,
  1915. IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "hostapd_sta" },
  1916. { PRISM2_PARAM_HOSTAPD_STA,
  1917. 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "gethostapd_sta" },
  1918. { PRISM2_PARAM_WPA,
  1919. IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "wpa" },
  1920. { PRISM2_PARAM_WPA,
  1921. 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getwpa" },
  1922. { PRISM2_PARAM_PRIVACY_INVOKED,
  1923. IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "privacy_invoked" },
  1924. { PRISM2_PARAM_PRIVACY_INVOKED,
  1925. 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getprivacy_invo" },
  1926. { PRISM2_PARAM_TKIP_COUNTERMEASURES,
  1927. IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "tkip_countermea" },
  1928. { PRISM2_PARAM_TKIP_COUNTERMEASURES,
  1929. 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "gettkip_counter" },
  1930. { PRISM2_PARAM_DROP_UNENCRYPTED,
  1931. IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "drop_unencrypte" },
  1932. { PRISM2_PARAM_DROP_UNENCRYPTED,
  1933. 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getdrop_unencry" },
  1934. { PRISM2_PARAM_SCAN_CHANNEL_MASK,
  1935. IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "scan_channels" },
  1936. { PRISM2_PARAM_SCAN_CHANNEL_MASK,
  1937. 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getscan_channel" },
  1938. };
  1939. static int prism2_ioctl_priv_inquire(struct net_device *dev, int *i)
  1940. {
  1941. struct hostap_interface *iface;
  1942. local_info_t *local;
  1943. iface = netdev_priv(dev);
  1944. local = iface->local;
  1945. if (local->func->cmd(dev, HFA384X_CMDCODE_INQUIRE, *i, NULL, NULL))
  1946. return -EOPNOTSUPP;
  1947. return 0;
  1948. }
  1949. static int prism2_ioctl_priv_prism2_param(struct net_device *dev,
  1950. struct iw_request_info *info,
  1951. void *wrqu, char *extra)
  1952. {
  1953. struct hostap_interface *iface;
  1954. local_info_t *local;
  1955. int *i = (int *) extra;
  1956. int param = *i;
  1957. int value = *(i + 1);
  1958. int ret = 0;
  1959. u16 val;
  1960. iface = netdev_priv(dev);
  1961. local = iface->local;
  1962. switch (param) {
  1963. case PRISM2_PARAM_TXRATECTRL:
  1964. local->fw_tx_rate_control = value;
  1965. break;
  1966. case PRISM2_PARAM_BEACON_INT:
  1967. if (hostap_set_word(dev, HFA384X_RID_CNFBEACONINT, value) ||
  1968. local->func->reset_port(dev))
  1969. ret = -EINVAL;
  1970. else
  1971. local->beacon_int = value;
  1972. break;
  1973. #ifndef PRISM2_NO_STATION_MODES
  1974. case PRISM2_PARAM_PSEUDO_IBSS:
  1975. if (value == local->pseudo_adhoc)
  1976. break;
  1977. if (value != 0 && value != 1) {
  1978. ret = -EINVAL;
  1979. break;
  1980. }
  1981. printk(KERN_DEBUG "prism2: %s: pseudo IBSS change %d -> %d\n",
  1982. dev->name, local->pseudo_adhoc, value);
  1983. local->pseudo_adhoc = value;
  1984. if (local->iw_mode != IW_MODE_ADHOC)
  1985. break;
  1986. if (hostap_set_word(dev, HFA384X_RID_CNFPORTTYPE,
  1987. hostap_get_porttype(local))) {
  1988. ret = -EOPNOTSUPP;
  1989. break;
  1990. }
  1991. if (local->func->reset_port(dev))
  1992. ret = -EINVAL;
  1993. break;
  1994. #endif /* PRISM2_NO_STATION_MODES */
  1995. case PRISM2_PARAM_ALC:
  1996. printk(KERN_DEBUG "%s: %s ALC\n", dev->name,
  1997. value == 0 ? "Disabling" : "Enabling");
  1998. val = HFA384X_TEST_CFG_BIT_ALC;
  1999. local->func->cmd(dev, HFA384X_CMDCODE_TEST |
  2000. (HFA384X_TEST_CFG_BITS << 8),
  2001. value == 0 ? 0 : 1, &val, NULL);
  2002. break;
  2003. case PRISM2_PARAM_DUMP:
  2004. local->frame_dump = value;
  2005. break;
  2006. case PRISM2_PARAM_OTHER_AP_POLICY:
  2007. if (value < 0 || value > 3) {
  2008. ret = -EINVAL;
  2009. break;
  2010. }
  2011. if (local->ap != NULL)
  2012. local->ap->ap_policy = value;
  2013. break;
  2014. case PRISM2_PARAM_AP_MAX_INACTIVITY:
  2015. if (value < 0 || value > 7 * 24 * 60 * 60) {
  2016. ret = -EINVAL;
  2017. break;
  2018. }
  2019. if (local->ap != NULL)
  2020. local->ap->max_inactivity = value * HZ;
  2021. break;
  2022. case PRISM2_PARAM_AP_BRIDGE_PACKETS:
  2023. if (local->ap != NULL)
  2024. local->ap->bridge_packets = value;
  2025. break;
  2026. case PRISM2_PARAM_DTIM_PERIOD:
  2027. if (value < 0 || value > 65535) {
  2028. ret = -EINVAL;
  2029. break;
  2030. }
  2031. if (hostap_set_word(dev, HFA384X_RID_CNFOWNDTIMPERIOD, value)
  2032. || local->func->reset_port(dev))
  2033. ret = -EINVAL;
  2034. else
  2035. local->dtim_period = value;
  2036. break;
  2037. case PRISM2_PARAM_AP_NULLFUNC_ACK:
  2038. if (local->ap != NULL)
  2039. local->ap->nullfunc_ack = value;
  2040. break;
  2041. case PRISM2_PARAM_MAX_WDS:
  2042. local->wds_max_connections = value;
  2043. break;
  2044. case PRISM2_PARAM_AP_AUTOM_AP_WDS:
  2045. if (local->ap != NULL) {
  2046. if (!local->ap->autom_ap_wds && value) {
  2047. /* add WDS link to all APs in STA table */
  2048. hostap_add_wds_links(local);
  2049. }
  2050. local->ap->autom_ap_wds = value;
  2051. }
  2052. break;
  2053. case PRISM2_PARAM_AP_AUTH_ALGS:
  2054. local->auth_algs = value;
  2055. if (hostap_set_auth_algs(local))
  2056. ret = -EINVAL;
  2057. break;
  2058. case PRISM2_PARAM_MONITOR_ALLOW_FCSERR:
  2059. local->monitor_allow_fcserr = value;
  2060. break;
  2061. case PRISM2_PARAM_HOST_ENCRYPT:
  2062. local->host_encrypt = value;
  2063. if (hostap_set_encryption(local) ||
  2064. local->func->reset_port(dev))
  2065. ret = -EINVAL;
  2066. break;
  2067. case PRISM2_PARAM_HOST_DECRYPT:
  2068. local->host_decrypt = value;
  2069. if (hostap_set_encryption(local) ||
  2070. local->func->reset_port(dev))
  2071. ret = -EINVAL;
  2072. break;
  2073. #ifndef PRISM2_NO_STATION_MODES
  2074. case PRISM2_PARAM_HOST_ROAMING:
  2075. if (value < 0 || value > 2) {
  2076. ret = -EINVAL;
  2077. break;
  2078. }
  2079. local->host_roaming = value;
  2080. if (hostap_set_roaming(local) || local->func->reset_port(dev))
  2081. ret = -EINVAL;
  2082. break;
  2083. #endif /* PRISM2_NO_STATION_MODES */
  2084. case PRISM2_PARAM_BCRX_STA_KEY:
  2085. local->bcrx_sta_key = value;
  2086. break;
  2087. case PRISM2_PARAM_IEEE_802_1X:
  2088. local->ieee_802_1x = value;
  2089. break;
  2090. case PRISM2_PARAM_ANTSEL_TX:
  2091. if (value < 0 || value > HOSTAP_ANTSEL_HIGH) {
  2092. ret = -EINVAL;
  2093. break;
  2094. }
  2095. local->antsel_tx = value;
  2096. hostap_set_antsel(local);
  2097. break;
  2098. case PRISM2_PARAM_ANTSEL_RX:
  2099. if (value < 0 || value > HOSTAP_ANTSEL_HIGH) {
  2100. ret = -EINVAL;
  2101. break;
  2102. }
  2103. local->antsel_rx = value;
  2104. hostap_set_antsel(local);
  2105. break;
  2106. case PRISM2_PARAM_MONITOR_TYPE:
  2107. if (value != PRISM2_MONITOR_80211 &&
  2108. value != PRISM2_MONITOR_CAPHDR &&
  2109. value != PRISM2_MONITOR_PRISM &&
  2110. value != PRISM2_MONITOR_RADIOTAP) {
  2111. ret = -EINVAL;
  2112. break;
  2113. }
  2114. local->monitor_type = value;
  2115. if (local->iw_mode == IW_MODE_MONITOR)
  2116. hostap_monitor_set_type(local);
  2117. break;
  2118. case PRISM2_PARAM_WDS_TYPE:
  2119. local->wds_type = value;
  2120. break;
  2121. case PRISM2_PARAM_HOSTSCAN:
  2122. {
  2123. struct hfa384x_hostscan_request scan_req;
  2124. u16 rate;
  2125. memset(&scan_req, 0, sizeof(scan_req));
  2126. scan_req.channel_list = cpu_to_le16(0x3fff);
  2127. switch (value) {
  2128. case 1: rate = HFA384X_RATES_1MBPS; break;
  2129. case 2: rate = HFA384X_RATES_2MBPS; break;
  2130. case 3: rate = HFA384X_RATES_5MBPS; break;
  2131. case 4: rate = HFA384X_RATES_11MBPS; break;
  2132. default: rate = HFA384X_RATES_1MBPS; break;
  2133. }
  2134. scan_req.txrate = cpu_to_le16(rate);
  2135. /* leave SSID empty to accept all SSIDs */
  2136. if (local->iw_mode == IW_MODE_MASTER) {
  2137. if (hostap_set_word(dev, HFA384X_RID_CNFPORTTYPE,
  2138. HFA384X_PORTTYPE_BSS) ||
  2139. local->func->reset_port(dev))
  2140. printk(KERN_DEBUG "Leaving Host AP mode "
  2141. "for HostScan failed\n");
  2142. }
  2143. if (local->func->set_rid(dev, HFA384X_RID_HOSTSCAN, &scan_req,
  2144. sizeof(scan_req))) {
  2145. printk(KERN_DEBUG "HOSTSCAN failed\n");
  2146. ret = -EINVAL;
  2147. }
  2148. if (local->iw_mode == IW_MODE_MASTER) {
  2149. wait_queue_t __wait;
  2150. init_waitqueue_entry(&__wait, current);
  2151. add_wait_queue(&local->hostscan_wq, &__wait);
  2152. set_current_state(TASK_INTERRUPTIBLE);
  2153. schedule_timeout(HZ);
  2154. if (signal_pending(current))
  2155. ret = -EINTR;
  2156. set_current_state(TASK_RUNNING);
  2157. remove_wait_queue(&local->hostscan_wq, &__wait);
  2158. if (hostap_set_word(dev, HFA384X_RID_CNFPORTTYPE,
  2159. HFA384X_PORTTYPE_HOSTAP) ||
  2160. local->func->reset_port(dev))
  2161. printk(KERN_DEBUG "Returning to Host AP mode "
  2162. "after HostScan failed\n");
  2163. }
  2164. break;
  2165. }
  2166. case PRISM2_PARAM_AP_SCAN:
  2167. local->passive_scan_interval = value;
  2168. if (timer_pending(&local->passive_scan_timer))
  2169. del_timer(&local->passive_scan_timer);
  2170. if (value > 0) {
  2171. local->passive_scan_timer.expires = jiffies +
  2172. local->passive_scan_interval * HZ;
  2173. add_timer(&local->passive_scan_timer);
  2174. }
  2175. break;
  2176. case PRISM2_PARAM_ENH_SEC:
  2177. if (value < 0 || value > 3) {
  2178. ret = -EINVAL;
  2179. break;
  2180. }
  2181. local->enh_sec = value;
  2182. if (hostap_set_word(dev, HFA384X_RID_CNFENHSECURITY,
  2183. local->enh_sec) ||
  2184. local->func->reset_port(dev)) {
  2185. printk(KERN_INFO "%s: cnfEnhSecurity requires STA f/w "
  2186. "1.6.3 or newer\n", dev->name);
  2187. ret = -EOPNOTSUPP;
  2188. }
  2189. break;
  2190. #ifdef PRISM2_IO_DEBUG
  2191. case PRISM2_PARAM_IO_DEBUG:
  2192. local->io_debug_enabled = value;
  2193. break;
  2194. #endif /* PRISM2_IO_DEBUG */
  2195. case PRISM2_PARAM_BASIC_RATES:
  2196. if ((value & local->tx_rate_control) != value || value == 0) {
  2197. printk(KERN_INFO "%s: invalid basic rate set - basic "
  2198. "rates must be in supported rate set\n",
  2199. dev->name);
  2200. ret = -EINVAL;
  2201. break;
  2202. }
  2203. local->basic_rates = value;
  2204. if (hostap_set_word(dev, HFA384X_RID_CNFBASICRATES,
  2205. local->basic_rates) ||
  2206. local->func->reset_port(dev))
  2207. ret = -EINVAL;
  2208. break;
  2209. case PRISM2_PARAM_OPER_RATES:
  2210. local->tx_rate_control = value;
  2211. if (hostap_set_rate(dev))
  2212. ret = -EINVAL;
  2213. break;
  2214. case PRISM2_PARAM_HOSTAPD:
  2215. ret = hostap_set_hostapd(local, value, 1);
  2216. break;
  2217. case PRISM2_PARAM_HOSTAPD_STA:
  2218. ret = hostap_set_hostapd_sta(local, value, 1);
  2219. break;
  2220. case PRISM2_PARAM_WPA:
  2221. local->wpa = value;
  2222. if (local->sta_fw_ver < PRISM2_FW_VER(1,7,0))
  2223. ret = -EOPNOTSUPP;
  2224. else if (hostap_set_word(dev, HFA384X_RID_SSNHANDLINGMODE,
  2225. value ? 1 : 0))
  2226. ret = -EINVAL;
  2227. break;
  2228. case PRISM2_PARAM_PRIVACY_INVOKED:
  2229. local->privacy_invoked = value;
  2230. if (hostap_set_encryption(local) ||
  2231. local->func->reset_port(dev))
  2232. ret = -EINVAL;
  2233. break;
  2234. case PRISM2_PARAM_TKIP_COUNTERMEASURES:
  2235. local->tkip_countermeasures = value;
  2236. break;
  2237. case PRISM2_PARAM_DROP_UNENCRYPTED:
  2238. local->drop_unencrypted = value;
  2239. break;
  2240. case PRISM2_PARAM_SCAN_CHANNEL_MASK:
  2241. local->scan_channel_mask = value;
  2242. break;
  2243. default:
  2244. printk(KERN_DEBUG "%s: prism2_param: unknown param %d\n",
  2245. dev->name, param);
  2246. ret = -EOPNOTSUPP;
  2247. break;
  2248. }
  2249. return ret;
  2250. }
  2251. static int prism2_ioctl_priv_get_prism2_param(struct net_device *dev,
  2252. struct iw_request_info *info,
  2253. void *wrqu, char *extra)
  2254. {
  2255. struct hostap_interface *iface;
  2256. local_info_t *local;
  2257. int *param = (int *) extra;
  2258. int ret = 0;
  2259. iface = netdev_priv(dev);
  2260. local = iface->local;
  2261. switch (*param) {
  2262. case PRISM2_PARAM_TXRATECTRL:
  2263. *param = local->fw_tx_rate_control;
  2264. break;
  2265. case PRISM2_PARAM_BEACON_INT:
  2266. *param = local->beacon_int;
  2267. break;
  2268. case PRISM2_PARAM_PSEUDO_IBSS:
  2269. *param = local->pseudo_adhoc;
  2270. break;
  2271. case PRISM2_PARAM_ALC:
  2272. ret = -EOPNOTSUPP; /* FIX */
  2273. break;
  2274. case PRISM2_PARAM_DUMP:
  2275. *param = local->frame_dump;
  2276. break;
  2277. case PRISM2_PARAM_OTHER_AP_POLICY:
  2278. if (local->ap != NULL)
  2279. *param = local->ap->ap_policy;
  2280. else
  2281. ret = -EOPNOTSUPP;
  2282. break;
  2283. case PRISM2_PARAM_AP_MAX_INACTIVITY:
  2284. if (local->ap != NULL)
  2285. *param = local->ap->max_inactivity / HZ;
  2286. else
  2287. ret = -EOPNOTSUPP;
  2288. break;
  2289. case PRISM2_PARAM_AP_BRIDGE_PACKETS:
  2290. if (local->ap != NULL)
  2291. *param = local->ap->bridge_packets;
  2292. else
  2293. ret = -EOPNOTSUPP;
  2294. break;
  2295. case PRISM2_PARAM_DTIM_PERIOD:
  2296. *param = local->dtim_period;
  2297. break;
  2298. case PRISM2_PARAM_AP_NULLFUNC_ACK:
  2299. if (local->ap != NULL)
  2300. *param = local->ap->nullfunc_ack;
  2301. else
  2302. ret = -EOPNOTSUPP;
  2303. break;
  2304. case PRISM2_PARAM_MAX_WDS:
  2305. *param = local->wds_max_connections;
  2306. break;
  2307. case PRISM2_PARAM_AP_AUTOM_AP_WDS:
  2308. if (local->ap != NULL)
  2309. *param = local->ap->autom_ap_wds;
  2310. else
  2311. ret = -EOPNOTSUPP;
  2312. break;
  2313. case PRISM2_PARAM_AP_AUTH_ALGS:
  2314. *param = local->auth_algs;
  2315. break;
  2316. case PRISM2_PARAM_MONITOR_ALLOW_FCSERR:
  2317. *param = local->monitor_allow_fcserr;
  2318. break;
  2319. case PRISM2_PARAM_HOST_ENCRYPT:
  2320. *param = local->host_encrypt;
  2321. break;
  2322. case PRISM2_PARAM_HOST_DECRYPT:
  2323. *param = local->host_decrypt;
  2324. break;
  2325. case PRISM2_PARAM_HOST_ROAMING:
  2326. *param = local->host_roaming;
  2327. break;
  2328. case PRISM2_PARAM_BCRX_STA_KEY:
  2329. *param = local->bcrx_sta_key;
  2330. break;
  2331. case PRISM2_PARAM_IEEE_802_1X:
  2332. *param = local->ieee_802_1x;
  2333. break;
  2334. case PRISM2_PARAM_ANTSEL_TX:
  2335. *param = local->antsel_tx;
  2336. break;
  2337. case PRISM2_PARAM_ANTSEL_RX:
  2338. *param = local->antsel_rx;
  2339. break;
  2340. case PRISM2_PARAM_MONITOR_TYPE:
  2341. *param = local->monitor_type;
  2342. break;
  2343. case PRISM2_PARAM_WDS_TYPE:
  2344. *param = local->wds_type;
  2345. break;
  2346. case PRISM2_PARAM_HOSTSCAN:
  2347. ret = -EOPNOTSUPP;
  2348. break;
  2349. case PRISM2_PARAM_AP_SCAN:
  2350. *param = local->passive_scan_interval;
  2351. break;
  2352. case PRISM2_PARAM_ENH_SEC:
  2353. *param = local->enh_sec;
  2354. break;
  2355. #ifdef PRISM2_IO_DEBUG
  2356. case PRISM2_PARAM_IO_DEBUG:
  2357. *param = local->io_debug_enabled;
  2358. break;
  2359. #endif /* PRISM2_IO_DEBUG */
  2360. case PRISM2_PARAM_BASIC_RATES:
  2361. *param = local->basic_rates;
  2362. break;
  2363. case PRISM2_PARAM_OPER_RATES:
  2364. *param = local->tx_rate_control;
  2365. break;
  2366. case PRISM2_PARAM_HOSTAPD:
  2367. *param = local->hostapd;
  2368. break;
  2369. case PRISM2_PARAM_HOSTAPD_STA:
  2370. *param = local->hostapd_sta;
  2371. break;
  2372. case PRISM2_PARAM_WPA:
  2373. if (local->sta_fw_ver < PRISM2_FW_VER(1,7,0))
  2374. ret = -EOPNOTSUPP;
  2375. *param = local->wpa;
  2376. break;
  2377. case PRISM2_PARAM_PRIVACY_INVOKED:
  2378. *param = local->privacy_invoked;
  2379. break;
  2380. case PRISM2_PARAM_TKIP_COUNTERMEASURES:
  2381. *param = local->tkip_countermeasures;
  2382. break;
  2383. case PRISM2_PARAM_DROP_UNENCRYPTED:
  2384. *param = local->drop_unencrypted;
  2385. break;
  2386. case PRISM2_PARAM_SCAN_CHANNEL_MASK:
  2387. *param = local->scan_channel_mask;
  2388. break;
  2389. default:
  2390. printk(KERN_DEBUG "%s: get_prism2_param: unknown param %d\n",
  2391. dev->name, *param);
  2392. ret = -EOPNOTSUPP;
  2393. break;
  2394. }
  2395. return ret;
  2396. }
  2397. static int prism2_ioctl_priv_readmif(struct net_device *dev,
  2398. struct iw_request_info *info,
  2399. void *wrqu, char *extra)
  2400. {
  2401. struct hostap_interface *iface;
  2402. local_info_t *local;
  2403. u16 resp0;
  2404. iface = netdev_priv(dev);
  2405. local = iface->local;
  2406. if (local->func->cmd(dev, HFA384X_CMDCODE_READMIF, *extra, NULL,
  2407. &resp0))
  2408. return -EOPNOTSUPP;
  2409. else
  2410. *extra = resp0;
  2411. return 0;
  2412. }
  2413. static int prism2_ioctl_priv_writemif(struct net_device *dev,
  2414. struct iw_request_info *info,
  2415. void *wrqu, char *extra)
  2416. {
  2417. struct hostap_interface *iface;
  2418. local_info_t *local;
  2419. u16 cr, val;
  2420. iface = netdev_priv(dev);
  2421. local = iface->local;
  2422. cr = *extra;
  2423. val = *(extra + 1);
  2424. if (local->func->cmd(dev, HFA384X_CMDCODE_WRITEMIF, cr, &val, NULL))
  2425. return -EOPNOTSUPP;
  2426. return 0;
  2427. }
  2428. static int prism2_ioctl_priv_monitor(struct net_device *dev, int *i)
  2429. {
  2430. struct hostap_interface *iface;
  2431. local_info_t *local;
  2432. int ret = 0;
  2433. u32 mode;
  2434. iface = netdev_priv(dev);
  2435. local = iface->local;
  2436. printk(KERN_DEBUG "%s: process %d (%s) used deprecated iwpriv monitor "
  2437. "- update software to use iwconfig mode monitor\n",
  2438. dev->name, task_pid_nr(current), current->comm);
  2439. /* Backward compatibility code - this can be removed at some point */
  2440. if (*i == 0) {
  2441. /* Disable monitor mode - old mode was not saved, so go to
  2442. * Master mode */
  2443. mode = IW_MODE_MASTER;
  2444. ret = prism2_ioctl_siwmode(dev, NULL, &mode, NULL);
  2445. } else if (*i == 1) {
  2446. /* netlink socket mode is not supported anymore since it did
  2447. * not separate different devices from each other and was not
  2448. * best method for delivering large amount of packets to
  2449. * user space */
  2450. ret = -EOPNOTSUPP;
  2451. } else if (*i == 2 || *i == 3) {
  2452. switch (*i) {
  2453. case 2:
  2454. local->monitor_type = PRISM2_MONITOR_80211;
  2455. break;
  2456. case 3:
  2457. local->monitor_type = PRISM2_MONITOR_PRISM;
  2458. break;
  2459. }
  2460. mode = IW_MODE_MONITOR;
  2461. ret = prism2_ioctl_siwmode(dev, NULL, &mode, NULL);
  2462. hostap_monitor_mode_enable(local);
  2463. } else
  2464. ret = -EINVAL;
  2465. return ret;
  2466. }
  2467. static int prism2_ioctl_priv_reset(struct net_device *dev, int *i)
  2468. {
  2469. struct hostap_interface *iface;
  2470. local_info_t *local;
  2471. iface = netdev_priv(dev);
  2472. local = iface->local;
  2473. printk(KERN_DEBUG "%s: manual reset request(%d)\n", dev->name, *i);
  2474. switch (*i) {
  2475. case 0:
  2476. /* Disable and enable card */
  2477. local->func->hw_shutdown(dev, 1);
  2478. local->func->hw_config(dev, 0);
  2479. break;
  2480. case 1:
  2481. /* COR sreset */
  2482. local->func->hw_reset(dev);
  2483. break;
  2484. case 2:
  2485. /* Disable and enable port 0 */
  2486. local->func->reset_port(dev);
  2487. break;
  2488. case 3:
  2489. prism2_sta_deauth(local, WLAN_REASON_DEAUTH_LEAVING);
  2490. if (local->func->cmd(dev, HFA384X_CMDCODE_DISABLE, 0, NULL,
  2491. NULL))
  2492. return -EINVAL;
  2493. break;
  2494. case 4:
  2495. if (local->func->cmd(dev, HFA384X_CMDCODE_ENABLE, 0, NULL,
  2496. NULL))
  2497. return -EINVAL;
  2498. break;
  2499. default:
  2500. printk(KERN_DEBUG "Unknown reset request %d\n", *i);
  2501. return -EOPNOTSUPP;
  2502. }
  2503. return 0;
  2504. }
  2505. static int prism2_ioctl_priv_set_rid_word(struct net_device *dev, int *i)
  2506. {
  2507. int rid = *i;
  2508. int value = *(i + 1);
  2509. printk(KERN_DEBUG "%s: Set RID[0x%X] = %d\n", dev->name, rid, value);
  2510. if (hostap_set_word(dev, rid, value))
  2511. return -EINVAL;
  2512. return 0;
  2513. }
  2514. #ifndef PRISM2_NO_KERNEL_IEEE80211_MGMT
  2515. static int ap_mac_cmd_ioctl(local_info_t *local, int *cmd)
  2516. {
  2517. int ret = 0;
  2518. switch (*cmd) {
  2519. case AP_MAC_CMD_POLICY_OPEN:
  2520. local->ap->mac_restrictions.policy = MAC_POLICY_OPEN;
  2521. break;
  2522. case AP_MAC_CMD_POLICY_ALLOW:
  2523. local->ap->mac_restrictions.policy = MAC_POLICY_ALLOW;
  2524. break;
  2525. case AP_MAC_CMD_POLICY_DENY:
  2526. local->ap->mac_restrictions.policy = MAC_POLICY_DENY;
  2527. break;
  2528. case AP_MAC_CMD_FLUSH:
  2529. ap_control_flush_macs(&local->ap->mac_restrictions);
  2530. break;
  2531. case AP_MAC_CMD_KICKALL:
  2532. ap_control_kickall(local->ap);
  2533. hostap_deauth_all_stas(local->dev, local->ap, 0);
  2534. break;
  2535. default:
  2536. ret = -EOPNOTSUPP;
  2537. break;
  2538. }
  2539. return ret;
  2540. }
  2541. #endif /* PRISM2_NO_KERNEL_IEEE80211_MGMT */
  2542. #ifdef PRISM2_DOWNLOAD_SUPPORT
  2543. static int prism2_ioctl_priv_download(local_info_t *local, struct iw_point *p)
  2544. {
  2545. struct prism2_download_param *param;
  2546. int ret = 0;
  2547. if (p->length < sizeof(struct prism2_download_param) ||
  2548. p->length > 1024 || !p->pointer)
  2549. return -EINVAL;
  2550. param = kmalloc(p->length, GFP_KERNEL);
  2551. if (param == NULL)
  2552. return -ENOMEM;
  2553. if (copy_from_user(param, p->pointer, p->length)) {
  2554. ret = -EFAULT;
  2555. goto out;
  2556. }
  2557. if (p->length < sizeof(struct prism2_download_param) +
  2558. param->num_areas * sizeof(struct prism2_download_area)) {
  2559. ret = -EINVAL;
  2560. goto out;
  2561. }
  2562. ret = local->func->download(local, param);
  2563. out:
  2564. kfree(param);
  2565. return ret;
  2566. }
  2567. #endif /* PRISM2_DOWNLOAD_SUPPORT */
  2568. static int prism2_set_genericelement(struct net_device *dev, u8 *elem,
  2569. size_t len)
  2570. {
  2571. struct hostap_interface *iface = netdev_priv(dev);
  2572. local_info_t *local = iface->local;
  2573. u8 *buf;
  2574. /*
  2575. * Add 16-bit length in the beginning of the buffer because Prism2 RID
  2576. * includes it.
  2577. */
  2578. buf = kmalloc(len + 2, GFP_KERNEL);
  2579. if (buf == NULL)
  2580. return -ENOMEM;
  2581. *((__le16 *) buf) = cpu_to_le16(len);
  2582. memcpy(buf + 2, elem, len);
  2583. kfree(local->generic_elem);
  2584. local->generic_elem = buf;
  2585. local->generic_elem_len = len + 2;
  2586. return local->func->set_rid(local->dev, HFA384X_RID_GENERICELEMENT,
  2587. buf, len + 2);
  2588. }
  2589. static int prism2_ioctl_siwauth(struct net_device *dev,
  2590. struct iw_request_info *info,
  2591. struct iw_param *data, char *extra)
  2592. {
  2593. struct hostap_interface *iface = netdev_priv(dev);
  2594. local_info_t *local = iface->local;
  2595. switch (data->flags & IW_AUTH_INDEX) {
  2596. case IW_AUTH_WPA_VERSION:
  2597. case IW_AUTH_CIPHER_PAIRWISE:
  2598. case IW_AUTH_CIPHER_GROUP:
  2599. case IW_AUTH_KEY_MGMT:
  2600. /*
  2601. * Host AP driver does not use these parameters and allows
  2602. * wpa_supplicant to control them internally.
  2603. */
  2604. break;
  2605. case IW_AUTH_TKIP_COUNTERMEASURES:
  2606. local->tkip_countermeasures = data->value;
  2607. break;
  2608. case IW_AUTH_DROP_UNENCRYPTED:
  2609. local->drop_unencrypted = data->value;
  2610. break;
  2611. case IW_AUTH_80211_AUTH_ALG:
  2612. local->auth_algs = data->value;
  2613. break;
  2614. case IW_AUTH_WPA_ENABLED:
  2615. if (data->value == 0) {
  2616. local->wpa = 0;
  2617. if (local->sta_fw_ver < PRISM2_FW_VER(1,7,0))
  2618. break;
  2619. prism2_set_genericelement(dev, "", 0);
  2620. local->host_roaming = 0;
  2621. local->privacy_invoked = 0;
  2622. if (hostap_set_word(dev, HFA384X_RID_SSNHANDLINGMODE,
  2623. 0) ||
  2624. hostap_set_roaming(local) ||
  2625. hostap_set_encryption(local) ||
  2626. local->func->reset_port(dev))
  2627. return -EINVAL;
  2628. break;
  2629. }
  2630. if (local->sta_fw_ver < PRISM2_FW_VER(1,7,0))
  2631. return -EOPNOTSUPP;
  2632. local->host_roaming = 2;
  2633. local->privacy_invoked = 1;
  2634. local->wpa = 1;
  2635. if (hostap_set_word(dev, HFA384X_RID_SSNHANDLINGMODE, 1) ||
  2636. hostap_set_roaming(local) ||
  2637. hostap_set_encryption(local) ||
  2638. local->func->reset_port(dev))
  2639. return -EINVAL;
  2640. break;
  2641. case IW_AUTH_RX_UNENCRYPTED_EAPOL:
  2642. local->ieee_802_1x = data->value;
  2643. break;
  2644. case IW_AUTH_PRIVACY_INVOKED:
  2645. local->privacy_invoked = data->value;
  2646. break;
  2647. default:
  2648. return -EOPNOTSUPP;
  2649. }
  2650. return 0;
  2651. }
  2652. static int prism2_ioctl_giwauth(struct net_device *dev,
  2653. struct iw_request_info *info,
  2654. struct iw_param *data, char *extra)
  2655. {
  2656. struct hostap_interface *iface = netdev_priv(dev);
  2657. local_info_t *local = iface->local;
  2658. switch (data->flags & IW_AUTH_INDEX) {
  2659. case IW_AUTH_WPA_VERSION:
  2660. case IW_AUTH_CIPHER_PAIRWISE:
  2661. case IW_AUTH_CIPHER_GROUP:
  2662. case IW_AUTH_KEY_MGMT:
  2663. /*
  2664. * Host AP driver does not use these parameters and allows
  2665. * wpa_supplicant to control them internally.
  2666. */
  2667. return -EOPNOTSUPP;
  2668. case IW_AUTH_TKIP_COUNTERMEASURES:
  2669. data->value = local->tkip_countermeasures;
  2670. break;
  2671. case IW_AUTH_DROP_UNENCRYPTED:
  2672. data->value = local->drop_unencrypted;
  2673. break;
  2674. case IW_AUTH_80211_AUTH_ALG:
  2675. data->value = local->auth_algs;
  2676. break;
  2677. case IW_AUTH_WPA_ENABLED:
  2678. data->value = local->wpa;
  2679. break;
  2680. case IW_AUTH_RX_UNENCRYPTED_EAPOL:
  2681. data->value = local->ieee_802_1x;
  2682. break;
  2683. default:
  2684. return -EOPNOTSUPP;
  2685. }
  2686. return 0;
  2687. }
  2688. static int prism2_ioctl_siwencodeext(struct net_device *dev,
  2689. struct iw_request_info *info,
  2690. struct iw_point *erq, char *extra)
  2691. {
  2692. struct hostap_interface *iface = netdev_priv(dev);
  2693. local_info_t *local = iface->local;
  2694. struct iw_encode_ext *ext = (struct iw_encode_ext *) extra;
  2695. int i, ret = 0;
  2696. struct lib80211_crypto_ops *ops;
  2697. struct lib80211_crypt_data **crypt;
  2698. void *sta_ptr;
  2699. u8 *addr;
  2700. const char *alg, *module;
  2701. i = erq->flags & IW_ENCODE_INDEX;
  2702. if (i > WEP_KEYS)
  2703. return -EINVAL;
  2704. if (i < 1 || i > WEP_KEYS)
  2705. i = local->crypt_info.tx_keyidx;
  2706. else
  2707. i--;
  2708. if (i < 0 || i >= WEP_KEYS)
  2709. return -EINVAL;
  2710. addr = ext->addr.sa_data;
  2711. if (is_broadcast_ether_addr(addr)) {
  2712. sta_ptr = NULL;
  2713. crypt = &local->crypt_info.crypt[i];
  2714. } else {
  2715. if (i != 0)
  2716. return -EINVAL;
  2717. sta_ptr = ap_crypt_get_ptrs(local->ap, addr, 0, &crypt);
  2718. if (sta_ptr == NULL) {
  2719. if (local->iw_mode == IW_MODE_INFRA) {
  2720. /*
  2721. * TODO: add STA entry for the current AP so
  2722. * that unicast key can be used. For now, this
  2723. * is emulated by using default key idx 0.
  2724. */
  2725. i = 0;
  2726. crypt = &local->crypt_info.crypt[i];
  2727. } else
  2728. return -EINVAL;
  2729. }
  2730. }
  2731. if ((erq->flags & IW_ENCODE_DISABLED) ||
  2732. ext->alg == IW_ENCODE_ALG_NONE) {
  2733. if (*crypt)
  2734. lib80211_crypt_delayed_deinit(&local->crypt_info, crypt);
  2735. goto done;
  2736. }
  2737. switch (ext->alg) {
  2738. case IW_ENCODE_ALG_WEP:
  2739. alg = "WEP";
  2740. module = "lib80211_crypt_wep";
  2741. break;
  2742. case IW_ENCODE_ALG_TKIP:
  2743. alg = "TKIP";
  2744. module = "lib80211_crypt_tkip";
  2745. break;
  2746. case IW_ENCODE_ALG_CCMP:
  2747. alg = "CCMP";
  2748. module = "lib80211_crypt_ccmp";
  2749. break;
  2750. default:
  2751. printk(KERN_DEBUG "%s: unsupported algorithm %d\n",
  2752. local->dev->name, ext->alg);
  2753. ret = -EOPNOTSUPP;
  2754. goto done;
  2755. }
  2756. ops = lib80211_get_crypto_ops(alg);
  2757. if (ops == NULL) {
  2758. request_module(module);
  2759. ops = lib80211_get_crypto_ops(alg);
  2760. }
  2761. if (ops == NULL) {
  2762. printk(KERN_DEBUG "%s: unknown crypto alg '%s'\n",
  2763. local->dev->name, alg);
  2764. ret = -EOPNOTSUPP;
  2765. goto done;
  2766. }
  2767. if (sta_ptr || ext->alg != IW_ENCODE_ALG_WEP) {
  2768. /*
  2769. * Per station encryption and other than WEP algorithms
  2770. * require host-based encryption, so force them on
  2771. * automatically.
  2772. */
  2773. local->host_decrypt = local->host_encrypt = 1;
  2774. }
  2775. if (*crypt == NULL || (*crypt)->ops != ops) {
  2776. struct lib80211_crypt_data *new_crypt;
  2777. lib80211_crypt_delayed_deinit(&local->crypt_info, crypt);
  2778. new_crypt = kzalloc(sizeof(struct lib80211_crypt_data),
  2779. GFP_KERNEL);
  2780. if (new_crypt == NULL) {
  2781. ret = -ENOMEM;
  2782. goto done;
  2783. }
  2784. new_crypt->ops = ops;
  2785. if (new_crypt->ops && try_module_get(new_crypt->ops->owner))
  2786. new_crypt->priv = new_crypt->ops->init(i);
  2787. if (new_crypt->priv == NULL) {
  2788. kfree(new_crypt);
  2789. ret = -EINVAL;
  2790. goto done;
  2791. }
  2792. *crypt = new_crypt;
  2793. }
  2794. /*
  2795. * TODO: if ext_flags does not have IW_ENCODE_EXT_RX_SEQ_VALID, the
  2796. * existing seq# should not be changed.
  2797. * TODO: if ext_flags has IW_ENCODE_EXT_TX_SEQ_VALID, next TX seq#
  2798. * should be changed to something else than zero.
  2799. */
  2800. if ((!(ext->ext_flags & IW_ENCODE_EXT_SET_TX_KEY) || ext->key_len > 0)
  2801. && (*crypt)->ops->set_key &&
  2802. (*crypt)->ops->set_key(ext->key, ext->key_len, ext->rx_seq,
  2803. (*crypt)->priv) < 0) {
  2804. printk(KERN_DEBUG "%s: key setting failed\n",
  2805. local->dev->name);
  2806. ret = -EINVAL;
  2807. goto done;
  2808. }
  2809. if (ext->ext_flags & IW_ENCODE_EXT_SET_TX_KEY) {
  2810. if (!sta_ptr)
  2811. local->crypt_info.tx_keyidx = i;
  2812. }
  2813. if (sta_ptr == NULL && ext->key_len > 0) {
  2814. int first = 1, j;
  2815. for (j = 0; j < WEP_KEYS; j++) {
  2816. if (j != i && local->crypt_info.crypt[j]) {
  2817. first = 0;
  2818. break;
  2819. }
  2820. }
  2821. if (first)
  2822. local->crypt_info.tx_keyidx = i;
  2823. }
  2824. done:
  2825. if (sta_ptr)
  2826. hostap_handle_sta_release(sta_ptr);
  2827. local->open_wep = erq->flags & IW_ENCODE_OPEN;
  2828. /*
  2829. * Do not reset port0 if card is in Managed mode since resetting will
  2830. * generate new IEEE 802.11 authentication which may end up in looping
  2831. * with IEEE 802.1X. Prism2 documentation seem to require port reset
  2832. * after WEP configuration. However, keys are apparently changed at
  2833. * least in Managed mode.
  2834. */
  2835. if (ret == 0 &&
  2836. (hostap_set_encryption(local) ||
  2837. (local->iw_mode != IW_MODE_INFRA &&
  2838. local->func->reset_port(local->dev))))
  2839. ret = -EINVAL;
  2840. return ret;
  2841. }
  2842. static int prism2_ioctl_giwencodeext(struct net_device *dev,
  2843. struct iw_request_info *info,
  2844. struct iw_point *erq, char *extra)
  2845. {
  2846. struct hostap_interface *iface = netdev_priv(dev);
  2847. local_info_t *local = iface->local;
  2848. struct lib80211_crypt_data **crypt;
  2849. void *sta_ptr;
  2850. int max_key_len, i;
  2851. struct iw_encode_ext *ext = (struct iw_encode_ext *) extra;
  2852. u8 *addr;
  2853. max_key_len = erq->length - sizeof(*ext);
  2854. if (max_key_len < 0)
  2855. return -EINVAL;
  2856. i = erq->flags & IW_ENCODE_INDEX;
  2857. if (i < 1 || i > WEP_KEYS)
  2858. i = local->crypt_info.tx_keyidx;
  2859. else
  2860. i--;
  2861. addr = ext->addr.sa_data;
  2862. if (is_broadcast_ether_addr(addr)) {
  2863. sta_ptr = NULL;
  2864. crypt = &local->crypt_info.crypt[i];
  2865. } else {
  2866. i = 0;
  2867. sta_ptr = ap_crypt_get_ptrs(local->ap, addr, 0, &crypt);
  2868. if (sta_ptr == NULL)
  2869. return -EINVAL;
  2870. }
  2871. erq->flags = i + 1;
  2872. memset(ext, 0, sizeof(*ext));
  2873. if (*crypt == NULL || (*crypt)->ops == NULL) {
  2874. ext->alg = IW_ENCODE_ALG_NONE;
  2875. ext->key_len = 0;
  2876. erq->flags |= IW_ENCODE_DISABLED;
  2877. } else {
  2878. if (strcmp((*crypt)->ops->name, "WEP") == 0)
  2879. ext->alg = IW_ENCODE_ALG_WEP;
  2880. else if (strcmp((*crypt)->ops->name, "TKIP") == 0)
  2881. ext->alg = IW_ENCODE_ALG_TKIP;
  2882. else if (strcmp((*crypt)->ops->name, "CCMP") == 0)
  2883. ext->alg = IW_ENCODE_ALG_CCMP;
  2884. else
  2885. return -EINVAL;
  2886. if ((*crypt)->ops->get_key) {
  2887. ext->key_len =
  2888. (*crypt)->ops->get_key(ext->key,
  2889. max_key_len,
  2890. ext->tx_seq,
  2891. (*crypt)->priv);
  2892. if (ext->key_len &&
  2893. (ext->alg == IW_ENCODE_ALG_TKIP ||
  2894. ext->alg == IW_ENCODE_ALG_CCMP))
  2895. ext->ext_flags |= IW_ENCODE_EXT_TX_SEQ_VALID;
  2896. }
  2897. }
  2898. if (sta_ptr)
  2899. hostap_handle_sta_release(sta_ptr);
  2900. return 0;
  2901. }
  2902. static int prism2_ioctl_set_encryption(local_info_t *local,
  2903. struct prism2_hostapd_param *param,
  2904. int param_len)
  2905. {
  2906. int ret = 0;
  2907. struct lib80211_crypto_ops *ops;
  2908. struct lib80211_crypt_data **crypt;
  2909. void *sta_ptr;
  2910. param->u.crypt.err = 0;
  2911. param->u.crypt.alg[HOSTAP_CRYPT_ALG_NAME_LEN - 1] = '\0';
  2912. if (param_len !=
  2913. (int) ((char *) param->u.crypt.key - (char *) param) +
  2914. param->u.crypt.key_len)
  2915. return -EINVAL;
  2916. if (is_broadcast_ether_addr(param->sta_addr)) {
  2917. if (param->u.crypt.idx >= WEP_KEYS)
  2918. return -EINVAL;
  2919. sta_ptr = NULL;
  2920. crypt = &local->crypt_info.crypt[param->u.crypt.idx];
  2921. } else {
  2922. if (param->u.crypt.idx)
  2923. return -EINVAL;
  2924. sta_ptr = ap_crypt_get_ptrs(
  2925. local->ap, param->sta_addr,
  2926. (param->u.crypt.flags & HOSTAP_CRYPT_FLAG_PERMANENT),
  2927. &crypt);
  2928. if (sta_ptr == NULL) {
  2929. param->u.crypt.err = HOSTAP_CRYPT_ERR_UNKNOWN_ADDR;
  2930. return -EINVAL;
  2931. }
  2932. }
  2933. if (strcmp(param->u.crypt.alg, "none") == 0) {
  2934. if (crypt)
  2935. lib80211_crypt_delayed_deinit(&local->crypt_info, crypt);
  2936. goto done;
  2937. }
  2938. ops = lib80211_get_crypto_ops(param->u.crypt.alg);
  2939. if (ops == NULL && strcmp(param->u.crypt.alg, "WEP") == 0) {
  2940. request_module("lib80211_crypt_wep");
  2941. ops = lib80211_get_crypto_ops(param->u.crypt.alg);
  2942. } else if (ops == NULL && strcmp(param->u.crypt.alg, "TKIP") == 0) {
  2943. request_module("lib80211_crypt_tkip");
  2944. ops = lib80211_get_crypto_ops(param->u.crypt.alg);
  2945. } else if (ops == NULL && strcmp(param->u.crypt.alg, "CCMP") == 0) {
  2946. request_module("lib80211_crypt_ccmp");
  2947. ops = lib80211_get_crypto_ops(param->u.crypt.alg);
  2948. }
  2949. if (ops == NULL) {
  2950. printk(KERN_DEBUG "%s: unknown crypto alg '%s'\n",
  2951. local->dev->name, param->u.crypt.alg);
  2952. param->u.crypt.err = HOSTAP_CRYPT_ERR_UNKNOWN_ALG;
  2953. ret = -EINVAL;
  2954. goto done;
  2955. }
  2956. /* station based encryption and other than WEP algorithms require
  2957. * host-based encryption, so force them on automatically */
  2958. local->host_decrypt = local->host_encrypt = 1;
  2959. if (*crypt == NULL || (*crypt)->ops != ops) {
  2960. struct lib80211_crypt_data *new_crypt;
  2961. lib80211_crypt_delayed_deinit(&local->crypt_info, crypt);
  2962. new_crypt = kzalloc(sizeof(struct lib80211_crypt_data),
  2963. GFP_KERNEL);
  2964. if (new_crypt == NULL) {
  2965. ret = -ENOMEM;
  2966. goto done;
  2967. }
  2968. new_crypt->ops = ops;
  2969. new_crypt->priv = new_crypt->ops->init(param->u.crypt.idx);
  2970. if (new_crypt->priv == NULL) {
  2971. kfree(new_crypt);
  2972. param->u.crypt.err =
  2973. HOSTAP_CRYPT_ERR_CRYPT_INIT_FAILED;
  2974. ret = -EINVAL;
  2975. goto done;
  2976. }
  2977. *crypt = new_crypt;
  2978. }
  2979. if ((!(param->u.crypt.flags & HOSTAP_CRYPT_FLAG_SET_TX_KEY) ||
  2980. param->u.crypt.key_len > 0) && (*crypt)->ops->set_key &&
  2981. (*crypt)->ops->set_key(param->u.crypt.key,
  2982. param->u.crypt.key_len, param->u.crypt.seq,
  2983. (*crypt)->priv) < 0) {
  2984. printk(KERN_DEBUG "%s: key setting failed\n",
  2985. local->dev->name);
  2986. param->u.crypt.err = HOSTAP_CRYPT_ERR_KEY_SET_FAILED;
  2987. ret = -EINVAL;
  2988. goto done;
  2989. }
  2990. if (param->u.crypt.flags & HOSTAP_CRYPT_FLAG_SET_TX_KEY) {
  2991. if (!sta_ptr)
  2992. local->crypt_info.tx_keyidx = param->u.crypt.idx;
  2993. else if (param->u.crypt.idx) {
  2994. printk(KERN_DEBUG "%s: TX key idx setting failed\n",
  2995. local->dev->name);
  2996. param->u.crypt.err =
  2997. HOSTAP_CRYPT_ERR_TX_KEY_SET_FAILED;
  2998. ret = -EINVAL;
  2999. goto done;
  3000. }
  3001. }
  3002. done:
  3003. if (sta_ptr)
  3004. hostap_handle_sta_release(sta_ptr);
  3005. /* Do not reset port0 if card is in Managed mode since resetting will
  3006. * generate new IEEE 802.11 authentication which may end up in looping
  3007. * with IEEE 802.1X. Prism2 documentation seem to require port reset
  3008. * after WEP configuration. However, keys are apparently changed at
  3009. * least in Managed mode. */
  3010. if (ret == 0 &&
  3011. (hostap_set_encryption(local) ||
  3012. (local->iw_mode != IW_MODE_INFRA &&
  3013. local->func->reset_port(local->dev)))) {
  3014. param->u.crypt.err = HOSTAP_CRYPT_ERR_CARD_CONF_FAILED;
  3015. return -EINVAL;
  3016. }
  3017. return ret;
  3018. }
  3019. static int prism2_ioctl_get_encryption(local_info_t *local,
  3020. struct prism2_hostapd_param *param,
  3021. int param_len)
  3022. {
  3023. struct lib80211_crypt_data **crypt;
  3024. void *sta_ptr;
  3025. int max_key_len;
  3026. param->u.crypt.err = 0;
  3027. max_key_len = param_len -
  3028. (int) ((char *) param->u.crypt.key - (char *) param);
  3029. if (max_key_len < 0)
  3030. return -EINVAL;
  3031. if (is_broadcast_ether_addr(param->sta_addr)) {
  3032. sta_ptr = NULL;
  3033. if (param->u.crypt.idx >= WEP_KEYS)
  3034. param->u.crypt.idx = local->crypt_info.tx_keyidx;
  3035. crypt = &local->crypt_info.crypt[param->u.crypt.idx];
  3036. } else {
  3037. param->u.crypt.idx = 0;
  3038. sta_ptr = ap_crypt_get_ptrs(local->ap, param->sta_addr, 0,
  3039. &crypt);
  3040. if (sta_ptr == NULL) {
  3041. param->u.crypt.err = HOSTAP_CRYPT_ERR_UNKNOWN_ADDR;
  3042. return -EINVAL;
  3043. }
  3044. }
  3045. if (*crypt == NULL || (*crypt)->ops == NULL) {
  3046. memcpy(param->u.crypt.alg, "none", 5);
  3047. param->u.crypt.key_len = 0;
  3048. param->u.crypt.idx = 0xff;
  3049. } else {
  3050. strncpy(param->u.crypt.alg, (*crypt)->ops->name,
  3051. HOSTAP_CRYPT_ALG_NAME_LEN);
  3052. param->u.crypt.key_len = 0;
  3053. memset(param->u.crypt.seq, 0, 8);
  3054. if ((*crypt)->ops->get_key) {
  3055. param->u.crypt.key_len =
  3056. (*crypt)->ops->get_key(param->u.crypt.key,
  3057. max_key_len,
  3058. param->u.crypt.seq,
  3059. (*crypt)->priv);
  3060. }
  3061. }
  3062. if (sta_ptr)
  3063. hostap_handle_sta_release(sta_ptr);
  3064. return 0;
  3065. }
  3066. static int prism2_ioctl_get_rid(local_info_t *local,
  3067. struct prism2_hostapd_param *param,
  3068. int param_len)
  3069. {
  3070. int max_len, res;
  3071. max_len = param_len - PRISM2_HOSTAPD_RID_HDR_LEN;
  3072. if (max_len < 0)
  3073. return -EINVAL;
  3074. res = local->func->get_rid(local->dev, param->u.rid.rid,
  3075. param->u.rid.data, param->u.rid.len, 0);
  3076. if (res >= 0) {
  3077. param->u.rid.len = res;
  3078. return 0;
  3079. }
  3080. return res;
  3081. }
  3082. static int prism2_ioctl_set_rid(local_info_t *local,
  3083. struct prism2_hostapd_param *param,
  3084. int param_len)
  3085. {
  3086. int max_len;
  3087. max_len = param_len - PRISM2_HOSTAPD_RID_HDR_LEN;
  3088. if (max_len < 0 || max_len < param->u.rid.len)
  3089. return -EINVAL;
  3090. return local->func->set_rid(local->dev, param->u.rid.rid,
  3091. param->u.rid.data, param->u.rid.len);
  3092. }
  3093. static int prism2_ioctl_set_assoc_ap_addr(local_info_t *local,
  3094. struct prism2_hostapd_param *param,
  3095. int param_len)
  3096. {
  3097. printk(KERN_DEBUG "%ssta: associated as client with AP %pM\n",
  3098. local->dev->name, param->sta_addr);
  3099. memcpy(local->assoc_ap_addr, param->sta_addr, ETH_ALEN);
  3100. return 0;
  3101. }
  3102. static int prism2_ioctl_siwgenie(struct net_device *dev,
  3103. struct iw_request_info *info,
  3104. struct iw_point *data, char *extra)
  3105. {
  3106. return prism2_set_genericelement(dev, extra, data->length);
  3107. }
  3108. static int prism2_ioctl_giwgenie(struct net_device *dev,
  3109. struct iw_request_info *info,
  3110. struct iw_point *data, char *extra)
  3111. {
  3112. struct hostap_interface *iface = netdev_priv(dev);
  3113. local_info_t *local = iface->local;
  3114. int len = local->generic_elem_len - 2;
  3115. if (len <= 0 || local->generic_elem == NULL) {
  3116. data->length = 0;
  3117. return 0;
  3118. }
  3119. if (data->length < len)
  3120. return -E2BIG;
  3121. data->length = len;
  3122. memcpy(extra, local->generic_elem + 2, len);
  3123. return 0;
  3124. }
  3125. static int prism2_ioctl_set_generic_element(local_info_t *local,
  3126. struct prism2_hostapd_param *param,
  3127. int param_len)
  3128. {
  3129. int max_len, len;
  3130. len = param->u.generic_elem.len;
  3131. max_len = param_len - PRISM2_HOSTAPD_GENERIC_ELEMENT_HDR_LEN;
  3132. if (max_len < 0 || max_len < len)
  3133. return -EINVAL;
  3134. return prism2_set_genericelement(local->dev,
  3135. param->u.generic_elem.data, len);
  3136. }
  3137. static int prism2_ioctl_siwmlme(struct net_device *dev,
  3138. struct iw_request_info *info,
  3139. struct iw_point *data, char *extra)
  3140. {
  3141. struct hostap_interface *iface = netdev_priv(dev);
  3142. local_info_t *local = iface->local;
  3143. struct iw_mlme *mlme = (struct iw_mlme *) extra;
  3144. __le16 reason;
  3145. reason = cpu_to_le16(mlme->reason_code);
  3146. switch (mlme->cmd) {
  3147. case IW_MLME_DEAUTH:
  3148. return prism2_sta_send_mgmt(local, mlme->addr.sa_data,
  3149. IEEE80211_STYPE_DEAUTH,
  3150. (u8 *) &reason, 2);
  3151. case IW_MLME_DISASSOC:
  3152. return prism2_sta_send_mgmt(local, mlme->addr.sa_data,
  3153. IEEE80211_STYPE_DISASSOC,
  3154. (u8 *) &reason, 2);
  3155. default:
  3156. return -EOPNOTSUPP;
  3157. }
  3158. }
  3159. static int prism2_ioctl_mlme(local_info_t *local,
  3160. struct prism2_hostapd_param *param)
  3161. {
  3162. __le16 reason;
  3163. reason = cpu_to_le16(param->u.mlme.reason_code);
  3164. switch (param->u.mlme.cmd) {
  3165. case MLME_STA_DEAUTH:
  3166. return prism2_sta_send_mgmt(local, param->sta_addr,
  3167. IEEE80211_STYPE_DEAUTH,
  3168. (u8 *) &reason, 2);
  3169. case MLME_STA_DISASSOC:
  3170. return prism2_sta_send_mgmt(local, param->sta_addr,
  3171. IEEE80211_STYPE_DISASSOC,
  3172. (u8 *) &reason, 2);
  3173. default:
  3174. return -EOPNOTSUPP;
  3175. }
  3176. }
  3177. static int prism2_ioctl_scan_req(local_info_t *local,
  3178. struct prism2_hostapd_param *param)
  3179. {
  3180. #ifndef PRISM2_NO_STATION_MODES
  3181. if ((local->iw_mode != IW_MODE_INFRA &&
  3182. local->iw_mode != IW_MODE_ADHOC) ||
  3183. (local->sta_fw_ver < PRISM2_FW_VER(1,3,1)))
  3184. return -EOPNOTSUPP;
  3185. if (!local->dev_enabled)
  3186. return -ENETDOWN;
  3187. return prism2_request_hostscan(local->dev, param->u.scan_req.ssid,
  3188. param->u.scan_req.ssid_len);
  3189. #else /* PRISM2_NO_STATION_MODES */
  3190. return -EOPNOTSUPP;
  3191. #endif /* PRISM2_NO_STATION_MODES */
  3192. }
  3193. static int prism2_ioctl_priv_hostapd(local_info_t *local, struct iw_point *p)
  3194. {
  3195. struct prism2_hostapd_param *param;
  3196. int ret = 0;
  3197. int ap_ioctl = 0;
  3198. if (p->length < sizeof(struct prism2_hostapd_param) ||
  3199. p->length > PRISM2_HOSTAPD_MAX_BUF_SIZE || !p->pointer)
  3200. return -EINVAL;
  3201. param = kmalloc(p->length, GFP_KERNEL);
  3202. if (param == NULL)
  3203. return -ENOMEM;
  3204. if (copy_from_user(param, p->pointer, p->length)) {
  3205. ret = -EFAULT;
  3206. goto out;
  3207. }
  3208. switch (param->cmd) {
  3209. case PRISM2_SET_ENCRYPTION:
  3210. ret = prism2_ioctl_set_encryption(local, param, p->length);
  3211. break;
  3212. case PRISM2_GET_ENCRYPTION:
  3213. ret = prism2_ioctl_get_encryption(local, param, p->length);
  3214. break;
  3215. case PRISM2_HOSTAPD_GET_RID:
  3216. ret = prism2_ioctl_get_rid(local, param, p->length);
  3217. break;
  3218. case PRISM2_HOSTAPD_SET_RID:
  3219. ret = prism2_ioctl_set_rid(local, param, p->length);
  3220. break;
  3221. case PRISM2_HOSTAPD_SET_ASSOC_AP_ADDR:
  3222. ret = prism2_ioctl_set_assoc_ap_addr(local, param, p->length);
  3223. break;
  3224. case PRISM2_HOSTAPD_SET_GENERIC_ELEMENT:
  3225. ret = prism2_ioctl_set_generic_element(local, param,
  3226. p->length);
  3227. break;
  3228. case PRISM2_HOSTAPD_MLME:
  3229. ret = prism2_ioctl_mlme(local, param);
  3230. break;
  3231. case PRISM2_HOSTAPD_SCAN_REQ:
  3232. ret = prism2_ioctl_scan_req(local, param);
  3233. break;
  3234. default:
  3235. ret = prism2_hostapd(local->ap, param);
  3236. ap_ioctl = 1;
  3237. break;
  3238. }
  3239. if (ret == 1 || !ap_ioctl) {
  3240. if (copy_to_user(p->pointer, param, p->length)) {
  3241. ret = -EFAULT;
  3242. goto out;
  3243. } else if (ap_ioctl)
  3244. ret = 0;
  3245. }
  3246. out:
  3247. kfree(param);
  3248. return ret;
  3249. }
  3250. static void prism2_get_drvinfo(struct net_device *dev,
  3251. struct ethtool_drvinfo *info)
  3252. {
  3253. struct hostap_interface *iface;
  3254. local_info_t *local;
  3255. iface = netdev_priv(dev);
  3256. local = iface->local;
  3257. strlcpy(info->driver, "hostap", sizeof(info->driver));
  3258. snprintf(info->fw_version, sizeof(info->fw_version),
  3259. "%d.%d.%d", (local->sta_fw_ver >> 16) & 0xff,
  3260. (local->sta_fw_ver >> 8) & 0xff,
  3261. local->sta_fw_ver & 0xff);
  3262. }
  3263. const struct ethtool_ops prism2_ethtool_ops = {
  3264. .get_drvinfo = prism2_get_drvinfo
  3265. };
  3266. /* Structures to export the Wireless Handlers */
  3267. static const iw_handler prism2_handler[] =
  3268. {
  3269. (iw_handler) NULL, /* SIOCSIWCOMMIT */
  3270. (iw_handler) prism2_get_name, /* SIOCGIWNAME */
  3271. (iw_handler) NULL, /* SIOCSIWNWID */
  3272. (iw_handler) NULL, /* SIOCGIWNWID */
  3273. (iw_handler) prism2_ioctl_siwfreq, /* SIOCSIWFREQ */
  3274. (iw_handler) prism2_ioctl_giwfreq, /* SIOCGIWFREQ */
  3275. (iw_handler) prism2_ioctl_siwmode, /* SIOCSIWMODE */
  3276. (iw_handler) prism2_ioctl_giwmode, /* SIOCGIWMODE */
  3277. (iw_handler) prism2_ioctl_siwsens, /* SIOCSIWSENS */
  3278. (iw_handler) prism2_ioctl_giwsens, /* SIOCGIWSENS */
  3279. (iw_handler) NULL /* not used */, /* SIOCSIWRANGE */
  3280. (iw_handler) prism2_ioctl_giwrange, /* SIOCGIWRANGE */
  3281. (iw_handler) NULL /* not used */, /* SIOCSIWPRIV */
  3282. (iw_handler) NULL /* kernel code */, /* SIOCGIWPRIV */
  3283. (iw_handler) NULL /* not used */, /* SIOCSIWSTATS */
  3284. (iw_handler) NULL /* kernel code */, /* SIOCGIWSTATS */
  3285. iw_handler_set_spy, /* SIOCSIWSPY */
  3286. iw_handler_get_spy, /* SIOCGIWSPY */
  3287. iw_handler_set_thrspy, /* SIOCSIWTHRSPY */
  3288. iw_handler_get_thrspy, /* SIOCGIWTHRSPY */
  3289. (iw_handler) prism2_ioctl_siwap, /* SIOCSIWAP */
  3290. (iw_handler) prism2_ioctl_giwap, /* SIOCGIWAP */
  3291. (iw_handler) prism2_ioctl_siwmlme, /* SIOCSIWMLME */
  3292. (iw_handler) prism2_ioctl_giwaplist, /* SIOCGIWAPLIST */
  3293. (iw_handler) prism2_ioctl_siwscan, /* SIOCSIWSCAN */
  3294. (iw_handler) prism2_ioctl_giwscan, /* SIOCGIWSCAN */
  3295. (iw_handler) prism2_ioctl_siwessid, /* SIOCSIWESSID */
  3296. (iw_handler) prism2_ioctl_giwessid, /* SIOCGIWESSID */
  3297. (iw_handler) prism2_ioctl_siwnickn, /* SIOCSIWNICKN */
  3298. (iw_handler) prism2_ioctl_giwnickn, /* SIOCGIWNICKN */
  3299. (iw_handler) NULL, /* -- hole -- */
  3300. (iw_handler) NULL, /* -- hole -- */
  3301. (iw_handler) prism2_ioctl_siwrate, /* SIOCSIWRATE */
  3302. (iw_handler) prism2_ioctl_giwrate, /* SIOCGIWRATE */
  3303. (iw_handler) prism2_ioctl_siwrts, /* SIOCSIWRTS */
  3304. (iw_handler) prism2_ioctl_giwrts, /* SIOCGIWRTS */
  3305. (iw_handler) prism2_ioctl_siwfrag, /* SIOCSIWFRAG */
  3306. (iw_handler) prism2_ioctl_giwfrag, /* SIOCGIWFRAG */
  3307. (iw_handler) prism2_ioctl_siwtxpow, /* SIOCSIWTXPOW */
  3308. (iw_handler) prism2_ioctl_giwtxpow, /* SIOCGIWTXPOW */
  3309. (iw_handler) prism2_ioctl_siwretry, /* SIOCSIWRETRY */
  3310. (iw_handler) prism2_ioctl_giwretry, /* SIOCGIWRETRY */
  3311. (iw_handler) prism2_ioctl_siwencode, /* SIOCSIWENCODE */
  3312. (iw_handler) prism2_ioctl_giwencode, /* SIOCGIWENCODE */
  3313. (iw_handler) prism2_ioctl_siwpower, /* SIOCSIWPOWER */
  3314. (iw_handler) prism2_ioctl_giwpower, /* SIOCGIWPOWER */
  3315. (iw_handler) NULL, /* -- hole -- */
  3316. (iw_handler) NULL, /* -- hole -- */
  3317. (iw_handler) prism2_ioctl_siwgenie, /* SIOCSIWGENIE */
  3318. (iw_handler) prism2_ioctl_giwgenie, /* SIOCGIWGENIE */
  3319. (iw_handler) prism2_ioctl_siwauth, /* SIOCSIWAUTH */
  3320. (iw_handler) prism2_ioctl_giwauth, /* SIOCGIWAUTH */
  3321. (iw_handler) prism2_ioctl_siwencodeext, /* SIOCSIWENCODEEXT */
  3322. (iw_handler) prism2_ioctl_giwencodeext, /* SIOCGIWENCODEEXT */
  3323. (iw_handler) NULL, /* SIOCSIWPMKSA */
  3324. (iw_handler) NULL, /* -- hole -- */
  3325. };
  3326. static const iw_handler prism2_private_handler[] =
  3327. { /* SIOCIWFIRSTPRIV + */
  3328. (iw_handler) prism2_ioctl_priv_prism2_param, /* 0 */
  3329. (iw_handler) prism2_ioctl_priv_get_prism2_param, /* 1 */
  3330. (iw_handler) prism2_ioctl_priv_writemif, /* 2 */
  3331. (iw_handler) prism2_ioctl_priv_readmif, /* 3 */
  3332. };
  3333. const struct iw_handler_def hostap_iw_handler_def =
  3334. {
  3335. .num_standard = ARRAY_SIZE(prism2_handler),
  3336. .num_private = ARRAY_SIZE(prism2_private_handler),
  3337. .num_private_args = ARRAY_SIZE(prism2_priv),
  3338. .standard = (iw_handler *) prism2_handler,
  3339. .private = (iw_handler *) prism2_private_handler,
  3340. .private_args = (struct iw_priv_args *) prism2_priv,
  3341. .get_wireless_stats = hostap_get_wireless_stats,
  3342. };
  3343. int hostap_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
  3344. {
  3345. struct iwreq *wrq = (struct iwreq *) ifr;
  3346. struct hostap_interface *iface;
  3347. local_info_t *local;
  3348. int ret = 0;
  3349. iface = netdev_priv(dev);
  3350. local = iface->local;
  3351. switch (cmd) {
  3352. /* Private ioctls (iwpriv) that have not yet been converted
  3353. * into new wireless extensions API */
  3354. case PRISM2_IOCTL_INQUIRE:
  3355. if (!capable(CAP_NET_ADMIN)) ret = -EPERM;
  3356. else ret = prism2_ioctl_priv_inquire(dev, (int *) wrq->u.name);
  3357. break;
  3358. case PRISM2_IOCTL_MONITOR:
  3359. if (!capable(CAP_NET_ADMIN)) ret = -EPERM;
  3360. else ret = prism2_ioctl_priv_monitor(dev, (int *) wrq->u.name);
  3361. break;
  3362. case PRISM2_IOCTL_RESET:
  3363. if (!capable(CAP_NET_ADMIN)) ret = -EPERM;
  3364. else ret = prism2_ioctl_priv_reset(dev, (int *) wrq->u.name);
  3365. break;
  3366. case PRISM2_IOCTL_WDS_ADD:
  3367. if (!capable(CAP_NET_ADMIN)) ret = -EPERM;
  3368. else ret = prism2_wds_add(local, wrq->u.ap_addr.sa_data, 1);
  3369. break;
  3370. case PRISM2_IOCTL_WDS_DEL:
  3371. if (!capable(CAP_NET_ADMIN)) ret = -EPERM;
  3372. else ret = prism2_wds_del(local, wrq->u.ap_addr.sa_data, 1, 0);
  3373. break;
  3374. case PRISM2_IOCTL_SET_RID_WORD:
  3375. if (!capable(CAP_NET_ADMIN)) ret = -EPERM;
  3376. else ret = prism2_ioctl_priv_set_rid_word(dev,
  3377. (int *) wrq->u.name);
  3378. break;
  3379. #ifndef PRISM2_NO_KERNEL_IEEE80211_MGMT
  3380. case PRISM2_IOCTL_MACCMD:
  3381. if (!capable(CAP_NET_ADMIN)) ret = -EPERM;
  3382. else ret = ap_mac_cmd_ioctl(local, (int *) wrq->u.name);
  3383. break;
  3384. case PRISM2_IOCTL_ADDMAC:
  3385. if (!capable(CAP_NET_ADMIN)) ret = -EPERM;
  3386. else ret = ap_control_add_mac(&local->ap->mac_restrictions,
  3387. wrq->u.ap_addr.sa_data);
  3388. break;
  3389. case PRISM2_IOCTL_DELMAC:
  3390. if (!capable(CAP_NET_ADMIN)) ret = -EPERM;
  3391. else ret = ap_control_del_mac(&local->ap->mac_restrictions,
  3392. wrq->u.ap_addr.sa_data);
  3393. break;
  3394. case PRISM2_IOCTL_KICKMAC:
  3395. if (!capable(CAP_NET_ADMIN)) ret = -EPERM;
  3396. else ret = ap_control_kick_mac(local->ap, local->dev,
  3397. wrq->u.ap_addr.sa_data);
  3398. break;
  3399. #endif /* PRISM2_NO_KERNEL_IEEE80211_MGMT */
  3400. /* Private ioctls that are not used with iwpriv;
  3401. * in SIOCDEVPRIVATE range */
  3402. #ifdef PRISM2_DOWNLOAD_SUPPORT
  3403. case PRISM2_IOCTL_DOWNLOAD:
  3404. if (!capable(CAP_NET_ADMIN)) ret = -EPERM;
  3405. else ret = prism2_ioctl_priv_download(local, &wrq->u.data);
  3406. break;
  3407. #endif /* PRISM2_DOWNLOAD_SUPPORT */
  3408. case PRISM2_IOCTL_HOSTAPD:
  3409. if (!capable(CAP_NET_ADMIN)) ret = -EPERM;
  3410. else ret = prism2_ioctl_priv_hostapd(local, &wrq->u.data);
  3411. break;
  3412. default:
  3413. ret = -EOPNOTSUPP;
  3414. break;
  3415. }
  3416. return ret;
  3417. }