]> git.karo-electronics.de Git - linux-beck.git/blob
c02967d0
[linux-beck.git] /
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 #include <linux/mei_cl_bus.h>
25
26 #include "hw.h"
27 #include "hw-me-regs.h"
28
29 /*
30  * watch dog definition
31  */
32 #define MEI_WD_HDR_SIZE       4
33 #define MEI_WD_STOP_MSG_SIZE  MEI_WD_HDR_SIZE
34 #define MEI_WD_START_MSG_SIZE (MEI_WD_HDR_SIZE + 16)
35
36 #define MEI_WD_DEFAULT_TIMEOUT   120  /* seconds */
37 #define MEI_WD_MIN_TIMEOUT       120  /* seconds */
38 #define MEI_WD_MAX_TIMEOUT     65535  /* seconds */
39
40 #define MEI_WD_STOP_TIMEOUT      10 /* msecs */
41
42 #define MEI_WD_STATE_INDEPENDENCE_MSG_SENT       (1 << 0)
43
44 #define MEI_RD_MSG_BUF_SIZE           (128 * sizeof(u32))
45
46
47 /*
48  * AMTHI Client UUID
49  */
50 extern const uuid_le mei_amthif_guid;
51
52 /*
53  * Watchdog Client UUID
54  */
55 extern const uuid_le mei_wd_guid;
56
57 /*
58  * Watchdog independence state message
59  */
60 extern const u8 mei_wd_state_independence_msg[3][4];
61
62 /*
63  * Number of Maximum MEI Clients
64  */
65 #define MEI_CLIENTS_MAX 256
66
67 /*
68  * Number of File descriptors/handles
69  * that can be opened to the driver.
70  *
71  * Limit to 255: 256 Total Clients
72  * minus internal client for MEI Bus Messags
73  */
74 #define  MEI_MAX_OPEN_HANDLE_COUNT (MEI_CLIENTS_MAX - 1)
75
76 /*
77  * Internal Clients Number
78  */
79 #define MEI_HOST_CLIENT_ID_ANY        (-1)
80 #define MEI_HBM_HOST_CLIENT_ID         0 /* not used, just for documentation */
81 #define MEI_WD_HOST_CLIENT_ID          1
82 #define MEI_IAMTHIF_HOST_CLIENT_ID     2
83
84
85 /* File state */
86 enum file_state {
87         MEI_FILE_INITIALIZING = 0,
88         MEI_FILE_CONNECTING,
89         MEI_FILE_CONNECTED,
90         MEI_FILE_DISCONNECTING,
91         MEI_FILE_DISCONNECTED
92 };
93
94 /* MEI device states */
95 enum mei_dev_state {
96         MEI_DEV_INITIALIZING = 0,
97         MEI_DEV_INIT_CLIENTS,
98         MEI_DEV_ENABLED,
99         MEI_DEV_RESETING,
100         MEI_DEV_DISABLED,
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_msg_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_msg_data request_buffer;
188         struct mei_msg_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         /* MEI CL bus data */
214         struct mei_cl_device *device;
215         struct list_head device_link;
216         uuid_le device_uuid;
217 };
218
219 /** struct mei_hw_ops
220  *
221  * @host_is_ready    - query for host readiness
222
223  * @hw_is_ready      - query if hw is ready
224  * @hw_reset         - reset hw
225  * @hw_start         - start hw after reset
226  * @hw_config        - configure hw
227
228  * @intr_clear       - clear pending interrupts
229  * @intr_enable      - enable interrupts
230  * @intr_disable     - disable interrupts
231
232  * @hbuf_free_slots  - query for write buffer empty slots
233  * @hbuf_is_ready    - query if write buffer is empty
234  * @hbuf_max_len     - query for write buffer max len
235
236  * @write            - write a message to FW
237
238  * @rdbuf_full_slots - query how many slots are filled
239
240  * @read_hdr         - get first 4 bytes (header)
241  * @read             - read a buffer from the FW
242  */
243 struct mei_hw_ops {
244
245         bool (*host_is_ready) (struct mei_device *dev);
246
247         bool (*hw_is_ready) (struct mei_device *dev);
248         void (*hw_reset) (struct mei_device *dev, bool enable);
249         int  (*hw_start) (struct mei_device *dev);
250         void (*hw_config) (struct mei_device *dev);
251
252         void (*intr_clear) (struct mei_device *dev);
253         void (*intr_enable) (struct mei_device *dev);
254         void (*intr_disable) (struct mei_device *dev);
255
256         int (*hbuf_free_slots) (struct mei_device *dev);
257         bool (*hbuf_is_ready) (struct mei_device *dev);
258         size_t (*hbuf_max_len) (const struct mei_device *dev);
259
260         int (*write)(struct mei_device *dev,
261                      struct mei_msg_hdr *hdr,
262                      unsigned char *buf);
263
264         int (*rdbuf_full_slots)(struct mei_device *dev);
265
266         u32 (*read_hdr)(const struct mei_device *dev);
267         int (*read) (struct mei_device *dev,
268                      unsigned char *buf, unsigned long len);
269 };
270
271 /* MEI bus API*/
272
273 /**
274  * struct mei_cl_ops - MEI CL device ops
275  * This structure allows ME host clients to implement technology
276  * specific operations.
277  *
278  * @enable: Enable an MEI CL device. Some devices require specific
279  *      HECI commands to initialize completely.
280  * @disable: Disable an MEI CL device.
281  * @send: Tx hook for the device. This allows ME host clients to trap
282  *      the device driver buffers before actually physically
283  *      pushing it to the ME.
284  * @recv: Rx hook for the device. This allows ME host clients to trap the
285  *      ME buffers before forwarding them to the device driver.
286  */
287 struct mei_cl_ops {
288         int (*enable)(struct mei_cl_device *device);
289         int (*disable)(struct mei_cl_device *device);
290         int (*send)(struct mei_cl_device *device, u8 *buf, size_t length);
291         int (*recv)(struct mei_cl_device *device, u8 *buf, size_t length);
292 };
293
294 struct mei_cl_device *mei_cl_add_device(struct mei_device *dev,
295                                         uuid_le uuid, char *name,
296                                         struct mei_cl_ops *ops);
297 void mei_cl_remove_device(struct mei_cl_device *device);
298
299 int __mei_cl_async_send(struct mei_cl *cl, u8 *buf, size_t length);
300 int __mei_cl_send(struct mei_cl *cl, u8 *buf, size_t length);
301 int __mei_cl_recv(struct mei_cl *cl, u8 *buf, size_t length);
302 void mei_cl_bus_rx_event(struct mei_cl *cl);
303 int mei_cl_bus_init(void);
304 void mei_cl_bus_exit(void);
305
306
307 /**
308  * struct mei_cl_device - MEI device handle
309  * An mei_cl_device pointer is returned from mei_add_device()
310  * and links MEI bus clients to their actual ME host client pointer.
311  * Drivers for MEI devices will get an mei_cl_device pointer
312  * when being probed and shall use it for doing ME bus I/O.
313  *
314  * @dev: linux driver model device pointer
315  * @uuid: me client uuid
316  * @cl: mei client
317  * @ops: ME transport ops
318  * @event_cb: Drivers register this callback to get asynchronous ME
319  *      events (e.g. Rx buffer pending) notifications.
320  * @events: Events bitmask sent to the driver.
321  * @priv_data: client private data
322  */
323 struct mei_cl_device {
324         struct device dev;
325
326         struct mei_cl *cl;
327
328         const struct mei_cl_ops *ops;
329
330         struct work_struct event_work;
331         mei_cl_event_cb_t event_cb;
332         void *event_context;
333         unsigned long events;
334
335         void *priv_data;
336 };
337
338 /**
339  * struct mei_device -  MEI private device struct
340
341  * @mem_addr - mem mapped base register address
342
343  * @hbuf_depth - depth of hardware host/write buffer is slots
344  * @hbuf_is_ready - query if the host host/write buffer is ready
345  * @wr_msg - the buffer for hbm control messages
346  * @wr_ext_msg - the buffer for hbm control responses (set in read cycle)
347  */
348 struct mei_device {
349         struct pci_dev *pdev;   /* pointer to pci device struct */
350         /*
351          * lists of queues
352          */
353         /* array of pointers to aio lists */
354         struct mei_cl_cb read_list;             /* driver read queue */
355         struct mei_cl_cb write_list;            /* driver write queue */
356         struct mei_cl_cb write_waiting_list;    /* write waiting queue */
357         struct mei_cl_cb ctrl_wr_list;          /* managed write IOCTL list */
358         struct mei_cl_cb ctrl_rd_list;          /* managed read IOCTL list */
359
360         /*
361          * list of files
362          */
363         struct list_head file_list;
364         long open_handle_count;
365
366         /*
367          * lock for the device
368          */
369         struct mutex device_lock; /* device lock */
370         struct delayed_work timer_work; /* MEI timer delayed work (timeouts) */
371
372         bool recvd_hw_ready;
373         bool recvd_msg;
374
375         /*
376          * waiting queue for receive message from FW
377          */
378         wait_queue_head_t wait_hw_ready;
379         wait_queue_head_t wait_recvd_msg;
380         wait_queue_head_t wait_stop_wd;
381
382         /*
383          * mei device  states
384          */
385         enum mei_dev_state dev_state;
386         enum mei_init_clients_states init_clients_state;
387         u16 init_clients_timer;
388
389         unsigned char rd_msg_buf[MEI_RD_MSG_BUF_SIZE];  /* control messages */
390         u32 rd_msg_hdr;
391
392         /* write buffer */
393         u8 hbuf_depth;
394         bool hbuf_is_ready;
395
396         /* used for control messages */
397         struct {
398                 struct mei_msg_hdr hdr;
399                 unsigned char data[128];
400         } wr_msg;
401
402         struct {
403                 struct mei_msg_hdr hdr;
404                 unsigned char data[4];  /* All HBM messages are 4 bytes */
405         } wr_ext_msg;           /* for control responses */
406
407         struct hbm_version version;
408
409         struct mei_me_client *me_clients; /* Note: memory has to be allocated */
410         DECLARE_BITMAP(me_clients_map, MEI_CLIENTS_MAX);
411         DECLARE_BITMAP(host_clients_map, MEI_CLIENTS_MAX);
412         u8 me_clients_num;
413         u8 me_client_presentation_num;
414         u8 me_client_index;
415
416         struct mei_cl wd_cl;
417         enum mei_wd_states wd_state;
418         bool wd_pending;
419         u16 wd_timeout;
420         unsigned char wd_data[MEI_WD_START_MSG_SIZE];
421
422
423         /* amthif list for cmd waiting */
424         struct mei_cl_cb amthif_cmd_list;
425         /* driver managed amthif list for reading completed amthif cmd data */
426         struct mei_cl_cb amthif_rd_complete_list;
427         struct file *iamthif_file_object;
428         struct mei_cl iamthif_cl;
429         struct mei_cl_cb *iamthif_current_cb;
430         int iamthif_mtu;
431         unsigned long iamthif_timer;
432         u32 iamthif_stall_timer;
433         unsigned char *iamthif_msg_buf; /* Note: memory has to be allocated */
434         u32 iamthif_msg_buf_size;
435         u32 iamthif_msg_buf_index;
436         enum iamthif_states iamthif_state;
437         bool iamthif_flow_control_pending;
438         bool iamthif_ioctl;
439         bool iamthif_canceled;
440
441         struct work_struct init_work;
442
443         /* List of bus devices */
444         struct list_head device_list;
445
446 #if IS_ENABLED(CONFIG_DEBUG_FS)
447         struct dentry *dbgfs_dir;
448 #endif /* CONFIG_DEBUG_FS */
449
450
451         const struct mei_hw_ops *ops;
452         char hw[0] __aligned(sizeof(void *));
453 };
454
455 static inline unsigned long mei_secs_to_jiffies(unsigned long sec)
456 {
457         return msecs_to_jiffies(sec * MSEC_PER_SEC);
458 }
459
460 /**
461  * mei_data2slots - get slots - number of (dwords) from a message length
462  *      + size of the mei header
463  * @length - size of the messages in bytes
464  * returns  - number of slots
465  */
466 static inline u32 mei_data2slots(size_t length)
467 {
468         return DIV_ROUND_UP(sizeof(struct mei_msg_hdr) + length, 4);
469 }
470
471 /*
472  * mei init function prototypes
473  */
474 void mei_device_init(struct mei_device *dev);
475 void mei_reset(struct mei_device *dev, int interrupts);
476 int mei_start(struct mei_device *dev);
477 void mei_stop(struct mei_device *dev);
478
479 /*
480  *  MEI interrupt functions prototype
481  */
482
483 void mei_timer(struct work_struct *work);
484 int mei_irq_read_handler(struct mei_device *dev,
485                 struct mei_cl_cb *cmpl_list, s32 *slots);
486
487 int mei_irq_write_handler(struct mei_device *dev, struct mei_cl_cb *cmpl_list);
488 void mei_irq_compl_handler(struct mei_device *dev, struct mei_cl_cb *cmpl_list);
489
490 /*
491  * AMTHIF - AMT Host Interface Functions
492  */
493 void mei_amthif_reset_params(struct mei_device *dev);
494
495 int mei_amthif_host_init(struct mei_device *dev);
496
497 int mei_amthif_write(struct mei_device *dev, struct mei_cl_cb *priv_cb);
498
499 int mei_amthif_read(struct mei_device *dev, struct file *file,
500                 char __user *ubuf, size_t length, loff_t *offset);
501
502 unsigned int mei_amthif_poll(struct mei_device *dev,
503                 struct file *file, poll_table *wait);
504
505 int mei_amthif_release(struct mei_device *dev, struct file *file);
506
507 struct mei_cl_cb *mei_amthif_find_read_list_entry(struct mei_device *dev,
508                                                 struct file *file);
509
510 void mei_amthif_run_next_cmd(struct mei_device *dev);
511
512
513 int mei_amthif_irq_write_complete(struct mei_device *dev, s32 *slots,
514                         struct mei_cl_cb *cb, struct mei_cl_cb *cmpl_list);
515
516 void mei_amthif_complete(struct mei_device *dev, struct mei_cl_cb *cb);
517 int mei_amthif_irq_read_message(struct mei_cl_cb *complete_list,
518                 struct mei_device *dev, struct mei_msg_hdr *mei_hdr);
519 int mei_amthif_irq_read(struct mei_device *dev, s32 *slots);
520
521
522 int mei_wd_send(struct mei_device *dev);
523 int mei_wd_stop(struct mei_device *dev);
524 int mei_wd_host_init(struct mei_device *dev);
525 /*
526  * mei_watchdog_register  - Registering watchdog interface
527  *   once we got connection to the WD Client
528  * @dev - mei device
529  */
530 void mei_watchdog_register(struct mei_device *dev);
531 /*
532  * mei_watchdog_unregister  - Unregistering watchdog interface
533  * @dev - mei device
534  */
535 void mei_watchdog_unregister(struct mei_device *dev);
536
537 /*
538  * Register Access Function
539  */
540
541 static inline void mei_hw_config(struct mei_device *dev)
542 {
543         dev->ops->hw_config(dev);
544 }
545 static inline void mei_hw_reset(struct mei_device *dev, bool enable)
546 {
547         dev->ops->hw_reset(dev, enable);
548 }
549
550 static inline void mei_hw_start(struct mei_device *dev)
551 {
552         dev->ops->hw_start(dev);
553 }
554
555 static inline void mei_clear_interrupts(struct mei_device *dev)
556 {
557         dev->ops->intr_clear(dev);
558 }
559
560 static inline void mei_enable_interrupts(struct mei_device *dev)
561 {
562         dev->ops->intr_enable(dev);
563 }
564
565 static inline void mei_disable_interrupts(struct mei_device *dev)
566 {
567         dev->ops->intr_disable(dev);
568 }
569
570 static inline bool mei_host_is_ready(struct mei_device *dev)
571 {
572         return dev->ops->host_is_ready(dev);
573 }
574 static inline bool mei_hw_is_ready(struct mei_device *dev)
575 {
576         return dev->ops->hw_is_ready(dev);
577 }
578
579 static inline bool mei_hbuf_is_ready(struct mei_device *dev)
580 {
581         return dev->ops->hbuf_is_ready(dev);
582 }
583
584 static inline int mei_hbuf_empty_slots(struct mei_device *dev)
585 {
586         return dev->ops->hbuf_free_slots(dev);
587 }
588
589 static inline size_t mei_hbuf_max_len(const struct mei_device *dev)
590 {
591         return dev->ops->hbuf_max_len(dev);
592 }
593
594 static inline int mei_write_message(struct mei_device *dev,
595                         struct mei_msg_hdr *hdr,
596                         unsigned char *buf)
597 {
598         return dev->ops->write(dev, hdr, buf);
599 }
600
601 static inline u32 mei_read_hdr(const struct mei_device *dev)
602 {
603         return dev->ops->read_hdr(dev);
604 }
605
606 static inline void mei_read_slots(struct mei_device *dev,
607                      unsigned char *buf, unsigned long len)
608 {
609         dev->ops->read(dev, buf, len);
610 }
611
612 static inline int mei_count_full_read_slots(struct mei_device *dev)
613 {
614         return dev->ops->rdbuf_full_slots(dev);
615 }
616
617 #if IS_ENABLED(CONFIG_DEBUG_FS)
618 int mei_dbgfs_register(struct mei_device *dev, const char *name);
619 void mei_dbgfs_deregister(struct mei_device *dev);
620 #else
621 static inline int mei_dbgfs_register(struct mei_device *dev, const char *name)
622 {
623         return 0;
624 }
625 static inline void mei_dbgfs_deregister(struct mei_device *dev) {}
626 #endif /* CONFIG_DEBUG_FS */
627
628 int mei_register(struct mei_device *dev);
629 void mei_deregister(struct mei_device *dev);
630
631 #define MEI_HDR_FMT "hdr:host=%02d me=%02d len=%d comp=%1d"
632 #define MEI_HDR_PRM(hdr)                  \
633         (hdr)->host_addr, (hdr)->me_addr, \
634         (hdr)->length, (hdr)->msg_complete
635
636 #endif