1 /* 2 * 3 * Intel Management Engine Interface (Intel MEI) Linux driver 4 * Copyright (c) 2003-2012, Intel Corporation. 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 17 #include <linux/export.h> 18 #include <linux/pci.h> 19 #include <linux/sched.h> 20 #include <linux/wait.h> 21 #include <linux/delay.h> 22 23 #include <linux/mei.h> 24 25 #include "mei_dev.h" 26 #include "hbm.h" 27 #include "client.h" 28 29 const char *mei_dev_state_str(int state) 30 { 31 #define MEI_DEV_STATE(state) case MEI_DEV_##state: return #state 32 switch (state) { 33 MEI_DEV_STATE(INITIALIZING); 34 MEI_DEV_STATE(INIT_CLIENTS); 35 MEI_DEV_STATE(ENABLED); 36 MEI_DEV_STATE(RESETTING); 37 MEI_DEV_STATE(DISABLED); 38 MEI_DEV_STATE(POWER_DOWN); 39 MEI_DEV_STATE(POWER_UP); 40 default: 41 return "unknown"; 42 } 43 #undef MEI_DEV_STATE 44 } 45 46 47 /** 48 * mei_cancel_work. Cancel mei background jobs 49 * 50 * @dev: the device structure 51 * 52 * returns 0 on success or < 0 if the reset hasn't succeeded 53 */ 54 void mei_cancel_work(struct mei_device *dev) 55 { 56 cancel_work_sync(&dev->init_work); 57 cancel_work_sync(&dev->reset_work); 58 59 cancel_delayed_work(&dev->timer_work); 60 } 61 EXPORT_SYMBOL_GPL(mei_cancel_work); 62 63 /** 64 * mei_reset - resets host and fw. 65 * 66 * @dev: the device structure 67 */ 68 int mei_reset(struct mei_device *dev) 69 { 70 enum mei_dev_state state = dev->dev_state; 71 bool interrupts_enabled; 72 int ret; 73 74 if (state != MEI_DEV_INITIALIZING && 75 state != MEI_DEV_DISABLED && 76 state != MEI_DEV_POWER_DOWN && 77 state != MEI_DEV_POWER_UP) 78 dev_warn(&dev->pdev->dev, "unexpected reset: dev_state = %s\n", 79 mei_dev_state_str(state)); 80 81 /* we're already in reset, cancel the init timer 82 * if the reset was called due the hbm protocol error 83 * we need to call it before hw start 84 * so the hbm watchdog won't kick in 85 */ 86 mei_hbm_idle(dev); 87 88 /* enter reset flow */ 89 interrupts_enabled = state != MEI_DEV_POWER_DOWN; 90 dev->dev_state = MEI_DEV_RESETTING; 91 92 dev->reset_count++; 93 if (dev->reset_count > MEI_MAX_CONSEC_RESET) { 94 dev_err(&dev->pdev->dev, "reset: reached maximal consecutive resets: disabling the device\n"); 95 dev->dev_state = MEI_DEV_DISABLED; 96 return -ENODEV; 97 } 98 99 ret = mei_hw_reset(dev, interrupts_enabled); 100 /* fall through and remove the sw state even if hw reset has failed */ 101 102 /* no need to clean up software state in case of power up */ 103 if (state != MEI_DEV_INITIALIZING && 104 state != MEI_DEV_POWER_UP) { 105 106 /* remove all waiting requests */ 107 mei_cl_all_write_clear(dev); 108 109 mei_cl_all_disconnect(dev); 110 111 /* wake up all readers and writers so they can be interrupted */ 112 mei_cl_all_wakeup(dev); 113 114 /* remove entry if already in list */ 115 dev_dbg(&dev->pdev->dev, "remove iamthif and wd from the file list.\n"); 116 mei_cl_unlink(&dev->wd_cl); 117 mei_cl_unlink(&dev->iamthif_cl); 118 mei_amthif_reset_params(dev); 119 } 120 121 122 dev->me_clients_num = 0; 123 dev->rd_msg_hdr = 0; 124 dev->wd_pending = false; 125 126 if (ret) { 127 dev_err(&dev->pdev->dev, "hw_reset failed ret = %d\n", ret); 128 return ret; 129 } 130 131 if (state == MEI_DEV_POWER_DOWN) { 132 dev_dbg(&dev->pdev->dev, "powering down: end of reset\n"); 133 dev->dev_state = MEI_DEV_DISABLED; 134 return 0; 135 } 136 137 ret = mei_hw_start(dev); 138 if (ret) { 139 dev_err(&dev->pdev->dev, "hw_start failed ret = %d\n", ret); 140 return ret; 141 } 142 143 dev_dbg(&dev->pdev->dev, "link is established start sending messages.\n"); 144 145 dev->dev_state = MEI_DEV_INIT_CLIENTS; 146 ret = mei_hbm_start_req(dev); 147 if (ret) { 148 dev_err(&dev->pdev->dev, "hbm_start failed ret = %d\n", ret); 149 dev->dev_state = MEI_DEV_RESETTING; 150 return ret; 151 } 152 153 return 0; 154 } 155 EXPORT_SYMBOL_GPL(mei_reset); 156 157 /** 158 * mei_start - initializes host and fw to start work. 159 * 160 * @dev: the device structure 161 * 162 * returns 0 on success, <0 on failure. 163 */ 164 int mei_start(struct mei_device *dev) 165 { 166 int ret; 167 mutex_lock(&dev->device_lock); 168 169 /* acknowledge interrupt and stop interrupts */ 170 mei_clear_interrupts(dev); 171 172 mei_hw_config(dev); 173 174 dev_dbg(&dev->pdev->dev, "reset in start the mei device.\n"); 175 176 dev->reset_count = 0; 177 do { 178 dev->dev_state = MEI_DEV_INITIALIZING; 179 ret = mei_reset(dev); 180 181 if (ret == -ENODEV || dev->dev_state == MEI_DEV_DISABLED) { 182 dev_err(&dev->pdev->dev, "reset failed ret = %d", ret); 183 goto err; 184 } 185 } while (ret); 186 187 /* we cannot start the device w/o hbm start message completed */ 188 if (dev->dev_state == MEI_DEV_DISABLED) { 189 dev_err(&dev->pdev->dev, "reset failed"); 190 goto err; 191 } 192 193 if (mei_hbm_start_wait(dev)) { 194 dev_err(&dev->pdev->dev, "HBM haven't started"); 195 goto err; 196 } 197 198 if (!mei_host_is_ready(dev)) { 199 dev_err(&dev->pdev->dev, "host is not ready.\n"); 200 goto err; 201 } 202 203 if (!mei_hw_is_ready(dev)) { 204 dev_err(&dev->pdev->dev, "ME is not ready.\n"); 205 goto err; 206 } 207 208 if (!mei_hbm_version_is_supported(dev)) { 209 dev_dbg(&dev->pdev->dev, "MEI start failed.\n"); 210 goto err; 211 } 212 213 dev_dbg(&dev->pdev->dev, "link layer has been established.\n"); 214 215 mutex_unlock(&dev->device_lock); 216 return 0; 217 err: 218 dev_err(&dev->pdev->dev, "link layer initialization failed.\n"); 219 dev->dev_state = MEI_DEV_DISABLED; 220 mutex_unlock(&dev->device_lock); 221 return -ENODEV; 222 } 223 EXPORT_SYMBOL_GPL(mei_start); 224 225 /** 226 * mei_restart - restart device after suspend 227 * 228 * @dev: the device structure 229 * 230 * returns 0 on success or -ENODEV if the restart hasn't succeeded 231 */ 232 int mei_restart(struct mei_device *dev) 233 { 234 int err; 235 236 mutex_lock(&dev->device_lock); 237 238 mei_clear_interrupts(dev); 239 240 dev->dev_state = MEI_DEV_POWER_UP; 241 dev->reset_count = 0; 242 243 err = mei_reset(dev); 244 245 mutex_unlock(&dev->device_lock); 246 247 if (err == -ENODEV || dev->dev_state == MEI_DEV_DISABLED) { 248 dev_err(&dev->pdev->dev, "device disabled = %d\n", err); 249 return -ENODEV; 250 } 251 252 /* try to start again */ 253 if (err) 254 schedule_work(&dev->reset_work); 255 256 257 return 0; 258 } 259 EXPORT_SYMBOL_GPL(mei_restart); 260 261 static void mei_reset_work(struct work_struct *work) 262 { 263 struct mei_device *dev = 264 container_of(work, struct mei_device, reset_work); 265 int ret; 266 267 mutex_lock(&dev->device_lock); 268 269 ret = mei_reset(dev); 270 271 mutex_unlock(&dev->device_lock); 272 273 if (dev->dev_state == MEI_DEV_DISABLED) { 274 dev_err(&dev->pdev->dev, "device disabled = %d\n", ret); 275 return; 276 } 277 278 /* retry reset in case of failure */ 279 if (ret) 280 schedule_work(&dev->reset_work); 281 } 282 283 void mei_stop(struct mei_device *dev) 284 { 285 dev_dbg(&dev->pdev->dev, "stopping the device.\n"); 286 287 mei_cancel_work(dev); 288 289 mei_nfc_host_exit(dev); 290 291 mei_cl_bus_remove_devices(dev); 292 293 mutex_lock(&dev->device_lock); 294 295 mei_wd_stop(dev); 296 297 dev->dev_state = MEI_DEV_POWER_DOWN; 298 mei_reset(dev); 299 300 mutex_unlock(&dev->device_lock); 301 302 mei_watchdog_unregister(dev); 303 } 304 EXPORT_SYMBOL_GPL(mei_stop); 305 306 307 308 void mei_device_init(struct mei_device *dev) 309 { 310 /* setup our list array */ 311 INIT_LIST_HEAD(&dev->file_list); 312 INIT_LIST_HEAD(&dev->device_list); 313 mutex_init(&dev->device_lock); 314 init_waitqueue_head(&dev->wait_hw_ready); 315 init_waitqueue_head(&dev->wait_recvd_msg); 316 init_waitqueue_head(&dev->wait_stop_wd); 317 dev->dev_state = MEI_DEV_INITIALIZING; 318 dev->reset_count = 0; 319 320 mei_io_list_init(&dev->read_list); 321 mei_io_list_init(&dev->write_list); 322 mei_io_list_init(&dev->write_waiting_list); 323 mei_io_list_init(&dev->ctrl_wr_list); 324 mei_io_list_init(&dev->ctrl_rd_list); 325 326 INIT_DELAYED_WORK(&dev->timer_work, mei_timer); 327 INIT_WORK(&dev->init_work, mei_host_client_init); 328 INIT_WORK(&dev->reset_work, mei_reset_work); 329 330 INIT_LIST_HEAD(&dev->wd_cl.link); 331 INIT_LIST_HEAD(&dev->iamthif_cl.link); 332 mei_io_list_init(&dev->amthif_cmd_list); 333 mei_io_list_init(&dev->amthif_rd_complete_list); 334 335 bitmap_zero(dev->host_clients_map, MEI_CLIENTS_MAX); 336 dev->open_handle_count = 0; 337 338 /* 339 * Reserving the first client ID 340 * 0: Reserved for MEI Bus Message communications 341 */ 342 bitmap_set(dev->host_clients_map, 0, 1); 343 } 344 EXPORT_SYMBOL_GPL(mei_device_init); 345 346