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