mei_dev.h 21.9 KB
Newer Older
1 2 3
/*
 *
 * Intel Management Engine Interface (Intel MEI) Linux driver
4
 * Copyright (c) 2003-2012, Intel Corporation.
5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms and conditions of the GNU General Public License,
 * version 2, as published by the Free Software Foundation.
 *
 * This program is distributed in the hope it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 * more details.
 *
 */

#ifndef _MEI_DEV_H_
#define _MEI_DEV_H_

#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"
T
Tomas Winkler 已提交
27
#include "hbm.h"
28 29 30 31

/*
 * watch dog definition
 */
32 33 34 35 36 37 38 39
#define MEI_WD_HDR_SIZE       4
#define MEI_WD_STOP_MSG_SIZE  MEI_WD_HDR_SIZE
#define MEI_WD_START_MSG_SIZE (MEI_WD_HDR_SIZE + 16)

#define MEI_WD_DEFAULT_TIMEOUT   120  /* seconds */
#define MEI_WD_MIN_TIMEOUT       120  /* seconds */
#define MEI_WD_MAX_TIMEOUT     65535  /* seconds */

40 41
#define MEI_WD_STOP_TIMEOUT      10 /* msecs */

42 43
#define MEI_WD_STATE_INDEPENDENCE_MSG_SENT       (1 << 0)

44 45
#define MEI_RD_MSG_BUF_SIZE           (128 * sizeof(u32))

46

47 48 49
/*
 * AMTHI Client UUID
 */
50
extern const uuid_le mei_amthif_guid;
51 52 53 54 55 56

/*
 * Watchdog Client UUID
 */
extern const uuid_le mei_wd_guid;

57 58 59 60 61
/*
 * Number of Maximum MEI Clients
 */
#define MEI_CLIENTS_MAX 256

62 63 64 65 66
/*
 * maximum number of consecutive resets
 */
#define MEI_MAX_CONSEC_RESET  3

67 68 69 70
/*
 * Number of File descriptors/handles
 * that can be opened to the driver.
 *
71
 * Limit to 255: 256 Total Clients
72
 * minus internal client for MEI Bus Messages
73
 */
74
#define  MEI_MAX_OPEN_HANDLE_COUNT (MEI_CLIENTS_MAX - 1)
75

76 77 78
/*
 * Internal Clients Number
 */
79 80
#define MEI_HOST_CLIENT_ID_ANY        (-1)
#define MEI_HBM_HOST_CLIENT_ID         0 /* not used, just for documentation */
81 82 83
#define MEI_WD_HOST_CLIENT_ID          1
#define MEI_IAMTHIF_HOST_CLIENT_ID     2

84 85 86 87 88 89 90 91 92 93 94

/* File state */
enum file_state {
	MEI_FILE_INITIALIZING = 0,
	MEI_FILE_CONNECTING,
	MEI_FILE_CONNECTED,
	MEI_FILE_DISCONNECTING,
	MEI_FILE_DISCONNECTED
};

/* MEI device states */
95 96 97 98
enum mei_dev_state {
	MEI_DEV_INITIALIZING = 0,
	MEI_DEV_INIT_CLIENTS,
	MEI_DEV_ENABLED,
B
Bill Nottingham 已提交
99
	MEI_DEV_RESETTING,
100 101 102
	MEI_DEV_DISABLED,
	MEI_DEV_POWER_DOWN,
	MEI_DEV_POWER_UP
103 104
};

105 106
const char *mei_dev_state_str(int state);

107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123
enum iamthif_states {
	MEI_IAMTHIF_IDLE,
	MEI_IAMTHIF_WRITING,
	MEI_IAMTHIF_FLOW_CONTROL,
	MEI_IAMTHIF_READING,
	MEI_IAMTHIF_READ_COMPLETE
};

enum mei_file_transaction_states {
	MEI_IDLE,
	MEI_WRITING,
	MEI_WRITE_COMPLETE,
	MEI_FLOW_CONTROL,
	MEI_READING,
	MEI_READ_COMPLETE
};

124 125 126 127 128 129
enum mei_wd_states {
	MEI_WD_IDLE,
	MEI_WD_RUNNING,
	MEI_WD_STOPPING,
};

130 131
/**
 * enum mei_cb_file_ops  - file operation associated with the callback
A
Alexander Usyskin 已提交
132 133 134 135 136
 * @MEI_FOP_READ:       read
 * @MEI_FOP_WRITE:      write
 * @MEI_FOP_CONNECT:    connect
 * @MEI_FOP_DISCONNECT: disconnect
 * @MEI_FOP_DISCONNECT_RSP: disconnect response
137 138 139 140
 */
enum mei_cb_file_ops {
	MEI_FOP_READ = 0,
	MEI_FOP_WRITE,
141
	MEI_FOP_CONNECT,
142
	MEI_FOP_DISCONNECT,
T
Tomas Winkler 已提交
143
	MEI_FOP_DISCONNECT_RSP,
144 145 146 147 148
};

/*
 * Intel MEI message data struct
 */
T
Tomas Winkler 已提交
149
struct mei_msg_data {
150
	u32 size;
151
	unsigned char *data;
152
};
153

154
/* Maximum number of processed FW status registers */
155 156 157 158
#define MEI_FW_STATUS_MAX 6
/* Minimal  buffer for FW status string (8 bytes in dw + space or '\0') */
#define MEI_FW_STATUS_STR_SZ (MEI_FW_STATUS_MAX * (8 + 1))

159 160 161 162

/*
 * struct mei_fw_status - storage of FW status data
 *
163 164
 * @count: number of actually available elements in array
 * @status: FW status registers
165 166 167 168 169 170
 */
struct mei_fw_status {
	int count;
	u32 status[MEI_FW_STATUS_MAX];
};

171 172 173
/**
 * struct mei_me_client - representation of me (fw) client
 *
174
 * @list: link in me client list
175
 * @refcnt: struct reference count
176 177 178
 * @props: client properties
 * @client_id: me client id
 * @mei_flow_ctrl_creds: flow control credits
179 180
 */
struct mei_me_client {
181
	struct list_head list;
182
	struct kref refcnt;
183 184 185 186 187
	struct mei_client_properties props;
	u8 client_id;
	u8 mei_flow_ctrl_creds;
};

188

189 190
struct mei_cl;

191
/**
192 193
 * struct mei_cl_cb - file operation callback structure
 *
194 195 196
 * @list: link in callback queue
 * @cl: file client who is running this operation
 * @fop_type: file operation type
197
 * @buf: buffer for data associated with the callback
A
Alexander Usyskin 已提交
198 199 200
 * @buf_idx: last read index
 * @read_time: last read operation time stamp (iamthif)
 * @file_object: pointer to file structure
201
 * @status: io status of the cb
A
Alexander Usyskin 已提交
202
 * @internal: communication between driver and FW flag
203
 * @completed: the transfer or reception has completed
204
 */
205
struct mei_cl_cb {
206
	struct list_head list;
207
	struct mei_cl *cl;
208
	enum mei_cb_file_ops fop_type;
209
	struct mei_msg_data buf;
210
	unsigned long buf_idx;
211 212
	unsigned long read_time;
	struct file *file_object;
213
	int status;
214
	u32 internal:1;
215
	u32 completed:1;
216 217
};

A
Alexander Usyskin 已提交
218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234
/**
 * struct mei_cl - me client host representation
 *    carried in file->private_data
 *
 * @link: link in the clients list
 * @dev: mei parent device
 * @state: file operation state
 * @tx_wait: wait queue for tx completion
 * @rx_wait: wait queue for rx completion
 * @wait:  wait queue for management operation
 * @status: connection status
 * @cl_uuid: client uuid name
 * @host_client_id: host id
 * @me_client_id: me/fw id
 * @mei_flow_ctrl_creds: transmit flow credentials
 * @timer_count:  watchdog timer for operation completion
 * @writing_state: state of the tx
T
Tomas Winkler 已提交
235 236
 * @rd_pending: pending read credits
 * @rd_completed: completed read
A
Alexander Usyskin 已提交
237 238 239 240
 *
 * @device: device on the mei client bus
 * @device_link:  link to bus clients
 */
241 242 243 244 245 246 247 248
struct mei_cl {
	struct list_head link;
	struct mei_device *dev;
	enum file_state state;
	wait_queue_head_t tx_wait;
	wait_queue_head_t rx_wait;
	wait_queue_head_t wait;
	int status;
249
	uuid_le cl_uuid;
250 251 252 253 254
	u8 host_client_id;
	u8 me_client_id;
	u8 mei_flow_ctrl_creds;
	u8 timer_count;
	enum mei_file_transaction_states writing_state;
T
Tomas Winkler 已提交
255 256
	struct list_head rd_pending;
	struct list_head rd_completed;
257 258 259 260

	/* MEI CL bus data */
	struct mei_cl_device *device;
	struct list_head device_link;
261 262
};

263 264
/** struct mei_hw_ops
 *
265
 * @host_is_ready    : query for host readiness
266

267 268 269 270
 * @hw_is_ready      : query if hw is ready
 * @hw_reset         : reset hw
 * @hw_start         : start hw after reset
 * @hw_config        : configure hw
271

272 273 274
 * @fw_status        : get fw status registers
 * @pg_state         : power gating state of the device
 * @pg_is_enabled    : is power gating enabled
275

276 277 278
 * @intr_clear       : clear pending interrupts
 * @intr_enable      : enable interrupts
 * @intr_disable     : disable interrupts
279

280 281 282
 * @hbuf_free_slots  : query for write buffer empty slots
 * @hbuf_is_ready    : query if write buffer is empty
 * @hbuf_max_len     : query for write buffer max len
283

284
 * @write            : write a message to FW
285

286
 * @rdbuf_full_slots : query how many slots are filled
287

288 289
 * @read_hdr         : get first 4 bytes (header)
 * @read             : read a buffer from the FW
290 291 292
 */
struct mei_hw_ops {

293
	bool (*host_is_ready)(struct mei_device *dev);
294

295 296 297 298
	bool (*hw_is_ready)(struct mei_device *dev);
	int (*hw_reset)(struct mei_device *dev, bool enable);
	int (*hw_start)(struct mei_device *dev);
	void (*hw_config)(struct mei_device *dev);
299

300 301

	int (*fw_status)(struct mei_device *dev, struct mei_fw_status *fw_sts);
302
	enum mei_pg_state (*pg_state)(struct mei_device *dev);
303 304
	bool (*pg_is_enabled)(struct mei_device *dev);

305 306 307
	void (*intr_clear)(struct mei_device *dev);
	void (*intr_enable)(struct mei_device *dev);
	void (*intr_disable)(struct mei_device *dev);
308

309 310 311
	int (*hbuf_free_slots)(struct mei_device *dev);
	bool (*hbuf_is_ready)(struct mei_device *dev);
	size_t (*hbuf_max_len)(const struct mei_device *dev);
312 313 314 315 316 317 318 319

	int (*write)(struct mei_device *dev,
		     struct mei_msg_hdr *hdr,
		     unsigned char *buf);

	int (*rdbuf_full_slots)(struct mei_device *dev);

	u32 (*read_hdr)(const struct mei_device *dev);
320
	int (*read)(struct mei_device *dev,
321 322 323
		     unsigned char *buf, unsigned long len);
};

324
/* MEI bus API*/
325 326

/**
327
 * struct mei_cl_ops - MEI CL device ops
328
 * This structure allows ME host clients to implement technology
329
 * specific operations.
330
 *
331 332 333
 * @enable: Enable an MEI CL device. Some devices require specific
 *	HECI commands to initialize completely.
 * @disable: Disable an MEI CL device.
334 335 336 337 338 339
 * @send: Tx hook for the device. This allows ME host clients to trap
 *	the device driver buffers before actually physically
 *	pushing it to the ME.
 * @recv: Rx hook for the device. This allows ME host clients to trap the
 *	ME buffers before forwarding them to the device driver.
 */
340 341 342
struct mei_cl_ops {
	int (*enable)(struct mei_cl_device *device);
	int (*disable)(struct mei_cl_device *device);
343 344 345 346
	int (*send)(struct mei_cl_device *device, u8 *buf, size_t length);
	int (*recv)(struct mei_cl_device *device, u8 *buf, size_t length);
};

347 348 349 350 351
struct mei_cl_device *mei_cl_add_device(struct mei_device *dev,
					uuid_le uuid, char *name,
					struct mei_cl_ops *ops);
void mei_cl_remove_device(struct mei_cl_device *device);

352 353 354
ssize_t __mei_cl_async_send(struct mei_cl *cl, u8 *buf, size_t length);
ssize_t __mei_cl_send(struct mei_cl *cl, u8 *buf, size_t length);
ssize_t __mei_cl_recv(struct mei_cl *cl, u8 *buf, size_t length);
355
void mei_cl_bus_rx_event(struct mei_cl *cl);
356
void mei_cl_bus_remove_devices(struct mei_device *dev);
357 358
int mei_cl_bus_init(void);
void mei_cl_bus_exit(void);
359
struct mei_cl *mei_cl_bus_find_cl_by_uuid(struct mei_device *dev, uuid_le uuid);
360 361


362 363 364 365 366 367 368 369 370
/**
 * struct mei_cl_device - MEI device handle
 * An mei_cl_device pointer is returned from mei_add_device()
 * and links MEI bus clients to their actual ME host client pointer.
 * Drivers for MEI devices will get an mei_cl_device pointer
 * when being probed and shall use it for doing ME bus I/O.
 *
 * @dev: linux driver model device pointer
 * @cl: mei client
371
 * @ops: ME transport ops
A
Alexander Usyskin 已提交
372
 * @event_work: async work to execute event callback
373 374
 * @event_cb: Drivers register this callback to get asynchronous ME
 *	events (e.g. Rx buffer pending) notifications.
A
Alexander Usyskin 已提交
375
 * @event_context: event callback run context
376
 * @events: Events bitmask sent to the driver.
377 378 379 380 381 382 383
 * @priv_data: client private data
 */
struct mei_cl_device {
	struct device dev;

	struct mei_cl *cl;

384
	const struct mei_cl_ops *ops;
385 386 387 388 389 390

	struct work_struct event_work;
	mei_cl_event_cb_t event_cb;
	void *event_context;
	unsigned long events;

391 392 393
	void *priv_data;
};

394

A
Alexander Usyskin 已提交
395
/**
396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418
 * enum mei_pg_event - power gating transition events
 *
 * @MEI_PG_EVENT_IDLE: the driver is not in power gating transition
 * @MEI_PG_EVENT_WAIT: the driver is waiting for a pg event to complete
 * @MEI_PG_EVENT_RECEIVED: the driver received pg event
 */
enum mei_pg_event {
	MEI_PG_EVENT_IDLE,
	MEI_PG_EVENT_WAIT,
	MEI_PG_EVENT_RECEIVED,
};

/**
 * enum mei_pg_state - device internal power gating state
 *
 * @MEI_PG_OFF: device is not power gated - it is active
 * @MEI_PG_ON:  device is power gated - it is in lower power state
 */
enum mei_pg_state {
	MEI_PG_OFF = 0,
	MEI_PG_ON =  1,
};

419 420
const char *mei_pg_state_str(enum mei_pg_state state);

421
/**
422
 * struct mei_device -  MEI private device struct
A
Alexander Usyskin 已提交
423
 *
424 425 426
 * @dev         : device on a bus
 * @cdev        : character device
 * @minor       : minor number allocated for device
427
 *
A
Alexander Usyskin 已提交
428 429 430 431
 * @write_list  : write pending list
 * @write_waiting_list : write completion list
 * @ctrl_wr_list : pending control write list
 * @ctrl_rd_list : pending control read list
432
 *
A
Alexander Usyskin 已提交
433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449
 * @file_list   : list of opened handles
 * @open_handle_count: number of opened handles
 *
 * @device_lock : big device lock
 * @timer_work  : MEI timer delayed work (timeouts)
 *
 * @recvd_hw_ready : hw ready message received flag
 *
 * @wait_hw_ready : wait queue for receive HW ready message form FW
 * @wait_pg     : wait queue for receive PG message from FW
 * @wait_hbm_start : wait queue for receive HBM start message from FW
 * @wait_stop_wd : wait queue for receive WD stop message from FW
 *
 * @reset_count : number of consecutive resets
 * @dev_state   : device state
 * @hbm_state   : state of host bus message protocol
 * @init_clients_timer : HBM init handshake timeout
450
 *
451
 * @pg_event    : power gating event
A
Alexander Usyskin 已提交
452 453 454 455 456
 * @pg_domain   : runtime PM domain
 *
 * @rd_msg_buf  : control messages buffer
 * @rd_msg_hdr  : read message header storage
 *
457 458 459
 * @hbuf_depth  : depth of hardware host/write buffer is slots
 * @hbuf_is_ready : query if the host host/write buffer is ready
 * @wr_msg      : the buffer for hbm control messages
A
Alexander Usyskin 已提交
460 461 462 463
 *
 * @version     : HBM protocol version in use
 * @hbm_f_pg_supported : hbm feature pgi protocol
 *
464
 * @me_clients_rwsem: rw lock over me_clients list
A
Alexander Usyskin 已提交
465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496
 * @me_clients  : list of FW clients
 * @me_clients_map : FW clients bit map
 * @host_clients_map : host clients id pool
 * @me_client_index : last FW client index in enumeration
 *
 * @wd_cl       : watchdog client
 * @wd_state    : watchdog client state
 * @wd_pending  : watchdog command is pending
 * @wd_timeout  : watchdog expiration timeout
 * @wd_data     : watchdog message buffer
 *
 * @amthif_cmd_list : amthif list for cmd waiting
 * @amthif_rd_complete_list : amthif list for reading completed cmd data
 * @iamthif_file_object : file for current amthif operation
 * @iamthif_cl  : amthif host client
 * @iamthif_current_cb : amthif current operation callback
 * @iamthif_open_count : number of opened amthif connections
 * @iamthif_mtu : amthif client max message length
 * @iamthif_timer : time stamp of current amthif command completion
 * @iamthif_stall_timer : timer to detect amthif hang
 * @iamthif_state : amthif processor state
 * @iamthif_canceled : current amthif command is canceled
 *
 * @init_work   : work item for the device init
 * @reset_work  : work item for the device reset
 *
 * @device_list : mei client bus list
 *
 * @dbgfs_dir   : debugfs mei root directory
 *
 * @ops:        : hw specific operations
 * @hw          : hw specific data
497
 */
498
struct mei_device {
499
	struct device *dev;
500 501 502
	struct cdev cdev;
	int minor;

A
Alexander Usyskin 已提交
503 504 505 506
	struct mei_cl_cb write_list;
	struct mei_cl_cb write_waiting_list;
	struct mei_cl_cb ctrl_wr_list;
	struct mei_cl_cb ctrl_rd_list;
507 508

	struct list_head file_list;
509
	long open_handle_count;
510

A
Alexander Usyskin 已提交
511 512
	struct mutex device_lock;
	struct delayed_work timer_work;
T
Tomas Winkler 已提交
513 514

	bool recvd_hw_ready;
515 516 517
	/*
	 * waiting queue for receive message from FW
	 */
T
Tomas Winkler 已提交
518
	wait_queue_head_t wait_hw_ready;
519
	wait_queue_head_t wait_pg;
520
	wait_queue_head_t wait_hbm_start;
521 522 523 524 525
	wait_queue_head_t wait_stop_wd;

	/*
	 * mei device  states
	 */
526
	unsigned long reset_count;
527
	enum mei_dev_state dev_state;
T
Tomas Winkler 已提交
528
	enum mei_hbm_state hbm_state;
529 530
	u16 init_clients_timer;

531 532 533 534
	/*
	 * Power Gating support
	 */
	enum mei_pg_event pg_event;
535
#ifdef CONFIG_PM
536
	struct dev_pm_domain pg_domain;
537
#endif /* CONFIG_PM */
538

A
Alexander Usyskin 已提交
539
	unsigned char rd_msg_buf[MEI_RD_MSG_BUF_SIZE];
540
	u32 rd_msg_hdr;
541

542 543 544 545
	/* write buffer */
	u8 hbuf_depth;
	bool hbuf_is_ready;

546 547 548 549 550 551
	/* used for control messages */
	struct {
		struct mei_msg_hdr hdr;
		unsigned char data[128];
	} wr_msg;

552
	struct hbm_version version;
553
	unsigned int hbm_f_pg_supported:1;
554

555
	struct rw_semaphore me_clients_rwsem;
556
	struct list_head me_clients;
557 558
	DECLARE_BITMAP(me_clients_map, MEI_CLIENTS_MAX);
	DECLARE_BITMAP(host_clients_map, MEI_CLIENTS_MAX);
559
	unsigned long me_client_index;
560

561
	struct mei_cl wd_cl;
562
	enum mei_wd_states wd_state;
563
	bool wd_pending;
564
	u16 wd_timeout;
565
	unsigned char wd_data[MEI_WD_START_MSG_SIZE];
566 567


568 569 570 571
	/* amthif list for cmd waiting */
	struct mei_cl_cb amthif_cmd_list;
	/* driver managed amthif list for reading completed amthif cmd data */
	struct mei_cl_cb amthif_rd_complete_list;
572 573
	struct file *iamthif_file_object;
	struct mei_cl iamthif_cl;
574
	struct mei_cl_cb *iamthif_current_cb;
T
Tomas Winkler 已提交
575
	long iamthif_open_count;
576 577 578 579
	int iamthif_mtu;
	unsigned long iamthif_timer;
	u32 iamthif_stall_timer;
	enum iamthif_states iamthif_state;
580
	bool iamthif_canceled;
581 582

	struct work_struct init_work;
583
	struct work_struct reset_work;
584

585 586 587
	/* List of bus devices */
	struct list_head device_list;

T
Tomas Winkler 已提交
588 589 590 591 592
#if IS_ENABLED(CONFIG_DEBUG_FS)
	struct dentry *dbgfs_dir;
#endif /* CONFIG_DEBUG_FS */


593
	const struct mei_hw_ops *ops;
594
	char hw[0] __aligned(sizeof(void *));
595 596
};

597 598 599 600 601
static inline unsigned long mei_secs_to_jiffies(unsigned long sec)
{
	return msecs_to_jiffies(sec * MSEC_PER_SEC);
}

T
Tomas Winkler 已提交
602 603 604
/**
 * mei_data2slots - get slots - number of (dwords) from a message length
 *	+ size of the mei header
A
Alexander Usyskin 已提交
605
 *
606 607 608
 * @length: size of the messages in bytes
 *
 * Return: number of slots
T
Tomas Winkler 已提交
609 610 611 612 613 614
 */
static inline u32 mei_data2slots(size_t length)
{
	return DIV_ROUND_UP(sizeof(struct mei_msg_hdr) + length, 4);
}

T
Tomas Winkler 已提交
615
/**
A
Alexander Usyskin 已提交
616 617
 * mei_slots2data - get data in slots - bytes from slots
 *
618
 * @slots: number of available slots
A
Alexander Usyskin 已提交
619
 *
620
 * Return: number of bytes in slots
T
Tomas Winkler 已提交
621 622 623 624 625 626
 */
static inline u32 mei_slots2data(int slots)
{
	return slots * 4;
}

627 628 629
/*
 * mei init function prototypes
 */
630 631 632
void mei_device_init(struct mei_device *dev,
		     struct device *device,
		     const struct mei_hw_ops *hw_ops);
633
int mei_reset(struct mei_device *dev);
634
int mei_start(struct mei_device *dev);
635
int mei_restart(struct mei_device *dev);
636
void mei_stop(struct mei_device *dev);
T
Tomas Winkler 已提交
637
void mei_cancel_work(struct mei_device *dev);
638 639 640

/*
 *  MEI interrupt functions prototype
641
 */
642

643
void mei_timer(struct work_struct *work);
644 645 646 647
int mei_irq_read_handler(struct mei_device *dev,
		struct mei_cl_cb *cmpl_list, s32 *slots);

int mei_irq_write_handler(struct mei_device *dev, struct mei_cl_cb *cmpl_list);
648
void mei_irq_compl_handler(struct mei_device *dev, struct mei_cl_cb *cmpl_list);
649

650 651 652 653 654
/*
 * AMTHIF - AMT Host Interface Functions
 */
void mei_amthif_reset_params(struct mei_device *dev);

655
int mei_amthif_host_init(struct mei_device *dev);
656 657

int mei_amthif_read(struct mei_device *dev, struct file *file,
658 659 660 661
		char __user *ubuf, size_t length, loff_t *offset);

unsigned int mei_amthif_poll(struct mei_device *dev,
		struct file *file, poll_table *wait);
662

663 664
int mei_amthif_release(struct mei_device *dev, struct file *file);

665
struct mei_cl_cb *mei_amthif_find_read_list_entry(struct mei_device *dev,
666 667
						struct file *file);

668 669
int mei_amthif_write(struct mei_cl *cl, struct mei_cl_cb *cb);
int mei_amthif_run_next_cmd(struct mei_device *dev);
670 671
int mei_amthif_irq_write(struct mei_cl *cl, struct mei_cl_cb *cb,
			struct mei_cl_cb *cmpl_list);
672 673

void mei_amthif_complete(struct mei_device *dev, struct mei_cl_cb *cb);
674
int mei_amthif_irq_read_msg(struct mei_cl *cl,
675 676 677 678
			    struct mei_msg_hdr *mei_hdr,
			    struct mei_cl_cb *complete_list);
int mei_amthif_irq_read(struct mei_device *dev, s32 *slots);

679 680 681 682
/*
 * NFC functions
 */
int mei_nfc_host_init(struct mei_device *dev);
T
Tomas Winkler 已提交
683
void mei_nfc_host_exit(struct mei_device *dev);
684 685 686 687 688

/*
 * NFC Client UUID
 */
extern const uuid_le mei_nfc_guid;
689

690 691 692 693 694 695
int mei_wd_send(struct mei_device *dev);
int mei_wd_stop(struct mei_device *dev);
int mei_wd_host_init(struct mei_device *dev);
/*
 * mei_watchdog_register  - Registering watchdog interface
 *   once we got connection to the WD Client
696
 * @dev: mei device
697
 */
698
int mei_watchdog_register(struct mei_device *dev);
699 700
/*
 * mei_watchdog_unregister  - Unregistering watchdog interface
701
 * @dev: mei device
702 703 704
 */
void mei_watchdog_unregister(struct mei_device *dev);

705 706 707 708
/*
 * Register Access Function
 */

709

710 711 712 713
static inline void mei_hw_config(struct mei_device *dev)
{
	dev->ops->hw_config(dev);
}
714

715 716 717 718 719
static inline enum mei_pg_state mei_pg_state(struct mei_device *dev)
{
	return dev->ops->pg_state(dev);
}

720 721 722 723 724
static inline bool mei_pg_is_enabled(struct mei_device *dev)
{
	return dev->ops->pg_is_enabled(dev);
}

725
static inline int mei_hw_reset(struct mei_device *dev, bool enable)
726
{
727
	return dev->ops->hw_reset(dev, enable);
728 729
}

730
static inline int mei_hw_start(struct mei_device *dev)
T
Tomas Winkler 已提交
731
{
732
	return dev->ops->hw_start(dev);
T
Tomas Winkler 已提交
733 734
}

735 736 737 738 739 740 741 742 743
static inline void mei_clear_interrupts(struct mei_device *dev)
{
	dev->ops->intr_clear(dev);
}

static inline void mei_enable_interrupts(struct mei_device *dev)
{
	dev->ops->intr_enable(dev);
}
744

745 746 747 748
static inline void mei_disable_interrupts(struct mei_device *dev)
{
	dev->ops->intr_disable(dev);
}
749

750 751 752 753 754 755 756 757
static inline bool mei_host_is_ready(struct mei_device *dev)
{
	return dev->ops->host_is_ready(dev);
}
static inline bool mei_hw_is_ready(struct mei_device *dev)
{
	return dev->ops->hw_is_ready(dev);
}
758

759 760 761 762
static inline bool mei_hbuf_is_ready(struct mei_device *dev)
{
	return dev->ops->hbuf_is_ready(dev);
}
763

764 765 766 767
static inline int mei_hbuf_empty_slots(struct mei_device *dev)
{
	return dev->ops->hbuf_free_slots(dev);
}
768

769 770 771 772
static inline size_t mei_hbuf_max_len(const struct mei_device *dev)
{
	return dev->ops->hbuf_max_len(dev);
}
773

774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795
static inline int mei_write_message(struct mei_device *dev,
			struct mei_msg_hdr *hdr,
			unsigned char *buf)
{
	return dev->ops->write(dev, hdr, buf);
}

static inline u32 mei_read_hdr(const struct mei_device *dev)
{
	return dev->ops->read_hdr(dev);
}

static inline void mei_read_slots(struct mei_device *dev,
		     unsigned char *buf, unsigned long len)
{
	dev->ops->read(dev, buf, len);
}

static inline int mei_count_full_read_slots(struct mei_device *dev)
{
	return dev->ops->rdbuf_full_slots(dev);
}
796

797 798 799 800 801
static inline int mei_fw_status(struct mei_device *dev,
				struct mei_fw_status *fw_status)
{
	return dev->ops->fw_status(dev, fw_status);
}
802

803 804
bool mei_hbuf_acquire(struct mei_device *dev);

805 806
bool mei_write_is_idle(struct mei_device *dev);

T
Tomas Winkler 已提交
807 808 809 810 811 812 813 814 815 816 817
#if IS_ENABLED(CONFIG_DEBUG_FS)
int mei_dbgfs_register(struct mei_device *dev, const char *name);
void mei_dbgfs_deregister(struct mei_device *dev);
#else
static inline int mei_dbgfs_register(struct mei_device *dev, const char *name)
{
	return 0;
}
static inline void mei_dbgfs_deregister(struct mei_device *dev) {}
#endif /* CONFIG_DEBUG_FS */

818
int mei_register(struct mei_device *dev, struct device *parent);
T
Tomas Winkler 已提交
819
void mei_deregister(struct mei_device *dev);
820

821
#define MEI_HDR_FMT "hdr:host=%02d me=%02d len=%d internal=%1d comp=%1d"
822 823
#define MEI_HDR_PRM(hdr)                  \
	(hdr)->host_addr, (hdr)->me_addr, \
824
	(hdr)->length, (hdr)->internal, (hdr)->msg_complete
825

826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853
ssize_t mei_fw_status2str(struct mei_fw_status *fw_sts, char *buf, size_t len);
/**
 * mei_fw_status_str - fetch and convert fw status registers to printable string
 *
 * @dev: the device structure
 * @buf: string buffer at minimal size MEI_FW_STATUS_STR_SZ
 * @len: buffer len must be >= MEI_FW_STATUS_STR_SZ
 *
 * Return: number of bytes written or < 0 on failure
 */
static inline ssize_t mei_fw_status_str(struct mei_device *dev,
					char *buf, size_t len)
{
	struct mei_fw_status fw_status;
	int ret;

	buf[0] = '\0';

	ret = mei_fw_status(dev, &fw_status);
	if (ret)
		return ret;

	ret = mei_fw_status2str(&fw_status, buf, MEI_FW_STATUS_STR_SZ);

	return ret;
}


854
#endif