1
2
3
4
5
6
7
8
9
10
11
12#include <linux/kernel.h>
13#include <linux/irq.h>
14#include <linux/init.h>
15
16#include <asm/mdesc.h>
17#include <asm/vio.h>
18
19static const struct vio_device_id *vio_match_device(
20 const struct vio_device_id *matches,
21 const struct vio_dev *dev)
22{
23 const char *type, *compat;
24 int len;
25
26 type = dev->type;
27 compat = dev->compat;
28 len = dev->compat_len;
29
30 while (matches->type[0] || matches->compat[0]) {
31 int match = 1;
32 if (matches->type[0])
33 match &= !strcmp(matches->type, type);
34
35 if (matches->compat[0]) {
36 match &= len &&
37 of_find_in_proplist(compat, matches->compat, len);
38 }
39 if (match)
40 return matches;
41 matches++;
42 }
43 return NULL;
44}
45
46static int vio_bus_match(struct device *dev, struct device_driver *drv)
47{
48 struct vio_dev *vio_dev = to_vio_dev(dev);
49 struct vio_driver *vio_drv = to_vio_driver(drv);
50 const struct vio_device_id *matches = vio_drv->id_table;
51
52 if (!matches)
53 return 0;
54
55 return vio_match_device(matches, vio_dev) != NULL;
56}
57
58static int vio_device_probe(struct device *dev)
59{
60 struct vio_dev *vdev = to_vio_dev(dev);
61 struct vio_driver *drv = to_vio_driver(dev->driver);
62 const struct vio_device_id *id;
63 int error = -ENODEV;
64
65 if (drv->probe) {
66 id = vio_match_device(drv->id_table, vdev);
67 if (id)
68 error = drv->probe(vdev, id);
69 }
70
71 return error;
72}
73
74static int vio_device_remove(struct device *dev)
75{
76 struct vio_dev *vdev = to_vio_dev(dev);
77 struct vio_driver *drv = to_vio_driver(dev->driver);
78
79 if (drv->remove)
80 return drv->remove(vdev);
81
82 return 1;
83}
84
85static ssize_t devspec_show(struct device *dev,
86 struct device_attribute *attr, char *buf)
87{
88 struct vio_dev *vdev = to_vio_dev(dev);
89 const char *str = "none";
90
91 if (!strcmp(vdev->type, "vnet-port"))
92 str = "vnet";
93 else if (!strcmp(vdev->type, "vdc-port"))
94 str = "vdisk";
95
96 return sprintf(buf, "%s\n", str);
97}
98
99static ssize_t type_show(struct device *dev,
100 struct device_attribute *attr, char *buf)
101{
102 struct vio_dev *vdev = to_vio_dev(dev);
103 return sprintf(buf, "%s\n", vdev->type);
104}
105
106static struct device_attribute vio_dev_attrs[] = {
107 __ATTR_RO(devspec),
108 __ATTR_RO(type),
109 __ATTR_NULL
110};
111
112static struct bus_type vio_bus_type = {
113 .name = "vio",
114 .dev_attrs = vio_dev_attrs,
115 .match = vio_bus_match,
116 .probe = vio_device_probe,
117 .remove = vio_device_remove,
118};
119
120int vio_register_driver(struct vio_driver *viodrv)
121{
122 viodrv->driver.bus = &vio_bus_type;
123
124 return driver_register(&viodrv->driver);
125}
126EXPORT_SYMBOL(vio_register_driver);
127
128void vio_unregister_driver(struct vio_driver *viodrv)
129{
130 driver_unregister(&viodrv->driver);
131}
132EXPORT_SYMBOL(vio_unregister_driver);
133
134static void vio_dev_release(struct device *dev)
135{
136 kfree(to_vio_dev(dev));
137}
138
139static ssize_t
140show_pciobppath_attr(struct device *dev, struct device_attribute *attr,
141 char *buf)
142{
143 struct vio_dev *vdev;
144 struct device_node *dp;
145
146 vdev = to_vio_dev(dev);
147 dp = vdev->dp;
148
149 return snprintf (buf, PAGE_SIZE, "%s\n", dp->full_name);
150}
151
152static DEVICE_ATTR(obppath, S_IRUSR | S_IRGRP | S_IROTH,
153 show_pciobppath_attr, NULL);
154
155static struct device_node *cdev_node;
156
157static struct vio_dev *root_vdev;
158static u64 cdev_cfg_handle;
159
160static void vio_fill_channel_info(struct mdesc_handle *hp, u64 mp,
161 struct vio_dev *vdev)
162{
163 u64 a;
164
165 mdesc_for_each_arc(a, hp, mp, MDESC_ARC_TYPE_FWD) {
166 const u64 *chan_id;
167 const u64 *irq;
168 u64 target;
169
170 target = mdesc_arc_target(hp, a);
171
172 irq = mdesc_get_property(hp, target, "tx-ino", NULL);
173 if (irq)
174 vdev->tx_irq = sun4v_build_virq(cdev_cfg_handle, *irq);
175
176 irq = mdesc_get_property(hp, target, "rx-ino", NULL);
177 if (irq)
178 vdev->rx_irq = sun4v_build_virq(cdev_cfg_handle, *irq);
179
180 chan_id = mdesc_get_property(hp, target, "id", NULL);
181 if (chan_id)
182 vdev->channel_id = *chan_id;
183 }
184}
185
186static struct vio_dev *vio_create_one(struct mdesc_handle *hp, u64 mp,
187 struct device *parent)
188{
189 const char *type, *compat, *bus_id_name;
190 struct device_node *dp;
191 struct vio_dev *vdev;
192 int err, tlen, clen;
193 const u64 *id, *cfg_handle;
194 u64 a;
195
196 type = mdesc_get_property(hp, mp, "device-type", &tlen);
197 if (!type) {
198 type = mdesc_get_property(hp, mp, "name", &tlen);
199 if (!type) {
200 type = mdesc_node_name(hp, mp);
201 tlen = strlen(type) + 1;
202 }
203 }
204 if (tlen > VIO_MAX_TYPE_LEN) {
205 printk(KERN_ERR "VIO: Type string [%s] is too long.\n",
206 type);
207 return NULL;
208 }
209
210 id = mdesc_get_property(hp, mp, "id", NULL);
211
212 cfg_handle = NULL;
213 mdesc_for_each_arc(a, hp, mp, MDESC_ARC_TYPE_BACK) {
214 u64 target;
215
216 target = mdesc_arc_target(hp, a);
217 cfg_handle = mdesc_get_property(hp, target,
218 "cfg-handle", NULL);
219 if (cfg_handle)
220 break;
221 }
222
223 bus_id_name = type;
224 if (!strcmp(type, "domain-services-port"))
225 bus_id_name = "ds";
226
227
228
229
230
231
232 if (strlen(bus_id_name) >= 20 - 4) {
233 printk(KERN_ERR "VIO: bus_id_name [%s] is too long.\n",
234 bus_id_name);
235 return NULL;
236 }
237
238 compat = mdesc_get_property(hp, mp, "device-type", &clen);
239 if (!compat) {
240 clen = 0;
241 } else if (clen > VIO_MAX_COMPAT_LEN) {
242 printk(KERN_ERR "VIO: Compat len %d for [%s] is too long.\n",
243 clen, type);
244 return NULL;
245 }
246
247 vdev = kzalloc(sizeof(*vdev), GFP_KERNEL);
248 if (!vdev) {
249 printk(KERN_ERR "VIO: Could not allocate vio_dev\n");
250 return NULL;
251 }
252
253 vdev->mp = mp;
254 memcpy(vdev->type, type, tlen);
255 if (compat)
256 memcpy(vdev->compat, compat, clen);
257 else
258 memset(vdev->compat, 0, sizeof(vdev->compat));
259 vdev->compat_len = clen;
260
261 vdev->channel_id = ~0UL;
262 vdev->tx_irq = ~0;
263 vdev->rx_irq = ~0;
264
265 vio_fill_channel_info(hp, mp, vdev);
266
267 if (!id) {
268 dev_set_name(&vdev->dev, "%s", bus_id_name);
269 vdev->dev_no = ~(u64)0;
270 } else if (!cfg_handle) {
271 dev_set_name(&vdev->dev, "%s-%llu", bus_id_name, *id);
272 vdev->dev_no = *id;
273 } else {
274 dev_set_name(&vdev->dev, "%s-%llu-%llu", bus_id_name,
275 *cfg_handle, *id);
276 vdev->dev_no = *cfg_handle;
277 }
278
279 vdev->dev.parent = parent;
280 vdev->dev.bus = &vio_bus_type;
281 vdev->dev.release = vio_dev_release;
282
283 if (parent == NULL) {
284 dp = cdev_node;
285 } else if (to_vio_dev(parent) == root_vdev) {
286 dp = of_get_next_child(cdev_node, NULL);
287 while (dp) {
288 if (!strcmp(dp->type, type))
289 break;
290
291 dp = of_get_next_child(cdev_node, dp);
292 }
293 } else {
294 dp = to_vio_dev(parent)->dp;
295 }
296 vdev->dp = dp;
297
298 printk(KERN_INFO "VIO: Adding device %s\n", dev_name(&vdev->dev));
299
300 err = device_register(&vdev->dev);
301 if (err) {
302 printk(KERN_ERR "VIO: Could not register device %s, err=%d\n",
303 dev_name(&vdev->dev), err);
304 kfree(vdev);
305 return NULL;
306 }
307 if (vdev->dp)
308 err = sysfs_create_file(&vdev->dev.kobj,
309 &dev_attr_obppath.attr);
310
311 return vdev;
312}
313
314static void vio_add(struct mdesc_handle *hp, u64 node)
315{
316 (void) vio_create_one(hp, node, &root_vdev->dev);
317}
318
319static int vio_md_node_match(struct device *dev, void *arg)
320{
321 struct vio_dev *vdev = to_vio_dev(dev);
322
323 if (vdev->mp == (u64) arg)
324 return 1;
325
326 return 0;
327}
328
329static void vio_remove(struct mdesc_handle *hp, u64 node)
330{
331 struct device *dev;
332
333 dev = device_find_child(&root_vdev->dev, (void *) node,
334 vio_md_node_match);
335 if (dev) {
336 printk(KERN_INFO "VIO: Removing device %s\n", dev_name(dev));
337
338 device_unregister(dev);
339 }
340}
341
342static struct mdesc_notifier_client vio_device_notifier = {
343 .add = vio_add,
344 .remove = vio_remove,
345 .node_name = "virtual-device-port",
346};
347
348
349
350
351
352
353static void vio_add_ds(struct mdesc_handle *hp, u64 node)
354{
355 int found;
356 u64 a;
357
358 found = 0;
359 mdesc_for_each_arc(a, hp, node, MDESC_ARC_TYPE_BACK) {
360 u64 target = mdesc_arc_target(hp, a);
361 const char *name = mdesc_node_name(hp, target);
362
363 if (!strcmp(name, "domain-services")) {
364 found = 1;
365 break;
366 }
367 }
368
369 if (found)
370 (void) vio_create_one(hp, node, &root_vdev->dev);
371}
372
373static struct mdesc_notifier_client vio_ds_notifier = {
374 .add = vio_add_ds,
375 .remove = vio_remove,
376 .node_name = "domain-services-port",
377};
378
379static const char *channel_devices_node = "channel-devices";
380static const char *channel_devices_compat = "SUNW,sun4v-channel-devices";
381static const char *cfg_handle_prop = "cfg-handle";
382
383static int __init vio_init(void)
384{
385 struct mdesc_handle *hp;
386 const char *compat;
387 const u64 *cfg_handle;
388 int err, len;
389 u64 root;
390
391 err = bus_register(&vio_bus_type);
392 if (err) {
393 printk(KERN_ERR "VIO: Could not register bus type err=%d\n",
394 err);
395 return err;
396 }
397
398 hp = mdesc_grab();
399 if (!hp)
400 return 0;
401
402 root = mdesc_node_by_name(hp, MDESC_NODE_NULL, channel_devices_node);
403 if (root == MDESC_NODE_NULL) {
404 printk(KERN_INFO "VIO: No channel-devices MDESC node.\n");
405 mdesc_release(hp);
406 return 0;
407 }
408
409 cdev_node = of_find_node_by_name(NULL, "channel-devices");
410 err = -ENODEV;
411 if (!cdev_node) {
412 printk(KERN_INFO "VIO: No channel-devices OBP node.\n");
413 goto out_release;
414 }
415
416 compat = mdesc_get_property(hp, root, "compatible", &len);
417 if (!compat) {
418 printk(KERN_ERR "VIO: Channel devices lacks compatible "
419 "property\n");
420 goto out_release;
421 }
422 if (!of_find_in_proplist(compat, channel_devices_compat, len)) {
423 printk(KERN_ERR "VIO: Channel devices node lacks (%s) "
424 "compat entry.\n", channel_devices_compat);
425 goto out_release;
426 }
427
428 cfg_handle = mdesc_get_property(hp, root, cfg_handle_prop, NULL);
429 if (!cfg_handle) {
430 printk(KERN_ERR "VIO: Channel devices lacks %s property\n",
431 cfg_handle_prop);
432 goto out_release;
433 }
434
435 cdev_cfg_handle = *cfg_handle;
436
437 root_vdev = vio_create_one(hp, root, NULL);
438 err = -ENODEV;
439 if (!root_vdev) {
440 printk(KERN_ERR "VIO: Coult not create root device.\n");
441 goto out_release;
442 }
443
444 mdesc_register_notifier(&vio_device_notifier);
445 mdesc_register_notifier(&vio_ds_notifier);
446
447 mdesc_release(hp);
448
449 return err;
450
451out_release:
452 mdesc_release(hp);
453 return err;
454}
455
456postcore_initcall(vio_init);
457
