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 #ifdef CONFIG_PM 215 int sp_suspend(struct sp_device *sp, pm_message_t state) 216 { 217 int ret; 218 219 if (sp->dev_vdata->ccp_vdata) { 220 ret = ccp_dev_suspend(sp, state); 221 if (ret) 222 return ret; 223 } 224 225 return 0; 226 } 227 228 int sp_resume(struct sp_device *sp) 229 { 230 int ret; 231 232 if (sp->dev_vdata->ccp_vdata) { 233 ret = ccp_dev_resume(sp); 234 if (ret) 235 return ret; 236 } 237 238 return 0; 239 } 240 #endif 241 242 struct sp_device *sp_get_psp_master_device(void) 243 { 244 struct sp_device *i, *ret = NULL; 245 unsigned long flags; 246 247 write_lock_irqsave(&sp_unit_lock, flags); 248 if (list_empty(&sp_units)) 249 goto unlock; 250 251 list_for_each_entry(i, &sp_units, entry) { 252 if (i->psp_data && i->get_psp_master_device) { 253 ret = i->get_psp_master_device(); 254 break; 255 } 256 } 257 258 unlock: 259 write_unlock_irqrestore(&sp_unit_lock, flags); 260 return ret; 261 } 262 263 static int __init sp_mod_init(void) 264 { 265 #ifdef CONFIG_X86 266 int ret; 267 268 ret = sp_pci_init(); 269 if (ret) 270 return ret; 271 272 #ifdef CONFIG_CRYPTO_DEV_SP_PSP 273 psp_pci_init(); 274 #endif 275 276 return 0; 277 #endif 278 279 #ifdef CONFIG_ARM64 280 int ret; 281 282 ret = sp_platform_init(); 283 if (ret) 284 return ret; 285 286 return 0; 287 #endif 288 289 return -ENODEV; 290 } 291 292 static void __exit sp_mod_exit(void) 293 { 294 #ifdef CONFIG_X86 295 296 #ifdef CONFIG_CRYPTO_DEV_SP_PSP 297 psp_pci_exit(); 298 #endif 299 300 sp_pci_exit(); 301 #endif 302 303 #ifdef CONFIG_ARM64 304 sp_platform_exit(); 305 #endif 306 } 307 308 module_init(sp_mod_init); 309 module_exit(sp_mod_exit); 310