mei_dev.h 20.8 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

/* File state */
enum file_state {
	MEI_FILE_INITIALIZING = 0,
	MEI_FILE_CONNECTING,
	MEI_FILE_CONNECTED,
	MEI_FILE_DISCONNECTING,
91 92
	MEI_FILE_DISCONNECT_REPLY,
	MEI_FILE_DISCONNECTED,
93 94 95
};

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

106 107
const char *mei_dev_state_str(int state);

108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124
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
};

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

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

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

155
/* Maximum number of processed FW status registers */
156 157 158 159
#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))

160 161 162 163

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

172 173 174
/**
 * struct mei_me_client - representation of me (fw) client
 *
175
 * @list: link in me client list
176
 * @refcnt: struct reference count
177 178 179
 * @props: client properties
 * @client_id: me client id
 * @mei_flow_ctrl_creds: flow control credits
180
 * @connect_count: number connections to this client
181
 * @bus_added: added to bus
182 183
 */
struct mei_me_client {
184
	struct list_head list;
185
	struct kref refcnt;
186 187 188
	struct mei_client_properties props;
	u8 client_id;
	u8 mei_flow_ctrl_creds;
189
	u8 connect_count;
190
	u8 bus_added;
191 192
};

193

194 195
struct mei_cl;

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

A
Alexander Usyskin 已提交
223 224 225 226 227 228 229 230 231 232 233
/**
 * 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
234
 * @me_cl: fw client connected
A
Alexander Usyskin 已提交
235 236 237
 * @host_client_id: host id
 * @mei_flow_ctrl_creds: transmit flow credentials
 * @timer_count:  watchdog timer for operation completion
238
 * @reserved: reserved for alignment
A
Alexander Usyskin 已提交
239
 * @writing_state: state of the tx
T
Tomas Winkler 已提交
240 241
 * @rd_pending: pending read credits
 * @rd_completed: completed read
A
Alexander Usyskin 已提交
242
 *
243
 * @cldev: device on the mei client bus
A
Alexander Usyskin 已提交
244
 */
245 246 247 248 249 250 251 252
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;
253
	struct mei_me_client *me_cl;
254 255 256
	u8 host_client_id;
	u8 mei_flow_ctrl_creds;
	u8 timer_count;
257
	u8 reserved;
258
	enum mei_file_transaction_states writing_state;
T
Tomas Winkler 已提交
259 260
	struct list_head rd_pending;
	struct list_head rd_completed;
261

262
	struct mei_cl_device *cldev;
263 264
};

265 266
/** struct mei_hw_ops
 *
267
 * @host_is_ready    : query for host readiness
268

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

274 275
 * @fw_status        : get fw status registers
 * @pg_state         : power gating state of the device
276
 * @pg_in_transition : is device now in pg transition
277
 * @pg_is_enabled    : is power gating enabled
278

279 280 281
 * @intr_clear       : clear pending interrupts
 * @intr_enable      : enable interrupts
 * @intr_disable     : disable interrupts
282

283 284 285
 * @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
286

287
 * @write            : write a message to FW
288

289
 * @rdbuf_full_slots : query how many slots are filled
290

291 292
 * @read_hdr         : get first 4 bytes (header)
 * @read             : read a buffer from the FW
293 294 295
 */
struct mei_hw_ops {

296
	bool (*host_is_ready)(struct mei_device *dev);
297

298 299 300 301
	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);
302

303 304

	int (*fw_status)(struct mei_device *dev, struct mei_fw_status *fw_sts);
305
	enum mei_pg_state (*pg_state)(struct mei_device *dev);
306
	bool (*pg_in_transition)(struct mei_device *dev);
307 308
	bool (*pg_is_enabled)(struct mei_device *dev);

309 310 311
	void (*intr_clear)(struct mei_device *dev);
	void (*intr_enable)(struct mei_device *dev);
	void (*intr_disable)(struct mei_device *dev);
312

313 314 315
	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);
316 317 318 319 320 321 322 323

	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);
324
	int (*read)(struct mei_device *dev,
325 326 327
		     unsigned char *buf, unsigned long len);
};

328
/* MEI bus API*/
329
void mei_cl_bus_rescan(struct mei_device *bus);
330
void mei_cl_dev_fixup(struct mei_cl_device *dev);
331 332
ssize_t __mei_cl_send(struct mei_cl *cl, u8 *buf, size_t length,
			bool blocking);
333
ssize_t __mei_cl_recv(struct mei_cl *cl, u8 *buf, size_t length);
334
void mei_cl_bus_rx_event(struct mei_cl *cl);
335
void mei_cl_bus_remove_devices(struct mei_device *bus);
336 337 338
int mei_cl_bus_init(void);
void mei_cl_bus_exit(void);

A
Alexander Usyskin 已提交
339
/**
340 341 342 343 344
 * 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
345 346
 * @MEI_PG_EVENT_INTR_WAIT: the driver is waiting for a pg event interrupt
 * @MEI_PG_EVENT_INTR_RECEIVED: the driver received pg event interrupt
347 348 349 350 351
 */
enum mei_pg_event {
	MEI_PG_EVENT_IDLE,
	MEI_PG_EVENT_WAIT,
	MEI_PG_EVENT_RECEIVED,
352 353
	MEI_PG_EVENT_INTR_WAIT,
	MEI_PG_EVENT_INTR_RECEIVED,
354 355 356 357 358 359 360 361 362 363 364 365 366
};

/**
 * 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,
};

367 368
const char *mei_pg_state_str(enum mei_pg_state state);

369
/**
370
 * struct mei_device -  MEI private device struct
A
Alexander Usyskin 已提交
371
 *
372 373 374
 * @dev         : device on a bus
 * @cdev        : character device
 * @minor       : minor number allocated for device
375
 *
A
Alexander Usyskin 已提交
376 377 378 379
 * @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
380
 *
A
Alexander Usyskin 已提交
381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397
 * @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
398
 *
399
 * @pg_event    : power gating event
A
Alexander Usyskin 已提交
400 401 402 403 404
 * @pg_domain   : runtime PM domain
 *
 * @rd_msg_buf  : control messages buffer
 * @rd_msg_hdr  : read message header storage
 *
405 406 407
 * @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 已提交
408 409 410
 *
 * @version     : HBM protocol version in use
 * @hbm_f_pg_supported : hbm feature pgi protocol
T
Tomas Winkler 已提交
411
 * @hbm_f_dc_supported : hbm feature dynamic clients
A
Alexander Usyskin 已提交
412
 *
413
 * @me_clients_rwsem: rw lock over me_clients list
A
Alexander Usyskin 已提交
414 415 416 417 418
 * @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
 *
419 420
 * @allow_fixed_address: allow user space to connect a fixed client
 *
A
Alexander Usyskin 已提交
421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441
 * @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_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
442
 * @cl_bus_lock : client bus list lock
A
Alexander Usyskin 已提交
443 444 445 446 447
 *
 * @dbgfs_dir   : debugfs mei root directory
 *
 * @ops:        : hw specific operations
 * @hw          : hw specific data
448
 */
449
struct mei_device {
450
	struct device *dev;
451 452 453
	struct cdev cdev;
	int minor;

A
Alexander Usyskin 已提交
454 455 456 457
	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;
458 459

	struct list_head file_list;
460
	long open_handle_count;
461

A
Alexander Usyskin 已提交
462 463
	struct mutex device_lock;
	struct delayed_work timer_work;
T
Tomas Winkler 已提交
464 465

	bool recvd_hw_ready;
466 467 468
	/*
	 * waiting queue for receive message from FW
	 */
T
Tomas Winkler 已提交
469
	wait_queue_head_t wait_hw_ready;
470
	wait_queue_head_t wait_pg;
471
	wait_queue_head_t wait_hbm_start;
472 473 474 475 476
	wait_queue_head_t wait_stop_wd;

	/*
	 * mei device  states
	 */
477
	unsigned long reset_count;
478
	enum mei_dev_state dev_state;
T
Tomas Winkler 已提交
479
	enum mei_hbm_state hbm_state;
480 481
	u16 init_clients_timer;

482 483 484 485
	/*
	 * Power Gating support
	 */
	enum mei_pg_event pg_event;
486
#ifdef CONFIG_PM
487
	struct dev_pm_domain pg_domain;
488
#endif /* CONFIG_PM */
489

A
Alexander Usyskin 已提交
490
	unsigned char rd_msg_buf[MEI_RD_MSG_BUF_SIZE];
491
	u32 rd_msg_hdr;
492

493 494 495 496
	/* write buffer */
	u8 hbuf_depth;
	bool hbuf_is_ready;

497 498 499 500 501 502
	/* used for control messages */
	struct {
		struct mei_msg_hdr hdr;
		unsigned char data[128];
	} wr_msg;

503
	struct hbm_version version;
504
	unsigned int hbm_f_pg_supported:1;
T
Tomas Winkler 已提交
505
	unsigned int hbm_f_dc_supported:1;
506

507
	struct rw_semaphore me_clients_rwsem;
508
	struct list_head me_clients;
509 510
	DECLARE_BITMAP(me_clients_map, MEI_CLIENTS_MAX);
	DECLARE_BITMAP(host_clients_map, MEI_CLIENTS_MAX);
511
	unsigned long me_client_index;
512

513 514
	u32 allow_fixed_address;

515
	struct mei_cl wd_cl;
516
	enum mei_wd_states wd_state;
517
	bool wd_pending;
518
	u16 wd_timeout;
519
	unsigned char wd_data[MEI_WD_START_MSG_SIZE];
520 521


522 523 524 525
	/* 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;
526 527
	struct file *iamthif_file_object;
	struct mei_cl iamthif_cl;
528
	struct mei_cl_cb *iamthif_current_cb;
T
Tomas Winkler 已提交
529
	long iamthif_open_count;
530 531 532
	unsigned long iamthif_timer;
	u32 iamthif_stall_timer;
	enum iamthif_states iamthif_state;
533
	bool iamthif_canceled;
534 535

	struct work_struct init_work;
536
	struct work_struct reset_work;
537

538 539
	/* List of bus devices */
	struct list_head device_list;
540
	struct mutex cl_bus_lock;
541

T
Tomas Winkler 已提交
542 543 544 545 546
#if IS_ENABLED(CONFIG_DEBUG_FS)
	struct dentry *dbgfs_dir;
#endif /* CONFIG_DEBUG_FS */


547
	const struct mei_hw_ops *ops;
548
	char hw[0] __aligned(sizeof(void *));
549 550
};

551 552 553 554 555
static inline unsigned long mei_secs_to_jiffies(unsigned long sec)
{
	return msecs_to_jiffies(sec * MSEC_PER_SEC);
}

T
Tomas Winkler 已提交
556 557 558
/**
 * mei_data2slots - get slots - number of (dwords) from a message length
 *	+ size of the mei header
A
Alexander Usyskin 已提交
559
 *
560 561 562
 * @length: size of the messages in bytes
 *
 * Return: number of slots
T
Tomas Winkler 已提交
563 564 565 566 567 568
 */
static inline u32 mei_data2slots(size_t length)
{
	return DIV_ROUND_UP(sizeof(struct mei_msg_hdr) + length, 4);
}

T
Tomas Winkler 已提交
569
/**
A
Alexander Usyskin 已提交
570 571
 * mei_slots2data - get data in slots - bytes from slots
 *
572
 * @slots: number of available slots
A
Alexander Usyskin 已提交
573
 *
574
 * Return: number of bytes in slots
T
Tomas Winkler 已提交
575 576 577 578 579 580
 */
static inline u32 mei_slots2data(int slots)
{
	return slots * 4;
}

581 582 583
/*
 * mei init function prototypes
 */
584 585 586
void mei_device_init(struct mei_device *dev,
		     struct device *device,
		     const struct mei_hw_ops *hw_ops);
587
int mei_reset(struct mei_device *dev);
588
int mei_start(struct mei_device *dev);
589
int mei_restart(struct mei_device *dev);
590
void mei_stop(struct mei_device *dev);
T
Tomas Winkler 已提交
591
void mei_cancel_work(struct mei_device *dev);
592 593 594

/*
 *  MEI interrupt functions prototype
595
 */
596

597
void mei_timer(struct work_struct *work);
598 599 600 601
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);
602
void mei_irq_compl_handler(struct mei_device *dev, struct mei_cl_cb *cmpl_list);
603

604 605 606 607 608
/*
 * AMTHIF - AMT Host Interface Functions
 */
void mei_amthif_reset_params(struct mei_device *dev);

609
int mei_amthif_host_init(struct mei_device *dev, struct mei_me_client *me_cl);
610 611

int mei_amthif_read(struct mei_device *dev, struct file *file,
612 613 614 615
		char __user *ubuf, size_t length, loff_t *offset);

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

617 618
int mei_amthif_release(struct mei_device *dev, struct file *file);

619
struct mei_cl_cb *mei_amthif_find_read_list_entry(struct mei_device *dev,
620 621
						struct file *file);

622 623
int mei_amthif_write(struct mei_cl *cl, struct mei_cl_cb *cb);
int mei_amthif_run_next_cmd(struct mei_device *dev);
624 625
int mei_amthif_irq_write(struct mei_cl *cl, struct mei_cl_cb *cb,
			struct mei_cl_cb *cmpl_list);
626 627

void mei_amthif_complete(struct mei_device *dev, struct mei_cl_cb *cb);
628
int mei_amthif_irq_read_msg(struct mei_cl *cl,
629 630 631 632
			    struct mei_msg_hdr *mei_hdr,
			    struct mei_cl_cb *complete_list);
int mei_amthif_irq_read(struct mei_device *dev, s32 *slots);

633 634 635
/*
 * NFC functions
 */
636
int mei_nfc_host_init(struct mei_device *dev, struct mei_me_client *me_cl);
T
Tomas Winkler 已提交
637
void mei_nfc_host_exit(struct mei_device *dev);
638 639 640 641 642

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

644 645
int mei_wd_send(struct mei_device *dev);
int mei_wd_stop(struct mei_device *dev);
646
int mei_wd_host_init(struct mei_device *dev, struct mei_me_client *me_cl);
647 648 649
/*
 * mei_watchdog_register  - Registering watchdog interface
 *   once we got connection to the WD Client
650
 * @dev: mei device
651
 */
652
int mei_watchdog_register(struct mei_device *dev);
653 654
/*
 * mei_watchdog_unregister  - Unregistering watchdog interface
655
 * @dev: mei device
656 657 658
 */
void mei_watchdog_unregister(struct mei_device *dev);

659 660 661 662
/*
 * Register Access Function
 */

663

664 665 666 667
static inline void mei_hw_config(struct mei_device *dev)
{
	dev->ops->hw_config(dev);
}
668

669 670 671 672 673
static inline enum mei_pg_state mei_pg_state(struct mei_device *dev)
{
	return dev->ops->pg_state(dev);
}

674 675 676 677 678
static inline bool mei_pg_in_transition(struct mei_device *dev)
{
	return dev->ops->pg_in_transition(dev);
}

679 680 681 682 683
static inline bool mei_pg_is_enabled(struct mei_device *dev)
{
	return dev->ops->pg_is_enabled(dev);
}

684
static inline int mei_hw_reset(struct mei_device *dev, bool enable)
685
{
686
	return dev->ops->hw_reset(dev, enable);
687 688
}

689
static inline int mei_hw_start(struct mei_device *dev)
T
Tomas Winkler 已提交
690
{
691
	return dev->ops->hw_start(dev);
T
Tomas Winkler 已提交
692 693
}

694 695 696 697 698 699 700 701 702
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);
}
703

704 705 706 707
static inline void mei_disable_interrupts(struct mei_device *dev)
{
	dev->ops->intr_disable(dev);
}
708

709 710 711 712 713 714 715 716
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);
}
717

718 719 720 721
static inline bool mei_hbuf_is_ready(struct mei_device *dev)
{
	return dev->ops->hbuf_is_ready(dev);
}
722

723 724 725 726
static inline int mei_hbuf_empty_slots(struct mei_device *dev)
{
	return dev->ops->hbuf_free_slots(dev);
}
727

728 729 730 731
static inline size_t mei_hbuf_max_len(const struct mei_device *dev)
{
	return dev->ops->hbuf_max_len(dev);
}
732

733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754
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);
}
755

756 757 758 759 760
static inline int mei_fw_status(struct mei_device *dev,
				struct mei_fw_status *fw_status)
{
	return dev->ops->fw_status(dev, fw_status);
}
761

762 763
bool mei_hbuf_acquire(struct mei_device *dev);

764 765
bool mei_write_is_idle(struct mei_device *dev);

T
Tomas Winkler 已提交
766 767 768 769 770 771 772 773 774 775 776
#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 */

777
int mei_register(struct mei_device *dev, struct device *parent);
T
Tomas Winkler 已提交
778
void mei_deregister(struct mei_device *dev);
779

780
#define MEI_HDR_FMT "hdr:host=%02d me=%02d len=%d internal=%1d comp=%1d"
781 782
#define MEI_HDR_PRM(hdr)                  \
	(hdr)->host_addr, (hdr)->me_addr, \
783
	(hdr)->length, (hdr)->internal, (hdr)->msg_complete
784

785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812
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;
}


813
#endif