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/mei.h> 23 #include "hw.h" 24 25 /* 26 * watch dog definition 27 */ 28 #define MEI_WATCHDOG_DATA_SIZE 16 29 #define MEI_START_WD_DATA_SIZE 20 30 #define MEI_WD_PARAMS_SIZE 4 31 #define MEI_WD_STATE_INDEPENDENCE_MSG_SENT (1 << 0) 32 33 #define MEI_RD_MSG_BUF_SIZE (128 * sizeof(u32)) 34 35 /* 36 * MEI PCI Device object 37 */ 38 extern struct pci_dev *mei_device; 39 40 41 /* 42 * AMTHI Client UUID 43 */ 44 extern const uuid_le mei_amthi_guid; 45 46 /* 47 * Watchdog Client UUID 48 */ 49 extern const uuid_le mei_wd_guid; 50 51 /* 52 * Watchdog independence state message 53 */ 54 extern const u8 mei_wd_state_independence_msg[3][4]; 55 56 /* 57 * Number of File descriptors/handles 58 * that can be opened to the driver. 59 * 60 * Limit to 253: 255 Total Clients 61 * minus internal client for AMTHI 62 * minus internal client for Watchdog 63 */ 64 #define MEI_MAX_OPEN_HANDLE_COUNT 253 65 66 /* 67 * Number of Maximum MEI Clients 68 */ 69 #define MEI_CLIENTS_MAX 255 70 71 /* File state */ 72 enum file_state { 73 MEI_FILE_INITIALIZING = 0, 74 MEI_FILE_CONNECTING, 75 MEI_FILE_CONNECTED, 76 MEI_FILE_DISCONNECTING, 77 MEI_FILE_DISCONNECTED 78 }; 79 80 /* MEI device states */ 81 enum mei_states { 82 MEI_INITIALIZING = 0, 83 MEI_INIT_CLIENTS, 84 MEI_ENABLED, 85 MEI_RESETING, 86 MEI_DISABLED, 87 MEI_RECOVERING_FROM_RESET, 88 MEI_POWER_DOWN, 89 MEI_POWER_UP 90 }; 91 92 /* init clients states*/ 93 enum mei_init_clients_states { 94 MEI_START_MESSAGE = 0, 95 MEI_ENUM_CLIENTS_MESSAGE, 96 MEI_CLIENT_PROPERTIES_MESSAGE 97 }; 98 99 enum iamthif_states { 100 MEI_IAMTHIF_IDLE, 101 MEI_IAMTHIF_WRITING, 102 MEI_IAMTHIF_FLOW_CONTROL, 103 MEI_IAMTHIF_READING, 104 MEI_IAMTHIF_READ_COMPLETE 105 }; 106 107 enum mei_file_transaction_states { 108 MEI_IDLE, 109 MEI_WRITING, 110 MEI_WRITE_COMPLETE, 111 MEI_FLOW_CONTROL, 112 MEI_READING, 113 MEI_READ_COMPLETE 114 }; 115 116 /* MEI CB */ 117 enum mei_cb_major_types { 118 MEI_READ = 0, 119 MEI_WRITE, 120 MEI_IOCTL, 121 MEI_OPEN, 122 MEI_CLOSE 123 }; 124 125 /* 126 * Intel MEI message data struct 127 */ 128 struct mei_message_data { 129 u32 size; 130 unsigned char *data; 131 } __packed; 132 133 134 struct mei_cl_cb { 135 struct list_head cb_list; 136 enum mei_cb_major_types major_file_operations; 137 void *file_private; 138 struct mei_message_data request_buffer; 139 struct mei_message_data response_buffer; 140 unsigned long information; 141 unsigned long read_time; 142 struct file *file_object; 143 }; 144 145 /* MEI client instance carried as file->pirvate_data*/ 146 struct mei_cl { 147 struct list_head link; 148 struct mei_device *dev; 149 enum file_state state; 150 wait_queue_head_t tx_wait; 151 wait_queue_head_t rx_wait; 152 wait_queue_head_t wait; 153 int read_pending; 154 int status; 155 /* ID of client connected */ 156 u8 host_client_id; 157 u8 me_client_id; 158 u8 mei_flow_ctrl_creds; 159 u8 timer_count; 160 enum mei_file_transaction_states reading_state; 161 enum mei_file_transaction_states writing_state; 162 int sm_state; 163 struct mei_cl_cb *read_cb; 164 }; 165 166 struct mei_io_list { 167 struct mei_cl_cb mei_cb; 168 }; 169 170 /* MEI private device struct */ 171 struct mei_device { 172 struct pci_dev *pdev; /* pointer to pci device struct */ 173 /* 174 * lists of queues 175 */ 176 /* array of pointers to aio lists */ 177 struct mei_io_list read_list; /* driver read queue */ 178 struct mei_io_list write_list; /* driver write queue */ 179 struct mei_io_list write_waiting_list; /* write waiting queue */ 180 struct mei_io_list ctrl_wr_list; /* managed write IOCTL list */ 181 struct mei_io_list ctrl_rd_list; /* managed read IOCTL list */ 182 struct mei_io_list amthi_cmd_list; /* amthi list for cmd waiting */ 183 184 /* driver managed amthi list for reading completed amthi cmd data */ 185 struct mei_io_list amthi_read_complete_list; 186 /* 187 * list of files 188 */ 189 struct list_head file_list; 190 long open_handle_count; 191 /* 192 * memory of device 193 */ 194 unsigned int mem_base; 195 unsigned int mem_length; 196 void __iomem *mem_addr; 197 /* 198 * lock for the device 199 */ 200 struct mutex device_lock; /* device lock */ 201 struct delayed_work timer_work; /* MEI timer delayed work (timeouts) */ 202 bool recvd_msg; 203 /* 204 * hw states of host and fw(ME) 205 */ 206 u32 host_hw_state; 207 u32 me_hw_state; 208 /* 209 * waiting queue for receive message from FW 210 */ 211 wait_queue_head_t wait_recvd_msg; 212 wait_queue_head_t wait_stop_wd; 213 214 /* 215 * mei device states 216 */ 217 enum mei_states mei_state; 218 enum mei_init_clients_states init_clients_state; 219 u16 init_clients_timer; 220 bool stop; 221 bool need_reset; 222 223 u32 extra_write_index; 224 unsigned char rd_msg_buf[MEI_RD_MSG_BUF_SIZE]; /* control messages */ 225 u32 wr_msg_buf[128]; /* used for control messages */ 226 u32 ext_msg_buf[8]; /* for control responses */ 227 u32 rd_msg_hdr; 228 229 struct hbm_version version; 230 231 struct mei_me_client *me_clients; /* Note: memory has to be allocated */ 232 DECLARE_BITMAP(me_clients_map, MEI_CLIENTS_MAX); 233 DECLARE_BITMAP(host_clients_map, MEI_CLIENTS_MAX); 234 u8 me_clients_num; 235 u8 me_client_presentation_num; 236 u8 me_client_index; 237 bool mei_host_buffer_is_empty; 238 239 struct mei_cl wd_cl; 240 bool wd_pending; 241 bool wd_stopped; 242 bool wd_bypass; /* if false, don't refresh watchdog ME client */ 243 u16 wd_timeout; /* seconds ((wd_data[1] << 8) + wd_data[0]) */ 244 u16 wd_due_counter; 245 unsigned char wd_data[MEI_START_WD_DATA_SIZE]; 246 247 248 249 struct file *iamthif_file_object; 250 struct mei_cl iamthif_cl; 251 struct mei_cl_cb *iamthif_current_cb; 252 int iamthif_mtu; 253 unsigned long iamthif_timer; 254 u32 iamthif_stall_timer; 255 unsigned char *iamthif_msg_buf; /* Note: memory has to be allocated */ 256 u32 iamthif_msg_buf_size; 257 u32 iamthif_msg_buf_index; 258 enum iamthif_states iamthif_state; 259 bool iamthif_flow_control_pending; 260 bool iamthif_ioctl; 261 bool iamthif_canceled; 262 263 bool wd_interface_reg; 264 }; 265 266 267 /* 268 * mei init function prototypes 269 */ 270 struct mei_device *mei_device_init(struct pci_dev *pdev); 271 void mei_reset(struct mei_device *dev, int interrupts); 272 int mei_hw_init(struct mei_device *dev); 273 int mei_task_initialize_clients(void *data); 274 int mei_initialize_clients(struct mei_device *dev); 275 int mei_disconnect_host_client(struct mei_device *dev, struct mei_cl *cl); 276 void mei_remove_client_from_file_list(struct mei_device *dev, u8 host_client_id); 277 void mei_host_init_iamthif(struct mei_device *dev); 278 void mei_allocate_me_clients_storage(struct mei_device *dev); 279 280 281 u8 mei_find_me_client_update_filext(struct mei_device *dev, 282 struct mei_cl *priv, 283 const uuid_le *cguid, u8 client_id); 284 285 /* 286 * MEI IO List Functions 287 */ 288 void mei_io_list_init(struct mei_io_list *list); 289 void mei_io_list_flush(struct mei_io_list *list, struct mei_cl *cl); 290 291 /* 292 * MEI ME Client Functions 293 */ 294 295 struct mei_cl *mei_cl_allocate(struct mei_device *dev); 296 void mei_cl_init(struct mei_cl *cl, struct mei_device *dev); 297 int mei_cl_flush_queues(struct mei_cl *cl); 298 /** 299 * mei_cl_cmp_id - tells if file private data have same id 300 * 301 * @fe1: private data of 1. file object 302 * @fe2: private data of 2. file object 303 * 304 * returns true - if ids are the same and not NULL 305 */ 306 static inline bool mei_cl_cmp_id(const struct mei_cl *cl1, 307 const struct mei_cl *cl2) 308 { 309 return cl1 && cl2 && 310 (cl1->host_client_id == cl2->host_client_id) && 311 (cl1->me_client_id == cl2->me_client_id); 312 } 313 314 315 316 /* 317 * MEI Host Client Functions 318 */ 319 void mei_host_start_message(struct mei_device *dev); 320 void mei_host_enum_clients_message(struct mei_device *dev); 321 int mei_host_client_properties(struct mei_device *dev); 322 323 /* 324 * MEI interrupt functions prototype 325 */ 326 irqreturn_t mei_interrupt_quick_handler(int irq, void *dev_id); 327 irqreturn_t mei_interrupt_thread_handler(int irq, void *dev_id); 328 void mei_timer(struct work_struct *work); 329 330 /* 331 * MEI input output function prototype 332 */ 333 int mei_ioctl_connect_client(struct file *file, 334 struct mei_connect_client_data *data); 335 336 int mei_start_read(struct mei_device *dev, struct mei_cl *cl); 337 338 int amthi_write(struct mei_device *dev, struct mei_cl_cb *priv_cb); 339 340 int amthi_read(struct mei_device *dev, struct file *file, 341 char __user *ubuf, size_t length, loff_t *offset); 342 343 struct mei_cl_cb *find_amthi_read_list_entry(struct mei_device *dev, 344 struct file *file); 345 346 void mei_run_next_iamthif_cmd(struct mei_device *dev); 347 348 void mei_free_cb_private(struct mei_cl_cb *priv_cb); 349 350 int mei_find_me_client_index(const struct mei_device *dev, uuid_le cuuid); 351 352 /* 353 * Register Access Function 354 */ 355 356 /** 357 * mei_reg_read - Reads 32bit data from the mei device 358 * 359 * @dev: the device structure 360 * @offset: offset from which to read the data 361 * 362 * returns register value (u32) 363 */ 364 static inline u32 mei_reg_read(struct mei_device *dev, unsigned long offset) 365 { 366 return ioread32(dev->mem_addr + offset); 367 } 368 369 /** 370 * mei_reg_write - Writes 32bit data to the mei device 371 * 372 * @dev: the device structure 373 * @offset: offset from which to write the data 374 * @value: register value to write (u32) 375 */ 376 static inline void mei_reg_write(struct mei_device *dev, 377 unsigned long offset, u32 value) 378 { 379 iowrite32(value, dev->mem_addr + offset); 380 } 381 382 /** 383 * mei_hcsr_read - Reads 32bit data from the host CSR 384 * 385 * @dev: the device structure 386 * 387 * returns the byte read. 388 */ 389 static inline u32 mei_hcsr_read(struct mei_device *dev) 390 { 391 return mei_reg_read(dev, H_CSR); 392 } 393 394 /** 395 * mei_mecsr_read - Reads 32bit data from the ME CSR 396 * 397 * @dev: the device structure 398 * 399 * returns ME_CSR_HA register value (u32) 400 */ 401 static inline u32 mei_mecsr_read(struct mei_device *dev) 402 { 403 return mei_reg_read(dev, ME_CSR_HA); 404 } 405 406 /** 407 * get_me_cb_rw - Reads 32bit data from the mei ME_CB_RW register 408 * 409 * @dev: the device structure 410 * 411 * returns ME_CB_RW register value (u32) 412 */ 413 static inline u32 mei_mecbrw_read(struct mei_device *dev) 414 { 415 return mei_reg_read(dev, ME_CB_RW); 416 } 417 418 419 /* 420 * mei interface function prototypes 421 */ 422 void mei_hcsr_set(struct mei_device *dev); 423 void mei_csr_clear_his(struct mei_device *dev); 424 425 void mei_enable_interrupts(struct mei_device *dev); 426 void mei_disable_interrupts(struct mei_device *dev); 427 428 #endif 429