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 #ifndef _MEI_DEV_H_ 18 #define _MEI_DEV_H_ 19 20 #include <linux/types.h> 21 #include <linux/watchdog.h> 22 #include <linux/poll.h> 23 #include <linux/mei.h> 24 25 #include "hw.h" 26 #include "hw-me-regs.h" 27 28 /* 29 * watch dog definition 30 */ 31 #define MEI_WD_HDR_SIZE 4 32 #define MEI_WD_STOP_MSG_SIZE MEI_WD_HDR_SIZE 33 #define MEI_WD_START_MSG_SIZE (MEI_WD_HDR_SIZE + 16) 34 35 #define MEI_WD_DEFAULT_TIMEOUT 120 /* seconds */ 36 #define MEI_WD_MIN_TIMEOUT 120 /* seconds */ 37 #define MEI_WD_MAX_TIMEOUT 65535 /* seconds */ 38 39 #define MEI_WD_STOP_TIMEOUT 10 /* msecs */ 40 41 #define MEI_WD_STATE_INDEPENDENCE_MSG_SENT (1 << 0) 42 43 #define MEI_RD_MSG_BUF_SIZE (128 * sizeof(u32)) 44 45 46 /* 47 * AMTHI Client UUID 48 */ 49 extern const uuid_le mei_amthif_guid; 50 51 /* 52 * Watchdog Client UUID 53 */ 54 extern const uuid_le mei_wd_guid; 55 56 /* 57 * Watchdog independence state message 58 */ 59 extern const u8 mei_wd_state_independence_msg[3][4]; 60 61 /* 62 * Number of Maximum MEI Clients 63 */ 64 #define MEI_CLIENTS_MAX 256 65 66 /* 67 * Number of File descriptors/handles 68 * that can be opened to the driver. 69 * 70 * Limit to 255: 256 Total Clients 71 * minus internal client for MEI Bus Messags 72 */ 73 #define MEI_MAX_OPEN_HANDLE_COUNT (MEI_CLIENTS_MAX - 1) 74 75 /* 76 * Internal Clients Number 77 */ 78 #define MEI_HOST_CLIENT_ID_ANY (-1) 79 #define MEI_HBM_HOST_CLIENT_ID 0 /* not used, just for documentation */ 80 #define MEI_WD_HOST_CLIENT_ID 1 81 #define MEI_IAMTHIF_HOST_CLIENT_ID 2 82 83 84 /* File state */ 85 enum file_state { 86 MEI_FILE_INITIALIZING = 0, 87 MEI_FILE_CONNECTING, 88 MEI_FILE_CONNECTED, 89 MEI_FILE_DISCONNECTING, 90 MEI_FILE_DISCONNECTED 91 }; 92 93 /* MEI device states */ 94 enum mei_dev_state { 95 MEI_DEV_INITIALIZING = 0, 96 MEI_DEV_INIT_CLIENTS, 97 MEI_DEV_ENABLED, 98 MEI_DEV_RESETING, 99 MEI_DEV_DISABLED, 100 MEI_DEV_RECOVERING_FROM_RESET, 101 MEI_DEV_POWER_DOWN, 102 MEI_DEV_POWER_UP 103 }; 104 105 const char *mei_dev_state_str(int state); 106 107 /* init clients states*/ 108 enum mei_init_clients_states { 109 MEI_START_MESSAGE = 0, 110 MEI_ENUM_CLIENTS_MESSAGE, 111 MEI_CLIENT_PROPERTIES_MESSAGE 112 }; 113 114 enum iamthif_states { 115 MEI_IAMTHIF_IDLE, 116 MEI_IAMTHIF_WRITING, 117 MEI_IAMTHIF_FLOW_CONTROL, 118 MEI_IAMTHIF_READING, 119 MEI_IAMTHIF_READ_COMPLETE 120 }; 121 122 enum mei_file_transaction_states { 123 MEI_IDLE, 124 MEI_WRITING, 125 MEI_WRITE_COMPLETE, 126 MEI_FLOW_CONTROL, 127 MEI_READING, 128 MEI_READ_COMPLETE 129 }; 130 131 enum mei_wd_states { 132 MEI_WD_IDLE, 133 MEI_WD_RUNNING, 134 MEI_WD_STOPPING, 135 }; 136 137 /** 138 * enum mei_cb_file_ops - file operation associated with the callback 139 * @MEI_FOP_READ - read 140 * @MEI_FOP_WRITE - write 141 * @MEI_FOP_IOCTL - ioctl 142 * @MEI_FOP_OPEN - open 143 * @MEI_FOP_CLOSE - close 144 */ 145 enum mei_cb_file_ops { 146 MEI_FOP_READ = 0, 147 MEI_FOP_WRITE, 148 MEI_FOP_IOCTL, 149 MEI_FOP_OPEN, 150 MEI_FOP_CLOSE 151 }; 152 153 /* 154 * Intel MEI message data struct 155 */ 156 struct mei_message_data { 157 u32 size; 158 unsigned char *data; 159 }; 160 161 /** 162 * struct mei_me_client - representation of me (fw) client 163 * 164 * @props - client properties 165 * @client_id - me client id 166 * @mei_flow_ctrl_creds - flow control credits 167 */ 168 struct mei_me_client { 169 struct mei_client_properties props; 170 u8 client_id; 171 u8 mei_flow_ctrl_creds; 172 }; 173 174 175 struct mei_cl; 176 177 /** 178 * struct mei_cl_cb - file operation callback structure 179 * 180 * @cl - file client who is running this operation 181 * @fop_type - file operation type 182 */ 183 struct mei_cl_cb { 184 struct list_head list; 185 struct mei_cl *cl; 186 enum mei_cb_file_ops fop_type; 187 struct mei_message_data request_buffer; 188 struct mei_message_data response_buffer; 189 unsigned long buf_idx; 190 unsigned long read_time; 191 struct file *file_object; 192 }; 193 194 /* MEI client instance carried as file->pirvate_data*/ 195 struct mei_cl { 196 struct list_head link; 197 struct mei_device *dev; 198 enum file_state state; 199 wait_queue_head_t tx_wait; 200 wait_queue_head_t rx_wait; 201 wait_queue_head_t wait; 202 int status; 203 /* ID of client connected */ 204 u8 host_client_id; 205 u8 me_client_id; 206 u8 mei_flow_ctrl_creds; 207 u8 timer_count; 208 enum mei_file_transaction_states reading_state; 209 enum mei_file_transaction_states writing_state; 210 int sm_state; 211 struct mei_cl_cb *read_cb; 212 }; 213 214 /** struct mei_hw_ops 215 * 216 * @host_is_ready - query for host readiness 217 218 * @hw_is_ready - query if hw is ready 219 * @hw_reset - reset hw 220 * @hw_start - start hw after reset 221 * @hw_config - configure hw 222 223 * @intr_clear - clear pending interrupts 224 * @intr_enable - enable interrupts 225 * @intr_disable - disable interrupts 226 227 * @hbuf_free_slots - query for write buffer empty slots 228 * @hbuf_is_ready - query if write buffer is empty 229 * @hbuf_max_len - query for write buffer max len 230 231 * @write - write a message to FW 232 233 * @rdbuf_full_slots - query how many slots are filled 234 235 * @read_hdr - get first 4 bytes (header) 236 * @read - read a buffer from the FW 237 */ 238 struct mei_hw_ops { 239 240 bool (*host_is_ready) (struct mei_device *dev); 241 242 bool (*hw_is_ready) (struct mei_device *dev); 243 void (*hw_reset) (struct mei_device *dev, bool enable); 244 int (*hw_start) (struct mei_device *dev); 245 void (*hw_config) (struct mei_device *dev); 246 247 void (*intr_clear) (struct mei_device *dev); 248 void (*intr_enable) (struct mei_device *dev); 249 void (*intr_disable) (struct mei_device *dev); 250 251 int (*hbuf_free_slots) (struct mei_device *dev); 252 bool (*hbuf_is_ready) (struct mei_device *dev); 253 size_t (*hbuf_max_len) (const struct mei_device *dev); 254 255 int (*write)(struct mei_device *dev, 256 struct mei_msg_hdr *hdr, 257 unsigned char *buf); 258 259 int (*rdbuf_full_slots)(struct mei_device *dev); 260 261 u32 (*read_hdr)(const struct mei_device *dev); 262 int (*read) (struct mei_device *dev, 263 unsigned char *buf, unsigned long len); 264 }; 265 266 /** 267 * struct mei_device - MEI private device struct 268 269 * @mem_addr - mem mapped base register address 270 271 * @hbuf_depth - depth of hardware host/write buffer is slots 272 * @hbuf_is_ready - query if the host host/write buffer is ready 273 * @wr_msg - the buffer for hbm control messages 274 * @wr_ext_msg - the buffer for hbm control responses (set in read cycle) 275 */ 276 struct mei_device { 277 struct pci_dev *pdev; /* pointer to pci device struct */ 278 /* 279 * lists of queues 280 */ 281 /* array of pointers to aio lists */ 282 struct mei_cl_cb read_list; /* driver read queue */ 283 struct mei_cl_cb write_list; /* driver write queue */ 284 struct mei_cl_cb write_waiting_list; /* write waiting queue */ 285 struct mei_cl_cb ctrl_wr_list; /* managed write IOCTL list */ 286 struct mei_cl_cb ctrl_rd_list; /* managed read IOCTL list */ 287 288 /* 289 * list of files 290 */ 291 struct list_head file_list; 292 long open_handle_count; 293 294 /* 295 * lock for the device 296 */ 297 struct mutex device_lock; /* device lock */ 298 struct delayed_work timer_work; /* MEI timer delayed work (timeouts) */ 299 300 bool recvd_hw_ready; 301 bool recvd_msg; 302 303 /* 304 * waiting queue for receive message from FW 305 */ 306 wait_queue_head_t wait_hw_ready; 307 wait_queue_head_t wait_recvd_msg; 308 wait_queue_head_t wait_stop_wd; 309 310 /* 311 * mei device states 312 */ 313 enum mei_dev_state dev_state; 314 enum mei_init_clients_states init_clients_state; 315 u16 init_clients_timer; 316 317 unsigned char rd_msg_buf[MEI_RD_MSG_BUF_SIZE]; /* control messages */ 318 u32 rd_msg_hdr; 319 320 /* write buffer */ 321 u8 hbuf_depth; 322 bool hbuf_is_ready; 323 324 /* used for control messages */ 325 struct { 326 struct mei_msg_hdr hdr; 327 unsigned char data[128]; 328 } wr_msg; 329 330 struct { 331 struct mei_msg_hdr hdr; 332 unsigned char data[4]; /* All HBM messages are 4 bytes */ 333 } wr_ext_msg; /* for control responses */ 334 335 struct hbm_version version; 336 337 struct mei_me_client *me_clients; /* Note: memory has to be allocated */ 338 DECLARE_BITMAP(me_clients_map, MEI_CLIENTS_MAX); 339 DECLARE_BITMAP(host_clients_map, MEI_CLIENTS_MAX); 340 u8 me_clients_num; 341 u8 me_client_presentation_num; 342 u8 me_client_index; 343 344 struct mei_cl wd_cl; 345 enum mei_wd_states wd_state; 346 bool wd_pending; 347 u16 wd_timeout; 348 unsigned char wd_data[MEI_WD_START_MSG_SIZE]; 349 350 351 /* amthif list for cmd waiting */ 352 struct mei_cl_cb amthif_cmd_list; 353 /* driver managed amthif list for reading completed amthif cmd data */ 354 struct mei_cl_cb amthif_rd_complete_list; 355 struct file *iamthif_file_object; 356 struct mei_cl iamthif_cl; 357 struct mei_cl_cb *iamthif_current_cb; 358 int iamthif_mtu; 359 unsigned long iamthif_timer; 360 u32 iamthif_stall_timer; 361 unsigned char *iamthif_msg_buf; /* Note: memory has to be allocated */ 362 u32 iamthif_msg_buf_size; 363 u32 iamthif_msg_buf_index; 364 enum iamthif_states iamthif_state; 365 bool iamthif_flow_control_pending; 366 bool iamthif_ioctl; 367 bool iamthif_canceled; 368 369 struct work_struct init_work; 370 371 const struct mei_hw_ops *ops; 372 char hw[0] __aligned(sizeof(void *)); 373 }; 374 375 static inline unsigned long mei_secs_to_jiffies(unsigned long sec) 376 { 377 return msecs_to_jiffies(sec * MSEC_PER_SEC); 378 } 379 380 /** 381 * mei_data2slots - get slots - number of (dwords) from a message length 382 * + size of the mei header 383 * @length - size of the messages in bytes 384 * returns - number of slots 385 */ 386 static inline u32 mei_data2slots(size_t length) 387 { 388 return DIV_ROUND_UP(sizeof(struct mei_msg_hdr) + length, 4); 389 } 390 391 392 /* 393 * mei init function prototypes 394 */ 395 void mei_device_init(struct mei_device *dev); 396 void mei_reset(struct mei_device *dev, int interrupts); 397 int mei_hw_init(struct mei_device *dev); 398 399 /* 400 * MEI interrupt functions prototype 401 */ 402 403 void mei_timer(struct work_struct *work); 404 int mei_irq_read_handler(struct mei_device *dev, 405 struct mei_cl_cb *cmpl_list, s32 *slots); 406 407 int mei_irq_write_handler(struct mei_device *dev, struct mei_cl_cb *cmpl_list); 408 409 void mei_irq_complete_handler(struct mei_cl *cl, struct mei_cl_cb *cb_pos); 410 411 /* 412 * AMTHIF - AMT Host Interface Functions 413 */ 414 void mei_amthif_reset_params(struct mei_device *dev); 415 416 int mei_amthif_host_init(struct mei_device *dev); 417 418 int mei_amthif_write(struct mei_device *dev, struct mei_cl_cb *priv_cb); 419 420 int mei_amthif_read(struct mei_device *dev, struct file *file, 421 char __user *ubuf, size_t length, loff_t *offset); 422 423 unsigned int mei_amthif_poll(struct mei_device *dev, 424 struct file *file, poll_table *wait); 425 426 int mei_amthif_release(struct mei_device *dev, struct file *file); 427 428 struct mei_cl_cb *mei_amthif_find_read_list_entry(struct mei_device *dev, 429 struct file *file); 430 431 void mei_amthif_run_next_cmd(struct mei_device *dev); 432 433 434 int mei_amthif_irq_write_complete(struct mei_device *dev, s32 *slots, 435 struct mei_cl_cb *cb, struct mei_cl_cb *cmpl_list); 436 437 void mei_amthif_complete(struct mei_device *dev, struct mei_cl_cb *cb); 438 int mei_amthif_irq_read_message(struct mei_cl_cb *complete_list, 439 struct mei_device *dev, struct mei_msg_hdr *mei_hdr); 440 int mei_amthif_irq_read(struct mei_device *dev, s32 *slots); 441 442 443 int mei_wd_send(struct mei_device *dev); 444 int mei_wd_stop(struct mei_device *dev); 445 int mei_wd_host_init(struct mei_device *dev); 446 /* 447 * mei_watchdog_register - Registering watchdog interface 448 * once we got connection to the WD Client 449 * @dev - mei device 450 */ 451 void mei_watchdog_register(struct mei_device *dev); 452 /* 453 * mei_watchdog_unregister - Unregistering watchdog interface 454 * @dev - mei device 455 */ 456 void mei_watchdog_unregister(struct mei_device *dev); 457 458 /* 459 * Register Access Function 460 */ 461 462 static inline void mei_hw_config(struct mei_device *dev) 463 { 464 dev->ops->hw_config(dev); 465 } 466 static inline void mei_hw_reset(struct mei_device *dev, bool enable) 467 { 468 dev->ops->hw_reset(dev, enable); 469 } 470 471 static inline void mei_hw_start(struct mei_device *dev) 472 { 473 dev->ops->hw_start(dev); 474 } 475 476 static inline void mei_clear_interrupts(struct mei_device *dev) 477 { 478 dev->ops->intr_clear(dev); 479 } 480 481 static inline void mei_enable_interrupts(struct mei_device *dev) 482 { 483 dev->ops->intr_enable(dev); 484 } 485 486 static inline void mei_disable_interrupts(struct mei_device *dev) 487 { 488 dev->ops->intr_disable(dev); 489 } 490 491 static inline bool mei_host_is_ready(struct mei_device *dev) 492 { 493 return dev->ops->host_is_ready(dev); 494 } 495 static inline bool mei_hw_is_ready(struct mei_device *dev) 496 { 497 return dev->ops->hw_is_ready(dev); 498 } 499 500 static inline bool mei_hbuf_is_ready(struct mei_device *dev) 501 { 502 return dev->ops->hbuf_is_ready(dev); 503 } 504 505 static inline int mei_hbuf_empty_slots(struct mei_device *dev) 506 { 507 return dev->ops->hbuf_free_slots(dev); 508 } 509 510 static inline size_t mei_hbuf_max_len(const struct mei_device *dev) 511 { 512 return dev->ops->hbuf_max_len(dev); 513 } 514 515 static inline int mei_write_message(struct mei_device *dev, 516 struct mei_msg_hdr *hdr, 517 unsigned char *buf) 518 { 519 return dev->ops->write(dev, hdr, buf); 520 } 521 522 static inline u32 mei_read_hdr(const struct mei_device *dev) 523 { 524 return dev->ops->read_hdr(dev); 525 } 526 527 static inline void mei_read_slots(struct mei_device *dev, 528 unsigned char *buf, unsigned long len) 529 { 530 dev->ops->read(dev, buf, len); 531 } 532 533 static inline int mei_count_full_read_slots(struct mei_device *dev) 534 { 535 return dev->ops->rdbuf_full_slots(dev); 536 } 537 538 int mei_register(struct device *dev); 539 void mei_deregister(void); 540 541 #define MEI_HDR_FMT "hdr:host=%02d me=%02d len=%d comp=%1d" 542 #define MEI_HDR_PRM(hdr) \ 543 (hdr)->host_addr, (hdr)->me_addr, \ 544 (hdr)->length, (hdr)->msg_complete 545 546 #endif 547