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/module.h>
15 #include <linux/slab.h>
16 #include <linux/mei.h>
17 #include <linux/mei_cl_bus.h>
18 #include <linux/component.h>
19 #include <drm/drm_connector.h>
20 #include <drm/i915_component.h>
21 #include <drm/i915_pxp_tee_interface.h>
22
23 #include "mei_pxp.h"
24
25 /**
26 * mei_pxp_send_message() - Sends a PXP message to ME FW.
27 * @dev: device corresponding to the mei_cl_device
28 * @message: a message buffer to send
29 * @size: size of the message
30 * Return: 0 on Success, <0 on Failure
31 */
32 static int
mei_pxp_send_message(struct device * dev,const void * message,size_t size)33 mei_pxp_send_message(struct device *dev, const void *message, size_t size)
34 {
35 struct mei_cl_device *cldev;
36 ssize_t byte;
37
38 if (!dev || !message)
39 return -EINVAL;
40
41 cldev = to_mei_cl_device(dev);
42
43 byte = mei_cldev_send(cldev, message, size);
44 if (byte < 0) {
45 dev_dbg(dev, "mei_cldev_send failed. %zd\n", byte);
46 return byte;
47 }
48
49 return 0;
50 }
51
52 /**
53 * mei_pxp_receive_message() - Receives a PXP message from ME FW.
54 * @dev: device corresponding to the mei_cl_device
55 * @buffer: a message buffer to contain the received message
56 * @size: size of the buffer
57 * Return: bytes sent on Success, <0 on Failure
58 */
59 static int
mei_pxp_receive_message(struct device * dev,void * buffer,size_t size)60 mei_pxp_receive_message(struct device *dev, void *buffer, size_t size)
61 {
62 struct mei_cl_device *cldev;
63 ssize_t byte;
64
65 if (!dev || !buffer)
66 return -EINVAL;
67
68 cldev = to_mei_cl_device(dev);
69
70 byte = mei_cldev_recv(cldev, buffer, size);
71 if (byte < 0) {
72 dev_dbg(dev, "mei_cldev_recv failed. %zd\n", byte);
73 return byte;
74 }
75
76 return byte;
77 }
78
79 /**
80 * mei_pxp_gsc_command() - sends a gsc command, by sending
81 * a sgl mei message to gsc and receiving reply from gsc
82 *
83 * @dev: device corresponding to the mei_cl_device
84 * @client_id: client id to send the command to
85 * @fence_id: fence id to send the command to
86 * @sg_in: scatter gather list containing addresses for rx message buffer
87 * @total_in_len: total length of data in 'in' sg, can be less than the sum of buffers sizes
88 * @sg_out: scatter gather list containing addresses for tx message buffer
89 *
90 * Return: bytes sent on Success, <0 on Failure
91 */
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)92 static ssize_t mei_pxp_gsc_command(struct device *dev, u8 client_id, u32 fence_id,
93 struct scatterlist *sg_in, size_t total_in_len,
94 struct scatterlist *sg_out)
95 {
96 struct mei_cl_device *cldev;
97
98 cldev = to_mei_cl_device(dev);
99
100 return mei_cldev_send_gsc_command(cldev, client_id, fence_id, sg_in, total_in_len, sg_out);
101 }
102
103 static const struct i915_pxp_component_ops mei_pxp_ops = {
104 .owner = THIS_MODULE,
105 .send = mei_pxp_send_message,
106 .recv = mei_pxp_receive_message,
107 .gsc_command = mei_pxp_gsc_command,
108 };
109
mei_component_master_bind(struct device * dev)110 static int mei_component_master_bind(struct device *dev)
111 {
112 struct mei_cl_device *cldev = to_mei_cl_device(dev);
113 struct i915_pxp_component *comp_master = mei_cldev_get_drvdata(cldev);
114 int ret;
115
116 comp_master->ops = &mei_pxp_ops;
117 comp_master->tee_dev = dev;
118 ret = component_bind_all(dev, comp_master);
119 if (ret < 0)
120 return ret;
121
122 return 0;
123 }
124
mei_component_master_unbind(struct device * dev)125 static void mei_component_master_unbind(struct device *dev)
126 {
127 struct mei_cl_device *cldev = to_mei_cl_device(dev);
128 struct i915_pxp_component *comp_master = mei_cldev_get_drvdata(cldev);
129
130 component_unbind_all(dev, comp_master);
131 }
132
133 static const struct component_master_ops mei_component_master_ops = {
134 .bind = mei_component_master_bind,
135 .unbind = mei_component_master_unbind,
136 };
137
138 /**
139 * mei_pxp_component_match - compare function for matching mei pxp.
140 *
141 * The function checks if the driver is i915, the subcomponent is PXP
142 * and the grand parent of pxp and the parent of i915 are the same
143 * PCH device.
144 *
145 * @dev: master device
146 * @subcomponent: subcomponent to match (I915_COMPONENT_PXP)
147 * @data: compare data (mei pxp device)
148 *
149 * Return:
150 * * 1 - if components match
151 * * 0 - otherwise
152 */
mei_pxp_component_match(struct device * dev,int subcomponent,void * data)153 static int mei_pxp_component_match(struct device *dev, int subcomponent,
154 void *data)
155 {
156 struct device *base = data;
157
158 if (!dev)
159 return 0;
160
161 if (!dev->driver || strcmp(dev->driver->name, "i915") ||
162 subcomponent != I915_COMPONENT_PXP)
163 return 0;
164
165 base = base->parent;
166 if (!base) /* mei device */
167 return 0;
168
169 base = base->parent; /* pci device */
170 /* for dgfx */
171 if (base && dev == base)
172 return 1;
173
174 /* for pch */
175 dev = dev->parent;
176 return (base && dev && dev == base);
177 }
178
mei_pxp_probe(struct mei_cl_device * cldev,const struct mei_cl_device_id * id)179 static int mei_pxp_probe(struct mei_cl_device *cldev,
180 const struct mei_cl_device_id *id)
181 {
182 struct i915_pxp_component *comp_master;
183 struct component_match *master_match;
184 int ret;
185
186 ret = mei_cldev_enable(cldev);
187 if (ret < 0) {
188 dev_err(&cldev->dev, "mei_cldev_enable Failed. %d\n", ret);
189 goto enable_err_exit;
190 }
191
192 comp_master = kzalloc(sizeof(*comp_master), GFP_KERNEL);
193 if (!comp_master) {
194 ret = -ENOMEM;
195 goto err_exit;
196 }
197
198 master_match = NULL;
199 component_match_add_typed(&cldev->dev, &master_match,
200 mei_pxp_component_match, &cldev->dev);
201 if (IS_ERR_OR_NULL(master_match)) {
202 ret = -ENOMEM;
203 goto err_exit;
204 }
205
206 mei_cldev_set_drvdata(cldev, comp_master);
207 ret = component_master_add_with_match(&cldev->dev,
208 &mei_component_master_ops,
209 master_match);
210 if (ret < 0) {
211 dev_err(&cldev->dev, "Master comp add failed %d\n", ret);
212 goto err_exit;
213 }
214
215 return 0;
216
217 err_exit:
218 mei_cldev_set_drvdata(cldev, NULL);
219 kfree(comp_master);
220 mei_cldev_disable(cldev);
221 enable_err_exit:
222 return ret;
223 }
224
mei_pxp_remove(struct mei_cl_device * cldev)225 static void mei_pxp_remove(struct mei_cl_device *cldev)
226 {
227 struct i915_pxp_component *comp_master = mei_cldev_get_drvdata(cldev);
228 int ret;
229
230 component_master_del(&cldev->dev, &mei_component_master_ops);
231 kfree(comp_master);
232 mei_cldev_set_drvdata(cldev, NULL);
233
234 ret = mei_cldev_disable(cldev);
235 if (ret)
236 dev_warn(&cldev->dev, "mei_cldev_disable() failed\n");
237 }
238
239 /* fbf6fcf1-96cf-4e2e-a6a6-1bab8cbe36b1 : PAVP GUID*/
240 #define MEI_GUID_PXP UUID_LE(0xfbf6fcf1, 0x96cf, 0x4e2e, 0xA6, \
241 0xa6, 0x1b, 0xab, 0x8c, 0xbe, 0x36, 0xb1)
242
243 static struct mei_cl_device_id mei_pxp_tbl[] = {
244 { .uuid = MEI_GUID_PXP, .version = MEI_CL_VERSION_ANY },
245 { }
246 };
247 MODULE_DEVICE_TABLE(mei, mei_pxp_tbl);
248
249 static struct mei_cl_driver mei_pxp_driver = {
250 .id_table = mei_pxp_tbl,
251 .name = KBUILD_MODNAME,
252 .probe = mei_pxp_probe,
253 .remove = mei_pxp_remove,
254 };
255
256 module_mei_cl_driver(mei_pxp_driver);
257
258 MODULE_AUTHOR("Intel Corporation");
259 MODULE_LICENSE("GPL");
260 MODULE_DESCRIPTION("MEI PXP");
261