1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3  * Copyright (C) 2018, Bin Meng <bmeng.cn@gmail.com>
4  *
5  * VirtIO PCI bus transport driver
6  * Ported from Linux drivers/virtio/virtio_pci*.c
7  */
8 
9 #include <common.h>
10 #include <dm.h>
11 #include <log.h>
12 #include <virtio_types.h>
13 #include <virtio.h>
14 #include <virtio_ring.h>
15 #include <dm/device.h>
16 #include <linux/bug.h>
17 #include <linux/compat.h>
18 #include <linux/err.h>
19 #include <linux/io.h>
20 #include "virtio_pci.h"
21 
22 #define VIRTIO_PCI_DRV_NAME	"virtio-pci.l"
23 
24 /* PCI device ID in the range 0x1000 to 0x103f */
25 #define VIRTIO_PCI_VENDOR_ID	0x1af4
26 #define VIRTIO_PCI_DEVICE_ID00	0x1000
27 #define VIRTIO_PCI_DEVICE_ID01	0x1001
28 #define VIRTIO_PCI_DEVICE_ID02	0x1002
29 #define VIRTIO_PCI_DEVICE_ID03	0x1003
30 #define VIRTIO_PCI_DEVICE_ID04	0x1004
31 #define VIRTIO_PCI_DEVICE_ID05	0x1005
32 #define VIRTIO_PCI_DEVICE_ID06	0x1006
33 #define VIRTIO_PCI_DEVICE_ID07	0x1007
34 #define VIRTIO_PCI_DEVICE_ID08	0x1008
35 #define VIRTIO_PCI_DEVICE_ID09	0x1009
36 #define VIRTIO_PCI_DEVICE_ID0A	0x100a
37 #define VIRTIO_PCI_DEVICE_ID0B	0x100b
38 #define VIRTIO_PCI_DEVICE_ID0C	0x100c
39 #define VIRTIO_PCI_DEVICE_ID0D	0x100d
40 #define VIRTIO_PCI_DEVICE_ID0E	0x100e
41 #define VIRTIO_PCI_DEVICE_ID0F	0x100f
42 #define VIRTIO_PCI_DEVICE_ID10	0x1010
43 #define VIRTIO_PCI_DEVICE_ID11	0x1011
44 #define VIRTIO_PCI_DEVICE_ID12	0x1012
45 #define VIRTIO_PCI_DEVICE_ID13	0x1013
46 #define VIRTIO_PCI_DEVICE_ID14	0x1014
47 #define VIRTIO_PCI_DEVICE_ID15	0x1015
48 #define VIRTIO_PCI_DEVICE_ID16	0x1016
49 #define VIRTIO_PCI_DEVICE_ID17	0x1017
50 #define VIRTIO_PCI_DEVICE_ID18	0x1018
51 #define VIRTIO_PCI_DEVICE_ID19	0x1019
52 #define VIRTIO_PCI_DEVICE_ID1A	0x101a
53 #define VIRTIO_PCI_DEVICE_ID1B	0x101b
54 #define VIRTIO_PCI_DEVICE_ID1C	0x101c
55 #define VIRTIO_PCI_DEVICE_ID1D	0x101d
56 #define VIRTIO_PCI_DEVICE_ID1E	0x101e
57 #define VIRTIO_PCI_DEVICE_ID1F	0x101f
58 #define VIRTIO_PCI_DEVICE_ID20	0x1020
59 #define VIRTIO_PCI_DEVICE_ID21	0x1021
60 #define VIRTIO_PCI_DEVICE_ID22	0x1022
61 #define VIRTIO_PCI_DEVICE_ID23	0x1023
62 #define VIRTIO_PCI_DEVICE_ID24	0x1024
63 #define VIRTIO_PCI_DEVICE_ID25	0x1025
64 #define VIRTIO_PCI_DEVICE_ID26	0x1026
65 #define VIRTIO_PCI_DEVICE_ID27	0x1027
66 #define VIRTIO_PCI_DEVICE_ID28	0x1028
67 #define VIRTIO_PCI_DEVICE_ID29	0x1029
68 #define VIRTIO_PCI_DEVICE_ID2A	0x102a
69 #define VIRTIO_PCI_DEVICE_ID2B	0x102b
70 #define VIRTIO_PCI_DEVICE_ID2C	0x102c
71 #define VIRTIO_PCI_DEVICE_ID2D	0x102d
72 #define VIRTIO_PCI_DEVICE_ID2E	0x102e
73 #define VIRTIO_PCI_DEVICE_ID2F	0x102f
74 #define VIRTIO_PCI_DEVICE_ID30	0x1030
75 #define VIRTIO_PCI_DEVICE_ID31	0x1031
76 #define VIRTIO_PCI_DEVICE_ID32	0x1032
77 #define VIRTIO_PCI_DEVICE_ID33	0x1033
78 #define VIRTIO_PCI_DEVICE_ID34	0x1034
79 #define VIRTIO_PCI_DEVICE_ID35	0x1035
80 #define VIRTIO_PCI_DEVICE_ID36	0x1036
81 #define VIRTIO_PCI_DEVICE_ID37	0x1037
82 #define VIRTIO_PCI_DEVICE_ID38	0x1038
83 #define VIRTIO_PCI_DEVICE_ID39	0x1039
84 #define VIRTIO_PCI_DEVICE_ID3A	0x103a
85 #define VIRTIO_PCI_DEVICE_ID3B	0x103b
86 #define VIRTIO_PCI_DEVICE_ID3C	0x103c
87 #define VIRTIO_PCI_DEVICE_ID3D	0x103d
88 #define VIRTIO_PCI_DEVICE_ID3E	0x103e
89 #define VIRTIO_PCI_DEVICE_ID3F	0x103f
90 
91 /**
92  * virtio pci transport driver private data
93  *
94  * @ioaddr:	pci transport device register base
95  * @version:	pci transport device version
96  */
97 struct virtio_pci_priv {
98 	void __iomem *ioaddr;
99 };
100 
virtio_pci_get_config(struct udevice * udev,unsigned int offset,void * buf,unsigned int len)101 static int virtio_pci_get_config(struct udevice *udev, unsigned int offset,
102 				 void *buf, unsigned int len)
103 {
104 	struct virtio_pci_priv *priv = dev_get_priv(udev);
105 	void __iomem *ioaddr = priv->ioaddr + VIRTIO_PCI_CONFIG_OFF(false);
106 	u8 *ptr = buf;
107 	int i;
108 
109 	for (i = 0; i < len; i++)
110 		ptr[i] = ioread8(ioaddr + i);
111 
112 	return 0;
113 }
114 
virtio_pci_set_config(struct udevice * udev,unsigned int offset,const void * buf,unsigned int len)115 static int virtio_pci_set_config(struct udevice *udev, unsigned int offset,
116 				 const void *buf, unsigned int len)
117 {
118 	struct virtio_pci_priv *priv = dev_get_priv(udev);
119 	void __iomem *ioaddr = priv->ioaddr + VIRTIO_PCI_CONFIG_OFF(false);
120 	const u8 *ptr = buf;
121 	int i;
122 
123 	for (i = 0; i < len; i++)
124 		iowrite8(ptr[i], ioaddr + i);
125 
126 	return 0;
127 }
128 
virtio_pci_get_status(struct udevice * udev,u8 * status)129 static int virtio_pci_get_status(struct udevice *udev, u8 *status)
130 {
131 	struct virtio_pci_priv *priv = dev_get_priv(udev);
132 
133 	*status = ioread8(priv->ioaddr + VIRTIO_PCI_STATUS);
134 
135 	return 0;
136 }
137 
virtio_pci_set_status(struct udevice * udev,u8 status)138 static int virtio_pci_set_status(struct udevice *udev, u8 status)
139 {
140 	struct virtio_pci_priv *priv = dev_get_priv(udev);
141 
142 	/* We should never be setting status to 0 */
143 	WARN_ON(status == 0);
144 
145 	iowrite8(status, priv->ioaddr + VIRTIO_PCI_STATUS);
146 
147 	return 0;
148 }
149 
virtio_pci_reset(struct udevice * udev)150 static int virtio_pci_reset(struct udevice *udev)
151 {
152 	struct virtio_pci_priv *priv = dev_get_priv(udev);
153 
154 	/* 0 status means a reset */
155 	iowrite8(0, priv->ioaddr + VIRTIO_PCI_STATUS);
156 
157 	/*
158 	 * Flush out the status write, and flush in device writes,
159 	 * including MSI-X interrupts, if any.
160 	 */
161 	ioread8(priv->ioaddr + VIRTIO_PCI_STATUS);
162 
163 	return 0;
164 }
165 
virtio_pci_get_features(struct udevice * udev,u64 * features)166 static int virtio_pci_get_features(struct udevice *udev, u64 *features)
167 {
168 	struct virtio_pci_priv *priv = dev_get_priv(udev);
169 
170 	/*
171 	 * When someone needs more than 32 feature bits, we'll need to
172 	 * steal a bit to indicate that the rest are somewhere else.
173 	 */
174 	*features = ioread32(priv->ioaddr + VIRTIO_PCI_HOST_FEATURES);
175 
176 	return 0;
177 }
178 
virtio_pci_set_features(struct udevice * udev)179 static int virtio_pci_set_features(struct udevice *udev)
180 {
181 	struct virtio_pci_priv *priv = dev_get_priv(udev);
182 	struct virtio_dev_priv *uc_priv = dev_get_uclass_priv(udev);
183 
184 	/* Make sure we don't have any features > 32 bits! */
185 	WARN_ON((u32)uc_priv->features != uc_priv->features);
186 
187 	/* We only support 32 feature bits */
188 	iowrite32(uc_priv->features, priv->ioaddr + VIRTIO_PCI_GUEST_FEATURES);
189 
190 	return 0;
191 }
192 
virtio_pci_setup_vq(struct udevice * udev,unsigned int index)193 static struct virtqueue *virtio_pci_setup_vq(struct udevice *udev,
194 					     unsigned int index)
195 {
196 	struct virtio_pci_priv *priv = dev_get_priv(udev);
197 	struct virtqueue *vq;
198 	unsigned int num;
199 	int err;
200 
201 	/* Select the queue we're interested in */
202 	iowrite16(index, priv->ioaddr + VIRTIO_PCI_QUEUE_SEL);
203 
204 	/* Check if queue is either not available or already active */
205 	num = ioread16(priv->ioaddr + VIRTIO_PCI_QUEUE_NUM);
206 	if (!num || ioread32(priv->ioaddr + VIRTIO_PCI_QUEUE_PFN)) {
207 		err = -ENOENT;
208 		goto error_available;
209 	}
210 
211 	/* Create the vring */
212 	vq = vring_create_virtqueue(index, num, VIRTIO_PCI_VRING_ALIGN, udev);
213 	if (!vq) {
214 		err = -ENOMEM;
215 		goto error_available;
216 	}
217 
218 	/* Activate the queue */
219 	iowrite32(virtqueue_get_desc_addr(vq) >> VIRTIO_PCI_QUEUE_ADDR_SHIFT,
220 		  priv->ioaddr + VIRTIO_PCI_QUEUE_PFN);
221 
222 	return vq;
223 
224 error_available:
225 	return ERR_PTR(err);
226 }
227 
virtio_pci_del_vq(struct virtqueue * vq)228 static void virtio_pci_del_vq(struct virtqueue *vq)
229 {
230 	struct virtio_pci_priv *priv = dev_get_priv(vq->vdev);
231 	unsigned int index = vq->index;
232 
233 	iowrite16(index, priv->ioaddr + VIRTIO_PCI_QUEUE_SEL);
234 
235 	/* Select and deactivate the queue */
236 	iowrite32(0, priv->ioaddr + VIRTIO_PCI_QUEUE_PFN);
237 
238 	vring_del_virtqueue(vq);
239 }
240 
virtio_pci_del_vqs(struct udevice * udev)241 static int virtio_pci_del_vqs(struct udevice *udev)
242 {
243 	struct virtio_dev_priv *uc_priv = dev_get_uclass_priv(udev);
244 	struct virtqueue *vq, *n;
245 
246 	list_for_each_entry_safe(vq, n, &uc_priv->vqs, list)
247 		virtio_pci_del_vq(vq);
248 
249 	return 0;
250 }
251 
virtio_pci_find_vqs(struct udevice * udev,unsigned int nvqs,struct virtqueue * vqs[])252 static int virtio_pci_find_vqs(struct udevice *udev, unsigned int nvqs,
253 			       struct virtqueue *vqs[])
254 {
255 	int i;
256 
257 	for (i = 0; i < nvqs; ++i) {
258 		vqs[i] = virtio_pci_setup_vq(udev, i);
259 		if (IS_ERR(vqs[i])) {
260 			virtio_pci_del_vqs(udev);
261 			return PTR_ERR(vqs[i]);
262 		}
263 	}
264 
265 	return 0;
266 }
267 
virtio_pci_notify(struct udevice * udev,struct virtqueue * vq)268 static int virtio_pci_notify(struct udevice *udev, struct virtqueue *vq)
269 {
270 	struct virtio_pci_priv *priv = dev_get_priv(udev);
271 
272 	/*
273 	 * We write the queue's selector into the notification register
274 	 * to signal the other end
275 	 */
276 	iowrite16(vq->index, priv->ioaddr + VIRTIO_PCI_QUEUE_NOTIFY);
277 
278 	return 0;
279 }
280 
virtio_pci_bind(struct udevice * udev)281 static int virtio_pci_bind(struct udevice *udev)
282 {
283 	static unsigned int num_devs;
284 	char name[20];
285 
286 	/* Create a unique device name for PCI type devices */
287 	sprintf(name, "%s#%u", VIRTIO_PCI_DRV_NAME, num_devs++);
288 	device_set_name(udev, name);
289 
290 	return 0;
291 }
292 
virtio_pci_probe(struct udevice * udev)293 static int virtio_pci_probe(struct udevice *udev)
294 {
295 	struct pci_child_plat *pplat = dev_get_parent_plat(udev);
296 	struct virtio_dev_priv *uc_priv = dev_get_uclass_priv(udev);
297 	struct virtio_pci_priv *priv = dev_get_priv(udev);
298 	u16 subvendor, subdevice;
299 	u8 revision;
300 
301 	/* We only own devices >= 0x1000 and <= 0x103f: leave the rest. */
302 	if (pplat->device < 0x1000 || pplat->device > 0x103f)
303 		return -ENODEV;
304 
305 	/* Transitional devices must have a PCI revision ID of 0 */
306 	dm_pci_read_config8(udev, PCI_REVISION_ID, &revision);
307 	if (revision != VIRTIO_PCI_ABI_VERSION) {
308 		printf("(%s): virtio_pci expected ABI version %d, got %d\n",
309 		       udev->name, VIRTIO_PCI_ABI_VERSION, revision);
310 		return -ENODEV;
311 	}
312 
313 	/*
314 	 * Transitional devices must have the PCI subsystem device ID matching
315 	 * the virtio device ID
316 	 */
317 	dm_pci_read_config16(udev, PCI_SUBSYSTEM_ID, &subdevice);
318 	dm_pci_read_config16(udev, PCI_SUBSYSTEM_VENDOR_ID, &subvendor);
319 	uc_priv->device = subdevice;
320 	uc_priv->vendor = subvendor;
321 
322 	priv->ioaddr = dm_pci_map_bar(udev, PCI_BASE_ADDRESS_0, PCI_REGION_IO);
323 	if (!priv->ioaddr)
324 		return -ENXIO;
325 	debug("(%s): virtio legacy device reg base %04lx\n",
326 	      udev->name, (ulong)priv->ioaddr);
327 
328 	debug("(%s): device (%d) vendor (%08x) version (%d)\n", udev->name,
329 	      uc_priv->device, uc_priv->vendor, revision);
330 
331 	return 0;
332 }
333 
334 static const struct dm_virtio_ops virtio_pci_ops = {
335 	.get_config	= virtio_pci_get_config,
336 	.set_config	= virtio_pci_set_config,
337 	.get_status	= virtio_pci_get_status,
338 	.set_status	= virtio_pci_set_status,
339 	.reset		= virtio_pci_reset,
340 	.get_features	= virtio_pci_get_features,
341 	.set_features	= virtio_pci_set_features,
342 	.find_vqs	= virtio_pci_find_vqs,
343 	.del_vqs	= virtio_pci_del_vqs,
344 	.notify		= virtio_pci_notify,
345 };
346 
347 U_BOOT_DRIVER(virtio_pci_legacy) = {
348 	.name	= VIRTIO_PCI_DRV_NAME,
349 	.id	= UCLASS_VIRTIO,
350 	.ops	= &virtio_pci_ops,
351 	.bind	= virtio_pci_bind,
352 	.probe	= virtio_pci_probe,
353 	.priv_auto	= sizeof(struct virtio_pci_priv),
354 };
355 
356 static struct pci_device_id virtio_pci_supported[] = {
357 	{ PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID00) },
358 	{ PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID01) },
359 	{ PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID02) },
360 	{ PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID03) },
361 	{ PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID04) },
362 	{ PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID05) },
363 	{ PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID06) },
364 	{ PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID07) },
365 	{ PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID08) },
366 	{ PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID09) },
367 	{ PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID0A) },
368 	{ PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID0B) },
369 	{ PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID0C) },
370 	{ PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID0D) },
371 	{ PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID0E) },
372 	{ PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID0F) },
373 	{ PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID10) },
374 	{ PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID11) },
375 	{ PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID12) },
376 	{ PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID13) },
377 	{ PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID14) },
378 	{ PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID15) },
379 	{ PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID16) },
380 	{ PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID17) },
381 	{ PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID18) },
382 	{ PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID19) },
383 	{ PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID1A) },
384 	{ PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID1B) },
385 	{ PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID1C) },
386 	{ PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID1D) },
387 	{ PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID1E) },
388 	{ PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID1F) },
389 	{ PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID20) },
390 	{ PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID21) },
391 	{ PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID22) },
392 	{ PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID23) },
393 	{ PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID24) },
394 	{ PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID25) },
395 	{ PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID26) },
396 	{ PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID27) },
397 	{ PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID28) },
398 	{ PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID29) },
399 	{ PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID2A) },
400 	{ PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID2B) },
401 	{ PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID2C) },
402 	{ PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID2D) },
403 	{ PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID2E) },
404 	{ PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID2F) },
405 	{ PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID30) },
406 	{ PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID31) },
407 	{ PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID32) },
408 	{ PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID33) },
409 	{ PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID34) },
410 	{ PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID35) },
411 	{ PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID36) },
412 	{ PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID37) },
413 	{ PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID38) },
414 	{ PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID39) },
415 	{ PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID3A) },
416 	{ PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID3B) },
417 	{ PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID3C) },
418 	{ PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID3D) },
419 	{ PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID3E) },
420 	{ PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID3F) },
421 	{},
422 };
423 
424 U_BOOT_PCI_DEVICE(virtio_pci_legacy, virtio_pci_supported);
425