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>
7 #include <uapi/linux/virtio_ids.h>
9 /* Unique numbering for virtio devices. */
10 static DEFINE_IDA(virtio_index_ida
);
12 static ssize_t
device_show(struct device
*_d
,
13 struct device_attribute
*attr
, char *buf
)
15 struct virtio_device
*dev
= dev_to_virtio(_d
);
16 return sprintf(buf
, "0x%04x\n", dev
->id
.device
);
18 static DEVICE_ATTR_RO(device
);
20 static ssize_t
vendor_show(struct device
*_d
,
21 struct device_attribute
*attr
, char *buf
)
23 struct virtio_device
*dev
= dev_to_virtio(_d
);
24 return sprintf(buf
, "0x%04x\n", dev
->id
.vendor
);
26 static DEVICE_ATTR_RO(vendor
);
28 static ssize_t
status_show(struct device
*_d
,
29 struct device_attribute
*attr
, char *buf
)
31 struct virtio_device
*dev
= dev_to_virtio(_d
);
32 return sprintf(buf
, "0x%08x\n", dev
->config
->get_status(dev
));
34 static DEVICE_ATTR_RO(status
);
36 static ssize_t
modalias_show(struct device
*_d
,
37 struct device_attribute
*attr
, char *buf
)
39 struct virtio_device
*dev
= dev_to_virtio(_d
);
40 return sprintf(buf
, "virtio:d%08Xv%08X\n",
41 dev
->id
.device
, dev
->id
.vendor
);
43 static DEVICE_ATTR_RO(modalias
);
45 static ssize_t
features_show(struct device
*_d
,
46 struct device_attribute
*attr
, char *buf
)
48 struct virtio_device
*dev
= dev_to_virtio(_d
);
52 /* We actually represent this as a bitstring, as it could be
53 * arbitrary length in future. */
54 for (i
= 0; i
< sizeof(dev
->features
)*8; i
++)
55 len
+= sprintf(buf
+len
, "%c",
56 __virtio_test_bit(dev
, i
) ? '1' : '0');
57 len
+= sprintf(buf
+len
, "\n");
60 static DEVICE_ATTR_RO(features
);
62 static struct attribute
*virtio_dev_attrs
[] = {
63 &dev_attr_device
.attr
,
64 &dev_attr_vendor
.attr
,
65 &dev_attr_status
.attr
,
66 &dev_attr_modalias
.attr
,
67 &dev_attr_features
.attr
,
70 ATTRIBUTE_GROUPS(virtio_dev
);
72 static inline int virtio_id_match(const struct virtio_device
*dev
,
73 const struct virtio_device_id
*id
)
75 if (id
->device
!= dev
->id
.device
&& id
->device
!= VIRTIO_DEV_ANY_ID
)
78 return id
->vendor
== VIRTIO_DEV_ANY_ID
|| id
->vendor
== dev
->id
.vendor
;
81 /* This looks through all the IDs a driver claims to support. If any of them
82 * match, we return 1 and the kernel will call virtio_dev_probe(). */
83 static int virtio_dev_match(struct device
*_dv
, struct device_driver
*_dr
)
86 struct virtio_device
*dev
= dev_to_virtio(_dv
);
87 const struct virtio_device_id
*ids
;
89 ids
= drv_to_virtio(_dr
)->id_table
;
90 for (i
= 0; ids
[i
].device
; i
++)
91 if (virtio_id_match(dev
, &ids
[i
]))
96 static int virtio_uevent(struct device
*_dv
, struct kobj_uevent_env
*env
)
98 struct virtio_device
*dev
= dev_to_virtio(_dv
);
100 return add_uevent_var(env
, "MODALIAS=virtio:d%08Xv%08X",
101 dev
->id
.device
, dev
->id
.vendor
);
104 void virtio_check_driver_offered_feature(const struct virtio_device
*vdev
,
108 struct virtio_driver
*drv
= drv_to_virtio(vdev
->dev
.driver
);
110 for (i
= 0; i
< drv
->feature_table_size
; i
++)
111 if (drv
->feature_table
[i
] == fbit
)
114 if (drv
->feature_table_legacy
) {
115 for (i
= 0; i
< drv
->feature_table_size_legacy
; i
++)
116 if (drv
->feature_table_legacy
[i
] == fbit
)
122 EXPORT_SYMBOL_GPL(virtio_check_driver_offered_feature
);
124 static void __virtio_config_changed(struct virtio_device
*dev
)
126 struct virtio_driver
*drv
= drv_to_virtio(dev
->dev
.driver
);
128 if (!dev
->config_enabled
)
129 dev
->config_change_pending
= true;
130 else if (drv
&& drv
->config_changed
)
131 drv
->config_changed(dev
);
134 void virtio_config_changed(struct virtio_device
*dev
)
138 spin_lock_irqsave(&dev
->config_lock
, flags
);
139 __virtio_config_changed(dev
);
140 spin_unlock_irqrestore(&dev
->config_lock
, flags
);
142 EXPORT_SYMBOL_GPL(virtio_config_changed
);
144 static void virtio_config_disable(struct virtio_device
*dev
)
146 spin_lock_irq(&dev
->config_lock
);
147 dev
->config_enabled
= false;
148 spin_unlock_irq(&dev
->config_lock
);
151 static void virtio_config_enable(struct virtio_device
*dev
)
153 spin_lock_irq(&dev
->config_lock
);
154 dev
->config_enabled
= true;
155 if (dev
->config_change_pending
)
156 __virtio_config_changed(dev
);
157 dev
->config_change_pending
= false;
158 spin_unlock_irq(&dev
->config_lock
);
161 void virtio_add_status(struct virtio_device
*dev
, unsigned int status
)
164 dev
->config
->set_status(dev
, dev
->config
->get_status(dev
) | status
);
166 EXPORT_SYMBOL_GPL(virtio_add_status
);
168 int virtio_finalize_features(struct virtio_device
*dev
)
170 int ret
= dev
->config
->finalize_features(dev
);
177 ret
= arch_has_restricted_virtio_memory_access();
179 if (!virtio_has_feature(dev
, VIRTIO_F_VERSION_1
)) {
181 "device must provide VIRTIO_F_VERSION_1\n");
185 if (!virtio_has_feature(dev
, VIRTIO_F_ACCESS_PLATFORM
)) {
187 "device must provide VIRTIO_F_ACCESS_PLATFORM\n");
192 if (!virtio_has_feature(dev
, VIRTIO_F_VERSION_1
))
195 virtio_add_status(dev
, VIRTIO_CONFIG_S_FEATURES_OK
);
196 status
= dev
->config
->get_status(dev
);
197 if (!(status
& VIRTIO_CONFIG_S_FEATURES_OK
)) {
198 dev_err(&dev
->dev
, "virtio: device refuses features: %x\n",
204 EXPORT_SYMBOL_GPL(virtio_finalize_features
);
206 static int virtio_dev_probe(struct device
*_d
)
209 struct virtio_device
*dev
= dev_to_virtio(_d
);
210 struct virtio_driver
*drv
= drv_to_virtio(dev
->dev
.driver
);
213 u64 driver_features_legacy
;
215 /* We have a driver! */
216 virtio_add_status(dev
, VIRTIO_CONFIG_S_DRIVER
);
218 /* Figure out what features the device supports. */
219 device_features
= dev
->config
->get_features(dev
);
221 /* Figure out what features the driver supports. */
223 for (i
= 0; i
< drv
->feature_table_size
; i
++) {
224 unsigned int f
= drv
->feature_table
[i
];
226 driver_features
|= (1ULL << f
);
229 /* Some drivers have a separate feature table for virtio v1.0 */
230 if (drv
->feature_table_legacy
) {
231 driver_features_legacy
= 0;
232 for (i
= 0; i
< drv
->feature_table_size_legacy
; i
++) {
233 unsigned int f
= drv
->feature_table_legacy
[i
];
235 driver_features_legacy
|= (1ULL << f
);
238 driver_features_legacy
= driver_features
;
241 if (device_features
& (1ULL << VIRTIO_F_VERSION_1
))
242 dev
->features
= driver_features
& device_features
;
244 dev
->features
= driver_features_legacy
& device_features
;
246 /* Transport features always preserved to pass to finalize_features. */
247 for (i
= VIRTIO_TRANSPORT_F_START
; i
< VIRTIO_TRANSPORT_F_END
; i
++)
248 if (device_features
& (1ULL << i
))
249 __virtio_set_bit(dev
, i
);
252 err
= drv
->validate(dev
);
257 err
= virtio_finalize_features(dev
);
261 err
= drv
->probe(dev
);
265 /* If probe didn't do it, mark device DRIVER_OK ourselves. */
266 if (!(dev
->config
->get_status(dev
) & VIRTIO_CONFIG_S_DRIVER_OK
))
267 virtio_device_ready(dev
);
272 virtio_config_enable(dev
);
276 virtio_add_status(dev
, VIRTIO_CONFIG_S_FAILED
);
281 static int virtio_dev_remove(struct device
*_d
)
283 struct virtio_device
*dev
= dev_to_virtio(_d
);
284 struct virtio_driver
*drv
= drv_to_virtio(dev
->dev
.driver
);
286 virtio_config_disable(dev
);
290 /* Driver should have reset device. */
291 WARN_ON_ONCE(dev
->config
->get_status(dev
));
293 /* Acknowledge the device's existence again. */
294 virtio_add_status(dev
, VIRTIO_CONFIG_S_ACKNOWLEDGE
);
298 static struct bus_type virtio_bus
= {
300 .match
= virtio_dev_match
,
301 .dev_groups
= virtio_dev_groups
,
302 .uevent
= virtio_uevent
,
303 .probe
= virtio_dev_probe
,
304 .remove
= virtio_dev_remove
,
307 int register_virtio_driver(struct virtio_driver
*driver
)
309 /* Catch this early. */
310 BUG_ON(driver
->feature_table_size
&& !driver
->feature_table
);
311 driver
->driver
.bus
= &virtio_bus
;
312 return driver_register(&driver
->driver
);
314 EXPORT_SYMBOL_GPL(register_virtio_driver
);
316 void unregister_virtio_driver(struct virtio_driver
*driver
)
318 driver_unregister(&driver
->driver
);
320 EXPORT_SYMBOL_GPL(unregister_virtio_driver
);
323 * register_virtio_device - register virtio device
324 * @dev : virtio device to be registered
326 * On error, the caller must call put_device on &@dev->dev (and not kfree),
327 * as another code path may have obtained a reference to @dev.
329 * Returns: 0 on suceess, -error on failure
331 int register_virtio_device(struct virtio_device
*dev
)
335 dev
->dev
.bus
= &virtio_bus
;
336 device_initialize(&dev
->dev
);
338 /* Assign a unique device index and hence name. */
339 err
= ida_simple_get(&virtio_index_ida
, 0, 0, GFP_KERNEL
);
344 dev_set_name(&dev
->dev
, "virtio%u", dev
->index
);
346 spin_lock_init(&dev
->config_lock
);
347 dev
->config_enabled
= false;
348 dev
->config_change_pending
= false;
350 /* We always start by resetting the device, in case a previous
351 * driver messed it up. This also tests that code path a little. */
352 dev
->config
->reset(dev
);
354 /* Acknowledge that we've seen the device. */
355 virtio_add_status(dev
, VIRTIO_CONFIG_S_ACKNOWLEDGE
);
357 INIT_LIST_HEAD(&dev
->vqs
);
360 * device_add() causes the bus infrastructure to look for a matching
363 err
= device_add(&dev
->dev
);
365 ida_simple_remove(&virtio_index_ida
, dev
->index
);
368 virtio_add_status(dev
, VIRTIO_CONFIG_S_FAILED
);
371 EXPORT_SYMBOL_GPL(register_virtio_device
);
373 bool is_virtio_device(struct device
*dev
)
375 return dev
->bus
== &virtio_bus
;
377 EXPORT_SYMBOL_GPL(is_virtio_device
);
379 void unregister_virtio_device(struct virtio_device
*dev
)
381 int index
= dev
->index
; /* save for after device release */
383 device_unregister(&dev
->dev
);
384 ida_simple_remove(&virtio_index_ida
, index
);
386 EXPORT_SYMBOL_GPL(unregister_virtio_device
);
388 #ifdef CONFIG_PM_SLEEP
389 int virtio_device_freeze(struct virtio_device
*dev
)
391 struct virtio_driver
*drv
= drv_to_virtio(dev
->dev
.driver
);
393 virtio_config_disable(dev
);
395 dev
->failed
= dev
->config
->get_status(dev
) & VIRTIO_CONFIG_S_FAILED
;
397 if (drv
&& drv
->freeze
)
398 return drv
->freeze(dev
);
402 EXPORT_SYMBOL_GPL(virtio_device_freeze
);
404 int virtio_device_restore(struct virtio_device
*dev
)
406 struct virtio_driver
*drv
= drv_to_virtio(dev
->dev
.driver
);
409 /* We always start by resetting the device, in case a previous
410 * driver messed it up. */
411 dev
->config
->reset(dev
);
413 /* Acknowledge that we've seen the device. */
414 virtio_add_status(dev
, VIRTIO_CONFIG_S_ACKNOWLEDGE
);
416 /* Maybe driver failed before freeze.
417 * Restore the failed status, for debugging. */
419 virtio_add_status(dev
, VIRTIO_CONFIG_S_FAILED
);
424 /* We have a driver! */
425 virtio_add_status(dev
, VIRTIO_CONFIG_S_DRIVER
);
427 ret
= virtio_finalize_features(dev
);
432 ret
= drv
->restore(dev
);
437 /* Finally, tell the device we're all set */
438 virtio_add_status(dev
, VIRTIO_CONFIG_S_DRIVER_OK
);
440 virtio_config_enable(dev
);
445 virtio_add_status(dev
, VIRTIO_CONFIG_S_FAILED
);
448 EXPORT_SYMBOL_GPL(virtio_device_restore
);
451 static int virtio_init(void)
453 if (bus_register(&virtio_bus
) != 0)
454 panic("virtio bus registration failed");
458 static void __exit
virtio_exit(void)
460 bus_unregister(&virtio_bus
);
461 ida_destroy(&virtio_index_ida
);
463 core_initcall(virtio_init
);
464 module_exit(virtio_exit
);
466 MODULE_LICENSE("GPL");