drivers/crypto/ccp/ccp-pci.c

   1 /*
   2  * AMD Cryptographic Coprocessor (CCP) driver
   3  *
   4  * Copyright (C) 2013,2016 Advanced Micro Devices, Inc.
   5  *
   6  * Author: Tom Lendacky <thomas.lendacky@amd.com>
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License version 2 as
  10  * published by the Free Software Foundation.
  11  */
  12
  13 #include <linux/module.h>
  14 #include <linux/kernel.h>
  15 #include <linux/device.h>
  16 #include <linux/pci.h>
  17 #include <linux/pci_ids.h>
  18 #include <linux/dma-mapping.h>
  19 #include <linux/kthread.h>
  20 #include <linux/sched.h>
  21 #include <linux/interrupt.h>
  22 #include <linux/spinlock.h>
  23 #include <linux/delay.h>
  24 #include <linux/ccp.h>
  25
  26 #include "ccp-dev.h"
  27
  28 #define IO_BAR                          2
  29 #define IO_OFFSET                       0x20000
  30
  31 #define MSIX_VECTORS                    2
  32
  33 struct ccp_msix {
  34         u32 vector;
  35         char name[16];
  36 };
  37
  38 struct ccp_pci {
  39         int msix_count;
  40         struct ccp_msix msix[MSIX_VECTORS];
  41 };
  42
  43 static int ccp_get_msix_irqs(struct ccp_device *ccp)
  44 {
  45         struct ccp_pci *ccp_pci = ccp->dev_specific;
  46         struct device *dev = ccp->dev;
  47         struct pci_dev *pdev = to_pci_dev(dev);
  48         struct msix_entry msix_entry[MSIX_VECTORS];
  49         unsigned int name_len = sizeof(ccp_pci->msix[0].name) - 1;
  50         int v, ret;
  51
  52         for (v = 0; v < ARRAY_SIZE(msix_entry); v++)
  53                 msix_entry[v].entry = v;
  54
  55         ret = pci_enable_msix_range(pdev, msix_entry, 1, v);
  56         if (ret < 0)
  57                 return ret;
  58
  59         ccp_pci->msix_count = ret;
  60         for (v = 0; v < ccp_pci->msix_count; v++) {
  61                 /* Set the interrupt names and request the irqs */
  62                 snprintf(ccp_pci->msix[v].name, name_len, "%s-%u",
  63                          ccp->name, v);
  64                 ccp_pci->msix[v].vector = msix_entry[v].vector;
  65                 ret = request_irq(ccp_pci->msix[v].vector,
  66                                   ccp->vdata->perform->irqhandler,
  67                                   0, ccp_pci->msix[v].name, dev);
  68                 if (ret) {
  69                         dev_notice(dev, "unable to allocate MSI-X IRQ (%d)\n",
  70                                    ret);
  71                         goto e_irq;
  72                 }
  73         }
  74
  75         return 0;
  76
  77 e_irq:
  78         while (v--)
  79                 free_irq(ccp_pci->msix[v].vector, dev);
  80
  81         pci_disable_msix(pdev);
  82
  83         ccp_pci->msix_count = 0;
  84
  85         return ret;
  86 }
  87
  88 static int ccp_get_msi_irq(struct ccp_device *ccp)
  89 {
  90         struct device *dev = ccp->dev;
  91         struct pci_dev *pdev = to_pci_dev(dev);
  92         int ret;
  93
  94         ret = pci_enable_msi(pdev);
  95         if (ret)
  96                 return ret;
  97
  98         ccp->irq = pdev->irq;
  99         ret = request_irq(ccp->irq, ccp->vdata->perform->irqhandler, 0,
 100                           ccp->name, dev);
 101         if (ret) {
 102                 dev_notice(dev, "unable to allocate MSI IRQ (%d)\n", ret);
 103                 goto e_msi;
 104         }
 105
 106         return 0;
 107
 108 e_msi:
 109         pci_disable_msi(pdev);
 110
 111         return ret;
 112 }
 113
 114 static int ccp_get_irqs(struct ccp_device *ccp)
 115 {
 116         struct device *dev = ccp->dev;
 117         int ret;
 118
 119         ret = ccp_get_msix_irqs(ccp);
 120         if (!ret)
 121                 return 0;
 122
 123         /* Couldn't get MSI-X vectors, try MSI */
 124         dev_notice(dev, "could not enable MSI-X (%d), trying MSI\n", ret);
 125         ret = ccp_get_msi_irq(ccp);
 126         if (!ret)
 127                 return 0;
 128
 129         /* Couldn't get MSI interrupt */
 130         dev_notice(dev, "could not enable MSI (%d)\n", ret);
 131
 132         return ret;
 133 }
 134
 135 static void ccp_free_irqs(struct ccp_device *ccp)
 136 {
 137         struct ccp_pci *ccp_pci = ccp->dev_specific;
 138         struct device *dev = ccp->dev;
 139         struct pci_dev *pdev = to_pci_dev(dev);
 140
 141         if (ccp_pci->msix_count) {
 142                 while (ccp_pci->msix_count--)
 143                         free_irq(ccp_pci->msix[ccp_pci->msix_count].vector,
 144                                  dev);
 145                 pci_disable_msix(pdev);
 146         } else {
 147                 free_irq(ccp->irq, dev);
 148                 pci_disable_msi(pdev);
 149         }
 150 }
 151
 152 static int ccp_find_mmio_area(struct ccp_device *ccp)
 153 {
 154         struct device *dev = ccp->dev;
 155         struct pci_dev *pdev = to_pci_dev(dev);
 156         resource_size_t io_len;
 157         unsigned long io_flags;
 158
 159         io_flags = pci_resource_flags(pdev, IO_BAR);
 160         io_len = pci_resource_len(pdev, IO_BAR);
 161         if ((io_flags & IORESOURCE_MEM) && (io_len >= (IO_OFFSET + 0x800)))
 162                 return IO_BAR;
 163
 164         return -EIO;
 165 }
 166
 167 static int ccp_pci_probe(struct pci_dev *pdev, const struct pci_device_id *id)
 168 {
 169         struct ccp_device *ccp;
 170         struct ccp_pci *ccp_pci;
 171         struct device *dev = &pdev->dev;
 172         unsigned int bar;
 173         int ret;
 174
 175         ret = -ENOMEM;
 176         ccp = ccp_alloc_struct(dev);
 177         if (!ccp)
 178                 goto e_err;
 179
 180         ccp_pci = devm_kzalloc(dev, sizeof(*ccp_pci), GFP_KERNEL);
 181         if (!ccp_pci)
 182                 goto e_err;
 183
 184         ccp->dev_specific = ccp_pci;
 185         ccp->vdata = (struct ccp_vdata *)id->driver_data;
 186         if (!ccp->vdata || !ccp->vdata->version) {
 187                 ret = -ENODEV;
 188                 dev_err(dev, "missing driver data\n");
 189                 goto e_err;
 190         }
 191         ccp->get_irq = ccp_get_irqs;
 192         ccp->free_irq = ccp_free_irqs;
 193
 194         ret = pci_request_regions(pdev, "ccp");
 195         if (ret) {
 196                 dev_err(dev, "pci_request_regions failed (%d)\n", ret);
 197                 goto e_err;
 198         }
 199
 200         ret = pci_enable_device(pdev);
 201         if (ret) {
 202                 dev_err(dev, "pci_enable_device failed (%d)\n", ret);
 203                 goto e_regions;
 204         }
 205
 206         pci_set_master(pdev);
 207
 208         ret = ccp_find_mmio_area(ccp);
 209         if (ret < 0)
 210                 goto e_device;
 211         bar = ret;
 212
 213         ret = -EIO;
 214         ccp->io_map = pci_iomap(pdev, bar, 0);
 215         if (!ccp->io_map) {
 216                 dev_err(dev, "pci_iomap failed\n");
 217                 goto e_device;
 218         }
 219         ccp->io_regs = ccp->io_map + IO_OFFSET;
 220
 221         ret = dma_set_mask_and_coherent(dev, DMA_BIT_MASK(48));
 222         if (ret) {
 223                 ret = dma_set_mask_and_coherent(dev, DMA_BIT_MASK(32));
 224                 if (ret) {
 225                         dev_err(dev, "dma_set_mask_and_coherent failed (%d)\n",
 226                                 ret);
 227                         goto e_iomap;
 228                 }
 229         }
 230
 231         dev_set_drvdata(dev, ccp);
 232
 233         ret = ccp->vdata->perform->init(ccp);
 234         if (ret)
 235                 goto e_iomap;
 236
 237         dev_notice(dev, "enabled\n");
 238
 239         return 0;
 240
 241 e_iomap:
 242         pci_iounmap(pdev, ccp->io_map);
 243
 244 e_device:
 245         pci_disable_device(pdev);
 246
 247 e_regions:
 248         pci_release_regions(pdev);
 249
 250 e_err:
 251         dev_notice(dev, "initialization failed\n");
 252         return ret;
 253 }
 254
 255 static void ccp_pci_remove(struct pci_dev *pdev)
 256 {
 257         struct device *dev = &pdev->dev;
 258         struct ccp_device *ccp = dev_get_drvdata(dev);
 259
 260         if (!ccp)
 261                 return;
 262
 263         ccp->vdata->perform->destroy(ccp);
 264
 265         pci_iounmap(pdev, ccp->io_map);
 266
 267         pci_disable_device(pdev);
 268
 269         pci_release_regions(pdev);
 270
 271         dev_notice(dev, "disabled\n");
 272 }
 273
 274 #ifdef CONFIG_PM
 275 static int ccp_pci_suspend(struct pci_dev *pdev, pm_message_t state)
 276 {
 277         struct device *dev = &pdev->dev;
 278         struct ccp_device *ccp = dev_get_drvdata(dev);
 279         unsigned long flags;
 280         unsigned int i;
 281
 282         spin_lock_irqsave(&ccp->cmd_lock, flags);
 283
 284         ccp->suspending = 1;
 285
 286         /* Wake all the queue kthreads to prepare for suspend */
 287         for (i = 0; i < ccp->cmd_q_count; i++)
 288                 wake_up_process(ccp->cmd_q[i].kthread);
 289
 290         spin_unlock_irqrestore(&ccp->cmd_lock, flags);
 291
 292         /* Wait for all queue kthreads to say they're done */
 293         while (!ccp_queues_suspended(ccp))
 294                 wait_event_interruptible(ccp->suspend_queue,
 295                                          ccp_queues_suspended(ccp));
 296
 297         return 0;
 298 }
 299
 300 static int ccp_pci_resume(struct pci_dev *pdev)
 301 {
 302         struct device *dev = &pdev->dev;
 303         struct ccp_device *ccp = dev_get_drvdata(dev);
 304         unsigned long flags;
 305         unsigned int i;
 306
 307         spin_lock_irqsave(&ccp->cmd_lock, flags);
 308
 309         ccp->suspending = 0;
 310
 311         /* Wake up all the kthreads */
 312         for (i = 0; i < ccp->cmd_q_count; i++) {
 313                 ccp->cmd_q[i].suspended = 0;
 314                 wake_up_process(ccp->cmd_q[i].kthread);
 315         }
 316
 317         spin_unlock_irqrestore(&ccp->cmd_lock, flags);
 318
 319         return 0;
 320 }
 321 #endif
 322
 323 static const struct pci_device_id ccp_pci_table[] = {
 324         { PCI_VDEVICE(AMD, 0x1537), (kernel_ulong_t)&ccpv3 },
 325         /* Last entry must be zero */
 326         { 0, }
 327 };
 328 MODULE_DEVICE_TABLE(pci, ccp_pci_table);
 329
 330 static struct pci_driver ccp_pci_driver = {
 331         .name = "ccp",
 332         .id_table = ccp_pci_table,
 333         .probe = ccp_pci_probe,
 334         .remove = ccp_pci_remove,
 335 #ifdef CONFIG_PM
 336         .suspend = ccp_pci_suspend,
 337         .resume = ccp_pci_resume,
 338 #endif
 339 };
 340
 341 int ccp_pci_init(void)
 342 {
 343         return pci_register_driver(&ccp_pci_driver);
 344 }
 345
 346 void ccp_pci_exit(void)
 347 {
 348         pci_unregister_driver(&ccp_pci_driver);
 349 }