drivers/crypto/ccp/sp-platform.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * AMD Secure Processor device driver
   4  *
   5  * Copyright (C) 2014,2018 Advanced Micro Devices, Inc.
   6  *
   7  * Author: Tom Lendacky <thomas.lendacky@amd.com>
   8  */
   9
  10 #include <linux/module.h>
  11 #include <linux/kernel.h>
  12 #include <linux/device.h>
  13 #include <linux/platform_device.h>
  14 #include <linux/ioport.h>
  15 #include <linux/dma-mapping.h>
  16 #include <linux/kthread.h>
  17 #include <linux/sched.h>
  18 #include <linux/interrupt.h>
  19 #include <linux/spinlock.h>
  20 #include <linux/delay.h>
  21 #include <linux/ccp.h>
  22 #include <linux/of.h>
  23 #include <linux/of_address.h>
  24 #include <linux/acpi.h>
  25
  26 #include "ccp-dev.h"
  27
  28 struct sp_platform {
  29         int coherent;
  30         unsigned int irq_count;
  31 };
  32
  33 static const struct sp_dev_vdata dev_vdata[] = {
  34         {
  35                 .bar = 0,
  36 #ifdef CONFIG_CRYPTO_DEV_SP_CCP
  37                 .ccp_vdata = &ccpv3_platform,
  38 #endif
  39         },
  40 };
  41
  42 #ifdef CONFIG_ACPI
  43 static const struct acpi_device_id sp_acpi_match[] = {
  44         { "AMDI0C00", (kernel_ulong_t)&dev_vdata[0] },
  45         { },
  46 };
  47 MODULE_DEVICE_TABLE(acpi, sp_acpi_match);
  48 #endif
  49
  50 #ifdef CONFIG_OF
  51 static const struct of_device_id sp_of_match[] = {
  52         { .compatible = "amd,ccp-seattle-v1a",
  53           .data = (const void *)&dev_vdata[0] },
  54         { },
  55 };
  56 MODULE_DEVICE_TABLE(of, sp_of_match);
  57 #endif
  58
  59 static struct sp_dev_vdata *sp_get_of_version(struct platform_device *pdev)
  60 {
  61 #ifdef CONFIG_OF
  62         const struct of_device_id *match;
  63
  64         match = of_match_node(sp_of_match, pdev->dev.of_node);
  65         if (match && match->data)
  66                 return (struct sp_dev_vdata *)match->data;
  67 #endif
  68         return NULL;
  69 }
  70
  71 static struct sp_dev_vdata *sp_get_acpi_version(struct platform_device *pdev)
  72 {
  73 #ifdef CONFIG_ACPI
  74         const struct acpi_device_id *match;
  75
  76         match = acpi_match_device(sp_acpi_match, &pdev->dev);
  77         if (match && match->driver_data)
  78                 return (struct sp_dev_vdata *)match->driver_data;
  79 #endif
  80         return NULL;
  81 }
  82
  83 static int sp_get_irqs(struct sp_device *sp)
  84 {
  85         struct sp_platform *sp_platform = sp->dev_specific;
  86         struct device *dev = sp->dev;
  87         struct platform_device *pdev = to_platform_device(dev);
  88         int ret;
  89
  90         sp_platform->irq_count = platform_irq_count(pdev);
  91
  92         ret = platform_get_irq(pdev, 0);
  93         if (ret < 0) {
  94                 dev_notice(dev, "unable to get IRQ (%d)\n", ret);
  95                 return ret;
  96         }
  97
  98         sp->psp_irq = ret;
  99         if (sp_platform->irq_count == 1) {
 100                 sp->ccp_irq = ret;
 101         } else {
 102                 ret = platform_get_irq(pdev, 1);
 103                 if (ret < 0) {
 104                         dev_notice(dev, "unable to get IRQ (%d)\n", ret);
 105                         return ret;
 106                 }
 107
 108                 sp->ccp_irq = ret;
 109         }
 110
 111         return 0;
 112 }
 113
 114 static int sp_platform_probe(struct platform_device *pdev)
 115 {
 116         struct sp_device *sp;
 117         struct sp_platform *sp_platform;
 118         struct device *dev = &pdev->dev;
 119         enum dev_dma_attr attr;
 120         int ret;
 121
 122         ret = -ENOMEM;
 123         sp = sp_alloc_struct(dev);
 124         if (!sp)
 125                 goto e_err;
 126
 127         sp_platform = devm_kzalloc(dev, sizeof(*sp_platform), GFP_KERNEL);
 128         if (!sp_platform)
 129                 goto e_err;
 130
 131         sp->dev_specific = sp_platform;
 132         sp->dev_vdata = pdev->dev.of_node ? sp_get_of_version(pdev)
 133                                          : sp_get_acpi_version(pdev);
 134         if (!sp->dev_vdata) {
 135                 ret = -ENODEV;
 136                 dev_err(dev, "missing driver data\n");
 137                 goto e_err;
 138         }
 139
 140         sp->io_map = devm_platform_ioremap_resource(pdev, 0);
 141         if (IS_ERR(sp->io_map)) {
 142                 ret = PTR_ERR(sp->io_map);
 143                 goto e_err;
 144         }
 145
 146         attr = device_get_dma_attr(dev);
 147         if (attr == DEV_DMA_NOT_SUPPORTED) {
 148                 dev_err(dev, "DMA is not supported");
 149                 goto e_err;
 150         }
 151
 152         sp_platform->coherent = (attr == DEV_DMA_COHERENT);
 153         if (sp_platform->coherent)
 154                 sp->axcache = CACHE_WB_NO_ALLOC;
 155         else
 156                 sp->axcache = CACHE_NONE;
 157
 158         ret = dma_set_mask_and_coherent(dev, DMA_BIT_MASK(48));
 159         if (ret) {
 160                 dev_err(dev, "dma_set_mask_and_coherent failed (%d)\n", ret);
 161                 goto e_err;
 162         }
 163
 164         ret = sp_get_irqs(sp);
 165         if (ret)
 166                 goto e_err;
 167
 168         dev_set_drvdata(dev, sp);
 169
 170         ret = sp_init(sp);
 171         if (ret)
 172                 goto e_err;
 173
 174         dev_notice(dev, "enabled\n");
 175
 176         return 0;
 177
 178 e_err:
 179         dev_notice(dev, "initialization failed\n");
 180         return ret;
 181 }
 182
 183 static void sp_platform_remove(struct platform_device *pdev)
 184 {
 185         struct device *dev = &pdev->dev;
 186         struct sp_device *sp = dev_get_drvdata(dev);
 187
 188         sp_destroy(sp);
 189
 190         dev_notice(dev, "disabled\n");
 191 }
 192
 193 #ifdef CONFIG_PM
 194 static int sp_platform_suspend(struct platform_device *pdev,
 195                                 pm_message_t state)
 196 {
 197         struct device *dev = &pdev->dev;
 198         struct sp_device *sp = dev_get_drvdata(dev);
 199
 200         return sp_suspend(sp);
 201 }
 202
 203 static int sp_platform_resume(struct platform_device *pdev)
 204 {
 205         struct device *dev = &pdev->dev;
 206         struct sp_device *sp = dev_get_drvdata(dev);
 207
 208         return sp_resume(sp);
 209 }
 210 #endif
 211
 212 static struct platform_driver sp_platform_driver = {
 213         .driver = {
 214                 .name = "ccp",
 215 #ifdef CONFIG_ACPI
 216                 .acpi_match_table = sp_acpi_match,
 217 #endif
 218 #ifdef CONFIG_OF
 219                 .of_match_table = sp_of_match,
 220 #endif
 221         },
 222         .probe = sp_platform_probe,
 223         .remove_new = sp_platform_remove,
 224 #ifdef CONFIG_PM
 225         .suspend = sp_platform_suspend,
 226         .resume = sp_platform_resume,
 227 #endif
 228 };
 229
 230 int sp_platform_init(void)
 231 {
 232         return platform_driver_register(&sp_platform_driver);
 233 }
 234
 235 void sp_platform_exit(void)
 236 {
 237         platform_driver_unregister(&sp_platform_driver);
 238 }