1 #include <linux/virtio.h>
2 #include <linux/spinlock.h>
3 #include <linux/virtio_config.h>
4 #include <linux/module.h>
7 /* Unique numbering for virtio devices. */
8 static DEFINE_IDA(virtio_index_ida
);
10 static ssize_t
device_show(struct device
*_d
,
11 struct device_attribute
*attr
, char *buf
)
13 struct virtio_device
*dev
= dev_to_virtio(_d
);
14 return sprintf(buf
, "0x%04x\n", dev
->id
.device
);
16 static DEVICE_ATTR_RO(device
);
18 static ssize_t
vendor_show(struct device
*_d
,
19 struct device_attribute
*attr
, char *buf
)
21 struct virtio_device
*dev
= dev_to_virtio(_d
);
22 return sprintf(buf
, "0x%04x\n", dev
->id
.vendor
);
24 static DEVICE_ATTR_RO(vendor
);
26 static ssize_t
status_show(struct device
*_d
,
27 struct device_attribute
*attr
, char *buf
)
29 struct virtio_device
*dev
= dev_to_virtio(_d
);
30 return sprintf(buf
, "0x%08x\n", dev
->config
->get_status(dev
));
32 static DEVICE_ATTR_RO(status
);
34 static ssize_t
modalias_show(struct device
*_d
,
35 struct device_attribute
*attr
, char *buf
)
37 struct virtio_device
*dev
= dev_to_virtio(_d
);
38 return sprintf(buf
, "virtio:d%08Xv%08X\n",
39 dev
->id
.device
, dev
->id
.vendor
);
41 static DEVICE_ATTR_RO(modalias
);
43 static ssize_t
features_show(struct device
*_d
,
44 struct device_attribute
*attr
, char *buf
)
46 struct virtio_device
*dev
= dev_to_virtio(_d
);
50 /* We actually represent this as a bitstring, as it could be
51 * arbitrary length in future. */
52 for (i
= 0; i
< sizeof(dev
->features
)*8; i
++)
53 len
+= sprintf(buf
+len
, "%c",
54 __virtio_test_bit(dev
, i
) ? '1' : '0');
55 len
+= sprintf(buf
+len
, "\n");
58 static DEVICE_ATTR_RO(features
);
60 static struct attribute
*virtio_dev_attrs
[] = {
61 &dev_attr_device
.attr
,
62 &dev_attr_vendor
.attr
,
63 &dev_attr_status
.attr
,
64 &dev_attr_modalias
.attr
,
65 &dev_attr_features
.attr
,
68 ATTRIBUTE_GROUPS(virtio_dev
);
70 static inline int virtio_id_match(const struct virtio_device
*dev
,
71 const struct virtio_device_id
*id
)
73 if (id
->device
!= dev
->id
.device
&& id
->device
!= VIRTIO_DEV_ANY_ID
)
76 return id
->vendor
== VIRTIO_DEV_ANY_ID
|| id
->vendor
== dev
->id
.vendor
;
79 /* This looks through all the IDs a driver claims to support. If any of them
80 * match, we return 1 and the kernel will call virtio_dev_probe(). */
81 static int virtio_dev_match(struct device
*_dv
, struct device_driver
*_dr
)
84 struct virtio_device
*dev
= dev_to_virtio(_dv
);
85 const struct virtio_device_id
*ids
;
87 ids
= drv_to_virtio(_dr
)->id_table
;
88 for (i
= 0; ids
[i
].device
; i
++)
89 if (virtio_id_match(dev
, &ids
[i
]))
94 static int virtio_uevent(struct device
*_dv
, struct kobj_uevent_env
*env
)
96 struct virtio_device
*dev
= dev_to_virtio(_dv
);
98 return add_uevent_var(env
, "MODALIAS=virtio:d%08Xv%08X",
99 dev
->id
.device
, dev
->id
.vendor
);
102 static void add_status(struct virtio_device
*dev
, unsigned status
)
104 dev
->config
->set_status(dev
, dev
->config
->get_status(dev
) | status
);
107 void virtio_check_driver_offered_feature(const struct virtio_device
*vdev
,
111 struct virtio_driver
*drv
= drv_to_virtio(vdev
->dev
.driver
);
113 for (i
= 0; i
< drv
->feature_table_size
; i
++)
114 if (drv
->feature_table
[i
] == fbit
)
117 if (drv
->feature_table_legacy
) {
118 for (i
= 0; i
< drv
->feature_table_size_legacy
; i
++)
119 if (drv
->feature_table_legacy
[i
] == fbit
)
125 EXPORT_SYMBOL_GPL(virtio_check_driver_offered_feature
);
127 static void __virtio_config_changed(struct virtio_device
*dev
)
129 struct virtio_driver
*drv
= drv_to_virtio(dev
->dev
.driver
);
131 if (!dev
->config_enabled
)
132 dev
->config_change_pending
= true;
133 else if (drv
&& drv
->config_changed
)
134 drv
->config_changed(dev
);
137 void virtio_config_changed(struct virtio_device
*dev
)
141 spin_lock_irqsave(&dev
->config_lock
, flags
);
142 __virtio_config_changed(dev
);
143 spin_unlock_irqrestore(&dev
->config_lock
, flags
);
145 EXPORT_SYMBOL_GPL(virtio_config_changed
);
147 static void virtio_config_disable(struct virtio_device
*dev
)
149 spin_lock_irq(&dev
->config_lock
);
150 dev
->config_enabled
= false;
151 spin_unlock_irq(&dev
->config_lock
);
154 static void virtio_config_enable(struct virtio_device
*dev
)
156 spin_lock_irq(&dev
->config_lock
);
157 dev
->config_enabled
= true;
158 if (dev
->config_change_pending
)
159 __virtio_config_changed(dev
);
160 dev
->config_change_pending
= false;
161 spin_unlock_irq(&dev
->config_lock
);
164 static int virtio_dev_probe(struct device
*_d
)
167 struct virtio_device
*dev
= dev_to_virtio(_d
);
168 struct virtio_driver
*drv
= drv_to_virtio(dev
->dev
.driver
);
171 u64 driver_features_legacy
;
174 /* We have a driver! */
175 add_status(dev
, VIRTIO_CONFIG_S_DRIVER
);
177 /* Figure out what features the device supports. */
178 device_features
= dev
->config
->get_features(dev
);
180 /* Figure out what features the driver supports. */
182 for (i
= 0; i
< drv
->feature_table_size
; i
++) {
183 unsigned int f
= drv
->feature_table
[i
];
185 driver_features
|= (1ULL << f
);
188 /* Some drivers have a separate feature table for virtio v1.0 */
189 if (drv
->feature_table_legacy
) {
190 driver_features_legacy
= 0;
191 for (i
= 0; i
< drv
->feature_table_size_legacy
; i
++) {
192 unsigned int f
= drv
->feature_table_legacy
[i
];
194 driver_features_legacy
|= (1ULL << f
);
197 driver_features_legacy
= driver_features
;
200 if (driver_features
& device_features
& (1ULL << VIRTIO_F_VERSION_1
))
201 dev
->features
= driver_features
& device_features
;
203 dev
->features
= driver_features_legacy
& device_features
;
205 /* Transport features always preserved to pass to finalize_features. */
206 for (i
= VIRTIO_TRANSPORT_F_START
; i
< VIRTIO_TRANSPORT_F_END
; i
++)
207 if (device_features
& (1ULL << i
))
208 __virtio_set_bit(dev
, i
);
210 dev
->config
->finalize_features(dev
);
212 if (virtio_has_feature(dev
, VIRTIO_F_VERSION_1
)) {
213 add_status(dev
, VIRTIO_CONFIG_S_FEATURES_OK
);
214 status
= dev
->config
->get_status(dev
);
215 if (!(status
& VIRTIO_CONFIG_S_FEATURES_OK
)) {
216 dev_err(_d
, "virtio: device refuses features: %x\n",
223 err
= drv
->probe(dev
);
227 add_status(dev
, VIRTIO_CONFIG_S_DRIVER_OK
);
231 virtio_config_enable(dev
);
235 add_status(dev
, VIRTIO_CONFIG_S_FAILED
);
240 static int virtio_dev_remove(struct device
*_d
)
242 struct virtio_device
*dev
= dev_to_virtio(_d
);
243 struct virtio_driver
*drv
= drv_to_virtio(dev
->dev
.driver
);
245 virtio_config_disable(dev
);
249 /* Driver should have reset device. */
250 WARN_ON_ONCE(dev
->config
->get_status(dev
));
252 /* Acknowledge the device's existence again. */
253 add_status(dev
, VIRTIO_CONFIG_S_ACKNOWLEDGE
);
257 static struct bus_type virtio_bus
= {
259 .match
= virtio_dev_match
,
260 .dev_groups
= virtio_dev_groups
,
261 .uevent
= virtio_uevent
,
262 .probe
= virtio_dev_probe
,
263 .remove
= virtio_dev_remove
,
266 int register_virtio_driver(struct virtio_driver
*driver
)
268 /* Catch this early. */
269 BUG_ON(driver
->feature_table_size
&& !driver
->feature_table
);
270 driver
->driver
.bus
= &virtio_bus
;
271 return driver_register(&driver
->driver
);
273 EXPORT_SYMBOL_GPL(register_virtio_driver
);
275 void unregister_virtio_driver(struct virtio_driver
*driver
)
277 driver_unregister(&driver
->driver
);
279 EXPORT_SYMBOL_GPL(unregister_virtio_driver
);
281 int register_virtio_device(struct virtio_device
*dev
)
285 dev
->dev
.bus
= &virtio_bus
;
287 /* Assign a unique device index and hence name. */
288 err
= ida_simple_get(&virtio_index_ida
, 0, 0, GFP_KERNEL
);
293 dev_set_name(&dev
->dev
, "virtio%u", dev
->index
);
295 spin_lock_init(&dev
->config_lock
);
296 dev
->config_enabled
= false;
297 dev
->config_change_pending
= false;
299 /* We always start by resetting the device, in case a previous
300 * driver messed it up. This also tests that code path a little. */
301 dev
->config
->reset(dev
);
303 /* Acknowledge that we've seen the device. */
304 add_status(dev
, VIRTIO_CONFIG_S_ACKNOWLEDGE
);
306 INIT_LIST_HEAD(&dev
->vqs
);
308 /* device_register() causes the bus infrastructure to look for a
309 * matching driver. */
310 err
= device_register(&dev
->dev
);
313 add_status(dev
, VIRTIO_CONFIG_S_FAILED
);
316 EXPORT_SYMBOL_GPL(register_virtio_device
);
318 void unregister_virtio_device(struct virtio_device
*dev
)
320 int index
= dev
->index
; /* save for after device release */
322 device_unregister(&dev
->dev
);
323 ida_simple_remove(&virtio_index_ida
, index
);
325 EXPORT_SYMBOL_GPL(unregister_virtio_device
);
327 #ifdef CONFIG_PM_SLEEP
328 int virtio_device_freeze(struct virtio_device
*dev
)
330 struct virtio_driver
*drv
= drv_to_virtio(dev
->dev
.driver
);
332 virtio_config_disable(dev
);
334 dev
->failed
= dev
->config
->get_status(dev
) & VIRTIO_CONFIG_S_FAILED
;
336 if (drv
&& drv
->freeze
)
337 return drv
->freeze(dev
);
341 EXPORT_SYMBOL_GPL(virtio_device_freeze
);
343 int virtio_device_restore(struct virtio_device
*dev
)
345 struct virtio_driver
*drv
= drv_to_virtio(dev
->dev
.driver
);
347 /* We always start by resetting the device, in case a previous
348 * driver messed it up. */
349 dev
->config
->reset(dev
);
351 /* Acknowledge that we've seen the device. */
352 add_status(dev
, VIRTIO_CONFIG_S_ACKNOWLEDGE
);
354 /* Maybe driver failed before freeze.
355 * Restore the failed status, for debugging. */
357 add_status(dev
, VIRTIO_CONFIG_S_FAILED
);
362 /* We have a driver! */
363 add_status(dev
, VIRTIO_CONFIG_S_DRIVER
);
365 dev
->config
->finalize_features(dev
);
368 int ret
= drv
->restore(dev
);
370 add_status(dev
, VIRTIO_CONFIG_S_FAILED
);
375 /* Finally, tell the device we're all set */
376 add_status(dev
, VIRTIO_CONFIG_S_DRIVER_OK
);
378 virtio_config_enable(dev
);
382 EXPORT_SYMBOL_GPL(virtio_device_restore
);
385 static int virtio_init(void)
387 if (bus_register(&virtio_bus
) != 0)
388 panic("virtio bus registration failed");
392 static void __exit
virtio_exit(void)
394 bus_unregister(&virtio_bus
);
396 core_initcall(virtio_init
);
397 module_exit(virtio_exit
);
399 MODULE_LICENSE("GPL");