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_set_ready - notify FW that host side is ready 217 * @host_is_ready - query for host readiness 218 219 * @hw_is_ready - query if hw is ready 220 * @hw_reset - reset hw 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 void (*host_set_ready) (struct mei_device *dev); 241 bool (*host_is_ready) (struct mei_device *dev); 242 243 bool (*hw_is_ready) (struct mei_device *dev); 244 void (*hw_reset) (struct mei_device *dev, bool enable); 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 bool recvd_msg; 300 301 /* 302 * waiting queue for receive message from FW 303 */ 304 wait_queue_head_t wait_recvd_msg; 305 wait_queue_head_t wait_stop_wd; 306 307 /* 308 * mei device states 309 */ 310 enum mei_dev_state dev_state; 311 enum mei_init_clients_states init_clients_state; 312 u16 init_clients_timer; 313 314 unsigned char rd_msg_buf[MEI_RD_MSG_BUF_SIZE]; /* control messages */ 315 u32 rd_msg_hdr; 316 317 /* write buffer */ 318 u8 hbuf_depth; 319 bool hbuf_is_ready; 320 321 /* used for control messages */ 322 struct { 323 struct mei_msg_hdr hdr; 324 unsigned char data[128]; 325 } wr_msg; 326 327 struct { 328 struct mei_msg_hdr hdr; 329 unsigned char data[4]; /* All HBM messages are 4 bytes */ 330 } wr_ext_msg; /* for control responses */ 331 332 struct hbm_version version; 333 334 struct mei_me_client *me_clients; /* Note: memory has to be allocated */ 335 DECLARE_BITMAP(me_clients_map, MEI_CLIENTS_MAX); 336 DECLARE_BITMAP(host_clients_map, MEI_CLIENTS_MAX); 337 u8 me_clients_num; 338 u8 me_client_presentation_num; 339 u8 me_client_index; 340 341 struct mei_cl wd_cl; 342 enum mei_wd_states wd_state; 343 bool wd_pending; 344 u16 wd_timeout; 345 unsigned char wd_data[MEI_WD_START_MSG_SIZE]; 346 347 348 /* amthif list for cmd waiting */ 349 struct mei_cl_cb amthif_cmd_list; 350 /* driver managed amthif list for reading completed amthif cmd data */ 351 struct mei_cl_cb amthif_rd_complete_list; 352 struct file *iamthif_file_object; 353 struct mei_cl iamthif_cl; 354 struct mei_cl_cb *iamthif_current_cb; 355 int iamthif_mtu; 356 unsigned long iamthif_timer; 357 u32 iamthif_stall_timer; 358 unsigned char *iamthif_msg_buf; /* Note: memory has to be allocated */ 359 u32 iamthif_msg_buf_size; 360 u32 iamthif_msg_buf_index; 361 enum iamthif_states iamthif_state; 362 bool iamthif_flow_control_pending; 363 bool iamthif_ioctl; 364 bool iamthif_canceled; 365 366 struct work_struct init_work; 367 368 const struct mei_hw_ops *ops; 369 char hw[0] __aligned(sizeof(void *)); 370 }; 371 372 static inline unsigned long mei_secs_to_jiffies(unsigned long sec) 373 { 374 return msecs_to_jiffies(sec * MSEC_PER_SEC); 375 } 376 377 378 /* 379 * mei init function prototypes 380 */ 381 void mei_device_init(struct mei_device *dev); 382 void mei_reset(struct mei_device *dev, int interrupts); 383 int mei_hw_init(struct mei_device *dev); 384 void mei_stop(struct mei_device *dev); 385 386 /* 387 * MEI interrupt functions prototype 388 */ 389 390 void mei_timer(struct work_struct *work); 391 int mei_irq_read_handler(struct mei_device *dev, 392 struct mei_cl_cb *cmpl_list, s32 *slots); 393 394 int mei_irq_write_handler(struct mei_device *dev, struct mei_cl_cb *cmpl_list); 395 396 void mei_irq_complete_handler(struct mei_cl *cl, struct mei_cl_cb *cb_pos); 397 398 /* 399 * AMTHIF - AMT Host Interface Functions 400 */ 401 void mei_amthif_reset_params(struct mei_device *dev); 402 403 int mei_amthif_host_init(struct mei_device *dev); 404 405 int mei_amthif_write(struct mei_device *dev, struct mei_cl_cb *priv_cb); 406 407 int mei_amthif_read(struct mei_device *dev, struct file *file, 408 char __user *ubuf, size_t length, loff_t *offset); 409 410 unsigned int mei_amthif_poll(struct mei_device *dev, 411 struct file *file, poll_table *wait); 412 413 int mei_amthif_release(struct mei_device *dev, struct file *file); 414 415 struct mei_cl_cb *mei_amthif_find_read_list_entry(struct mei_device *dev, 416 struct file *file); 417 418 void mei_amthif_run_next_cmd(struct mei_device *dev); 419 420 421 int mei_amthif_irq_write_complete(struct mei_device *dev, s32 *slots, 422 struct mei_cl_cb *cb, struct mei_cl_cb *cmpl_list); 423 424 void mei_amthif_complete(struct mei_device *dev, struct mei_cl_cb *cb); 425 int mei_amthif_irq_read_message(struct mei_cl_cb *complete_list, 426 struct mei_device *dev, struct mei_msg_hdr *mei_hdr); 427 int mei_amthif_irq_read(struct mei_device *dev, s32 *slots); 428 429 430 int mei_wd_send(struct mei_device *dev); 431 int mei_wd_stop(struct mei_device *dev); 432 int mei_wd_host_init(struct mei_device *dev); 433 /* 434 * mei_watchdog_register - Registering watchdog interface 435 * once we got connection to the WD Client 436 * @dev - mei device 437 */ 438 void mei_watchdog_register(struct mei_device *dev); 439 /* 440 * mei_watchdog_unregister - Unregistering watchdog interface 441 * @dev - mei device 442 */ 443 void mei_watchdog_unregister(struct mei_device *dev); 444 445 /* 446 * Register Access Function 447 */ 448 449 static inline void mei_hw_config(struct mei_device *dev) 450 { 451 dev->ops->hw_config(dev); 452 } 453 static inline void mei_hw_reset(struct mei_device *dev, bool enable) 454 { 455 dev->ops->hw_reset(dev, enable); 456 } 457 458 static inline void mei_clear_interrupts(struct mei_device *dev) 459 { 460 dev->ops->intr_clear(dev); 461 } 462 463 static inline void mei_enable_interrupts(struct mei_device *dev) 464 { 465 dev->ops->intr_enable(dev); 466 } 467 468 static inline void mei_disable_interrupts(struct mei_device *dev) 469 { 470 dev->ops->intr_disable(dev); 471 } 472 473 static inline void mei_host_set_ready(struct mei_device *dev) 474 { 475 dev->ops->host_set_ready(dev); 476 } 477 static inline bool mei_host_is_ready(struct mei_device *dev) 478 { 479 return dev->ops->host_is_ready(dev); 480 } 481 static inline bool mei_hw_is_ready(struct mei_device *dev) 482 { 483 return dev->ops->hw_is_ready(dev); 484 } 485 486 static inline bool mei_hbuf_is_ready(struct mei_device *dev) 487 { 488 return dev->ops->hbuf_is_ready(dev); 489 } 490 491 static inline int mei_hbuf_empty_slots(struct mei_device *dev) 492 { 493 return dev->ops->hbuf_free_slots(dev); 494 } 495 496 static inline size_t mei_hbuf_max_len(const struct mei_device *dev) 497 { 498 return dev->ops->hbuf_max_len(dev); 499 } 500 501 static inline int mei_write_message(struct mei_device *dev, 502 struct mei_msg_hdr *hdr, 503 unsigned char *buf) 504 { 505 return dev->ops->write(dev, hdr, buf); 506 } 507 508 static inline u32 mei_read_hdr(const struct mei_device *dev) 509 { 510 return dev->ops->read_hdr(dev); 511 } 512 513 static inline void mei_read_slots(struct mei_device *dev, 514 unsigned char *buf, unsigned long len) 515 { 516 dev->ops->read(dev, buf, len); 517 } 518 519 static inline int mei_count_full_read_slots(struct mei_device *dev) 520 { 521 return dev->ops->rdbuf_full_slots(dev); 522 } 523 524 int mei_register(struct device *dev); 525 void mei_deregister(void); 526 527 #define MEI_HDR_FMT "hdr:host=%02d me=%02d len=%d comp=%1d" 528 #define MEI_HDR_PRM(hdr) \ 529 (hdr)->host_addr, (hdr)->me_addr, \ 530 (hdr)->length, (hdr)->msg_complete 531 532 #endif 533