1 // SPDX-License-Identifier: GPL-2.0-only
2 #include <linux/virtio.h>
3 #include <linux/spinlock.h>
4 #include <linux/virtio_config.h>
5 #include <linux/module.h>
8 #include <uapi/linux/virtio_ids.h>
10 /* Unique numbering for virtio devices. */
11 static DEFINE_IDA(virtio_index_ida
);
13 static ssize_t
device_show(struct device
*_d
,
14 struct device_attribute
*attr
, char *buf
)
16 struct virtio_device
*dev
= dev_to_virtio(_d
);
17 return sprintf(buf
, "0x%04x\n", dev
->id
.device
);
19 static DEVICE_ATTR_RO(device
);
21 static ssize_t
vendor_show(struct device
*_d
,
22 struct device_attribute
*attr
, char *buf
)
24 struct virtio_device
*dev
= dev_to_virtio(_d
);
25 return sprintf(buf
, "0x%04x\n", dev
->id
.vendor
);
27 static DEVICE_ATTR_RO(vendor
);
29 static ssize_t
status_show(struct device
*_d
,
30 struct device_attribute
*attr
, char *buf
)
32 struct virtio_device
*dev
= dev_to_virtio(_d
);
33 return sprintf(buf
, "0x%08x\n", dev
->config
->get_status(dev
));
35 static DEVICE_ATTR_RO(status
);
37 static ssize_t
modalias_show(struct device
*_d
,
38 struct device_attribute
*attr
, char *buf
)
40 struct virtio_device
*dev
= dev_to_virtio(_d
);
41 return sprintf(buf
, "virtio:d%08Xv%08X\n",
42 dev
->id
.device
, dev
->id
.vendor
);
44 static DEVICE_ATTR_RO(modalias
);
46 static ssize_t
features_show(struct device
*_d
,
47 struct device_attribute
*attr
, char *buf
)
49 struct virtio_device
*dev
= dev_to_virtio(_d
);
53 /* We actually represent this as a bitstring, as it could be
54 * arbitrary length in future. */
55 for (i
= 0; i
< sizeof(dev
->features
)*8; i
++)
56 len
+= sprintf(buf
+len
, "%c",
57 __virtio_test_bit(dev
, i
) ? '1' : '0');
58 len
+= sprintf(buf
+len
, "\n");
61 static DEVICE_ATTR_RO(features
);
63 static struct attribute
*virtio_dev_attrs
[] = {
64 &dev_attr_device
.attr
,
65 &dev_attr_vendor
.attr
,
66 &dev_attr_status
.attr
,
67 &dev_attr_modalias
.attr
,
68 &dev_attr_features
.attr
,
71 ATTRIBUTE_GROUPS(virtio_dev
);
73 static inline int virtio_id_match(const struct virtio_device
*dev
,
74 const struct virtio_device_id
*id
)
76 if (id
->device
!= dev
->id
.device
&& id
->device
!= VIRTIO_DEV_ANY_ID
)
79 return id
->vendor
== VIRTIO_DEV_ANY_ID
|| id
->vendor
== dev
->id
.vendor
;
82 /* This looks through all the IDs a driver claims to support. If any of them
83 * match, we return 1 and the kernel will call virtio_dev_probe(). */
84 static int virtio_dev_match(struct device
*_dv
, struct device_driver
*_dr
)
87 struct virtio_device
*dev
= dev_to_virtio(_dv
);
88 const struct virtio_device_id
*ids
;
90 ids
= drv_to_virtio(_dr
)->id_table
;
91 for (i
= 0; ids
[i
].device
; i
++)
92 if (virtio_id_match(dev
, &ids
[i
]))
97 static int virtio_uevent(struct device
*_dv
, struct kobj_uevent_env
*env
)
99 struct virtio_device
*dev
= dev_to_virtio(_dv
);
101 return add_uevent_var(env
, "MODALIAS=virtio:d%08Xv%08X",
102 dev
->id
.device
, dev
->id
.vendor
);
105 void virtio_check_driver_offered_feature(const struct virtio_device
*vdev
,
109 struct virtio_driver
*drv
= drv_to_virtio(vdev
->dev
.driver
);
111 for (i
= 0; i
< drv
->feature_table_size
; i
++)
112 if (drv
->feature_table
[i
] == fbit
)
115 if (drv
->feature_table_legacy
) {
116 for (i
= 0; i
< drv
->feature_table_size_legacy
; i
++)
117 if (drv
->feature_table_legacy
[i
] == fbit
)
123 EXPORT_SYMBOL_GPL(virtio_check_driver_offered_feature
);
125 static void __virtio_config_changed(struct virtio_device
*dev
)
127 struct virtio_driver
*drv
= drv_to_virtio(dev
->dev
.driver
);
129 if (!dev
->config_enabled
)
130 dev
->config_change_pending
= true;
131 else if (drv
&& drv
->config_changed
)
132 drv
->config_changed(dev
);
135 void virtio_config_changed(struct virtio_device
*dev
)
139 spin_lock_irqsave(&dev
->config_lock
, flags
);
140 __virtio_config_changed(dev
);
141 spin_unlock_irqrestore(&dev
->config_lock
, flags
);
143 EXPORT_SYMBOL_GPL(virtio_config_changed
);
145 static void virtio_config_disable(struct virtio_device
*dev
)
147 spin_lock_irq(&dev
->config_lock
);
148 dev
->config_enabled
= false;
149 spin_unlock_irq(&dev
->config_lock
);
152 static void virtio_config_enable(struct virtio_device
*dev
)
154 spin_lock_irq(&dev
->config_lock
);
155 dev
->config_enabled
= true;
156 if (dev
->config_change_pending
)
157 __virtio_config_changed(dev
);
158 dev
->config_change_pending
= false;
159 spin_unlock_irq(&dev
->config_lock
);
162 void virtio_add_status(struct virtio_device
*dev
, unsigned int status
)
165 dev
->config
->set_status(dev
, dev
->config
->get_status(dev
) | status
);
167 EXPORT_SYMBOL_GPL(virtio_add_status
);
169 int virtio_finalize_features(struct virtio_device
*dev
)
171 int ret
= dev
->config
->finalize_features(dev
);
178 ret
= arch_has_restricted_virtio_memory_access();
180 if (!virtio_has_feature(dev
, VIRTIO_F_VERSION_1
)) {
182 "device must provide VIRTIO_F_VERSION_1\n");
186 if (!virtio_has_feature(dev
, VIRTIO_F_ACCESS_PLATFORM
)) {
188 "device must provide VIRTIO_F_ACCESS_PLATFORM\n");
193 if (!virtio_has_feature(dev
, VIRTIO_F_VERSION_1
))
196 virtio_add_status(dev
, VIRTIO_CONFIG_S_FEATURES_OK
);
197 status
= dev
->config
->get_status(dev
);
198 if (!(status
& VIRTIO_CONFIG_S_FEATURES_OK
)) {
199 dev_err(&dev
->dev
, "virtio: device refuses features: %x\n",
205 EXPORT_SYMBOL_GPL(virtio_finalize_features
);
207 static int virtio_dev_probe(struct device
*_d
)
210 struct virtio_device
*dev
= dev_to_virtio(_d
);
211 struct virtio_driver
*drv
= drv_to_virtio(dev
->dev
.driver
);
214 u64 driver_features_legacy
;
216 /* We have a driver! */
217 virtio_add_status(dev
, VIRTIO_CONFIG_S_DRIVER
);
219 /* Figure out what features the device supports. */
220 device_features
= dev
->config
->get_features(dev
);
222 /* Figure out what features the driver supports. */
224 for (i
= 0; i
< drv
->feature_table_size
; i
++) {
225 unsigned int f
= drv
->feature_table
[i
];
227 driver_features
|= (1ULL << f
);
230 /* Some drivers have a separate feature table for virtio v1.0 */
231 if (drv
->feature_table_legacy
) {
232 driver_features_legacy
= 0;
233 for (i
= 0; i
< drv
->feature_table_size_legacy
; i
++) {
234 unsigned int f
= drv
->feature_table_legacy
[i
];
236 driver_features_legacy
|= (1ULL << f
);
239 driver_features_legacy
= driver_features
;
243 * Some devices detect legacy solely via F_VERSION_1. Write
244 * F_VERSION_1 to force LE config space accesses before FEATURES_OK for
247 if (drv
->validate
&& !virtio_legacy_is_little_endian()
248 && device_features
& BIT_ULL(VIRTIO_F_VERSION_1
)) {
249 dev
->features
= BIT_ULL(VIRTIO_F_VERSION_1
);
250 dev
->config
->finalize_features(dev
);
253 if (device_features
& (1ULL << VIRTIO_F_VERSION_1
))
254 dev
->features
= driver_features
& device_features
;
256 dev
->features
= driver_features_legacy
& device_features
;
258 /* Transport features always preserved to pass to finalize_features. */
259 for (i
= VIRTIO_TRANSPORT_F_START
; i
< VIRTIO_TRANSPORT_F_END
; i
++)
260 if (device_features
& (1ULL << i
))
261 __virtio_set_bit(dev
, i
);
264 err
= drv
->validate(dev
);
269 err
= virtio_finalize_features(dev
);
273 err
= drv
->probe(dev
);
277 /* If probe didn't do it, mark device DRIVER_OK ourselves. */
278 if (!(dev
->config
->get_status(dev
) & VIRTIO_CONFIG_S_DRIVER_OK
))
279 virtio_device_ready(dev
);
284 virtio_config_enable(dev
);
288 virtio_add_status(dev
, VIRTIO_CONFIG_S_FAILED
);
293 static void virtio_dev_remove(struct device
*_d
)
295 struct virtio_device
*dev
= dev_to_virtio(_d
);
296 struct virtio_driver
*drv
= drv_to_virtio(dev
->dev
.driver
);
298 virtio_config_disable(dev
);
302 /* Driver should have reset device. */
303 WARN_ON_ONCE(dev
->config
->get_status(dev
));
305 /* Acknowledge the device's existence again. */
306 virtio_add_status(dev
, VIRTIO_CONFIG_S_ACKNOWLEDGE
);
308 of_node_put(dev
->dev
.of_node
);
311 static struct bus_type virtio_bus
= {
313 .match
= virtio_dev_match
,
314 .dev_groups
= virtio_dev_groups
,
315 .uevent
= virtio_uevent
,
316 .probe
= virtio_dev_probe
,
317 .remove
= virtio_dev_remove
,
320 int register_virtio_driver(struct virtio_driver
*driver
)
322 /* Catch this early. */
323 BUG_ON(driver
->feature_table_size
&& !driver
->feature_table
);
324 driver
->driver
.bus
= &virtio_bus
;
325 return driver_register(&driver
->driver
);
327 EXPORT_SYMBOL_GPL(register_virtio_driver
);
329 void unregister_virtio_driver(struct virtio_driver
*driver
)
331 driver_unregister(&driver
->driver
);
333 EXPORT_SYMBOL_GPL(unregister_virtio_driver
);
335 static int virtio_device_of_init(struct virtio_device
*dev
)
337 struct device_node
*np
, *pnode
= dev_of_node(dev
->dev
.parent
);
338 char compat
[] = "virtio,deviceXXXXXXXX";
344 count
= of_get_available_child_count(pnode
);
348 /* There can be only 1 child node */
349 if (WARN_ON(count
> 1))
352 np
= of_get_next_available_child(pnode
, NULL
);
356 ret
= snprintf(compat
, sizeof(compat
), "virtio,device%x", dev
->id
.device
);
357 BUG_ON(ret
>= sizeof(compat
));
360 * On powerpc/pseries virtio devices are PCI devices so PCI
361 * vendor/device ids play the role of the "compatible" property.
362 * Simply don't init of_node in this case.
364 if (!of_device_is_compatible(np
, compat
)) {
369 dev
->dev
.of_node
= np
;
378 * register_virtio_device - register virtio device
379 * @dev : virtio device to be registered
381 * On error, the caller must call put_device on &@dev->dev (and not kfree),
382 * as another code path may have obtained a reference to @dev.
384 * Returns: 0 on suceess, -error on failure
386 int register_virtio_device(struct virtio_device
*dev
)
390 dev
->dev
.bus
= &virtio_bus
;
391 device_initialize(&dev
->dev
);
393 /* Assign a unique device index and hence name. */
394 err
= ida_simple_get(&virtio_index_ida
, 0, 0, GFP_KERNEL
);
399 dev_set_name(&dev
->dev
, "virtio%u", dev
->index
);
401 err
= virtio_device_of_init(dev
);
405 spin_lock_init(&dev
->config_lock
);
406 dev
->config_enabled
= false;
407 dev
->config_change_pending
= false;
409 /* We always start by resetting the device, in case a previous
410 * driver messed it up. This also tests that code path a little. */
411 dev
->config
->reset(dev
);
413 /* Acknowledge that we've seen the device. */
414 virtio_add_status(dev
, VIRTIO_CONFIG_S_ACKNOWLEDGE
);
416 INIT_LIST_HEAD(&dev
->vqs
);
417 spin_lock_init(&dev
->vqs_list_lock
);
420 * device_add() causes the bus infrastructure to look for a matching
423 err
= device_add(&dev
->dev
);
425 goto out_of_node_put
;
430 of_node_put(dev
->dev
.of_node
);
432 ida_simple_remove(&virtio_index_ida
, dev
->index
);
434 virtio_add_status(dev
, VIRTIO_CONFIG_S_FAILED
);
437 EXPORT_SYMBOL_GPL(register_virtio_device
);
439 bool is_virtio_device(struct device
*dev
)
441 return dev
->bus
== &virtio_bus
;
443 EXPORT_SYMBOL_GPL(is_virtio_device
);
445 void unregister_virtio_device(struct virtio_device
*dev
)
447 int index
= dev
->index
; /* save for after device release */
449 device_unregister(&dev
->dev
);
450 ida_simple_remove(&virtio_index_ida
, index
);
452 EXPORT_SYMBOL_GPL(unregister_virtio_device
);
454 #ifdef CONFIG_PM_SLEEP
455 int virtio_device_freeze(struct virtio_device
*dev
)
457 struct virtio_driver
*drv
= drv_to_virtio(dev
->dev
.driver
);
459 virtio_config_disable(dev
);
461 dev
->failed
= dev
->config
->get_status(dev
) & VIRTIO_CONFIG_S_FAILED
;
463 if (drv
&& drv
->freeze
)
464 return drv
->freeze(dev
);
468 EXPORT_SYMBOL_GPL(virtio_device_freeze
);
470 int virtio_device_restore(struct virtio_device
*dev
)
472 struct virtio_driver
*drv
= drv_to_virtio(dev
->dev
.driver
);
475 /* We always start by resetting the device, in case a previous
476 * driver messed it up. */
477 dev
->config
->reset(dev
);
479 /* Acknowledge that we've seen the device. */
480 virtio_add_status(dev
, VIRTIO_CONFIG_S_ACKNOWLEDGE
);
482 /* Maybe driver failed before freeze.
483 * Restore the failed status, for debugging. */
485 virtio_add_status(dev
, VIRTIO_CONFIG_S_FAILED
);
490 /* We have a driver! */
491 virtio_add_status(dev
, VIRTIO_CONFIG_S_DRIVER
);
493 ret
= virtio_finalize_features(dev
);
498 ret
= drv
->restore(dev
);
503 /* Finally, tell the device we're all set */
504 virtio_add_status(dev
, VIRTIO_CONFIG_S_DRIVER_OK
);
506 virtio_config_enable(dev
);
511 virtio_add_status(dev
, VIRTIO_CONFIG_S_FAILED
);
514 EXPORT_SYMBOL_GPL(virtio_device_restore
);
517 static int virtio_init(void)
519 if (bus_register(&virtio_bus
) != 0)
520 panic("virtio bus registration failed");
524 static void __exit
virtio_exit(void)
526 bus_unregister(&virtio_bus
);
527 ida_destroy(&virtio_index_ida
);
529 core_initcall(virtio_init
);
530 module_exit(virtio_exit
);
532 MODULE_LICENSE("GPL");