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
);
166 /* We have a driver! */
167 add_status(dev
, VIRTIO_CONFIG_S_DRIVER
);
169 /* Figure out what features the device supports. */
170 device_features
= dev
->config
->get_features(dev
);
172 /* Figure out what features the driver supports. */
174 for (i
= 0; i
< drv
->feature_table_size
; i
++) {
175 unsigned int f
= drv
->feature_table
[i
];
177 driver_features
|= (1ULL << f
);
180 dev
->features
= driver_features
& device_features
;
182 /* Transport features always preserved to pass to finalize_features. */
183 for (i
= VIRTIO_TRANSPORT_F_START
; i
< VIRTIO_TRANSPORT_F_END
; i
++)
184 if (device_features
& (1ULL << i
))
185 __virtio_set_bit(dev
, i
);
187 dev
->config
->finalize_features(dev
);
189 if (virtio_has_feature(dev
, VIRTIO_F_VERSION_1
)) {
190 add_status(dev
, VIRTIO_CONFIG_S_FEATURES_OK
);
191 status
= dev
->config
->get_status(dev
);
192 if (!(status
& VIRTIO_CONFIG_S_FEATURES_OK
)) {
193 dev_err(_d
, "virtio: device refuses features: %x\n",
200 err
= drv
->probe(dev
);
204 add_status(dev
, VIRTIO_CONFIG_S_DRIVER_OK
);
208 virtio_config_enable(dev
);
212 add_status(dev
, VIRTIO_CONFIG_S_FAILED
);
217 static int virtio_dev_remove(struct device
*_d
)
219 struct virtio_device
*dev
= dev_to_virtio(_d
);
220 struct virtio_driver
*drv
= drv_to_virtio(dev
->dev
.driver
);
222 virtio_config_disable(dev
);
226 /* Driver should have reset device. */
227 WARN_ON_ONCE(dev
->config
->get_status(dev
));
229 /* Acknowledge the device's existence again. */
230 add_status(dev
, VIRTIO_CONFIG_S_ACKNOWLEDGE
);
234 static struct bus_type virtio_bus
= {
236 .match
= virtio_dev_match
,
237 .dev_groups
= virtio_dev_groups
,
238 .uevent
= virtio_uevent
,
239 .probe
= virtio_dev_probe
,
240 .remove
= virtio_dev_remove
,
243 int register_virtio_driver(struct virtio_driver
*driver
)
245 /* Catch this early. */
246 BUG_ON(driver
->feature_table_size
&& !driver
->feature_table
);
247 driver
->driver
.bus
= &virtio_bus
;
248 return driver_register(&driver
->driver
);
250 EXPORT_SYMBOL_GPL(register_virtio_driver
);
252 void unregister_virtio_driver(struct virtio_driver
*driver
)
254 driver_unregister(&driver
->driver
);
256 EXPORT_SYMBOL_GPL(unregister_virtio_driver
);
258 int register_virtio_device(struct virtio_device
*dev
)
262 dev
->dev
.bus
= &virtio_bus
;
264 /* Assign a unique device index and hence name. */
265 err
= ida_simple_get(&virtio_index_ida
, 0, 0, GFP_KERNEL
);
270 dev_set_name(&dev
->dev
, "virtio%u", dev
->index
);
272 spin_lock_init(&dev
->config_lock
);
273 dev
->config_enabled
= false;
274 dev
->config_change_pending
= false;
276 /* We always start by resetting the device, in case a previous
277 * driver messed it up. This also tests that code path a little. */
278 dev
->config
->reset(dev
);
280 /* Acknowledge that we've seen the device. */
281 add_status(dev
, VIRTIO_CONFIG_S_ACKNOWLEDGE
);
283 INIT_LIST_HEAD(&dev
->vqs
);
285 /* device_register() causes the bus infrastructure to look for a
286 * matching driver. */
287 err
= device_register(&dev
->dev
);
290 add_status(dev
, VIRTIO_CONFIG_S_FAILED
);
293 EXPORT_SYMBOL_GPL(register_virtio_device
);
295 void unregister_virtio_device(struct virtio_device
*dev
)
297 int index
= dev
->index
; /* save for after device release */
299 device_unregister(&dev
->dev
);
300 ida_simple_remove(&virtio_index_ida
, index
);
302 EXPORT_SYMBOL_GPL(unregister_virtio_device
);
304 #ifdef CONFIG_PM_SLEEP
305 int virtio_device_freeze(struct virtio_device
*dev
)
307 struct virtio_driver
*drv
= drv_to_virtio(dev
->dev
.driver
);
309 virtio_config_disable(dev
);
311 dev
->failed
= dev
->config
->get_status(dev
) & VIRTIO_CONFIG_S_FAILED
;
313 if (drv
&& drv
->freeze
)
314 return drv
->freeze(dev
);
318 EXPORT_SYMBOL_GPL(virtio_device_freeze
);
320 int virtio_device_restore(struct virtio_device
*dev
)
322 struct virtio_driver
*drv
= drv_to_virtio(dev
->dev
.driver
);
324 /* We always start by resetting the device, in case a previous
325 * driver messed it up. */
326 dev
->config
->reset(dev
);
328 /* Acknowledge that we've seen the device. */
329 add_status(dev
, VIRTIO_CONFIG_S_ACKNOWLEDGE
);
331 /* Maybe driver failed before freeze.
332 * Restore the failed status, for debugging. */
334 add_status(dev
, VIRTIO_CONFIG_S_FAILED
);
339 /* We have a driver! */
340 add_status(dev
, VIRTIO_CONFIG_S_DRIVER
);
342 dev
->config
->finalize_features(dev
);
345 int ret
= drv
->restore(dev
);
347 add_status(dev
, VIRTIO_CONFIG_S_FAILED
);
352 /* Finally, tell the device we're all set */
353 add_status(dev
, VIRTIO_CONFIG_S_DRIVER_OK
);
355 virtio_config_enable(dev
);
359 EXPORT_SYMBOL_GPL(virtio_device_restore
);
362 static int virtio_init(void)
364 if (bus_register(&virtio_bus
) != 0)
365 panic("virtio bus registration failed");
369 static void __exit
virtio_exit(void)
371 bus_unregister(&virtio_bus
);
373 core_initcall(virtio_init
);
374 module_exit(virtio_exit
);
376 MODULE_LICENSE("GPL");