wmi_unified_sta_tlv.c 77 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442244324442445244624472448244924502451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481248224832484248524862487248824892490249124922493249424952496249724982499250025012502250325042505250625072508
  1. /*
  2. * Copyright (c) 2013-2018 The Linux Foundation. All rights reserved.
  3. *
  4. * Permission to use, copy, modify, and/or distribute this software for
  5. * any purpose with or without fee is hereby granted, provided that the
  6. * above copyright notice and this permission notice appear in all
  7. * copies.
  8. *
  9. * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
  10. * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
  11. * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
  12. * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
  13. * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
  14. * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  15. * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  16. * PERFORMANCE OF THIS SOFTWARE.
  17. */
  18. #include <osdep.h>
  19. #include "wmi.h"
  20. #include "wmi_version.h"
  21. #include "wmi_unified_priv.h"
  22. #include "wmi_unified_sta_param.h"
  23. #include "wmi_unified_sta_api.h"
  24. /**
  25. * send_set_sta_sa_query_param_cmd_tlv() - set sta sa query parameters
  26. * @wmi_handle: wmi handle
  27. * @vdev_id: vdev id
  28. * @max_retries: max retries
  29. * @retry_interval: retry interval
  30. * This function sets sta query related parameters in fw.
  31. *
  32. * Return: QDF_STATUS_SUCCESS for success otherwise failure
  33. */
  34. static QDF_STATUS send_set_sta_sa_query_param_cmd_tlv(wmi_unified_t wmi_handle,
  35. uint8_t vdev_id,
  36. uint32_t max_retries,
  37. uint32_t retry_interval)
  38. {
  39. wmi_buf_t buf;
  40. WMI_PMF_OFFLOAD_SET_SA_QUERY_CMD_fixed_param *cmd;
  41. int len;
  42. len = sizeof(*cmd);
  43. buf = wmi_buf_alloc(wmi_handle, len);
  44. if (!buf) {
  45. return QDF_STATUS_E_FAILURE;
  46. }
  47. cmd = (WMI_PMF_OFFLOAD_SET_SA_QUERY_CMD_fixed_param *)wmi_buf_data(buf);
  48. WMITLV_SET_HDR(&cmd->tlv_header,
  49. WMITLV_TAG_STRUC_WMI_PMF_OFFLOAD_SET_SA_QUERY_CMD_fixed_param,
  50. WMITLV_GET_STRUCT_TLVLEN
  51. (WMI_PMF_OFFLOAD_SET_SA_QUERY_CMD_fixed_param));
  52. cmd->vdev_id = vdev_id;
  53. cmd->sa_query_max_retry_count = max_retries;
  54. cmd->sa_query_retry_interval = retry_interval;
  55. WMI_LOGD(FL("STA sa query: vdev_id:%d interval:%u retry count:%d"),
  56. vdev_id, retry_interval, max_retries);
  57. wmi_mtrace(WMI_PMF_OFFLOAD_SET_SA_QUERY_CMDID, cmd->vdev_id, 0);
  58. if (wmi_unified_cmd_send(wmi_handle, buf, len,
  59. WMI_PMF_OFFLOAD_SET_SA_QUERY_CMDID)) {
  60. WMI_LOGE(FL("Failed to offload STA SA Query"));
  61. wmi_buf_free(buf);
  62. return QDF_STATUS_E_FAILURE;
  63. }
  64. WMI_LOGD(FL("Exit :"));
  65. return 0;
  66. }
  67. /**
  68. * send_set_sta_keep_alive_cmd_tlv() - set sta keep alive parameters
  69. * @wmi_handle: wmi handle
  70. * @params: sta keep alive parameter
  71. *
  72. * This function sets keep alive related parameters in fw.
  73. *
  74. * Return: CDF status
  75. */
  76. static QDF_STATUS send_set_sta_keep_alive_cmd_tlv(wmi_unified_t wmi_handle,
  77. struct sta_params *params)
  78. {
  79. wmi_buf_t buf;
  80. WMI_STA_KEEPALIVE_CMD_fixed_param *cmd;
  81. WMI_STA_KEEPALVE_ARP_RESPONSE *arp_rsp;
  82. uint8_t *buf_ptr;
  83. int len;
  84. QDF_STATUS ret;
  85. WMI_LOGD("%s: Enter", __func__);
  86. len = sizeof(*cmd) + sizeof(*arp_rsp);
  87. buf = wmi_buf_alloc(wmi_handle, len);
  88. if (!buf) {
  89. return QDF_STATUS_E_FAILURE;
  90. }
  91. cmd = (WMI_STA_KEEPALIVE_CMD_fixed_param *) wmi_buf_data(buf);
  92. buf_ptr = (uint8_t *) cmd;
  93. WMITLV_SET_HDR(&cmd->tlv_header,
  94. WMITLV_TAG_STRUC_WMI_STA_KEEPALIVE_CMD_fixed_param,
  95. WMITLV_GET_STRUCT_TLVLEN
  96. (WMI_STA_KEEPALIVE_CMD_fixed_param));
  97. cmd->interval = params->timeperiod;
  98. cmd->enable = (params->timeperiod) ? 1 : 0;
  99. cmd->vdev_id = params->vdev_id;
  100. WMI_LOGD("Keep Alive: vdev_id:%d interval:%u method:%d", params->vdev_id,
  101. params->timeperiod, params->method);
  102. arp_rsp = (WMI_STA_KEEPALVE_ARP_RESPONSE *) (buf_ptr + sizeof(*cmd));
  103. WMITLV_SET_HDR(&arp_rsp->tlv_header,
  104. WMITLV_TAG_STRUC_WMI_STA_KEEPALVE_ARP_RESPONSE,
  105. WMITLV_GET_STRUCT_TLVLEN(WMI_STA_KEEPALVE_ARP_RESPONSE));
  106. if ((params->method == WMI_KEEP_ALIVE_UNSOLICIT_ARP_RSP) ||
  107. (params->method ==
  108. WMI_STA_KEEPALIVE_METHOD_GRATUITOUS_ARP_REQUEST)) {
  109. if ((NULL == params->hostv4addr) ||
  110. (NULL == params->destv4addr) ||
  111. (NULL == params->destmac)) {
  112. WMI_LOGE("%s: received null pointer, hostv4addr:%pK "
  113. "destv4addr:%pK destmac:%pK ", __func__,
  114. params->hostv4addr, params->destv4addr,
  115. params->destmac);
  116. wmi_buf_free(buf);
  117. return QDF_STATUS_E_FAILURE;
  118. }
  119. cmd->method = params->method;
  120. qdf_mem_copy(&arp_rsp->sender_prot_addr, params->hostv4addr,
  121. WMI_IPV4_ADDR_LEN);
  122. qdf_mem_copy(&arp_rsp->target_prot_addr, params->destv4addr,
  123. WMI_IPV4_ADDR_LEN);
  124. WMI_CHAR_ARRAY_TO_MAC_ADDR(params->destmac, &arp_rsp->dest_mac_addr);
  125. } else {
  126. cmd->method = WMI_STA_KEEPALIVE_METHOD_NULL_FRAME;
  127. }
  128. wmi_mtrace(WMI_STA_KEEPALIVE_CMDID, cmd->vdev_id, 0);
  129. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  130. WMI_STA_KEEPALIVE_CMDID);
  131. if (QDF_IS_STATUS_ERROR(ret)) {
  132. WMI_LOGE("Failed to set KeepAlive");
  133. wmi_buf_free(buf);
  134. }
  135. WMI_LOGD("%s: Exit", __func__);
  136. return ret;
  137. }
  138. /**
  139. * send_vdev_set_gtx_cfg_cmd_tlv() - set GTX params
  140. * @wmi_handle: wmi handle
  141. * @if_id: vdev id
  142. * @gtx_info: GTX config params
  143. *
  144. * This function set GTX related params in firmware.
  145. *
  146. * Return: QDF_STATUS_SUCCESS for success or error code
  147. */
  148. static QDF_STATUS send_vdev_set_gtx_cfg_cmd_tlv(wmi_unified_t wmi_handle, uint32_t if_id,
  149. struct wmi_gtx_config *gtx_info)
  150. {
  151. wmi_vdev_set_gtx_params_cmd_fixed_param *cmd;
  152. wmi_buf_t buf;
  153. QDF_STATUS ret;
  154. int len = sizeof(wmi_vdev_set_gtx_params_cmd_fixed_param);
  155. buf = wmi_buf_alloc(wmi_handle, len);
  156. if (!buf) {
  157. return QDF_STATUS_E_NOMEM;
  158. }
  159. cmd = (wmi_vdev_set_gtx_params_cmd_fixed_param *) wmi_buf_data(buf);
  160. WMITLV_SET_HDR(&cmd->tlv_header,
  161. WMITLV_TAG_STRUC_wmi_vdev_set_gtx_params_cmd_fixed_param,
  162. WMITLV_GET_STRUCT_TLVLEN
  163. (wmi_vdev_set_gtx_params_cmd_fixed_param));
  164. cmd->vdev_id = if_id;
  165. cmd->gtxRTMask[0] = gtx_info->gtx_rt_mask[0];
  166. cmd->gtxRTMask[1] = gtx_info->gtx_rt_mask[1];
  167. cmd->userGtxMask = gtx_info->gtx_usrcfg;
  168. cmd->gtxPERThreshold = gtx_info->gtx_threshold;
  169. cmd->gtxPERMargin = gtx_info->gtx_margin;
  170. cmd->gtxTPCstep = gtx_info->gtx_tpcstep;
  171. cmd->gtxTPCMin = gtx_info->gtx_tpcmin;
  172. cmd->gtxBWMask = gtx_info->gtx_bwmask;
  173. WMI_LOGD("Setting vdev%d GTX values:htmcs 0x%x, vhtmcs 0x%x, usermask 0x%x, \
  174. gtxPERThreshold %d, gtxPERMargin %d, gtxTPCstep %d, gtxTPCMin %d, \
  175. gtxBWMask 0x%x.", if_id, cmd->gtxRTMask[0], cmd->gtxRTMask[1],
  176. cmd->userGtxMask, cmd->gtxPERThreshold, cmd->gtxPERMargin,
  177. cmd->gtxTPCstep, cmd->gtxTPCMin, cmd->gtxBWMask);
  178. wmi_mtrace(WMI_VDEV_SET_GTX_PARAMS_CMDID, cmd->vdev_id, 0);
  179. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  180. WMI_VDEV_SET_GTX_PARAMS_CMDID);
  181. if (QDF_IS_STATUS_ERROR(ret)) {
  182. WMI_LOGE("Failed to set GTX PARAMS");
  183. wmi_buf_free(buf);
  184. }
  185. return ret;
  186. }
  187. /**
  188. * send_process_dhcp_ind_cmd_tlv() - process dhcp indication from SME
  189. * @wmi_handle: wmi handle
  190. * @ta_dhcp_ind: DHCP indication parameter
  191. *
  192. * Return: CDF Status
  193. */
  194. static QDF_STATUS send_process_dhcp_ind_cmd_tlv(wmi_unified_t wmi_handle,
  195. wmi_peer_set_param_cmd_fixed_param *ta_dhcp_ind)
  196. {
  197. QDF_STATUS status;
  198. wmi_buf_t buf = NULL;
  199. uint8_t *buf_ptr;
  200. wmi_peer_set_param_cmd_fixed_param *peer_set_param_fp;
  201. int len = sizeof(wmi_peer_set_param_cmd_fixed_param);
  202. buf = wmi_buf_alloc(wmi_handle, len);
  203. if (!buf) {
  204. return QDF_STATUS_E_NOMEM;
  205. }
  206. buf_ptr = (uint8_t *) wmi_buf_data(buf);
  207. peer_set_param_fp = (wmi_peer_set_param_cmd_fixed_param *) buf_ptr;
  208. WMITLV_SET_HDR(&peer_set_param_fp->tlv_header,
  209. WMITLV_TAG_STRUC_wmi_peer_set_param_cmd_fixed_param,
  210. WMITLV_GET_STRUCT_TLVLEN
  211. (wmi_peer_set_param_cmd_fixed_param));
  212. /* fill in values */
  213. peer_set_param_fp->vdev_id = ta_dhcp_ind->vdev_id;
  214. peer_set_param_fp->param_id = ta_dhcp_ind->param_id;
  215. peer_set_param_fp->param_value = ta_dhcp_ind->param_value;
  216. qdf_mem_copy(&peer_set_param_fp->peer_macaddr,
  217. &ta_dhcp_ind->peer_macaddr,
  218. sizeof(ta_dhcp_ind->peer_macaddr));
  219. wmi_mtrace(WMI_PEER_SET_PARAM_CMDID, NO_SESSION, 0);
  220. status = wmi_unified_cmd_send(wmi_handle, buf,
  221. len, WMI_PEER_SET_PARAM_CMDID);
  222. if (QDF_IS_STATUS_ERROR(status)) {
  223. WMI_LOGE("%s: wmi_unified_cmd_send WMI_PEER_SET_PARAM_CMD"
  224. " returned Error %d", __func__, status);
  225. wmi_buf_free(buf);
  226. }
  227. return status;
  228. }
  229. /**
  230. * send_get_link_speed_cmd_tlv() -send command to get linkspeed
  231. * @wmi_handle: wmi handle
  232. * @pLinkSpeed: link speed info
  233. *
  234. * Return: CDF status
  235. */
  236. static QDF_STATUS send_get_link_speed_cmd_tlv(wmi_unified_t wmi_handle,
  237. wmi_mac_addr peer_macaddr)
  238. {
  239. wmi_peer_get_estimated_linkspeed_cmd_fixed_param *cmd;
  240. wmi_buf_t wmi_buf;
  241. uint32_t len;
  242. uint8_t *buf_ptr;
  243. len = sizeof(wmi_peer_get_estimated_linkspeed_cmd_fixed_param);
  244. wmi_buf = wmi_buf_alloc(wmi_handle, len);
  245. if (!wmi_buf) {
  246. return QDF_STATUS_E_NOMEM;
  247. }
  248. buf_ptr = (uint8_t *) wmi_buf_data(wmi_buf);
  249. cmd = (wmi_peer_get_estimated_linkspeed_cmd_fixed_param *) buf_ptr;
  250. WMITLV_SET_HDR(&cmd->tlv_header,
  251. WMITLV_TAG_STRUC_wmi_peer_get_estimated_linkspeed_cmd_fixed_param,
  252. WMITLV_GET_STRUCT_TLVLEN
  253. (wmi_peer_get_estimated_linkspeed_cmd_fixed_param));
  254. /* Copy the peer macaddress to the wma buffer */
  255. qdf_mem_copy(&cmd->peer_macaddr,
  256. &peer_macaddr,
  257. sizeof(peer_macaddr));
  258. wmi_mtrace(WMI_PEER_GET_ESTIMATED_LINKSPEED_CMDID, cmd->vdev_id, 0);
  259. if (wmi_unified_cmd_send(wmi_handle, wmi_buf, len,
  260. WMI_PEER_GET_ESTIMATED_LINKSPEED_CMDID)) {
  261. WMI_LOGE("%s: failed to send link speed command", __func__);
  262. wmi_buf_free(wmi_buf);
  263. return QDF_STATUS_E_FAILURE;
  264. }
  265. return QDF_STATUS_SUCCESS;
  266. }
  267. /**
  268. * send_fw_profiling_cmd_tlv() - send FW profiling cmd to WLAN FW
  269. * @wmi_handl: wmi handle
  270. * @cmd: Profiling command index
  271. * @value1: parameter1 value
  272. * @value2: parameter2 value
  273. *
  274. * Return: QDF_STATUS_SUCCESS for success else error code
  275. */
  276. static QDF_STATUS send_fw_profiling_cmd_tlv(wmi_unified_t wmi_handle,
  277. uint32_t cmd, uint32_t value1, uint32_t value2)
  278. {
  279. wmi_buf_t buf;
  280. int32_t len = 0;
  281. int ret;
  282. wmi_wlan_profile_trigger_cmd_fixed_param *prof_trig_cmd;
  283. wmi_wlan_profile_set_hist_intvl_cmd_fixed_param *hist_intvl_cmd;
  284. wmi_wlan_profile_enable_profile_id_cmd_fixed_param *profile_enable_cmd;
  285. wmi_wlan_profile_get_prof_data_cmd_fixed_param *profile_getdata_cmd;
  286. switch (cmd) {
  287. case WMI_WLAN_PROFILE_TRIGGER_CMDID:
  288. len = sizeof(wmi_wlan_profile_trigger_cmd_fixed_param);
  289. buf = wmi_buf_alloc(wmi_handle, len);
  290. if (!buf) {
  291. return QDF_STATUS_E_NOMEM;
  292. }
  293. prof_trig_cmd =
  294. (wmi_wlan_profile_trigger_cmd_fixed_param *)
  295. wmi_buf_data(buf);
  296. WMITLV_SET_HDR(&prof_trig_cmd->tlv_header,
  297. WMITLV_TAG_STRUC_wmi_wlan_profile_trigger_cmd_fixed_param,
  298. WMITLV_GET_STRUCT_TLVLEN
  299. (wmi_wlan_profile_trigger_cmd_fixed_param));
  300. prof_trig_cmd->enable = value1;
  301. wmi_mtrace(WMI_WLAN_PROFILE_TRIGGER_CMDID, NO_SESSION, 0);
  302. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  303. WMI_WLAN_PROFILE_TRIGGER_CMDID);
  304. if (ret) {
  305. WMI_LOGE("PROFILE_TRIGGER cmd Failed with value %d",
  306. value1);
  307. wmi_buf_free(buf);
  308. return ret;
  309. }
  310. break;
  311. case WMI_WLAN_PROFILE_GET_PROFILE_DATA_CMDID:
  312. len = sizeof(wmi_wlan_profile_get_prof_data_cmd_fixed_param);
  313. buf = wmi_buf_alloc(wmi_handle, len);
  314. if (!buf) {
  315. return QDF_STATUS_E_NOMEM;
  316. }
  317. profile_getdata_cmd =
  318. (wmi_wlan_profile_get_prof_data_cmd_fixed_param *)
  319. wmi_buf_data(buf);
  320. WMITLV_SET_HDR(&profile_getdata_cmd->tlv_header,
  321. WMITLV_TAG_STRUC_wmi_wlan_profile_get_prof_data_cmd_fixed_param,
  322. WMITLV_GET_STRUCT_TLVLEN
  323. (wmi_wlan_profile_get_prof_data_cmd_fixed_param));
  324. wmi_mtrace(WMI_WLAN_PROFILE_GET_PROFILE_DATA_CMDID,
  325. NO_SESSION, 0);
  326. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  327. WMI_WLAN_PROFILE_GET_PROFILE_DATA_CMDID);
  328. if (ret) {
  329. WMI_LOGE("PROFILE_DATA cmd Failed for id %d value %d",
  330. value1, value2);
  331. wmi_buf_free(buf);
  332. return ret;
  333. }
  334. break;
  335. case WMI_WLAN_PROFILE_SET_HIST_INTVL_CMDID:
  336. len = sizeof(wmi_wlan_profile_set_hist_intvl_cmd_fixed_param);
  337. buf = wmi_buf_alloc(wmi_handle, len);
  338. if (!buf) {
  339. return QDF_STATUS_E_NOMEM;
  340. }
  341. hist_intvl_cmd =
  342. (wmi_wlan_profile_set_hist_intvl_cmd_fixed_param *)
  343. wmi_buf_data(buf);
  344. WMITLV_SET_HDR(&hist_intvl_cmd->tlv_header,
  345. WMITLV_TAG_STRUC_wmi_wlan_profile_set_hist_intvl_cmd_fixed_param,
  346. WMITLV_GET_STRUCT_TLVLEN
  347. (wmi_wlan_profile_set_hist_intvl_cmd_fixed_param));
  348. hist_intvl_cmd->profile_id = value1;
  349. hist_intvl_cmd->value = value2;
  350. wmi_mtrace(WMI_WLAN_PROFILE_SET_HIST_INTVL_CMDID,
  351. NO_SESSION, 0);
  352. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  353. WMI_WLAN_PROFILE_SET_HIST_INTVL_CMDID);
  354. if (ret) {
  355. WMI_LOGE("HIST_INTVL cmd Failed for id %d value %d",
  356. value1, value2);
  357. wmi_buf_free(buf);
  358. return ret;
  359. }
  360. break;
  361. case WMI_WLAN_PROFILE_ENABLE_PROFILE_ID_CMDID:
  362. len =
  363. sizeof(wmi_wlan_profile_enable_profile_id_cmd_fixed_param);
  364. buf = wmi_buf_alloc(wmi_handle, len);
  365. if (!buf) {
  366. return QDF_STATUS_E_NOMEM;
  367. }
  368. profile_enable_cmd =
  369. (wmi_wlan_profile_enable_profile_id_cmd_fixed_param *)
  370. wmi_buf_data(buf);
  371. WMITLV_SET_HDR(&profile_enable_cmd->tlv_header,
  372. WMITLV_TAG_STRUC_wmi_wlan_profile_enable_profile_id_cmd_fixed_param,
  373. WMITLV_GET_STRUCT_TLVLEN
  374. (wmi_wlan_profile_enable_profile_id_cmd_fixed_param));
  375. profile_enable_cmd->profile_id = value1;
  376. profile_enable_cmd->enable = value2;
  377. wmi_mtrace(WMI_WLAN_PROFILE_ENABLE_PROFILE_ID_CMDID,
  378. NO_SESSION, 0);
  379. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  380. WMI_WLAN_PROFILE_ENABLE_PROFILE_ID_CMDID);
  381. if (ret) {
  382. WMI_LOGE("enable cmd Failed for id %d value %d",
  383. value1, value2);
  384. wmi_buf_free(buf);
  385. return ret;
  386. }
  387. break;
  388. default:
  389. WMI_LOGD("%s: invalid profiling command", __func__);
  390. break;
  391. }
  392. return 0;
  393. }
  394. /**
  395. * send_nat_keepalive_en_cmd_tlv() - enable NAT keepalive filter
  396. * @wmi_handle: wmi handle
  397. * @vdev_id: vdev id
  398. *
  399. * Return: QDF_STATUS_SUCCESS for success or error code
  400. */
  401. static QDF_STATUS send_nat_keepalive_en_cmd_tlv(wmi_unified_t wmi_handle, uint8_t vdev_id)
  402. {
  403. WMI_VDEV_IPSEC_NATKEEPALIVE_FILTER_CMD_fixed_param *cmd;
  404. wmi_buf_t buf;
  405. int32_t len = sizeof(*cmd);
  406. WMI_LOGD("%s: vdev_id %d", __func__, vdev_id);
  407. buf = wmi_buf_alloc(wmi_handle, len);
  408. if (!buf) {
  409. return QDF_STATUS_E_NOMEM;
  410. }
  411. cmd = (WMI_VDEV_IPSEC_NATKEEPALIVE_FILTER_CMD_fixed_param *)
  412. wmi_buf_data(buf);
  413. WMITLV_SET_HDR(&cmd->tlv_header,
  414. WMITLV_TAG_STRUC_WMI_VDEV_IPSEC_NATKEEPALIVE_FILTER_CMD_fixed_param,
  415. WMITLV_GET_STRUCT_TLVLEN
  416. (WMI_VDEV_IPSEC_NATKEEPALIVE_FILTER_CMD_fixed_param));
  417. cmd->vdev_id = vdev_id;
  418. cmd->action = IPSEC_NATKEEPALIVE_FILTER_ENABLE;
  419. wmi_mtrace(WMI_VDEV_IPSEC_NATKEEPALIVE_FILTER_CMDID, cmd->vdev_id, 0);
  420. if (wmi_unified_cmd_send(wmi_handle, buf, len,
  421. WMI_VDEV_IPSEC_NATKEEPALIVE_FILTER_CMDID)) {
  422. WMI_LOGP("%s: Failed to send NAT keepalive enable command",
  423. __func__);
  424. wmi_buf_free(buf);
  425. return QDF_STATUS_E_FAILURE;
  426. }
  427. return 0;
  428. }
  429. static QDF_STATUS send_wlm_latency_level_cmd_tlv(wmi_unified_t wmi_handle,
  430. struct wlm_latency_level_param *params)
  431. {
  432. wmi_wlm_config_cmd_fixed_param *cmd;
  433. wmi_buf_t buf;
  434. uint32_t len = sizeof(*cmd);
  435. static uint32_t ll[4] = {100, 60, 40, 20};
  436. buf = wmi_buf_alloc(wmi_handle, len);
  437. if (!buf) {
  438. return QDF_STATUS_E_NOMEM;
  439. }
  440. cmd = (wmi_wlm_config_cmd_fixed_param *)wmi_buf_data(buf);
  441. WMITLV_SET_HDR(&cmd->tlv_header,
  442. WMITLV_TAG_STRUC_wmi_wlm_config_cmd_fixed_param,
  443. WMITLV_GET_STRUCT_TLVLEN
  444. (wmi_wlm_config_cmd_fixed_param));
  445. cmd->vdev_id = params->vdev_id;
  446. cmd->latency_level = params->wlm_latency_level;
  447. cmd->ul_latency = ll[params->wlm_latency_level];
  448. cmd->dl_latency = ll[params->wlm_latency_level];
  449. cmd->flags = params->wlm_latency_flags;
  450. wmi_mtrace(WMI_WLM_CONFIG_CMDID, cmd->vdev_id, 0);
  451. if (wmi_unified_cmd_send(wmi_handle, buf, len,
  452. WMI_WLM_CONFIG_CMDID)) {
  453. WMI_LOGE("%s: Failed to send setting latency config command",
  454. __func__);
  455. wmi_buf_free(buf);
  456. return QDF_STATUS_E_FAILURE;
  457. }
  458. return 0;
  459. }
  460. /**
  461. * send_nan_req_cmd_tlv() - to send nan request to target
  462. * @wmi_handle: wmi handle
  463. * @nan_req: request data which will be non-null
  464. *
  465. * Return: CDF status
  466. */
  467. static QDF_STATUS send_nan_req_cmd_tlv(wmi_unified_t wmi_handle,
  468. struct nan_req_params *nan_req)
  469. {
  470. QDF_STATUS ret;
  471. wmi_nan_cmd_param *cmd;
  472. wmi_buf_t buf;
  473. uint16_t len = sizeof(*cmd);
  474. uint16_t nan_data_len, nan_data_len_aligned;
  475. uint8_t *buf_ptr;
  476. /*
  477. * <----- cmd ------------><-- WMI_TLV_HDR_SIZE --><--- data ---->
  478. * +------------+----------+-----------------------+--------------+
  479. * | tlv_header | data_len | WMITLV_TAG_ARRAY_BYTE | nan_req_data |
  480. * +------------+----------+-----------------------+--------------+
  481. */
  482. if (!nan_req) {
  483. WMI_LOGE("%s:nan req is not valid", __func__);
  484. return QDF_STATUS_E_FAILURE;
  485. }
  486. nan_data_len = nan_req->request_data_len;
  487. nan_data_len_aligned = roundup(nan_req->request_data_len,
  488. sizeof(uint32_t));
  489. if (nan_data_len_aligned < nan_req->request_data_len) {
  490. WMI_LOGE("%s: integer overflow while rounding up data_len",
  491. __func__);
  492. return QDF_STATUS_E_FAILURE;
  493. }
  494. if (nan_data_len_aligned > WMI_SVC_MSG_MAX_SIZE - WMI_TLV_HDR_SIZE) {
  495. WMI_LOGE("%s: wmi_max_msg_size overflow for given datalen",
  496. __func__);
  497. return QDF_STATUS_E_FAILURE;
  498. }
  499. len += WMI_TLV_HDR_SIZE + nan_data_len_aligned;
  500. buf = wmi_buf_alloc(wmi_handle, len);
  501. if (!buf) {
  502. return QDF_STATUS_E_NOMEM;
  503. }
  504. buf_ptr = (uint8_t *) wmi_buf_data(buf);
  505. cmd = (wmi_nan_cmd_param *) buf_ptr;
  506. WMITLV_SET_HDR(&cmd->tlv_header,
  507. WMITLV_TAG_STRUC_wmi_nan_cmd_param,
  508. WMITLV_GET_STRUCT_TLVLEN(wmi_nan_cmd_param));
  509. cmd->data_len = nan_req->request_data_len;
  510. WMI_LOGD("%s: The data len value is %u",
  511. __func__, nan_req->request_data_len);
  512. buf_ptr += sizeof(wmi_nan_cmd_param);
  513. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_BYTE, nan_data_len_aligned);
  514. buf_ptr += WMI_TLV_HDR_SIZE;
  515. qdf_mem_copy(buf_ptr, nan_req->request_data, cmd->data_len);
  516. wmi_mtrace(WMI_NAN_CMDID, NO_SESSION, 0);
  517. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  518. WMI_NAN_CMDID);
  519. if (QDF_IS_STATUS_ERROR(ret)) {
  520. WMI_LOGE("%s Failed to send set param command ret = %d",
  521. __func__, ret);
  522. wmi_buf_free(buf);
  523. }
  524. return ret;
  525. }
  526. #ifdef CONVERGED_TDLS_ENABLE
  527. /**
  528. * tdls_get_wmi_offchannel_mode - Get WMI tdls off channel mode
  529. * @tdls_sw_mode: tdls_sw_mode
  530. *
  531. * This function returns wmi tdls offchannel mode
  532. *
  533. * Return: enum value of wmi tdls offchannel mode
  534. */
  535. static uint8_t tdls_get_wmi_offchannel_mode(uint8_t tdls_sw_mode)
  536. {
  537. uint8_t off_chan_mode;
  538. switch (tdls_sw_mode) {
  539. case ENABLE_CHANSWITCH:
  540. off_chan_mode = WMI_TDLS_ENABLE_OFFCHANNEL;
  541. break;
  542. case DISABLE_CHANSWITCH:
  543. off_chan_mode = WMI_TDLS_DISABLE_OFFCHANNEL;
  544. break;
  545. default:
  546. WMI_LOGD(FL("unknown tdls_sw_mode %d"), tdls_sw_mode);
  547. off_chan_mode = WMI_TDLS_DISABLE_OFFCHANNEL;
  548. }
  549. return off_chan_mode;
  550. }
  551. /**
  552. * tdls_get_wmi_offchannel_bw - Get WMI tdls off channel Bandwidth
  553. * @tdls_sw_mode: tdls_sw_mode
  554. *
  555. * This function returns wmi tdls offchannel bandwidth
  556. *
  557. * Return: TDLS offchannel bandwidth
  558. */
  559. static uint8_t tdls_get_wmi_offchannel_bw(uint16_t tdls_off_ch_bw_offset)
  560. {
  561. uint8_t off_chan_bw;
  562. switch (tdls_off_ch_bw_offset) {
  563. case BW20:
  564. off_chan_bw = WMI_TDLS_OFFCHAN_20MHZ;
  565. break;
  566. case BW40_LOW_PRIMARY:
  567. case BW40_HIGH_PRIMARY:
  568. off_chan_bw = WMI_TDLS_OFFCHAN_40MHZ;
  569. break;
  570. case BW80:
  571. off_chan_bw = WMI_TDLS_OFFCHAN_80MHZ;
  572. case BWALL:
  573. off_chan_bw = WMI_TDLS_OFFCHAN_160MHZ;
  574. default:
  575. WMI_LOGD(FL("unknown tdls offchannel bw offset %d"),
  576. tdls_off_ch_bw_offset);
  577. off_chan_bw = WMI_TDLS_OFFCHAN_20MHZ;
  578. }
  579. return off_chan_bw;
  580. }
  581. /**
  582. * send_set_tdls_offchan_mode_cmd_tlv() - set tdls off channel mode
  583. * @wmi_handle: wmi handle
  584. * @chan_switch_params: Pointer to tdls channel switch parameter structure
  585. *
  586. * This function sets tdls off channel mode
  587. *
  588. * Return: 0 on success; Negative errno otherwise
  589. */
  590. static QDF_STATUS send_set_tdls_offchan_mode_cmd_tlv(wmi_unified_t wmi_handle,
  591. struct tdls_channel_switch_params *chan_switch_params)
  592. {
  593. wmi_tdls_set_offchan_mode_cmd_fixed_param *cmd;
  594. wmi_buf_t wmi_buf;
  595. u_int16_t len = sizeof(wmi_tdls_set_offchan_mode_cmd_fixed_param);
  596. wmi_buf = wmi_buf_alloc(wmi_handle, len);
  597. if (!wmi_buf) {
  598. return QDF_STATUS_E_FAILURE;
  599. }
  600. cmd = (wmi_tdls_set_offchan_mode_cmd_fixed_param *)
  601. wmi_buf_data(wmi_buf);
  602. WMITLV_SET_HDR(&cmd->tlv_header,
  603. WMITLV_TAG_STRUC_wmi_tdls_set_offchan_mode_cmd_fixed_param,
  604. WMITLV_GET_STRUCT_TLVLEN(
  605. wmi_tdls_set_offchan_mode_cmd_fixed_param));
  606. WMI_CHAR_ARRAY_TO_MAC_ADDR(chan_switch_params->peer_mac_addr,
  607. &cmd->peer_macaddr);
  608. cmd->vdev_id = chan_switch_params->vdev_id;
  609. cmd->offchan_mode =
  610. tdls_get_wmi_offchannel_mode(chan_switch_params->tdls_sw_mode);
  611. cmd->is_peer_responder = chan_switch_params->is_responder;
  612. cmd->offchan_num = chan_switch_params->tdls_off_ch;
  613. cmd->offchan_bw_bitmap =
  614. tdls_get_wmi_offchannel_bw(
  615. chan_switch_params->tdls_off_ch_bw_offset);
  616. cmd->offchan_oper_class = chan_switch_params->oper_class;
  617. WMI_LOGD(FL("Peer MAC Addr mac_addr31to0: 0x%x, mac_addr47to32: 0x%x"),
  618. cmd->peer_macaddr.mac_addr31to0,
  619. cmd->peer_macaddr.mac_addr47to32);
  620. WMI_LOGD(FL(
  621. "vdev_id: %d, off channel mode: %d, off channel Num: %d, "
  622. "off channel offset: 0x%x, is_peer_responder: %d, operating class: %d"
  623. ),
  624. cmd->vdev_id,
  625. cmd->offchan_mode,
  626. cmd->offchan_num,
  627. cmd->offchan_bw_bitmap,
  628. cmd->is_peer_responder,
  629. cmd->offchan_oper_class);
  630. wmi_mtrace(WMI_TDLS_SET_OFFCHAN_MODE_CMDID, cmd->vdev_id, 0);
  631. if (wmi_unified_cmd_send(wmi_handle, wmi_buf, len,
  632. WMI_TDLS_SET_OFFCHAN_MODE_CMDID)) {
  633. WMI_LOGP(FL("failed to send tdls off chan command"));
  634. wmi_buf_free(wmi_buf);
  635. return QDF_STATUS_E_FAILURE;
  636. }
  637. return QDF_STATUS_SUCCESS;
  638. }
  639. /**
  640. * send_update_fw_tdls_state_cmd_tlv() - send enable/disable tdls for a vdev
  641. * @wmi_handle: wmi handle
  642. * @pwmaTdlsparams: TDLS params
  643. *
  644. * Return: 0 for success or error code
  645. */
  646. static QDF_STATUS send_update_fw_tdls_state_cmd_tlv(wmi_unified_t wmi_handle,
  647. void *tdls_param, uint8_t tdls_state)
  648. {
  649. wmi_tdls_set_state_cmd_fixed_param *cmd;
  650. wmi_buf_t wmi_buf;
  651. struct wmi_tdls_params *wmi_tdls = (struct wmi_tdls_params *) tdls_param;
  652. uint16_t len = sizeof(wmi_tdls_set_state_cmd_fixed_param);
  653. wmi_buf = wmi_buf_alloc(wmi_handle, len);
  654. if (!wmi_buf) {
  655. return QDF_STATUS_E_FAILURE;
  656. }
  657. cmd = (wmi_tdls_set_state_cmd_fixed_param *) wmi_buf_data(wmi_buf);
  658. WMITLV_SET_HDR(&cmd->tlv_header,
  659. WMITLV_TAG_STRUC_wmi_tdls_set_state_cmd_fixed_param,
  660. WMITLV_GET_STRUCT_TLVLEN
  661. (wmi_tdls_set_state_cmd_fixed_param));
  662. cmd->vdev_id = wmi_tdls->vdev_id;
  663. cmd->state = tdls_state;
  664. cmd->notification_interval_ms = wmi_tdls->notification_interval_ms;
  665. cmd->tx_discovery_threshold = wmi_tdls->tx_discovery_threshold;
  666. cmd->tx_teardown_threshold = wmi_tdls->tx_teardown_threshold;
  667. cmd->rssi_teardown_threshold = wmi_tdls->rssi_teardown_threshold;
  668. cmd->rssi_delta = wmi_tdls->rssi_delta;
  669. cmd->tdls_options = wmi_tdls->tdls_options;
  670. cmd->tdls_peer_traffic_ind_window = wmi_tdls->peer_traffic_ind_window;
  671. cmd->tdls_peer_traffic_response_timeout_ms =
  672. wmi_tdls->peer_traffic_response_timeout;
  673. cmd->tdls_puapsd_mask = wmi_tdls->puapsd_mask;
  674. cmd->tdls_puapsd_inactivity_time_ms = wmi_tdls->puapsd_inactivity_time;
  675. cmd->tdls_puapsd_rx_frame_threshold =
  676. wmi_tdls->puapsd_rx_frame_threshold;
  677. cmd->teardown_notification_ms =
  678. wmi_tdls->teardown_notification_ms;
  679. cmd->tdls_peer_kickout_threshold =
  680. wmi_tdls->tdls_peer_kickout_threshold;
  681. WMI_LOGD("%s: tdls_state: %d, state: %d, "
  682. "notification_interval_ms: %d, "
  683. "tx_discovery_threshold: %d, "
  684. "tx_teardown_threshold: %d, "
  685. "rssi_teardown_threshold: %d, "
  686. "rssi_delta: %d, "
  687. "tdls_options: 0x%x, "
  688. "tdls_peer_traffic_ind_window: %d, "
  689. "tdls_peer_traffic_response_timeout: %d, "
  690. "tdls_puapsd_mask: 0x%x, "
  691. "tdls_puapsd_inactivity_time: %d, "
  692. "tdls_puapsd_rx_frame_threshold: %d, "
  693. "teardown_notification_ms: %d, "
  694. "tdls_peer_kickout_threshold: %d",
  695. __func__, tdls_state, cmd->state,
  696. cmd->notification_interval_ms,
  697. cmd->tx_discovery_threshold,
  698. cmd->tx_teardown_threshold,
  699. cmd->rssi_teardown_threshold,
  700. cmd->rssi_delta,
  701. cmd->tdls_options,
  702. cmd->tdls_peer_traffic_ind_window,
  703. cmd->tdls_peer_traffic_response_timeout_ms,
  704. cmd->tdls_puapsd_mask,
  705. cmd->tdls_puapsd_inactivity_time_ms,
  706. cmd->tdls_puapsd_rx_frame_threshold,
  707. cmd->teardown_notification_ms,
  708. cmd->tdls_peer_kickout_threshold);
  709. wmi_mtrace(WMI_TDLS_SET_STATE_CMDID, cmd->vdev_id, 0);
  710. if (wmi_unified_cmd_send(wmi_handle, wmi_buf, len,
  711. WMI_TDLS_SET_STATE_CMDID)) {
  712. WMI_LOGP("%s: failed to send tdls set state command", __func__);
  713. wmi_buf_free(wmi_buf);
  714. return QDF_STATUS_E_FAILURE;
  715. }
  716. WMI_LOGD("%s: vdev_id %d", __func__, wmi_tdls->vdev_id);
  717. return QDF_STATUS_SUCCESS;
  718. }
  719. /**
  720. * send_update_tdls_peer_state_cmd_tlv() - update TDLS peer state
  721. * @wmi_handle: wmi handle
  722. * @peerStateParams: TDLS peer state params
  723. *
  724. * Return: QDF_STATUS_SUCCESS for success or error code
  725. */
  726. static QDF_STATUS send_update_tdls_peer_state_cmd_tlv(wmi_unified_t wmi_handle,
  727. struct tdls_peer_state_params *peerStateParams,
  728. uint32_t *ch_mhz)
  729. {
  730. wmi_tdls_peer_update_cmd_fixed_param *cmd;
  731. wmi_tdls_peer_capabilities *peer_cap;
  732. wmi_channel *chan_info;
  733. wmi_buf_t wmi_buf;
  734. uint8_t *buf_ptr;
  735. uint32_t i;
  736. int32_t len = sizeof(wmi_tdls_peer_update_cmd_fixed_param) +
  737. sizeof(wmi_tdls_peer_capabilities);
  738. len += WMI_TLV_HDR_SIZE +
  739. sizeof(wmi_channel) * peerStateParams->peerCap.peerChanLen;
  740. wmi_buf = wmi_buf_alloc(wmi_handle, len);
  741. if (!wmi_buf) {
  742. return QDF_STATUS_E_FAILURE;
  743. }
  744. buf_ptr = (uint8_t *) wmi_buf_data(wmi_buf);
  745. cmd = (wmi_tdls_peer_update_cmd_fixed_param *) buf_ptr;
  746. WMITLV_SET_HDR(&cmd->tlv_header,
  747. WMITLV_TAG_STRUC_wmi_tdls_peer_update_cmd_fixed_param,
  748. WMITLV_GET_STRUCT_TLVLEN
  749. (wmi_tdls_peer_update_cmd_fixed_param));
  750. cmd->vdev_id = peerStateParams->vdevId;
  751. WMI_CHAR_ARRAY_TO_MAC_ADDR(peerStateParams->peerMacAddr,
  752. &cmd->peer_macaddr);
  753. cmd->peer_state = peerStateParams->peerState;
  754. WMI_LOGD("%s: vdev_id: %d, peerStateParams->peerMacAddr: %pM, "
  755. "peer_macaddr.mac_addr31to0: 0x%x, "
  756. "peer_macaddr.mac_addr47to32: 0x%x, peer_state: %d",
  757. __func__, cmd->vdev_id, peerStateParams->peerMacAddr,
  758. cmd->peer_macaddr.mac_addr31to0,
  759. cmd->peer_macaddr.mac_addr47to32, cmd->peer_state);
  760. buf_ptr += sizeof(wmi_tdls_peer_update_cmd_fixed_param);
  761. peer_cap = (wmi_tdls_peer_capabilities *) buf_ptr;
  762. WMITLV_SET_HDR(&peer_cap->tlv_header,
  763. WMITLV_TAG_STRUC_wmi_tdls_peer_capabilities,
  764. WMITLV_GET_STRUCT_TLVLEN(wmi_tdls_peer_capabilities));
  765. if ((peerStateParams->peerCap.peerUapsdQueue & 0x08) >> 3)
  766. WMI_SET_TDLS_PEER_VO_UAPSD(peer_cap);
  767. if ((peerStateParams->peerCap.peerUapsdQueue & 0x04) >> 2)
  768. WMI_SET_TDLS_PEER_VI_UAPSD(peer_cap);
  769. if ((peerStateParams->peerCap.peerUapsdQueue & 0x02) >> 1)
  770. WMI_SET_TDLS_PEER_BK_UAPSD(peer_cap);
  771. if (peerStateParams->peerCap.peerUapsdQueue & 0x01)
  772. WMI_SET_TDLS_PEER_BE_UAPSD(peer_cap);
  773. /* Ack and More Data Ack are sent as 0, so no need to set
  774. * but fill SP
  775. */
  776. WMI_SET_TDLS_PEER_SP_UAPSD(peer_cap,
  777. peerStateParams->peerCap.peerMaxSp);
  778. peer_cap->buff_sta_support =
  779. peerStateParams->peerCap.peerBuffStaSupport;
  780. peer_cap->off_chan_support =
  781. peerStateParams->peerCap.peerOffChanSupport;
  782. peer_cap->peer_curr_operclass =
  783. peerStateParams->peerCap.peerCurrOperClass;
  784. /* self curr operclass is not being used and so pass op class for
  785. * preferred off chan in it.
  786. */
  787. peer_cap->self_curr_operclass =
  788. peerStateParams->peerCap.opClassForPrefOffChan;
  789. peer_cap->peer_chan_len = peerStateParams->peerCap.peerChanLen;
  790. peer_cap->peer_operclass_len =
  791. peerStateParams->peerCap.peerOperClassLen;
  792. WMI_LOGD("%s: peer_operclass_len: %d",
  793. __func__, peer_cap->peer_operclass_len);
  794. for (i = 0; i < WMI_TDLS_MAX_SUPP_OPER_CLASSES; i++) {
  795. peer_cap->peer_operclass[i] =
  796. peerStateParams->peerCap.peerOperClass[i];
  797. WMI_LOGD("%s: peer_operclass[%d]: %d",
  798. __func__, i, peer_cap->peer_operclass[i]);
  799. }
  800. peer_cap->is_peer_responder = peerStateParams->peerCap.isPeerResponder;
  801. peer_cap->pref_offchan_num = peerStateParams->peerCap.prefOffChanNum;
  802. peer_cap->pref_offchan_bw =
  803. peerStateParams->peerCap.prefOffChanBandwidth;
  804. WMI_LOGD
  805. ("%s: peer_qos: 0x%x, buff_sta_support: %d, off_chan_support: %d, "
  806. "peer_curr_operclass: %d, self_curr_operclass: %d, peer_chan_len: "
  807. "%d, peer_operclass_len: %d, is_peer_responder: %d, pref_offchan_num:"
  808. " %d, pref_offchan_bw: %d",
  809. __func__, peer_cap->peer_qos, peer_cap->buff_sta_support,
  810. peer_cap->off_chan_support, peer_cap->peer_curr_operclass,
  811. peer_cap->self_curr_operclass, peer_cap->peer_chan_len,
  812. peer_cap->peer_operclass_len, peer_cap->is_peer_responder,
  813. peer_cap->pref_offchan_num, peer_cap->pref_offchan_bw);
  814. /* next fill variable size array of peer chan info */
  815. buf_ptr += sizeof(wmi_tdls_peer_capabilities);
  816. WMITLV_SET_HDR(buf_ptr,
  817. WMITLV_TAG_ARRAY_STRUC,
  818. sizeof(wmi_channel) *
  819. peerStateParams->peerCap.peerChanLen);
  820. chan_info = (wmi_channel *) (buf_ptr + WMI_TLV_HDR_SIZE);
  821. for (i = 0; i < peerStateParams->peerCap.peerChanLen; ++i) {
  822. WMITLV_SET_HDR(&chan_info->tlv_header,
  823. WMITLV_TAG_STRUC_wmi_channel,
  824. WMITLV_GET_STRUCT_TLVLEN(wmi_channel));
  825. chan_info->mhz = ch_mhz[i];
  826. chan_info->band_center_freq1 = chan_info->mhz;
  827. chan_info->band_center_freq2 = 0;
  828. WMI_LOGD("%s: chan[%d] = %u", __func__, i, chan_info->mhz);
  829. if (peerStateParams->peerCap.peerChan[i].dfsSet) {
  830. WMI_SET_CHANNEL_FLAG(chan_info, WMI_CHAN_FLAG_PASSIVE);
  831. WMI_LOGI("chan[%d] DFS[%d]\n",
  832. peerStateParams->peerCap.peerChan[i].chanId,
  833. peerStateParams->peerCap.peerChan[i].dfsSet);
  834. }
  835. if (chan_info->mhz < WMI_2_4_GHZ_MAX_FREQ)
  836. WMI_SET_CHANNEL_MODE(chan_info, MODE_11G);
  837. else
  838. WMI_SET_CHANNEL_MODE(chan_info, MODE_11A);
  839. WMI_SET_CHANNEL_MAX_TX_POWER(chan_info,
  840. peerStateParams->peerCap.
  841. peerChan[i].pwr);
  842. WMI_SET_CHANNEL_REG_POWER(chan_info,
  843. peerStateParams->peerCap.peerChan[i].
  844. pwr);
  845. WMI_LOGD("Channel TX power[%d] = %u: %d", i, chan_info->mhz,
  846. peerStateParams->peerCap.peerChan[i].pwr);
  847. chan_info++;
  848. }
  849. wmi_mtrace(WMI_TDLS_PEER_UPDATE_CMDID, cmd->vdev_id, 0);
  850. if (wmi_unified_cmd_send(wmi_handle, wmi_buf, len,
  851. WMI_TDLS_PEER_UPDATE_CMDID)) {
  852. WMI_LOGE("%s: failed to send tdls peer update state command",
  853. __func__);
  854. wmi_buf_free(wmi_buf);
  855. return QDF_STATUS_E_FAILURE;
  856. }
  857. return QDF_STATUS_SUCCESS;
  858. }
  859. /**
  860. * extract_vdev_tdls_ev_param_tlv() - extract vdev tdls param from event
  861. * @wmi_handle: wmi handle
  862. * @param evt_buf: pointer to event buffer
  863. * @param param: Pointer to hold vdev tdls param
  864. *
  865. * Return: QDF_STATUS_SUCCESS for success or error code
  866. */
  867. static QDF_STATUS extract_vdev_tdls_ev_param_tlv(wmi_unified_t wmi_handle,
  868. void *evt_buf, struct tdls_event_info *param)
  869. {
  870. WMI_TDLS_PEER_EVENTID_param_tlvs *param_buf;
  871. wmi_tdls_peer_event_fixed_param *evt;
  872. param_buf = (WMI_TDLS_PEER_EVENTID_param_tlvs *)evt_buf;
  873. if (!param_buf) {
  874. WMI_LOGE("%s: NULL param_buf", __func__);
  875. return QDF_STATUS_E_NULL_VALUE;
  876. }
  877. evt = param_buf->fixed_param;
  878. qdf_mem_zero(param, sizeof(*param));
  879. param->vdev_id = evt->vdev_id;
  880. WMI_MAC_ADDR_TO_CHAR_ARRAY(&evt->peer_macaddr,
  881. param->peermac.bytes);
  882. switch (evt->peer_status) {
  883. case WMI_TDLS_SHOULD_DISCOVER:
  884. param->message_type = TDLS_SHOULD_DISCOVER;
  885. break;
  886. case WMI_TDLS_SHOULD_TEARDOWN:
  887. param->message_type = TDLS_SHOULD_TEARDOWN;
  888. break;
  889. case WMI_TDLS_PEER_DISCONNECTED:
  890. param->message_type = TDLS_PEER_DISCONNECTED;
  891. break;
  892. case WMI_TDLS_CONNECTION_TRACKER_NOTIFICATION:
  893. param->message_type = TDLS_CONNECTION_TRACKER_NOTIFY;
  894. break;
  895. default:
  896. WMI_LOGE("%s: Discarding unknown tdls event %d from target",
  897. __func__, evt->peer_status);
  898. return QDF_STATUS_E_INVAL;
  899. };
  900. switch (evt->peer_reason) {
  901. case WMI_TDLS_TEARDOWN_REASON_TX:
  902. param->peer_reason = TDLS_TEARDOWN_TX;
  903. break;
  904. case WMI_TDLS_TEARDOWN_REASON_RSSI:
  905. param->peer_reason = TDLS_TEARDOWN_RSSI;
  906. break;
  907. case WMI_TDLS_TEARDOWN_REASON_SCAN:
  908. param->peer_reason = TDLS_TEARDOWN_SCAN;
  909. break;
  910. case WMI_TDLS_DISCONNECTED_REASON_PEER_DELETE:
  911. param->peer_reason = TDLS_DISCONNECTED_PEER_DELETE;
  912. break;
  913. case WMI_TDLS_TEARDOWN_REASON_PTR_TIMEOUT:
  914. param->peer_reason = TDLS_TEARDOWN_PTR_TIMEOUT;
  915. break;
  916. case WMI_TDLS_TEARDOWN_REASON_BAD_PTR:
  917. param->peer_reason = TDLS_TEARDOWN_BAD_PTR;
  918. break;
  919. case WMI_TDLS_TEARDOWN_REASON_NO_RESPONSE:
  920. param->peer_reason = TDLS_TEARDOWN_NO_RSP;
  921. break;
  922. case WMI_TDLS_ENTER_BUF_STA:
  923. param->peer_reason = TDLS_PEER_ENTER_BUF_STA;
  924. break;
  925. case WMI_TDLS_EXIT_BUF_STA:
  926. param->peer_reason = TDLS_PEER_EXIT_BUF_STA;
  927. break;
  928. case WMI_TDLS_ENTER_BT_BUSY_MODE:
  929. param->peer_reason = TDLS_ENTER_BT_BUSY;
  930. break;
  931. case WMI_TDLS_EXIT_BT_BUSY_MODE:
  932. param->peer_reason = TDLS_EXIT_BT_BUSY;
  933. break;
  934. case WMI_TDLS_SCAN_STARTED_EVENT:
  935. param->peer_reason = TDLS_SCAN_STARTED;
  936. break;
  937. case WMI_TDLS_SCAN_COMPLETED_EVENT:
  938. param->peer_reason = TDLS_SCAN_COMPLETED;
  939. break;
  940. default:
  941. WMI_LOGE("%s: unknown reason %d in tdls event %d from target",
  942. __func__, evt->peer_reason, evt->peer_status);
  943. return QDF_STATUS_E_INVAL;
  944. };
  945. WMI_LOGD("%s: tdls event, peer: %pM, type: 0x%x, reason: %d, vdev: %d",
  946. __func__, param->peermac.bytes, param->message_type,
  947. param->peer_reason, param->vdev_id);
  948. return QDF_STATUS_SUCCESS;
  949. }
  950. void wmi_tdls_attach_tlv(struct wmi_unified *wmi_handle)
  951. {
  952. struct wmi_ops *ops = wmi_handle->ops;
  953. ops->send_set_tdls_offchan_mode_cmd =
  954. send_set_tdls_offchan_mode_cmd_tlv;
  955. ops->send_update_fw_tdls_state_cmd =
  956. send_update_fw_tdls_state_cmd_tlv;
  957. ops->send_update_tdls_peer_state_cmd =
  958. send_update_tdls_peer_state_cmd_tlv;
  959. ops->extract_vdev_tdls_ev_param = extract_vdev_tdls_ev_param_tlv;
  960. }
  961. #endif /* CONVERGED_TDLS_ENABLE */
  962. /*
  963. * send_process_set_ie_info_cmd_tlv() - Function to send IE info to firmware
  964. * @wmi_handle: Pointer to WMi handle
  965. * @ie_data: Pointer for ie data
  966. *
  967. * This function sends IE information to firmware
  968. *
  969. * Return: QDF_STATUS_SUCCESS for success otherwise failure
  970. *
  971. */
  972. static QDF_STATUS send_process_set_ie_info_cmd_tlv(wmi_unified_t wmi_handle,
  973. struct vdev_ie_info_param *ie_info)
  974. {
  975. wmi_vdev_set_ie_cmd_fixed_param *cmd;
  976. wmi_buf_t buf;
  977. uint8_t *buf_ptr;
  978. uint32_t len, ie_len_aligned;
  979. QDF_STATUS ret;
  980. ie_len_aligned = roundup(ie_info->length, sizeof(uint32_t));
  981. /* Allocate memory for the WMI command */
  982. len = sizeof(*cmd) + WMI_TLV_HDR_SIZE + ie_len_aligned;
  983. buf = wmi_buf_alloc(wmi_handle, len);
  984. if (!buf) {
  985. return QDF_STATUS_E_NOMEM;
  986. }
  987. buf_ptr = wmi_buf_data(buf);
  988. qdf_mem_zero(buf_ptr, len);
  989. /* Populate the WMI command */
  990. cmd = (wmi_vdev_set_ie_cmd_fixed_param *)buf_ptr;
  991. WMITLV_SET_HDR(&cmd->tlv_header,
  992. WMITLV_TAG_STRUC_wmi_vdev_set_ie_cmd_fixed_param,
  993. WMITLV_GET_STRUCT_TLVLEN(
  994. wmi_vdev_set_ie_cmd_fixed_param));
  995. cmd->vdev_id = ie_info->vdev_id;
  996. cmd->ie_id = ie_info->ie_id;
  997. cmd->ie_len = ie_info->length;
  998. cmd->band = ie_info->band;
  999. WMI_LOGD(FL("IE:%d of size:%d sent for vdev:%d"), ie_info->ie_id,
  1000. ie_info->length, ie_info->vdev_id);
  1001. buf_ptr += sizeof(*cmd);
  1002. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_BYTE, ie_len_aligned);
  1003. buf_ptr += WMI_TLV_HDR_SIZE;
  1004. qdf_mem_copy(buf_ptr, ie_info->data, cmd->ie_len);
  1005. wmi_mtrace(WMI_VDEV_SET_IE_CMDID, cmd->vdev_id, 0);
  1006. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  1007. WMI_VDEV_SET_IE_CMDID);
  1008. if (QDF_IS_STATUS_ERROR(ret)) {
  1009. WMI_LOGE(FL("Failed to send set IE command ret = %d"), ret);
  1010. wmi_buf_free(buf);
  1011. }
  1012. return ret;
  1013. }
  1014. /**
  1015. * send_set_base_macaddr_indicate_cmd_tlv() - set base mac address in fw
  1016. * @wmi_handle: wmi handle
  1017. * @custom_addr: base mac address
  1018. *
  1019. * Return: QDF_STATUS_SUCCESS for success or error code
  1020. */
  1021. static QDF_STATUS send_set_base_macaddr_indicate_cmd_tlv(wmi_unified_t wmi_handle,
  1022. uint8_t *custom_addr)
  1023. {
  1024. wmi_pdev_set_base_macaddr_cmd_fixed_param *cmd;
  1025. wmi_buf_t buf;
  1026. int err;
  1027. buf = wmi_buf_alloc(wmi_handle, sizeof(*cmd));
  1028. if (!buf) {
  1029. return QDF_STATUS_E_NOMEM;
  1030. }
  1031. cmd = (wmi_pdev_set_base_macaddr_cmd_fixed_param *) wmi_buf_data(buf);
  1032. qdf_mem_zero(cmd, sizeof(*cmd));
  1033. WMITLV_SET_HDR(&cmd->tlv_header,
  1034. WMITLV_TAG_STRUC_wmi_pdev_set_base_macaddr_cmd_fixed_param,
  1035. WMITLV_GET_STRUCT_TLVLEN
  1036. (wmi_pdev_set_base_macaddr_cmd_fixed_param));
  1037. WMI_CHAR_ARRAY_TO_MAC_ADDR(custom_addr, &cmd->base_macaddr);
  1038. cmd->pdev_id = wmi_handle->ops->convert_pdev_id_host_to_target(
  1039. WMI_HOST_PDEV_ID_SOC);
  1040. wmi_mtrace(WMI_PDEV_SET_BASE_MACADDR_CMDID, NO_SESSION, 0);
  1041. err = wmi_unified_cmd_send(wmi_handle, buf,
  1042. sizeof(*cmd),
  1043. WMI_PDEV_SET_BASE_MACADDR_CMDID);
  1044. if (err) {
  1045. WMI_LOGE("Failed to send set_base_macaddr cmd");
  1046. wmi_buf_free(buf);
  1047. return QDF_STATUS_E_FAILURE;
  1048. }
  1049. return 0;
  1050. }
  1051. #ifdef WLAN_FEATURE_DISA
  1052. /**
  1053. * send_encrypt_decrypt_send_cmd() - send encrypt/decrypt cmd to fw
  1054. * @wmi_handle: wmi handle
  1055. * @params: encrypt/decrypt params
  1056. *
  1057. * Return: QDF_STATUS_SUCCESS for success or error code
  1058. */
  1059. static
  1060. QDF_STATUS send_encrypt_decrypt_send_cmd_tlv(wmi_unified_t wmi_handle,
  1061. struct disa_encrypt_decrypt_req_params *encrypt_decrypt_params)
  1062. {
  1063. wmi_vdev_encrypt_decrypt_data_req_cmd_fixed_param *cmd;
  1064. wmi_buf_t wmi_buf;
  1065. uint8_t *buf_ptr;
  1066. QDF_STATUS ret;
  1067. uint32_t len;
  1068. WMI_LOGD(FL("Send encrypt decrypt cmd"));
  1069. len = sizeof(*cmd) +
  1070. roundup(encrypt_decrypt_params->data_len, sizeof(uint32_t)) +
  1071. WMI_TLV_HDR_SIZE;
  1072. wmi_buf = wmi_buf_alloc(wmi_handle, len);
  1073. if (!wmi_buf) {
  1074. return QDF_STATUS_E_NOMEM;
  1075. }
  1076. buf_ptr = wmi_buf_data(wmi_buf);
  1077. cmd = (wmi_vdev_encrypt_decrypt_data_req_cmd_fixed_param *)buf_ptr;
  1078. WMITLV_SET_HDR(&cmd->tlv_header,
  1079. WMITLV_TAG_STRUC_wmi_vdev_encrypt_decrypt_data_req_cmd_fixed_param,
  1080. WMITLV_GET_STRUCT_TLVLEN(
  1081. wmi_vdev_encrypt_decrypt_data_req_cmd_fixed_param));
  1082. cmd->vdev_id = encrypt_decrypt_params->vdev_id;
  1083. cmd->key_flag = encrypt_decrypt_params->key_flag;
  1084. cmd->key_idx = encrypt_decrypt_params->key_idx;
  1085. cmd->key_cipher = encrypt_decrypt_params->key_cipher;
  1086. cmd->key_len = encrypt_decrypt_params->key_len;
  1087. cmd->key_txmic_len = encrypt_decrypt_params->key_txmic_len;
  1088. cmd->key_rxmic_len = encrypt_decrypt_params->key_rxmic_len;
  1089. qdf_mem_copy(cmd->key_data, encrypt_decrypt_params->key_data,
  1090. encrypt_decrypt_params->key_len);
  1091. qdf_mem_copy(cmd->mac_hdr, encrypt_decrypt_params->mac_header,
  1092. MAX_MAC_HEADER_LEN);
  1093. cmd->data_len = encrypt_decrypt_params->data_len;
  1094. if (cmd->data_len) {
  1095. buf_ptr += sizeof(*cmd);
  1096. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_BYTE,
  1097. roundup(encrypt_decrypt_params->data_len,
  1098. sizeof(uint32_t)));
  1099. buf_ptr += WMI_TLV_HDR_SIZE;
  1100. qdf_mem_copy(buf_ptr, encrypt_decrypt_params->data,
  1101. encrypt_decrypt_params->data_len);
  1102. }
  1103. /* This conversion is to facilitate data to FW in little endian */
  1104. cmd->pn[5] = encrypt_decrypt_params->pn[0];
  1105. cmd->pn[4] = encrypt_decrypt_params->pn[1];
  1106. cmd->pn[3] = encrypt_decrypt_params->pn[2];
  1107. cmd->pn[2] = encrypt_decrypt_params->pn[3];
  1108. cmd->pn[1] = encrypt_decrypt_params->pn[4];
  1109. cmd->pn[0] = encrypt_decrypt_params->pn[5];
  1110. wmi_mtrace(WMI_VDEV_ENCRYPT_DECRYPT_DATA_REQ_CMDID, cmd->vdev_id, 0);
  1111. ret = wmi_unified_cmd_send(wmi_handle,
  1112. wmi_buf, len,
  1113. WMI_VDEV_ENCRYPT_DECRYPT_DATA_REQ_CMDID);
  1114. if (QDF_IS_STATUS_ERROR(ret)) {
  1115. WMI_LOGE("Failed to send ENCRYPT DECRYPT cmd: %d", ret);
  1116. wmi_buf_free(wmi_buf);
  1117. }
  1118. return ret;
  1119. }
  1120. /**
  1121. * extract_encrypt_decrypt_resp_event_tlv() - extract encrypt decrypt resp
  1122. * params from event
  1123. * @wmi_handle: wmi handle
  1124. * @evt_buf: pointer to event buffer
  1125. * @resp: Pointer to hold resp parameters
  1126. *
  1127. * Return: QDF_STATUS_SUCCESS for success or error code
  1128. */
  1129. static
  1130. QDF_STATUS extract_encrypt_decrypt_resp_event_tlv(wmi_unified_t wmi_handle,
  1131. void *evt_buf, struct disa_encrypt_decrypt_resp_params *resp)
  1132. {
  1133. WMI_VDEV_ENCRYPT_DECRYPT_DATA_RESP_EVENTID_param_tlvs *param_buf;
  1134. wmi_vdev_encrypt_decrypt_data_resp_event_fixed_param *data_event;
  1135. param_buf = evt_buf;
  1136. if (!param_buf) {
  1137. WMI_LOGE("encrypt decrypt resp evt_buf is NULL");
  1138. return QDF_STATUS_E_INVAL;
  1139. }
  1140. data_event = param_buf->fixed_param;
  1141. resp->vdev_id = data_event->vdev_id;
  1142. resp->status = data_event->status;
  1143. if ((data_event->data_length > param_buf->num_enc80211_frame) ||
  1144. (data_event->data_length > WMI_SVC_MSG_MAX_SIZE - WMI_TLV_HDR_SIZE -
  1145. sizeof(*data_event))) {
  1146. WMI_LOGE("FW msg data_len %d more than TLV hdr %d",
  1147. data_event->data_length,
  1148. param_buf->num_enc80211_frame);
  1149. return QDF_STATUS_E_INVAL;
  1150. }
  1151. resp->data_len = data_event->data_length;
  1152. if (resp->data_len)
  1153. resp->data = (uint8_t *)param_buf->enc80211_frame;
  1154. return QDF_STATUS_SUCCESS;
  1155. }
  1156. void wmi_disa_attach_tlv(struct wmi_unified *wmi_handle)
  1157. {
  1158. struct wmi_ops *ops = wmi_handle->ops;
  1159. ops->send_encrypt_decrypt_send_cmd =
  1160. send_encrypt_decrypt_send_cmd_tlv;
  1161. ops->extract_encrypt_decrypt_resp_event =
  1162. extract_encrypt_decrypt_resp_event_tlv;
  1163. }
  1164. #endif /* WLAN_FEATURE_DISA */
  1165. /**
  1166. * send_sar_limit_cmd_tlv() - send sar limit cmd to fw
  1167. * @wmi_handle: wmi handle
  1168. * @params: sar limit params
  1169. *
  1170. * Return: QDF_STATUS_SUCCESS for success or error code
  1171. */
  1172. static QDF_STATUS send_sar_limit_cmd_tlv(wmi_unified_t wmi_handle,
  1173. struct sar_limit_cmd_params *sar_limit_params)
  1174. {
  1175. wmi_buf_t buf;
  1176. QDF_STATUS qdf_status;
  1177. wmi_sar_limits_cmd_fixed_param *cmd;
  1178. int i;
  1179. uint8_t *buf_ptr;
  1180. wmi_sar_limit_cmd_row *wmi_sar_rows_list;
  1181. struct sar_limit_cmd_row *sar_rows_list;
  1182. uint32_t len = sizeof(*cmd) + WMI_TLV_HDR_SIZE;
  1183. len += sizeof(wmi_sar_limit_cmd_row) * sar_limit_params->num_limit_rows;
  1184. buf = wmi_buf_alloc(wmi_handle, len);
  1185. if (!buf) {
  1186. qdf_status = QDF_STATUS_E_NOMEM;
  1187. goto end;
  1188. }
  1189. buf_ptr = (uint8_t *) wmi_buf_data(buf);
  1190. cmd = (wmi_sar_limits_cmd_fixed_param *) buf_ptr;
  1191. WMITLV_SET_HDR(&cmd->tlv_header,
  1192. WMITLV_TAG_STRUC_wmi_sar_limits_cmd_fixed_param,
  1193. WMITLV_GET_STRUCT_TLVLEN
  1194. (wmi_sar_limits_cmd_fixed_param));
  1195. cmd->sar_enable = sar_limit_params->sar_enable;
  1196. cmd->commit_limits = sar_limit_params->commit_limits;
  1197. cmd->num_limit_rows = sar_limit_params->num_limit_rows;
  1198. WMI_LOGD("no of sar rows = %d, len = %d",
  1199. sar_limit_params->num_limit_rows, len);
  1200. buf_ptr += sizeof(*cmd);
  1201. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
  1202. sizeof(wmi_sar_limit_cmd_row) *
  1203. sar_limit_params->num_limit_rows);
  1204. if (cmd->num_limit_rows == 0)
  1205. goto send_sar_limits;
  1206. wmi_sar_rows_list = (wmi_sar_limit_cmd_row *)
  1207. (buf_ptr + WMI_TLV_HDR_SIZE);
  1208. sar_rows_list = sar_limit_params->sar_limit_row_list;
  1209. for (i = 0; i < sar_limit_params->num_limit_rows; i++) {
  1210. WMITLV_SET_HDR(&wmi_sar_rows_list->tlv_header,
  1211. WMITLV_TAG_STRUC_wmi_sar_limit_cmd_row,
  1212. WMITLV_GET_STRUCT_TLVLEN(wmi_sar_limit_cmd_row));
  1213. wmi_sar_rows_list->band_id = sar_rows_list->band_id;
  1214. wmi_sar_rows_list->chain_id = sar_rows_list->chain_id;
  1215. wmi_sar_rows_list->mod_id = sar_rows_list->mod_id;
  1216. wmi_sar_rows_list->limit_value = sar_rows_list->limit_value;
  1217. wmi_sar_rows_list->validity_bitmap =
  1218. sar_rows_list->validity_bitmap;
  1219. WMI_LOGD("row %d, band_id = %d, chain_id = %d, mod_id = %d, limit_value = %d, validity_bitmap = %d",
  1220. i, wmi_sar_rows_list->band_id,
  1221. wmi_sar_rows_list->chain_id,
  1222. wmi_sar_rows_list->mod_id,
  1223. wmi_sar_rows_list->limit_value,
  1224. wmi_sar_rows_list->validity_bitmap);
  1225. sar_rows_list++;
  1226. wmi_sar_rows_list++;
  1227. }
  1228. send_sar_limits:
  1229. wmi_mtrace(WMI_SAR_LIMITS_CMDID, NO_SESSION, 0);
  1230. qdf_status = wmi_unified_cmd_send(wmi_handle, buf, len,
  1231. WMI_SAR_LIMITS_CMDID);
  1232. if (QDF_IS_STATUS_ERROR(qdf_status)) {
  1233. WMI_LOGE("Failed to send WMI_SAR_LIMITS_CMDID");
  1234. wmi_buf_free(buf);
  1235. }
  1236. end:
  1237. return qdf_status;
  1238. }
  1239. static QDF_STATUS get_sar_limit_cmd_tlv(wmi_unified_t wmi_handle)
  1240. {
  1241. wmi_sar_get_limits_cmd_fixed_param *cmd;
  1242. wmi_buf_t wmi_buf;
  1243. uint32_t len;
  1244. QDF_STATUS status;
  1245. WMI_LOGD(FL("Enter"));
  1246. len = sizeof(*cmd);
  1247. wmi_buf = wmi_buf_alloc(wmi_handle, len);
  1248. if (!wmi_buf) {
  1249. return QDF_STATUS_E_NOMEM;
  1250. }
  1251. cmd = (wmi_sar_get_limits_cmd_fixed_param *)wmi_buf_data(wmi_buf);
  1252. WMITLV_SET_HDR(&cmd->tlv_header,
  1253. WMITLV_TAG_STRUC_wmi_sar_get_limits_cmd_fixed_param,
  1254. WMITLV_GET_STRUCT_TLVLEN
  1255. (wmi_sar_get_limits_cmd_fixed_param));
  1256. cmd->reserved = 0;
  1257. wmi_mtrace(WMI_SAR_GET_LIMITS_CMDID, NO_SESSION, 0);
  1258. status = wmi_unified_cmd_send(wmi_handle, wmi_buf, len,
  1259. WMI_SAR_GET_LIMITS_CMDID);
  1260. if (QDF_IS_STATUS_ERROR(status)) {
  1261. WMI_LOGE(FL("Failed to send get SAR limit cmd: %d"), status);
  1262. wmi_buf_free(wmi_buf);
  1263. }
  1264. WMI_LOGD(FL("Exit"));
  1265. return status;
  1266. }
  1267. /**
  1268. * wmi_sar2_result_string() - return string conversion of sar2 result
  1269. * @result: sar2 result value
  1270. *
  1271. * This utility function helps log string conversion of sar2 result.
  1272. *
  1273. * Return: string conversion of sar 2 result, if match found;
  1274. * "Unknown response" otherwise.
  1275. */
  1276. static const char *wmi_sar2_result_string(uint32_t result)
  1277. {
  1278. switch (result) {
  1279. CASE_RETURN_STRING(WMI_SAR2_SUCCESS);
  1280. CASE_RETURN_STRING(WMI_SAR2_INVALID_ANTENNA_INDEX);
  1281. CASE_RETURN_STRING(WMI_SAR2_INVALID_TABLE_INDEX);
  1282. CASE_RETURN_STRING(WMI_SAR2_STATE_ERROR);
  1283. CASE_RETURN_STRING(WMI_SAR2_BDF_NO_TABLE);
  1284. default:
  1285. return "Unknown response";
  1286. }
  1287. }
  1288. /**
  1289. * extract_sar2_result_event_tlv() - process sar response event from FW.
  1290. * @handle: wma handle
  1291. * @event: event buffer
  1292. * @len: buffer length
  1293. *
  1294. * Return: 0 for success or error code
  1295. */
  1296. static QDF_STATUS extract_sar2_result_event_tlv(void *handle,
  1297. uint8_t *event,
  1298. uint32_t len)
  1299. {
  1300. wmi_sar2_result_event_fixed_param *sar2_fixed_param;
  1301. WMI_SAR2_RESULT_EVENTID_param_tlvs *param_buf =
  1302. (WMI_SAR2_RESULT_EVENTID_param_tlvs *)event;
  1303. if (!param_buf) {
  1304. WMI_LOGI("Invalid sar2 result event buffer");
  1305. return QDF_STATUS_E_INVAL;
  1306. }
  1307. sar2_fixed_param = param_buf->fixed_param;
  1308. if (!sar2_fixed_param) {
  1309. WMI_LOGI("Invalid sar2 result event fixed param buffer");
  1310. return QDF_STATUS_E_INVAL;
  1311. }
  1312. WMI_LOGI("SAR2 result: %s",
  1313. wmi_sar2_result_string(sar2_fixed_param->result));
  1314. return QDF_STATUS_SUCCESS;
  1315. }
  1316. static QDF_STATUS extract_sar_limit_event_tlv(wmi_unified_t wmi_handle,
  1317. uint8_t *evt_buf,
  1318. struct sar_limit_event *event)
  1319. {
  1320. wmi_sar_get_limits_event_fixed_param *fixed_param;
  1321. WMI_SAR_GET_LIMITS_EVENTID_param_tlvs *param_buf;
  1322. wmi_sar_get_limit_event_row *row_in;
  1323. struct sar_limit_event_row *row_out;
  1324. uint32_t row;
  1325. if (!evt_buf) {
  1326. WMI_LOGE(FL("input event is NULL"));
  1327. return QDF_STATUS_E_INVAL;
  1328. }
  1329. if (!event) {
  1330. WMI_LOGE(FL("output event is NULL"));
  1331. return QDF_STATUS_E_INVAL;
  1332. }
  1333. param_buf = (WMI_SAR_GET_LIMITS_EVENTID_param_tlvs *)evt_buf;
  1334. fixed_param = param_buf->fixed_param;
  1335. if (!fixed_param) {
  1336. WMI_LOGE(FL("Invalid fixed param"));
  1337. return QDF_STATUS_E_INVAL;
  1338. }
  1339. event->sar_enable = fixed_param->sar_enable;
  1340. event->num_limit_rows = fixed_param->num_limit_rows;
  1341. if (event->num_limit_rows > param_buf->num_sar_get_limits) {
  1342. WMI_LOGE(FL("Num rows %d exceeds sar_get_limits rows len %d"),
  1343. event->num_limit_rows, param_buf->num_sar_get_limits);
  1344. return QDF_STATUS_E_INVAL;
  1345. }
  1346. if (event->num_limit_rows > MAX_SAR_LIMIT_ROWS_SUPPORTED) {
  1347. QDF_ASSERT(0);
  1348. WMI_LOGE(FL("Num rows %d exceeds max of %d"),
  1349. event->num_limit_rows,
  1350. MAX_SAR_LIMIT_ROWS_SUPPORTED);
  1351. event->num_limit_rows = MAX_SAR_LIMIT_ROWS_SUPPORTED;
  1352. }
  1353. row_in = param_buf->sar_get_limits;
  1354. if (!row_in) {
  1355. WMI_LOGD("sar_get_limits is NULL");
  1356. } else {
  1357. row_out = &event->sar_limit_row[0];
  1358. for (row = 0; row < event->num_limit_rows; row++) {
  1359. row_out->band_id = row_in->band_id;
  1360. row_out->chain_id = row_in->chain_id;
  1361. row_out->mod_id = row_in->mod_id;
  1362. row_out->limit_value = row_in->limit_value;
  1363. row_out++;
  1364. row_in++;
  1365. }
  1366. }
  1367. return QDF_STATUS_SUCCESS;
  1368. }
  1369. /**
  1370. * send_set_del_pmkid_cache_cmd_tlv() - send wmi cmd of set del pmkid
  1371. * @wmi_handle: wmi handler
  1372. * @pmk_info: pointer to PMK cache entry
  1373. * @vdev_id: vdev id
  1374. *
  1375. * Return: 0 for success and non zero for failure
  1376. */
  1377. static QDF_STATUS send_set_del_pmkid_cache_cmd_tlv(wmi_unified_t wmi_handle,
  1378. struct wmi_unified_pmk_cache *pmk_info)
  1379. {
  1380. wmi_pdev_update_pmk_cache_cmd_fixed_param *cmd;
  1381. wmi_buf_t buf;
  1382. QDF_STATUS status;
  1383. uint8_t *buf_ptr;
  1384. wmi_pmk_cache *pmksa;
  1385. uint32_t len = sizeof(*cmd);
  1386. if (pmk_info->pmk_len)
  1387. len += WMI_TLV_HDR_SIZE + sizeof(*pmksa);
  1388. buf = wmi_buf_alloc(wmi_handle, len);
  1389. if (!buf) {
  1390. return QDF_STATUS_E_NOMEM;
  1391. }
  1392. buf_ptr = (uint8_t *) wmi_buf_data(buf);
  1393. cmd = (wmi_pdev_update_pmk_cache_cmd_fixed_param *) buf_ptr;
  1394. WMITLV_SET_HDR(&cmd->tlv_header,
  1395. WMITLV_TAG_STRUC_wmi_pdev_update_pmk_cache_cmd_fixed_param,
  1396. WMITLV_GET_STRUCT_TLVLEN(
  1397. wmi_pdev_update_pmk_cache_cmd_fixed_param));
  1398. cmd->vdev_id = pmk_info->session_id;
  1399. /* If pmk_info->pmk_len is 0, this is a flush request */
  1400. if (!pmk_info->pmk_len) {
  1401. cmd->op_flag = WMI_PMK_CACHE_OP_FLAG_FLUSH_ALL;
  1402. cmd->num_cache = 0;
  1403. goto send_cmd;
  1404. }
  1405. cmd->num_cache = 1;
  1406. buf_ptr += sizeof(*cmd);
  1407. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
  1408. sizeof(*pmksa));
  1409. buf_ptr += WMI_TLV_HDR_SIZE;
  1410. pmksa = (wmi_pmk_cache *)buf_ptr;
  1411. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_STRUC_wmi_pmk_cache,
  1412. WMITLV_GET_STRUCT_TLVLEN
  1413. (wmi_pmk_cache));
  1414. pmksa->pmk_len = pmk_info->pmk_len;
  1415. qdf_mem_copy(pmksa->pmk, pmk_info->pmk, pmksa->pmk_len);
  1416. pmksa->pmkid_len = pmk_info->pmkid_len;
  1417. qdf_mem_copy(pmksa->pmkid, pmk_info->pmkid, pmksa->pmkid_len);
  1418. qdf_mem_copy(&(pmksa->bssid), &(pmk_info->bssid), sizeof(wmi_mac_addr));
  1419. pmksa->ssid.ssid_len = pmk_info->ssid.length;
  1420. qdf_mem_copy(&(pmksa->ssid.ssid), &(pmk_info->ssid.mac_ssid),
  1421. pmksa->ssid.ssid_len);
  1422. pmksa->cache_id = pmk_info->cache_id;
  1423. pmksa->cat_flag = pmk_info->cat_flag;
  1424. pmksa->action_flag = pmk_info->action_flag;
  1425. send_cmd:
  1426. wmi_mtrace(WMI_PDEV_UPDATE_PMK_CACHE_CMDID, cmd->vdev_id, 0);
  1427. status = wmi_unified_cmd_send(wmi_handle, buf, len,
  1428. WMI_PDEV_UPDATE_PMK_CACHE_CMDID);
  1429. if (status != QDF_STATUS_SUCCESS) {
  1430. WMI_LOGE("%s: failed to send set del pmkid cache command %d",
  1431. __func__, status);
  1432. wmi_buf_free(buf);
  1433. }
  1434. return status;
  1435. }
  1436. /**
  1437. * send_del_ts_cmd_tlv() - send DELTS request to fw
  1438. * @wmi_handle: wmi handle
  1439. * @msg: delts params
  1440. *
  1441. * Return: CDF status
  1442. */
  1443. static QDF_STATUS send_del_ts_cmd_tlv(wmi_unified_t wmi_handle, uint8_t vdev_id,
  1444. uint8_t ac)
  1445. {
  1446. wmi_vdev_wmm_delts_cmd_fixed_param *cmd;
  1447. wmi_buf_t buf;
  1448. int32_t len = sizeof(*cmd);
  1449. buf = wmi_buf_alloc(wmi_handle, len);
  1450. if (!buf) {
  1451. return QDF_STATUS_E_NOMEM;
  1452. }
  1453. cmd = (wmi_vdev_wmm_delts_cmd_fixed_param *) wmi_buf_data(buf);
  1454. WMITLV_SET_HDR(&cmd->tlv_header,
  1455. WMITLV_TAG_STRUC_wmi_vdev_wmm_delts_cmd_fixed_param,
  1456. WMITLV_GET_STRUCT_TLVLEN
  1457. (wmi_vdev_wmm_delts_cmd_fixed_param));
  1458. cmd->vdev_id = vdev_id;
  1459. cmd->ac = ac;
  1460. WMI_LOGD("Delts vdev:%d, ac:%d, %s:%d",
  1461. cmd->vdev_id, cmd->ac, __func__, __LINE__);
  1462. wmi_mtrace(WMI_VDEV_WMM_DELTS_CMDID, cmd->vdev_id, 0);
  1463. if (wmi_unified_cmd_send(wmi_handle, buf, len,
  1464. WMI_VDEV_WMM_DELTS_CMDID)) {
  1465. WMI_LOGP("%s: Failed to send vdev DELTS command", __func__);
  1466. wmi_buf_free(buf);
  1467. return QDF_STATUS_E_FAILURE;
  1468. }
  1469. return QDF_STATUS_SUCCESS;
  1470. }
  1471. /**
  1472. * send_aggr_qos_cmd_tlv() - send aggr qos request to fw
  1473. * @wmi_handle: handle to wmi
  1474. * @aggr_qos_rsp_msg - combined struct for all ADD_TS requests.
  1475. *
  1476. * A function to handle WMI_AGGR_QOS_REQ. This will send out
  1477. * ADD_TS requestes to firmware in loop for all the ACs with
  1478. * active flow.
  1479. *
  1480. * Return: CDF status
  1481. */
  1482. static QDF_STATUS send_aggr_qos_cmd_tlv(wmi_unified_t wmi_handle,
  1483. struct aggr_add_ts_param *aggr_qos_rsp_msg)
  1484. {
  1485. int i = 0;
  1486. wmi_vdev_wmm_addts_cmd_fixed_param *cmd;
  1487. wmi_buf_t buf;
  1488. int32_t len = sizeof(*cmd);
  1489. for (i = 0; i < WMI_QOS_NUM_AC_MAX; i++) {
  1490. /* if flow in this AC is active */
  1491. if (((1 << i) & aggr_qos_rsp_msg->tspecIdx)) {
  1492. /*
  1493. * as per implementation of wma_add_ts_req() we
  1494. * are not waiting any response from firmware so
  1495. * apart from sending ADDTS to firmware just send
  1496. * success to upper layers
  1497. */
  1498. aggr_qos_rsp_msg->status[i] = QDF_STATUS_SUCCESS;
  1499. buf = wmi_buf_alloc(wmi_handle, len);
  1500. if (!buf) {
  1501. return QDF_STATUS_E_NOMEM;
  1502. }
  1503. cmd = (wmi_vdev_wmm_addts_cmd_fixed_param *)
  1504. wmi_buf_data(buf);
  1505. WMITLV_SET_HDR(&cmd->tlv_header,
  1506. WMITLV_TAG_STRUC_wmi_vdev_wmm_addts_cmd_fixed_param,
  1507. WMITLV_GET_STRUCT_TLVLEN
  1508. (wmi_vdev_wmm_addts_cmd_fixed_param));
  1509. cmd->vdev_id = aggr_qos_rsp_msg->vdev_id;
  1510. cmd->ac =
  1511. WMI_TID_TO_AC(aggr_qos_rsp_msg->tspec[i].tsinfo.
  1512. traffic.userPrio);
  1513. cmd->medium_time_us =
  1514. aggr_qos_rsp_msg->tspec[i].mediumTime * 32;
  1515. cmd->downgrade_type = WMM_AC_DOWNGRADE_DEPRIO;
  1516. WMI_LOGD("%s:%d: Addts vdev:%d, ac:%d, mediumTime:%d downgrade_type:%d",
  1517. __func__, __LINE__, cmd->vdev_id, cmd->ac,
  1518. cmd->medium_time_us, cmd->downgrade_type);
  1519. wmi_mtrace(WMI_VDEV_WMM_ADDTS_CMDID, cmd->vdev_id, 0);
  1520. if (wmi_unified_cmd_send(wmi_handle, buf, len,
  1521. WMI_VDEV_WMM_ADDTS_CMDID)) {
  1522. WMI_LOGP("%s: Failed to send vdev ADDTS command",
  1523. __func__);
  1524. aggr_qos_rsp_msg->status[i] =
  1525. QDF_STATUS_E_FAILURE;
  1526. wmi_buf_free(buf);
  1527. return QDF_STATUS_E_FAILURE;
  1528. }
  1529. }
  1530. }
  1531. return QDF_STATUS_SUCCESS;
  1532. }
  1533. /**
  1534. * send_add_ts_cmd_tlv() - send ADDTS request to fw
  1535. * @wmi_handle: wmi handle
  1536. * @msg: ADDTS params
  1537. *
  1538. * Return: CDF status
  1539. */
  1540. static QDF_STATUS send_add_ts_cmd_tlv(wmi_unified_t wmi_handle,
  1541. struct add_ts_param *msg)
  1542. {
  1543. wmi_vdev_wmm_addts_cmd_fixed_param *cmd;
  1544. wmi_buf_t buf;
  1545. int32_t len = sizeof(*cmd);
  1546. msg->status = QDF_STATUS_SUCCESS;
  1547. buf = wmi_buf_alloc(wmi_handle, len);
  1548. if (!buf) {
  1549. return QDF_STATUS_E_NOMEM;
  1550. }
  1551. cmd = (wmi_vdev_wmm_addts_cmd_fixed_param *) wmi_buf_data(buf);
  1552. WMITLV_SET_HDR(&cmd->tlv_header,
  1553. WMITLV_TAG_STRUC_wmi_vdev_wmm_addts_cmd_fixed_param,
  1554. WMITLV_GET_STRUCT_TLVLEN
  1555. (wmi_vdev_wmm_addts_cmd_fixed_param));
  1556. cmd->vdev_id = msg->sme_session_id;
  1557. cmd->ac = msg->tspec.tsinfo.traffic.userPrio;
  1558. cmd->medium_time_us = msg->tspec.mediumTime * 32;
  1559. cmd->downgrade_type = WMM_AC_DOWNGRADE_DROP;
  1560. WMI_LOGD("Addts vdev:%d, ac:%d, mediumTime:%d, downgrade_type:%d %s:%d",
  1561. cmd->vdev_id, cmd->ac, cmd->medium_time_us,
  1562. cmd->downgrade_type, __func__, __LINE__);
  1563. wmi_mtrace(WMI_VDEV_WMM_ADDTS_CMDID, cmd->vdev_id, 0);
  1564. if (wmi_unified_cmd_send(wmi_handle, buf, len,
  1565. WMI_VDEV_WMM_ADDTS_CMDID)) {
  1566. WMI_LOGP("%s: Failed to send vdev ADDTS command", __func__);
  1567. msg->status = QDF_STATUS_E_FAILURE;
  1568. wmi_buf_free(buf);
  1569. return QDF_STATUS_E_FAILURE;
  1570. }
  1571. return QDF_STATUS_SUCCESS;
  1572. }
  1573. /**
  1574. * send_process_add_periodic_tx_ptrn_cmd_tlv - add periodic tx ptrn
  1575. * @wmi_handle: wmi handle
  1576. * @pAddPeriodicTxPtrnParams: tx ptrn params
  1577. *
  1578. * Retrun: CDF status
  1579. */
  1580. static QDF_STATUS send_process_add_periodic_tx_ptrn_cmd_tlv(wmi_unified_t wmi_handle,
  1581. struct periodic_tx_pattern *
  1582. pAddPeriodicTxPtrnParams,
  1583. uint8_t vdev_id)
  1584. {
  1585. WMI_ADD_PROACTIVE_ARP_RSP_PATTERN_CMD_fixed_param *cmd;
  1586. wmi_buf_t wmi_buf;
  1587. uint32_t len;
  1588. uint8_t *buf_ptr;
  1589. uint32_t ptrn_len, ptrn_len_aligned;
  1590. int j;
  1591. ptrn_len = pAddPeriodicTxPtrnParams->ucPtrnSize;
  1592. ptrn_len_aligned = roundup(ptrn_len, sizeof(uint32_t));
  1593. len = sizeof(WMI_ADD_PROACTIVE_ARP_RSP_PATTERN_CMD_fixed_param) +
  1594. WMI_TLV_HDR_SIZE + ptrn_len_aligned;
  1595. wmi_buf = wmi_buf_alloc(wmi_handle, len);
  1596. if (!wmi_buf) {
  1597. return QDF_STATUS_E_NOMEM;
  1598. }
  1599. buf_ptr = (uint8_t *) wmi_buf_data(wmi_buf);
  1600. cmd = (WMI_ADD_PROACTIVE_ARP_RSP_PATTERN_CMD_fixed_param *) buf_ptr;
  1601. WMITLV_SET_HDR(&cmd->tlv_header,
  1602. WMITLV_TAG_STRUC_WMI_ADD_PROACTIVE_ARP_RSP_PATTERN_CMD_fixed_param,
  1603. WMITLV_GET_STRUCT_TLVLEN
  1604. (WMI_ADD_PROACTIVE_ARP_RSP_PATTERN_CMD_fixed_param));
  1605. /* Pass the pattern id to delete for the corresponding vdev id */
  1606. cmd->vdev_id = vdev_id;
  1607. cmd->pattern_id = pAddPeriodicTxPtrnParams->ucPtrnId;
  1608. cmd->timeout = pAddPeriodicTxPtrnParams->usPtrnIntervalMs;
  1609. cmd->length = pAddPeriodicTxPtrnParams->ucPtrnSize;
  1610. /* Pattern info */
  1611. buf_ptr += sizeof(WMI_ADD_PROACTIVE_ARP_RSP_PATTERN_CMD_fixed_param);
  1612. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_BYTE, ptrn_len_aligned);
  1613. buf_ptr += WMI_TLV_HDR_SIZE;
  1614. qdf_mem_copy(buf_ptr, pAddPeriodicTxPtrnParams->ucPattern, ptrn_len);
  1615. for (j = 0; j < pAddPeriodicTxPtrnParams->ucPtrnSize; j++)
  1616. WMI_LOGD("%s: Add Ptrn: %02x", __func__, buf_ptr[j] & 0xff);
  1617. WMI_LOGD("%s: Add ptrn id: %d vdev_id: %d",
  1618. __func__, cmd->pattern_id, cmd->vdev_id);
  1619. wmi_mtrace(WMI_ADD_PROACTIVE_ARP_RSP_PATTERN_CMDID, cmd->vdev_id, 0);
  1620. if (wmi_unified_cmd_send(wmi_handle, wmi_buf, len,
  1621. WMI_ADD_PROACTIVE_ARP_RSP_PATTERN_CMDID)) {
  1622. WMI_LOGE("%s: failed to add pattern set state command",
  1623. __func__);
  1624. wmi_buf_free(wmi_buf);
  1625. return QDF_STATUS_E_FAILURE;
  1626. }
  1627. return QDF_STATUS_SUCCESS;
  1628. }
  1629. /**
  1630. * send_process_del_periodic_tx_ptrn_cmd_tlv - del periodic tx ptrn
  1631. * @wmi_handle: wmi handle
  1632. * @vdev_id: vdev id
  1633. * @pattern_id: pattern id
  1634. *
  1635. * Retrun: CDF status
  1636. */
  1637. static QDF_STATUS send_process_del_periodic_tx_ptrn_cmd_tlv(wmi_unified_t wmi_handle,
  1638. uint8_t vdev_id,
  1639. uint8_t pattern_id)
  1640. {
  1641. WMI_DEL_PROACTIVE_ARP_RSP_PATTERN_CMD_fixed_param *cmd;
  1642. wmi_buf_t wmi_buf;
  1643. uint32_t len =
  1644. sizeof(WMI_DEL_PROACTIVE_ARP_RSP_PATTERN_CMD_fixed_param);
  1645. wmi_buf = wmi_buf_alloc(wmi_handle, len);
  1646. if (!wmi_buf) {
  1647. return QDF_STATUS_E_NOMEM;
  1648. }
  1649. cmd = (WMI_DEL_PROACTIVE_ARP_RSP_PATTERN_CMD_fixed_param *)
  1650. wmi_buf_data(wmi_buf);
  1651. WMITLV_SET_HDR(&cmd->tlv_header,
  1652. WMITLV_TAG_STRUC_WMI_DEL_PROACTIVE_ARP_RSP_PATTERN_CMD_fixed_param,
  1653. WMITLV_GET_STRUCT_TLVLEN
  1654. (WMI_DEL_PROACTIVE_ARP_RSP_PATTERN_CMD_fixed_param));
  1655. /* Pass the pattern id to delete for the corresponding vdev id */
  1656. cmd->vdev_id = vdev_id;
  1657. cmd->pattern_id = pattern_id;
  1658. WMI_LOGD("%s: Del ptrn id: %d vdev_id: %d",
  1659. __func__, cmd->pattern_id, cmd->vdev_id);
  1660. wmi_mtrace(WMI_DEL_PROACTIVE_ARP_RSP_PATTERN_CMDID, cmd->vdev_id, 0);
  1661. if (wmi_unified_cmd_send(wmi_handle, wmi_buf, len,
  1662. WMI_DEL_PROACTIVE_ARP_RSP_PATTERN_CMDID)) {
  1663. WMI_LOGE("%s: failed to send del pattern command", __func__);
  1664. wmi_buf_free(wmi_buf);
  1665. return QDF_STATUS_E_FAILURE;
  1666. }
  1667. return QDF_STATUS_SUCCESS;
  1668. }
  1669. /**
  1670. * send_set_auto_shutdown_timer_cmd_tlv() - sets auto shutdown timer in firmware
  1671. * @wmi_handle: wmi handle
  1672. * @timer_val: auto shutdown timer value
  1673. *
  1674. * Return: CDF status
  1675. */
  1676. static QDF_STATUS send_set_auto_shutdown_timer_cmd_tlv(wmi_unified_t wmi_handle,
  1677. uint32_t timer_val)
  1678. {
  1679. QDF_STATUS status;
  1680. wmi_buf_t buf = NULL;
  1681. uint8_t *buf_ptr;
  1682. wmi_host_auto_shutdown_cfg_cmd_fixed_param *wmi_auto_sh_cmd;
  1683. int len = sizeof(wmi_host_auto_shutdown_cfg_cmd_fixed_param);
  1684. WMI_LOGD("%s: Set WMI_HOST_AUTO_SHUTDOWN_CFG_CMDID:TIMER_VAL=%d",
  1685. __func__, timer_val);
  1686. buf = wmi_buf_alloc(wmi_handle, len);
  1687. if (!buf) {
  1688. return QDF_STATUS_E_NOMEM;
  1689. }
  1690. buf_ptr = (uint8_t *) wmi_buf_data(buf);
  1691. wmi_auto_sh_cmd =
  1692. (wmi_host_auto_shutdown_cfg_cmd_fixed_param *) buf_ptr;
  1693. wmi_auto_sh_cmd->timer_value = timer_val;
  1694. WMITLV_SET_HDR(&wmi_auto_sh_cmd->tlv_header,
  1695. WMITLV_TAG_STRUC_wmi_host_auto_shutdown_cfg_cmd_fixed_param,
  1696. WMITLV_GET_STRUCT_TLVLEN
  1697. (wmi_host_auto_shutdown_cfg_cmd_fixed_param));
  1698. wmi_mtrace(WMI_HOST_AUTO_SHUTDOWN_CFG_CMDID, NO_SESSION, 0);
  1699. status = wmi_unified_cmd_send(wmi_handle, buf,
  1700. len, WMI_HOST_AUTO_SHUTDOWN_CFG_CMDID);
  1701. if (QDF_IS_STATUS_ERROR(status)) {
  1702. WMI_LOGE("%s: WMI_HOST_AUTO_SHUTDOWN_CFG_CMDID Err %d",
  1703. __func__, status);
  1704. wmi_buf_free(buf);
  1705. }
  1706. return status;
  1707. }
  1708. /**
  1709. * send_set_led_flashing_cmd_tlv() - set led flashing in fw
  1710. * @wmi_handle: wmi handle
  1711. * @flashing: flashing request
  1712. *
  1713. * Return: CDF status
  1714. */
  1715. static QDF_STATUS send_set_led_flashing_cmd_tlv(wmi_unified_t wmi_handle,
  1716. struct flashing_req_params *flashing)
  1717. {
  1718. wmi_set_led_flashing_cmd_fixed_param *cmd;
  1719. QDF_STATUS status;
  1720. wmi_buf_t buf;
  1721. uint8_t *buf_ptr;
  1722. int32_t len = sizeof(wmi_set_led_flashing_cmd_fixed_param);
  1723. buf = wmi_buf_alloc(wmi_handle, len);
  1724. if (!buf) {
  1725. return QDF_STATUS_E_NOMEM;
  1726. }
  1727. buf_ptr = (uint8_t *) wmi_buf_data(buf);
  1728. cmd = (wmi_set_led_flashing_cmd_fixed_param *) buf_ptr;
  1729. WMITLV_SET_HDR(&cmd->tlv_header,
  1730. WMITLV_TAG_STRUC_wmi_set_led_flashing_cmd_fixed_param,
  1731. WMITLV_GET_STRUCT_TLVLEN
  1732. (wmi_set_led_flashing_cmd_fixed_param));
  1733. cmd->pattern_id = flashing->pattern_id;
  1734. cmd->led_x0 = flashing->led_x0;
  1735. cmd->led_x1 = flashing->led_x1;
  1736. wmi_mtrace(WMI_PDEV_SET_LED_FLASHING_CMDID, NO_SESSION, 0);
  1737. status = wmi_unified_cmd_send(wmi_handle, buf, len,
  1738. WMI_PDEV_SET_LED_FLASHING_CMDID);
  1739. if (QDF_IS_STATUS_ERROR(status)) {
  1740. WMI_LOGE("%s: wmi_unified_cmd_send WMI_PEER_SET_PARAM_CMD"
  1741. " returned Error %d", __func__, status);
  1742. wmi_buf_free(buf);
  1743. }
  1744. return status;
  1745. }
  1746. /**
  1747. * send_process_ch_avoid_update_cmd_tlv() - handles channel avoid update request
  1748. * @wmi_handle: wmi handle
  1749. * @ch_avoid_update_req: channel avoid update params
  1750. *
  1751. * Return: CDF status
  1752. */
  1753. static QDF_STATUS send_process_ch_avoid_update_cmd_tlv(wmi_unified_t wmi_handle)
  1754. {
  1755. QDF_STATUS status;
  1756. wmi_buf_t buf = NULL;
  1757. uint8_t *buf_ptr;
  1758. wmi_chan_avoid_update_cmd_param *ch_avoid_update_fp;
  1759. int len = sizeof(wmi_chan_avoid_update_cmd_param);
  1760. buf = wmi_buf_alloc(wmi_handle, len);
  1761. if (!buf) {
  1762. return QDF_STATUS_E_NOMEM;
  1763. }
  1764. buf_ptr = (uint8_t *) wmi_buf_data(buf);
  1765. ch_avoid_update_fp = (wmi_chan_avoid_update_cmd_param *) buf_ptr;
  1766. WMITLV_SET_HDR(&ch_avoid_update_fp->tlv_header,
  1767. WMITLV_TAG_STRUC_wmi_chan_avoid_update_cmd_param,
  1768. WMITLV_GET_STRUCT_TLVLEN
  1769. (wmi_chan_avoid_update_cmd_param));
  1770. wmi_mtrace(WMI_CHAN_AVOID_UPDATE_CMDID, NO_SESSION, 0);
  1771. status = wmi_unified_cmd_send(wmi_handle, buf,
  1772. len, WMI_CHAN_AVOID_UPDATE_CMDID);
  1773. if (QDF_IS_STATUS_ERROR(status)) {
  1774. WMI_LOGE("wmi_unified_cmd_send"
  1775. " WMITLV_TABLE_WMI_CHAN_AVOID_UPDATE"
  1776. " returned Error %d", status);
  1777. wmi_buf_free(buf);
  1778. }
  1779. return status;
  1780. }
  1781. /**
  1782. * send_pdev_set_pcl_cmd_tlv() - Send WMI_SOC_SET_PCL_CMDID to FW
  1783. * @wmi_handle: wmi handle
  1784. * @msg: PCL structure containing the PCL and the number of channels
  1785. *
  1786. * WMI_PDEV_SET_PCL_CMDID provides a Preferred Channel List (PCL) to the WLAN
  1787. * firmware. The DBS Manager is the consumer of this information in the WLAN
  1788. * firmware. The channel list will be used when a Virtual DEVice (VDEV) needs
  1789. * to migrate to a new channel without host driver involvement. An example of
  1790. * this behavior is Legacy Fast Roaming (LFR 3.0). Generally, the host will
  1791. * manage the channel selection without firmware involvement.
  1792. *
  1793. * WMI_PDEV_SET_PCL_CMDID will carry only the weight list and not the actual
  1794. * channel list. The weights corresponds to the channels sent in
  1795. * WMI_SCAN_CHAN_LIST_CMDID. The channels from PCL would be having a higher
  1796. * weightage compared to the non PCL channels.
  1797. *
  1798. * Return: Success if the cmd is sent successfully to the firmware
  1799. */
  1800. static QDF_STATUS send_pdev_set_pcl_cmd_tlv(wmi_unified_t wmi_handle,
  1801. struct wmi_pcl_chan_weights *msg)
  1802. {
  1803. wmi_pdev_set_pcl_cmd_fixed_param *cmd;
  1804. wmi_buf_t buf;
  1805. uint8_t *buf_ptr;
  1806. uint32_t *cmd_args, i, len;
  1807. uint32_t chan_len;
  1808. chan_len = msg->saved_num_chan;
  1809. len = sizeof(*cmd) +
  1810. WMI_TLV_HDR_SIZE + (chan_len * sizeof(uint32_t));
  1811. buf = wmi_buf_alloc(wmi_handle, len);
  1812. if (!buf) {
  1813. return QDF_STATUS_E_NOMEM;
  1814. }
  1815. cmd = (wmi_pdev_set_pcl_cmd_fixed_param *) wmi_buf_data(buf);
  1816. buf_ptr = (uint8_t *) cmd;
  1817. WMITLV_SET_HDR(&cmd->tlv_header,
  1818. WMITLV_TAG_STRUC_wmi_pdev_set_pcl_cmd_fixed_param,
  1819. WMITLV_GET_STRUCT_TLVLEN(wmi_pdev_set_pcl_cmd_fixed_param));
  1820. cmd->pdev_id = wmi_handle->ops->convert_pdev_id_host_to_target(
  1821. WMI_HOST_PDEV_ID_SOC);
  1822. cmd->num_chan = chan_len;
  1823. WMI_LOGD("%s: Total chan (PCL) len:%d", __func__, cmd->num_chan);
  1824. buf_ptr += sizeof(wmi_pdev_set_pcl_cmd_fixed_param);
  1825. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_UINT32,
  1826. (chan_len * sizeof(uint32_t)));
  1827. cmd_args = (uint32_t *) (buf_ptr + WMI_TLV_HDR_SIZE);
  1828. for (i = 0; i < chan_len ; i++) {
  1829. cmd_args[i] = msg->weighed_valid_list[i];
  1830. WMI_LOGD("%s: chan:%d weight:%d", __func__,
  1831. msg->saved_chan_list[i], cmd_args[i]);
  1832. }
  1833. wmi_mtrace(WMI_PDEV_SET_PCL_CMDID, NO_SESSION, 0);
  1834. if (wmi_unified_cmd_send(wmi_handle, buf, len,
  1835. WMI_PDEV_SET_PCL_CMDID)) {
  1836. WMI_LOGE("%s: Failed to send WMI_PDEV_SET_PCL_CMDID", __func__);
  1837. wmi_buf_free(buf);
  1838. return QDF_STATUS_E_FAILURE;
  1839. }
  1840. return QDF_STATUS_SUCCESS;
  1841. }
  1842. /**
  1843. * send_pdev_set_hw_mode_cmd_tlv() - Send WMI_PDEV_SET_HW_MODE_CMDID to FW
  1844. * @wmi_handle: wmi handle
  1845. * @msg: Structure containing the following parameters
  1846. *
  1847. * - hw_mode_index: The HW_Mode field is a enumerated type that is selected
  1848. * from the HW_Mode table, which is returned in the WMI_SERVICE_READY_EVENTID.
  1849. *
  1850. * Provides notification to the WLAN firmware that host driver is requesting a
  1851. * HardWare (HW) Mode change. This command is needed to support iHelium in the
  1852. * configurations that include the Dual Band Simultaneous (DBS) feature.
  1853. *
  1854. * Return: Success if the cmd is sent successfully to the firmware
  1855. */
  1856. static QDF_STATUS send_pdev_set_hw_mode_cmd_tlv(wmi_unified_t wmi_handle,
  1857. uint32_t hw_mode_index)
  1858. {
  1859. wmi_pdev_set_hw_mode_cmd_fixed_param *cmd;
  1860. wmi_buf_t buf;
  1861. uint32_t len;
  1862. len = sizeof(*cmd);
  1863. buf = wmi_buf_alloc(wmi_handle, len);
  1864. if (!buf) {
  1865. return QDF_STATUS_E_NOMEM;
  1866. }
  1867. cmd = (wmi_pdev_set_hw_mode_cmd_fixed_param *) wmi_buf_data(buf);
  1868. WMITLV_SET_HDR(&cmd->tlv_header,
  1869. WMITLV_TAG_STRUC_wmi_pdev_set_hw_mode_cmd_fixed_param,
  1870. WMITLV_GET_STRUCT_TLVLEN(wmi_pdev_set_hw_mode_cmd_fixed_param));
  1871. cmd->pdev_id = wmi_handle->ops->convert_pdev_id_host_to_target(
  1872. WMI_HOST_PDEV_ID_SOC);
  1873. cmd->hw_mode_index = hw_mode_index;
  1874. WMI_LOGI("%s: HW mode index:%d", __func__, cmd->hw_mode_index);
  1875. wmi_mtrace(WMI_PDEV_SET_HW_MODE_CMDID, NO_SESSION, 0);
  1876. if (wmi_unified_cmd_send(wmi_handle, buf, len,
  1877. WMI_PDEV_SET_HW_MODE_CMDID)) {
  1878. WMI_LOGE("%s: Failed to send WMI_PDEV_SET_HW_MODE_CMDID",
  1879. __func__);
  1880. wmi_buf_free(buf);
  1881. return QDF_STATUS_E_FAILURE;
  1882. }
  1883. return QDF_STATUS_SUCCESS;
  1884. }
  1885. #ifdef WLAN_POLICY_MGR_ENABLE
  1886. /**
  1887. * send_pdev_set_dual_mac_config_cmd_tlv() - Set dual mac config to FW
  1888. * @wmi_handle: wmi handle
  1889. * @msg: Dual MAC config parameters
  1890. *
  1891. * Configures WLAN firmware with the dual MAC features
  1892. *
  1893. * Return: QDF_STATUS. 0 on success.
  1894. */
  1895. static
  1896. QDF_STATUS send_pdev_set_dual_mac_config_cmd_tlv(wmi_unified_t wmi_handle,
  1897. struct policy_mgr_dual_mac_config *msg)
  1898. {
  1899. wmi_pdev_set_mac_config_cmd_fixed_param *cmd;
  1900. wmi_buf_t buf;
  1901. uint32_t len;
  1902. len = sizeof(*cmd);
  1903. buf = wmi_buf_alloc(wmi_handle, len);
  1904. if (!buf) {
  1905. return QDF_STATUS_E_FAILURE;
  1906. }
  1907. cmd = (wmi_pdev_set_mac_config_cmd_fixed_param *) wmi_buf_data(buf);
  1908. WMITLV_SET_HDR(&cmd->tlv_header,
  1909. WMITLV_TAG_STRUC_wmi_pdev_set_mac_config_cmd_fixed_param,
  1910. WMITLV_GET_STRUCT_TLVLEN(
  1911. wmi_pdev_set_mac_config_cmd_fixed_param));
  1912. cmd->pdev_id = wmi_handle->ops->convert_pdev_id_host_to_target(
  1913. WMI_HOST_PDEV_ID_SOC);
  1914. cmd->concurrent_scan_config_bits = msg->scan_config;
  1915. cmd->fw_mode_config_bits = msg->fw_mode_config;
  1916. WMI_LOGD("%s: scan_config:%x fw_mode_config:%x",
  1917. __func__, msg->scan_config, msg->fw_mode_config);
  1918. wmi_mtrace(WMI_PDEV_SET_MAC_CONFIG_CMDID, NO_SESSION, 0);
  1919. if (wmi_unified_cmd_send(wmi_handle, buf, len,
  1920. WMI_PDEV_SET_MAC_CONFIG_CMDID)) {
  1921. WMI_LOGE("%s: Failed to send WMI_PDEV_SET_MAC_CONFIG_CMDID",
  1922. __func__);
  1923. wmi_buf_free(buf);
  1924. }
  1925. return QDF_STATUS_SUCCESS;
  1926. }
  1927. void wmi_policy_mgr_attach_tlv(struct wmi_unified *wmi_handle)
  1928. {
  1929. struct wmi_ops *ops = wmi_handle->ops;
  1930. ops->send_pdev_set_dual_mac_config_cmd =
  1931. send_pdev_set_dual_mac_config_cmd_tlv;
  1932. }
  1933. #endif /* WLAN_POLICY_MGR_ENABLE */
  1934. /**
  1935. * send_adapt_dwelltime_params_cmd_tlv() - send wmi cmd of adaptive dwelltime
  1936. * configuration params
  1937. * @wma_handle: wma handler
  1938. * @dwelltime_params: pointer to dwelltime_params
  1939. *
  1940. * Return: QDF_STATUS_SUCCESS on success and QDF failure reason code for failure
  1941. */
  1942. static
  1943. QDF_STATUS send_adapt_dwelltime_params_cmd_tlv(wmi_unified_t wmi_handle,
  1944. struct wmi_adaptive_dwelltime_params *dwelltime_params)
  1945. {
  1946. wmi_scan_adaptive_dwell_config_fixed_param *dwell_param;
  1947. wmi_scan_adaptive_dwell_parameters_tlv *cmd;
  1948. wmi_buf_t buf;
  1949. uint8_t *buf_ptr;
  1950. int32_t err;
  1951. int len;
  1952. len = sizeof(wmi_scan_adaptive_dwell_config_fixed_param);
  1953. len += WMI_TLV_HDR_SIZE; /* TLV for ext_thresholds*/
  1954. len += sizeof(wmi_scan_adaptive_dwell_parameters_tlv);
  1955. buf = wmi_buf_alloc(wmi_handle, len);
  1956. if (!buf) {
  1957. return QDF_STATUS_E_NOMEM;
  1958. }
  1959. buf_ptr = (uint8_t *) wmi_buf_data(buf);
  1960. dwell_param = (wmi_scan_adaptive_dwell_config_fixed_param *) buf_ptr;
  1961. WMITLV_SET_HDR(&dwell_param->tlv_header,
  1962. WMITLV_TAG_STRUC_wmi_scan_adaptive_dwell_config_fixed_param,
  1963. WMITLV_GET_STRUCT_TLVLEN
  1964. (wmi_scan_adaptive_dwell_config_fixed_param));
  1965. dwell_param->enable = dwelltime_params->is_enabled;
  1966. buf_ptr += sizeof(wmi_scan_adaptive_dwell_config_fixed_param);
  1967. WMITLV_SET_HDR(buf_ptr,
  1968. WMITLV_TAG_ARRAY_STRUC,
  1969. sizeof(wmi_scan_adaptive_dwell_parameters_tlv));
  1970. buf_ptr += WMI_TLV_HDR_SIZE;
  1971. cmd = (wmi_scan_adaptive_dwell_parameters_tlv *) buf_ptr;
  1972. WMITLV_SET_HDR(&cmd->tlv_header,
  1973. WMITLV_TAG_STRUC_wmi_scan_adaptive_dwell_parameters_tlv,
  1974. WMITLV_GET_STRUCT_TLVLEN(
  1975. wmi_scan_adaptive_dwell_parameters_tlv));
  1976. cmd->default_adaptive_dwell_mode = dwelltime_params->dwelltime_mode;
  1977. cmd->adapative_lpf_weight = dwelltime_params->lpf_weight;
  1978. cmd->passive_monitor_interval_ms = dwelltime_params->passive_mon_intval;
  1979. cmd->wifi_activity_threshold_pct = dwelltime_params->wifi_act_threshold;
  1980. wmi_mtrace(WMI_SCAN_ADAPTIVE_DWELL_CONFIG_CMDID, NO_SESSION, 0);
  1981. err = wmi_unified_cmd_send(wmi_handle, buf,
  1982. len, WMI_SCAN_ADAPTIVE_DWELL_CONFIG_CMDID);
  1983. if (err) {
  1984. WMI_LOGE("Failed to send adapt dwelltime cmd err=%d", err);
  1985. wmi_buf_free(buf);
  1986. return QDF_STATUS_E_FAILURE;
  1987. }
  1988. return QDF_STATUS_SUCCESS;
  1989. }
  1990. /**
  1991. * send_dbs_scan_sel_params_cmd_tlv() - send wmi cmd of DBS scan selection
  1992. * configuration params
  1993. * @wmi_handle: wmi handler
  1994. * @dbs_scan_params: pointer to wmi_dbs_scan_sel_params
  1995. *
  1996. * Return: QDF_STATUS_SUCCESS on success and QDF failure reason code for failure
  1997. */
  1998. static QDF_STATUS send_dbs_scan_sel_params_cmd_tlv(wmi_unified_t wmi_handle,
  1999. struct wmi_dbs_scan_sel_params *dbs_scan_params)
  2000. {
  2001. wmi_scan_dbs_duty_cycle_fixed_param *dbs_scan_param;
  2002. wmi_scan_dbs_duty_cycle_tlv_param *cmd;
  2003. wmi_buf_t buf;
  2004. uint8_t *buf_ptr;
  2005. QDF_STATUS err;
  2006. uint32_t i;
  2007. int len;
  2008. len = sizeof(*dbs_scan_param);
  2009. len += WMI_TLV_HDR_SIZE;
  2010. len += dbs_scan_params->num_clients * sizeof(*cmd);
  2011. buf = wmi_buf_alloc(wmi_handle, len);
  2012. if (!buf) {
  2013. return QDF_STATUS_E_NOMEM;
  2014. }
  2015. buf_ptr = (uint8_t *) wmi_buf_data(buf);
  2016. dbs_scan_param = (wmi_scan_dbs_duty_cycle_fixed_param *) buf_ptr;
  2017. WMITLV_SET_HDR(&dbs_scan_param->tlv_header,
  2018. WMITLV_TAG_STRUC_wmi_scan_dbs_duty_cycle_fixed_param,
  2019. WMITLV_GET_STRUCT_TLVLEN
  2020. (wmi_scan_dbs_duty_cycle_fixed_param));
  2021. dbs_scan_param->num_clients = dbs_scan_params->num_clients;
  2022. dbs_scan_param->pdev_id = dbs_scan_params->pdev_id;
  2023. buf_ptr += sizeof(*dbs_scan_param);
  2024. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
  2025. (sizeof(*cmd) * dbs_scan_params->num_clients));
  2026. buf_ptr = buf_ptr + (uint8_t) WMI_TLV_HDR_SIZE;
  2027. for (i = 0; i < dbs_scan_params->num_clients; i++) {
  2028. cmd = (wmi_scan_dbs_duty_cycle_tlv_param *) buf_ptr;
  2029. WMITLV_SET_HDR(&cmd->tlv_header,
  2030. WMITLV_TAG_STRUC_wmi_scan_dbs_duty_cycle_param_tlv,
  2031. WMITLV_GET_STRUCT_TLVLEN(
  2032. wmi_scan_dbs_duty_cycle_tlv_param));
  2033. cmd->module_id = dbs_scan_params->module_id[i];
  2034. cmd->num_dbs_scans = dbs_scan_params->num_dbs_scans[i];
  2035. cmd->num_non_dbs_scans = dbs_scan_params->num_non_dbs_scans[i];
  2036. buf_ptr = buf_ptr + (uint8_t) sizeof(*cmd);
  2037. }
  2038. wmi_mtrace(WMI_SET_SCAN_DBS_DUTY_CYCLE_CMDID, NO_SESSION, 0);
  2039. err = wmi_unified_cmd_send(wmi_handle, buf,
  2040. len, WMI_SET_SCAN_DBS_DUTY_CYCLE_CMDID);
  2041. if (QDF_IS_STATUS_ERROR(err)) {
  2042. WMI_LOGE("Failed to send dbs scan selection cmd err=%d", err);
  2043. wmi_buf_free(buf);
  2044. return QDF_STATUS_E_FAILURE;
  2045. }
  2046. return QDF_STATUS_SUCCESS;
  2047. }
  2048. /**
  2049. * send_set_arp_stats_req_cmd_tlv() - send wmi cmd to set arp stats request
  2050. * @wmi_handle: wmi handler
  2051. * @req_buf: set arp stats request buffer
  2052. *
  2053. * Return: 0 for success and non zero for failure
  2054. */
  2055. static QDF_STATUS send_set_arp_stats_req_cmd_tlv(wmi_unified_t wmi_handle,
  2056. struct set_arp_stats *req_buf)
  2057. {
  2058. wmi_buf_t buf = NULL;
  2059. QDF_STATUS status;
  2060. int len;
  2061. uint8_t *buf_ptr;
  2062. wmi_vdev_set_arp_stats_cmd_fixed_param *wmi_set_arp;
  2063. len = sizeof(wmi_vdev_set_arp_stats_cmd_fixed_param);
  2064. if (req_buf->pkt_type_bitmap) {
  2065. len += WMI_TLV_HDR_SIZE;
  2066. len += sizeof(wmi_vdev_set_connectivity_check_stats);
  2067. }
  2068. buf = wmi_buf_alloc(wmi_handle, len);
  2069. if (!buf) {
  2070. return QDF_STATUS_E_NOMEM;
  2071. }
  2072. buf_ptr = (uint8_t *) wmi_buf_data(buf);
  2073. wmi_set_arp =
  2074. (wmi_vdev_set_arp_stats_cmd_fixed_param *) buf_ptr;
  2075. WMITLV_SET_HDR(&wmi_set_arp->tlv_header,
  2076. WMITLV_TAG_STRUC_wmi_vdev_set_arp_stats_cmd_fixed_param,
  2077. WMITLV_GET_STRUCT_TLVLEN
  2078. (wmi_vdev_set_arp_stats_cmd_fixed_param));
  2079. /* fill in per roam config values */
  2080. wmi_set_arp->vdev_id = req_buf->vdev_id;
  2081. wmi_set_arp->set_clr = req_buf->flag;
  2082. wmi_set_arp->pkt_type = req_buf->pkt_type;
  2083. wmi_set_arp->ipv4 = req_buf->ip_addr;
  2084. WMI_LOGD("NUD Stats: vdev_id %u set_clr %u pkt_type:%u ipv4 %u",
  2085. wmi_set_arp->vdev_id, wmi_set_arp->set_clr,
  2086. wmi_set_arp->pkt_type, wmi_set_arp->ipv4);
  2087. /*
  2088. * pkt_type_bitmap should be non-zero to ensure
  2089. * presence of additional stats.
  2090. */
  2091. if (req_buf->pkt_type_bitmap) {
  2092. wmi_vdev_set_connectivity_check_stats *wmi_set_connect_stats;
  2093. buf_ptr += sizeof(wmi_vdev_set_arp_stats_cmd_fixed_param);
  2094. WMITLV_SET_HDR(buf_ptr,
  2095. WMITLV_TAG_ARRAY_STRUC,
  2096. sizeof(wmi_vdev_set_connectivity_check_stats));
  2097. buf_ptr += WMI_TLV_HDR_SIZE;
  2098. wmi_set_connect_stats =
  2099. (wmi_vdev_set_connectivity_check_stats *)buf_ptr;
  2100. WMITLV_SET_HDR(&wmi_set_connect_stats->tlv_header,
  2101. WMITLV_TAG_STRUC_wmi_vdev_set_connectivity_check_stats,
  2102. WMITLV_GET_STRUCT_TLVLEN(
  2103. wmi_vdev_set_connectivity_check_stats));
  2104. wmi_set_connect_stats->pkt_type_bitmap =
  2105. req_buf->pkt_type_bitmap;
  2106. wmi_set_connect_stats->tcp_src_port = req_buf->tcp_src_port;
  2107. wmi_set_connect_stats->tcp_dst_port = req_buf->tcp_dst_port;
  2108. wmi_set_connect_stats->icmp_ipv4 = req_buf->icmp_ipv4;
  2109. WMI_LOGD("Connectivity Stats: pkt_type_bitmap %u tcp_src_port:%u tcp_dst_port %u icmp_ipv4 %u",
  2110. wmi_set_connect_stats->pkt_type_bitmap,
  2111. wmi_set_connect_stats->tcp_src_port,
  2112. wmi_set_connect_stats->tcp_dst_port,
  2113. wmi_set_connect_stats->icmp_ipv4);
  2114. }
  2115. /* Send per roam config parameters */
  2116. wmi_mtrace(WMI_VDEV_SET_ARP_STAT_CMDID, NO_SESSION, 0);
  2117. status = wmi_unified_cmd_send(wmi_handle, buf,
  2118. len, WMI_VDEV_SET_ARP_STAT_CMDID);
  2119. if (QDF_IS_STATUS_ERROR(status)) {
  2120. WMI_LOGE("WMI_SET_ARP_STATS_CMDID failed, Error %d",
  2121. status);
  2122. goto error;
  2123. }
  2124. WMI_LOGD(FL("set arp stats flag=%d, vdev=%d"),
  2125. req_buf->flag, req_buf->vdev_id);
  2126. return QDF_STATUS_SUCCESS;
  2127. error:
  2128. wmi_buf_free(buf);
  2129. return status;
  2130. }
  2131. /**
  2132. * send_get_arp_stats_req_cmd_tlv() - send wmi cmd to get arp stats request
  2133. * @wmi_handle: wmi handler
  2134. * @req_buf: get arp stats request buffer
  2135. *
  2136. * Return: 0 for success and non zero for failure
  2137. */
  2138. static QDF_STATUS send_get_arp_stats_req_cmd_tlv(wmi_unified_t wmi_handle,
  2139. struct get_arp_stats *req_buf)
  2140. {
  2141. wmi_buf_t buf = NULL;
  2142. QDF_STATUS status;
  2143. int len;
  2144. uint8_t *buf_ptr;
  2145. wmi_vdev_get_arp_stats_cmd_fixed_param *get_arp_stats;
  2146. len = sizeof(wmi_vdev_get_arp_stats_cmd_fixed_param);
  2147. buf = wmi_buf_alloc(wmi_handle, len);
  2148. if (!buf) {
  2149. return QDF_STATUS_E_NOMEM;
  2150. }
  2151. buf_ptr = (uint8_t *) wmi_buf_data(buf);
  2152. get_arp_stats =
  2153. (wmi_vdev_get_arp_stats_cmd_fixed_param *) buf_ptr;
  2154. WMITLV_SET_HDR(&get_arp_stats->tlv_header,
  2155. WMITLV_TAG_STRUC_wmi_vdev_get_arp_stats_cmd_fixed_param,
  2156. WMITLV_GET_STRUCT_TLVLEN
  2157. (wmi_vdev_get_arp_stats_cmd_fixed_param));
  2158. /* fill in arp stats req cmd values */
  2159. get_arp_stats->vdev_id = req_buf->vdev_id;
  2160. WMI_LOGI(FL("vdev=%d"), req_buf->vdev_id);
  2161. /* Send per roam config parameters */
  2162. wmi_mtrace(WMI_VDEV_GET_ARP_STAT_CMDID, NO_SESSION, 0);
  2163. status = wmi_unified_cmd_send(wmi_handle, buf,
  2164. len, WMI_VDEV_GET_ARP_STAT_CMDID);
  2165. if (QDF_IS_STATUS_ERROR(status)) {
  2166. WMI_LOGE("WMI_GET_ARP_STATS_CMDID failed, Error %d",
  2167. status);
  2168. goto error;
  2169. }
  2170. return QDF_STATUS_SUCCESS;
  2171. error:
  2172. wmi_buf_free(buf);
  2173. return status;
  2174. }
  2175. void wmi_sta_attach_tlv(wmi_unified_t wmi_handle)
  2176. {
  2177. struct wmi_ops *ops = wmi_handle->ops;
  2178. ops->send_set_sta_sa_query_param_cmd =
  2179. send_set_sta_sa_query_param_cmd_tlv;
  2180. ops->send_set_sta_keep_alive_cmd = send_set_sta_keep_alive_cmd_tlv;
  2181. ops->send_vdev_set_gtx_cfg_cmd = send_vdev_set_gtx_cfg_cmd_tlv;
  2182. ops->send_process_dhcp_ind_cmd = send_process_dhcp_ind_cmd_tlv;
  2183. ops->send_get_link_speed_cmd = send_get_link_speed_cmd_tlv;
  2184. ops->send_fw_profiling_cmd = send_fw_profiling_cmd_tlv;
  2185. ops->send_nat_keepalive_en_cmd = send_nat_keepalive_en_cmd_tlv;
  2186. ops->send_wlm_latency_level_cmd = send_wlm_latency_level_cmd_tlv;
  2187. ops->send_nan_req_cmd = send_nan_req_cmd_tlv;
  2188. ops->send_process_set_ie_info_cmd = send_process_set_ie_info_cmd_tlv;
  2189. ops->send_set_base_macaddr_indicate_cmd =
  2190. send_set_base_macaddr_indicate_cmd_tlv;
  2191. ops->send_sar_limit_cmd = send_sar_limit_cmd_tlv;
  2192. ops->get_sar_limit_cmd = get_sar_limit_cmd_tlv;
  2193. ops->extract_sar_limit_event = extract_sar_limit_event_tlv;
  2194. ops->extract_sar2_result_event = extract_sar2_result_event_tlv;
  2195. ops->send_set_del_pmkid_cache_cmd = send_set_del_pmkid_cache_cmd_tlv;
  2196. ops->send_del_ts_cmd = send_del_ts_cmd_tlv;
  2197. ops->send_aggr_qos_cmd = send_aggr_qos_cmd_tlv;
  2198. ops->send_add_ts_cmd = send_add_ts_cmd_tlv;
  2199. ops->send_process_add_periodic_tx_ptrn_cmd =
  2200. send_process_add_periodic_tx_ptrn_cmd_tlv;
  2201. ops->send_process_del_periodic_tx_ptrn_cmd =
  2202. send_process_del_periodic_tx_ptrn_cmd_tlv;
  2203. ops->send_set_auto_shutdown_timer_cmd =
  2204. send_set_auto_shutdown_timer_cmd_tlv;
  2205. ops->send_set_led_flashing_cmd = send_set_led_flashing_cmd_tlv;
  2206. ops->send_process_ch_avoid_update_cmd =
  2207. send_process_ch_avoid_update_cmd_tlv;
  2208. ops->send_pdev_set_pcl_cmd = send_pdev_set_pcl_cmd_tlv;
  2209. ops->send_pdev_set_hw_mode_cmd = send_pdev_set_hw_mode_cmd_tlv;
  2210. ops->send_adapt_dwelltime_params_cmd =
  2211. send_adapt_dwelltime_params_cmd_tlv;
  2212. ops->send_dbs_scan_sel_params_cmd =
  2213. send_dbs_scan_sel_params_cmd_tlv;
  2214. ops->send_set_arp_stats_req_cmd = send_set_arp_stats_req_cmd_tlv;
  2215. ops->send_get_arp_stats_req_cmd = send_get_arp_stats_req_cmd_tlv;
  2216. wmi_tdls_attach_tlv(wmi_handle);
  2217. wmi_disa_attach_tlv(wmi_handle);
  2218. wmi_policy_mgr_attach_tlv(wmi_handle);
  2219. }