abc_common.c 29 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026
  1. /* abc_common.c
  2. *
  3. * Abnormal Behavior Catcher Common Driver
  4. *
  5. * Copyright (C) 2017 Samsung Electronics
  6. *
  7. *
  8. * This program is free software; you can redistribute it and/or modify
  9. * it under the terms of the GNU General Public License as published by
  10. * the Free Software Foundation; either version 2 of the License, or
  11. * (at your option) any later version.
  12. *
  13. * This program is distributed in the hope that it will be useful,
  14. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  16. * GNU General Public License for more details.
  17. *
  18. */
  19. #include <linux/sti/abc_common.h>
  20. #include <linux/sti/abc_spec_manager.h>
  21. #if IS_ENABLED(CONFIG_SEC_KUNIT)
  22. #include <linux/sti/abc_kunit.h>
  23. #endif
  24. #define DEBUG_ABC
  25. #define WARNING_REPORT
  26. struct abc_info *pinfo;
  27. EXPORT_SYMBOL_KUNIT(pinfo);
  28. struct list_head abc_pre_event_list;
  29. EXPORT_SYMBOL_KUNIT(abc_pre_event_list);
  30. int abc_pre_event_cnt;
  31. EXPORT_SYMBOL_KUNIT(abc_pre_event_cnt);
  32. bool abc_save_pre_event;
  33. EXPORT_SYMBOL_KUNIT(abc_save_pre_event);
  34. struct device *sec_abc;
  35. EXPORT_SYMBOL_KUNIT(sec_abc);
  36. int abc_enable_mode;
  37. EXPORT_SYMBOL_KUNIT(abc_enable_mode);
  38. int abc_init;
  39. EXPORT_SYMBOL_KUNIT(abc_init);
  40. int REGISTERED_ABC_EVENT_TOTAL;
  41. EXPORT_SYMBOL_KUNIT(REGISTERED_ABC_EVENT_TOTAL);
  42. #if IS_ENABLED(CONFIG_SEC_KUNIT)
  43. char abc_common_kunit_test_work_str[ABC_TEST_UEVENT_MAX][ABC_TEST_STR_MAX] = {"", };
  44. EXPORT_SYMBOL_KUNIT(abc_common_kunit_test_work_str);
  45. char sec_abc_kunit_test_log_str[ABC_TEST_STR_MAX];
  46. EXPORT_SYMBOL_KUNIT(sec_abc_kunit_test_log_str);
  47. char abc_hub_kunit_test_uevent_str[ABC_HUB_TEST_STR_MAX];
  48. EXPORT_SYMBOL_KUNIT(abc_hub_kunit_test_uevent_str);
  49. #endif
  50. /* "module_name", "error_name", "host", on, singular_spec, error_count */
  51. struct registered_abc_event_struct abc_event_list[] = {
  52. {"audio", "spk_amp", "it", true, true, 0, ABC_GROUP_NONE},
  53. {"audio", "spk_amp_short", "it", true, true, 0, ABC_GROUP_NONE},
  54. {"battery", "dc_batt_ov", "it", true, true, 0, ABC_GROUP_NONE},
  55. {"battery", "dc_i2c_fail", "it", true, true, 0, ABC_GROUP_NONE},
  56. {"battery", "over_voltage", "it", true, true, 0, ABC_GROUP_NONE},
  57. {"battery", "pd_input_ocp", "it", true, true, 0, ABC_GROUP_NONE},
  58. {"battery", "safety_timer", "it", true, true, 0, ABC_GROUP_NONE},
  59. {"battery", "pp_open", "it", true, true, 0, ABC_GROUP_NONE},
  60. {"battery", "lim_stuck", "it", true, true, 0, ABC_GROUP_NONE},
  61. {"battery", "lim_i2c_fail", "it", true, true, 0, ABC_GROUP_NONE},
  62. {"battery", "vsys_ovp", "it", true, true, 0, ABC_GROUP_NONE},
  63. {"battery", "dc_current", "it", true, true, 0, ABC_GROUP_NONE},
  64. {"battery", "store_fg_asoc0", "it", true, true, 0, ABC_GROUP_NONE},
  65. {"battery", "show_fg_asoc0", "it", true, true, 0, ABC_GROUP_NONE},
  66. {"battery", "charger_irq_error", "", true, true, 0, ABC_GROUP_NONE},
  67. {"bootc", "boot_time_fail", "", true, true, 0, ABC_GROUP_NONE},
  68. {"camera", "camera_error", "", true, true, 0, ABC_GROUP_NONE},
  69. {"camera", "i2c_fail", "", true, false, 0, ABC_GROUP_NONE},
  70. {"camera", "icp_error", "", true, true, 0, ABC_GROUP_NONE},
  71. {"camera", "ipp_overflow", "", true, true, 0, ABC_GROUP_NONE},
  72. {"camera", "mipi_overflow", "", true, false, 0, ABC_GROUP_NONE},
  73. #if IS_ENABLED(CONFIG_SEC_FACTORY)
  74. {"camera", "mipi_error_rw1", "", true, false, 0, ABC_GROUP_CAMERA_MIPI_ERROR_ALL},
  75. {"camera", "mipi_error_rs1", "", true, false, 0, ABC_GROUP_CAMERA_MIPI_ERROR_ALL},
  76. {"camera", "mipi_error_rt1", "", true, false, 0, ABC_GROUP_CAMERA_MIPI_ERROR_ALL},
  77. {"camera", "mipi_error_rt2", "", true, false, 0, ABC_GROUP_CAMERA_MIPI_ERROR_ALL},
  78. {"camera", "mipi_error_fw1", "", true, false, 0, ABC_GROUP_CAMERA_MIPI_ERROR_ALL},
  79. {"camera", "mipi_error_uw1", "", true, false, 0, ABC_GROUP_CAMERA_MIPI_ERROR_ALL},
  80. {"camera", "mipi_error_rm1", "", true, false, 0, ABC_GROUP_CAMERA_MIPI_ERROR_ALL},
  81. {"camera", "mipi_error_rb1", "", true, false, 0, ABC_GROUP_CAMERA_MIPI_ERROR_ALL},
  82. {"camera", "mipi_error_fs1", "", true, false, 0, ABC_GROUP_CAMERA_MIPI_ERROR_ALL},
  83. #else
  84. {"camera", "mipi_error_rw1", "", false, false, 0, ABC_GROUP_CAMERA_MIPI_ERROR_ALL},
  85. {"camera", "mipi_error_rs1", "", false, false, 0, ABC_GROUP_CAMERA_MIPI_ERROR_ALL},
  86. {"camera", "mipi_error_rt1", "", false, false, 0, ABC_GROUP_CAMERA_MIPI_ERROR_ALL},
  87. {"camera", "mipi_error_rt2", "", false, false, 0, ABC_GROUP_CAMERA_MIPI_ERROR_ALL},
  88. {"camera", "mipi_error_fw1", "", false, false, 0, ABC_GROUP_CAMERA_MIPI_ERROR_ALL},
  89. {"camera", "mipi_error_uw1", "", false, false, 0, ABC_GROUP_CAMERA_MIPI_ERROR_ALL},
  90. {"camera", "mipi_error_rm1", "", false, false, 0, ABC_GROUP_CAMERA_MIPI_ERROR_ALL},
  91. {"camera", "mipi_error_rb1", "", false, false, 0, ABC_GROUP_CAMERA_MIPI_ERROR_ALL},
  92. {"camera", "mipi_error_fs1", "", false, false, 0, ABC_GROUP_CAMERA_MIPI_ERROR_ALL},
  93. #endif
  94. {"cond", "CAM_CONNECT", "", true, true, 0, ABC_GROUP_NONE},
  95. {"cond", "LOWER_C2C_DETECT", "", true, true, 0, ABC_GROUP_NONE},
  96. {"cond", "MAIN_BAT_DETECT", "", true, true, 0, ABC_GROUP_NONE},
  97. {"cond", "MAIN_DIGITIZER_DETECT", "", true, true, 0, ABC_GROUP_NONE},
  98. {"cond", "SUB_BAT_DETECT", "", true, true, 0, ABC_GROUP_NONE},
  99. {"cond", "SUB_CONNECT", "", true, true, 0, ABC_GROUP_NONE},
  100. {"cond", "SUB_LOWER_DETECT", "", true, true, 0, ABC_GROUP_NONE},
  101. {"cond", "SUB_UB_DETECT", "", true, true, 0, ABC_GROUP_NONE},
  102. {"cond", "TOF_CONNECT", "", true, true, 0, ABC_GROUP_NONE},
  103. {"cond", "UPPER_C2C_DETECT", "", true, true, 0, ABC_GROUP_NONE},
  104. {"decon", "fence_timeout", "", true, true, 0, ABC_GROUP_NONE},
  105. {"display", "act_section_dsierr0", "", true, true, 0, ABC_GROUP_NONE},
  106. {"display", "act_section_dsierr1", "", true, true, 0, ABC_GROUP_NONE},
  107. {"display", "panel_main_no_te", "", true, true, 0, ABC_GROUP_NONE},
  108. {"display", "panel_sub_no_te", "", true, true, 0, ABC_GROUP_NONE},
  109. {"gpu", "gpu_fault", "", true, false, 0, ABC_GROUP_NONE},
  110. {"gpu", "gpu_job_timeout", "", true, false, 0, ABC_GROUP_NONE},
  111. {"gpu_qc", "gpu_fault", "", true, false, 0, ABC_GROUP_NONE},
  112. {"gpu_qc", "gpu_page_fault", "", true, false, 0, ABC_GROUP_NONE},
  113. {"mm", "venus_data_corrupt", "", true, true, 0, ABC_GROUP_NONE},
  114. {"mm", "venus_fw_load_fail", "", true, true, 0, ABC_GROUP_NONE},
  115. {"mm", "venus_hung", "", true, false, 0, ABC_GROUP_NONE},
  116. {"mm", "vidc_sys_err_type2", "", true, true, 0, ABC_GROUP_NONE},
  117. {"mm", "vidc_sys_err_type3", "", true, true, 0, ABC_GROUP_NONE},
  118. {"muic", "afc_hv_fail", "", true, true, 0, ABC_GROUP_NONE},
  119. {"muic", "cable_short", "", true, true, 0, ABC_GROUP_NONE},
  120. {"muic", "qc_hv_fail", "", true, true, 0, ABC_GROUP_NONE},
  121. {"npu", "npu_fw_warning", "", true, true, 0, ABC_GROUP_NONE},
  122. {"pdic", "i2c_fail", "it", true, true, 0, ABC_GROUP_NONE},
  123. {"pdic", "water_det", "", true, true, 0, ABC_GROUP_NONE},
  124. {"pdic", "ccic_stuck", "it", true, true, 0, ABC_GROUP_NONE},
  125. {"pmic", "s2dos05_bulk_read", "it", true, true, 0, ABC_GROUP_NONE},
  126. {"pmic", "s2dos05_bulk_write", "it", true, true, 0, ABC_GROUP_NONE},
  127. {"pmic", "s2dos05_read_reg", "it", true, true, 0, ABC_GROUP_NONE},
  128. {"pmic", "s2dos05_read_word", "it", true, true, 0, ABC_GROUP_NONE},
  129. {"pmic", "s2dos05_update_reg", "it", true, true, 0, ABC_GROUP_NONE},
  130. {"pmic", "s2dos05_write_reg", "it", true, true, 0, ABC_GROUP_NONE},
  131. {"pmic", "s2dos05_bulk_read_fail", "it", true, true, 0, ABC_GROUP_NONE},
  132. {"pmic", "s2dos05_bulk_write_fail", "it", true, true, 0, ABC_GROUP_NONE},
  133. {"pmic", "s2dos05_read_reg_fail", "it", true, true, 0, ABC_GROUP_NONE},
  134. {"pmic", "s2dos05_read_word_fail", "it", true, true, 0, ABC_GROUP_NONE},
  135. {"pmic", "s2dos05_update_reg_fail", "it", true, true, 0, ABC_GROUP_NONE},
  136. {"pmic", "s2dos05_write_reg_fail", "it", true, true, 0, ABC_GROUP_NONE},
  137. {"pmic", "s2dos05_scp", "", true, true, 0, ABC_GROUP_NONE},
  138. {"pmic", "s2dos05_ssd", "", true, true, 0, ABC_GROUP_NONE},
  139. {"storage", "mmc_hwreset_err", "", true, true, 0, ABC_GROUP_NONE},
  140. {"storage", "sd_removed_err", "", true, true, 0, ABC_GROUP_NONE},
  141. {"storage", "ufs_hwreset_err", "it", true, true, 0, ABC_GROUP_NONE},
  142. {"storage", "ufs_medium_err", "it", true, true, 0, ABC_GROUP_NONE},
  143. {"storage", "ufs_hardware_err", "it", true, true, 0, ABC_GROUP_NONE},
  144. {"tsp", "tsp_int_fault", "", true, false, 0, ABC_GROUP_NONE},
  145. {"tsp_sub", "tsp_int_fault", "", true, false, 0, ABC_GROUP_NONE},
  146. {"ub_main", "ub_disconnected", "it", true, true, 0, ABC_GROUP_NONE},
  147. {"ub_sub", "ub_disconnected", "it", true, true, 0, ABC_GROUP_NONE},
  148. {"vib", "fw_load_fail", "it", true, true, 0, ABC_GROUP_NONE},
  149. {"vib", "int_gnd_short", "", true, false, 0, ABC_GROUP_NONE},
  150. {"wacom", "digitizer_not_connected", "", true, true, 0, ABC_GROUP_NONE},
  151. #if IS_ENABLED(CONFIG_SEC_KUNIT)
  152. {"kunit", "test_warn", "", true, true, 0, ABC_GROUP_NONE},
  153. {"kunit", "test_info", "", true, true, 0, ABC_GROUP_NONE},
  154. {"kunit", "test_error", "", true, true, 0, ABC_GROUP_NONE},
  155. #endif
  156. };
  157. EXPORT_SYMBOL_KUNIT(abc_event_list);
  158. struct abc_enable_cmd_struct enable_cmd_list[] = {
  159. {ERROR_REPORT_MODE_ENABLE, ERROR_REPORT_MODE_BIT, "ERROR_REPORT=1"},
  160. {ERROR_REPORT_MODE_DISABLE, ERROR_REPORT_MODE_BIT, "ERROR_REPORT=0"},
  161. {ALL_REPORT_MODE_ENABLE, ALL_REPORT_MODE_BIT, "ALL_REPORT=1"},
  162. {ALL_REPORT_MODE_DISABLE, ALL_REPORT_MODE_BIT, "ALL_REPORT=0"},
  163. {PRE_EVENT_ENABLE, PRE_EVENT_ENABLE_BIT, "PRE_EVENT=1"},
  164. {PRE_EVENT_DISABLE, PRE_EVENT_ENABLE_BIT, "PRE_EVENT=0"},
  165. };
  166. #if IS_ENABLED(CONFIG_OF)
  167. static const struct of_device_id sec_abc_dt_match[] = {
  168. { .compatible = "samsung,sec_abc" },
  169. { }
  170. };
  171. #endif
  172. #if IS_ENABLED(CONFIG_SEC_KUNIT)
  173. void abc_common_test_get_work_str(char *utest_event_str[])
  174. {
  175. int i;
  176. for (i = 0; i < ABC_TEST_UEVENT_MAX; i++) {
  177. if (utest_event_str[i]) {
  178. if (i >= 2 && !strncmp(utest_event_str[i], TIME_KEYWORD, strlen(TIME_KEYWORD)))
  179. strlcpy(abc_common_kunit_test_work_str[i],
  180. TIME_KEYWORD, ABC_TEST_STR_MAX);
  181. else
  182. strlcpy(abc_common_kunit_test_work_str[i],
  183. utest_event_str[i], ABC_TEST_STR_MAX);
  184. }
  185. }
  186. }
  187. EXPORT_SYMBOL_KUNIT(abc_common_test_get_work_str);
  188. void abc_common_test_get_log_str(char *log_str)
  189. {
  190. strlcpy(sec_abc_kunit_test_log_str, log_str, sizeof(sec_abc_kunit_test_log_str));
  191. }
  192. EXPORT_SYMBOL_KUNIT(abc_common_test_get_log_str);
  193. #endif
  194. static int sec_abc_resume(struct device *dev)
  195. {
  196. return 0;
  197. }
  198. static int sec_abc_remove(struct platform_device *pdev)
  199. {
  200. return 0;
  201. }
  202. static const struct dev_pm_ops sec_abc_pm = {
  203. .resume = sec_abc_resume,
  204. };
  205. int sec_abc_get_idx_of_registered_event(char *module_name, char *error_name)
  206. {
  207. int i;
  208. for (i = 0; i < REGISTERED_ABC_EVENT_TOTAL; i++)
  209. if (!strncmp(module_name, abc_event_list[i].module_name, ABC_EVENT_STR_MAX) &&
  210. !strncmp(error_name, abc_event_list[i].error_name, ABC_EVENT_STR_MAX))
  211. return i;
  212. return -1;
  213. }
  214. EXPORT_SYMBOL_KUNIT(sec_abc_get_idx_of_registered_event);
  215. #if !IS_ENABLED(CONFIG_SEC_FACTORY) && !IS_ENABLED(CONFIG_SEC_KUNIT)
  216. static int sec_abc_get_error_count(char *module_name, char *error_name)
  217. {
  218. int i = sec_abc_get_idx_of_registered_event(module_name, error_name);
  219. if (i >= 0)
  220. return abc_event_list[i].error_count;
  221. return 0;
  222. }
  223. static void sec_abc_update_error_count(char *module_name, char *error_name)
  224. {
  225. int i = sec_abc_get_idx_of_registered_event(module_name, error_name);
  226. if (i >= 0)
  227. abc_event_list[i].error_count++;
  228. }
  229. static void sec_abc_reset_error_count(void)
  230. {
  231. int i;
  232. for (i = 0; i < REGISTERED_ABC_EVENT_TOTAL; i++)
  233. abc_event_list[i].error_count = 0;
  234. }
  235. static bool sec_abc_is_skip_event(char *abc_str)
  236. {
  237. struct abc_key_data key_data;
  238. int count;
  239. if (sec_abc_make_key_data(&key_data, abc_str)) {
  240. ABC_PRINT("Event string isn't valid. Check Input : %s", abc_str);
  241. return true;
  242. }
  243. count = sec_abc_get_error_count(key_data.event_module, key_data.event_name);
  244. if (count >= ABC_SKIP_EVENT_COUNT_THRESHOLD) {
  245. if (count == ABC_SKIP_EVENT_COUNT_THRESHOLD) {
  246. ABC_PRINT("[%s-%s] ABC Error already detected %d times! It is skipped from now on!",
  247. key_data.event_module, key_data.event_name, ABC_SKIP_EVENT_COUNT_THRESHOLD);
  248. sec_abc_update_error_count(key_data.event_module, key_data.event_name);
  249. }
  250. return true;
  251. }
  252. return false;
  253. }
  254. #endif
  255. void sec_abc_send_uevent(struct abc_key_data *key_data, char *uevent_type)
  256. {
  257. char *uevent_str[ABC_UEVENT_MAX] = {0,};
  258. char uevent_module_str[ABC_EVENT_STR_MAX + 7];
  259. char uevent_event_str[ABC_EVENT_STR_MAX + ABC_TYPE_STR_MAX];
  260. char uevent_host_str[ABC_EVENT_STR_MAX];
  261. char uevent_ext_log_str[ABC_EVENT_STR_MAX];
  262. char timestamp[TIME_STAMP_STR_MAX];
  263. int idx;
  264. if (!sec_abc_get_enabled()) {
  265. ABC_PRINT("ABC isn't enabled. Save pre_event");
  266. sec_abc_save_pre_events(key_data, uevent_type);
  267. return;
  268. }
  269. snprintf(uevent_module_str, ABC_EVENT_STR_MAX, "MODULE=%s", key_data->event_module);
  270. snprintf(uevent_event_str, ABC_EVENT_STR_MAX, "%s=%s", uevent_type, key_data->event_name);
  271. snprintf(timestamp, TIME_STAMP_STR_MAX, "TIMESTAMP=%d", key_data->cur_time);
  272. uevent_str[0] = uevent_module_str;
  273. uevent_str[1] = uevent_event_str;
  274. uevent_str[2] = timestamp;
  275. if (abc_event_list[key_data->idx].host[0]) {
  276. snprintf(uevent_host_str, ABC_EVENT_STR_MAX, "HOST=%s", abc_event_list[key_data->idx].host);
  277. uevent_str[3] = uevent_host_str;
  278. }
  279. if (key_data->ext_log[0]) {
  280. snprintf(uevent_ext_log_str, ABC_EVENT_STR_MAX, "EXT_LOG=%s", key_data->ext_log);
  281. uevent_str[4] = uevent_ext_log_str;
  282. }
  283. for (idx = 0; uevent_str[idx]; idx++)
  284. ABC_PRINT("%s", uevent_str[idx]);
  285. #if IS_ENABLED(CONFIG_SEC_KUNIT)
  286. abc_common_test_get_work_str(uevent_str);
  287. complete(&pinfo->test_uevent_done);
  288. #endif
  289. #if !IS_ENABLED(CONFIG_SEC_FACTORY) && !IS_ENABLED(CONFIG_SEC_KUNIT)
  290. sec_abc_update_error_count(key_data->event_module, key_data->event_name);
  291. #endif
  292. kobject_uevent_env(&sec_abc->kobj, KOBJ_CHANGE, uevent_str);
  293. }
  294. EXPORT_SYMBOL_KUNIT(sec_abc_send_uevent);
  295. __visible_for_testing
  296. struct abc_pre_event *sec_abc_get_pre_event_node(struct abc_key_data *key_data)
  297. {
  298. struct abc_pre_event *pre_event;
  299. list_for_each_entry(pre_event, &abc_pre_event_list, node) {
  300. if (!strcmp(pre_event->key_data.event_module, key_data->event_module) &&
  301. !strcmp(pre_event->key_data.event_name, key_data->event_name)) {
  302. ABC_PRINT("return matched node");
  303. return pre_event;
  304. }
  305. }
  306. pre_event = NULL;
  307. if (abc_pre_event_cnt < ABC_PREOCCURRED_EVENT_MAX) {
  308. pre_event = kzalloc(sizeof(*pre_event), GFP_KERNEL);
  309. if (pre_event) {
  310. list_add_tail(&pre_event->node, &abc_pre_event_list);
  311. abc_pre_event_cnt++;
  312. ABC_PRINT("return new node");
  313. } else
  314. ABC_PRINT("failed to get node");
  315. }
  316. return pre_event;
  317. }
  318. EXPORT_SYMBOL_KUNIT(sec_abc_get_pre_event_node);
  319. __visible_for_testing
  320. int sec_abc_clear_pre_events(void)
  321. {
  322. struct abc_pre_event *pre_event;
  323. int cnt = 0;
  324. ABC_PRINT("start");
  325. mutex_lock(&pinfo->pre_event_mutex);
  326. while (!list_empty(&abc_pre_event_list)) {
  327. pre_event = list_first_entry(&abc_pre_event_list,
  328. struct abc_pre_event,
  329. node);
  330. list_del(&pre_event->node);
  331. kfree(pre_event);
  332. cnt++;
  333. }
  334. abc_pre_event_cnt = 0;
  335. /* Once Pre_events were cleared, don't save pre_event anymore. */
  336. abc_save_pre_event = false;
  337. abc_enable_mode &= ~(PRE_EVENT_ENABLE_BIT);
  338. #if IS_ENABLED(CONFIG_SEC_KUNIT)
  339. complete(&pinfo->test_work_done);
  340. #endif
  341. mutex_unlock(&pinfo->pre_event_mutex);
  342. ABC_PRINT("end");
  343. return cnt;
  344. }
  345. EXPORT_SYMBOL_KUNIT(sec_abc_clear_pre_events);
  346. __visible_for_testing
  347. int sec_abc_process_pre_events(void)
  348. {
  349. struct abc_pre_event *pre_event;
  350. int i, cnt = 0;
  351. ABC_PRINT("start");
  352. mutex_lock(&pinfo->pre_event_mutex);
  353. list_for_each_entry(pre_event, &abc_pre_event_list, node) {
  354. if (abc_enable_mode & ALL_REPORT_MODE_BIT) {
  355. ABC_PRINT("All report mode. Send uevent");
  356. cnt += pre_event->all_cnt;
  357. for (i = 0; i < pre_event->all_cnt; i++)
  358. sec_abc_send_uevent(&pre_event->key_data, pre_event->key_data.event_type);
  359. }
  360. cnt += pre_event->error_cnt;
  361. for (i = 0; i < pre_event->error_cnt; i++)
  362. if (abc_event_list[pre_event->key_data.idx].enabled)
  363. sec_abc_send_uevent(&pre_event->key_data, "ERROR");
  364. }
  365. mutex_unlock(&pinfo->pre_event_mutex);
  366. ABC_PRINT("pre_event cnt : %d end", cnt);
  367. return cnt;
  368. }
  369. EXPORT_SYMBOL_KUNIT(sec_abc_process_pre_events);
  370. int sec_abc_save_pre_events(struct abc_key_data *key_data, char *uevent_type)
  371. {
  372. struct abc_pre_event *pre_event;
  373. int ret = 0;
  374. mutex_lock(&pinfo->pre_event_mutex);
  375. ABC_PRINT("start Module(%s) Event(%s) Type(%s)",
  376. key_data->event_module,
  377. key_data->event_name,
  378. uevent_type);
  379. pre_event = sec_abc_get_pre_event_node(key_data);
  380. if (!pre_event) {
  381. ABC_PRINT_KUNIT("Failed to add Pre_event");
  382. ret = -EINVAL;
  383. goto out;
  384. }
  385. pre_event->key_data = *key_data;
  386. if (!strncmp(uevent_type, "ERROR", 5))
  387. pre_event->error_cnt++;
  388. else
  389. pre_event->all_cnt++;
  390. out:
  391. mutex_unlock(&pinfo->pre_event_mutex);
  392. ABC_PRINT("end");
  393. return ret;
  394. }
  395. EXPORT_SYMBOL_KUNIT(sec_abc_save_pre_events);
  396. __visible_for_testing
  397. void sec_abc_process_changed_enable_mode(void)
  398. {
  399. if (sec_abc_get_enabled()) {
  400. if (abc_enable_mode & PRE_EVENT_ENABLE_BIT) {
  401. sec_abc_process_pre_events();
  402. ABC_PRINT_KUNIT("Pre_events processed");
  403. } else {
  404. ABC_PRINT_KUNIT("ABC enabled. Pre_event disabled");
  405. }
  406. complete(&pinfo->enable_done);
  407. } else {
  408. ABC_PRINT_KUNIT("ABC is disabled. Clear events");
  409. sec_abc_reset_all_buffer();
  410. #if !IS_ENABLED(CONFIG_SEC_FACTORY) && !IS_ENABLED(CONFIG_SEC_KUNIT)
  411. sec_abc_reset_error_count();
  412. #endif
  413. }
  414. ABC_PRINT("%d Pre_events cleared", sec_abc_clear_pre_events());
  415. }
  416. EXPORT_SYMBOL_KUNIT(sec_abc_process_changed_enable_mode);
  417. /* Change ABC driver's enable mode.
  418. *
  419. * Interface with ACT : write "1" or "0"
  420. * Interfcae with LABO
  421. * ex) "ERROR_REPORT=1,PRE_EVENT=1", "ALL_REPORT=1,ERROR_REPORT=0,PRE_EVENT=0" ...
  422. *
  423. */
  424. __visible_for_testing
  425. ssize_t enabled_store(struct device *dev,
  426. struct device_attribute *attr,
  427. const char *buf,
  428. size_t count)
  429. {
  430. char *c, *p, *enable_cmd[ABC_CMD_MAX];
  431. char temp[ABC_CMD_STR_MAX * 3];
  432. int items, i, j, idx = 0;
  433. bool chk = false;
  434. int origin_enable_mode = abc_enable_mode;
  435. if (!strncmp(buf, "1", 1)) {
  436. /* Interface with ACT */
  437. ABC_PRINT("Error report mode enabled");
  438. abc_enable_mode |= ERROR_REPORT_MODE_BIT;
  439. } else if (!strncmp(buf, "0", 1)) {
  440. ABC_PRINT("Error report mode disabled");
  441. abc_enable_mode &= (~ERROR_REPORT_MODE_BIT);
  442. } else {
  443. strlcpy(temp, buf, ABC_CMD_STR_MAX * 3);
  444. p = temp;
  445. items = ARRAY_SIZE(enable_cmd_list);
  446. while ((c = strsep(&p, ",")) != NULL && idx < ABC_CMD_MAX) {
  447. enable_cmd[idx] = c;
  448. idx++;
  449. }
  450. for (i = 0; i < idx; i++) {
  451. chk = false;
  452. for (j = 0; j < items; j++) {
  453. if (!strncmp(enable_cmd[i],
  454. enable_cmd_list[j].abc_cmd_str,
  455. strlen(enable_cmd_list[j].abc_cmd_str))) {
  456. if (strstr(enable_cmd_list[j].abc_cmd_str, "=1"))
  457. abc_enable_mode |= enable_cmd_list[j].enable_value;
  458. else
  459. abc_enable_mode &= ~(enable_cmd_list[j].enable_value);
  460. chk = true;
  461. }
  462. }
  463. if (!chk) {
  464. ABC_PRINT_KUNIT("Invalid string. Check the Input");
  465. abc_enable_mode = origin_enable_mode;
  466. return count;
  467. }
  468. }
  469. }
  470. sec_abc_process_changed_enable_mode();
  471. return count;
  472. }
  473. EXPORT_SYMBOL_KUNIT(enabled_store);
  474. __visible_for_testing
  475. ssize_t enabled_show(struct device *dev,
  476. struct device_attribute *attr,
  477. char *buf)
  478. {
  479. if (sec_abc_get_enabled())
  480. return sprintf(buf, "1\n");
  481. else
  482. return sprintf(buf, "0\n");
  483. }
  484. EXPORT_SYMBOL_KUNIT(enabled_show);
  485. static DEVICE_ATTR_RW(enabled);
  486. __visible_for_testing
  487. ssize_t spec_store(struct device *dev,
  488. struct device_attribute *attr,
  489. const char *buf,
  490. size_t count)
  491. {
  492. mutex_lock(&pinfo->spec_mutex);
  493. sec_abc_change_spec(buf);
  494. mutex_unlock(&pinfo->spec_mutex);
  495. return count;
  496. }
  497. EXPORT_SYMBOL_KUNIT(spec_store);
  498. __visible_for_testing
  499. ssize_t spec_show(struct device *dev,
  500. struct device_attribute *attr,
  501. char *buf)
  502. {
  503. int count = 0;
  504. mutex_lock(&pinfo->spec_mutex);
  505. count = sec_abc_read_spec(buf);
  506. mutex_unlock(&pinfo->spec_mutex);
  507. return count;
  508. }
  509. EXPORT_SYMBOL_KUNIT(spec_show);
  510. static DEVICE_ATTR_RW(spec);
  511. __visible_for_testing
  512. ssize_t features_store(struct device *dev,
  513. struct device_attribute *attr,
  514. const char *buf,
  515. size_t count)
  516. {
  517. return count;
  518. }
  519. __visible_for_testing
  520. ssize_t features_show(struct device *dev,
  521. struct device_attribute *attr,
  522. char *buf)
  523. {
  524. int count = 0;
  525. count += scnprintf(buf, PAGE_SIZE, "spec_control\nhost\n");
  526. return count;
  527. }
  528. EXPORT_SYMBOL_KUNIT(features_show);
  529. static DEVICE_ATTR_RW(features);
  530. __visible_for_testing
  531. ssize_t list_store(struct device *dev,
  532. struct device_attribute *attr,
  533. const char *buf,
  534. size_t count)
  535. {
  536. return count;
  537. }
  538. EXPORT_SYMBOL_KUNIT(list_store);
  539. __visible_for_testing
  540. ssize_t list_show(struct device *dev,
  541. struct device_attribute *attr,
  542. char *buf)
  543. {
  544. int count = 0;
  545. int i;
  546. for (i = 0; i < REGISTERED_ABC_EVENT_TOTAL; i++)
  547. {
  548. count += scnprintf(buf + count, PAGE_SIZE - count, "%s,%s\n",
  549. abc_event_list[i].module_name, abc_event_list[i].error_name);
  550. }
  551. ABC_PRINT("%d", count);
  552. return count;
  553. }
  554. EXPORT_SYMBOL_KUNIT(list_show);
  555. static DEVICE_ATTR_RW(list);
  556. static struct attribute *sec_abc_attr[] = {
  557. &dev_attr_enabled.attr,
  558. &dev_attr_spec.attr,
  559. &dev_attr_features.attr,
  560. &dev_attr_list.attr,
  561. NULL,
  562. };
  563. static struct attribute_group sec_abc_attr_group = {
  564. .attrs = sec_abc_attr,
  565. };
  566. int sec_abc_get_enabled(void)
  567. {
  568. return (abc_enable_mode & (ERROR_REPORT_MODE_BIT | ALL_REPORT_MODE_BIT));
  569. }
  570. EXPORT_SYMBOL(sec_abc_get_enabled);
  571. static void sec_abc_work_func_clear_pre_events(struct work_struct *work)
  572. {
  573. ABC_DEBUG("start");
  574. sec_abc_clear_pre_events();
  575. ABC_DEBUG("end");
  576. }
  577. #if IS_ENABLED(CONFIG_UML)
  578. static void sec_abc_init_key_data(struct abc_key_data *key_data)
  579. {
  580. memset(key_data->event_module, 0, sizeof(key_data->event_module));
  581. memset(key_data->event_name, 0, sizeof(key_data->event_name));
  582. memset(key_data->event_type, 0, sizeof(key_data->event_type));
  583. memset(key_data->ext_log, 0, sizeof(key_data->ext_log));
  584. }
  585. #endif
  586. static void sec_abc_work_func(struct work_struct *work)
  587. {
  588. struct abc_event_work *event_work_data;
  589. struct abc_key_data key_data;
  590. int idx;
  591. mutex_lock(&pinfo->work_mutex);
  592. event_work_data = container_of(work, struct abc_event_work, work);
  593. ABC_DEBUG("work start. str : %s", event_work_data->abc_str);
  594. #if IS_ENABLED(CONFIG_UML)
  595. sec_abc_init_key_data(&key_data);
  596. #endif
  597. if (sec_abc_make_key_data(&key_data, event_work_data->abc_str)) {
  598. ABC_PRINT("Event string isn't valid. Check Input : %s", event_work_data->abc_str);
  599. goto abc_work_end;
  600. }
  601. idx = sec_abc_get_idx_of_registered_event(key_data.event_module, key_data.event_name);
  602. if (idx < 0) {
  603. ABC_PRINT_KUNIT("%s : %s isn't registered", key_data.event_module, key_data.event_name);
  604. goto abc_work_end;
  605. }
  606. key_data.idx = idx;
  607. #if IS_ENABLED(CONFIG_SEC_ABC_MOTTO)
  608. #if !IS_ENABLED(CONFIG_UML)
  609. motto_send_device_info(key_data.event_module, key_data.event_name);
  610. #endif
  611. #endif
  612. if (abc_enable_mode & (ALL_REPORT_MODE_BIT | PRE_EVENT_ENABLE_BIT)) {
  613. ABC_PRINT("All report mode may be enabled. Send uevent");
  614. sec_abc_send_uevent(&key_data, key_data.event_type);
  615. }
  616. if (!abc_event_list[idx].enabled || !strncmp(key_data.event_type, "INFO", 4)) {
  617. ABC_PRINT_KUNIT("Don't send error report");
  618. goto abc_work_end;
  619. }
  620. if (abc_event_list[idx].singular_spec) {
  621. ABC_PRINT("Send uevent : %s", event_work_data->abc_str);
  622. sec_abc_send_uevent(&key_data, "ERROR");
  623. } else {
  624. sec_abc_enqueue_event_data(&key_data);
  625. if (sec_abc_reached_spec(&key_data)) {
  626. ABC_PRINT("Send uevent : %s", event_work_data->abc_str);
  627. sec_abc_send_uevent(&key_data, "ERROR");
  628. sec_abc_reset_event_buffer(&key_data);
  629. }
  630. }
  631. abc_work_end:
  632. ABC_DEBUG("work done");
  633. mutex_unlock(&pinfo->work_mutex);
  634. #if IS_ENABLED(CONFIG_SEC_KUNIT)
  635. complete(&pinfo->test_work_done);
  636. #endif
  637. }
  638. /* event string format
  639. *
  640. * ex)
  641. * MODULE=tsp@WARN=power_status_mismatch
  642. * MODULE=gpu@INFO=gpu_fault
  643. * MODULE=tsp@ERROR=power_status_mismatch@EXT_LOG=fw_ver(0108)
  644. *
  645. */
  646. __visible_for_testing
  647. void sec_abc_enqueue_work(struct abc_event_work work_data[], char *str)
  648. {
  649. int idx;
  650. for (idx = 0; idx < ABC_WORK_MAX; idx++) {
  651. if (!work_pending(&work_data[idx].work)) {
  652. ABC_DEBUG("Event %s use work[%d]", str, idx);
  653. strlcpy(work_data[idx].abc_str, str, ABC_BUFFER_MAX);
  654. queue_work(pinfo->workqueue, &work_data[idx].work);
  655. return;
  656. }
  657. }
  658. ABC_PRINT("Failed. All works are in queue");
  659. }
  660. void sec_abc_send_event(char *str)
  661. {
  662. #if !IS_ENABLED(CONFIG_SEC_FACTORY) && !IS_ENABLED(CONFIG_SEC_KUNIT)
  663. if (sec_abc_is_skip_event(str))
  664. return;
  665. #endif
  666. if (!abc_init) {
  667. ABC_PRINT_KUNIT("ABC driver is not initialized!(%s)", str);
  668. return;
  669. }
  670. if (!sec_abc_get_enabled() && !abc_save_pre_event) {
  671. ABC_PRINT_KUNIT("ABC is disabled and pre_event is disabled.(%s)", str);
  672. return;
  673. }
  674. ABC_PRINT("ABC is working. Queue work.(%s)", str);
  675. sec_abc_enqueue_work(pinfo->event_work_data, str);
  676. }
  677. EXPORT_SYMBOL(sec_abc_send_event);
  678. /**
  679. * sec_abc_wait_enable() - wait for abc enable done
  680. * Return : 0 for success, -1 for fail(timeout or abc not initialized)
  681. */
  682. int sec_abc_wait_enabled(void)
  683. {
  684. unsigned long timeout;
  685. if (!abc_init) {
  686. ABC_PRINT_KUNIT("ABC driver is not initialized!");
  687. return -1;
  688. }
  689. if (sec_abc_get_enabled())
  690. return 0;
  691. reinit_completion(&pinfo->enable_done);
  692. timeout = wait_for_completion_timeout(&pinfo->enable_done,
  693. msecs_to_jiffies(ABC_WAIT_ENABLE_TIMEOUT));
  694. if (timeout == 0) {
  695. ABC_PRINT_KUNIT("timeout!");
  696. return -1;
  697. }
  698. return 0;
  699. }
  700. EXPORT_SYMBOL(sec_abc_wait_enabled);
  701. __visible_for_testing
  702. void sec_abc_init_work(struct abc_info *pinfo)
  703. {
  704. int idx;
  705. pinfo->workqueue = create_singlethread_workqueue("sec_abc_wq");
  706. INIT_DELAYED_WORK(&pinfo->clear_pre_events, sec_abc_work_func_clear_pre_events);
  707. /* After timeout clear abc events occurred when abc disalbed. */
  708. queue_delayed_work(pinfo->workqueue,
  709. &pinfo->clear_pre_events,
  710. msecs_to_jiffies(ABC_CLEAR_EVENT_TIMEOUT));
  711. /* Work for abc_events & pre_events (events occurred before enabled) */
  712. for (idx = 0; idx < ABC_WORK_MAX; idx++)
  713. INIT_WORK(&pinfo->event_work_data[idx].work, sec_abc_work_func);
  714. }
  715. EXPORT_SYMBOL_KUNIT(sec_abc_init_work);
  716. __visible_for_testing
  717. int sec_abc_get_registered_abc_event_total(void)
  718. {
  719. return ARRAY_SIZE(abc_event_list);
  720. }
  721. EXPORT_SYMBOL_KUNIT(sec_abc_get_registered_abc_event_total);
  722. static int sec_abc_probe(struct platform_device *pdev)
  723. {
  724. struct abc_platform_data *pdata;
  725. int ret = 0;
  726. ABC_PRINT("start");
  727. abc_init = false;
  728. REGISTERED_ABC_EVENT_TOTAL = sec_abc_get_registered_abc_event_total();
  729. if (pdev->dev.of_node) {
  730. pdata = devm_kzalloc(&pdev->dev,
  731. sizeof(struct abc_platform_data), GFP_KERNEL);
  732. if (!pdata) {
  733. dev_err(&pdev->dev, "Failed to allocate platform data");
  734. ret = -ENOMEM;
  735. goto out;
  736. }
  737. pdev->dev.platform_data = pdata;
  738. ret = abc_parse_dt(&pdev->dev);
  739. if (ret) {
  740. dev_err(&pdev->dev, "Failed to parse dt data");
  741. goto err_parse_dt;
  742. }
  743. ABC_PRINT("parse dt done");
  744. } else {
  745. pdata = pdev->dev.platform_data;
  746. }
  747. if (!pdata) {
  748. dev_err(&pdev->dev, "There are no platform data");
  749. ret = -EINVAL;
  750. goto out;
  751. }
  752. pinfo = kzalloc(sizeof(*pinfo), GFP_KERNEL);
  753. if (!pinfo) {
  754. ret = -ENOMEM;
  755. goto err_alloc_pinfo;
  756. }
  757. #if IS_ENABLED(CONFIG_DRV_SAMSUNG)
  758. pinfo->dev = sec_device_create(pinfo, "sec_abc");
  759. #else
  760. pinfo->dev = device_create(sec_class, NULL, 0, NULL, "sec_abc");
  761. #endif
  762. if (IS_ERR(pinfo->dev)) {
  763. pr_err("%s Failed to create device(sec_abc)!", __func__);
  764. ret = -ENODEV;
  765. goto err_create_device;
  766. }
  767. sec_abc = pinfo->dev;
  768. ret = sysfs_create_group(&pinfo->dev->kobj, &sec_abc_attr_group);
  769. if (ret) {
  770. pr_err("%s: Failed to create device attribute group", __func__);
  771. goto err_create_abc_attr_group;
  772. }
  773. INIT_LIST_HEAD(&abc_pre_event_list);
  774. sec_abc_init_work(pinfo);
  775. if (!pinfo->workqueue)
  776. goto err_create_abc_wq;
  777. #if IS_ENABLED(CONFIG_SEC_KUNIT)
  778. init_completion(&pinfo->test_uevent_done);
  779. init_completion(&pinfo->test_work_done);
  780. #endif
  781. init_completion(&pinfo->enable_done);
  782. mutex_init(&pinfo->pre_event_mutex);
  783. mutex_init(&pinfo->enable_mutex);
  784. mutex_init(&pinfo->work_mutex);
  785. mutex_init(&pinfo->spec_mutex);
  786. pinfo->pdata = pdata;
  787. platform_set_drvdata(pdev, pinfo);
  788. #if IS_ENABLED(CONFIG_SEC_ABC_MOTTO)
  789. motto_init(pdev);
  790. #endif
  791. abc_init = true;
  792. abc_enable_mode |= PRE_EVENT_ENABLE_BIT;
  793. abc_save_pre_event = true;
  794. ABC_PRINT("success");
  795. return ret;
  796. err_create_abc_wq:
  797. sysfs_remove_group(&pinfo->dev->kobj, &sec_abc_attr_group);
  798. err_create_abc_attr_group:
  799. #if IS_ENABLED(CONFIG_DRV_SAMSUNG)
  800. sec_device_destroy(sec_abc->devt);
  801. #else
  802. device_destroy(sec_class, sec_abc->devt);
  803. #endif
  804. err_create_device:
  805. kfree(pinfo);
  806. err_alloc_pinfo:
  807. err_parse_dt:
  808. devm_kfree(&pdev->dev, pdata);
  809. pdev->dev.platform_data = NULL;
  810. out:
  811. return ret;
  812. }
  813. void sec_abc_free_pre_events(void)
  814. {
  815. struct abc_pre_event *pre_event;
  816. while (!list_empty(&abc_pre_event_list)) {
  817. pre_event = list_first_entry(
  818. &abc_pre_event_list,
  819. struct abc_pre_event,
  820. node);
  821. list_del(&pre_event->node);
  822. kfree(pre_event);
  823. }
  824. }
  825. EXPORT_SYMBOL_KUNIT(sec_abc_free_pre_events);
  826. __visible_for_testing
  827. void sec_abc_free_allocated_memory(void)
  828. {
  829. sec_abc_free_pre_events();
  830. sec_abc_free_spec_buffer();
  831. }
  832. EXPORT_SYMBOL_KUNIT(sec_abc_free_allocated_memory);
  833. static struct platform_driver sec_abc_driver = {
  834. .probe = sec_abc_probe,
  835. .remove = sec_abc_remove,
  836. .driver = {
  837. .name = "sec_abc",
  838. .owner = THIS_MODULE,
  839. #if IS_ENABLED(CONFIG_PM)
  840. .pm = &sec_abc_pm,
  841. #endif
  842. #if IS_ENABLED(CONFIG_OF)
  843. .of_match_table = of_match_ptr(sec_abc_dt_match),
  844. #endif
  845. },
  846. };
  847. static int __init sec_abc_init(void)
  848. {
  849. ABC_PRINT("start");
  850. return platform_driver_register(&sec_abc_driver);
  851. }
  852. static void __exit sec_abc_exit(void)
  853. {
  854. ABC_PRINT("exit");
  855. sec_abc_free_allocated_memory();
  856. return platform_driver_unregister(&sec_abc_driver);
  857. }
  858. module_init(sec_abc_init);
  859. module_exit(sec_abc_exit);
  860. MODULE_DESCRIPTION("Samsung ABC Driver");
  861. MODULE_AUTHOR("Samsung Electronics");
  862. MODULE_LICENSE("GPL");