rndis_wlan.c 74 KB

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