sta.c 33 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235
  1. /******************************************************************************
  2. *
  3. * This file is provided under a dual BSD/GPLv2 license. When using or
  4. * redistributing this file, you may do so under either license.
  5. *
  6. * GPL LICENSE SUMMARY
  7. *
  8. * Copyright(c) 2012 - 2013 Intel Corporation. All rights reserved.
  9. *
  10. * This program is free software; you can redistribute it and/or modify
  11. * it under the terms of version 2 of the GNU General Public License as
  12. * published by the Free Software Foundation.
  13. *
  14. * This program is distributed in the hope that it will be useful, but
  15. * WITHOUT ANY WARRANTY; without even the implied warranty of
  16. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  17. * General Public License for more details.
  18. *
  19. * You should have received a copy of the GNU General Public License
  20. * along with this program; if not, write to the Free Software
  21. * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110,
  22. * USA
  23. *
  24. * The full GNU General Public License is included in this distribution
  25. * in the file called LICENSE.GPL.
  26. *
  27. * Contact Information:
  28. * Intel Linux Wireless <ilw@linux.intel.com>
  29. * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
  30. *
  31. * BSD LICENSE
  32. *
  33. * Copyright(c) 2012 - 2013 Intel Corporation. All rights reserved.
  34. * All rights reserved.
  35. *
  36. * Redistribution and use in source and binary forms, with or without
  37. * modification, are permitted provided that the following conditions
  38. * are met:
  39. *
  40. * * Redistributions of source code must retain the above copyright
  41. * notice, this list of conditions and the following disclaimer.
  42. * * Redistributions in binary form must reproduce the above copyright
  43. * notice, this list of conditions and the following disclaimer in
  44. * the documentation and/or other materials provided with the
  45. * distribution.
  46. * * Neither the name Intel Corporation nor the names of its
  47. * contributors may be used to endorse or promote products derived
  48. * from this software without specific prior written permission.
  49. *
  50. * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  51. * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  52. * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  53. * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  54. * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  55. * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  56. * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  57. * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  58. * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  59. * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  60. * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  61. *
  62. *****************************************************************************/
  63. #include <net/mac80211.h>
  64. #include "mvm.h"
  65. #include "sta.h"
  66. static int iwl_mvm_find_free_sta_id(struct iwl_mvm *mvm)
  67. {
  68. int sta_id;
  69. WARN_ON_ONCE(test_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status));
  70. lockdep_assert_held(&mvm->mutex);
  71. /* Don't take rcu_read_lock() since we are protected by mvm->mutex */
  72. for (sta_id = 0; sta_id < IWL_MVM_STATION_COUNT; sta_id++)
  73. if (!rcu_dereference_protected(mvm->fw_id_to_mac_id[sta_id],
  74. lockdep_is_held(&mvm->mutex)))
  75. return sta_id;
  76. return IWL_MVM_STATION_COUNT;
  77. }
  78. /* send station add/update command to firmware */
  79. int iwl_mvm_sta_send_to_fw(struct iwl_mvm *mvm, struct ieee80211_sta *sta,
  80. bool update)
  81. {
  82. struct iwl_mvm_sta *mvm_sta = (void *)sta->drv_priv;
  83. struct iwl_mvm_add_sta_cmd add_sta_cmd;
  84. int ret;
  85. u32 status;
  86. u32 agg_size = 0, mpdu_dens = 0;
  87. memset(&add_sta_cmd, 0, sizeof(add_sta_cmd));
  88. add_sta_cmd.sta_id = mvm_sta->sta_id;
  89. add_sta_cmd.mac_id_n_color = cpu_to_le32(mvm_sta->mac_id_n_color);
  90. if (!update) {
  91. add_sta_cmd.tfd_queue_msk = cpu_to_le32(mvm_sta->tfd_queue_msk);
  92. memcpy(&add_sta_cmd.addr, sta->addr, ETH_ALEN);
  93. }
  94. add_sta_cmd.add_modify = update ? 1 : 0;
  95. /* STA_FLG_FAT_EN_MSK ? */
  96. /* STA_FLG_MIMO_EN_MSK ? */
  97. if (sta->ht_cap.ht_supported) {
  98. add_sta_cmd.station_flags_msk |=
  99. cpu_to_le32(STA_FLG_MAX_AGG_SIZE_MSK |
  100. STA_FLG_AGG_MPDU_DENS_MSK);
  101. mpdu_dens = sta->ht_cap.ampdu_density;
  102. }
  103. if (sta->vht_cap.vht_supported) {
  104. agg_size = sta->vht_cap.cap &
  105. IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK;
  106. agg_size >>=
  107. IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_SHIFT;
  108. } else if (sta->ht_cap.ht_supported) {
  109. agg_size = sta->ht_cap.ampdu_factor;
  110. }
  111. add_sta_cmd.station_flags |=
  112. cpu_to_le32(agg_size << STA_FLG_MAX_AGG_SIZE_SHIFT);
  113. add_sta_cmd.station_flags |=
  114. cpu_to_le32(mpdu_dens << STA_FLG_AGG_MPDU_DENS_SHIFT);
  115. status = ADD_STA_SUCCESS;
  116. ret = iwl_mvm_send_cmd_pdu_status(mvm, ADD_STA, sizeof(add_sta_cmd),
  117. &add_sta_cmd, &status);
  118. if (ret)
  119. return ret;
  120. switch (status) {
  121. case ADD_STA_SUCCESS:
  122. IWL_DEBUG_ASSOC(mvm, "ADD_STA PASSED\n");
  123. break;
  124. default:
  125. ret = -EIO;
  126. IWL_ERR(mvm, "ADD_STA failed\n");
  127. break;
  128. }
  129. return ret;
  130. }
  131. int iwl_mvm_add_sta(struct iwl_mvm *mvm,
  132. struct ieee80211_vif *vif,
  133. struct ieee80211_sta *sta)
  134. {
  135. struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
  136. struct iwl_mvm_sta *mvm_sta = (void *)sta->drv_priv;
  137. int i, ret, sta_id;
  138. lockdep_assert_held(&mvm->mutex);
  139. if (!test_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status))
  140. sta_id = iwl_mvm_find_free_sta_id(mvm);
  141. else
  142. sta_id = mvm_sta->sta_id;
  143. if (WARN_ON_ONCE(sta_id == IWL_MVM_STATION_COUNT))
  144. return -ENOSPC;
  145. spin_lock_init(&mvm_sta->lock);
  146. mvm_sta->sta_id = sta_id;
  147. mvm_sta->mac_id_n_color = FW_CMD_ID_AND_COLOR(mvmvif->id,
  148. mvmvif->color);
  149. mvm_sta->vif = vif;
  150. mvm_sta->max_agg_bufsize = LINK_QUAL_AGG_FRAME_LIMIT_DEF;
  151. /* HW restart, don't assume the memory has been zeroed */
  152. atomic_set(&mvm_sta->pending_frames, 0);
  153. mvm_sta->tid_disable_agg = 0;
  154. mvm_sta->tfd_queue_msk = 0;
  155. for (i = 0; i < IEEE80211_NUM_ACS; i++)
  156. if (vif->hw_queue[i] != IEEE80211_INVAL_HW_QUEUE)
  157. mvm_sta->tfd_queue_msk |= BIT(vif->hw_queue[i]);
  158. if (vif->cab_queue != IEEE80211_INVAL_HW_QUEUE)
  159. mvm_sta->tfd_queue_msk |= BIT(vif->cab_queue);
  160. /* for HW restart - need to reset the seq_number etc... */
  161. memset(mvm_sta->tid_data, 0, sizeof(mvm_sta->tid_data));
  162. ret = iwl_mvm_sta_send_to_fw(mvm, sta, false);
  163. if (ret)
  164. return ret;
  165. /* The first station added is the AP, the others are TDLS STAs */
  166. if (vif->type == NL80211_IFTYPE_STATION &&
  167. mvmvif->ap_sta_id == IWL_MVM_STATION_COUNT)
  168. mvmvif->ap_sta_id = sta_id;
  169. rcu_assign_pointer(mvm->fw_id_to_mac_id[sta_id], sta);
  170. return 0;
  171. }
  172. int iwl_mvm_update_sta(struct iwl_mvm *mvm,
  173. struct ieee80211_vif *vif,
  174. struct ieee80211_sta *sta)
  175. {
  176. return iwl_mvm_sta_send_to_fw(mvm, sta, true);
  177. }
  178. int iwl_mvm_drain_sta(struct iwl_mvm *mvm, struct iwl_mvm_sta *mvmsta,
  179. bool drain)
  180. {
  181. struct iwl_mvm_add_sta_cmd cmd = {};
  182. int ret;
  183. u32 status;
  184. lockdep_assert_held(&mvm->mutex);
  185. cmd.mac_id_n_color = cpu_to_le32(mvmsta->mac_id_n_color);
  186. cmd.sta_id = mvmsta->sta_id;
  187. cmd.add_modify = STA_MODE_MODIFY;
  188. cmd.station_flags = drain ? cpu_to_le32(STA_FLG_DRAIN_FLOW) : 0;
  189. cmd.station_flags_msk = cpu_to_le32(STA_FLG_DRAIN_FLOW);
  190. status = ADD_STA_SUCCESS;
  191. ret = iwl_mvm_send_cmd_pdu_status(mvm, ADD_STA, sizeof(cmd),
  192. &cmd, &status);
  193. if (ret)
  194. return ret;
  195. switch (status) {
  196. case ADD_STA_SUCCESS:
  197. IWL_DEBUG_INFO(mvm, "Frames for staid %d will drained in fw\n",
  198. mvmsta->sta_id);
  199. break;
  200. default:
  201. ret = -EIO;
  202. IWL_ERR(mvm, "Couldn't drain frames for staid %d\n",
  203. mvmsta->sta_id);
  204. break;
  205. }
  206. return ret;
  207. }
  208. /*
  209. * Remove a station from the FW table. Before sending the command to remove
  210. * the station validate that the station is indeed known to the driver (sanity
  211. * only).
  212. */
  213. static int iwl_mvm_rm_sta_common(struct iwl_mvm *mvm, u8 sta_id)
  214. {
  215. struct ieee80211_sta *sta;
  216. struct iwl_mvm_rm_sta_cmd rm_sta_cmd = {
  217. .sta_id = sta_id,
  218. };
  219. int ret;
  220. sta = rcu_dereference_protected(mvm->fw_id_to_mac_id[sta_id],
  221. lockdep_is_held(&mvm->mutex));
  222. /* Note: internal stations are marked as error values */
  223. if (!sta) {
  224. IWL_ERR(mvm, "Invalid station id\n");
  225. return -EINVAL;
  226. }
  227. ret = iwl_mvm_send_cmd_pdu(mvm, REMOVE_STA, CMD_SYNC,
  228. sizeof(rm_sta_cmd), &rm_sta_cmd);
  229. if (ret) {
  230. IWL_ERR(mvm, "Failed to remove station. Id=%d\n", sta_id);
  231. return ret;
  232. }
  233. return 0;
  234. }
  235. void iwl_mvm_sta_drained_wk(struct work_struct *wk)
  236. {
  237. struct iwl_mvm *mvm = container_of(wk, struct iwl_mvm, sta_drained_wk);
  238. u8 sta_id;
  239. /*
  240. * The mutex is needed because of the SYNC cmd, but not only: if the
  241. * work would run concurrently with iwl_mvm_rm_sta, it would run before
  242. * iwl_mvm_rm_sta sets the station as busy, and exit. Then
  243. * iwl_mvm_rm_sta would set the station as busy, and nobody will clean
  244. * that later.
  245. */
  246. mutex_lock(&mvm->mutex);
  247. for_each_set_bit(sta_id, mvm->sta_drained, IWL_MVM_STATION_COUNT) {
  248. int ret;
  249. struct ieee80211_sta *sta =
  250. rcu_dereference_protected(mvm->fw_id_to_mac_id[sta_id],
  251. lockdep_is_held(&mvm->mutex));
  252. /* This station is in use */
  253. if (!IS_ERR(sta))
  254. continue;
  255. if (PTR_ERR(sta) == -EINVAL) {
  256. IWL_ERR(mvm, "Drained sta %d, but it is internal?\n",
  257. sta_id);
  258. continue;
  259. }
  260. if (!sta) {
  261. IWL_ERR(mvm, "Drained sta %d, but it was NULL?\n",
  262. sta_id);
  263. continue;
  264. }
  265. WARN_ON(PTR_ERR(sta) != -EBUSY);
  266. /* This station was removed and we waited until it got drained,
  267. * we can now proceed and remove it.
  268. */
  269. ret = iwl_mvm_rm_sta_common(mvm, sta_id);
  270. if (ret) {
  271. IWL_ERR(mvm,
  272. "Couldn't remove sta %d after it was drained\n",
  273. sta_id);
  274. continue;
  275. }
  276. rcu_assign_pointer(mvm->fw_id_to_mac_id[sta_id], NULL);
  277. clear_bit(sta_id, mvm->sta_drained);
  278. }
  279. mutex_unlock(&mvm->mutex);
  280. }
  281. int iwl_mvm_rm_sta(struct iwl_mvm *mvm,
  282. struct ieee80211_vif *vif,
  283. struct ieee80211_sta *sta)
  284. {
  285. struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
  286. struct iwl_mvm_sta *mvm_sta = (void *)sta->drv_priv;
  287. int ret;
  288. lockdep_assert_held(&mvm->mutex);
  289. if (vif->type == NL80211_IFTYPE_STATION &&
  290. mvmvif->ap_sta_id == mvm_sta->sta_id) {
  291. /*
  292. * Put a non-NULL since the fw station isn't removed.
  293. * It will be removed after the MAC will be set as
  294. * unassoc.
  295. */
  296. rcu_assign_pointer(mvm->fw_id_to_mac_id[mvm_sta->sta_id],
  297. ERR_PTR(-EINVAL));
  298. /* flush its queues here since we are freeing mvm_sta */
  299. ret = iwl_mvm_flush_tx_path(mvm, mvm_sta->tfd_queue_msk, true);
  300. /* if we are associated - we can't remove the AP STA now */
  301. if (vif->bss_conf.assoc)
  302. return ret;
  303. /* unassoc - go ahead - remove the AP STA now */
  304. mvmvif->ap_sta_id = IWL_MVM_STATION_COUNT;
  305. }
  306. /*
  307. * There are frames pending on the AC queues for this station.
  308. * We need to wait until all the frames are drained...
  309. */
  310. if (atomic_read(&mvm_sta->pending_frames)) {
  311. ret = iwl_mvm_drain_sta(mvm, mvm_sta, true);
  312. rcu_assign_pointer(mvm->fw_id_to_mac_id[mvm_sta->sta_id],
  313. ERR_PTR(-EBUSY));
  314. } else {
  315. ret = iwl_mvm_rm_sta_common(mvm, mvm_sta->sta_id);
  316. rcu_assign_pointer(mvm->fw_id_to_mac_id[mvm_sta->sta_id], NULL);
  317. }
  318. return ret;
  319. }
  320. int iwl_mvm_rm_sta_id(struct iwl_mvm *mvm,
  321. struct ieee80211_vif *vif,
  322. u8 sta_id)
  323. {
  324. int ret = iwl_mvm_rm_sta_common(mvm, sta_id);
  325. lockdep_assert_held(&mvm->mutex);
  326. rcu_assign_pointer(mvm->fw_id_to_mac_id[sta_id], NULL);
  327. return ret;
  328. }
  329. int iwl_mvm_allocate_int_sta(struct iwl_mvm *mvm, struct iwl_mvm_int_sta *sta,
  330. u32 qmask)
  331. {
  332. if (!test_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status)) {
  333. sta->sta_id = iwl_mvm_find_free_sta_id(mvm);
  334. if (WARN_ON_ONCE(sta->sta_id == IWL_MVM_STATION_COUNT))
  335. return -ENOSPC;
  336. }
  337. sta->tfd_queue_msk = qmask;
  338. /* put a non-NULL value so iterating over the stations won't stop */
  339. rcu_assign_pointer(mvm->fw_id_to_mac_id[sta->sta_id], ERR_PTR(-EINVAL));
  340. return 0;
  341. }
  342. void iwl_mvm_dealloc_int_sta(struct iwl_mvm *mvm, struct iwl_mvm_int_sta *sta)
  343. {
  344. rcu_assign_pointer(mvm->fw_id_to_mac_id[sta->sta_id], NULL);
  345. memset(sta, 0, sizeof(struct iwl_mvm_int_sta));
  346. sta->sta_id = IWL_MVM_STATION_COUNT;
  347. }
  348. static int iwl_mvm_add_int_sta_common(struct iwl_mvm *mvm,
  349. struct iwl_mvm_int_sta *sta,
  350. const u8 *addr,
  351. u16 mac_id, u16 color)
  352. {
  353. struct iwl_mvm_add_sta_cmd cmd;
  354. int ret;
  355. u32 status;
  356. lockdep_assert_held(&mvm->mutex);
  357. memset(&cmd, 0, sizeof(struct iwl_mvm_add_sta_cmd));
  358. cmd.sta_id = sta->sta_id;
  359. cmd.mac_id_n_color = cpu_to_le32(FW_CMD_ID_AND_COLOR(mac_id,
  360. color));
  361. cmd.tfd_queue_msk = cpu_to_le32(sta->tfd_queue_msk);
  362. if (addr)
  363. memcpy(cmd.addr, addr, ETH_ALEN);
  364. ret = iwl_mvm_send_cmd_pdu_status(mvm, ADD_STA, sizeof(cmd),
  365. &cmd, &status);
  366. if (ret)
  367. return ret;
  368. switch (status) {
  369. case ADD_STA_SUCCESS:
  370. IWL_DEBUG_INFO(mvm, "Internal station added.\n");
  371. return 0;
  372. default:
  373. ret = -EIO;
  374. IWL_ERR(mvm, "Add internal station failed, status=0x%x\n",
  375. status);
  376. break;
  377. }
  378. return ret;
  379. }
  380. int iwl_mvm_add_aux_sta(struct iwl_mvm *mvm)
  381. {
  382. int ret;
  383. lockdep_assert_held(&mvm->mutex);
  384. /* Add the aux station, but without any queues */
  385. ret = iwl_mvm_allocate_int_sta(mvm, &mvm->aux_sta, 0);
  386. if (ret)
  387. return ret;
  388. ret = iwl_mvm_add_int_sta_common(mvm, &mvm->aux_sta, NULL,
  389. MAC_INDEX_AUX, 0);
  390. if (ret)
  391. iwl_mvm_dealloc_int_sta(mvm, &mvm->aux_sta);
  392. return ret;
  393. }
  394. /*
  395. * Send the add station command for the vif's broadcast station.
  396. * Assumes that the station was already allocated.
  397. *
  398. * @mvm: the mvm component
  399. * @vif: the interface to which the broadcast station is added
  400. * @bsta: the broadcast station to add.
  401. */
  402. int iwl_mvm_send_bcast_sta(struct iwl_mvm *mvm, struct ieee80211_vif *vif,
  403. struct iwl_mvm_int_sta *bsta)
  404. {
  405. struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
  406. static const u8 baddr[] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
  407. lockdep_assert_held(&mvm->mutex);
  408. if (WARN_ON_ONCE(bsta->sta_id == IWL_MVM_STATION_COUNT))
  409. return -ENOSPC;
  410. return iwl_mvm_add_int_sta_common(mvm, bsta, baddr,
  411. mvmvif->id, mvmvif->color);
  412. }
  413. /* Send the FW a request to remove the station from it's internal data
  414. * structures, but DO NOT remove the entry from the local data structures. */
  415. int iwl_mvm_send_rm_bcast_sta(struct iwl_mvm *mvm,
  416. struct iwl_mvm_int_sta *bsta)
  417. {
  418. int ret;
  419. lockdep_assert_held(&mvm->mutex);
  420. ret = iwl_mvm_rm_sta_common(mvm, bsta->sta_id);
  421. if (ret)
  422. IWL_WARN(mvm, "Failed sending remove station\n");
  423. return ret;
  424. }
  425. /* Allocate a new station entry for the broadcast station to the given vif,
  426. * and send it to the FW.
  427. * Note that each P2P mac should have its own broadcast station.
  428. *
  429. * @mvm: the mvm component
  430. * @vif: the interface to which the broadcast station is added
  431. * @bsta: the broadcast station to add. */
  432. int iwl_mvm_add_bcast_sta(struct iwl_mvm *mvm, struct ieee80211_vif *vif,
  433. struct iwl_mvm_int_sta *bsta)
  434. {
  435. struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
  436. static const u8 baddr[] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
  437. u32 qmask;
  438. int ret;
  439. lockdep_assert_held(&mvm->mutex);
  440. qmask = iwl_mvm_mac_get_queues_mask(mvm, vif);
  441. ret = iwl_mvm_allocate_int_sta(mvm, bsta, qmask);
  442. if (ret)
  443. return ret;
  444. ret = iwl_mvm_add_int_sta_common(mvm, bsta, baddr,
  445. mvmvif->id, mvmvif->color);
  446. if (ret)
  447. iwl_mvm_dealloc_int_sta(mvm, bsta);
  448. return ret;
  449. }
  450. /*
  451. * Send the FW a request to remove the station from it's internal data
  452. * structures, and in addition remove it from the local data structure.
  453. */
  454. int iwl_mvm_rm_bcast_sta(struct iwl_mvm *mvm, struct iwl_mvm_int_sta *bsta)
  455. {
  456. int ret;
  457. lockdep_assert_held(&mvm->mutex);
  458. ret = iwl_mvm_rm_sta_common(mvm, bsta->sta_id);
  459. if (ret)
  460. return ret;
  461. iwl_mvm_dealloc_int_sta(mvm, bsta);
  462. return ret;
  463. }
  464. int iwl_mvm_sta_rx_agg(struct iwl_mvm *mvm, struct ieee80211_sta *sta,
  465. int tid, u16 ssn, bool start)
  466. {
  467. struct iwl_mvm_sta *mvm_sta = (void *)sta->drv_priv;
  468. struct iwl_mvm_add_sta_cmd cmd = {};
  469. int ret;
  470. u32 status;
  471. lockdep_assert_held(&mvm->mutex);
  472. cmd.mac_id_n_color = cpu_to_le32(mvm_sta->mac_id_n_color);
  473. cmd.sta_id = mvm_sta->sta_id;
  474. cmd.add_modify = STA_MODE_MODIFY;
  475. cmd.add_immediate_ba_tid = (u8) tid;
  476. cmd.add_immediate_ba_ssn = cpu_to_le16(ssn);
  477. cmd.modify_mask = start ? STA_MODIFY_ADD_BA_TID :
  478. STA_MODIFY_REMOVE_BA_TID;
  479. status = ADD_STA_SUCCESS;
  480. ret = iwl_mvm_send_cmd_pdu_status(mvm, ADD_STA, sizeof(cmd),
  481. &cmd, &status);
  482. if (ret)
  483. return ret;
  484. switch (status) {
  485. case ADD_STA_SUCCESS:
  486. IWL_DEBUG_INFO(mvm, "RX BA Session %sed in fw\n",
  487. start ? "start" : "stopp");
  488. break;
  489. case ADD_STA_IMMEDIATE_BA_FAILURE:
  490. IWL_WARN(mvm, "RX BA Session refused by fw\n");
  491. ret = -ENOSPC;
  492. break;
  493. default:
  494. ret = -EIO;
  495. IWL_ERR(mvm, "RX BA Session failed %sing, status 0x%x\n",
  496. start ? "start" : "stopp", status);
  497. break;
  498. }
  499. return ret;
  500. }
  501. static int iwl_mvm_sta_tx_agg(struct iwl_mvm *mvm, struct ieee80211_sta *sta,
  502. int tid, u8 queue, bool start)
  503. {
  504. struct iwl_mvm_sta *mvm_sta = (void *)sta->drv_priv;
  505. struct iwl_mvm_add_sta_cmd cmd = {};
  506. int ret;
  507. u32 status;
  508. lockdep_assert_held(&mvm->mutex);
  509. if (start) {
  510. mvm_sta->tfd_queue_msk |= BIT(queue);
  511. mvm_sta->tid_disable_agg &= ~BIT(tid);
  512. } else {
  513. mvm_sta->tfd_queue_msk &= ~BIT(queue);
  514. mvm_sta->tid_disable_agg |= BIT(tid);
  515. }
  516. cmd.mac_id_n_color = cpu_to_le32(mvm_sta->mac_id_n_color);
  517. cmd.sta_id = mvm_sta->sta_id;
  518. cmd.add_modify = STA_MODE_MODIFY;
  519. cmd.modify_mask = STA_MODIFY_QUEUES | STA_MODIFY_TID_DISABLE_TX;
  520. cmd.tfd_queue_msk = cpu_to_le32(mvm_sta->tfd_queue_msk);
  521. cmd.tid_disable_tx = cpu_to_le16(mvm_sta->tid_disable_agg);
  522. status = ADD_STA_SUCCESS;
  523. ret = iwl_mvm_send_cmd_pdu_status(mvm, ADD_STA, sizeof(cmd),
  524. &cmd, &status);
  525. if (ret)
  526. return ret;
  527. switch (status) {
  528. case ADD_STA_SUCCESS:
  529. break;
  530. default:
  531. ret = -EIO;
  532. IWL_ERR(mvm, "TX BA Session failed %sing, status 0x%x\n",
  533. start ? "start" : "stopp", status);
  534. break;
  535. }
  536. return ret;
  537. }
  538. static const u8 tid_to_ac[] = {
  539. IEEE80211_AC_BE,
  540. IEEE80211_AC_BK,
  541. IEEE80211_AC_BK,
  542. IEEE80211_AC_BE,
  543. IEEE80211_AC_VI,
  544. IEEE80211_AC_VI,
  545. IEEE80211_AC_VO,
  546. IEEE80211_AC_VO,
  547. };
  548. int iwl_mvm_sta_tx_agg_start(struct iwl_mvm *mvm, struct ieee80211_vif *vif,
  549. struct ieee80211_sta *sta, u16 tid, u16 *ssn)
  550. {
  551. struct iwl_mvm_sta *mvmsta = (void *)sta->drv_priv;
  552. struct iwl_mvm_tid_data *tid_data;
  553. int txq_id;
  554. if (WARN_ON_ONCE(tid >= IWL_MAX_TID_COUNT))
  555. return -EINVAL;
  556. if (mvmsta->tid_data[tid].state != IWL_AGG_OFF) {
  557. IWL_ERR(mvm, "Start AGG when state is not IWL_AGG_OFF %d!\n",
  558. mvmsta->tid_data[tid].state);
  559. return -ENXIO;
  560. }
  561. lockdep_assert_held(&mvm->mutex);
  562. for (txq_id = IWL_MVM_FIRST_AGG_QUEUE;
  563. txq_id <= IWL_MVM_LAST_AGG_QUEUE; txq_id++)
  564. if (mvm->queue_to_mac80211[txq_id] ==
  565. IWL_INVALID_MAC80211_QUEUE)
  566. break;
  567. if (txq_id > IWL_MVM_LAST_AGG_QUEUE) {
  568. IWL_ERR(mvm, "Failed to allocate agg queue\n");
  569. return -EIO;
  570. }
  571. /* the new tx queue is still connected to the same mac80211 queue */
  572. mvm->queue_to_mac80211[txq_id] = vif->hw_queue[tid_to_ac[tid]];
  573. spin_lock_bh(&mvmsta->lock);
  574. tid_data = &mvmsta->tid_data[tid];
  575. tid_data->ssn = SEQ_TO_SN(tid_data->seq_number);
  576. tid_data->txq_id = txq_id;
  577. *ssn = tid_data->ssn;
  578. IWL_DEBUG_TX_QUEUES(mvm,
  579. "Start AGG: sta %d tid %d queue %d - ssn = %d, next_recl = %d\n",
  580. mvmsta->sta_id, tid, txq_id, tid_data->ssn,
  581. tid_data->next_reclaimed);
  582. if (tid_data->ssn == tid_data->next_reclaimed) {
  583. tid_data->state = IWL_AGG_STARTING;
  584. ieee80211_start_tx_ba_cb_irqsafe(vif, sta->addr, tid);
  585. } else {
  586. tid_data->state = IWL_EMPTYING_HW_QUEUE_ADDBA;
  587. }
  588. spin_unlock_bh(&mvmsta->lock);
  589. return 0;
  590. }
  591. int iwl_mvm_sta_tx_agg_oper(struct iwl_mvm *mvm, struct ieee80211_vif *vif,
  592. struct ieee80211_sta *sta, u16 tid, u8 buf_size)
  593. {
  594. struct iwl_mvm_sta *mvmsta = (void *)sta->drv_priv;
  595. struct iwl_mvm_tid_data *tid_data = &mvmsta->tid_data[tid];
  596. int queue, fifo, ret;
  597. u16 ssn;
  598. buf_size = min_t(int, buf_size, LINK_QUAL_AGG_FRAME_LIMIT_DEF);
  599. spin_lock_bh(&mvmsta->lock);
  600. ssn = tid_data->ssn;
  601. queue = tid_data->txq_id;
  602. tid_data->state = IWL_AGG_ON;
  603. tid_data->ssn = 0xffff;
  604. spin_unlock_bh(&mvmsta->lock);
  605. fifo = iwl_mvm_ac_to_tx_fifo[tid_to_ac[tid]];
  606. ret = iwl_mvm_sta_tx_agg(mvm, sta, tid, queue, true);
  607. if (ret)
  608. return -EIO;
  609. iwl_trans_txq_enable(mvm->trans, queue, fifo, mvmsta->sta_id, tid,
  610. buf_size, ssn);
  611. /*
  612. * Even though in theory the peer could have different
  613. * aggregation reorder buffer sizes for different sessions,
  614. * our ucode doesn't allow for that and has a global limit
  615. * for each station. Therefore, use the minimum of all the
  616. * aggregation sessions and our default value.
  617. */
  618. mvmsta->max_agg_bufsize =
  619. min(mvmsta->max_agg_bufsize, buf_size);
  620. mvmsta->lq_sta.lq.agg_frame_cnt_limit = mvmsta->max_agg_bufsize;
  621. if (mvm->cfg->ht_params->use_rts_for_aggregation) {
  622. /*
  623. * switch to RTS/CTS if it is the prefer protection
  624. * method for HT traffic
  625. */
  626. mvmsta->lq_sta.lq.flags |= LQ_FLAG_SET_STA_TLC_RTS_MSK;
  627. /*
  628. * TODO: remove the TLC_RTS flag when we tear down the last
  629. * AGG session (agg_tids_count in DVM)
  630. */
  631. }
  632. IWL_DEBUG_HT(mvm, "Tx aggregation enabled on ra = %pM tid = %d\n",
  633. sta->addr, tid);
  634. return iwl_mvm_send_lq_cmd(mvm, &mvmsta->lq_sta.lq, CMD_ASYNC, false);
  635. }
  636. int iwl_mvm_sta_tx_agg_stop(struct iwl_mvm *mvm, struct ieee80211_vif *vif,
  637. struct ieee80211_sta *sta, u16 tid)
  638. {
  639. struct iwl_mvm_sta *mvmsta = (void *)sta->drv_priv;
  640. struct iwl_mvm_tid_data *tid_data = &mvmsta->tid_data[tid];
  641. u16 txq_id;
  642. int err;
  643. spin_lock_bh(&mvmsta->lock);
  644. txq_id = tid_data->txq_id;
  645. IWL_DEBUG_TX_QUEUES(mvm, "Stop AGG: sta %d tid %d q %d state %d\n",
  646. mvmsta->sta_id, tid, txq_id, tid_data->state);
  647. switch (tid_data->state) {
  648. case IWL_AGG_ON:
  649. tid_data->ssn = SEQ_TO_SN(tid_data->seq_number);
  650. IWL_DEBUG_TX_QUEUES(mvm,
  651. "ssn = %d, next_recl = %d\n",
  652. tid_data->ssn, tid_data->next_reclaimed);
  653. /* There are still packets for this RA / TID in the HW */
  654. if (tid_data->ssn != tid_data->next_reclaimed) {
  655. tid_data->state = IWL_EMPTYING_HW_QUEUE_DELBA;
  656. err = 0;
  657. break;
  658. }
  659. tid_data->ssn = 0xffff;
  660. iwl_trans_txq_disable(mvm->trans, txq_id);
  661. /* fall through */
  662. case IWL_AGG_STARTING:
  663. case IWL_EMPTYING_HW_QUEUE_ADDBA:
  664. /*
  665. * The agg session has been stopped before it was set up. This
  666. * can happen when the AddBA timer times out for example.
  667. */
  668. /* No barriers since we are under mutex */
  669. lockdep_assert_held(&mvm->mutex);
  670. mvm->queue_to_mac80211[txq_id] = IWL_INVALID_MAC80211_QUEUE;
  671. ieee80211_stop_tx_ba_cb_irqsafe(vif, sta->addr, tid);
  672. tid_data->state = IWL_AGG_OFF;
  673. err = 0;
  674. break;
  675. default:
  676. IWL_ERR(mvm,
  677. "Stopping AGG while state not ON or starting for %d on %d (%d)\n",
  678. mvmsta->sta_id, tid, tid_data->state);
  679. IWL_ERR(mvm,
  680. "\ttid_data->txq_id = %d\n", tid_data->txq_id);
  681. err = -EINVAL;
  682. }
  683. spin_unlock_bh(&mvmsta->lock);
  684. return err;
  685. }
  686. static int iwl_mvm_set_fw_key_idx(struct iwl_mvm *mvm)
  687. {
  688. int i;
  689. lockdep_assert_held(&mvm->mutex);
  690. i = find_first_zero_bit(mvm->fw_key_table, STA_KEY_MAX_NUM);
  691. if (i == STA_KEY_MAX_NUM)
  692. return STA_KEY_IDX_INVALID;
  693. __set_bit(i, mvm->fw_key_table);
  694. return i;
  695. }
  696. static u8 iwl_mvm_get_key_sta_id(struct ieee80211_vif *vif,
  697. struct ieee80211_sta *sta)
  698. {
  699. struct iwl_mvm_vif *mvmvif = (void *)vif->drv_priv;
  700. if (sta) {
  701. struct iwl_mvm_sta *mvm_sta = (void *)sta->drv_priv;
  702. return mvm_sta->sta_id;
  703. }
  704. /*
  705. * The device expects GTKs for station interfaces to be
  706. * installed as GTKs for the AP station. If we have no
  707. * station ID, then use AP's station ID.
  708. */
  709. if (vif->type == NL80211_IFTYPE_STATION &&
  710. mvmvif->ap_sta_id != IWL_MVM_STATION_COUNT)
  711. return mvmvif->ap_sta_id;
  712. return IWL_INVALID_STATION;
  713. }
  714. static int iwl_mvm_send_sta_key(struct iwl_mvm *mvm,
  715. struct iwl_mvm_sta *mvm_sta,
  716. struct ieee80211_key_conf *keyconf,
  717. u8 sta_id, u32 tkip_iv32, u16 *tkip_p1k,
  718. u32 cmd_flags)
  719. {
  720. __le16 key_flags;
  721. struct iwl_mvm_add_sta_cmd cmd = {};
  722. int ret, status;
  723. u16 keyidx;
  724. int i;
  725. keyidx = (keyconf->keyidx << STA_KEY_FLG_KEYID_POS) &
  726. STA_KEY_FLG_KEYID_MSK;
  727. key_flags = cpu_to_le16(keyidx);
  728. key_flags |= cpu_to_le16(STA_KEY_FLG_WEP_KEY_MAP);
  729. switch (keyconf->cipher) {
  730. case WLAN_CIPHER_SUITE_TKIP:
  731. key_flags |= cpu_to_le16(STA_KEY_FLG_TKIP);
  732. cmd.key.tkip_rx_tsc_byte2 = tkip_iv32;
  733. for (i = 0; i < 5; i++)
  734. cmd.key.tkip_rx_ttak[i] = cpu_to_le16(tkip_p1k[i]);
  735. memcpy(cmd.key.key, keyconf->key, keyconf->keylen);
  736. break;
  737. case WLAN_CIPHER_SUITE_CCMP:
  738. key_flags |= cpu_to_le16(STA_KEY_FLG_CCM);
  739. memcpy(cmd.key.key, keyconf->key, keyconf->keylen);
  740. break;
  741. default:
  742. WARN_ON(1);
  743. return -EINVAL;
  744. }
  745. if (!(keyconf->flags & IEEE80211_KEY_FLAG_PAIRWISE))
  746. key_flags |= cpu_to_le16(STA_KEY_MULTICAST);
  747. cmd.mac_id_n_color = cpu_to_le32(mvm_sta->mac_id_n_color);
  748. cmd.key.key_offset = keyconf->hw_key_idx;
  749. cmd.key.key_flags = key_flags;
  750. cmd.add_modify = STA_MODE_MODIFY;
  751. cmd.modify_mask = STA_MODIFY_KEY;
  752. cmd.sta_id = sta_id;
  753. status = ADD_STA_SUCCESS;
  754. if (cmd_flags == CMD_SYNC)
  755. ret = iwl_mvm_send_cmd_pdu_status(mvm, ADD_STA, sizeof(cmd),
  756. &cmd, &status);
  757. else
  758. ret = iwl_mvm_send_cmd_pdu(mvm, ADD_STA, CMD_ASYNC,
  759. sizeof(cmd), &cmd);
  760. switch (status) {
  761. case ADD_STA_SUCCESS:
  762. IWL_DEBUG_WEP(mvm, "MODIFY_STA: set dynamic key passed\n");
  763. break;
  764. default:
  765. ret = -EIO;
  766. IWL_ERR(mvm, "MODIFY_STA: set dynamic key failed\n");
  767. break;
  768. }
  769. return ret;
  770. }
  771. static int iwl_mvm_send_sta_igtk(struct iwl_mvm *mvm,
  772. struct ieee80211_key_conf *keyconf,
  773. u8 sta_id, bool remove_key)
  774. {
  775. struct iwl_mvm_mgmt_mcast_key_cmd igtk_cmd = {};
  776. /* verify the key details match the required command's expectations */
  777. if (WARN_ON((keyconf->cipher != WLAN_CIPHER_SUITE_AES_CMAC) ||
  778. (keyconf->flags & IEEE80211_KEY_FLAG_PAIRWISE) ||
  779. (keyconf->keyidx != 4 && keyconf->keyidx != 5)))
  780. return -EINVAL;
  781. igtk_cmd.key_id = cpu_to_le32(keyconf->keyidx);
  782. igtk_cmd.sta_id = cpu_to_le32(sta_id);
  783. if (remove_key) {
  784. igtk_cmd.ctrl_flags |= cpu_to_le32(STA_KEY_NOT_VALID);
  785. } else {
  786. struct ieee80211_key_seq seq;
  787. const u8 *pn;
  788. memcpy(igtk_cmd.IGTK, keyconf->key, keyconf->keylen);
  789. ieee80211_aes_cmac_calculate_k1_k2(keyconf,
  790. igtk_cmd.K1, igtk_cmd.K2);
  791. ieee80211_get_key_rx_seq(keyconf, 0, &seq);
  792. pn = seq.aes_cmac.pn;
  793. igtk_cmd.receive_seq_cnt = cpu_to_le64(((u64) pn[5] << 0) |
  794. ((u64) pn[4] << 8) |
  795. ((u64) pn[3] << 16) |
  796. ((u64) pn[2] << 24) |
  797. ((u64) pn[1] << 32) |
  798. ((u64) pn[0] << 40));
  799. }
  800. IWL_DEBUG_INFO(mvm, "%s igtk for sta %u\n",
  801. remove_key ? "removing" : "installing",
  802. igtk_cmd.sta_id);
  803. return iwl_mvm_send_cmd_pdu(mvm, MGMT_MCAST_KEY, CMD_SYNC,
  804. sizeof(igtk_cmd), &igtk_cmd);
  805. }
  806. static inline u8 *iwl_mvm_get_mac_addr(struct iwl_mvm *mvm,
  807. struct ieee80211_vif *vif,
  808. struct ieee80211_sta *sta)
  809. {
  810. struct iwl_mvm_vif *mvmvif = (void *)vif->drv_priv;
  811. if (sta)
  812. return sta->addr;
  813. if (vif->type == NL80211_IFTYPE_STATION &&
  814. mvmvif->ap_sta_id != IWL_MVM_STATION_COUNT) {
  815. u8 sta_id = mvmvif->ap_sta_id;
  816. sta = rcu_dereference_protected(mvm->fw_id_to_mac_id[sta_id],
  817. lockdep_is_held(&mvm->mutex));
  818. return sta->addr;
  819. }
  820. return NULL;
  821. }
  822. int iwl_mvm_set_sta_key(struct iwl_mvm *mvm,
  823. struct ieee80211_vif *vif,
  824. struct ieee80211_sta *sta,
  825. struct ieee80211_key_conf *keyconf,
  826. bool have_key_offset)
  827. {
  828. struct iwl_mvm_sta *mvm_sta;
  829. int ret;
  830. u8 *addr, sta_id;
  831. struct ieee80211_key_seq seq;
  832. u16 p1k[5];
  833. lockdep_assert_held(&mvm->mutex);
  834. /* Get the station id from the mvm local station table */
  835. sta_id = iwl_mvm_get_key_sta_id(vif, sta);
  836. if (sta_id == IWL_INVALID_STATION) {
  837. IWL_ERR(mvm, "Failed to find station id\n");
  838. return -EINVAL;
  839. }
  840. if (keyconf->cipher == WLAN_CIPHER_SUITE_AES_CMAC) {
  841. ret = iwl_mvm_send_sta_igtk(mvm, keyconf, sta_id, false);
  842. goto end;
  843. }
  844. /*
  845. * It is possible that the 'sta' parameter is NULL, and thus
  846. * there is a need to retrieve the sta from the local station table.
  847. */
  848. if (!sta) {
  849. sta = rcu_dereference_protected(mvm->fw_id_to_mac_id[sta_id],
  850. lockdep_is_held(&mvm->mutex));
  851. if (IS_ERR_OR_NULL(sta)) {
  852. IWL_ERR(mvm, "Invalid station id\n");
  853. return -EINVAL;
  854. }
  855. }
  856. mvm_sta = (struct iwl_mvm_sta *)sta->drv_priv;
  857. if (WARN_ON_ONCE(mvm_sta->vif != vif))
  858. return -EINVAL;
  859. if (!have_key_offset) {
  860. /*
  861. * The D3 firmware hardcodes the PTK offset to 0, so we have to
  862. * configure it there. As a result, this workaround exists to
  863. * let the caller set the key offset (hw_key_idx), see d3.c.
  864. */
  865. keyconf->hw_key_idx = iwl_mvm_set_fw_key_idx(mvm);
  866. if (keyconf->hw_key_idx == STA_KEY_IDX_INVALID)
  867. return -ENOSPC;
  868. }
  869. switch (keyconf->cipher) {
  870. case WLAN_CIPHER_SUITE_TKIP:
  871. addr = iwl_mvm_get_mac_addr(mvm, vif, sta);
  872. /* get phase 1 key from mac80211 */
  873. ieee80211_get_key_rx_seq(keyconf, 0, &seq);
  874. ieee80211_get_tkip_rx_p1k(keyconf, addr, seq.tkip.iv32, p1k);
  875. ret = iwl_mvm_send_sta_key(mvm, mvm_sta, keyconf, sta_id,
  876. seq.tkip.iv32, p1k, CMD_SYNC);
  877. break;
  878. case WLAN_CIPHER_SUITE_CCMP:
  879. ret = iwl_mvm_send_sta_key(mvm, mvm_sta, keyconf, sta_id,
  880. 0, NULL, CMD_SYNC);
  881. break;
  882. default:
  883. IWL_ERR(mvm, "Unknown cipher %x\n", keyconf->cipher);
  884. ret = -EINVAL;
  885. }
  886. if (ret)
  887. __clear_bit(keyconf->hw_key_idx, mvm->fw_key_table);
  888. end:
  889. IWL_DEBUG_WEP(mvm, "key: cipher=%x len=%d idx=%d sta=%pM ret=%d\n",
  890. keyconf->cipher, keyconf->keylen, keyconf->keyidx,
  891. sta->addr, ret);
  892. return ret;
  893. }
  894. int iwl_mvm_remove_sta_key(struct iwl_mvm *mvm,
  895. struct ieee80211_vif *vif,
  896. struct ieee80211_sta *sta,
  897. struct ieee80211_key_conf *keyconf)
  898. {
  899. struct iwl_mvm_sta *mvm_sta;
  900. struct iwl_mvm_add_sta_cmd cmd = {};
  901. __le16 key_flags;
  902. int ret, status;
  903. u8 sta_id;
  904. lockdep_assert_held(&mvm->mutex);
  905. /* Get the station id from the mvm local station table */
  906. sta_id = iwl_mvm_get_key_sta_id(vif, sta);
  907. IWL_DEBUG_WEP(mvm, "mvm remove dynamic key: idx=%d sta=%d\n",
  908. keyconf->keyidx, sta_id);
  909. if (keyconf->cipher == WLAN_CIPHER_SUITE_AES_CMAC)
  910. return iwl_mvm_send_sta_igtk(mvm, keyconf, sta_id, true);
  911. ret = __test_and_clear_bit(keyconf->hw_key_idx, mvm->fw_key_table);
  912. if (!ret) {
  913. IWL_ERR(mvm, "offset %d not used in fw key table.\n",
  914. keyconf->hw_key_idx);
  915. return -ENOENT;
  916. }
  917. if (sta_id == IWL_INVALID_STATION) {
  918. IWL_DEBUG_WEP(mvm, "station non-existent, early return.\n");
  919. return 0;
  920. }
  921. /*
  922. * It is possible that the 'sta' parameter is NULL, and thus
  923. * there is a need to retrieve the sta from the local station table,
  924. * for example when a GTK is removed (where the sta_id will then be
  925. * the AP ID, and no station was passed by mac80211.)
  926. */
  927. if (!sta) {
  928. sta = rcu_dereference_protected(mvm->fw_id_to_mac_id[sta_id],
  929. lockdep_is_held(&mvm->mutex));
  930. if (!sta) {
  931. IWL_ERR(mvm, "Invalid station id\n");
  932. return -EINVAL;
  933. }
  934. }
  935. mvm_sta = (struct iwl_mvm_sta *)sta->drv_priv;
  936. if (WARN_ON_ONCE(mvm_sta->vif != vif))
  937. return -EINVAL;
  938. key_flags = cpu_to_le16((keyconf->keyidx << STA_KEY_FLG_KEYID_POS) &
  939. STA_KEY_FLG_KEYID_MSK);
  940. key_flags |= cpu_to_le16(STA_KEY_FLG_NO_ENC | STA_KEY_FLG_WEP_KEY_MAP);
  941. key_flags |= cpu_to_le16(STA_KEY_NOT_VALID);
  942. if (!(keyconf->flags & IEEE80211_KEY_FLAG_PAIRWISE))
  943. key_flags |= cpu_to_le16(STA_KEY_MULTICAST);
  944. cmd.mac_id_n_color = cpu_to_le32(mvm_sta->mac_id_n_color);
  945. cmd.key.key_flags = key_flags;
  946. cmd.key.key_offset = keyconf->hw_key_idx;
  947. cmd.sta_id = sta_id;
  948. cmd.modify_mask = STA_MODIFY_KEY;
  949. cmd.add_modify = STA_MODE_MODIFY;
  950. status = ADD_STA_SUCCESS;
  951. ret = iwl_mvm_send_cmd_pdu_status(mvm, ADD_STA, sizeof(cmd),
  952. &cmd, &status);
  953. switch (status) {
  954. case ADD_STA_SUCCESS:
  955. IWL_DEBUG_WEP(mvm, "MODIFY_STA: remove sta key passed\n");
  956. break;
  957. default:
  958. ret = -EIO;
  959. IWL_ERR(mvm, "MODIFY_STA: remove sta key failed\n");
  960. break;
  961. }
  962. return ret;
  963. }
  964. void iwl_mvm_update_tkip_key(struct iwl_mvm *mvm,
  965. struct ieee80211_vif *vif,
  966. struct ieee80211_key_conf *keyconf,
  967. struct ieee80211_sta *sta, u32 iv32,
  968. u16 *phase1key)
  969. {
  970. struct iwl_mvm_sta *mvm_sta;
  971. u8 sta_id = iwl_mvm_get_key_sta_id(vif, sta);
  972. if (WARN_ON_ONCE(sta_id == IWL_INVALID_STATION))
  973. return;
  974. rcu_read_lock();
  975. if (!sta) {
  976. sta = rcu_dereference(mvm->fw_id_to_mac_id[sta_id]);
  977. if (WARN_ON(IS_ERR_OR_NULL(sta))) {
  978. rcu_read_unlock();
  979. return;
  980. }
  981. }
  982. mvm_sta = (void *)sta->drv_priv;
  983. iwl_mvm_send_sta_key(mvm, mvm_sta, keyconf, sta_id,
  984. iv32, phase1key, CMD_ASYNC);
  985. rcu_read_unlock();
  986. }
  987. void iwl_mvm_sta_modify_ps_wake(struct iwl_mvm *mvm, int sta_id)
  988. {
  989. struct iwl_mvm_add_sta_cmd cmd = {
  990. .add_modify = STA_MODE_MODIFY,
  991. .sta_id = sta_id,
  992. .modify_mask = STA_MODIFY_SLEEPING_STA_TX_COUNT,
  993. .sleep_state_flags = cpu_to_le16(STA_SLEEP_STATE_AWAKE),
  994. };
  995. int ret;
  996. /*
  997. * Same modify mask for sleep_tx_count and sleep_state_flags but this
  998. * should be fine since if we set the STA as "awake", then
  999. * sleep_tx_count is not relevant.
  1000. */
  1001. ret = iwl_mvm_send_cmd_pdu(mvm, ADD_STA, CMD_ASYNC, sizeof(cmd), &cmd);
  1002. if (ret)
  1003. IWL_ERR(mvm, "Failed to send ADD_STA command (%d)\n", ret);
  1004. }
  1005. void iwl_mvm_sta_modify_sleep_tx_count(struct iwl_mvm *mvm, int sta_id,
  1006. enum ieee80211_frame_release_type reason,
  1007. u16 cnt)
  1008. {
  1009. u16 sleep_state_flags =
  1010. (reason == IEEE80211_FRAME_RELEASE_UAPSD) ?
  1011. STA_SLEEP_STATE_UAPSD : STA_SLEEP_STATE_PS_POLL;
  1012. struct iwl_mvm_add_sta_cmd cmd = {
  1013. .add_modify = STA_MODE_MODIFY,
  1014. .sta_id = sta_id,
  1015. .modify_mask = STA_MODIFY_SLEEPING_STA_TX_COUNT,
  1016. .sleep_tx_count = cpu_to_le16(cnt),
  1017. /*
  1018. * Same modify mask for sleep_tx_count and sleep_state_flags so
  1019. * we must set the sleep_state_flags too.
  1020. */
  1021. .sleep_state_flags = cpu_to_le16(sleep_state_flags),
  1022. };
  1023. int ret;
  1024. /* TODO: somehow the fw doesn't seem to take PS_POLL into account */
  1025. ret = iwl_mvm_send_cmd_pdu(mvm, ADD_STA, CMD_ASYNC, sizeof(cmd), &cmd);
  1026. if (ret)
  1027. IWL_ERR(mvm, "Failed to send ADD_STA command (%d)\n", ret);
  1028. }