1 #include <linux/virtio.h>
2 #include <linux/spinlock.h>
3 #include <linux/virtio_config.h>
5 /* Unique numbering for virtio devices. */
6 static unsigned int dev_index
;
8 static ssize_t
device_show(struct device
*_d
,
9 struct device_attribute
*attr
, char *buf
)
11 struct virtio_device
*dev
= container_of(_d
,struct virtio_device
,dev
);
12 return sprintf(buf
, "%hu", dev
->id
.device
);
14 static ssize_t
vendor_show(struct device
*_d
,
15 struct device_attribute
*attr
, char *buf
)
17 struct virtio_device
*dev
= container_of(_d
,struct virtio_device
,dev
);
18 return sprintf(buf
, "%hu", dev
->id
.vendor
);
20 static ssize_t
status_show(struct device
*_d
,
21 struct device_attribute
*attr
, char *buf
)
23 struct virtio_device
*dev
= container_of(_d
,struct virtio_device
,dev
);
24 return sprintf(buf
, "0x%08x", dev
->config
->get_status(dev
));
26 static ssize_t
modalias_show(struct device
*_d
,
27 struct device_attribute
*attr
, char *buf
)
29 struct virtio_device
*dev
= container_of(_d
,struct virtio_device
,dev
);
31 return sprintf(buf
, "virtio:d%08Xv%08X\n",
32 dev
->id
.device
, dev
->id
.vendor
);
34 static struct device_attribute virtio_dev_attrs
[] = {
42 static inline int virtio_id_match(const struct virtio_device
*dev
,
43 const struct virtio_device_id
*id
)
45 if (id
->device
!= dev
->id
.device
)
48 return id
->vendor
== VIRTIO_DEV_ANY_ID
|| id
->vendor
!= dev
->id
.vendor
;
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
)
56 struct virtio_device
*dev
= container_of(_dv
,struct virtio_device
,dev
);
57 const struct virtio_device_id
*ids
;
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
]))
66 static int virtio_uevent(struct device
*_dv
, struct kobj_uevent_env
*env
)
68 struct virtio_device
*dev
= container_of(_dv
,struct virtio_device
,dev
);
70 return add_uevent_var(env
, "MODALIAS=virtio:d%08Xv%08X",
71 dev
->id
.device
, dev
->id
.vendor
);
74 static void add_status(struct virtio_device
*dev
, unsigned status
)
76 dev
->config
->set_status(dev
, dev
->config
->get_status(dev
) | status
);
79 void virtio_check_driver_offered_feature(const struct virtio_device
*vdev
,
83 struct virtio_driver
*drv
= container_of(vdev
->dev
.driver
,
84 struct virtio_driver
, driver
);
86 for (i
= 0; i
< drv
->feature_table_size
; i
++)
87 if (drv
->feature_table
[i
] == fbit
)
91 EXPORT_SYMBOL_GPL(virtio_check_driver_offered_feature
);
93 static int virtio_dev_probe(struct device
*_d
)
96 struct virtio_device
*dev
= container_of(_d
,struct virtio_device
,dev
);
97 struct virtio_driver
*drv
= container_of(dev
->dev
.driver
,
98 struct virtio_driver
, driver
);
101 /* We have a driver! */
102 add_status(dev
, VIRTIO_CONFIG_S_DRIVER
);
104 /* Figure out what features the device supports. */
105 device_features
= dev
->config
->get_features(dev
);
107 /* Features supported by both device and driver into dev->features. */
108 memset(dev
->features
, 0, sizeof(dev
->features
));
109 for (i
= 0; i
< drv
->feature_table_size
; i
++) {
110 unsigned int f
= drv
->feature_table
[i
];
112 if (device_features
& (1 << f
))
113 set_bit(f
, dev
->features
);
116 /* Transport features are always preserved to pass to set_features. */
117 for (i
= VIRTIO_TRANSPORT_F_START
; i
< VIRTIO_TRANSPORT_F_END
; i
++)
118 if (device_features
& (1 << i
))
119 set_bit(i
, dev
->features
);
121 err
= drv
->probe(dev
);
123 add_status(dev
, VIRTIO_CONFIG_S_FAILED
);
125 /* They should never have set feature bits beyond 32 */
126 dev
->config
->set_features(dev
, dev
->features
[0]);
127 add_status(dev
, VIRTIO_CONFIG_S_DRIVER_OK
);
132 static int virtio_dev_remove(struct device
*_d
)
134 struct virtio_device
*dev
= container_of(_d
,struct virtio_device
,dev
);
135 struct virtio_driver
*drv
= container_of(dev
->dev
.driver
,
136 struct virtio_driver
, driver
);
140 /* Driver should have reset device. */
141 BUG_ON(dev
->config
->get_status(dev
));
143 /* Acknowledge the device's existence again. */
144 add_status(dev
, VIRTIO_CONFIG_S_ACKNOWLEDGE
);
148 static struct bus_type virtio_bus
= {
150 .match
= virtio_dev_match
,
151 .dev_attrs
= virtio_dev_attrs
,
152 .uevent
= virtio_uevent
,
153 .probe
= virtio_dev_probe
,
154 .remove
= virtio_dev_remove
,
157 int register_virtio_driver(struct virtio_driver
*driver
)
159 /* Catch this early. */
160 BUG_ON(driver
->feature_table_size
&& !driver
->feature_table
);
161 driver
->driver
.bus
= &virtio_bus
;
162 return driver_register(&driver
->driver
);
164 EXPORT_SYMBOL_GPL(register_virtio_driver
);
166 void unregister_virtio_driver(struct virtio_driver
*driver
)
168 driver_unregister(&driver
->driver
);
170 EXPORT_SYMBOL_GPL(unregister_virtio_driver
);
172 int register_virtio_device(struct virtio_device
*dev
)
176 dev
->dev
.bus
= &virtio_bus
;
178 /* Assign a unique device index and hence name. */
179 dev
->index
= dev_index
++;
180 sprintf(dev
->dev
.bus_id
, "virtio%u", dev
->index
);
182 /* We always start by resetting the device, in case a previous
183 * driver messed it up. This also tests that code path a little. */
184 dev
->config
->reset(dev
);
186 /* Acknowledge that we've seen the device. */
187 add_status(dev
, VIRTIO_CONFIG_S_ACKNOWLEDGE
);
189 /* device_register() causes the bus infrastructure to look for a
190 * matching driver. */
191 err
= device_register(&dev
->dev
);
193 add_status(dev
, VIRTIO_CONFIG_S_FAILED
);
196 EXPORT_SYMBOL_GPL(register_virtio_device
);
198 void unregister_virtio_device(struct virtio_device
*dev
)
200 device_unregister(&dev
->dev
);
202 EXPORT_SYMBOL_GPL(unregister_virtio_device
);
204 static int virtio_init(void)
206 if (bus_register(&virtio_bus
) != 0)
207 panic("virtio bus registration failed");
211 static void __exit
virtio_exit(void)
213 bus_unregister(&virtio_bus
);
215 core_initcall(virtio_init
);
216 module_exit(virtio_exit
);
218 MODULE_LICENSE("GPL");