1/*
2 * AMD Secure Processor device driver
3 *
4 * Copyright (C) 2014,2018 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 sp_platform {
32 int coherent;
33 unsigned int irq_count;
34};
35
36static const struct sp_dev_vdata dev_vdata[] = {
37 {
38 .bar = 0,
39#ifdef CONFIG_CRYPTO_DEV_SP_CCP
40 .ccp_vdata = &ccpv3_platform,
41#endif
42 },
43};
44
45#ifdef CONFIG_ACPI
46static const struct acpi_device_id sp_acpi_match[] = {
47 { "AMDI0C00", (kernel_ulong_t)&dev_vdata[0] },
48 { },
49};
50MODULE_DEVICE_TABLE(acpi, sp_acpi_match);
51#endif
52
53#ifdef CONFIG_OF
54static const struct of_device_id sp_of_match[] = {
55 { .compatible = "amd,ccp-seattle-v1a",
56 .data = (const void *)&dev_vdata[0] },
57 { },
58};
59MODULE_DEVICE_TABLE(of, sp_of_match);
60#endif
61
62static struct sp_dev_vdata *sp_get_of_version(struct platform_device *pdev)
63{
64#ifdef CONFIG_OF
65 const struct of_device_id *match;
66
67 match = of_match_node(sp_of_match, pdev->dev.of_node);
68 if (match && match->data)
69 return (struct sp_dev_vdata *)match->data;
70#endif
71 return NULL;
72}
73
74static struct sp_dev_vdata *sp_get_acpi_version(struct platform_device *pdev)
75{
76#ifdef CONFIG_ACPI
77 const struct acpi_device_id *match;
78
79 match = acpi_match_device(sp_acpi_match, &pdev->dev);
80 if (match && match->driver_data)
81 return (struct sp_dev_vdata *)match->driver_data;
82#endif
83 return NULL;
84}
85
86static int sp_get_irqs(struct sp_device *sp)
87{
88 struct sp_platform *sp_platform = sp->dev_specific;
89 struct device *dev = sp->dev;
90 struct platform_device *pdev = to_platform_device(dev);
91 unsigned int i, count;
92 int ret;
93
94 for (i = 0, count = 0; i < pdev->num_resources; i++) {
95 struct resource *res = &pdev->resource[i];
96
97 if (resource_type(res) == IORESOURCE_IRQ)
98 count++;
99 }
100
101 sp_platform->irq_count = count;
102
103 ret = platform_get_irq(pdev, 0);
104 if (ret < 0) {
105 dev_notice(dev, "unable to get IRQ (%d)\n", ret);
106 return ret;
107 }
108
109 sp->psp_irq = ret;
110 if (count == 1) {
111 sp->ccp_irq = ret;
112 } else {
113 ret = platform_get_irq(pdev, 1);
114 if (ret < 0) {
115 dev_notice(dev, "unable to get IRQ (%d)\n", ret);
116 return ret;
117 }
118
119 sp->ccp_irq = ret;
120 }
121
122 return 0;
123}
124
125static int sp_platform_probe(struct platform_device *pdev)
126{
127 struct sp_device *sp;
128 struct sp_platform *sp_platform;
129 struct device *dev = &pdev->dev;
130 enum dev_dma_attr attr;
131 struct resource *ior;
132 int ret;
133
134 ret = -ENOMEM;
135 sp = sp_alloc_struct(dev);
136 if (!sp)
137 goto e_err;
138
139 sp_platform = devm_kzalloc(dev, sizeof(*sp_platform), GFP_KERNEL);
140 if (!sp_platform)
141 goto e_err;
142
143 sp->dev_specific = sp_platform;
144 sp->dev_vdata = pdev->dev.of_node ? sp_get_of_version(pdev)
145 : sp_get_acpi_version(pdev);
146 if (!sp->dev_vdata) {
147 ret = -ENODEV;
148 dev_err(dev, "missing driver data\n");
149 goto e_err;
150 }
151
152 ior = platform_get_resource(pdev, IORESOURCE_MEM, 0);
153 sp->io_map = devm_ioremap_resource(dev, ior);
154 if (IS_ERR(sp->io_map)) {
155 ret = PTR_ERR(sp->io_map);
156 goto e_err;
157 }
158
159 attr = device_get_dma_attr(dev);
160 if (attr == DEV_DMA_NOT_SUPPORTED) {
161 dev_err(dev, "DMA is not supported");
162 goto e_err;
163 }
164
165 sp_platform->coherent = (attr == DEV_DMA_COHERENT);
166 if (sp_platform->coherent)
167 sp->axcache = CACHE_WB_NO_ALLOC;
168 else
169 sp->axcache = CACHE_NONE;
170
171 ret = dma_set_mask_and_coherent(dev, DMA_BIT_MASK(48));
172 if (ret) {
173 dev_err(dev, "dma_set_mask_and_coherent failed (%d)\n", ret);
174 goto e_err;
175 }
176
177 ret = sp_get_irqs(sp);
178 if (ret)
179 goto e_err;
180
181 dev_set_drvdata(dev, sp);
182
183 ret = sp_init(sp);
184 if (ret)
185 goto e_err;
186
187 dev_notice(dev, "enabled\n");
188
189 return 0;
190
191e_err:
192 dev_notice(dev, "initialization failed\n");
193 return ret;
194}
195
196static int sp_platform_remove(struct platform_device *pdev)
197{
198 struct device *dev = &pdev->dev;
199 struct sp_device *sp = dev_get_drvdata(dev);
200
201 sp_destroy(sp);
202
203 dev_notice(dev, "disabled\n");
204
205 return 0;
206}
207
208#ifdef CONFIG_PM
209static int sp_platform_suspend(struct platform_device *pdev,
210 pm_message_t state)
211{
212 struct device *dev = &pdev->dev;
213 struct sp_device *sp = dev_get_drvdata(dev);
214
215 return sp_suspend(sp, state);
216}
217
218static int sp_platform_resume(struct platform_device *pdev)
219{
220 struct device *dev = &pdev->dev;
221 struct sp_device *sp = dev_get_drvdata(dev);
222
223 return sp_resume(sp);
224}
225#endif
226
227static struct platform_driver sp_platform_driver = {
228 .driver = {
229 .name = "ccp",
230#ifdef CONFIG_ACPI
231 .acpi_match_table = sp_acpi_match,
232#endif
233#ifdef CONFIG_OF
234 .of_match_table = sp_of_match,
235#endif
236 },
237 .probe = sp_platform_probe,
238 .remove = sp_platform_remove,
239#ifdef CONFIG_PM
240 .suspend = sp_platform_suspend,
241 .resume = sp_platform_resume,
242#endif
243};
244
245int sp_platform_init(void)
246{
247 return platform_driver_register(&sp_platform_driver);
248}
249
250void sp_platform_exit(void)
251{
252 platform_driver_unregister(&sp_platform_driver);
253}
254