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
;
242 if (device_features
& (1ULL << VIRTIO_F_VERSION_1
))
243 dev
->features
= driver_features
& device_features
;
245 dev
->features
= driver_features_legacy
& device_features
;
247 /* Transport features always preserved to pass to finalize_features. */
248 for (i
= VIRTIO_TRANSPORT_F_START
; i
< VIRTIO_TRANSPORT_F_END
; i
++)
249 if (device_features
& (1ULL << i
))
250 __virtio_set_bit(dev
, i
);
253 err
= drv
->validate(dev
);
258 err
= virtio_finalize_features(dev
);
262 err
= drv
->probe(dev
);
266 /* If probe didn't do it, mark device DRIVER_OK ourselves. */
267 if (!(dev
->config
->get_status(dev
) & VIRTIO_CONFIG_S_DRIVER_OK
))
268 virtio_device_ready(dev
);
273 virtio_config_enable(dev
);
277 virtio_add_status(dev
, VIRTIO_CONFIG_S_FAILED
);
282 static void virtio_dev_remove(struct device
*_d
)
284 struct virtio_device
*dev
= dev_to_virtio(_d
);
285 struct virtio_driver
*drv
= drv_to_virtio(dev
->dev
.driver
);
287 virtio_config_disable(dev
);
291 /* Driver should have reset device. */
292 WARN_ON_ONCE(dev
->config
->get_status(dev
));
294 /* Acknowledge the device's existence again. */
295 virtio_add_status(dev
, VIRTIO_CONFIG_S_ACKNOWLEDGE
);
297 of_node_put(dev
->dev
.of_node
);
300 static struct bus_type virtio_bus
= {
302 .match
= virtio_dev_match
,
303 .dev_groups
= virtio_dev_groups
,
304 .uevent
= virtio_uevent
,
305 .probe
= virtio_dev_probe
,
306 .remove
= virtio_dev_remove
,
309 int register_virtio_driver(struct virtio_driver
*driver
)
311 /* Catch this early. */
312 BUG_ON(driver
->feature_table_size
&& !driver
->feature_table
);
313 driver
->driver
.bus
= &virtio_bus
;
314 return driver_register(&driver
->driver
);
316 EXPORT_SYMBOL_GPL(register_virtio_driver
);
318 void unregister_virtio_driver(struct virtio_driver
*driver
)
320 driver_unregister(&driver
->driver
);
322 EXPORT_SYMBOL_GPL(unregister_virtio_driver
);
324 static int virtio_device_of_init(struct virtio_device
*dev
)
326 struct device_node
*np
, *pnode
= dev_of_node(dev
->dev
.parent
);
327 char compat
[] = "virtio,deviceXXXXXXXX";
333 count
= of_get_available_child_count(pnode
);
337 /* There can be only 1 child node */
338 if (WARN_ON(count
> 1))
341 np
= of_get_next_available_child(pnode
, NULL
);
345 ret
= snprintf(compat
, sizeof(compat
), "virtio,device%x", dev
->id
.device
);
346 BUG_ON(ret
>= sizeof(compat
));
348 if (!of_device_is_compatible(np
, compat
)) {
353 dev
->dev
.of_node
= np
;
362 * register_virtio_device - register virtio device
363 * @dev : virtio device to be registered
365 * On error, the caller must call put_device on &@dev->dev (and not kfree),
366 * as another code path may have obtained a reference to @dev.
368 * Returns: 0 on suceess, -error on failure
370 int register_virtio_device(struct virtio_device
*dev
)
374 dev
->dev
.bus
= &virtio_bus
;
375 device_initialize(&dev
->dev
);
377 /* Assign a unique device index and hence name. */
378 err
= ida_simple_get(&virtio_index_ida
, 0, 0, GFP_KERNEL
);
383 dev_set_name(&dev
->dev
, "virtio%u", dev
->index
);
385 err
= virtio_device_of_init(dev
);
389 spin_lock_init(&dev
->config_lock
);
390 dev
->config_enabled
= false;
391 dev
->config_change_pending
= false;
393 /* We always start by resetting the device, in case a previous
394 * driver messed it up. This also tests that code path a little. */
395 dev
->config
->reset(dev
);
397 /* Acknowledge that we've seen the device. */
398 virtio_add_status(dev
, VIRTIO_CONFIG_S_ACKNOWLEDGE
);
400 INIT_LIST_HEAD(&dev
->vqs
);
401 spin_lock_init(&dev
->vqs_list_lock
);
404 * device_add() causes the bus infrastructure to look for a matching
407 err
= device_add(&dev
->dev
);
409 goto out_of_node_put
;
414 of_node_put(dev
->dev
.of_node
);
416 ida_simple_remove(&virtio_index_ida
, dev
->index
);
418 virtio_add_status(dev
, VIRTIO_CONFIG_S_FAILED
);
421 EXPORT_SYMBOL_GPL(register_virtio_device
);
423 bool is_virtio_device(struct device
*dev
)
425 return dev
->bus
== &virtio_bus
;
427 EXPORT_SYMBOL_GPL(is_virtio_device
);
429 void unregister_virtio_device(struct virtio_device
*dev
)
431 int index
= dev
->index
; /* save for after device release */
433 device_unregister(&dev
->dev
);
434 ida_simple_remove(&virtio_index_ida
, index
);
436 EXPORT_SYMBOL_GPL(unregister_virtio_device
);
438 #ifdef CONFIG_PM_SLEEP
439 int virtio_device_freeze(struct virtio_device
*dev
)
441 struct virtio_driver
*drv
= drv_to_virtio(dev
->dev
.driver
);
443 virtio_config_disable(dev
);
445 dev
->failed
= dev
->config
->get_status(dev
) & VIRTIO_CONFIG_S_FAILED
;
447 if (drv
&& drv
->freeze
)
448 return drv
->freeze(dev
);
452 EXPORT_SYMBOL_GPL(virtio_device_freeze
);
454 int virtio_device_restore(struct virtio_device
*dev
)
456 struct virtio_driver
*drv
= drv_to_virtio(dev
->dev
.driver
);
459 /* We always start by resetting the device, in case a previous
460 * driver messed it up. */
461 dev
->config
->reset(dev
);
463 /* Acknowledge that we've seen the device. */
464 virtio_add_status(dev
, VIRTIO_CONFIG_S_ACKNOWLEDGE
);
466 /* Maybe driver failed before freeze.
467 * Restore the failed status, for debugging. */
469 virtio_add_status(dev
, VIRTIO_CONFIG_S_FAILED
);
474 /* We have a driver! */
475 virtio_add_status(dev
, VIRTIO_CONFIG_S_DRIVER
);
477 ret
= virtio_finalize_features(dev
);
482 ret
= drv
->restore(dev
);
487 /* Finally, tell the device we're all set */
488 virtio_add_status(dev
, VIRTIO_CONFIG_S_DRIVER_OK
);
490 virtio_config_enable(dev
);
495 virtio_add_status(dev
, VIRTIO_CONFIG_S_FAILED
);
498 EXPORT_SYMBOL_GPL(virtio_device_restore
);
501 static int virtio_init(void)
503 if (bus_register(&virtio_bus
) != 0)
504 panic("virtio bus registration failed");
508 static void __exit
virtio_exit(void)
510 bus_unregister(&virtio_bus
);
511 ida_destroy(&virtio_index_ida
);
513 core_initcall(virtio_init
);
514 module_exit(virtio_exit
);
516 MODULE_LICENSE("GPL");