drivers/crypto/ccp/ccp-platform.c

   1 /*
   2  * AMD Cryptographic Coprocessor (CCP) driver
   3  *
   4  * Copyright (C) 2014,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/platform_device.h>
  17 #include <linux/ioport.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 #include <linux/of.h>
  26 #include <linux/of_address.h>
  27 #include <linux/acpi.h>
  28
  29 #include "ccp-dev.h"
  30
  31 struct ccp_platform {
  32         int coherent;
  33 };
  34
  35 static const struct acpi_device_id ccp_acpi_match[];
  36 static const struct of_device_id ccp_of_match[];
  37
  38 static struct ccp_vdata *ccp_get_of_version(struct platform_device *pdev)
  39 {
  40 #ifdef CONFIG_OF
  41         const struct of_device_id *match;
  42
  43         match = of_match_node(ccp_of_match, pdev->dev.of_node);
  44         if (match && match->data)
  45                 return (struct ccp_vdata *)match->data;
  46 #endif
  47         return 0;
  48 }
  49
  50 static struct ccp_vdata *ccp_get_acpi_version(struct platform_device *pdev)
  51 {
  52 #ifdef CONFIG_ACPI
  53         const struct acpi_device_id *match;
  54
  55         match = acpi_match_device(ccp_acpi_match, &pdev->dev);
  56         if (match && match->driver_data)
  57                 return (struct ccp_vdata *)match->driver_data;
  58 #endif
  59         return 0;
  60 }
  61
  62 static int ccp_get_irq(struct ccp_device *ccp)
  63 {
  64         struct device *dev = ccp->dev;
  65         struct platform_device *pdev = to_platform_device(dev);
  66         int ret;
  67
  68         ret = platform_get_irq(pdev, 0);
  69         if (ret < 0)
  70                 return ret;
  71
  72         ccp->irq = ret;
  73         ret = request_irq(ccp->irq, ccp->vdata->perform->irqhandler, 0,
  74                           ccp->name, dev);
  75         if (ret) {
  76                 dev_notice(dev, "unable to allocate IRQ (%d)\n", ret);
  77                 return ret;
  78         }
  79
  80         return 0;
  81 }
  82
  83 static int ccp_get_irqs(struct ccp_device *ccp)
  84 {
  85         struct device *dev = ccp->dev;
  86         int ret;
  87
  88         ret = ccp_get_irq(ccp);
  89         if (!ret)
  90                 return 0;
  91
  92         /* Couldn't get an interrupt */
  93         dev_notice(dev, "could not enable interrupts (%d)\n", ret);
  94
  95         return ret;
  96 }
  97
  98 static void ccp_free_irqs(struct ccp_device *ccp)
  99 {
 100         struct device *dev = ccp->dev;
 101
 102         free_irq(ccp->irq, dev);
 103 }
 104
 105 static struct resource *ccp_find_mmio_area(struct ccp_device *ccp)
 106 {
 107         struct device *dev = ccp->dev;
 108         struct platform_device *pdev = to_platform_device(dev);
 109         struct resource *ior;
 110
 111         ior = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 112         if (ior && (resource_size(ior) >= 0x800))
 113                 return ior;
 114
 115         return NULL;
 116 }
 117
 118 static int ccp_platform_probe(struct platform_device *pdev)
 119 {
 120         struct ccp_device *ccp;
 121         struct ccp_platform *ccp_platform;
 122         struct device *dev = &pdev->dev;
 123         enum dev_dma_attr attr;
 124         struct resource *ior;
 125         int ret;
 126
 127         ret = -ENOMEM;
 128         ccp = ccp_alloc_struct(dev);
 129         if (!ccp)
 130                 goto e_err;
 131
 132         ccp_platform = devm_kzalloc(dev, sizeof(*ccp_platform), GFP_KERNEL);
 133         if (!ccp_platform)
 134                 goto e_err;
 135
 136         ccp->dev_specific = ccp_platform;
 137         ccp->vdata = pdev->dev.of_node ? ccp_get_of_version(pdev)
 138                                          : ccp_get_acpi_version(pdev);
 139         if (!ccp->vdata || !ccp->vdata->version) {
 140                 ret = -ENODEV;
 141                 dev_err(dev, "missing driver data\n");
 142                 goto e_err;
 143         }
 144         ccp->get_irq = ccp_get_irqs;
 145         ccp->free_irq = ccp_free_irqs;
 146
 147         ior = ccp_find_mmio_area(ccp);
 148         ccp->io_map = devm_ioremap_resource(dev, ior);
 149         if (IS_ERR(ccp->io_map)) {
 150                 ret = PTR_ERR(ccp->io_map);
 151                 goto e_err;
 152         }
 153         ccp->io_regs = ccp->io_map;
 154
 155         attr = device_get_dma_attr(dev);
 156         if (attr == DEV_DMA_NOT_SUPPORTED) {
 157                 dev_err(dev, "DMA is not supported");
 158                 goto e_err;
 159         }
 160
 161         ccp_platform->coherent = (attr == DEV_DMA_COHERENT);
 162         if (ccp_platform->coherent)
 163                 ccp->axcache = CACHE_WB_NO_ALLOC;
 164         else
 165                 ccp->axcache = CACHE_NONE;
 166
 167         ret = dma_set_mask_and_coherent(dev, DMA_BIT_MASK(48));
 168         if (ret) {
 169                 dev_err(dev, "dma_set_mask_and_coherent failed (%d)\n", ret);
 170                 goto e_err;
 171         }
 172
 173         dev_set_drvdata(dev, ccp);
 174
 175         ret = ccp->vdata->perform->init(ccp);
 176         if (ret)
 177                 goto e_err;
 178
 179         dev_notice(dev, "enabled\n");
 180
 181         return 0;
 182
 183 e_err:
 184         dev_notice(dev, "initialization failed\n");
 185         return ret;
 186 }
 187
 188 static int ccp_platform_remove(struct platform_device *pdev)
 189 {
 190         struct device *dev = &pdev->dev;
 191         struct ccp_device *ccp = dev_get_drvdata(dev);
 192
 193         ccp->vdata->perform->destroy(ccp);
 194
 195         dev_notice(dev, "disabled\n");
 196
 197         return 0;
 198 }
 199
 200 #ifdef CONFIG_PM
 201 static int ccp_platform_suspend(struct platform_device *pdev,
 202                                 pm_message_t state)
 203 {
 204         struct device *dev = &pdev->dev;
 205         struct ccp_device *ccp = dev_get_drvdata(dev);
 206         unsigned long flags;
 207         unsigned int i;
 208
 209         spin_lock_irqsave(&ccp->cmd_lock, flags);
 210
 211         ccp->suspending = 1;
 212
 213         /* Wake all the queue kthreads to prepare for suspend */
 214         for (i = 0; i < ccp->cmd_q_count; i++)
 215                 wake_up_process(ccp->cmd_q[i].kthread);
 216
 217         spin_unlock_irqrestore(&ccp->cmd_lock, flags);
 218
 219         /* Wait for all queue kthreads to say they're done */
 220         while (!ccp_queues_suspended(ccp))
 221                 wait_event_interruptible(ccp->suspend_queue,
 222                                          ccp_queues_suspended(ccp));
 223
 224         return 0;
 225 }
 226
 227 static int ccp_platform_resume(struct platform_device *pdev)
 228 {
 229         struct device *dev = &pdev->dev;
 230         struct ccp_device *ccp = dev_get_drvdata(dev);
 231         unsigned long flags;
 232         unsigned int i;
 233
 234         spin_lock_irqsave(&ccp->cmd_lock, flags);
 235
 236         ccp->suspending = 0;
 237
 238         /* Wake up all the kthreads */
 239         for (i = 0; i < ccp->cmd_q_count; i++) {
 240                 ccp->cmd_q[i].suspended = 0;
 241                 wake_up_process(ccp->cmd_q[i].kthread);
 242         }
 243
 244         spin_unlock_irqrestore(&ccp->cmd_lock, flags);
 245
 246         return 0;
 247 }
 248 #endif
 249
 250 #ifdef CONFIG_ACPI
 251 static const struct acpi_device_id ccp_acpi_match[] = {
 252         { "AMDI0C00", (kernel_ulong_t)&ccpv3 },
 253         { },
 254 };
 255 MODULE_DEVICE_TABLE(acpi, ccp_acpi_match);
 256 #endif
 257
 258 #ifdef CONFIG_OF
 259 static const struct of_device_id ccp_of_match[] = {
 260         { .compatible = "amd,ccp-seattle-v1a",
 261           .data = (const void *)&ccpv3 },
 262         { },
 263 };
 264 MODULE_DEVICE_TABLE(of, ccp_of_match);
 265 #endif
 266
 267 static struct platform_driver ccp_platform_driver = {
 268         .driver = {
 269                 .name = "ccp",
 270 #ifdef CONFIG_ACPI
 271                 .acpi_match_table = ccp_acpi_match,
 272 #endif
 273 #ifdef CONFIG_OF
 274                 .of_match_table = ccp_of_match,
 275 #endif
 276         },
 277         .probe = ccp_platform_probe,
 278         .remove = ccp_platform_remove,
 279 #ifdef CONFIG_PM
 280         .suspend = ccp_platform_suspend,
 281         .resume = ccp_platform_resume,
 282 #endif
 283 };
 284
 285 int ccp_platform_init(void)
 286 {
 287         return platform_driver_register(&ccp_platform_driver);
 288 }
 289
 290 void ccp_platform_exit(void)
 291 {
 292         platform_driver_unregister(&ccp_platform_driver);
 293 }