init.c 10.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418
  1. // SPDX-License-Identifier: GPL-2.0
  2. /*
  3. * Copyright (c) 2012-2022, Intel Corporation. All rights reserved.
  4. * Intel Management Engine Interface (Intel MEI) Linux driver
  5. */
  6. #include <linux/export.h>
  7. #include <linux/sched.h>
  8. #include <linux/wait.h>
  9. #include <linux/delay.h>
  10. #include <linux/mei.h>
  11. #include "mei_dev.h"
  12. #include "hbm.h"
  13. #include "client.h"
  14. const char *mei_dev_state_str(int state)
  15. {
  16. #define MEI_DEV_STATE(state) case MEI_DEV_##state: return #state
  17. switch (state) {
  18. MEI_DEV_STATE(INITIALIZING);
  19. MEI_DEV_STATE(INIT_CLIENTS);
  20. MEI_DEV_STATE(ENABLED);
  21. MEI_DEV_STATE(RESETTING);
  22. MEI_DEV_STATE(DISABLED);
  23. MEI_DEV_STATE(POWERING_DOWN);
  24. MEI_DEV_STATE(POWER_DOWN);
  25. MEI_DEV_STATE(POWER_UP);
  26. default:
  27. return "unknown";
  28. }
  29. #undef MEI_DEV_STATE
  30. }
  31. const char *mei_pg_state_str(enum mei_pg_state state)
  32. {
  33. #define MEI_PG_STATE(state) case MEI_PG_##state: return #state
  34. switch (state) {
  35. MEI_PG_STATE(OFF);
  36. MEI_PG_STATE(ON);
  37. default:
  38. return "unknown";
  39. }
  40. #undef MEI_PG_STATE
  41. }
  42. /**
  43. * mei_fw_status2str - convert fw status registers to printable string
  44. *
  45. * @fw_status: firmware status
  46. * @buf: string buffer at minimal size MEI_FW_STATUS_STR_SZ
  47. * @len: buffer len must be >= MEI_FW_STATUS_STR_SZ
  48. *
  49. * Return: number of bytes written or -EINVAL if buffer is to small
  50. */
  51. ssize_t mei_fw_status2str(struct mei_fw_status *fw_status,
  52. char *buf, size_t len)
  53. {
  54. ssize_t cnt = 0;
  55. int i;
  56. buf[0] = '\0';
  57. if (len < MEI_FW_STATUS_STR_SZ)
  58. return -EINVAL;
  59. for (i = 0; i < fw_status->count; i++)
  60. cnt += scnprintf(buf + cnt, len - cnt, "%08X ",
  61. fw_status->status[i]);
  62. /* drop last space */
  63. buf[cnt] = '\0';
  64. return cnt;
  65. }
  66. EXPORT_SYMBOL_GPL(mei_fw_status2str);
  67. /**
  68. * mei_cancel_work - Cancel mei background jobs
  69. *
  70. * @dev: the device structure
  71. */
  72. void mei_cancel_work(struct mei_device *dev)
  73. {
  74. cancel_work_sync(&dev->reset_work);
  75. cancel_work_sync(&dev->bus_rescan_work);
  76. cancel_delayed_work_sync(&dev->timer_work);
  77. }
  78. EXPORT_SYMBOL_GPL(mei_cancel_work);
  79. /**
  80. * mei_reset - resets host and fw.
  81. *
  82. * @dev: the device structure
  83. *
  84. * Return: 0 on success or < 0 if the reset hasn't succeeded
  85. */
  86. int mei_reset(struct mei_device *dev)
  87. {
  88. enum mei_dev_state state = dev->dev_state;
  89. bool interrupts_enabled;
  90. int ret;
  91. if (state != MEI_DEV_INITIALIZING &&
  92. state != MEI_DEV_DISABLED &&
  93. state != MEI_DEV_POWER_DOWN &&
  94. state != MEI_DEV_POWER_UP) {
  95. char fw_sts_str[MEI_FW_STATUS_STR_SZ];
  96. mei_fw_status_str(dev, fw_sts_str, MEI_FW_STATUS_STR_SZ);
  97. dev_warn(dev->dev, "unexpected reset: dev_state = %s fw status = %s\n",
  98. mei_dev_state_str(state), fw_sts_str);
  99. }
  100. mei_clear_interrupts(dev);
  101. /* we're already in reset, cancel the init timer
  102. * if the reset was called due the hbm protocol error
  103. * we need to call it before hw start
  104. * so the hbm watchdog won't kick in
  105. */
  106. mei_hbm_idle(dev);
  107. /* enter reset flow */
  108. interrupts_enabled = state != MEI_DEV_POWER_DOWN;
  109. mei_set_devstate(dev, MEI_DEV_RESETTING);
  110. dev->reset_count++;
  111. if (dev->reset_count > MEI_MAX_CONSEC_RESET) {
  112. dev_err(dev->dev, "reset: reached maximal consecutive resets: disabling the device\n");
  113. mei_set_devstate(dev, MEI_DEV_DISABLED);
  114. return -ENODEV;
  115. }
  116. ret = mei_hw_reset(dev, interrupts_enabled);
  117. /* fall through and remove the sw state even if hw reset has failed */
  118. /* no need to clean up software state in case of power up */
  119. if (state != MEI_DEV_INITIALIZING && state != MEI_DEV_POWER_UP)
  120. mei_cl_all_disconnect(dev);
  121. mei_hbm_reset(dev);
  122. memset(dev->rd_msg_hdr, 0, sizeof(dev->rd_msg_hdr));
  123. if (ret) {
  124. dev_err(dev->dev, "hw_reset failed ret = %d\n", ret);
  125. return ret;
  126. }
  127. if (state == MEI_DEV_POWER_DOWN) {
  128. dev_dbg(dev->dev, "powering down: end of reset\n");
  129. mei_set_devstate(dev, MEI_DEV_DISABLED);
  130. return 0;
  131. }
  132. ret = mei_hw_start(dev);
  133. if (ret) {
  134. dev_err(dev->dev, "hw_start failed ret = %d\n", ret);
  135. return ret;
  136. }
  137. if (dev->dev_state != MEI_DEV_RESETTING) {
  138. dev_dbg(dev->dev, "wrong state = %d on link start\n", dev->dev_state);
  139. return 0;
  140. }
  141. dev_dbg(dev->dev, "link is established start sending messages.\n");
  142. mei_set_devstate(dev, MEI_DEV_INIT_CLIENTS);
  143. ret = mei_hbm_start_req(dev);
  144. if (ret) {
  145. dev_err(dev->dev, "hbm_start failed ret = %d\n", ret);
  146. mei_set_devstate(dev, MEI_DEV_RESETTING);
  147. return ret;
  148. }
  149. return 0;
  150. }
  151. EXPORT_SYMBOL_GPL(mei_reset);
  152. /**
  153. * mei_start - initializes host and fw to start work.
  154. *
  155. * @dev: the device structure
  156. *
  157. * Return: 0 on success, <0 on failure.
  158. */
  159. int mei_start(struct mei_device *dev)
  160. {
  161. int ret;
  162. mutex_lock(&dev->device_lock);
  163. /* acknowledge interrupt and stop interrupts */
  164. mei_clear_interrupts(dev);
  165. ret = mei_hw_config(dev);
  166. if (ret)
  167. goto err;
  168. dev_dbg(dev->dev, "reset in start the mei device.\n");
  169. dev->reset_count = 0;
  170. do {
  171. mei_set_devstate(dev, MEI_DEV_INITIALIZING);
  172. ret = mei_reset(dev);
  173. if (ret == -ENODEV || dev->dev_state == MEI_DEV_DISABLED) {
  174. dev_err(dev->dev, "reset failed ret = %d", ret);
  175. goto err;
  176. }
  177. } while (ret);
  178. if (mei_hbm_start_wait(dev)) {
  179. dev_err(dev->dev, "HBM haven't started");
  180. goto err;
  181. }
  182. if (!mei_hbm_version_is_supported(dev)) {
  183. dev_dbg(dev->dev, "MEI start failed.\n");
  184. goto err;
  185. }
  186. dev_dbg(dev->dev, "link layer has been established.\n");
  187. mutex_unlock(&dev->device_lock);
  188. return 0;
  189. err:
  190. dev_err(dev->dev, "link layer initialization failed.\n");
  191. mei_set_devstate(dev, MEI_DEV_DISABLED);
  192. mutex_unlock(&dev->device_lock);
  193. return -ENODEV;
  194. }
  195. EXPORT_SYMBOL_GPL(mei_start);
  196. /**
  197. * mei_restart - restart device after suspend
  198. *
  199. * @dev: the device structure
  200. *
  201. * Return: 0 on success or -ENODEV if the restart hasn't succeeded
  202. */
  203. int mei_restart(struct mei_device *dev)
  204. {
  205. int err;
  206. mutex_lock(&dev->device_lock);
  207. mei_set_devstate(dev, MEI_DEV_POWER_UP);
  208. dev->reset_count = 0;
  209. err = mei_reset(dev);
  210. mutex_unlock(&dev->device_lock);
  211. if (err == -ENODEV || dev->dev_state == MEI_DEV_DISABLED) {
  212. dev_err(dev->dev, "device disabled = %d\n", err);
  213. return -ENODEV;
  214. }
  215. /* try to start again */
  216. if (err)
  217. schedule_work(&dev->reset_work);
  218. return 0;
  219. }
  220. EXPORT_SYMBOL_GPL(mei_restart);
  221. static void mei_reset_work(struct work_struct *work)
  222. {
  223. struct mei_device *dev =
  224. container_of(work, struct mei_device, reset_work);
  225. int ret;
  226. mei_clear_interrupts(dev);
  227. mei_synchronize_irq(dev);
  228. mutex_lock(&dev->device_lock);
  229. ret = mei_reset(dev);
  230. mutex_unlock(&dev->device_lock);
  231. if (dev->dev_state == MEI_DEV_DISABLED) {
  232. dev_err(dev->dev, "device disabled = %d\n", ret);
  233. return;
  234. }
  235. /* retry reset in case of failure */
  236. if (ret)
  237. schedule_work(&dev->reset_work);
  238. }
  239. void mei_stop(struct mei_device *dev)
  240. {
  241. dev_dbg(dev->dev, "stopping the device.\n");
  242. mutex_lock(&dev->device_lock);
  243. mei_set_devstate(dev, MEI_DEV_POWERING_DOWN);
  244. mutex_unlock(&dev->device_lock);
  245. mei_cl_bus_remove_devices(dev);
  246. mutex_lock(&dev->device_lock);
  247. mei_set_devstate(dev, MEI_DEV_POWER_DOWN);
  248. mutex_unlock(&dev->device_lock);
  249. mei_cancel_work(dev);
  250. mei_clear_interrupts(dev);
  251. mei_synchronize_irq(dev);
  252. /* to catch HW-initiated reset */
  253. mei_cancel_work(dev);
  254. mutex_lock(&dev->device_lock);
  255. mei_reset(dev);
  256. /* move device to disabled state unconditionally */
  257. mei_set_devstate(dev, MEI_DEV_DISABLED);
  258. mutex_unlock(&dev->device_lock);
  259. }
  260. EXPORT_SYMBOL_GPL(mei_stop);
  261. /**
  262. * mei_write_is_idle - check if the write queues are idle
  263. *
  264. * @dev: the device structure
  265. *
  266. * Return: true of there is no pending write
  267. */
  268. bool mei_write_is_idle(struct mei_device *dev)
  269. {
  270. bool idle = (dev->dev_state == MEI_DEV_ENABLED &&
  271. list_empty(&dev->ctrl_wr_list) &&
  272. list_empty(&dev->write_list) &&
  273. list_empty(&dev->write_waiting_list));
  274. dev_dbg(dev->dev, "write pg: is idle[%d] state=%s ctrl=%01d write=%01d wwait=%01d\n",
  275. idle,
  276. mei_dev_state_str(dev->dev_state),
  277. list_empty(&dev->ctrl_wr_list),
  278. list_empty(&dev->write_list),
  279. list_empty(&dev->write_waiting_list));
  280. return idle;
  281. }
  282. EXPORT_SYMBOL_GPL(mei_write_is_idle);
  283. /**
  284. * mei_device_init - initialize mei_device structure
  285. *
  286. * @dev: the mei device
  287. * @device: the device structure
  288. * @slow_fw: configure longer timeouts as FW is slow
  289. * @hw_ops: hw operations
  290. */
  291. void mei_device_init(struct mei_device *dev,
  292. struct device *device,
  293. bool slow_fw,
  294. const struct mei_hw_ops *hw_ops)
  295. {
  296. /* setup our list array */
  297. INIT_LIST_HEAD(&dev->file_list);
  298. INIT_LIST_HEAD(&dev->device_list);
  299. INIT_LIST_HEAD(&dev->me_clients);
  300. mutex_init(&dev->device_lock);
  301. init_rwsem(&dev->me_clients_rwsem);
  302. mutex_init(&dev->cl_bus_lock);
  303. init_waitqueue_head(&dev->wait_hw_ready);
  304. init_waitqueue_head(&dev->wait_pg);
  305. init_waitqueue_head(&dev->wait_hbm_start);
  306. dev->dev_state = MEI_DEV_INITIALIZING;
  307. dev->reset_count = 0;
  308. INIT_LIST_HEAD(&dev->write_list);
  309. INIT_LIST_HEAD(&dev->write_waiting_list);
  310. INIT_LIST_HEAD(&dev->ctrl_wr_list);
  311. INIT_LIST_HEAD(&dev->ctrl_rd_list);
  312. dev->tx_queue_limit = MEI_TX_QUEUE_LIMIT_DEFAULT;
  313. INIT_DELAYED_WORK(&dev->timer_work, mei_timer);
  314. INIT_WORK(&dev->reset_work, mei_reset_work);
  315. INIT_WORK(&dev->bus_rescan_work, mei_cl_bus_rescan_work);
  316. bitmap_zero(dev->host_clients_map, MEI_CLIENTS_MAX);
  317. dev->open_handle_count = 0;
  318. dev->pxp_mode = MEI_DEV_PXP_DEFAULT;
  319. /*
  320. * Reserving the first client ID
  321. * 0: Reserved for MEI Bus Message communications
  322. */
  323. bitmap_set(dev->host_clients_map, 0, 1);
  324. dev->pg_event = MEI_PG_EVENT_IDLE;
  325. dev->ops = hw_ops;
  326. dev->dev = device;
  327. dev->timeouts.hw_ready = mei_secs_to_jiffies(MEI_HW_READY_TIMEOUT);
  328. dev->timeouts.connect = MEI_CONNECT_TIMEOUT;
  329. dev->timeouts.client_init = MEI_CLIENTS_INIT_TIMEOUT;
  330. dev->timeouts.pgi = mei_secs_to_jiffies(MEI_PGI_TIMEOUT);
  331. dev->timeouts.d0i3 = mei_secs_to_jiffies(MEI_D0I3_TIMEOUT);
  332. if (slow_fw) {
  333. dev->timeouts.cl_connect = mei_secs_to_jiffies(MEI_CL_CONNECT_TIMEOUT_SLOW);
  334. dev->timeouts.hbm = mei_secs_to_jiffies(MEI_HBM_TIMEOUT_SLOW);
  335. dev->timeouts.mkhi_recv = msecs_to_jiffies(MKHI_RCV_TIMEOUT_SLOW);
  336. } else {
  337. dev->timeouts.cl_connect = mei_secs_to_jiffies(MEI_CL_CONNECT_TIMEOUT);
  338. dev->timeouts.hbm = mei_secs_to_jiffies(MEI_HBM_TIMEOUT);
  339. dev->timeouts.mkhi_recv = msecs_to_jiffies(MKHI_RCV_TIMEOUT);
  340. }
  341. }
  342. EXPORT_SYMBOL_GPL(mei_device_init);