1#include <linux/virtio.h>
2#include <linux/spinlock.h>
3#include <linux/virtio_config.h>
4#include <linux/module.h>
5#include <linux/idr.h>
6#include <uapi/linux/virtio_ids.h>
7
8
9static DEFINE_IDA(virtio_index_ida);
10
11static ssize_t device_show(struct device *_d,
12 struct device_attribute *attr, char *buf)
13{
14 struct virtio_device *dev = dev_to_virtio(_d);
15 return sprintf(buf, "0x%04x\n", dev->id.device);
16}
17static DEVICE_ATTR_RO(device);
18
19static ssize_t vendor_show(struct device *_d,
20 struct device_attribute *attr, char *buf)
21{
22 struct virtio_device *dev = dev_to_virtio(_d);
23 return sprintf(buf, "0x%04x\n", dev->id.vendor);
24}
25static DEVICE_ATTR_RO(vendor);
26
27static ssize_t status_show(struct device *_d,
28 struct device_attribute *attr, char *buf)
29{
30 struct virtio_device *dev = dev_to_virtio(_d);
31 return sprintf(buf, "0x%08x\n", dev->config->get_status(dev));
32}
33static DEVICE_ATTR_RO(status);
34
35static ssize_t modalias_show(struct device *_d,
36 struct device_attribute *attr, char *buf)
37{
38 struct virtio_device *dev = dev_to_virtio(_d);
39 return sprintf(buf, "virtio:d%08Xv%08X\n",
40 dev->id.device, dev->id.vendor);
41}
42static DEVICE_ATTR_RO(modalias);
43
44static ssize_t features_show(struct device *_d,
45 struct device_attribute *attr, char *buf)
46{
47 struct virtio_device *dev = dev_to_virtio(_d);
48 unsigned int i;
49 ssize_t len = 0;
50
51
52
53 for (i = 0; i < sizeof(dev->features)*8; i++)
54 len += sprintf(buf+len, "%c",
55 __virtio_test_bit(dev, i) ? '1' : '0');
56 len += sprintf(buf+len, "\n");
57 return len;
58}
59static DEVICE_ATTR_RO(features);
60
61static struct attribute *virtio_dev_attrs[] = {
62 &dev_attr_device.attr,
63 &dev_attr_vendor.attr,
64 &dev_attr_status.attr,
65 &dev_attr_modalias.attr,
66 &dev_attr_features.attr,
67 NULL,
68};
69ATTRIBUTE_GROUPS(virtio_dev);
70
71static inline int virtio_id_match(const struct virtio_device *dev,
72 const struct virtio_device_id *id)
73{
74 if (id->device != dev->id.device && id->device != VIRTIO_DEV_ANY_ID)
75 return 0;
76
77 return id->vendor == VIRTIO_DEV_ANY_ID || id->vendor == dev->id.vendor;
78}
79
80
81
82static int virtio_dev_match(struct device *_dv, struct device_driver *_dr)
83{
84 unsigned int i;
85 struct virtio_device *dev = dev_to_virtio(_dv);
86 const struct virtio_device_id *ids;
87
88 ids = drv_to_virtio(_dr)->id_table;
89 for (i = 0; ids[i].device; i++)
90 if (virtio_id_match(dev, &ids[i]))
91 return 1;
92 return 0;
93}
94
95static int virtio_uevent(struct device *_dv, struct kobj_uevent_env *env)
96{
97 struct virtio_device *dev = dev_to_virtio(_dv);
98
99 return add_uevent_var(env, "MODALIAS=virtio:d%08Xv%08X",
100 dev->id.device, dev->id.vendor);
101}
102
103void virtio_check_driver_offered_feature(const struct virtio_device *vdev,
104 unsigned int fbit)
105{
106 unsigned int i;
107 struct virtio_driver *drv = drv_to_virtio(vdev->dev.driver);
108
109 for (i = 0; i < drv->feature_table_size; i++)
110 if (drv->feature_table[i] == fbit)
111 return;
112
113 if (drv->feature_table_legacy) {
114 for (i = 0; i < drv->feature_table_size_legacy; i++)
115 if (drv->feature_table_legacy[i] == fbit)
116 return;
117 }
118
119 BUG();
120}
121EXPORT_SYMBOL_GPL(virtio_check_driver_offered_feature);
122
123static void __virtio_config_changed(struct virtio_device *dev)
124{
125 struct virtio_driver *drv = drv_to_virtio(dev->dev.driver);
126
127 if (!dev->config_enabled)
128 dev->config_change_pending = true;
129 else if (drv && drv->config_changed)
130 drv->config_changed(dev);
131}
132
133void virtio_config_changed(struct virtio_device *dev)
134{
135 unsigned long flags;
136
137 spin_lock_irqsave(&dev->config_lock, flags);
138 __virtio_config_changed(dev);
139 spin_unlock_irqrestore(&dev->config_lock, flags);
140}
141EXPORT_SYMBOL_GPL(virtio_config_changed);
142
143void virtio_config_disable(struct virtio_device *dev)
144{
145 spin_lock_irq(&dev->config_lock);
146 dev->config_enabled = false;
147 spin_unlock_irq(&dev->config_lock);
148}
149EXPORT_SYMBOL_GPL(virtio_config_disable);
150
151void virtio_config_enable(struct virtio_device *dev)
152{
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);
159}
160EXPORT_SYMBOL_GPL(virtio_config_enable);
161
162void virtio_add_status(struct virtio_device *dev, unsigned int status)
163{
164 might_sleep();
165 dev->config->set_status(dev, dev->config->get_status(dev) | status);
166}
167EXPORT_SYMBOL_GPL(virtio_add_status);
168
169int virtio_finalize_features(struct virtio_device *dev)
170{
171 int ret = dev->config->finalize_features(dev);
172 unsigned status;
173
174 might_sleep();
175 if (ret)
176 return ret;
177
178 if (!virtio_has_feature(dev, VIRTIO_F_VERSION_1))
179 return 0;
180
181 virtio_add_status(dev, VIRTIO_CONFIG_S_FEATURES_OK);
182 status = dev->config->get_status(dev);
183 if (!(status & VIRTIO_CONFIG_S_FEATURES_OK)) {
184 dev_err(&dev->dev, "virtio: device refuses features: %x\n",
185 status);
186 return -ENODEV;
187 }
188 return 0;
189}
190EXPORT_SYMBOL_GPL(virtio_finalize_features);
191
192static int virtio_dev_probe(struct device *_d)
193{
194 int err, i;
195 struct virtio_device *dev = dev_to_virtio(_d);
196 struct virtio_driver *drv = drv_to_virtio(dev->dev.driver);
197 u64 device_features;
198 u64 driver_features;
199 u64 driver_features_legacy;
200
201
202 virtio_add_status(dev, VIRTIO_CONFIG_S_DRIVER);
203
204
205 device_features = dev->config->get_features(dev);
206
207
208 driver_features = 0;
209 for (i = 0; i < drv->feature_table_size; i++) {
210 unsigned int f = drv->feature_table[i];
211 BUG_ON(f >= 64);
212 driver_features |= (1ULL << f);
213 }
214
215
216 if (drv->feature_table_legacy) {
217 driver_features_legacy = 0;
218 for (i = 0; i < drv->feature_table_size_legacy; i++) {
219 unsigned int f = drv->feature_table_legacy[i];
220 BUG_ON(f >= 64);
221 driver_features_legacy |= (1ULL << f);
222 }
223 } else {
224 driver_features_legacy = driver_features;
225 }
226
227 if (device_features & (1ULL << VIRTIO_F_VERSION_1))
228 dev->features = driver_features & device_features;
229 else
230 dev->features = driver_features_legacy & device_features;
231
232
233 for (i = VIRTIO_TRANSPORT_F_START; i < VIRTIO_TRANSPORT_F_END; i++)
234 if (device_features & (1ULL << i))
235 __virtio_set_bit(dev, i);
236
237 if (drv->validate) {
238 err = drv->validate(dev);
239 if (err)
240 goto err;
241 }
242
243 err = virtio_finalize_features(dev);
244 if (err)
245 goto err;
246
247 err = drv->probe(dev);
248 if (err)
249 goto err;
250
251
252 if (!(dev->config->get_status(dev) & VIRTIO_CONFIG_S_DRIVER_OK))
253 virtio_device_ready(dev);
254
255 if (drv->scan)
256 drv->scan(dev);
257
258 virtio_config_enable(dev);
259
260 return 0;
261err:
262 virtio_add_status(dev, VIRTIO_CONFIG_S_FAILED);
263 return err;
264
265}
266
267static int virtio_dev_remove(struct device *_d)
268{
269 struct virtio_device *dev = dev_to_virtio(_d);
270 struct virtio_driver *drv = drv_to_virtio(dev->dev.driver);
271
272 virtio_config_disable(dev);
273
274 drv->remove(dev);
275
276
277 WARN_ON_ONCE(dev->config->get_status(dev));
278
279
280 virtio_add_status(dev, VIRTIO_CONFIG_S_ACKNOWLEDGE);
281 return 0;
282}
283
284static struct bus_type virtio_bus = {
285 .name = "virtio",
286 .match = virtio_dev_match,
287 .dev_groups = virtio_dev_groups,
288 .uevent = virtio_uevent,
289 .probe = virtio_dev_probe,
290 .remove = virtio_dev_remove,
291};
292
293int register_virtio_driver(struct virtio_driver *driver)
294{
295
296 BUG_ON(driver->feature_table_size && !driver->feature_table);
297 driver->driver.bus = &virtio_bus;
298 return driver_register(&driver->driver);
299}
300EXPORT_SYMBOL_GPL(register_virtio_driver);
301
302void unregister_virtio_driver(struct virtio_driver *driver)
303{
304 driver_unregister(&driver->driver);
305}
306EXPORT_SYMBOL_GPL(unregister_virtio_driver);
307
308
309
310
311
312
313
314
315
316
317int register_virtio_device(struct virtio_device *dev)
318{
319 int err;
320
321 dev->dev.bus = &virtio_bus;
322 device_initialize(&dev->dev);
323
324
325 err = ida_simple_get(&virtio_index_ida, 0, 0, GFP_KERNEL);
326 if (err < 0)
327 goto out;
328
329 dev->index = err;
330 dev_set_name(&dev->dev, "virtio%u", dev->index);
331
332 spin_lock_init(&dev->config_lock);
333 dev->config_enabled = false;
334 dev->config_change_pending = false;
335
336
337
338 dev->config->reset(dev);
339
340
341 virtio_add_status(dev, VIRTIO_CONFIG_S_ACKNOWLEDGE);
342
343 INIT_LIST_HEAD(&dev->vqs);
344
345
346
347
348
349 err = device_add(&dev->dev);
350 if (err)
351 ida_simple_remove(&virtio_index_ida, dev->index);
352out:
353 if (err)
354 virtio_add_status(dev, VIRTIO_CONFIG_S_FAILED);
355 return err;
356}
357EXPORT_SYMBOL_GPL(register_virtio_device);
358
359void unregister_virtio_device(struct virtio_device *dev)
360{
361 int index = dev->index;
362
363 device_unregister(&dev->dev);
364 ida_simple_remove(&virtio_index_ida, index);
365}
366EXPORT_SYMBOL_GPL(unregister_virtio_device);
367
368#ifdef CONFIG_PM_SLEEP
369int virtio_device_freeze(struct virtio_device *dev)
370{
371 struct virtio_driver *drv = drv_to_virtio(dev->dev.driver);
372
373 virtio_config_disable(dev);
374
375 dev->failed = dev->config->get_status(dev) & VIRTIO_CONFIG_S_FAILED;
376
377 if (drv && drv->freeze)
378 return drv->freeze(dev);
379
380 return 0;
381}
382EXPORT_SYMBOL_GPL(virtio_device_freeze);
383
384int virtio_device_restore(struct virtio_device *dev)
385{
386 struct virtio_driver *drv = drv_to_virtio(dev->dev.driver);
387 int ret;
388
389
390
391 dev->config->reset(dev);
392
393
394 virtio_add_status(dev, VIRTIO_CONFIG_S_ACKNOWLEDGE);
395
396
397
398 if (dev->failed)
399 virtio_add_status(dev, VIRTIO_CONFIG_S_FAILED);
400
401 if (!drv)
402 return 0;
403
404
405 virtio_add_status(dev, VIRTIO_CONFIG_S_DRIVER);
406
407 ret = virtio_finalize_features(dev);
408 if (ret)
409 goto err;
410
411 if (drv->restore) {
412 ret = drv->restore(dev);
413 if (ret)
414 goto err;
415 }
416
417
418 virtio_add_status(dev, VIRTIO_CONFIG_S_DRIVER_OK);
419
420 virtio_config_enable(dev);
421
422 return 0;
423
424err:
425 virtio_add_status(dev, VIRTIO_CONFIG_S_FAILED);
426 return ret;
427}
428EXPORT_SYMBOL_GPL(virtio_device_restore);
429#endif
430
431static int virtio_init(void)
432{
433 if (bus_register(&virtio_bus) != 0)
434 panic("virtio bus registration failed");
435 return 0;
436}
437
438static void __exit virtio_exit(void)
439{
440 bus_unregister(&virtio_bus);
441 ida_destroy(&virtio_index_ida);
442}
443core_initcall(virtio_init);
444module_exit(virtio_exit);
445
446MODULE_LICENSE("GPL");
447