Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
virtio.c
Go to the documentation of this file.
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 
7 /* Unique numbering for virtio devices. */
8 static DEFINE_IDA(virtio_index_ida);
9 
10 static ssize_t device_show(struct device *_d,
11  struct device_attribute *attr, char *buf)
12 {
13  struct virtio_device *dev = container_of(_d,struct virtio_device,dev);
14  return sprintf(buf, "0x%04x\n", dev->id.device);
15 }
16 static ssize_t vendor_show(struct device *_d,
17  struct device_attribute *attr, char *buf)
18 {
19  struct virtio_device *dev = container_of(_d,struct virtio_device,dev);
20  return sprintf(buf, "0x%04x\n", dev->id.vendor);
21 }
22 static ssize_t status_show(struct device *_d,
23  struct device_attribute *attr, char *buf)
24 {
25  struct virtio_device *dev = container_of(_d,struct virtio_device,dev);
26  return sprintf(buf, "0x%08x\n", dev->config->get_status(dev));
27 }
28 static ssize_t modalias_show(struct device *_d,
29  struct device_attribute *attr, char *buf)
30 {
31  struct virtio_device *dev = container_of(_d,struct virtio_device,dev);
32 
33  return sprintf(buf, "virtio:d%08Xv%08X\n",
34  dev->id.device, dev->id.vendor);
35 }
36 static ssize_t features_show(struct device *_d,
37  struct device_attribute *attr, char *buf)
38 {
39  struct virtio_device *dev = container_of(_d, struct virtio_device, dev);
40  unsigned int i;
41  ssize_t len = 0;
42 
43  /* We actually represent this as a bitstring, as it could be
44  * arbitrary length in future. */
45  for (i = 0; i < ARRAY_SIZE(dev->features)*BITS_PER_LONG; i++)
46  len += sprintf(buf+len, "%c",
47  test_bit(i, dev->features) ? '1' : '0');
48  len += sprintf(buf+len, "\n");
49  return len;
50 }
51 static struct device_attribute virtio_dev_attrs[] = {
55  __ATTR_RO(modalias),
58 };
59 
60 static inline int virtio_id_match(const struct virtio_device *dev,
61  const struct virtio_device_id *id)
62 {
63  if (id->device != dev->id.device && id->device != VIRTIO_DEV_ANY_ID)
64  return 0;
65 
66  return id->vendor == VIRTIO_DEV_ANY_ID || id->vendor == dev->id.vendor;
67 }
68 
69 /* This looks through all the IDs a driver claims to support. If any of them
70  * match, we return 1 and the kernel will call virtio_dev_probe(). */
71 static int virtio_dev_match(struct device *_dv, struct device_driver *_dr)
72 {
73  unsigned int i;
74  struct virtio_device *dev = container_of(_dv,struct virtio_device,dev);
75  const struct virtio_device_id *ids;
76 
77  ids = container_of(_dr, struct virtio_driver, driver)->id_table;
78  for (i = 0; ids[i].device; i++)
79  if (virtio_id_match(dev, &ids[i]))
80  return 1;
81  return 0;
82 }
83 
84 static int virtio_uevent(struct device *_dv, struct kobj_uevent_env *env)
85 {
86  struct virtio_device *dev = container_of(_dv,struct virtio_device,dev);
87 
88  return add_uevent_var(env, "MODALIAS=virtio:d%08Xv%08X",
89  dev->id.device, dev->id.vendor);
90 }
91 
92 static void add_status(struct virtio_device *dev, unsigned status)
93 {
94  dev->config->set_status(dev, dev->config->get_status(dev) | status);
95 }
96 
98  unsigned int fbit)
99 {
100  unsigned int i;
101  struct virtio_driver *drv = container_of(vdev->dev.driver,
102  struct virtio_driver, driver);
103 
104  for (i = 0; i < drv->feature_table_size; i++)
105  if (drv->feature_table[i] == fbit)
106  return;
107  BUG();
108 }
110 
111 static int virtio_dev_probe(struct device *_d)
112 {
113  int err, i;
114  struct virtio_device *dev = container_of(_d,struct virtio_device,dev);
115  struct virtio_driver *drv = container_of(dev->dev.driver,
116  struct virtio_driver, driver);
117  u32 device_features;
118 
119  /* We have a driver! */
120  add_status(dev, VIRTIO_CONFIG_S_DRIVER);
121 
122  /* Figure out what features the device supports. */
123  device_features = dev->config->get_features(dev);
124 
125  /* Features supported by both device and driver into dev->features. */
126  memset(dev->features, 0, sizeof(dev->features));
127  for (i = 0; i < drv->feature_table_size; i++) {
128  unsigned int f = drv->feature_table[i];
129  BUG_ON(f >= 32);
130  if (device_features & (1 << f))
131  set_bit(f, dev->features);
132  }
133 
134  /* Transport features always preserved to pass to finalize_features. */
136  if (device_features & (1 << i))
137  set_bit(i, dev->features);
138 
139  dev->config->finalize_features(dev);
140 
141  err = drv->probe(dev);
142  if (err)
143  add_status(dev, VIRTIO_CONFIG_S_FAILED);
144  else {
145  add_status(dev, VIRTIO_CONFIG_S_DRIVER_OK);
146  if (drv->scan)
147  drv->scan(dev);
148  }
149 
150  return err;
151 }
152 
153 static int virtio_dev_remove(struct device *_d)
154 {
155  struct virtio_device *dev = container_of(_d,struct virtio_device,dev);
156  struct virtio_driver *drv = container_of(dev->dev.driver,
157  struct virtio_driver, driver);
158 
159  drv->remove(dev);
160 
161  /* Driver should have reset device. */
162  WARN_ON_ONCE(dev->config->get_status(dev));
163 
164  /* Acknowledge the device's existence again. */
165  add_status(dev, VIRTIO_CONFIG_S_ACKNOWLEDGE);
166  return 0;
167 }
168 
169 static struct bus_type virtio_bus = {
170  .name = "virtio",
171  .match = virtio_dev_match,
172  .dev_attrs = virtio_dev_attrs,
173  .uevent = virtio_uevent,
174  .probe = virtio_dev_probe,
175  .remove = virtio_dev_remove,
176 };
177 
179 {
180  /* Catch this early. */
181  BUG_ON(driver->feature_table_size && !driver->feature_table);
182  driver->driver.bus = &virtio_bus;
183  return driver_register(&driver->driver);
184 }
186 
188 {
189  driver_unregister(&driver->driver);
190 }
192 
194 {
195  int err;
196 
197  dev->dev.bus = &virtio_bus;
198 
199  /* Assign a unique device index and hence name. */
200  err = ida_simple_get(&virtio_index_ida, 0, 0, GFP_KERNEL);
201  if (err < 0)
202  goto out;
203 
204  dev->index = err;
205  dev_set_name(&dev->dev, "virtio%u", dev->index);
206 
207  /* We always start by resetting the device, in case a previous
208  * driver messed it up. This also tests that code path a little. */
209  dev->config->reset(dev);
210 
211  /* Acknowledge that we've seen the device. */
212  add_status(dev, VIRTIO_CONFIG_S_ACKNOWLEDGE);
213 
214  INIT_LIST_HEAD(&dev->vqs);
215 
216  /* device_register() causes the bus infrastructure to look for a
217  * matching driver. */
218  err = device_register(&dev->dev);
219 out:
220  if (err)
221  add_status(dev, VIRTIO_CONFIG_S_FAILED);
222  return err;
223 }
225 
227 {
228  int index = dev->index; /* save for after device release */
229 
230  device_unregister(&dev->dev);
231  ida_simple_remove(&virtio_index_ida, index);
232 }
234 
235 static int virtio_init(void)
236 {
237  if (bus_register(&virtio_bus) != 0)
238  panic("virtio bus registration failed");
239  return 0;
240 }
241 
242 static void __exit virtio_exit(void)
243 {
244  bus_unregister(&virtio_bus);
245 }
246 core_initcall(virtio_init);
247 module_exit(virtio_exit);
248 
249 MODULE_LICENSE("GPL");