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
155struct 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 if (strlen(bus_id_name) >= KOBJ_NAME_LEN - 4) {
228 printk(KERN_ERR "VIO: bus_id_name [%s] is too long.\n",
229 bus_id_name);
230 return NULL;
231 }
232
233 compat = mdesc_get_property(hp, mp, "device-type", &clen);
234 if (!compat) {
235 clen = 0;
236 } else if (clen > VIO_MAX_COMPAT_LEN) {
237 printk(KERN_ERR "VIO: Compat len %d for [%s] is too long.\n",
238 clen, type);
239 return NULL;
240 }
241
242 vdev = kzalloc(sizeof(*vdev), GFP_KERNEL);
243 if (!vdev) {
244 printk(KERN_ERR "VIO: Could not allocate vio_dev\n");
245 return NULL;
246 }
247
248 vdev->mp = mp;
249 memcpy(vdev->type, type, tlen);
250 if (compat)
251 memcpy(vdev->compat, compat, clen);
252 else
253 memset(vdev->compat, 0, sizeof(vdev->compat));
254 vdev->compat_len = clen;
255
256 vdev->channel_id = ~0UL;
257 vdev->tx_irq = ~0;
258 vdev->rx_irq = ~0;
259
260 vio_fill_channel_info(hp, mp, vdev);
261
262 if (!id) {
263 snprintf(vdev->dev.bus_id, BUS_ID_SIZE, "%s",
264 bus_id_name);
265 vdev->dev_no = ~(u64)0;
266 } else if (!cfg_handle) {
267 snprintf(vdev->dev.bus_id, BUS_ID_SIZE, "%s-%lu",
268 bus_id_name, *id);
269 vdev->dev_no = *id;
270 } else {
271 snprintf(vdev->dev.bus_id, BUS_ID_SIZE, "%s-%lu-%lu",
272 bus_id_name, *cfg_handle, *id);
273 vdev->dev_no = *cfg_handle;
274 }
275
276 vdev->dev.parent = parent;
277 vdev->dev.bus = &vio_bus_type;
278 vdev->dev.release = vio_dev_release;
279
280 if (parent == NULL) {
281 dp = cdev_node;
282 } else if (to_vio_dev(parent) == root_vdev) {
283 dp = of_get_next_child(cdev_node, NULL);
284 while (dp) {
285 if (!strcmp(dp->type, type))
286 break;
287
288 dp = of_get_next_child(cdev_node, dp);
289 }
290 } else {
291 dp = to_vio_dev(parent)->dp;
292 }
293 vdev->dp = dp;
294
295 printk(KERN_INFO "VIO: Adding device %s\n", vdev->dev.bus_id);
296
297 err = device_register(&vdev->dev);
298 if (err) {
299 printk(KERN_ERR "VIO: Could not register device %s, err=%d\n",
300 vdev->dev.bus_id, err);
301 kfree(vdev);
302 return NULL;
303 }
304 if (vdev->dp)
305 err = sysfs_create_file(&vdev->dev.kobj,
306 &dev_attr_obppath.attr);
307
308 return vdev;
309}
310
311static void vio_add(struct mdesc_handle *hp, u64 node)
312{
313 (void) vio_create_one(hp, node, &root_vdev->dev);
314}
315
316static int vio_md_node_match(struct device *dev, void *arg)
317{
318 struct vio_dev *vdev = to_vio_dev(dev);
319
320 if (vdev->mp == (u64) arg)
321 return 1;
322
323 return 0;
324}
325
326static void vio_remove(struct mdesc_handle *hp, u64 node)
327{
328 struct device *dev;
329
330 dev = device_find_child(&root_vdev->dev, (void *) node,
331 vio_md_node_match);
332 if (dev) {
333 printk(KERN_INFO "VIO: Removing device %s\n", dev->bus_id);
334
335 device_unregister(dev);
336 }
337}
338
339static struct mdesc_notifier_client vio_device_notifier = {
340 .add = vio_add,
341 .remove = vio_remove,
342 .node_name = "virtual-device-port",
343};
344
345
346
347
348
349
350static void vio_add_ds(struct mdesc_handle *hp, u64 node)
351{
352 int found;
353 u64 a;
354
355 found = 0;
356 mdesc_for_each_arc(a, hp, node, MDESC_ARC_TYPE_BACK) {
357 u64 target = mdesc_arc_target(hp, a);
358 const char *name = mdesc_node_name(hp, target);
359
360 if (!strcmp(name, "domain-services")) {
361 found = 1;
362 break;
363 }
364 }
365
366 if (found)
367 (void) vio_create_one(hp, node, &root_vdev->dev);
368}
369
370static struct mdesc_notifier_client vio_ds_notifier = {
371 .add = vio_add_ds,
372 .remove = vio_remove,
373 .node_name = "domain-services-port",
374};
375
376const char *channel_devices_node = "channel-devices";
377const char *channel_devices_compat = "SUNW,sun4v-channel-devices";
378const char *cfg_handle_prop = "cfg-handle";
379
380static int __init vio_init(void)
381{
382 struct mdesc_handle *hp;
383 const char *compat;
384 const u64 *cfg_handle;
385 int err, len;
386 u64 root;
387
388 err = bus_register(&vio_bus_type);
389 if (err) {
390 printk(KERN_ERR "VIO: Could not register bus type err=%d\n",
391 err);
392 return err;
393 }
394
395 hp = mdesc_grab();
396 if (!hp)
397 return 0;
398
399 root = mdesc_node_by_name(hp, MDESC_NODE_NULL, channel_devices_node);
400 if (root == MDESC_NODE_NULL) {
401 printk(KERN_INFO "VIO: No channel-devices MDESC node.\n");
402 mdesc_release(hp);
403 return 0;
404 }
405
406 cdev_node = of_find_node_by_name(NULL, "channel-devices");
407 err = -ENODEV;
408 if (!cdev_node) {
409 printk(KERN_INFO "VIO: No channel-devices OBP node.\n");
410 goto out_release;
411 }
412
413 compat = mdesc_get_property(hp, root, "compatible", &len);
414 if (!compat) {
415 printk(KERN_ERR "VIO: Channel devices lacks compatible "
416 "property\n");
417 goto out_release;
418 }
419 if (!of_find_in_proplist(compat, channel_devices_compat, len)) {
420 printk(KERN_ERR "VIO: Channel devices node lacks (%s) "
421 "compat entry.\n", channel_devices_compat);
422 goto out_release;
423 }
424
425 cfg_handle = mdesc_get_property(hp, root, cfg_handle_prop, NULL);
426 if (!cfg_handle) {
427 printk(KERN_ERR "VIO: Channel devices lacks %s property\n",
428 cfg_handle_prop);
429 goto out_release;
430 }
431
432 cdev_cfg_handle = *cfg_handle;
433
434 root_vdev = vio_create_one(hp, root, NULL);
435 err = -ENODEV;
436 if (!root_vdev) {
437 printk(KERN_ERR "VIO: Coult not create root device.\n");
438 goto out_release;
439 }
440
441 mdesc_register_notifier(&vio_device_notifier);
442 mdesc_register_notifier(&vio_ds_notifier);
443
444 mdesc_release(hp);
445
446 return err;
447
448out_release:
449 mdesc_release(hp);
450 return err;
451}
452
453postcore_initcall(vio_init);
454
