main.c 50 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864
  1. /*
  2. * Copyright 2002-2005, Instant802 Networks, Inc.
  3. * Copyright 2005-2006, Devicescape Software, Inc.
  4. * Copyright 2006-2007 Jiri Benc <jbenc@suse.cz>
  5. *
  6. * This program is free software; you can redistribute it and/or modify
  7. * it under the terms of the GNU General Public License version 2 as
  8. * published by the Free Software Foundation.
  9. */
  10. #include <net/mac80211.h>
  11. #include <net/ieee80211_radiotap.h>
  12. #include <linux/module.h>
  13. #include <linux/init.h>
  14. #include <linux/netdevice.h>
  15. #include <linux/types.h>
  16. #include <linux/slab.h>
  17. #include <linux/skbuff.h>
  18. #include <linux/etherdevice.h>
  19. #include <linux/if_arp.h>
  20. #include <linux/wireless.h>
  21. #include <linux/rtnetlink.h>
  22. #include <linux/bitmap.h>
  23. #include <net/net_namespace.h>
  24. #include <net/cfg80211.h>
  25. #include "ieee80211_i.h"
  26. #include "rate.h"
  27. #include "mesh.h"
  28. #include "wep.h"
  29. #include "wme.h"
  30. #include "aes_ccm.h"
  31. #include "led.h"
  32. #include "cfg.h"
  33. #include "debugfs.h"
  34. #include "debugfs_netdev.h"
  35. /*
  36. * For seeing transmitted packets on monitor interfaces
  37. * we have a radiotap header too.
  38. */
  39. struct ieee80211_tx_status_rtap_hdr {
  40. struct ieee80211_radiotap_header hdr;
  41. __le16 tx_flags;
  42. u8 data_retries;
  43. } __attribute__ ((packed));
  44. /* common interface routines */
  45. static int header_parse_80211(const struct sk_buff *skb, unsigned char *haddr)
  46. {
  47. memcpy(haddr, skb_mac_header(skb) + 10, ETH_ALEN); /* addr2 */
  48. return ETH_ALEN;
  49. }
  50. /* must be called under mdev tx lock */
  51. static void ieee80211_configure_filter(struct ieee80211_local *local)
  52. {
  53. unsigned int changed_flags;
  54. unsigned int new_flags = 0;
  55. if (atomic_read(&local->iff_promiscs))
  56. new_flags |= FIF_PROMISC_IN_BSS;
  57. if (atomic_read(&local->iff_allmultis))
  58. new_flags |= FIF_ALLMULTI;
  59. if (local->monitors)
  60. new_flags |= FIF_BCN_PRBRESP_PROMISC;
  61. if (local->fif_fcsfail)
  62. new_flags |= FIF_FCSFAIL;
  63. if (local->fif_plcpfail)
  64. new_flags |= FIF_PLCPFAIL;
  65. if (local->fif_control)
  66. new_flags |= FIF_CONTROL;
  67. if (local->fif_other_bss)
  68. new_flags |= FIF_OTHER_BSS;
  69. changed_flags = local->filter_flags ^ new_flags;
  70. /* be a bit nasty */
  71. new_flags |= (1<<31);
  72. local->ops->configure_filter(local_to_hw(local),
  73. changed_flags, &new_flags,
  74. local->mdev->mc_count,
  75. local->mdev->mc_list);
  76. WARN_ON(new_flags & (1<<31));
  77. local->filter_flags = new_flags & ~(1<<31);
  78. }
  79. /* master interface */
  80. static int ieee80211_master_open(struct net_device *dev)
  81. {
  82. struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
  83. struct ieee80211_sub_if_data *sdata;
  84. int res = -EOPNOTSUPP;
  85. /* we hold the RTNL here so can safely walk the list */
  86. list_for_each_entry(sdata, &local->interfaces, list) {
  87. if (netif_running(sdata->dev)) {
  88. res = 0;
  89. break;
  90. }
  91. }
  92. if (res)
  93. return res;
  94. netif_tx_start_all_queues(local->mdev);
  95. return 0;
  96. }
  97. static int ieee80211_master_stop(struct net_device *dev)
  98. {
  99. struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
  100. struct ieee80211_sub_if_data *sdata;
  101. /* we hold the RTNL here so can safely walk the list */
  102. list_for_each_entry(sdata, &local->interfaces, list)
  103. if (netif_running(sdata->dev))
  104. dev_close(sdata->dev);
  105. return 0;
  106. }
  107. static void ieee80211_master_set_multicast_list(struct net_device *dev)
  108. {
  109. struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
  110. ieee80211_configure_filter(local);
  111. }
  112. /* regular interfaces */
  113. static int ieee80211_change_mtu(struct net_device *dev, int new_mtu)
  114. {
  115. int meshhdrlen;
  116. struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
  117. meshhdrlen = (sdata->vif.type == IEEE80211_IF_TYPE_MESH_POINT) ? 5 : 0;
  118. /* FIX: what would be proper limits for MTU?
  119. * This interface uses 802.3 frames. */
  120. if (new_mtu < 256 ||
  121. new_mtu > IEEE80211_MAX_DATA_LEN - 24 - 6 - meshhdrlen) {
  122. return -EINVAL;
  123. }
  124. #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
  125. printk(KERN_DEBUG "%s: setting MTU %d\n", dev->name, new_mtu);
  126. #endif /* CONFIG_MAC80211_VERBOSE_DEBUG */
  127. dev->mtu = new_mtu;
  128. return 0;
  129. }
  130. static inline int identical_mac_addr_allowed(int type1, int type2)
  131. {
  132. return (type1 == IEEE80211_IF_TYPE_MNTR ||
  133. type2 == IEEE80211_IF_TYPE_MNTR ||
  134. (type1 == IEEE80211_IF_TYPE_AP &&
  135. type2 == IEEE80211_IF_TYPE_WDS) ||
  136. (type1 == IEEE80211_IF_TYPE_WDS &&
  137. (type2 == IEEE80211_IF_TYPE_WDS ||
  138. type2 == IEEE80211_IF_TYPE_AP)) ||
  139. (type1 == IEEE80211_IF_TYPE_AP &&
  140. type2 == IEEE80211_IF_TYPE_VLAN) ||
  141. (type1 == IEEE80211_IF_TYPE_VLAN &&
  142. (type2 == IEEE80211_IF_TYPE_AP ||
  143. type2 == IEEE80211_IF_TYPE_VLAN)));
  144. }
  145. static int ieee80211_open(struct net_device *dev)
  146. {
  147. struct ieee80211_sub_if_data *sdata, *nsdata;
  148. struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
  149. struct sta_info *sta;
  150. struct ieee80211_if_init_conf conf;
  151. u32 changed = 0;
  152. int res;
  153. bool need_hw_reconfig = 0;
  154. sdata = IEEE80211_DEV_TO_SUB_IF(dev);
  155. /* we hold the RTNL here so can safely walk the list */
  156. list_for_each_entry(nsdata, &local->interfaces, list) {
  157. struct net_device *ndev = nsdata->dev;
  158. if (ndev != dev && netif_running(ndev)) {
  159. /*
  160. * Allow only a single IBSS interface to be up at any
  161. * time. This is restricted because beacon distribution
  162. * cannot work properly if both are in the same IBSS.
  163. *
  164. * To remove this restriction we'd have to disallow them
  165. * from setting the same SSID on different IBSS interfaces
  166. * belonging to the same hardware. Then, however, we're
  167. * faced with having to adopt two different TSF timers...
  168. */
  169. if (sdata->vif.type == IEEE80211_IF_TYPE_IBSS &&
  170. nsdata->vif.type == IEEE80211_IF_TYPE_IBSS)
  171. return -EBUSY;
  172. /*
  173. * The remaining checks are only performed for interfaces
  174. * with the same MAC address.
  175. */
  176. if (compare_ether_addr(dev->dev_addr, ndev->dev_addr))
  177. continue;
  178. /*
  179. * check whether it may have the same address
  180. */
  181. if (!identical_mac_addr_allowed(sdata->vif.type,
  182. nsdata->vif.type))
  183. return -ENOTUNIQ;
  184. /*
  185. * can only add VLANs to enabled APs
  186. */
  187. if (sdata->vif.type == IEEE80211_IF_TYPE_VLAN &&
  188. nsdata->vif.type == IEEE80211_IF_TYPE_AP)
  189. sdata->bss = &nsdata->u.ap;
  190. }
  191. }
  192. switch (sdata->vif.type) {
  193. case IEEE80211_IF_TYPE_WDS:
  194. if (!is_valid_ether_addr(sdata->u.wds.remote_addr))
  195. return -ENOLINK;
  196. break;
  197. case IEEE80211_IF_TYPE_VLAN:
  198. if (!sdata->bss)
  199. return -ENOLINK;
  200. list_add(&sdata->u.vlan.list, &sdata->bss->vlans);
  201. break;
  202. case IEEE80211_IF_TYPE_AP:
  203. sdata->bss = &sdata->u.ap;
  204. break;
  205. case IEEE80211_IF_TYPE_STA:
  206. case IEEE80211_IF_TYPE_MNTR:
  207. case IEEE80211_IF_TYPE_IBSS:
  208. case IEEE80211_IF_TYPE_MESH_POINT:
  209. /* no special treatment */
  210. break;
  211. case IEEE80211_IF_TYPE_INVALID:
  212. /* cannot happen */
  213. WARN_ON(1);
  214. break;
  215. }
  216. if (local->open_count == 0) {
  217. res = 0;
  218. if (local->ops->start)
  219. res = local->ops->start(local_to_hw(local));
  220. if (res)
  221. goto err_del_bss;
  222. need_hw_reconfig = 1;
  223. ieee80211_led_radio(local, local->hw.conf.radio_enabled);
  224. }
  225. switch (sdata->vif.type) {
  226. case IEEE80211_IF_TYPE_VLAN:
  227. /* no need to tell driver */
  228. break;
  229. case IEEE80211_IF_TYPE_MNTR:
  230. if (sdata->u.mntr_flags & MONITOR_FLAG_COOK_FRAMES) {
  231. local->cooked_mntrs++;
  232. break;
  233. }
  234. /* must be before the call to ieee80211_configure_filter */
  235. local->monitors++;
  236. if (local->monitors == 1)
  237. local->hw.conf.flags |= IEEE80211_CONF_RADIOTAP;
  238. if (sdata->u.mntr_flags & MONITOR_FLAG_FCSFAIL)
  239. local->fif_fcsfail++;
  240. if (sdata->u.mntr_flags & MONITOR_FLAG_PLCPFAIL)
  241. local->fif_plcpfail++;
  242. if (sdata->u.mntr_flags & MONITOR_FLAG_CONTROL)
  243. local->fif_control++;
  244. if (sdata->u.mntr_flags & MONITOR_FLAG_OTHER_BSS)
  245. local->fif_other_bss++;
  246. netif_addr_lock_bh(local->mdev);
  247. ieee80211_configure_filter(local);
  248. netif_addr_unlock_bh(local->mdev);
  249. break;
  250. case IEEE80211_IF_TYPE_STA:
  251. case IEEE80211_IF_TYPE_IBSS:
  252. sdata->u.sta.flags &= ~IEEE80211_STA_PREV_BSSID_SET;
  253. /* fall through */
  254. default:
  255. conf.vif = &sdata->vif;
  256. conf.type = sdata->vif.type;
  257. conf.mac_addr = dev->dev_addr;
  258. res = local->ops->add_interface(local_to_hw(local), &conf);
  259. if (res)
  260. goto err_stop;
  261. if (ieee80211_vif_is_mesh(&sdata->vif))
  262. ieee80211_start_mesh(sdata->dev);
  263. changed |= ieee80211_reset_erp_info(dev);
  264. ieee80211_bss_info_change_notify(sdata, changed);
  265. ieee80211_enable_keys(sdata);
  266. if (sdata->vif.type == IEEE80211_IF_TYPE_STA &&
  267. !(sdata->flags & IEEE80211_SDATA_USERSPACE_MLME))
  268. netif_carrier_off(dev);
  269. else
  270. netif_carrier_on(dev);
  271. }
  272. if (sdata->vif.type == IEEE80211_IF_TYPE_WDS) {
  273. /* Create STA entry for the WDS peer */
  274. sta = sta_info_alloc(sdata, sdata->u.wds.remote_addr,
  275. GFP_KERNEL);
  276. if (!sta) {
  277. res = -ENOMEM;
  278. goto err_del_interface;
  279. }
  280. /* no locking required since STA is not live yet */
  281. sta->flags |= WLAN_STA_AUTHORIZED;
  282. res = sta_info_insert(sta);
  283. if (res) {
  284. /* STA has been freed */
  285. goto err_del_interface;
  286. }
  287. }
  288. if (local->open_count == 0) {
  289. res = dev_open(local->mdev);
  290. WARN_ON(res);
  291. if (res)
  292. goto err_del_interface;
  293. tasklet_enable(&local->tx_pending_tasklet);
  294. tasklet_enable(&local->tasklet);
  295. }
  296. /*
  297. * set_multicast_list will be invoked by the networking core
  298. * which will check whether any increments here were done in
  299. * error and sync them down to the hardware as filter flags.
  300. */
  301. if (sdata->flags & IEEE80211_SDATA_ALLMULTI)
  302. atomic_inc(&local->iff_allmultis);
  303. if (sdata->flags & IEEE80211_SDATA_PROMISC)
  304. atomic_inc(&local->iff_promiscs);
  305. local->open_count++;
  306. if (need_hw_reconfig)
  307. ieee80211_hw_config(local);
  308. /*
  309. * ieee80211_sta_work is disabled while network interface
  310. * is down. Therefore, some configuration changes may not
  311. * yet be effective. Trigger execution of ieee80211_sta_work
  312. * to fix this.
  313. */
  314. if (sdata->vif.type == IEEE80211_IF_TYPE_STA ||
  315. sdata->vif.type == IEEE80211_IF_TYPE_IBSS) {
  316. struct ieee80211_if_sta *ifsta = &sdata->u.sta;
  317. queue_work(local->hw.workqueue, &ifsta->work);
  318. }
  319. netif_tx_start_all_queues(dev);
  320. return 0;
  321. err_del_interface:
  322. local->ops->remove_interface(local_to_hw(local), &conf);
  323. err_stop:
  324. if (!local->open_count && local->ops->stop)
  325. local->ops->stop(local_to_hw(local));
  326. err_del_bss:
  327. sdata->bss = NULL;
  328. if (sdata->vif.type == IEEE80211_IF_TYPE_VLAN)
  329. list_del(&sdata->u.vlan.list);
  330. return res;
  331. }
  332. static int ieee80211_stop(struct net_device *dev)
  333. {
  334. struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
  335. struct ieee80211_local *local = sdata->local;
  336. struct ieee80211_if_init_conf conf;
  337. struct sta_info *sta;
  338. /*
  339. * Stop TX on this interface first.
  340. */
  341. netif_tx_stop_all_queues(dev);
  342. /*
  343. * Now delete all active aggregation sessions.
  344. */
  345. rcu_read_lock();
  346. list_for_each_entry_rcu(sta, &local->sta_list, list) {
  347. if (sta->sdata == sdata)
  348. ieee80211_sta_tear_down_BA_sessions(dev, sta->addr);
  349. }
  350. rcu_read_unlock();
  351. /*
  352. * Remove all stations associated with this interface.
  353. *
  354. * This must be done before calling ops->remove_interface()
  355. * because otherwise we can later invoke ops->sta_notify()
  356. * whenever the STAs are removed, and that invalidates driver
  357. * assumptions about always getting a vif pointer that is valid
  358. * (because if we remove a STA after ops->remove_interface()
  359. * the driver will have removed the vif info already!)
  360. *
  361. * We could relax this and only unlink the stations from the
  362. * hash table and list but keep them on a per-sdata list that
  363. * will be inserted back again when the interface is brought
  364. * up again, but I don't currently see a use case for that,
  365. * except with WDS which gets a STA entry created when it is
  366. * brought up.
  367. */
  368. sta_info_flush(local, sdata);
  369. /*
  370. * Don't count this interface for promisc/allmulti while it
  371. * is down. dev_mc_unsync() will invoke set_multicast_list
  372. * on the master interface which will sync these down to the
  373. * hardware as filter flags.
  374. */
  375. if (sdata->flags & IEEE80211_SDATA_ALLMULTI)
  376. atomic_dec(&local->iff_allmultis);
  377. if (sdata->flags & IEEE80211_SDATA_PROMISC)
  378. atomic_dec(&local->iff_promiscs);
  379. dev_mc_unsync(local->mdev, dev);
  380. /* APs need special treatment */
  381. if (sdata->vif.type == IEEE80211_IF_TYPE_AP) {
  382. struct ieee80211_sub_if_data *vlan, *tmp;
  383. struct beacon_data *old_beacon = sdata->u.ap.beacon;
  384. /* remove beacon */
  385. rcu_assign_pointer(sdata->u.ap.beacon, NULL);
  386. synchronize_rcu();
  387. kfree(old_beacon);
  388. /* down all dependent devices, that is VLANs */
  389. list_for_each_entry_safe(vlan, tmp, &sdata->u.ap.vlans,
  390. u.vlan.list)
  391. dev_close(vlan->dev);
  392. WARN_ON(!list_empty(&sdata->u.ap.vlans));
  393. }
  394. local->open_count--;
  395. switch (sdata->vif.type) {
  396. case IEEE80211_IF_TYPE_VLAN:
  397. list_del(&sdata->u.vlan.list);
  398. /* no need to tell driver */
  399. break;
  400. case IEEE80211_IF_TYPE_MNTR:
  401. if (sdata->u.mntr_flags & MONITOR_FLAG_COOK_FRAMES) {
  402. local->cooked_mntrs--;
  403. break;
  404. }
  405. local->monitors--;
  406. if (local->monitors == 0)
  407. local->hw.conf.flags &= ~IEEE80211_CONF_RADIOTAP;
  408. if (sdata->u.mntr_flags & MONITOR_FLAG_FCSFAIL)
  409. local->fif_fcsfail--;
  410. if (sdata->u.mntr_flags & MONITOR_FLAG_PLCPFAIL)
  411. local->fif_plcpfail--;
  412. if (sdata->u.mntr_flags & MONITOR_FLAG_CONTROL)
  413. local->fif_control--;
  414. if (sdata->u.mntr_flags & MONITOR_FLAG_OTHER_BSS)
  415. local->fif_other_bss--;
  416. netif_addr_lock_bh(local->mdev);
  417. ieee80211_configure_filter(local);
  418. netif_addr_unlock_bh(local->mdev);
  419. break;
  420. case IEEE80211_IF_TYPE_MESH_POINT:
  421. case IEEE80211_IF_TYPE_STA:
  422. case IEEE80211_IF_TYPE_IBSS:
  423. sdata->u.sta.state = IEEE80211_DISABLED;
  424. memset(sdata->u.sta.bssid, 0, ETH_ALEN);
  425. del_timer_sync(&sdata->u.sta.timer);
  426. /*
  427. * When we get here, the interface is marked down.
  428. * Call synchronize_rcu() to wait for the RX path
  429. * should it be using the interface and enqueuing
  430. * frames at this very time on another CPU.
  431. */
  432. synchronize_rcu();
  433. skb_queue_purge(&sdata->u.sta.skb_queue);
  434. if (local->scan_dev == sdata->dev) {
  435. if (!local->ops->hw_scan) {
  436. local->sta_sw_scanning = 0;
  437. cancel_delayed_work(&local->scan_work);
  438. } else
  439. local->sta_hw_scanning = 0;
  440. }
  441. sdata->u.sta.flags &= ~IEEE80211_STA_PRIVACY_INVOKED;
  442. kfree(sdata->u.sta.extra_ie);
  443. sdata->u.sta.extra_ie = NULL;
  444. sdata->u.sta.extra_ie_len = 0;
  445. /* fall through */
  446. default:
  447. conf.vif = &sdata->vif;
  448. conf.type = sdata->vif.type;
  449. conf.mac_addr = dev->dev_addr;
  450. /* disable all keys for as long as this netdev is down */
  451. ieee80211_disable_keys(sdata);
  452. local->ops->remove_interface(local_to_hw(local), &conf);
  453. }
  454. sdata->bss = NULL;
  455. if (local->open_count == 0) {
  456. if (netif_running(local->mdev))
  457. dev_close(local->mdev);
  458. if (local->ops->stop)
  459. local->ops->stop(local_to_hw(local));
  460. ieee80211_led_radio(local, 0);
  461. flush_workqueue(local->hw.workqueue);
  462. tasklet_disable(&local->tx_pending_tasklet);
  463. tasklet_disable(&local->tasklet);
  464. }
  465. return 0;
  466. }
  467. int ieee80211_start_tx_ba_session(struct ieee80211_hw *hw, u8 *ra, u16 tid)
  468. {
  469. struct ieee80211_local *local = hw_to_local(hw);
  470. struct sta_info *sta;
  471. struct ieee80211_sub_if_data *sdata;
  472. u16 start_seq_num = 0;
  473. u8 *state;
  474. int ret;
  475. DECLARE_MAC_BUF(mac);
  476. if (tid >= STA_TID_NUM)
  477. return -EINVAL;
  478. #ifdef CONFIG_MAC80211_HT_DEBUG
  479. printk(KERN_DEBUG "Open BA session requested for %s tid %u\n",
  480. print_mac(mac, ra), tid);
  481. #endif /* CONFIG_MAC80211_HT_DEBUG */
  482. rcu_read_lock();
  483. sta = sta_info_get(local, ra);
  484. if (!sta) {
  485. #ifdef CONFIG_MAC80211_HT_DEBUG
  486. printk(KERN_DEBUG "Could not find the station\n");
  487. #endif
  488. ret = -ENOENT;
  489. goto exit;
  490. }
  491. spin_lock_bh(&sta->lock);
  492. /* we have tried too many times, receiver does not want A-MPDU */
  493. if (sta->ampdu_mlme.addba_req_num[tid] > HT_AGG_MAX_RETRIES) {
  494. ret = -EBUSY;
  495. goto err_unlock_sta;
  496. }
  497. state = &sta->ampdu_mlme.tid_state_tx[tid];
  498. /* check if the TID is not in aggregation flow already */
  499. if (*state != HT_AGG_STATE_IDLE) {
  500. #ifdef CONFIG_MAC80211_HT_DEBUG
  501. printk(KERN_DEBUG "BA request denied - session is not "
  502. "idle on tid %u\n", tid);
  503. #endif /* CONFIG_MAC80211_HT_DEBUG */
  504. ret = -EAGAIN;
  505. goto err_unlock_sta;
  506. }
  507. /* prepare A-MPDU MLME for Tx aggregation */
  508. sta->ampdu_mlme.tid_tx[tid] =
  509. kmalloc(sizeof(struct tid_ampdu_tx), GFP_ATOMIC);
  510. if (!sta->ampdu_mlme.tid_tx[tid]) {
  511. #ifdef CONFIG_MAC80211_HT_DEBUG
  512. if (net_ratelimit())
  513. printk(KERN_ERR "allocate tx mlme to tid %d failed\n",
  514. tid);
  515. #endif
  516. ret = -ENOMEM;
  517. goto err_unlock_sta;
  518. }
  519. /* Tx timer */
  520. sta->ampdu_mlme.tid_tx[tid]->addba_resp_timer.function =
  521. sta_addba_resp_timer_expired;
  522. sta->ampdu_mlme.tid_tx[tid]->addba_resp_timer.data =
  523. (unsigned long)&sta->timer_to_tid[tid];
  524. init_timer(&sta->ampdu_mlme.tid_tx[tid]->addba_resp_timer);
  525. /* create a new queue for this aggregation */
  526. ret = ieee80211_ht_agg_queue_add(local, sta, tid);
  527. /* case no queue is available to aggregation
  528. * don't switch to aggregation */
  529. if (ret) {
  530. #ifdef CONFIG_MAC80211_HT_DEBUG
  531. printk(KERN_DEBUG "BA request denied - queue unavailable for"
  532. " tid %d\n", tid);
  533. #endif /* CONFIG_MAC80211_HT_DEBUG */
  534. goto err_unlock_queue;
  535. }
  536. sdata = sta->sdata;
  537. /* Ok, the Addba frame hasn't been sent yet, but if the driver calls the
  538. * call back right away, it must see that the flow has begun */
  539. *state |= HT_ADDBA_REQUESTED_MSK;
  540. if (local->ops->ampdu_action)
  541. ret = local->ops->ampdu_action(hw, IEEE80211_AMPDU_TX_START,
  542. ra, tid, &start_seq_num);
  543. if (ret) {
  544. /* No need to requeue the packets in the agg queue, since we
  545. * held the tx lock: no packet could be enqueued to the newly
  546. * allocated queue */
  547. ieee80211_ht_agg_queue_remove(local, sta, tid, 0);
  548. #ifdef CONFIG_MAC80211_HT_DEBUG
  549. printk(KERN_DEBUG "BA request denied - HW unavailable for"
  550. " tid %d\n", tid);
  551. #endif /* CONFIG_MAC80211_HT_DEBUG */
  552. *state = HT_AGG_STATE_IDLE;
  553. goto err_unlock_queue;
  554. }
  555. /* Will put all the packets in the new SW queue */
  556. ieee80211_requeue(local, ieee802_1d_to_ac[tid]);
  557. spin_unlock_bh(&sta->lock);
  558. /* send an addBA request */
  559. sta->ampdu_mlme.dialog_token_allocator++;
  560. sta->ampdu_mlme.tid_tx[tid]->dialog_token =
  561. sta->ampdu_mlme.dialog_token_allocator;
  562. sta->ampdu_mlme.tid_tx[tid]->ssn = start_seq_num;
  563. ieee80211_send_addba_request(sta->sdata->dev, ra, tid,
  564. sta->ampdu_mlme.tid_tx[tid]->dialog_token,
  565. sta->ampdu_mlme.tid_tx[tid]->ssn,
  566. 0x40, 5000);
  567. /* activate the timer for the recipient's addBA response */
  568. sta->ampdu_mlme.tid_tx[tid]->addba_resp_timer.expires =
  569. jiffies + ADDBA_RESP_INTERVAL;
  570. add_timer(&sta->ampdu_mlme.tid_tx[tid]->addba_resp_timer);
  571. #ifdef CONFIG_MAC80211_HT_DEBUG
  572. printk(KERN_DEBUG "activated addBA response timer on tid %d\n", tid);
  573. #endif
  574. goto exit;
  575. err_unlock_queue:
  576. kfree(sta->ampdu_mlme.tid_tx[tid]);
  577. sta->ampdu_mlme.tid_tx[tid] = NULL;
  578. ret = -EBUSY;
  579. err_unlock_sta:
  580. spin_unlock_bh(&sta->lock);
  581. exit:
  582. rcu_read_unlock();
  583. return ret;
  584. }
  585. EXPORT_SYMBOL(ieee80211_start_tx_ba_session);
  586. int ieee80211_stop_tx_ba_session(struct ieee80211_hw *hw,
  587. u8 *ra, u16 tid,
  588. enum ieee80211_back_parties initiator)
  589. {
  590. struct ieee80211_local *local = hw_to_local(hw);
  591. struct sta_info *sta;
  592. u8 *state;
  593. int ret = 0;
  594. DECLARE_MAC_BUF(mac);
  595. if (tid >= STA_TID_NUM)
  596. return -EINVAL;
  597. rcu_read_lock();
  598. sta = sta_info_get(local, ra);
  599. if (!sta) {
  600. rcu_read_unlock();
  601. return -ENOENT;
  602. }
  603. /* check if the TID is in aggregation */
  604. state = &sta->ampdu_mlme.tid_state_tx[tid];
  605. spin_lock_bh(&sta->lock);
  606. if (*state != HT_AGG_STATE_OPERATIONAL) {
  607. ret = -ENOENT;
  608. goto stop_BA_exit;
  609. }
  610. #ifdef CONFIG_MAC80211_HT_DEBUG
  611. printk(KERN_DEBUG "Tx BA session stop requested for %s tid %u\n",
  612. print_mac(mac, ra), tid);
  613. #endif /* CONFIG_MAC80211_HT_DEBUG */
  614. ieee80211_stop_queue(hw, sta->tid_to_tx_q[tid]);
  615. *state = HT_AGG_STATE_REQ_STOP_BA_MSK |
  616. (initiator << HT_AGG_STATE_INITIATOR_SHIFT);
  617. if (local->ops->ampdu_action)
  618. ret = local->ops->ampdu_action(hw, IEEE80211_AMPDU_TX_STOP,
  619. ra, tid, NULL);
  620. /* case HW denied going back to legacy */
  621. if (ret) {
  622. WARN_ON(ret != -EBUSY);
  623. *state = HT_AGG_STATE_OPERATIONAL;
  624. ieee80211_wake_queue(hw, sta->tid_to_tx_q[tid]);
  625. goto stop_BA_exit;
  626. }
  627. stop_BA_exit:
  628. spin_unlock_bh(&sta->lock);
  629. rcu_read_unlock();
  630. return ret;
  631. }
  632. EXPORT_SYMBOL(ieee80211_stop_tx_ba_session);
  633. void ieee80211_start_tx_ba_cb(struct ieee80211_hw *hw, u8 *ra, u16 tid)
  634. {
  635. struct ieee80211_local *local = hw_to_local(hw);
  636. struct sta_info *sta;
  637. u8 *state;
  638. DECLARE_MAC_BUF(mac);
  639. if (tid >= STA_TID_NUM) {
  640. #ifdef CONFIG_MAC80211_HT_DEBUG
  641. printk(KERN_DEBUG "Bad TID value: tid = %d (>= %d)\n",
  642. tid, STA_TID_NUM);
  643. #endif
  644. return;
  645. }
  646. rcu_read_lock();
  647. sta = sta_info_get(local, ra);
  648. if (!sta) {
  649. rcu_read_unlock();
  650. #ifdef CONFIG_MAC80211_HT_DEBUG
  651. printk(KERN_DEBUG "Could not find station: %s\n",
  652. print_mac(mac, ra));
  653. #endif
  654. return;
  655. }
  656. state = &sta->ampdu_mlme.tid_state_tx[tid];
  657. spin_lock_bh(&sta->lock);
  658. if (!(*state & HT_ADDBA_REQUESTED_MSK)) {
  659. #ifdef CONFIG_MAC80211_HT_DEBUG
  660. printk(KERN_DEBUG "addBA was not requested yet, state is %d\n",
  661. *state);
  662. #endif
  663. spin_unlock_bh(&sta->lock);
  664. rcu_read_unlock();
  665. return;
  666. }
  667. WARN_ON_ONCE(*state & HT_ADDBA_DRV_READY_MSK);
  668. *state |= HT_ADDBA_DRV_READY_MSK;
  669. if (*state == HT_AGG_STATE_OPERATIONAL) {
  670. #ifdef CONFIG_MAC80211_HT_DEBUG
  671. printk(KERN_DEBUG "Aggregation is on for tid %d \n", tid);
  672. #endif
  673. ieee80211_wake_queue(hw, sta->tid_to_tx_q[tid]);
  674. }
  675. spin_unlock_bh(&sta->lock);
  676. rcu_read_unlock();
  677. }
  678. EXPORT_SYMBOL(ieee80211_start_tx_ba_cb);
  679. void ieee80211_stop_tx_ba_cb(struct ieee80211_hw *hw, u8 *ra, u8 tid)
  680. {
  681. struct ieee80211_local *local = hw_to_local(hw);
  682. struct sta_info *sta;
  683. u8 *state;
  684. int agg_queue;
  685. DECLARE_MAC_BUF(mac);
  686. if (tid >= STA_TID_NUM) {
  687. #ifdef CONFIG_MAC80211_HT_DEBUG
  688. printk(KERN_DEBUG "Bad TID value: tid = %d (>= %d)\n",
  689. tid, STA_TID_NUM);
  690. #endif
  691. return;
  692. }
  693. #ifdef CONFIG_MAC80211_HT_DEBUG
  694. printk(KERN_DEBUG "Stopping Tx BA session for %s tid %d\n",
  695. print_mac(mac, ra), tid);
  696. #endif /* CONFIG_MAC80211_HT_DEBUG */
  697. rcu_read_lock();
  698. sta = sta_info_get(local, ra);
  699. if (!sta) {
  700. #ifdef CONFIG_MAC80211_HT_DEBUG
  701. printk(KERN_DEBUG "Could not find station: %s\n",
  702. print_mac(mac, ra));
  703. #endif
  704. rcu_read_unlock();
  705. return;
  706. }
  707. state = &sta->ampdu_mlme.tid_state_tx[tid];
  708. /* NOTE: no need to use sta->lock in this state check, as
  709. * ieee80211_stop_tx_ba_session will let only one stop call to
  710. * pass through per sta/tid
  711. */
  712. if ((*state & HT_AGG_STATE_REQ_STOP_BA_MSK) == 0) {
  713. #ifdef CONFIG_MAC80211_HT_DEBUG
  714. printk(KERN_DEBUG "unexpected callback to A-MPDU stop\n");
  715. #endif
  716. rcu_read_unlock();
  717. return;
  718. }
  719. if (*state & HT_AGG_STATE_INITIATOR_MSK)
  720. ieee80211_send_delba(sta->sdata->dev, ra, tid,
  721. WLAN_BACK_INITIATOR, WLAN_REASON_QSTA_NOT_USE);
  722. agg_queue = sta->tid_to_tx_q[tid];
  723. ieee80211_ht_agg_queue_remove(local, sta, tid, 1);
  724. /* We just requeued the all the frames that were in the
  725. * removed queue, and since we might miss a softirq we do
  726. * netif_schedule_queue. ieee80211_wake_queue is not used
  727. * here as this queue is not necessarily stopped
  728. */
  729. netif_schedule_queue(netdev_get_tx_queue(local->mdev, agg_queue));
  730. spin_lock_bh(&sta->lock);
  731. *state = HT_AGG_STATE_IDLE;
  732. sta->ampdu_mlme.addba_req_num[tid] = 0;
  733. kfree(sta->ampdu_mlme.tid_tx[tid]);
  734. sta->ampdu_mlme.tid_tx[tid] = NULL;
  735. spin_unlock_bh(&sta->lock);
  736. rcu_read_unlock();
  737. }
  738. EXPORT_SYMBOL(ieee80211_stop_tx_ba_cb);
  739. void ieee80211_start_tx_ba_cb_irqsafe(struct ieee80211_hw *hw,
  740. const u8 *ra, u16 tid)
  741. {
  742. struct ieee80211_local *local = hw_to_local(hw);
  743. struct ieee80211_ra_tid *ra_tid;
  744. struct sk_buff *skb = dev_alloc_skb(0);
  745. if (unlikely(!skb)) {
  746. #ifdef CONFIG_MAC80211_HT_DEBUG
  747. if (net_ratelimit())
  748. printk(KERN_WARNING "%s: Not enough memory, "
  749. "dropping start BA session", skb->dev->name);
  750. #endif
  751. return;
  752. }
  753. ra_tid = (struct ieee80211_ra_tid *) &skb->cb;
  754. memcpy(&ra_tid->ra, ra, ETH_ALEN);
  755. ra_tid->tid = tid;
  756. skb->pkt_type = IEEE80211_ADDBA_MSG;
  757. skb_queue_tail(&local->skb_queue, skb);
  758. tasklet_schedule(&local->tasklet);
  759. }
  760. EXPORT_SYMBOL(ieee80211_start_tx_ba_cb_irqsafe);
  761. void ieee80211_stop_tx_ba_cb_irqsafe(struct ieee80211_hw *hw,
  762. const u8 *ra, u16 tid)
  763. {
  764. struct ieee80211_local *local = hw_to_local(hw);
  765. struct ieee80211_ra_tid *ra_tid;
  766. struct sk_buff *skb = dev_alloc_skb(0);
  767. if (unlikely(!skb)) {
  768. #ifdef CONFIG_MAC80211_HT_DEBUG
  769. if (net_ratelimit())
  770. printk(KERN_WARNING "%s: Not enough memory, "
  771. "dropping stop BA session", skb->dev->name);
  772. #endif
  773. return;
  774. }
  775. ra_tid = (struct ieee80211_ra_tid *) &skb->cb;
  776. memcpy(&ra_tid->ra, ra, ETH_ALEN);
  777. ra_tid->tid = tid;
  778. skb->pkt_type = IEEE80211_DELBA_MSG;
  779. skb_queue_tail(&local->skb_queue, skb);
  780. tasklet_schedule(&local->tasklet);
  781. }
  782. EXPORT_SYMBOL(ieee80211_stop_tx_ba_cb_irqsafe);
  783. static void ieee80211_set_multicast_list(struct net_device *dev)
  784. {
  785. struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
  786. struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
  787. int allmulti, promisc, sdata_allmulti, sdata_promisc;
  788. allmulti = !!(dev->flags & IFF_ALLMULTI);
  789. promisc = !!(dev->flags & IFF_PROMISC);
  790. sdata_allmulti = !!(sdata->flags & IEEE80211_SDATA_ALLMULTI);
  791. sdata_promisc = !!(sdata->flags & IEEE80211_SDATA_PROMISC);
  792. if (allmulti != sdata_allmulti) {
  793. if (dev->flags & IFF_ALLMULTI)
  794. atomic_inc(&local->iff_allmultis);
  795. else
  796. atomic_dec(&local->iff_allmultis);
  797. sdata->flags ^= IEEE80211_SDATA_ALLMULTI;
  798. }
  799. if (promisc != sdata_promisc) {
  800. if (dev->flags & IFF_PROMISC)
  801. atomic_inc(&local->iff_promiscs);
  802. else
  803. atomic_dec(&local->iff_promiscs);
  804. sdata->flags ^= IEEE80211_SDATA_PROMISC;
  805. }
  806. dev_mc_sync(local->mdev, dev);
  807. }
  808. static const struct header_ops ieee80211_header_ops = {
  809. .create = eth_header,
  810. .parse = header_parse_80211,
  811. .rebuild = eth_rebuild_header,
  812. .cache = eth_header_cache,
  813. .cache_update = eth_header_cache_update,
  814. };
  815. void ieee80211_if_setup(struct net_device *dev)
  816. {
  817. ether_setup(dev);
  818. dev->hard_start_xmit = ieee80211_subif_start_xmit;
  819. dev->wireless_handlers = &ieee80211_iw_handler_def;
  820. dev->set_multicast_list = ieee80211_set_multicast_list;
  821. dev->change_mtu = ieee80211_change_mtu;
  822. dev->open = ieee80211_open;
  823. dev->stop = ieee80211_stop;
  824. dev->destructor = free_netdev;
  825. }
  826. /* everything else */
  827. int ieee80211_if_config(struct ieee80211_sub_if_data *sdata, u32 changed)
  828. {
  829. struct ieee80211_local *local = sdata->local;
  830. struct ieee80211_if_conf conf;
  831. if (WARN_ON(!netif_running(sdata->dev)))
  832. return 0;
  833. if (!local->ops->config_interface)
  834. return 0;
  835. memset(&conf, 0, sizeof(conf));
  836. conf.changed = changed;
  837. if (sdata->vif.type == IEEE80211_IF_TYPE_STA ||
  838. sdata->vif.type == IEEE80211_IF_TYPE_IBSS) {
  839. conf.bssid = sdata->u.sta.bssid;
  840. conf.ssid = sdata->u.sta.ssid;
  841. conf.ssid_len = sdata->u.sta.ssid_len;
  842. } else if (sdata->vif.type == IEEE80211_IF_TYPE_AP) {
  843. conf.bssid = sdata->dev->dev_addr;
  844. conf.ssid = sdata->u.ap.ssid;
  845. conf.ssid_len = sdata->u.ap.ssid_len;
  846. } else if (ieee80211_vif_is_mesh(&sdata->vif)) {
  847. u8 zero[ETH_ALEN] = { 0 };
  848. conf.bssid = zero;
  849. conf.ssid = zero;
  850. conf.ssid_len = 0;
  851. } else {
  852. WARN_ON(1);
  853. return -EINVAL;
  854. }
  855. if (WARN_ON(!conf.bssid && (changed & IEEE80211_IFCC_BSSID)))
  856. return -EINVAL;
  857. if (WARN_ON(!conf.ssid && (changed & IEEE80211_IFCC_SSID)))
  858. return -EINVAL;
  859. return local->ops->config_interface(local_to_hw(local),
  860. &sdata->vif, &conf);
  861. }
  862. int ieee80211_hw_config(struct ieee80211_local *local)
  863. {
  864. struct ieee80211_channel *chan;
  865. int ret = 0;
  866. if (local->sta_sw_scanning)
  867. chan = local->scan_channel;
  868. else
  869. chan = local->oper_channel;
  870. local->hw.conf.channel = chan;
  871. if (!local->hw.conf.power_level)
  872. local->hw.conf.power_level = chan->max_power;
  873. else
  874. local->hw.conf.power_level = min(chan->max_power,
  875. local->hw.conf.power_level);
  876. local->hw.conf.max_antenna_gain = chan->max_antenna_gain;
  877. #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
  878. printk(KERN_DEBUG "%s: HW CONFIG: freq=%d\n",
  879. wiphy_name(local->hw.wiphy), chan->center_freq);
  880. #endif
  881. if (local->open_count)
  882. ret = local->ops->config(local_to_hw(local), &local->hw.conf);
  883. return ret;
  884. }
  885. /**
  886. * ieee80211_handle_ht should be used only after legacy configuration
  887. * has been determined namely band, as ht configuration depends upon
  888. * the hardware's HT abilities for a _specific_ band.
  889. */
  890. u32 ieee80211_handle_ht(struct ieee80211_local *local, int enable_ht,
  891. struct ieee80211_ht_info *req_ht_cap,
  892. struct ieee80211_ht_bss_info *req_bss_cap)
  893. {
  894. struct ieee80211_conf *conf = &local->hw.conf;
  895. struct ieee80211_supported_band *sband;
  896. struct ieee80211_ht_info ht_conf;
  897. struct ieee80211_ht_bss_info ht_bss_conf;
  898. u32 changed = 0;
  899. int i;
  900. u8 max_tx_streams = IEEE80211_HT_CAP_MAX_STREAMS;
  901. u8 tx_mcs_set_cap;
  902. sband = local->hw.wiphy->bands[conf->channel->band];
  903. memset(&ht_conf, 0, sizeof(struct ieee80211_ht_info));
  904. memset(&ht_bss_conf, 0, sizeof(struct ieee80211_ht_bss_info));
  905. /* HT is not supported */
  906. if (!sband->ht_info.ht_supported) {
  907. conf->flags &= ~IEEE80211_CONF_SUPPORT_HT_MODE;
  908. goto out;
  909. }
  910. /* disable HT */
  911. if (!enable_ht) {
  912. if (conf->flags & IEEE80211_CONF_SUPPORT_HT_MODE)
  913. changed |= BSS_CHANGED_HT;
  914. conf->flags &= ~IEEE80211_CONF_SUPPORT_HT_MODE;
  915. conf->ht_conf.ht_supported = 0;
  916. goto out;
  917. }
  918. if (!(conf->flags & IEEE80211_CONF_SUPPORT_HT_MODE))
  919. changed |= BSS_CHANGED_HT;
  920. conf->flags |= IEEE80211_CONF_SUPPORT_HT_MODE;
  921. ht_conf.ht_supported = 1;
  922. ht_conf.cap = req_ht_cap->cap & sband->ht_info.cap;
  923. ht_conf.cap &= ~(IEEE80211_HT_CAP_MIMO_PS);
  924. ht_conf.cap |= sband->ht_info.cap & IEEE80211_HT_CAP_MIMO_PS;
  925. ht_bss_conf.primary_channel = req_bss_cap->primary_channel;
  926. ht_bss_conf.bss_cap = req_bss_cap->bss_cap;
  927. ht_bss_conf.bss_op_mode = req_bss_cap->bss_op_mode;
  928. ht_conf.ampdu_factor = req_ht_cap->ampdu_factor;
  929. ht_conf.ampdu_density = req_ht_cap->ampdu_density;
  930. /* Bits 96-100 */
  931. tx_mcs_set_cap = sband->ht_info.supp_mcs_set[12];
  932. /* configure suppoerted Tx MCS according to requested MCS
  933. * (based in most cases on Rx capabilities of peer) and self
  934. * Tx MCS capabilities (as defined by low level driver HW
  935. * Tx capabilities) */
  936. if (!(tx_mcs_set_cap & IEEE80211_HT_CAP_MCS_TX_DEFINED))
  937. goto check_changed;
  938. /* Counting from 0 therfore + 1 */
  939. if (tx_mcs_set_cap & IEEE80211_HT_CAP_MCS_TX_RX_DIFF)
  940. max_tx_streams = ((tx_mcs_set_cap &
  941. IEEE80211_HT_CAP_MCS_TX_STREAMS) >> 2) + 1;
  942. for (i = 0; i < max_tx_streams; i++)
  943. ht_conf.supp_mcs_set[i] =
  944. sband->ht_info.supp_mcs_set[i] &
  945. req_ht_cap->supp_mcs_set[i];
  946. if (tx_mcs_set_cap & IEEE80211_HT_CAP_MCS_TX_UEQM)
  947. for (i = IEEE80211_SUPP_MCS_SET_UEQM;
  948. i < IEEE80211_SUPP_MCS_SET_LEN; i++)
  949. ht_conf.supp_mcs_set[i] =
  950. sband->ht_info.supp_mcs_set[i] &
  951. req_ht_cap->supp_mcs_set[i];
  952. check_changed:
  953. /* if bss configuration changed store the new one */
  954. if (memcmp(&conf->ht_conf, &ht_conf, sizeof(ht_conf)) ||
  955. memcmp(&conf->ht_bss_conf, &ht_bss_conf, sizeof(ht_bss_conf))) {
  956. changed |= BSS_CHANGED_HT;
  957. memcpy(&conf->ht_conf, &ht_conf, sizeof(ht_conf));
  958. memcpy(&conf->ht_bss_conf, &ht_bss_conf, sizeof(ht_bss_conf));
  959. }
  960. out:
  961. return changed;
  962. }
  963. void ieee80211_bss_info_change_notify(struct ieee80211_sub_if_data *sdata,
  964. u32 changed)
  965. {
  966. struct ieee80211_local *local = sdata->local;
  967. if (!changed)
  968. return;
  969. if (local->ops->bss_info_changed)
  970. local->ops->bss_info_changed(local_to_hw(local),
  971. &sdata->vif,
  972. &sdata->bss_conf,
  973. changed);
  974. }
  975. u32 ieee80211_reset_erp_info(struct net_device *dev)
  976. {
  977. struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
  978. sdata->bss_conf.use_cts_prot = 0;
  979. sdata->bss_conf.use_short_preamble = 0;
  980. return BSS_CHANGED_ERP_CTS_PROT | BSS_CHANGED_ERP_PREAMBLE;
  981. }
  982. void ieee80211_tx_status_irqsafe(struct ieee80211_hw *hw,
  983. struct sk_buff *skb)
  984. {
  985. struct ieee80211_local *local = hw_to_local(hw);
  986. struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
  987. int tmp;
  988. skb->dev = local->mdev;
  989. skb->pkt_type = IEEE80211_TX_STATUS_MSG;
  990. skb_queue_tail(info->flags & IEEE80211_TX_CTL_REQ_TX_STATUS ?
  991. &local->skb_queue : &local->skb_queue_unreliable, skb);
  992. tmp = skb_queue_len(&local->skb_queue) +
  993. skb_queue_len(&local->skb_queue_unreliable);
  994. while (tmp > IEEE80211_IRQSAFE_QUEUE_LIMIT &&
  995. (skb = skb_dequeue(&local->skb_queue_unreliable))) {
  996. dev_kfree_skb_irq(skb);
  997. tmp--;
  998. I802_DEBUG_INC(local->tx_status_drop);
  999. }
  1000. tasklet_schedule(&local->tasklet);
  1001. }
  1002. EXPORT_SYMBOL(ieee80211_tx_status_irqsafe);
  1003. static void ieee80211_tasklet_handler(unsigned long data)
  1004. {
  1005. struct ieee80211_local *local = (struct ieee80211_local *) data;
  1006. struct sk_buff *skb;
  1007. struct ieee80211_rx_status rx_status;
  1008. struct ieee80211_ra_tid *ra_tid;
  1009. while ((skb = skb_dequeue(&local->skb_queue)) ||
  1010. (skb = skb_dequeue(&local->skb_queue_unreliable))) {
  1011. switch (skb->pkt_type) {
  1012. case IEEE80211_RX_MSG:
  1013. /* status is in skb->cb */
  1014. memcpy(&rx_status, skb->cb, sizeof(rx_status));
  1015. /* Clear skb->pkt_type in order to not confuse kernel
  1016. * netstack. */
  1017. skb->pkt_type = 0;
  1018. __ieee80211_rx(local_to_hw(local), skb, &rx_status);
  1019. break;
  1020. case IEEE80211_TX_STATUS_MSG:
  1021. skb->pkt_type = 0;
  1022. ieee80211_tx_status(local_to_hw(local), skb);
  1023. break;
  1024. case IEEE80211_DELBA_MSG:
  1025. ra_tid = (struct ieee80211_ra_tid *) &skb->cb;
  1026. ieee80211_stop_tx_ba_cb(local_to_hw(local),
  1027. ra_tid->ra, ra_tid->tid);
  1028. dev_kfree_skb(skb);
  1029. break;
  1030. case IEEE80211_ADDBA_MSG:
  1031. ra_tid = (struct ieee80211_ra_tid *) &skb->cb;
  1032. ieee80211_start_tx_ba_cb(local_to_hw(local),
  1033. ra_tid->ra, ra_tid->tid);
  1034. dev_kfree_skb(skb);
  1035. break ;
  1036. default:
  1037. WARN_ON(1);
  1038. dev_kfree_skb(skb);
  1039. break;
  1040. }
  1041. }
  1042. }
  1043. /* Remove added headers (e.g., QoS control), encryption header/MIC, etc. to
  1044. * make a prepared TX frame (one that has been given to hw) to look like brand
  1045. * new IEEE 802.11 frame that is ready to go through TX processing again.
  1046. */
  1047. static void ieee80211_remove_tx_extra(struct ieee80211_local *local,
  1048. struct ieee80211_key *key,
  1049. struct sk_buff *skb)
  1050. {
  1051. int hdrlen, iv_len, mic_len;
  1052. hdrlen = ieee80211_get_hdrlen_from_skb(skb);
  1053. if (!key)
  1054. goto no_key;
  1055. switch (key->conf.alg) {
  1056. case ALG_WEP:
  1057. iv_len = WEP_IV_LEN;
  1058. mic_len = WEP_ICV_LEN;
  1059. break;
  1060. case ALG_TKIP:
  1061. iv_len = TKIP_IV_LEN;
  1062. mic_len = TKIP_ICV_LEN;
  1063. break;
  1064. case ALG_CCMP:
  1065. iv_len = CCMP_HDR_LEN;
  1066. mic_len = CCMP_MIC_LEN;
  1067. break;
  1068. default:
  1069. goto no_key;
  1070. }
  1071. if (skb->len >= mic_len &&
  1072. !(key->flags & KEY_FLAG_UPLOADED_TO_HARDWARE))
  1073. skb_trim(skb, skb->len - mic_len);
  1074. if (skb->len >= iv_len && skb->len > hdrlen) {
  1075. memmove(skb->data + iv_len, skb->data, hdrlen);
  1076. skb_pull(skb, iv_len);
  1077. }
  1078. no_key:
  1079. {
  1080. struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
  1081. u16 fc = le16_to_cpu(hdr->frame_control);
  1082. if ((fc & 0x8C) == 0x88) /* QoS Control Field */ {
  1083. fc &= ~IEEE80211_STYPE_QOS_DATA;
  1084. hdr->frame_control = cpu_to_le16(fc);
  1085. memmove(skb->data + 2, skb->data, hdrlen - 2);
  1086. skb_pull(skb, 2);
  1087. }
  1088. }
  1089. }
  1090. static void ieee80211_handle_filtered_frame(struct ieee80211_local *local,
  1091. struct sta_info *sta,
  1092. struct sk_buff *skb)
  1093. {
  1094. struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
  1095. sta->tx_filtered_count++;
  1096. /*
  1097. * Clear the TX filter mask for this STA when sending the next
  1098. * packet. If the STA went to power save mode, this will happen
  1099. * when it wakes up for the next time.
  1100. */
  1101. set_sta_flags(sta, WLAN_STA_CLEAR_PS_FILT);
  1102. /*
  1103. * This code races in the following way:
  1104. *
  1105. * (1) STA sends frame indicating it will go to sleep and does so
  1106. * (2) hardware/firmware adds STA to filter list, passes frame up
  1107. * (3) hardware/firmware processes TX fifo and suppresses a frame
  1108. * (4) we get TX status before having processed the frame and
  1109. * knowing that the STA has gone to sleep.
  1110. *
  1111. * This is actually quite unlikely even when both those events are
  1112. * processed from interrupts coming in quickly after one another or
  1113. * even at the same time because we queue both TX status events and
  1114. * RX frames to be processed by a tasklet and process them in the
  1115. * same order that they were received or TX status last. Hence, there
  1116. * is no race as long as the frame RX is processed before the next TX
  1117. * status, which drivers can ensure, see below.
  1118. *
  1119. * Note that this can only happen if the hardware or firmware can
  1120. * actually add STAs to the filter list, if this is done by the
  1121. * driver in response to set_tim() (which will only reduce the race
  1122. * this whole filtering tries to solve, not completely solve it)
  1123. * this situation cannot happen.
  1124. *
  1125. * To completely solve this race drivers need to make sure that they
  1126. * (a) don't mix the irq-safe/not irq-safe TX status/RX processing
  1127. * functions and
  1128. * (b) always process RX events before TX status events if ordering
  1129. * can be unknown, for example with different interrupt status
  1130. * bits.
  1131. */
  1132. if (test_sta_flags(sta, WLAN_STA_PS) &&
  1133. skb_queue_len(&sta->tx_filtered) < STA_MAX_TX_BUFFER) {
  1134. ieee80211_remove_tx_extra(local, sta->key, skb);
  1135. skb_queue_tail(&sta->tx_filtered, skb);
  1136. return;
  1137. }
  1138. if (!test_sta_flags(sta, WLAN_STA_PS) &&
  1139. !(info->flags & IEEE80211_TX_CTL_REQUEUE)) {
  1140. /* Software retry the packet once */
  1141. info->flags |= IEEE80211_TX_CTL_REQUEUE;
  1142. ieee80211_remove_tx_extra(local, sta->key, skb);
  1143. dev_queue_xmit(skb);
  1144. return;
  1145. }
  1146. #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
  1147. if (net_ratelimit())
  1148. printk(KERN_DEBUG "%s: dropped TX filtered frame, "
  1149. "queue_len=%d PS=%d @%lu\n",
  1150. wiphy_name(local->hw.wiphy),
  1151. skb_queue_len(&sta->tx_filtered),
  1152. !!test_sta_flags(sta, WLAN_STA_PS), jiffies);
  1153. #endif
  1154. dev_kfree_skb(skb);
  1155. }
  1156. void ieee80211_tx_status(struct ieee80211_hw *hw, struct sk_buff *skb)
  1157. {
  1158. struct sk_buff *skb2;
  1159. struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
  1160. struct ieee80211_local *local = hw_to_local(hw);
  1161. struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
  1162. u16 frag, type;
  1163. __le16 fc;
  1164. struct ieee80211_tx_status_rtap_hdr *rthdr;
  1165. struct ieee80211_sub_if_data *sdata;
  1166. struct net_device *prev_dev = NULL;
  1167. struct sta_info *sta;
  1168. rcu_read_lock();
  1169. if (info->status.excessive_retries) {
  1170. sta = sta_info_get(local, hdr->addr1);
  1171. if (sta) {
  1172. if (test_sta_flags(sta, WLAN_STA_PS)) {
  1173. /*
  1174. * The STA is in power save mode, so assume
  1175. * that this TX packet failed because of that.
  1176. */
  1177. ieee80211_handle_filtered_frame(local, sta, skb);
  1178. rcu_read_unlock();
  1179. return;
  1180. }
  1181. }
  1182. }
  1183. fc = hdr->frame_control;
  1184. if ((info->flags & IEEE80211_TX_STAT_AMPDU_NO_BACK) &&
  1185. (ieee80211_is_data_qos(fc))) {
  1186. u16 tid, ssn;
  1187. u8 *qc;
  1188. sta = sta_info_get(local, hdr->addr1);
  1189. if (sta) {
  1190. qc = ieee80211_get_qos_ctl(hdr);
  1191. tid = qc[0] & 0xf;
  1192. ssn = ((le16_to_cpu(hdr->seq_ctrl) + 0x10)
  1193. & IEEE80211_SCTL_SEQ);
  1194. ieee80211_send_bar(sta->sdata->dev, hdr->addr1,
  1195. tid, ssn);
  1196. }
  1197. }
  1198. if (info->flags & IEEE80211_TX_STAT_TX_FILTERED) {
  1199. sta = sta_info_get(local, hdr->addr1);
  1200. if (sta) {
  1201. ieee80211_handle_filtered_frame(local, sta, skb);
  1202. rcu_read_unlock();
  1203. return;
  1204. }
  1205. } else
  1206. rate_control_tx_status(local->mdev, skb);
  1207. rcu_read_unlock();
  1208. ieee80211_led_tx(local, 0);
  1209. /* SNMP counters
  1210. * Fragments are passed to low-level drivers as separate skbs, so these
  1211. * are actually fragments, not frames. Update frame counters only for
  1212. * the first fragment of the frame. */
  1213. frag = le16_to_cpu(hdr->seq_ctrl) & IEEE80211_SCTL_FRAG;
  1214. type = le16_to_cpu(hdr->frame_control) & IEEE80211_FCTL_FTYPE;
  1215. if (info->flags & IEEE80211_TX_STAT_ACK) {
  1216. if (frag == 0) {
  1217. local->dot11TransmittedFrameCount++;
  1218. if (is_multicast_ether_addr(hdr->addr1))
  1219. local->dot11MulticastTransmittedFrameCount++;
  1220. if (info->status.retry_count > 0)
  1221. local->dot11RetryCount++;
  1222. if (info->status.retry_count > 1)
  1223. local->dot11MultipleRetryCount++;
  1224. }
  1225. /* This counter shall be incremented for an acknowledged MPDU
  1226. * with an individual address in the address 1 field or an MPDU
  1227. * with a multicast address in the address 1 field of type Data
  1228. * or Management. */
  1229. if (!is_multicast_ether_addr(hdr->addr1) ||
  1230. type == IEEE80211_FTYPE_DATA ||
  1231. type == IEEE80211_FTYPE_MGMT)
  1232. local->dot11TransmittedFragmentCount++;
  1233. } else {
  1234. if (frag == 0)
  1235. local->dot11FailedCount++;
  1236. }
  1237. /* this was a transmitted frame, but now we want to reuse it */
  1238. skb_orphan(skb);
  1239. /*
  1240. * This is a bit racy but we can avoid a lot of work
  1241. * with this test...
  1242. */
  1243. if (!local->monitors && !local->cooked_mntrs) {
  1244. dev_kfree_skb(skb);
  1245. return;
  1246. }
  1247. /* send frame to monitor interfaces now */
  1248. if (skb_headroom(skb) < sizeof(*rthdr)) {
  1249. printk(KERN_ERR "ieee80211_tx_status: headroom too small\n");
  1250. dev_kfree_skb(skb);
  1251. return;
  1252. }
  1253. rthdr = (struct ieee80211_tx_status_rtap_hdr *)
  1254. skb_push(skb, sizeof(*rthdr));
  1255. memset(rthdr, 0, sizeof(*rthdr));
  1256. rthdr->hdr.it_len = cpu_to_le16(sizeof(*rthdr));
  1257. rthdr->hdr.it_present =
  1258. cpu_to_le32((1 << IEEE80211_RADIOTAP_TX_FLAGS) |
  1259. (1 << IEEE80211_RADIOTAP_DATA_RETRIES));
  1260. if (!(info->flags & IEEE80211_TX_STAT_ACK) &&
  1261. !is_multicast_ether_addr(hdr->addr1))
  1262. rthdr->tx_flags |= cpu_to_le16(IEEE80211_RADIOTAP_F_TX_FAIL);
  1263. if ((info->flags & IEEE80211_TX_CTL_USE_RTS_CTS) &&
  1264. (info->flags & IEEE80211_TX_CTL_USE_CTS_PROTECT))
  1265. rthdr->tx_flags |= cpu_to_le16(IEEE80211_RADIOTAP_F_TX_CTS);
  1266. else if (info->flags & IEEE80211_TX_CTL_USE_RTS_CTS)
  1267. rthdr->tx_flags |= cpu_to_le16(IEEE80211_RADIOTAP_F_TX_RTS);
  1268. rthdr->data_retries = info->status.retry_count;
  1269. /* XXX: is this sufficient for BPF? */
  1270. skb_set_mac_header(skb, 0);
  1271. skb->ip_summed = CHECKSUM_UNNECESSARY;
  1272. skb->pkt_type = PACKET_OTHERHOST;
  1273. skb->protocol = htons(ETH_P_802_2);
  1274. memset(skb->cb, 0, sizeof(skb->cb));
  1275. rcu_read_lock();
  1276. list_for_each_entry_rcu(sdata, &local->interfaces, list) {
  1277. if (sdata->vif.type == IEEE80211_IF_TYPE_MNTR) {
  1278. if (!netif_running(sdata->dev))
  1279. continue;
  1280. if (prev_dev) {
  1281. skb2 = skb_clone(skb, GFP_ATOMIC);
  1282. if (skb2) {
  1283. skb2->dev = prev_dev;
  1284. netif_rx(skb2);
  1285. }
  1286. }
  1287. prev_dev = sdata->dev;
  1288. }
  1289. }
  1290. if (prev_dev) {
  1291. skb->dev = prev_dev;
  1292. netif_rx(skb);
  1293. skb = NULL;
  1294. }
  1295. rcu_read_unlock();
  1296. dev_kfree_skb(skb);
  1297. }
  1298. EXPORT_SYMBOL(ieee80211_tx_status);
  1299. struct ieee80211_hw *ieee80211_alloc_hw(size_t priv_data_len,
  1300. const struct ieee80211_ops *ops)
  1301. {
  1302. struct ieee80211_local *local;
  1303. int priv_size;
  1304. struct wiphy *wiphy;
  1305. /* Ensure 32-byte alignment of our private data and hw private data.
  1306. * We use the wiphy priv data for both our ieee80211_local and for
  1307. * the driver's private data
  1308. *
  1309. * In memory it'll be like this:
  1310. *
  1311. * +-------------------------+
  1312. * | struct wiphy |
  1313. * +-------------------------+
  1314. * | struct ieee80211_local |
  1315. * +-------------------------+
  1316. * | driver's private data |
  1317. * +-------------------------+
  1318. *
  1319. */
  1320. priv_size = ((sizeof(struct ieee80211_local) +
  1321. NETDEV_ALIGN_CONST) & ~NETDEV_ALIGN_CONST) +
  1322. priv_data_len;
  1323. wiphy = wiphy_new(&mac80211_config_ops, priv_size);
  1324. if (!wiphy)
  1325. return NULL;
  1326. wiphy->privid = mac80211_wiphy_privid;
  1327. local = wiphy_priv(wiphy);
  1328. local->hw.wiphy = wiphy;
  1329. local->hw.priv = (char *)local +
  1330. ((sizeof(struct ieee80211_local) +
  1331. NETDEV_ALIGN_CONST) & ~NETDEV_ALIGN_CONST);
  1332. BUG_ON(!ops->tx);
  1333. BUG_ON(!ops->start);
  1334. BUG_ON(!ops->stop);
  1335. BUG_ON(!ops->config);
  1336. BUG_ON(!ops->add_interface);
  1337. BUG_ON(!ops->remove_interface);
  1338. BUG_ON(!ops->configure_filter);
  1339. local->ops = ops;
  1340. local->hw.queues = 1; /* default */
  1341. local->bridge_packets = 1;
  1342. local->rts_threshold = IEEE80211_MAX_RTS_THRESHOLD;
  1343. local->fragmentation_threshold = IEEE80211_MAX_FRAG_THRESHOLD;
  1344. local->short_retry_limit = 7;
  1345. local->long_retry_limit = 4;
  1346. local->hw.conf.radio_enabled = 1;
  1347. INIT_LIST_HEAD(&local->interfaces);
  1348. spin_lock_init(&local->key_lock);
  1349. INIT_DELAYED_WORK(&local->scan_work, ieee80211_sta_scan_work);
  1350. sta_info_init(local);
  1351. tasklet_init(&local->tx_pending_tasklet, ieee80211_tx_pending,
  1352. (unsigned long)local);
  1353. tasklet_disable(&local->tx_pending_tasklet);
  1354. tasklet_init(&local->tasklet,
  1355. ieee80211_tasklet_handler,
  1356. (unsigned long) local);
  1357. tasklet_disable(&local->tasklet);
  1358. skb_queue_head_init(&local->skb_queue);
  1359. skb_queue_head_init(&local->skb_queue_unreliable);
  1360. return local_to_hw(local);
  1361. }
  1362. EXPORT_SYMBOL(ieee80211_alloc_hw);
  1363. int ieee80211_register_hw(struct ieee80211_hw *hw)
  1364. {
  1365. struct ieee80211_local *local = hw_to_local(hw);
  1366. const char *name;
  1367. int result;
  1368. enum ieee80211_band band;
  1369. struct net_device *mdev;
  1370. struct wireless_dev *mwdev;
  1371. /*
  1372. * generic code guarantees at least one band,
  1373. * set this very early because much code assumes
  1374. * that hw.conf.channel is assigned
  1375. */
  1376. for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
  1377. struct ieee80211_supported_band *sband;
  1378. sband = local->hw.wiphy->bands[band];
  1379. if (sband) {
  1380. /* init channel we're on */
  1381. local->hw.conf.channel =
  1382. local->oper_channel =
  1383. local->scan_channel = &sband->channels[0];
  1384. break;
  1385. }
  1386. }
  1387. result = wiphy_register(local->hw.wiphy);
  1388. if (result < 0)
  1389. return result;
  1390. /*
  1391. * We use the number of queues for feature tests (QoS, HT) internally
  1392. * so restrict them appropriately.
  1393. */
  1394. if (hw->queues > IEEE80211_MAX_QUEUES)
  1395. hw->queues = IEEE80211_MAX_QUEUES;
  1396. if (hw->ampdu_queues > IEEE80211_MAX_AMPDU_QUEUES)
  1397. hw->ampdu_queues = IEEE80211_MAX_AMPDU_QUEUES;
  1398. if (hw->queues < 4)
  1399. hw->ampdu_queues = 0;
  1400. mdev = alloc_netdev_mq(sizeof(struct wireless_dev),
  1401. "wmaster%d", ether_setup,
  1402. ieee80211_num_queues(hw));
  1403. if (!mdev)
  1404. goto fail_mdev_alloc;
  1405. mwdev = netdev_priv(mdev);
  1406. mdev->ieee80211_ptr = mwdev;
  1407. mwdev->wiphy = local->hw.wiphy;
  1408. local->mdev = mdev;
  1409. ieee80211_rx_bss_list_init(local);
  1410. mdev->hard_start_xmit = ieee80211_master_start_xmit;
  1411. mdev->open = ieee80211_master_open;
  1412. mdev->stop = ieee80211_master_stop;
  1413. mdev->type = ARPHRD_IEEE80211;
  1414. mdev->header_ops = &ieee80211_header_ops;
  1415. mdev->set_multicast_list = ieee80211_master_set_multicast_list;
  1416. name = wiphy_dev(local->hw.wiphy)->driver->name;
  1417. local->hw.workqueue = create_freezeable_workqueue(name);
  1418. if (!local->hw.workqueue) {
  1419. result = -ENOMEM;
  1420. goto fail_workqueue;
  1421. }
  1422. /*
  1423. * The hardware needs headroom for sending the frame,
  1424. * and we need some headroom for passing the frame to monitor
  1425. * interfaces, but never both at the same time.
  1426. */
  1427. local->tx_headroom = max_t(unsigned int , local->hw.extra_tx_headroom,
  1428. sizeof(struct ieee80211_tx_status_rtap_hdr));
  1429. debugfs_hw_add(local);
  1430. if (local->hw.conf.beacon_int < 10)
  1431. local->hw.conf.beacon_int = 100;
  1432. if (local->hw.max_listen_interval == 0)
  1433. local->hw.max_listen_interval = 1;
  1434. local->hw.conf.listen_interval = local->hw.max_listen_interval;
  1435. local->wstats_flags |= local->hw.flags & (IEEE80211_HW_SIGNAL_UNSPEC |
  1436. IEEE80211_HW_SIGNAL_DB |
  1437. IEEE80211_HW_SIGNAL_DBM) ?
  1438. IW_QUAL_QUAL_UPDATED : IW_QUAL_QUAL_INVALID;
  1439. local->wstats_flags |= local->hw.flags & IEEE80211_HW_NOISE_DBM ?
  1440. IW_QUAL_NOISE_UPDATED : IW_QUAL_NOISE_INVALID;
  1441. if (local->hw.flags & IEEE80211_HW_SIGNAL_DBM)
  1442. local->wstats_flags |= IW_QUAL_DBM;
  1443. result = sta_info_start(local);
  1444. if (result < 0)
  1445. goto fail_sta_info;
  1446. rtnl_lock();
  1447. result = dev_alloc_name(local->mdev, local->mdev->name);
  1448. if (result < 0)
  1449. goto fail_dev;
  1450. memcpy(local->mdev->dev_addr, local->hw.wiphy->perm_addr, ETH_ALEN);
  1451. SET_NETDEV_DEV(local->mdev, wiphy_dev(local->hw.wiphy));
  1452. result = register_netdevice(local->mdev);
  1453. if (result < 0)
  1454. goto fail_dev;
  1455. result = ieee80211_init_rate_ctrl_alg(local,
  1456. hw->rate_control_algorithm);
  1457. if (result < 0) {
  1458. printk(KERN_DEBUG "%s: Failed to initialize rate control "
  1459. "algorithm\n", wiphy_name(local->hw.wiphy));
  1460. goto fail_rate;
  1461. }
  1462. result = ieee80211_wep_init(local);
  1463. if (result < 0) {
  1464. printk(KERN_DEBUG "%s: Failed to initialize wep: %d\n",
  1465. wiphy_name(local->hw.wiphy), result);
  1466. goto fail_wep;
  1467. }
  1468. local->mdev->select_queue = ieee80211_select_queue;
  1469. /* add one default STA interface */
  1470. result = ieee80211_if_add(local, "wlan%d", NULL,
  1471. IEEE80211_IF_TYPE_STA, NULL);
  1472. if (result)
  1473. printk(KERN_WARNING "%s: Failed to add default virtual iface\n",
  1474. wiphy_name(local->hw.wiphy));
  1475. rtnl_unlock();
  1476. ieee80211_led_init(local);
  1477. return 0;
  1478. fail_wep:
  1479. rate_control_deinitialize(local);
  1480. fail_rate:
  1481. unregister_netdevice(local->mdev);
  1482. local->mdev = NULL;
  1483. fail_dev:
  1484. rtnl_unlock();
  1485. sta_info_stop(local);
  1486. fail_sta_info:
  1487. debugfs_hw_del(local);
  1488. destroy_workqueue(local->hw.workqueue);
  1489. fail_workqueue:
  1490. if (local->mdev)
  1491. free_netdev(local->mdev);
  1492. fail_mdev_alloc:
  1493. wiphy_unregister(local->hw.wiphy);
  1494. return result;
  1495. }
  1496. EXPORT_SYMBOL(ieee80211_register_hw);
  1497. void ieee80211_unregister_hw(struct ieee80211_hw *hw)
  1498. {
  1499. struct ieee80211_local *local = hw_to_local(hw);
  1500. tasklet_kill(&local->tx_pending_tasklet);
  1501. tasklet_kill(&local->tasklet);
  1502. rtnl_lock();
  1503. /*
  1504. * At this point, interface list manipulations are fine
  1505. * because the driver cannot be handing us frames any
  1506. * more and the tasklet is killed.
  1507. */
  1508. /* First, we remove all virtual interfaces. */
  1509. ieee80211_remove_interfaces(local);
  1510. /* then, finally, remove the master interface */
  1511. unregister_netdevice(local->mdev);
  1512. rtnl_unlock();
  1513. ieee80211_rx_bss_list_deinit(local);
  1514. ieee80211_clear_tx_pending(local);
  1515. sta_info_stop(local);
  1516. rate_control_deinitialize(local);
  1517. debugfs_hw_del(local);
  1518. if (skb_queue_len(&local->skb_queue)
  1519. || skb_queue_len(&local->skb_queue_unreliable))
  1520. printk(KERN_WARNING "%s: skb_queue not empty\n",
  1521. wiphy_name(local->hw.wiphy));
  1522. skb_queue_purge(&local->skb_queue);
  1523. skb_queue_purge(&local->skb_queue_unreliable);
  1524. destroy_workqueue(local->hw.workqueue);
  1525. wiphy_unregister(local->hw.wiphy);
  1526. ieee80211_wep_free(local);
  1527. ieee80211_led_exit(local);
  1528. free_netdev(local->mdev);
  1529. }
  1530. EXPORT_SYMBOL(ieee80211_unregister_hw);
  1531. void ieee80211_free_hw(struct ieee80211_hw *hw)
  1532. {
  1533. struct ieee80211_local *local = hw_to_local(hw);
  1534. wiphy_free(local->hw.wiphy);
  1535. }
  1536. EXPORT_SYMBOL(ieee80211_free_hw);
  1537. static int __init ieee80211_init(void)
  1538. {
  1539. struct sk_buff *skb;
  1540. int ret;
  1541. BUILD_BUG_ON(sizeof(struct ieee80211_tx_info) > sizeof(skb->cb));
  1542. BUILD_BUG_ON(offsetof(struct ieee80211_tx_info, driver_data) +
  1543. IEEE80211_TX_INFO_DRIVER_DATA_SIZE > sizeof(skb->cb));
  1544. ret = rc80211_pid_init();
  1545. if (ret)
  1546. return ret;
  1547. ieee80211_debugfs_netdev_init();
  1548. return 0;
  1549. }
  1550. static void __exit ieee80211_exit(void)
  1551. {
  1552. rc80211_pid_exit();
  1553. /*
  1554. * For key todo, it'll be empty by now but the work
  1555. * might still be scheduled.
  1556. */
  1557. flush_scheduled_work();
  1558. if (mesh_allocated)
  1559. ieee80211s_stop();
  1560. ieee80211_debugfs_netdev_exit();
  1561. }
  1562. subsys_initcall(ieee80211_init);
  1563. module_exit(ieee80211_exit);
  1564. MODULE_DESCRIPTION("IEEE 802.11 subsystem");
  1565. MODULE_LICENSE("GPL");