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