wmi_unified_vdev_tlv.c 18 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604
  1. /*
  2. * Copyright (c) 2016-2020 The Linux Foundation. All rights reserved.
  3. * Copyright (c) 2022-2023 Qualcomm Innovation Center, Inc. All rights reserved.
  4. *
  5. * Permission to use, copy, modify, and/or distribute this software for
  6. * any purpose with or without fee is hereby granted, provided that the
  7. * above copyright notice and this permission notice appear in all
  8. * copies.
  9. *
  10. * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
  11. * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
  12. * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
  13. * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
  14. * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
  15. * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  16. * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  17. * PERFORMANCE OF THIS SOFTWARE.
  18. */
  19. #include <osdep.h>
  20. #include <qdf_module.h>
  21. #include <qdf_list.h>
  22. #include <qdf_platform.h>
  23. #include <wmi_unified_vdev_tlv.h>
  24. #include <wlan_vdev_mgr_tgt_if_tx_defs.h>
  25. static QDF_STATUS
  26. send_vdev_config_ratemask_cmd_tlv(struct wmi_unified *wmi_handle,
  27. struct config_ratemask_params *param)
  28. {
  29. wmi_vdev_config_ratemask_cmd_fixed_param *cmd;
  30. wmi_buf_t buf;
  31. int32_t len = sizeof(*cmd);
  32. buf = wmi_buf_alloc(wmi_handle, len);
  33. if (!buf) {
  34. wmi_err("wmi_buf_alloc failed");
  35. return QDF_STATUS_E_FAILURE;
  36. }
  37. cmd = (wmi_vdev_config_ratemask_cmd_fixed_param *)wmi_buf_data(buf);
  38. WMITLV_SET_HDR(&cmd->tlv_header,
  39. WMITLV_TAG_STRUC_wmi_vdev_config_ratemask_fixed_param,
  40. WMITLV_GET_STRUCT_TLVLEN(
  41. wmi_vdev_config_ratemask_cmd_fixed_param));
  42. cmd->vdev_id = param->vdev_id;
  43. cmd->type = param->type;
  44. cmd->mask_lower32 = param->lower32;
  45. cmd->mask_higher32 = param->higher32;
  46. cmd->mask_lower32_2 = param->lower32_2;
  47. cmd->mask_higher32_2 = param->higher32_2;
  48. wmi_debug("vdev_id %d type %d lower32 0x%x lower32_2 0x%x",
  49. cmd->vdev_id, cmd->type, cmd->mask_lower32,
  50. cmd->mask_lower32_2);
  51. wmi_debug("higher32 0x%x higher32_2 0x%x", cmd->mask_higher32,
  52. cmd->mask_higher32_2);
  53. wmi_mtrace(WMI_VDEV_RATEMASK_CMDID, cmd->vdev_id, 0);
  54. if (wmi_unified_cmd_send(wmi_handle, buf, len,
  55. WMI_VDEV_RATEMASK_CMDID)) {
  56. wmi_err("Setting vdev ratemask failed");
  57. wmi_buf_free(buf);
  58. return QDF_STATUS_E_FAILURE;
  59. }
  60. return QDF_STATUS_SUCCESS;
  61. }
  62. static QDF_STATUS
  63. send_beacon_send_cmd_tlv(struct wmi_unified *wmi_handle,
  64. struct beacon_params *param)
  65. {
  66. QDF_STATUS ret;
  67. wmi_bcn_send_from_host_cmd_fixed_param *cmd;
  68. wmi_buf_t wmi_buf;
  69. qdf_dma_addr_t dma_addr;
  70. uint32_t dtim_flag = 0;
  71. wmi_buf = wmi_buf_alloc(wmi_handle, sizeof(*cmd));
  72. if (!wmi_buf) {
  73. wmi_err("wmi_buf_alloc failed");
  74. return QDF_STATUS_E_NOMEM;
  75. }
  76. if (param->is_dtim_count_zero) {
  77. dtim_flag |= WMI_BCN_SEND_DTIM_ZERO;
  78. if (param->is_bitctl_reqd) {
  79. /* deliver CAB traffic in next DTIM beacon */
  80. dtim_flag |= WMI_BCN_SEND_DTIM_BITCTL_SET;
  81. }
  82. }
  83. cmd = (wmi_bcn_send_from_host_cmd_fixed_param *)wmi_buf_data(wmi_buf);
  84. WMITLV_SET_HDR(
  85. &cmd->tlv_header,
  86. WMITLV_TAG_STRUC_wmi_bcn_send_from_host_cmd_fixed_param,
  87. WMITLV_GET_STRUCT_TLVLEN
  88. (wmi_bcn_send_from_host_cmd_fixed_param));
  89. cmd->vdev_id = param->vdev_id;
  90. cmd->data_len = qdf_nbuf_len(param->wbuf);
  91. cmd->frame_ctrl = param->frame_ctrl;
  92. cmd->dtim_flag = dtim_flag;
  93. dma_addr = qdf_nbuf_get_frag_paddr(param->wbuf, 0);
  94. cmd->frag_ptr_lo = qdf_get_lower_32_bits(dma_addr);
  95. #if defined(HTT_PADDR64)
  96. cmd->frag_ptr_hi = qdf_get_upper_32_bits(dma_addr) & 0x1F;
  97. #endif
  98. cmd->bcn_antenna = param->bcn_txant;
  99. wmi_mtrace(WMI_PDEV_SEND_BCN_CMDID, cmd->vdev_id, 0);
  100. ret = wmi_unified_cmd_send(wmi_handle, wmi_buf, sizeof(*cmd),
  101. WMI_PDEV_SEND_BCN_CMDID);
  102. if (ret != QDF_STATUS_SUCCESS) {
  103. wmi_err("Failed to send bcn: %d", ret);
  104. wmi_buf_free(wmi_buf);
  105. }
  106. return ret;
  107. }
  108. static QDF_STATUS
  109. extract_tbttoffset_num_vdevs_tlv(struct wmi_unified *wmi_handle, void *evt_buf,
  110. uint32_t *num_vdevs)
  111. {
  112. WMI_TBTTOFFSET_UPDATE_EVENTID_param_tlvs *param_buf;
  113. wmi_tbtt_offset_event_fixed_param *tbtt_offset_event;
  114. uint32_t vdev_map;
  115. param_buf = (WMI_TBTTOFFSET_UPDATE_EVENTID_param_tlvs *)evt_buf;
  116. if (!param_buf) {
  117. wmi_err("Invalid tbtt update ext event buffer");
  118. return QDF_STATUS_E_INVAL;
  119. }
  120. tbtt_offset_event = param_buf->fixed_param;
  121. vdev_map = tbtt_offset_event->vdev_map;
  122. *num_vdevs = wmi_vdev_map_to_num_vdevs(vdev_map);
  123. return QDF_STATUS_SUCCESS;
  124. }
  125. static QDF_STATUS
  126. send_peer_filter_set_tx_cmd_tlv(struct wmi_unified *wmi_handle,
  127. uint8_t macaddr[],
  128. struct set_tx_peer_filter *param)
  129. {
  130. wmi_peer_tx_filter_cmd_fixed_param *cmd;
  131. wmi_buf_t buf;
  132. uint32_t len = sizeof(*cmd);
  133. buf = wmi_buf_alloc(wmi_handle, len);
  134. if (!buf)
  135. return QDF_STATUS_E_FAILURE;
  136. cmd = (wmi_peer_tx_filter_cmd_fixed_param *)wmi_buf_data(buf);
  137. WMITLV_SET_HDR(&cmd->tlv_header,
  138. WMITLV_TAG_STRUC_wmi_peer_tx_filter_cmd_fixed_param,
  139. WMITLV_GET_STRUCT_TLVLEN(
  140. wmi_peer_tx_filter_cmd_fixed_param));
  141. cmd->vdev_id = param->vdev_id;
  142. cmd->action = param->action;
  143. WMI_CHAR_ARRAY_TO_MAC_ADDR(macaddr, &cmd->addr);
  144. wmi_mtrace(WMI_PEER_TX_FILTER_CMDID, cmd->vdev_id, 0);
  145. if (wmi_unified_cmd_send(wmi_handle, buf, len,
  146. WMI_PEER_TX_FILTER_CMDID)) {
  147. wmi_err("Failed to set neighbour rx param");
  148. wmi_buf_free(buf);
  149. return QDF_STATUS_E_FAILURE;
  150. }
  151. return QDF_STATUS_SUCCESS;
  152. }
  153. static QDF_STATUS
  154. send_vdev_set_neighbour_rx_cmd_tlv(struct wmi_unified *wmi_handle,
  155. uint8_t macaddr[QDF_MAC_ADDR_SIZE],
  156. struct set_neighbour_rx_params *param)
  157. {
  158. wmi_vdev_filter_nrp_config_cmd_fixed_param *cmd;
  159. wmi_buf_t buf;
  160. int32_t len = sizeof(*cmd);
  161. buf = wmi_buf_alloc(wmi_handle, len);
  162. if (!buf) {
  163. wmi_err("wmi_buf_alloc failed");
  164. return QDF_STATUS_E_FAILURE;
  165. }
  166. cmd = (wmi_vdev_filter_nrp_config_cmd_fixed_param *)wmi_buf_data(buf);
  167. WMITLV_SET_HDR(&cmd->tlv_header,
  168. WMITLV_TAG_STRUC_wmi_vdev_filter_nrp_config_cmd_fixed_param,
  169. WMITLV_GET_STRUCT_TLVLEN(
  170. wmi_vdev_filter_nrp_config_cmd_fixed_param));
  171. cmd->vdev_id = param->vdev_id;
  172. cmd->bssid_idx = param->idx;
  173. cmd->action = param->action;
  174. cmd->type = param->type;
  175. WMI_CHAR_ARRAY_TO_MAC_ADDR(macaddr, &cmd->addr);
  176. cmd->flag = 0;
  177. wmi_mtrace(WMI_VDEV_FILTER_NEIGHBOR_RX_PACKETS_CMDID, cmd->vdev_id, 0);
  178. if (wmi_unified_cmd_send(wmi_handle, buf, len,
  179. WMI_VDEV_FILTER_NEIGHBOR_RX_PACKETS_CMDID)) {
  180. wmi_err("Failed to set neighbour rx param");
  181. wmi_buf_free(buf);
  182. return QDF_STATUS_E_FAILURE;
  183. }
  184. return QDF_STATUS_SUCCESS;
  185. }
  186. static QDF_STATUS
  187. extract_vdev_start_resp_tlv(struct wmi_unified *wmi_handle, void *evt_buf,
  188. struct vdev_start_response *vdev_rsp)
  189. {
  190. WMI_VDEV_START_RESP_EVENTID_param_tlvs *param_buf;
  191. wmi_vdev_start_response_event_fixed_param *ev;
  192. param_buf = (WMI_VDEV_START_RESP_EVENTID_param_tlvs *)evt_buf;
  193. if (!param_buf) {
  194. wmi_err("Invalid start response event buffer");
  195. return QDF_STATUS_E_INVAL;
  196. }
  197. ev = param_buf->fixed_param;
  198. if (!ev) {
  199. wmi_err("Invalid start response event buffer");
  200. return QDF_STATUS_E_INVAL;
  201. }
  202. qdf_mem_zero(vdev_rsp, sizeof(*vdev_rsp));
  203. vdev_rsp->vdev_id = ev->vdev_id;
  204. vdev_rsp->requestor_id = ev->requestor_id;
  205. switch (ev->resp_type) {
  206. case WMI_VDEV_START_RESP_EVENT:
  207. vdev_rsp->resp_type = WMI_HOST_VDEV_START_RESP_EVENT;
  208. break;
  209. case WMI_VDEV_RESTART_RESP_EVENT:
  210. vdev_rsp->resp_type = WMI_HOST_VDEV_RESTART_RESP_EVENT;
  211. break;
  212. default:
  213. wmi_err("Invalid start response event buffer");
  214. break;
  215. };
  216. vdev_rsp->status = ev->status;
  217. vdev_rsp->chain_mask = ev->chain_mask;
  218. vdev_rsp->smps_mode = ev->smps_mode;
  219. vdev_rsp->mac_id = ev->mac_id;
  220. vdev_rsp->cfgd_tx_streams = ev->cfgd_tx_streams;
  221. vdev_rsp->cfgd_rx_streams = ev->cfgd_rx_streams;
  222. vdev_rsp->max_allowed_tx_power = ev->max_allowed_tx_power;
  223. return QDF_STATUS_SUCCESS;
  224. }
  225. static QDF_STATUS
  226. extract_vdev_delete_resp_tlv(struct wmi_unified *wmi_handle, void *evt_buf,
  227. struct vdev_delete_response *delete_rsp)
  228. {
  229. WMI_VDEV_DELETE_RESP_EVENTID_param_tlvs *param_buf;
  230. wmi_vdev_delete_resp_event_fixed_param *ev;
  231. param_buf = (WMI_VDEV_DELETE_RESP_EVENTID_param_tlvs *)evt_buf;
  232. if (!param_buf) {
  233. wmi_err("Invalid vdev delete response event buffer");
  234. return QDF_STATUS_E_INVAL;
  235. }
  236. ev = param_buf->fixed_param;
  237. if (!ev) {
  238. wmi_err("Invalid vdev delete response event");
  239. return QDF_STATUS_E_INVAL;
  240. }
  241. qdf_mem_zero(delete_rsp, sizeof(*delete_rsp));
  242. delete_rsp->vdev_id = ev->vdev_id;
  243. return QDF_STATUS_SUCCESS;
  244. }
  245. static QDF_STATUS extract_vdev_peer_delete_all_response_event_tlv(
  246. wmi_unified_t wmi_hdl,
  247. void *evt_buf,
  248. struct peer_delete_all_response *param)
  249. {
  250. WMI_VDEV_DELETE_ALL_PEER_RESP_EVENTID_param_tlvs *param_buf;
  251. wmi_vdev_delete_all_peer_resp_event_fixed_param *ev;
  252. param_buf = (WMI_VDEV_DELETE_ALL_PEER_RESP_EVENTID_param_tlvs *)evt_buf;
  253. ev = (wmi_vdev_delete_all_peer_resp_event_fixed_param *)
  254. param_buf->fixed_param;
  255. if (!ev) {
  256. wmi_err("Invalid peer_delete all response");
  257. return QDF_STATUS_E_FAILURE;
  258. }
  259. param->vdev_id = ev->vdev_id;
  260. param->status = ev->status;
  261. return QDF_STATUS_SUCCESS;
  262. }
  263. static QDF_STATUS
  264. extract_vdev_stopped_param_tlv(struct wmi_unified *wmi_handle,
  265. void *evt_buf, uint32_t *vdev_id)
  266. {
  267. WMI_VDEV_STOPPED_EVENTID_param_tlvs *param_buf;
  268. wmi_vdev_stopped_event_fixed_param *resp_event;
  269. param_buf = (WMI_VDEV_STOPPED_EVENTID_param_tlvs *)evt_buf;
  270. if (!param_buf) {
  271. wmi_err("Invalid event buffer");
  272. return QDF_STATUS_E_INVAL;
  273. }
  274. resp_event = param_buf->fixed_param;
  275. *vdev_id = resp_event->vdev_id;
  276. return QDF_STATUS_SUCCESS;
  277. }
  278. static QDF_STATUS extract_ext_tbttoffset_num_vdevs_tlv(
  279. wmi_unified_t wmi_hdl,
  280. void *evt_buf,
  281. uint32_t *num_vdevs)
  282. {
  283. WMI_TBTTOFFSET_EXT_UPDATE_EVENTID_param_tlvs *param_buf;
  284. wmi_tbtt_offset_ext_event_fixed_param *tbtt_offset_ext_event;
  285. param_buf = (WMI_TBTTOFFSET_EXT_UPDATE_EVENTID_param_tlvs *)evt_buf;
  286. if (!param_buf) {
  287. wmi_err("Invalid tbtt update ext event buffer");
  288. return QDF_STATUS_E_INVAL;
  289. }
  290. tbtt_offset_ext_event = param_buf->fixed_param;
  291. *num_vdevs = tbtt_offset_ext_event->num_vdevs;
  292. return QDF_STATUS_SUCCESS;
  293. }
  294. static QDF_STATUS extract_tbttoffset_update_params_tlv(
  295. wmi_unified_t wmi_hdl,
  296. void *evt_buf, uint8_t idx,
  297. struct tbttoffset_params *tbtt_param)
  298. {
  299. WMI_TBTTOFFSET_UPDATE_EVENTID_param_tlvs *param_buf;
  300. wmi_tbtt_offset_event_fixed_param *tbtt_offset_event;
  301. uint32_t vdev_map;
  302. param_buf = (WMI_TBTTOFFSET_UPDATE_EVENTID_param_tlvs *)evt_buf;
  303. if (!param_buf) {
  304. wmi_err("Invalid tbtt update event buffer");
  305. return QDF_STATUS_E_INVAL;
  306. }
  307. tbtt_offset_event = param_buf->fixed_param;
  308. vdev_map = tbtt_offset_event->vdev_map;
  309. tbtt_param->vdev_id = wmi_vdev_map_to_vdev_id(vdev_map, idx);
  310. if (tbtt_param->vdev_id == WLAN_INVALID_VDEV_ID)
  311. return QDF_STATUS_E_INVAL;
  312. tbtt_param->tbttoffset =
  313. param_buf->tbttoffset_list[tbtt_param->vdev_id];
  314. if (param_buf->tbtt_qtime_low_us_list)
  315. tbtt_param->vdev_tbtt_qtime_lo =
  316. param_buf->tbtt_qtime_low_us_list[tbtt_param->vdev_id];
  317. if (param_buf->tbtt_qtime_high_us_list)
  318. tbtt_param->vdev_tbtt_qtime_hi =
  319. param_buf->tbtt_qtime_high_us_list[tbtt_param->vdev_id];
  320. return QDF_STATUS_SUCCESS;
  321. }
  322. static QDF_STATUS extract_ext_tbttoffset_update_params_tlv(
  323. wmi_unified_t wmi_hdl,
  324. void *evt_buf, uint8_t idx,
  325. struct tbttoffset_params *tbtt_param)
  326. {
  327. WMI_TBTTOFFSET_EXT_UPDATE_EVENTID_param_tlvs *param_buf;
  328. wmi_tbtt_offset_info *tbtt_offset_info;
  329. param_buf = (WMI_TBTTOFFSET_EXT_UPDATE_EVENTID_param_tlvs *)evt_buf;
  330. if (!param_buf) {
  331. wmi_err("Invalid tbtt update event buffer");
  332. return QDF_STATUS_E_INVAL;
  333. }
  334. tbtt_offset_info = &param_buf->tbtt_offset_info[idx];
  335. tbtt_param->vdev_id = tbtt_offset_info->vdev_id;
  336. tbtt_param->tbttoffset = tbtt_offset_info->tbttoffset;
  337. tbtt_param->vdev_tbtt_qtime_lo = tbtt_offset_info->tbtt_qtime_low_us;
  338. tbtt_param->vdev_tbtt_qtime_hi = tbtt_offset_info->tbtt_qtime_high_us;
  339. return QDF_STATUS_SUCCESS;
  340. }
  341. static QDF_STATUS extract_muedca_params_tlv(wmi_unified_t wmi_hdl,
  342. void *evt_buf,
  343. struct muedca_params *muedca_param_list)
  344. {
  345. WMI_MUEDCA_PARAMS_CONFIG_EVENTID_param_tlvs *param_buf;
  346. wmi_muedca_params_config_event_fixed_param *muedca_param;
  347. int i;
  348. param_buf = (WMI_MUEDCA_PARAMS_CONFIG_EVENTID_param_tlvs *)evt_buf;
  349. if (!param_buf) {
  350. wmi_err("Invalid muedca evt buffer");
  351. return QDF_STATUS_E_INVAL;
  352. }
  353. muedca_param = param_buf->fixed_param;
  354. muedca_param_list->pdev_id = wmi_hdl->ops->
  355. convert_target_pdev_id_to_host(wmi_hdl,
  356. muedca_param->pdev_id);
  357. for (i = 0; i < WMI_AC_MAX; i++) {
  358. muedca_param_list->muedca_aifsn[i] = muedca_param->aifsn[i] &
  359. WMI_MUEDCA_PARAM_MASK;
  360. muedca_param_list->muedca_ecwmin[i] = muedca_param->ecwmin[i] &
  361. WMI_MUEDCA_PARAM_MASK;
  362. muedca_param_list->muedca_ecwmax[i] = muedca_param->ecwmax[i] &
  363. WMI_MUEDCA_PARAM_MASK;
  364. muedca_param_list->muedca_timer[i] = muedca_param->muedca_expiration_time[i] &
  365. WMI_MUEDCA_PARAM_MASK;
  366. }
  367. return QDF_STATUS_SUCCESS;
  368. }
  369. #ifdef WLAN_FEATURE_SR
  370. static QDF_STATUS
  371. vdev_param_sr_prohibit_send_tlv(struct wmi_unified *wmi_handle,
  372. struct sr_prohibit_param *param)
  373. {
  374. wmi_vdev_param_enable_sr_prohibit_fixed_param *cmd;
  375. wmi_buf_t buf;
  376. int32_t len = sizeof(*cmd);
  377. buf = wmi_buf_alloc(wmi_handle, len);
  378. if (!buf) {
  379. wmi_err("wmi_buf_alloc failed");
  380. return QDF_STATUS_E_FAILURE;
  381. }
  382. cmd = (wmi_vdev_param_enable_sr_prohibit_fixed_param *)
  383. wmi_buf_data(buf);
  384. WMITLV_SET_HDR
  385. (&cmd->tlv_header,
  386. WMITLV_TAG_STRUC_wmi_vdev_param_enable_sr_prohibit_fixed_param,
  387. WMITLV_GET_STRUCT_TLVLEN
  388. (wmi_vdev_param_enable_sr_prohibit_fixed_param));
  389. cmd->vdev_id = param->vdev_id;
  390. cmd->tidmap = 0;
  391. cmd->prohibit_enable = param->sr_he_siga_val15_allowed;
  392. wmi_debug("SR Prohibit enabled: %d", cmd->prohibit_enable);
  393. wmi_mtrace(WMI_VDEV_PARAM_ENABLE_SR_PROHIBIT_CMDID, cmd->vdev_id, 0);
  394. if (wmi_unified_cmd_send(wmi_handle, buf, len,
  395. WMI_VDEV_PARAM_ENABLE_SR_PROHIBIT_CMDID)) {
  396. wmi_err("Failed to set neighbour rx param");
  397. wmi_buf_free(buf);
  398. return QDF_STATUS_E_FAILURE;
  399. }
  400. return QDF_STATUS_SUCCESS;
  401. }
  402. static void wmi_vdev_attach_sr_cmds_tlv(struct wmi_ops *wmi_ops)
  403. {
  404. if (!wmi_ops)
  405. return;
  406. wmi_ops->vdev_param_sr_prohibit_send =
  407. vdev_param_sr_prohibit_send_tlv;
  408. }
  409. #else
  410. static inline void wmi_vdev_attach_sr_cmds_tlv(struct wmi_ops *wmi_ops)
  411. {
  412. }
  413. #endif
  414. static void
  415. set_peer_tx_vlan_config(wmi_peer_config_vlan_cmd_fixed_param *cmd,
  416. struct peer_vlan_config_param *cfg)
  417. {
  418. WMI_VLAN_TX_SET(cmd->peer_vlan_config_mask, cfg->tx_cmd);
  419. /* Setting insert_or_strip bit for Tx */
  420. WMI_TX_INSERT_OR_STRIP_SET(cmd->peer_vlan_config_mask,
  421. cfg->tx_strip_insert);
  422. if (cfg->tx_strip_insert_inner && cfg->tx_strip_insert) {
  423. /* Setting the strip_insert_vlan_inner bit fo Tx */
  424. WMI_TX_STRIP_INSERT_VLAN_INNER_SET(cmd->peer_vlan_config_mask,
  425. cfg->tx_strip_insert_inner);
  426. /* If Insert inner tag bit is set, then fill inner_tci */
  427. WMI_TX_INSERT_VLAN_INNER_TCI_SET(cmd->insert_vlan_tci,
  428. cfg->insert_vlan_inner_tci);
  429. }
  430. if (cfg->tx_strip_insert_outer && cfg->tx_strip_insert) {
  431. /* Setting the strip_insert_vlan_outer bit for Tx */
  432. WMI_TX_STRIP_INSERT_VLAN_OUTER_SET(cmd->peer_vlan_config_mask,
  433. cfg->tx_strip_insert_outer);
  434. /* If Insert outer tag bit is set, then fill outer_tci */
  435. WMI_TX_INSERT_VLAN_OUTER_TCI_SET(cmd->insert_vlan_tci,
  436. cfg->insert_vlan_outer_tci);
  437. }
  438. }
  439. static void
  440. wmi_set_peer_vlan_config(wmi_peer_config_vlan_cmd_fixed_param *cmd,
  441. struct peer_vlan_config_param *param)
  442. {
  443. /* Tx command - Check if cmd is Tx then configure Tx cmd */
  444. if (param->tx_cmd)
  445. set_peer_tx_vlan_config(cmd, param);
  446. /* Rx command - Check if cmd is Rx then configure Rx cmd */
  447. if (param->rx_cmd) {
  448. WMI_VLAN_RX_SET(cmd->peer_vlan_config_mask, param->rx_cmd);
  449. /* Setting the strip_vlan_c_tag_decap bit in RX */
  450. WMI_RX_STRIP_VLAN_C_TAG_SET(cmd->peer_vlan_config_mask,
  451. param->rx_strip_c_tag);
  452. /* Setting the strip_vlan_s_tag_decap bit in RX */
  453. WMI_RX_STRIP_VLAN_S_TAG_SET(cmd->peer_vlan_config_mask,
  454. param->rx_strip_s_tag);
  455. /* Setting the insert_vlan_c_tag_decap bit in RX */
  456. WMI_RX_INSERT_VLAN_C_TAG_SET(cmd->peer_vlan_config_mask,
  457. param->rx_insert_c_tag);
  458. /* Setting the insert_vlan_s_tag_decap bit in RX */
  459. WMI_RX_INSERT_VLAN_S_TAG_SET(cmd->peer_vlan_config_mask,
  460. param->rx_insert_s_tag);
  461. }
  462. }
  463. static QDF_STATUS
  464. send_peer_vlan_config_cmd_tlv(wmi_unified_t wmi,
  465. uint8_t peer_addr[QDF_MAC_ADDR_SIZE],
  466. struct peer_vlan_config_param *param)
  467. {
  468. wmi_peer_config_vlan_cmd_fixed_param *cmd;
  469. wmi_buf_t buf;
  470. uint32_t len = sizeof(*cmd);
  471. buf = wmi_buf_alloc(wmi, len);
  472. if (!buf)
  473. return QDF_STATUS_E_NOMEM;
  474. cmd = (wmi_peer_config_vlan_cmd_fixed_param *)wmi_buf_data(buf);
  475. WMITLV_SET_HDR(&cmd->tlv_header,
  476. WMITLV_TAG_STRUC_wmi_peer_config_vlan_cmd_fixed_param,
  477. WMITLV_GET_STRUCT_TLVLEN
  478. (wmi_peer_config_vlan_cmd_fixed_param));
  479. WMI_CHAR_ARRAY_TO_MAC_ADDR(peer_addr, &cmd->peer_macaddr);
  480. /* vdev id */
  481. cmd->vdev_id = param->vdev_id;
  482. wmi_set_peer_vlan_config(cmd, param);
  483. if (wmi_unified_cmd_send(wmi, buf, len, WMI_PEER_CONFIG_VLAN_CMDID)) {
  484. wmi_err("Failed to send peer hw vlan acceleration command");
  485. wmi_buf_free(buf);
  486. return QDF_STATUS_E_FAILURE;
  487. }
  488. return QDF_STATUS_SUCCESS;
  489. }
  490. void wmi_vdev_attach_tlv(struct wmi_unified *wmi_handle)
  491. {
  492. struct wmi_ops *wmi_ops;
  493. if (!wmi_handle) {
  494. wmi_err("null wmi handle");
  495. return;
  496. }
  497. wmi_ops = wmi_handle->ops;
  498. wmi_ops->extract_vdev_delete_resp = extract_vdev_delete_resp_tlv;
  499. wmi_ops->extract_vdev_stopped_param = extract_vdev_stopped_param_tlv;
  500. wmi_ops->extract_vdev_start_resp = extract_vdev_start_resp_tlv;
  501. wmi_ops->extract_vdev_peer_delete_all_response_event =
  502. extract_vdev_peer_delete_all_response_event_tlv;
  503. wmi_ops->extract_tbttoffset_num_vdevs =
  504. extract_tbttoffset_num_vdevs_tlv;
  505. wmi_ops->extract_tbttoffset_update_params =
  506. extract_tbttoffset_update_params_tlv;
  507. wmi_ops->extract_ext_tbttoffset_update_params =
  508. extract_ext_tbttoffset_update_params_tlv;
  509. wmi_ops->extract_ext_tbttoffset_num_vdevs =
  510. extract_ext_tbttoffset_num_vdevs_tlv;
  511. wmi_ops->extract_muedca_params_handler =
  512. extract_muedca_params_tlv;
  513. wmi_ops->send_vdev_set_neighbour_rx_cmd =
  514. send_vdev_set_neighbour_rx_cmd_tlv;
  515. wmi_ops->send_beacon_send_cmd = send_beacon_send_cmd_tlv;
  516. wmi_ops->send_vdev_config_ratemask_cmd =
  517. send_vdev_config_ratemask_cmd_tlv;
  518. wmi_ops->send_peer_filter_set_tx_cmd = send_peer_filter_set_tx_cmd_tlv;
  519. wmi_ops->send_peer_vlan_config_cmd = send_peer_vlan_config_cmd_tlv;
  520. wmi_vdev_attach_sr_cmds_tlv(wmi_ops);
  521. }