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 memset(&dev->wr_ext_msg, 0, sizeof(dev->wr_ext_msg)); 120 } 121 122 123 dev->me_clients_num = 0; 124 dev->rd_msg_hdr = 0; 125 dev->wd_pending = false; 126 127 if (ret) { 128 dev_err(&dev->pdev->dev, "hw_reset failed ret = %d\n", ret); 129 return ret; 130 } 131 132 if (state == MEI_DEV_POWER_DOWN) { 133 dev_dbg(&dev->pdev->dev, "powering down: end of reset\n"); 134 dev->dev_state = MEI_DEV_DISABLED; 135 return 0; 136 } 137 138 ret = mei_hw_start(dev); 139 if (ret) { 140 dev_err(&dev->pdev->dev, "hw_start failed ret = %d\n", ret); 141 return ret; 142 } 143 144 dev_dbg(&dev->pdev->dev, "link is established start sending messages.\n"); 145 146 dev->dev_state = MEI_DEV_INIT_CLIENTS; 147 ret = mei_hbm_start_req(dev); 148 if (ret) { 149 dev_err(&dev->pdev->dev, "hbm_start failed ret = %d\n", ret); 150 dev->dev_state = MEI_DEV_RESETTING; 151 return ret; 152 } 153 154 return 0; 155 } 156 EXPORT_SYMBOL_GPL(mei_reset); 157 158 /** 159 * mei_start - initializes host and fw to start work. 160 * 161 * @dev: the device structure 162 * 163 * returns 0 on success, <0 on failure. 164 */ 165 int mei_start(struct mei_device *dev) 166 { 167 int ret; 168 mutex_lock(&dev->device_lock); 169 170 /* acknowledge interrupt and stop interrupts */ 171 mei_clear_interrupts(dev); 172 173 mei_hw_config(dev); 174 175 dev_dbg(&dev->pdev->dev, "reset in start the mei device.\n"); 176 177 dev->reset_count = 0; 178 do { 179 dev->dev_state = MEI_DEV_INITIALIZING; 180 ret = mei_reset(dev); 181 182 if (ret == -ENODEV || dev->dev_state == MEI_DEV_DISABLED) { 183 dev_err(&dev->pdev->dev, "reset failed ret = %d", ret); 184 goto err; 185 } 186 } while (ret); 187 188 /* we cannot start the device w/o hbm start message completed */ 189 if (dev->dev_state == MEI_DEV_DISABLED) { 190 dev_err(&dev->pdev->dev, "reset failed"); 191 goto err; 192 } 193 194 if (mei_hbm_start_wait(dev)) { 195 dev_err(&dev->pdev->dev, "HBM haven't started"); 196 goto err; 197 } 198 199 if (!mei_host_is_ready(dev)) { 200 dev_err(&dev->pdev->dev, "host is not ready.\n"); 201 goto err; 202 } 203 204 if (!mei_hw_is_ready(dev)) { 205 dev_err(&dev->pdev->dev, "ME is not ready.\n"); 206 goto err; 207 } 208 209 if (!mei_hbm_version_is_supported(dev)) { 210 dev_dbg(&dev->pdev->dev, "MEI start failed.\n"); 211 goto err; 212 } 213 214 dev_dbg(&dev->pdev->dev, "link layer has been established.\n"); 215 216 mutex_unlock(&dev->device_lock); 217 return 0; 218 err: 219 dev_err(&dev->pdev->dev, "link layer initialization failed.\n"); 220 dev->dev_state = MEI_DEV_DISABLED; 221 mutex_unlock(&dev->device_lock); 222 return -ENODEV; 223 } 224 EXPORT_SYMBOL_GPL(mei_start); 225 226 /** 227 * mei_restart - restart device after suspend 228 * 229 * @dev: the device structure 230 * 231 * returns 0 on success or -ENODEV if the restart hasn't succeeded 232 */ 233 int mei_restart(struct mei_device *dev) 234 { 235 int err; 236 237 mutex_lock(&dev->device_lock); 238 239 mei_clear_interrupts(dev); 240 241 dev->dev_state = MEI_DEV_POWER_UP; 242 dev->reset_count = 0; 243 244 err = mei_reset(dev); 245 246 mutex_unlock(&dev->device_lock); 247 248 if (err == -ENODEV || dev->dev_state == MEI_DEV_DISABLED) { 249 dev_err(&dev->pdev->dev, "device disabled = %d\n", err); 250 return -ENODEV; 251 } 252 253 /* try to start again */ 254 if (err) 255 schedule_work(&dev->reset_work); 256 257 258 return 0; 259 } 260 EXPORT_SYMBOL_GPL(mei_restart); 261 262 static void mei_reset_work(struct work_struct *work) 263 { 264 struct mei_device *dev = 265 container_of(work, struct mei_device, reset_work); 266 int ret; 267 268 mutex_lock(&dev->device_lock); 269 270 ret = mei_reset(dev); 271 272 mutex_unlock(&dev->device_lock); 273 274 if (dev->dev_state == MEI_DEV_DISABLED) { 275 dev_err(&dev->pdev->dev, "device disabled = %d\n", ret); 276 return; 277 } 278 279 /* retry reset in case of failure */ 280 if (ret) 281 schedule_work(&dev->reset_work); 282 } 283 284 void mei_stop(struct mei_device *dev) 285 { 286 dev_dbg(&dev->pdev->dev, "stopping the device.\n"); 287 288 mei_cancel_work(dev); 289 290 mei_nfc_host_exit(dev); 291 292 mutex_lock(&dev->device_lock); 293 294 mei_wd_stop(dev); 295 296 dev->dev_state = MEI_DEV_POWER_DOWN; 297 mei_reset(dev); 298 299 mutex_unlock(&dev->device_lock); 300 301 mei_watchdog_unregister(dev); 302 } 303 EXPORT_SYMBOL_GPL(mei_stop); 304 305 306 307 void mei_device_init(struct mei_device *dev) 308 { 309 /* setup our list array */ 310 INIT_LIST_HEAD(&dev->file_list); 311 INIT_LIST_HEAD(&dev->device_list); 312 mutex_init(&dev->device_lock); 313 init_waitqueue_head(&dev->wait_hw_ready); 314 init_waitqueue_head(&dev->wait_recvd_msg); 315 init_waitqueue_head(&dev->wait_stop_wd); 316 dev->dev_state = MEI_DEV_INITIALIZING; 317 dev->reset_count = 0; 318 319 mei_io_list_init(&dev->read_list); 320 mei_io_list_init(&dev->write_list); 321 mei_io_list_init(&dev->write_waiting_list); 322 mei_io_list_init(&dev->ctrl_wr_list); 323 mei_io_list_init(&dev->ctrl_rd_list); 324 325 INIT_DELAYED_WORK(&dev->timer_work, mei_timer); 326 INIT_WORK(&dev->init_work, mei_host_client_init); 327 INIT_WORK(&dev->reset_work, mei_reset_work); 328 329 INIT_LIST_HEAD(&dev->wd_cl.link); 330 INIT_LIST_HEAD(&dev->iamthif_cl.link); 331 mei_io_list_init(&dev->amthif_cmd_list); 332 mei_io_list_init(&dev->amthif_rd_complete_list); 333 334 bitmap_zero(dev->host_clients_map, MEI_CLIENTS_MAX); 335 dev->open_handle_count = 0; 336 337 /* 338 * Reserving the first client ID 339 * 0: Reserved for MEI Bus Message communications 340 */ 341 bitmap_set(dev->host_clients_map, 0, 1); 342 } 343 EXPORT_SYMBOL_GPL(mei_device_init); 344 345