drivers/crypto/ccp/sp-dev.c

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