1 #include <linux/virtio.h> 2 #include <linux/spinlock.h> 3 #include <linux/virtio_config.h> 4 5 /* Unique numbering for virtio devices. */ 6 static unsigned int dev_index; 7 8 static ssize_t device_show(struct device *_d, 9 struct device_attribute *attr, char *buf) 10 { 11 struct virtio_device *dev = container_of(_d,struct virtio_device,dev); 12 return sprintf(buf, "%hu", dev->id.device); 13 } 14 static ssize_t vendor_show(struct device *_d, 15 struct device_attribute *attr, char *buf) 16 { 17 struct virtio_device *dev = container_of(_d,struct virtio_device,dev); 18 return sprintf(buf, "%hu", dev->id.vendor); 19 } 20 static ssize_t status_show(struct device *_d, 21 struct device_attribute *attr, char *buf) 22 { 23 struct virtio_device *dev = container_of(_d,struct virtio_device,dev); 24 return sprintf(buf, "0x%08x", dev->config->get_status(dev)); 25 } 26 static ssize_t modalias_show(struct device *_d, 27 struct device_attribute *attr, char *buf) 28 { 29 struct virtio_device *dev = container_of(_d,struct virtio_device,dev); 30 31 return sprintf(buf, "virtio:d%08Xv%08X\n", 32 dev->id.device, dev->id.vendor); 33 } 34 static struct device_attribute virtio_dev_attrs[] = { 35 __ATTR_RO(device), 36 __ATTR_RO(vendor), 37 __ATTR_RO(status), 38 __ATTR_RO(modalias), 39 __ATTR_NULL 40 }; 41 42 static inline int virtio_id_match(const struct virtio_device *dev, 43 const struct virtio_device_id *id) 44 { 45 if (id->device != dev->id.device) 46 return 0; 47 48 return id->vendor == VIRTIO_DEV_ANY_ID || id->vendor != dev->id.vendor; 49 } 50 51 /* This looks through all the IDs a driver claims to support. If any of them 52 * match, we return 1 and the kernel will call virtio_dev_probe(). */ 53 static int virtio_dev_match(struct device *_dv, struct device_driver *_dr) 54 { 55 unsigned int i; 56 struct virtio_device *dev = container_of(_dv,struct virtio_device,dev); 57 const struct virtio_device_id *ids; 58 59 ids = container_of(_dr, struct virtio_driver, driver)->id_table; 60 for (i = 0; ids[i].device; i++) 61 if (virtio_id_match(dev, &ids[i])) 62 return 1; 63 return 0; 64 } 65 66 static int virtio_uevent(struct device *_dv, struct kobj_uevent_env *env) 67 { 68 struct virtio_device *dev = container_of(_dv,struct virtio_device,dev); 69 70 return add_uevent_var(env, "MODALIAS=virtio:d%08Xv%08X", 71 dev->id.device, dev->id.vendor); 72 } 73 74 static struct bus_type virtio_bus = { 75 .name = "virtio", 76 .match = virtio_dev_match, 77 .dev_attrs = virtio_dev_attrs, 78 .uevent = virtio_uevent, 79 }; 80 81 static void add_status(struct virtio_device *dev, unsigned status) 82 { 83 dev->config->set_status(dev, dev->config->get_status(dev) | status); 84 } 85 86 void virtio_check_driver_offered_feature(const struct virtio_device *vdev, 87 unsigned int fbit) 88 { 89 unsigned int i; 90 struct virtio_driver *drv = container_of(vdev->dev.driver, 91 struct virtio_driver, driver); 92 93 for (i = 0; i < drv->feature_table_size; i++) 94 if (drv->feature_table[i] == fbit) 95 return; 96 BUG(); 97 } 98 EXPORT_SYMBOL_GPL(virtio_check_driver_offered_feature); 99 100 static int virtio_dev_probe(struct device *_d) 101 { 102 int err, i; 103 struct virtio_device *dev = container_of(_d,struct virtio_device,dev); 104 struct virtio_driver *drv = container_of(dev->dev.driver, 105 struct virtio_driver, driver); 106 u32 device_features; 107 108 /* We have a driver! */ 109 add_status(dev, VIRTIO_CONFIG_S_DRIVER); 110 111 /* Figure out what features the device supports. */ 112 device_features = dev->config->get_features(dev); 113 114 /* Features supported by both device and driver into dev->features. */ 115 memset(dev->features, 0, sizeof(dev->features)); 116 for (i = 0; i < drv->feature_table_size; i++) { 117 unsigned int f = drv->feature_table[i]; 118 BUG_ON(f >= 32); 119 if (device_features & (1 << f)) 120 set_bit(f, dev->features); 121 } 122 123 err = drv->probe(dev); 124 if (err) 125 add_status(dev, VIRTIO_CONFIG_S_FAILED); 126 else { 127 /* They should never have set feature bits beyond 32 */ 128 dev->config->set_features(dev, dev->features[0]); 129 add_status(dev, VIRTIO_CONFIG_S_DRIVER_OK); 130 } 131 return err; 132 } 133 134 static int virtio_dev_remove(struct device *_d) 135 { 136 struct virtio_device *dev = container_of(_d,struct virtio_device,dev); 137 struct virtio_driver *drv = container_of(dev->dev.driver, 138 struct virtio_driver, driver); 139 140 drv->remove(dev); 141 142 /* Driver should have reset device. */ 143 BUG_ON(dev->config->get_status(dev)); 144 145 /* Acknowledge the device's existence again. */ 146 add_status(dev, VIRTIO_CONFIG_S_ACKNOWLEDGE); 147 return 0; 148 } 149 150 int register_virtio_driver(struct virtio_driver *driver) 151 { 152 /* Catch this early. */ 153 BUG_ON(driver->feature_table_size && !driver->feature_table); 154 driver->driver.bus = &virtio_bus; 155 driver->driver.probe = virtio_dev_probe; 156 driver->driver.remove = virtio_dev_remove; 157 return driver_register(&driver->driver); 158 } 159 EXPORT_SYMBOL_GPL(register_virtio_driver); 160 161 void unregister_virtio_driver(struct virtio_driver *driver) 162 { 163 driver_unregister(&driver->driver); 164 } 165 EXPORT_SYMBOL_GPL(unregister_virtio_driver); 166 167 int register_virtio_device(struct virtio_device *dev) 168 { 169 int err; 170 171 dev->dev.bus = &virtio_bus; 172 173 /* Assign a unique device index and hence name. */ 174 dev->index = dev_index++; 175 sprintf(dev->dev.bus_id, "virtio%u", dev->index); 176 177 /* We always start by resetting the device, in case a previous 178 * driver messed it up. This also tests that code path a little. */ 179 dev->config->reset(dev); 180 181 /* Acknowledge that we've seen the device. */ 182 add_status(dev, VIRTIO_CONFIG_S_ACKNOWLEDGE); 183 184 /* device_register() causes the bus infrastructure to look for a 185 * matching driver. */ 186 err = device_register(&dev->dev); 187 if (err) 188 add_status(dev, VIRTIO_CONFIG_S_FAILED); 189 return err; 190 } 191 EXPORT_SYMBOL_GPL(register_virtio_device); 192 193 void unregister_virtio_device(struct virtio_device *dev) 194 { 195 device_unregister(&dev->dev); 196 } 197 EXPORT_SYMBOL_GPL(unregister_virtio_device); 198 199 static int virtio_init(void) 200 { 201 if (bus_register(&virtio_bus) != 0) 202 panic("virtio bus registration failed"); 203 return 0; 204 } 205 206 static void __exit virtio_exit(void) 207 { 208 bus_unregister(&virtio_bus); 209 } 210 core_initcall(virtio_init); 211 module_exit(virtio_exit); 212 213 MODULE_LICENSE("GPL"); 214