1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * AMD Secure Processor driver 4 * 5 * Copyright (C) 2017-2018 Advanced Micro Devices, Inc. 6 * 7 * Author: Tom Lendacky <thomas.lendacky@amd.com> 8 * Author: Gary R Hook <gary.hook@amd.com> 9 * Author: Brijesh Singh <brijesh.singh@amd.com> 10 */ 11 12 #include <linux/module.h> 13 #include <linux/kernel.h> 14 #include <linux/kthread.h> 15 #include <linux/sched.h> 16 #include <linux/interrupt.h> 17 #include <linux/spinlock.h> 18 #include <linux/spinlock_types.h> 19 #include <linux/types.h> 20 #include <linux/ccp.h> 21 22 #include "ccp-dev.h" 23 #include "sp-dev.h" 24 25 MODULE_AUTHOR("Tom Lendacky <thomas.lendacky@amd.com>"); 26 MODULE_AUTHOR("Gary R Hook <gary.hook@amd.com>"); 27 MODULE_LICENSE("GPL"); 28 MODULE_VERSION("1.1.0"); 29 MODULE_DESCRIPTION("AMD Secure Processor driver"); 30 31 /* List of SPs, SP count, read-write access lock, and access functions 32 * 33 * Lock structure: get sp_unit_lock for reading whenever we need to 34 * examine the SP list. 35 */ 36 static DEFINE_RWLOCK(sp_unit_lock); 37 static LIST_HEAD(sp_units); 38 39 /* Ever-increasing value to produce unique unit numbers */ 40 static atomic_t sp_ordinal; 41 42 static void sp_add_device(struct sp_device *sp) 43 { 44 unsigned long flags; 45 46 write_lock_irqsave(&sp_unit_lock, flags); 47 48 list_add_tail(&sp->entry, &sp_units); 49 50 write_unlock_irqrestore(&sp_unit_lock, flags); 51 } 52 53 static void sp_del_device(struct sp_device *sp) 54 { 55 unsigned long flags; 56 57 write_lock_irqsave(&sp_unit_lock, flags); 58 59 list_del(&sp->entry); 60 61 write_unlock_irqrestore(&sp_unit_lock, flags); 62 } 63 64 static irqreturn_t sp_irq_handler(int irq, void *data) 65 { 66 struct sp_device *sp = data; 67 68 if (sp->ccp_irq_handler) 69 sp->ccp_irq_handler(irq, sp->ccp_irq_data); 70 71 if (sp->psp_irq_handler) 72 sp->psp_irq_handler(irq, sp->psp_irq_data); 73 74 return IRQ_HANDLED; 75 } 76 77 int sp_request_ccp_irq(struct sp_device *sp, irq_handler_t handler, 78 const char *name, void *data) 79 { 80 int ret; 81 82 if ((sp->psp_irq == sp->ccp_irq) && sp->dev_vdata->psp_vdata) { 83 /* Need a common routine to manage all interrupts */ 84 sp->ccp_irq_data = data; 85 sp->ccp_irq_handler = handler; 86 87 if (!sp->irq_registered) { 88 ret = request_irq(sp->ccp_irq, sp_irq_handler, 0, 89 sp->name, sp); 90 if (ret) 91 return ret; 92 93 sp->irq_registered = true; 94 } 95 } else { 96 /* Each sub-device can manage it's own interrupt */ 97 ret = request_irq(sp->ccp_irq, handler, 0, name, data); 98 if (ret) 99 return ret; 100 } 101 102 return 0; 103 } 104 105 int sp_request_psp_irq(struct sp_device *sp, irq_handler_t handler, 106 const char *name, void *data) 107 { 108 int ret; 109 110 if ((sp->psp_irq == sp->ccp_irq) && sp->dev_vdata->ccp_vdata) { 111 /* Need a common routine to manage all interrupts */ 112 sp->psp_irq_data = data; 113 sp->psp_irq_handler = handler; 114 115 if (!sp->irq_registered) { 116 ret = request_irq(sp->psp_irq, sp_irq_handler, 0, 117 sp->name, sp); 118 if (ret) 119 return ret; 120 121 sp->irq_registered = true; 122 } 123 } else { 124 /* Each sub-device can manage it's own interrupt */ 125 ret = request_irq(sp->psp_irq, handler, 0, name, data); 126 if (ret) 127 return ret; 128 } 129 130 return 0; 131 } 132 133 void sp_free_ccp_irq(struct sp_device *sp, void *data) 134 { 135 if ((sp->psp_irq == sp->ccp_irq) && sp->dev_vdata->psp_vdata) { 136 /* Using common routine to manage all interrupts */ 137 if (!sp->psp_irq_handler) { 138 /* Nothing else using it, so free it */ 139 free_irq(sp->ccp_irq, sp); 140 141 sp->irq_registered = false; 142 } 143 144 sp->ccp_irq_handler = NULL; 145 sp->ccp_irq_data = NULL; 146 } else { 147 /* Each sub-device can manage it's own interrupt */ 148 free_irq(sp->ccp_irq, data); 149 } 150 } 151 152 void sp_free_psp_irq(struct sp_device *sp, void *data) 153 { 154 if ((sp->psp_irq == sp->ccp_irq) && sp->dev_vdata->ccp_vdata) { 155 /* Using common routine to manage all interrupts */ 156 if (!sp->ccp_irq_handler) { 157 /* Nothing else using it, so free it */ 158 free_irq(sp->psp_irq, sp); 159 160 sp->irq_registered = false; 161 } 162 163 sp->psp_irq_handler = NULL; 164 sp->psp_irq_data = NULL; 165 } else { 166 /* Each sub-device can manage it's own interrupt */ 167 free_irq(sp->psp_irq, data); 168 } 169 } 170 171 /** 172 * sp_alloc_struct - allocate and initialize the sp_device struct 173 * 174 * @dev: device struct of the SP 175 */ 176 struct sp_device *sp_alloc_struct(struct device *dev) 177 { 178 struct sp_device *sp; 179 180 sp = devm_kzalloc(dev, sizeof(*sp), GFP_KERNEL); 181 if (!sp) 182 return NULL; 183 184 sp->dev = dev; 185 sp->ord = atomic_inc_return(&sp_ordinal); 186 snprintf(sp->name, SP_MAX_NAME_LEN, "sp-%u", sp->ord); 187 188 return sp; 189 } 190 191 int sp_init(struct sp_device *sp) 192 { 193 sp_add_device(sp); 194 195 if (sp->dev_vdata->ccp_vdata) 196 ccp_dev_init(sp); 197 198 if (sp->dev_vdata->psp_vdata) 199 psp_dev_init(sp); 200 return 0; 201 } 202 203 void sp_destroy(struct sp_device *sp) 204 { 205 if (sp->dev_vdata->ccp_vdata) 206 ccp_dev_destroy(sp); 207 208 if (sp->dev_vdata->psp_vdata) 209 psp_dev_destroy(sp); 210 211 sp_del_device(sp); 212 } 213 214 int sp_suspend(struct sp_device *sp) 215 { 216 int ret; 217 218 if (sp->dev_vdata->ccp_vdata) { 219 ret = ccp_dev_suspend(sp); 220 if (ret) 221 return ret; 222 } 223 224 return 0; 225 } 226 227 int sp_resume(struct sp_device *sp) 228 { 229 int ret; 230 231 if (sp->dev_vdata->ccp_vdata) { 232 ret = ccp_dev_resume(sp); 233 if (ret) 234 return ret; 235 } 236 237 return 0; 238 } 239 240 struct sp_device *sp_get_psp_master_device(void) 241 { 242 struct sp_device *i, *ret = NULL; 243 unsigned long flags; 244 245 write_lock_irqsave(&sp_unit_lock, flags); 246 if (list_empty(&sp_units)) 247 goto unlock; 248 249 list_for_each_entry(i, &sp_units, entry) { 250 if (i->psp_data && i->get_psp_master_device) { 251 ret = i->get_psp_master_device(); 252 break; 253 } 254 } 255 256 unlock: 257 write_unlock_irqrestore(&sp_unit_lock, flags); 258 return ret; 259 } 260 261 static int __init sp_mod_init(void) 262 { 263 #ifdef CONFIG_X86 264 int ret; 265 266 ret = sp_pci_init(); 267 if (ret) 268 return ret; 269 270 #ifdef CONFIG_CRYPTO_DEV_SP_PSP 271 psp_pci_init(); 272 #endif 273 274 return 0; 275 #endif 276 277 #ifdef CONFIG_ARM64 278 int ret; 279 280 ret = sp_platform_init(); 281 if (ret) 282 return ret; 283 284 return 0; 285 #endif 286 287 return -ENODEV; 288 } 289 290 static void __exit sp_mod_exit(void) 291 { 292 #ifdef CONFIG_X86 293 294 #ifdef CONFIG_CRYPTO_DEV_SP_PSP 295 psp_pci_exit(); 296 #endif 297 298 sp_pci_exit(); 299 #endif 300 301 #ifdef CONFIG_ARM64 302 sp_platform_exit(); 303 #endif 304 } 305 306 module_init(sp_mod_init); 307 module_exit(sp_mod_exit); 308