319 lines · c
1// SPDX-License-Identifier: GPL-2.02 3#include <linux/i2c.h>4#include <linux/pci.h>5#include <linux/psp-platform-access.h>6#include <linux/psp.h>7#include <linux/workqueue.h>8 9#include "i2c-designware-core.h"10 11#define PSP_I2C_RESERVATION_TIME_MS 10012 13#define PSP_I2C_REQ_RETRY_CNT 40014#define PSP_I2C_REQ_RETRY_DELAY_US (25 * USEC_PER_MSEC)15#define PSP_I2C_REQ_STS_OK 0x016#define PSP_I2C_REQ_STS_BUS_BUSY 0x117#define PSP_I2C_REQ_STS_INV_PARAM 0x318 19enum psp_i2c_req_type {20 PSP_I2C_REQ_ACQUIRE,21 PSP_I2C_REQ_RELEASE,22 PSP_I2C_REQ_MAX23};24 25struct psp_i2c_req {26 struct psp_req_buffer_hdr hdr;27 enum psp_i2c_req_type type;28};29 30static DEFINE_MUTEX(psp_i2c_access_mutex);31static unsigned long psp_i2c_sem_acquired;32static u32 psp_i2c_access_count;33static bool psp_i2c_mbox_fail;34static struct device *psp_i2c_dev;35 36static int (*_psp_send_i2c_req)(struct psp_i2c_req *req);37 38/* Helper to verify status returned by PSP */39static int check_i2c_req_sts(struct psp_i2c_req *req)40{41 u32 status;42 43 /* Status field in command-response buffer is updated by PSP */44 status = READ_ONCE(req->hdr.status);45 46 switch (status) {47 case PSP_I2C_REQ_STS_OK:48 return 0;49 case PSP_I2C_REQ_STS_BUS_BUSY:50 return -EBUSY;51 case PSP_I2C_REQ_STS_INV_PARAM:52 default:53 return -EIO;54 }55}56 57/*58 * Errors in x86-PSP i2c-arbitration protocol may occur at two levels:59 * 1. mailbox communication - PSP is not operational or some IO errors with60 * basic communication had happened.61 * 2. i2c-requests - PSP refuses to grant i2c arbitration to x86 for too long.62 *63 * In order to distinguish between these in error handling code all mailbox64 * communication errors on the first level (from CCP symbols) will be passed65 * up and if -EIO is returned the second level will be checked.66 */67static int psp_send_i2c_req_cezanne(struct psp_i2c_req *req)68{69 int ret;70 71 ret = psp_send_platform_access_msg(PSP_I2C_REQ_BUS_CMD, (struct psp_request *)req);72 if (ret == -EIO)73 return check_i2c_req_sts(req);74 75 return ret;76}77 78static int psp_send_i2c_req_doorbell(struct psp_i2c_req *req)79{80 int ret;81 82 ret = psp_ring_platform_doorbell(req->type, &req->hdr.status);83 if (ret == -EIO)84 return check_i2c_req_sts(req);85 86 return ret;87}88 89static int psp_send_i2c_req(enum psp_i2c_req_type i2c_req_type)90{91 struct psp_i2c_req *req;92 unsigned long start;93 int status, ret;94 95 /* Allocate command-response buffer */96 req = kzalloc(sizeof(*req), GFP_KERNEL);97 if (!req)98 return -ENOMEM;99 100 req->hdr.payload_size = sizeof(*req);101 req->type = i2c_req_type;102 103 start = jiffies;104 ret = read_poll_timeout(_psp_send_i2c_req, status,105 (status != -EBUSY),106 PSP_I2C_REQ_RETRY_DELAY_US,107 PSP_I2C_REQ_RETRY_CNT * PSP_I2C_REQ_RETRY_DELAY_US,108 0, req);109 if (ret) {110 dev_err(psp_i2c_dev, "Timed out waiting for PSP to %s I2C bus\n",111 (i2c_req_type == PSP_I2C_REQ_ACQUIRE) ?112 "release" : "acquire");113 goto cleanup;114 }115 116 ret = status;117 if (ret) {118 dev_err(psp_i2c_dev, "PSP communication error\n");119 goto cleanup;120 }121 122 dev_dbg(psp_i2c_dev, "Request accepted by PSP after %ums\n",123 jiffies_to_msecs(jiffies - start));124 125cleanup:126 if (ret) {127 dev_err(psp_i2c_dev, "Assume i2c bus is for exclusive host usage\n");128 psp_i2c_mbox_fail = true;129 }130 131 kfree(req);132 return ret;133}134 135static void release_bus(void)136{137 int status;138 139 if (!psp_i2c_sem_acquired)140 return;141 142 status = psp_send_i2c_req(PSP_I2C_REQ_RELEASE);143 if (status)144 return;145 146 dev_dbg(psp_i2c_dev, "PSP semaphore held for %ums\n",147 jiffies_to_msecs(jiffies - psp_i2c_sem_acquired));148 149 psp_i2c_sem_acquired = 0;150}151 152static void psp_release_i2c_bus_deferred(struct work_struct *work)153{154 mutex_lock(&psp_i2c_access_mutex);155 156 /*157 * If there is any pending transaction, cannot release the bus here.158 * psp_release_i2c_bus will take care of this later.159 */160 if (psp_i2c_access_count)161 goto cleanup;162 163 release_bus();164 165cleanup:166 mutex_unlock(&psp_i2c_access_mutex);167}168static DECLARE_DELAYED_WORK(release_queue, psp_release_i2c_bus_deferred);169 170static int psp_acquire_i2c_bus(void)171{172 int status;173 174 mutex_lock(&psp_i2c_access_mutex);175 176 /* Return early if mailbox malfunctioned */177 if (psp_i2c_mbox_fail)178 goto cleanup;179 180 psp_i2c_access_count++;181 182 /*183 * No need to request bus arbitration once we are inside semaphore184 * reservation period.185 */186 if (psp_i2c_sem_acquired)187 goto cleanup;188 189 status = psp_send_i2c_req(PSP_I2C_REQ_ACQUIRE);190 if (status)191 goto cleanup;192 193 psp_i2c_sem_acquired = jiffies;194 195 schedule_delayed_work(&release_queue,196 msecs_to_jiffies(PSP_I2C_RESERVATION_TIME_MS));197 198 /*199 * In case of errors with PSP arbitrator psp_i2c_mbox_fail variable is200 * set above. As a consequence consecutive calls to acquire will bypass201 * communication with PSP. At any case i2c bus is granted to the caller,202 * thus always return success.203 */204cleanup:205 mutex_unlock(&psp_i2c_access_mutex);206 return 0;207}208 209static void psp_release_i2c_bus(void)210{211 mutex_lock(&psp_i2c_access_mutex);212 213 /* Return early if mailbox was malfunctional */214 if (psp_i2c_mbox_fail)215 goto cleanup;216 217 /*218 * If we are last owner of PSP semaphore, need to release aribtration219 * via mailbox.220 */221 psp_i2c_access_count--;222 if (psp_i2c_access_count)223 goto cleanup;224 225 /*226 * Send a release command to PSP if the semaphore reservation timeout227 * elapsed but x86 still owns the controller.228 */229 if (!delayed_work_pending(&release_queue))230 release_bus();231 232cleanup:233 mutex_unlock(&psp_i2c_access_mutex);234}235 236/*237 * Locking methods are based on the default implementation from238 * drivers/i2c/i2c-core-base.c, but with psp acquire and release operations239 * added. With this in place we can ensure that i2c clients on the bus shared240 * with psp are able to lock HW access to the bus for arbitrary number of241 * operations - that is e.g. write-wait-read.242 */243static void i2c_adapter_dw_psp_lock_bus(struct i2c_adapter *adapter,244 unsigned int flags)245{246 psp_acquire_i2c_bus();247 rt_mutex_lock_nested(&adapter->bus_lock, i2c_adapter_depth(adapter));248}249 250static int i2c_adapter_dw_psp_trylock_bus(struct i2c_adapter *adapter,251 unsigned int flags)252{253 int ret;254 255 ret = rt_mutex_trylock(&adapter->bus_lock);256 if (ret)257 return ret;258 259 psp_acquire_i2c_bus();260 261 return ret;262}263 264static void i2c_adapter_dw_psp_unlock_bus(struct i2c_adapter *adapter,265 unsigned int flags)266{267 psp_release_i2c_bus();268 rt_mutex_unlock(&adapter->bus_lock);269}270 271static const struct i2c_lock_operations i2c_dw_psp_lock_ops = {272 .lock_bus = i2c_adapter_dw_psp_lock_bus,273 .trylock_bus = i2c_adapter_dw_psp_trylock_bus,274 .unlock_bus = i2c_adapter_dw_psp_unlock_bus,275};276 277int i2c_dw_amdpsp_probe_lock_support(struct dw_i2c_dev *dev)278{279 struct pci_dev *rdev;280 281 if (!IS_REACHABLE(CONFIG_CRYPTO_DEV_CCP_DD))282 return -ENODEV;283 284 if (!dev)285 return -ENODEV;286 287 if (!(dev->flags & ARBITRATION_SEMAPHORE))288 return -ENODEV;289 290 /* Allow to bind only one instance of a driver */291 if (psp_i2c_dev)292 return -EEXIST;293 294 /* Cezanne uses platform mailbox, Mendocino and later use doorbell */295 rdev = pci_get_domain_bus_and_slot(0, 0, PCI_DEVFN(0, 0));296 if (rdev->device == 0x1630)297 _psp_send_i2c_req = psp_send_i2c_req_cezanne;298 else299 _psp_send_i2c_req = psp_send_i2c_req_doorbell;300 pci_dev_put(rdev);301 302 if (psp_check_platform_access_status())303 return -EPROBE_DEFER;304 305 psp_i2c_dev = dev->dev;306 307 dev_info(psp_i2c_dev, "I2C bus managed by AMD PSP\n");308 309 /*310 * Install global locking callbacks for adapter as well as internal i2c311 * controller locks.312 */313 dev->adapter.lock_ops = &i2c_dw_psp_lock_ops;314 dev->acquire_lock = psp_acquire_i2c_bus;315 dev->release_lock = psp_release_i2c_bus;316 317 return 0;318}319