345 lines · c
1// SPDX-License-Identifier: GPL-2.02/*3 * Copyright © 2020 - 2021 Intel Corporation4 */5 6/**7 * DOC: MEI_PXP Client Driver8 *9 * The mei_pxp driver acts as a translation layer between PXP10 * protocol implementer (I915) and ME FW by translating PXP11 * 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 27static 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 succeed38 */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_device48 * @message: a message buffer to send49 * @size: size of the message50 * @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 choose58 * to abandon with the same thread id.59 * -ETIME : Request is timed out.60 * Caller may attempt to try again immediately.61 */62static int63mei_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_device97 * @buffer: a message buffer to contain the received message98 * @size: size of the buffer99 * @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 calling107 * (with a different owning thread) to retrieve existing unclaimed response108 * (and may discard it).109 * -ETIME : Request is timed out.110 * Caller may attempt to try again from send immediately.111 */112static int113mei_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 125retry: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 sending153 * a sgl mei message to gsc and receiving reply from gsc154 *155 * @dev: device corresponding to the mei_cl_device156 * @client_id: client id to send the command to157 * @fence_id: fence id to send the command to158 * @sg_in: scatter gather list containing addresses for rx message buffer159 * @total_in_len: total length of data in 'in' sg, can be less than the sum of buffers sizes160 * @sg_out: scatter gather list containing addresses for tx message buffer161 *162 * Return: bytes sent on Success, <0 on Failure163 */164static 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 175static 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 182static 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 197static 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 205static 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 PXP214 * and the grand parent of pxp and the parent of i915 are the same215 * PCH device.216 *217 * @dev: master device218 * @subcomponent: subcomponent to match (I915_COMPONENT_PXP)219 * @data: compare data (mei pxp device)220 *221 * Return:222 * * 1 - if components match223 * * 0 - otherwise224 */225static 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 263static 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 301err_exit:302 mei_cldev_set_drvdata(cldev, NULL);303 kfree(comp_master);304 mei_cldev_disable(cldev);305enable_err_exit:306 return ret;307}308 309static 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 327static struct mei_cl_device_id mei_pxp_tbl[] = {328 { .uuid = MEI_GUID_PXP, .version = MEI_CL_VERSION_ANY },329 { }330};331MODULE_DEVICE_TABLE(mei, mei_pxp_tbl);332 333static 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 340module_mei_cl_driver(mei_pxp_driver);341 342MODULE_AUTHOR("Intel Corporation");343MODULE_LICENSE("GPL");344MODULE_DESCRIPTION("MEI PXP");345