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
)
118 EXPORT_SYMBOL_GPL(virtio_check_driver_offered_feature
);
120 static void __virtio_config_changed(struct virtio_device
*dev
)
122 struct virtio_driver
*drv
= drv_to_virtio(dev
->dev
.driver
);
124 if (!dev
->config_enabled
)
125 dev
->config_change_pending
= true;
126 else if (drv
&& drv
->config_changed
)
127 drv
->config_changed(dev
);
130 void virtio_config_changed(struct virtio_device
*dev
)
134 spin_lock_irqsave(&dev
->config_lock
, flags
);
135 __virtio_config_changed(dev
);
136 spin_unlock_irqrestore(&dev
->config_lock
, flags
);
138 EXPORT_SYMBOL_GPL(virtio_config_changed
);
140 static void virtio_config_disable(struct virtio_device
*dev
)
142 spin_lock_irq(&dev
->config_lock
);
143 dev
->config_enabled
= false;
144 spin_unlock_irq(&dev
->config_lock
);
147 static void virtio_config_enable(struct virtio_device
*dev
)
149 spin_lock_irq(&dev
->config_lock
);
150 dev
->config_enabled
= true;
151 if (dev
->config_change_pending
)
152 __virtio_config_changed(dev
);
153 dev
->config_change_pending
= false;
154 spin_unlock_irq(&dev
->config_lock
);
157 static int virtio_dev_probe(struct device
*_d
)
160 struct virtio_device
*dev
= dev_to_virtio(_d
);
161 struct virtio_driver
*drv
= drv_to_virtio(dev
->dev
.driver
);
165 /* We have a driver! */
166 add_status(dev
, VIRTIO_CONFIG_S_DRIVER
);
168 /* Figure out what features the device supports. */
169 device_features
= dev
->config
->get_features(dev
);
171 /* Features supported by both device and driver into dev->features. */
173 for (i
= 0; i
< drv
->feature_table_size
; i
++) {
174 unsigned int f
= drv
->feature_table
[i
];
176 if (device_features
& (1ULL << f
))
177 __virtio_set_bit(dev
, f
);
180 /* Transport features always preserved to pass to finalize_features. */
181 for (i
= VIRTIO_TRANSPORT_F_START
; i
< VIRTIO_TRANSPORT_F_END
; i
++)
182 if (device_features
& (1ULL << i
))
183 __virtio_set_bit(dev
, i
);
185 dev
->config
->finalize_features(dev
);
187 if (virtio_has_feature(dev
, VIRTIO_F_VERSION_1
)) {
188 add_status(dev
, VIRTIO_CONFIG_S_FEATURES_OK
);
189 status
= dev
->config
->get_status(dev
);
190 if (!(status
& VIRTIO_CONFIG_S_FEATURES_OK
)) {
191 dev_err(_d
, "virtio: device refuses features: %x\n",
198 err
= drv
->probe(dev
);
202 add_status(dev
, VIRTIO_CONFIG_S_DRIVER_OK
);
206 virtio_config_enable(dev
);
210 add_status(dev
, VIRTIO_CONFIG_S_FAILED
);
215 static int virtio_dev_remove(struct device
*_d
)
217 struct virtio_device
*dev
= dev_to_virtio(_d
);
218 struct virtio_driver
*drv
= drv_to_virtio(dev
->dev
.driver
);
220 virtio_config_disable(dev
);
224 /* Driver should have reset device. */
225 WARN_ON_ONCE(dev
->config
->get_status(dev
));
227 /* Acknowledge the device's existence again. */
228 add_status(dev
, VIRTIO_CONFIG_S_ACKNOWLEDGE
);
232 static struct bus_type virtio_bus
= {
234 .match
= virtio_dev_match
,
235 .dev_groups
= virtio_dev_groups
,
236 .uevent
= virtio_uevent
,
237 .probe
= virtio_dev_probe
,
238 .remove
= virtio_dev_remove
,
241 int register_virtio_driver(struct virtio_driver
*driver
)
243 /* Catch this early. */
244 BUG_ON(driver
->feature_table_size
&& !driver
->feature_table
);
245 driver
->driver
.bus
= &virtio_bus
;
246 return driver_register(&driver
->driver
);
248 EXPORT_SYMBOL_GPL(register_virtio_driver
);
250 void unregister_virtio_driver(struct virtio_driver
*driver
)
252 driver_unregister(&driver
->driver
);
254 EXPORT_SYMBOL_GPL(unregister_virtio_driver
);
256 int register_virtio_device(struct virtio_device
*dev
)
260 dev
->dev
.bus
= &virtio_bus
;
262 /* Assign a unique device index and hence name. */
263 err
= ida_simple_get(&virtio_index_ida
, 0, 0, GFP_KERNEL
);
268 dev_set_name(&dev
->dev
, "virtio%u", dev
->index
);
270 spin_lock_init(&dev
->config_lock
);
271 dev
->config_enabled
= false;
272 dev
->config_change_pending
= false;
274 /* We always start by resetting the device, in case a previous
275 * driver messed it up. This also tests that code path a little. */
276 dev
->config
->reset(dev
);
278 /* Acknowledge that we've seen the device. */
279 add_status(dev
, VIRTIO_CONFIG_S_ACKNOWLEDGE
);
281 INIT_LIST_HEAD(&dev
->vqs
);
283 /* device_register() causes the bus infrastructure to look for a
284 * matching driver. */
285 err
= device_register(&dev
->dev
);
288 add_status(dev
, VIRTIO_CONFIG_S_FAILED
);
291 EXPORT_SYMBOL_GPL(register_virtio_device
);
293 void unregister_virtio_device(struct virtio_device
*dev
)
295 int index
= dev
->index
; /* save for after device release */
297 device_unregister(&dev
->dev
);
298 ida_simple_remove(&virtio_index_ida
, index
);
300 EXPORT_SYMBOL_GPL(unregister_virtio_device
);
302 #ifdef CONFIG_PM_SLEEP
303 int virtio_device_freeze(struct virtio_device
*dev
)
305 struct virtio_driver
*drv
= drv_to_virtio(dev
->dev
.driver
);
307 virtio_config_disable(dev
);
309 dev
->failed
= dev
->config
->get_status(dev
) & VIRTIO_CONFIG_S_FAILED
;
311 if (drv
&& drv
->freeze
)
312 return drv
->freeze(dev
);
316 EXPORT_SYMBOL_GPL(virtio_device_freeze
);
318 int virtio_device_restore(struct virtio_device
*dev
)
320 struct virtio_driver
*drv
= drv_to_virtio(dev
->dev
.driver
);
322 /* We always start by resetting the device, in case a previous
323 * driver messed it up. */
324 dev
->config
->reset(dev
);
326 /* Acknowledge that we've seen the device. */
327 add_status(dev
, VIRTIO_CONFIG_S_ACKNOWLEDGE
);
329 /* Maybe driver failed before freeze.
330 * Restore the failed status, for debugging. */
332 add_status(dev
, VIRTIO_CONFIG_S_FAILED
);
337 /* We have a driver! */
338 add_status(dev
, VIRTIO_CONFIG_S_DRIVER
);
340 dev
->config
->finalize_features(dev
);
343 int ret
= drv
->restore(dev
);
345 add_status(dev
, VIRTIO_CONFIG_S_FAILED
);
350 /* Finally, tell the device we're all set */
351 add_status(dev
, VIRTIO_CONFIG_S_DRIVER_OK
);
353 virtio_config_enable(dev
);
357 EXPORT_SYMBOL_GPL(virtio_device_restore
);
360 static int virtio_init(void)
362 if (bus_register(&virtio_bus
) != 0)
363 panic("virtio bus registration failed");
367 static void __exit
virtio_exit(void)
369 bus_unregister(&virtio_bus
);
371 core_initcall(virtio_init
);
372 module_exit(virtio_exit
);
374 MODULE_LICENSE("GPL");