mac-ctxt.c 35 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125
  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 COPYING.
  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 <linux/etherdevice.h>
  64. #include <net/mac80211.h>
  65. #include "iwl-io.h"
  66. #include "iwl-prph.h"
  67. #include "fw-api.h"
  68. #include "mvm.h"
  69. const u8 iwl_mvm_ac_to_tx_fifo[] = {
  70. IWL_MVM_TX_FIFO_BK,
  71. IWL_MVM_TX_FIFO_BE,
  72. IWL_MVM_TX_FIFO_VI,
  73. IWL_MVM_TX_FIFO_VO,
  74. };
  75. struct iwl_mvm_mac_iface_iterator_data {
  76. struct iwl_mvm *mvm;
  77. struct ieee80211_vif *vif;
  78. unsigned long available_mac_ids[BITS_TO_LONGS(NUM_MAC_INDEX_DRIVER)];
  79. unsigned long available_tsf_ids[BITS_TO_LONGS(NUM_TSF_IDS)];
  80. unsigned long used_hw_queues[BITS_TO_LONGS(IWL_MVM_FIRST_AGG_QUEUE)];
  81. enum iwl_tsf_id preferred_tsf;
  82. bool found_vif;
  83. };
  84. static void iwl_mvm_mac_iface_iterator(void *_data, u8 *mac,
  85. struct ieee80211_vif *vif)
  86. {
  87. struct iwl_mvm_mac_iface_iterator_data *data = _data;
  88. struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
  89. u32 ac;
  90. /* Iterator may already find the interface being added -- skip it */
  91. if (vif == data->vif) {
  92. data->found_vif = true;
  93. return;
  94. }
  95. /* Mark the queues used by the vif */
  96. for (ac = 0; ac < IEEE80211_NUM_ACS; ac++)
  97. if (vif->hw_queue[ac] != IEEE80211_INVAL_HW_QUEUE)
  98. __set_bit(vif->hw_queue[ac], data->used_hw_queues);
  99. if (vif->cab_queue != IEEE80211_INVAL_HW_QUEUE)
  100. __set_bit(vif->cab_queue, data->used_hw_queues);
  101. /*
  102. * Mark MAC IDs as used by clearing the available bit, and
  103. * (below) mark TSFs as used if their existing use is not
  104. * compatible with the new interface type.
  105. * No locking or atomic bit operations are needed since the
  106. * data is on the stack of the caller function.
  107. */
  108. __clear_bit(mvmvif->id, data->available_mac_ids);
  109. /*
  110. * The TSF is a hardware/firmware resource, there are 4 and
  111. * the driver should assign and free them as needed. However,
  112. * there are cases where 2 MACs should share the same TSF ID
  113. * for the purpose of clock sync, an optimization to avoid
  114. * clock drift causing overlapping TBTTs/DTIMs for a GO and
  115. * client in the system.
  116. *
  117. * The firmware will decide according to the MAC type which
  118. * will be the master and slave. Clients that need to sync
  119. * with a remote station will be the master, and an AP or GO
  120. * will be the slave.
  121. *
  122. * Depending on the new interface type it can be slaved to
  123. * or become the master of an existing interface.
  124. */
  125. switch (data->vif->type) {
  126. case NL80211_IFTYPE_STATION:
  127. /*
  128. * The new interface is client, so if the existing one
  129. * we're iterating is an AP, the TSF should be used to
  130. * avoid drift between the new client and existing AP,
  131. * the existing AP will get drift updates from the new
  132. * client context in this case
  133. */
  134. if (vif->type == NL80211_IFTYPE_AP) {
  135. if (data->preferred_tsf == NUM_TSF_IDS &&
  136. test_bit(mvmvif->tsf_id, data->available_tsf_ids))
  137. data->preferred_tsf = mvmvif->tsf_id;
  138. return;
  139. }
  140. break;
  141. case NL80211_IFTYPE_AP:
  142. /*
  143. * The new interface is AP/GO, so should get drift
  144. * updates from an existing client or use the same
  145. * TSF as an existing GO. There's no drift between
  146. * TSFs internally but if they used different TSFs
  147. * then a new client MAC could update one of them
  148. * and cause drift that way.
  149. */
  150. if (vif->type == NL80211_IFTYPE_STATION ||
  151. vif->type == NL80211_IFTYPE_AP) {
  152. if (data->preferred_tsf == NUM_TSF_IDS &&
  153. test_bit(mvmvif->tsf_id, data->available_tsf_ids))
  154. data->preferred_tsf = mvmvif->tsf_id;
  155. return;
  156. }
  157. break;
  158. default:
  159. /*
  160. * For all other interface types there's no need to
  161. * take drift into account. Either they're exclusive
  162. * like IBSS and monitor, or we don't care much about
  163. * their TSF (like P2P Device), but we won't be able
  164. * to share the TSF resource.
  165. */
  166. break;
  167. }
  168. /*
  169. * Unless we exited above, we can't share the TSF resource
  170. * that the virtual interface we're iterating over is using
  171. * with the new one, so clear the available bit and if this
  172. * was the preferred one, reset that as well.
  173. */
  174. __clear_bit(mvmvif->tsf_id, data->available_tsf_ids);
  175. if (data->preferred_tsf == mvmvif->tsf_id)
  176. data->preferred_tsf = NUM_TSF_IDS;
  177. }
  178. /*
  179. * Get the mask of the queus used by the vif
  180. */
  181. u32 iwl_mvm_mac_get_queues_mask(struct iwl_mvm *mvm,
  182. struct ieee80211_vif *vif)
  183. {
  184. u32 qmask = 0, ac;
  185. if (vif->type == NL80211_IFTYPE_P2P_DEVICE)
  186. return BIT(IWL_MVM_OFFCHANNEL_QUEUE);
  187. for (ac = 0; ac < IEEE80211_NUM_ACS; ac++)
  188. if (vif->hw_queue[ac] != IEEE80211_INVAL_HW_QUEUE)
  189. qmask |= BIT(vif->hw_queue[ac]);
  190. return qmask;
  191. }
  192. static int iwl_mvm_mac_ctxt_allocate_resources(struct iwl_mvm *mvm,
  193. struct ieee80211_vif *vif)
  194. {
  195. struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
  196. struct iwl_mvm_mac_iface_iterator_data data = {
  197. .mvm = mvm,
  198. .vif = vif,
  199. .available_mac_ids = { (1 << NUM_MAC_INDEX_DRIVER) - 1 },
  200. .available_tsf_ids = { (1 << NUM_TSF_IDS) - 1 },
  201. /* no preference yet */
  202. .preferred_tsf = NUM_TSF_IDS,
  203. .used_hw_queues = {
  204. BIT(IWL_MVM_OFFCHANNEL_QUEUE) |
  205. BIT(IWL_MVM_AUX_QUEUE) |
  206. BIT(IWL_MVM_CMD_QUEUE)
  207. },
  208. .found_vif = false,
  209. };
  210. u32 ac;
  211. int ret, i;
  212. /*
  213. * Allocate a MAC ID and a TSF for this MAC, along with the queues
  214. * and other resources.
  215. */
  216. /*
  217. * Before the iterator, we start with all MAC IDs and TSFs available.
  218. *
  219. * During iteration, all MAC IDs are cleared that are in use by other
  220. * virtual interfaces, and all TSF IDs are cleared that can't be used
  221. * by this new virtual interface because they're used by an interface
  222. * that can't share it with the new one.
  223. * At the same time, we check if there's a preferred TSF in the case
  224. * that we should share it with another interface.
  225. */
  226. /* Currently, MAC ID 0 should be used only for the managed vif */
  227. if (vif->type != NL80211_IFTYPE_STATION || vif->p2p)
  228. __clear_bit(0, data.available_mac_ids);
  229. ieee80211_iterate_active_interfaces_atomic(
  230. mvm->hw, IEEE80211_IFACE_ITER_RESUME_ALL,
  231. iwl_mvm_mac_iface_iterator, &data);
  232. /*
  233. * In the case we're getting here during resume, it's similar to
  234. * firmware restart, and with RESUME_ALL the iterator will find
  235. * the vif being added already.
  236. * We don't want to reassign any IDs in either case since doing
  237. * so would probably assign different IDs (as interfaces aren't
  238. * necessarily added in the same order), but the old IDs were
  239. * preserved anyway, so skip ID assignment for both resume and
  240. * recovery.
  241. */
  242. if (data.found_vif)
  243. return 0;
  244. /* Therefore, in recovery, we can't get here */
  245. if (WARN_ON_ONCE(test_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status)))
  246. return -EBUSY;
  247. mvmvif->id = find_first_bit(data.available_mac_ids,
  248. NUM_MAC_INDEX_DRIVER);
  249. if (mvmvif->id == NUM_MAC_INDEX_DRIVER) {
  250. IWL_ERR(mvm, "Failed to init MAC context - no free ID!\n");
  251. ret = -EIO;
  252. goto exit_fail;
  253. }
  254. if (data.preferred_tsf != NUM_TSF_IDS)
  255. mvmvif->tsf_id = data.preferred_tsf;
  256. else
  257. mvmvif->tsf_id = find_first_bit(data.available_tsf_ids,
  258. NUM_TSF_IDS);
  259. if (mvmvif->tsf_id == NUM_TSF_IDS) {
  260. IWL_ERR(mvm, "Failed to init MAC context - no free TSF!\n");
  261. ret = -EIO;
  262. goto exit_fail;
  263. }
  264. mvmvif->color = 0;
  265. INIT_LIST_HEAD(&mvmvif->time_event_data.list);
  266. mvmvif->time_event_data.id = TE_MAX;
  267. /* No need to allocate data queues to P2P Device MAC.*/
  268. if (vif->type == NL80211_IFTYPE_P2P_DEVICE) {
  269. for (ac = 0; ac < IEEE80211_NUM_ACS; ac++)
  270. vif->hw_queue[ac] = IEEE80211_INVAL_HW_QUEUE;
  271. return 0;
  272. }
  273. /* Find available queues, and allocate them to the ACs */
  274. for (ac = 0; ac < IEEE80211_NUM_ACS; ac++) {
  275. u8 queue = find_first_zero_bit(data.used_hw_queues,
  276. IWL_MVM_FIRST_AGG_QUEUE);
  277. if (queue >= IWL_MVM_FIRST_AGG_QUEUE) {
  278. IWL_ERR(mvm, "Failed to allocate queue\n");
  279. ret = -EIO;
  280. goto exit_fail;
  281. }
  282. __set_bit(queue, data.used_hw_queues);
  283. vif->hw_queue[ac] = queue;
  284. }
  285. /* Allocate the CAB queue for softAP and GO interfaces */
  286. if (vif->type == NL80211_IFTYPE_AP) {
  287. u8 queue = find_first_zero_bit(data.used_hw_queues,
  288. IWL_MVM_FIRST_AGG_QUEUE);
  289. if (queue >= IWL_MVM_FIRST_AGG_QUEUE) {
  290. IWL_ERR(mvm, "Failed to allocate cab queue\n");
  291. ret = -EIO;
  292. goto exit_fail;
  293. }
  294. vif->cab_queue = queue;
  295. } else {
  296. vif->cab_queue = IEEE80211_INVAL_HW_QUEUE;
  297. }
  298. mvmvif->bcast_sta.sta_id = IWL_MVM_STATION_COUNT;
  299. mvmvif->ap_sta_id = IWL_MVM_STATION_COUNT;
  300. for (i = 0; i < NUM_IWL_MVM_SMPS_REQ; i++)
  301. mvmvif->smps_requests[i] = IEEE80211_SMPS_AUTOMATIC;
  302. return 0;
  303. exit_fail:
  304. memset(mvmvif, 0, sizeof(struct iwl_mvm_vif));
  305. memset(vif->hw_queue, IEEE80211_INVAL_HW_QUEUE, sizeof(vif->hw_queue));
  306. vif->cab_queue = IEEE80211_INVAL_HW_QUEUE;
  307. return ret;
  308. }
  309. int iwl_mvm_mac_ctxt_init(struct iwl_mvm *mvm, struct ieee80211_vif *vif)
  310. {
  311. u32 ac;
  312. int ret;
  313. lockdep_assert_held(&mvm->mutex);
  314. ret = iwl_mvm_mac_ctxt_allocate_resources(mvm, vif);
  315. if (ret)
  316. return ret;
  317. switch (vif->type) {
  318. case NL80211_IFTYPE_P2P_DEVICE:
  319. iwl_trans_ac_txq_enable(mvm->trans, IWL_MVM_OFFCHANNEL_QUEUE,
  320. IWL_MVM_TX_FIFO_VO);
  321. break;
  322. case NL80211_IFTYPE_AP:
  323. iwl_trans_ac_txq_enable(mvm->trans, vif->cab_queue,
  324. IWL_MVM_TX_FIFO_MCAST);
  325. /* fall through */
  326. default:
  327. for (ac = 0; ac < IEEE80211_NUM_ACS; ac++)
  328. iwl_trans_ac_txq_enable(mvm->trans, vif->hw_queue[ac],
  329. iwl_mvm_ac_to_tx_fifo[ac]);
  330. break;
  331. }
  332. return 0;
  333. }
  334. void iwl_mvm_mac_ctxt_release(struct iwl_mvm *mvm, struct ieee80211_vif *vif)
  335. {
  336. int ac;
  337. lockdep_assert_held(&mvm->mutex);
  338. switch (vif->type) {
  339. case NL80211_IFTYPE_P2P_DEVICE:
  340. iwl_trans_txq_disable(mvm->trans, IWL_MVM_OFFCHANNEL_QUEUE);
  341. break;
  342. case NL80211_IFTYPE_AP:
  343. iwl_trans_txq_disable(mvm->trans, vif->cab_queue);
  344. /* fall through */
  345. default:
  346. for (ac = 0; ac < IEEE80211_NUM_ACS; ac++)
  347. iwl_trans_txq_disable(mvm->trans, vif->hw_queue[ac]);
  348. }
  349. }
  350. static void iwl_mvm_ack_rates(struct iwl_mvm *mvm,
  351. struct ieee80211_vif *vif,
  352. enum ieee80211_band band,
  353. u8 *cck_rates, u8 *ofdm_rates)
  354. {
  355. struct ieee80211_supported_band *sband;
  356. unsigned long basic = vif->bss_conf.basic_rates;
  357. int lowest_present_ofdm = 100;
  358. int lowest_present_cck = 100;
  359. u8 cck = 0;
  360. u8 ofdm = 0;
  361. int i;
  362. sband = mvm->hw->wiphy->bands[band];
  363. for_each_set_bit(i, &basic, BITS_PER_LONG) {
  364. int hw = sband->bitrates[i].hw_value;
  365. if (hw >= IWL_FIRST_OFDM_RATE) {
  366. ofdm |= BIT(hw - IWL_FIRST_OFDM_RATE);
  367. if (lowest_present_ofdm > hw)
  368. lowest_present_ofdm = hw;
  369. } else {
  370. BUILD_BUG_ON(IWL_FIRST_CCK_RATE != 0);
  371. cck |= BIT(hw);
  372. if (lowest_present_cck > hw)
  373. lowest_present_cck = hw;
  374. }
  375. }
  376. /*
  377. * Now we've got the basic rates as bitmaps in the ofdm and cck
  378. * variables. This isn't sufficient though, as there might not
  379. * be all the right rates in the bitmap. E.g. if the only basic
  380. * rates are 5.5 Mbps and 11 Mbps, we still need to add 1 Mbps
  381. * and 6 Mbps because the 802.11-2007 standard says in 9.6:
  382. *
  383. * [...] a STA responding to a received frame shall transmit
  384. * its Control Response frame [...] at the highest rate in the
  385. * BSSBasicRateSet parameter that is less than or equal to the
  386. * rate of the immediately previous frame in the frame exchange
  387. * sequence ([...]) and that is of the same modulation class
  388. * ([...]) as the received frame. If no rate contained in the
  389. * BSSBasicRateSet parameter meets these conditions, then the
  390. * control frame sent in response to a received frame shall be
  391. * transmitted at the highest mandatory rate of the PHY that is
  392. * less than or equal to the rate of the received frame, and
  393. * that is of the same modulation class as the received frame.
  394. *
  395. * As a consequence, we need to add all mandatory rates that are
  396. * lower than all of the basic rates to these bitmaps.
  397. */
  398. if (IWL_RATE_24M_INDEX < lowest_present_ofdm)
  399. ofdm |= IWL_RATE_BIT_MSK(24) >> IWL_FIRST_OFDM_RATE;
  400. if (IWL_RATE_12M_INDEX < lowest_present_ofdm)
  401. ofdm |= IWL_RATE_BIT_MSK(12) >> IWL_FIRST_OFDM_RATE;
  402. /* 6M already there or needed so always add */
  403. ofdm |= IWL_RATE_BIT_MSK(6) >> IWL_FIRST_OFDM_RATE;
  404. /*
  405. * CCK is a bit more complex with DSSS vs. HR/DSSS vs. ERP.
  406. * Note, however:
  407. * - if no CCK rates are basic, it must be ERP since there must
  408. * be some basic rates at all, so they're OFDM => ERP PHY
  409. * (or we're in 5 GHz, and the cck bitmap will never be used)
  410. * - if 11M is a basic rate, it must be ERP as well, so add 5.5M
  411. * - if 5.5M is basic, 1M and 2M are mandatory
  412. * - if 2M is basic, 1M is mandatory
  413. * - if 1M is basic, that's the only valid ACK rate.
  414. * As a consequence, it's not as complicated as it sounds, just add
  415. * any lower rates to the ACK rate bitmap.
  416. */
  417. if (IWL_RATE_11M_INDEX < lowest_present_cck)
  418. cck |= IWL_RATE_BIT_MSK(11) >> IWL_FIRST_CCK_RATE;
  419. if (IWL_RATE_5M_INDEX < lowest_present_cck)
  420. cck |= IWL_RATE_BIT_MSK(5) >> IWL_FIRST_CCK_RATE;
  421. if (IWL_RATE_2M_INDEX < lowest_present_cck)
  422. cck |= IWL_RATE_BIT_MSK(2) >> IWL_FIRST_CCK_RATE;
  423. /* 1M already there or needed so always add */
  424. cck |= IWL_RATE_BIT_MSK(1) >> IWL_FIRST_CCK_RATE;
  425. *cck_rates = cck;
  426. *ofdm_rates = ofdm;
  427. }
  428. static void iwl_mvm_mac_ctxt_cmd_common(struct iwl_mvm *mvm,
  429. struct ieee80211_vif *vif,
  430. struct iwl_mac_ctx_cmd *cmd,
  431. u32 action)
  432. {
  433. struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
  434. struct ieee80211_chanctx_conf *chanctx;
  435. u8 cck_ack_rates, ofdm_ack_rates;
  436. int i;
  437. cmd->id_and_color = cpu_to_le32(FW_CMD_ID_AND_COLOR(mvmvif->id,
  438. mvmvif->color));
  439. cmd->action = cpu_to_le32(action);
  440. switch (vif->type) {
  441. case NL80211_IFTYPE_STATION:
  442. if (vif->p2p)
  443. cmd->mac_type = cpu_to_le32(FW_MAC_TYPE_P2P_STA);
  444. else
  445. cmd->mac_type = cpu_to_le32(FW_MAC_TYPE_BSS_STA);
  446. break;
  447. case NL80211_IFTYPE_AP:
  448. cmd->mac_type = cpu_to_le32(FW_MAC_TYPE_GO);
  449. break;
  450. case NL80211_IFTYPE_MONITOR:
  451. cmd->mac_type = cpu_to_le32(FW_MAC_TYPE_LISTENER);
  452. break;
  453. case NL80211_IFTYPE_P2P_DEVICE:
  454. cmd->mac_type = cpu_to_le32(FW_MAC_TYPE_P2P_DEVICE);
  455. break;
  456. case NL80211_IFTYPE_ADHOC:
  457. cmd->mac_type = cpu_to_le32(FW_MAC_TYPE_IBSS);
  458. break;
  459. default:
  460. WARN_ON_ONCE(1);
  461. }
  462. cmd->tsf_id = cpu_to_le32(mvmvif->tsf_id);
  463. memcpy(cmd->node_addr, vif->addr, ETH_ALEN);
  464. if (vif->bss_conf.bssid)
  465. memcpy(cmd->bssid_addr, vif->bss_conf.bssid, ETH_ALEN);
  466. else
  467. eth_broadcast_addr(cmd->bssid_addr);
  468. rcu_read_lock();
  469. chanctx = rcu_dereference(vif->chanctx_conf);
  470. iwl_mvm_ack_rates(mvm, vif, chanctx ? chanctx->def.chan->band
  471. : IEEE80211_BAND_2GHZ,
  472. &cck_ack_rates, &ofdm_ack_rates);
  473. rcu_read_unlock();
  474. cmd->cck_rates = cpu_to_le32((u32)cck_ack_rates);
  475. cmd->ofdm_rates = cpu_to_le32((u32)ofdm_ack_rates);
  476. cmd->cck_short_preamble =
  477. cpu_to_le32(vif->bss_conf.use_short_preamble ?
  478. MAC_FLG_SHORT_PREAMBLE : 0);
  479. cmd->short_slot =
  480. cpu_to_le32(vif->bss_conf.use_short_slot ?
  481. MAC_FLG_SHORT_SLOT : 0);
  482. for (i = 0; i < AC_NUM; i++) {
  483. cmd->ac[i].cw_min = cpu_to_le16(mvmvif->queue_params[i].cw_min);
  484. cmd->ac[i].cw_max = cpu_to_le16(mvmvif->queue_params[i].cw_max);
  485. cmd->ac[i].aifsn = mvmvif->queue_params[i].aifs;
  486. cmd->ac[i].edca_txop =
  487. cpu_to_le16(mvmvif->queue_params[i].txop * 32);
  488. cmd->ac[i].fifos_mask = BIT(iwl_mvm_ac_to_tx_fifo[i]);
  489. }
  490. /* in AP mode, the MCAST FIFO takes the EDCA params from VO */
  491. if (vif->type == NL80211_IFTYPE_AP)
  492. cmd->ac[AC_VO].fifos_mask |= BIT(IWL_MVM_TX_FIFO_MCAST);
  493. if (vif->bss_conf.qos)
  494. cmd->qos_flags |= cpu_to_le32(MAC_QOS_FLG_UPDATE_EDCA);
  495. /* Don't use cts to self as the fw doesn't support it currently. */
  496. if (vif->bss_conf.use_cts_prot)
  497. cmd->protection_flags |= cpu_to_le32(MAC_PROT_FLG_TGG_PROTECT);
  498. /*
  499. * I think that we should enable these 2 flags regardless the HT PROT
  500. * fields in the HT IE, but I am not sure. Someone knows whom to ask?...
  501. */
  502. if (vif->bss_conf.chandef.width != NL80211_CHAN_WIDTH_20_NOHT) {
  503. cmd->qos_flags |= cpu_to_le32(MAC_QOS_FLG_TGN);
  504. cmd->protection_flags |= cpu_to_le32(MAC_PROT_FLG_HT_PROT |
  505. MAC_PROT_FLG_FAT_PROT);
  506. }
  507. cmd->filter_flags = cpu_to_le32(MAC_FILTER_ACCEPT_GRP);
  508. }
  509. static int iwl_mvm_mac_ctxt_send_cmd(struct iwl_mvm *mvm,
  510. struct iwl_mac_ctx_cmd *cmd)
  511. {
  512. int ret = iwl_mvm_send_cmd_pdu(mvm, MAC_CONTEXT_CMD, CMD_SYNC,
  513. sizeof(*cmd), cmd);
  514. if (ret)
  515. IWL_ERR(mvm, "Failed to send MAC context (action:%d): %d\n",
  516. le32_to_cpu(cmd->action), ret);
  517. return ret;
  518. }
  519. /*
  520. * Fill the specific data for mac context of type station or p2p client
  521. */
  522. static void iwl_mvm_mac_ctxt_cmd_fill_sta(struct iwl_mvm *mvm,
  523. struct ieee80211_vif *vif,
  524. struct iwl_mac_data_sta *ctxt_sta,
  525. bool force_assoc_off)
  526. {
  527. /* We need the dtim_period to set the MAC as associated */
  528. if (vif->bss_conf.assoc && vif->bss_conf.dtim_period &&
  529. !force_assoc_off) {
  530. u32 dtim_offs;
  531. /*
  532. * The DTIM count counts down, so when it is N that means N
  533. * more beacon intervals happen until the DTIM TBTT. Therefore
  534. * add this to the current time. If that ends up being in the
  535. * future, the firmware will handle it.
  536. *
  537. * Also note that the system_timestamp (which we get here as
  538. * "sync_device_ts") and TSF timestamp aren't at exactly the
  539. * same offset in the frame -- the TSF is at the first symbol
  540. * of the TSF, the system timestamp is at signal acquisition
  541. * time. This means there's an offset between them of at most
  542. * a few hundred microseconds (24 * 8 bits + PLCP time gives
  543. * 384us in the longest case), this is currently not relevant
  544. * as the firmware wakes up around 2ms before the TBTT.
  545. */
  546. dtim_offs = vif->bss_conf.sync_dtim_count *
  547. vif->bss_conf.beacon_int;
  548. /* convert TU to usecs */
  549. dtim_offs *= 1024;
  550. ctxt_sta->dtim_tsf =
  551. cpu_to_le64(vif->bss_conf.sync_tsf + dtim_offs);
  552. ctxt_sta->dtim_time =
  553. cpu_to_le32(vif->bss_conf.sync_device_ts + dtim_offs);
  554. IWL_DEBUG_INFO(mvm, "DTIM TBTT is 0x%llx/0x%x, offset %d\n",
  555. le64_to_cpu(ctxt_sta->dtim_tsf),
  556. le32_to_cpu(ctxt_sta->dtim_time),
  557. dtim_offs);
  558. ctxt_sta->is_assoc = cpu_to_le32(1);
  559. } else {
  560. ctxt_sta->is_assoc = cpu_to_le32(0);
  561. }
  562. ctxt_sta->bi = cpu_to_le32(vif->bss_conf.beacon_int);
  563. ctxt_sta->bi_reciprocal =
  564. cpu_to_le32(iwl_mvm_reciprocal(vif->bss_conf.beacon_int));
  565. ctxt_sta->dtim_interval = cpu_to_le32(vif->bss_conf.beacon_int *
  566. vif->bss_conf.dtim_period);
  567. ctxt_sta->dtim_reciprocal =
  568. cpu_to_le32(iwl_mvm_reciprocal(vif->bss_conf.beacon_int *
  569. vif->bss_conf.dtim_period));
  570. ctxt_sta->listen_interval = cpu_to_le32(mvm->hw->conf.listen_interval);
  571. ctxt_sta->assoc_id = cpu_to_le32(vif->bss_conf.aid);
  572. }
  573. static int iwl_mvm_mac_ctxt_cmd_station(struct iwl_mvm *mvm,
  574. struct ieee80211_vif *vif,
  575. u32 action)
  576. {
  577. struct iwl_mac_ctx_cmd cmd = {};
  578. WARN_ON(vif->type != NL80211_IFTYPE_STATION || vif->p2p);
  579. /* Fill the common data for all mac context types */
  580. iwl_mvm_mac_ctxt_cmd_common(mvm, vif, &cmd, action);
  581. /* Allow beacons to pass through as long as we are not associated,or we
  582. * do not have dtim period information */
  583. if (!vif->bss_conf.assoc || !vif->bss_conf.dtim_period)
  584. cmd.filter_flags |= cpu_to_le32(MAC_FILTER_IN_BEACON);
  585. else
  586. cmd.filter_flags &= ~cpu_to_le32(MAC_FILTER_IN_BEACON);
  587. /* Fill the data specific for station mode */
  588. iwl_mvm_mac_ctxt_cmd_fill_sta(mvm, vif, &cmd.sta,
  589. action == FW_CTXT_ACTION_ADD);
  590. return iwl_mvm_mac_ctxt_send_cmd(mvm, &cmd);
  591. }
  592. static int iwl_mvm_mac_ctxt_cmd_p2p_client(struct iwl_mvm *mvm,
  593. struct ieee80211_vif *vif,
  594. u32 action)
  595. {
  596. struct iwl_mac_ctx_cmd cmd = {};
  597. struct ieee80211_p2p_noa_attr *noa = &vif->bss_conf.p2p_noa_attr;
  598. WARN_ON(vif->type != NL80211_IFTYPE_STATION || !vif->p2p);
  599. /* Fill the common data for all mac context types */
  600. iwl_mvm_mac_ctxt_cmd_common(mvm, vif, &cmd, action);
  601. /* Fill the data specific for station mode */
  602. iwl_mvm_mac_ctxt_cmd_fill_sta(mvm, vif, &cmd.p2p_sta.sta,
  603. action == FW_CTXT_ACTION_ADD);
  604. cmd.p2p_sta.ctwin = cpu_to_le32(noa->oppps_ctwindow &
  605. IEEE80211_P2P_OPPPS_CTWINDOW_MASK);
  606. return iwl_mvm_mac_ctxt_send_cmd(mvm, &cmd);
  607. }
  608. static int iwl_mvm_mac_ctxt_cmd_listener(struct iwl_mvm *mvm,
  609. struct ieee80211_vif *vif,
  610. u32 action)
  611. {
  612. struct iwl_mac_ctx_cmd cmd = {};
  613. WARN_ON(vif->type != NL80211_IFTYPE_MONITOR);
  614. iwl_mvm_mac_ctxt_cmd_common(mvm, vif, &cmd, action);
  615. cmd.filter_flags = cpu_to_le32(MAC_FILTER_IN_PROMISC |
  616. MAC_FILTER_IN_CONTROL_AND_MGMT |
  617. MAC_FILTER_IN_BEACON |
  618. MAC_FILTER_IN_PROBE_REQUEST);
  619. return iwl_mvm_mac_ctxt_send_cmd(mvm, &cmd);
  620. }
  621. struct iwl_mvm_go_iterator_data {
  622. bool go_active;
  623. };
  624. static void iwl_mvm_go_iterator(void *_data, u8 *mac, struct ieee80211_vif *vif)
  625. {
  626. struct iwl_mvm_go_iterator_data *data = _data;
  627. struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
  628. if (vif->type == NL80211_IFTYPE_AP && vif->p2p && mvmvif->ap_active)
  629. data->go_active = true;
  630. }
  631. static int iwl_mvm_mac_ctxt_cmd_p2p_device(struct iwl_mvm *mvm,
  632. struct ieee80211_vif *vif,
  633. u32 action)
  634. {
  635. struct iwl_mac_ctx_cmd cmd = {};
  636. struct iwl_mvm_go_iterator_data data = {};
  637. WARN_ON(vif->type != NL80211_IFTYPE_P2P_DEVICE);
  638. iwl_mvm_mac_ctxt_cmd_common(mvm, vif, &cmd, action);
  639. cmd.protection_flags |= cpu_to_le32(MAC_PROT_FLG_TGG_PROTECT);
  640. /* Override the filter flags to accept only probe requests */
  641. cmd.filter_flags = cpu_to_le32(MAC_FILTER_IN_PROBE_REQUEST);
  642. /*
  643. * This flag should be set to true when the P2P Device is
  644. * discoverable and there is at least another active P2P GO. Settings
  645. * this flag will allow the P2P Device to be discoverable on other
  646. * channels in addition to its listen channel.
  647. * Note that this flag should not be set in other cases as it opens the
  648. * Rx filters on all MAC and increases the number of interrupts.
  649. */
  650. ieee80211_iterate_active_interfaces_atomic(
  651. mvm->hw, IEEE80211_IFACE_ITER_RESUME_ALL,
  652. iwl_mvm_go_iterator, &data);
  653. cmd.p2p_dev.is_disc_extended = cpu_to_le32(data.go_active ? 1 : 0);
  654. return iwl_mvm_mac_ctxt_send_cmd(mvm, &cmd);
  655. }
  656. static void iwl_mvm_mac_ctxt_set_tim(struct iwl_mvm *mvm,
  657. struct iwl_mac_beacon_cmd *beacon_cmd,
  658. u8 *beacon, u32 frame_size)
  659. {
  660. u32 tim_idx;
  661. struct ieee80211_mgmt *mgmt = (struct ieee80211_mgmt *)beacon;
  662. /* The index is relative to frame start but we start looking at the
  663. * variable-length part of the beacon. */
  664. tim_idx = mgmt->u.beacon.variable - beacon;
  665. /* Parse variable-length elements of beacon to find WLAN_EID_TIM */
  666. while ((tim_idx < (frame_size - 2)) &&
  667. (beacon[tim_idx] != WLAN_EID_TIM))
  668. tim_idx += beacon[tim_idx+1] + 2;
  669. /* If TIM field was found, set variables */
  670. if ((tim_idx < (frame_size - 1)) && (beacon[tim_idx] == WLAN_EID_TIM)) {
  671. beacon_cmd->tim_idx = cpu_to_le32(tim_idx);
  672. beacon_cmd->tim_size = cpu_to_le32((u32)beacon[tim_idx+1]);
  673. } else {
  674. IWL_WARN(mvm, "Unable to find TIM Element in beacon\n");
  675. }
  676. }
  677. static int iwl_mvm_mac_ctxt_send_beacon(struct iwl_mvm *mvm,
  678. struct ieee80211_vif *vif,
  679. struct sk_buff *beacon)
  680. {
  681. struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
  682. struct iwl_host_cmd cmd = {
  683. .id = BEACON_TEMPLATE_CMD,
  684. .flags = CMD_ASYNC,
  685. };
  686. struct iwl_mac_beacon_cmd beacon_cmd = {};
  687. struct ieee80211_tx_info *info;
  688. u32 beacon_skb_len;
  689. u32 rate;
  690. if (WARN_ON(!beacon))
  691. return -EINVAL;
  692. beacon_skb_len = beacon->len;
  693. /* TODO: for now the beacon template id is set to be the mac context id.
  694. * Might be better to handle it as another resource ... */
  695. beacon_cmd.template_id = cpu_to_le32((u32)mvmvif->id);
  696. /* Set up TX command fields */
  697. beacon_cmd.tx.len = cpu_to_le16((u16)beacon_skb_len);
  698. beacon_cmd.tx.sta_id = mvmvif->bcast_sta.sta_id;
  699. beacon_cmd.tx.life_time = cpu_to_le32(TX_CMD_LIFE_TIME_INFINITE);
  700. beacon_cmd.tx.tx_flags = cpu_to_le32(TX_CMD_FLG_SEQ_CTL |
  701. TX_CMD_FLG_BT_DIS |
  702. TX_CMD_FLG_TSF);
  703. mvm->mgmt_last_antenna_idx =
  704. iwl_mvm_next_antenna(mvm, iwl_fw_valid_tx_ant(mvm->fw),
  705. mvm->mgmt_last_antenna_idx);
  706. beacon_cmd.tx.rate_n_flags =
  707. cpu_to_le32(BIT(mvm->mgmt_last_antenna_idx) <<
  708. RATE_MCS_ANT_POS);
  709. info = IEEE80211_SKB_CB(beacon);
  710. if (info->band == IEEE80211_BAND_5GHZ || vif->p2p) {
  711. rate = IWL_FIRST_OFDM_RATE;
  712. } else {
  713. rate = IWL_FIRST_CCK_RATE;
  714. beacon_cmd.tx.rate_n_flags |= cpu_to_le32(RATE_MCS_CCK_MSK);
  715. }
  716. beacon_cmd.tx.rate_n_flags |=
  717. cpu_to_le32(iwl_mvm_mac80211_idx_to_hwrate(rate));
  718. /* Set up TX beacon command fields */
  719. iwl_mvm_mac_ctxt_set_tim(mvm, &beacon_cmd,
  720. beacon->data,
  721. beacon_skb_len);
  722. /* Submit command */
  723. cmd.len[0] = sizeof(beacon_cmd);
  724. cmd.data[0] = &beacon_cmd;
  725. cmd.dataflags[0] = 0;
  726. cmd.len[1] = beacon_skb_len;
  727. cmd.data[1] = beacon->data;
  728. cmd.dataflags[1] = IWL_HCMD_DFL_DUP;
  729. return iwl_mvm_send_cmd(mvm, &cmd);
  730. }
  731. /* The beacon template for the AP/GO context has changed and needs update */
  732. int iwl_mvm_mac_ctxt_beacon_changed(struct iwl_mvm *mvm,
  733. struct ieee80211_vif *vif)
  734. {
  735. struct sk_buff *beacon;
  736. int ret;
  737. WARN_ON(vif->type != NL80211_IFTYPE_AP);
  738. beacon = ieee80211_beacon_get(mvm->hw, vif);
  739. if (!beacon)
  740. return -ENOMEM;
  741. ret = iwl_mvm_mac_ctxt_send_beacon(mvm, vif, beacon);
  742. dev_kfree_skb(beacon);
  743. return ret;
  744. }
  745. struct iwl_mvm_mac_ap_iterator_data {
  746. struct iwl_mvm *mvm;
  747. struct ieee80211_vif *vif;
  748. u32 beacon_device_ts;
  749. u16 beacon_int;
  750. };
  751. /* Find the beacon_device_ts and beacon_int for a managed interface */
  752. static void iwl_mvm_mac_ap_iterator(void *_data, u8 *mac,
  753. struct ieee80211_vif *vif)
  754. {
  755. struct iwl_mvm_mac_ap_iterator_data *data = _data;
  756. if (vif->type != NL80211_IFTYPE_STATION || !vif->bss_conf.assoc)
  757. return;
  758. /* Station client has higher priority over P2P client*/
  759. if (vif->p2p && data->beacon_device_ts)
  760. return;
  761. data->beacon_device_ts = vif->bss_conf.sync_device_ts;
  762. data->beacon_int = vif->bss_conf.beacon_int;
  763. }
  764. /*
  765. * Fill the specific data for mac context of type AP of P2P GO
  766. */
  767. static void iwl_mvm_mac_ctxt_cmd_fill_ap(struct iwl_mvm *mvm,
  768. struct ieee80211_vif *vif,
  769. struct iwl_mac_data_ap *ctxt_ap,
  770. bool add)
  771. {
  772. struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
  773. struct iwl_mvm_mac_ap_iterator_data data = {
  774. .mvm = mvm,
  775. .vif = vif,
  776. .beacon_device_ts = 0
  777. };
  778. ctxt_ap->bi = cpu_to_le32(vif->bss_conf.beacon_int);
  779. ctxt_ap->bi_reciprocal =
  780. cpu_to_le32(iwl_mvm_reciprocal(vif->bss_conf.beacon_int));
  781. ctxt_ap->dtim_interval = cpu_to_le32(vif->bss_conf.beacon_int *
  782. vif->bss_conf.dtim_period);
  783. ctxt_ap->dtim_reciprocal =
  784. cpu_to_le32(iwl_mvm_reciprocal(vif->bss_conf.beacon_int *
  785. vif->bss_conf.dtim_period));
  786. ctxt_ap->mcast_qid = cpu_to_le32(vif->cab_queue);
  787. /*
  788. * Only set the beacon time when the MAC is being added, when we
  789. * just modify the MAC then we should keep the time -- the firmware
  790. * can otherwise have a "jumping" TBTT.
  791. */
  792. if (add) {
  793. /*
  794. * If there is a station/P2P client interface which is
  795. * associated, set the AP's TBTT far enough from the station's
  796. * TBTT. Otherwise, set it to the current system time
  797. */
  798. ieee80211_iterate_active_interfaces_atomic(
  799. mvm->hw, IEEE80211_IFACE_ITER_RESUME_ALL,
  800. iwl_mvm_mac_ap_iterator, &data);
  801. if (data.beacon_device_ts) {
  802. u32 rand = (prandom_u32() % (80 - 20)) + 20;
  803. mvmvif->ap_beacon_time = data.beacon_device_ts +
  804. ieee80211_tu_to_usec(data.beacon_int * rand /
  805. 100);
  806. } else {
  807. mvmvif->ap_beacon_time =
  808. iwl_read_prph(mvm->trans,
  809. DEVICE_SYSTEM_TIME_REG);
  810. }
  811. }
  812. ctxt_ap->beacon_time = cpu_to_le32(mvmvif->ap_beacon_time);
  813. ctxt_ap->beacon_tsf = 0; /* unused */
  814. /* TODO: Assume that the beacon id == mac context id */
  815. ctxt_ap->beacon_template = cpu_to_le32(mvmvif->id);
  816. }
  817. static int iwl_mvm_mac_ctxt_cmd_ap(struct iwl_mvm *mvm,
  818. struct ieee80211_vif *vif,
  819. u32 action)
  820. {
  821. struct iwl_mac_ctx_cmd cmd = {};
  822. WARN_ON(vif->type != NL80211_IFTYPE_AP || vif->p2p);
  823. /* Fill the common data for all mac context types */
  824. iwl_mvm_mac_ctxt_cmd_common(mvm, vif, &cmd, action);
  825. /* Also enable probe requests to pass */
  826. cmd.filter_flags |= cpu_to_le32(MAC_FILTER_IN_PROBE_REQUEST);
  827. /* Fill the data specific for ap mode */
  828. iwl_mvm_mac_ctxt_cmd_fill_ap(mvm, vif, &cmd.ap,
  829. action == FW_CTXT_ACTION_ADD);
  830. return iwl_mvm_mac_ctxt_send_cmd(mvm, &cmd);
  831. }
  832. static int iwl_mvm_mac_ctxt_cmd_go(struct iwl_mvm *mvm,
  833. struct ieee80211_vif *vif,
  834. u32 action)
  835. {
  836. struct iwl_mac_ctx_cmd cmd = {};
  837. struct ieee80211_p2p_noa_attr *noa = &vif->bss_conf.p2p_noa_attr;
  838. WARN_ON(vif->type != NL80211_IFTYPE_AP || !vif->p2p);
  839. /* Fill the common data for all mac context types */
  840. iwl_mvm_mac_ctxt_cmd_common(mvm, vif, &cmd, action);
  841. /* Fill the data specific for GO mode */
  842. iwl_mvm_mac_ctxt_cmd_fill_ap(mvm, vif, &cmd.go.ap,
  843. action == FW_CTXT_ACTION_ADD);
  844. cmd.go.ctwin = cpu_to_le32(noa->oppps_ctwindow &
  845. IEEE80211_P2P_OPPPS_CTWINDOW_MASK);
  846. cmd.go.opp_ps_enabled =
  847. cpu_to_le32(!!(noa->oppps_ctwindow &
  848. IEEE80211_P2P_OPPPS_ENABLE_BIT));
  849. return iwl_mvm_mac_ctxt_send_cmd(mvm, &cmd);
  850. }
  851. static int iwl_mvm_mac_ctx_send(struct iwl_mvm *mvm, struct ieee80211_vif *vif,
  852. u32 action)
  853. {
  854. switch (vif->type) {
  855. case NL80211_IFTYPE_STATION:
  856. if (!vif->p2p)
  857. return iwl_mvm_mac_ctxt_cmd_station(mvm, vif,
  858. action);
  859. else
  860. return iwl_mvm_mac_ctxt_cmd_p2p_client(mvm, vif,
  861. action);
  862. break;
  863. case NL80211_IFTYPE_AP:
  864. if (!vif->p2p)
  865. return iwl_mvm_mac_ctxt_cmd_ap(mvm, vif, action);
  866. else
  867. return iwl_mvm_mac_ctxt_cmd_go(mvm, vif, action);
  868. break;
  869. case NL80211_IFTYPE_MONITOR:
  870. return iwl_mvm_mac_ctxt_cmd_listener(mvm, vif, action);
  871. case NL80211_IFTYPE_P2P_DEVICE:
  872. return iwl_mvm_mac_ctxt_cmd_p2p_device(mvm, vif, action);
  873. default:
  874. break;
  875. }
  876. return -EOPNOTSUPP;
  877. }
  878. int iwl_mvm_mac_ctxt_add(struct iwl_mvm *mvm, struct ieee80211_vif *vif)
  879. {
  880. struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
  881. int ret;
  882. if (WARN_ONCE(mvmvif->uploaded, "Adding active MAC %pM/%d\n",
  883. vif->addr, ieee80211_vif_type_p2p(vif)))
  884. return -EIO;
  885. ret = iwl_mvm_mac_ctx_send(mvm, vif, FW_CTXT_ACTION_ADD);
  886. if (ret)
  887. return ret;
  888. mvmvif->uploaded = true;
  889. return 0;
  890. }
  891. int iwl_mvm_mac_ctxt_changed(struct iwl_mvm *mvm, struct ieee80211_vif *vif)
  892. {
  893. struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
  894. if (WARN_ONCE(!mvmvif->uploaded, "Changing inactive MAC %pM/%d\n",
  895. vif->addr, ieee80211_vif_type_p2p(vif)))
  896. return -EIO;
  897. return iwl_mvm_mac_ctx_send(mvm, vif, FW_CTXT_ACTION_MODIFY);
  898. }
  899. int iwl_mvm_mac_ctxt_remove(struct iwl_mvm *mvm, struct ieee80211_vif *vif)
  900. {
  901. struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
  902. struct iwl_mac_ctx_cmd cmd;
  903. int ret;
  904. if (WARN_ONCE(!mvmvif->uploaded, "Removing inactive MAC %pM/%d\n",
  905. vif->addr, ieee80211_vif_type_p2p(vif)))
  906. return -EIO;
  907. memset(&cmd, 0, sizeof(cmd));
  908. cmd.id_and_color = cpu_to_le32(FW_CMD_ID_AND_COLOR(mvmvif->id,
  909. mvmvif->color));
  910. cmd.action = cpu_to_le32(FW_CTXT_ACTION_REMOVE);
  911. ret = iwl_mvm_send_cmd_pdu(mvm, MAC_CONTEXT_CMD, CMD_SYNC,
  912. sizeof(cmd), &cmd);
  913. if (ret) {
  914. IWL_ERR(mvm, "Failed to remove MAC context: %d\n", ret);
  915. return ret;
  916. }
  917. mvmvif->uploaded = false;
  918. return 0;
  919. }
  920. int iwl_mvm_rx_beacon_notif(struct iwl_mvm *mvm,
  921. struct iwl_rx_cmd_buffer *rxb,
  922. struct iwl_device_cmd *cmd)
  923. {
  924. struct iwl_rx_packet *pkt = rxb_addr(rxb);
  925. struct iwl_beacon_notif *beacon = (void *)pkt->data;
  926. u16 status __maybe_unused =
  927. le16_to_cpu(beacon->beacon_notify_hdr.status.status);
  928. u32 rate __maybe_unused =
  929. le32_to_cpu(beacon->beacon_notify_hdr.initial_rate);
  930. IWL_DEBUG_RX(mvm, "beacon status %#x retries:%d tsf:0x%16llX rate:%d\n",
  931. status & TX_STATUS_MSK,
  932. beacon->beacon_notify_hdr.failure_frame,
  933. le64_to_cpu(beacon->tsf),
  934. rate);
  935. return 0;
  936. }
  937. static void iwl_mvm_beacon_loss_iterator(void *_data, u8 *mac,
  938. struct ieee80211_vif *vif)
  939. {
  940. u16 *id = _data;
  941. struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
  942. if (mvmvif->id == *id)
  943. ieee80211_beacon_loss(vif);
  944. }
  945. int iwl_mvm_rx_missed_beacons_notif(struct iwl_mvm *mvm,
  946. struct iwl_rx_cmd_buffer *rxb,
  947. struct iwl_device_cmd *cmd)
  948. {
  949. struct iwl_rx_packet *pkt = rxb_addr(rxb);
  950. struct iwl_missed_beacons_notif *missed_beacons = (void *)pkt->data;
  951. u16 id = (u16)le32_to_cpu(missed_beacons->mac_id);
  952. ieee80211_iterate_active_interfaces_atomic(mvm->hw,
  953. IEEE80211_IFACE_ITER_NORMAL,
  954. iwl_mvm_beacon_loss_iterator,
  955. &id);
  956. return 0;
  957. }