Tom Lendacky | c4f4b32 | 2014-06-05 10:17:57 -0500 | [diff] [blame] | 1 | /* |
| 2 | * AMD Cryptographic Coprocessor (CCP) driver |
| 3 | * |
Gary R Hook | 553d237 | 2016-03-01 13:49:04 -0600 | [diff] [blame] | 4 | * Copyright (C) 2014,2016 Advanced Micro Devices, Inc. |
Tom Lendacky | c4f4b32 | 2014-06-05 10:17:57 -0500 | [diff] [blame] | 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> |
Tom Lendacky | 126ae9a | 2014-07-10 10:58:35 -0500 | [diff] [blame] | 25 | #include <linux/of.h> |
Tom Lendacky | 6c50634 | 2015-02-03 13:07:29 -0600 | [diff] [blame] | 26 | #include <linux/of_address.h> |
| 27 | #include <linux/acpi.h> |
Tom Lendacky | c4f4b32 | 2014-06-05 10:17:57 -0500 | [diff] [blame] | 28 | |
| 29 | #include "ccp-dev.h" |
| 30 | |
Tom Lendacky | 6c50634 | 2015-02-03 13:07:29 -0600 | [diff] [blame] | 31 | struct ccp_platform { |
Tom Lendacky | 6c50634 | 2015-02-03 13:07:29 -0600 | [diff] [blame] | 32 | int coherent; |
| 33 | }; |
| 34 | |
Gary R Hook | c7019c4 | 2016-03-01 13:49:15 -0600 | [diff] [blame] | 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 |
pjambhlekar | 9d1fb19 | 2017-05-03 09:32:09 +0530 | [diff] [blame] | 47 | return NULL; |
Gary R Hook | c7019c4 | 2016-03-01 13:49:15 -0600 | [diff] [blame] | 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 |
pjambhlekar | 9d1fb19 | 2017-05-03 09:32:09 +0530 | [diff] [blame] | 59 | return NULL; |
Gary R Hook | c7019c4 | 2016-03-01 13:49:15 -0600 | [diff] [blame] | 60 | } |
| 61 | |
Tom Lendacky | c4f4b32 | 2014-06-05 10:17:57 -0500 | [diff] [blame] | 62 | static int ccp_get_irq(struct ccp_device *ccp) |
| 63 | { |
| 64 | struct device *dev = ccp->dev; |
Geliang Tang | c6c59bf | 2015-12-23 20:49:01 +0800 | [diff] [blame] | 65 | struct platform_device *pdev = to_platform_device(dev); |
Tom Lendacky | c4f4b32 | 2014-06-05 10:17:57 -0500 | [diff] [blame] | 66 | int ret; |
| 67 | |
| 68 | ret = platform_get_irq(pdev, 0); |
Gustavo A. R. Silva | 28a2cc6 | 2017-06-30 00:59:52 -0500 | [diff] [blame] | 69 | if (ret < 0) { |
| 70 | dev_notice(dev, "unable to get IRQ (%d)\n", ret); |
Tom Lendacky | c4f4b32 | 2014-06-05 10:17:57 -0500 | [diff] [blame] | 71 | return ret; |
Gustavo A. R. Silva | 28a2cc6 | 2017-06-30 00:59:52 -0500 | [diff] [blame] | 72 | } |
Tom Lendacky | c4f4b32 | 2014-06-05 10:17:57 -0500 | [diff] [blame] | 73 | |
| 74 | ccp->irq = ret; |
Gary R Hook | ea0375a | 2016-03-01 13:49:25 -0600 | [diff] [blame] | 75 | ret = request_irq(ccp->irq, ccp->vdata->perform->irqhandler, 0, |
| 76 | ccp->name, dev); |
Tom Lendacky | c4f4b32 | 2014-06-05 10:17:57 -0500 | [diff] [blame] | 77 | if (ret) { |
| 78 | dev_notice(dev, "unable to allocate IRQ (%d)\n", ret); |
| 79 | return ret; |
| 80 | } |
| 81 | |
| 82 | return 0; |
| 83 | } |
| 84 | |
| 85 | static int ccp_get_irqs(struct ccp_device *ccp) |
| 86 | { |
| 87 | struct device *dev = ccp->dev; |
| 88 | int ret; |
| 89 | |
| 90 | ret = ccp_get_irq(ccp); |
| 91 | if (!ret) |
| 92 | return 0; |
| 93 | |
| 94 | /* Couldn't get an interrupt */ |
| 95 | dev_notice(dev, "could not enable interrupts (%d)\n", ret); |
| 96 | |
| 97 | return ret; |
| 98 | } |
| 99 | |
| 100 | static void ccp_free_irqs(struct ccp_device *ccp) |
| 101 | { |
| 102 | struct device *dev = ccp->dev; |
| 103 | |
| 104 | free_irq(ccp->irq, dev); |
| 105 | } |
| 106 | |
Tom Lendacky | c4f4b32 | 2014-06-05 10:17:57 -0500 | [diff] [blame] | 107 | static int ccp_platform_probe(struct platform_device *pdev) |
| 108 | { |
| 109 | struct ccp_device *ccp; |
Tom Lendacky | 6c50634 | 2015-02-03 13:07:29 -0600 | [diff] [blame] | 110 | struct ccp_platform *ccp_platform; |
Tom Lendacky | c4f4b32 | 2014-06-05 10:17:57 -0500 | [diff] [blame] | 111 | struct device *dev = &pdev->dev; |
Suthikulpanit, Suravee | 1831eff | 2015-10-28 15:50:50 -0700 | [diff] [blame] | 112 | enum dev_dma_attr attr; |
Tom Lendacky | c4f4b32 | 2014-06-05 10:17:57 -0500 | [diff] [blame] | 113 | struct resource *ior; |
| 114 | int ret; |
| 115 | |
| 116 | ret = -ENOMEM; |
| 117 | ccp = ccp_alloc_struct(dev); |
| 118 | if (!ccp) |
| 119 | goto e_err; |
| 120 | |
Tom Lendacky | 6c50634 | 2015-02-03 13:07:29 -0600 | [diff] [blame] | 121 | ccp_platform = devm_kzalloc(dev, sizeof(*ccp_platform), GFP_KERNEL); |
| 122 | if (!ccp_platform) |
| 123 | goto e_err; |
| 124 | |
| 125 | ccp->dev_specific = ccp_platform; |
Gary R Hook | c7019c4 | 2016-03-01 13:49:15 -0600 | [diff] [blame] | 126 | ccp->vdata = pdev->dev.of_node ? ccp_get_of_version(pdev) |
| 127 | : ccp_get_acpi_version(pdev); |
| 128 | if (!ccp->vdata || !ccp->vdata->version) { |
| 129 | ret = -ENODEV; |
| 130 | dev_err(dev, "missing driver data\n"); |
| 131 | goto e_err; |
| 132 | } |
Tom Lendacky | c4f4b32 | 2014-06-05 10:17:57 -0500 | [diff] [blame] | 133 | ccp->get_irq = ccp_get_irqs; |
| 134 | ccp->free_irq = ccp_free_irqs; |
| 135 | |
Brijesh Singh | 970e830 | 2017-07-06 09:59:13 -0500 | [diff] [blame^] | 136 | ior = platform_get_resource(pdev, IORESOURCE_MEM, 0); |
Tom Lendacky | c4f4b32 | 2014-06-05 10:17:57 -0500 | [diff] [blame] | 137 | ccp->io_map = devm_ioremap_resource(dev, ior); |
| 138 | if (IS_ERR(ccp->io_map)) { |
| 139 | ret = PTR_ERR(ccp->io_map); |
Tom Lendacky | be03a3a | 2015-02-03 13:07:23 -0600 | [diff] [blame] | 140 | goto e_err; |
Tom Lendacky | c4f4b32 | 2014-06-05 10:17:57 -0500 | [diff] [blame] | 141 | } |
| 142 | ccp->io_regs = ccp->io_map; |
| 143 | |
Suthikulpanit, Suravee | 1831eff | 2015-10-28 15:50:50 -0700 | [diff] [blame] | 144 | attr = device_get_dma_attr(dev); |
| 145 | if (attr == DEV_DMA_NOT_SUPPORTED) { |
| 146 | dev_err(dev, "DMA is not supported"); |
| 147 | goto e_err; |
| 148 | } |
| 149 | |
| 150 | ccp_platform->coherent = (attr == DEV_DMA_COHERENT); |
| 151 | if (ccp_platform->coherent) |
| 152 | ccp->axcache = CACHE_WB_NO_ALLOC; |
| 153 | else |
| 154 | ccp->axcache = CACHE_NONE; |
| 155 | |
Tom Lendacky | 261bf07 | 2015-02-03 13:07:17 -0600 | [diff] [blame] | 156 | ret = dma_set_mask_and_coherent(dev, DMA_BIT_MASK(48)); |
| 157 | if (ret) { |
| 158 | dev_err(dev, "dma_set_mask_and_coherent failed (%d)\n", ret); |
Tom Lendacky | be03a3a | 2015-02-03 13:07:23 -0600 | [diff] [blame] | 159 | goto e_err; |
Tom Lendacky | 261bf07 | 2015-02-03 13:07:17 -0600 | [diff] [blame] | 160 | } |
Tom Lendacky | c4f4b32 | 2014-06-05 10:17:57 -0500 | [diff] [blame] | 161 | |
Tom Lendacky | c4f4b32 | 2014-06-05 10:17:57 -0500 | [diff] [blame] | 162 | dev_set_drvdata(dev, ccp); |
| 163 | |
Brijesh Singh | 970e830 | 2017-07-06 09:59:13 -0500 | [diff] [blame^] | 164 | ret = ccp_dev_init(ccp); |
Tom Lendacky | c4f4b32 | 2014-06-05 10:17:57 -0500 | [diff] [blame] | 165 | if (ret) |
Tom Lendacky | be03a3a | 2015-02-03 13:07:23 -0600 | [diff] [blame] | 166 | goto e_err; |
Tom Lendacky | c4f4b32 | 2014-06-05 10:17:57 -0500 | [diff] [blame] | 167 | |
| 168 | dev_notice(dev, "enabled\n"); |
| 169 | |
| 170 | return 0; |
| 171 | |
Tom Lendacky | c4f4b32 | 2014-06-05 10:17:57 -0500 | [diff] [blame] | 172 | e_err: |
| 173 | dev_notice(dev, "initialization failed\n"); |
| 174 | return ret; |
| 175 | } |
| 176 | |
| 177 | static int ccp_platform_remove(struct platform_device *pdev) |
| 178 | { |
| 179 | struct device *dev = &pdev->dev; |
| 180 | struct ccp_device *ccp = dev_get_drvdata(dev); |
| 181 | |
Brijesh Singh | 970e830 | 2017-07-06 09:59:13 -0500 | [diff] [blame^] | 182 | ccp_dev_destroy(ccp); |
Tom Lendacky | c4f4b32 | 2014-06-05 10:17:57 -0500 | [diff] [blame] | 183 | |
Tom Lendacky | c4f4b32 | 2014-06-05 10:17:57 -0500 | [diff] [blame] | 184 | dev_notice(dev, "disabled\n"); |
| 185 | |
| 186 | return 0; |
| 187 | } |
| 188 | |
| 189 | #ifdef CONFIG_PM |
| 190 | static int ccp_platform_suspend(struct platform_device *pdev, |
| 191 | pm_message_t state) |
| 192 | { |
| 193 | struct device *dev = &pdev->dev; |
| 194 | struct ccp_device *ccp = dev_get_drvdata(dev); |
Tom Lendacky | c4f4b32 | 2014-06-05 10:17:57 -0500 | [diff] [blame] | 195 | |
Brijesh Singh | 970e830 | 2017-07-06 09:59:13 -0500 | [diff] [blame^] | 196 | return ccp_dev_suspend(ccp, state); |
Tom Lendacky | c4f4b32 | 2014-06-05 10:17:57 -0500 | [diff] [blame] | 197 | } |
| 198 | |
| 199 | static int ccp_platform_resume(struct platform_device *pdev) |
| 200 | { |
| 201 | struct device *dev = &pdev->dev; |
| 202 | struct ccp_device *ccp = dev_get_drvdata(dev); |
Tom Lendacky | c4f4b32 | 2014-06-05 10:17:57 -0500 | [diff] [blame] | 203 | |
Brijesh Singh | 970e830 | 2017-07-06 09:59:13 -0500 | [diff] [blame^] | 204 | return ccp_dev_resume(ccp); |
Tom Lendacky | c4f4b32 | 2014-06-05 10:17:57 -0500 | [diff] [blame] | 205 | } |
| 206 | #endif |
| 207 | |
Tom Lendacky | 6c50634 | 2015-02-03 13:07:29 -0600 | [diff] [blame] | 208 | #ifdef CONFIG_ACPI |
| 209 | static const struct acpi_device_id ccp_acpi_match[] = { |
Gary R Hook | c7019c4 | 2016-03-01 13:49:15 -0600 | [diff] [blame] | 210 | { "AMDI0C00", (kernel_ulong_t)&ccpv3 }, |
Tom Lendacky | 6c50634 | 2015-02-03 13:07:29 -0600 | [diff] [blame] | 211 | { }, |
| 212 | }; |
Tom Lendacky | 6170511 | 2015-06-30 12:57:14 -0500 | [diff] [blame] | 213 | MODULE_DEVICE_TABLE(acpi, ccp_acpi_match); |
Tom Lendacky | 6c50634 | 2015-02-03 13:07:29 -0600 | [diff] [blame] | 214 | #endif |
| 215 | |
| 216 | #ifdef CONFIG_OF |
| 217 | static const struct of_device_id ccp_of_match[] = { |
Gary R Hook | c7019c4 | 2016-03-01 13:49:15 -0600 | [diff] [blame] | 218 | { .compatible = "amd,ccp-seattle-v1a", |
Brijesh Singh | 970e830 | 2017-07-06 09:59:13 -0500 | [diff] [blame^] | 219 | .data = (const void *)&ccpv3_platform }, |
Tom Lendacky | c4f4b32 | 2014-06-05 10:17:57 -0500 | [diff] [blame] | 220 | { }, |
| 221 | }; |
Tom Lendacky | 6170511 | 2015-06-30 12:57:14 -0500 | [diff] [blame] | 222 | MODULE_DEVICE_TABLE(of, ccp_of_match); |
Tom Lendacky | 6c50634 | 2015-02-03 13:07:29 -0600 | [diff] [blame] | 223 | #endif |
Tom Lendacky | c4f4b32 | 2014-06-05 10:17:57 -0500 | [diff] [blame] | 224 | |
| 225 | static struct platform_driver ccp_platform_driver = { |
| 226 | .driver = { |
Tom Lendacky | 166db19 | 2015-10-01 16:32:50 -0500 | [diff] [blame] | 227 | .name = "ccp", |
Tom Lendacky | 6c50634 | 2015-02-03 13:07:29 -0600 | [diff] [blame] | 228 | #ifdef CONFIG_ACPI |
| 229 | .acpi_match_table = ccp_acpi_match, |
| 230 | #endif |
| 231 | #ifdef CONFIG_OF |
| 232 | .of_match_table = ccp_of_match, |
| 233 | #endif |
Tom Lendacky | c4f4b32 | 2014-06-05 10:17:57 -0500 | [diff] [blame] | 234 | }, |
| 235 | .probe = ccp_platform_probe, |
| 236 | .remove = ccp_platform_remove, |
| 237 | #ifdef CONFIG_PM |
| 238 | .suspend = ccp_platform_suspend, |
| 239 | .resume = ccp_platform_resume, |
| 240 | #endif |
| 241 | }; |
| 242 | |
| 243 | int ccp_platform_init(void) |
| 244 | { |
| 245 | return platform_driver_register(&ccp_platform_driver); |
| 246 | } |
| 247 | |
| 248 | void ccp_platform_exit(void) |
| 249 | { |
| 250 | platform_driver_unregister(&ccp_platform_driver); |
| 251 | } |