Merge commit 'tip/core/iommu' into amd-iommu/fixes
[linux-2.6] / arch / powerpc / platforms / iseries / vio.c
1 /*
2  * Legacy iSeries specific vio initialisation
3  * that needs to be built in (not a module).
4  *
5  * © Copyright 2007 IBM Corporation
6  *      Author: Stephen Rothwell
7  *      Some parts collected from various other files
8  *
9  * This program is free software;  you can redistribute it and/or
10  * modify it under the terms of the GNU General Public License as
11  * published by the Free Software Foundation; either version 2 of the
12  * License, or (at your option) any later version.
13  *
14  * This program is distributed in the hope that it will be useful, but
15  * WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17  * General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, write to the Free Software Foundation,
21  * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22  */
23 #include <linux/of.h>
24 #include <linux/init.h>
25 #include <linux/gfp.h>
26 #include <linux/completion.h>
27 #include <linux/proc_fs.h>
28 #include <linux/module.h>
29
30 #include <asm/firmware.h>
31 #include <asm/vio.h>
32 #include <asm/iseries/vio.h>
33 #include <asm/iseries/iommu.h>
34 #include <asm/iseries/hv_types.h>
35 #include <asm/iseries/hv_lp_event.h>
36
37 #define FIRST_VTY       0
38 #define NUM_VTYS        1
39 #define FIRST_VSCSI     (FIRST_VTY + NUM_VTYS)
40 #define NUM_VSCSIS      1
41 #define FIRST_VLAN      (FIRST_VSCSI + NUM_VSCSIS)
42 #define NUM_VLANS       HVMAXARCHITECTEDVIRTUALLANS
43 #define FIRST_VIODASD   (FIRST_VLAN + NUM_VLANS)
44 #define NUM_VIODASDS    HVMAXARCHITECTEDVIRTUALDISKS
45 #define FIRST_VIOCD     (FIRST_VIODASD + NUM_VIODASDS)
46 #define NUM_VIOCDS      HVMAXARCHITECTEDVIRTUALCDROMS
47 #define FIRST_VIOTAPE   (FIRST_VIOCD + NUM_VIOCDS)
48 #define NUM_VIOTAPES    HVMAXARCHITECTEDVIRTUALTAPES
49
50 struct vio_waitevent {
51         struct completion       com;
52         int                     rc;
53         u16                     sub_result;
54 };
55
56 struct vio_resource {
57         char    rsrcname[10];
58         char    type[4];
59         char    model[3];
60 };
61
62 static struct property *new_property(const char *name, int length,
63                 const void *value)
64 {
65         struct property *np = kzalloc(sizeof(*np) + strlen(name) + 1 + length,
66                         GFP_KERNEL);
67
68         if (!np)
69                 return NULL;
70         np->name = (char *)(np + 1);
71         np->value = np->name + strlen(name) + 1;
72         strcpy(np->name, name);
73         memcpy(np->value, value, length);
74         np->length = length;
75         return np;
76 }
77
78 static void free_property(struct property *np)
79 {
80         kfree(np);
81 }
82
83 static struct device_node *new_node(const char *path,
84                 struct device_node *parent)
85 {
86         struct device_node *np = kzalloc(sizeof(*np), GFP_KERNEL);
87
88         if (!np)
89                 return NULL;
90         np->full_name = kmalloc(strlen(path) + 1, GFP_KERNEL);
91         if (!np->full_name) {
92                 kfree(np);
93                 return NULL;
94         }
95         strcpy(np->full_name, path);
96         of_node_set_flag(np, OF_DYNAMIC);
97         kref_init(&np->kref);
98         np->parent = of_node_get(parent);
99         return np;
100 }
101
102 static void free_node(struct device_node *np)
103 {
104         struct property *next;
105         struct property *prop;
106
107         next = np->properties;
108         while (next) {
109                 prop = next;
110                 next = prop->next;
111                 free_property(prop);
112         }
113         of_node_put(np->parent);
114         kfree(np->full_name);
115         kfree(np);
116 }
117
118 static int add_string_property(struct device_node *np, const char *name,
119                 const char *value)
120 {
121         struct property *nprop = new_property(name, strlen(value) + 1, value);
122
123         if (!nprop)
124                 return 0;
125         prom_add_property(np, nprop);
126         return 1;
127 }
128
129 static int add_raw_property(struct device_node *np, const char *name,
130                 int length, const void *value)
131 {
132         struct property *nprop = new_property(name, length, value);
133
134         if (!nprop)
135                 return 0;
136         prom_add_property(np, nprop);
137         return 1;
138 }
139
140 static struct device_node *do_device_node(struct device_node *parent,
141                 const char *name, u32 reg, u32 unit, const char *type,
142                 const char *compat, struct vio_resource *res)
143 {
144         struct device_node *np;
145         char path[32];
146
147         snprintf(path, sizeof(path), "/vdevice/%s@%08x", name, reg);
148         np = new_node(path, parent);
149         if (!np)
150                 return NULL;
151         if (!add_string_property(np, "name", name) ||
152                 !add_string_property(np, "device_type", type) ||
153                 !add_string_property(np, "compatible", compat) ||
154                 !add_raw_property(np, "reg", sizeof(reg), &reg) ||
155                 !add_raw_property(np, "linux,unit_address",
156                         sizeof(unit), &unit)) {
157                 goto node_free;
158         }
159         if (res) {
160                 if (!add_raw_property(np, "linux,vio_rsrcname",
161                                 sizeof(res->rsrcname), res->rsrcname) ||
162                         !add_raw_property(np, "linux,vio_type",
163                                 sizeof(res->type), res->type) ||
164                         !add_raw_property(np, "linux,vio_model",
165                                 sizeof(res->model), res->model))
166                         goto node_free;
167         }
168         np->name = of_get_property(np, "name", NULL);
169         np->type = of_get_property(np, "device_type", NULL);
170         of_attach_node(np);
171 #ifdef CONFIG_PROC_DEVICETREE
172         if (parent->pde) {
173                 struct proc_dir_entry *ent;
174
175                 ent = proc_mkdir(strrchr(np->full_name, '/') + 1, parent->pde);
176                 if (ent)
177                         proc_device_tree_add_node(np, ent);
178         }
179 #endif
180         return np;
181
182  node_free:
183         free_node(np);
184         return NULL;
185 }
186
187 /*
188  * This is here so that we can dynamically add viodasd
189  * devices without exposing all the above infrastructure.
190  */
191 struct vio_dev *vio_create_viodasd(u32 unit)
192 {
193         struct device_node *vio_root;
194         struct device_node *np;
195         struct vio_dev *vdev = NULL;
196
197         vio_root = of_find_node_by_path("/vdevice");
198         if (!vio_root)
199                 return NULL;
200         np = do_device_node(vio_root, "viodasd", FIRST_VIODASD + unit, unit,
201                         "block", "IBM,iSeries-viodasd", NULL);
202         of_node_put(vio_root);
203         if (np) {
204                 vdev = vio_register_device_node(np);
205                 if (!vdev)
206                         free_node(np);
207         }
208         return vdev;
209 }
210 EXPORT_SYMBOL_GPL(vio_create_viodasd);
211
212 static void __init handle_block_event(struct HvLpEvent *event)
213 {
214         struct vioblocklpevent *bevent = (struct vioblocklpevent *)event;
215         struct vio_waitevent *pwe;
216
217         if (event == NULL)
218                 /* Notification that a partition went away! */
219                 return;
220         /* First, we should NEVER get an int here...only acks */
221         if (hvlpevent_is_int(event)) {
222                 printk(KERN_WARNING "handle_viod_request: "
223                        "Yikes! got an int in viodasd event handler!\n");
224                 if (hvlpevent_need_ack(event)) {
225                         event->xRc = HvLpEvent_Rc_InvalidSubtype;
226                         HvCallEvent_ackLpEvent(event);
227                 }
228                 return;
229         }
230
231         switch (event->xSubtype & VIOMINOR_SUBTYPE_MASK) {
232         case vioblockopen:
233                 /*
234                  * Handle a response to an open request.  We get all the
235                  * disk information in the response, so update it.  The
236                  * correlation token contains a pointer to a waitevent
237                  * structure that has a completion in it.  update the
238                  * return code in the waitevent structure and post the
239                  * completion to wake up the guy who sent the request
240                  */
241                 pwe = (struct vio_waitevent *)event->xCorrelationToken;
242                 pwe->rc = event->xRc;
243                 pwe->sub_result = bevent->sub_result;
244                 complete(&pwe->com);
245                 break;
246         case vioblockclose:
247                 break;
248         default:
249                 printk(KERN_WARNING "handle_viod_request: unexpected subtype!");
250                 if (hvlpevent_need_ack(event)) {
251                         event->xRc = HvLpEvent_Rc_InvalidSubtype;
252                         HvCallEvent_ackLpEvent(event);
253                 }
254         }
255 }
256
257 static void __init probe_disk(struct device_node *vio_root, u32 unit)
258 {
259         HvLpEvent_Rc hvrc;
260         struct vio_waitevent we;
261         u16 flags = 0;
262
263 retry:
264         init_completion(&we.com);
265
266         /* Send the open event to OS/400 */
267         hvrc = HvCallEvent_signalLpEventFast(viopath_hostLp,
268                         HvLpEvent_Type_VirtualIo,
269                         viomajorsubtype_blockio | vioblockopen,
270                         HvLpEvent_AckInd_DoAck, HvLpEvent_AckType_ImmediateAck,
271                         viopath_sourceinst(viopath_hostLp),
272                         viopath_targetinst(viopath_hostLp),
273                         (u64)(unsigned long)&we, VIOVERSION << 16,
274                         ((u64)unit << 48) | ((u64)flags<< 32),
275                         0, 0, 0);
276         if (hvrc != 0) {
277                 printk(KERN_WARNING "probe_disk: bad rc on HV open %d\n",
278                         (int)hvrc);
279                 return;
280         }
281
282         wait_for_completion(&we.com);
283
284         if (we.rc != 0) {
285                 if (flags != 0)
286                         return;
287                 /* try again with read only flag set */
288                 flags = vioblockflags_ro;
289                 goto retry;
290         }
291
292         /* Send the close event to OS/400.  We DON'T expect a response */
293         hvrc = HvCallEvent_signalLpEventFast(viopath_hostLp,
294                         HvLpEvent_Type_VirtualIo,
295                         viomajorsubtype_blockio | vioblockclose,
296                         HvLpEvent_AckInd_NoAck, HvLpEvent_AckType_ImmediateAck,
297                         viopath_sourceinst(viopath_hostLp),
298                         viopath_targetinst(viopath_hostLp),
299                         0, VIOVERSION << 16,
300                         ((u64)unit << 48) | ((u64)flags << 32),
301                         0, 0, 0);
302         if (hvrc != 0) {
303                 printk(KERN_WARNING "probe_disk: "
304                        "bad rc sending event to OS/400 %d\n", (int)hvrc);
305                 return;
306         }
307
308         do_device_node(vio_root, "viodasd", FIRST_VIODASD + unit, unit,
309                         "block", "IBM,iSeries-viodasd", NULL);
310 }
311
312 static void __init get_viodasd_info(struct device_node *vio_root)
313 {
314         int rc;
315         u32 unit;
316
317         rc = viopath_open(viopath_hostLp, viomajorsubtype_blockio, 2);
318         if (rc) {
319                 printk(KERN_WARNING "get_viodasd_info: "
320                        "error opening path to host partition %d\n",
321                        viopath_hostLp);
322                 return;
323         }
324
325         /* Initialize our request handler */
326         vio_setHandler(viomajorsubtype_blockio, handle_block_event);
327
328         for (unit = 0; unit < HVMAXARCHITECTEDVIRTUALDISKS; unit++)
329                 probe_disk(vio_root, unit);
330
331         vio_clearHandler(viomajorsubtype_blockio);
332         viopath_close(viopath_hostLp, viomajorsubtype_blockio, 2);
333 }
334
335 static void __init handle_cd_event(struct HvLpEvent *event)
336 {
337         struct viocdlpevent *bevent;
338         struct vio_waitevent *pwe;
339
340         if (!event)
341                 /* Notification that a partition went away! */
342                 return;
343
344         /* First, we should NEVER get an int here...only acks */
345         if (hvlpevent_is_int(event)) {
346                 printk(KERN_WARNING "handle_cd_event: got an unexpected int\n");
347                 if (hvlpevent_need_ack(event)) {
348                         event->xRc = HvLpEvent_Rc_InvalidSubtype;
349                         HvCallEvent_ackLpEvent(event);
350                 }
351                 return;
352         }
353
354         bevent = (struct viocdlpevent *)event;
355
356         switch (event->xSubtype & VIOMINOR_SUBTYPE_MASK) {
357         case viocdgetinfo:
358                 pwe = (struct vio_waitevent *)event->xCorrelationToken;
359                 pwe->rc = event->xRc;
360                 pwe->sub_result = bevent->sub_result;
361                 complete(&pwe->com);
362                 break;
363
364         default:
365                 printk(KERN_WARNING "handle_cd_event: "
366                         "message with unexpected subtype %0x04X!\n",
367                         event->xSubtype & VIOMINOR_SUBTYPE_MASK);
368                 if (hvlpevent_need_ack(event)) {
369                         event->xRc = HvLpEvent_Rc_InvalidSubtype;
370                         HvCallEvent_ackLpEvent(event);
371                 }
372         }
373 }
374
375 static void __init get_viocd_info(struct device_node *vio_root)
376 {
377         HvLpEvent_Rc hvrc;
378         u32 unit;
379         struct vio_waitevent we;
380         struct vio_resource *unitinfo;
381         dma_addr_t unitinfo_dmaaddr;
382         int ret;
383
384         ret = viopath_open(viopath_hostLp, viomajorsubtype_cdio, 2);
385         if (ret) {
386                 printk(KERN_WARNING
387                         "get_viocd_info: error opening path to host partition %d\n",
388                         viopath_hostLp);
389                 return;
390         }
391
392         /* Initialize our request handler */
393         vio_setHandler(viomajorsubtype_cdio, handle_cd_event);
394
395         unitinfo = iseries_hv_alloc(
396                         sizeof(*unitinfo) * HVMAXARCHITECTEDVIRTUALCDROMS,
397                         &unitinfo_dmaaddr, GFP_ATOMIC);
398         if (!unitinfo) {
399                 printk(KERN_WARNING
400                         "get_viocd_info: error allocating unitinfo\n");
401                 goto clear_handler;
402         }
403
404         memset(unitinfo, 0, sizeof(*unitinfo) * HVMAXARCHITECTEDVIRTUALCDROMS);
405
406         init_completion(&we.com);
407
408         hvrc = HvCallEvent_signalLpEventFast(viopath_hostLp,
409                         HvLpEvent_Type_VirtualIo,
410                         viomajorsubtype_cdio | viocdgetinfo,
411                         HvLpEvent_AckInd_DoAck, HvLpEvent_AckType_ImmediateAck,
412                         viopath_sourceinst(viopath_hostLp),
413                         viopath_targetinst(viopath_hostLp),
414                         (u64)&we, VIOVERSION << 16, unitinfo_dmaaddr, 0,
415                         sizeof(*unitinfo) * HVMAXARCHITECTEDVIRTUALCDROMS, 0);
416         if (hvrc != HvLpEvent_Rc_Good) {
417                 printk(KERN_WARNING
418                         "get_viocd_info: cdrom error sending event. rc %d\n",
419                         (int)hvrc);
420                 goto hv_free;
421         }
422
423         wait_for_completion(&we.com);
424
425         if (we.rc) {
426                 printk(KERN_WARNING "get_viocd_info: bad rc %d:0x%04X\n",
427                         we.rc, we.sub_result);
428                 goto hv_free;
429         }
430
431         for (unit = 0; (unit < HVMAXARCHITECTEDVIRTUALCDROMS) &&
432                         unitinfo[unit].rsrcname[0]; unit++) {
433                 if (!do_device_node(vio_root, "viocd", FIRST_VIOCD + unit, unit,
434                                 "block", "IBM,iSeries-viocd", &unitinfo[unit]))
435                         break;
436         }
437
438  hv_free:
439         iseries_hv_free(sizeof(*unitinfo) * HVMAXARCHITECTEDVIRTUALCDROMS,
440                         unitinfo, unitinfo_dmaaddr);
441  clear_handler:
442         vio_clearHandler(viomajorsubtype_cdio);
443         viopath_close(viopath_hostLp, viomajorsubtype_cdio, 2);
444 }
445
446 /* Handle interrupt events for tape */
447 static void __init handle_tape_event(struct HvLpEvent *event)
448 {
449         struct vio_waitevent *we;
450         struct viotapelpevent *tevent = (struct viotapelpevent *)event;
451
452         if (event == NULL)
453                 /* Notification that a partition went away! */
454                 return;
455
456         we = (struct vio_waitevent *)event->xCorrelationToken;
457         switch (event->xSubtype & VIOMINOR_SUBTYPE_MASK) {
458         case viotapegetinfo:
459                 we->rc = tevent->sub_type_result;
460                 complete(&we->com);
461                 break;
462         default:
463                 printk(KERN_WARNING "handle_tape_event: weird ack\n");
464         }
465 }
466
467 static void __init get_viotape_info(struct device_node *vio_root)
468 {
469         HvLpEvent_Rc hvrc;
470         u32 unit;
471         struct vio_resource *unitinfo;
472         dma_addr_t unitinfo_dmaaddr;
473         size_t len = sizeof(*unitinfo) * HVMAXARCHITECTEDVIRTUALTAPES;
474         struct vio_waitevent we;
475         int ret;
476
477         ret = viopath_open(viopath_hostLp, viomajorsubtype_tape, 2);
478         if (ret) {
479                 printk(KERN_WARNING "get_viotape_info: "
480                         "error on viopath_open to hostlp %d\n", ret);
481                 return;
482         }
483
484         vio_setHandler(viomajorsubtype_tape, handle_tape_event);
485
486         unitinfo = iseries_hv_alloc(len, &unitinfo_dmaaddr, GFP_ATOMIC);
487         if (!unitinfo)
488                 goto clear_handler;
489
490         memset(unitinfo, 0, len);
491
492         hvrc = HvCallEvent_signalLpEventFast(viopath_hostLp,
493                         HvLpEvent_Type_VirtualIo,
494                         viomajorsubtype_tape | viotapegetinfo,
495                         HvLpEvent_AckInd_DoAck, HvLpEvent_AckType_ImmediateAck,
496                         viopath_sourceinst(viopath_hostLp),
497                         viopath_targetinst(viopath_hostLp),
498                         (u64)(unsigned long)&we, VIOVERSION << 16,
499                         unitinfo_dmaaddr, len, 0, 0);
500         if (hvrc != HvLpEvent_Rc_Good) {
501                 printk(KERN_WARNING "get_viotape_info: hv error on op %d\n",
502                                 (int)hvrc);
503                 goto hv_free;
504         }
505
506         wait_for_completion(&we.com);
507
508         for (unit = 0; (unit < HVMAXARCHITECTEDVIRTUALTAPES) &&
509                         unitinfo[unit].rsrcname[0]; unit++) {
510                 if (!do_device_node(vio_root, "viotape", FIRST_VIOTAPE + unit,
511                                 unit, "byte", "IBM,iSeries-viotape",
512                                 &unitinfo[unit]))
513                         break;
514         }
515
516  hv_free:
517         iseries_hv_free(len, unitinfo, unitinfo_dmaaddr);
518  clear_handler:
519         vio_clearHandler(viomajorsubtype_tape);
520         viopath_close(viopath_hostLp, viomajorsubtype_tape, 2);
521 }
522
523 static int __init iseries_vio_init(void)
524 {
525         struct device_node *vio_root;
526         int ret = -ENODEV;
527
528         if (!firmware_has_feature(FW_FEATURE_ISERIES))
529                 goto out;
530
531         iommu_vio_init();
532
533         vio_root = of_find_node_by_path("/vdevice");
534         if (!vio_root)
535                 goto out;
536
537         if (viopath_hostLp == HvLpIndexInvalid) {
538                 vio_set_hostlp();
539                 /* If we don't have a host, bail out */
540                 if (viopath_hostLp == HvLpIndexInvalid)
541                         goto put_node;
542         }
543
544         get_viodasd_info(vio_root);
545         get_viocd_info(vio_root);
546         get_viotape_info(vio_root);
547
548         ret = 0;
549
550  put_node:
551         of_node_put(vio_root);
552  out:
553         return ret;
554 }
555 arch_initcall(iseries_vio_init);