[thirdparty/u-boot.git] / drivers / pci_endpoint / sandbox-pci_ep.c

// SPDX-License-Identifier: GPL-2.0+
/*
 * Copyright (c) 2019 Ramon Fried <ramon.fried@gmail.com>
 */

#include <common.h>
#include <dm.h>
#include <errno.h>
#include <pci.h>
#include <pci_ep.h>
#include <asm/test.h>

/**
 * struct sandbox_pci_ep_priv - private data for driver
 * @hdr: Stores the EP device header
 * @msix: required MSIx count;
 * @msi: required MSI count;
 */
struct sandbox_pci_ep_priv {
	struct pci_ep_header hdr;
	struct pci_bar bars[6];
	int msix;
	int msi;
	int irq_count;
};

/* Method exported for testing purposes */
int sandbox_get_pci_ep_irq_count(struct udevice *dev)
{
	struct sandbox_pci_ep_priv *priv = dev_get_priv(dev);

	return priv->irq_count;
}

static const struct udevice_id sandbox_pci_ep_ids[] = {
	{ .compatible = "sandbox,pci_ep" },
	{ }
};

static int sandbox_write_header(struct udevice *dev, uint fn,
				struct pci_ep_header *hdr)
{
	struct sandbox_pci_ep_priv *priv = dev_get_priv(dev);

	if (fn > 0)
		return -ENODEV;

	memcpy(&priv->hdr, hdr, sizeof(*hdr));

	return 0;
}

static int sandbox_read_header(struct udevice *dev, uint fn,
			       struct pci_ep_header *hdr)
{
	struct sandbox_pci_ep_priv *priv = dev_get_priv(dev);

	if (fn > 0)
		return -ENODEV;

	memcpy(hdr, &priv->hdr, sizeof(*hdr));

	return 0;
}

static int sandbox_set_bar(struct udevice *dev, uint fn,
			   struct pci_bar *ep_bar)
{
	struct sandbox_pci_ep_priv *priv = dev_get_priv(dev);
	int bar_idx;

	if (fn > 0)
		return -ENODEV;

	bar_idx = ep_bar->barno;

	memcpy(&priv->bars[bar_idx], ep_bar, sizeof(*ep_bar));

	return 0;
}

static int sandbox_read_bar(struct udevice *dev, uint fn,
			    struct pci_bar *ep_bar, enum pci_barno barno)
{
	struct sandbox_pci_ep_priv *priv = dev_get_priv(dev);

	if (fn > 0)
		return -ENODEV;

	memcpy(ep_bar, &priv->bars[barno], sizeof(*ep_bar));

	return 0;
}

static int sandbox_set_msi(struct udevice *dev, uint fn, uint interrupts)
{
	struct sandbox_pci_ep_priv *priv = dev_get_priv(dev);

	if (fn > 0)
		return -ENODEV;

	priv->msi = interrupts;

	return 0;
}

static int sandbox_get_msi(struct udevice *dev, uint fn)
{
	struct sandbox_pci_ep_priv *priv = dev_get_priv(dev);

	if (fn > 0)
		return -ENODEV;

	return priv->msi;
}

static int sandbox_set_msix(struct udevice *dev, uint fn, uint interrupts)
{
	struct sandbox_pci_ep_priv *priv = dev_get_priv(dev);

	if (fn > 0)
		return -ENODEV;

	priv->msix = interrupts;

	return 0;
}

static int sandbox_get_msix(struct udevice *dev, uint fn)
{
	struct sandbox_pci_ep_priv *priv = dev_get_priv(dev);

	if (fn > 0)
		return -ENODEV;

	return priv->msix;
}

static int sandbox_raise_irq(struct udevice *dev, uint fn,
			     enum pci_ep_irq_type type, uint interrupt_num)
{
	struct sandbox_pci_ep_priv *priv = dev_get_priv(dev);

	if (fn > 0)
		return -ENODEV;

	priv->irq_count++;

	return 0;
}

static int sandbox_pci_ep_probe(struct udevice *dev)
{
	struct sandbox_pci_ep_priv *priv = dev_get_priv(dev);

	memset(priv, 0, sizeof(*priv));
	return 0;
}

static struct pci_ep_ops sandbox_pci_ep_ops = {
	.write_header = sandbox_write_header,
	.read_header = sandbox_read_header,
	.set_bar = sandbox_set_bar,
	.read_bar = sandbox_read_bar,
	.set_msi = sandbox_set_msi,
	.get_msi = sandbox_get_msi,
	.set_msix = sandbox_set_msix,
	.get_msix = sandbox_get_msix,
	.raise_irq = sandbox_raise_irq,
};

U_BOOT_DRIVER(pci_ep_sandbox) = {
	.name		= "pci_ep_sandbox",
	.id		= UCLASS_PCI_EP,
	.of_match	= sandbox_pci_ep_ids,
	.probe		= sandbox_pci_ep_probe,
	.ops		= &sandbox_pci_ep_ops,
	.priv_auto_alloc_size = sizeof(struct sandbox_pci_ep_priv),
};
Commit	Line	Data
bb413337 RF	1	// SPDX-License-Identifier: GPL-2.0+
	2	/*
	3	* Copyright (c) 2019 Ramon Fried <ramon.fried@gmail.com>
	4	*/
	5
	6	#include <common.h>
	7	#include <dm.h>
	8	#include <errno.h>
	9	#include <pci.h>
	10	#include <pci_ep.h>
	11	#include <asm/test.h>
	12
	13	/**
	14	* struct sandbox_pci_ep_priv - private data for driver
	15	* @hdr: Stores the EP device header
	16	* @msix: required MSIx count;
	17	* @msi: required MSI count;
	18	*/
	19	struct sandbox_pci_ep_priv {
	20	struct pci_ep_header hdr;
	21	struct pci_bar bars[6];
	22	int msix;
	23	int msi;
	24	int irq_count;
	25	};
	26
	27	/* Method exported for testing purposes */
	28	int sandbox_get_pci_ep_irq_count(struct udevice *dev)
	29	{
	30	struct sandbox_pci_ep_priv *priv = dev_get_priv(dev);
	31
	32	return priv->irq_count;
	33	}
	34
	35	static const struct udevice_id sandbox_pci_ep_ids[] = {
	36	{ .compatible = "sandbox,pci_ep" },
	37	{ }
	38	};
	39
	40	static int sandbox_write_header(struct udevice *dev, uint fn,
	41	struct pci_ep_header *hdr)
	42	{
	43	struct sandbox_pci_ep_priv *priv = dev_get_priv(dev);
	44
	45	if (fn > 0)
	46	return -ENODEV;
	47
	48	memcpy(&priv->hdr, hdr, sizeof(*hdr));
	49
	50	return 0;
	51	}
	52
	53	static int sandbox_read_header(struct udevice *dev, uint fn,
	54	struct pci_ep_header *hdr)
	55	{
	56	struct sandbox_pci_ep_priv *priv = dev_get_priv(dev);
	57
	58	if (fn > 0)
	59	return -ENODEV;
	60
	61	memcpy(hdr, &priv->hdr, sizeof(*hdr));
	62
	63	return 0;
	64	}
65
66	static int sandbox_set_bar(struct udevice *dev, uint fn,
67	struct pci_bar *ep_bar)
68	{
69	struct sandbox_pci_ep_priv *priv = dev_get_priv(dev);
70	int bar_idx;
71
72	if (fn > 0)
73	return -ENODEV;
74
75	bar_idx = ep_bar->barno;
76
77	memcpy(&priv->bars[bar_idx], ep_bar, sizeof(*ep_bar));
78
79	return 0;
80	}
81
82	static int sandbox_read_bar(struct udevice *dev, uint fn,
83	struct pci_bar *ep_bar, enum pci_barno barno)
84	{
85	struct sandbox_pci_ep_priv *priv = dev_get_priv(dev);
bb413337 RF	86
	87	if (fn > 0)
	88	return -ENODEV;
	89
eb187425	90	memcpy(ep_bar, &priv->bars[barno], sizeof(*ep_bar));
bb413337 RF	91
	92	return 0;
	93	}
	94
	95	static int sandbox_set_msi(struct udevice *dev, uint fn, uint interrupts)
	96	{
	97	struct sandbox_pci_ep_priv *priv = dev_get_priv(dev);
	98
	99	if (fn > 0)
	100	return -ENODEV;
	101
	102	priv->msi = interrupts;
	103
	104	return 0;
	105	}
	106
	107	static int sandbox_get_msi(struct udevice *dev, uint fn)
	108	{
	109	struct sandbox_pci_ep_priv *priv = dev_get_priv(dev);
	110
	111	if (fn > 0)
	112	return -ENODEV;
	113
	114	return priv->msi;
	115	}
	116
	117	static int sandbox_set_msix(struct udevice *dev, uint fn, uint interrupts)
	118	{
	119	struct sandbox_pci_ep_priv *priv = dev_get_priv(dev);
	120
	121	if (fn > 0)
	122	return -ENODEV;
	123
	124	priv->msix = interrupts;
	125
	126	return 0;
	127	}
	128
	129	static int sandbox_get_msix(struct udevice *dev, uint fn)
	130	{
	131	struct sandbox_pci_ep_priv *priv = dev_get_priv(dev);
	132
	133	if (fn > 0)
	134	return -ENODEV;
	135
	136	return priv->msix;
	137	}
	138
	139	static int sandbox_raise_irq(struct udevice *dev, uint fn,
	140	enum pci_ep_irq_type type, uint interrupt_num)
	141	{
	142	struct sandbox_pci_ep_priv *priv = dev_get_priv(dev);
	143
	144	if (fn > 0)
	145	return -ENODEV;
	146
	147	priv->irq_count++;
	148
	149	return 0;
	150	}
	151
	152	static int sandbox_pci_ep_probe(struct udevice *dev)
	153	{
	154	struct sandbox_pci_ep_priv *priv = dev_get_priv(dev);
155
156	memset(priv, 0, sizeof(*priv));
157	return 0;
158	}
159
160	static struct pci_ep_ops sandbox_pci_ep_ops = {
161	.write_header = sandbox_write_header,
162	.read_header = sandbox_read_header,
163	.set_bar = sandbox_set_bar,
164	.read_bar = sandbox_read_bar,
165	.set_msi = sandbox_set_msi,
166	.get_msi = sandbox_get_msi,
167	.set_msix = sandbox_set_msix,
168	.get_msix = sandbox_get_msix,
169	.raise_irq = sandbox_raise_irq,
170	};
171
172	U_BOOT_DRIVER(pci_ep_sandbox) = {
173	.name = "pci_ep_sandbox",
174	.id = UCLASS_PCI_EP,
175	.of_match = sandbox_pci_ep_ids,
176	.probe = sandbox_pci_ep_probe,
177	.ops = &sandbox_pci_ep_ops,
178	.priv_auto_alloc_size = sizeof(struct sandbox_pci_ep_priv),
179	};