nan_ucfg_api.c 15 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643
  1. /*
  2. * Copyright (c) 2017-2019 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. /**
  19. * DOC: contains interface definitions for OS_IF layer
  20. */
  21. #include "nan_ucfg_api.h"
  22. #include "nan_public_structs.h"
  23. #include "wlan_nan_api.h"
  24. #include "../../core/src/nan_main_i.h"
  25. #include "scheduler_api.h"
  26. #include "wlan_objmgr_psoc_obj.h"
  27. #include "wlan_objmgr_pdev_obj.h"
  28. #include "wlan_objmgr_vdev_obj.h"
  29. #include "wlan_osif_request_manager.h"
  30. struct wlan_objmgr_psoc;
  31. struct wlan_objmgr_vdev;
  32. inline QDF_STATUS ucfg_nan_set_ndi_state(struct wlan_objmgr_vdev *vdev,
  33. uint32_t state)
  34. {
  35. struct nan_vdev_priv_obj *priv_obj = nan_get_vdev_priv_obj(vdev);
  36. if (!priv_obj) {
  37. nan_err("priv_obj is null");
  38. return QDF_STATUS_E_NULL_VALUE;
  39. }
  40. qdf_spin_lock_bh(&priv_obj->lock);
  41. priv_obj->state = state;
  42. qdf_spin_unlock_bh(&priv_obj->lock);
  43. return QDF_STATUS_SUCCESS;
  44. }
  45. inline enum nan_datapath_state ucfg_nan_get_ndi_state(
  46. struct wlan_objmgr_vdev *vdev)
  47. {
  48. enum nan_datapath_state val;
  49. struct nan_vdev_priv_obj *priv_obj = nan_get_vdev_priv_obj(vdev);
  50. if (!priv_obj) {
  51. nan_err("priv_obj is null");
  52. return NAN_DATA_INVALID_STATE;
  53. }
  54. qdf_spin_lock_bh(&priv_obj->lock);
  55. val = priv_obj->state;
  56. qdf_spin_unlock_bh(&priv_obj->lock);
  57. return val;
  58. }
  59. inline QDF_STATUS ucfg_nan_set_active_peers(struct wlan_objmgr_vdev *vdev,
  60. uint32_t val)
  61. {
  62. struct nan_vdev_priv_obj *priv_obj = nan_get_vdev_priv_obj(vdev);
  63. if (!priv_obj) {
  64. nan_err("priv_obj is null");
  65. return QDF_STATUS_E_NULL_VALUE;
  66. }
  67. qdf_spin_lock_bh(&priv_obj->lock);
  68. priv_obj->active_ndp_peers = val;
  69. qdf_spin_unlock_bh(&priv_obj->lock);
  70. return QDF_STATUS_SUCCESS;
  71. }
  72. inline uint32_t ucfg_nan_get_active_peers(struct wlan_objmgr_vdev *vdev)
  73. {
  74. uint32_t val;
  75. struct nan_vdev_priv_obj *priv_obj = nan_get_vdev_priv_obj(vdev);
  76. if (!priv_obj) {
  77. nan_err("priv_obj is null");
  78. return 0;
  79. }
  80. qdf_spin_lock_bh(&priv_obj->lock);
  81. val = priv_obj->active_ndp_peers;
  82. qdf_spin_unlock_bh(&priv_obj->lock);
  83. return val;
  84. }
  85. inline QDF_STATUS ucfg_nan_set_ndp_create_transaction_id(
  86. struct wlan_objmgr_vdev *vdev, uint16_t val)
  87. {
  88. struct nan_vdev_priv_obj *priv_obj = nan_get_vdev_priv_obj(vdev);
  89. if (!priv_obj) {
  90. nan_err("priv_obj is null");
  91. return QDF_STATUS_E_NULL_VALUE;
  92. }
  93. qdf_spin_lock_bh(&priv_obj->lock);
  94. priv_obj->ndp_create_transaction_id = val;
  95. qdf_spin_unlock_bh(&priv_obj->lock);
  96. return QDF_STATUS_SUCCESS;
  97. }
  98. inline uint16_t ucfg_nan_get_ndp_create_transaction_id(
  99. struct wlan_objmgr_vdev *vdev)
  100. {
  101. uint16_t val;
  102. struct nan_vdev_priv_obj *priv_obj = nan_get_vdev_priv_obj(vdev);
  103. if (!priv_obj) {
  104. nan_err("priv_obj is null");
  105. return 0;
  106. }
  107. qdf_spin_lock_bh(&priv_obj->lock);
  108. val = priv_obj->ndp_create_transaction_id;
  109. qdf_spin_unlock_bh(&priv_obj->lock);
  110. return val;
  111. }
  112. inline QDF_STATUS ucfg_nan_set_ndp_delete_transaction_id(
  113. struct wlan_objmgr_vdev *vdev, uint16_t val)
  114. {
  115. struct nan_vdev_priv_obj *priv_obj = nan_get_vdev_priv_obj(vdev);
  116. if (!priv_obj) {
  117. nan_err("priv_obj is null");
  118. return QDF_STATUS_E_NULL_VALUE;
  119. }
  120. qdf_spin_lock_bh(&priv_obj->lock);
  121. priv_obj->ndp_delete_transaction_id = val;
  122. qdf_spin_unlock_bh(&priv_obj->lock);
  123. return QDF_STATUS_SUCCESS;
  124. }
  125. inline uint16_t ucfg_nan_get_ndp_delete_transaction_id(
  126. struct wlan_objmgr_vdev *vdev)
  127. {
  128. uint16_t val;
  129. struct nan_vdev_priv_obj *priv_obj = nan_get_vdev_priv_obj(vdev);
  130. if (!priv_obj) {
  131. nan_err("priv_obj is null");
  132. return 0;
  133. }
  134. qdf_spin_lock_bh(&priv_obj->lock);
  135. val = priv_obj->ndp_delete_transaction_id;
  136. qdf_spin_unlock_bh(&priv_obj->lock);
  137. return val;
  138. }
  139. inline QDF_STATUS ucfg_nan_set_ndi_delete_rsp_reason(
  140. struct wlan_objmgr_vdev *vdev, uint32_t val)
  141. {
  142. struct nan_vdev_priv_obj *priv_obj = nan_get_vdev_priv_obj(vdev);
  143. if (!priv_obj) {
  144. nan_err("priv_obj is null");
  145. return QDF_STATUS_E_NULL_VALUE;
  146. }
  147. qdf_spin_lock_bh(&priv_obj->lock);
  148. priv_obj->ndi_delete_rsp_reason = val;
  149. qdf_spin_unlock_bh(&priv_obj->lock);
  150. return QDF_STATUS_SUCCESS;
  151. }
  152. inline uint32_t ucfg_nan_get_ndi_delete_rsp_reason(
  153. struct wlan_objmgr_vdev *vdev)
  154. {
  155. uint32_t val;
  156. struct nan_vdev_priv_obj *priv_obj = nan_get_vdev_priv_obj(vdev);
  157. if (!priv_obj) {
  158. nan_err("priv_obj is null");
  159. return 0;
  160. }
  161. qdf_spin_lock_bh(&priv_obj->lock);
  162. val = priv_obj->ndi_delete_rsp_reason;
  163. qdf_spin_unlock_bh(&priv_obj->lock);
  164. return val;
  165. }
  166. inline QDF_STATUS ucfg_nan_set_ndi_delete_rsp_status(
  167. struct wlan_objmgr_vdev *vdev, uint32_t val)
  168. {
  169. struct nan_vdev_priv_obj *priv_obj = nan_get_vdev_priv_obj(vdev);
  170. if (!priv_obj) {
  171. nan_err("priv_obj is null");
  172. return QDF_STATUS_E_NULL_VALUE;
  173. }
  174. qdf_spin_lock_bh(&priv_obj->lock);
  175. priv_obj->ndi_delete_rsp_status = val;
  176. qdf_spin_unlock_bh(&priv_obj->lock);
  177. return QDF_STATUS_SUCCESS;
  178. }
  179. inline uint32_t ucfg_nan_get_ndi_delete_rsp_status(
  180. struct wlan_objmgr_vdev *vdev)
  181. {
  182. uint32_t val;
  183. struct nan_vdev_priv_obj *priv_obj = nan_get_vdev_priv_obj(vdev);
  184. if (!priv_obj) {
  185. nan_err("priv_obj is null");
  186. return QDF_STATUS_E_NULL_VALUE;
  187. }
  188. qdf_spin_lock_bh(&priv_obj->lock);
  189. val = priv_obj->ndi_delete_rsp_status;
  190. qdf_spin_unlock_bh(&priv_obj->lock);
  191. return val;
  192. }
  193. inline QDF_STATUS ucfg_nan_get_callbacks(struct wlan_objmgr_psoc *psoc,
  194. struct nan_callbacks *cb_obj)
  195. {
  196. struct nan_psoc_priv_obj *psoc_obj = nan_get_psoc_priv_obj(psoc);
  197. if (!psoc_obj) {
  198. nan_err("nan psoc priv object is NULL");
  199. return QDF_STATUS_E_NULL_VALUE;
  200. }
  201. qdf_spin_lock_bh(&psoc_obj->lock);
  202. qdf_mem_copy(cb_obj, &psoc_obj->cb_obj, sizeof(*cb_obj));
  203. qdf_spin_unlock_bh(&psoc_obj->lock);
  204. return QDF_STATUS_SUCCESS;
  205. }
  206. static QDF_STATUS ucfg_nan_sch_msg_flush_cb(struct scheduler_msg *msg)
  207. {
  208. struct wlan_objmgr_vdev *vdev = NULL;
  209. if (!msg || !msg->bodyptr)
  210. return QDF_STATUS_E_NULL_VALUE;
  211. switch (msg->type) {
  212. case NDP_INITIATOR_REQ:
  213. vdev = ((struct nan_datapath_initiator_req *)
  214. msg->bodyptr)->vdev;
  215. break;
  216. case NDP_RESPONDER_REQ:
  217. vdev = ((struct nan_datapath_responder_req *)
  218. msg->bodyptr)->vdev;
  219. break;
  220. case NDP_END_REQ:
  221. vdev = ((struct nan_datapath_end_req *)msg->bodyptr)->vdev;
  222. break;
  223. default:
  224. nan_err("Invalid NAN msg type during sch flush");
  225. return QDF_STATUS_E_INVAL;
  226. }
  227. if (vdev) {
  228. wlan_objmgr_vdev_release_ref(vdev, WLAN_NAN_ID);
  229. qdf_mem_free(msg->bodyptr);
  230. }
  231. return QDF_STATUS_SUCCESS;
  232. }
  233. QDF_STATUS ucfg_nan_req_processor(struct wlan_objmgr_vdev *vdev,
  234. void *in_req, uint32_t req_type)
  235. {
  236. uint32_t len;
  237. QDF_STATUS status;
  238. struct scheduler_msg msg = {0};
  239. if (!in_req) {
  240. nan_alert("req is null");
  241. return QDF_STATUS_E_NULL_VALUE;
  242. }
  243. switch (req_type) {
  244. case NDP_INITIATOR_REQ:
  245. len = sizeof(struct nan_datapath_initiator_req);
  246. break;
  247. case NDP_RESPONDER_REQ:
  248. len = sizeof(struct nan_datapath_responder_req);
  249. break;
  250. case NDP_END_REQ:
  251. len = sizeof(struct nan_datapath_end_req);
  252. break;
  253. default:
  254. nan_err("in correct message req type: %d", req_type);
  255. return QDF_STATUS_E_INVAL;
  256. }
  257. msg.bodyptr = qdf_mem_malloc(len);
  258. if (!msg.bodyptr) {
  259. nan_err("malloc failed");
  260. return QDF_STATUS_E_NOMEM;
  261. }
  262. qdf_mem_copy(msg.bodyptr, in_req, len);
  263. msg.type = req_type;
  264. msg.callback = nan_scheduled_msg_handler;
  265. msg.flush_callback = ucfg_nan_sch_msg_flush_cb;
  266. status = scheduler_post_message(QDF_MODULE_ID_HDD,
  267. QDF_MODULE_ID_NAN,
  268. QDF_MODULE_ID_OS_IF, &msg);
  269. if (QDF_IS_STATUS_ERROR(status))
  270. qdf_mem_free(msg.bodyptr);
  271. return status;
  272. }
  273. void ucfg_nan_datapath_event_handler(struct wlan_objmgr_psoc *psoc,
  274. struct wlan_objmgr_vdev *vdev,
  275. uint32_t type, void *msg)
  276. {
  277. struct nan_psoc_priv_obj *psoc_obj = nan_get_psoc_priv_obj(psoc);
  278. if (!psoc_obj) {
  279. nan_err("nan psoc priv object is NULL");
  280. return;
  281. }
  282. psoc_obj->cb_obj.os_if_ndp_event_handler(psoc, vdev, type, msg);
  283. }
  284. static void ucfg_concurrency_nan_disable_callback(void *cookie)
  285. {
  286. struct osif_request *request;
  287. request = osif_request_get(cookie);
  288. if (request) {
  289. osif_request_complete(request);
  290. osif_request_put(request);
  291. } else {
  292. nan_err("Obsolete request (cookie:0x%pK), do nothing", cookie);
  293. }
  294. }
  295. int ucfg_nan_register_hdd_callbacks(struct wlan_objmgr_psoc *psoc,
  296. struct nan_callbacks *cb_obj)
  297. {
  298. struct nan_psoc_priv_obj *psoc_obj = nan_get_psoc_priv_obj(psoc);
  299. if (!psoc_obj) {
  300. nan_err("nan psoc priv object is NULL");
  301. return -EINVAL;
  302. }
  303. psoc_obj->cb_obj.ndi_open = cb_obj->ndi_open;
  304. psoc_obj->cb_obj.ndi_start = cb_obj->ndi_start;
  305. psoc_obj->cb_obj.ndi_delete = cb_obj->ndi_delete;
  306. psoc_obj->cb_obj.ndi_close = cb_obj->ndi_close;
  307. psoc_obj->cb_obj.drv_ndi_create_rsp_handler =
  308. cb_obj->drv_ndi_create_rsp_handler;
  309. psoc_obj->cb_obj.drv_ndi_delete_rsp_handler =
  310. cb_obj->drv_ndi_delete_rsp_handler;
  311. psoc_obj->cb_obj.new_peer_ind = cb_obj->new_peer_ind;
  312. psoc_obj->cb_obj.peer_departed_ind = cb_obj->peer_departed_ind;
  313. psoc_obj->cb_obj.os_if_ndp_event_handler =
  314. cb_obj->os_if_ndp_event_handler;
  315. psoc_obj->cb_obj.os_if_nan_event_handler =
  316. cb_obj->os_if_nan_event_handler;
  317. psoc_obj->cb_obj.ucfg_explicit_disable_cb =
  318. ucfg_concurrency_nan_disable_callback;
  319. return 0;
  320. }
  321. int ucfg_nan_register_lim_callbacks(struct wlan_objmgr_psoc *psoc,
  322. struct nan_callbacks *cb_obj)
  323. {
  324. struct nan_psoc_priv_obj *psoc_obj = nan_get_psoc_priv_obj(psoc);
  325. if (!psoc_obj) {
  326. nan_err("nan psoc priv object is NULL");
  327. return -EINVAL;
  328. }
  329. psoc_obj->cb_obj.add_ndi_peer = cb_obj->add_ndi_peer;
  330. psoc_obj->cb_obj.ndp_delete_peers = cb_obj->ndp_delete_peers;
  331. psoc_obj->cb_obj.delete_peers_by_addr = cb_obj->delete_peers_by_addr;
  332. return 0;
  333. }
  334. int ucfg_nan_register_wma_callbacks(struct wlan_objmgr_psoc *psoc,
  335. struct nan_callbacks *cb_obj)
  336. {
  337. struct nan_psoc_priv_obj *psoc_obj = nan_get_psoc_priv_obj(psoc);
  338. if (!psoc_obj) {
  339. nan_err("nan psoc priv object is NULL");
  340. return -EINVAL;
  341. }
  342. psoc_obj->cb_obj.update_ndi_conn = cb_obj->update_ndi_conn;
  343. return 0;
  344. }
  345. void ucfg_nan_set_tgt_caps(struct wlan_objmgr_psoc *psoc,
  346. struct nan_tgt_caps *nan_caps)
  347. {
  348. struct nan_psoc_priv_obj *psoc_priv = nan_get_psoc_priv_obj(psoc);
  349. if (!psoc_priv) {
  350. nan_err("nan psoc priv object is NULL");
  351. return;
  352. }
  353. psoc_priv->nan_caps = *nan_caps;
  354. }
  355. bool ucfg_is_nan_disable_supported(struct wlan_objmgr_psoc *psoc)
  356. {
  357. struct nan_psoc_priv_obj *psoc_priv;
  358. psoc_priv = nan_get_psoc_priv_obj(psoc);
  359. if (!psoc_priv) {
  360. nan_err("nan psoc priv object is NULL");
  361. return false;
  362. }
  363. return (psoc_priv->nan_caps.nan_disable_supported == 1);
  364. }
  365. bool ucfg_is_nan_dbs_supported(struct wlan_objmgr_psoc *psoc)
  366. {
  367. struct nan_psoc_priv_obj *psoc_priv;
  368. psoc_priv = nan_get_psoc_priv_obj(psoc);
  369. if (!psoc_priv) {
  370. nan_err("nan psoc priv object is NULL");
  371. return false;
  372. }
  373. return (psoc_priv->nan_caps.nan_dbs_supported == 1);
  374. }
  375. bool ucfg_is_nan_enable_allowed(struct wlan_objmgr_psoc *psoc, uint8_t nan_chan)
  376. {
  377. return nan_is_enable_allowed(psoc, nan_chan);
  378. }
  379. QDF_STATUS ucfg_nan_discovery_req(void *in_req, uint32_t req_type)
  380. {
  381. struct wlan_objmgr_psoc *psoc;
  382. struct scheduler_msg msg = {0};
  383. uint32_t len;
  384. QDF_STATUS status;
  385. if (!in_req) {
  386. nan_alert("NAN Discovery req is null");
  387. return QDF_STATUS_E_NULL_VALUE;
  388. }
  389. switch (req_type) {
  390. case NAN_ENABLE_REQ: {
  391. struct nan_enable_req *req = in_req;
  392. psoc = req->psoc;
  393. /*
  394. * Take a psoc reference while it is being used by the
  395. * NAN requests.
  396. */
  397. status = wlan_objmgr_psoc_try_get_ref(psoc,
  398. WLAN_NAN_ID);
  399. if (QDF_IS_STATUS_ERROR(status)) {
  400. nan_err("Couldn't obtain psoc ref");
  401. return status;
  402. }
  403. status = nan_discovery_pre_enable(psoc,
  404. req->social_chan_2g);
  405. if (QDF_IS_STATUS_SUCCESS(status)) {
  406. len = sizeof(struct nan_enable_req) +
  407. req->params.request_data_len;
  408. } else {
  409. wlan_objmgr_psoc_release_ref(psoc,
  410. WLAN_NAN_ID);
  411. return status;
  412. }
  413. break;
  414. }
  415. case NAN_DISABLE_REQ: {
  416. struct nan_disable_req *req = in_req;
  417. psoc = req->psoc;
  418. status = wlan_objmgr_psoc_try_get_ref(psoc,
  419. WLAN_NAN_ID);
  420. if (QDF_IS_STATUS_ERROR(status)) {
  421. nan_err("Couldn't obtain psoc ref");
  422. return status;
  423. }
  424. status =
  425. nan_set_discovery_state(req->psoc,
  426. NAN_DISC_DISABLE_IN_PROGRESS);
  427. if (QDF_IS_STATUS_SUCCESS(status)) {
  428. len = sizeof(struct nan_disable_req) +
  429. req->params.request_data_len;
  430. } else {
  431. wlan_objmgr_psoc_release_ref(psoc,
  432. WLAN_NAN_ID);
  433. return status;
  434. }
  435. break;
  436. }
  437. case NAN_GENERIC_REQ: {
  438. struct nan_generic_req *req = in_req;
  439. psoc = req->psoc;
  440. status = wlan_objmgr_psoc_try_get_ref(psoc,
  441. WLAN_NAN_ID);
  442. if (QDF_IS_STATUS_ERROR(status)) {
  443. nan_err("Couldn't obtain psoc ref");
  444. return status;
  445. }
  446. len = sizeof(struct nan_generic_req) +
  447. req->params.request_data_len;
  448. break;
  449. }
  450. default:
  451. nan_err("in correct message req type: %d", req_type);
  452. return QDF_STATUS_E_INVAL;
  453. }
  454. msg.bodyptr = qdf_mem_malloc(len);
  455. if (!msg.bodyptr) {
  456. wlan_objmgr_psoc_release_ref(psoc, WLAN_NAN_ID);
  457. return QDF_STATUS_E_NOMEM;
  458. }
  459. qdf_mem_copy(msg.bodyptr, in_req, len);
  460. msg.type = req_type;
  461. msg.callback = nan_discovery_scheduled_handler;
  462. msg.flush_callback = nan_discovery_flush_callback;
  463. status = scheduler_post_message(QDF_MODULE_ID_NAN,
  464. QDF_MODULE_ID_NAN,
  465. QDF_MODULE_ID_OS_IF, &msg);
  466. if (QDF_IS_STATUS_ERROR(status)) {
  467. nan_err("failed to post msg to NAN component, status: %d",
  468. status);
  469. nan_discovery_flush_callback(&msg);
  470. }
  471. return status;
  472. }
  473. void ucfg_nan_disable_concurrency(struct wlan_objmgr_psoc *psoc)
  474. {
  475. struct nan_disable_req nan_req = {0};
  476. enum nan_disc_state curr_nan_state;
  477. struct nan_psoc_priv_obj *psoc_priv;
  478. struct osif_request *request;
  479. static const struct osif_request_params params = {
  480. .priv_size = 0,
  481. .timeout_ms = 1000,
  482. };
  483. QDF_STATUS status;
  484. int err;
  485. if (!psoc) {
  486. nan_err("psoc object is NULL, no action will be taken");
  487. return;
  488. }
  489. psoc_priv = nan_get_psoc_priv_obj(psoc);
  490. if (!psoc_priv) {
  491. nan_err("nan psoc priv object is NULL");
  492. return;
  493. }
  494. if (!ucfg_is_nan_disable_supported(psoc))
  495. return;
  496. qdf_spin_lock_bh(&psoc_priv->lock);
  497. curr_nan_state = nan_get_discovery_state(psoc);
  498. if (curr_nan_state == NAN_DISC_DISABLED ||
  499. curr_nan_state == NAN_DISC_DISABLE_IN_PROGRESS) {
  500. qdf_spin_unlock_bh(&psoc_priv->lock);
  501. return;
  502. }
  503. qdf_spin_unlock_bh(&psoc_priv->lock);
  504. request = osif_request_alloc(&params);
  505. if (!request) {
  506. nan_err("Request allocation failure");
  507. return;
  508. }
  509. nan_req.psoc = psoc;
  510. nan_req.disable_2g_discovery = true;
  511. nan_req.disable_5g_discovery = true;
  512. status = ucfg_nan_discovery_req(&nan_req, NAN_DISABLE_REQ);
  513. if (QDF_IS_STATUS_ERROR(status)) {
  514. nan_err("Unable to disable NAN Discovery");
  515. osif_request_put(request);
  516. return;
  517. }
  518. psoc_priv->disable_context = osif_request_cookie(request);
  519. psoc_priv->is_explicit_disable = true;
  520. nan_debug("Successfully sent NAN Disable request");
  521. err = osif_request_wait_for_response(request);
  522. if (err)
  523. nan_err("NAN Disable timed out waiting for disable ind-%d",
  524. err);
  525. else
  526. nan_debug("NAN Disabled successfully");
  527. psoc_priv->is_explicit_disable = false;
  528. osif_request_put(request);
  529. }