rndis_wlan.c 71 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150215121522153215421552156215721582159216021612162216321642165216621672168216921702171217221732174217521762177217821792180218121822183218421852186218721882189219021912192219321942195219621972198219922002201220222032204220522062207220822092210221122122213221422152216221722182219222022212222222322242225222622272228222922302231223222332234223522362237223822392240224122422243224422452246224722482249225022512252225322542255225622572258225922602261226222632264226522662267226822692270227122722273227422752276227722782279228022812282228322842285228622872288228922902291229222932294229522962297229822992300230123022303230423052306230723082309231023112312231323142315231623172318231923202321232223232324232523262327232823292330233123322333233423352336233723382339234023412342234323442345234623472348234923502351235223532354235523562357235823592360236123622363236423652366236723682369237023712372237323742375237623772378237923802381238223832384238523862387238823892390239123922393239423952396239723982399240024012402240324042405240624072408240924102411241224132414241524162417241824192420242124222423242424252426242724282429243024312432243324342435243624372438243924402441244224432444244524462447244824492450245124522453245424552456245724582459246024612462246324642465246624672468246924702471247224732474247524762477247824792480248124822483248424852486248724882489249024912492249324942495249624972498249925002501250225032504250525062507250825092510251125122513251425152516251725182519252025212522252325242525252625272528252925302531253225332534253525362537253825392540254125422543254425452546254725482549255025512552255325542555255625572558255925602561256225632564256525662567256825692570257125722573257425752576257725782579258025812582258325842585258625872588258925902591259225932594259525962597259825992600260126022603260426052606260726082609261026112612261326142615261626172618261926202621262226232624262526262627262826292630263126322633263426352636263726382639264026412642264326442645264626472648264926502651265226532654265526562657265826592660266126622663266426652666266726682669267026712672267326742675267626772678267926802681268226832684268526862687268826892690
  1. /*
  2. * Driver for RNDIS based wireless USB devices.
  3. *
  4. * Copyright (C) 2007 by Bjorge Dijkstra <bjd@jooz.net>
  5. * Copyright (C) 2008 by Jussi Kivilinna <jussi.kivilinna@mbnet.fi>
  6. *
  7. * This program is free software; you can redistribute it and/or modify
  8. * it under the terms of the GNU General Public License as published by
  9. * the Free Software Foundation; either version 2 of the License, or
  10. * (at your option) any later version.
  11. *
  12. * This program is distributed in the hope that it will be useful,
  13. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  15. * GNU General Public License for more details.
  16. *
  17. * You should have received a copy of the GNU General Public License
  18. * along with this program; if not, write to the Free Software
  19. * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  20. *
  21. * Portions of this file are based on NDISwrapper project,
  22. * Copyright (C) 2003-2005 Pontus Fuchs, Giridhar Pemmasani
  23. * http://ndiswrapper.sourceforge.net/
  24. */
  25. // #define DEBUG // error path messages, extra info
  26. // #define VERBOSE // more; success messages
  27. #include <linux/module.h>
  28. #include <linux/init.h>
  29. #include <linux/netdevice.h>
  30. #include <linux/etherdevice.h>
  31. #include <linux/ethtool.h>
  32. #include <linux/workqueue.h>
  33. #include <linux/mutex.h>
  34. #include <linux/mii.h>
  35. #include <linux/usb.h>
  36. #include <linux/usb/cdc.h>
  37. #include <linux/wireless.h>
  38. #include <linux/ieee80211.h>
  39. #include <linux/if_arp.h>
  40. #include <linux/ctype.h>
  41. #include <linux/spinlock.h>
  42. #include <net/iw_handler.h>
  43. #include <net/cfg80211.h>
  44. #include <linux/usb/usbnet.h>
  45. #include <linux/usb/rndis_host.h>
  46. /* NOTE: All these are settings for Broadcom chipset */
  47. static char modparam_country[4] = "EU";
  48. module_param_string(country, modparam_country, 4, 0444);
  49. MODULE_PARM_DESC(country, "Country code (ISO 3166-1 alpha-2), default: EU");
  50. static int modparam_frameburst = 1;
  51. module_param_named(frameburst, modparam_frameburst, int, 0444);
  52. MODULE_PARM_DESC(frameburst, "enable frame bursting (default: on)");
  53. static int modparam_afterburner = 0;
  54. module_param_named(afterburner, modparam_afterburner, int, 0444);
  55. MODULE_PARM_DESC(afterburner,
  56. "enable afterburner aka '125 High Speed Mode' (default: off)");
  57. static int modparam_power_save = 0;
  58. module_param_named(power_save, modparam_power_save, int, 0444);
  59. MODULE_PARM_DESC(power_save,
  60. "set power save mode: 0=off, 1=on, 2=fast (default: off)");
  61. static int modparam_power_output = 3;
  62. module_param_named(power_output, modparam_power_output, int, 0444);
  63. MODULE_PARM_DESC(power_output,
  64. "set power output: 0=25%, 1=50%, 2=75%, 3=100% (default: 100%)");
  65. static int modparam_roamtrigger = -70;
  66. module_param_named(roamtrigger, modparam_roamtrigger, int, 0444);
  67. MODULE_PARM_DESC(roamtrigger,
  68. "set roaming dBm trigger: -80=optimize for distance, "
  69. "-60=bandwidth (default: -70)");
  70. static int modparam_roamdelta = 1;
  71. module_param_named(roamdelta, modparam_roamdelta, int, 0444);
  72. MODULE_PARM_DESC(roamdelta,
  73. "set roaming tendency: 0=aggressive, 1=moderate, "
  74. "2=conservative (default: moderate)");
  75. static int modparam_workaround_interval = 500;
  76. module_param_named(workaround_interval, modparam_workaround_interval,
  77. int, 0444);
  78. MODULE_PARM_DESC(workaround_interval,
  79. "set stall workaround interval in msecs (default: 500)");
  80. /* various RNDIS OID defs */
  81. #define OID_GEN_LINK_SPEED cpu_to_le32(0x00010107)
  82. #define OID_GEN_RNDIS_CONFIG_PARAMETER cpu_to_le32(0x0001021b)
  83. #define OID_GEN_XMIT_OK cpu_to_le32(0x00020101)
  84. #define OID_GEN_RCV_OK cpu_to_le32(0x00020102)
  85. #define OID_GEN_XMIT_ERROR cpu_to_le32(0x00020103)
  86. #define OID_GEN_RCV_ERROR cpu_to_le32(0x00020104)
  87. #define OID_GEN_RCV_NO_BUFFER cpu_to_le32(0x00020105)
  88. #define OID_802_3_PERMANENT_ADDRESS cpu_to_le32(0x01010101)
  89. #define OID_802_3_CURRENT_ADDRESS cpu_to_le32(0x01010102)
  90. #define OID_802_3_MULTICAST_LIST cpu_to_le32(0x01010103)
  91. #define OID_802_3_MAXIMUM_LIST_SIZE cpu_to_le32(0x01010104)
  92. #define OID_802_11_BSSID cpu_to_le32(0x0d010101)
  93. #define OID_802_11_SSID cpu_to_le32(0x0d010102)
  94. #define OID_802_11_INFRASTRUCTURE_MODE cpu_to_le32(0x0d010108)
  95. #define OID_802_11_ADD_WEP cpu_to_le32(0x0d010113)
  96. #define OID_802_11_REMOVE_WEP cpu_to_le32(0x0d010114)
  97. #define OID_802_11_DISASSOCIATE cpu_to_le32(0x0d010115)
  98. #define OID_802_11_AUTHENTICATION_MODE cpu_to_le32(0x0d010118)
  99. #define OID_802_11_PRIVACY_FILTER cpu_to_le32(0x0d010119)
  100. #define OID_802_11_BSSID_LIST_SCAN cpu_to_le32(0x0d01011a)
  101. #define OID_802_11_ENCRYPTION_STATUS cpu_to_le32(0x0d01011b)
  102. #define OID_802_11_ADD_KEY cpu_to_le32(0x0d01011d)
  103. #define OID_802_11_REMOVE_KEY cpu_to_le32(0x0d01011e)
  104. #define OID_802_11_ASSOCIATION_INFORMATION cpu_to_le32(0x0d01011f)
  105. #define OID_802_11_PMKID cpu_to_le32(0x0d010123)
  106. #define OID_802_11_NETWORK_TYPES_SUPPORTED cpu_to_le32(0x0d010203)
  107. #define OID_802_11_NETWORK_TYPE_IN_USE cpu_to_le32(0x0d010204)
  108. #define OID_802_11_TX_POWER_LEVEL cpu_to_le32(0x0d010205)
  109. #define OID_802_11_RSSI cpu_to_le32(0x0d010206)
  110. #define OID_802_11_RSSI_TRIGGER cpu_to_le32(0x0d010207)
  111. #define OID_802_11_FRAGMENTATION_THRESHOLD cpu_to_le32(0x0d010209)
  112. #define OID_802_11_RTS_THRESHOLD cpu_to_le32(0x0d01020a)
  113. #define OID_802_11_SUPPORTED_RATES cpu_to_le32(0x0d01020e)
  114. #define OID_802_11_CONFIGURATION cpu_to_le32(0x0d010211)
  115. #define OID_802_11_BSSID_LIST cpu_to_le32(0x0d010217)
  116. /* Typical noise/maximum signal level values taken from ndiswrapper iw_ndis.h */
  117. #define WL_NOISE -96 /* typical noise level in dBm */
  118. #define WL_SIGMAX -32 /* typical maximum signal level in dBm */
  119. /* Assume that Broadcom 4320 (only chipset at time of writing known to be
  120. * based on wireless rndis) has default txpower of 13dBm.
  121. * This value is from Linksys WUSB54GSC User Guide, Appendix F: Specifications.
  122. * 13dBm == 19.9mW
  123. */
  124. #define BCM4320_DEFAULT_TXPOWER 20
  125. /* codes for "status" field of completion messages */
  126. #define RNDIS_STATUS_ADAPTER_NOT_READY cpu_to_le32(0xc0010011)
  127. #define RNDIS_STATUS_ADAPTER_NOT_OPEN cpu_to_le32(0xc0010012)
  128. /* NDIS data structures. Taken from wpa_supplicant driver_ndis.c
  129. * slightly modified for datatype endianess, etc
  130. */
  131. #define NDIS_802_11_LENGTH_SSID 32
  132. #define NDIS_802_11_LENGTH_RATES 8
  133. #define NDIS_802_11_LENGTH_RATES_EX 16
  134. enum ndis_80211_net_type {
  135. ndis_80211_type_freq_hop,
  136. ndis_80211_type_direct_seq,
  137. ndis_80211_type_ofdm_a,
  138. ndis_80211_type_ofdm_g
  139. };
  140. enum ndis_80211_net_infra {
  141. ndis_80211_infra_adhoc,
  142. ndis_80211_infra_infra,
  143. ndis_80211_infra_auto_unknown
  144. };
  145. enum ndis_80211_auth_mode {
  146. ndis_80211_auth_open,
  147. ndis_80211_auth_shared,
  148. ndis_80211_auth_auto_switch,
  149. ndis_80211_auth_wpa,
  150. ndis_80211_auth_wpa_psk,
  151. ndis_80211_auth_wpa_none,
  152. ndis_80211_auth_wpa2,
  153. ndis_80211_auth_wpa2_psk
  154. };
  155. enum ndis_80211_encr_status {
  156. ndis_80211_encr_wep_enabled,
  157. ndis_80211_encr_disabled,
  158. ndis_80211_encr_wep_key_absent,
  159. ndis_80211_encr_not_supported,
  160. ndis_80211_encr_tkip_enabled,
  161. ndis_80211_encr_tkip_key_absent,
  162. ndis_80211_encr_ccmp_enabled,
  163. ndis_80211_encr_ccmp_key_absent
  164. };
  165. enum ndis_80211_priv_filter {
  166. ndis_80211_priv_accept_all,
  167. ndis_80211_priv_8021x_wep
  168. };
  169. struct ndis_80211_ssid {
  170. __le32 length;
  171. u8 essid[NDIS_802_11_LENGTH_SSID];
  172. } __attribute__((packed));
  173. struct ndis_80211_conf_freq_hop {
  174. __le32 length;
  175. __le32 hop_pattern;
  176. __le32 hop_set;
  177. __le32 dwell_time;
  178. } __attribute__((packed));
  179. struct ndis_80211_conf {
  180. __le32 length;
  181. __le32 beacon_period;
  182. __le32 atim_window;
  183. __le32 ds_config;
  184. struct ndis_80211_conf_freq_hop fh_config;
  185. } __attribute__((packed));
  186. struct ndis_80211_bssid_ex {
  187. __le32 length;
  188. u8 mac[6];
  189. u8 padding[2];
  190. struct ndis_80211_ssid ssid;
  191. __le32 privacy;
  192. __le32 rssi;
  193. __le32 net_type;
  194. struct ndis_80211_conf config;
  195. __le32 net_infra;
  196. u8 rates[NDIS_802_11_LENGTH_RATES_EX];
  197. __le32 ie_length;
  198. u8 ies[0];
  199. } __attribute__((packed));
  200. struct ndis_80211_bssid_list_ex {
  201. __le32 num_items;
  202. struct ndis_80211_bssid_ex bssid[0];
  203. } __attribute__((packed));
  204. struct ndis_80211_fixed_ies {
  205. u8 timestamp[8];
  206. __le16 beacon_interval;
  207. __le16 capabilities;
  208. } __attribute__((packed));
  209. struct ndis_80211_wep_key {
  210. __le32 size;
  211. __le32 index;
  212. __le32 length;
  213. u8 material[32];
  214. } __attribute__((packed));
  215. struct ndis_80211_key {
  216. __le32 size;
  217. __le32 index;
  218. __le32 length;
  219. u8 bssid[6];
  220. u8 padding[6];
  221. u8 rsc[8];
  222. u8 material[32];
  223. } __attribute__((packed));
  224. struct ndis_80211_remove_key {
  225. __le32 size;
  226. __le32 index;
  227. u8 bssid[6];
  228. } __attribute__((packed));
  229. struct ndis_config_param {
  230. __le32 name_offs;
  231. __le32 name_length;
  232. __le32 type;
  233. __le32 value_offs;
  234. __le32 value_length;
  235. } __attribute__((packed));
  236. struct ndis_80211_assoc_info {
  237. __le32 length;
  238. __le16 req_ies;
  239. struct req_ie {
  240. __le16 capa;
  241. __le16 listen_interval;
  242. u8 cur_ap_address[6];
  243. } req_ie;
  244. __le32 req_ie_length;
  245. __le32 offset_req_ies;
  246. __le16 resp_ies;
  247. struct resp_ie {
  248. __le16 capa;
  249. __le16 status_code;
  250. __le16 assoc_id;
  251. } resp_ie;
  252. __le32 resp_ie_length;
  253. __le32 offset_resp_ies;
  254. } __attribute__((packed));
  255. /* these have to match what is in wpa_supplicant */
  256. enum wpa_alg { WPA_ALG_NONE, WPA_ALG_WEP, WPA_ALG_TKIP, WPA_ALG_CCMP };
  257. enum wpa_cipher { CIPHER_NONE, CIPHER_WEP40, CIPHER_TKIP, CIPHER_CCMP,
  258. CIPHER_WEP104 };
  259. enum wpa_key_mgmt { KEY_MGMT_802_1X, KEY_MGMT_PSK, KEY_MGMT_NONE,
  260. KEY_MGMT_802_1X_NO_WPA, KEY_MGMT_WPA_NONE };
  261. /*
  262. * private data
  263. */
  264. #define NET_TYPE_11FB 0
  265. #define CAP_MODE_80211A 1
  266. #define CAP_MODE_80211B 2
  267. #define CAP_MODE_80211G 4
  268. #define CAP_MODE_MASK 7
  269. #define CAP_SUPPORT_TXPOWER 8
  270. #define WORK_LINK_UP (1<<0)
  271. #define WORK_LINK_DOWN (1<<1)
  272. #define WORK_SET_MULTICAST_LIST (1<<2)
  273. #define COMMAND_BUFFER_SIZE (CONTROL_BUFFER_SIZE + sizeof(struct rndis_set))
  274. static const struct ieee80211_channel rndis_channels[] = {
  275. { .center_freq = 2412 },
  276. { .center_freq = 2417 },
  277. { .center_freq = 2422 },
  278. { .center_freq = 2427 },
  279. { .center_freq = 2432 },
  280. { .center_freq = 2437 },
  281. { .center_freq = 2442 },
  282. { .center_freq = 2447 },
  283. { .center_freq = 2452 },
  284. { .center_freq = 2457 },
  285. { .center_freq = 2462 },
  286. { .center_freq = 2467 },
  287. { .center_freq = 2472 },
  288. { .center_freq = 2484 },
  289. };
  290. static const struct ieee80211_rate rndis_rates[] = {
  291. { .bitrate = 10 },
  292. { .bitrate = 20, .flags = IEEE80211_RATE_SHORT_PREAMBLE },
  293. { .bitrate = 55, .flags = IEEE80211_RATE_SHORT_PREAMBLE },
  294. { .bitrate = 110, .flags = IEEE80211_RATE_SHORT_PREAMBLE },
  295. { .bitrate = 60 },
  296. { .bitrate = 90 },
  297. { .bitrate = 120 },
  298. { .bitrate = 180 },
  299. { .bitrate = 240 },
  300. { .bitrate = 360 },
  301. { .bitrate = 480 },
  302. { .bitrate = 540 }
  303. };
  304. /* RNDIS device private data */
  305. struct rndis_wext_private {
  306. struct usbnet *usbdev;
  307. struct wireless_dev wdev;
  308. struct cfg80211_scan_request *scan_request;
  309. struct workqueue_struct *workqueue;
  310. struct delayed_work stats_work;
  311. struct delayed_work scan_work;
  312. struct work_struct work;
  313. struct mutex command_lock;
  314. spinlock_t stats_lock;
  315. unsigned long work_pending;
  316. struct ieee80211_supported_band band;
  317. struct ieee80211_channel channels[ARRAY_SIZE(rndis_channels)];
  318. struct ieee80211_rate rates[ARRAY_SIZE(rndis_rates)];
  319. struct iw_statistics iwstats;
  320. struct iw_statistics privstats;
  321. int caps;
  322. int multicast_size;
  323. /* module parameters */
  324. char param_country[4];
  325. int param_frameburst;
  326. int param_afterburner;
  327. int param_power_save;
  328. int param_power_output;
  329. int param_roamtrigger;
  330. int param_roamdelta;
  331. u32 param_workaround_interval;
  332. /* hardware state */
  333. int radio_on;
  334. int infra_mode;
  335. struct ndis_80211_ssid essid;
  336. /* encryption stuff */
  337. int encr_tx_key_index;
  338. char encr_keys[4][32];
  339. int encr_key_len[4];
  340. int wpa_version;
  341. int wpa_keymgmt;
  342. int wpa_authalg;
  343. int wpa_ie_len;
  344. u8 *wpa_ie;
  345. int wpa_cipher_pair;
  346. int wpa_cipher_group;
  347. u8 command_buffer[COMMAND_BUFFER_SIZE];
  348. };
  349. /*
  350. * cfg80211 ops
  351. */
  352. static int rndis_change_virtual_intf(struct wiphy *wiphy, int ifindex,
  353. enum nl80211_iftype type, u32 *flags,
  354. struct vif_params *params);
  355. static int rndis_scan(struct wiphy *wiphy, struct net_device *dev,
  356. struct cfg80211_scan_request *request);
  357. static struct cfg80211_ops rndis_config_ops = {
  358. .change_virtual_intf = rndis_change_virtual_intf,
  359. .scan = rndis_scan,
  360. };
  361. static void *rndis_wiphy_privid = &rndis_wiphy_privid;
  362. static const int bcm4320_power_output[4] = { 25, 50, 75, 100 };
  363. static const unsigned char zero_bssid[ETH_ALEN] = {0,};
  364. static const unsigned char ffff_bssid[ETH_ALEN] = { 0xff, 0xff, 0xff,
  365. 0xff, 0xff, 0xff };
  366. static struct rndis_wext_private *get_rndis_wext_priv(struct usbnet *dev)
  367. {
  368. return (struct rndis_wext_private *)dev->driver_priv;
  369. }
  370. static u32 get_bcm4320_power(struct rndis_wext_private *priv)
  371. {
  372. return BCM4320_DEFAULT_TXPOWER *
  373. bcm4320_power_output[priv->param_power_output] / 100;
  374. }
  375. /* translate error code */
  376. static int rndis_error_status(__le32 rndis_status)
  377. {
  378. int ret = -EINVAL;
  379. switch (rndis_status) {
  380. case RNDIS_STATUS_SUCCESS:
  381. ret = 0;
  382. break;
  383. case RNDIS_STATUS_FAILURE:
  384. case RNDIS_STATUS_INVALID_DATA:
  385. ret = -EINVAL;
  386. break;
  387. case RNDIS_STATUS_NOT_SUPPORTED:
  388. ret = -EOPNOTSUPP;
  389. break;
  390. case RNDIS_STATUS_ADAPTER_NOT_READY:
  391. case RNDIS_STATUS_ADAPTER_NOT_OPEN:
  392. ret = -EBUSY;
  393. break;
  394. }
  395. return ret;
  396. }
  397. static int rndis_query_oid(struct usbnet *dev, __le32 oid, void *data, int *len)
  398. {
  399. struct rndis_wext_private *priv = get_rndis_wext_priv(dev);
  400. union {
  401. void *buf;
  402. struct rndis_msg_hdr *header;
  403. struct rndis_query *get;
  404. struct rndis_query_c *get_c;
  405. } u;
  406. int ret, buflen;
  407. buflen = *len + sizeof(*u.get);
  408. if (buflen < CONTROL_BUFFER_SIZE)
  409. buflen = CONTROL_BUFFER_SIZE;
  410. if (buflen > COMMAND_BUFFER_SIZE) {
  411. u.buf = kmalloc(buflen, GFP_KERNEL);
  412. if (!u.buf)
  413. return -ENOMEM;
  414. } else {
  415. u.buf = priv->command_buffer;
  416. }
  417. mutex_lock(&priv->command_lock);
  418. memset(u.get, 0, sizeof *u.get);
  419. u.get->msg_type = RNDIS_MSG_QUERY;
  420. u.get->msg_len = cpu_to_le32(sizeof *u.get);
  421. u.get->oid = oid;
  422. ret = rndis_command(dev, u.header, buflen);
  423. if (ret == 0) {
  424. ret = le32_to_cpu(u.get_c->len);
  425. *len = (*len > ret) ? ret : *len;
  426. memcpy(data, u.buf + le32_to_cpu(u.get_c->offset) + 8, *len);
  427. ret = rndis_error_status(u.get_c->status);
  428. }
  429. mutex_unlock(&priv->command_lock);
  430. if (u.buf != priv->command_buffer)
  431. kfree(u.buf);
  432. return ret;
  433. }
  434. static int rndis_set_oid(struct usbnet *dev, __le32 oid, void *data, int len)
  435. {
  436. struct rndis_wext_private *priv = get_rndis_wext_priv(dev);
  437. union {
  438. void *buf;
  439. struct rndis_msg_hdr *header;
  440. struct rndis_set *set;
  441. struct rndis_set_c *set_c;
  442. } u;
  443. int ret, buflen;
  444. buflen = len + sizeof(*u.set);
  445. if (buflen < CONTROL_BUFFER_SIZE)
  446. buflen = CONTROL_BUFFER_SIZE;
  447. if (buflen > COMMAND_BUFFER_SIZE) {
  448. u.buf = kmalloc(buflen, GFP_KERNEL);
  449. if (!u.buf)
  450. return -ENOMEM;
  451. } else {
  452. u.buf = priv->command_buffer;
  453. }
  454. mutex_lock(&priv->command_lock);
  455. memset(u.set, 0, sizeof *u.set);
  456. u.set->msg_type = RNDIS_MSG_SET;
  457. u.set->msg_len = cpu_to_le32(sizeof(*u.set) + len);
  458. u.set->oid = oid;
  459. u.set->len = cpu_to_le32(len);
  460. u.set->offset = cpu_to_le32(sizeof(*u.set) - 8);
  461. u.set->handle = cpu_to_le32(0);
  462. memcpy(u.buf + sizeof(*u.set), data, len);
  463. ret = rndis_command(dev, u.header, buflen);
  464. if (ret == 0)
  465. ret = rndis_error_status(u.set_c->status);
  466. mutex_unlock(&priv->command_lock);
  467. if (u.buf != priv->command_buffer)
  468. kfree(u.buf);
  469. return ret;
  470. }
  471. /*
  472. * Specs say that we can only set config parameters only soon after device
  473. * initialization.
  474. * value_type: 0 = u32, 2 = unicode string
  475. */
  476. static int rndis_set_config_parameter(struct usbnet *dev, char *param,
  477. int value_type, void *value)
  478. {
  479. struct ndis_config_param *infobuf;
  480. int value_len, info_len, param_len, ret, i;
  481. __le16 *unibuf;
  482. __le32 *dst_value;
  483. if (value_type == 0)
  484. value_len = sizeof(__le32);
  485. else if (value_type == 2)
  486. value_len = strlen(value) * sizeof(__le16);
  487. else
  488. return -EINVAL;
  489. param_len = strlen(param) * sizeof(__le16);
  490. info_len = sizeof(*infobuf) + param_len + value_len;
  491. #ifdef DEBUG
  492. info_len += 12;
  493. #endif
  494. infobuf = kmalloc(info_len, GFP_KERNEL);
  495. if (!infobuf)
  496. return -ENOMEM;
  497. #ifdef DEBUG
  498. info_len -= 12;
  499. /* extra 12 bytes are for padding (debug output) */
  500. memset(infobuf, 0xCC, info_len + 12);
  501. #endif
  502. if (value_type == 2)
  503. devdbg(dev, "setting config parameter: %s, value: %s",
  504. param, (u8 *)value);
  505. else
  506. devdbg(dev, "setting config parameter: %s, value: %d",
  507. param, *(u32 *)value);
  508. infobuf->name_offs = cpu_to_le32(sizeof(*infobuf));
  509. infobuf->name_length = cpu_to_le32(param_len);
  510. infobuf->type = cpu_to_le32(value_type);
  511. infobuf->value_offs = cpu_to_le32(sizeof(*infobuf) + param_len);
  512. infobuf->value_length = cpu_to_le32(value_len);
  513. /* simple string to unicode string conversion */
  514. unibuf = (void *)infobuf + sizeof(*infobuf);
  515. for (i = 0; i < param_len / sizeof(__le16); i++)
  516. unibuf[i] = cpu_to_le16(param[i]);
  517. if (value_type == 2) {
  518. unibuf = (void *)infobuf + sizeof(*infobuf) + param_len;
  519. for (i = 0; i < value_len / sizeof(__le16); i++)
  520. unibuf[i] = cpu_to_le16(((u8 *)value)[i]);
  521. } else {
  522. dst_value = (void *)infobuf + sizeof(*infobuf) + param_len;
  523. *dst_value = cpu_to_le32(*(u32 *)value);
  524. }
  525. #ifdef DEBUG
  526. devdbg(dev, "info buffer (len: %d):", info_len);
  527. for (i = 0; i < info_len; i += 12) {
  528. u32 *tmp = (u32 *)((u8 *)infobuf + i);
  529. devdbg(dev, "%08X:%08X:%08X",
  530. cpu_to_be32(tmp[0]),
  531. cpu_to_be32(tmp[1]),
  532. cpu_to_be32(tmp[2]));
  533. }
  534. #endif
  535. ret = rndis_set_oid(dev, OID_GEN_RNDIS_CONFIG_PARAMETER,
  536. infobuf, info_len);
  537. if (ret != 0)
  538. devdbg(dev, "setting rndis config paramater failed, %d.", ret);
  539. kfree(infobuf);
  540. return ret;
  541. }
  542. static int rndis_set_config_parameter_str(struct usbnet *dev,
  543. char *param, char *value)
  544. {
  545. return(rndis_set_config_parameter(dev, param, 2, value));
  546. }
  547. /*static int rndis_set_config_parameter_u32(struct usbnet *dev,
  548. char *param, u32 value)
  549. {
  550. return(rndis_set_config_parameter(dev, param, 0, &value));
  551. }*/
  552. /*
  553. * data conversion functions
  554. */
  555. static int level_to_qual(int level)
  556. {
  557. int qual = 100 * (level - WL_NOISE) / (WL_SIGMAX - WL_NOISE);
  558. return qual >= 0 ? (qual <= 100 ? qual : 100) : 0;
  559. }
  560. static void dsconfig_to_freq(unsigned int dsconfig, struct iw_freq *freq)
  561. {
  562. freq->e = 0;
  563. freq->i = 0;
  564. freq->flags = 0;
  565. /* see comment in wireless.h above the "struct iw_freq"
  566. * definition for an explanation of this if
  567. * NOTE: 1000000 is due to the kHz
  568. */
  569. if (dsconfig > 1000000) {
  570. freq->m = dsconfig / 10;
  571. freq->e = 1;
  572. } else
  573. freq->m = dsconfig;
  574. /* convert from kHz to Hz */
  575. freq->e += 3;
  576. }
  577. static int freq_to_dsconfig(struct iw_freq *freq, unsigned int *dsconfig)
  578. {
  579. if (freq->m < 1000 && freq->e == 0) {
  580. if (freq->m >= 1 && freq->m <= 14)
  581. *dsconfig = ieee80211_dsss_chan_to_freq(freq->m) * 1000;
  582. else
  583. return -1;
  584. } else {
  585. int i;
  586. *dsconfig = freq->m;
  587. for (i = freq->e; i > 0; i--)
  588. *dsconfig *= 10;
  589. *dsconfig /= 1000;
  590. }
  591. return 0;
  592. }
  593. /*
  594. * common functions
  595. */
  596. static int
  597. add_wep_key(struct usbnet *usbdev, char *key, int key_len, int index);
  598. static int get_essid(struct usbnet *usbdev, struct ndis_80211_ssid *ssid)
  599. {
  600. int ret, len;
  601. len = sizeof(*ssid);
  602. ret = rndis_query_oid(usbdev, OID_802_11_SSID, ssid, &len);
  603. if (ret != 0)
  604. ssid->length = 0;
  605. #ifdef DEBUG
  606. {
  607. unsigned char tmp[NDIS_802_11_LENGTH_SSID + 1];
  608. memcpy(tmp, ssid->essid, le32_to_cpu(ssid->length));
  609. tmp[le32_to_cpu(ssid->length)] = 0;
  610. devdbg(usbdev, "get_essid: '%s', ret: %d", tmp, ret);
  611. }
  612. #endif
  613. return ret;
  614. }
  615. static int set_essid(struct usbnet *usbdev, struct ndis_80211_ssid *ssid)
  616. {
  617. struct rndis_wext_private *priv = get_rndis_wext_priv(usbdev);
  618. int ret;
  619. ret = rndis_set_oid(usbdev, OID_802_11_SSID, ssid, sizeof(*ssid));
  620. if (ret == 0) {
  621. memcpy(&priv->essid, ssid, sizeof(priv->essid));
  622. priv->radio_on = 1;
  623. devdbg(usbdev, "set_essid: radio_on = 1");
  624. }
  625. return ret;
  626. }
  627. static int get_bssid(struct usbnet *usbdev, u8 bssid[ETH_ALEN])
  628. {
  629. int ret, len;
  630. len = ETH_ALEN;
  631. ret = rndis_query_oid(usbdev, OID_802_11_BSSID, bssid, &len);
  632. if (ret != 0)
  633. memset(bssid, 0, ETH_ALEN);
  634. return ret;
  635. }
  636. static int get_association_info(struct usbnet *usbdev,
  637. struct ndis_80211_assoc_info *info, int len)
  638. {
  639. return rndis_query_oid(usbdev, OID_802_11_ASSOCIATION_INFORMATION,
  640. info, &len);
  641. }
  642. static int is_associated(struct usbnet *usbdev)
  643. {
  644. u8 bssid[ETH_ALEN];
  645. int ret;
  646. ret = get_bssid(usbdev, bssid);
  647. return(ret == 0 && memcmp(bssid, zero_bssid, ETH_ALEN) != 0);
  648. }
  649. static int disassociate(struct usbnet *usbdev, int reset_ssid)
  650. {
  651. struct rndis_wext_private *priv = get_rndis_wext_priv(usbdev);
  652. struct ndis_80211_ssid ssid;
  653. int i, ret = 0;
  654. if (priv->radio_on) {
  655. ret = rndis_set_oid(usbdev, OID_802_11_DISASSOCIATE, NULL, 0);
  656. if (ret == 0) {
  657. priv->radio_on = 0;
  658. devdbg(usbdev, "disassociate: radio_on = 0");
  659. if (reset_ssid)
  660. msleep(100);
  661. }
  662. }
  663. /* disassociate causes radio to be turned off; if reset_ssid
  664. * is given, set random ssid to enable radio */
  665. if (reset_ssid) {
  666. ssid.length = cpu_to_le32(sizeof(ssid.essid));
  667. get_random_bytes(&ssid.essid[2], sizeof(ssid.essid)-2);
  668. ssid.essid[0] = 0x1;
  669. ssid.essid[1] = 0xff;
  670. for (i = 2; i < sizeof(ssid.essid); i++)
  671. ssid.essid[i] = 0x1 + (ssid.essid[i] * 0xfe / 0xff);
  672. ret = set_essid(usbdev, &ssid);
  673. }
  674. return ret;
  675. }
  676. static int set_auth_mode(struct usbnet *usbdev, int wpa_version, int authalg)
  677. {
  678. struct rndis_wext_private *priv = get_rndis_wext_priv(usbdev);
  679. __le32 tmp;
  680. int auth_mode, ret;
  681. devdbg(usbdev, "set_auth_mode: wpa_version=0x%x authalg=0x%x "
  682. "keymgmt=0x%x", wpa_version, authalg, priv->wpa_keymgmt);
  683. if (wpa_version & IW_AUTH_WPA_VERSION_WPA2) {
  684. if (priv->wpa_keymgmt & IW_AUTH_KEY_MGMT_802_1X)
  685. auth_mode = ndis_80211_auth_wpa2;
  686. else
  687. auth_mode = ndis_80211_auth_wpa2_psk;
  688. } else if (wpa_version & IW_AUTH_WPA_VERSION_WPA) {
  689. if (priv->wpa_keymgmt & IW_AUTH_KEY_MGMT_802_1X)
  690. auth_mode = ndis_80211_auth_wpa;
  691. else if (priv->wpa_keymgmt & IW_AUTH_KEY_MGMT_PSK)
  692. auth_mode = ndis_80211_auth_wpa_psk;
  693. else
  694. auth_mode = ndis_80211_auth_wpa_none;
  695. } else if (authalg & IW_AUTH_ALG_SHARED_KEY) {
  696. if (authalg & IW_AUTH_ALG_OPEN_SYSTEM)
  697. auth_mode = ndis_80211_auth_auto_switch;
  698. else
  699. auth_mode = ndis_80211_auth_shared;
  700. } else
  701. auth_mode = ndis_80211_auth_open;
  702. tmp = cpu_to_le32(auth_mode);
  703. ret = rndis_set_oid(usbdev, OID_802_11_AUTHENTICATION_MODE, &tmp,
  704. sizeof(tmp));
  705. if (ret != 0) {
  706. devwarn(usbdev, "setting auth mode failed (%08X)", ret);
  707. return ret;
  708. }
  709. priv->wpa_version = wpa_version;
  710. priv->wpa_authalg = authalg;
  711. return 0;
  712. }
  713. static int set_priv_filter(struct usbnet *usbdev)
  714. {
  715. struct rndis_wext_private *priv = get_rndis_wext_priv(usbdev);
  716. __le32 tmp;
  717. devdbg(usbdev, "set_priv_filter: wpa_version=0x%x", priv->wpa_version);
  718. if (priv->wpa_version & IW_AUTH_WPA_VERSION_WPA2 ||
  719. priv->wpa_version & IW_AUTH_WPA_VERSION_WPA)
  720. tmp = cpu_to_le32(ndis_80211_priv_8021x_wep);
  721. else
  722. tmp = cpu_to_le32(ndis_80211_priv_accept_all);
  723. return rndis_set_oid(usbdev, OID_802_11_PRIVACY_FILTER, &tmp,
  724. sizeof(tmp));
  725. }
  726. static int set_encr_mode(struct usbnet *usbdev, int pairwise, int groupwise)
  727. {
  728. struct rndis_wext_private *priv = get_rndis_wext_priv(usbdev);
  729. __le32 tmp;
  730. int encr_mode, ret;
  731. devdbg(usbdev, "set_encr_mode: cipher_pair=0x%x cipher_group=0x%x",
  732. pairwise,
  733. groupwise);
  734. if (pairwise & IW_AUTH_CIPHER_CCMP)
  735. encr_mode = ndis_80211_encr_ccmp_enabled;
  736. else if (pairwise & IW_AUTH_CIPHER_TKIP)
  737. encr_mode = ndis_80211_encr_tkip_enabled;
  738. else if (pairwise &
  739. (IW_AUTH_CIPHER_WEP40 | IW_AUTH_CIPHER_WEP104))
  740. encr_mode = ndis_80211_encr_wep_enabled;
  741. else if (groupwise & IW_AUTH_CIPHER_CCMP)
  742. encr_mode = ndis_80211_encr_ccmp_enabled;
  743. else if (groupwise & IW_AUTH_CIPHER_TKIP)
  744. encr_mode = ndis_80211_encr_tkip_enabled;
  745. else
  746. encr_mode = ndis_80211_encr_disabled;
  747. tmp = cpu_to_le32(encr_mode);
  748. ret = rndis_set_oid(usbdev, OID_802_11_ENCRYPTION_STATUS, &tmp,
  749. sizeof(tmp));
  750. if (ret != 0) {
  751. devwarn(usbdev, "setting encr mode failed (%08X)", ret);
  752. return ret;
  753. }
  754. priv->wpa_cipher_pair = pairwise;
  755. priv->wpa_cipher_group = groupwise;
  756. return 0;
  757. }
  758. static int set_assoc_params(struct usbnet *usbdev)
  759. {
  760. struct rndis_wext_private *priv = get_rndis_wext_priv(usbdev);
  761. set_auth_mode(usbdev, priv->wpa_version, priv->wpa_authalg);
  762. set_priv_filter(usbdev);
  763. set_encr_mode(usbdev, priv->wpa_cipher_pair, priv->wpa_cipher_group);
  764. return 0;
  765. }
  766. static int set_infra_mode(struct usbnet *usbdev, int mode)
  767. {
  768. struct rndis_wext_private *priv = get_rndis_wext_priv(usbdev);
  769. __le32 tmp;
  770. int ret, i;
  771. devdbg(usbdev, "set_infra_mode: infra_mode=0x%x", priv->infra_mode);
  772. tmp = cpu_to_le32(mode);
  773. ret = rndis_set_oid(usbdev, OID_802_11_INFRASTRUCTURE_MODE, &tmp,
  774. sizeof(tmp));
  775. if (ret != 0) {
  776. devwarn(usbdev, "setting infra mode failed (%08X)", ret);
  777. return ret;
  778. }
  779. /* NDIS drivers clear keys when infrastructure mode is
  780. * changed. But Linux tools assume otherwise. So set the
  781. * keys */
  782. if (priv->wpa_keymgmt == 0 ||
  783. priv->wpa_keymgmt == IW_AUTH_KEY_MGMT_802_1X) {
  784. for (i = 0; i < 4; i++) {
  785. if (priv->encr_key_len[i] > 0)
  786. add_wep_key(usbdev, priv->encr_keys[i],
  787. priv->encr_key_len[i], i);
  788. }
  789. }
  790. priv->infra_mode = mode;
  791. return 0;
  792. }
  793. static void set_default_iw_params(struct usbnet *usbdev)
  794. {
  795. struct rndis_wext_private *priv = get_rndis_wext_priv(usbdev);
  796. priv->wpa_keymgmt = 0;
  797. priv->wpa_version = 0;
  798. set_infra_mode(usbdev, ndis_80211_infra_infra);
  799. set_auth_mode(usbdev, IW_AUTH_WPA_VERSION_DISABLED,
  800. IW_AUTH_ALG_OPEN_SYSTEM);
  801. set_priv_filter(usbdev);
  802. set_encr_mode(usbdev, IW_AUTH_CIPHER_NONE, IW_AUTH_CIPHER_NONE);
  803. }
  804. static int deauthenticate(struct usbnet *usbdev)
  805. {
  806. int ret;
  807. ret = disassociate(usbdev, 1);
  808. set_default_iw_params(usbdev);
  809. return ret;
  810. }
  811. /* index must be 0 - N, as per NDIS */
  812. static int add_wep_key(struct usbnet *usbdev, char *key, int key_len, int index)
  813. {
  814. struct rndis_wext_private *priv = get_rndis_wext_priv(usbdev);
  815. struct ndis_80211_wep_key ndis_key;
  816. int ret;
  817. if (key_len <= 0 || key_len > 32 || index < 0 || index >= 4)
  818. return -EINVAL;
  819. memset(&ndis_key, 0, sizeof(ndis_key));
  820. ndis_key.size = cpu_to_le32(sizeof(ndis_key));
  821. ndis_key.length = cpu_to_le32(key_len);
  822. ndis_key.index = cpu_to_le32(index);
  823. memcpy(&ndis_key.material, key, key_len);
  824. if (index == priv->encr_tx_key_index) {
  825. ndis_key.index |= cpu_to_le32(1 << 31);
  826. ret = set_encr_mode(usbdev, IW_AUTH_CIPHER_WEP104,
  827. IW_AUTH_CIPHER_NONE);
  828. if (ret)
  829. devwarn(usbdev, "encryption couldn't be enabled (%08X)",
  830. ret);
  831. }
  832. ret = rndis_set_oid(usbdev, OID_802_11_ADD_WEP, &ndis_key,
  833. sizeof(ndis_key));
  834. if (ret != 0) {
  835. devwarn(usbdev, "adding encryption key %d failed (%08X)",
  836. index+1, ret);
  837. return ret;
  838. }
  839. priv->encr_key_len[index] = key_len;
  840. memcpy(&priv->encr_keys[index], key, key_len);
  841. return 0;
  842. }
  843. /* remove_key is for both wep and wpa */
  844. static int remove_key(struct usbnet *usbdev, int index, u8 bssid[ETH_ALEN])
  845. {
  846. struct rndis_wext_private *priv = get_rndis_wext_priv(usbdev);
  847. struct ndis_80211_remove_key remove_key;
  848. __le32 keyindex;
  849. int ret;
  850. if (priv->encr_key_len[index] == 0)
  851. return 0;
  852. priv->encr_key_len[index] = 0;
  853. memset(&priv->encr_keys[index], 0, sizeof(priv->encr_keys[index]));
  854. if (priv->wpa_cipher_pair == IW_AUTH_CIPHER_TKIP ||
  855. priv->wpa_cipher_pair == IW_AUTH_CIPHER_CCMP ||
  856. priv->wpa_cipher_group == IW_AUTH_CIPHER_TKIP ||
  857. priv->wpa_cipher_group == IW_AUTH_CIPHER_CCMP) {
  858. remove_key.size = cpu_to_le32(sizeof(remove_key));
  859. remove_key.index = cpu_to_le32(index);
  860. if (bssid) {
  861. /* pairwise key */
  862. if (memcmp(bssid, ffff_bssid, ETH_ALEN) != 0)
  863. remove_key.index |= cpu_to_le32(1 << 30);
  864. memcpy(remove_key.bssid, bssid,
  865. sizeof(remove_key.bssid));
  866. } else
  867. memset(remove_key.bssid, 0xff,
  868. sizeof(remove_key.bssid));
  869. ret = rndis_set_oid(usbdev, OID_802_11_REMOVE_KEY, &remove_key,
  870. sizeof(remove_key));
  871. if (ret != 0)
  872. return ret;
  873. } else {
  874. keyindex = cpu_to_le32(index);
  875. ret = rndis_set_oid(usbdev, OID_802_11_REMOVE_WEP, &keyindex,
  876. sizeof(keyindex));
  877. if (ret != 0) {
  878. devwarn(usbdev,
  879. "removing encryption key %d failed (%08X)",
  880. index, ret);
  881. return ret;
  882. }
  883. }
  884. /* if it is transmit key, disable encryption */
  885. if (index == priv->encr_tx_key_index)
  886. set_encr_mode(usbdev, IW_AUTH_CIPHER_NONE, IW_AUTH_CIPHER_NONE);
  887. return 0;
  888. }
  889. static void set_multicast_list(struct usbnet *usbdev)
  890. {
  891. struct rndis_wext_private *priv = get_rndis_wext_priv(usbdev);
  892. struct dev_mc_list *mclist;
  893. __le32 filter;
  894. int ret, i, size;
  895. char *buf;
  896. filter = RNDIS_PACKET_TYPE_DIRECTED | RNDIS_PACKET_TYPE_BROADCAST;
  897. if (usbdev->net->flags & IFF_PROMISC) {
  898. filter |= RNDIS_PACKET_TYPE_PROMISCUOUS |
  899. RNDIS_PACKET_TYPE_ALL_LOCAL;
  900. } else if (usbdev->net->flags & IFF_ALLMULTI ||
  901. usbdev->net->mc_count > priv->multicast_size) {
  902. filter |= RNDIS_PACKET_TYPE_ALL_MULTICAST;
  903. } else if (usbdev->net->mc_count > 0) {
  904. size = min(priv->multicast_size, usbdev->net->mc_count);
  905. buf = kmalloc(size * ETH_ALEN, GFP_KERNEL);
  906. if (!buf) {
  907. devwarn(usbdev,
  908. "couldn't alloc %d bytes of memory",
  909. size * ETH_ALEN);
  910. return;
  911. }
  912. mclist = usbdev->net->mc_list;
  913. for (i = 0; i < size && mclist; mclist = mclist->next) {
  914. if (mclist->dmi_addrlen != ETH_ALEN)
  915. continue;
  916. memcpy(buf + i * ETH_ALEN, mclist->dmi_addr, ETH_ALEN);
  917. i++;
  918. }
  919. ret = rndis_set_oid(usbdev, OID_802_3_MULTICAST_LIST, buf,
  920. i * ETH_ALEN);
  921. if (ret == 0 && i > 0)
  922. filter |= RNDIS_PACKET_TYPE_MULTICAST;
  923. else
  924. filter |= RNDIS_PACKET_TYPE_ALL_MULTICAST;
  925. devdbg(usbdev, "OID_802_3_MULTICAST_LIST(%d, max: %d) -> %d",
  926. i, priv->multicast_size, ret);
  927. kfree(buf);
  928. }
  929. ret = rndis_set_oid(usbdev, OID_GEN_CURRENT_PACKET_FILTER, &filter,
  930. sizeof(filter));
  931. if (ret < 0) {
  932. devwarn(usbdev, "couldn't set packet filter: %08x",
  933. le32_to_cpu(filter));
  934. }
  935. devdbg(usbdev, "OID_GEN_CURRENT_PACKET_FILTER(%08x) -> %d",
  936. le32_to_cpu(filter), ret);
  937. }
  938. /*
  939. * cfg80211 ops
  940. */
  941. static int rndis_change_virtual_intf(struct wiphy *wiphy, int ifindex,
  942. enum nl80211_iftype type, u32 *flags,
  943. struct vif_params *params)
  944. {
  945. struct net_device *dev;
  946. struct usbnet *usbdev;
  947. int mode;
  948. /* we're under RTNL */
  949. dev = __dev_get_by_index(&init_net, ifindex);
  950. if (!dev)
  951. return -ENODEV;
  952. usbdev = netdev_priv(dev);
  953. switch (type) {
  954. case NL80211_IFTYPE_ADHOC:
  955. mode = ndis_80211_infra_adhoc;
  956. break;
  957. case NL80211_IFTYPE_STATION:
  958. mode = ndis_80211_infra_infra;
  959. break;
  960. default:
  961. return -EINVAL;
  962. }
  963. return set_infra_mode(usbdev, mode);
  964. }
  965. #define SCAN_DELAY_JIFFIES (HZ)
  966. static int rndis_scan(struct wiphy *wiphy, struct net_device *dev,
  967. struct cfg80211_scan_request *request)
  968. {
  969. struct usbnet *usbdev = netdev_priv(dev);
  970. struct rndis_wext_private *priv = get_rndis_wext_priv(usbdev);
  971. int ret;
  972. __le32 tmp;
  973. devdbg(usbdev, "cfg80211.scan");
  974. if (!request)
  975. return -EINVAL;
  976. if (priv->scan_request && priv->scan_request != request)
  977. return -EBUSY;
  978. priv->scan_request = request;
  979. tmp = cpu_to_le32(1);
  980. ret = rndis_set_oid(usbdev, OID_802_11_BSSID_LIST_SCAN, &tmp,
  981. sizeof(tmp));
  982. if (ret == 0) {
  983. /* Wait before retrieving scan results from device */
  984. queue_delayed_work(priv->workqueue, &priv->scan_work,
  985. SCAN_DELAY_JIFFIES);
  986. }
  987. return ret;
  988. }
  989. static struct cfg80211_bss *rndis_bss_info_update(struct usbnet *usbdev,
  990. struct ndis_80211_bssid_ex *bssid)
  991. {
  992. struct rndis_wext_private *priv = get_rndis_wext_priv(usbdev);
  993. struct ieee80211_channel *channel;
  994. s32 signal;
  995. u64 timestamp;
  996. u16 capability;
  997. u16 beacon_interval;
  998. struct ndis_80211_fixed_ies *fixed;
  999. int ie_len, bssid_len;
  1000. u8 *ie;
  1001. /* parse bssid structure */
  1002. bssid_len = le32_to_cpu(bssid->length);
  1003. if (bssid_len < sizeof(struct ndis_80211_bssid_ex) +
  1004. sizeof(struct ndis_80211_fixed_ies))
  1005. return NULL;
  1006. fixed = (struct ndis_80211_fixed_ies *)bssid->ies;
  1007. ie = (void *)(bssid->ies + sizeof(struct ndis_80211_fixed_ies));
  1008. ie_len = min(bssid_len - (int)sizeof(*bssid),
  1009. (int)le32_to_cpu(bssid->ie_length));
  1010. ie_len -= sizeof(struct ndis_80211_fixed_ies);
  1011. if (ie_len < 0)
  1012. return NULL;
  1013. /* extract data for cfg80211_inform_bss */
  1014. channel = ieee80211_get_channel(priv->wdev.wiphy,
  1015. KHZ_TO_MHZ(le32_to_cpu(bssid->config.ds_config)));
  1016. if (!channel)
  1017. return NULL;
  1018. signal = level_to_qual(le32_to_cpu(bssid->rssi));
  1019. timestamp = le64_to_cpu(*(__le64 *)fixed->timestamp);
  1020. capability = le16_to_cpu(fixed->capabilities);
  1021. beacon_interval = le16_to_cpu(fixed->beacon_interval);
  1022. return cfg80211_inform_bss(priv->wdev.wiphy, channel, bssid->mac,
  1023. timestamp, capability, beacon_interval, ie, ie_len, signal,
  1024. GFP_KERNEL);
  1025. }
  1026. static int rndis_check_bssid_list(struct usbnet *usbdev)
  1027. {
  1028. void *buf = NULL;
  1029. struct ndis_80211_bssid_list_ex *bssid_list;
  1030. struct ndis_80211_bssid_ex *bssid;
  1031. int ret = -EINVAL, len, count, bssid_len;
  1032. devdbg(usbdev, "check_bssid_list");
  1033. len = CONTROL_BUFFER_SIZE;
  1034. buf = kmalloc(len, GFP_KERNEL);
  1035. if (!buf) {
  1036. ret = -ENOMEM;
  1037. goto out;
  1038. }
  1039. ret = rndis_query_oid(usbdev, OID_802_11_BSSID_LIST, buf, &len);
  1040. if (ret != 0)
  1041. goto out;
  1042. bssid_list = buf;
  1043. bssid = bssid_list->bssid;
  1044. bssid_len = le32_to_cpu(bssid->length);
  1045. count = le32_to_cpu(bssid_list->num_items);
  1046. devdbg(usbdev, "check_bssid_list: %d BSSIDs found", count);
  1047. while (count && ((void *)bssid + bssid_len) <= (buf + len)) {
  1048. rndis_bss_info_update(usbdev, bssid);
  1049. bssid = (void *)bssid + bssid_len;
  1050. bssid_len = le32_to_cpu(bssid->length);
  1051. count--;
  1052. }
  1053. out:
  1054. kfree(buf);
  1055. return ret;
  1056. }
  1057. static void rndis_get_scan_results(struct work_struct *work)
  1058. {
  1059. struct rndis_wext_private *priv =
  1060. container_of(work, struct rndis_wext_private, scan_work.work);
  1061. struct usbnet *usbdev = priv->usbdev;
  1062. int ret;
  1063. devdbg(usbdev, "get_scan_results");
  1064. ret = rndis_check_bssid_list(usbdev);
  1065. cfg80211_scan_done(priv->scan_request, ret < 0);
  1066. priv->scan_request = NULL;
  1067. }
  1068. /*
  1069. * wireless extension handlers
  1070. */
  1071. static int rndis_iw_commit(struct net_device *dev,
  1072. struct iw_request_info *info, union iwreq_data *wrqu, char *extra)
  1073. {
  1074. /* dummy op */
  1075. return 0;
  1076. }
  1077. static int rndis_iw_set_essid(struct net_device *dev,
  1078. struct iw_request_info *info, union iwreq_data *wrqu, char *essid)
  1079. {
  1080. struct ndis_80211_ssid ssid;
  1081. int length = wrqu->essid.length;
  1082. struct usbnet *usbdev = netdev_priv(dev);
  1083. devdbg(usbdev, "SIOCSIWESSID: [flags:%d,len:%d] '%.32s'",
  1084. wrqu->essid.flags, wrqu->essid.length, essid);
  1085. if (length > NDIS_802_11_LENGTH_SSID)
  1086. length = NDIS_802_11_LENGTH_SSID;
  1087. ssid.length = cpu_to_le32(length);
  1088. if (length > 0)
  1089. memcpy(ssid.essid, essid, length);
  1090. else
  1091. memset(ssid.essid, 0, NDIS_802_11_LENGTH_SSID);
  1092. set_assoc_params(usbdev);
  1093. if (!wrqu->essid.flags || length == 0)
  1094. return disassociate(usbdev, 1);
  1095. else
  1096. return set_essid(usbdev, &ssid);
  1097. }
  1098. static int rndis_iw_get_essid(struct net_device *dev,
  1099. struct iw_request_info *info, union iwreq_data *wrqu, char *essid)
  1100. {
  1101. struct ndis_80211_ssid ssid;
  1102. struct usbnet *usbdev = netdev_priv(dev);
  1103. int ret;
  1104. ret = get_essid(usbdev, &ssid);
  1105. if (ret == 0 && le32_to_cpu(ssid.length) > 0) {
  1106. wrqu->essid.flags = 1;
  1107. wrqu->essid.length = le32_to_cpu(ssid.length);
  1108. memcpy(essid, ssid.essid, wrqu->essid.length);
  1109. essid[wrqu->essid.length] = 0;
  1110. } else {
  1111. memset(essid, 0, sizeof(NDIS_802_11_LENGTH_SSID));
  1112. wrqu->essid.flags = 0;
  1113. wrqu->essid.length = 0;
  1114. }
  1115. devdbg(usbdev, "SIOCGIWESSID: %s", essid);
  1116. return ret;
  1117. }
  1118. static int rndis_iw_get_bssid(struct net_device *dev,
  1119. struct iw_request_info *info, union iwreq_data *wrqu, char *extra)
  1120. {
  1121. struct usbnet *usbdev = netdev_priv(dev);
  1122. unsigned char bssid[ETH_ALEN];
  1123. int ret;
  1124. ret = get_bssid(usbdev, bssid);
  1125. if (ret == 0)
  1126. devdbg(usbdev, "SIOCGIWAP: %pM", bssid);
  1127. else
  1128. devdbg(usbdev, "SIOCGIWAP: <not associated>");
  1129. wrqu->ap_addr.sa_family = ARPHRD_ETHER;
  1130. memcpy(wrqu->ap_addr.sa_data, bssid, ETH_ALEN);
  1131. return ret;
  1132. }
  1133. static int rndis_iw_set_bssid(struct net_device *dev,
  1134. struct iw_request_info *info, union iwreq_data *wrqu, char *extra)
  1135. {
  1136. struct usbnet *usbdev = netdev_priv(dev);
  1137. u8 *bssid = (u8 *)wrqu->ap_addr.sa_data;
  1138. int ret;
  1139. devdbg(usbdev, "SIOCSIWAP: %pM", bssid);
  1140. ret = rndis_set_oid(usbdev, OID_802_11_BSSID, bssid, ETH_ALEN);
  1141. /* user apps may set ap's mac address, which is not required;
  1142. * they may fail to work if this function fails, so return
  1143. * success */
  1144. if (ret)
  1145. devwarn(usbdev, "setting AP mac address failed (%08X)", ret);
  1146. return 0;
  1147. }
  1148. static int rndis_iw_set_auth(struct net_device *dev,
  1149. struct iw_request_info *info, union iwreq_data *wrqu, char *extra)
  1150. {
  1151. struct iw_param *p = &wrqu->param;
  1152. struct usbnet *usbdev = netdev_priv(dev);
  1153. struct rndis_wext_private *priv = get_rndis_wext_priv(usbdev);
  1154. int ret = -ENOTSUPP;
  1155. switch (p->flags & IW_AUTH_INDEX) {
  1156. case IW_AUTH_WPA_VERSION:
  1157. devdbg(usbdev, "SIOCSIWAUTH: WPA_VERSION, %08x", p->value);
  1158. priv->wpa_version = p->value;
  1159. ret = 0;
  1160. break;
  1161. case IW_AUTH_CIPHER_PAIRWISE:
  1162. devdbg(usbdev, "SIOCSIWAUTH: CIPHER_PAIRWISE, %08x", p->value);
  1163. priv->wpa_cipher_pair = p->value;
  1164. ret = 0;
  1165. break;
  1166. case IW_AUTH_CIPHER_GROUP:
  1167. devdbg(usbdev, "SIOCSIWAUTH: CIPHER_GROUP, %08x", p->value);
  1168. priv->wpa_cipher_group = p->value;
  1169. ret = 0;
  1170. break;
  1171. case IW_AUTH_KEY_MGMT:
  1172. devdbg(usbdev, "SIOCSIWAUTH: KEY_MGMT, %08x", p->value);
  1173. priv->wpa_keymgmt = p->value;
  1174. ret = 0;
  1175. break;
  1176. case IW_AUTH_TKIP_COUNTERMEASURES:
  1177. devdbg(usbdev, "SIOCSIWAUTH: TKIP_COUNTERMEASURES, %08x",
  1178. p->value);
  1179. ret = 0;
  1180. break;
  1181. case IW_AUTH_DROP_UNENCRYPTED:
  1182. devdbg(usbdev, "SIOCSIWAUTH: DROP_UNENCRYPTED, %08x", p->value);
  1183. ret = 0;
  1184. break;
  1185. case IW_AUTH_80211_AUTH_ALG:
  1186. devdbg(usbdev, "SIOCSIWAUTH: 80211_AUTH_ALG, %08x", p->value);
  1187. priv->wpa_authalg = p->value;
  1188. ret = 0;
  1189. break;
  1190. case IW_AUTH_WPA_ENABLED:
  1191. devdbg(usbdev, "SIOCSIWAUTH: WPA_ENABLED, %08x", p->value);
  1192. if (wrqu->param.value)
  1193. deauthenticate(usbdev);
  1194. ret = 0;
  1195. break;
  1196. case IW_AUTH_RX_UNENCRYPTED_EAPOL:
  1197. devdbg(usbdev, "SIOCSIWAUTH: RX_UNENCRYPTED_EAPOL, %08x",
  1198. p->value);
  1199. ret = 0;
  1200. break;
  1201. case IW_AUTH_ROAMING_CONTROL:
  1202. devdbg(usbdev, "SIOCSIWAUTH: ROAMING_CONTROL, %08x", p->value);
  1203. ret = 0;
  1204. break;
  1205. case IW_AUTH_PRIVACY_INVOKED:
  1206. devdbg(usbdev, "SIOCSIWAUTH: invalid cmd %d",
  1207. wrqu->param.flags & IW_AUTH_INDEX);
  1208. return -EOPNOTSUPP;
  1209. default:
  1210. devdbg(usbdev, "SIOCSIWAUTH: UNKNOWN %08x, %08x",
  1211. p->flags & IW_AUTH_INDEX, p->value);
  1212. }
  1213. return ret;
  1214. }
  1215. static int rndis_iw_get_auth(struct net_device *dev,
  1216. struct iw_request_info *info, union iwreq_data *wrqu, char *extra)
  1217. {
  1218. struct iw_param *p = &wrqu->param;
  1219. struct usbnet *usbdev = netdev_priv(dev);
  1220. struct rndis_wext_private *priv = get_rndis_wext_priv(usbdev);
  1221. switch (p->flags & IW_AUTH_INDEX) {
  1222. case IW_AUTH_WPA_VERSION:
  1223. p->value = priv->wpa_version;
  1224. break;
  1225. case IW_AUTH_CIPHER_PAIRWISE:
  1226. p->value = priv->wpa_cipher_pair;
  1227. break;
  1228. case IW_AUTH_CIPHER_GROUP:
  1229. p->value = priv->wpa_cipher_group;
  1230. break;
  1231. case IW_AUTH_KEY_MGMT:
  1232. p->value = priv->wpa_keymgmt;
  1233. break;
  1234. case IW_AUTH_80211_AUTH_ALG:
  1235. p->value = priv->wpa_authalg;
  1236. break;
  1237. default:
  1238. devdbg(usbdev, "SIOCGIWAUTH: invalid cmd %d",
  1239. wrqu->param.flags & IW_AUTH_INDEX);
  1240. return -EOPNOTSUPP;
  1241. }
  1242. return 0;
  1243. }
  1244. static int rndis_iw_set_encode(struct net_device *dev,
  1245. struct iw_request_info *info, union iwreq_data *wrqu, char *extra)
  1246. {
  1247. struct usbnet *usbdev = netdev_priv(dev);
  1248. struct rndis_wext_private *priv = get_rndis_wext_priv(usbdev);
  1249. int ret, index, key_len;
  1250. u8 *key;
  1251. index = (wrqu->encoding.flags & IW_ENCODE_INDEX);
  1252. /* iwconfig gives index as 1 - N */
  1253. if (index > 0)
  1254. index--;
  1255. else
  1256. index = priv->encr_tx_key_index;
  1257. if (index < 0 || index >= 4) {
  1258. devwarn(usbdev, "encryption index out of range (%u)", index);
  1259. return -EINVAL;
  1260. }
  1261. /* remove key if disabled */
  1262. if (wrqu->data.flags & IW_ENCODE_DISABLED) {
  1263. if (remove_key(usbdev, index, NULL))
  1264. return -EINVAL;
  1265. else
  1266. return 0;
  1267. }
  1268. /* global encryption state (for all keys) */
  1269. if (wrqu->data.flags & IW_ENCODE_OPEN)
  1270. ret = set_auth_mode(usbdev, IW_AUTH_WPA_VERSION_DISABLED,
  1271. IW_AUTH_ALG_OPEN_SYSTEM);
  1272. else /*if (wrqu->data.flags & IW_ENCODE_RESTRICTED)*/
  1273. ret = set_auth_mode(usbdev, IW_AUTH_WPA_VERSION_DISABLED,
  1274. IW_AUTH_ALG_SHARED_KEY);
  1275. if (ret != 0)
  1276. return ret;
  1277. if (wrqu->data.length > 0) {
  1278. key_len = wrqu->data.length;
  1279. key = extra;
  1280. } else {
  1281. /* must be set as tx key */
  1282. if (priv->encr_key_len[index] == 0)
  1283. return -EINVAL;
  1284. key_len = priv->encr_key_len[index];
  1285. key = priv->encr_keys[index];
  1286. priv->encr_tx_key_index = index;
  1287. }
  1288. if (add_wep_key(usbdev, key, key_len, index) != 0)
  1289. return -EINVAL;
  1290. if (index == priv->encr_tx_key_index)
  1291. /* ndis drivers want essid to be set after setting encr */
  1292. set_essid(usbdev, &priv->essid);
  1293. return 0;
  1294. }
  1295. static int rndis_iw_set_encode_ext(struct net_device *dev,
  1296. struct iw_request_info *info, union iwreq_data *wrqu, char *extra)
  1297. {
  1298. struct iw_encode_ext *ext = (struct iw_encode_ext *)extra;
  1299. struct usbnet *usbdev = netdev_priv(dev);
  1300. struct rndis_wext_private *priv = get_rndis_wext_priv(usbdev);
  1301. struct ndis_80211_key ndis_key;
  1302. int keyidx, ret;
  1303. u8 *addr;
  1304. keyidx = wrqu->encoding.flags & IW_ENCODE_INDEX;
  1305. /* iwconfig gives index as 1 - N */
  1306. if (keyidx)
  1307. keyidx--;
  1308. else
  1309. keyidx = priv->encr_tx_key_index;
  1310. if (keyidx < 0 || keyidx >= 4)
  1311. return -EINVAL;
  1312. if (ext->alg == WPA_ALG_WEP) {
  1313. if (ext->ext_flags & IW_ENCODE_EXT_SET_TX_KEY)
  1314. priv->encr_tx_key_index = keyidx;
  1315. return add_wep_key(usbdev, ext->key, ext->key_len, keyidx);
  1316. }
  1317. if ((wrqu->encoding.flags & IW_ENCODE_DISABLED) ||
  1318. ext->alg == IW_ENCODE_ALG_NONE || ext->key_len == 0)
  1319. return remove_key(usbdev, keyidx, NULL);
  1320. if (ext->key_len > sizeof(ndis_key.material))
  1321. return -1;
  1322. memset(&ndis_key, 0, sizeof(ndis_key));
  1323. ndis_key.size = cpu_to_le32(sizeof(ndis_key) -
  1324. sizeof(ndis_key.material) + ext->key_len);
  1325. ndis_key.length = cpu_to_le32(ext->key_len);
  1326. ndis_key.index = cpu_to_le32(keyidx);
  1327. if (ext->ext_flags & IW_ENCODE_EXT_RX_SEQ_VALID) {
  1328. memcpy(ndis_key.rsc, ext->rx_seq, 6);
  1329. ndis_key.index |= cpu_to_le32(1 << 29);
  1330. }
  1331. addr = ext->addr.sa_data;
  1332. if (ext->ext_flags & IW_ENCODE_EXT_GROUP_KEY) {
  1333. /* group key */
  1334. if (priv->infra_mode == ndis_80211_infra_adhoc)
  1335. memset(ndis_key.bssid, 0xff, ETH_ALEN);
  1336. else
  1337. get_bssid(usbdev, ndis_key.bssid);
  1338. } else {
  1339. /* pairwise key */
  1340. ndis_key.index |= cpu_to_le32(1 << 30);
  1341. memcpy(ndis_key.bssid, addr, ETH_ALEN);
  1342. }
  1343. if (ext->ext_flags & IW_ENCODE_EXT_SET_TX_KEY)
  1344. ndis_key.index |= cpu_to_le32(1 << 31);
  1345. if (ext->alg == IW_ENCODE_ALG_TKIP && ext->key_len == 32) {
  1346. /* wpa_supplicant gives us the Michael MIC RX/TX keys in
  1347. * different order than NDIS spec, so swap the order here. */
  1348. memcpy(ndis_key.material, ext->key, 16);
  1349. memcpy(ndis_key.material + 16, ext->key + 24, 8);
  1350. memcpy(ndis_key.material + 24, ext->key + 16, 8);
  1351. } else
  1352. memcpy(ndis_key.material, ext->key, ext->key_len);
  1353. ret = rndis_set_oid(usbdev, OID_802_11_ADD_KEY, &ndis_key,
  1354. le32_to_cpu(ndis_key.size));
  1355. devdbg(usbdev, "SIOCSIWENCODEEXT: OID_802_11_ADD_KEY -> %08X", ret);
  1356. if (ret != 0)
  1357. return ret;
  1358. priv->encr_key_len[keyidx] = ext->key_len;
  1359. memcpy(&priv->encr_keys[keyidx], ndis_key.material, ext->key_len);
  1360. if (ext->ext_flags & IW_ENCODE_EXT_SET_TX_KEY)
  1361. priv->encr_tx_key_index = keyidx;
  1362. return 0;
  1363. }
  1364. static int rndis_iw_set_genie(struct net_device *dev,
  1365. struct iw_request_info *info, union iwreq_data *wrqu, char *extra)
  1366. {
  1367. struct usbnet *usbdev = netdev_priv(dev);
  1368. struct rndis_wext_private *priv = get_rndis_wext_priv(usbdev);
  1369. int ret = 0;
  1370. #ifdef DEBUG
  1371. int j;
  1372. u8 *gie = extra;
  1373. for (j = 0; j < wrqu->data.length; j += 8)
  1374. devdbg(usbdev,
  1375. "SIOCSIWGENIE %04x - "
  1376. "%02x %02x %02x %02x %02x %02x %02x %02x", j,
  1377. gie[j + 0], gie[j + 1], gie[j + 2], gie[j + 3],
  1378. gie[j + 4], gie[j + 5], gie[j + 6], gie[j + 7]);
  1379. #endif
  1380. /* clear existing IEs */
  1381. if (priv->wpa_ie_len) {
  1382. kfree(priv->wpa_ie);
  1383. priv->wpa_ie_len = 0;
  1384. }
  1385. /* set new IEs */
  1386. priv->wpa_ie = kmalloc(wrqu->data.length, GFP_KERNEL);
  1387. if (priv->wpa_ie) {
  1388. priv->wpa_ie_len = wrqu->data.length;
  1389. memcpy(priv->wpa_ie, extra, priv->wpa_ie_len);
  1390. } else
  1391. ret = -ENOMEM;
  1392. return ret;
  1393. }
  1394. static int rndis_iw_get_genie(struct net_device *dev,
  1395. struct iw_request_info *info, union iwreq_data *wrqu, char *extra)
  1396. {
  1397. struct usbnet *usbdev = netdev_priv(dev);
  1398. struct rndis_wext_private *priv = get_rndis_wext_priv(usbdev);
  1399. devdbg(usbdev, "SIOCGIWGENIE");
  1400. if (priv->wpa_ie_len == 0 || priv->wpa_ie == NULL) {
  1401. wrqu->data.length = 0;
  1402. return 0;
  1403. }
  1404. if (wrqu->data.length < priv->wpa_ie_len)
  1405. return -E2BIG;
  1406. wrqu->data.length = priv->wpa_ie_len;
  1407. memcpy(extra, priv->wpa_ie, priv->wpa_ie_len);
  1408. return 0;
  1409. }
  1410. static int rndis_iw_set_rts(struct net_device *dev,
  1411. struct iw_request_info *info, union iwreq_data *wrqu, char *extra)
  1412. {
  1413. struct usbnet *usbdev = netdev_priv(dev);
  1414. __le32 tmp;
  1415. devdbg(usbdev, "SIOCSIWRTS");
  1416. tmp = cpu_to_le32(wrqu->rts.value);
  1417. return rndis_set_oid(usbdev, OID_802_11_RTS_THRESHOLD, &tmp,
  1418. sizeof(tmp));
  1419. }
  1420. static int rndis_iw_get_rts(struct net_device *dev,
  1421. struct iw_request_info *info, union iwreq_data *wrqu, char *extra)
  1422. {
  1423. struct usbnet *usbdev = netdev_priv(dev);
  1424. __le32 tmp;
  1425. int len, ret;
  1426. len = sizeof(tmp);
  1427. ret = rndis_query_oid(usbdev, OID_802_11_RTS_THRESHOLD, &tmp, &len);
  1428. if (ret == 0) {
  1429. wrqu->rts.value = le32_to_cpu(tmp);
  1430. wrqu->rts.flags = 1;
  1431. wrqu->rts.disabled = 0;
  1432. }
  1433. devdbg(usbdev, "SIOCGIWRTS: %d", wrqu->rts.value);
  1434. return ret;
  1435. }
  1436. static int rndis_iw_set_frag(struct net_device *dev,
  1437. struct iw_request_info *info, union iwreq_data *wrqu, char *extra)
  1438. {
  1439. struct usbnet *usbdev = netdev_priv(dev);
  1440. __le32 tmp;
  1441. devdbg(usbdev, "SIOCSIWFRAG");
  1442. tmp = cpu_to_le32(wrqu->frag.value);
  1443. return rndis_set_oid(usbdev, OID_802_11_FRAGMENTATION_THRESHOLD, &tmp,
  1444. sizeof(tmp));
  1445. }
  1446. static int rndis_iw_get_frag(struct net_device *dev,
  1447. struct iw_request_info *info, union iwreq_data *wrqu, char *extra)
  1448. {
  1449. struct usbnet *usbdev = netdev_priv(dev);
  1450. __le32 tmp;
  1451. int len, ret;
  1452. len = sizeof(tmp);
  1453. ret = rndis_query_oid(usbdev, OID_802_11_FRAGMENTATION_THRESHOLD, &tmp,
  1454. &len);
  1455. if (ret == 0) {
  1456. wrqu->frag.value = le32_to_cpu(tmp);
  1457. wrqu->frag.flags = 1;
  1458. wrqu->frag.disabled = 0;
  1459. }
  1460. devdbg(usbdev, "SIOCGIWFRAG: %d", wrqu->frag.value);
  1461. return ret;
  1462. }
  1463. static int rndis_iw_set_freq(struct net_device *dev,
  1464. struct iw_request_info *info, union iwreq_data *wrqu, char *extra)
  1465. {
  1466. struct usbnet *usbdev = netdev_priv(dev);
  1467. struct ndis_80211_conf config;
  1468. unsigned int dsconfig;
  1469. int len, ret;
  1470. /* this OID is valid only when not associated */
  1471. if (is_associated(usbdev))
  1472. return 0;
  1473. dsconfig = 0;
  1474. if (freq_to_dsconfig(&wrqu->freq, &dsconfig))
  1475. return -EINVAL;
  1476. len = sizeof(config);
  1477. ret = rndis_query_oid(usbdev, OID_802_11_CONFIGURATION, &config, &len);
  1478. if (ret != 0) {
  1479. devdbg(usbdev, "SIOCSIWFREQ: querying configuration failed");
  1480. return 0;
  1481. }
  1482. config.ds_config = cpu_to_le32(dsconfig);
  1483. devdbg(usbdev, "SIOCSIWFREQ: %d * 10^%d", wrqu->freq.m, wrqu->freq.e);
  1484. return rndis_set_oid(usbdev, OID_802_11_CONFIGURATION, &config,
  1485. sizeof(config));
  1486. }
  1487. static int rndis_iw_get_freq(struct net_device *dev,
  1488. struct iw_request_info *info, union iwreq_data *wrqu, char *extra)
  1489. {
  1490. struct usbnet *usbdev = netdev_priv(dev);
  1491. struct ndis_80211_conf config;
  1492. int len, ret;
  1493. len = sizeof(config);
  1494. ret = rndis_query_oid(usbdev, OID_802_11_CONFIGURATION, &config, &len);
  1495. if (ret == 0)
  1496. dsconfig_to_freq(le32_to_cpu(config.ds_config), &wrqu->freq);
  1497. devdbg(usbdev, "SIOCGIWFREQ: %d", wrqu->freq.m);
  1498. return ret;
  1499. }
  1500. static int rndis_iw_get_txpower(struct net_device *dev,
  1501. struct iw_request_info *info, union iwreq_data *wrqu, char *extra)
  1502. {
  1503. struct usbnet *usbdev = netdev_priv(dev);
  1504. struct rndis_wext_private *priv = get_rndis_wext_priv(usbdev);
  1505. __le32 tx_power;
  1506. int ret = 0, len;
  1507. if (priv->radio_on) {
  1508. if (priv->caps & CAP_SUPPORT_TXPOWER) {
  1509. len = sizeof(tx_power);
  1510. ret = rndis_query_oid(usbdev, OID_802_11_TX_POWER_LEVEL,
  1511. &tx_power, &len);
  1512. if (ret != 0)
  1513. return ret;
  1514. } else
  1515. /* fake incase not supported */
  1516. tx_power = cpu_to_le32(get_bcm4320_power(priv));
  1517. wrqu->txpower.flags = IW_TXPOW_MWATT;
  1518. wrqu->txpower.value = le32_to_cpu(tx_power);
  1519. wrqu->txpower.disabled = 0;
  1520. } else {
  1521. wrqu->txpower.flags = IW_TXPOW_MWATT;
  1522. wrqu->txpower.value = 0;
  1523. wrqu->txpower.disabled = 1;
  1524. }
  1525. devdbg(usbdev, "SIOCGIWTXPOW: %d", wrqu->txpower.value);
  1526. return ret;
  1527. }
  1528. static int rndis_iw_set_txpower(struct net_device *dev,
  1529. struct iw_request_info *info, union iwreq_data *wrqu, char *extra)
  1530. {
  1531. struct usbnet *usbdev = netdev_priv(dev);
  1532. struct rndis_wext_private *priv = get_rndis_wext_priv(usbdev);
  1533. __le32 tx_power = 0;
  1534. int ret = 0;
  1535. if (!wrqu->txpower.disabled) {
  1536. if (wrqu->txpower.flags == IW_TXPOW_MWATT)
  1537. tx_power = cpu_to_le32(wrqu->txpower.value);
  1538. else { /* wrqu->txpower.flags == IW_TXPOW_DBM */
  1539. if (wrqu->txpower.value > 20)
  1540. tx_power = cpu_to_le32(128);
  1541. else if (wrqu->txpower.value < -43)
  1542. tx_power = cpu_to_le32(127);
  1543. else {
  1544. signed char tmp;
  1545. tmp = wrqu->txpower.value;
  1546. tmp = -12 - tmp;
  1547. tmp <<= 2;
  1548. tx_power = cpu_to_le32((unsigned char)tmp);
  1549. }
  1550. }
  1551. }
  1552. devdbg(usbdev, "SIOCSIWTXPOW: %d", le32_to_cpu(tx_power));
  1553. if (le32_to_cpu(tx_power) != 0) {
  1554. if (priv->caps & CAP_SUPPORT_TXPOWER) {
  1555. /* turn radio on first */
  1556. if (!priv->radio_on)
  1557. disassociate(usbdev, 1);
  1558. ret = rndis_set_oid(usbdev, OID_802_11_TX_POWER_LEVEL,
  1559. &tx_power, sizeof(tx_power));
  1560. if (ret != 0)
  1561. ret = -EOPNOTSUPP;
  1562. return ret;
  1563. } else {
  1564. /* txpower unsupported, just turn radio on */
  1565. if (!priv->radio_on)
  1566. return disassociate(usbdev, 1);
  1567. return 0; /* all ready on */
  1568. }
  1569. }
  1570. /* tx_power == 0, turn off radio */
  1571. return disassociate(usbdev, 0);
  1572. }
  1573. static int rndis_iw_get_rate(struct net_device *dev,
  1574. struct iw_request_info *info, union iwreq_data *wrqu, char *extra)
  1575. {
  1576. struct usbnet *usbdev = netdev_priv(dev);
  1577. __le32 tmp;
  1578. int ret, len;
  1579. len = sizeof(tmp);
  1580. ret = rndis_query_oid(usbdev, OID_GEN_LINK_SPEED, &tmp, &len);
  1581. if (ret == 0) {
  1582. wrqu->bitrate.value = le32_to_cpu(tmp) * 100;
  1583. wrqu->bitrate.disabled = 0;
  1584. wrqu->bitrate.flags = 1;
  1585. }
  1586. return ret;
  1587. }
  1588. static int rndis_iw_set_mlme(struct net_device *dev,
  1589. struct iw_request_info *info, union iwreq_data *wrqu, char *extra)
  1590. {
  1591. struct usbnet *usbdev = netdev_priv(dev);
  1592. struct rndis_wext_private *priv = get_rndis_wext_priv(usbdev);
  1593. struct iw_mlme *mlme = (struct iw_mlme *)extra;
  1594. unsigned char bssid[ETH_ALEN];
  1595. get_bssid(usbdev, bssid);
  1596. if (memcmp(bssid, mlme->addr.sa_data, ETH_ALEN))
  1597. return -EINVAL;
  1598. switch (mlme->cmd) {
  1599. case IW_MLME_DEAUTH:
  1600. return deauthenticate(usbdev);
  1601. case IW_MLME_DISASSOC:
  1602. return disassociate(usbdev, priv->radio_on);
  1603. default:
  1604. return -EOPNOTSUPP;
  1605. }
  1606. return 0;
  1607. }
  1608. static struct iw_statistics *rndis_get_wireless_stats(struct net_device *dev)
  1609. {
  1610. struct usbnet *usbdev = netdev_priv(dev);
  1611. struct rndis_wext_private *priv = get_rndis_wext_priv(usbdev);
  1612. unsigned long flags;
  1613. spin_lock_irqsave(&priv->stats_lock, flags);
  1614. memcpy(&priv->iwstats, &priv->privstats, sizeof(priv->iwstats));
  1615. spin_unlock_irqrestore(&priv->stats_lock, flags);
  1616. return &priv->iwstats;
  1617. }
  1618. #define IW_IOCTL(x) [(x) - SIOCSIWCOMMIT]
  1619. static const iw_handler rndis_iw_handler[] =
  1620. {
  1621. IW_IOCTL(SIOCSIWCOMMIT) = rndis_iw_commit,
  1622. IW_IOCTL(SIOCGIWNAME) = (iw_handler) cfg80211_wext_giwname,
  1623. IW_IOCTL(SIOCSIWFREQ) = rndis_iw_set_freq,
  1624. IW_IOCTL(SIOCGIWFREQ) = rndis_iw_get_freq,
  1625. IW_IOCTL(SIOCSIWMODE) = (iw_handler) cfg80211_wext_siwmode,
  1626. IW_IOCTL(SIOCGIWMODE) = (iw_handler) cfg80211_wext_giwmode,
  1627. IW_IOCTL(SIOCGIWRANGE) = (iw_handler) cfg80211_wext_giwrange,
  1628. IW_IOCTL(SIOCSIWAP) = rndis_iw_set_bssid,
  1629. IW_IOCTL(SIOCGIWAP) = rndis_iw_get_bssid,
  1630. IW_IOCTL(SIOCSIWSCAN) = (iw_handler) cfg80211_wext_siwscan,
  1631. IW_IOCTL(SIOCGIWSCAN) = (iw_handler) cfg80211_wext_giwscan,
  1632. IW_IOCTL(SIOCSIWESSID) = rndis_iw_set_essid,
  1633. IW_IOCTL(SIOCGIWESSID) = rndis_iw_get_essid,
  1634. IW_IOCTL(SIOCGIWRATE) = rndis_iw_get_rate,
  1635. IW_IOCTL(SIOCSIWRTS) = rndis_iw_set_rts,
  1636. IW_IOCTL(SIOCGIWRTS) = rndis_iw_get_rts,
  1637. IW_IOCTL(SIOCSIWFRAG) = rndis_iw_set_frag,
  1638. IW_IOCTL(SIOCGIWFRAG) = rndis_iw_get_frag,
  1639. IW_IOCTL(SIOCSIWTXPOW) = rndis_iw_set_txpower,
  1640. IW_IOCTL(SIOCGIWTXPOW) = rndis_iw_get_txpower,
  1641. IW_IOCTL(SIOCSIWENCODE) = rndis_iw_set_encode,
  1642. IW_IOCTL(SIOCSIWENCODEEXT) = rndis_iw_set_encode_ext,
  1643. IW_IOCTL(SIOCSIWAUTH) = rndis_iw_set_auth,
  1644. IW_IOCTL(SIOCGIWAUTH) = rndis_iw_get_auth,
  1645. IW_IOCTL(SIOCSIWGENIE) = rndis_iw_set_genie,
  1646. IW_IOCTL(SIOCGIWGENIE) = rndis_iw_get_genie,
  1647. IW_IOCTL(SIOCSIWMLME) = rndis_iw_set_mlme,
  1648. };
  1649. static const iw_handler rndis_wext_private_handler[] = {
  1650. };
  1651. static const struct iw_priv_args rndis_wext_private_args[] = {
  1652. };
  1653. static const struct iw_handler_def rndis_iw_handlers = {
  1654. .num_standard = ARRAY_SIZE(rndis_iw_handler),
  1655. .num_private = ARRAY_SIZE(rndis_wext_private_handler),
  1656. .num_private_args = ARRAY_SIZE(rndis_wext_private_args),
  1657. .standard = (iw_handler *)rndis_iw_handler,
  1658. .private = (iw_handler *)rndis_wext_private_handler,
  1659. .private_args = (struct iw_priv_args *)rndis_wext_private_args,
  1660. .get_wireless_stats = rndis_get_wireless_stats,
  1661. };
  1662. static void rndis_wext_worker(struct work_struct *work)
  1663. {
  1664. struct rndis_wext_private *priv =
  1665. container_of(work, struct rndis_wext_private, work);
  1666. struct usbnet *usbdev = priv->usbdev;
  1667. union iwreq_data evt;
  1668. unsigned char bssid[ETH_ALEN];
  1669. struct ndis_80211_assoc_info *info;
  1670. int assoc_size = sizeof(*info) + IW_CUSTOM_MAX + 32;
  1671. int ret, offset;
  1672. if (test_and_clear_bit(WORK_LINK_UP, &priv->work_pending)) {
  1673. netif_carrier_on(usbdev->net);
  1674. info = kzalloc(assoc_size, GFP_KERNEL);
  1675. if (!info)
  1676. goto get_bssid;
  1677. /* Get association info IEs from device and send them back to
  1678. * userspace. */
  1679. ret = get_association_info(usbdev, info, assoc_size);
  1680. if (!ret) {
  1681. evt.data.length = le32_to_cpu(info->req_ie_length);
  1682. if (evt.data.length > 0) {
  1683. offset = le32_to_cpu(info->offset_req_ies);
  1684. wireless_send_event(usbdev->net,
  1685. IWEVASSOCREQIE, &evt,
  1686. (char *)info + offset);
  1687. }
  1688. evt.data.length = le32_to_cpu(info->resp_ie_length);
  1689. if (evt.data.length > 0) {
  1690. offset = le32_to_cpu(info->offset_resp_ies);
  1691. wireless_send_event(usbdev->net,
  1692. IWEVASSOCRESPIE, &evt,
  1693. (char *)info + offset);
  1694. }
  1695. }
  1696. kfree(info);
  1697. get_bssid:
  1698. ret = get_bssid(usbdev, bssid);
  1699. if (!ret) {
  1700. evt.data.flags = 0;
  1701. evt.data.length = 0;
  1702. memcpy(evt.ap_addr.sa_data, bssid, ETH_ALEN);
  1703. wireless_send_event(usbdev->net, SIOCGIWAP, &evt, NULL);
  1704. }
  1705. }
  1706. if (test_and_clear_bit(WORK_LINK_DOWN, &priv->work_pending)) {
  1707. netif_carrier_off(usbdev->net);
  1708. evt.data.flags = 0;
  1709. evt.data.length = 0;
  1710. memset(evt.ap_addr.sa_data, 0, ETH_ALEN);
  1711. wireless_send_event(usbdev->net, SIOCGIWAP, &evt, NULL);
  1712. }
  1713. if (test_and_clear_bit(WORK_SET_MULTICAST_LIST, &priv->work_pending))
  1714. set_multicast_list(usbdev);
  1715. }
  1716. static void rndis_wext_set_multicast_list(struct net_device *dev)
  1717. {
  1718. struct usbnet *usbdev = netdev_priv(dev);
  1719. struct rndis_wext_private *priv = get_rndis_wext_priv(usbdev);
  1720. if (test_bit(WORK_SET_MULTICAST_LIST, &priv->work_pending))
  1721. return;
  1722. set_bit(WORK_SET_MULTICAST_LIST, &priv->work_pending);
  1723. queue_work(priv->workqueue, &priv->work);
  1724. }
  1725. static void rndis_wext_link_change(struct usbnet *usbdev, int state)
  1726. {
  1727. struct rndis_wext_private *priv = get_rndis_wext_priv(usbdev);
  1728. /* queue work to avoid recursive calls into rndis_command */
  1729. set_bit(state ? WORK_LINK_UP : WORK_LINK_DOWN, &priv->work_pending);
  1730. queue_work(priv->workqueue, &priv->work);
  1731. }
  1732. static int rndis_wext_get_caps(struct usbnet *usbdev)
  1733. {
  1734. struct {
  1735. __le32 num_items;
  1736. __le32 items[8];
  1737. } networks_supported;
  1738. int len, retval, i, n;
  1739. __le32 tx_power;
  1740. struct rndis_wext_private *priv = get_rndis_wext_priv(usbdev);
  1741. /* determine if supports setting txpower */
  1742. len = sizeof(tx_power);
  1743. retval = rndis_query_oid(usbdev, OID_802_11_TX_POWER_LEVEL, &tx_power,
  1744. &len);
  1745. if (retval == 0 && le32_to_cpu(tx_power) != 0xFF)
  1746. priv->caps |= CAP_SUPPORT_TXPOWER;
  1747. /* determine supported modes */
  1748. len = sizeof(networks_supported);
  1749. retval = rndis_query_oid(usbdev, OID_802_11_NETWORK_TYPES_SUPPORTED,
  1750. &networks_supported, &len);
  1751. if (retval >= 0) {
  1752. n = le32_to_cpu(networks_supported.num_items);
  1753. if (n > 8)
  1754. n = 8;
  1755. for (i = 0; i < n; i++) {
  1756. switch (le32_to_cpu(networks_supported.items[i])) {
  1757. case ndis_80211_type_freq_hop:
  1758. case ndis_80211_type_direct_seq:
  1759. priv->caps |= CAP_MODE_80211B;
  1760. break;
  1761. case ndis_80211_type_ofdm_a:
  1762. priv->caps |= CAP_MODE_80211A;
  1763. break;
  1764. case ndis_80211_type_ofdm_g:
  1765. priv->caps |= CAP_MODE_80211G;
  1766. break;
  1767. }
  1768. }
  1769. }
  1770. return retval;
  1771. }
  1772. #define STATS_UPDATE_JIFFIES (HZ)
  1773. static void rndis_update_wireless_stats(struct work_struct *work)
  1774. {
  1775. struct rndis_wext_private *priv =
  1776. container_of(work, struct rndis_wext_private, stats_work.work);
  1777. struct usbnet *usbdev = priv->usbdev;
  1778. struct iw_statistics iwstats;
  1779. __le32 rssi, tmp;
  1780. int len, ret, j;
  1781. unsigned long flags;
  1782. int update_jiffies = STATS_UPDATE_JIFFIES;
  1783. void *buf;
  1784. spin_lock_irqsave(&priv->stats_lock, flags);
  1785. memcpy(&iwstats, &priv->privstats, sizeof(iwstats));
  1786. spin_unlock_irqrestore(&priv->stats_lock, flags);
  1787. /* only update stats when connected */
  1788. if (!is_associated(usbdev)) {
  1789. iwstats.qual.qual = 0;
  1790. iwstats.qual.level = 0;
  1791. iwstats.qual.updated = IW_QUAL_QUAL_UPDATED
  1792. | IW_QUAL_LEVEL_UPDATED
  1793. | IW_QUAL_NOISE_INVALID
  1794. | IW_QUAL_QUAL_INVALID
  1795. | IW_QUAL_LEVEL_INVALID;
  1796. goto end;
  1797. }
  1798. len = sizeof(rssi);
  1799. ret = rndis_query_oid(usbdev, OID_802_11_RSSI, &rssi, &len);
  1800. devdbg(usbdev, "stats: OID_802_11_RSSI -> %d, rssi:%d", ret,
  1801. le32_to_cpu(rssi));
  1802. if (ret == 0) {
  1803. memset(&iwstats.qual, 0, sizeof(iwstats.qual));
  1804. iwstats.qual.qual = level_to_qual(le32_to_cpu(rssi));
  1805. iwstats.qual.level = level_to_qual(le32_to_cpu(rssi));
  1806. iwstats.qual.updated = IW_QUAL_QUAL_UPDATED
  1807. | IW_QUAL_LEVEL_UPDATED
  1808. | IW_QUAL_NOISE_INVALID;
  1809. }
  1810. memset(&iwstats.discard, 0, sizeof(iwstats.discard));
  1811. len = sizeof(tmp);
  1812. ret = rndis_query_oid(usbdev, OID_GEN_XMIT_ERROR, &tmp, &len);
  1813. if (ret == 0)
  1814. iwstats.discard.misc += le32_to_cpu(tmp);
  1815. len = sizeof(tmp);
  1816. ret = rndis_query_oid(usbdev, OID_GEN_RCV_ERROR, &tmp, &len);
  1817. if (ret == 0)
  1818. iwstats.discard.misc += le32_to_cpu(tmp);
  1819. len = sizeof(tmp);
  1820. ret = rndis_query_oid(usbdev, OID_GEN_RCV_NO_BUFFER, &tmp, &len);
  1821. if (ret == 0)
  1822. iwstats.discard.misc += le32_to_cpu(tmp);
  1823. /* Workaround transfer stalls on poor quality links.
  1824. * TODO: find right way to fix these stalls (as stalls do not happen
  1825. * with ndiswrapper/windows driver). */
  1826. if (iwstats.qual.qual <= 25) {
  1827. /* Decrease stats worker interval to catch stalls.
  1828. * faster. Faster than 400-500ms causes packet loss,
  1829. * Slower doesn't catch stalls fast enough.
  1830. */
  1831. j = msecs_to_jiffies(priv->param_workaround_interval);
  1832. if (j > STATS_UPDATE_JIFFIES)
  1833. j = STATS_UPDATE_JIFFIES;
  1834. else if (j <= 0)
  1835. j = 1;
  1836. update_jiffies = j;
  1837. /* Send scan OID. Use of both OIDs is required to get device
  1838. * working.
  1839. */
  1840. tmp = cpu_to_le32(1);
  1841. rndis_set_oid(usbdev, OID_802_11_BSSID_LIST_SCAN, &tmp,
  1842. sizeof(tmp));
  1843. len = CONTROL_BUFFER_SIZE;
  1844. buf = kmalloc(len, GFP_KERNEL);
  1845. if (!buf)
  1846. goto end;
  1847. rndis_query_oid(usbdev, OID_802_11_BSSID_LIST, buf, &len);
  1848. kfree(buf);
  1849. }
  1850. end:
  1851. spin_lock_irqsave(&priv->stats_lock, flags);
  1852. memcpy(&priv->privstats, &iwstats, sizeof(iwstats));
  1853. spin_unlock_irqrestore(&priv->stats_lock, flags);
  1854. if (update_jiffies >= HZ)
  1855. update_jiffies = round_jiffies_relative(update_jiffies);
  1856. else {
  1857. j = round_jiffies_relative(update_jiffies);
  1858. if (abs(j - update_jiffies) <= 10)
  1859. update_jiffies = j;
  1860. }
  1861. queue_delayed_work(priv->workqueue, &priv->stats_work, update_jiffies);
  1862. }
  1863. static int bcm4320_early_init(struct usbnet *usbdev)
  1864. {
  1865. struct rndis_wext_private *priv = get_rndis_wext_priv(usbdev);
  1866. char buf[8];
  1867. /* Early initialization settings, setting these won't have effect
  1868. * if called after generic_rndis_bind().
  1869. */
  1870. priv->param_country[0] = modparam_country[0];
  1871. priv->param_country[1] = modparam_country[1];
  1872. priv->param_country[2] = 0;
  1873. priv->param_frameburst = modparam_frameburst;
  1874. priv->param_afterburner = modparam_afterburner;
  1875. priv->param_power_save = modparam_power_save;
  1876. priv->param_power_output = modparam_power_output;
  1877. priv->param_roamtrigger = modparam_roamtrigger;
  1878. priv->param_roamdelta = modparam_roamdelta;
  1879. priv->param_country[0] = toupper(priv->param_country[0]);
  1880. priv->param_country[1] = toupper(priv->param_country[1]);
  1881. /* doesn't support EU as country code, use FI instead */
  1882. if (!strcmp(priv->param_country, "EU"))
  1883. strcpy(priv->param_country, "FI");
  1884. if (priv->param_power_save < 0)
  1885. priv->param_power_save = 0;
  1886. else if (priv->param_power_save > 2)
  1887. priv->param_power_save = 2;
  1888. if (priv->param_power_output < 0)
  1889. priv->param_power_output = 0;
  1890. else if (priv->param_power_output > 3)
  1891. priv->param_power_output = 3;
  1892. if (priv->param_roamtrigger < -80)
  1893. priv->param_roamtrigger = -80;
  1894. else if (priv->param_roamtrigger > -60)
  1895. priv->param_roamtrigger = -60;
  1896. if (priv->param_roamdelta < 0)
  1897. priv->param_roamdelta = 0;
  1898. else if (priv->param_roamdelta > 2)
  1899. priv->param_roamdelta = 2;
  1900. if (modparam_workaround_interval < 0)
  1901. priv->param_workaround_interval = 500;
  1902. else
  1903. priv->param_workaround_interval = modparam_workaround_interval;
  1904. rndis_set_config_parameter_str(usbdev, "Country", priv->param_country);
  1905. rndis_set_config_parameter_str(usbdev, "FrameBursting",
  1906. priv->param_frameburst ? "1" : "0");
  1907. rndis_set_config_parameter_str(usbdev, "Afterburner",
  1908. priv->param_afterburner ? "1" : "0");
  1909. sprintf(buf, "%d", priv->param_power_save);
  1910. rndis_set_config_parameter_str(usbdev, "PowerSaveMode", buf);
  1911. sprintf(buf, "%d", priv->param_power_output);
  1912. rndis_set_config_parameter_str(usbdev, "PwrOut", buf);
  1913. sprintf(buf, "%d", priv->param_roamtrigger);
  1914. rndis_set_config_parameter_str(usbdev, "RoamTrigger", buf);
  1915. sprintf(buf, "%d", priv->param_roamdelta);
  1916. rndis_set_config_parameter_str(usbdev, "RoamDelta", buf);
  1917. return 0;
  1918. }
  1919. /* same as rndis_netdev_ops but with local multicast handler */
  1920. static const struct net_device_ops rndis_wext_netdev_ops = {
  1921. .ndo_open = usbnet_open,
  1922. .ndo_stop = usbnet_stop,
  1923. .ndo_start_xmit = usbnet_start_xmit,
  1924. .ndo_tx_timeout = usbnet_tx_timeout,
  1925. .ndo_set_mac_address = eth_mac_addr,
  1926. .ndo_validate_addr = eth_validate_addr,
  1927. .ndo_set_multicast_list = rndis_wext_set_multicast_list,
  1928. };
  1929. static int rndis_wext_bind(struct usbnet *usbdev, struct usb_interface *intf)
  1930. {
  1931. struct wiphy *wiphy;
  1932. struct rndis_wext_private *priv;
  1933. int retval, len;
  1934. __le32 tmp;
  1935. /* allocate wiphy and rndis private data
  1936. * NOTE: We only support a single virtual interface, so wiphy
  1937. * and wireless_dev are somewhat synonymous for this device.
  1938. */
  1939. wiphy = wiphy_new(&rndis_config_ops, sizeof(struct rndis_wext_private));
  1940. if (!wiphy)
  1941. return -ENOMEM;
  1942. priv = wiphy_priv(wiphy);
  1943. usbdev->net->ieee80211_ptr = &priv->wdev;
  1944. priv->wdev.wiphy = wiphy;
  1945. priv->wdev.iftype = NL80211_IFTYPE_STATION;
  1946. /* These have to be initialized before calling generic_rndis_bind().
  1947. * Otherwise we'll be in big trouble in rndis_wext_early_init().
  1948. */
  1949. usbdev->driver_priv = priv;
  1950. usbdev->net->wireless_handlers = &rndis_iw_handlers;
  1951. priv->usbdev = usbdev;
  1952. mutex_init(&priv->command_lock);
  1953. spin_lock_init(&priv->stats_lock);
  1954. /* because rndis_command() sleeps we need to use workqueue */
  1955. priv->workqueue = create_singlethread_workqueue("rndis_wlan");
  1956. INIT_WORK(&priv->work, rndis_wext_worker);
  1957. INIT_DELAYED_WORK(&priv->stats_work, rndis_update_wireless_stats);
  1958. INIT_DELAYED_WORK(&priv->scan_work, rndis_get_scan_results);
  1959. /* try bind rndis_host */
  1960. retval = generic_rndis_bind(usbdev, intf, FLAG_RNDIS_PHYM_WIRELESS);
  1961. if (retval < 0)
  1962. goto fail;
  1963. /* generic_rndis_bind set packet filter to multicast_all+
  1964. * promisc mode which doesn't work well for our devices (device
  1965. * picks up rssi to closest station instead of to access point).
  1966. *
  1967. * rndis_host wants to avoid all OID as much as possible
  1968. * so do promisc/multicast handling in rndis_wext.
  1969. */
  1970. usbdev->net->netdev_ops = &rndis_wext_netdev_ops;
  1971. tmp = RNDIS_PACKET_TYPE_DIRECTED | RNDIS_PACKET_TYPE_BROADCAST;
  1972. retval = rndis_set_oid(usbdev, OID_GEN_CURRENT_PACKET_FILTER, &tmp,
  1973. sizeof(tmp));
  1974. len = sizeof(tmp);
  1975. retval = rndis_query_oid(usbdev, OID_802_3_MAXIMUM_LIST_SIZE, &tmp,
  1976. &len);
  1977. priv->multicast_size = le32_to_cpu(tmp);
  1978. if (retval < 0 || priv->multicast_size < 0)
  1979. priv->multicast_size = 0;
  1980. if (priv->multicast_size > 0)
  1981. usbdev->net->flags |= IFF_MULTICAST;
  1982. else
  1983. usbdev->net->flags &= ~IFF_MULTICAST;
  1984. priv->iwstats.qual.qual = 0;
  1985. priv->iwstats.qual.level = 0;
  1986. priv->iwstats.qual.updated = IW_QUAL_QUAL_UPDATED
  1987. | IW_QUAL_LEVEL_UPDATED
  1988. | IW_QUAL_NOISE_INVALID
  1989. | IW_QUAL_QUAL_INVALID
  1990. | IW_QUAL_LEVEL_INVALID;
  1991. /* fill-out wiphy structure and register w/ cfg80211 */
  1992. memcpy(wiphy->perm_addr, usbdev->net->dev_addr, ETH_ALEN);
  1993. wiphy->privid = rndis_wiphy_privid;
  1994. wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION)
  1995. | BIT(NL80211_IFTYPE_ADHOC);
  1996. wiphy->max_scan_ssids = 1;
  1997. /* TODO: fill-out band information based on priv->caps */
  1998. rndis_wext_get_caps(usbdev);
  1999. memcpy(priv->channels, rndis_channels, sizeof(rndis_channels));
  2000. memcpy(priv->rates, rndis_rates, sizeof(rndis_rates));
  2001. priv->band.channels = priv->channels;
  2002. priv->band.n_channels = ARRAY_SIZE(rndis_channels);
  2003. priv->band.bitrates = priv->rates;
  2004. priv->band.n_bitrates = ARRAY_SIZE(rndis_rates);
  2005. wiphy->bands[IEEE80211_BAND_2GHZ] = &priv->band;
  2006. wiphy->signal_type = CFG80211_SIGNAL_TYPE_UNSPEC;
  2007. set_wiphy_dev(wiphy, &usbdev->udev->dev);
  2008. if (wiphy_register(wiphy)) {
  2009. retval = -ENODEV;
  2010. goto fail;
  2011. }
  2012. set_default_iw_params(usbdev);
  2013. /* turn radio on */
  2014. priv->radio_on = 1;
  2015. disassociate(usbdev, 1);
  2016. netif_carrier_off(usbdev->net);
  2017. queue_delayed_work(priv->workqueue, &priv->stats_work,
  2018. round_jiffies_relative(STATS_UPDATE_JIFFIES));
  2019. return 0;
  2020. fail:
  2021. cancel_delayed_work_sync(&priv->stats_work);
  2022. cancel_delayed_work_sync(&priv->scan_work);
  2023. cancel_work_sync(&priv->work);
  2024. flush_workqueue(priv->workqueue);
  2025. destroy_workqueue(priv->workqueue);
  2026. wiphy_free(wiphy);
  2027. return retval;
  2028. }
  2029. static void rndis_wext_unbind(struct usbnet *usbdev, struct usb_interface *intf)
  2030. {
  2031. struct rndis_wext_private *priv = get_rndis_wext_priv(usbdev);
  2032. /* turn radio off */
  2033. disassociate(usbdev, 0);
  2034. cancel_delayed_work_sync(&priv->stats_work);
  2035. cancel_delayed_work_sync(&priv->scan_work);
  2036. cancel_work_sync(&priv->work);
  2037. flush_workqueue(priv->workqueue);
  2038. destroy_workqueue(priv->workqueue);
  2039. if (priv && priv->wpa_ie_len)
  2040. kfree(priv->wpa_ie);
  2041. rndis_unbind(usbdev, intf);
  2042. wiphy_unregister(priv->wdev.wiphy);
  2043. wiphy_free(priv->wdev.wiphy);
  2044. }
  2045. static int rndis_wext_reset(struct usbnet *usbdev)
  2046. {
  2047. return deauthenticate(usbdev);
  2048. }
  2049. static const struct driver_info bcm4320b_info = {
  2050. .description = "Wireless RNDIS device, BCM4320b based",
  2051. .flags = FLAG_WLAN | FLAG_FRAMING_RN | FLAG_NO_SETINT,
  2052. .bind = rndis_wext_bind,
  2053. .unbind = rndis_wext_unbind,
  2054. .status = rndis_status,
  2055. .rx_fixup = rndis_rx_fixup,
  2056. .tx_fixup = rndis_tx_fixup,
  2057. .reset = rndis_wext_reset,
  2058. .early_init = bcm4320_early_init,
  2059. .link_change = rndis_wext_link_change,
  2060. };
  2061. static const struct driver_info bcm4320a_info = {
  2062. .description = "Wireless RNDIS device, BCM4320a based",
  2063. .flags = FLAG_WLAN | FLAG_FRAMING_RN | FLAG_NO_SETINT,
  2064. .bind = rndis_wext_bind,
  2065. .unbind = rndis_wext_unbind,
  2066. .status = rndis_status,
  2067. .rx_fixup = rndis_rx_fixup,
  2068. .tx_fixup = rndis_tx_fixup,
  2069. .reset = rndis_wext_reset,
  2070. .early_init = bcm4320_early_init,
  2071. .link_change = rndis_wext_link_change,
  2072. };
  2073. static const struct driver_info rndis_wext_info = {
  2074. .description = "Wireless RNDIS device",
  2075. .flags = FLAG_WLAN | FLAG_FRAMING_RN | FLAG_NO_SETINT,
  2076. .bind = rndis_wext_bind,
  2077. .unbind = rndis_wext_unbind,
  2078. .status = rndis_status,
  2079. .rx_fixup = rndis_rx_fixup,
  2080. .tx_fixup = rndis_tx_fixup,
  2081. .reset = rndis_wext_reset,
  2082. .early_init = bcm4320_early_init,
  2083. .link_change = rndis_wext_link_change,
  2084. };
  2085. /*-------------------------------------------------------------------------*/
  2086. static const struct usb_device_id products [] = {
  2087. #define RNDIS_MASTER_INTERFACE \
  2088. .bInterfaceClass = USB_CLASS_COMM, \
  2089. .bInterfaceSubClass = 2 /* ACM */, \
  2090. .bInterfaceProtocol = 0x0ff
  2091. /* INF driver for these devices have DriverVer >= 4.xx.xx.xx and many custom
  2092. * parameters available. Chipset marked as 'BCM4320SKFBG' in NDISwrapper-wiki.
  2093. */
  2094. {
  2095. .match_flags = USB_DEVICE_ID_MATCH_INT_INFO
  2096. | USB_DEVICE_ID_MATCH_DEVICE,
  2097. .idVendor = 0x0411,
  2098. .idProduct = 0x00bc, /* Buffalo WLI-U2-KG125S */
  2099. RNDIS_MASTER_INTERFACE,
  2100. .driver_info = (unsigned long) &bcm4320b_info,
  2101. }, {
  2102. .match_flags = USB_DEVICE_ID_MATCH_INT_INFO
  2103. | USB_DEVICE_ID_MATCH_DEVICE,
  2104. .idVendor = 0x0baf,
  2105. .idProduct = 0x011b, /* U.S. Robotics USR5421 */
  2106. RNDIS_MASTER_INTERFACE,
  2107. .driver_info = (unsigned long) &bcm4320b_info,
  2108. }, {
  2109. .match_flags = USB_DEVICE_ID_MATCH_INT_INFO
  2110. | USB_DEVICE_ID_MATCH_DEVICE,
  2111. .idVendor = 0x050d,
  2112. .idProduct = 0x011b, /* Belkin F5D7051 */
  2113. RNDIS_MASTER_INTERFACE,
  2114. .driver_info = (unsigned long) &bcm4320b_info,
  2115. }, {
  2116. .match_flags = USB_DEVICE_ID_MATCH_INT_INFO
  2117. | USB_DEVICE_ID_MATCH_DEVICE,
  2118. .idVendor = 0x1799, /* Belkin has two vendor ids */
  2119. .idProduct = 0x011b, /* Belkin F5D7051 */
  2120. RNDIS_MASTER_INTERFACE,
  2121. .driver_info = (unsigned long) &bcm4320b_info,
  2122. }, {
  2123. .match_flags = USB_DEVICE_ID_MATCH_INT_INFO
  2124. | USB_DEVICE_ID_MATCH_DEVICE,
  2125. .idVendor = 0x13b1,
  2126. .idProduct = 0x0014, /* Linksys WUSB54GSv2 */
  2127. RNDIS_MASTER_INTERFACE,
  2128. .driver_info = (unsigned long) &bcm4320b_info,
  2129. }, {
  2130. .match_flags = USB_DEVICE_ID_MATCH_INT_INFO
  2131. | USB_DEVICE_ID_MATCH_DEVICE,
  2132. .idVendor = 0x13b1,
  2133. .idProduct = 0x0026, /* Linksys WUSB54GSC */
  2134. RNDIS_MASTER_INTERFACE,
  2135. .driver_info = (unsigned long) &bcm4320b_info,
  2136. }, {
  2137. .match_flags = USB_DEVICE_ID_MATCH_INT_INFO
  2138. | USB_DEVICE_ID_MATCH_DEVICE,
  2139. .idVendor = 0x0b05,
  2140. .idProduct = 0x1717, /* Asus WL169gE */
  2141. RNDIS_MASTER_INTERFACE,
  2142. .driver_info = (unsigned long) &bcm4320b_info,
  2143. }, {
  2144. .match_flags = USB_DEVICE_ID_MATCH_INT_INFO
  2145. | USB_DEVICE_ID_MATCH_DEVICE,
  2146. .idVendor = 0x0a5c,
  2147. .idProduct = 0xd11b, /* Eminent EM4045 */
  2148. RNDIS_MASTER_INTERFACE,
  2149. .driver_info = (unsigned long) &bcm4320b_info,
  2150. }, {
  2151. .match_flags = USB_DEVICE_ID_MATCH_INT_INFO
  2152. | USB_DEVICE_ID_MATCH_DEVICE,
  2153. .idVendor = 0x1690,
  2154. .idProduct = 0x0715, /* BT Voyager 1055 */
  2155. RNDIS_MASTER_INTERFACE,
  2156. .driver_info = (unsigned long) &bcm4320b_info,
  2157. },
  2158. /* These devices have DriverVer < 4.xx.xx.xx and do not have any custom
  2159. * parameters available, hardware probably contain older firmware version with
  2160. * no way of updating. Chipset marked as 'BCM4320????' in NDISwrapper-wiki.
  2161. */
  2162. {
  2163. .match_flags = USB_DEVICE_ID_MATCH_INT_INFO
  2164. | USB_DEVICE_ID_MATCH_DEVICE,
  2165. .idVendor = 0x13b1,
  2166. .idProduct = 0x000e, /* Linksys WUSB54GSv1 */
  2167. RNDIS_MASTER_INTERFACE,
  2168. .driver_info = (unsigned long) &bcm4320a_info,
  2169. }, {
  2170. .match_flags = USB_DEVICE_ID_MATCH_INT_INFO
  2171. | USB_DEVICE_ID_MATCH_DEVICE,
  2172. .idVendor = 0x0baf,
  2173. .idProduct = 0x0111, /* U.S. Robotics USR5420 */
  2174. RNDIS_MASTER_INTERFACE,
  2175. .driver_info = (unsigned long) &bcm4320a_info,
  2176. }, {
  2177. .match_flags = USB_DEVICE_ID_MATCH_INT_INFO
  2178. | USB_DEVICE_ID_MATCH_DEVICE,
  2179. .idVendor = 0x0411,
  2180. .idProduct = 0x004b, /* BUFFALO WLI-USB-G54 */
  2181. RNDIS_MASTER_INTERFACE,
  2182. .driver_info = (unsigned long) &bcm4320a_info,
  2183. },
  2184. /* Generic Wireless RNDIS devices that we don't have exact
  2185. * idVendor/idProduct/chip yet.
  2186. */
  2187. {
  2188. /* RNDIS is MSFT's un-official variant of CDC ACM */
  2189. USB_INTERFACE_INFO(USB_CLASS_COMM, 2 /* ACM */, 0x0ff),
  2190. .driver_info = (unsigned long) &rndis_wext_info,
  2191. }, {
  2192. /* "ActiveSync" is an undocumented variant of RNDIS, used in WM5 */
  2193. USB_INTERFACE_INFO(USB_CLASS_MISC, 1, 1),
  2194. .driver_info = (unsigned long) &rndis_wext_info,
  2195. },
  2196. { }, // END
  2197. };
  2198. MODULE_DEVICE_TABLE(usb, products);
  2199. static struct usb_driver rndis_wlan_driver = {
  2200. .name = "rndis_wlan",
  2201. .id_table = products,
  2202. .probe = usbnet_probe,
  2203. .disconnect = usbnet_disconnect,
  2204. .suspend = usbnet_suspend,
  2205. .resume = usbnet_resume,
  2206. };
  2207. static int __init rndis_wlan_init(void)
  2208. {
  2209. return usb_register(&rndis_wlan_driver);
  2210. }
  2211. module_init(rndis_wlan_init);
  2212. static void __exit rndis_wlan_exit(void)
  2213. {
  2214. usb_deregister(&rndis_wlan_driver);
  2215. }
  2216. module_exit(rndis_wlan_exit);
  2217. MODULE_AUTHOR("Bjorge Dijkstra");
  2218. MODULE_AUTHOR("Jussi Kivilinna");
  2219. MODULE_DESCRIPTION("Driver for RNDIS based USB Wireless adapters");
  2220. MODULE_LICENSE("GPL");