1 // SPDX-License-Identifier: GPL-2.0 2 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 100 12 13 #define PSP_I2C_REQ_RETRY_CNT 400 14 #define PSP_I2C_REQ_RETRY_DELAY_US (25 * USEC_PER_MSEC) 15 #define PSP_I2C_REQ_STS_OK 0x0 16 #define PSP_I2C_REQ_STS_BUS_BUSY 0x1 17 #define PSP_I2C_REQ_STS_INV_PARAM 0x3 18 19 enum psp_i2c_req_type { 20 PSP_I2C_REQ_ACQUIRE, 21 PSP_I2C_REQ_RELEASE, 22 PSP_I2C_REQ_MAX 23 }; 24 25 struct psp_i2c_req { 26 struct psp_req_buffer_hdr hdr; 27 enum psp_i2c_req_type type; 28 }; 29 30 static DEFINE_MUTEX(psp_i2c_access_mutex); 31 static unsigned long psp_i2c_sem_acquired; 32 static u32 psp_i2c_access_count; 33 static bool psp_i2c_mbox_fail; 34 static struct device *psp_i2c_dev; 35 36 static int (*_psp_send_i2c_req)(struct psp_i2c_req *req); 37 38 /* Helper to verify status returned by PSP */ 39 static 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 with 60 * 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 mailbox 64 * communication errors on the first level (from CCP symbols) will be passed 65 * up and if -EIO is returned the second level will be checked. 66 */ 67 static 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 78 static 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 89 static 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 125 cleanup: 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 135 static 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 152 static 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 165 cleanup: 166 mutex_unlock(&psp_i2c_access_mutex); 167 } 168 static DECLARE_DELAYED_WORK(release_queue, psp_release_i2c_bus_deferred); 169 170 static 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 semaphore 184 * 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 is 200 * set above. As a consequence consecutive calls to acquire will bypass 201 * communication with PSP. At any case i2c bus is granted to the caller, 202 * thus always return success. 203 */ 204 cleanup: 205 mutex_unlock(&psp_i2c_access_mutex); 206 return 0; 207 } 208 209 static 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 aribtration 219 * 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 timeout 227 * elapsed but x86 still owns the controller. 228 */ 229 if (!delayed_work_pending(&release_queue)) 230 release_bus(); 231 232 cleanup: 233 mutex_unlock(&psp_i2c_access_mutex); 234 } 235 236 /* 237 * Locking methods are based on the default implementation from 238 * drivers/i2c/i2c-core-base.c, but with psp acquire and release operations 239 * added. With this in place we can ensure that i2c clients on the bus shared 240 * with psp are able to lock HW access to the bus for arbitrary number of 241 * operations - that is e.g. write-wait-read. 242 */ 243 static 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 250 static 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 264 static 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 271 static 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 277 int 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 else 299 _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 i2c 311 * 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