Loading...
1/*
2 *
3 * Intel Management Engine Interface (Intel MEI) Linux driver
4 * Copyright (c) 2003-2012, Intel Corporation.
5 *
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms and conditions of the GNU General Public License,
8 * version 2, as published by the Free Software Foundation.
9 *
10 * This program is distributed in the hope it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
13 * more details.
14 *
15 */
16
17#ifndef _MEI_CLIENT_H_
18#define _MEI_CLIENT_H_
19
20#include <linux/types.h>
21#include <linux/watchdog.h>
22#include <linux/poll.h>
23#include <linux/mei.h>
24
25#include "mei_dev.h"
26
27int mei_me_cl_by_uuid(const struct mei_device *dev, const uuid_le *cuuid);
28int mei_me_cl_by_id(struct mei_device *dev, u8 client_id);
29
30/*
31 * MEI IO Functions
32 */
33struct mei_cl_cb *mei_io_cb_init(struct mei_cl *cl, struct file *fp);
34void mei_io_cb_free(struct mei_cl_cb *priv_cb);
35int mei_io_cb_alloc_req_buf(struct mei_cl_cb *cb, size_t length);
36int mei_io_cb_alloc_resp_buf(struct mei_cl_cb *cb, size_t length);
37
38
39/**
40 * mei_io_list_init - Sets up a queue list.
41 *
42 * @list: An instance cl callback structure
43 */
44static inline void mei_io_list_init(struct mei_cl_cb *list)
45{
46 INIT_LIST_HEAD(&list->list);
47}
48/*
49 * MEI Host Client Functions
50 */
51
52struct mei_cl *mei_cl_allocate(struct mei_device *dev);
53void mei_cl_init(struct mei_cl *cl, struct mei_device *dev);
54
55
56int mei_cl_link(struct mei_cl *cl, int id);
57int mei_cl_unlink(struct mei_cl *cl);
58
59int mei_cl_flush_queues(struct mei_cl *cl);
60struct mei_cl_cb *mei_cl_find_read_cb(struct mei_cl *cl);
61
62
63int mei_cl_flow_ctrl_creds(struct mei_cl *cl);
64
65int mei_cl_flow_ctrl_reduce(struct mei_cl *cl);
66/*
67 * MEI input output function prototype
68 */
69static inline bool mei_cl_is_connected(struct mei_cl *cl)
70{
71 return cl->dev &&
72 cl->dev->dev_state == MEI_DEV_ENABLED &&
73 cl->state == MEI_FILE_CONNECTED;
74}
75static inline bool mei_cl_is_transitioning(struct mei_cl *cl)
76{
77 return MEI_FILE_INITIALIZING == cl->state ||
78 MEI_FILE_DISCONNECTED == cl->state ||
79 MEI_FILE_DISCONNECTING == cl->state;
80}
81
82bool mei_cl_is_other_connecting(struct mei_cl *cl);
83int mei_cl_disconnect(struct mei_cl *cl);
84int mei_cl_connect(struct mei_cl *cl, struct file *file);
85int mei_cl_read_start(struct mei_cl *cl, size_t length);
86int mei_cl_write(struct mei_cl *cl, struct mei_cl_cb *cb, bool blocking);
87int mei_cl_irq_write(struct mei_cl *cl, struct mei_cl_cb *cb,
88 struct mei_cl_cb *cmpl_list);
89
90void mei_cl_complete(struct mei_cl *cl, struct mei_cl_cb *cb);
91
92void mei_host_client_init(struct work_struct *work);
93
94
95
96void mei_cl_all_disconnect(struct mei_device *dev);
97void mei_cl_all_wakeup(struct mei_device *dev);
98void mei_cl_all_write_clear(struct mei_device *dev);
99
100#define MEI_CL_FMT "cl:host=%02d me=%02d "
101#define MEI_CL_PRM(cl) (cl)->host_client_id, (cl)->me_client_id
102
103#define cl_dbg(dev, cl, format, arg...) \
104 dev_dbg(&(dev)->pdev->dev, MEI_CL_FMT format, MEI_CL_PRM(cl), ##arg)
105
106#define cl_err(dev, cl, format, arg...) \
107 dev_err(&(dev)->pdev->dev, MEI_CL_FMT format, MEI_CL_PRM(cl), ##arg)
108
109#endif /* _MEI_CLIENT_H_ */
1/* SPDX-License-Identifier: GPL-2.0 */
2/*
3 * Copyright (c) 2003-2018, Intel Corporation. All rights reserved.
4 * Intel Management Engine Interface (Intel MEI) Linux driver
5 */
6
7#ifndef _MEI_CLIENT_H_
8#define _MEI_CLIENT_H_
9
10#include <linux/types.h>
11#include <linux/poll.h>
12#include <linux/mei.h>
13
14#include "mei_dev.h"
15
16/*
17 * reference counting base function
18 */
19void mei_me_cl_init(struct mei_me_client *me_cl);
20void mei_me_cl_put(struct mei_me_client *me_cl);
21struct mei_me_client *mei_me_cl_get(struct mei_me_client *me_cl);
22
23void mei_me_cl_add(struct mei_device *dev, struct mei_me_client *me_cl);
24void mei_me_cl_del(struct mei_device *dev, struct mei_me_client *me_cl);
25
26struct mei_me_client *mei_me_cl_by_uuid(struct mei_device *dev,
27 const uuid_le *uuid);
28struct mei_me_client *mei_me_cl_by_id(struct mei_device *dev, u8 client_id);
29struct mei_me_client *mei_me_cl_by_uuid_id(struct mei_device *dev,
30 const uuid_le *uuid, u8 client_id);
31void mei_me_cl_rm_by_uuid(struct mei_device *dev, const uuid_le *uuid);
32void mei_me_cl_rm_by_uuid_id(struct mei_device *dev,
33 const uuid_le *uuid, u8 id);
34void mei_me_cl_rm_all(struct mei_device *dev);
35
36/**
37 * mei_me_cl_is_active - check whether me client is active in the fw
38 *
39 * @me_cl: me client
40 *
41 * Return: true if the me client is active in the firmware
42 */
43static inline bool mei_me_cl_is_active(const struct mei_me_client *me_cl)
44{
45 return !list_empty_careful(&me_cl->list);
46}
47
48/**
49 * mei_me_cl_uuid - return me client protocol name (uuid)
50 *
51 * @me_cl: me client
52 *
53 * Return: me client protocol name
54 */
55static inline const uuid_le *mei_me_cl_uuid(const struct mei_me_client *me_cl)
56{
57 return &me_cl->props.protocol_name;
58}
59
60/**
61 * mei_me_cl_ver - return me client protocol version
62 *
63 * @me_cl: me client
64 *
65 * Return: me client protocol version
66 */
67static inline u8 mei_me_cl_ver(const struct mei_me_client *me_cl)
68{
69 return me_cl->props.protocol_version;
70}
71
72/*
73 * MEI IO Functions
74 */
75void mei_io_cb_free(struct mei_cl_cb *priv_cb);
76
77/*
78 * MEI Host Client Functions
79 */
80
81struct mei_cl *mei_cl_allocate(struct mei_device *dev);
82
83int mei_cl_link(struct mei_cl *cl);
84int mei_cl_unlink(struct mei_cl *cl);
85
86struct mei_cl *mei_cl_alloc_linked(struct mei_device *dev);
87
88struct mei_cl_cb *mei_cl_read_cb(const struct mei_cl *cl,
89 const struct file *fp);
90struct mei_cl_cb *mei_cl_alloc_cb(struct mei_cl *cl, size_t length,
91 enum mei_cb_file_ops type,
92 const struct file *fp);
93struct mei_cl_cb *mei_cl_enqueue_ctrl_wr_cb(struct mei_cl *cl, size_t length,
94 enum mei_cb_file_ops type,
95 const struct file *fp);
96int mei_cl_flush_queues(struct mei_cl *cl, const struct file *fp);
97
98/*
99 * MEI input output function prototype
100 */
101
102/**
103 * mei_cl_is_connected - host client is connected
104 *
105 * @cl: host client
106 *
107 * Return: true if the host client is connected
108 */
109static inline bool mei_cl_is_connected(struct mei_cl *cl)
110{
111 return cl->state == MEI_FILE_CONNECTED;
112}
113
114/**
115 * mei_cl_me_id - me client id
116 *
117 * @cl: host client
118 *
119 * Return: me client id or 0 if client is not connected
120 */
121static inline u8 mei_cl_me_id(const struct mei_cl *cl)
122{
123 return cl->me_cl ? cl->me_cl->client_id : 0;
124}
125
126/**
127 * mei_cl_mtu - maximal message that client can send and receive
128 *
129 * @cl: host client
130 *
131 * Return: mtu
132 */
133static inline size_t mei_cl_mtu(const struct mei_cl *cl)
134{
135 return cl->me_cl->props.max_msg_length;
136}
137
138/**
139 * mei_cl_is_fixed_address - check whether the me client uses fixed address
140 *
141 * @cl: host client
142 *
143 * Return: true if the client is connected and it has fixed me address
144 */
145static inline bool mei_cl_is_fixed_address(const struct mei_cl *cl)
146{
147 return cl->me_cl && cl->me_cl->props.fixed_address;
148}
149
150/**
151 * mei_cl_is_single_recv_buf- check whether the me client
152 * uses single receiving buffer
153 *
154 * @cl: host client
155 *
156 * Return: true if single_recv_buf == 1; 0 otherwise
157 */
158static inline bool mei_cl_is_single_recv_buf(const struct mei_cl *cl)
159{
160 return cl->me_cl->props.single_recv_buf;
161}
162
163/**
164 * mei_cl_uuid - client's uuid
165 *
166 * @cl: host client
167 *
168 * Return: return uuid of connected me client
169 */
170static inline const uuid_le *mei_cl_uuid(const struct mei_cl *cl)
171{
172 return mei_me_cl_uuid(cl->me_cl);
173}
174
175/**
176 * mei_cl_host_addr - client's host address
177 *
178 * @cl: host client
179 *
180 * Return: 0 for fixed address client, host address for dynamic client
181 */
182static inline u8 mei_cl_host_addr(const struct mei_cl *cl)
183{
184 return mei_cl_is_fixed_address(cl) ? 0 : cl->host_client_id;
185}
186
187int mei_cl_disconnect(struct mei_cl *cl);
188int mei_cl_irq_disconnect(struct mei_cl *cl, struct mei_cl_cb *cb,
189 struct list_head *cmpl_list);
190int mei_cl_connect(struct mei_cl *cl, struct mei_me_client *me_cl,
191 const struct file *file);
192int mei_cl_irq_connect(struct mei_cl *cl, struct mei_cl_cb *cb,
193 struct list_head *cmpl_list);
194int mei_cl_read_start(struct mei_cl *cl, size_t length, const struct file *fp);
195ssize_t mei_cl_write(struct mei_cl *cl, struct mei_cl_cb *cb);
196int mei_cl_irq_write(struct mei_cl *cl, struct mei_cl_cb *cb,
197 struct list_head *cmpl_list);
198
199void mei_cl_complete(struct mei_cl *cl, struct mei_cl_cb *cb);
200
201void mei_host_client_init(struct mei_device *dev);
202
203u8 mei_cl_notify_fop2req(enum mei_cb_file_ops fop);
204enum mei_cb_file_ops mei_cl_notify_req2fop(u8 request);
205int mei_cl_notify_request(struct mei_cl *cl,
206 const struct file *file, u8 request);
207int mei_cl_irq_notify(struct mei_cl *cl, struct mei_cl_cb *cb,
208 struct list_head *cmpl_list);
209int mei_cl_notify_get(struct mei_cl *cl, bool block, bool *notify_ev);
210void mei_cl_notify(struct mei_cl *cl);
211
212void mei_cl_all_disconnect(struct mei_device *dev);
213
214#define MEI_CL_FMT "cl:host=%02d me=%02d "
215#define MEI_CL_PRM(cl) (cl)->host_client_id, mei_cl_me_id(cl)
216
217#define cl_dbg(dev, cl, format, arg...) \
218 dev_dbg((dev)->dev, MEI_CL_FMT format, MEI_CL_PRM(cl), ##arg)
219
220#define cl_warn(dev, cl, format, arg...) \
221 dev_warn((dev)->dev, MEI_CL_FMT format, MEI_CL_PRM(cl), ##arg)
222
223#define cl_err(dev, cl, format, arg...) \
224 dev_err((dev)->dev, MEI_CL_FMT format, MEI_CL_PRM(cl), ##arg)
225
226#endif /* _MEI_CLIENT_H_ */