wlan_dsc_psoc.c 7.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383
  1. /*
  2. * Copyright (c) 2018 The Linux Foundation. All rights reserved.
  3. *
  4. * Permission to use, copy, modify, and/or distribute this software for
  5. * any purpose with or without fee is hereby granted, provided that the
  6. * above copyright notice and this permission notice appear in all
  7. * copies.
  8. *
  9. * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
  10. * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
  11. * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
  12. * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
  13. * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
  14. * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  15. * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  16. * PERFORMANCE OF THIS SOFTWARE.
  17. */
  18. #include "qdf_list.h"
  19. #include "qdf_status.h"
  20. #include "qdf_talloc.h"
  21. #include "qdf_types.h"
  22. #include "__wlan_dsc.h"
  23. #include "wlan_dsc.h"
  24. #define __dsc_driver_lock(psoc) __dsc_lock((psoc)->driver)
  25. #define __dsc_driver_unlock(psoc) __dsc_unlock((psoc)->driver)
  26. static QDF_STATUS
  27. __dsc_psoc_create(struct dsc_driver *driver, struct dsc_psoc **out_psoc)
  28. {
  29. struct dsc_psoc *psoc;
  30. if (!dsc_assert(driver))
  31. return QDF_STATUS_E_INVAL;
  32. if (!dsc_assert(out_psoc))
  33. return QDF_STATUS_E_INVAL;
  34. *out_psoc = NULL;
  35. psoc = qdf_talloc_type(driver, psoc);
  36. if (!psoc)
  37. return QDF_STATUS_E_NOMEM;
  38. /* init */
  39. psoc->driver = driver;
  40. qdf_list_create(&psoc->vdevs, 0);
  41. __dsc_trans_init(&psoc->trans);
  42. __dsc_ops_init(&psoc->ops);
  43. /* attach */
  44. __dsc_driver_lock(psoc);
  45. qdf_list_insert_back(&driver->psocs, &psoc->node);
  46. __dsc_driver_unlock(psoc);
  47. *out_psoc = psoc;
  48. return QDF_STATUS_SUCCESS;
  49. }
  50. QDF_STATUS
  51. dsc_psoc_create(struct dsc_driver *driver, struct dsc_psoc **out_psoc)
  52. {
  53. QDF_STATUS status;
  54. dsc_enter();
  55. status = __dsc_psoc_create(driver, out_psoc);
  56. dsc_exit();
  57. return status;
  58. }
  59. static void __dsc_psoc_destroy(struct dsc_psoc **out_psoc)
  60. {
  61. struct dsc_psoc *psoc;
  62. if (!dsc_assert(out_psoc))
  63. return;
  64. psoc = *out_psoc;
  65. if (!dsc_assert(psoc))
  66. return;
  67. *out_psoc = NULL;
  68. /* assert no children */
  69. dsc_assert(qdf_list_empty(&psoc->vdevs));
  70. /* flush pending transitions */
  71. while (__dsc_trans_abort(&psoc->trans))
  72. ;
  73. /* detach */
  74. __dsc_driver_lock(psoc);
  75. qdf_list_remove_node(&psoc->driver->psocs, &psoc->node);
  76. __dsc_driver_unlock(psoc);
  77. /* de-init */
  78. __dsc_ops_deinit(&psoc->ops);
  79. __dsc_trans_deinit(&psoc->trans);
  80. qdf_list_destroy(&psoc->vdevs);
  81. psoc->driver = NULL;
  82. qdf_tfree(psoc);
  83. }
  84. void dsc_psoc_destroy(struct dsc_psoc **out_psoc)
  85. {
  86. dsc_enter();
  87. __dsc_psoc_destroy(out_psoc);
  88. dsc_exit();
  89. }
  90. static bool __dsc_psoc_trans_active_down_tree(struct dsc_psoc *psoc)
  91. {
  92. struct dsc_vdev *vdev;
  93. dsc_for_each_psoc_vdev(psoc, vdev) {
  94. if (__dsc_trans_active(&vdev->trans))
  95. return true;
  96. }
  97. return false;
  98. }
  99. static bool __dsc_psoc_can_op(struct dsc_psoc *psoc)
  100. {
  101. return !__dsc_trans_active_or_queued(&psoc->driver->trans) &&
  102. !__dsc_trans_active_or_queued(&psoc->trans);
  103. }
  104. static bool __dsc_psoc_can_trans(struct dsc_psoc *psoc)
  105. {
  106. return !__dsc_trans_active_or_queued(&psoc->driver->trans) &&
  107. !__dsc_trans_active_or_queued(&psoc->trans) &&
  108. !__dsc_psoc_trans_active_down_tree(psoc);
  109. }
  110. static bool __dsc_psoc_can_trigger(struct dsc_psoc *psoc)
  111. {
  112. return !__dsc_trans_active_or_queued(&psoc->driver->trans) &&
  113. !__dsc_trans_active(&psoc->trans) &&
  114. !__dsc_psoc_trans_active_down_tree(psoc);
  115. }
  116. static QDF_STATUS
  117. __dsc_psoc_trans_start_nolock(struct dsc_psoc *psoc, const char *desc)
  118. {
  119. if (!__dsc_psoc_can_trans(psoc))
  120. return QDF_STATUS_E_AGAIN;
  121. return __dsc_trans_start(&psoc->trans, desc);
  122. }
  123. static QDF_STATUS
  124. __dsc_psoc_trans_start(struct dsc_psoc *psoc, const char *desc)
  125. {
  126. QDF_STATUS status;
  127. if (!dsc_assert(psoc))
  128. return QDF_STATUS_E_INVAL;
  129. if (!dsc_assert(desc))
  130. return QDF_STATUS_E_INVAL;
  131. __dsc_driver_lock(psoc);
  132. status = __dsc_psoc_trans_start_nolock(psoc, desc);
  133. __dsc_driver_unlock(psoc);
  134. return status;
  135. }
  136. QDF_STATUS dsc_psoc_trans_start(struct dsc_psoc *psoc, const char *desc)
  137. {
  138. QDF_STATUS status;
  139. dsc_enter_str(desc);
  140. status = __dsc_psoc_trans_start(psoc, desc);
  141. dsc_exit_status(status);
  142. return status;
  143. }
  144. static QDF_STATUS
  145. __dsc_psoc_trans_start_wait(struct dsc_psoc *psoc, const char *desc)
  146. {
  147. QDF_STATUS status;
  148. struct dsc_tran tran = { 0 };
  149. if (!dsc_assert(psoc))
  150. return QDF_STATUS_E_INVAL;
  151. if (!dsc_assert(desc))
  152. return QDF_STATUS_E_INVAL;
  153. __dsc_driver_lock(psoc);
  154. /* try to start without waiting */
  155. status = __dsc_psoc_trans_start_nolock(psoc, desc);
  156. if (QDF_IS_STATUS_SUCCESS(status))
  157. goto unlock;
  158. status = __dsc_trans_queue(&psoc->trans, &tran, desc);
  159. if (QDF_IS_STATUS_ERROR(status))
  160. goto unlock;
  161. __dsc_driver_unlock(psoc);
  162. return __dsc_tran_wait(&tran);
  163. unlock:
  164. __dsc_driver_unlock(psoc);
  165. return status;
  166. }
  167. QDF_STATUS dsc_psoc_trans_start_wait(struct dsc_psoc *psoc, const char *desc)
  168. {
  169. QDF_STATUS status;
  170. dsc_enter_str(desc);
  171. status = __dsc_psoc_trans_start_wait(psoc, desc);
  172. dsc_exit_status(status);
  173. return status;
  174. }
  175. static void __dsc_psoc_trigger_trans(struct dsc_psoc *psoc)
  176. {
  177. struct dsc_vdev *vdev;
  178. if (__dsc_driver_trans_trigger_checked(psoc->driver))
  179. return;
  180. if (__dsc_trans_trigger(&psoc->trans))
  181. return;
  182. dsc_for_each_psoc_vdev(psoc, vdev)
  183. __dsc_trans_trigger(&vdev->trans);
  184. }
  185. static void __dsc_psoc_trans_stop(struct dsc_psoc *psoc)
  186. {
  187. if (!dsc_assert(psoc))
  188. return;
  189. __dsc_driver_lock(psoc);
  190. __dsc_trans_stop(&psoc->trans);
  191. __dsc_psoc_trigger_trans(psoc);
  192. __dsc_driver_unlock(psoc);
  193. }
  194. void dsc_psoc_trans_stop(struct dsc_psoc *psoc)
  195. {
  196. dsc_enter();
  197. __dsc_psoc_trans_stop(psoc);
  198. dsc_exit();
  199. }
  200. static void __dsc_psoc_assert_trans_protected(struct dsc_psoc *psoc)
  201. {
  202. if (!dsc_assert(psoc))
  203. return;
  204. __dsc_driver_lock(psoc);
  205. dsc_assert(__dsc_trans_active(&psoc->trans) ||
  206. __dsc_trans_active(&psoc->driver->trans));
  207. __dsc_driver_unlock(psoc);
  208. }
  209. void dsc_psoc_assert_trans_protected(struct dsc_psoc *psoc)
  210. {
  211. dsc_enter();
  212. __dsc_psoc_assert_trans_protected(psoc);
  213. dsc_exit();
  214. }
  215. bool __dsc_psoc_trans_trigger_checked(struct dsc_psoc *psoc)
  216. {
  217. if (qdf_list_empty(&psoc->trans.queue))
  218. return false;
  219. /* handled, but don't trigger; we need to wait for more children */
  220. if (!__dsc_psoc_can_trigger(psoc))
  221. return true;
  222. return __dsc_trans_trigger(&psoc->trans);
  223. }
  224. static QDF_STATUS __dsc_psoc_op_start(struct dsc_psoc *psoc, const char *func)
  225. {
  226. QDF_STATUS status;
  227. if (!dsc_assert(psoc))
  228. return QDF_STATUS_E_INVAL;
  229. if (!dsc_assert(func))
  230. return QDF_STATUS_E_INVAL;
  231. __dsc_driver_lock(psoc);
  232. if (!__dsc_psoc_can_op(psoc)) {
  233. status = QDF_STATUS_E_AGAIN;
  234. goto unlock;
  235. }
  236. status = __dsc_ops_insert(&psoc->ops, func);
  237. unlock:
  238. __dsc_driver_unlock(psoc);
  239. return status;
  240. }
  241. QDF_STATUS _dsc_psoc_op_start(struct dsc_psoc *psoc, const char *func)
  242. {
  243. QDF_STATUS status;
  244. dsc_enter_str(func);
  245. status = __dsc_psoc_op_start(psoc, func);
  246. dsc_exit_status(status);
  247. return status;
  248. }
  249. static void __dsc_psoc_op_stop(struct dsc_psoc *psoc, const char *func)
  250. {
  251. if (!dsc_assert(psoc))
  252. return;
  253. if (!dsc_assert(func))
  254. return;
  255. __dsc_driver_lock(psoc);
  256. if (__dsc_ops_remove(&psoc->ops, func))
  257. qdf_event_set(&psoc->ops.event);
  258. __dsc_driver_unlock(psoc);
  259. }
  260. void _dsc_psoc_op_stop(struct dsc_psoc *psoc, const char *func)
  261. {
  262. dsc_enter_str(func);
  263. __dsc_psoc_op_stop(psoc, func);
  264. dsc_exit();
  265. }
  266. static void __dsc_psoc_wait_for_ops(struct dsc_psoc *psoc)
  267. {
  268. struct dsc_vdev *vdev;
  269. bool wait;
  270. if (!dsc_assert(psoc))
  271. return;
  272. __dsc_driver_lock(psoc);
  273. /* flushing without preventing new ops is almost certainly a bug */
  274. dsc_assert(!__dsc_psoc_can_op(psoc));
  275. wait = psoc->ops.count > 0;
  276. if (wait)
  277. qdf_event_reset(&psoc->ops.event);
  278. __dsc_driver_unlock(psoc);
  279. if (wait)
  280. qdf_wait_single_event(&psoc->ops.event, 0);
  281. /* wait for down-tree ops to complete as well */
  282. dsc_for_each_psoc_vdev(psoc, vdev)
  283. dsc_vdev_wait_for_ops(vdev);
  284. }
  285. void dsc_psoc_wait_for_ops(struct dsc_psoc *psoc)
  286. {
  287. dsc_enter();
  288. __dsc_psoc_wait_for_ops(psoc);
  289. dsc_exit();
  290. }