cfg80211.c 49 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745
  1. /*
  2. * Marvell Wireless LAN device driver: CFG80211
  3. *
  4. * Copyright (C) 2011, Marvell International Ltd.
  5. *
  6. * This software file (the "File") is distributed by Marvell International
  7. * Ltd. under the terms of the GNU General Public License Version 2, June 1991
  8. * (the "License"). You may use, redistribute and/or modify this File in
  9. * accordance with the terms and conditions of the License, a copy of which
  10. * is available by writing to the Free Software Foundation, Inc.,
  11. * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA or on the
  12. * worldwide web at http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
  13. *
  14. * THE FILE IS DISTRIBUTED AS-IS, WITHOUT WARRANTY OF ANY KIND, AND THE
  15. * IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE
  16. * ARE EXPRESSLY DISCLAIMED. The License provides additional details about
  17. * this warranty disclaimer.
  18. */
  19. #include "cfg80211.h"
  20. #include "main.h"
  21. static const struct ieee80211_iface_limit mwifiex_ap_sta_limits[] = {
  22. {
  23. .max = 1, .types = BIT(NL80211_IFTYPE_STATION),
  24. },
  25. {
  26. .max = 1, .types = BIT(NL80211_IFTYPE_AP),
  27. },
  28. };
  29. static const struct ieee80211_iface_combination mwifiex_iface_comb_ap_sta = {
  30. .limits = mwifiex_ap_sta_limits,
  31. .num_different_channels = 1,
  32. .n_limits = ARRAY_SIZE(mwifiex_ap_sta_limits),
  33. .max_interfaces = MWIFIEX_MAX_BSS_NUM,
  34. .beacon_int_infra_match = true,
  35. };
  36. /*
  37. * This function maps the nl802.11 channel type into driver channel type.
  38. *
  39. * The mapping is as follows -
  40. * NL80211_CHAN_NO_HT -> IEEE80211_HT_PARAM_CHA_SEC_NONE
  41. * NL80211_CHAN_HT20 -> IEEE80211_HT_PARAM_CHA_SEC_NONE
  42. * NL80211_CHAN_HT40PLUS -> IEEE80211_HT_PARAM_CHA_SEC_ABOVE
  43. * NL80211_CHAN_HT40MINUS -> IEEE80211_HT_PARAM_CHA_SEC_BELOW
  44. * Others -> IEEE80211_HT_PARAM_CHA_SEC_NONE
  45. */
  46. static u8
  47. mwifiex_cfg80211_channel_type_to_sec_chan_offset(enum nl80211_channel_type
  48. channel_type)
  49. {
  50. switch (channel_type) {
  51. case NL80211_CHAN_NO_HT:
  52. case NL80211_CHAN_HT20:
  53. return IEEE80211_HT_PARAM_CHA_SEC_NONE;
  54. case NL80211_CHAN_HT40PLUS:
  55. return IEEE80211_HT_PARAM_CHA_SEC_ABOVE;
  56. case NL80211_CHAN_HT40MINUS:
  57. return IEEE80211_HT_PARAM_CHA_SEC_BELOW;
  58. default:
  59. return IEEE80211_HT_PARAM_CHA_SEC_NONE;
  60. }
  61. }
  62. /*
  63. * This function checks whether WEP is set.
  64. */
  65. static int
  66. mwifiex_is_alg_wep(u32 cipher)
  67. {
  68. switch (cipher) {
  69. case WLAN_CIPHER_SUITE_WEP40:
  70. case WLAN_CIPHER_SUITE_WEP104:
  71. return 1;
  72. default:
  73. break;
  74. }
  75. return 0;
  76. }
  77. /*
  78. * This function retrieves the private structure from kernel wiphy structure.
  79. */
  80. static void *mwifiex_cfg80211_get_adapter(struct wiphy *wiphy)
  81. {
  82. return (void *) (*(unsigned long *) wiphy_priv(wiphy));
  83. }
  84. /*
  85. * CFG802.11 operation handler to delete a network key.
  86. */
  87. static int
  88. mwifiex_cfg80211_del_key(struct wiphy *wiphy, struct net_device *netdev,
  89. u8 key_index, bool pairwise, const u8 *mac_addr)
  90. {
  91. struct mwifiex_private *priv = mwifiex_netdev_get_priv(netdev);
  92. const u8 bc_mac[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
  93. const u8 *peer_mac = pairwise ? mac_addr : bc_mac;
  94. if (mwifiex_set_encode(priv, NULL, 0, key_index, peer_mac, 1)) {
  95. wiphy_err(wiphy, "deleting the crypto keys\n");
  96. return -EFAULT;
  97. }
  98. wiphy_dbg(wiphy, "info: crypto keys deleted\n");
  99. return 0;
  100. }
  101. /*
  102. * CFG802.11 operation handler to set Tx power.
  103. */
  104. static int
  105. mwifiex_cfg80211_set_tx_power(struct wiphy *wiphy,
  106. enum nl80211_tx_power_setting type,
  107. int mbm)
  108. {
  109. struct mwifiex_adapter *adapter = mwifiex_cfg80211_get_adapter(wiphy);
  110. struct mwifiex_private *priv;
  111. struct mwifiex_power_cfg power_cfg;
  112. int dbm = MBM_TO_DBM(mbm);
  113. if (type == NL80211_TX_POWER_FIXED) {
  114. power_cfg.is_power_auto = 0;
  115. power_cfg.power_level = dbm;
  116. } else {
  117. power_cfg.is_power_auto = 1;
  118. }
  119. priv = mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_ANY);
  120. return mwifiex_set_tx_power(priv, &power_cfg);
  121. }
  122. /*
  123. * CFG802.11 operation handler to set Power Save option.
  124. *
  125. * The timeout value, if provided, is currently ignored.
  126. */
  127. static int
  128. mwifiex_cfg80211_set_power_mgmt(struct wiphy *wiphy,
  129. struct net_device *dev,
  130. bool enabled, int timeout)
  131. {
  132. struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
  133. u32 ps_mode;
  134. if (timeout)
  135. wiphy_dbg(wiphy,
  136. "info: ignore timeout value for IEEE Power Save\n");
  137. ps_mode = enabled;
  138. return mwifiex_drv_set_power(priv, &ps_mode);
  139. }
  140. /*
  141. * CFG802.11 operation handler to set the default network key.
  142. */
  143. static int
  144. mwifiex_cfg80211_set_default_key(struct wiphy *wiphy, struct net_device *netdev,
  145. u8 key_index, bool unicast,
  146. bool multicast)
  147. {
  148. struct mwifiex_private *priv = mwifiex_netdev_get_priv(netdev);
  149. /* Return if WEP key not configured */
  150. if (!priv->sec_info.wep_enabled)
  151. return 0;
  152. if (mwifiex_set_encode(priv, NULL, 0, key_index, NULL, 0)) {
  153. wiphy_err(wiphy, "set default Tx key index\n");
  154. return -EFAULT;
  155. }
  156. return 0;
  157. }
  158. /*
  159. * CFG802.11 operation handler to add a network key.
  160. */
  161. static int
  162. mwifiex_cfg80211_add_key(struct wiphy *wiphy, struct net_device *netdev,
  163. u8 key_index, bool pairwise, const u8 *mac_addr,
  164. struct key_params *params)
  165. {
  166. struct mwifiex_private *priv = mwifiex_netdev_get_priv(netdev);
  167. const u8 bc_mac[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
  168. const u8 *peer_mac = pairwise ? mac_addr : bc_mac;
  169. if (mwifiex_set_encode(priv, params->key, params->key_len,
  170. key_index, peer_mac, 0)) {
  171. wiphy_err(wiphy, "crypto keys added\n");
  172. return -EFAULT;
  173. }
  174. return 0;
  175. }
  176. /*
  177. * This function sends domain information to the firmware.
  178. *
  179. * The following information are passed to the firmware -
  180. * - Country codes
  181. * - Sub bands (first channel, number of channels, maximum Tx power)
  182. */
  183. static int mwifiex_send_domain_info_cmd_fw(struct wiphy *wiphy)
  184. {
  185. u8 no_of_triplet = 0;
  186. struct ieee80211_country_ie_triplet *t;
  187. u8 no_of_parsed_chan = 0;
  188. u8 first_chan = 0, next_chan = 0, max_pwr = 0;
  189. u8 i, flag = 0;
  190. enum ieee80211_band band;
  191. struct ieee80211_supported_band *sband;
  192. struct ieee80211_channel *ch;
  193. struct mwifiex_adapter *adapter = mwifiex_cfg80211_get_adapter(wiphy);
  194. struct mwifiex_private *priv;
  195. struct mwifiex_802_11d_domain_reg *domain_info = &adapter->domain_reg;
  196. /* Set country code */
  197. domain_info->country_code[0] = adapter->country_code[0];
  198. domain_info->country_code[1] = adapter->country_code[1];
  199. domain_info->country_code[2] = ' ';
  200. band = mwifiex_band_to_radio_type(adapter->config_bands);
  201. if (!wiphy->bands[band]) {
  202. wiphy_err(wiphy, "11D: setting domain info in FW\n");
  203. return -1;
  204. }
  205. sband = wiphy->bands[band];
  206. for (i = 0; i < sband->n_channels ; i++) {
  207. ch = &sband->channels[i];
  208. if (ch->flags & IEEE80211_CHAN_DISABLED)
  209. continue;
  210. if (!flag) {
  211. flag = 1;
  212. first_chan = (u32) ch->hw_value;
  213. next_chan = first_chan;
  214. max_pwr = ch->max_power;
  215. no_of_parsed_chan = 1;
  216. continue;
  217. }
  218. if (ch->hw_value == next_chan + 1 &&
  219. ch->max_power == max_pwr) {
  220. next_chan++;
  221. no_of_parsed_chan++;
  222. } else {
  223. t = &domain_info->triplet[no_of_triplet];
  224. t->chans.first_channel = first_chan;
  225. t->chans.num_channels = no_of_parsed_chan;
  226. t->chans.max_power = max_pwr;
  227. no_of_triplet++;
  228. first_chan = (u32) ch->hw_value;
  229. next_chan = first_chan;
  230. max_pwr = ch->max_power;
  231. no_of_parsed_chan = 1;
  232. }
  233. }
  234. if (flag) {
  235. t = &domain_info->triplet[no_of_triplet];
  236. t->chans.first_channel = first_chan;
  237. t->chans.num_channels = no_of_parsed_chan;
  238. t->chans.max_power = max_pwr;
  239. no_of_triplet++;
  240. }
  241. domain_info->no_of_triplet = no_of_triplet;
  242. priv = mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_ANY);
  243. if (mwifiex_send_cmd_async(priv, HostCmd_CMD_802_11D_DOMAIN_INFO,
  244. HostCmd_ACT_GEN_SET, 0, NULL)) {
  245. wiphy_err(wiphy, "11D: setting domain info in FW\n");
  246. return -1;
  247. }
  248. return 0;
  249. }
  250. /*
  251. * CFG802.11 regulatory domain callback function.
  252. *
  253. * This function is called when the regulatory domain is changed due to the
  254. * following reasons -
  255. * - Set by driver
  256. * - Set by system core
  257. * - Set by user
  258. * - Set bt Country IE
  259. */
  260. static int mwifiex_reg_notifier(struct wiphy *wiphy,
  261. struct regulatory_request *request)
  262. {
  263. struct mwifiex_adapter *adapter = mwifiex_cfg80211_get_adapter(wiphy);
  264. wiphy_dbg(wiphy, "info: cfg80211 regulatory domain callback for %c%c\n",
  265. request->alpha2[0], request->alpha2[1]);
  266. memcpy(adapter->country_code, request->alpha2, sizeof(request->alpha2));
  267. switch (request->initiator) {
  268. case NL80211_REGDOM_SET_BY_DRIVER:
  269. case NL80211_REGDOM_SET_BY_CORE:
  270. case NL80211_REGDOM_SET_BY_USER:
  271. break;
  272. /* Todo: apply driver specific changes in channel flags based
  273. on the request initiator if necessary. */
  274. case NL80211_REGDOM_SET_BY_COUNTRY_IE:
  275. break;
  276. }
  277. mwifiex_send_domain_info_cmd_fw(wiphy);
  278. return 0;
  279. }
  280. /*
  281. * This function sets the RF channel.
  282. *
  283. * This function creates multiple IOCTL requests, populates them accordingly
  284. * and issues them to set the band/channel and frequency.
  285. */
  286. static int
  287. mwifiex_set_rf_channel(struct mwifiex_private *priv,
  288. struct ieee80211_channel *chan,
  289. enum nl80211_channel_type channel_type)
  290. {
  291. struct mwifiex_chan_freq_power cfp;
  292. u32 config_bands = 0;
  293. struct wiphy *wiphy = priv->wdev->wiphy;
  294. struct mwifiex_adapter *adapter = priv->adapter;
  295. if (chan) {
  296. /* Set appropriate bands */
  297. if (chan->band == IEEE80211_BAND_2GHZ) {
  298. if (channel_type == NL80211_CHAN_NO_HT)
  299. if (priv->adapter->config_bands == BAND_B ||
  300. priv->adapter->config_bands == BAND_G)
  301. config_bands =
  302. priv->adapter->config_bands;
  303. else
  304. config_bands = BAND_B | BAND_G;
  305. else
  306. config_bands = BAND_B | BAND_G | BAND_GN;
  307. } else {
  308. if (channel_type == NL80211_CHAN_NO_HT)
  309. config_bands = BAND_A;
  310. else
  311. config_bands = BAND_AN | BAND_A;
  312. }
  313. if (!((config_bands | adapter->fw_bands) &
  314. ~adapter->fw_bands)) {
  315. adapter->config_bands = config_bands;
  316. if (priv->bss_mode == NL80211_IFTYPE_ADHOC) {
  317. adapter->adhoc_start_band = config_bands;
  318. if ((config_bands & BAND_GN) ||
  319. (config_bands & BAND_AN))
  320. adapter->adhoc_11n_enabled = true;
  321. else
  322. adapter->adhoc_11n_enabled = false;
  323. }
  324. }
  325. adapter->sec_chan_offset =
  326. mwifiex_cfg80211_channel_type_to_sec_chan_offset
  327. (channel_type);
  328. adapter->channel_type = channel_type;
  329. mwifiex_send_domain_info_cmd_fw(wiphy);
  330. }
  331. wiphy_dbg(wiphy, "info: setting band %d, chan offset %d, mode %d\n",
  332. config_bands, adapter->sec_chan_offset, priv->bss_mode);
  333. if (!chan)
  334. return 0;
  335. memset(&cfp, 0, sizeof(cfp));
  336. cfp.freq = chan->center_freq;
  337. cfp.channel = ieee80211_frequency_to_channel(chan->center_freq);
  338. if (mwifiex_bss_set_channel(priv, &cfp))
  339. return -EFAULT;
  340. if (priv->bss_type == MWIFIEX_BSS_TYPE_STA)
  341. return mwifiex_drv_change_adhoc_chan(priv, cfp.channel);
  342. else
  343. return mwifiex_uap_set_channel(priv, cfp.channel);
  344. }
  345. /*
  346. * CFG802.11 operation handler to set channel.
  347. *
  348. * This function can only be used when station is not connected.
  349. */
  350. static int
  351. mwifiex_cfg80211_set_channel(struct wiphy *wiphy, struct net_device *dev,
  352. struct ieee80211_channel *chan,
  353. enum nl80211_channel_type channel_type)
  354. {
  355. struct mwifiex_private *priv;
  356. struct mwifiex_adapter *adapter = mwifiex_cfg80211_get_adapter(wiphy);
  357. if (dev)
  358. priv = mwifiex_netdev_get_priv(dev);
  359. else
  360. priv = mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_STA);
  361. if (priv->media_connected) {
  362. wiphy_err(wiphy, "This is invalid in connected state\n");
  363. return -EINVAL;
  364. }
  365. return mwifiex_set_rf_channel(priv, chan, channel_type);
  366. }
  367. /*
  368. * This function sets the fragmentation threshold.
  369. *
  370. * The fragmentation threshold value must lie between MWIFIEX_FRAG_MIN_VALUE
  371. * and MWIFIEX_FRAG_MAX_VALUE.
  372. */
  373. static int
  374. mwifiex_set_frag(struct mwifiex_private *priv, u32 frag_thr)
  375. {
  376. if (frag_thr < MWIFIEX_FRAG_MIN_VALUE ||
  377. frag_thr > MWIFIEX_FRAG_MAX_VALUE)
  378. frag_thr = MWIFIEX_FRAG_MAX_VALUE;
  379. return mwifiex_send_cmd_sync(priv, HostCmd_CMD_802_11_SNMP_MIB,
  380. HostCmd_ACT_GEN_SET, FRAG_THRESH_I,
  381. &frag_thr);
  382. }
  383. /*
  384. * This function sets the RTS threshold.
  385. * The rts value must lie between MWIFIEX_RTS_MIN_VALUE
  386. * and MWIFIEX_RTS_MAX_VALUE.
  387. */
  388. static int
  389. mwifiex_set_rts(struct mwifiex_private *priv, u32 rts_thr)
  390. {
  391. if (rts_thr < MWIFIEX_RTS_MIN_VALUE || rts_thr > MWIFIEX_RTS_MAX_VALUE)
  392. rts_thr = MWIFIEX_RTS_MAX_VALUE;
  393. return mwifiex_send_cmd_sync(priv, HostCmd_CMD_802_11_SNMP_MIB,
  394. HostCmd_ACT_GEN_SET, RTS_THRESH_I,
  395. &rts_thr);
  396. }
  397. /*
  398. * CFG802.11 operation handler to set wiphy parameters.
  399. *
  400. * This function can be used to set the RTS threshold and the
  401. * Fragmentation threshold of the driver.
  402. */
  403. static int
  404. mwifiex_cfg80211_set_wiphy_params(struct wiphy *wiphy, u32 changed)
  405. {
  406. struct mwifiex_adapter *adapter = mwifiex_cfg80211_get_adapter(wiphy);
  407. struct mwifiex_private *priv;
  408. struct mwifiex_uap_bss_param *bss_cfg;
  409. int ret, bss_started, i;
  410. for (i = 0; i < adapter->priv_num; i++) {
  411. priv = adapter->priv[i];
  412. switch (priv->bss_role) {
  413. case MWIFIEX_BSS_ROLE_UAP:
  414. bss_cfg = kzalloc(sizeof(struct mwifiex_uap_bss_param),
  415. GFP_KERNEL);
  416. if (!bss_cfg)
  417. return -ENOMEM;
  418. mwifiex_set_sys_config_invalid_data(bss_cfg);
  419. if (changed & WIPHY_PARAM_RTS_THRESHOLD)
  420. bss_cfg->rts_threshold = wiphy->rts_threshold;
  421. if (changed & WIPHY_PARAM_FRAG_THRESHOLD)
  422. bss_cfg->frag_threshold = wiphy->frag_threshold;
  423. if (changed & WIPHY_PARAM_RETRY_LONG)
  424. bss_cfg->retry_limit = wiphy->retry_long;
  425. bss_started = priv->bss_started;
  426. ret = mwifiex_send_cmd_sync(priv,
  427. HostCmd_CMD_UAP_BSS_STOP,
  428. HostCmd_ACT_GEN_SET, 0,
  429. NULL);
  430. if (ret) {
  431. wiphy_err(wiphy, "Failed to stop the BSS\n");
  432. kfree(bss_cfg);
  433. return ret;
  434. }
  435. ret = mwifiex_send_cmd_async(priv,
  436. HostCmd_CMD_UAP_SYS_CONFIG,
  437. HostCmd_ACT_GEN_SET,
  438. UAP_BSS_PARAMS_I, bss_cfg);
  439. kfree(bss_cfg);
  440. if (ret) {
  441. wiphy_err(wiphy, "Failed to set bss config\n");
  442. return ret;
  443. }
  444. if (!bss_started)
  445. break;
  446. ret = mwifiex_send_cmd_async(priv,
  447. HostCmd_CMD_UAP_BSS_START,
  448. HostCmd_ACT_GEN_SET, 0,
  449. NULL);
  450. if (ret) {
  451. wiphy_err(wiphy, "Failed to start BSS\n");
  452. return ret;
  453. }
  454. break;
  455. case MWIFIEX_BSS_ROLE_STA:
  456. if (changed & WIPHY_PARAM_RTS_THRESHOLD) {
  457. ret = mwifiex_set_rts(priv,
  458. wiphy->rts_threshold);
  459. if (ret)
  460. return ret;
  461. }
  462. if (changed & WIPHY_PARAM_FRAG_THRESHOLD) {
  463. ret = mwifiex_set_frag(priv,
  464. wiphy->frag_threshold);
  465. if (ret)
  466. return ret;
  467. }
  468. break;
  469. }
  470. }
  471. return 0;
  472. }
  473. /*
  474. * CFG802.11 operation handler to change interface type.
  475. */
  476. static int
  477. mwifiex_cfg80211_change_virtual_intf(struct wiphy *wiphy,
  478. struct net_device *dev,
  479. enum nl80211_iftype type, u32 *flags,
  480. struct vif_params *params)
  481. {
  482. int ret;
  483. struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
  484. switch (dev->ieee80211_ptr->iftype) {
  485. case NL80211_IFTYPE_ADHOC:
  486. switch (type) {
  487. case NL80211_IFTYPE_STATION:
  488. break;
  489. case NL80211_IFTYPE_UNSPECIFIED:
  490. wiphy_warn(wiphy, "%s: kept type as IBSS\n", dev->name);
  491. case NL80211_IFTYPE_ADHOC: /* This shouldn't happen */
  492. return 0;
  493. case NL80211_IFTYPE_AP:
  494. default:
  495. wiphy_err(wiphy, "%s: changing to %d not supported\n",
  496. dev->name, type);
  497. return -EOPNOTSUPP;
  498. }
  499. break;
  500. case NL80211_IFTYPE_STATION:
  501. switch (type) {
  502. case NL80211_IFTYPE_ADHOC:
  503. break;
  504. case NL80211_IFTYPE_UNSPECIFIED:
  505. wiphy_warn(wiphy, "%s: kept type as STA\n", dev->name);
  506. case NL80211_IFTYPE_STATION: /* This shouldn't happen */
  507. return 0;
  508. case NL80211_IFTYPE_AP:
  509. default:
  510. wiphy_err(wiphy, "%s: changing to %d not supported\n",
  511. dev->name, type);
  512. return -EOPNOTSUPP;
  513. }
  514. break;
  515. case NL80211_IFTYPE_AP:
  516. switch (type) {
  517. case NL80211_IFTYPE_UNSPECIFIED:
  518. wiphy_warn(wiphy, "%s: kept type as AP\n", dev->name);
  519. case NL80211_IFTYPE_AP: /* This shouldn't happen */
  520. return 0;
  521. case NL80211_IFTYPE_ADHOC:
  522. case NL80211_IFTYPE_STATION:
  523. default:
  524. wiphy_err(wiphy, "%s: changing to %d not supported\n",
  525. dev->name, type);
  526. return -EOPNOTSUPP;
  527. }
  528. break;
  529. default:
  530. wiphy_err(wiphy, "%s: unknown iftype: %d\n",
  531. dev->name, dev->ieee80211_ptr->iftype);
  532. return -EOPNOTSUPP;
  533. }
  534. dev->ieee80211_ptr->iftype = type;
  535. priv->bss_mode = type;
  536. mwifiex_deauthenticate(priv, NULL);
  537. priv->sec_info.authentication_mode = NL80211_AUTHTYPE_OPEN_SYSTEM;
  538. ret = mwifiex_send_cmd_sync(priv, HostCmd_CMD_SET_BSS_MODE,
  539. HostCmd_ACT_GEN_SET, 0, NULL);
  540. return ret;
  541. }
  542. /*
  543. * This function dumps the station information on a buffer.
  544. *
  545. * The following information are shown -
  546. * - Total bytes transmitted
  547. * - Total bytes received
  548. * - Total packets transmitted
  549. * - Total packets received
  550. * - Signal quality level
  551. * - Transmission rate
  552. */
  553. static int
  554. mwifiex_dump_station_info(struct mwifiex_private *priv,
  555. struct station_info *sinfo)
  556. {
  557. struct mwifiex_rate_cfg rate;
  558. sinfo->filled = STATION_INFO_RX_BYTES | STATION_INFO_TX_BYTES |
  559. STATION_INFO_RX_PACKETS | STATION_INFO_TX_PACKETS |
  560. STATION_INFO_TX_BITRATE |
  561. STATION_INFO_SIGNAL | STATION_INFO_SIGNAL_AVG;
  562. /* Get signal information from the firmware */
  563. if (mwifiex_send_cmd_sync(priv, HostCmd_CMD_RSSI_INFO,
  564. HostCmd_ACT_GEN_GET, 0, NULL)) {
  565. dev_err(priv->adapter->dev, "failed to get signal information\n");
  566. return -EFAULT;
  567. }
  568. if (mwifiex_drv_get_data_rate(priv, &rate)) {
  569. dev_err(priv->adapter->dev, "getting data rate\n");
  570. return -EFAULT;
  571. }
  572. /* Get DTIM period information from firmware */
  573. mwifiex_send_cmd_sync(priv, HostCmd_CMD_802_11_SNMP_MIB,
  574. HostCmd_ACT_GEN_GET, DTIM_PERIOD_I,
  575. &priv->dtim_period);
  576. /*
  577. * Bit 0 in tx_htinfo indicates that current Tx rate is 11n rate. Valid
  578. * MCS index values for us are 0 to 7.
  579. */
  580. if ((priv->tx_htinfo & BIT(0)) && (priv->tx_rate < 8)) {
  581. sinfo->txrate.mcs = priv->tx_rate;
  582. sinfo->txrate.flags |= RATE_INFO_FLAGS_MCS;
  583. /* 40MHz rate */
  584. if (priv->tx_htinfo & BIT(1))
  585. sinfo->txrate.flags |= RATE_INFO_FLAGS_40_MHZ_WIDTH;
  586. /* SGI enabled */
  587. if (priv->tx_htinfo & BIT(2))
  588. sinfo->txrate.flags |= RATE_INFO_FLAGS_SHORT_GI;
  589. }
  590. sinfo->signal_avg = priv->bcn_rssi_avg;
  591. sinfo->rx_bytes = priv->stats.rx_bytes;
  592. sinfo->tx_bytes = priv->stats.tx_bytes;
  593. sinfo->rx_packets = priv->stats.rx_packets;
  594. sinfo->tx_packets = priv->stats.tx_packets;
  595. sinfo->signal = priv->bcn_rssi_avg;
  596. /* bit rate is in 500 kb/s units. Convert it to 100kb/s units */
  597. sinfo->txrate.legacy = rate.rate * 5;
  598. if (priv->bss_mode == NL80211_IFTYPE_STATION) {
  599. sinfo->filled |= STATION_INFO_BSS_PARAM;
  600. sinfo->bss_param.flags = 0;
  601. if (priv->curr_bss_params.bss_descriptor.cap_info_bitmap &
  602. WLAN_CAPABILITY_SHORT_PREAMBLE)
  603. sinfo->bss_param.flags |=
  604. BSS_PARAM_FLAGS_SHORT_PREAMBLE;
  605. if (priv->curr_bss_params.bss_descriptor.cap_info_bitmap &
  606. WLAN_CAPABILITY_SHORT_SLOT_TIME)
  607. sinfo->bss_param.flags |=
  608. BSS_PARAM_FLAGS_SHORT_SLOT_TIME;
  609. sinfo->bss_param.dtim_period = priv->dtim_period;
  610. sinfo->bss_param.beacon_interval =
  611. priv->curr_bss_params.bss_descriptor.beacon_period;
  612. }
  613. return 0;
  614. }
  615. /*
  616. * CFG802.11 operation handler to get station information.
  617. *
  618. * This function only works in connected mode, and dumps the
  619. * requested station information, if available.
  620. */
  621. static int
  622. mwifiex_cfg80211_get_station(struct wiphy *wiphy, struct net_device *dev,
  623. u8 *mac, struct station_info *sinfo)
  624. {
  625. struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
  626. if (!priv->media_connected)
  627. return -ENOENT;
  628. if (memcmp(mac, priv->cfg_bssid, ETH_ALEN))
  629. return -ENOENT;
  630. return mwifiex_dump_station_info(priv, sinfo);
  631. }
  632. /*
  633. * CFG802.11 operation handler to dump station information.
  634. */
  635. static int
  636. mwifiex_cfg80211_dump_station(struct wiphy *wiphy, struct net_device *dev,
  637. int idx, u8 *mac, struct station_info *sinfo)
  638. {
  639. struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
  640. if (!priv->media_connected || idx)
  641. return -ENOENT;
  642. memcpy(mac, priv->cfg_bssid, ETH_ALEN);
  643. return mwifiex_dump_station_info(priv, sinfo);
  644. }
  645. /* Supported rates to be advertised to the cfg80211 */
  646. static struct ieee80211_rate mwifiex_rates[] = {
  647. {.bitrate = 10, .hw_value = 2, },
  648. {.bitrate = 20, .hw_value = 4, },
  649. {.bitrate = 55, .hw_value = 11, },
  650. {.bitrate = 110, .hw_value = 22, },
  651. {.bitrate = 60, .hw_value = 12, },
  652. {.bitrate = 90, .hw_value = 18, },
  653. {.bitrate = 120, .hw_value = 24, },
  654. {.bitrate = 180, .hw_value = 36, },
  655. {.bitrate = 240, .hw_value = 48, },
  656. {.bitrate = 360, .hw_value = 72, },
  657. {.bitrate = 480, .hw_value = 96, },
  658. {.bitrate = 540, .hw_value = 108, },
  659. };
  660. /* Channel definitions to be advertised to cfg80211 */
  661. static struct ieee80211_channel mwifiex_channels_2ghz[] = {
  662. {.center_freq = 2412, .hw_value = 1, },
  663. {.center_freq = 2417, .hw_value = 2, },
  664. {.center_freq = 2422, .hw_value = 3, },
  665. {.center_freq = 2427, .hw_value = 4, },
  666. {.center_freq = 2432, .hw_value = 5, },
  667. {.center_freq = 2437, .hw_value = 6, },
  668. {.center_freq = 2442, .hw_value = 7, },
  669. {.center_freq = 2447, .hw_value = 8, },
  670. {.center_freq = 2452, .hw_value = 9, },
  671. {.center_freq = 2457, .hw_value = 10, },
  672. {.center_freq = 2462, .hw_value = 11, },
  673. {.center_freq = 2467, .hw_value = 12, },
  674. {.center_freq = 2472, .hw_value = 13, },
  675. {.center_freq = 2484, .hw_value = 14, },
  676. };
  677. static struct ieee80211_supported_band mwifiex_band_2ghz = {
  678. .channels = mwifiex_channels_2ghz,
  679. .n_channels = ARRAY_SIZE(mwifiex_channels_2ghz),
  680. .bitrates = mwifiex_rates,
  681. .n_bitrates = ARRAY_SIZE(mwifiex_rates),
  682. };
  683. static struct ieee80211_channel mwifiex_channels_5ghz[] = {
  684. {.center_freq = 5040, .hw_value = 8, },
  685. {.center_freq = 5060, .hw_value = 12, },
  686. {.center_freq = 5080, .hw_value = 16, },
  687. {.center_freq = 5170, .hw_value = 34, },
  688. {.center_freq = 5190, .hw_value = 38, },
  689. {.center_freq = 5210, .hw_value = 42, },
  690. {.center_freq = 5230, .hw_value = 46, },
  691. {.center_freq = 5180, .hw_value = 36, },
  692. {.center_freq = 5200, .hw_value = 40, },
  693. {.center_freq = 5220, .hw_value = 44, },
  694. {.center_freq = 5240, .hw_value = 48, },
  695. {.center_freq = 5260, .hw_value = 52, },
  696. {.center_freq = 5280, .hw_value = 56, },
  697. {.center_freq = 5300, .hw_value = 60, },
  698. {.center_freq = 5320, .hw_value = 64, },
  699. {.center_freq = 5500, .hw_value = 100, },
  700. {.center_freq = 5520, .hw_value = 104, },
  701. {.center_freq = 5540, .hw_value = 108, },
  702. {.center_freq = 5560, .hw_value = 112, },
  703. {.center_freq = 5580, .hw_value = 116, },
  704. {.center_freq = 5600, .hw_value = 120, },
  705. {.center_freq = 5620, .hw_value = 124, },
  706. {.center_freq = 5640, .hw_value = 128, },
  707. {.center_freq = 5660, .hw_value = 132, },
  708. {.center_freq = 5680, .hw_value = 136, },
  709. {.center_freq = 5700, .hw_value = 140, },
  710. {.center_freq = 5745, .hw_value = 149, },
  711. {.center_freq = 5765, .hw_value = 153, },
  712. {.center_freq = 5785, .hw_value = 157, },
  713. {.center_freq = 5805, .hw_value = 161, },
  714. {.center_freq = 5825, .hw_value = 165, },
  715. };
  716. static struct ieee80211_supported_band mwifiex_band_5ghz = {
  717. .channels = mwifiex_channels_5ghz,
  718. .n_channels = ARRAY_SIZE(mwifiex_channels_5ghz),
  719. .bitrates = mwifiex_rates + 4,
  720. .n_bitrates = ARRAY_SIZE(mwifiex_rates) - 4,
  721. };
  722. /* Supported crypto cipher suits to be advertised to cfg80211 */
  723. static const u32 mwifiex_cipher_suites[] = {
  724. WLAN_CIPHER_SUITE_WEP40,
  725. WLAN_CIPHER_SUITE_WEP104,
  726. WLAN_CIPHER_SUITE_TKIP,
  727. WLAN_CIPHER_SUITE_CCMP,
  728. };
  729. /*
  730. * CFG802.11 operation handler for setting bit rates.
  731. *
  732. * Function selects legacy bang B/G/BG from corresponding bitrates selection.
  733. * Currently only 2.4GHz band is supported.
  734. */
  735. static int mwifiex_cfg80211_set_bitrate_mask(struct wiphy *wiphy,
  736. struct net_device *dev,
  737. const u8 *peer,
  738. const struct cfg80211_bitrate_mask *mask)
  739. {
  740. struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
  741. int index = 0, mode = 0, i;
  742. struct mwifiex_adapter *adapter = priv->adapter;
  743. /* Currently only 2.4GHz is supported */
  744. for (i = 0; i < mwifiex_band_2ghz.n_bitrates; i++) {
  745. /*
  746. * Rates below 6 Mbps in the table are CCK rates; 802.11b
  747. * and from 6 they are OFDM; 802.11G
  748. */
  749. if (mwifiex_rates[i].bitrate == 60) {
  750. index = 1 << i;
  751. break;
  752. }
  753. }
  754. if (mask->control[IEEE80211_BAND_2GHZ].legacy < index) {
  755. mode = BAND_B;
  756. } else {
  757. mode = BAND_G;
  758. if (mask->control[IEEE80211_BAND_2GHZ].legacy % index)
  759. mode |= BAND_B;
  760. }
  761. if (!((mode | adapter->fw_bands) & ~adapter->fw_bands)) {
  762. adapter->config_bands = mode;
  763. if (priv->bss_mode == NL80211_IFTYPE_ADHOC) {
  764. adapter->adhoc_start_band = mode;
  765. adapter->adhoc_11n_enabled = false;
  766. }
  767. }
  768. adapter->sec_chan_offset = IEEE80211_HT_PARAM_CHA_SEC_NONE;
  769. adapter->channel_type = NL80211_CHAN_NO_HT;
  770. wiphy_debug(wiphy, "info: device configured in 802.11%s%s mode\n",
  771. (mode & BAND_B) ? "b" : "", (mode & BAND_G) ? "g" : "");
  772. return 0;
  773. }
  774. /*
  775. * CFG802.11 operation handler for connection quality monitoring.
  776. *
  777. * This function subscribes/unsubscribes HIGH_RSSI and LOW_RSSI
  778. * events to FW.
  779. */
  780. static int mwifiex_cfg80211_set_cqm_rssi_config(struct wiphy *wiphy,
  781. struct net_device *dev,
  782. s32 rssi_thold, u32 rssi_hyst)
  783. {
  784. struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
  785. struct mwifiex_ds_misc_subsc_evt subsc_evt;
  786. priv->cqm_rssi_thold = rssi_thold;
  787. priv->cqm_rssi_hyst = rssi_hyst;
  788. memset(&subsc_evt, 0x00, sizeof(struct mwifiex_ds_misc_subsc_evt));
  789. subsc_evt.events = BITMASK_BCN_RSSI_LOW | BITMASK_BCN_RSSI_HIGH;
  790. /* Subscribe/unsubscribe low and high rssi events */
  791. if (rssi_thold && rssi_hyst) {
  792. subsc_evt.action = HostCmd_ACT_BITWISE_SET;
  793. subsc_evt.bcn_l_rssi_cfg.abs_value = abs(rssi_thold);
  794. subsc_evt.bcn_h_rssi_cfg.abs_value = abs(rssi_thold);
  795. subsc_evt.bcn_l_rssi_cfg.evt_freq = 1;
  796. subsc_evt.bcn_h_rssi_cfg.evt_freq = 1;
  797. return mwifiex_send_cmd_sync(priv,
  798. HostCmd_CMD_802_11_SUBSCRIBE_EVENT,
  799. 0, 0, &subsc_evt);
  800. } else {
  801. subsc_evt.action = HostCmd_ACT_BITWISE_CLR;
  802. return mwifiex_send_cmd_sync(priv,
  803. HostCmd_CMD_802_11_SUBSCRIBE_EVENT,
  804. 0, 0, &subsc_evt);
  805. }
  806. return 0;
  807. }
  808. /* cfg80211 operation handler for stop ap.
  809. * Function stops BSS running at uAP interface.
  810. */
  811. static int mwifiex_cfg80211_stop_ap(struct wiphy *wiphy, struct net_device *dev)
  812. {
  813. struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
  814. if (mwifiex_send_cmd_sync(priv, HostCmd_CMD_UAP_BSS_STOP,
  815. HostCmd_ACT_GEN_SET, 0, NULL)) {
  816. wiphy_err(wiphy, "Failed to stop the BSS\n");
  817. return -1;
  818. }
  819. return 0;
  820. }
  821. /* cfg80211 operation handler for start_ap.
  822. * Function sets beacon period, DTIM period, SSID and security into
  823. * AP config structure.
  824. * AP is configured with these settings and BSS is started.
  825. */
  826. static int mwifiex_cfg80211_start_ap(struct wiphy *wiphy,
  827. struct net_device *dev,
  828. struct cfg80211_ap_settings *params)
  829. {
  830. struct mwifiex_uap_bss_param *bss_cfg;
  831. struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
  832. if (priv->bss_type != MWIFIEX_BSS_TYPE_UAP)
  833. return -1;
  834. if (mwifiex_set_mgmt_ies(priv, params))
  835. return -1;
  836. bss_cfg = kzalloc(sizeof(struct mwifiex_uap_bss_param), GFP_KERNEL);
  837. if (!bss_cfg)
  838. return -ENOMEM;
  839. mwifiex_set_sys_config_invalid_data(bss_cfg);
  840. if (params->beacon_interval)
  841. bss_cfg->beacon_period = params->beacon_interval;
  842. if (params->dtim_period)
  843. bss_cfg->dtim_period = params->dtim_period;
  844. if (params->ssid && params->ssid_len) {
  845. memcpy(bss_cfg->ssid.ssid, params->ssid, params->ssid_len);
  846. bss_cfg->ssid.ssid_len = params->ssid_len;
  847. }
  848. if (mwifiex_set_secure_params(priv, bss_cfg, params)) {
  849. kfree(bss_cfg);
  850. wiphy_err(wiphy, "Failed to parse secuirty parameters!\n");
  851. return -1;
  852. }
  853. if (mwifiex_send_cmd_sync(priv, HostCmd_CMD_UAP_BSS_STOP,
  854. HostCmd_ACT_GEN_SET, 0, NULL)) {
  855. wiphy_err(wiphy, "Failed to stop the BSS\n");
  856. kfree(bss_cfg);
  857. return -1;
  858. }
  859. if (mwifiex_send_cmd_async(priv, HostCmd_CMD_UAP_SYS_CONFIG,
  860. HostCmd_ACT_GEN_SET,
  861. UAP_BSS_PARAMS_I, bss_cfg)) {
  862. wiphy_err(wiphy, "Failed to set the SSID\n");
  863. kfree(bss_cfg);
  864. return -1;
  865. }
  866. kfree(bss_cfg);
  867. if (mwifiex_send_cmd_async(priv, HostCmd_CMD_UAP_BSS_START,
  868. HostCmd_ACT_GEN_SET, 0, NULL)) {
  869. wiphy_err(wiphy, "Failed to start the BSS\n");
  870. return -1;
  871. }
  872. return 0;
  873. }
  874. /*
  875. * CFG802.11 operation handler for disconnection request.
  876. *
  877. * This function does not work when there is already a disconnection
  878. * procedure going on.
  879. */
  880. static int
  881. mwifiex_cfg80211_disconnect(struct wiphy *wiphy, struct net_device *dev,
  882. u16 reason_code)
  883. {
  884. struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
  885. if (mwifiex_deauthenticate(priv, NULL))
  886. return -EFAULT;
  887. wiphy_dbg(wiphy, "info: successfully disconnected from %pM:"
  888. " reason code %d\n", priv->cfg_bssid, reason_code);
  889. memset(priv->cfg_bssid, 0, ETH_ALEN);
  890. return 0;
  891. }
  892. /*
  893. * This function informs the CFG802.11 subsystem of a new IBSS.
  894. *
  895. * The following information are sent to the CFG802.11 subsystem
  896. * to register the new IBSS. If we do not register the new IBSS,
  897. * a kernel panic will result.
  898. * - SSID
  899. * - SSID length
  900. * - BSSID
  901. * - Channel
  902. */
  903. static int mwifiex_cfg80211_inform_ibss_bss(struct mwifiex_private *priv)
  904. {
  905. struct ieee80211_channel *chan;
  906. struct mwifiex_bss_info bss_info;
  907. struct cfg80211_bss *bss;
  908. int ie_len;
  909. u8 ie_buf[IEEE80211_MAX_SSID_LEN + sizeof(struct ieee_types_header)];
  910. enum ieee80211_band band;
  911. if (mwifiex_get_bss_info(priv, &bss_info))
  912. return -1;
  913. ie_buf[0] = WLAN_EID_SSID;
  914. ie_buf[1] = bss_info.ssid.ssid_len;
  915. memcpy(&ie_buf[sizeof(struct ieee_types_header)],
  916. &bss_info.ssid.ssid, bss_info.ssid.ssid_len);
  917. ie_len = ie_buf[1] + sizeof(struct ieee_types_header);
  918. band = mwifiex_band_to_radio_type(priv->curr_bss_params.band);
  919. chan = __ieee80211_get_channel(priv->wdev->wiphy,
  920. ieee80211_channel_to_frequency(bss_info.bss_chan,
  921. band));
  922. bss = cfg80211_inform_bss(priv->wdev->wiphy, chan,
  923. bss_info.bssid, 0, WLAN_CAPABILITY_IBSS,
  924. 0, ie_buf, ie_len, 0, GFP_KERNEL);
  925. cfg80211_put_bss(bss);
  926. memcpy(priv->cfg_bssid, bss_info.bssid, ETH_ALEN);
  927. return 0;
  928. }
  929. /*
  930. * This function connects with a BSS.
  931. *
  932. * This function handles both Infra and Ad-Hoc modes. It also performs
  933. * validity checking on the provided parameters, disconnects from the
  934. * current BSS (if any), sets up the association/scan parameters,
  935. * including security settings, and performs specific SSID scan before
  936. * trying to connect.
  937. *
  938. * For Infra mode, the function returns failure if the specified SSID
  939. * is not found in scan table. However, for Ad-Hoc mode, it can create
  940. * the IBSS if it does not exist. On successful completion in either case,
  941. * the function notifies the CFG802.11 subsystem of the new BSS connection.
  942. */
  943. static int
  944. mwifiex_cfg80211_assoc(struct mwifiex_private *priv, size_t ssid_len, u8 *ssid,
  945. u8 *bssid, int mode, struct ieee80211_channel *channel,
  946. struct cfg80211_connect_params *sme, bool privacy)
  947. {
  948. struct cfg80211_ssid req_ssid;
  949. int ret, auth_type = 0;
  950. struct cfg80211_bss *bss = NULL;
  951. u8 is_scanning_required = 0;
  952. memset(&req_ssid, 0, sizeof(struct cfg80211_ssid));
  953. req_ssid.ssid_len = ssid_len;
  954. if (ssid_len > IEEE80211_MAX_SSID_LEN) {
  955. dev_err(priv->adapter->dev, "invalid SSID - aborting\n");
  956. return -EINVAL;
  957. }
  958. memcpy(req_ssid.ssid, ssid, ssid_len);
  959. if (!req_ssid.ssid_len || req_ssid.ssid[0] < 0x20) {
  960. dev_err(priv->adapter->dev, "invalid SSID - aborting\n");
  961. return -EINVAL;
  962. }
  963. /* disconnect before try to associate */
  964. mwifiex_deauthenticate(priv, NULL);
  965. if (channel)
  966. ret = mwifiex_set_rf_channel(priv, channel,
  967. priv->adapter->channel_type);
  968. /* As this is new association, clear locally stored
  969. * keys and security related flags */
  970. priv->sec_info.wpa_enabled = false;
  971. priv->sec_info.wpa2_enabled = false;
  972. priv->wep_key_curr_index = 0;
  973. priv->sec_info.encryption_mode = 0;
  974. priv->sec_info.is_authtype_auto = 0;
  975. ret = mwifiex_set_encode(priv, NULL, 0, 0, NULL, 1);
  976. if (mode == NL80211_IFTYPE_ADHOC) {
  977. /* "privacy" is set only for ad-hoc mode */
  978. if (privacy) {
  979. /*
  980. * Keep WLAN_CIPHER_SUITE_WEP104 for now so that
  981. * the firmware can find a matching network from the
  982. * scan. The cfg80211 does not give us the encryption
  983. * mode at this stage so just setting it to WEP here.
  984. */
  985. priv->sec_info.encryption_mode =
  986. WLAN_CIPHER_SUITE_WEP104;
  987. priv->sec_info.authentication_mode =
  988. NL80211_AUTHTYPE_OPEN_SYSTEM;
  989. }
  990. goto done;
  991. }
  992. /* Now handle infra mode. "sme" is valid for infra mode only */
  993. if (sme->auth_type == NL80211_AUTHTYPE_AUTOMATIC) {
  994. auth_type = NL80211_AUTHTYPE_OPEN_SYSTEM;
  995. priv->sec_info.is_authtype_auto = 1;
  996. } else {
  997. auth_type = sme->auth_type;
  998. }
  999. if (sme->crypto.n_ciphers_pairwise) {
  1000. priv->sec_info.encryption_mode =
  1001. sme->crypto.ciphers_pairwise[0];
  1002. priv->sec_info.authentication_mode = auth_type;
  1003. }
  1004. if (sme->crypto.cipher_group) {
  1005. priv->sec_info.encryption_mode = sme->crypto.cipher_group;
  1006. priv->sec_info.authentication_mode = auth_type;
  1007. }
  1008. if (sme->ie)
  1009. ret = mwifiex_set_gen_ie(priv, sme->ie, sme->ie_len);
  1010. if (sme->key) {
  1011. if (mwifiex_is_alg_wep(priv->sec_info.encryption_mode)) {
  1012. dev_dbg(priv->adapter->dev,
  1013. "info: setting wep encryption"
  1014. " with key len %d\n", sme->key_len);
  1015. priv->wep_key_curr_index = sme->key_idx;
  1016. ret = mwifiex_set_encode(priv, sme->key, sme->key_len,
  1017. sme->key_idx, NULL, 0);
  1018. }
  1019. }
  1020. done:
  1021. /*
  1022. * Scan entries are valid for some time (15 sec). So we can save one
  1023. * active scan time if we just try cfg80211_get_bss first. If it fails
  1024. * then request scan and cfg80211_get_bss() again for final output.
  1025. */
  1026. while (1) {
  1027. if (is_scanning_required) {
  1028. /* Do specific SSID scanning */
  1029. if (mwifiex_request_scan(priv, &req_ssid)) {
  1030. dev_err(priv->adapter->dev, "scan error\n");
  1031. return -EFAULT;
  1032. }
  1033. }
  1034. /* Find the BSS we want using available scan results */
  1035. if (mode == NL80211_IFTYPE_ADHOC)
  1036. bss = cfg80211_get_bss(priv->wdev->wiphy, channel,
  1037. bssid, ssid, ssid_len,
  1038. WLAN_CAPABILITY_IBSS,
  1039. WLAN_CAPABILITY_IBSS);
  1040. else
  1041. bss = cfg80211_get_bss(priv->wdev->wiphy, channel,
  1042. bssid, ssid, ssid_len,
  1043. WLAN_CAPABILITY_ESS,
  1044. WLAN_CAPABILITY_ESS);
  1045. if (!bss) {
  1046. if (is_scanning_required) {
  1047. dev_warn(priv->adapter->dev,
  1048. "assoc: requested bss not found in scan results\n");
  1049. break;
  1050. }
  1051. is_scanning_required = 1;
  1052. } else {
  1053. dev_dbg(priv->adapter->dev,
  1054. "info: trying to associate to '%s' bssid %pM\n",
  1055. (char *) req_ssid.ssid, bss->bssid);
  1056. memcpy(&priv->cfg_bssid, bss->bssid, ETH_ALEN);
  1057. break;
  1058. }
  1059. }
  1060. if (mwifiex_bss_start(priv, bss, &req_ssid))
  1061. return -EFAULT;
  1062. if (mode == NL80211_IFTYPE_ADHOC) {
  1063. /* Inform the BSS information to kernel, otherwise
  1064. * kernel will give a panic after successful assoc */
  1065. if (mwifiex_cfg80211_inform_ibss_bss(priv))
  1066. return -EFAULT;
  1067. }
  1068. return ret;
  1069. }
  1070. /*
  1071. * CFG802.11 operation handler for association request.
  1072. *
  1073. * This function does not work when the current mode is set to Ad-Hoc, or
  1074. * when there is already an association procedure going on. The given BSS
  1075. * information is used to associate.
  1076. */
  1077. static int
  1078. mwifiex_cfg80211_connect(struct wiphy *wiphy, struct net_device *dev,
  1079. struct cfg80211_connect_params *sme)
  1080. {
  1081. struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
  1082. int ret = 0;
  1083. if (priv->bss_mode == NL80211_IFTYPE_ADHOC) {
  1084. wiphy_err(wiphy, "received infra assoc request "
  1085. "when station is in ibss mode\n");
  1086. goto done;
  1087. }
  1088. if (priv->bss_mode == NL80211_IFTYPE_AP) {
  1089. wiphy_err(wiphy, "skip association request for AP interface\n");
  1090. goto done;
  1091. }
  1092. wiphy_dbg(wiphy, "info: Trying to associate to %s and bssid %pM\n",
  1093. (char *) sme->ssid, sme->bssid);
  1094. ret = mwifiex_cfg80211_assoc(priv, sme->ssid_len, sme->ssid, sme->bssid,
  1095. priv->bss_mode, sme->channel, sme, 0);
  1096. done:
  1097. if (!ret) {
  1098. cfg80211_connect_result(priv->netdev, priv->cfg_bssid, NULL, 0,
  1099. NULL, 0, WLAN_STATUS_SUCCESS,
  1100. GFP_KERNEL);
  1101. dev_dbg(priv->adapter->dev,
  1102. "info: associated to bssid %pM successfully\n",
  1103. priv->cfg_bssid);
  1104. } else {
  1105. dev_dbg(priv->adapter->dev,
  1106. "info: association to bssid %pM failed\n",
  1107. priv->cfg_bssid);
  1108. memset(priv->cfg_bssid, 0, ETH_ALEN);
  1109. }
  1110. return ret;
  1111. }
  1112. /*
  1113. * CFG802.11 operation handler to join an IBSS.
  1114. *
  1115. * This function does not work in any mode other than Ad-Hoc, or if
  1116. * a join operation is already in progress.
  1117. */
  1118. static int
  1119. mwifiex_cfg80211_join_ibss(struct wiphy *wiphy, struct net_device *dev,
  1120. struct cfg80211_ibss_params *params)
  1121. {
  1122. struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
  1123. int ret = 0;
  1124. if (priv->bss_mode != NL80211_IFTYPE_ADHOC) {
  1125. wiphy_err(wiphy, "request to join ibss received "
  1126. "when station is not in ibss mode\n");
  1127. goto done;
  1128. }
  1129. wiphy_dbg(wiphy, "info: trying to join to %s and bssid %pM\n",
  1130. (char *) params->ssid, params->bssid);
  1131. ret = mwifiex_cfg80211_assoc(priv, params->ssid_len, params->ssid,
  1132. params->bssid, priv->bss_mode,
  1133. params->channel, NULL, params->privacy);
  1134. done:
  1135. if (!ret) {
  1136. cfg80211_ibss_joined(priv->netdev, priv->cfg_bssid, GFP_KERNEL);
  1137. dev_dbg(priv->adapter->dev,
  1138. "info: joined/created adhoc network with bssid"
  1139. " %pM successfully\n", priv->cfg_bssid);
  1140. } else {
  1141. dev_dbg(priv->adapter->dev,
  1142. "info: failed creating/joining adhoc network\n");
  1143. }
  1144. return ret;
  1145. }
  1146. /*
  1147. * CFG802.11 operation handler to leave an IBSS.
  1148. *
  1149. * This function does not work if a leave operation is
  1150. * already in progress.
  1151. */
  1152. static int
  1153. mwifiex_cfg80211_leave_ibss(struct wiphy *wiphy, struct net_device *dev)
  1154. {
  1155. struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
  1156. wiphy_dbg(wiphy, "info: disconnecting from essid %pM\n",
  1157. priv->cfg_bssid);
  1158. if (mwifiex_deauthenticate(priv, NULL))
  1159. return -EFAULT;
  1160. memset(priv->cfg_bssid, 0, ETH_ALEN);
  1161. return 0;
  1162. }
  1163. /*
  1164. * CFG802.11 operation handler for scan request.
  1165. *
  1166. * This function issues a scan request to the firmware based upon
  1167. * the user specified scan configuration. On successfull completion,
  1168. * it also informs the results.
  1169. */
  1170. static int
  1171. mwifiex_cfg80211_scan(struct wiphy *wiphy, struct net_device *dev,
  1172. struct cfg80211_scan_request *request)
  1173. {
  1174. struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
  1175. int i;
  1176. struct ieee80211_channel *chan;
  1177. wiphy_dbg(wiphy, "info: received scan request on %s\n", dev->name);
  1178. priv->scan_request = request;
  1179. priv->user_scan_cfg = kzalloc(sizeof(struct mwifiex_user_scan_cfg),
  1180. GFP_KERNEL);
  1181. if (!priv->user_scan_cfg) {
  1182. dev_err(priv->adapter->dev, "failed to alloc scan_req\n");
  1183. return -ENOMEM;
  1184. }
  1185. priv->user_scan_cfg->num_ssids = request->n_ssids;
  1186. priv->user_scan_cfg->ssid_list = request->ssids;
  1187. if (request->ie && request->ie_len) {
  1188. for (i = 0; i < MWIFIEX_MAX_VSIE_NUM; i++) {
  1189. if (priv->vs_ie[i].mask != MWIFIEX_VSIE_MASK_CLEAR)
  1190. continue;
  1191. priv->vs_ie[i].mask = MWIFIEX_VSIE_MASK_SCAN;
  1192. memcpy(&priv->vs_ie[i].ie, request->ie,
  1193. request->ie_len);
  1194. break;
  1195. }
  1196. }
  1197. for (i = 0; i < request->n_channels; i++) {
  1198. chan = request->channels[i];
  1199. priv->user_scan_cfg->chan_list[i].chan_number = chan->hw_value;
  1200. priv->user_scan_cfg->chan_list[i].radio_type = chan->band;
  1201. if (chan->flags & IEEE80211_CHAN_PASSIVE_SCAN)
  1202. priv->user_scan_cfg->chan_list[i].scan_type =
  1203. MWIFIEX_SCAN_TYPE_PASSIVE;
  1204. else
  1205. priv->user_scan_cfg->chan_list[i].scan_type =
  1206. MWIFIEX_SCAN_TYPE_ACTIVE;
  1207. priv->user_scan_cfg->chan_list[i].scan_time = 0;
  1208. }
  1209. if (mwifiex_set_user_scan_ioctl(priv, priv->user_scan_cfg))
  1210. return -EFAULT;
  1211. if (request->ie && request->ie_len) {
  1212. for (i = 0; i < MWIFIEX_MAX_VSIE_NUM; i++) {
  1213. if (priv->vs_ie[i].mask == MWIFIEX_VSIE_MASK_SCAN) {
  1214. priv->vs_ie[i].mask = MWIFIEX_VSIE_MASK_CLEAR;
  1215. memset(&priv->vs_ie[i].ie, 0,
  1216. MWIFIEX_MAX_VSIE_LEN);
  1217. }
  1218. }
  1219. }
  1220. return 0;
  1221. }
  1222. /*
  1223. * This function sets up the CFG802.11 specific HT capability fields
  1224. * with default values.
  1225. *
  1226. * The following default values are set -
  1227. * - HT Supported = True
  1228. * - Maximum AMPDU length factor = IEEE80211_HT_MAX_AMPDU_64K
  1229. * - Minimum AMPDU spacing = IEEE80211_HT_MPDU_DENSITY_NONE
  1230. * - HT Capabilities supported by firmware
  1231. * - MCS information, Rx mask = 0xff
  1232. * - MCD information, Tx parameters = IEEE80211_HT_MCS_TX_DEFINED (0x01)
  1233. */
  1234. static void
  1235. mwifiex_setup_ht_caps(struct ieee80211_sta_ht_cap *ht_info,
  1236. struct mwifiex_private *priv)
  1237. {
  1238. int rx_mcs_supp;
  1239. struct ieee80211_mcs_info mcs_set;
  1240. u8 *mcs = (u8 *)&mcs_set;
  1241. struct mwifiex_adapter *adapter = priv->adapter;
  1242. ht_info->ht_supported = true;
  1243. ht_info->ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K;
  1244. ht_info->ampdu_density = IEEE80211_HT_MPDU_DENSITY_NONE;
  1245. memset(&ht_info->mcs, 0, sizeof(ht_info->mcs));
  1246. /* Fill HT capability information */
  1247. if (ISSUPP_CHANWIDTH40(adapter->hw_dot_11n_dev_cap))
  1248. ht_info->cap |= IEEE80211_HT_CAP_SUP_WIDTH_20_40;
  1249. else
  1250. ht_info->cap &= ~IEEE80211_HT_CAP_SUP_WIDTH_20_40;
  1251. if (ISSUPP_SHORTGI20(adapter->hw_dot_11n_dev_cap))
  1252. ht_info->cap |= IEEE80211_HT_CAP_SGI_20;
  1253. else
  1254. ht_info->cap &= ~IEEE80211_HT_CAP_SGI_20;
  1255. if (ISSUPP_SHORTGI40(adapter->hw_dot_11n_dev_cap))
  1256. ht_info->cap |= IEEE80211_HT_CAP_SGI_40;
  1257. else
  1258. ht_info->cap &= ~IEEE80211_HT_CAP_SGI_40;
  1259. if (ISSUPP_RXSTBC(adapter->hw_dot_11n_dev_cap))
  1260. ht_info->cap |= 1 << IEEE80211_HT_CAP_RX_STBC_SHIFT;
  1261. else
  1262. ht_info->cap &= ~(3 << IEEE80211_HT_CAP_RX_STBC_SHIFT);
  1263. if (ISSUPP_TXSTBC(adapter->hw_dot_11n_dev_cap))
  1264. ht_info->cap |= IEEE80211_HT_CAP_TX_STBC;
  1265. else
  1266. ht_info->cap &= ~IEEE80211_HT_CAP_TX_STBC;
  1267. ht_info->cap &= ~IEEE80211_HT_CAP_MAX_AMSDU;
  1268. ht_info->cap |= IEEE80211_HT_CAP_SM_PS;
  1269. rx_mcs_supp = GET_RXMCSSUPP(adapter->hw_dev_mcs_support);
  1270. /* Set MCS for 1x1 */
  1271. memset(mcs, 0xff, rx_mcs_supp);
  1272. /* Clear all the other values */
  1273. memset(&mcs[rx_mcs_supp], 0,
  1274. sizeof(struct ieee80211_mcs_info) - rx_mcs_supp);
  1275. if (priv->bss_mode == NL80211_IFTYPE_STATION ||
  1276. ISSUPP_CHANWIDTH40(adapter->hw_dot_11n_dev_cap))
  1277. /* Set MCS32 for infra mode or ad-hoc mode with 40MHz support */
  1278. SETHT_MCS32(mcs_set.rx_mask);
  1279. memcpy((u8 *) &ht_info->mcs, mcs, sizeof(struct ieee80211_mcs_info));
  1280. ht_info->mcs.tx_params = IEEE80211_HT_MCS_TX_DEFINED;
  1281. }
  1282. /*
  1283. * create a new virtual interface with the given name
  1284. */
  1285. struct net_device *mwifiex_add_virtual_intf(struct wiphy *wiphy,
  1286. char *name,
  1287. enum nl80211_iftype type,
  1288. u32 *flags,
  1289. struct vif_params *params)
  1290. {
  1291. struct mwifiex_adapter *adapter = mwifiex_cfg80211_get_adapter(wiphy);
  1292. struct mwifiex_private *priv;
  1293. struct net_device *dev;
  1294. void *mdev_priv;
  1295. struct wireless_dev *wdev;
  1296. if (!adapter)
  1297. return NULL;
  1298. switch (type) {
  1299. case NL80211_IFTYPE_UNSPECIFIED:
  1300. case NL80211_IFTYPE_STATION:
  1301. case NL80211_IFTYPE_ADHOC:
  1302. priv = adapter->priv[MWIFIEX_BSS_TYPE_STA];
  1303. if (priv->bss_mode) {
  1304. wiphy_err(wiphy,
  1305. "cannot create multiple sta/adhoc ifaces\n");
  1306. return NULL;
  1307. }
  1308. wdev = kzalloc(sizeof(struct wireless_dev), GFP_KERNEL);
  1309. if (!wdev)
  1310. return NULL;
  1311. wdev->wiphy = wiphy;
  1312. priv->wdev = wdev;
  1313. wdev->iftype = NL80211_IFTYPE_STATION;
  1314. if (type == NL80211_IFTYPE_UNSPECIFIED)
  1315. priv->bss_mode = NL80211_IFTYPE_STATION;
  1316. else
  1317. priv->bss_mode = type;
  1318. priv->bss_type = MWIFIEX_BSS_TYPE_STA;
  1319. priv->frame_type = MWIFIEX_DATA_FRAME_TYPE_ETH_II;
  1320. priv->bss_priority = MWIFIEX_BSS_ROLE_STA;
  1321. priv->bss_role = MWIFIEX_BSS_ROLE_STA;
  1322. priv->bss_num = 0;
  1323. break;
  1324. case NL80211_IFTYPE_AP:
  1325. priv = adapter->priv[MWIFIEX_BSS_TYPE_UAP];
  1326. if (priv->bss_mode) {
  1327. wiphy_err(wiphy, "Can't create multiple AP interfaces");
  1328. return NULL;
  1329. }
  1330. wdev = kzalloc(sizeof(struct wireless_dev), GFP_KERNEL);
  1331. if (!wdev)
  1332. return NULL;
  1333. priv->wdev = wdev;
  1334. wdev->wiphy = wiphy;
  1335. wdev->iftype = NL80211_IFTYPE_AP;
  1336. priv->bss_type = MWIFIEX_BSS_TYPE_UAP;
  1337. priv->frame_type = MWIFIEX_DATA_FRAME_TYPE_ETH_II;
  1338. priv->bss_priority = MWIFIEX_BSS_ROLE_UAP;
  1339. priv->bss_role = MWIFIEX_BSS_ROLE_UAP;
  1340. priv->bss_started = 0;
  1341. priv->bss_num = 0;
  1342. priv->bss_mode = type;
  1343. break;
  1344. default:
  1345. wiphy_err(wiphy, "type not supported\n");
  1346. return NULL;
  1347. }
  1348. dev = alloc_netdev_mq(sizeof(struct mwifiex_private *), name,
  1349. ether_setup, 1);
  1350. if (!dev) {
  1351. wiphy_err(wiphy, "no memory available for netdevice\n");
  1352. goto error;
  1353. }
  1354. mwifiex_init_priv_params(priv, dev);
  1355. priv->netdev = dev;
  1356. mwifiex_setup_ht_caps(&wiphy->bands[IEEE80211_BAND_2GHZ]->ht_cap, priv);
  1357. if (adapter->config_bands & BAND_A)
  1358. mwifiex_setup_ht_caps(
  1359. &wiphy->bands[IEEE80211_BAND_5GHZ]->ht_cap, priv);
  1360. dev_net_set(dev, wiphy_net(wiphy));
  1361. dev->ieee80211_ptr = priv->wdev;
  1362. dev->ieee80211_ptr->iftype = priv->bss_mode;
  1363. memcpy(dev->dev_addr, wiphy->perm_addr, ETH_ALEN);
  1364. memcpy(dev->perm_addr, wiphy->perm_addr, ETH_ALEN);
  1365. SET_NETDEV_DEV(dev, wiphy_dev(wiphy));
  1366. dev->flags |= IFF_BROADCAST | IFF_MULTICAST;
  1367. dev->watchdog_timeo = MWIFIEX_DEFAULT_WATCHDOG_TIMEOUT;
  1368. dev->hard_header_len += MWIFIEX_MIN_DATA_HEADER_LEN;
  1369. mdev_priv = netdev_priv(dev);
  1370. *((unsigned long *) mdev_priv) = (unsigned long) priv;
  1371. SET_NETDEV_DEV(dev, adapter->dev);
  1372. /* Register network device */
  1373. if (register_netdevice(dev)) {
  1374. wiphy_err(wiphy, "cannot register virtual network device\n");
  1375. goto error;
  1376. }
  1377. sema_init(&priv->async_sem, 1);
  1378. priv->scan_pending_on_block = false;
  1379. dev_dbg(adapter->dev, "info: %s: Marvell 802.11 Adapter\n", dev->name);
  1380. #ifdef CONFIG_DEBUG_FS
  1381. mwifiex_dev_debugfs_init(priv);
  1382. #endif
  1383. return dev;
  1384. error:
  1385. if (dev && (dev->reg_state == NETREG_UNREGISTERED))
  1386. free_netdev(dev);
  1387. priv->bss_mode = NL80211_IFTYPE_UNSPECIFIED;
  1388. return NULL;
  1389. }
  1390. EXPORT_SYMBOL_GPL(mwifiex_add_virtual_intf);
  1391. /*
  1392. * del_virtual_intf: remove the virtual interface determined by dev
  1393. */
  1394. int mwifiex_del_virtual_intf(struct wiphy *wiphy, struct net_device *dev)
  1395. {
  1396. struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
  1397. #ifdef CONFIG_DEBUG_FS
  1398. mwifiex_dev_debugfs_remove(priv);
  1399. #endif
  1400. if (!netif_queue_stopped(priv->netdev))
  1401. netif_stop_queue(priv->netdev);
  1402. if (netif_carrier_ok(priv->netdev))
  1403. netif_carrier_off(priv->netdev);
  1404. if (dev->reg_state == NETREG_REGISTERED)
  1405. unregister_netdevice(dev);
  1406. if (dev->reg_state == NETREG_UNREGISTERED)
  1407. free_netdev(dev);
  1408. /* Clear the priv in adapter */
  1409. priv->netdev = NULL;
  1410. priv->media_connected = false;
  1411. priv->bss_mode = NL80211_IFTYPE_UNSPECIFIED;
  1412. return 0;
  1413. }
  1414. EXPORT_SYMBOL_GPL(mwifiex_del_virtual_intf);
  1415. /* station cfg80211 operations */
  1416. static struct cfg80211_ops mwifiex_cfg80211_ops = {
  1417. .add_virtual_intf = mwifiex_add_virtual_intf,
  1418. .del_virtual_intf = mwifiex_del_virtual_intf,
  1419. .change_virtual_intf = mwifiex_cfg80211_change_virtual_intf,
  1420. .scan = mwifiex_cfg80211_scan,
  1421. .connect = mwifiex_cfg80211_connect,
  1422. .disconnect = mwifiex_cfg80211_disconnect,
  1423. .get_station = mwifiex_cfg80211_get_station,
  1424. .dump_station = mwifiex_cfg80211_dump_station,
  1425. .set_wiphy_params = mwifiex_cfg80211_set_wiphy_params,
  1426. .set_channel = mwifiex_cfg80211_set_channel,
  1427. .join_ibss = mwifiex_cfg80211_join_ibss,
  1428. .leave_ibss = mwifiex_cfg80211_leave_ibss,
  1429. .add_key = mwifiex_cfg80211_add_key,
  1430. .del_key = mwifiex_cfg80211_del_key,
  1431. .set_default_key = mwifiex_cfg80211_set_default_key,
  1432. .set_power_mgmt = mwifiex_cfg80211_set_power_mgmt,
  1433. .set_tx_power = mwifiex_cfg80211_set_tx_power,
  1434. .set_bitrate_mask = mwifiex_cfg80211_set_bitrate_mask,
  1435. .start_ap = mwifiex_cfg80211_start_ap,
  1436. .stop_ap = mwifiex_cfg80211_stop_ap,
  1437. .set_cqm_rssi_config = mwifiex_cfg80211_set_cqm_rssi_config,
  1438. };
  1439. /*
  1440. * This function registers the device with CFG802.11 subsystem.
  1441. *
  1442. * The function creates the wireless device/wiphy, populates it with
  1443. * default parameters and handler function pointers, and finally
  1444. * registers the device.
  1445. */
  1446. int mwifiex_register_cfg80211(struct mwifiex_adapter *adapter)
  1447. {
  1448. int ret;
  1449. void *wdev_priv;
  1450. struct wiphy *wiphy;
  1451. struct mwifiex_private *priv = adapter->priv[MWIFIEX_BSS_TYPE_STA];
  1452. u8 *country_code;
  1453. /* create a new wiphy for use with cfg80211 */
  1454. wiphy = wiphy_new(&mwifiex_cfg80211_ops,
  1455. sizeof(struct mwifiex_adapter *));
  1456. if (!wiphy) {
  1457. dev_err(adapter->dev, "%s: creating new wiphy\n", __func__);
  1458. return -ENOMEM;
  1459. }
  1460. wiphy->max_scan_ssids = MWIFIEX_MAX_SSID_LIST_LENGTH;
  1461. wiphy->max_scan_ie_len = MWIFIEX_MAX_VSIE_LEN;
  1462. wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
  1463. BIT(NL80211_IFTYPE_ADHOC) |
  1464. BIT(NL80211_IFTYPE_AP);
  1465. wiphy->bands[IEEE80211_BAND_2GHZ] = &mwifiex_band_2ghz;
  1466. if (adapter->config_bands & BAND_A)
  1467. wiphy->bands[IEEE80211_BAND_5GHZ] = &mwifiex_band_5ghz;
  1468. else
  1469. wiphy->bands[IEEE80211_BAND_5GHZ] = NULL;
  1470. wiphy->iface_combinations = &mwifiex_iface_comb_ap_sta;
  1471. wiphy->n_iface_combinations = 1;
  1472. /* Initialize cipher suits */
  1473. wiphy->cipher_suites = mwifiex_cipher_suites;
  1474. wiphy->n_cipher_suites = ARRAY_SIZE(mwifiex_cipher_suites);
  1475. memcpy(wiphy->perm_addr, priv->curr_addr, ETH_ALEN);
  1476. wiphy->signal_type = CFG80211_SIGNAL_TYPE_MBM;
  1477. wiphy->flags |= WIPHY_FLAG_HAVE_AP_SME | WIPHY_FLAG_CUSTOM_REGULATORY;
  1478. /* Reserve space for mwifiex specific private data for BSS */
  1479. wiphy->bss_priv_size = sizeof(struct mwifiex_bss_priv);
  1480. wiphy->reg_notifier = mwifiex_reg_notifier;
  1481. /* Set struct mwifiex_adapter pointer in wiphy_priv */
  1482. wdev_priv = wiphy_priv(wiphy);
  1483. *(unsigned long *)wdev_priv = (unsigned long)adapter;
  1484. set_wiphy_dev(wiphy, (struct device *)priv->adapter->dev);
  1485. ret = wiphy_register(wiphy);
  1486. if (ret < 0) {
  1487. dev_err(adapter->dev,
  1488. "%s: wiphy_register failed: %d\n", __func__, ret);
  1489. wiphy_free(wiphy);
  1490. return ret;
  1491. }
  1492. country_code = mwifiex_11d_code_2_region(priv->adapter->region_code);
  1493. if (country_code && regulatory_hint(wiphy, country_code))
  1494. dev_err(adapter->dev, "regulatory_hint() failed\n");
  1495. adapter->wiphy = wiphy;
  1496. return ret;
  1497. }