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 19 #include "qdf_module.h" 20 #include "qdf_trace.h" 21 #include "qdf_platform.h" 22 23 /** 24 * The following callbacks should be defined static to make sure they are 25 * initialized to NULL 26 */ 27 static qdf_self_recovery_callback self_recovery_cb; 28 static qdf_is_fw_down_callback is_fw_down_cb; 29 static qdf_is_driver_unloading_callback is_driver_unloading_cb; 30 static qdf_is_recovering_callback is_recovering_cb; 31 static qdf_is_drv_connected_callback is_drv_connected_cb; 32 static qdf_wmi_send_over_qmi_callback _wmi_send_recv_qmi_cb; 33 34 void qdf_register_fw_down_callback(qdf_is_fw_down_callback is_fw_down) 35 { 36 is_fw_down_cb = is_fw_down; 37 } 38 39 qdf_export_symbol(qdf_register_fw_down_callback); 40 41 bool qdf_is_fw_down(void) 42 { 43 if (!is_fw_down_cb) { 44 QDF_TRACE(QDF_MODULE_ID_QDF, QDF_TRACE_LEVEL_ERROR, 45 "fw down callback is not registered"); 46 return false; 47 } 48 49 return is_fw_down_cb(); 50 } 51 qdf_export_symbol(qdf_is_fw_down); 52 53 void qdf_register_wmi_send_recv_qmi_callback(qdf_wmi_send_over_qmi_callback 54 wmi_send_recv_qmi_cb) 55 { 56 _wmi_send_recv_qmi_cb = wmi_send_recv_qmi_cb; 57 } 58 59 qdf_export_symbol(qdf_register_wmi_send_recv_qmi_callback); 60 61 QDF_STATUS qdf_wmi_send_recv_qmi(void *buf, uint32_t len, void *cb_ctx, 62 qdf_wmi_recv_qmi_cb wmi_recv_qmi_cb) 63 { 64 if (!_wmi_send_recv_qmi_cb) { 65 QDF_TRACE(QDF_MODULE_ID_QDF, QDF_TRACE_LEVEL_ERROR, 66 "Platform callback for WMI over QMI not registered"); 67 return QDF_STATUS_E_INVAL; 68 } 69 70 return _wmi_send_recv_qmi_cb(buf, len, cb_ctx, wmi_recv_qmi_cb); 71 } 72 73 qdf_export_symbol(qdf_wmi_send_recv_qmi); 74 75 void qdf_register_is_driver_unloading_callback( 76 qdf_is_driver_unloading_callback callback) 77 { 78 is_driver_unloading_cb = callback; 79 } 80 81 qdf_export_symbol(qdf_register_is_driver_unloading_callback); 82 83 void qdf_register_self_recovery_callback(qdf_self_recovery_callback callback) 84 { 85 self_recovery_cb = callback; 86 } 87 88 qdf_export_symbol(qdf_register_self_recovery_callback); 89 90 void __qdf_trigger_self_recovery(enum qdf_hang_reason reason, 91 const char *func, const uint32_t line) 92 { 93 if (self_recovery_cb) 94 self_recovery_cb(reason, func, line); 95 else 96 QDF_DEBUG_PANIC_FL(func, line, ""); 97 } 98 99 qdf_export_symbol(__qdf_trigger_self_recovery); 100 101 void qdf_register_recovering_state_query_callback( 102 qdf_is_recovering_callback is_recovering) 103 { 104 is_recovering_cb = is_recovering; 105 } 106 107 bool qdf_is_driver_unloading(void) 108 { 109 if (is_driver_unloading_cb) 110 return is_driver_unloading_cb(); 111 return false; 112 } 113 114 qdf_export_symbol(qdf_is_driver_unloading); 115 116 bool qdf_is_recovering(void) 117 { 118 if (is_recovering_cb) 119 return is_recovering_cb(); 120 return false; 121 } 122 123 qdf_export_symbol(qdf_is_recovering); 124 125 static qdf_op_protect_cb __on_op_protect; 126 static qdf_op_unprotect_cb __on_op_unprotect; 127 128 void qdf_op_callbacks_register(qdf_op_protect_cb on_protect, 129 qdf_op_unprotect_cb on_unprotect) 130 { 131 __on_op_protect = on_protect; 132 __on_op_unprotect = on_unprotect; 133 } 134 qdf_export_symbol(qdf_op_callbacks_register); 135 136 int __qdf_op_protect(struct qdf_op_sync **out_sync, const char *func) 137 { 138 if (!__on_op_protect) 139 return 0; 140 141 return __on_op_protect((void **)out_sync, func); 142 } 143 qdf_export_symbol(__qdf_op_protect); 144 145 void __qdf_op_unprotect(struct qdf_op_sync *sync, const char *func) 146 { 147 if (__on_op_unprotect) 148 __on_op_unprotect(sync, func); 149 } 150 qdf_export_symbol(__qdf_op_unprotect); 151 152 void qdf_register_drv_connected_callback(qdf_is_drv_connected_callback 153 is_drv_connected) 154 { 155 is_drv_connected_cb = is_drv_connected; 156 } 157 qdf_export_symbol(qdf_register_drv_connected_callback); 158 159 bool qdf_is_drv_connected(void) 160 { 161 if (!is_drv_connected_cb) { 162 qdf_err("drv connected callback is not registered"); 163 return false; 164 } 165 166 return is_drv_connected_cb(); 167 } 168 qdf_export_symbol(qdf_is_drv_connected); 169 170 void qdf_check_state_before_panic(void) 171 { 172 if (!qdf_is_recovering() && !qdf_is_fw_down()) 173 QDF_BUG(0); 174 } 175 176 qdf_export_symbol(qdf_check_state_before_panic); 177 178