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         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);