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
< ARRAY_SIZE(dev
->features
)*BITS_PER_LONG
; i
++)
53 len
+= sprintf(buf
+len
, "%c",
54 test_bit(i
, dev
->features
) ? '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
);
164 /* We have a driver! */
165 add_status(dev
, VIRTIO_CONFIG_S_DRIVER
);
167 /* Figure out what features the device supports. */
168 device_features
= dev
->config
->get_features(dev
);
170 /* Features supported by both device and driver into dev->features. */
171 memset(dev
->features
, 0, sizeof(dev
->features
));
172 for (i
= 0; i
< drv
->feature_table_size
; i
++) {
173 unsigned int f
= drv
->feature_table
[i
];
175 if (device_features
& (1 << f
))
176 set_bit(f
, dev
->features
);
179 /* Transport features always preserved to pass to finalize_features. */
180 for (i
= VIRTIO_TRANSPORT_F_START
; i
< VIRTIO_TRANSPORT_F_END
; i
++)
181 if (device_features
& (1 << i
))
182 set_bit(i
, dev
->features
);
184 dev
->config
->finalize_features(dev
);
186 err
= drv
->probe(dev
);
188 add_status(dev
, VIRTIO_CONFIG_S_FAILED
);
190 add_status(dev
, VIRTIO_CONFIG_S_DRIVER_OK
);
194 virtio_config_enable(dev
);
200 static int virtio_dev_remove(struct device
*_d
)
202 struct virtio_device
*dev
= dev_to_virtio(_d
);
203 struct virtio_driver
*drv
= drv_to_virtio(dev
->dev
.driver
);
205 virtio_config_disable(dev
);
209 /* Driver should have reset device. */
210 WARN_ON_ONCE(dev
->config
->get_status(dev
));
212 /* Acknowledge the device's existence again. */
213 add_status(dev
, VIRTIO_CONFIG_S_ACKNOWLEDGE
);
217 static struct bus_type virtio_bus
= {
219 .match
= virtio_dev_match
,
220 .dev_groups
= virtio_dev_groups
,
221 .uevent
= virtio_uevent
,
222 .probe
= virtio_dev_probe
,
223 .remove
= virtio_dev_remove
,
226 int register_virtio_driver(struct virtio_driver
*driver
)
228 /* Catch this early. */
229 BUG_ON(driver
->feature_table_size
&& !driver
->feature_table
);
230 driver
->driver
.bus
= &virtio_bus
;
231 return driver_register(&driver
->driver
);
233 EXPORT_SYMBOL_GPL(register_virtio_driver
);
235 void unregister_virtio_driver(struct virtio_driver
*driver
)
237 driver_unregister(&driver
->driver
);
239 EXPORT_SYMBOL_GPL(unregister_virtio_driver
);
241 int register_virtio_device(struct virtio_device
*dev
)
245 dev
->dev
.bus
= &virtio_bus
;
247 /* Assign a unique device index and hence name. */
248 err
= ida_simple_get(&virtio_index_ida
, 0, 0, GFP_KERNEL
);
253 dev_set_name(&dev
->dev
, "virtio%u", dev
->index
);
255 spin_lock_init(&dev
->config_lock
);
256 dev
->config_enabled
= false;
257 dev
->config_change_pending
= false;
259 /* We always start by resetting the device, in case a previous
260 * driver messed it up. This also tests that code path a little. */
261 dev
->config
->reset(dev
);
263 /* Acknowledge that we've seen the device. */
264 add_status(dev
, VIRTIO_CONFIG_S_ACKNOWLEDGE
);
266 INIT_LIST_HEAD(&dev
->vqs
);
268 /* device_register() causes the bus infrastructure to look for a
269 * matching driver. */
270 err
= device_register(&dev
->dev
);
273 add_status(dev
, VIRTIO_CONFIG_S_FAILED
);
276 EXPORT_SYMBOL_GPL(register_virtio_device
);
278 void unregister_virtio_device(struct virtio_device
*dev
)
280 int index
= dev
->index
; /* save for after device release */
282 device_unregister(&dev
->dev
);
283 ida_simple_remove(&virtio_index_ida
, index
);
285 EXPORT_SYMBOL_GPL(unregister_virtio_device
);
287 #ifdef CONFIG_PM_SLEEP
288 int virtio_device_freeze(struct virtio_device
*dev
)
290 struct virtio_driver
*drv
= drv_to_virtio(dev
->dev
.driver
);
292 virtio_config_disable(dev
);
294 dev
->failed
= dev
->config
->get_status(dev
) & VIRTIO_CONFIG_S_FAILED
;
296 if (drv
&& drv
->freeze
)
297 return drv
->freeze(dev
);
301 EXPORT_SYMBOL_GPL(virtio_device_freeze
);
303 int virtio_device_restore(struct virtio_device
*dev
)
305 struct virtio_driver
*drv
= drv_to_virtio(dev
->dev
.driver
);
307 /* We always start by resetting the device, in case a previous
308 * driver messed it up. */
309 dev
->config
->reset(dev
);
311 /* Acknowledge that we've seen the device. */
312 add_status(dev
, VIRTIO_CONFIG_S_ACKNOWLEDGE
);
314 /* Maybe driver failed before freeze.
315 * Restore the failed status, for debugging. */
317 add_status(dev
, VIRTIO_CONFIG_S_FAILED
);
322 /* We have a driver! */
323 add_status(dev
, VIRTIO_CONFIG_S_DRIVER
);
325 dev
->config
->finalize_features(dev
);
328 int ret
= drv
->restore(dev
);
330 add_status(dev
, VIRTIO_CONFIG_S_FAILED
);
335 /* Finally, tell the device we're all set */
336 add_status(dev
, VIRTIO_CONFIG_S_DRIVER_OK
);
338 virtio_config_enable(dev
);
342 EXPORT_SYMBOL_GPL(virtio_device_restore
);
345 static int virtio_init(void)
347 if (bus_register(&virtio_bus
) != 0)
348 panic("virtio bus registration failed");
352 static void __exit
virtio_exit(void)
354 bus_unregister(&virtio_bus
);
356 core_initcall(virtio_init
);
357 module_exit(virtio_exit
);
359 MODULE_LICENSE("GPL");