drivers/crypto/ccp/sp-dev.c

   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 <[email protected]>
   8  * Author: Gary R Hook <[email protected]>
   9  * Author: Brijesh Singh <[email protected]>
  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 <[email protected]>");
  26 MODULE_AUTHOR("Gary R Hook <[email protected]>");
  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);