tjh.dev
Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
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
31struct ccp_platform {
32 int coherent;
33};
34
35static const struct acpi_device_id ccp_acpi_match[];
36static const struct of_device_id ccp_of_match[];
37
38static 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
50static 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
62static 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
83static 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
98static void ccp_free_irqs(struct ccp_device *ccp)
99{
100 struct device *dev = ccp->dev;
101
102 free_irq(ccp->irq, dev);
103}
104
105static 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
118static 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
183e_err:
184 dev_notice(dev, "initialization failed\n");
185 return ret;
186}
187
188static 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
201static 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
227static 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
251static const struct acpi_device_id ccp_acpi_match[] = {
252 { "AMDI0C00", (kernel_ulong_t)&ccpv3 },
253 { },
254};
255MODULE_DEVICE_TABLE(acpi, ccp_acpi_match);
256#endif
257
258#ifdef CONFIG_OF
259static const struct of_device_id ccp_of_match[] = {
260 { .compatible = "amd,ccp-seattle-v1a",
261 .data = (const void *)&ccpv3 },
262 { },
263};
264MODULE_DEVICE_TABLE(of, ccp_of_match);
265#endif
266
267static 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
285int ccp_platform_init(void)
286{
287 return platform_driver_register(&ccp_platform_driver);
288}
289
290void ccp_platform_exit(void)
291{
292 platform_driver_unregister(&ccp_platform_driver);
293}