linux/drivers/crypto/ccp/sp-pci.c
<<
>>
Prefs
   1// SPDX-License-Identifier: GPL-2.0-only
   2/*
   3 * AMD Secure Processor device driver
   4 *
   5 * Copyright (C) 2013,2019 Advanced Micro Devices, Inc.
   6 *
   7 * Author: Tom Lendacky <thomas.lendacky@amd.com>
   8 * Author: Gary R Hook <gary.hook@amd.com>
   9 */
  10
  11#include <linux/module.h>
  12#include <linux/kernel.h>
  13#include <linux/device.h>
  14#include <linux/pci.h>
  15#include <linux/pci_ids.h>
  16#include <linux/dma-mapping.h>
  17#include <linux/kthread.h>
  18#include <linux/sched.h>
  19#include <linux/interrupt.h>
  20#include <linux/spinlock.h>
  21#include <linux/delay.h>
  22#include <linux/ccp.h>
  23
  24#include "ccp-dev.h"
  25#include "psp-dev.h"
  26
  27#define MSIX_VECTORS                    2
  28
  29struct sp_pci {
  30        int msix_count;
  31        struct msix_entry msix_entry[MSIX_VECTORS];
  32};
  33static struct sp_device *sp_dev_master;
  34
  35static int sp_get_msix_irqs(struct sp_device *sp)
  36{
  37        struct sp_pci *sp_pci = sp->dev_specific;
  38        struct device *dev = sp->dev;
  39        struct pci_dev *pdev = to_pci_dev(dev);
  40        int v, ret;
  41
  42        for (v = 0; v < ARRAY_SIZE(sp_pci->msix_entry); v++)
  43                sp_pci->msix_entry[v].entry = v;
  44
  45        ret = pci_enable_msix_range(pdev, sp_pci->msix_entry, 1, v);
  46        if (ret < 0)
  47                return ret;
  48
  49        sp_pci->msix_count = ret;
  50        sp->use_tasklet = true;
  51
  52        sp->psp_irq = sp_pci->msix_entry[0].vector;
  53        sp->ccp_irq = (sp_pci->msix_count > 1) ? sp_pci->msix_entry[1].vector
  54                                               : sp_pci->msix_entry[0].vector;
  55        return 0;
  56}
  57
  58static int sp_get_msi_irq(struct sp_device *sp)
  59{
  60        struct device *dev = sp->dev;
  61        struct pci_dev *pdev = to_pci_dev(dev);
  62        int ret;
  63
  64        ret = pci_enable_msi(pdev);
  65        if (ret)
  66                return ret;
  67
  68        sp->ccp_irq = pdev->irq;
  69        sp->psp_irq = pdev->irq;
  70
  71        return 0;
  72}
  73
  74static int sp_get_irqs(struct sp_device *sp)
  75{
  76        struct device *dev = sp->dev;
  77        int ret;
  78
  79        ret = sp_get_msix_irqs(sp);
  80        if (!ret)
  81                return 0;
  82
  83        /* Couldn't get MSI-X vectors, try MSI */
  84        dev_notice(dev, "could not enable MSI-X (%d), trying MSI\n", ret);
  85        ret = sp_get_msi_irq(sp);
  86        if (!ret)
  87                return 0;
  88
  89        /* Couldn't get MSI interrupt */
  90        dev_notice(dev, "could not enable MSI (%d)\n", ret);
  91
  92        return ret;
  93}
  94
  95static void sp_free_irqs(struct sp_device *sp)
  96{
  97        struct sp_pci *sp_pci = sp->dev_specific;
  98        struct device *dev = sp->dev;
  99        struct pci_dev *pdev = to_pci_dev(dev);
 100
 101        if (sp_pci->msix_count)
 102                pci_disable_msix(pdev);
 103        else if (sp->psp_irq)
 104                pci_disable_msi(pdev);
 105
 106        sp->ccp_irq = 0;
 107        sp->psp_irq = 0;
 108}
 109
 110static bool sp_pci_is_master(struct sp_device *sp)
 111{
 112        struct device *dev_cur, *dev_new;
 113        struct pci_dev *pdev_cur, *pdev_new;
 114
 115        dev_new = sp->dev;
 116        dev_cur = sp_dev_master->dev;
 117
 118        pdev_new = to_pci_dev(dev_new);
 119        pdev_cur = to_pci_dev(dev_cur);
 120
 121        if (pdev_new->bus->number < pdev_cur->bus->number)
 122                return true;
 123
 124        if (PCI_SLOT(pdev_new->devfn) < PCI_SLOT(pdev_cur->devfn))
 125                return true;
 126
 127        if (PCI_FUNC(pdev_new->devfn) < PCI_FUNC(pdev_cur->devfn))
 128                return true;
 129
 130        return false;
 131}
 132
 133static void psp_set_master(struct sp_device *sp)
 134{
 135        if (!sp_dev_master) {
 136                sp_dev_master = sp;
 137                return;
 138        }
 139
 140        if (sp_pci_is_master(sp))
 141                sp_dev_master = sp;
 142}
 143
 144static struct sp_device *psp_get_master(void)
 145{
 146        return sp_dev_master;
 147}
 148
 149static void psp_clear_master(struct sp_device *sp)
 150{
 151        if (sp == sp_dev_master) {
 152                sp_dev_master = NULL;
 153                dev_dbg(sp->dev, "Cleared sp_dev_master\n");
 154        }
 155}
 156
 157static int sp_pci_probe(struct pci_dev *pdev, const struct pci_device_id *id)
 158{
 159        struct sp_device *sp;
 160        struct sp_pci *sp_pci;
 161        struct device *dev = &pdev->dev;
 162        void __iomem * const *iomap_table;
 163        int bar_mask;
 164        int ret;
 165
 166        ret = -ENOMEM;
 167        sp = sp_alloc_struct(dev);
 168        if (!sp)
 169                goto e_err;
 170
 171        sp_pci = devm_kzalloc(dev, sizeof(*sp_pci), GFP_KERNEL);
 172        if (!sp_pci)
 173                goto e_err;
 174
 175        sp->dev_specific = sp_pci;
 176        sp->dev_vdata = (struct sp_dev_vdata *)id->driver_data;
 177        if (!sp->dev_vdata) {
 178                ret = -ENODEV;
 179                dev_err(dev, "missing driver data\n");
 180                goto e_err;
 181        }
 182
 183        ret = pcim_enable_device(pdev);
 184        if (ret) {
 185                dev_err(dev, "pcim_enable_device failed (%d)\n", ret);
 186                goto e_err;
 187        }
 188
 189        bar_mask = pci_select_bars(pdev, IORESOURCE_MEM);
 190        ret = pcim_iomap_regions(pdev, bar_mask, "ccp");
 191        if (ret) {
 192                dev_err(dev, "pcim_iomap_regions failed (%d)\n", ret);
 193                goto e_err;
 194        }
 195
 196        iomap_table = pcim_iomap_table(pdev);
 197        if (!iomap_table) {
 198                dev_err(dev, "pcim_iomap_table failed\n");
 199                ret = -ENOMEM;
 200                goto e_err;
 201        }
 202
 203        sp->io_map = iomap_table[sp->dev_vdata->bar];
 204        if (!sp->io_map) {
 205                dev_err(dev, "ioremap failed\n");
 206                ret = -ENOMEM;
 207                goto e_err;
 208        }
 209
 210        ret = sp_get_irqs(sp);
 211        if (ret)
 212                goto e_err;
 213
 214        pci_set_master(pdev);
 215        sp->set_psp_master_device = psp_set_master;
 216        sp->get_psp_master_device = psp_get_master;
 217        sp->clear_psp_master_device = psp_clear_master;
 218
 219        ret = dma_set_mask_and_coherent(dev, DMA_BIT_MASK(48));
 220        if (ret) {
 221                ret = dma_set_mask_and_coherent(dev, DMA_BIT_MASK(32));
 222                if (ret) {
 223                        dev_err(dev, "dma_set_mask_and_coherent failed (%d)\n",
 224                                ret);
 225                        goto free_irqs;
 226                }
 227        }
 228
 229        dev_set_drvdata(dev, sp);
 230
 231        ret = sp_init(sp);
 232        if (ret)
 233                goto free_irqs;
 234
 235        return 0;
 236
 237free_irqs:
 238        sp_free_irqs(sp);
 239e_err:
 240        dev_notice(dev, "initialization failed\n");
 241        return ret;
 242}
 243
 244static void sp_pci_remove(struct pci_dev *pdev)
 245{
 246        struct device *dev = &pdev->dev;
 247        struct sp_device *sp = dev_get_drvdata(dev);
 248
 249        if (!sp)
 250                return;
 251
 252        sp_destroy(sp);
 253
 254        sp_free_irqs(sp);
 255}
 256
 257static int __maybe_unused sp_pci_suspend(struct device *dev)
 258{
 259        struct sp_device *sp = dev_get_drvdata(dev);
 260
 261        return sp_suspend(sp);
 262}
 263
 264static int __maybe_unused sp_pci_resume(struct device *dev)
 265{
 266        struct sp_device *sp = dev_get_drvdata(dev);
 267
 268        return sp_resume(sp);
 269}
 270
 271#ifdef CONFIG_CRYPTO_DEV_SP_PSP
 272static const struct sev_vdata sevv1 = {
 273        .cmdresp_reg            = 0x10580,
 274        .cmdbuff_addr_lo_reg    = 0x105e0,
 275        .cmdbuff_addr_hi_reg    = 0x105e4,
 276};
 277
 278static const struct sev_vdata sevv2 = {
 279        .cmdresp_reg            = 0x10980,
 280        .cmdbuff_addr_lo_reg    = 0x109e0,
 281        .cmdbuff_addr_hi_reg    = 0x109e4,
 282};
 283
 284static const struct tee_vdata teev1 = {
 285        .cmdresp_reg            = 0x10544,
 286        .cmdbuff_addr_lo_reg    = 0x10548,
 287        .cmdbuff_addr_hi_reg    = 0x1054c,
 288        .ring_wptr_reg          = 0x10550,
 289        .ring_rptr_reg          = 0x10554,
 290};
 291
 292static const struct psp_vdata pspv1 = {
 293        .sev                    = &sevv1,
 294        .feature_reg            = 0x105fc,
 295        .inten_reg              = 0x10610,
 296        .intsts_reg             = 0x10614,
 297};
 298
 299static const struct psp_vdata pspv2 = {
 300        .sev                    = &sevv2,
 301        .feature_reg            = 0x109fc,
 302        .inten_reg              = 0x10690,
 303        .intsts_reg             = 0x10694,
 304};
 305
 306static const struct psp_vdata pspv3 = {
 307        .tee                    = &teev1,
 308        .feature_reg            = 0x109fc,
 309        .inten_reg              = 0x10690,
 310        .intsts_reg             = 0x10694,
 311};
 312#endif
 313
 314static const struct sp_dev_vdata dev_vdata[] = {
 315        {       /* 0 */
 316                .bar = 2,
 317#ifdef CONFIG_CRYPTO_DEV_SP_CCP
 318                .ccp_vdata = &ccpv3,
 319#endif
 320        },
 321        {       /* 1 */
 322                .bar = 2,
 323#ifdef CONFIG_CRYPTO_DEV_SP_CCP
 324                .ccp_vdata = &ccpv5a,
 325#endif
 326#ifdef CONFIG_CRYPTO_DEV_SP_PSP
 327                .psp_vdata = &pspv1,
 328#endif
 329        },
 330        {       /* 2 */
 331                .bar = 2,
 332#ifdef CONFIG_CRYPTO_DEV_SP_CCP
 333                .ccp_vdata = &ccpv5b,
 334#endif
 335        },
 336        {       /* 3 */
 337                .bar = 2,
 338#ifdef CONFIG_CRYPTO_DEV_SP_CCP
 339                .ccp_vdata = &ccpv5a,
 340#endif
 341#ifdef CONFIG_CRYPTO_DEV_SP_PSP
 342                .psp_vdata = &pspv2,
 343#endif
 344        },
 345        {       /* 4 */
 346                .bar = 2,
 347#ifdef CONFIG_CRYPTO_DEV_SP_CCP
 348                .ccp_vdata = &ccpv5a,
 349#endif
 350#ifdef CONFIG_CRYPTO_DEV_SP_PSP
 351                .psp_vdata = &pspv3,
 352#endif
 353        },
 354};
 355static const struct pci_device_id sp_pci_table[] = {
 356        { PCI_VDEVICE(AMD, 0x1537), (kernel_ulong_t)&dev_vdata[0] },
 357        { PCI_VDEVICE(AMD, 0x1456), (kernel_ulong_t)&dev_vdata[1] },
 358        { PCI_VDEVICE(AMD, 0x1468), (kernel_ulong_t)&dev_vdata[2] },
 359        { PCI_VDEVICE(AMD, 0x1486), (kernel_ulong_t)&dev_vdata[3] },
 360        { PCI_VDEVICE(AMD, 0x15DF), (kernel_ulong_t)&dev_vdata[4] },
 361        { PCI_VDEVICE(AMD, 0x1649), (kernel_ulong_t)&dev_vdata[4] },
 362        /* Last entry must be zero */
 363        { 0, }
 364};
 365MODULE_DEVICE_TABLE(pci, sp_pci_table);
 366
 367static SIMPLE_DEV_PM_OPS(sp_pci_pm_ops, sp_pci_suspend, sp_pci_resume);
 368
 369static struct pci_driver sp_pci_driver = {
 370        .name = "ccp",
 371        .id_table = sp_pci_table,
 372        .probe = sp_pci_probe,
 373        .remove = sp_pci_remove,
 374        .driver.pm = &sp_pci_pm_ops,
 375};
 376
 377int sp_pci_init(void)
 378{
 379        return pci_register_driver(&sp_pci_driver);
 380}
 381
 382void sp_pci_exit(void)
 383{
 384        pci_unregister_driver(&sp_pci_driver);
 385}
 386