blob: 87db0976671cabd60e4279d9215d79b44d593e42 [file] [log] [blame]
Oren Weilab841162011-05-15 13:43:41 +03001/*
2 *
3 * Intel Management Engine Interface (Intel MEI) Linux driver
Tomas Winkler733ba912012-02-09 19:25:53 +02004 * Copyright (c) 2003-2012, Intel Corporation.
Oren Weilab841162011-05-15 13:43:41 +03005 *
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>
Oren Weil9ce178e2011-09-07 09:03:09 +030021#include <linux/watchdog.h>
Tomas Winkler744f0f22012-11-11 17:38:02 +020022#include <linux/poll.h>
Tomas Winkler4f3afe12012-05-09 16:38:59 +030023#include <linux/mei.h>
Samuel Ortize5354102013-03-27 17:29:53 +020024#include <linux/mei_cl_bus.h>
Tomas Winkler66ef5ea2012-12-25 19:06:02 +020025
Oren Weilab841162011-05-15 13:43:41 +030026#include "hw.h"
Tomas Winkler9b0d5ef2013-04-18 23:03:48 +030027#include "hbm.h"
Oren Weilab841162011-05-15 13:43:41 +030028
29/*
Oren Weilab841162011-05-15 13:43:41 +030030 * watch dog definition
31 */
Tomas Winkler248ffdf2012-08-16 19:39:42 +030032#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
Tomas Winklerc216fde2012-08-16 19:39:43 +030040#define MEI_WD_STOP_TIMEOUT 10 /* msecs */
41
Oren Weilab841162011-05-15 13:43:41 +030042#define MEI_WD_STATE_INDEPENDENCE_MSG_SENT (1 << 0)
43
Tomas Winkleredf1eed2012-02-09 19:25:54 +020044#define MEI_RD_MSG_BUF_SIZE (128 * sizeof(u32))
45
Oren Weil9ce178e2011-09-07 09:03:09 +030046
47/*
Oren Weilab841162011-05-15 13:43:41 +030048 * AMTHI Client UUID
49 */
Tomas Winkler1a1aca42013-01-08 23:07:21 +020050extern const uuid_le mei_amthif_guid;
Oren Weilab841162011-05-15 13:43:41 +030051
52/*
53 * Watchdog Client UUID
54 */
55extern const uuid_le mei_wd_guid;
56
57/*
Tomas Winkler1e2776c2012-08-24 00:35:58 +030058 * Number of Maximum MEI Clients
59 */
60#define MEI_CLIENTS_MAX 256
61
62/*
Tomas Winkler6adb8ef2014-01-12 00:36:10 +020063 * maximum number of consecutive resets
64 */
65#define MEI_MAX_CONSEC_RESET 3
66
67/*
Oren Weilab841162011-05-15 13:43:41 +030068 * Number of File descriptors/handles
69 * that can be opened to the driver.
70 *
Tomas Winkler781d0d82013-01-08 23:07:22 +020071 * Limit to 255: 256 Total Clients
Alexander Usyskin83ce0742014-01-08 22:31:46 +020072 * minus internal client for MEI Bus Messages
Oren Weilab841162011-05-15 13:43:41 +030073 */
Tomas Winkler781d0d82013-01-08 23:07:22 +020074#define MEI_MAX_OPEN_HANDLE_COUNT (MEI_CLIENTS_MAX - 1)
Oren Weilab841162011-05-15 13:43:41 +030075
Tomas Winkler1d3f3da2012-12-25 19:06:01 +020076/*
77 * Internal Clients Number
78 */
Tomas Winkler781d0d82013-01-08 23:07:22 +020079#define MEI_HOST_CLIENT_ID_ANY (-1)
80#define MEI_HBM_HOST_CLIENT_ID 0 /* not used, just for documentation */
Tomas Winkler1d3f3da2012-12-25 19:06:01 +020081#define MEI_WD_HOST_CLIENT_ID 1
82#define MEI_IAMTHIF_HOST_CLIENT_ID 2
83
Oren Weilab841162011-05-15 13:43:41 +030084
85/* File state */
86enum file_state {
87 MEI_FILE_INITIALIZING = 0,
88 MEI_FILE_CONNECTING,
89 MEI_FILE_CONNECTED,
90 MEI_FILE_DISCONNECTING,
Tomas Winkler3c666182015-05-04 09:43:52 +030091 MEI_FILE_DISCONNECT_REPLY,
92 MEI_FILE_DISCONNECTED,
Oren Weilab841162011-05-15 13:43:41 +030093};
94
95/* MEI device states */
Tomas Winklerb210d752012-08-07 00:03:56 +030096enum mei_dev_state {
97 MEI_DEV_INITIALIZING = 0,
98 MEI_DEV_INIT_CLIENTS,
99 MEI_DEV_ENABLED,
Bill Nottingham0cfee512013-04-19 22:01:36 +0300100 MEI_DEV_RESETTING,
Tomas Winklerb210d752012-08-07 00:03:56 +0300101 MEI_DEV_DISABLED,
Tomas Winklerb210d752012-08-07 00:03:56 +0300102 MEI_DEV_POWER_DOWN,
103 MEI_DEV_POWER_UP
Oren Weilab841162011-05-15 13:43:41 +0300104};
105
Tomas Winklerb210d752012-08-07 00:03:56 +0300106const char *mei_dev_state_str(int state);
107
Oren Weilab841162011-05-15 13:43:41 +0300108enum iamthif_states {
109 MEI_IAMTHIF_IDLE,
110 MEI_IAMTHIF_WRITING,
111 MEI_IAMTHIF_FLOW_CONTROL,
112 MEI_IAMTHIF_READING,
113 MEI_IAMTHIF_READ_COMPLETE
114};
115
116enum mei_file_transaction_states {
117 MEI_IDLE,
118 MEI_WRITING,
119 MEI_WRITE_COMPLETE,
120 MEI_FLOW_CONTROL,
121 MEI_READING,
122 MEI_READ_COMPLETE
123};
124
Tomas Winklerc216fde2012-08-16 19:39:43 +0300125enum mei_wd_states {
126 MEI_WD_IDLE,
127 MEI_WD_RUNNING,
128 MEI_WD_STOPPING,
129};
130
Tomas Winkler4b8960b2012-11-11 17:38:00 +0200131/**
132 * enum mei_cb_file_ops - file operation associated with the callback
Alexander Usyskince231392014-09-29 16:31:50 +0300133 * @MEI_FOP_READ: read
134 * @MEI_FOP_WRITE: write
135 * @MEI_FOP_CONNECT: connect
136 * @MEI_FOP_DISCONNECT: disconnect
137 * @MEI_FOP_DISCONNECT_RSP: disconnect response
Tomas Winkler4b8960b2012-11-11 17:38:00 +0200138 */
139enum mei_cb_file_ops {
140 MEI_FOP_READ = 0,
141 MEI_FOP_WRITE,
Tomas Winkler02a7eec2014-02-12 21:41:51 +0200142 MEI_FOP_CONNECT,
Tomas Winkler5a8373f2014-08-21 14:29:17 +0300143 MEI_FOP_DISCONNECT,
Tomas Winkler6bb948c2014-02-12 21:41:52 +0200144 MEI_FOP_DISCONNECT_RSP,
Oren Weilab841162011-05-15 13:43:41 +0300145};
146
147/*
148 * Intel MEI message data struct
149 */
Tomas Winkler4234a6d2013-04-08 21:56:37 +0300150struct mei_msg_data {
Oren Weilab841162011-05-15 13:43:41 +0300151 u32 size;
Tomas Winkleredf1eed2012-02-09 19:25:54 +0200152 unsigned char *data;
Tomas Winklerf0609392012-09-11 00:43:21 +0300153};
Oren Weilab841162011-05-15 13:43:41 +0300154
Alexander Usyskin04dd3662014-03-31 17:59:23 +0300155/* Maximum number of processed FW status registers */
Alexander Usyskinedca5ea2014-11-19 17:01:38 +0200156#define MEI_FW_STATUS_MAX 6
157/* Minimal buffer for FW status string (8 bytes in dw + space or '\0') */
158#define MEI_FW_STATUS_STR_SZ (MEI_FW_STATUS_MAX * (8 + 1))
159
Alexander Usyskin04dd3662014-03-31 17:59:23 +0300160
161/*
162 * struct mei_fw_status - storage of FW status data
163 *
Alexander Usyskina8605ea2014-09-29 16:31:49 +0300164 * @count: number of actually available elements in array
165 * @status: FW status registers
Alexander Usyskin04dd3662014-03-31 17:59:23 +0300166 */
167struct mei_fw_status {
168 int count;
169 u32 status[MEI_FW_STATUS_MAX];
170};
171
Tomas Winklerdb7da792012-12-25 19:06:05 +0200172/**
173 * struct mei_me_client - representation of me (fw) client
174 *
Alexander Usyskina8605ea2014-09-29 16:31:49 +0300175 * @list: link in me client list
Tomas Winkler79563db2015-01-11 00:07:16 +0200176 * @refcnt: struct reference count
Alexander Usyskina8605ea2014-09-29 16:31:49 +0300177 * @props: client properties
178 * @client_id: me client id
179 * @mei_flow_ctrl_creds: flow control credits
Tomas Winklerdb7da792012-12-25 19:06:05 +0200180 */
181struct mei_me_client {
Tomas Winkler5ca2d382014-08-21 14:29:13 +0300182 struct list_head list;
Tomas Winkler79563db2015-01-11 00:07:16 +0200183 struct kref refcnt;
Tomas Winklerdb7da792012-12-25 19:06:05 +0200184 struct mei_client_properties props;
185 u8 client_id;
186 u8 mei_flow_ctrl_creds;
187};
188
Oren Weilab841162011-05-15 13:43:41 +0300189
Tomas Winklerdb3ed432012-11-11 17:37:59 +0200190struct mei_cl;
191
Tomas Winkler4b8960b2012-11-11 17:38:00 +0200192/**
Tomas Winklerdb3ed432012-11-11 17:37:59 +0200193 * struct mei_cl_cb - file operation callback structure
194 *
Alexander Usyskina8605ea2014-09-29 16:31:49 +0300195 * @list: link in callback queue
196 * @cl: file client who is running this operation
197 * @fop_type: file operation type
Tomas Winkler5db75142015-02-10 10:39:42 +0200198 * @buf: buffer for data associated with the callback
Alexander Usyskince231392014-09-29 16:31:50 +0300199 * @buf_idx: last read index
200 * @read_time: last read operation time stamp (iamthif)
201 * @file_object: pointer to file structure
Tomas Winkler3d33ff22015-02-10 10:39:36 +0200202 * @status: io status of the cb
Alexander Usyskince231392014-09-29 16:31:50 +0300203 * @internal: communication between driver and FW flag
Tomas Winkler86601722015-02-10 10:39:40 +0200204 * @completed: the transfer or reception has completed
Tomas Winklerdb3ed432012-11-11 17:37:59 +0200205 */
Oren Weilab841162011-05-15 13:43:41 +0300206struct mei_cl_cb {
Tomas Winklerfb601ad2012-10-15 12:06:48 +0200207 struct list_head list;
Tomas Winklerdb3ed432012-11-11 17:37:59 +0200208 struct mei_cl *cl;
Tomas Winkler4b8960b2012-11-11 17:38:00 +0200209 enum mei_cb_file_ops fop_type;
Tomas Winkler5db75142015-02-10 10:39:42 +0200210 struct mei_msg_data buf;
Tomas Winklerebb108ef2012-10-09 16:50:16 +0200211 unsigned long buf_idx;
Oren Weilab841162011-05-15 13:43:41 +0300212 unsigned long read_time;
213 struct file *file_object;
Tomas Winkler3d33ff22015-02-10 10:39:36 +0200214 int status;
Tomas Winkler479327f2013-12-17 15:56:56 +0200215 u32 internal:1;
Tomas Winkler86601722015-02-10 10:39:40 +0200216 u32 completed:1;
Oren Weilab841162011-05-15 13:43:41 +0300217};
218
Alexander Usyskince231392014-09-29 16:31:50 +0300219/**
220 * struct mei_cl - me client host representation
221 * carried in file->private_data
222 *
223 * @link: link in the clients list
224 * @dev: mei parent device
225 * @state: file operation state
226 * @tx_wait: wait queue for tx completion
227 * @rx_wait: wait queue for rx completion
228 * @wait: wait queue for management operation
229 * @status: connection status
Alexander Usyskind49ed642015-05-04 09:43:54 +0300230 * @me_cl: fw client connected
Alexander Usyskince231392014-09-29 16:31:50 +0300231 * @host_client_id: host id
Alexander Usyskince231392014-09-29 16:31:50 +0300232 * @mei_flow_ctrl_creds: transmit flow credentials
233 * @timer_count: watchdog timer for operation completion
Alexander Usyskind49ed642015-05-04 09:43:54 +0300234 * @reserved: reserved for alignment
Alexander Usyskince231392014-09-29 16:31:50 +0300235 * @writing_state: state of the tx
Tomas Winklera9bed612015-02-10 10:39:46 +0200236 * @rd_pending: pending read credits
237 * @rd_completed: completed read
Alexander Usyskince231392014-09-29 16:31:50 +0300238 *
239 * @device: device on the mei client bus
240 * @device_link: link to bus clients
241 */
Oren Weilab841162011-05-15 13:43:41 +0300242struct mei_cl {
243 struct list_head link;
244 struct mei_device *dev;
245 enum file_state state;
246 wait_queue_head_t tx_wait;
247 wait_queue_head_t rx_wait;
248 wait_queue_head_t wait;
Oren Weilab841162011-05-15 13:43:41 +0300249 int status;
Alexander Usyskind49ed642015-05-04 09:43:54 +0300250 struct mei_me_client *me_cl;
Oren Weilab841162011-05-15 13:43:41 +0300251 u8 host_client_id;
Oren Weilab841162011-05-15 13:43:41 +0300252 u8 mei_flow_ctrl_creds;
253 u8 timer_count;
Alexander Usyskind49ed642015-05-04 09:43:54 +0300254 u8 reserved;
Oren Weilab841162011-05-15 13:43:41 +0300255 enum mei_file_transaction_states writing_state;
Tomas Winklera9bed612015-02-10 10:39:46 +0200256 struct list_head rd_pending;
257 struct list_head rd_completed;
Samuel Ortiza7b71bc2013-03-27 17:29:56 +0200258
259 /* MEI CL bus data */
260 struct mei_cl_device *device;
261 struct list_head device_link;
Oren Weilab841162011-05-15 13:43:41 +0300262};
263
Tomas Winkler827eef52013-02-06 14:06:41 +0200264/** struct mei_hw_ops
265 *
Alexander Usyskina8605ea2014-09-29 16:31:49 +0300266 * @host_is_ready : query for host readiness
Tomas Winkler827eef52013-02-06 14:06:41 +0200267
Alexander Usyskina8605ea2014-09-29 16:31:49 +0300268 * @hw_is_ready : query if hw is ready
269 * @hw_reset : reset hw
270 * @hw_start : start hw after reset
271 * @hw_config : configure hw
Tomas Winkler827eef52013-02-06 14:06:41 +0200272
Alexander Usyskina8605ea2014-09-29 16:31:49 +0300273 * @fw_status : get fw status registers
274 * @pg_state : power gating state of the device
275 * @pg_is_enabled : is power gating enabled
Tomas Winkleree7e5af2014-03-18 22:51:58 +0200276
Alexander Usyskina8605ea2014-09-29 16:31:49 +0300277 * @intr_clear : clear pending interrupts
278 * @intr_enable : enable interrupts
279 * @intr_disable : disable interrupts
Tomas Winkler827eef52013-02-06 14:06:41 +0200280
Alexander Usyskina8605ea2014-09-29 16:31:49 +0300281 * @hbuf_free_slots : query for write buffer empty slots
282 * @hbuf_is_ready : query if write buffer is empty
283 * @hbuf_max_len : query for write buffer max len
Tomas Winkler827eef52013-02-06 14:06:41 +0200284
Alexander Usyskina8605ea2014-09-29 16:31:49 +0300285 * @write : write a message to FW
Tomas Winkler827eef52013-02-06 14:06:41 +0200286
Alexander Usyskina8605ea2014-09-29 16:31:49 +0300287 * @rdbuf_full_slots : query how many slots are filled
Tomas Winkler827eef52013-02-06 14:06:41 +0200288
Alexander Usyskina8605ea2014-09-29 16:31:49 +0300289 * @read_hdr : get first 4 bytes (header)
290 * @read : read a buffer from the FW
Tomas Winkler827eef52013-02-06 14:06:41 +0200291 */
292struct mei_hw_ops {
293
Tomas Winklerd63b3092014-03-16 14:35:54 +0200294 bool (*host_is_ready)(struct mei_device *dev);
Tomas Winkler827eef52013-02-06 14:06:41 +0200295
Tomas Winklerd63b3092014-03-16 14:35:54 +0200296 bool (*hw_is_ready)(struct mei_device *dev);
297 int (*hw_reset)(struct mei_device *dev, bool enable);
298 int (*hw_start)(struct mei_device *dev);
299 void (*hw_config)(struct mei_device *dev);
Tomas Winkler827eef52013-02-06 14:06:41 +0200300
Tomas Winkler1bd30b62014-09-29 16:31:43 +0300301
302 int (*fw_status)(struct mei_device *dev, struct mei_fw_status *fw_sts);
Tomas Winkler964a2332014-03-18 22:51:59 +0200303 enum mei_pg_state (*pg_state)(struct mei_device *dev);
Tomas Winkleree7e5af2014-03-18 22:51:58 +0200304 bool (*pg_is_enabled)(struct mei_device *dev);
305
Tomas Winklerd63b3092014-03-16 14:35:54 +0200306 void (*intr_clear)(struct mei_device *dev);
307 void (*intr_enable)(struct mei_device *dev);
308 void (*intr_disable)(struct mei_device *dev);
Tomas Winkler827eef52013-02-06 14:06:41 +0200309
Tomas Winklerd63b3092014-03-16 14:35:54 +0200310 int (*hbuf_free_slots)(struct mei_device *dev);
311 bool (*hbuf_is_ready)(struct mei_device *dev);
312 size_t (*hbuf_max_len)(const struct mei_device *dev);
Tomas Winkler827eef52013-02-06 14:06:41 +0200313
314 int (*write)(struct mei_device *dev,
315 struct mei_msg_hdr *hdr,
316 unsigned char *buf);
317
318 int (*rdbuf_full_slots)(struct mei_device *dev);
319
320 u32 (*read_hdr)(const struct mei_device *dev);
Tomas Winklerd63b3092014-03-16 14:35:54 +0200321 int (*read)(struct mei_device *dev,
Tomas Winkler827eef52013-02-06 14:06:41 +0200322 unsigned char *buf, unsigned long len);
323};
324
Samuel Ortize5354102013-03-27 17:29:53 +0200325/* MEI bus API*/
Samuel Ortiz3e833292013-03-27 17:29:55 +0200326
327/**
Samuel Ortize46980a2013-04-09 01:51:38 +0300328 * struct mei_cl_ops - MEI CL device ops
Samuel Ortiz3e833292013-03-27 17:29:55 +0200329 * This structure allows ME host clients to implement technology
Samuel Ortize46980a2013-04-09 01:51:38 +0300330 * specific operations.
Samuel Ortiz3e833292013-03-27 17:29:55 +0200331 *
Samuel Ortize46980a2013-04-09 01:51:38 +0300332 * @enable: Enable an MEI CL device. Some devices require specific
333 * HECI commands to initialize completely.
334 * @disable: Disable an MEI CL device.
Samuel Ortiz3e833292013-03-27 17:29:55 +0200335 * @send: Tx hook for the device. This allows ME host clients to trap
336 * the device driver buffers before actually physically
337 * pushing it to the ME.
338 * @recv: Rx hook for the device. This allows ME host clients to trap the
339 * ME buffers before forwarding them to the device driver.
340 */
Samuel Ortize46980a2013-04-09 01:51:38 +0300341struct mei_cl_ops {
342 int (*enable)(struct mei_cl_device *device);
343 int (*disable)(struct mei_cl_device *device);
Samuel Ortiz3e833292013-03-27 17:29:55 +0200344 int (*send)(struct mei_cl_device *device, u8 *buf, size_t length);
345 int (*recv)(struct mei_cl_device *device, u8 *buf, size_t length);
346};
347
Samuel Ortize46980a2013-04-09 01:51:38 +0300348struct mei_cl_device *mei_cl_add_device(struct mei_device *dev,
Alexander Usyskind49ed642015-05-04 09:43:54 +0300349 struct mei_me_client *me_cl,
350 struct mei_cl *cl,
351 char *name,
Samuel Ortize46980a2013-04-09 01:51:38 +0300352 struct mei_cl_ops *ops);
353void mei_cl_remove_device(struct mei_cl_device *device);
354
Tomas Winkler39db74c2014-11-27 14:07:28 +0200355ssize_t __mei_cl_async_send(struct mei_cl *cl, u8 *buf, size_t length);
356ssize_t __mei_cl_send(struct mei_cl *cl, u8 *buf, size_t length);
357ssize_t __mei_cl_recv(struct mei_cl *cl, u8 *buf, size_t length);
Samuel Ortizcf3baef2013-03-27 17:29:57 +0200358void mei_cl_bus_rx_event(struct mei_cl *cl);
Tomas Winkler48705692014-02-17 15:13:19 +0200359void mei_cl_bus_remove_devices(struct mei_device *dev);
Samuel Ortizcf3baef2013-03-27 17:29:57 +0200360int mei_cl_bus_init(void);
361void mei_cl_bus_exit(void);
Tomas Winklera176c242014-11-05 18:18:52 +0200362struct mei_cl *mei_cl_bus_find_cl_by_uuid(struct mei_device *dev, uuid_le uuid);
Samuel Ortizcf3baef2013-03-27 17:29:57 +0200363
364
Samuel Ortize5354102013-03-27 17:29:53 +0200365/**
366 * struct mei_cl_device - MEI device handle
367 * An mei_cl_device pointer is returned from mei_add_device()
368 * and links MEI bus clients to their actual ME host client pointer.
369 * Drivers for MEI devices will get an mei_cl_device pointer
370 * when being probed and shall use it for doing ME bus I/O.
371 *
372 * @dev: linux driver model device pointer
Alexander Usyskind49ed642015-05-04 09:43:54 +0300373 * @me_cl: me client
Samuel Ortize5354102013-03-27 17:29:53 +0200374 * @cl: mei client
Samuel Ortiz3e833292013-03-27 17:29:55 +0200375 * @ops: ME transport ops
Alexander Usyskince231392014-09-29 16:31:50 +0300376 * @event_work: async work to execute event callback
Samuel Ortiz3e833292013-03-27 17:29:55 +0200377 * @event_cb: Drivers register this callback to get asynchronous ME
378 * events (e.g. Rx buffer pending) notifications.
Alexander Usyskince231392014-09-29 16:31:50 +0300379 * @event_context: event callback run context
Samuel Ortiz3e833292013-03-27 17:29:55 +0200380 * @events: Events bitmask sent to the driver.
Samuel Ortize5354102013-03-27 17:29:53 +0200381 * @priv_data: client private data
382 */
383struct mei_cl_device {
384 struct device dev;
385
Alexander Usyskind49ed642015-05-04 09:43:54 +0300386 struct mei_me_client *me_cl;
Samuel Ortize5354102013-03-27 17:29:53 +0200387 struct mei_cl *cl;
388
Samuel Ortize46980a2013-04-09 01:51:38 +0300389 const struct mei_cl_ops *ops;
Samuel Ortiz3e833292013-03-27 17:29:55 +0200390
391 struct work_struct event_work;
392 mei_cl_event_cb_t event_cb;
393 void *event_context;
394 unsigned long events;
395
Samuel Ortize5354102013-03-27 17:29:53 +0200396 void *priv_data;
397};
398
Tomas Winkler964a2332014-03-18 22:51:59 +0200399
Alexander Usyskince231392014-09-29 16:31:50 +0300400/**
Tomas Winkler964a2332014-03-18 22:51:59 +0200401 * enum mei_pg_event - power gating transition events
402 *
403 * @MEI_PG_EVENT_IDLE: the driver is not in power gating transition
404 * @MEI_PG_EVENT_WAIT: the driver is waiting for a pg event to complete
405 * @MEI_PG_EVENT_RECEIVED: the driver received pg event
406 */
407enum mei_pg_event {
408 MEI_PG_EVENT_IDLE,
409 MEI_PG_EVENT_WAIT,
410 MEI_PG_EVENT_RECEIVED,
411};
412
413/**
414 * enum mei_pg_state - device internal power gating state
415 *
416 * @MEI_PG_OFF: device is not power gated - it is active
417 * @MEI_PG_ON: device is power gated - it is in lower power state
418 */
419enum mei_pg_state {
420 MEI_PG_OFF = 0,
421 MEI_PG_ON = 1,
422};
423
Alexander Usyskin1beeb4b2014-09-29 16:31:33 +0300424const char *mei_pg_state_str(enum mei_pg_state state);
425
Tomas Winkler24aadc82012-06-25 23:46:27 +0300426/**
Tomas Winkler5fb54fb2012-11-18 15:13:15 +0200427 * struct mei_device - MEI private device struct
Alexander Usyskince231392014-09-29 16:31:50 +0300428 *
Alexander Usyskina8605ea2014-09-29 16:31:49 +0300429 * @dev : device on a bus
430 * @cdev : character device
431 * @minor : minor number allocated for device
Alexander Usyskinf3d8e872014-06-23 15:10:35 +0300432 *
Alexander Usyskince231392014-09-29 16:31:50 +0300433 * @write_list : write pending list
434 * @write_waiting_list : write completion list
435 * @ctrl_wr_list : pending control write list
436 * @ctrl_rd_list : pending control read list
Tomas Winklerbae1cc72014-08-21 14:29:21 +0300437 *
Alexander Usyskince231392014-09-29 16:31:50 +0300438 * @file_list : list of opened handles
439 * @open_handle_count: number of opened handles
440 *
441 * @device_lock : big device lock
442 * @timer_work : MEI timer delayed work (timeouts)
443 *
444 * @recvd_hw_ready : hw ready message received flag
445 *
446 * @wait_hw_ready : wait queue for receive HW ready message form FW
447 * @wait_pg : wait queue for receive PG message from FW
448 * @wait_hbm_start : wait queue for receive HBM start message from FW
449 * @wait_stop_wd : wait queue for receive WD stop message from FW
450 *
451 * @reset_count : number of consecutive resets
452 * @dev_state : device state
453 * @hbm_state : state of host bus message protocol
454 * @init_clients_timer : HBM init handshake timeout
Tomas Winklerbae1cc72014-08-21 14:29:21 +0300455 *
Alexander Usyskina8605ea2014-09-29 16:31:49 +0300456 * @pg_event : power gating event
Alexander Usyskince231392014-09-29 16:31:50 +0300457 * @pg_domain : runtime PM domain
458 *
459 * @rd_msg_buf : control messages buffer
460 * @rd_msg_hdr : read message header storage
461 *
Alexander Usyskina8605ea2014-09-29 16:31:49 +0300462 * @hbuf_depth : depth of hardware host/write buffer is slots
463 * @hbuf_is_ready : query if the host host/write buffer is ready
464 * @wr_msg : the buffer for hbm control messages
Alexander Usyskince231392014-09-29 16:31:50 +0300465 *
466 * @version : HBM protocol version in use
467 * @hbm_f_pg_supported : hbm feature pgi protocol
468 *
Tomas Winklerb7d88512015-02-10 10:39:31 +0200469 * @me_clients_rwsem: rw lock over me_clients list
Alexander Usyskince231392014-09-29 16:31:50 +0300470 * @me_clients : list of FW clients
471 * @me_clients_map : FW clients bit map
472 * @host_clients_map : host clients id pool
473 * @me_client_index : last FW client index in enumeration
474 *
475 * @wd_cl : watchdog client
476 * @wd_state : watchdog client state
477 * @wd_pending : watchdog command is pending
478 * @wd_timeout : watchdog expiration timeout
479 * @wd_data : watchdog message buffer
480 *
481 * @amthif_cmd_list : amthif list for cmd waiting
482 * @amthif_rd_complete_list : amthif list for reading completed cmd data
483 * @iamthif_file_object : file for current amthif operation
484 * @iamthif_cl : amthif host client
485 * @iamthif_current_cb : amthif current operation callback
486 * @iamthif_open_count : number of opened amthif connections
487 * @iamthif_mtu : amthif client max message length
488 * @iamthif_timer : time stamp of current amthif command completion
489 * @iamthif_stall_timer : timer to detect amthif hang
Alexander Usyskince231392014-09-29 16:31:50 +0300490 * @iamthif_state : amthif processor state
Alexander Usyskince231392014-09-29 16:31:50 +0300491 * @iamthif_canceled : current amthif command is canceled
492 *
493 * @init_work : work item for the device init
494 * @reset_work : work item for the device reset
495 *
496 * @device_list : mei client bus list
497 *
498 * @dbgfs_dir : debugfs mei root directory
499 *
500 * @ops: : hw specific operations
501 * @hw : hw specific data
Tomas Winkler24aadc82012-06-25 23:46:27 +0300502 */
Oren Weilab841162011-05-15 13:43:41 +0300503struct mei_device {
Tomas Winkler3a7e9b62014-09-29 16:31:41 +0300504 struct device *dev;
Alexander Usyskinf3d8e872014-06-23 15:10:35 +0300505 struct cdev cdev;
506 int minor;
507
Alexander Usyskince231392014-09-29 16:31:50 +0300508 struct mei_cl_cb write_list;
509 struct mei_cl_cb write_waiting_list;
510 struct mei_cl_cb ctrl_wr_list;
511 struct mei_cl_cb ctrl_rd_list;
Oren Weilab841162011-05-15 13:43:41 +0300512
Oren Weilab841162011-05-15 13:43:41 +0300513 struct list_head file_list;
Tomas Winklereb9af0a2011-05-25 17:28:22 +0300514 long open_handle_count;
Tomas Winklerfecb0d52012-12-25 19:06:04 +0200515
Alexander Usyskince231392014-09-29 16:31:50 +0300516 struct mutex device_lock;
517 struct delayed_work timer_work;
Tomas Winkleraafae7e2013-03-11 18:27:03 +0200518
519 bool recvd_hw_ready;
Oren Weilab841162011-05-15 13:43:41 +0300520 /*
521 * waiting queue for receive message from FW
522 */
Tomas Winkleraafae7e2013-03-11 18:27:03 +0200523 wait_queue_head_t wait_hw_ready;
Tomas Winkler4fcbc992014-03-18 22:51:55 +0200524 wait_queue_head_t wait_pg;
Alexander Usyskincb02efc2014-08-21 14:29:19 +0300525 wait_queue_head_t wait_hbm_start;
Oren Weilab841162011-05-15 13:43:41 +0300526 wait_queue_head_t wait_stop_wd;
527
528 /*
529 * mei device states
530 */
Tomas Winkler6adb8ef2014-01-12 00:36:10 +0200531 unsigned long reset_count;
Tomas Winklerb210d752012-08-07 00:03:56 +0300532 enum mei_dev_state dev_state;
Tomas Winkler9b0d5ef2013-04-18 23:03:48 +0300533 enum mei_hbm_state hbm_state;
Oren Weilab841162011-05-15 13:43:41 +0300534 u16 init_clients_timer;
Oren Weilab841162011-05-15 13:43:41 +0300535
Tomas Winkler964a2332014-03-18 22:51:59 +0200536 /*
537 * Power Gating support
538 */
539 enum mei_pg_event pg_event;
Rafael J. Wysockibbd6d0502014-12-04 22:43:07 +0100540#ifdef CONFIG_PM
Tomas Winklere13fa902014-03-18 22:52:05 +0200541 struct dev_pm_domain pg_domain;
Rafael J. Wysockibbd6d0502014-12-04 22:43:07 +0100542#endif /* CONFIG_PM */
Tomas Winkler964a2332014-03-18 22:51:59 +0200543
Alexander Usyskince231392014-09-29 16:31:50 +0300544 unsigned char rd_msg_buf[MEI_RD_MSG_BUF_SIZE];
Oren Weilab841162011-05-15 13:43:41 +0300545 u32 rd_msg_hdr;
Tomas Winklere46f1872012-12-25 19:06:10 +0200546
Tomas Winkler330dd7d2013-02-06 14:06:43 +0200547 /* write buffer */
548 u8 hbuf_depth;
549 bool hbuf_is_ready;
550
Tomas Winklere46f1872012-12-25 19:06:10 +0200551 /* used for control messages */
552 struct {
553 struct mei_msg_hdr hdr;
554 unsigned char data[128];
555 } wr_msg;
556
Oren Weilab841162011-05-15 13:43:41 +0300557 struct hbm_version version;
Tomas Winklerbae1cc72014-08-21 14:29:21 +0300558 unsigned int hbm_f_pg_supported:1;
Oren Weilab841162011-05-15 13:43:41 +0300559
Tomas Winklerb7d88512015-02-10 10:39:31 +0200560 struct rw_semaphore me_clients_rwsem;
Tomas Winkler5ca2d382014-08-21 14:29:13 +0300561 struct list_head me_clients;
Oren Weilab841162011-05-15 13:43:41 +0300562 DECLARE_BITMAP(me_clients_map, MEI_CLIENTS_MAX);
563 DECLARE_BITMAP(host_clients_map, MEI_CLIENTS_MAX);
Tomas Winkler1aee3512013-09-02 13:29:45 +0300564 unsigned long me_client_index;
Oren Weilab841162011-05-15 13:43:41 +0300565
Tomas Winklereb9af0a2011-05-25 17:28:22 +0300566 struct mei_cl wd_cl;
Tomas Winklerc216fde2012-08-16 19:39:43 +0300567 enum mei_wd_states wd_state;
Tomas Winklereb9af0a2011-05-25 17:28:22 +0300568 bool wd_pending;
Tomas Winklerc216fde2012-08-16 19:39:43 +0300569 u16 wd_timeout;
Tomas Winkler248ffdf2012-08-16 19:39:42 +0300570 unsigned char wd_data[MEI_WD_START_MSG_SIZE];
Oren Weilab841162011-05-15 13:43:41 +0300571
572
Tomas Winklere773efc2012-11-11 17:37:58 +0200573 /* amthif list for cmd waiting */
574 struct mei_cl_cb amthif_cmd_list;
575 /* driver managed amthif list for reading completed amthif cmd data */
576 struct mei_cl_cb amthif_rd_complete_list;
Oren Weilab841162011-05-15 13:43:41 +0300577 struct file *iamthif_file_object;
578 struct mei_cl iamthif_cl;
Tomas Winklereb9af0a2011-05-25 17:28:22 +0300579 struct mei_cl_cb *iamthif_current_cb;
Tomas Winkler22f96a02013-09-16 23:44:47 +0300580 long iamthif_open_count;
Oren Weilab841162011-05-15 13:43:41 +0300581 int iamthif_mtu;
582 unsigned long iamthif_timer;
583 u32 iamthif_stall_timer;
Oren Weilab841162011-05-15 13:43:41 +0300584 enum iamthif_states iamthif_state;
Tomas Winklereb9af0a2011-05-25 17:28:22 +0300585 bool iamthif_canceled;
Samuel Ortizc1174c02012-11-18 15:13:20 +0200586
587 struct work_struct init_work;
Tomas Winkler544f9462014-01-08 20:19:21 +0200588 struct work_struct reset_work;
Tomas Winkler827eef52013-02-06 14:06:41 +0200589
Samuel Ortiza7b71bc2013-03-27 17:29:56 +0200590 /* List of bus devices */
591 struct list_head device_list;
592
Tomas Winkler30e53bb2013-04-05 22:10:34 +0300593#if IS_ENABLED(CONFIG_DEBUG_FS)
594 struct dentry *dbgfs_dir;
595#endif /* CONFIG_DEBUG_FS */
596
597
Tomas Winkler827eef52013-02-06 14:06:41 +0200598 const struct mei_hw_ops *ops;
Tomas Winkler52c34562013-02-06 14:06:40 +0200599 char hw[0] __aligned(sizeof(void *));
Oren Weilab841162011-05-15 13:43:41 +0300600};
601
Tomas Winkler3870c322012-11-01 21:17:14 +0200602static inline unsigned long mei_secs_to_jiffies(unsigned long sec)
603{
604 return msecs_to_jiffies(sec * MSEC_PER_SEC);
605}
606
Tomas Winklerc8c8d082013-03-11 18:27:02 +0200607/**
608 * mei_data2slots - get slots - number of (dwords) from a message length
609 * + size of the mei header
Alexander Usyskince231392014-09-29 16:31:50 +0300610 *
Alexander Usyskina8605ea2014-09-29 16:31:49 +0300611 * @length: size of the messages in bytes
612 *
613 * Return: number of slots
Tomas Winklerc8c8d082013-03-11 18:27:02 +0200614 */
615static inline u32 mei_data2slots(size_t length)
616{
617 return DIV_ROUND_UP(sizeof(struct mei_msg_hdr) + length, 4);
618}
619
Tomas Winkler10ee9072013-11-11 13:26:08 +0200620/**
Alexander Usyskince231392014-09-29 16:31:50 +0300621 * mei_slots2data - get data in slots - bytes from slots
622 *
Alexander Usyskina8605ea2014-09-29 16:31:49 +0300623 * @slots: number of available slots
Alexander Usyskince231392014-09-29 16:31:50 +0300624 *
Alexander Usyskina8605ea2014-09-29 16:31:49 +0300625 * Return: number of bytes in slots
Tomas Winkler10ee9072013-11-11 13:26:08 +0200626 */
627static inline u32 mei_slots2data(int slots)
628{
629 return slots * 4;
630}
631
Oren Weilab841162011-05-15 13:43:41 +0300632/*
633 * mei init function prototypes
634 */
Tomas Winkler3a7e9b62014-09-29 16:31:41 +0300635void mei_device_init(struct mei_device *dev,
636 struct device *device,
637 const struct mei_hw_ops *hw_ops);
Tomas Winkler33ec0822014-01-12 00:36:09 +0200638int mei_reset(struct mei_device *dev);
Tomas Winklerc4d589b2013-03-27 16:58:28 +0200639int mei_start(struct mei_device *dev);
Tomas Winkler33ec0822014-01-12 00:36:09 +0200640int mei_restart(struct mei_device *dev);
Tomas Winkler7cb035d2013-03-10 13:56:08 +0200641void mei_stop(struct mei_device *dev);
Tomas Winklerdc844b02013-11-11 13:26:06 +0200642void mei_cancel_work(struct mei_device *dev);
Tomas Winklerc95efb72011-05-25 17:28:21 +0300643
Tomas Winklerc95efb72011-05-25 17:28:21 +0300644/*
645 * MEI interrupt functions prototype
Oren Weilab841162011-05-15 13:43:41 +0300646 */
Tomas Winkler06ecd642013-02-06 14:06:42 +0200647
Oren Weila61c6532011-09-07 09:03:13 +0300648void mei_timer(struct work_struct *work);
Tomas Winkler06ecd642013-02-06 14:06:42 +0200649int mei_irq_read_handler(struct mei_device *dev,
650 struct mei_cl_cb *cmpl_list, s32 *slots);
651
652int mei_irq_write_handler(struct mei_device *dev, struct mei_cl_cb *cmpl_list);
Tomas Winkler4c6e22b2013-03-17 11:41:20 +0200653void mei_irq_compl_handler(struct mei_device *dev, struct mei_cl_cb *cmpl_list);
Oren Weilab841162011-05-15 13:43:41 +0300654
655/*
Tomas Winkler19838fb2012-11-01 21:17:15 +0200656 * AMTHIF - AMT Host Interface Functions
657 */
658void mei_amthif_reset_params(struct mei_device *dev);
659
Alexander Usyskind49ed642015-05-04 09:43:54 +0300660int mei_amthif_host_init(struct mei_device *dev, struct mei_me_client *me_cl);
Tomas Winkler19838fb2012-11-01 21:17:15 +0200661
Tomas Winkler19838fb2012-11-01 21:17:15 +0200662int mei_amthif_read(struct mei_device *dev, struct file *file,
Tomas Winkler744f0f22012-11-11 17:38:02 +0200663 char __user *ubuf, size_t length, loff_t *offset);
664
665unsigned int mei_amthif_poll(struct mei_device *dev,
666 struct file *file, poll_table *wait);
Oren Weilab841162011-05-15 13:43:41 +0300667
Tomas Winklera562d5c2012-11-11 17:38:01 +0200668int mei_amthif_release(struct mei_device *dev, struct file *file);
669
Tomas Winkler19838fb2012-11-01 21:17:15 +0200670struct mei_cl_cb *mei_amthif_find_read_list_entry(struct mei_device *dev,
Oren Weilab841162011-05-15 13:43:41 +0300671 struct file *file);
672
Tomas Winkler86601722015-02-10 10:39:40 +0200673int mei_amthif_write(struct mei_cl *cl, struct mei_cl_cb *cb);
674int mei_amthif_run_next_cmd(struct mei_device *dev);
Tomas Winkler9d098192014-02-19 17:35:48 +0200675int mei_amthif_irq_write(struct mei_cl *cl, struct mei_cl_cb *cb,
676 struct mei_cl_cb *cmpl_list);
Tomas Winkler5ceb46e2013-04-19 21:16:53 +0300677
678void mei_amthif_complete(struct mei_device *dev, struct mei_cl_cb *cb);
Tomas Winklerdb4756f2015-02-10 10:39:37 +0200679int mei_amthif_irq_read_msg(struct mei_cl *cl,
Tomas Winkler5ceb46e2013-04-19 21:16:53 +0300680 struct mei_msg_hdr *mei_hdr,
681 struct mei_cl_cb *complete_list);
682int mei_amthif_irq_read(struct mei_device *dev, s32 *slots);
683
Samuel Ortiz59fcd7c2013-04-11 03:03:29 +0200684/*
685 * NFC functions
686 */
Alexander Usyskind49ed642015-05-04 09:43:54 +0300687int mei_nfc_host_init(struct mei_device *dev, struct mei_me_client *me_cl);
Tomas Winklerdc844b02013-11-11 13:26:06 +0200688void mei_nfc_host_exit(struct mei_device *dev);
Samuel Ortiz59fcd7c2013-04-11 03:03:29 +0200689
690/*
691 * NFC Client UUID
692 */
693extern const uuid_le mei_nfc_guid;
Oren Weilab841162011-05-15 13:43:41 +0300694
Tomas Winkler37e7d6e2013-01-08 23:07:16 +0200695int mei_wd_send(struct mei_device *dev);
696int mei_wd_stop(struct mei_device *dev);
Alexander Usyskind49ed642015-05-04 09:43:54 +0300697int mei_wd_host_init(struct mei_device *dev, struct mei_me_client *me_cl);
Tomas Winkler37e7d6e2013-01-08 23:07:16 +0200698/*
699 * mei_watchdog_register - Registering watchdog interface
700 * once we got connection to the WD Client
Alexander Usyskina8605ea2014-09-29 16:31:49 +0300701 * @dev: mei device
Tomas Winkler37e7d6e2013-01-08 23:07:16 +0200702 */
Tomas Winkler64092852014-02-17 15:13:21 +0200703int mei_watchdog_register(struct mei_device *dev);
Tomas Winkler37e7d6e2013-01-08 23:07:16 +0200704/*
705 * mei_watchdog_unregister - Unregistering watchdog interface
Alexander Usyskina8605ea2014-09-29 16:31:49 +0300706 * @dev: mei device
Tomas Winkler37e7d6e2013-01-08 23:07:16 +0200707 */
708void mei_watchdog_unregister(struct mei_device *dev);
709
Oren Weilab841162011-05-15 13:43:41 +0300710/*
711 * Register Access Function
712 */
713
Alexander Usyskin8d929d42014-05-13 01:30:53 +0300714
Tomas Winkler827eef52013-02-06 14:06:41 +0200715static inline void mei_hw_config(struct mei_device *dev)
716{
717 dev->ops->hw_config(dev);
718}
Tomas Winkleree7e5af2014-03-18 22:51:58 +0200719
Tomas Winkler964a2332014-03-18 22:51:59 +0200720static inline enum mei_pg_state mei_pg_state(struct mei_device *dev)
721{
722 return dev->ops->pg_state(dev);
723}
724
Tomas Winkleree7e5af2014-03-18 22:51:58 +0200725static inline bool mei_pg_is_enabled(struct mei_device *dev)
726{
727 return dev->ops->pg_is_enabled(dev);
728}
729
Tomas Winklerc20c68d2013-06-23 10:42:49 +0300730static inline int mei_hw_reset(struct mei_device *dev, bool enable)
Tomas Winkler827eef52013-02-06 14:06:41 +0200731{
Tomas Winklerc20c68d2013-06-23 10:42:49 +0300732 return dev->ops->hw_reset(dev, enable);
Tomas Winkler827eef52013-02-06 14:06:41 +0200733}
Oren Weilab841162011-05-15 13:43:41 +0300734
Tomas Winkler9049f792013-06-23 22:49:04 +0300735static inline int mei_hw_start(struct mei_device *dev)
Tomas Winkleraafae7e2013-03-11 18:27:03 +0200736{
Tomas Winkler9049f792013-06-23 22:49:04 +0300737 return dev->ops->hw_start(dev);
Tomas Winkleraafae7e2013-03-11 18:27:03 +0200738}
739
Tomas Winkler827eef52013-02-06 14:06:41 +0200740static inline void mei_clear_interrupts(struct mei_device *dev)
741{
742 dev->ops->intr_clear(dev);
743}
Oren Weilab841162011-05-15 13:43:41 +0300744
Tomas Winkler827eef52013-02-06 14:06:41 +0200745static inline void mei_enable_interrupts(struct mei_device *dev)
746{
747 dev->ops->intr_enable(dev);
748}
Tomas Winklere7e0c232013-01-08 23:07:31 +0200749
Tomas Winkler827eef52013-02-06 14:06:41 +0200750static inline void mei_disable_interrupts(struct mei_device *dev)
751{
752 dev->ops->intr_disable(dev);
753}
Oren Weilab841162011-05-15 13:43:41 +0300754
Tomas Winkler827eef52013-02-06 14:06:41 +0200755static inline bool mei_host_is_ready(struct mei_device *dev)
756{
757 return dev->ops->host_is_ready(dev);
758}
759static inline bool mei_hw_is_ready(struct mei_device *dev)
760{
761 return dev->ops->hw_is_ready(dev);
762}
Tomas Winkler115ba282013-01-08 23:07:29 +0200763
Tomas Winkler827eef52013-02-06 14:06:41 +0200764static inline bool mei_hbuf_is_ready(struct mei_device *dev)
765{
766 return dev->ops->hbuf_is_ready(dev);
767}
Tomas Winkler3a65dd42012-12-25 19:06:06 +0200768
Tomas Winkler827eef52013-02-06 14:06:41 +0200769static inline int mei_hbuf_empty_slots(struct mei_device *dev)
770{
771 return dev->ops->hbuf_free_slots(dev);
772}
773
774static inline size_t mei_hbuf_max_len(const struct mei_device *dev)
775{
776 return dev->ops->hbuf_max_len(dev);
777}
778
779static inline int mei_write_message(struct mei_device *dev,
780 struct mei_msg_hdr *hdr,
781 unsigned char *buf)
782{
783 return dev->ops->write(dev, hdr, buf);
784}
785
786static inline u32 mei_read_hdr(const struct mei_device *dev)
787{
788 return dev->ops->read_hdr(dev);
789}
790
791static inline void mei_read_slots(struct mei_device *dev,
792 unsigned char *buf, unsigned long len)
793{
794 dev->ops->read(dev, buf, len);
795}
796
797static inline int mei_count_full_read_slots(struct mei_device *dev)
798{
799 return dev->ops->rdbuf_full_slots(dev);
800}
Tomas Winkler5bd64712012-11-18 15:13:14 +0200801
Tomas Winkler1bd30b62014-09-29 16:31:43 +0300802static inline int mei_fw_status(struct mei_device *dev,
803 struct mei_fw_status *fw_status)
804{
805 return dev->ops->fw_status(dev, fw_status);
806}
Alexander Usyskin04dd3662014-03-31 17:59:23 +0300807
Tomas Winkler6aae48f2014-02-19 17:35:47 +0200808bool mei_hbuf_acquire(struct mei_device *dev);
809
Tomas Winklera532bbe2014-03-18 22:52:01 +0200810bool mei_write_is_idle(struct mei_device *dev);
811
Tomas Winkler30e53bb2013-04-05 22:10:34 +0300812#if IS_ENABLED(CONFIG_DEBUG_FS)
813int mei_dbgfs_register(struct mei_device *dev, const char *name);
814void mei_dbgfs_deregister(struct mei_device *dev);
815#else
816static inline int mei_dbgfs_register(struct mei_device *dev, const char *name)
817{
818 return 0;
819}
820static inline void mei_dbgfs_deregister(struct mei_device *dev) {}
821#endif /* CONFIG_DEBUG_FS */
822
Alexander Usyskinf3d8e872014-06-23 15:10:35 +0300823int mei_register(struct mei_device *dev, struct device *parent);
Tomas Winkler30e53bb2013-04-05 22:10:34 +0300824void mei_deregister(struct mei_device *dev);
Tomas Winkler2703d4b2013-02-06 14:06:39 +0200825
Tomas Winkler479327f2013-12-17 15:56:56 +0200826#define MEI_HDR_FMT "hdr:host=%02d me=%02d len=%d internal=%1d comp=%1d"
Tomas Winkler15d4acc2012-12-25 19:06:00 +0200827#define MEI_HDR_PRM(hdr) \
828 (hdr)->host_addr, (hdr)->me_addr, \
Tomas Winkler479327f2013-12-17 15:56:56 +0200829 (hdr)->length, (hdr)->internal, (hdr)->msg_complete
Tomas Winkler15d4acc2012-12-25 19:06:00 +0200830
Alexander Usyskinedca5ea2014-11-19 17:01:38 +0200831ssize_t mei_fw_status2str(struct mei_fw_status *fw_sts, char *buf, size_t len);
832/**
833 * mei_fw_status_str - fetch and convert fw status registers to printable string
834 *
835 * @dev: the device structure
836 * @buf: string buffer at minimal size MEI_FW_STATUS_STR_SZ
837 * @len: buffer len must be >= MEI_FW_STATUS_STR_SZ
838 *
839 * Return: number of bytes written or < 0 on failure
840 */
841static inline ssize_t mei_fw_status_str(struct mei_device *dev,
842 char *buf, size_t len)
843{
844 struct mei_fw_status fw_status;
845 int ret;
846
847 buf[0] = '\0';
848
849 ret = mei_fw_status(dev, &fw_status);
850 if (ret)
851 return ret;
852
853 ret = mei_fw_status2str(&fw_status, buf, MEI_FW_STATUS_STR_SZ);
854
855 return ret;
856}
857
858
Oren Weilab841162011-05-15 13:43:41 +0300859#endif