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