Oren Weil | 91f01c6 | 2011-05-15 13:43:44 +0300 | [diff] [blame] | 1 | /* |
| 2 | * |
| 3 | * Intel Management Engine Interface (Intel MEI) Linux driver |
Tomas Winkler | 733ba91 | 2012-02-09 19:25:53 +0200 | [diff] [blame] | 4 | * Copyright (c) 2003-2012, Intel Corporation. |
Oren Weil | 91f01c6 | 2011-05-15 13:43:44 +0300 | [diff] [blame] | 5 | * |
| 6 | * This program is free software; you can redistribute it and/or modify it |
| 7 | * under the terms and conditions of the GNU General Public License, |
| 8 | * version 2, as published by the Free Software Foundation. |
| 9 | * |
| 10 | * This program is distributed in the hope it will be useful, but WITHOUT |
| 11 | * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| 12 | * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for |
| 13 | * more details. |
| 14 | * |
| 15 | */ |
| 16 | |
Tomas Winkler | 40e0b67 | 2013-03-27 16:58:30 +0200 | [diff] [blame] | 17 | #include <linux/export.h> |
Oren Weil | 91f01c6 | 2011-05-15 13:43:44 +0300 | [diff] [blame] | 18 | #include <linux/sched.h> |
| 19 | #include <linux/wait.h> |
| 20 | #include <linux/delay.h> |
| 21 | |
Tomas Winkler | 4f3afe1 | 2012-05-09 16:38:59 +0300 | [diff] [blame] | 22 | #include <linux/mei.h> |
Oren Weil | 91f01c6 | 2011-05-15 13:43:44 +0300 | [diff] [blame] | 23 | |
Tomas Winkler | 47a7380 | 2012-12-25 19:06:03 +0200 | [diff] [blame] | 24 | #include "mei_dev.h" |
Tomas Winkler | aafae7e | 2013-03-11 18:27:03 +0200 | [diff] [blame] | 25 | #include "hbm.h" |
Tomas Winkler | 90e0b5f | 2013-01-08 23:07:14 +0200 | [diff] [blame] | 26 | #include "client.h" |
Tomas Winkler | 47a7380 | 2012-12-25 19:06:03 +0200 | [diff] [blame] | 27 | |
Tomas Winkler | b210d75 | 2012-08-07 00:03:56 +0300 | [diff] [blame] | 28 | const char *mei_dev_state_str(int state) |
| 29 | { |
| 30 | #define MEI_DEV_STATE(state) case MEI_DEV_##state: return #state |
| 31 | switch (state) { |
| 32 | MEI_DEV_STATE(INITIALIZING); |
| 33 | MEI_DEV_STATE(INIT_CLIENTS); |
| 34 | MEI_DEV_STATE(ENABLED); |
Bill Nottingham | 0cfee51 | 2013-04-19 22:01:36 +0300 | [diff] [blame] | 35 | MEI_DEV_STATE(RESETTING); |
Tomas Winkler | b210d75 | 2012-08-07 00:03:56 +0300 | [diff] [blame] | 36 | MEI_DEV_STATE(DISABLED); |
Tomas Winkler | b210d75 | 2012-08-07 00:03:56 +0300 | [diff] [blame] | 37 | MEI_DEV_STATE(POWER_DOWN); |
| 38 | MEI_DEV_STATE(POWER_UP); |
| 39 | default: |
Masanari Iida | 8b513d0 | 2013-05-21 23:13:12 +0900 | [diff] [blame] | 40 | return "unknown"; |
Tomas Winkler | b210d75 | 2012-08-07 00:03:56 +0300 | [diff] [blame] | 41 | } |
| 42 | #undef MEI_DEV_STATE |
| 43 | } |
| 44 | |
Alexander Usyskin | 1beeb4b | 2014-09-29 16:31:33 +0300 | [diff] [blame] | 45 | const char *mei_pg_state_str(enum mei_pg_state state) |
| 46 | { |
| 47 | #define MEI_PG_STATE(state) case MEI_PG_##state: return #state |
| 48 | switch (state) { |
| 49 | MEI_PG_STATE(OFF); |
| 50 | MEI_PG_STATE(ON); |
| 51 | default: |
| 52 | return "unknown"; |
| 53 | } |
| 54 | #undef MEI_PG_STATE |
| 55 | } |
| 56 | |
Alexander Usyskin | edca5ea | 2014-11-19 17:01:38 +0200 | [diff] [blame] | 57 | /** |
| 58 | * mei_fw_status2str - convert fw status registers to printable string |
| 59 | * |
| 60 | * @fw_status: firmware status |
| 61 | * @buf: string buffer at minimal size MEI_FW_STATUS_STR_SZ |
| 62 | * @len: buffer len must be >= MEI_FW_STATUS_STR_SZ |
| 63 | * |
| 64 | * Return: number of bytes written or -EINVAL if buffer is to small |
| 65 | */ |
| 66 | ssize_t mei_fw_status2str(struct mei_fw_status *fw_status, |
| 67 | char *buf, size_t len) |
| 68 | { |
| 69 | ssize_t cnt = 0; |
| 70 | int i; |
| 71 | |
| 72 | buf[0] = '\0'; |
| 73 | |
| 74 | if (len < MEI_FW_STATUS_STR_SZ) |
| 75 | return -EINVAL; |
| 76 | |
| 77 | for (i = 0; i < fw_status->count; i++) |
| 78 | cnt += scnprintf(buf + cnt, len - cnt, "%08X ", |
| 79 | fw_status->status[i]); |
| 80 | |
| 81 | /* drop last space */ |
| 82 | buf[cnt] = '\0'; |
| 83 | return cnt; |
| 84 | } |
| 85 | EXPORT_SYMBOL_GPL(mei_fw_status2str); |
Tomas Winkler | 33ec082 | 2014-01-12 00:36:09 +0200 | [diff] [blame] | 86 | |
| 87 | /** |
Alexander Usyskin | a8605ea | 2014-09-29 16:31:49 +0300 | [diff] [blame] | 88 | * mei_cancel_work - Cancel mei background jobs |
Tomas Winkler | 33ec082 | 2014-01-12 00:36:09 +0200 | [diff] [blame] | 89 | * |
| 90 | * @dev: the device structure |
Tomas Winkler | 33ec082 | 2014-01-12 00:36:09 +0200 | [diff] [blame] | 91 | */ |
| 92 | void mei_cancel_work(struct mei_device *dev) |
| 93 | { |
| 94 | cancel_work_sync(&dev->init_work); |
| 95 | cancel_work_sync(&dev->reset_work); |
| 96 | |
| 97 | cancel_delayed_work(&dev->timer_work); |
| 98 | } |
| 99 | EXPORT_SYMBOL_GPL(mei_cancel_work); |
| 100 | |
| 101 | /** |
| 102 | * mei_reset - resets host and fw. |
| 103 | * |
| 104 | * @dev: the device structure |
Alexander Usyskin | ce23139 | 2014-09-29 16:31:50 +0300 | [diff] [blame] | 105 | * |
| 106 | * Return: 0 on success or < 0 if the reset hasn't succeeded |
Tomas Winkler | 33ec082 | 2014-01-12 00:36:09 +0200 | [diff] [blame] | 107 | */ |
| 108 | int mei_reset(struct mei_device *dev) |
| 109 | { |
| 110 | enum mei_dev_state state = dev->dev_state; |
| 111 | bool interrupts_enabled; |
| 112 | int ret; |
| 113 | |
| 114 | if (state != MEI_DEV_INITIALIZING && |
| 115 | state != MEI_DEV_DISABLED && |
| 116 | state != MEI_DEV_POWER_DOWN && |
Alexander Usyskin | 04dd366 | 2014-03-31 17:59:23 +0300 | [diff] [blame] | 117 | state != MEI_DEV_POWER_UP) { |
Alexander Usyskin | edca5ea | 2014-11-19 17:01:38 +0200 | [diff] [blame] | 118 | char fw_sts_str[MEI_FW_STATUS_STR_SZ]; |
Tomas Winkler | 92db155 | 2014-09-29 16:31:37 +0300 | [diff] [blame] | 119 | |
Alexander Usyskin | edca5ea | 2014-11-19 17:01:38 +0200 | [diff] [blame] | 120 | mei_fw_status_str(dev, fw_sts_str, MEI_FW_STATUS_STR_SZ); |
| 121 | dev_warn(dev->dev, "unexpected reset: dev_state = %s fw status = %s\n", |
| 122 | mei_dev_state_str(state), fw_sts_str); |
Alexander Usyskin | 04dd366 | 2014-03-31 17:59:23 +0300 | [diff] [blame] | 123 | } |
Tomas Winkler | 33ec082 | 2014-01-12 00:36:09 +0200 | [diff] [blame] | 124 | |
| 125 | /* we're already in reset, cancel the init timer |
| 126 | * if the reset was called due the hbm protocol error |
| 127 | * we need to call it before hw start |
| 128 | * so the hbm watchdog won't kick in |
| 129 | */ |
| 130 | mei_hbm_idle(dev); |
| 131 | |
| 132 | /* enter reset flow */ |
| 133 | interrupts_enabled = state != MEI_DEV_POWER_DOWN; |
| 134 | dev->dev_state = MEI_DEV_RESETTING; |
| 135 | |
Tomas Winkler | 6adb8ef | 2014-01-12 00:36:10 +0200 | [diff] [blame] | 136 | dev->reset_count++; |
| 137 | if (dev->reset_count > MEI_MAX_CONSEC_RESET) { |
Tomas Winkler | 2bf94cab | 2014-09-29 16:31:42 +0300 | [diff] [blame] | 138 | dev_err(dev->dev, "reset: reached maximal consecutive resets: disabling the device\n"); |
Tomas Winkler | 6adb8ef | 2014-01-12 00:36:10 +0200 | [diff] [blame] | 139 | dev->dev_state = MEI_DEV_DISABLED; |
| 140 | return -ENODEV; |
| 141 | } |
| 142 | |
Tomas Winkler | 33ec082 | 2014-01-12 00:36:09 +0200 | [diff] [blame] | 143 | ret = mei_hw_reset(dev, interrupts_enabled); |
| 144 | /* fall through and remove the sw state even if hw reset has failed */ |
| 145 | |
| 146 | /* no need to clean up software state in case of power up */ |
| 147 | if (state != MEI_DEV_INITIALIZING && |
| 148 | state != MEI_DEV_POWER_UP) { |
| 149 | |
| 150 | /* remove all waiting requests */ |
| 151 | mei_cl_all_write_clear(dev); |
| 152 | |
| 153 | mei_cl_all_disconnect(dev); |
| 154 | |
| 155 | /* wake up all readers and writers so they can be interrupted */ |
| 156 | mei_cl_all_wakeup(dev); |
| 157 | |
| 158 | /* remove entry if already in list */ |
Tomas Winkler | 2bf94cab | 2014-09-29 16:31:42 +0300 | [diff] [blame] | 159 | dev_dbg(dev->dev, "remove iamthif and wd from the file list.\n"); |
Tomas Winkler | 33ec082 | 2014-01-12 00:36:09 +0200 | [diff] [blame] | 160 | mei_cl_unlink(&dev->wd_cl); |
| 161 | mei_cl_unlink(&dev->iamthif_cl); |
| 162 | mei_amthif_reset_params(dev); |
Tomas Winkler | 33ec082 | 2014-01-12 00:36:09 +0200 | [diff] [blame] | 163 | } |
| 164 | |
Tomas Winkler | 84b3294 | 2014-05-07 16:51:28 +0300 | [diff] [blame] | 165 | mei_hbm_reset(dev); |
Tomas Winkler | 33ec082 | 2014-01-12 00:36:09 +0200 | [diff] [blame] | 166 | |
Tomas Winkler | 33ec082 | 2014-01-12 00:36:09 +0200 | [diff] [blame] | 167 | dev->rd_msg_hdr = 0; |
| 168 | dev->wd_pending = false; |
| 169 | |
| 170 | if (ret) { |
Tomas Winkler | 2bf94cab | 2014-09-29 16:31:42 +0300 | [diff] [blame] | 171 | dev_err(dev->dev, "hw_reset failed ret = %d\n", ret); |
Tomas Winkler | 33ec082 | 2014-01-12 00:36:09 +0200 | [diff] [blame] | 172 | return ret; |
| 173 | } |
| 174 | |
| 175 | if (state == MEI_DEV_POWER_DOWN) { |
Tomas Winkler | 2bf94cab | 2014-09-29 16:31:42 +0300 | [diff] [blame] | 176 | dev_dbg(dev->dev, "powering down: end of reset\n"); |
Tomas Winkler | 33ec082 | 2014-01-12 00:36:09 +0200 | [diff] [blame] | 177 | dev->dev_state = MEI_DEV_DISABLED; |
| 178 | return 0; |
| 179 | } |
| 180 | |
| 181 | ret = mei_hw_start(dev); |
| 182 | if (ret) { |
Tomas Winkler | 2bf94cab | 2014-09-29 16:31:42 +0300 | [diff] [blame] | 183 | dev_err(dev->dev, "hw_start failed ret = %d\n", ret); |
Tomas Winkler | 33ec082 | 2014-01-12 00:36:09 +0200 | [diff] [blame] | 184 | return ret; |
| 185 | } |
| 186 | |
Tomas Winkler | 2bf94cab | 2014-09-29 16:31:42 +0300 | [diff] [blame] | 187 | dev_dbg(dev->dev, "link is established start sending messages.\n"); |
Tomas Winkler | 33ec082 | 2014-01-12 00:36:09 +0200 | [diff] [blame] | 188 | |
| 189 | dev->dev_state = MEI_DEV_INIT_CLIENTS; |
| 190 | ret = mei_hbm_start_req(dev); |
| 191 | if (ret) { |
Tomas Winkler | 2bf94cab | 2014-09-29 16:31:42 +0300 | [diff] [blame] | 192 | dev_err(dev->dev, "hbm_start failed ret = %d\n", ret); |
Tomas Winkler | 7d93e58 | 2014-01-14 23:10:10 +0200 | [diff] [blame] | 193 | dev->dev_state = MEI_DEV_RESETTING; |
Tomas Winkler | 33ec082 | 2014-01-12 00:36:09 +0200 | [diff] [blame] | 194 | return ret; |
| 195 | } |
| 196 | |
| 197 | return 0; |
| 198 | } |
| 199 | EXPORT_SYMBOL_GPL(mei_reset); |
| 200 | |
Oren Weil | 91f01c6 | 2011-05-15 13:43:44 +0300 | [diff] [blame] | 201 | /** |
Tomas Winkler | c4d589b | 2013-03-27 16:58:28 +0200 | [diff] [blame] | 202 | * mei_start - initializes host and fw to start work. |
Oren Weil | 91f01c6 | 2011-05-15 13:43:44 +0300 | [diff] [blame] | 203 | * |
| 204 | * @dev: the device structure |
| 205 | * |
Alexander Usyskin | a8605ea | 2014-09-29 16:31:49 +0300 | [diff] [blame] | 206 | * Return: 0 on success, <0 on failure. |
Oren Weil | 91f01c6 | 2011-05-15 13:43:44 +0300 | [diff] [blame] | 207 | */ |
Tomas Winkler | c4d589b | 2013-03-27 16:58:28 +0200 | [diff] [blame] | 208 | int mei_start(struct mei_device *dev) |
Oren Weil | 91f01c6 | 2011-05-15 13:43:44 +0300 | [diff] [blame] | 209 | { |
Tomas Winkler | 7d93e58 | 2014-01-14 23:10:10 +0200 | [diff] [blame] | 210 | int ret; |
Tomas Winkler | 92db155 | 2014-09-29 16:31:37 +0300 | [diff] [blame] | 211 | |
Oren Weil | 91f01c6 | 2011-05-15 13:43:44 +0300 | [diff] [blame] | 212 | mutex_lock(&dev->device_lock); |
| 213 | |
Tomas Winkler | 33ec082 | 2014-01-12 00:36:09 +0200 | [diff] [blame] | 214 | /* acknowledge interrupt and stop interrupts */ |
Tomas Winkler | 3a65dd4 | 2012-12-25 19:06:06 +0200 | [diff] [blame] | 215 | mei_clear_interrupts(dev); |
Oren Weil | 91f01c6 | 2011-05-15 13:43:44 +0300 | [diff] [blame] | 216 | |
Tomas Winkler | e7e0c23 | 2013-01-08 23:07:31 +0200 | [diff] [blame] | 217 | mei_hw_config(dev); |
Tomas Winkler | 24aadc8 | 2012-06-25 23:46:27 +0300 | [diff] [blame] | 218 | |
Tomas Winkler | 2bf94cab | 2014-09-29 16:31:42 +0300 | [diff] [blame] | 219 | dev_dbg(dev->dev, "reset in start the mei device.\n"); |
Oren Weil | 91f01c6 | 2011-05-15 13:43:44 +0300 | [diff] [blame] | 220 | |
Tomas Winkler | 6adb8ef | 2014-01-12 00:36:10 +0200 | [diff] [blame] | 221 | dev->reset_count = 0; |
Tomas Winkler | 7d93e58 | 2014-01-14 23:10:10 +0200 | [diff] [blame] | 222 | do { |
| 223 | dev->dev_state = MEI_DEV_INITIALIZING; |
| 224 | ret = mei_reset(dev); |
Tomas Winkler | 33ec082 | 2014-01-12 00:36:09 +0200 | [diff] [blame] | 225 | |
Tomas Winkler | 7d93e58 | 2014-01-14 23:10:10 +0200 | [diff] [blame] | 226 | if (ret == -ENODEV || dev->dev_state == MEI_DEV_DISABLED) { |
Tomas Winkler | 2bf94cab | 2014-09-29 16:31:42 +0300 | [diff] [blame] | 227 | dev_err(dev->dev, "reset failed ret = %d", ret); |
Tomas Winkler | 7d93e58 | 2014-01-14 23:10:10 +0200 | [diff] [blame] | 228 | goto err; |
| 229 | } |
| 230 | } while (ret); |
| 231 | |
| 232 | /* we cannot start the device w/o hbm start message completed */ |
Tomas Winkler | 33ec082 | 2014-01-12 00:36:09 +0200 | [diff] [blame] | 233 | if (dev->dev_state == MEI_DEV_DISABLED) { |
Tomas Winkler | 2bf94cab | 2014-09-29 16:31:42 +0300 | [diff] [blame] | 234 | dev_err(dev->dev, "reset failed"); |
Tomas Winkler | 33ec082 | 2014-01-12 00:36:09 +0200 | [diff] [blame] | 235 | goto err; |
| 236 | } |
Oren Weil | 91f01c6 | 2011-05-15 13:43:44 +0300 | [diff] [blame] | 237 | |
Tomas Winkler | 9b0d5ef | 2013-04-18 23:03:48 +0300 | [diff] [blame] | 238 | if (mei_hbm_start_wait(dev)) { |
Tomas Winkler | 2bf94cab | 2014-09-29 16:31:42 +0300 | [diff] [blame] | 239 | dev_err(dev->dev, "HBM haven't started"); |
Tomas Winkler | e7e0c23 | 2013-01-08 23:07:31 +0200 | [diff] [blame] | 240 | goto err; |
Oren Weil | 91f01c6 | 2011-05-15 13:43:44 +0300 | [diff] [blame] | 241 | } |
| 242 | |
Tomas Winkler | e7e0c23 | 2013-01-08 23:07:31 +0200 | [diff] [blame] | 243 | if (!mei_host_is_ready(dev)) { |
Tomas Winkler | 2bf94cab | 2014-09-29 16:31:42 +0300 | [diff] [blame] | 244 | dev_err(dev->dev, "host is not ready.\n"); |
Tomas Winkler | e7e0c23 | 2013-01-08 23:07:31 +0200 | [diff] [blame] | 245 | goto err; |
| 246 | } |
Oren Weil | 91f01c6 | 2011-05-15 13:43:44 +0300 | [diff] [blame] | 247 | |
Tomas Winkler | 827eef5 | 2013-02-06 14:06:41 +0200 | [diff] [blame] | 248 | if (!mei_hw_is_ready(dev)) { |
Tomas Winkler | 2bf94cab | 2014-09-29 16:31:42 +0300 | [diff] [blame] | 249 | dev_err(dev->dev, "ME is not ready.\n"); |
Tomas Winkler | e7e0c23 | 2013-01-08 23:07:31 +0200 | [diff] [blame] | 250 | goto err; |
Oren Weil | 91f01c6 | 2011-05-15 13:43:44 +0300 | [diff] [blame] | 251 | } |
| 252 | |
Tomas Winkler | 2c9b48a | 2013-06-16 09:16:31 +0300 | [diff] [blame] | 253 | if (!mei_hbm_version_is_supported(dev)) { |
Tomas Winkler | 2bf94cab | 2014-09-29 16:31:42 +0300 | [diff] [blame] | 254 | dev_dbg(dev->dev, "MEI start failed.\n"); |
Tomas Winkler | e7e0c23 | 2013-01-08 23:07:31 +0200 | [diff] [blame] | 255 | goto err; |
Oren Weil | 91f01c6 | 2011-05-15 13:43:44 +0300 | [diff] [blame] | 256 | } |
| 257 | |
Tomas Winkler | 2bf94cab | 2014-09-29 16:31:42 +0300 | [diff] [blame] | 258 | dev_dbg(dev->dev, "link layer has been established.\n"); |
Oren Weil | 91f01c6 | 2011-05-15 13:43:44 +0300 | [diff] [blame] | 259 | |
Oren Weil | 91f01c6 | 2011-05-15 13:43:44 +0300 | [diff] [blame] | 260 | mutex_unlock(&dev->device_lock); |
Tomas Winkler | e7e0c23 | 2013-01-08 23:07:31 +0200 | [diff] [blame] | 261 | return 0; |
| 262 | err: |
Tomas Winkler | 2bf94cab | 2014-09-29 16:31:42 +0300 | [diff] [blame] | 263 | dev_err(dev->dev, "link layer initialization failed.\n"); |
Tomas Winkler | e7e0c23 | 2013-01-08 23:07:31 +0200 | [diff] [blame] | 264 | dev->dev_state = MEI_DEV_DISABLED; |
| 265 | mutex_unlock(&dev->device_lock); |
| 266 | return -ENODEV; |
Oren Weil | 91f01c6 | 2011-05-15 13:43:44 +0300 | [diff] [blame] | 267 | } |
Tomas Winkler | 40e0b67 | 2013-03-27 16:58:30 +0200 | [diff] [blame] | 268 | EXPORT_SYMBOL_GPL(mei_start); |
Oren Weil | 91f01c6 | 2011-05-15 13:43:44 +0300 | [diff] [blame] | 269 | |
Tomas Winkler | 544f946 | 2014-01-08 20:19:21 +0200 | [diff] [blame] | 270 | /** |
Tomas Winkler | 33ec082 | 2014-01-12 00:36:09 +0200 | [diff] [blame] | 271 | * mei_restart - restart device after suspend |
Tomas Winkler | 544f946 | 2014-01-08 20:19:21 +0200 | [diff] [blame] | 272 | * |
| 273 | * @dev: the device structure |
Oren Weil | 91f01c6 | 2011-05-15 13:43:44 +0300 | [diff] [blame] | 274 | * |
Alexander Usyskin | a8605ea | 2014-09-29 16:31:49 +0300 | [diff] [blame] | 275 | * Return: 0 on success or -ENODEV if the restart hasn't succeeded |
Oren Weil | 91f01c6 | 2011-05-15 13:43:44 +0300 | [diff] [blame] | 276 | */ |
Tomas Winkler | 33ec082 | 2014-01-12 00:36:09 +0200 | [diff] [blame] | 277 | int mei_restart(struct mei_device *dev) |
Oren Weil | 91f01c6 | 2011-05-15 13:43:44 +0300 | [diff] [blame] | 278 | { |
Tomas Winkler | 33ec082 | 2014-01-12 00:36:09 +0200 | [diff] [blame] | 279 | int err; |
Oren Weil | 91f01c6 | 2011-05-15 13:43:44 +0300 | [diff] [blame] | 280 | |
Tomas Winkler | 33ec082 | 2014-01-12 00:36:09 +0200 | [diff] [blame] | 281 | mutex_lock(&dev->device_lock); |
Oren Weil | 91f01c6 | 2011-05-15 13:43:44 +0300 | [diff] [blame] | 282 | |
Tomas Winkler | 33ec082 | 2014-01-12 00:36:09 +0200 | [diff] [blame] | 283 | mei_clear_interrupts(dev); |
Alexander Usyskin | f931f4f | 2013-10-21 22:05:43 +0300 | [diff] [blame] | 284 | |
Tomas Winkler | 33ec082 | 2014-01-12 00:36:09 +0200 | [diff] [blame] | 285 | dev->dev_state = MEI_DEV_POWER_UP; |
Tomas Winkler | 6adb8ef | 2014-01-12 00:36:10 +0200 | [diff] [blame] | 286 | dev->reset_count = 0; |
Tomas Winkler | 66ae460 | 2014-01-08 20:19:22 +0200 | [diff] [blame] | 287 | |
Tomas Winkler | 33ec082 | 2014-01-12 00:36:09 +0200 | [diff] [blame] | 288 | err = mei_reset(dev); |
Oren Weil | 91f01c6 | 2011-05-15 13:43:44 +0300 | [diff] [blame] | 289 | |
Tomas Winkler | 33ec082 | 2014-01-12 00:36:09 +0200 | [diff] [blame] | 290 | mutex_unlock(&dev->device_lock); |
Oren Weil | 91f01c6 | 2011-05-15 13:43:44 +0300 | [diff] [blame] | 291 | |
Tomas Winkler | 7d93e58 | 2014-01-14 23:10:10 +0200 | [diff] [blame] | 292 | if (err == -ENODEV || dev->dev_state == MEI_DEV_DISABLED) { |
Tomas Winkler | 2bf94cab | 2014-09-29 16:31:42 +0300 | [diff] [blame] | 293 | dev_err(dev->dev, "device disabled = %d\n", err); |
Tomas Winkler | 33ec082 | 2014-01-12 00:36:09 +0200 | [diff] [blame] | 294 | return -ENODEV; |
Tomas Winkler | 7d93e58 | 2014-01-14 23:10:10 +0200 | [diff] [blame] | 295 | } |
| 296 | |
| 297 | /* try to start again */ |
| 298 | if (err) |
| 299 | schedule_work(&dev->reset_work); |
| 300 | |
Oren Weil | 91f01c6 | 2011-05-15 13:43:44 +0300 | [diff] [blame] | 301 | |
Tomas Winkler | 33ec082 | 2014-01-12 00:36:09 +0200 | [diff] [blame] | 302 | return 0; |
Oren Weil | 91f01c6 | 2011-05-15 13:43:44 +0300 | [diff] [blame] | 303 | } |
Tomas Winkler | 33ec082 | 2014-01-12 00:36:09 +0200 | [diff] [blame] | 304 | EXPORT_SYMBOL_GPL(mei_restart); |
| 305 | |
Tomas Winkler | 544f946 | 2014-01-08 20:19:21 +0200 | [diff] [blame] | 306 | static void mei_reset_work(struct work_struct *work) |
| 307 | { |
| 308 | struct mei_device *dev = |
| 309 | container_of(work, struct mei_device, reset_work); |
Tomas Winkler | 7d93e58 | 2014-01-14 23:10:10 +0200 | [diff] [blame] | 310 | int ret; |
Tomas Winkler | 544f946 | 2014-01-08 20:19:21 +0200 | [diff] [blame] | 311 | |
| 312 | mutex_lock(&dev->device_lock); |
| 313 | |
Tomas Winkler | 7d93e58 | 2014-01-14 23:10:10 +0200 | [diff] [blame] | 314 | ret = mei_reset(dev); |
Tomas Winkler | 544f946 | 2014-01-08 20:19:21 +0200 | [diff] [blame] | 315 | |
| 316 | mutex_unlock(&dev->device_lock); |
Tomas Winkler | 33ec082 | 2014-01-12 00:36:09 +0200 | [diff] [blame] | 317 | |
Tomas Winkler | 7d93e58 | 2014-01-14 23:10:10 +0200 | [diff] [blame] | 318 | if (dev->dev_state == MEI_DEV_DISABLED) { |
Tomas Winkler | 2bf94cab | 2014-09-29 16:31:42 +0300 | [diff] [blame] | 319 | dev_err(dev->dev, "device disabled = %d\n", ret); |
Tomas Winkler | 7d93e58 | 2014-01-14 23:10:10 +0200 | [diff] [blame] | 320 | return; |
| 321 | } |
| 322 | |
| 323 | /* retry reset in case of failure */ |
| 324 | if (ret) |
| 325 | schedule_work(&dev->reset_work); |
Tomas Winkler | 544f946 | 2014-01-08 20:19:21 +0200 | [diff] [blame] | 326 | } |
| 327 | |
Tomas Winkler | 7cb035d | 2013-03-10 13:56:08 +0200 | [diff] [blame] | 328 | void mei_stop(struct mei_device *dev) |
| 329 | { |
Tomas Winkler | 2bf94cab | 2014-09-29 16:31:42 +0300 | [diff] [blame] | 330 | dev_dbg(dev->dev, "stopping the device.\n"); |
Tomas Winkler | 7cb035d | 2013-03-10 13:56:08 +0200 | [diff] [blame] | 331 | |
Tomas Winkler | 6009595 | 2015-07-23 15:08:47 +0300 | [diff] [blame] | 332 | mei_cl_bus_remove_devices(dev); |
Samuel Ortiz | 5e85b36 | 2013-06-10 10:10:25 +0300 | [diff] [blame] | 333 | |
Tomas Winkler | 97ccf63 | 2015-10-13 15:02:37 +0300 | [diff] [blame] | 334 | mei_cancel_work(dev); |
| 335 | |
Tomas Winkler | 7cb035d | 2013-03-10 13:56:08 +0200 | [diff] [blame] | 336 | mutex_lock(&dev->device_lock); |
| 337 | |
Tomas Winkler | 7cb035d | 2013-03-10 13:56:08 +0200 | [diff] [blame] | 338 | mei_wd_stop(dev); |
| 339 | |
| 340 | dev->dev_state = MEI_DEV_POWER_DOWN; |
Tomas Winkler | 33ec082 | 2014-01-12 00:36:09 +0200 | [diff] [blame] | 341 | mei_reset(dev); |
Alexander Usyskin | 6c15a85 | 2015-02-10 10:36:36 +0200 | [diff] [blame] | 342 | /* move device to disabled state unconditionally */ |
| 343 | dev->dev_state = MEI_DEV_DISABLED; |
Tomas Winkler | 7cb035d | 2013-03-10 13:56:08 +0200 | [diff] [blame] | 344 | |
| 345 | mutex_unlock(&dev->device_lock); |
| 346 | |
Tomas Winkler | 2e64712 | 2013-03-27 16:58:26 +0200 | [diff] [blame] | 347 | mei_watchdog_unregister(dev); |
Tomas Winkler | 7cb035d | 2013-03-10 13:56:08 +0200 | [diff] [blame] | 348 | } |
Tomas Winkler | 40e0b67 | 2013-03-27 16:58:30 +0200 | [diff] [blame] | 349 | EXPORT_SYMBOL_GPL(mei_stop); |
Oren Weil | 91f01c6 | 2011-05-15 13:43:44 +0300 | [diff] [blame] | 350 | |
Tomas Winkler | a532bbe | 2014-03-18 22:52:01 +0200 | [diff] [blame] | 351 | /** |
| 352 | * mei_write_is_idle - check if the write queues are idle |
| 353 | * |
| 354 | * @dev: the device structure |
| 355 | * |
Alexander Usyskin | a8605ea | 2014-09-29 16:31:49 +0300 | [diff] [blame] | 356 | * Return: true of there is no pending write |
Tomas Winkler | a532bbe | 2014-03-18 22:52:01 +0200 | [diff] [blame] | 357 | */ |
| 358 | bool mei_write_is_idle(struct mei_device *dev) |
| 359 | { |
| 360 | bool idle = (dev->dev_state == MEI_DEV_ENABLED && |
| 361 | list_empty(&dev->ctrl_wr_list.list) && |
Tomas Winkler | 41c95b0 | 2015-05-07 15:54:00 +0300 | [diff] [blame] | 362 | list_empty(&dev->write_list.list) && |
| 363 | list_empty(&dev->write_waiting_list.list)); |
Samuel Ortiz | c1174c0 | 2012-11-18 15:13:20 +0200 | [diff] [blame] | 364 | |
Tomas Winkler | 41c95b0 | 2015-05-07 15:54:00 +0300 | [diff] [blame] | 365 | dev_dbg(dev->dev, "write pg: is idle[%d] state=%s ctrl=%01d write=%01d wwait=%01d\n", |
Tomas Winkler | a532bbe | 2014-03-18 22:52:01 +0200 | [diff] [blame] | 366 | idle, |
| 367 | mei_dev_state_str(dev->dev_state), |
| 368 | list_empty(&dev->ctrl_wr_list.list), |
Tomas Winkler | 41c95b0 | 2015-05-07 15:54:00 +0300 | [diff] [blame] | 369 | list_empty(&dev->write_list.list), |
| 370 | list_empty(&dev->write_waiting_list.list)); |
Tomas Winkler | a532bbe | 2014-03-18 22:52:01 +0200 | [diff] [blame] | 371 | |
| 372 | return idle; |
| 373 | } |
| 374 | EXPORT_SYMBOL_GPL(mei_write_is_idle); |
Oren Weil | 91f01c6 | 2011-05-15 13:43:44 +0300 | [diff] [blame] | 375 | |
Tomas Winkler | 3a7e9b6 | 2014-09-29 16:31:41 +0300 | [diff] [blame] | 376 | /** |
| 377 | * mei_device_init -- initialize mei_device structure |
| 378 | * |
| 379 | * @dev: the mei device |
| 380 | * @device: the device structure |
| 381 | * @hw_ops: hw operations |
| 382 | */ |
| 383 | void mei_device_init(struct mei_device *dev, |
| 384 | struct device *device, |
| 385 | const struct mei_hw_ops *hw_ops) |
Tomas Winkler | 544f946 | 2014-01-08 20:19:21 +0200 | [diff] [blame] | 386 | { |
| 387 | /* setup our list array */ |
| 388 | INIT_LIST_HEAD(&dev->file_list); |
| 389 | INIT_LIST_HEAD(&dev->device_list); |
Tomas Winkler | 5ca2d38 | 2014-08-21 14:29:13 +0300 | [diff] [blame] | 390 | INIT_LIST_HEAD(&dev->me_clients); |
Tomas Winkler | 544f946 | 2014-01-08 20:19:21 +0200 | [diff] [blame] | 391 | mutex_init(&dev->device_lock); |
Tomas Winkler | b7d8851 | 2015-02-10 10:39:31 +0200 | [diff] [blame] | 392 | init_rwsem(&dev->me_clients_rwsem); |
Tomas Winkler | 0ff0a8d | 2015-07-23 15:08:42 +0300 | [diff] [blame] | 393 | mutex_init(&dev->cl_bus_lock); |
Tomas Winkler | 544f946 | 2014-01-08 20:19:21 +0200 | [diff] [blame] | 394 | init_waitqueue_head(&dev->wait_hw_ready); |
Tomas Winkler | 4fcbc99 | 2014-03-18 22:51:55 +0200 | [diff] [blame] | 395 | init_waitqueue_head(&dev->wait_pg); |
Alexander Usyskin | cb02efc | 2014-08-21 14:29:19 +0300 | [diff] [blame] | 396 | init_waitqueue_head(&dev->wait_hbm_start); |
Tomas Winkler | 544f946 | 2014-01-08 20:19:21 +0200 | [diff] [blame] | 397 | init_waitqueue_head(&dev->wait_stop_wd); |
| 398 | dev->dev_state = MEI_DEV_INITIALIZING; |
Tomas Winkler | 6adb8ef | 2014-01-12 00:36:10 +0200 | [diff] [blame] | 399 | dev->reset_count = 0; |
Tomas Winkler | 544f946 | 2014-01-08 20:19:21 +0200 | [diff] [blame] | 400 | |
Tomas Winkler | 544f946 | 2014-01-08 20:19:21 +0200 | [diff] [blame] | 401 | mei_io_list_init(&dev->write_list); |
| 402 | mei_io_list_init(&dev->write_waiting_list); |
| 403 | mei_io_list_init(&dev->ctrl_wr_list); |
| 404 | mei_io_list_init(&dev->ctrl_rd_list); |
| 405 | |
| 406 | INIT_DELAYED_WORK(&dev->timer_work, mei_timer); |
| 407 | INIT_WORK(&dev->init_work, mei_host_client_init); |
| 408 | INIT_WORK(&dev->reset_work, mei_reset_work); |
| 409 | |
| 410 | INIT_LIST_HEAD(&dev->wd_cl.link); |
| 411 | INIT_LIST_HEAD(&dev->iamthif_cl.link); |
| 412 | mei_io_list_init(&dev->amthif_cmd_list); |
| 413 | mei_io_list_init(&dev->amthif_rd_complete_list); |
| 414 | |
| 415 | bitmap_zero(dev->host_clients_map, MEI_CLIENTS_MAX); |
| 416 | dev->open_handle_count = 0; |
| 417 | |
| 418 | /* |
| 419 | * Reserving the first client ID |
| 420 | * 0: Reserved for MEI Bus Message communications |
| 421 | */ |
| 422 | bitmap_set(dev->host_clients_map, 0, 1); |
Tomas Winkler | 964a233 | 2014-03-18 22:51:59 +0200 | [diff] [blame] | 423 | |
| 424 | dev->pg_event = MEI_PG_EVENT_IDLE; |
Tomas Winkler | 3a7e9b6 | 2014-09-29 16:31:41 +0300 | [diff] [blame] | 425 | dev->ops = hw_ops; |
| 426 | dev->dev = device; |
Tomas Winkler | 544f946 | 2014-01-08 20:19:21 +0200 | [diff] [blame] | 427 | } |
| 428 | EXPORT_SYMBOL_GPL(mei_device_init); |
| 429 | |