wmi_unified_pmo_tlv.c 59 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973
  1. /*
  2. * Copyright (c) 2018-2020 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_unified_priv.h"
  21. #include "wmi_unified_pmo_api.h"
  22. #ifdef FEATURE_WLAN_D0WOW
  23. /**
  24. * send_d0wow_enable_cmd_tlv() - WMI d0 wow enable function
  25. * @param wmi_handle: handle to WMI.
  26. * @mac_id: radio context
  27. *
  28. * Return: 0 on success and error code on failure.
  29. */
  30. static QDF_STATUS send_d0wow_enable_cmd_tlv(wmi_unified_t wmi_handle,
  31. uint8_t mac_id)
  32. {
  33. wmi_d0_wow_enable_disable_cmd_fixed_param *cmd;
  34. wmi_buf_t buf;
  35. int32_t len;
  36. QDF_STATUS status;
  37. len = sizeof(wmi_d0_wow_enable_disable_cmd_fixed_param);
  38. buf = wmi_buf_alloc(wmi_handle, len);
  39. if (!buf) {
  40. return QDF_STATUS_E_NOMEM;
  41. }
  42. cmd = (wmi_d0_wow_enable_disable_cmd_fixed_param *) wmi_buf_data(buf);
  43. WMITLV_SET_HDR(&cmd->tlv_header,
  44. WMITLV_TAG_STRUC_wmi_d0_wow_enable_disable_cmd_fixed_param,
  45. WMITLV_GET_STRUCT_TLVLEN
  46. (wmi_d0_wow_enable_disable_cmd_fixed_param));
  47. cmd->enable = true;
  48. wmi_mtrace(WMI_D0_WOW_ENABLE_DISABLE_CMDID, NO_SESSION, 0);
  49. status = wmi_unified_cmd_send(wmi_handle, buf, len,
  50. WMI_D0_WOW_ENABLE_DISABLE_CMDID);
  51. if (QDF_IS_STATUS_ERROR(status))
  52. wmi_buf_free(buf);
  53. return status;
  54. }
  55. /**
  56. * send_d0wow_disable_cmd_tlv() - WMI d0 wow disable function
  57. * @param wmi_handle: handle to WMI.
  58. * @mac_id: radio context
  59. *
  60. * Return: 0 on success and error code on failure.
  61. */
  62. static QDF_STATUS send_d0wow_disable_cmd_tlv(wmi_unified_t wmi_handle,
  63. uint8_t mac_id)
  64. {
  65. wmi_d0_wow_enable_disable_cmd_fixed_param *cmd;
  66. wmi_buf_t buf;
  67. int32_t len;
  68. QDF_STATUS status;
  69. len = sizeof(wmi_d0_wow_enable_disable_cmd_fixed_param);
  70. buf = wmi_buf_alloc(wmi_handle, len);
  71. if (!buf) {
  72. return QDF_STATUS_E_NOMEM;
  73. }
  74. cmd = (wmi_d0_wow_enable_disable_cmd_fixed_param *) wmi_buf_data(buf);
  75. WMITLV_SET_HDR(&cmd->tlv_header,
  76. WMITLV_TAG_STRUC_wmi_d0_wow_enable_disable_cmd_fixed_param,
  77. WMITLV_GET_STRUCT_TLVLEN
  78. (wmi_d0_wow_enable_disable_cmd_fixed_param));
  79. cmd->enable = false;
  80. wmi_mtrace(WMI_D0_WOW_ENABLE_DISABLE_CMDID, NO_SESSION, 0);
  81. status = wmi_unified_cmd_send(wmi_handle, buf, len,
  82. WMI_D0_WOW_ENABLE_DISABLE_CMDID);
  83. if (QDF_IS_STATUS_ERROR(status))
  84. wmi_buf_free(buf);
  85. return status;
  86. }
  87. void wmi_d0wow_attach_tlv(struct wmi_unified *wmi_handle)
  88. {
  89. struct wmi_ops *ops = wmi_handle->ops;
  90. ops->send_d0wow_enable_cmd = send_d0wow_enable_cmd_tlv;
  91. ops->send_d0wow_disable_cmd = send_d0wow_disable_cmd_tlv;
  92. }
  93. #endif /* FEATURE_WLAN_D0WOW */
  94. /**
  95. * send_add_wow_wakeup_event_cmd_tlv() - Configures wow wakeup events.
  96. * @wmi_handle: wmi handle
  97. * @vdev_id: vdev id
  98. * @bitmap: Event bitmap
  99. * @enable: enable/disable
  100. *
  101. * Return: CDF status
  102. */
  103. static QDF_STATUS send_add_wow_wakeup_event_cmd_tlv(wmi_unified_t wmi_handle,
  104. uint32_t vdev_id,
  105. uint32_t *bitmap,
  106. bool enable)
  107. {
  108. WMI_WOW_ADD_DEL_EVT_CMD_fixed_param *cmd;
  109. uint16_t len;
  110. wmi_buf_t buf;
  111. int ret;
  112. len = sizeof(WMI_WOW_ADD_DEL_EVT_CMD_fixed_param);
  113. buf = wmi_buf_alloc(wmi_handle, len);
  114. if (!buf) {
  115. return QDF_STATUS_E_NOMEM;
  116. }
  117. cmd = (WMI_WOW_ADD_DEL_EVT_CMD_fixed_param *) wmi_buf_data(buf);
  118. WMITLV_SET_HDR(&cmd->tlv_header,
  119. WMITLV_TAG_STRUC_WMI_WOW_ADD_DEL_EVT_CMD_fixed_param,
  120. WMITLV_GET_STRUCT_TLVLEN
  121. (WMI_WOW_ADD_DEL_EVT_CMD_fixed_param));
  122. cmd->vdev_id = vdev_id;
  123. cmd->is_add = enable;
  124. qdf_mem_copy(&(cmd->event_bitmaps[0]), bitmap, sizeof(uint32_t) *
  125. WMI_WOW_MAX_EVENT_BM_LEN);
  126. wmi_debug("Wakeup pattern 0x%x%x%x%x %s in fw", cmd->event_bitmaps[0],
  127. cmd->event_bitmaps[1], cmd->event_bitmaps[2],
  128. cmd->event_bitmaps[3], enable ? "enabled" : "disabled");
  129. wmi_mtrace(WMI_WOW_ENABLE_DISABLE_WAKE_EVENT_CMDID, cmd->vdev_id, 0);
  130. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  131. WMI_WOW_ENABLE_DISABLE_WAKE_EVENT_CMDID);
  132. if (ret) {
  133. wmi_err("Failed to config wow wakeup event");
  134. wmi_buf_free(buf);
  135. return QDF_STATUS_E_FAILURE;
  136. }
  137. return QDF_STATUS_SUCCESS;
  138. }
  139. /**
  140. * send_wow_patterns_to_fw_cmd_tlv() - Sends WOW patterns to FW.
  141. * @wmi_handle: wmi handle
  142. * @vdev_id: vdev id
  143. * @ptrn_id: pattern id
  144. * @ptrn: pattern
  145. * @ptrn_len: pattern length
  146. * @ptrn_offset: pattern offset
  147. * @mask: mask
  148. * @mask_len: mask length
  149. * @user: true for user configured pattern and false for default pattern
  150. * @default_patterns: default patterns
  151. *
  152. * Return: CDF status
  153. */
  154. static QDF_STATUS send_wow_patterns_to_fw_cmd_tlv(wmi_unified_t wmi_handle,
  155. uint8_t vdev_id, uint8_t ptrn_id,
  156. const uint8_t *ptrn, uint8_t ptrn_len,
  157. uint8_t ptrn_offset, const uint8_t *mask,
  158. uint8_t mask_len, bool user,
  159. uint8_t default_patterns)
  160. {
  161. WMI_WOW_ADD_PATTERN_CMD_fixed_param *cmd;
  162. WOW_BITMAP_PATTERN_T *bitmap_pattern;
  163. wmi_buf_t buf;
  164. uint8_t *buf_ptr;
  165. int32_t len;
  166. int ret;
  167. len = sizeof(WMI_WOW_ADD_PATTERN_CMD_fixed_param) +
  168. WMI_TLV_HDR_SIZE +
  169. 1 * sizeof(WOW_BITMAP_PATTERN_T) +
  170. WMI_TLV_HDR_SIZE +
  171. 0 * sizeof(WOW_IPV4_SYNC_PATTERN_T) +
  172. WMI_TLV_HDR_SIZE +
  173. 0 * sizeof(WOW_IPV6_SYNC_PATTERN_T) +
  174. WMI_TLV_HDR_SIZE +
  175. 0 * sizeof(WOW_MAGIC_PATTERN_CMD) +
  176. WMI_TLV_HDR_SIZE +
  177. 0 * sizeof(uint32_t) + WMI_TLV_HDR_SIZE + 1 * sizeof(uint32_t);
  178. buf = wmi_buf_alloc(wmi_handle, len);
  179. if (!buf) {
  180. return QDF_STATUS_E_NOMEM;
  181. }
  182. cmd = (WMI_WOW_ADD_PATTERN_CMD_fixed_param *) wmi_buf_data(buf);
  183. buf_ptr = (uint8_t *) cmd;
  184. WMITLV_SET_HDR(&cmd->tlv_header,
  185. WMITLV_TAG_STRUC_WMI_WOW_ADD_PATTERN_CMD_fixed_param,
  186. WMITLV_GET_STRUCT_TLVLEN
  187. (WMI_WOW_ADD_PATTERN_CMD_fixed_param));
  188. cmd->vdev_id = vdev_id;
  189. cmd->pattern_id = ptrn_id;
  190. cmd->pattern_type = WOW_BITMAP_PATTERN;
  191. buf_ptr += sizeof(WMI_WOW_ADD_PATTERN_CMD_fixed_param);
  192. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
  193. sizeof(WOW_BITMAP_PATTERN_T));
  194. buf_ptr += WMI_TLV_HDR_SIZE;
  195. bitmap_pattern = (WOW_BITMAP_PATTERN_T *) buf_ptr;
  196. WMITLV_SET_HDR(&bitmap_pattern->tlv_header,
  197. WMITLV_TAG_STRUC_WOW_BITMAP_PATTERN_T,
  198. WMITLV_GET_STRUCT_TLVLEN(WOW_BITMAP_PATTERN_T));
  199. qdf_mem_copy(&bitmap_pattern->patternbuf[0], ptrn, ptrn_len);
  200. qdf_mem_copy(&bitmap_pattern->bitmaskbuf[0], mask, mask_len);
  201. bitmap_pattern->pattern_offset = ptrn_offset;
  202. bitmap_pattern->pattern_len = ptrn_len;
  203. if (bitmap_pattern->pattern_len > WOW_DEFAULT_BITMAP_PATTERN_SIZE)
  204. bitmap_pattern->pattern_len = WOW_DEFAULT_BITMAP_PATTERN_SIZE;
  205. if (bitmap_pattern->pattern_len > WOW_DEFAULT_BITMASK_SIZE)
  206. bitmap_pattern->pattern_len = WOW_DEFAULT_BITMASK_SIZE;
  207. bitmap_pattern->bitmask_len = bitmap_pattern->pattern_len;
  208. bitmap_pattern->pattern_id = ptrn_id;
  209. wmi_debug("vdev: %d, ptrn id: %d, ptrn len: %d, ptrn offset: %d user %d",
  210. cmd->vdev_id, cmd->pattern_id, bitmap_pattern->pattern_len,
  211. bitmap_pattern->pattern_offset, user);
  212. wmi_debug("Pattern: ");
  213. QDF_TRACE_HEX_DUMP(QDF_MODULE_ID_WMI, QDF_TRACE_LEVEL_DEBUG,
  214. &bitmap_pattern->patternbuf[0],
  215. bitmap_pattern->pattern_len);
  216. wmi_debug("Mask: ");
  217. QDF_TRACE_HEX_DUMP(QDF_MODULE_ID_WMI, QDF_TRACE_LEVEL_DEBUG,
  218. &bitmap_pattern->bitmaskbuf[0],
  219. bitmap_pattern->pattern_len);
  220. buf_ptr += sizeof(WOW_BITMAP_PATTERN_T);
  221. /* Fill TLV for WMITLV_TAG_STRUC_WOW_IPV4_SYNC_PATTERN_T but no data. */
  222. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC, 0);
  223. buf_ptr += WMI_TLV_HDR_SIZE;
  224. /* Fill TLV for WMITLV_TAG_STRUC_WOW_IPV6_SYNC_PATTERN_T but no data. */
  225. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC, 0);
  226. buf_ptr += WMI_TLV_HDR_SIZE;
  227. /* Fill TLV for WMITLV_TAG_STRUC_WOW_MAGIC_PATTERN_CMD but no data. */
  228. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC, 0);
  229. buf_ptr += WMI_TLV_HDR_SIZE;
  230. /* Fill TLV for pattern_info_timeout but no data. */
  231. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_UINT32, 0);
  232. buf_ptr += WMI_TLV_HDR_SIZE;
  233. /* Fill TLV for ratelimit_interval with dummy data as this fix elem */
  234. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_UINT32, 1 * sizeof(uint32_t));
  235. buf_ptr += WMI_TLV_HDR_SIZE;
  236. *(uint32_t *) buf_ptr = 0;
  237. wmi_mtrace(WMI_WOW_ADD_WAKE_PATTERN_CMDID, cmd->vdev_id, 0);
  238. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  239. WMI_WOW_ADD_WAKE_PATTERN_CMDID);
  240. if (ret) {
  241. wmi_err("Failed to send wow ptrn to fw");
  242. wmi_buf_free(buf);
  243. return QDF_STATUS_E_FAILURE;
  244. }
  245. return QDF_STATUS_SUCCESS;
  246. }
  247. /**
  248. * fill_arp_offload_params_tlv() - Fill ARP offload data
  249. * @wmi_handle: wmi handle
  250. * @offload_req: offload request
  251. * @buf_ptr: buffer pointer
  252. *
  253. * To fill ARP offload data to firmware
  254. * when target goes to wow mode.
  255. *
  256. * Return: None
  257. */
  258. static void fill_arp_offload_params_tlv(wmi_unified_t wmi_handle,
  259. struct pmo_arp_offload_params *offload_req, uint8_t **buf_ptr)
  260. {
  261. int i;
  262. WMI_ARP_OFFLOAD_TUPLE *arp_tuple;
  263. bool enable_or_disable = offload_req->enable;
  264. WMITLV_SET_HDR(*buf_ptr, WMITLV_TAG_ARRAY_STRUC,
  265. (WMI_MAX_ARP_OFFLOADS*sizeof(WMI_ARP_OFFLOAD_TUPLE)));
  266. *buf_ptr += WMI_TLV_HDR_SIZE;
  267. for (i = 0; i < WMI_MAX_ARP_OFFLOADS; i++) {
  268. arp_tuple = (WMI_ARP_OFFLOAD_TUPLE *)*buf_ptr;
  269. WMITLV_SET_HDR(&arp_tuple->tlv_header,
  270. WMITLV_TAG_STRUC_WMI_ARP_OFFLOAD_TUPLE,
  271. WMITLV_GET_STRUCT_TLVLEN(WMI_ARP_OFFLOAD_TUPLE));
  272. /* Fill data for ARP and NS in the first tupple for LA */
  273. if ((enable_or_disable & PMO_OFFLOAD_ENABLE) && (i == 0)) {
  274. /* Copy the target ip addr and flags */
  275. arp_tuple->flags = WMI_ARPOFF_FLAGS_VALID;
  276. qdf_mem_copy(&arp_tuple->target_ipaddr,
  277. offload_req->host_ipv4_addr,
  278. WMI_IPV4_ADDR_LEN);
  279. wmi_debug("ARPOffload IP4 address: %pI4",
  280. offload_req->host_ipv4_addr);
  281. }
  282. *buf_ptr += sizeof(WMI_ARP_OFFLOAD_TUPLE);
  283. }
  284. }
  285. #ifdef WLAN_NS_OFFLOAD
  286. /**
  287. * fill_ns_offload_params_tlv() - Fill NS offload data
  288. * @wmi|_handle: wmi handle
  289. * @offload_req: offload request
  290. * @buf_ptr: buffer pointer
  291. *
  292. * To fill NS offload data to firmware
  293. * when target goes to wow mode.
  294. *
  295. * Return: None
  296. */
  297. static void fill_ns_offload_params_tlv(wmi_unified_t wmi_handle,
  298. struct pmo_ns_offload_params *ns_req, uint8_t **buf_ptr)
  299. {
  300. int i;
  301. WMI_NS_OFFLOAD_TUPLE *ns_tuple;
  302. WMITLV_SET_HDR(*buf_ptr, WMITLV_TAG_ARRAY_STRUC,
  303. (WMI_MAX_NS_OFFLOADS * sizeof(WMI_NS_OFFLOAD_TUPLE)));
  304. *buf_ptr += WMI_TLV_HDR_SIZE;
  305. for (i = 0; i < WMI_MAX_NS_OFFLOADS; i++) {
  306. ns_tuple = (WMI_NS_OFFLOAD_TUPLE *)*buf_ptr;
  307. WMITLV_SET_HDR(&ns_tuple->tlv_header,
  308. WMITLV_TAG_STRUC_WMI_NS_OFFLOAD_TUPLE,
  309. (sizeof(WMI_NS_OFFLOAD_TUPLE) - WMI_TLV_HDR_SIZE));
  310. /*
  311. * Fill data only for NS offload in the first ARP tuple for LA
  312. */
  313. if ((ns_req->enable & PMO_OFFLOAD_ENABLE)) {
  314. ns_tuple->flags |= WMI_NSOFF_FLAGS_VALID;
  315. /* Copy the target/solicitation/remote ip addr */
  316. if (ns_req->target_ipv6_addr_valid[i])
  317. qdf_mem_copy(&ns_tuple->target_ipaddr[0],
  318. &ns_req->target_ipv6_addr[i],
  319. sizeof(WMI_IPV6_ADDR));
  320. qdf_mem_copy(&ns_tuple->solicitation_ipaddr,
  321. &ns_req->self_ipv6_addr[i],
  322. sizeof(WMI_IPV6_ADDR));
  323. if (ns_req->target_ipv6_addr_ac_type[i]) {
  324. ns_tuple->flags |=
  325. WMI_NSOFF_FLAGS_IS_IPV6_ANYCAST;
  326. }
  327. wmi_debug("Index %d NS solicitedIp %pI6, targetIp %pI6",
  328. i, &ns_req->self_ipv6_addr[i],
  329. &ns_req->target_ipv6_addr[i]);
  330. /* target MAC is optional, check if it is valid,
  331. * if this is not valid, the target will use the known
  332. * local MAC address rather than the tuple
  333. */
  334. WMI_CHAR_ARRAY_TO_MAC_ADDR(
  335. ns_req->self_macaddr.bytes,
  336. &ns_tuple->target_mac);
  337. if ((ns_tuple->target_mac.mac_addr31to0 != 0) ||
  338. (ns_tuple->target_mac.mac_addr47to32 != 0)) {
  339. ns_tuple->flags |= WMI_NSOFF_FLAGS_MAC_VALID;
  340. }
  341. }
  342. *buf_ptr += sizeof(WMI_NS_OFFLOAD_TUPLE);
  343. }
  344. }
  345. /**
  346. * fill_nsoffload_ext_tlv() - Fill NS offload ext data
  347. * @wmi: wmi handle
  348. * @offload_req: offload request
  349. * @buf_ptr: buffer pointer
  350. *
  351. * To fill extended NS offload extended data to firmware
  352. * when target goes to wow mode.
  353. *
  354. * Return: None
  355. */
  356. static void fill_nsoffload_ext_tlv(wmi_unified_t wmi_handle,
  357. struct pmo_ns_offload_params *ns_req, uint8_t **buf_ptr)
  358. {
  359. int i;
  360. WMI_NS_OFFLOAD_TUPLE *ns_tuple;
  361. uint32_t count, num_ns_ext_tuples;
  362. count = ns_req->num_ns_offload_count;
  363. num_ns_ext_tuples = ns_req->num_ns_offload_count -
  364. WMI_MAX_NS_OFFLOADS;
  365. /* Populate extended NS offload tuples */
  366. WMITLV_SET_HDR(*buf_ptr, WMITLV_TAG_ARRAY_STRUC,
  367. (num_ns_ext_tuples * sizeof(WMI_NS_OFFLOAD_TUPLE)));
  368. *buf_ptr += WMI_TLV_HDR_SIZE;
  369. for (i = WMI_MAX_NS_OFFLOADS; i < count; i++) {
  370. ns_tuple = (WMI_NS_OFFLOAD_TUPLE *)*buf_ptr;
  371. WMITLV_SET_HDR(&ns_tuple->tlv_header,
  372. WMITLV_TAG_STRUC_WMI_NS_OFFLOAD_TUPLE,
  373. (sizeof(WMI_NS_OFFLOAD_TUPLE)-WMI_TLV_HDR_SIZE));
  374. /*
  375. * Fill data only for NS offload in the first ARP tuple for LA
  376. */
  377. if ((ns_req->enable & PMO_OFFLOAD_ENABLE)) {
  378. ns_tuple->flags |= WMI_NSOFF_FLAGS_VALID;
  379. /* Copy the target/solicitation/remote ip addr */
  380. if (ns_req->target_ipv6_addr_valid[i])
  381. qdf_mem_copy(&ns_tuple->target_ipaddr[0],
  382. &ns_req->target_ipv6_addr[i],
  383. sizeof(WMI_IPV6_ADDR));
  384. qdf_mem_copy(&ns_tuple->solicitation_ipaddr,
  385. &ns_req->self_ipv6_addr[i],
  386. sizeof(WMI_IPV6_ADDR));
  387. if (ns_req->target_ipv6_addr_ac_type[i]) {
  388. ns_tuple->flags |=
  389. WMI_NSOFF_FLAGS_IS_IPV6_ANYCAST;
  390. }
  391. wmi_debug("Index %d NS solicitedIp %pI6, targetIp %pI6",
  392. i, &ns_req->self_ipv6_addr[i],
  393. &ns_req->target_ipv6_addr[i]);
  394. /* target MAC is optional, check if it is valid,
  395. * if this is not valid, the target will use the
  396. * known local MAC address rather than the tuple
  397. */
  398. WMI_CHAR_ARRAY_TO_MAC_ADDR(
  399. ns_req->self_macaddr.bytes,
  400. &ns_tuple->target_mac);
  401. if ((ns_tuple->target_mac.mac_addr31to0 != 0) ||
  402. (ns_tuple->target_mac.mac_addr47to32 != 0)) {
  403. ns_tuple->flags |= WMI_NSOFF_FLAGS_MAC_VALID;
  404. }
  405. }
  406. *buf_ptr += sizeof(WMI_NS_OFFLOAD_TUPLE);
  407. }
  408. }
  409. #else
  410. static void fill_ns_offload_params_tlv(wmi_unified_t wmi_handle,
  411. struct pmo_ns_offload_params *ns_req, uint8_t **buf_ptr)
  412. {
  413. }
  414. static void fill_nsoffload_ext_tlv(wmi_unified_t wmi_handle,
  415. struct pmo_ns_offload_params *ns_req, uint8_t **buf_ptr)
  416. {
  417. }
  418. #endif
  419. /**
  420. * send_enable_arp_ns_offload_cmd_tlv() - enable ARP NS offload
  421. * @wma: wmi handle
  422. * @arp_offload_req: arp offload request
  423. * @ns_offload_req: ns offload request
  424. * @arp_only: flag
  425. *
  426. * To configure ARP NS off load data to firmware
  427. * when target goes to wow mode.
  428. *
  429. * Return: QDF Status
  430. */
  431. static QDF_STATUS send_enable_arp_ns_offload_cmd_tlv(wmi_unified_t wmi_handle,
  432. struct pmo_arp_offload_params *arp_offload_req,
  433. struct pmo_ns_offload_params *ns_offload_req,
  434. uint8_t vdev_id)
  435. {
  436. int32_t res;
  437. WMI_SET_ARP_NS_OFFLOAD_CMD_fixed_param *cmd;
  438. uint8_t *buf_ptr;
  439. wmi_buf_t buf;
  440. int32_t len;
  441. uint32_t count = 0, num_ns_ext_tuples = 0;
  442. count = ns_offload_req->num_ns_offload_count;
  443. /*
  444. * TLV place holder size for array of NS tuples
  445. * TLV place holder size for array of ARP tuples
  446. */
  447. len = sizeof(WMI_SET_ARP_NS_OFFLOAD_CMD_fixed_param) +
  448. WMI_TLV_HDR_SIZE +
  449. WMI_MAX_NS_OFFLOADS * sizeof(WMI_NS_OFFLOAD_TUPLE) +
  450. WMI_TLV_HDR_SIZE +
  451. WMI_MAX_ARP_OFFLOADS * sizeof(WMI_ARP_OFFLOAD_TUPLE);
  452. /*
  453. * If there are more than WMI_MAX_NS_OFFLOADS addresses then allocate
  454. * extra length for extended NS offload tuples which follows ARP offload
  455. * tuples. Host needs to fill this structure in following format:
  456. * 2 NS ofload tuples
  457. * 2 ARP offload tuples
  458. * N numbers of extended NS offload tuples if HDD has given more than
  459. * 2 NS offload addresses
  460. */
  461. if (count > WMI_MAX_NS_OFFLOADS) {
  462. num_ns_ext_tuples = count - WMI_MAX_NS_OFFLOADS;
  463. len += WMI_TLV_HDR_SIZE + num_ns_ext_tuples
  464. * sizeof(WMI_NS_OFFLOAD_TUPLE);
  465. }
  466. buf = wmi_buf_alloc(wmi_handle, len);
  467. if (!buf) {
  468. return QDF_STATUS_E_NOMEM;
  469. }
  470. buf_ptr = (uint8_t *) wmi_buf_data(buf);
  471. cmd = (WMI_SET_ARP_NS_OFFLOAD_CMD_fixed_param *) buf_ptr;
  472. WMITLV_SET_HDR(&cmd->tlv_header,
  473. WMITLV_TAG_STRUC_WMI_SET_ARP_NS_OFFLOAD_CMD_fixed_param,
  474. WMITLV_GET_STRUCT_TLVLEN
  475. (WMI_SET_ARP_NS_OFFLOAD_CMD_fixed_param));
  476. cmd->flags = 0;
  477. cmd->vdev_id = vdev_id;
  478. cmd->num_ns_ext_tuples = num_ns_ext_tuples;
  479. wmi_debug("ARP NS Offload vdev_id: %d", cmd->vdev_id);
  480. buf_ptr += sizeof(WMI_SET_ARP_NS_OFFLOAD_CMD_fixed_param);
  481. fill_ns_offload_params_tlv(wmi_handle, ns_offload_req, &buf_ptr);
  482. fill_arp_offload_params_tlv(wmi_handle, arp_offload_req, &buf_ptr);
  483. if (num_ns_ext_tuples)
  484. fill_nsoffload_ext_tlv(wmi_handle, ns_offload_req, &buf_ptr);
  485. wmi_mtrace(WMI_SET_ARP_NS_OFFLOAD_CMDID, cmd->vdev_id, 0);
  486. res = wmi_unified_cmd_send(wmi_handle, buf, len,
  487. WMI_SET_ARP_NS_OFFLOAD_CMDID);
  488. if (res) {
  489. wmi_err("Failed to enable ARP NDP/NSffload");
  490. wmi_buf_free(buf);
  491. return QDF_STATUS_E_FAILURE;
  492. }
  493. return QDF_STATUS_SUCCESS;
  494. }
  495. /**
  496. * send_add_clear_mcbc_filter_cmd_tlv() - set mcast filter command to fw
  497. * @wmi_handle: wmi handle
  498. * @vdev_id: vdev id
  499. * @multicastAddr: mcast address
  500. * @clearList: clear list flag
  501. *
  502. * Return: QDF_STATUS_SUCCESS for success or error code
  503. */
  504. static QDF_STATUS send_add_clear_mcbc_filter_cmd_tlv(wmi_unified_t wmi_handle,
  505. uint8_t vdev_id,
  506. struct qdf_mac_addr multicast_addr,
  507. bool clearList)
  508. {
  509. WMI_SET_MCASTBCAST_FILTER_CMD_fixed_param *cmd;
  510. wmi_buf_t buf;
  511. int err;
  512. buf = wmi_buf_alloc(wmi_handle, sizeof(*cmd));
  513. if (!buf) {
  514. return QDF_STATUS_E_NOMEM;
  515. }
  516. cmd = (WMI_SET_MCASTBCAST_FILTER_CMD_fixed_param *) wmi_buf_data(buf);
  517. qdf_mem_zero(cmd, sizeof(*cmd));
  518. WMITLV_SET_HDR(&cmd->tlv_header,
  519. WMITLV_TAG_STRUC_WMI_SET_MCASTBCAST_FILTER_CMD_fixed_param,
  520. WMITLV_GET_STRUCT_TLVLEN
  521. (WMI_SET_MCASTBCAST_FILTER_CMD_fixed_param));
  522. cmd->action =
  523. (clearList ? WMI_MCAST_FILTER_DELETE : WMI_MCAST_FILTER_SET);
  524. cmd->vdev_id = vdev_id;
  525. WMI_CHAR_ARRAY_TO_MAC_ADDR(multicast_addr.bytes, &cmd->mcastbdcastaddr);
  526. wmi_debug("Action:%d; vdev_id:%d; clearList:%d; MCBC MAC Addr: "QDF_MAC_ADDR_FMT,
  527. cmd->action, vdev_id, clearList,
  528. QDF_MAC_ADDR_REF(multicast_addr.bytes));
  529. wmi_mtrace(WMI_SET_MCASTBCAST_FILTER_CMDID, cmd->vdev_id, 0);
  530. err = wmi_unified_cmd_send(wmi_handle, buf,
  531. sizeof(*cmd),
  532. WMI_SET_MCASTBCAST_FILTER_CMDID);
  533. if (err) {
  534. wmi_err("Failed to send set_param cmd");
  535. wmi_buf_free(buf);
  536. return QDF_STATUS_E_FAILURE;
  537. }
  538. return QDF_STATUS_SUCCESS;
  539. }
  540. /**
  541. * send_multiple_add_clear_mcbc_filter_cmd_tlv() - send multiple mcast filter
  542. * command to fw
  543. * @wmi_handle: wmi handle
  544. * @vdev_id: vdev id
  545. * @mcast_filter_params: mcast filter params
  546. *
  547. * Return: QDF_STATUS_SUCCESS for success or error code
  548. */
  549. static QDF_STATUS send_multiple_add_clear_mcbc_filter_cmd_tlv(
  550. wmi_unified_t wmi_handle,
  551. uint8_t vdev_id,
  552. struct pmo_mcast_filter_params *filter_param)
  553. {
  554. WMI_SET_MULTIPLE_MCAST_FILTER_CMD_fixed_param *cmd;
  555. uint8_t *buf_ptr;
  556. wmi_buf_t buf;
  557. int err;
  558. int i;
  559. uint8_t *mac_addr_src_ptr = NULL;
  560. wmi_mac_addr *mac_addr_dst_ptr;
  561. uint32_t len = sizeof(*cmd) + WMI_TLV_HDR_SIZE +
  562. sizeof(wmi_mac_addr) * filter_param->multicast_addr_cnt;
  563. buf = wmi_buf_alloc(wmi_handle, len);
  564. if (!buf) {
  565. return QDF_STATUS_E_NOMEM;
  566. }
  567. buf_ptr = (uint8_t *) wmi_buf_data(buf);
  568. cmd = (WMI_SET_MULTIPLE_MCAST_FILTER_CMD_fixed_param *)
  569. wmi_buf_data(buf);
  570. qdf_mem_zero(cmd, sizeof(*cmd));
  571. WMITLV_SET_HDR(&cmd->tlv_header,
  572. WMITLV_TAG_STRUC_wmi_set_multiple_mcast_filter_cmd_fixed_param,
  573. WMITLV_GET_STRUCT_TLVLEN
  574. (WMI_SET_MULTIPLE_MCAST_FILTER_CMD_fixed_param));
  575. cmd->operation =
  576. ((filter_param->action == 0) ? WMI_MULTIPLE_MCAST_FILTER_DELETE
  577. : WMI_MULTIPLE_MCAST_FILTER_ADD);
  578. cmd->vdev_id = vdev_id;
  579. cmd->num_mcastaddrs = filter_param->multicast_addr_cnt;
  580. buf_ptr += sizeof(*cmd);
  581. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_FIXED_STRUC,
  582. sizeof(wmi_mac_addr) *
  583. filter_param->multicast_addr_cnt);
  584. if (filter_param->multicast_addr_cnt == 0)
  585. goto send_cmd;
  586. mac_addr_src_ptr = (uint8_t *)&filter_param->multicast_addr;
  587. mac_addr_dst_ptr = (wmi_mac_addr *)
  588. (buf_ptr + WMI_TLV_HDR_SIZE);
  589. for (i = 0; i < filter_param->multicast_addr_cnt; i++) {
  590. WMI_CHAR_ARRAY_TO_MAC_ADDR(mac_addr_src_ptr, mac_addr_dst_ptr);
  591. mac_addr_src_ptr += ATH_MAC_LEN;
  592. mac_addr_dst_ptr++;
  593. }
  594. send_cmd:
  595. wmi_mtrace(WMI_SET_MULTIPLE_MCAST_FILTER_CMDID, cmd->vdev_id, 0);
  596. err = wmi_unified_cmd_send(wmi_handle, buf,
  597. len,
  598. WMI_SET_MULTIPLE_MCAST_FILTER_CMDID);
  599. if (err) {
  600. wmi_err("Failed to send set_param cmd");
  601. wmi_buf_free(buf);
  602. return QDF_STATUS_E_FAILURE;
  603. }
  604. return QDF_STATUS_SUCCESS;
  605. }
  606. static QDF_STATUS send_conf_hw_filter_cmd_tlv(wmi_unified_t wmi,
  607. struct pmo_hw_filter_params *req)
  608. {
  609. QDF_STATUS status;
  610. wmi_hw_data_filter_cmd_fixed_param *cmd;
  611. wmi_buf_t wmi_buf;
  612. if (!req) {
  613. wmi_err("req is null");
  614. return QDF_STATUS_E_INVAL;
  615. }
  616. wmi_buf = wmi_buf_alloc(wmi, sizeof(*cmd));
  617. if (!wmi_buf) {
  618. return QDF_STATUS_E_NOMEM;
  619. }
  620. cmd = (wmi_hw_data_filter_cmd_fixed_param *)wmi_buf_data(wmi_buf);
  621. WMITLV_SET_HDR(&cmd->tlv_header,
  622. WMITLV_TAG_STRUC_wmi_hw_data_filter_cmd_fixed_param,
  623. WMITLV_GET_STRUCT_TLVLEN(wmi_hw_data_filter_cmd_fixed_param));
  624. cmd->vdev_id = req->vdev_id;
  625. cmd->enable = req->enable;
  626. /* Set all modes in case of disable */
  627. if (!cmd->enable)
  628. cmd->hw_filter_bitmap = ((uint32_t)~0U);
  629. else
  630. cmd->hw_filter_bitmap = req->mode_bitmap;
  631. wmi_debug("Send %s hw filter mode: 0x%X for vdev id %d",
  632. req->enable ? "enable" : "disable", req->mode_bitmap,
  633. req->vdev_id);
  634. wmi_mtrace(WMI_HW_DATA_FILTER_CMDID, cmd->vdev_id, 0);
  635. status = wmi_unified_cmd_send(wmi, wmi_buf, sizeof(*cmd),
  636. WMI_HW_DATA_FILTER_CMDID);
  637. if (QDF_IS_STATUS_ERROR(status)) {
  638. wmi_err("Failed to configure hw filter");
  639. wmi_buf_free(wmi_buf);
  640. }
  641. return status;
  642. }
  643. static void
  644. fill_fils_tlv_params(WMI_GTK_OFFLOAD_CMD_fixed_param *cmd,
  645. uint8_t vdev_id,
  646. struct pmo_gtk_req *params)
  647. {
  648. uint8_t *buf_ptr;
  649. wmi_gtk_offload_fils_tlv_param *ext_param;
  650. buf_ptr = (uint8_t *) cmd + sizeof(*cmd);
  651. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
  652. sizeof(*ext_param));
  653. buf_ptr += WMI_TLV_HDR_SIZE;
  654. ext_param = (wmi_gtk_offload_fils_tlv_param *)buf_ptr;
  655. WMITLV_SET_HDR(&ext_param->tlv_header,
  656. WMITLV_TAG_STRUC_wmi_gtk_offload_extended_tlv_param,
  657. WMITLV_GET_STRUCT_TLVLEN(
  658. wmi_gtk_offload_fils_tlv_param));
  659. ext_param->vdev_id = vdev_id;
  660. ext_param->flags = cmd->flags;
  661. ext_param->kek_len = params->kek_len;
  662. qdf_mem_copy(ext_param->KEK, params->kek, params->kek_len);
  663. qdf_mem_copy(ext_param->KCK, params->kck,
  664. WMI_GTK_OFFLOAD_KCK_BYTES);
  665. qdf_mem_copy(ext_param->replay_counter, &params->replay_counter,
  666. GTK_REPLAY_COUNTER_BYTES);
  667. }
  668. /**
  669. * send_gtk_offload_cmd_tlv() - send GTK offload command to fw
  670. * @wmi_handle: wmi handle
  671. * @vdev_id: vdev id
  672. * @params: GTK offload parameters
  673. *
  674. * Return: CDF status
  675. */
  676. static
  677. QDF_STATUS send_gtk_offload_cmd_tlv(wmi_unified_t wmi_handle, uint8_t vdev_id,
  678. struct pmo_gtk_req *params,
  679. bool enable_offload,
  680. uint32_t gtk_offload_opcode)
  681. {
  682. int len;
  683. wmi_buf_t buf;
  684. WMI_GTK_OFFLOAD_CMD_fixed_param *cmd;
  685. QDF_STATUS status = QDF_STATUS_SUCCESS;
  686. len = sizeof(*cmd);
  687. if (params->is_fils_connection)
  688. len += WMI_TLV_HDR_SIZE +
  689. sizeof(wmi_gtk_offload_fils_tlv_param);
  690. /* alloc wmi buffer */
  691. buf = wmi_buf_alloc(wmi_handle, len);
  692. if (!buf) {
  693. status = QDF_STATUS_E_NOMEM;
  694. goto out;
  695. }
  696. cmd = (WMI_GTK_OFFLOAD_CMD_fixed_param *) wmi_buf_data(buf);
  697. WMITLV_SET_HDR(&cmd->tlv_header,
  698. WMITLV_TAG_STRUC_WMI_GTK_OFFLOAD_CMD_fixed_param,
  699. WMITLV_GET_STRUCT_TLVLEN
  700. (WMI_GTK_OFFLOAD_CMD_fixed_param));
  701. cmd->vdev_id = vdev_id;
  702. /* Request target to enable GTK offload */
  703. if (enable_offload == PMO_GTK_OFFLOAD_ENABLE) {
  704. cmd->flags = gtk_offload_opcode;
  705. /* Copy the keys and replay counter */
  706. qdf_mem_copy(cmd->KCK, params->kck, sizeof(cmd->KCK));
  707. qdf_mem_copy(cmd->KEK, params->kek, sizeof(cmd->KEK));
  708. qdf_mem_copy(cmd->replay_counter, &params->replay_counter,
  709. GTK_REPLAY_COUNTER_BYTES);
  710. } else {
  711. cmd->flags = gtk_offload_opcode;
  712. }
  713. if (params->is_fils_connection)
  714. fill_fils_tlv_params(cmd, vdev_id, params);
  715. wmi_debug("VDEVID: %d, GTK_FLAGS: x%x kek len %d",
  716. vdev_id, cmd->flags, params->kek_len);
  717. /* send the wmi command */
  718. wmi_mtrace(WMI_GTK_OFFLOAD_CMDID, cmd->vdev_id, 0);
  719. if (wmi_unified_cmd_send(wmi_handle, buf, len,
  720. WMI_GTK_OFFLOAD_CMDID)) {
  721. wmi_err("Failed to send WMI_GTK_OFFLOAD_CMDID");
  722. wmi_buf_free(buf);
  723. status = QDF_STATUS_E_FAILURE;
  724. }
  725. out:
  726. return status;
  727. }
  728. /**
  729. * send_process_gtk_offload_getinfo_cmd_tlv() - send GTK offload cmd to fw
  730. * @wmi_handle: wmi handle
  731. * @params: GTK offload params
  732. *
  733. * Return: CDF status
  734. */
  735. static QDF_STATUS send_process_gtk_offload_getinfo_cmd_tlv(
  736. wmi_unified_t wmi_handle,
  737. uint8_t vdev_id,
  738. uint64_t offload_req_opcode)
  739. {
  740. int len;
  741. wmi_buf_t buf;
  742. WMI_GTK_OFFLOAD_CMD_fixed_param *cmd;
  743. QDF_STATUS status = QDF_STATUS_SUCCESS;
  744. len = sizeof(*cmd);
  745. /* alloc wmi buffer */
  746. buf = wmi_buf_alloc(wmi_handle, len);
  747. if (!buf) {
  748. status = QDF_STATUS_E_NOMEM;
  749. goto out;
  750. }
  751. cmd = (WMI_GTK_OFFLOAD_CMD_fixed_param *) wmi_buf_data(buf);
  752. WMITLV_SET_HDR(&cmd->tlv_header,
  753. WMITLV_TAG_STRUC_WMI_GTK_OFFLOAD_CMD_fixed_param,
  754. WMITLV_GET_STRUCT_TLVLEN
  755. (WMI_GTK_OFFLOAD_CMD_fixed_param));
  756. /* Request for GTK offload status */
  757. cmd->flags = offload_req_opcode;
  758. cmd->vdev_id = vdev_id;
  759. /* send the wmi command */
  760. wmi_mtrace(WMI_GTK_OFFLOAD_CMDID, cmd->vdev_id, 0);
  761. if (wmi_unified_cmd_send(wmi_handle, buf, len,
  762. WMI_GTK_OFFLOAD_CMDID)) {
  763. wmi_err("Failed to send WMI_GTK_OFFLOAD_CMDID for req info");
  764. wmi_buf_free(buf);
  765. status = QDF_STATUS_E_FAILURE;
  766. }
  767. out:
  768. return status;
  769. }
  770. /**
  771. * send_enable_enhance_multicast_offload_tlv() - send enhance multicast offload
  772. * @wmi_handle: wmi handle
  773. * @vdev_id: vdev id
  774. * @action: true for enable else false
  775. *
  776. * To enable enhance multicast offload to firmware
  777. * when target goes to wow mode.
  778. *
  779. * Return: QDF Status
  780. */
  781. static
  782. QDF_STATUS send_enable_enhance_multicast_offload_tlv(
  783. wmi_unified_t wmi_handle,
  784. uint8_t vdev_id, bool action)
  785. {
  786. QDF_STATUS status;
  787. wmi_buf_t buf;
  788. wmi_config_enhanced_mcast_filter_cmd_fixed_param *cmd;
  789. buf = wmi_buf_alloc(wmi_handle, sizeof(*cmd));
  790. if (!buf) {
  791. return QDF_STATUS_E_NOMEM;
  792. }
  793. cmd = (wmi_config_enhanced_mcast_filter_cmd_fixed_param *)
  794. wmi_buf_data(buf);
  795. WMITLV_SET_HDR(&cmd->tlv_header,
  796. WMITLV_TAG_STRUC_wmi_config_enhanced_mcast_filter_fixed_param,
  797. WMITLV_GET_STRUCT_TLVLEN(
  798. wmi_config_enhanced_mcast_filter_cmd_fixed_param));
  799. cmd->vdev_id = vdev_id;
  800. cmd->enable = ((action == 0) ? ENHANCED_MCAST_FILTER_DISABLED :
  801. ENHANCED_MCAST_FILTER_ENABLED);
  802. wmi_debug("config enhance multicast offload action %d for vdev %d",
  803. action, vdev_id);
  804. wmi_mtrace(WMI_CONFIG_ENHANCED_MCAST_FILTER_CMDID, cmd->vdev_id, 0);
  805. status = wmi_unified_cmd_send(wmi_handle, buf,
  806. sizeof(*cmd), WMI_CONFIG_ENHANCED_MCAST_FILTER_CMDID);
  807. if (status != QDF_STATUS_SUCCESS) {
  808. wmi_buf_free(buf);
  809. wmi_err("Failed to send ENHANCED_MCAST_FILTER_CMDID");
  810. }
  811. return status;
  812. }
  813. /**
  814. * extract_gtk_rsp_event_tlv() - extract gtk rsp params from event
  815. * @wmi_handle: wmi handle
  816. * @param evt_buf: pointer to event buffer
  817. * @param hdr: Pointer to hold header
  818. * @param bufp: Pointer to hold pointer to rx param buffer
  819. *
  820. * Return: QDF_STATUS_SUCCESS for success or error code
  821. */
  822. static QDF_STATUS extract_gtk_rsp_event_tlv(wmi_unified_t wmi_handle,
  823. void *evt_buf, struct pmo_gtk_rsp_params *gtk_rsp_param, uint32_t len)
  824. {
  825. WMI_GTK_OFFLOAD_STATUS_EVENT_fixed_param *fixed_param;
  826. WMI_GTK_OFFLOAD_STATUS_EVENTID_param_tlvs *param_buf;
  827. param_buf = (WMI_GTK_OFFLOAD_STATUS_EVENTID_param_tlvs *)evt_buf;
  828. if (!param_buf) {
  829. wmi_err("gtk param_buf is NULL");
  830. return QDF_STATUS_E_INVAL;
  831. }
  832. if (len < sizeof(WMI_GTK_OFFLOAD_STATUS_EVENT_fixed_param)) {
  833. wmi_err("Invalid length for GTK status");
  834. return QDF_STATUS_E_INVAL;
  835. }
  836. fixed_param = (WMI_GTK_OFFLOAD_STATUS_EVENT_fixed_param *)
  837. param_buf->fixed_param;
  838. if (fixed_param->vdev_id >= WLAN_UMAC_PSOC_MAX_VDEVS) {
  839. wmi_err_rl("Invalid vdev_id %u", fixed_param->vdev_id);
  840. return QDF_STATUS_E_INVAL;
  841. }
  842. gtk_rsp_param->vdev_id = fixed_param->vdev_id;
  843. gtk_rsp_param->status_flag = QDF_STATUS_SUCCESS;
  844. gtk_rsp_param->refresh_cnt = fixed_param->refresh_cnt;
  845. qdf_mem_copy(&gtk_rsp_param->replay_counter,
  846. &fixed_param->replay_counter,
  847. GTK_REPLAY_COUNTER_BYTES);
  848. return QDF_STATUS_SUCCESS;
  849. }
  850. #ifdef FEATURE_WLAN_RA_FILTERING
  851. /**
  852. * send_wow_sta_ra_filter_cmd_tlv() - set RA filter pattern in fw
  853. * @wmi_handle: wmi handle
  854. * @vdev_id: vdev id
  855. *
  856. * Return: CDF status
  857. */
  858. static QDF_STATUS send_wow_sta_ra_filter_cmd_tlv(wmi_unified_t wmi_handle,
  859. uint8_t vdev_id,
  860. uint8_t default_pattern,
  861. uint16_t rate_limit_interval)
  862. {
  863. WMI_WOW_ADD_PATTERN_CMD_fixed_param *cmd;
  864. wmi_buf_t buf;
  865. uint8_t *buf_ptr;
  866. int32_t len;
  867. int ret;
  868. len = sizeof(WMI_WOW_ADD_PATTERN_CMD_fixed_param) +
  869. WMI_TLV_HDR_SIZE +
  870. 0 * sizeof(WOW_BITMAP_PATTERN_T) +
  871. WMI_TLV_HDR_SIZE +
  872. 0 * sizeof(WOW_IPV4_SYNC_PATTERN_T) +
  873. WMI_TLV_HDR_SIZE +
  874. 0 * sizeof(WOW_IPV6_SYNC_PATTERN_T) +
  875. WMI_TLV_HDR_SIZE +
  876. 0 * sizeof(WOW_MAGIC_PATTERN_CMD) +
  877. WMI_TLV_HDR_SIZE +
  878. 0 * sizeof(uint32_t) + WMI_TLV_HDR_SIZE + 1 * sizeof(uint32_t);
  879. buf = wmi_buf_alloc(wmi_handle, len);
  880. if (!buf) {
  881. return QDF_STATUS_E_NOMEM;
  882. }
  883. cmd = (WMI_WOW_ADD_PATTERN_CMD_fixed_param *) wmi_buf_data(buf);
  884. buf_ptr = (uint8_t *) cmd;
  885. WMITLV_SET_HDR(&cmd->tlv_header,
  886. WMITLV_TAG_STRUC_WMI_WOW_ADD_PATTERN_CMD_fixed_param,
  887. WMITLV_GET_STRUCT_TLVLEN
  888. (WMI_WOW_ADD_PATTERN_CMD_fixed_param));
  889. cmd->vdev_id = vdev_id;
  890. cmd->pattern_id = default_pattern,
  891. cmd->pattern_type = WOW_IPV6_RA_PATTERN;
  892. buf_ptr += sizeof(WMI_WOW_ADD_PATTERN_CMD_fixed_param);
  893. /* Fill TLV for WMITLV_TAG_STRUC_WOW_BITMAP_PATTERN_T but no data. */
  894. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC, 0);
  895. buf_ptr += WMI_TLV_HDR_SIZE;
  896. /* Fill TLV for WMITLV_TAG_STRUC_WOW_IPV4_SYNC_PATTERN_T but no data. */
  897. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC, 0);
  898. buf_ptr += WMI_TLV_HDR_SIZE;
  899. /* Fill TLV for WMITLV_TAG_STRUC_WOW_IPV6_SYNC_PATTERN_T but no data. */
  900. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC, 0);
  901. buf_ptr += WMI_TLV_HDR_SIZE;
  902. /* Fill TLV for WMITLV_TAG_STRUC_WOW_MAGIC_PATTERN_CMD but no data. */
  903. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC, 0);
  904. buf_ptr += WMI_TLV_HDR_SIZE;
  905. /* Fill TLV for pattern_info_timeout but no data. */
  906. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_UINT32, 0);
  907. buf_ptr += WMI_TLV_HDR_SIZE;
  908. /* Fill TLV for ra_ratelimit_interval. */
  909. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_UINT32, sizeof(uint32_t));
  910. buf_ptr += WMI_TLV_HDR_SIZE;
  911. *((uint32_t *) buf_ptr) = rate_limit_interval;
  912. wmi_debug("send RA rate limit [%d] to fw vdev = %d",
  913. rate_limit_interval, vdev_id);
  914. wmi_mtrace(WMI_WOW_ADD_WAKE_PATTERN_CMDID, cmd->vdev_id, 0);
  915. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  916. WMI_WOW_ADD_WAKE_PATTERN_CMDID);
  917. if (ret) {
  918. wmi_err("Failed to send RA rate limit to fw");
  919. wmi_buf_free(buf);
  920. return QDF_STATUS_E_FAILURE;
  921. }
  922. return QDF_STATUS_SUCCESS;
  923. }
  924. void wmi_ra_filtering_attach_tlv(struct wmi_unified *wmi_handle)
  925. {
  926. struct wmi_ops *ops = wmi_handle->ops;
  927. ops->send_wow_sta_ra_filter_cmd = send_wow_sta_ra_filter_cmd_tlv;
  928. }
  929. #endif /* FEATURE_WLAN_RA_FILTERING */
  930. /**
  931. * send_action_frame_patterns_cmd_tlv() - send wmi cmd of action filter params
  932. * @wmi_handle: wmi handler
  933. * @action_params: pointer to action_params
  934. *
  935. * Return: 0 for success, otherwise appropriate error code
  936. */
  937. static QDF_STATUS send_action_frame_patterns_cmd_tlv(wmi_unified_t wmi_handle,
  938. struct pmo_action_wakeup_set_params *action_params)
  939. {
  940. WMI_WOW_SET_ACTION_WAKE_UP_CMD_fixed_param *cmd;
  941. wmi_buf_t buf;
  942. int i;
  943. int32_t err;
  944. uint32_t len = 0, *cmd_args;
  945. uint8_t *buf_ptr;
  946. len = (PMO_SUPPORTED_ACTION_CATE * sizeof(uint32_t))
  947. + WMI_TLV_HDR_SIZE + sizeof(*cmd);
  948. buf = wmi_buf_alloc(wmi_handle, len);
  949. if (!buf) {
  950. return QDF_STATUS_E_NOMEM;
  951. }
  952. cmd = (WMI_WOW_SET_ACTION_WAKE_UP_CMD_fixed_param *) wmi_buf_data(buf);
  953. buf_ptr = (uint8_t *)cmd;
  954. WMITLV_SET_HDR(&cmd->tlv_header,
  955. WMITLV_TAG_STRUC_wmi_wow_set_action_wake_up_cmd_fixed_param,
  956. WMITLV_GET_STRUCT_TLVLEN(
  957. WMI_WOW_SET_ACTION_WAKE_UP_CMD_fixed_param));
  958. cmd->vdev_id = action_params->vdev_id;
  959. cmd->operation = action_params->operation;
  960. for (i = 0; i < MAX_SUPPORTED_ACTION_CATEGORY_ELE_LIST; i++)
  961. cmd->action_category_map[i] =
  962. action_params->action_category_map[i];
  963. buf_ptr += sizeof(WMI_WOW_SET_ACTION_WAKE_UP_CMD_fixed_param);
  964. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_UINT32,
  965. (PMO_SUPPORTED_ACTION_CATE * sizeof(uint32_t)));
  966. buf_ptr += WMI_TLV_HDR_SIZE;
  967. cmd_args = (uint32_t *) buf_ptr;
  968. for (i = 0; i < PMO_SUPPORTED_ACTION_CATE; i++)
  969. cmd_args[i] = action_params->action_per_category[i];
  970. wmi_mtrace(WMI_WOW_SET_ACTION_WAKE_UP_CMDID, cmd->vdev_id, 0);
  971. err = wmi_unified_cmd_send(wmi_handle, buf,
  972. len, WMI_WOW_SET_ACTION_WAKE_UP_CMDID);
  973. if (err) {
  974. wmi_err("Failed to send ap_ps_egap cmd");
  975. wmi_buf_free(buf);
  976. return QDF_STATUS_E_FAILURE;
  977. }
  978. return QDF_STATUS_SUCCESS;
  979. }
  980. #ifdef FEATURE_WLAN_LPHB
  981. /**
  982. * send_lphb_config_hbenable_cmd_tlv() - enable command of LPHB configuration
  983. * @wmi_handle: wmi handle
  984. * @lphb_conf_req: configuration info
  985. *
  986. * Return: CDF status
  987. */
  988. static QDF_STATUS send_lphb_config_hbenable_cmd_tlv(wmi_unified_t wmi_handle,
  989. wmi_hb_set_enable_cmd_fixed_param *params)
  990. {
  991. QDF_STATUS status;
  992. wmi_buf_t buf = NULL;
  993. uint8_t *buf_ptr;
  994. wmi_hb_set_enable_cmd_fixed_param *hb_enable_fp;
  995. int len = sizeof(wmi_hb_set_enable_cmd_fixed_param);
  996. buf = wmi_buf_alloc(wmi_handle, len);
  997. if (!buf) {
  998. return QDF_STATUS_E_NOMEM;
  999. }
  1000. buf_ptr = (uint8_t *) wmi_buf_data(buf);
  1001. hb_enable_fp = (wmi_hb_set_enable_cmd_fixed_param *) buf_ptr;
  1002. WMITLV_SET_HDR(&hb_enable_fp->tlv_header,
  1003. WMITLV_TAG_STRUC_wmi_hb_set_enable_cmd_fixed_param,
  1004. WMITLV_GET_STRUCT_TLVLEN
  1005. (wmi_hb_set_enable_cmd_fixed_param));
  1006. /* fill in values */
  1007. hb_enable_fp->vdev_id = params->session;
  1008. hb_enable_fp->enable = params->enable;
  1009. hb_enable_fp->item = params->item;
  1010. hb_enable_fp->session = params->session;
  1011. wmi_mtrace(WMI_HB_SET_ENABLE_CMDID, NO_SESSION, 0);
  1012. status = wmi_unified_cmd_send(wmi_handle, buf,
  1013. len, WMI_HB_SET_ENABLE_CMDID);
  1014. if (QDF_IS_STATUS_ERROR(status)) {
  1015. wmi_err("cmd_send WMI_HB_SET_ENABLE returned Error %d",
  1016. status);
  1017. wmi_buf_free(buf);
  1018. }
  1019. return status;
  1020. }
  1021. /**
  1022. * send_lphb_config_tcp_params_cmd_tlv() - set tcp params of LPHB configuration
  1023. * @wmi_handle: wmi handle
  1024. * @lphb_conf_req: lphb config request
  1025. *
  1026. * Return: CDF status
  1027. */
  1028. static QDF_STATUS send_lphb_config_tcp_params_cmd_tlv(wmi_unified_t wmi_handle,
  1029. wmi_hb_set_tcp_params_cmd_fixed_param *lphb_conf_req)
  1030. {
  1031. QDF_STATUS status;
  1032. wmi_buf_t buf = NULL;
  1033. uint8_t *buf_ptr;
  1034. wmi_hb_set_tcp_params_cmd_fixed_param *hb_tcp_params_fp;
  1035. int len = sizeof(wmi_hb_set_tcp_params_cmd_fixed_param);
  1036. buf = wmi_buf_alloc(wmi_handle, len);
  1037. if (!buf) {
  1038. return QDF_STATUS_E_NOMEM;
  1039. }
  1040. buf_ptr = (uint8_t *) wmi_buf_data(buf);
  1041. hb_tcp_params_fp = (wmi_hb_set_tcp_params_cmd_fixed_param *) buf_ptr;
  1042. WMITLV_SET_HDR(&hb_tcp_params_fp->tlv_header,
  1043. WMITLV_TAG_STRUC_wmi_hb_set_tcp_params_cmd_fixed_param,
  1044. WMITLV_GET_STRUCT_TLVLEN
  1045. (wmi_hb_set_tcp_params_cmd_fixed_param));
  1046. /* fill in values */
  1047. hb_tcp_params_fp->vdev_id = lphb_conf_req->vdev_id;
  1048. hb_tcp_params_fp->srv_ip = lphb_conf_req->srv_ip;
  1049. hb_tcp_params_fp->dev_ip = lphb_conf_req->dev_ip;
  1050. hb_tcp_params_fp->seq = lphb_conf_req->seq;
  1051. hb_tcp_params_fp->src_port = lphb_conf_req->src_port;
  1052. hb_tcp_params_fp->dst_port = lphb_conf_req->dst_port;
  1053. hb_tcp_params_fp->interval = lphb_conf_req->interval;
  1054. hb_tcp_params_fp->timeout = lphb_conf_req->timeout;
  1055. hb_tcp_params_fp->session = lphb_conf_req->session;
  1056. qdf_mem_copy(&hb_tcp_params_fp->gateway_mac,
  1057. &lphb_conf_req->gateway_mac,
  1058. sizeof(hb_tcp_params_fp->gateway_mac));
  1059. wmi_mtrace(WMI_HB_SET_TCP_PARAMS_CMDID, NO_SESSION, 0);
  1060. status = wmi_unified_cmd_send(wmi_handle, buf,
  1061. len, WMI_HB_SET_TCP_PARAMS_CMDID);
  1062. if (QDF_IS_STATUS_ERROR(status)) {
  1063. wmi_err("cmd_send WMI_HB_SET_TCP_PARAMS returned Error %d",
  1064. status);
  1065. wmi_buf_free(buf);
  1066. }
  1067. return status;
  1068. }
  1069. /**
  1070. * send_lphb_config_tcp_pkt_filter_cmd_tlv() - configure tcp packet filter cmd
  1071. * @wmi_handle: wmi handle
  1072. * @lphb_conf_req: lphb config request
  1073. *
  1074. * Return: CDF status
  1075. */
  1076. static
  1077. QDF_STATUS send_lphb_config_tcp_pkt_filter_cmd_tlv(wmi_unified_t wmi_handle,
  1078. wmi_hb_set_tcp_pkt_filter_cmd_fixed_param *g_hb_tcp_filter_fp)
  1079. {
  1080. QDF_STATUS status;
  1081. wmi_buf_t buf = NULL;
  1082. uint8_t *buf_ptr;
  1083. wmi_hb_set_tcp_pkt_filter_cmd_fixed_param *hb_tcp_filter_fp;
  1084. int len = sizeof(wmi_hb_set_tcp_pkt_filter_cmd_fixed_param);
  1085. buf = wmi_buf_alloc(wmi_handle, len);
  1086. if (!buf) {
  1087. return QDF_STATUS_E_NOMEM;
  1088. }
  1089. buf_ptr = (uint8_t *) wmi_buf_data(buf);
  1090. hb_tcp_filter_fp =
  1091. (wmi_hb_set_tcp_pkt_filter_cmd_fixed_param *) buf_ptr;
  1092. WMITLV_SET_HDR(&hb_tcp_filter_fp->tlv_header,
  1093. WMITLV_TAG_STRUC_wmi_hb_set_tcp_pkt_filter_cmd_fixed_param,
  1094. WMITLV_GET_STRUCT_TLVLEN
  1095. (wmi_hb_set_tcp_pkt_filter_cmd_fixed_param));
  1096. /* fill in values */
  1097. hb_tcp_filter_fp->vdev_id = g_hb_tcp_filter_fp->vdev_id;
  1098. hb_tcp_filter_fp->length = g_hb_tcp_filter_fp->length;
  1099. hb_tcp_filter_fp->offset = g_hb_tcp_filter_fp->offset;
  1100. hb_tcp_filter_fp->session = g_hb_tcp_filter_fp->session;
  1101. memcpy((void *)&hb_tcp_filter_fp->filter,
  1102. (void *)&g_hb_tcp_filter_fp->filter,
  1103. WMI_WLAN_HB_MAX_FILTER_SIZE);
  1104. wmi_mtrace(WMI_HB_SET_TCP_PKT_FILTER_CMDID, NO_SESSION, 0);
  1105. status = wmi_unified_cmd_send(wmi_handle, buf,
  1106. len, WMI_HB_SET_TCP_PKT_FILTER_CMDID);
  1107. if (QDF_IS_STATUS_ERROR(status)) {
  1108. wmi_err("cmd_send WMI_HB_SET_TCP_PKT_FILTER returned Error %d",
  1109. status);
  1110. wmi_buf_free(buf);
  1111. }
  1112. return status;
  1113. }
  1114. /**
  1115. * send_lphb_config_udp_params_cmd_tlv() - configure udp param command of LPHB
  1116. * @wmi_handle: wmi handle
  1117. * @lphb_conf_req: lphb config request
  1118. *
  1119. * Return: CDF status
  1120. */
  1121. static QDF_STATUS send_lphb_config_udp_params_cmd_tlv(wmi_unified_t wmi_handle,
  1122. wmi_hb_set_udp_params_cmd_fixed_param *lphb_conf_req)
  1123. {
  1124. QDF_STATUS status;
  1125. wmi_buf_t buf = NULL;
  1126. uint8_t *buf_ptr;
  1127. wmi_hb_set_udp_params_cmd_fixed_param *hb_udp_params_fp;
  1128. int len = sizeof(wmi_hb_set_udp_params_cmd_fixed_param);
  1129. buf = wmi_buf_alloc(wmi_handle, len);
  1130. if (!buf) {
  1131. return QDF_STATUS_E_NOMEM;
  1132. }
  1133. buf_ptr = (uint8_t *) wmi_buf_data(buf);
  1134. hb_udp_params_fp = (wmi_hb_set_udp_params_cmd_fixed_param *) buf_ptr;
  1135. WMITLV_SET_HDR(&hb_udp_params_fp->tlv_header,
  1136. WMITLV_TAG_STRUC_wmi_hb_set_udp_params_cmd_fixed_param,
  1137. WMITLV_GET_STRUCT_TLVLEN
  1138. (wmi_hb_set_udp_params_cmd_fixed_param));
  1139. /* fill in values */
  1140. hb_udp_params_fp->vdev_id = lphb_conf_req->vdev_id;
  1141. hb_udp_params_fp->srv_ip = lphb_conf_req->srv_ip;
  1142. hb_udp_params_fp->dev_ip = lphb_conf_req->dev_ip;
  1143. hb_udp_params_fp->src_port = lphb_conf_req->src_port;
  1144. hb_udp_params_fp->dst_port = lphb_conf_req->dst_port;
  1145. hb_udp_params_fp->interval = lphb_conf_req->interval;
  1146. hb_udp_params_fp->timeout = lphb_conf_req->timeout;
  1147. hb_udp_params_fp->session = lphb_conf_req->session;
  1148. qdf_mem_copy(&hb_udp_params_fp->gateway_mac,
  1149. &lphb_conf_req->gateway_mac,
  1150. sizeof(lphb_conf_req->gateway_mac));
  1151. wmi_mtrace(WMI_HB_SET_UDP_PARAMS_CMDID, NO_SESSION, 0);
  1152. status = wmi_unified_cmd_send(wmi_handle, buf,
  1153. len, WMI_HB_SET_UDP_PARAMS_CMDID);
  1154. if (QDF_IS_STATUS_ERROR(status)) {
  1155. wmi_err("cmd_send WMI_HB_SET_UDP_PARAMS returned Error %d",
  1156. status);
  1157. wmi_buf_free(buf);
  1158. }
  1159. return status;
  1160. }
  1161. /**
  1162. * send_lphb_config_udp_pkt_filter_cmd_tlv() - configure udp pkt filter command
  1163. * @wmi_handle: wmi handle
  1164. * @lphb_conf_req: lphb config request
  1165. *
  1166. * Return: CDF status
  1167. */
  1168. static
  1169. QDF_STATUS send_lphb_config_udp_pkt_filter_cmd_tlv(wmi_unified_t wmi_handle,
  1170. wmi_hb_set_udp_pkt_filter_cmd_fixed_param *lphb_conf_req)
  1171. {
  1172. QDF_STATUS status;
  1173. wmi_buf_t buf = NULL;
  1174. uint8_t *buf_ptr;
  1175. wmi_hb_set_udp_pkt_filter_cmd_fixed_param *hb_udp_filter_fp;
  1176. int len = sizeof(wmi_hb_set_udp_pkt_filter_cmd_fixed_param);
  1177. buf = wmi_buf_alloc(wmi_handle, len);
  1178. if (!buf) {
  1179. return QDF_STATUS_E_NOMEM;
  1180. }
  1181. buf_ptr = (uint8_t *) wmi_buf_data(buf);
  1182. hb_udp_filter_fp =
  1183. (wmi_hb_set_udp_pkt_filter_cmd_fixed_param *) buf_ptr;
  1184. WMITLV_SET_HDR(&hb_udp_filter_fp->tlv_header,
  1185. WMITLV_TAG_STRUC_wmi_hb_set_udp_pkt_filter_cmd_fixed_param,
  1186. WMITLV_GET_STRUCT_TLVLEN
  1187. (wmi_hb_set_udp_pkt_filter_cmd_fixed_param));
  1188. /* fill in values */
  1189. hb_udp_filter_fp->vdev_id = lphb_conf_req->vdev_id;
  1190. hb_udp_filter_fp->length = lphb_conf_req->length;
  1191. hb_udp_filter_fp->offset = lphb_conf_req->offset;
  1192. hb_udp_filter_fp->session = lphb_conf_req->session;
  1193. memcpy((void *)&hb_udp_filter_fp->filter,
  1194. (void *)&lphb_conf_req->filter,
  1195. WMI_WLAN_HB_MAX_FILTER_SIZE);
  1196. wmi_mtrace(WMI_HB_SET_UDP_PKT_FILTER_CMDID, NO_SESSION, 0);
  1197. status = wmi_unified_cmd_send(wmi_handle, buf,
  1198. len, WMI_HB_SET_UDP_PKT_FILTER_CMDID);
  1199. if (QDF_IS_STATUS_ERROR(status)) {
  1200. wmi_err("cmd_send WMI_HB_SET_UDP_PKT_FILTER returned Error %d",
  1201. status);
  1202. wmi_buf_free(buf);
  1203. }
  1204. return status;
  1205. }
  1206. void wmi_lphb_attach_tlv(struct wmi_unified *wmi_handle)
  1207. {
  1208. struct wmi_ops *ops = wmi_handle->ops;
  1209. ops->send_lphb_config_hbenable_cmd =
  1210. send_lphb_config_hbenable_cmd_tlv;
  1211. ops->send_lphb_config_tcp_params_cmd =
  1212. send_lphb_config_tcp_params_cmd_tlv;
  1213. ops->send_lphb_config_tcp_pkt_filter_cmd =
  1214. send_lphb_config_tcp_pkt_filter_cmd_tlv;
  1215. ops->send_lphb_config_udp_params_cmd =
  1216. send_lphb_config_udp_params_cmd_tlv;
  1217. ops->send_lphb_config_udp_pkt_filter_cmd =
  1218. send_lphb_config_udp_pkt_filter_cmd_tlv;
  1219. }
  1220. #endif /* FEATURE_WLAN_LPHB */
  1221. #ifdef WLAN_FEATURE_PACKET_FILTERING
  1222. /**
  1223. * send_enable_disable_packet_filter_cmd_tlv() - enable/disable packet filter
  1224. * @wmi_handle: wmi handle
  1225. * @vdev_id: vdev id
  1226. * @enable: Flag to enable/disable packet filter
  1227. *
  1228. * Return: QDF_STATUS_SUCCESS for success or error code
  1229. */
  1230. static QDF_STATUS send_enable_disable_packet_filter_cmd_tlv(
  1231. wmi_unified_t wmi_handle, uint8_t vdev_id, bool enable)
  1232. {
  1233. int32_t len;
  1234. int ret = 0;
  1235. wmi_buf_t buf;
  1236. WMI_PACKET_FILTER_ENABLE_CMD_fixed_param *cmd;
  1237. len = sizeof(WMI_PACKET_FILTER_ENABLE_CMD_fixed_param);
  1238. buf = wmi_buf_alloc(wmi_handle, len);
  1239. if (!buf) {
  1240. return QDF_STATUS_E_NOMEM;
  1241. }
  1242. cmd = (WMI_PACKET_FILTER_ENABLE_CMD_fixed_param *) wmi_buf_data(buf);
  1243. WMITLV_SET_HDR(&cmd->tlv_header,
  1244. WMITLV_TAG_STRUC_wmi_packet_filter_enable_fixed_param,
  1245. WMITLV_GET_STRUCT_TLVLEN(
  1246. WMI_PACKET_FILTER_ENABLE_CMD_fixed_param));
  1247. cmd->vdev_id = vdev_id;
  1248. if (enable)
  1249. cmd->enable = PACKET_FILTER_SET_ENABLE;
  1250. else
  1251. cmd->enable = PACKET_FILTER_SET_DISABLE;
  1252. wmi_err("Packet filter enable %d for vdev_id %d", cmd->enable, vdev_id);
  1253. wmi_mtrace(WMI_PACKET_FILTER_ENABLE_CMDID, cmd->vdev_id, 0);
  1254. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  1255. WMI_PACKET_FILTER_ENABLE_CMDID);
  1256. if (ret) {
  1257. wmi_err("Failed to send packet filter wmi cmd to fw");
  1258. wmi_buf_free(buf);
  1259. }
  1260. return ret;
  1261. }
  1262. /**
  1263. * send_config_packet_filter_cmd_tlv() - configure packet filter in target
  1264. * @wmi_handle: wmi handle
  1265. * @vdev_id: vdev id
  1266. * @rcv_filter_param: Packet filter parameters
  1267. * @filter_id: Filter id
  1268. * @enable: Flag to add/delete packet filter configuration
  1269. *
  1270. * Return: QDF_STATUS_SUCCESS for success or error code
  1271. */
  1272. static QDF_STATUS send_config_packet_filter_cmd_tlv(wmi_unified_t wmi_handle,
  1273. uint8_t vdev_id, struct pmo_rcv_pkt_fltr_cfg *rcv_filter_param,
  1274. uint8_t filter_id, bool enable)
  1275. {
  1276. int len, i;
  1277. int err = 0;
  1278. wmi_buf_t buf;
  1279. WMI_PACKET_FILTER_CONFIG_CMD_fixed_param *cmd;
  1280. /* allocate the memory */
  1281. len = sizeof(*cmd);
  1282. buf = wmi_buf_alloc(wmi_handle, len);
  1283. if (!buf) {
  1284. return QDF_STATUS_E_NOMEM;
  1285. }
  1286. cmd = (WMI_PACKET_FILTER_CONFIG_CMD_fixed_param *)wmi_buf_data(buf);
  1287. WMITLV_SET_HDR(&cmd->tlv_header,
  1288. WMITLV_TAG_STRUC_wmi_packet_filter_config_fixed_param,
  1289. WMITLV_GET_STRUCT_TLVLEN
  1290. (WMI_PACKET_FILTER_CONFIG_CMD_fixed_param));
  1291. cmd->vdev_id = vdev_id;
  1292. cmd->filter_id = filter_id;
  1293. if (enable)
  1294. cmd->filter_action = PACKET_FILTER_SET_ACTIVE;
  1295. else
  1296. cmd->filter_action = PACKET_FILTER_SET_INACTIVE;
  1297. if (enable) {
  1298. cmd->num_params = QDF_MIN(
  1299. WMI_PACKET_FILTER_MAX_CMP_PER_PACKET_FILTER,
  1300. rcv_filter_param->num_params);
  1301. cmd->filter_type = rcv_filter_param->filter_type;
  1302. cmd->coalesce_time = rcv_filter_param->coalesce_time;
  1303. for (i = 0; i < cmd->num_params; i++) {
  1304. cmd->paramsData[i].proto_type =
  1305. rcv_filter_param->params_data[i].protocol_layer;
  1306. cmd->paramsData[i].cmp_type =
  1307. rcv_filter_param->params_data[i].compare_flag;
  1308. cmd->paramsData[i].data_length =
  1309. rcv_filter_param->params_data[i].data_length;
  1310. cmd->paramsData[i].data_offset =
  1311. rcv_filter_param->params_data[i].data_offset;
  1312. memcpy(&cmd->paramsData[i].compareData,
  1313. rcv_filter_param->params_data[i].compare_data,
  1314. sizeof(cmd->paramsData[i].compareData));
  1315. memcpy(&cmd->paramsData[i].dataMask,
  1316. rcv_filter_param->params_data[i].data_mask,
  1317. sizeof(cmd->paramsData[i].dataMask));
  1318. }
  1319. }
  1320. wmi_err("Packet filter action %d filter with id: %d, num_params=%d",
  1321. cmd->filter_action, cmd->filter_id, cmd->num_params);
  1322. /* send the command along with data */
  1323. wmi_mtrace(WMI_PACKET_FILTER_CONFIG_CMDID, cmd->vdev_id, 0);
  1324. err = wmi_unified_cmd_send(wmi_handle, buf, len,
  1325. WMI_PACKET_FILTER_CONFIG_CMDID);
  1326. if (err) {
  1327. wmi_err("Failed to send pkt_filter cmd");
  1328. wmi_buf_free(buf);
  1329. return QDF_STATUS_E_FAILURE;
  1330. }
  1331. return QDF_STATUS_SUCCESS;
  1332. }
  1333. void wmi_packet_filtering_attach_tlv(struct wmi_unified *wmi_handle)
  1334. {
  1335. struct wmi_ops *ops = wmi_handle->ops;
  1336. ops->send_enable_disable_packet_filter_cmd =
  1337. send_enable_disable_packet_filter_cmd_tlv;
  1338. ops->send_config_packet_filter_cmd =
  1339. send_config_packet_filter_cmd_tlv;
  1340. }
  1341. #endif /* WLAN_FEATURE_PACKET_FILTERING */
  1342. /**
  1343. * send_wow_delete_pattern_cmd_tlv() - delete wow pattern in target
  1344. * @wmi_handle: wmi handle
  1345. * @ptrn_id: pattern id
  1346. * @vdev_id: vdev id
  1347. *
  1348. * Return: CDF status
  1349. */
  1350. static QDF_STATUS send_wow_delete_pattern_cmd_tlv(wmi_unified_t wmi_handle,
  1351. uint8_t ptrn_id,
  1352. uint8_t vdev_id)
  1353. {
  1354. WMI_WOW_DEL_PATTERN_CMD_fixed_param *cmd;
  1355. wmi_buf_t buf;
  1356. int32_t len;
  1357. int ret;
  1358. len = sizeof(WMI_WOW_DEL_PATTERN_CMD_fixed_param);
  1359. buf = wmi_buf_alloc(wmi_handle, len);
  1360. if (!buf) {
  1361. return QDF_STATUS_E_NOMEM;
  1362. }
  1363. cmd = (WMI_WOW_DEL_PATTERN_CMD_fixed_param *) wmi_buf_data(buf);
  1364. WMITLV_SET_HDR(&cmd->tlv_header,
  1365. WMITLV_TAG_STRUC_WMI_WOW_DEL_PATTERN_CMD_fixed_param,
  1366. WMITLV_GET_STRUCT_TLVLEN(
  1367. WMI_WOW_DEL_PATTERN_CMD_fixed_param));
  1368. cmd->vdev_id = vdev_id;
  1369. cmd->pattern_id = ptrn_id;
  1370. cmd->pattern_type = WOW_BITMAP_PATTERN;
  1371. wmi_mtrace(WMI_WOW_DEL_WAKE_PATTERN_CMDID, cmd->vdev_id, 0);
  1372. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  1373. WMI_WOW_DEL_WAKE_PATTERN_CMDID);
  1374. if (ret) {
  1375. wmi_err("Failed to delete wow ptrn from fw");
  1376. wmi_buf_free(buf);
  1377. return QDF_STATUS_E_FAILURE;
  1378. }
  1379. return QDF_STATUS_SUCCESS;
  1380. }
  1381. #ifdef WMI_HOST_WAKEUP_OVER_QMI
  1382. static inline
  1383. QDF_STATUS wmi_unified_cmd_send_chk(struct wmi_unified *wmi_handle,
  1384. wmi_buf_t buf,
  1385. uint32_t buflen, uint32_t cmd_id)
  1386. {
  1387. wmi_debug("Send WMI_WOW_HOSTWAKEUP_FROM_SLEEP_CMDID over QMI");
  1388. return wmi_unified_cmd_send_over_qmi(wmi_handle, buf,
  1389. buflen, cmd_id);
  1390. }
  1391. #else
  1392. static inline
  1393. QDF_STATUS wmi_unified_cmd_send_chk(struct wmi_unified *wmi_handle,
  1394. wmi_buf_t buf,
  1395. uint32_t buflen, uint32_t cmd_id)
  1396. {
  1397. return wmi_unified_cmd_send(wmi_handle, buf,
  1398. buflen, cmd_id);
  1399. }
  1400. #endif
  1401. /**
  1402. * send_host_wakeup_ind_to_fw_cmd_tlv() - send wakeup ind to fw
  1403. * @wmi_handle: wmi handle
  1404. *
  1405. * Sends host wakeup indication to FW. On receiving this indication,
  1406. * FW will come out of WOW.
  1407. *
  1408. * Return: CDF status
  1409. */
  1410. static QDF_STATUS send_host_wakeup_ind_to_fw_cmd_tlv(wmi_unified_t wmi_handle)
  1411. {
  1412. wmi_wow_hostwakeup_from_sleep_cmd_fixed_param *cmd;
  1413. wmi_buf_t buf;
  1414. QDF_STATUS qdf_status = QDF_STATUS_SUCCESS;
  1415. int32_t len;
  1416. int ret;
  1417. len = sizeof(wmi_wow_hostwakeup_from_sleep_cmd_fixed_param);
  1418. buf = wmi_buf_alloc(wmi_handle, len);
  1419. if (!buf) {
  1420. return QDF_STATUS_E_NOMEM;
  1421. }
  1422. cmd = (wmi_wow_hostwakeup_from_sleep_cmd_fixed_param *)
  1423. wmi_buf_data(buf);
  1424. WMITLV_SET_HDR(&cmd->tlv_header,
  1425. WMITLV_TAG_STRUC_wmi_wow_hostwakeup_from_sleep_cmd_fixed_param,
  1426. WMITLV_GET_STRUCT_TLVLEN
  1427. (wmi_wow_hostwakeup_from_sleep_cmd_fixed_param));
  1428. wmi_mtrace(WMI_WOW_HOSTWAKEUP_FROM_SLEEP_CMDID, NO_SESSION, 0);
  1429. ret = wmi_unified_cmd_send_chk(wmi_handle, buf, len,
  1430. WMI_WOW_HOSTWAKEUP_FROM_SLEEP_CMDID);
  1431. if (ret) {
  1432. wmi_err("Failed to send host wakeup indication to fw");
  1433. wmi_buf_free(buf);
  1434. return QDF_STATUS_E_FAILURE;
  1435. }
  1436. return qdf_status;
  1437. }
  1438. /**
  1439. * send_wow_timer_pattern_cmd_tlv() - set timer pattern tlv, so that firmware
  1440. * will wake up host after specified time is elapsed
  1441. * @wmi_handle: wmi handle
  1442. * @vdev_id: vdev id
  1443. * @cookie: value to identify reason why host set up wake call.
  1444. * @time: time in ms
  1445. *
  1446. * Return: QDF status
  1447. */
  1448. static QDF_STATUS send_wow_timer_pattern_cmd_tlv(wmi_unified_t wmi_handle,
  1449. uint8_t vdev_id, uint32_t cookie, uint32_t time)
  1450. {
  1451. WMI_WOW_ADD_PATTERN_CMD_fixed_param *cmd;
  1452. wmi_buf_t buf;
  1453. uint8_t *buf_ptr;
  1454. int32_t len;
  1455. int ret;
  1456. len = sizeof(WMI_WOW_ADD_PATTERN_CMD_fixed_param) +
  1457. WMI_TLV_HDR_SIZE + 0 * sizeof(WOW_BITMAP_PATTERN_T) +
  1458. WMI_TLV_HDR_SIZE + 0 * sizeof(WOW_IPV4_SYNC_PATTERN_T) +
  1459. WMI_TLV_HDR_SIZE + 0 * sizeof(WOW_IPV6_SYNC_PATTERN_T) +
  1460. WMI_TLV_HDR_SIZE + 0 * sizeof(WOW_MAGIC_PATTERN_CMD) +
  1461. WMI_TLV_HDR_SIZE + 1 * sizeof(uint32_t) +
  1462. WMI_TLV_HDR_SIZE + 1 * sizeof(uint32_t);
  1463. buf = wmi_buf_alloc(wmi_handle, len);
  1464. if (!buf) {
  1465. return QDF_STATUS_E_NOMEM;
  1466. }
  1467. cmd = (WMI_WOW_ADD_PATTERN_CMD_fixed_param *) wmi_buf_data(buf);
  1468. buf_ptr = (uint8_t *) cmd;
  1469. WMITLV_SET_HDR(&cmd->tlv_header,
  1470. WMITLV_TAG_STRUC_WMI_WOW_ADD_PATTERN_CMD_fixed_param,
  1471. WMITLV_GET_STRUCT_TLVLEN
  1472. (WMI_WOW_ADD_PATTERN_CMD_fixed_param));
  1473. cmd->vdev_id = vdev_id;
  1474. cmd->pattern_id = cookie,
  1475. cmd->pattern_type = WOW_TIMER_PATTERN;
  1476. buf_ptr += sizeof(WMI_WOW_ADD_PATTERN_CMD_fixed_param);
  1477. /* Fill TLV for WMITLV_TAG_STRUC_WOW_BITMAP_PATTERN_T but no data. */
  1478. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC, 0);
  1479. buf_ptr += WMI_TLV_HDR_SIZE;
  1480. /* Fill TLV for WMITLV_TAG_STRUC_WOW_IPV4_SYNC_PATTERN_T but no data. */
  1481. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC, 0);
  1482. buf_ptr += WMI_TLV_HDR_SIZE;
  1483. /* Fill TLV for WMITLV_TAG_STRUC_WOW_IPV6_SYNC_PATTERN_T but no data. */
  1484. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC, 0);
  1485. buf_ptr += WMI_TLV_HDR_SIZE;
  1486. /* Fill TLV for WMITLV_TAG_STRUC_WOW_MAGIC_PATTERN_CMD but no data. */
  1487. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC, 0);
  1488. buf_ptr += WMI_TLV_HDR_SIZE;
  1489. /* Fill TLV for pattern_info_timeout, and time value */
  1490. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_UINT32, sizeof(uint32_t));
  1491. buf_ptr += WMI_TLV_HDR_SIZE;
  1492. *((uint32_t *) buf_ptr) = time;
  1493. buf_ptr += sizeof(uint32_t);
  1494. /* Fill TLV for ra_ratelimit_interval. with dummy 0 value */
  1495. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_UINT32, sizeof(uint32_t));
  1496. buf_ptr += WMI_TLV_HDR_SIZE;
  1497. *((uint32_t *) buf_ptr) = 0;
  1498. wmi_debug("send wake timer pattern with time[%d] to fw vdev = %d",
  1499. time, vdev_id);
  1500. wmi_mtrace(WMI_WOW_ADD_WAKE_PATTERN_CMDID, cmd->vdev_id, 0);
  1501. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  1502. WMI_WOW_ADD_WAKE_PATTERN_CMDID);
  1503. if (ret) {
  1504. wmi_err("Failed to send wake timer pattern to fw");
  1505. wmi_buf_free(buf);
  1506. return QDF_STATUS_E_FAILURE;
  1507. }
  1508. return QDF_STATUS_SUCCESS;
  1509. }
  1510. #ifdef WLAN_FEATURE_EXTWOW_SUPPORT
  1511. /**
  1512. * send_enable_ext_wow_cmd_tlv() - enable ext wow in fw
  1513. * @wmi_handle: wmi handle
  1514. * @params: ext wow params
  1515. *
  1516. * Return:0 for success or error code
  1517. */
  1518. static QDF_STATUS send_enable_ext_wow_cmd_tlv(wmi_unified_t wmi_handle,
  1519. struct ext_wow_params *params)
  1520. {
  1521. wmi_extwow_enable_cmd_fixed_param *cmd;
  1522. wmi_buf_t buf;
  1523. int32_t len;
  1524. int ret;
  1525. len = sizeof(wmi_extwow_enable_cmd_fixed_param);
  1526. buf = wmi_buf_alloc(wmi_handle, len);
  1527. if (!buf) {
  1528. return QDF_STATUS_E_NOMEM;
  1529. }
  1530. cmd = (wmi_extwow_enable_cmd_fixed_param *) wmi_buf_data(buf);
  1531. WMITLV_SET_HDR(&cmd->tlv_header,
  1532. WMITLV_TAG_STRUC_wmi_extwow_enable_cmd_fixed_param,
  1533. WMITLV_GET_STRUCT_TLVLEN
  1534. (wmi_extwow_enable_cmd_fixed_param));
  1535. cmd->vdev_id = params->vdev_id;
  1536. cmd->type = params->type;
  1537. cmd->wakeup_pin_num = params->wakeup_pin_num;
  1538. wmi_debug("vdev_id %d type %d Wakeup_pin_num %x",
  1539. cmd->vdev_id, cmd->type, cmd->wakeup_pin_num);
  1540. wmi_mtrace(WMI_EXTWOW_ENABLE_CMDID, cmd->vdev_id, 0);
  1541. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  1542. WMI_EXTWOW_ENABLE_CMDID);
  1543. if (ret) {
  1544. wmi_err("Failed to set EXTWOW Enable");
  1545. wmi_buf_free(buf);
  1546. return QDF_STATUS_E_FAILURE;
  1547. }
  1548. return QDF_STATUS_SUCCESS;
  1549. }
  1550. /**
  1551. * send_set_app_type2_params_in_fw_cmd_tlv() - set app type2 params in fw
  1552. * @wmi_handle: wmi handle
  1553. * @appType2Params: app type2 params
  1554. *
  1555. * Return: CDF status
  1556. */
  1557. static QDF_STATUS send_set_app_type2_params_in_fw_cmd_tlv(wmi_unified_t wmi_handle,
  1558. struct app_type2_params *appType2Params)
  1559. {
  1560. wmi_extwow_set_app_type2_params_cmd_fixed_param *cmd;
  1561. wmi_buf_t buf;
  1562. int32_t len;
  1563. int ret;
  1564. len = sizeof(wmi_extwow_set_app_type2_params_cmd_fixed_param);
  1565. buf = wmi_buf_alloc(wmi_handle, len);
  1566. if (!buf) {
  1567. return QDF_STATUS_E_NOMEM;
  1568. }
  1569. cmd = (wmi_extwow_set_app_type2_params_cmd_fixed_param *)
  1570. wmi_buf_data(buf);
  1571. WMITLV_SET_HDR(&cmd->tlv_header,
  1572. WMITLV_TAG_STRUC_wmi_extwow_set_app_type2_params_cmd_fixed_param,
  1573. WMITLV_GET_STRUCT_TLVLEN
  1574. (wmi_extwow_set_app_type2_params_cmd_fixed_param));
  1575. cmd->vdev_id = appType2Params->vdev_id;
  1576. qdf_mem_copy(cmd->rc4_key, appType2Params->rc4_key, 16);
  1577. cmd->rc4_key_len = appType2Params->rc4_key_len;
  1578. cmd->ip_id = appType2Params->ip_id;
  1579. cmd->ip_device_ip = appType2Params->ip_device_ip;
  1580. cmd->ip_server_ip = appType2Params->ip_server_ip;
  1581. cmd->tcp_src_port = appType2Params->tcp_src_port;
  1582. cmd->tcp_dst_port = appType2Params->tcp_dst_port;
  1583. cmd->tcp_seq = appType2Params->tcp_seq;
  1584. cmd->tcp_ack_seq = appType2Params->tcp_ack_seq;
  1585. cmd->keepalive_init = appType2Params->keepalive_init;
  1586. cmd->keepalive_min = appType2Params->keepalive_min;
  1587. cmd->keepalive_max = appType2Params->keepalive_max;
  1588. cmd->keepalive_inc = appType2Params->keepalive_inc;
  1589. WMI_CHAR_ARRAY_TO_MAC_ADDR(appType2Params->gateway_mac.bytes,
  1590. &cmd->gateway_mac);
  1591. cmd->tcp_tx_timeout_val = appType2Params->tcp_tx_timeout_val;
  1592. cmd->tcp_rx_timeout_val = appType2Params->tcp_rx_timeout_val;
  1593. wmi_debug("vdev_id %d gateway_mac "QDF_MAC_ADDR_FMT" "
  1594. "rc4_key %.16s rc4_key_len %u "
  1595. "ip_id %x ip_device_ip %x ip_server_ip %x "
  1596. "tcp_src_port %u tcp_dst_port %u tcp_seq %u "
  1597. "tcp_ack_seq %u keepalive_init %u keepalive_min %u "
  1598. "keepalive_max %u keepalive_inc %u "
  1599. "tcp_tx_timeout_val %u tcp_rx_timeout_val %u",
  1600. cmd->vdev_id,
  1601. QDF_MAC_ADDR_REF(appType2Params->gateway_mac.bytes),
  1602. cmd->rc4_key, cmd->rc4_key_len,
  1603. cmd->ip_id, cmd->ip_device_ip, cmd->ip_server_ip,
  1604. cmd->tcp_src_port, cmd->tcp_dst_port, cmd->tcp_seq,
  1605. cmd->tcp_ack_seq, cmd->keepalive_init, cmd->keepalive_min,
  1606. cmd->keepalive_max, cmd->keepalive_inc,
  1607. cmd->tcp_tx_timeout_val, cmd->tcp_rx_timeout_val);
  1608. wmi_mtrace(WMI_EXTWOW_SET_APP_TYPE2_PARAMS_CMDID, cmd->vdev_id, 0);
  1609. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  1610. WMI_EXTWOW_SET_APP_TYPE2_PARAMS_CMDID);
  1611. if (ret) {
  1612. wmi_err("Failed to set APP TYPE2 PARAMS");
  1613. wmi_buf_free(buf);
  1614. return QDF_STATUS_E_FAILURE;
  1615. }
  1616. return QDF_STATUS_SUCCESS;
  1617. }
  1618. /**
  1619. * send_app_type1_params_in_fw_cmd_tlv() - set app type1 params in fw
  1620. * @wmi_handle: wmi handle
  1621. * @app_type1_params: app type1 params
  1622. *
  1623. * Return: CDF status
  1624. */
  1625. static QDF_STATUS send_app_type1_params_in_fw_cmd_tlv(wmi_unified_t wmi_handle,
  1626. struct app_type1_params *app_type1_params)
  1627. {
  1628. wmi_extwow_set_app_type1_params_cmd_fixed_param *cmd;
  1629. wmi_buf_t buf;
  1630. int32_t len;
  1631. int ret;
  1632. len = sizeof(wmi_extwow_set_app_type1_params_cmd_fixed_param);
  1633. buf = wmi_buf_alloc(wmi_handle, len);
  1634. if (!buf) {
  1635. return QDF_STATUS_E_NOMEM;
  1636. }
  1637. cmd = (wmi_extwow_set_app_type1_params_cmd_fixed_param *)
  1638. wmi_buf_data(buf);
  1639. WMITLV_SET_HDR(&cmd->tlv_header,
  1640. WMITLV_TAG_STRUC_wmi_extwow_set_app_type1_params_cmd_fixed_param,
  1641. WMITLV_GET_STRUCT_TLVLEN
  1642. (wmi_extwow_set_app_type1_params_cmd_fixed_param));
  1643. cmd->vdev_id = app_type1_params->vdev_id;
  1644. WMI_CHAR_ARRAY_TO_MAC_ADDR(app_type1_params->wakee_mac_addr.bytes,
  1645. &cmd->wakee_mac);
  1646. qdf_mem_copy(cmd->ident, app_type1_params->identification_id, 8);
  1647. cmd->ident_len = app_type1_params->id_length;
  1648. qdf_mem_copy(cmd->passwd, app_type1_params->password, 16);
  1649. cmd->passwd_len = app_type1_params->pass_length;
  1650. wmi_debug("vdev_id %d wakee_mac_addr "QDF_MAC_ADDR_FMT" "
  1651. "identification_id %.8s id_length %u "
  1652. "password %.16s pass_length %u",
  1653. cmd->vdev_id,
  1654. QDF_MAC_ADDR_REF(app_type1_params->wakee_mac_addr.bytes),
  1655. cmd->ident, cmd->ident_len, cmd->passwd, cmd->passwd_len);
  1656. wmi_mtrace(WMI_EXTWOW_SET_APP_TYPE1_PARAMS_CMDID, cmd->vdev_id, 0);
  1657. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  1658. WMI_EXTWOW_SET_APP_TYPE1_PARAMS_CMDID);
  1659. if (ret) {
  1660. wmi_err("Failed to set APP TYPE1 PARAMS");
  1661. wmi_buf_free(buf);
  1662. return QDF_STATUS_E_FAILURE;
  1663. }
  1664. return QDF_STATUS_SUCCESS;
  1665. }
  1666. void wmi_extwow_attach_tlv(struct wmi_unified *wmi_handle)
  1667. {
  1668. struct wmi_ops *ops = wmi_handle->ops;
  1669. ops->send_enable_ext_wow_cmd = send_enable_ext_wow_cmd_tlv;
  1670. ops->send_set_app_type2_params_in_fw_cmd =
  1671. send_set_app_type2_params_in_fw_cmd_tlv;
  1672. ops->send_app_type1_params_in_fw_cmd =
  1673. send_app_type1_params_in_fw_cmd_tlv;
  1674. }
  1675. #endif /* WLAN_FEATURE_EXTWOW_SUPPORT */
  1676. void wmi_pmo_attach_tlv(wmi_unified_t wmi_handle)
  1677. {
  1678. struct wmi_ops *ops = wmi_handle->ops;
  1679. ops->send_add_wow_wakeup_event_cmd =
  1680. send_add_wow_wakeup_event_cmd_tlv;
  1681. ops->send_wow_patterns_to_fw_cmd = send_wow_patterns_to_fw_cmd_tlv;
  1682. ops->send_enable_arp_ns_offload_cmd =
  1683. send_enable_arp_ns_offload_cmd_tlv;
  1684. ops->send_add_clear_mcbc_filter_cmd =
  1685. send_add_clear_mcbc_filter_cmd_tlv;
  1686. ops->send_multiple_add_clear_mcbc_filter_cmd =
  1687. send_multiple_add_clear_mcbc_filter_cmd_tlv;
  1688. ops->send_conf_hw_filter_cmd = send_conf_hw_filter_cmd_tlv;
  1689. ops->send_gtk_offload_cmd = send_gtk_offload_cmd_tlv;
  1690. ops->send_process_gtk_offload_getinfo_cmd =
  1691. send_process_gtk_offload_getinfo_cmd_tlv;
  1692. ops->send_enable_enhance_multicast_offload_cmd =
  1693. send_enable_enhance_multicast_offload_tlv;
  1694. ops->extract_gtk_rsp_event = extract_gtk_rsp_event_tlv;
  1695. ops->send_action_frame_patterns_cmd =
  1696. send_action_frame_patterns_cmd_tlv;
  1697. ops->send_wow_delete_pattern_cmd = send_wow_delete_pattern_cmd_tlv;
  1698. ops->send_host_wakeup_ind_to_fw_cmd =
  1699. send_host_wakeup_ind_to_fw_cmd_tlv;
  1700. ops->send_wow_timer_pattern_cmd = send_wow_timer_pattern_cmd_tlv;
  1701. wmi_d0wow_attach_tlv(wmi_handle);
  1702. wmi_ra_filtering_attach_tlv(wmi_handle);
  1703. wmi_lphb_attach_tlv(wmi_handle);
  1704. wmi_packet_filtering_attach_tlv(wmi_handle);
  1705. wmi_extwow_attach_tlv(wmi_handle);
  1706. }