1/*
  2 * AMD Secure Processor device driver
  3 *
  4 * Copyright (C) 2013,2016 Advanced Micro Devices, Inc.
  5 *
  6 * Author: Tom Lendacky <thomas.lendacky@amd.com>
  7 * Author: Gary R Hook <gary.hook@amd.com>
  8 *
  9 * This program is free software; you can redistribute it and/or modify
 10 * it under the terms of the GNU General Public License version 2 as
 11 * published by the Free Software Foundation.
 12 */
 13
 14#include <linux/module.h>
 15#include <linux/kernel.h>
 16#include <linux/device.h>
 17#include <linux/pci.h>
 18#include <linux/pci_ids.h>
 19#include <linux/dma-mapping.h>
 20#include <linux/kthread.h>
 21#include <linux/sched.h>
 22#include <linux/interrupt.h>
 23#include <linux/spinlock.h>
 24#include <linux/delay.h>
 25#include <linux/ccp.h>
 26
 27#include "ccp-dev.h"
 28#include "psp-dev.h"
 29
 30#define MSIX_VECTORS			2
 31
 32struct sp_pci {
 33	int msix_count;
 34	struct msix_entry msix_entry[MSIX_VECTORS];
 35};
 36static struct sp_device *sp_dev_master;
 37
 38static int sp_get_msix_irqs(struct sp_device *sp)
 39{
 40	struct sp_pci *sp_pci = sp->dev_specific;
 41	struct device *dev = sp->dev;
 42	struct pci_dev *pdev = to_pci_dev(dev);
 43	int v, ret;
 44
 45	for (v = 0; v < ARRAY_SIZE(sp_pci->msix_entry); v++)
 46		sp_pci->msix_entry[v].entry = v;
 47
 48	ret = pci_enable_msix_range(pdev, sp_pci->msix_entry, 1, v);
 49	if (ret < 0)
 50		return ret;
 51
 52	sp_pci->msix_count = ret;
 53	sp->use_tasklet = true;
 54
 55	sp->psp_irq = sp_pci->msix_entry[0].vector;
 56	sp->ccp_irq = (sp_pci->msix_count > 1) ? sp_pci->msix_entry[1].vector
 57					       : sp_pci->msix_entry[0].vector;
 58	return 0;
 59}
 60
 61static int sp_get_msi_irq(struct sp_device *sp)
 62{
 63	struct device *dev = sp->dev;
 64	struct pci_dev *pdev = to_pci_dev(dev);
 65	int ret;
 66
 67	ret = pci_enable_msi(pdev);
 68	if (ret)
 69		return ret;
 70
 71	sp->ccp_irq = pdev->irq;
 72	sp->psp_irq = pdev->irq;
 73
 74	return 0;
 75}
 76
 77static int sp_get_irqs(struct sp_device *sp)
 78{
 79	struct device *dev = sp->dev;
 80	int ret;
 81
 82	ret = sp_get_msix_irqs(sp);
 83	if (!ret)
 84		return 0;
 85
 86	/* Couldn't get MSI-X vectors, try MSI */
 87	dev_notice(dev, "could not enable MSI-X (%d), trying MSI\n", ret);
 88	ret = sp_get_msi_irq(sp);
 89	if (!ret)
 90		return 0;
 91
 92	/* Couldn't get MSI interrupt */
 93	dev_notice(dev, "could not enable MSI (%d)\n", ret);
 94
 95	return ret;
 96}
 97
 98static void sp_free_irqs(struct sp_device *sp)
 99{
100	struct sp_pci *sp_pci = sp->dev_specific;
101	struct device *dev = sp->dev;
102	struct pci_dev *pdev = to_pci_dev(dev);
103
104	if (sp_pci->msix_count)
105		pci_disable_msix(pdev);
106	else if (sp->psp_irq)
107		pci_disable_msi(pdev);
108
109	sp->ccp_irq = 0;
110	sp->psp_irq = 0;
111}
112
113static bool sp_pci_is_master(struct sp_device *sp)
114{
115	struct device *dev_cur, *dev_new;
116	struct pci_dev *pdev_cur, *pdev_new;
117
118	dev_new = sp->dev;
119	dev_cur = sp_dev_master->dev;
120
121	pdev_new = to_pci_dev(dev_new);
122	pdev_cur = to_pci_dev(dev_cur);
123
124	if (pdev_new->bus->number < pdev_cur->bus->number)
125		return true;
126
127	if (PCI_SLOT(pdev_new->devfn) < PCI_SLOT(pdev_cur->devfn))
128		return true;
129
130	if (PCI_FUNC(pdev_new->devfn) < PCI_FUNC(pdev_cur->devfn))
131		return true;
132
133	return false;
134}
135
136static void psp_set_master(struct sp_device *sp)
137{
138	if (!sp_dev_master) {
139		sp_dev_master = sp;
140		return;
141	}
142
143	if (sp_pci_is_master(sp))
144		sp_dev_master = sp;
145}
146
147static struct sp_device *psp_get_master(void)
148{
149	return sp_dev_master;
150}
151
152static int sp_pci_probe(struct pci_dev *pdev, const struct pci_device_id *id)
153{
154	struct sp_device *sp;
155	struct sp_pci *sp_pci;
156	struct device *dev = &pdev->dev;
157	void __iomem * const *iomap_table;
158	int bar_mask;
159	int ret;
160
161	ret = -ENOMEM;
162	sp = sp_alloc_struct(dev);
163	if (!sp)
164		goto e_err;
165
166	sp_pci = devm_kzalloc(dev, sizeof(*sp_pci), GFP_KERNEL);
167	if (!sp_pci)
168		goto e_err;
169
170	sp->dev_specific = sp_pci;
171	sp->dev_vdata = (struct sp_dev_vdata *)id->driver_data;
172	if (!sp->dev_vdata) {
173		ret = -ENODEV;
174		dev_err(dev, "missing driver data\n");
175		goto e_err;
176	}
177
178	ret = pcim_enable_device(pdev);
179	if (ret) {
180		dev_err(dev, "pcim_enable_device failed (%d)\n", ret);
181		goto e_err;
182	}
183
184	bar_mask = pci_select_bars(pdev, IORESOURCE_MEM);
185	ret = pcim_iomap_regions(pdev, bar_mask, "ccp");
186	if (ret) {
187		dev_err(dev, "pcim_iomap_regions failed (%d)\n", ret);
188		goto e_err;
189	}
190
191	iomap_table = pcim_iomap_table(pdev);
192	if (!iomap_table) {
193		dev_err(dev, "pcim_iomap_table failed\n");
194		ret = -ENOMEM;
195		goto e_err;
196	}
197
198	sp->io_map = iomap_table[sp->dev_vdata->bar];
199	if (!sp->io_map) {
200		dev_err(dev, "ioremap failed\n");
201		ret = -ENOMEM;
202		goto e_err;
203	}
204
205	ret = sp_get_irqs(sp);
206	if (ret)
207		goto e_err;
208
209	pci_set_master(pdev);
210	sp->set_psp_master_device = psp_set_master;
211	sp->get_psp_master_device = psp_get_master;
212
213	ret = dma_set_mask_and_coherent(dev, DMA_BIT_MASK(48));
214	if (ret) {
215		ret = dma_set_mask_and_coherent(dev, DMA_BIT_MASK(32));
216		if (ret) {
217			dev_err(dev, "dma_set_mask_and_coherent failed (%d)\n",
218				ret);
219			goto e_err;
220		}
221	}
222
223	dev_set_drvdata(dev, sp);
224
225	ret = sp_init(sp);
226	if (ret)
227		goto e_err;
228
229	dev_notice(dev, "enabled\n");
230
231	return 0;
232
233e_err:
234	dev_notice(dev, "initialization failed\n");
235	return ret;
236}
237
238static void sp_pci_remove(struct pci_dev *pdev)
239{
240	struct device *dev = &pdev->dev;
241	struct sp_device *sp = dev_get_drvdata(dev);
242
243	if (!sp)
244		return;
245
246	sp_destroy(sp);
247
248	sp_free_irqs(sp);
249
250	dev_notice(dev, "disabled\n");
251}
252
253#ifdef CONFIG_PM
254static int sp_pci_suspend(struct pci_dev *pdev, pm_message_t state)
255{
256	struct device *dev = &pdev->dev;
257	struct sp_device *sp = dev_get_drvdata(dev);
258
259	return sp_suspend(sp, state);
260}
261
262static int sp_pci_resume(struct pci_dev *pdev)
263{
264	struct device *dev = &pdev->dev;
265	struct sp_device *sp = dev_get_drvdata(dev);
266
267	return sp_resume(sp);
268}
269#endif
270
271#ifdef CONFIG_CRYPTO_DEV_SP_PSP
272static const struct psp_vdata psp_entry = {
273	.offset = 0x10500,
274};
275#endif
276
277static const struct sp_dev_vdata dev_vdata[] = {
278	{
279		.bar = 2,
280#ifdef CONFIG_CRYPTO_DEV_SP_CCP
281		.ccp_vdata = &ccpv3,
282#endif
283	},
284	{
285		.bar = 2,
286#ifdef CONFIG_CRYPTO_DEV_SP_CCP
287		.ccp_vdata = &ccpv5a,
288#endif
289#ifdef CONFIG_CRYPTO_DEV_SP_PSP
290		.psp_vdata = &psp_entry
291#endif
292	},
293	{
294		.bar = 2,
295#ifdef CONFIG_CRYPTO_DEV_SP_CCP
296		.ccp_vdata = &ccpv5b,
297#endif
298	},
299};
300static const struct pci_device_id sp_pci_table[] = {
301	{ PCI_VDEVICE(AMD, 0x1537), (kernel_ulong_t)&dev_vdata[0] },
302	{ PCI_VDEVICE(AMD, 0x1456), (kernel_ulong_t)&dev_vdata[1] },
303	{ PCI_VDEVICE(AMD, 0x1468), (kernel_ulong_t)&dev_vdata[2] },
304	/* Last entry must be zero */
305	{ 0, }
306};
307MODULE_DEVICE_TABLE(pci, sp_pci_table);
308
309static struct pci_driver sp_pci_driver = {
310	.name = "ccp",
311	.id_table = sp_pci_table,
312	.probe = sp_pci_probe,
313	.remove = sp_pci_remove,
314#ifdef CONFIG_PM
315	.suspend = sp_pci_suspend,
316	.resume = sp_pci_resume,
317#endif
318};
319
320int sp_pci_init(void)
321{
322	return pci_register_driver(&sp_pci_driver);
323}
324
325void sp_pci_exit(void)
326{
327	pci_unregister_driver(&sp_pci_driver);
328}