wlan_dsc_vdev.c 9.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389
  1. /*
  2. * Copyright (c) 2018-2021 The Linux Foundation. All rights reserved.
  3. * Copyright (c) 2022 Qualcomm Innovation Center, Inc. All rights reserved.
  4. *
  5. * Permission to use, copy, modify, and/or distribute this software for
  6. * any purpose with or without fee is hereby granted, provided that the
  7. * above copyright notice and this permission notice appear in all
  8. * copies.
  9. *
  10. * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
  11. * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
  12. * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
  13. * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
  14. * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
  15. * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  16. * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  17. * PERFORMANCE OF THIS SOFTWARE.
  18. */
  19. #include "qdf_list.h"
  20. #include "qdf_status.h"
  21. #include "qdf_talloc.h"
  22. #include "qdf_types.h"
  23. #include "__wlan_dsc.h"
  24. #include "wlan_dsc.h"
  25. #include "qdf_platform.h"
  26. #define __dsc_driver_lock(vdev) __dsc_lock((vdev)->psoc->driver)
  27. #define __dsc_driver_unlock(vdev) __dsc_unlock((vdev)->psoc->driver)
  28. static QDF_STATUS
  29. __dsc_vdev_create(struct dsc_psoc *psoc, struct dsc_vdev **out_vdev)
  30. {
  31. struct dsc_vdev *vdev;
  32. if (!dsc_assert(psoc))
  33. return QDF_STATUS_E_INVAL;
  34. if (!dsc_assert(out_vdev))
  35. return QDF_STATUS_E_INVAL;
  36. *out_vdev = NULL;
  37. vdev = qdf_talloc_type(psoc, vdev);
  38. if (!vdev)
  39. return QDF_STATUS_E_NOMEM;
  40. /* init */
  41. vdev->psoc = psoc;
  42. __dsc_trans_init(&vdev->trans);
  43. __dsc_ops_init(&vdev->ops);
  44. /* attach */
  45. __dsc_driver_lock(vdev);
  46. qdf_list_insert_back(&psoc->vdevs, &vdev->node);
  47. __dsc_driver_unlock(vdev);
  48. *out_vdev = vdev;
  49. return QDF_STATUS_SUCCESS;
  50. }
  51. QDF_STATUS dsc_vdev_create(struct dsc_psoc *psoc, struct dsc_vdev **out_vdev)
  52. {
  53. QDF_STATUS status;
  54. status = __dsc_vdev_create(psoc, out_vdev);
  55. return status;
  56. }
  57. static void __dsc_vdev_destroy(struct dsc_vdev **out_vdev)
  58. {
  59. struct dsc_vdev *vdev;
  60. if (!dsc_assert(out_vdev))
  61. return;
  62. vdev = *out_vdev;
  63. if (!dsc_assert(vdev))
  64. return;
  65. *out_vdev = NULL;
  66. /* flush pending transitions */
  67. while (__dsc_trans_abort(&vdev->trans))
  68. ;
  69. /* detach */
  70. __dsc_driver_lock(vdev);
  71. qdf_list_remove_node(&vdev->psoc->vdevs, &vdev->node);
  72. __dsc_driver_unlock(vdev);
  73. /* de-init */
  74. __dsc_ops_deinit(&vdev->ops);
  75. __dsc_trans_deinit(&vdev->trans);
  76. vdev->psoc = NULL;
  77. qdf_tfree(vdev);
  78. }
  79. void dsc_vdev_destroy(struct dsc_vdev **out_vdev)
  80. {
  81. __dsc_vdev_destroy(out_vdev);
  82. }
  83. #define __dsc_vdev_can_op(vdev) __dsc_vdev_can_trans(vdev)
  84. /*
  85. * __dsc_vdev_can_trans() - Returns if the vdev transition can occur or not
  86. * @vdev: The DSC vdev
  87. *
  88. * This function checks if the vdev transition can occur or not by checking if
  89. * any other down the tree/up the tree transition/operation is taking place.
  90. *
  91. * If there are any driver transition taking place, then the vdev trans/ops
  92. * should be rejected and not queued in the DSC queue. Return QDF_STATUS_E_INVAL
  93. * in this case.
  94. *
  95. * If there are any psoc transition taking place because of SSR, then vdev
  96. * trans/op should be rejected and queued in the DSC queue so that it may be
  97. * resumed after the current trans/op is completed. return QDF_STATUS_E_BUSY
  98. * in this case.
  99. *
  100. * If there is a psoc transition taking place because of psoc idle shutdown,
  101. * then the vdev trans/ops should be rejected and queued in the DSC queue so
  102. * that it may be resumed after the current trans/ops is completed. Return
  103. * QDF_STATUS_E_BUSY in this case.
  104. *
  105. * If there are any vdev trans/ops taking place, then the vdev trans/ops
  106. * should be rejected and queued in the DSC queue so that it may be resumed
  107. * after the current trans/ops is completed. Return QDF_STATUS_E_BUSY in this
  108. * case.
  109. *
  110. * Return: QDF_STATUS_SUCCESS if transition is allowed, error code if not.
  111. */
  112. static QDF_STATUS __dsc_vdev_can_trans(struct dsc_vdev *vdev)
  113. {
  114. if (__dsc_trans_active_or_queued(&vdev->psoc->driver->trans))
  115. return QDF_STATUS_E_INVAL;
  116. if (qdf_is_recovering())
  117. return QDF_STATUS_E_INVAL;
  118. if (__dsc_trans_active_or_queued(&vdev->psoc->trans)) {
  119. /* psoc idle shutdown(wifi off) needs to be added in DSC queue
  120. * to avoid wifi on failure while previous psoc idle shutdown
  121. * is in progress and wifi is turned on. And Wifi On also needs
  122. * to be added to the queue so that it waits for SSR to
  123. * complete.
  124. */
  125. if (qdf_is_driver_unloading())
  126. return QDF_STATUS_E_INVAL;
  127. else
  128. return QDF_STATUS_E_BUSY;
  129. }
  130. if (__dsc_trans_active_or_queued(&vdev->trans))
  131. return QDF_STATUS_E_BUSY;
  132. return QDF_STATUS_SUCCESS;
  133. }
  134. static QDF_STATUS
  135. __dsc_vdev_trans_start_nolock(struct dsc_vdev *vdev, const char *desc)
  136. {
  137. QDF_STATUS status = QDF_STATUS_SUCCESS;
  138. status = __dsc_vdev_can_trans(vdev);
  139. if (QDF_IS_STATUS_ERROR(status))
  140. return status;
  141. return __dsc_trans_start(&vdev->trans, desc);
  142. }
  143. static QDF_STATUS
  144. __dsc_vdev_trans_start(struct dsc_vdev *vdev, const char *desc)
  145. {
  146. QDF_STATUS status;
  147. if (!dsc_assert(vdev))
  148. return QDF_STATUS_E_INVAL;
  149. if (!dsc_assert(desc))
  150. return QDF_STATUS_E_INVAL;
  151. __dsc_driver_lock(vdev);
  152. status = __dsc_vdev_trans_start_nolock(vdev, desc);
  153. __dsc_driver_unlock(vdev);
  154. return status;
  155. }
  156. QDF_STATUS dsc_vdev_trans_start(struct dsc_vdev *vdev, const char *desc)
  157. {
  158. QDF_STATUS status;
  159. dsc_enter_str(desc);
  160. status = __dsc_vdev_trans_start(vdev, desc);
  161. if (QDF_IS_STATUS_ERROR(status))
  162. dsc_exit_status(status);
  163. return status;
  164. }
  165. static QDF_STATUS
  166. __dsc_vdev_trans_start_wait(struct dsc_vdev *vdev, const char *desc)
  167. {
  168. QDF_STATUS status;
  169. struct dsc_tran tran = { 0 };
  170. if (!dsc_assert(vdev))
  171. return QDF_STATUS_E_INVAL;
  172. if (!dsc_assert(desc))
  173. return QDF_STATUS_E_INVAL;
  174. __dsc_driver_lock(vdev);
  175. /* try to start without waiting */
  176. status = __dsc_vdev_trans_start_nolock(vdev, desc);
  177. if (QDF_IS_STATUS_SUCCESS(status) || status == QDF_STATUS_E_INVAL)
  178. goto unlock;
  179. status = __dsc_trans_queue(&vdev->trans, &tran, desc);
  180. if (QDF_IS_STATUS_ERROR(status))
  181. goto unlock;
  182. __dsc_driver_unlock(vdev);
  183. return __dsc_tran_wait(&tran);
  184. unlock:
  185. __dsc_driver_unlock(vdev);
  186. return status;
  187. }
  188. QDF_STATUS dsc_vdev_trans_start_wait(struct dsc_vdev *vdev, const char *desc)
  189. {
  190. QDF_STATUS status;
  191. dsc_enter_str(desc);
  192. status = __dsc_vdev_trans_start_wait(vdev, desc);
  193. if (QDF_IS_STATUS_ERROR(status))
  194. dsc_exit_status(status);
  195. return status;
  196. }
  197. static void __dsc_vdev_trigger_trans(struct dsc_vdev *vdev)
  198. {
  199. if (__dsc_driver_trans_trigger_checked(vdev->psoc->driver))
  200. return;
  201. if (__dsc_psoc_trans_trigger_checked(vdev->psoc))
  202. return;
  203. __dsc_trans_trigger(&vdev->trans);
  204. }
  205. static void __dsc_vdev_trans_stop(struct dsc_vdev *vdev)
  206. {
  207. if (!dsc_assert(vdev))
  208. return;
  209. __dsc_driver_lock(vdev);
  210. __dsc_trans_stop(&vdev->trans);
  211. __dsc_vdev_trigger_trans(vdev);
  212. __dsc_driver_unlock(vdev);
  213. }
  214. void dsc_vdev_trans_stop(struct dsc_vdev *vdev)
  215. {
  216. __dsc_vdev_trans_stop(vdev);
  217. }
  218. static void __dsc_vdev_assert_trans_protected(struct dsc_vdev *vdev)
  219. {
  220. if (!dsc_assert(vdev))
  221. return;
  222. __dsc_driver_lock(vdev);
  223. dsc_assert(__dsc_trans_active(&vdev->trans) ||
  224. __dsc_trans_active(&vdev->psoc->trans) ||
  225. __dsc_trans_active(&vdev->psoc->driver->trans));
  226. __dsc_driver_unlock(vdev);
  227. }
  228. void dsc_vdev_assert_trans_protected(struct dsc_vdev *vdev)
  229. {
  230. __dsc_vdev_assert_trans_protected(vdev);
  231. }
  232. static QDF_STATUS __dsc_vdev_op_start(struct dsc_vdev *vdev, const char *func)
  233. {
  234. QDF_STATUS status;
  235. if (!dsc_assert(vdev))
  236. return QDF_STATUS_E_INVAL;
  237. if (!dsc_assert(func))
  238. return QDF_STATUS_E_INVAL;
  239. __dsc_driver_lock(vdev);
  240. status = __dsc_vdev_can_op(vdev);
  241. if (QDF_IS_STATUS_ERROR(status))
  242. goto unlock;
  243. status = __dsc_ops_insert(&vdev->ops, func);
  244. unlock:
  245. __dsc_driver_unlock(vdev);
  246. return status;
  247. }
  248. QDF_STATUS _dsc_vdev_op_start(struct dsc_vdev *vdev, const char *func)
  249. {
  250. QDF_STATUS status;
  251. /* do not log from here because it can flood log message because vdev
  252. * op protect is per vdev operation
  253. */
  254. status = __dsc_vdev_op_start(vdev, func);
  255. return status;
  256. }
  257. static void __dsc_vdev_op_stop(struct dsc_vdev *vdev, const char *func)
  258. {
  259. if (!dsc_assert(vdev))
  260. return;
  261. if (!dsc_assert(func))
  262. return;
  263. __dsc_driver_lock(vdev);
  264. if (__dsc_ops_remove(&vdev->ops, func))
  265. qdf_event_set(&vdev->ops.event);
  266. __dsc_driver_unlock(vdev);
  267. }
  268. void _dsc_vdev_op_stop(struct dsc_vdev *vdev, const char *func)
  269. {
  270. /* do not log from here because it can flood log message because vdev
  271. * op protect is per vdev operation
  272. */
  273. __dsc_vdev_op_stop(vdev, func);
  274. }
  275. static void __dsc_vdev_wait_for_ops(struct dsc_vdev *vdev)
  276. {
  277. bool wait;
  278. if (!dsc_assert(vdev))
  279. return;
  280. __dsc_driver_lock(vdev);
  281. wait = vdev->ops.count > 0;
  282. if (wait)
  283. qdf_event_reset(&vdev->ops.event);
  284. __dsc_driver_unlock(vdev);
  285. if (wait)
  286. qdf_wait_single_event(&vdev->ops.event, 0);
  287. }
  288. void dsc_vdev_wait_for_ops(struct dsc_vdev *vdev)
  289. {
  290. __dsc_vdev_wait_for_ops(vdev);
  291. }
  292. uint8_t dsc_vdev_get_cached_cmd(struct dsc_vdev *vdev)
  293. {
  294. return vdev->nb_cmd_during_ssr;
  295. }
  296. void dsc_vdev_cache_command(struct dsc_vdev *vdev, uint8_t cmd_id)
  297. {
  298. vdev->nb_cmd_during_ssr = cmd_id;
  299. }