1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Copyright © 2020 - 2021 Intel Corporation
4 */
5
6 /**
7 * DOC: MEI_PXP Client Driver
8 *
9 * The mei_pxp driver acts as a translation layer between PXP
10 * protocol implementer (I915) and ME FW by translating PXP
11 * negotiation messages to ME FW command payloads and vice versa.
12 */
13
14 #include <linux/delay.h>
15 #include <linux/module.h>
16 #include <linux/pci.h>
17 #include <linux/slab.h>
18 #include <linux/mei.h>
19 #include <linux/mei_cl_bus.h>
20 #include <linux/component.h>
21 #include <drm/drm_connector.h>
22 #include <drm/intel/i915_component.h>
23 #include <drm/intel/i915_pxp_tee_interface.h>
24
25 #include "mei_pxp.h"
26
mei_pxp_reenable(const struct device * dev,struct mei_cl_device * cldev)27 static inline int mei_pxp_reenable(const struct device *dev, struct mei_cl_device *cldev)
28 {
29 int ret;
30
31 dev_warn(dev, "Trying to reset the channel...\n");
32 ret = mei_cldev_disable(cldev);
33 if (ret < 0)
34 dev_warn(dev, "mei_cldev_disable failed. %d\n", ret);
35 /*
36 * Explicitly ignoring disable failure,
37 * enable may fix the states and succeed
38 */
39 ret = mei_cldev_enable(cldev);
40 if (ret < 0)
41 dev_err(dev, "mei_cldev_enable failed. %d\n", ret);
42 return ret;
43 }
44
45 /**
46 * mei_pxp_send_message() - Sends a PXP message to ME FW.
47 * @dev: device corresponding to the mei_cl_device
48 * @message: a message buffer to send
49 * @size: size of the message
50 * @timeout_ms: timeout in milliseconds, zero means wait indefinitely.
51 *
52 * Returns: 0 on Success, <0 on Failure with the following defined failures.
53 * -ENODEV: Client was not connected.
54 * Caller may attempt to try again immediately.
55 * -ENOMEM: Internal memory allocation failure experienced.
56 * Caller may sleep to allow kernel reclaim before retrying.
57 * -EINTR : Calling thread received a signal. Caller may choose
58 * to abandon with the same thread id.
59 * -ETIME : Request is timed out.
60 * Caller may attempt to try again immediately.
61 */
62 static int
mei_pxp_send_message(struct device * dev,const void * message,size_t size,unsigned long timeout_ms)63 mei_pxp_send_message(struct device *dev, const void *message, size_t size, unsigned long timeout_ms)
64 {
65 struct mei_cl_device *cldev;
66 ssize_t byte;
67 int ret;
68
69 if (!dev || !message)
70 return -EINVAL;
71
72 cldev = to_mei_cl_device(dev);
73
74 byte = mei_cldev_send_timeout(cldev, message, size, timeout_ms);
75 if (byte < 0) {
76 dev_dbg(dev, "mei_cldev_send failed. %zd\n", byte);
77 switch (byte) {
78 case -ENOMEM:
79 fallthrough;
80 case -ENODEV:
81 fallthrough;
82 case -ETIME:
83 ret = mei_pxp_reenable(dev, cldev);
84 if (ret)
85 byte = ret;
86 break;
87 }
88 return byte;
89 }
90
91 return 0;
92 }
93
94 /**
95 * mei_pxp_receive_message() - Receives a PXP message from ME FW.
96 * @dev: device corresponding to the mei_cl_device
97 * @buffer: a message buffer to contain the received message
98 * @size: size of the buffer
99 * @timeout_ms: timeout in milliseconds, zero means wait indefinitely.
100 *
101 * Returns: number of bytes send on Success, <0 on Failure with the following defined failures.
102 * -ENODEV: Client was not connected.
103 * Caller may attempt to try again from send immediately.
104 * -ENOMEM: Internal memory allocation failure experienced.
105 * Caller may sleep to allow kernel reclaim before retrying.
106 * -EINTR : Calling thread received a signal. Caller will need to repeat calling
107 * (with a different owning thread) to retrieve existing unclaimed response
108 * (and may discard it).
109 * -ETIME : Request is timed out.
110 * Caller may attempt to try again from send immediately.
111 */
112 static int
mei_pxp_receive_message(struct device * dev,void * buffer,size_t size,unsigned long timeout_ms)113 mei_pxp_receive_message(struct device *dev, void *buffer, size_t size, unsigned long timeout_ms)
114 {
115 struct mei_cl_device *cldev;
116 ssize_t byte;
117 bool retry = false;
118 int ret;
119
120 if (!dev || !buffer)
121 return -EINVAL;
122
123 cldev = to_mei_cl_device(dev);
124
125 retry:
126 byte = mei_cldev_recv_timeout(cldev, buffer, size, timeout_ms);
127 if (byte < 0) {
128 dev_dbg(dev, "mei_cldev_recv failed. %zd\n", byte);
129 switch (byte) {
130 case -ENOMEM:
131 /* Retry the read when pages are reclaimed */
132 msleep(20);
133 if (!retry) {
134 retry = true;
135 goto retry;
136 }
137 fallthrough;
138 case -ENODEV:
139 fallthrough;
140 case -ETIME:
141 ret = mei_pxp_reenable(dev, cldev);
142 if (ret)
143 byte = ret;
144 break;
145 }
146 }
147
148 return byte;
149 }
150
151 /**
152 * mei_pxp_gsc_command() - sends a gsc command, by sending
153 * a sgl mei message to gsc and receiving reply from gsc
154 *
155 * @dev: device corresponding to the mei_cl_device
156 * @client_id: client id to send the command to
157 * @fence_id: fence id to send the command to
158 * @sg_in: scatter gather list containing addresses for rx message buffer
159 * @total_in_len: total length of data in 'in' sg, can be less than the sum of buffers sizes
160 * @sg_out: scatter gather list containing addresses for tx message buffer
161 *
162 * Return: bytes sent on Success, <0 on Failure
163 */
mei_pxp_gsc_command(struct device * dev,u8 client_id,u32 fence_id,struct scatterlist * sg_in,size_t total_in_len,struct scatterlist * sg_out)164 static ssize_t mei_pxp_gsc_command(struct device *dev, u8 client_id, u32 fence_id,
165 struct scatterlist *sg_in, size_t total_in_len,
166 struct scatterlist *sg_out)
167 {
168 struct mei_cl_device *cldev;
169
170 cldev = to_mei_cl_device(dev);
171
172 return mei_cldev_send_gsc_command(cldev, client_id, fence_id, sg_in, total_in_len, sg_out);
173 }
174
175 static const struct i915_pxp_component_ops mei_pxp_ops = {
176 .owner = THIS_MODULE,
177 .send = mei_pxp_send_message,
178 .recv = mei_pxp_receive_message,
179 .gsc_command = mei_pxp_gsc_command,
180 };
181
mei_component_master_bind(struct device * dev)182 static int mei_component_master_bind(struct device *dev)
183 {
184 struct mei_cl_device *cldev = to_mei_cl_device(dev);
185 struct i915_pxp_component *comp_master = mei_cldev_get_drvdata(cldev);
186 int ret;
187
188 comp_master->ops = &mei_pxp_ops;
189 comp_master->tee_dev = dev;
190 ret = component_bind_all(dev, comp_master);
191 if (ret < 0)
192 return ret;
193
194 return 0;
195 }
196
mei_component_master_unbind(struct device * dev)197 static void mei_component_master_unbind(struct device *dev)
198 {
199 struct mei_cl_device *cldev = to_mei_cl_device(dev);
200 struct i915_pxp_component *comp_master = mei_cldev_get_drvdata(cldev);
201
202 component_unbind_all(dev, comp_master);
203 }
204
205 static const struct component_master_ops mei_component_master_ops = {
206 .bind = mei_component_master_bind,
207 .unbind = mei_component_master_unbind,
208 };
209
210 /**
211 * mei_pxp_component_match - compare function for matching mei pxp.
212 *
213 * The function checks if the driver is i915, the subcomponent is PXP
214 * and the grand parent of pxp and the parent of i915 are the same
215 * PCH device.
216 *
217 * @dev: master device
218 * @subcomponent: subcomponent to match (I915_COMPONENT_PXP)
219 * @data: compare data (mei pxp device)
220 *
221 * Return:
222 * * 1 - if components match
223 * * 0 - otherwise
224 */
mei_pxp_component_match(struct device * dev,int subcomponent,void * data)225 static int mei_pxp_component_match(struct device *dev, int subcomponent,
226 void *data)
227 {
228 struct device *base = data;
229 struct pci_dev *pdev;
230
231 if (!dev)
232 return 0;
233
234 if (!dev_is_pci(dev))
235 return 0;
236
237 pdev = to_pci_dev(dev);
238
239 if (pdev->vendor != PCI_VENDOR_ID_INTEL)
240 return 0;
241
242 if (pdev->class != (PCI_CLASS_DISPLAY_VGA << 8) &&
243 pdev->class != (PCI_CLASS_DISPLAY_OTHER << 8))
244 return 0;
245
246 if (subcomponent != I915_COMPONENT_PXP)
247 return 0;
248
249 base = base->parent;
250 if (!base) /* mei device */
251 return 0;
252
253 base = base->parent; /* pci device */
254 /* for dgfx */
255 if (base && dev == base)
256 return 1;
257
258 /* for pch */
259 dev = dev->parent;
260 return (base && dev && dev == base);
261 }
262
mei_pxp_probe(struct mei_cl_device * cldev,const struct mei_cl_device_id * id)263 static int mei_pxp_probe(struct mei_cl_device *cldev,
264 const struct mei_cl_device_id *id)
265 {
266 struct i915_pxp_component *comp_master;
267 struct component_match *master_match;
268 int ret;
269
270 ret = mei_cldev_enable(cldev);
271 if (ret < 0) {
272 dev_err(&cldev->dev, "mei_cldev_enable Failed. %d\n", ret);
273 goto enable_err_exit;
274 }
275
276 comp_master = kzalloc(sizeof(*comp_master), GFP_KERNEL);
277 if (!comp_master) {
278 ret = -ENOMEM;
279 goto err_exit;
280 }
281
282 master_match = NULL;
283 component_match_add_typed(&cldev->dev, &master_match,
284 mei_pxp_component_match, &cldev->dev);
285 if (IS_ERR_OR_NULL(master_match)) {
286 ret = -ENOMEM;
287 goto err_exit;
288 }
289
290 mei_cldev_set_drvdata(cldev, comp_master);
291 ret = component_master_add_with_match(&cldev->dev,
292 &mei_component_master_ops,
293 master_match);
294 if (ret < 0) {
295 dev_err(&cldev->dev, "Master comp add failed %d\n", ret);
296 goto err_exit;
297 }
298
299 return 0;
300
301 err_exit:
302 mei_cldev_set_drvdata(cldev, NULL);
303 kfree(comp_master);
304 mei_cldev_disable(cldev);
305 enable_err_exit:
306 return ret;
307 }
308
mei_pxp_remove(struct mei_cl_device * cldev)309 static void mei_pxp_remove(struct mei_cl_device *cldev)
310 {
311 struct i915_pxp_component *comp_master = mei_cldev_get_drvdata(cldev);
312 int ret;
313
314 component_master_del(&cldev->dev, &mei_component_master_ops);
315 kfree(comp_master);
316 mei_cldev_set_drvdata(cldev, NULL);
317
318 ret = mei_cldev_disable(cldev);
319 if (ret)
320 dev_warn(&cldev->dev, "mei_cldev_disable() failed\n");
321 }
322
323 /* fbf6fcf1-96cf-4e2e-a6a6-1bab8cbe36b1 : PAVP GUID*/
324 #define MEI_GUID_PXP UUID_LE(0xfbf6fcf1, 0x96cf, 0x4e2e, 0xA6, \
325 0xa6, 0x1b, 0xab, 0x8c, 0xbe, 0x36, 0xb1)
326
327 static struct mei_cl_device_id mei_pxp_tbl[] = {
328 { .uuid = MEI_GUID_PXP, .version = MEI_CL_VERSION_ANY },
329 { }
330 };
331 MODULE_DEVICE_TABLE(mei, mei_pxp_tbl);
332
333 static struct mei_cl_driver mei_pxp_driver = {
334 .id_table = mei_pxp_tbl,
335 .name = KBUILD_MODNAME,
336 .probe = mei_pxp_probe,
337 .remove = mei_pxp_remove,
338 };
339
340 module_mei_cl_driver(mei_pxp_driver);
341
342 MODULE_AUTHOR("Intel Corporation");
343 MODULE_LICENSE("GPL");
344 MODULE_DESCRIPTION("MEI PXP");
345