switch procfs to umode_t use
[linux-2.6.git] / drivers / message / i2o / i2o_proc.c
1 /*
2  *      procfs handler for Linux I2O subsystem
3  *
4  *      (c) Copyright 1999      Deepak Saxena
5  *
6  *      Originally written by Deepak Saxena(deepak@plexity.net)
7  *
8  *      This program is free software; you can redistribute it and/or modify it
9  *      under the terms of the GNU General Public License as published by the
10  *      Free Software Foundation; either version 2 of the License, or (at your
11  *      option) any later version.
12  *
13  *      This is an initial test release. The code is based on the design of the
14  *      ide procfs system (drivers/block/ide-proc.c). Some code taken from
15  *      i2o-core module by Alan Cox.
16  *
17  *      DISCLAIMER: This code is still under development/test and may cause
18  *      your system to behave unpredictably.  Use at your own discretion.
19  *
20  *
21  *      Fixes/additions:
22  *              Juha Sievänen (Juha.Sievanen@cs.Helsinki.FI),
23  *              Auvo Häkkinen (Auvo.Hakkinen@cs.Helsinki.FI)
24  *              University of Helsinki, Department of Computer Science
25  *                      LAN entries
26  *              Markus Lidel <Markus.Lidel@shadowconnect.com>
27  *                      Changes for new I2O API
28  */
29
30 #define OSM_NAME        "proc-osm"
31 #define OSM_VERSION     "1.316"
32 #define OSM_DESCRIPTION "I2O ProcFS OSM"
33
34 #define I2O_MAX_MODULES 4
35 // FIXME!
36 #define FMT_U64_HEX "0x%08x%08x"
37 #define U64_VAL(pu64) *((u32*)(pu64)+1), *((u32*)(pu64))
38
39 #include <linux/types.h>
40 #include <linux/kernel.h>
41 #include <linux/pci.h>
42 #include <linux/i2o.h>
43 #include <linux/slab.h>
44 #include <linux/proc_fs.h>
45 #include <linux/seq_file.h>
46 #include <linux/init.h>
47 #include <linux/module.h>
48 #include <linux/errno.h>
49 #include <linux/spinlock.h>
50 #include <linux/workqueue.h>
51
52 #include <asm/io.h>
53 #include <asm/uaccess.h>
54 #include <asm/byteorder.h>
55
56 /* Structure used to define /proc entries */
57 typedef struct _i2o_proc_entry_t {
58         char *name;             /* entry name */
59         umode_t mode;           /* mode */
60         const struct file_operations *fops;     /* open function */
61 } i2o_proc_entry;
62
63 /* global I2O /proc/i2o entry */
64 static struct proc_dir_entry *i2o_proc_dir_root;
65
66 /* proc OSM driver struct */
67 static struct i2o_driver i2o_proc_driver = {
68         .name = OSM_NAME,
69 };
70
71 static int print_serial_number(struct seq_file *seq, u8 * serialno, int max_len)
72 {
73         int i;
74
75         /* 19990419 -sralston
76          *      The I2O v1.5 (and v2.0 so far) "official specification"
77          *      got serial numbers WRONG!
78          *      Apparently, and despite what Section 3.4.4 says and
79          *      Figure 3-35 shows (pg 3-39 in the pdf doc),
80          *      the convention / consensus seems to be:
81          *        + First byte is SNFormat
82          *        + Second byte is SNLen (but only if SNFormat==7 (?))
83          *        + (v2.0) SCSI+BS may use IEEE Registered (64 or 128 bit) format
84          */
85         switch (serialno[0]) {
86         case I2O_SNFORMAT_BINARY:       /* Binary */
87                 seq_printf(seq, "0x");
88                 for (i = 0; i < serialno[1]; i++) {
89                         seq_printf(seq, "%02X", serialno[2 + i]);
90                 }
91                 break;
92
93         case I2O_SNFORMAT_ASCII:        /* ASCII */
94                 if (serialno[1] < ' ') {        /* printable or SNLen? */
95                         /* sanity */
96                         max_len =
97                             (max_len < serialno[1]) ? max_len : serialno[1];
98                         serialno[1 + max_len] = '\0';
99
100                         /* just print it */
101                         seq_printf(seq, "%s", &serialno[2]);
102                 } else {
103                         /* print chars for specified length */
104                         for (i = 0; i < serialno[1]; i++) {
105                                 seq_printf(seq, "%c", serialno[2 + i]);
106                         }
107                 }
108                 break;
109
110         case I2O_SNFORMAT_UNICODE:      /* UNICODE */
111                 seq_printf(seq, "UNICODE Format.  Can't Display\n");
112                 break;
113
114         case I2O_SNFORMAT_LAN48_MAC:    /* LAN-48 MAC Address */
115                 seq_printf(seq, "LAN-48 MAC address @ %pM", &serialno[2]);
116                 break;
117
118         case I2O_SNFORMAT_WAN:  /* WAN MAC Address */
119                 /* FIXME: Figure out what a WAN access address looks like?? */
120                 seq_printf(seq, "WAN Access Address");
121                 break;
122
123 /* plus new in v2.0 */
124         case I2O_SNFORMAT_LAN64_MAC:    /* LAN-64 MAC Address */
125                 /* FIXME: Figure out what a LAN-64 address really looks like?? */
126                 seq_printf(seq,
127                            "LAN-64 MAC address @ [?:%02X:%02X:?] %pM",
128                            serialno[8], serialno[9], &serialno[2]);
129                 break;
130
131         case I2O_SNFORMAT_DDM:  /* I2O DDM */
132                 seq_printf(seq,
133                            "DDM: Tid=%03Xh, Rsvd=%04Xh, OrgId=%04Xh",
134                            *(u16 *) & serialno[2],
135                            *(u16 *) & serialno[4], *(u16 *) & serialno[6]);
136                 break;
137
138         case I2O_SNFORMAT_IEEE_REG64:   /* IEEE Registered (64-bit) */
139         case I2O_SNFORMAT_IEEE_REG128:  /* IEEE Registered (128-bit) */
140                 /* FIXME: Figure if this is even close?? */
141                 seq_printf(seq,
142                            "IEEE NodeName(hi,lo)=(%08Xh:%08Xh), PortName(hi,lo)=(%08Xh:%08Xh)\n",
143                            *(u32 *) & serialno[2],
144                            *(u32 *) & serialno[6],
145                            *(u32 *) & serialno[10], *(u32 *) & serialno[14]);
146                 break;
147
148         case I2O_SNFORMAT_UNKNOWN:      /* Unknown 0    */
149         case I2O_SNFORMAT_UNKNOWN2:     /* Unknown 0xff */
150         default:
151                 seq_printf(seq, "Unknown data format (0x%02x)", serialno[0]);
152                 break;
153         }
154
155         return 0;
156 }
157
158 /**
159  *      i2o_get_class_name -    do i2o class name lookup
160  *      @class: class number
161  *
162  *      Return a descriptive string for an i2o class.
163  */
164 static const char *i2o_get_class_name(int class)
165 {
166         int idx = 16;
167         static char *i2o_class_name[] = {
168                 "Executive",
169                 "Device Driver Module",
170                 "Block Device",
171                 "Tape Device",
172                 "LAN Interface",
173                 "WAN Interface",
174                 "Fibre Channel Port",
175                 "Fibre Channel Device",
176                 "SCSI Device",
177                 "ATE Port",
178                 "ATE Device",
179                 "Floppy Controller",
180                 "Floppy Device",
181                 "Secondary Bus Port",
182                 "Peer Transport Agent",
183                 "Peer Transport",
184                 "Unknown"
185         };
186
187         switch (class & 0xfff) {
188         case I2O_CLASS_EXECUTIVE:
189                 idx = 0;
190                 break;
191         case I2O_CLASS_DDM:
192                 idx = 1;
193                 break;
194         case I2O_CLASS_RANDOM_BLOCK_STORAGE:
195                 idx = 2;
196                 break;
197         case I2O_CLASS_SEQUENTIAL_STORAGE:
198                 idx = 3;
199                 break;
200         case I2O_CLASS_LAN:
201                 idx = 4;
202                 break;
203         case I2O_CLASS_WAN:
204                 idx = 5;
205                 break;
206         case I2O_CLASS_FIBRE_CHANNEL_PORT:
207                 idx = 6;
208                 break;
209         case I2O_CLASS_FIBRE_CHANNEL_PERIPHERAL:
210                 idx = 7;
211                 break;
212         case I2O_CLASS_SCSI_PERIPHERAL:
213                 idx = 8;
214                 break;
215         case I2O_CLASS_ATE_PORT:
216                 idx = 9;
217                 break;
218         case I2O_CLASS_ATE_PERIPHERAL:
219                 idx = 10;
220                 break;
221         case I2O_CLASS_FLOPPY_CONTROLLER:
222                 idx = 11;
223                 break;
224         case I2O_CLASS_FLOPPY_DEVICE:
225                 idx = 12;
226                 break;
227         case I2O_CLASS_BUS_ADAPTER:
228                 idx = 13;
229                 break;
230         case I2O_CLASS_PEER_TRANSPORT_AGENT:
231                 idx = 14;
232                 break;
233         case I2O_CLASS_PEER_TRANSPORT:
234                 idx = 15;
235                 break;
236         }
237
238         return i2o_class_name[idx];
239 }
240
241 #define SCSI_TABLE_SIZE 13
242 static char *scsi_devices[] = {
243         "Direct-Access Read/Write",
244         "Sequential-Access Storage",
245         "Printer",
246         "Processor",
247         "WORM Device",
248         "CD-ROM Device",
249         "Scanner Device",
250         "Optical Memory Device",
251         "Medium Changer Device",
252         "Communications Device",
253         "Graphics Art Pre-Press Device",
254         "Graphics Art Pre-Press Device",
255         "Array Controller Device"
256 };
257
258 static char *chtostr(u8 * chars, int n)
259 {
260         char tmp[256];
261         tmp[0] = 0;
262         return strncat(tmp, (char *)chars, n);
263 }
264
265 static int i2o_report_query_status(struct seq_file *seq, int block_status,
266                                    char *group)
267 {
268         switch (block_status) {
269         case -ETIMEDOUT:
270                 return seq_printf(seq, "Timeout reading group %s.\n", group);
271         case -ENOMEM:
272                 return seq_printf(seq, "No free memory to read the table.\n");
273         case -I2O_PARAMS_STATUS_INVALID_GROUP_ID:
274                 return seq_printf(seq, "Group %s not supported.\n", group);
275         default:
276                 return seq_printf(seq,
277                                   "Error reading group %s. BlockStatus 0x%02X\n",
278                                   group, -block_status);
279         }
280 }
281
282 static char *bus_strings[] = {
283         "Local Bus",
284         "ISA",
285         "EISA",
286         "MCA",
287         "PCI",
288         "PCMCIA",
289         "NUBUS",
290         "CARDBUS"
291 };
292
293 static int i2o_seq_show_hrt(struct seq_file *seq, void *v)
294 {
295         struct i2o_controller *c = (struct i2o_controller *)seq->private;
296         i2o_hrt *hrt = (i2o_hrt *) c->hrt.virt;
297         u32 bus;
298         int i;
299
300         if (hrt->hrt_version) {
301                 seq_printf(seq,
302                            "HRT table for controller is too new a version.\n");
303                 return 0;
304         }
305
306         seq_printf(seq, "HRT has %d entries of %d bytes each.\n",
307                    hrt->num_entries, hrt->entry_len << 2);
308
309         for (i = 0; i < hrt->num_entries; i++) {
310                 seq_printf(seq, "Entry %d:\n", i);
311                 seq_printf(seq, "   Adapter ID: %0#10x\n",
312                            hrt->hrt_entry[i].adapter_id);
313                 seq_printf(seq, "   Controlling tid: %0#6x\n",
314                            hrt->hrt_entry[i].parent_tid);
315
316                 if (hrt->hrt_entry[i].bus_type != 0x80) {
317                         bus = hrt->hrt_entry[i].bus_type;
318                         seq_printf(seq, "   %s Information\n",
319                                    bus_strings[bus]);
320
321                         switch (bus) {
322                         case I2O_BUS_LOCAL:
323                                 seq_printf(seq, "     IOBase: %0#6x,",
324                                            hrt->hrt_entry[i].bus.local_bus.
325                                            LbBaseIOPort);
326                                 seq_printf(seq, " MemoryBase: %0#10x\n",
327                                            hrt->hrt_entry[i].bus.local_bus.
328                                            LbBaseMemoryAddress);
329                                 break;
330
331                         case I2O_BUS_ISA:
332                                 seq_printf(seq, "     IOBase: %0#6x,",
333                                            hrt->hrt_entry[i].bus.isa_bus.
334                                            IsaBaseIOPort);
335                                 seq_printf(seq, " MemoryBase: %0#10x,",
336                                            hrt->hrt_entry[i].bus.isa_bus.
337                                            IsaBaseMemoryAddress);
338                                 seq_printf(seq, " CSN: %0#4x,",
339                                            hrt->hrt_entry[i].bus.isa_bus.CSN);
340                                 break;
341
342                         case I2O_BUS_EISA:
343                                 seq_printf(seq, "     IOBase: %0#6x,",
344                                            hrt->hrt_entry[i].bus.eisa_bus.
345                                            EisaBaseIOPort);
346                                 seq_printf(seq, " MemoryBase: %0#10x,",
347                                            hrt->hrt_entry[i].bus.eisa_bus.
348                                            EisaBaseMemoryAddress);
349                                 seq_printf(seq, " Slot: %0#4x,",
350                                            hrt->hrt_entry[i].bus.eisa_bus.
351                                            EisaSlotNumber);
352                                 break;
353
354                         case I2O_BUS_MCA:
355                                 seq_printf(seq, "     IOBase: %0#6x,",
356                                            hrt->hrt_entry[i].bus.mca_bus.
357                                            McaBaseIOPort);
358                                 seq_printf(seq, " MemoryBase: %0#10x,",
359                                            hrt->hrt_entry[i].bus.mca_bus.
360                                            McaBaseMemoryAddress);
361                                 seq_printf(seq, " Slot: %0#4x,",
362                                            hrt->hrt_entry[i].bus.mca_bus.
363                                            McaSlotNumber);
364                                 break;
365
366                         case I2O_BUS_PCI:
367                                 seq_printf(seq, "     Bus: %0#4x",
368                                            hrt->hrt_entry[i].bus.pci_bus.
369                                            PciBusNumber);
370                                 seq_printf(seq, " Dev: %0#4x",
371                                            hrt->hrt_entry[i].bus.pci_bus.
372                                            PciDeviceNumber);
373                                 seq_printf(seq, " Func: %0#4x",
374                                            hrt->hrt_entry[i].bus.pci_bus.
375                                            PciFunctionNumber);
376                                 seq_printf(seq, " Vendor: %0#6x",
377                                            hrt->hrt_entry[i].bus.pci_bus.
378                                            PciVendorID);
379                                 seq_printf(seq, " Device: %0#6x\n",
380                                            hrt->hrt_entry[i].bus.pci_bus.
381                                            PciDeviceID);
382                                 break;
383
384                         default:
385                                 seq_printf(seq, "      Unsupported Bus Type\n");
386                         }
387                 } else
388                         seq_printf(seq, "   Unknown Bus Type\n");
389         }
390
391         return 0;
392 }
393
394 static int i2o_seq_show_lct(struct seq_file *seq, void *v)
395 {
396         struct i2o_controller *c = (struct i2o_controller *)seq->private;
397         i2o_lct *lct = (i2o_lct *) c->lct;
398         int entries;
399         int i;
400
401 #define BUS_TABLE_SIZE 3
402         static char *bus_ports[] = {
403                 "Generic Bus",
404                 "SCSI Bus",
405                 "Fibre Channel Bus"
406         };
407
408         entries = (lct->table_size - 3) / 9;
409
410         seq_printf(seq, "LCT contains %d %s\n", entries,
411                    entries == 1 ? "entry" : "entries");
412         if (lct->boot_tid)
413                 seq_printf(seq, "Boot Device @ ID %d\n", lct->boot_tid);
414
415         seq_printf(seq, "Current Change Indicator: %#10x\n", lct->change_ind);
416
417         for (i = 0; i < entries; i++) {
418                 seq_printf(seq, "Entry %d\n", i);
419                 seq_printf(seq, "  Class, SubClass  : %s",
420                            i2o_get_class_name(lct->lct_entry[i].class_id));
421
422                 /*
423                  *      Classes which we'll print subclass info for
424                  */
425                 switch (lct->lct_entry[i].class_id & 0xFFF) {
426                 case I2O_CLASS_RANDOM_BLOCK_STORAGE:
427                         switch (lct->lct_entry[i].sub_class) {
428                         case 0x00:
429                                 seq_printf(seq, ", Direct-Access Read/Write");
430                                 break;
431
432                         case 0x04:
433                                 seq_printf(seq, ", WORM Drive");
434                                 break;
435
436                         case 0x05:
437                                 seq_printf(seq, ", CD-ROM Drive");
438                                 break;
439
440                         case 0x07:
441                                 seq_printf(seq, ", Optical Memory Device");
442                                 break;
443
444                         default:
445                                 seq_printf(seq, ", Unknown (0x%02x)",
446                                            lct->lct_entry[i].sub_class);
447                                 break;
448                         }
449                         break;
450
451                 case I2O_CLASS_LAN:
452                         switch (lct->lct_entry[i].sub_class & 0xFF) {
453                         case 0x30:
454                                 seq_printf(seq, ", Ethernet");
455                                 break;
456
457                         case 0x40:
458                                 seq_printf(seq, ", 100base VG");
459                                 break;
460
461                         case 0x50:
462                                 seq_printf(seq, ", IEEE 802.5/Token-Ring");
463                                 break;
464
465                         case 0x60:
466                                 seq_printf(seq, ", ANSI X3T9.5 FDDI");
467                                 break;
468
469                         case 0x70:
470                                 seq_printf(seq, ", Fibre Channel");
471                                 break;
472
473                         default:
474                                 seq_printf(seq, ", Unknown Sub-Class (0x%02x)",
475                                            lct->lct_entry[i].sub_class & 0xFF);
476                                 break;
477                         }
478                         break;
479
480                 case I2O_CLASS_SCSI_PERIPHERAL:
481                         if (lct->lct_entry[i].sub_class < SCSI_TABLE_SIZE)
482                                 seq_printf(seq, ", %s",
483                                            scsi_devices[lct->lct_entry[i].
484                                                         sub_class]);
485                         else
486                                 seq_printf(seq, ", Unknown Device Type");
487                         break;
488
489                 case I2O_CLASS_BUS_ADAPTER:
490                         if (lct->lct_entry[i].sub_class < BUS_TABLE_SIZE)
491                                 seq_printf(seq, ", %s",
492                                            bus_ports[lct->lct_entry[i].
493                                                      sub_class]);
494                         else
495                                 seq_printf(seq, ", Unknown Bus Type");
496                         break;
497                 }
498                 seq_printf(seq, "\n");
499
500                 seq_printf(seq, "  Local TID        : 0x%03x\n",
501                            lct->lct_entry[i].tid);
502                 seq_printf(seq, "  User TID         : 0x%03x\n",
503                            lct->lct_entry[i].user_tid);
504                 seq_printf(seq, "  Parent TID       : 0x%03x\n",
505                            lct->lct_entry[i].parent_tid);
506                 seq_printf(seq, "  Identity Tag     : 0x%x%x%x%x%x%x%x%x\n",
507                            lct->lct_entry[i].identity_tag[0],
508                            lct->lct_entry[i].identity_tag[1],
509                            lct->lct_entry[i].identity_tag[2],
510                            lct->lct_entry[i].identity_tag[3],
511                            lct->lct_entry[i].identity_tag[4],
512                            lct->lct_entry[i].identity_tag[5],
513                            lct->lct_entry[i].identity_tag[6],
514                            lct->lct_entry[i].identity_tag[7]);
515                 seq_printf(seq, "  Change Indicator : %0#10x\n",
516                            lct->lct_entry[i].change_ind);
517                 seq_printf(seq, "  Event Capab Mask : %0#10x\n",
518                            lct->lct_entry[i].device_flags);
519         }
520
521         return 0;
522 }
523
524 static int i2o_seq_show_status(struct seq_file *seq, void *v)
525 {
526         struct i2o_controller *c = (struct i2o_controller *)seq->private;
527         char prodstr[25];
528         int version;
529         i2o_status_block *sb = c->status_block.virt;
530
531         i2o_status_get(c);      // reread the status block
532
533         seq_printf(seq, "Organization ID        : %0#6x\n", sb->org_id);
534
535         version = sb->i2o_version;
536
537 /* FIXME for Spec 2.0
538         if (version == 0x02) {
539                 seq_printf(seq, "Lowest I2O version supported: ");
540                 switch(workspace[2]) {
541                         case 0x00:
542                                 seq_printf(seq, "1.0\n");
543                                 break;
544                         case 0x01:
545                                 seq_printf(seq, "1.5\n");
546                                 break;
547                         case 0x02:
548                                 seq_printf(seq, "2.0\n");
549                                 break;
550                 }
551
552                 seq_printf(seq, "Highest I2O version supported: ");
553                 switch(workspace[3]) {
554                         case 0x00:
555                                 seq_printf(seq, "1.0\n");
556                                 break;
557                         case 0x01:
558                                 seq_printf(seq, "1.5\n");
559                                 break;
560                         case 0x02:
561                                 seq_printf(seq, "2.0\n");
562                                 break;
563                 }
564         }
565 */
566         seq_printf(seq, "IOP ID                 : %0#5x\n", sb->iop_id);
567         seq_printf(seq, "Host Unit ID           : %0#6x\n", sb->host_unit_id);
568         seq_printf(seq, "Segment Number         : %0#5x\n", sb->segment_number);
569
570         seq_printf(seq, "I2O version            : ");
571         switch (version) {
572         case 0x00:
573                 seq_printf(seq, "1.0\n");
574                 break;
575         case 0x01:
576                 seq_printf(seq, "1.5\n");
577                 break;
578         case 0x02:
579                 seq_printf(seq, "2.0\n");
580                 break;
581         default:
582                 seq_printf(seq, "Unknown version\n");
583         }
584
585         seq_printf(seq, "IOP State              : ");
586         switch (sb->iop_state) {
587         case 0x01:
588                 seq_printf(seq, "INIT\n");
589                 break;
590
591         case 0x02:
592                 seq_printf(seq, "RESET\n");
593                 break;
594
595         case 0x04:
596                 seq_printf(seq, "HOLD\n");
597                 break;
598
599         case 0x05:
600                 seq_printf(seq, "READY\n");
601                 break;
602
603         case 0x08:
604                 seq_printf(seq, "OPERATIONAL\n");
605                 break;
606
607         case 0x10:
608                 seq_printf(seq, "FAILED\n");
609                 break;
610
611         case 0x11:
612                 seq_printf(seq, "FAULTED\n");
613                 break;
614
615         default:
616                 seq_printf(seq, "Unknown\n");
617                 break;
618         }
619
620         seq_printf(seq, "Messenger Type         : ");
621         switch (sb->msg_type) {
622         case 0x00:
623                 seq_printf(seq, "Memory mapped\n");
624                 break;
625         case 0x01:
626                 seq_printf(seq, "Memory mapped only\n");
627                 break;
628         case 0x02:
629                 seq_printf(seq, "Remote only\n");
630                 break;
631         case 0x03:
632                 seq_printf(seq, "Memory mapped and remote\n");
633                 break;
634         default:
635                 seq_printf(seq, "Unknown\n");
636         }
637
638         seq_printf(seq, "Inbound Frame Size     : %d bytes\n",
639                    sb->inbound_frame_size << 2);
640         seq_printf(seq, "Max Inbound Frames     : %d\n",
641                    sb->max_inbound_frames);
642         seq_printf(seq, "Current Inbound Frames : %d\n",
643                    sb->cur_inbound_frames);
644         seq_printf(seq, "Max Outbound Frames    : %d\n",
645                    sb->max_outbound_frames);
646
647         /* Spec doesn't say if NULL terminated or not... */
648         memcpy(prodstr, sb->product_id, 24);
649         prodstr[24] = '\0';
650         seq_printf(seq, "Product ID             : %s\n", prodstr);
651         seq_printf(seq, "Expected LCT Size      : %d bytes\n",
652                    sb->expected_lct_size);
653
654         seq_printf(seq, "IOP Capabilities\n");
655         seq_printf(seq, "    Context Field Size Support : ");
656         switch (sb->iop_capabilities & 0x0000003) {
657         case 0:
658                 seq_printf(seq, "Supports only 32-bit context fields\n");
659                 break;
660         case 1:
661                 seq_printf(seq, "Supports only 64-bit context fields\n");
662                 break;
663         case 2:
664                 seq_printf(seq, "Supports 32-bit and 64-bit context fields, "
665                            "but not concurrently\n");
666                 break;
667         case 3:
668                 seq_printf(seq, "Supports 32-bit and 64-bit context fields "
669                            "concurrently\n");
670                 break;
671         default:
672                 seq_printf(seq, "0x%08x\n", sb->iop_capabilities);
673         }
674         seq_printf(seq, "    Current Context Field Size : ");
675         switch (sb->iop_capabilities & 0x0000000C) {
676         case 0:
677                 seq_printf(seq, "not configured\n");
678                 break;
679         case 4:
680                 seq_printf(seq, "Supports only 32-bit context fields\n");
681                 break;
682         case 8:
683                 seq_printf(seq, "Supports only 64-bit context fields\n");
684                 break;
685         case 12:
686                 seq_printf(seq, "Supports both 32-bit or 64-bit context fields "
687                            "concurrently\n");
688                 break;
689         default:
690                 seq_printf(seq, "\n");
691         }
692         seq_printf(seq, "    Inbound Peer Support       : %s\n",
693                    (sb->
694                     iop_capabilities & 0x00000010) ? "Supported" :
695                    "Not supported");
696         seq_printf(seq, "    Outbound Peer Support      : %s\n",
697                    (sb->
698                     iop_capabilities & 0x00000020) ? "Supported" :
699                    "Not supported");
700         seq_printf(seq, "    Peer to Peer Support       : %s\n",
701                    (sb->
702                     iop_capabilities & 0x00000040) ? "Supported" :
703                    "Not supported");
704
705         seq_printf(seq, "Desired private memory size   : %d kB\n",
706                    sb->desired_mem_size >> 10);
707         seq_printf(seq, "Allocated private memory size : %d kB\n",
708                    sb->current_mem_size >> 10);
709         seq_printf(seq, "Private memory base address   : %0#10x\n",
710                    sb->current_mem_base);
711         seq_printf(seq, "Desired private I/O size      : %d kB\n",
712                    sb->desired_io_size >> 10);
713         seq_printf(seq, "Allocated private I/O size    : %d kB\n",
714                    sb->current_io_size >> 10);
715         seq_printf(seq, "Private I/O base address      : %0#10x\n",
716                    sb->current_io_base);
717
718         return 0;
719 }
720
721 static int i2o_seq_show_hw(struct seq_file *seq, void *v)
722 {
723         struct i2o_controller *c = (struct i2o_controller *)seq->private;
724         static u32 work32[5];
725         static u8 *work8 = (u8 *) work32;
726         static u16 *work16 = (u16 *) work32;
727         int token;
728         u32 hwcap;
729
730         static char *cpu_table[] = {
731                 "Intel 80960 series",
732                 "AMD2900 series",
733                 "Motorola 68000 series",
734                 "ARM series",
735                 "MIPS series",
736                 "Sparc series",
737                 "PowerPC series",
738                 "Intel x86 series"
739         };
740
741         token =
742             i2o_parm_field_get(c->exec, 0x0000, -1, &work32, sizeof(work32));
743
744         if (token < 0) {
745                 i2o_report_query_status(seq, token, "0x0000 IOP Hardware");
746                 return 0;
747         }
748
749         seq_printf(seq, "I2O Vendor ID    : %0#6x\n", work16[0]);
750         seq_printf(seq, "Product ID       : %0#6x\n", work16[1]);
751         seq_printf(seq, "CPU              : ");
752         if (work8[16] > 8)
753                 seq_printf(seq, "Unknown\n");
754         else
755                 seq_printf(seq, "%s\n", cpu_table[work8[16]]);
756         /* Anyone using ProcessorVersion? */
757
758         seq_printf(seq, "RAM              : %dkB\n", work32[1] >> 10);
759         seq_printf(seq, "Non-Volatile Mem : %dkB\n", work32[2] >> 10);
760
761         hwcap = work32[3];
762         seq_printf(seq, "Capabilities : 0x%08x\n", hwcap);
763         seq_printf(seq, "   [%s] Self booting\n",
764                    (hwcap & 0x00000001) ? "+" : "-");
765         seq_printf(seq, "   [%s] Upgradable IRTOS\n",
766                    (hwcap & 0x00000002) ? "+" : "-");
767         seq_printf(seq, "   [%s] Supports downloading DDMs\n",
768                    (hwcap & 0x00000004) ? "+" : "-");
769         seq_printf(seq, "   [%s] Supports installing DDMs\n",
770                    (hwcap & 0x00000008) ? "+" : "-");
771         seq_printf(seq, "   [%s] Battery-backed RAM\n",
772                    (hwcap & 0x00000010) ? "+" : "-");
773
774         return 0;
775 }
776
777 /* Executive group 0003h - Executing DDM List (table) */
778 static int i2o_seq_show_ddm_table(struct seq_file *seq, void *v)
779 {
780         struct i2o_controller *c = (struct i2o_controller *)seq->private;
781         int token;
782         int i;
783
784         typedef struct _i2o_exec_execute_ddm_table {
785                 u16 ddm_tid;
786                 u8 module_type;
787                 u8 reserved;
788                 u16 i2o_vendor_id;
789                 u16 module_id;
790                 u8 module_name_version[28];
791                 u32 data_size;
792                 u32 code_size;
793         } i2o_exec_execute_ddm_table;
794
795         struct {
796                 u16 result_count;
797                 u16 pad;
798                 u16 block_size;
799                 u8 block_status;
800                 u8 error_info_size;
801                 u16 row_count;
802                 u16 more_flag;
803                 i2o_exec_execute_ddm_table ddm_table[I2O_MAX_MODULES];
804         } *result;
805
806         i2o_exec_execute_ddm_table ddm_table;
807
808         result = kmalloc(sizeof(*result), GFP_KERNEL);
809         if (!result)
810                 return -ENOMEM;
811
812         token = i2o_parm_table_get(c->exec, I2O_PARAMS_TABLE_GET, 0x0003, -1,
813                                    NULL, 0, result, sizeof(*result));
814
815         if (token < 0) {
816                 i2o_report_query_status(seq, token,
817                                         "0x0003 Executing DDM List");
818                 goto out;
819         }
820
821         seq_printf(seq,
822                    "Tid   Module_type     Vendor Mod_id  Module_name             Vrs  Data_size Code_size\n");
823         ddm_table = result->ddm_table[0];
824
825         for (i = 0; i < result->row_count; ddm_table = result->ddm_table[++i]) {
826                 seq_printf(seq, "0x%03x ", ddm_table.ddm_tid & 0xFFF);
827
828                 switch (ddm_table.module_type) {
829                 case 0x01:
830                         seq_printf(seq, "Downloaded DDM  ");
831                         break;
832                 case 0x22:
833                         seq_printf(seq, "Embedded DDM    ");
834                         break;
835                 default:
836                         seq_printf(seq, "                ");
837                 }
838
839                 seq_printf(seq, "%-#7x", ddm_table.i2o_vendor_id);
840                 seq_printf(seq, "%-#8x", ddm_table.module_id);
841                 seq_printf(seq, "%-29s",
842                            chtostr(ddm_table.module_name_version, 28));
843                 seq_printf(seq, "%9d  ", ddm_table.data_size);
844                 seq_printf(seq, "%8d", ddm_table.code_size);
845
846                 seq_printf(seq, "\n");
847         }
848       out:
849         kfree(result);
850         return 0;
851 }
852
853 /* Executive group 0004h - Driver Store (scalar) */
854 static int i2o_seq_show_driver_store(struct seq_file *seq, void *v)
855 {
856         struct i2o_controller *c = (struct i2o_controller *)seq->private;
857         u32 work32[8];
858         int token;
859
860         token =
861             i2o_parm_field_get(c->exec, 0x0004, -1, &work32, sizeof(work32));
862         if (token < 0) {
863                 i2o_report_query_status(seq, token, "0x0004 Driver Store");
864                 return 0;
865         }
866
867         seq_printf(seq, "Module limit  : %d\n"
868                    "Module count  : %d\n"
869                    "Current space : %d kB\n"
870                    "Free space    : %d kB\n",
871                    work32[0], work32[1], work32[2] >> 10, work32[3] >> 10);
872
873         return 0;
874 }
875
876 /* Executive group 0005h - Driver Store Table (table) */
877 static int i2o_seq_show_drivers_stored(struct seq_file *seq, void *v)
878 {
879         typedef struct _i2o_driver_store {
880                 u16 stored_ddm_index;
881                 u8 module_type;
882                 u8 reserved;
883                 u16 i2o_vendor_id;
884                 u16 module_id;
885                 u8 module_name_version[28];
886                 u8 date[8];
887                 u32 module_size;
888                 u32 mpb_size;
889                 u32 module_flags;
890         } i2o_driver_store_table;
891
892         struct i2o_controller *c = (struct i2o_controller *)seq->private;
893         int token;
894         int i;
895
896         typedef struct {
897                 u16 result_count;
898                 u16 pad;
899                 u16 block_size;
900                 u8 block_status;
901                 u8 error_info_size;
902                 u16 row_count;
903                 u16 more_flag;
904                 i2o_driver_store_table dst[I2O_MAX_MODULES];
905         } i2o_driver_result_table;
906
907         i2o_driver_result_table *result;
908         i2o_driver_store_table *dst;
909
910         result = kmalloc(sizeof(i2o_driver_result_table), GFP_KERNEL);
911         if (result == NULL)
912                 return -ENOMEM;
913
914         token = i2o_parm_table_get(c->exec, I2O_PARAMS_TABLE_GET, 0x0005, -1,
915                                    NULL, 0, result, sizeof(*result));
916
917         if (token < 0) {
918                 i2o_report_query_status(seq, token,
919                                         "0x0005 DRIVER STORE TABLE");
920                 kfree(result);
921                 return 0;
922         }
923
924         seq_printf(seq,
925                    "#  Module_type     Vendor Mod_id  Module_name             Vrs"
926                    "Date     Mod_size Par_size Flags\n");
927         for (i = 0, dst = &result->dst[0]; i < result->row_count;
928              dst = &result->dst[++i]) {
929                 seq_printf(seq, "%-3d", dst->stored_ddm_index);
930                 switch (dst->module_type) {
931                 case 0x01:
932                         seq_printf(seq, "Downloaded DDM  ");
933                         break;
934                 case 0x22:
935                         seq_printf(seq, "Embedded DDM    ");
936                         break;
937                 default:
938                         seq_printf(seq, "                ");
939                 }
940
941                 seq_printf(seq, "%-#7x", dst->i2o_vendor_id);
942                 seq_printf(seq, "%-#8x", dst->module_id);
943                 seq_printf(seq, "%-29s", chtostr(dst->module_name_version, 28));
944                 seq_printf(seq, "%-9s", chtostr(dst->date, 8));
945                 seq_printf(seq, "%8d ", dst->module_size);
946                 seq_printf(seq, "%8d ", dst->mpb_size);
947                 seq_printf(seq, "0x%04x", dst->module_flags);
948                 seq_printf(seq, "\n");
949         }
950
951         kfree(result);
952         return 0;
953 }
954
955 /* Generic group F000h - Params Descriptor (table) */
956 static int i2o_seq_show_groups(struct seq_file *seq, void *v)
957 {
958         struct i2o_device *d = (struct i2o_device *)seq->private;
959         int token;
960         int i;
961         u8 properties;
962
963         typedef struct _i2o_group_info {
964                 u16 group_number;
965                 u16 field_count;
966                 u16 row_count;
967                 u8 properties;
968                 u8 reserved;
969         } i2o_group_info;
970
971         struct {
972                 u16 result_count;
973                 u16 pad;
974                 u16 block_size;
975                 u8 block_status;
976                 u8 error_info_size;
977                 u16 row_count;
978                 u16 more_flag;
979                 i2o_group_info group[256];
980         } *result;
981
982         result = kmalloc(sizeof(*result), GFP_KERNEL);
983         if (!result)
984                 return -ENOMEM;
985
986         token = i2o_parm_table_get(d, I2O_PARAMS_TABLE_GET, 0xF000, -1, NULL, 0,
987                                    result, sizeof(*result));
988
989         if (token < 0) {
990                 i2o_report_query_status(seq, token, "0xF000 Params Descriptor");
991                 goto out;
992         }
993
994         seq_printf(seq,
995                    "#  Group   FieldCount RowCount Type   Add Del Clear\n");
996
997         for (i = 0; i < result->row_count; i++) {
998                 seq_printf(seq, "%-3d", i);
999                 seq_printf(seq, "0x%04X ", result->group[i].group_number);
1000                 seq_printf(seq, "%10d ", result->group[i].field_count);
1001                 seq_printf(seq, "%8d ", result->group[i].row_count);
1002
1003                 properties = result->group[i].properties;
1004                 if (properties & 0x1)
1005                         seq_printf(seq, "Table  ");
1006                 else
1007                         seq_printf(seq, "Scalar ");
1008                 if (properties & 0x2)
1009                         seq_printf(seq, " + ");
1010                 else
1011                         seq_printf(seq, " - ");
1012                 if (properties & 0x4)
1013                         seq_printf(seq, "  + ");
1014                 else
1015                         seq_printf(seq, "  - ");
1016                 if (properties & 0x8)
1017                         seq_printf(seq, "  + ");
1018                 else
1019                         seq_printf(seq, "  - ");
1020
1021                 seq_printf(seq, "\n");
1022         }
1023
1024         if (result->more_flag)
1025                 seq_printf(seq, "There is more...\n");
1026       out:
1027         kfree(result);
1028         return 0;
1029 }
1030
1031 /* Generic group F001h - Physical Device Table (table) */
1032 static int i2o_seq_show_phys_device(struct seq_file *seq, void *v)
1033 {
1034         struct i2o_device *d = (struct i2o_device *)seq->private;
1035         int token;
1036         int i;
1037
1038         struct {
1039                 u16 result_count;
1040                 u16 pad;
1041                 u16 block_size;
1042                 u8 block_status;
1043                 u8 error_info_size;
1044                 u16 row_count;
1045                 u16 more_flag;
1046                 u32 adapter_id[64];
1047         } result;
1048
1049         token = i2o_parm_table_get(d, I2O_PARAMS_TABLE_GET, 0xF001, -1, NULL, 0,
1050                                    &result, sizeof(result));
1051
1052         if (token < 0) {
1053                 i2o_report_query_status(seq, token,
1054                                         "0xF001 Physical Device Table");
1055                 return 0;
1056         }
1057
1058         if (result.row_count)
1059                 seq_printf(seq, "#  AdapterId\n");
1060
1061         for (i = 0; i < result.row_count; i++) {
1062                 seq_printf(seq, "%-2d", i);
1063                 seq_printf(seq, "%#7x\n", result.adapter_id[i]);
1064         }
1065
1066         if (result.more_flag)
1067                 seq_printf(seq, "There is more...\n");
1068
1069         return 0;
1070 }
1071
1072 /* Generic group F002h - Claimed Table (table) */
1073 static int i2o_seq_show_claimed(struct seq_file *seq, void *v)
1074 {
1075         struct i2o_device *d = (struct i2o_device *)seq->private;
1076         int token;
1077         int i;
1078
1079         struct {
1080                 u16 result_count;
1081                 u16 pad;
1082                 u16 block_size;
1083                 u8 block_status;
1084                 u8 error_info_size;
1085                 u16 row_count;
1086                 u16 more_flag;
1087                 u16 claimed_tid[64];
1088         } result;
1089
1090         token = i2o_parm_table_get(d, I2O_PARAMS_TABLE_GET, 0xF002, -1, NULL, 0,
1091                                    &result, sizeof(result));
1092
1093         if (token < 0) {
1094                 i2o_report_query_status(seq, token, "0xF002 Claimed Table");
1095                 return 0;
1096         }
1097
1098         if (result.row_count)
1099                 seq_printf(seq, "#  ClaimedTid\n");
1100
1101         for (i = 0; i < result.row_count; i++) {
1102                 seq_printf(seq, "%-2d", i);
1103                 seq_printf(seq, "%#7x\n", result.claimed_tid[i]);
1104         }
1105
1106         if (result.more_flag)
1107                 seq_printf(seq, "There is more...\n");
1108
1109         return 0;
1110 }
1111
1112 /* Generic group F003h - User Table (table) */
1113 static int i2o_seq_show_users(struct seq_file *seq, void *v)
1114 {
1115         struct i2o_device *d = (struct i2o_device *)seq->private;
1116         int token;
1117         int i;
1118
1119         typedef struct _i2o_user_table {
1120                 u16 instance;
1121                 u16 user_tid;
1122                 u8 claim_type;
1123                 u8 reserved1;
1124                 u16 reserved2;
1125         } i2o_user_table;
1126
1127         struct {
1128                 u16 result_count;
1129                 u16 pad;
1130                 u16 block_size;
1131                 u8 block_status;
1132                 u8 error_info_size;
1133                 u16 row_count;
1134                 u16 more_flag;
1135                 i2o_user_table user[64];
1136         } *result;
1137
1138         result = kmalloc(sizeof(*result), GFP_KERNEL);
1139         if (!result)
1140                 return -ENOMEM;
1141
1142         token = i2o_parm_table_get(d, I2O_PARAMS_TABLE_GET, 0xF003, -1, NULL, 0,
1143                                    result, sizeof(*result));
1144
1145         if (token < 0) {
1146                 i2o_report_query_status(seq, token, "0xF003 User Table");
1147                 goto out;
1148         }
1149
1150         seq_printf(seq, "#  Instance UserTid ClaimType\n");
1151
1152         for (i = 0; i < result->row_count; i++) {
1153                 seq_printf(seq, "%-3d", i);
1154                 seq_printf(seq, "%#8x ", result->user[i].instance);
1155                 seq_printf(seq, "%#7x ", result->user[i].user_tid);
1156                 seq_printf(seq, "%#9x\n", result->user[i].claim_type);
1157         }
1158
1159         if (result->more_flag)
1160                 seq_printf(seq, "There is more...\n");
1161       out:
1162         kfree(result);
1163         return 0;
1164 }
1165
1166 /* Generic group F005h - Private message extensions (table) (optional) */
1167 static int i2o_seq_show_priv_msgs(struct seq_file *seq, void *v)
1168 {
1169         struct i2o_device *d = (struct i2o_device *)seq->private;
1170         int token;
1171         int i;
1172
1173         typedef struct _i2o_private {
1174                 u16 ext_instance;
1175                 u16 organization_id;
1176                 u16 x_function_code;
1177         } i2o_private;
1178
1179         struct {
1180                 u16 result_count;
1181                 u16 pad;
1182                 u16 block_size;
1183                 u8 block_status;
1184                 u8 error_info_size;
1185                 u16 row_count;
1186                 u16 more_flag;
1187                 i2o_private extension[64];
1188         } result;
1189
1190         token = i2o_parm_table_get(d, I2O_PARAMS_TABLE_GET, 0xF000, -1, NULL, 0,
1191                                    &result, sizeof(result));
1192
1193         if (token < 0) {
1194                 i2o_report_query_status(seq, token,
1195                                         "0xF005 Private Message Extensions (optional)");
1196                 return 0;
1197         }
1198
1199         seq_printf(seq, "Instance#  OrgId  FunctionCode\n");
1200
1201         for (i = 0; i < result.row_count; i++) {
1202                 seq_printf(seq, "%0#9x ", result.extension[i].ext_instance);
1203                 seq_printf(seq, "%0#6x ", result.extension[i].organization_id);
1204                 seq_printf(seq, "%0#6x", result.extension[i].x_function_code);
1205
1206                 seq_printf(seq, "\n");
1207         }
1208
1209         if (result.more_flag)
1210                 seq_printf(seq, "There is more...\n");
1211
1212         return 0;
1213 }
1214
1215 /* Generic group F006h - Authorized User Table (table) */
1216 static int i2o_seq_show_authorized_users(struct seq_file *seq, void *v)
1217 {
1218         struct i2o_device *d = (struct i2o_device *)seq->private;
1219         int token;
1220         int i;
1221
1222         struct {
1223                 u16 result_count;
1224                 u16 pad;
1225                 u16 block_size;
1226                 u8 block_status;
1227                 u8 error_info_size;
1228                 u16 row_count;
1229                 u16 more_flag;
1230                 u32 alternate_tid[64];
1231         } result;
1232
1233         token = i2o_parm_table_get(d, I2O_PARAMS_TABLE_GET, 0xF006, -1, NULL, 0,
1234                                    &result, sizeof(result));
1235
1236         if (token < 0) {
1237                 i2o_report_query_status(seq, token,
1238                                         "0xF006 Autohorized User Table");
1239                 return 0;
1240         }
1241
1242         if (result.row_count)
1243                 seq_printf(seq, "#  AlternateTid\n");
1244
1245         for (i = 0; i < result.row_count; i++) {
1246                 seq_printf(seq, "%-2d", i);
1247                 seq_printf(seq, "%#7x ", result.alternate_tid[i]);
1248         }
1249
1250         if (result.more_flag)
1251                 seq_printf(seq, "There is more...\n");
1252
1253         return 0;
1254 }
1255
1256 /* Generic group F100h - Device Identity (scalar) */
1257 static int i2o_seq_show_dev_identity(struct seq_file *seq, void *v)
1258 {
1259         struct i2o_device *d = (struct i2o_device *)seq->private;
1260         static u32 work32[128]; // allow for "stuff" + up to 256 byte (max) serial number
1261         // == (allow) 512d bytes (max)
1262         static u16 *work16 = (u16 *) work32;
1263         int token;
1264
1265         token = i2o_parm_field_get(d, 0xF100, -1, &work32, sizeof(work32));
1266
1267         if (token < 0) {
1268                 i2o_report_query_status(seq, token, "0xF100 Device Identity");
1269                 return 0;
1270         }
1271
1272         seq_printf(seq, "Device Class  : %s\n", i2o_get_class_name(work16[0]));
1273         seq_printf(seq, "Owner TID     : %0#5x\n", work16[2]);
1274         seq_printf(seq, "Parent TID    : %0#5x\n", work16[3]);
1275         seq_printf(seq, "Vendor info   : %s\n",
1276                    chtostr((u8 *) (work32 + 2), 16));
1277         seq_printf(seq, "Product info  : %s\n",
1278                    chtostr((u8 *) (work32 + 6), 16));
1279         seq_printf(seq, "Description   : %s\n",
1280                    chtostr((u8 *) (work32 + 10), 16));
1281         seq_printf(seq, "Product rev.  : %s\n",
1282                    chtostr((u8 *) (work32 + 14), 8));
1283
1284         seq_printf(seq, "Serial number : ");
1285         print_serial_number(seq, (u8 *) (work32 + 16),
1286                             /* allow for SNLen plus
1287                              * possible trailing '\0'
1288                              */
1289                             sizeof(work32) - (16 * sizeof(u32)) - 2);
1290         seq_printf(seq, "\n");
1291
1292         return 0;
1293 }
1294
1295 static int i2o_seq_show_dev_name(struct seq_file *seq, void *v)
1296 {
1297         struct i2o_device *d = (struct i2o_device *)seq->private;
1298
1299         seq_printf(seq, "%s\n", dev_name(&d->device));
1300
1301         return 0;
1302 }
1303
1304 /* Generic group F101h - DDM Identity (scalar) */
1305 static int i2o_seq_show_ddm_identity(struct seq_file *seq, void *v)
1306 {
1307         struct i2o_device *d = (struct i2o_device *)seq->private;
1308         int token;
1309
1310         struct {
1311                 u16 ddm_tid;
1312                 u8 module_name[24];
1313                 u8 module_rev[8];
1314                 u8 sn_format;
1315                 u8 serial_number[12];
1316                 u8 pad[256];    // allow up to 256 byte (max) serial number
1317         } result;
1318
1319         token = i2o_parm_field_get(d, 0xF101, -1, &result, sizeof(result));
1320
1321         if (token < 0) {
1322                 i2o_report_query_status(seq, token, "0xF101 DDM Identity");
1323                 return 0;
1324         }
1325
1326         seq_printf(seq, "Registering DDM TID : 0x%03x\n", result.ddm_tid);
1327         seq_printf(seq, "Module name         : %s\n",
1328                    chtostr(result.module_name, 24));
1329         seq_printf(seq, "Module revision     : %s\n",
1330                    chtostr(result.module_rev, 8));
1331
1332         seq_printf(seq, "Serial number       : ");
1333         print_serial_number(seq, result.serial_number, sizeof(result) - 36);
1334         /* allow for SNLen plus possible trailing '\0' */
1335
1336         seq_printf(seq, "\n");
1337
1338         return 0;
1339 }
1340
1341 /* Generic group F102h - User Information (scalar) */
1342 static int i2o_seq_show_uinfo(struct seq_file *seq, void *v)
1343 {
1344         struct i2o_device *d = (struct i2o_device *)seq->private;
1345         int token;
1346
1347         struct {
1348                 u8 device_name[64];
1349                 u8 service_name[64];
1350                 u8 physical_location[64];
1351                 u8 instance_number[4];
1352         } result;
1353
1354         token = i2o_parm_field_get(d, 0xF102, -1, &result, sizeof(result));
1355
1356         if (token < 0) {
1357                 i2o_report_query_status(seq, token, "0xF102 User Information");
1358                 return 0;
1359         }
1360
1361         seq_printf(seq, "Device name     : %s\n",
1362                    chtostr(result.device_name, 64));
1363         seq_printf(seq, "Service name    : %s\n",
1364                    chtostr(result.service_name, 64));
1365         seq_printf(seq, "Physical name   : %s\n",
1366                    chtostr(result.physical_location, 64));
1367         seq_printf(seq, "Instance number : %s\n",
1368                    chtostr(result.instance_number, 4));
1369
1370         return 0;
1371 }
1372
1373 /* Generic group F103h - SGL Operating Limits (scalar) */
1374 static int i2o_seq_show_sgl_limits(struct seq_file *seq, void *v)
1375 {
1376         struct i2o_device *d = (struct i2o_device *)seq->private;
1377         static u32 work32[12];
1378         static u16 *work16 = (u16 *) work32;
1379         static u8 *work8 = (u8 *) work32;
1380         int token;
1381
1382         token = i2o_parm_field_get(d, 0xF103, -1, &work32, sizeof(work32));
1383
1384         if (token < 0) {
1385                 i2o_report_query_status(seq, token,
1386                                         "0xF103 SGL Operating Limits");
1387                 return 0;
1388         }
1389
1390         seq_printf(seq, "SGL chain size        : %d\n", work32[0]);
1391         seq_printf(seq, "Max SGL chain size    : %d\n", work32[1]);
1392         seq_printf(seq, "SGL chain size target : %d\n", work32[2]);
1393         seq_printf(seq, "SGL frag count        : %d\n", work16[6]);
1394         seq_printf(seq, "Max SGL frag count    : %d\n", work16[7]);
1395         seq_printf(seq, "SGL frag count target : %d\n", work16[8]);
1396
1397 /* FIXME
1398         if (d->i2oversion == 0x02)
1399         {
1400 */
1401         seq_printf(seq, "SGL data alignment    : %d\n", work16[8]);
1402         seq_printf(seq, "SGL addr limit        : %d\n", work8[20]);
1403         seq_printf(seq, "SGL addr sizes supported : ");
1404         if (work8[21] & 0x01)
1405                 seq_printf(seq, "32 bit ");
1406         if (work8[21] & 0x02)
1407                 seq_printf(seq, "64 bit ");
1408         if (work8[21] & 0x04)
1409                 seq_printf(seq, "96 bit ");
1410         if (work8[21] & 0x08)
1411                 seq_printf(seq, "128 bit ");
1412         seq_printf(seq, "\n");
1413 /*
1414         }
1415 */
1416
1417         return 0;
1418 }
1419
1420 /* Generic group F200h - Sensors (scalar) */
1421 static int i2o_seq_show_sensors(struct seq_file *seq, void *v)
1422 {
1423         struct i2o_device *d = (struct i2o_device *)seq->private;
1424         int token;
1425
1426         struct {
1427                 u16 sensor_instance;
1428                 u8 component;
1429                 u16 component_instance;
1430                 u8 sensor_class;
1431                 u8 sensor_type;
1432                 u8 scaling_exponent;
1433                 u32 actual_reading;
1434                 u32 minimum_reading;
1435                 u32 low2lowcat_treshold;
1436                 u32 lowcat2low_treshold;
1437                 u32 lowwarn2low_treshold;
1438                 u32 low2lowwarn_treshold;
1439                 u32 norm2lowwarn_treshold;
1440                 u32 lowwarn2norm_treshold;
1441                 u32 nominal_reading;
1442                 u32 hiwarn2norm_treshold;
1443                 u32 norm2hiwarn_treshold;
1444                 u32 high2hiwarn_treshold;
1445                 u32 hiwarn2high_treshold;
1446                 u32 hicat2high_treshold;
1447                 u32 hi2hicat_treshold;
1448                 u32 maximum_reading;
1449                 u8 sensor_state;
1450                 u16 event_enable;
1451         } result;
1452
1453         token = i2o_parm_field_get(d, 0xF200, -1, &result, sizeof(result));
1454
1455         if (token < 0) {
1456                 i2o_report_query_status(seq, token,
1457                                         "0xF200 Sensors (optional)");
1458                 return 0;
1459         }
1460
1461         seq_printf(seq, "Sensor instance       : %d\n", result.sensor_instance);
1462
1463         seq_printf(seq, "Component             : %d = ", result.component);
1464         switch (result.component) {
1465         case 0:
1466                 seq_printf(seq, "Other");
1467                 break;
1468         case 1:
1469                 seq_printf(seq, "Planar logic Board");
1470                 break;
1471         case 2:
1472                 seq_printf(seq, "CPU");
1473                 break;
1474         case 3:
1475                 seq_printf(seq, "Chassis");
1476                 break;
1477         case 4:
1478                 seq_printf(seq, "Power Supply");
1479                 break;
1480         case 5:
1481                 seq_printf(seq, "Storage");
1482                 break;
1483         case 6:
1484                 seq_printf(seq, "External");
1485                 break;
1486         }
1487         seq_printf(seq, "\n");
1488
1489         seq_printf(seq, "Component instance    : %d\n",
1490                    result.component_instance);
1491         seq_printf(seq, "Sensor class          : %s\n",
1492                    result.sensor_class ? "Analog" : "Digital");
1493
1494         seq_printf(seq, "Sensor type           : %d = ", result.sensor_type);
1495         switch (result.sensor_type) {
1496         case 0:
1497                 seq_printf(seq, "Other\n");
1498                 break;
1499         case 1:
1500                 seq_printf(seq, "Thermal\n");
1501                 break;
1502         case 2:
1503                 seq_printf(seq, "DC voltage (DC volts)\n");
1504                 break;
1505         case 3:
1506                 seq_printf(seq, "AC voltage (AC volts)\n");
1507                 break;
1508         case 4:
1509                 seq_printf(seq, "DC current (DC amps)\n");
1510                 break;
1511         case 5:
1512                 seq_printf(seq, "AC current (AC volts)\n");
1513                 break;
1514         case 6:
1515                 seq_printf(seq, "Door open\n");
1516                 break;
1517         case 7:
1518                 seq_printf(seq, "Fan operational\n");
1519                 break;
1520         }
1521
1522         seq_printf(seq, "Scaling exponent      : %d\n",
1523                    result.scaling_exponent);
1524         seq_printf(seq, "Actual reading        : %d\n", result.actual_reading);
1525         seq_printf(seq, "Minimum reading       : %d\n", result.minimum_reading);
1526         seq_printf(seq, "Low2LowCat treshold   : %d\n",
1527                    result.low2lowcat_treshold);
1528         seq_printf(seq, "LowCat2Low treshold   : %d\n",
1529                    result.lowcat2low_treshold);
1530         seq_printf(seq, "LowWarn2Low treshold  : %d\n",
1531                    result.lowwarn2low_treshold);
1532         seq_printf(seq, "Low2LowWarn treshold  : %d\n",
1533                    result.low2lowwarn_treshold);
1534         seq_printf(seq, "Norm2LowWarn treshold : %d\n",
1535                    result.norm2lowwarn_treshold);
1536         seq_printf(seq, "LowWarn2Norm treshold : %d\n",
1537                    result.lowwarn2norm_treshold);
1538         seq_printf(seq, "Nominal reading       : %d\n", result.nominal_reading);
1539         seq_printf(seq, "HiWarn2Norm treshold  : %d\n",
1540                    result.hiwarn2norm_treshold);
1541         seq_printf(seq, "Norm2HiWarn treshold  : %d\n",
1542                    result.norm2hiwarn_treshold);
1543         seq_printf(seq, "High2HiWarn treshold  : %d\n",
1544                    result.high2hiwarn_treshold);
1545         seq_printf(seq, "HiWarn2High treshold  : %d\n",
1546                    result.hiwarn2high_treshold);
1547         seq_printf(seq, "HiCat2High treshold   : %d\n",
1548                    result.hicat2high_treshold);
1549         seq_printf(seq, "High2HiCat treshold   : %d\n",
1550                    result.hi2hicat_treshold);
1551         seq_printf(seq, "Maximum reading       : %d\n", result.maximum_reading);
1552
1553         seq_printf(seq, "Sensor state          : %d = ", result.sensor_state);
1554         switch (result.sensor_state) {
1555         case 0:
1556                 seq_printf(seq, "Normal\n");
1557                 break;
1558         case 1:
1559                 seq_printf(seq, "Abnormal\n");
1560                 break;
1561         case 2:
1562                 seq_printf(seq, "Unknown\n");
1563                 break;
1564         case 3:
1565                 seq_printf(seq, "Low Catastrophic (LoCat)\n");
1566                 break;
1567         case 4:
1568                 seq_printf(seq, "Low (Low)\n");
1569                 break;
1570         case 5:
1571                 seq_printf(seq, "Low Warning (LoWarn)\n");
1572                 break;
1573         case 6:
1574                 seq_printf(seq, "High Warning (HiWarn)\n");
1575                 break;
1576         case 7:
1577                 seq_printf(seq, "High (High)\n");
1578                 break;
1579         case 8:
1580                 seq_printf(seq, "High Catastrophic (HiCat)\n");
1581                 break;
1582         }
1583
1584         seq_printf(seq, "Event_enable : 0x%02X\n", result.event_enable);
1585         seq_printf(seq, "    [%s] Operational state change. \n",
1586                    (result.event_enable & 0x01) ? "+" : "-");
1587         seq_printf(seq, "    [%s] Low catastrophic. \n",
1588                    (result.event_enable & 0x02) ? "+" : "-");
1589         seq_printf(seq, "    [%s] Low reading. \n",
1590                    (result.event_enable & 0x04) ? "+" : "-");
1591         seq_printf(seq, "    [%s] Low warning. \n",
1592                    (result.event_enable & 0x08) ? "+" : "-");
1593         seq_printf(seq,
1594                    "    [%s] Change back to normal from out of range state. \n",
1595                    (result.event_enable & 0x10) ? "+" : "-");
1596         seq_printf(seq, "    [%s] High warning. \n",
1597                    (result.event_enable & 0x20) ? "+" : "-");
1598         seq_printf(seq, "    [%s] High reading. \n",
1599                    (result.event_enable & 0x40) ? "+" : "-");
1600         seq_printf(seq, "    [%s] High catastrophic. \n",
1601                    (result.event_enable & 0x80) ? "+" : "-");
1602
1603         return 0;
1604 }
1605
1606 static int i2o_seq_open_hrt(struct inode *inode, struct file *file)
1607 {
1608         return single_open(file, i2o_seq_show_hrt, PDE(inode)->data);
1609 };
1610
1611 static int i2o_seq_open_lct(struct inode *inode, struct file *file)
1612 {
1613         return single_open(file, i2o_seq_show_lct, PDE(inode)->data);
1614 };
1615
1616 static int i2o_seq_open_status(struct inode *inode, struct file *file)
1617 {
1618         return single_open(file, i2o_seq_show_status, PDE(inode)->data);
1619 };
1620
1621 static int i2o_seq_open_hw(struct inode *inode, struct file *file)
1622 {
1623         return single_open(file, i2o_seq_show_hw, PDE(inode)->data);
1624 };
1625
1626 static int i2o_seq_open_ddm_table(struct inode *inode, struct file *file)
1627 {
1628         return single_open(file, i2o_seq_show_ddm_table, PDE(inode)->data);
1629 };
1630
1631 static int i2o_seq_open_driver_store(struct inode *inode, struct file *file)
1632 {
1633         return single_open(file, i2o_seq_show_driver_store, PDE(inode)->data);
1634 };
1635
1636 static int i2o_seq_open_drivers_stored(struct inode *inode, struct file *file)
1637 {
1638         return single_open(file, i2o_seq_show_drivers_stored, PDE(inode)->data);
1639 };
1640
1641 static int i2o_seq_open_groups(struct inode *inode, struct file *file)
1642 {
1643         return single_open(file, i2o_seq_show_groups, PDE(inode)->data);
1644 };
1645
1646 static int i2o_seq_open_phys_device(struct inode *inode, struct file *file)
1647 {
1648         return single_open(file, i2o_seq_show_phys_device, PDE(inode)->data);
1649 };
1650
1651 static int i2o_seq_open_claimed(struct inode *inode, struct file *file)
1652 {
1653         return single_open(file, i2o_seq_show_claimed, PDE(inode)->data);
1654 };
1655
1656 static int i2o_seq_open_users(struct inode *inode, struct file *file)
1657 {
1658         return single_open(file, i2o_seq_show_users, PDE(inode)->data);
1659 };
1660
1661 static int i2o_seq_open_priv_msgs(struct inode *inode, struct file *file)
1662 {
1663         return single_open(file, i2o_seq_show_priv_msgs, PDE(inode)->data);
1664 };
1665
1666 static int i2o_seq_open_authorized_users(struct inode *inode, struct file *file)
1667 {
1668         return single_open(file, i2o_seq_show_authorized_users,
1669                            PDE(inode)->data);
1670 };
1671
1672 static int i2o_seq_open_dev_identity(struct inode *inode, struct file *file)
1673 {
1674         return single_open(file, i2o_seq_show_dev_identity, PDE(inode)->data);
1675 };
1676
1677 static int i2o_seq_open_ddm_identity(struct inode *inode, struct file *file)
1678 {
1679         return single_open(file, i2o_seq_show_ddm_identity, PDE(inode)->data);
1680 };
1681
1682 static int i2o_seq_open_uinfo(struct inode *inode, struct file *file)
1683 {
1684         return single_open(file, i2o_seq_show_uinfo, PDE(inode)->data);
1685 };
1686
1687 static int i2o_seq_open_sgl_limits(struct inode *inode, struct file *file)
1688 {
1689         return single_open(file, i2o_seq_show_sgl_limits, PDE(inode)->data);
1690 };
1691
1692 static int i2o_seq_open_sensors(struct inode *inode, struct file *file)
1693 {
1694         return single_open(file, i2o_seq_show_sensors, PDE(inode)->data);
1695 };
1696
1697 static int i2o_seq_open_dev_name(struct inode *inode, struct file *file)
1698 {
1699         return single_open(file, i2o_seq_show_dev_name, PDE(inode)->data);
1700 };
1701
1702 static const struct file_operations i2o_seq_fops_lct = {
1703         .open = i2o_seq_open_lct,
1704         .read = seq_read,
1705         .llseek = seq_lseek,
1706         .release = single_release,
1707 };
1708
1709 static const struct file_operations i2o_seq_fops_hrt = {
1710         .open = i2o_seq_open_hrt,
1711         .read = seq_read,
1712         .llseek = seq_lseek,
1713         .release = single_release,
1714 };
1715
1716 static const struct file_operations i2o_seq_fops_status = {
1717         .open = i2o_seq_open_status,
1718         .read = seq_read,
1719         .llseek = seq_lseek,
1720         .release = single_release,
1721 };
1722
1723 static const struct file_operations i2o_seq_fops_hw = {
1724         .open = i2o_seq_open_hw,
1725         .read = seq_read,
1726         .llseek = seq_lseek,
1727         .release = single_release,
1728 };
1729
1730 static const struct file_operations i2o_seq_fops_ddm_table = {
1731         .open = i2o_seq_open_ddm_table,
1732         .read = seq_read,
1733         .llseek = seq_lseek,
1734         .release = single_release,
1735 };
1736
1737 static const struct file_operations i2o_seq_fops_driver_store = {
1738         .open = i2o_seq_open_driver_store,
1739         .read = seq_read,
1740         .llseek = seq_lseek,
1741         .release = single_release,
1742 };
1743
1744 static const struct file_operations i2o_seq_fops_drivers_stored = {
1745         .open = i2o_seq_open_drivers_stored,
1746         .read = seq_read,
1747         .llseek = seq_lseek,
1748         .release = single_release,
1749 };
1750
1751 static const struct file_operations i2o_seq_fops_groups = {
1752         .open = i2o_seq_open_groups,
1753         .read = seq_read,
1754         .llseek = seq_lseek,
1755         .release = single_release,
1756 };
1757
1758 static const struct file_operations i2o_seq_fops_phys_device = {
1759         .open = i2o_seq_open_phys_device,
1760         .read = seq_read,
1761         .llseek = seq_lseek,
1762         .release = single_release,
1763 };
1764
1765 static const struct file_operations i2o_seq_fops_claimed = {
1766         .open = i2o_seq_open_claimed,
1767         .read = seq_read,
1768         .llseek = seq_lseek,
1769         .release = single_release,
1770 };
1771
1772 static const struct file_operations i2o_seq_fops_users = {
1773         .open = i2o_seq_open_users,
1774         .read = seq_read,
1775         .llseek = seq_lseek,
1776         .release = single_release,
1777 };
1778
1779 static const struct file_operations i2o_seq_fops_priv_msgs = {
1780         .open = i2o_seq_open_priv_msgs,
1781         .read = seq_read,
1782         .llseek = seq_lseek,
1783         .release = single_release,
1784 };
1785
1786 static const struct file_operations i2o_seq_fops_authorized_users = {
1787         .open = i2o_seq_open_authorized_users,
1788         .read = seq_read,
1789         .llseek = seq_lseek,
1790         .release = single_release,
1791 };
1792
1793 static const struct file_operations i2o_seq_fops_dev_name = {
1794         .open = i2o_seq_open_dev_name,
1795         .read = seq_read,
1796         .llseek = seq_lseek,
1797         .release = single_release,
1798 };
1799
1800 static const struct file_operations i2o_seq_fops_dev_identity = {
1801         .open = i2o_seq_open_dev_identity,
1802         .read = seq_read,
1803         .llseek = seq_lseek,
1804         .release = single_release,
1805 };
1806
1807 static const struct file_operations i2o_seq_fops_ddm_identity = {
1808         .open = i2o_seq_open_ddm_identity,
1809         .read = seq_read,
1810         .llseek = seq_lseek,
1811         .release = single_release,
1812 };
1813
1814 static const struct file_operations i2o_seq_fops_uinfo = {
1815         .open = i2o_seq_open_uinfo,
1816         .read = seq_read,
1817         .llseek = seq_lseek,
1818         .release = single_release,
1819 };
1820
1821 static const struct file_operations i2o_seq_fops_sgl_limits = {
1822         .open = i2o_seq_open_sgl_limits,
1823         .read = seq_read,
1824         .llseek = seq_lseek,
1825         .release = single_release,
1826 };
1827
1828 static const struct file_operations i2o_seq_fops_sensors = {
1829         .open = i2o_seq_open_sensors,
1830         .read = seq_read,
1831         .llseek = seq_lseek,
1832         .release = single_release,
1833 };
1834
1835 /*
1836  * IOP specific entries...write field just in case someone
1837  * ever wants one.
1838  */
1839 static i2o_proc_entry i2o_proc_generic_iop_entries[] = {
1840         {"hrt", S_IFREG | S_IRUGO, &i2o_seq_fops_hrt},
1841         {"lct", S_IFREG | S_IRUGO, &i2o_seq_fops_lct},
1842         {"status", S_IFREG | S_IRUGO, &i2o_seq_fops_status},
1843         {"hw", S_IFREG | S_IRUGO, &i2o_seq_fops_hw},
1844         {"ddm_table", S_IFREG | S_IRUGO, &i2o_seq_fops_ddm_table},
1845         {"driver_store", S_IFREG | S_IRUGO, &i2o_seq_fops_driver_store},
1846         {"drivers_stored", S_IFREG | S_IRUGO, &i2o_seq_fops_drivers_stored},
1847         {NULL, 0, NULL}
1848 };
1849
1850 /*
1851  * Device specific entries
1852  */
1853 static i2o_proc_entry generic_dev_entries[] = {
1854         {"groups", S_IFREG | S_IRUGO, &i2o_seq_fops_groups},
1855         {"phys_dev", S_IFREG | S_IRUGO, &i2o_seq_fops_phys_device},
1856         {"claimed", S_IFREG | S_IRUGO, &i2o_seq_fops_claimed},
1857         {"users", S_IFREG | S_IRUGO, &i2o_seq_fops_users},
1858         {"priv_msgs", S_IFREG | S_IRUGO, &i2o_seq_fops_priv_msgs},
1859         {"authorized_users", S_IFREG | S_IRUGO, &i2o_seq_fops_authorized_users},
1860         {"dev_identity", S_IFREG | S_IRUGO, &i2o_seq_fops_dev_identity},
1861         {"ddm_identity", S_IFREG | S_IRUGO, &i2o_seq_fops_ddm_identity},
1862         {"user_info", S_IFREG | S_IRUGO, &i2o_seq_fops_uinfo},
1863         {"sgl_limits", S_IFREG | S_IRUGO, &i2o_seq_fops_sgl_limits},
1864         {"sensors", S_IFREG | S_IRUGO, &i2o_seq_fops_sensors},
1865         {NULL, 0, NULL}
1866 };
1867
1868 /*
1869  *  Storage unit specific entries (SCSI Periph, BS) with device names
1870  */
1871 static i2o_proc_entry rbs_dev_entries[] = {
1872         {"dev_name", S_IFREG | S_IRUGO, &i2o_seq_fops_dev_name},
1873         {NULL, 0, NULL}
1874 };
1875
1876 /**
1877  *      i2o_proc_create_entries - Creates proc dir entries
1878  *      @dir: proc dir entry under which the entries should be placed
1879  *      @i2o_pe: pointer to the entries which should be added
1880  *      @data: pointer to I2O controller or device
1881  *
1882  *      Create proc dir entries for a I2O controller or I2O device.
1883  *
1884  *      Returns 0 on success or negative error code on failure.
1885  */
1886 static int i2o_proc_create_entries(struct proc_dir_entry *dir,
1887                                    i2o_proc_entry * i2o_pe, void *data)
1888 {
1889         struct proc_dir_entry *tmp;
1890
1891         while (i2o_pe->name) {
1892                 tmp = proc_create_data(i2o_pe->name, i2o_pe->mode, dir,
1893                                        i2o_pe->fops, data);
1894                 if (!tmp)
1895                         return -1;
1896
1897                 i2o_pe++;
1898         }
1899
1900         return 0;
1901 }
1902
1903 /**
1904  *      i2o_proc_subdir_remove - Remove child entries from a proc entry
1905  *      @dir: proc dir entry from which the childs should be removed
1906  *
1907  *      Iterate over each i2o proc entry under dir and remove it. If the child
1908  *      also has entries, remove them too.
1909  */
1910 static void i2o_proc_subdir_remove(struct proc_dir_entry *dir)
1911 {
1912         struct proc_dir_entry *pe, *tmp;
1913         pe = dir->subdir;
1914         while (pe) {
1915                 tmp = pe->next;
1916                 i2o_proc_subdir_remove(pe);
1917                 remove_proc_entry(pe->name, dir);
1918                 pe = tmp;
1919         }
1920 };
1921
1922 /**
1923  *      i2o_proc_device_add - Add an I2O device to the proc dir
1924  *      @dir: proc dir entry to which the device should be added
1925  *      @dev: I2O device which should be added
1926  *
1927  *      Add an I2O device to the proc dir entry dir and create the entries for
1928  *      the device depending on the class of the I2O device.
1929  */
1930 static void i2o_proc_device_add(struct proc_dir_entry *dir,
1931                                 struct i2o_device *dev)
1932 {
1933         char buff[10];
1934         struct proc_dir_entry *devdir;
1935         i2o_proc_entry *i2o_pe = NULL;
1936
1937         sprintf(buff, "%03x", dev->lct_data.tid);
1938
1939         osm_debug("adding device /proc/i2o/%s/%s\n", dev->iop->name, buff);
1940
1941         devdir = proc_mkdir(buff, dir);
1942         if (!devdir) {
1943                 osm_warn("Could not allocate procdir!\n");
1944                 return;
1945         }
1946
1947         devdir->data = dev;
1948
1949         i2o_proc_create_entries(devdir, generic_dev_entries, dev);
1950
1951         /* Inform core that we want updates about this device's status */
1952         switch (dev->lct_data.class_id) {
1953         case I2O_CLASS_SCSI_PERIPHERAL:
1954         case I2O_CLASS_RANDOM_BLOCK_STORAGE:
1955                 i2o_pe = rbs_dev_entries;
1956                 break;
1957         default:
1958                 break;
1959         }
1960         if (i2o_pe)
1961                 i2o_proc_create_entries(devdir, i2o_pe, dev);
1962 }
1963
1964 /**
1965  *      i2o_proc_iop_add - Add an I2O controller to the i2o proc tree
1966  *      @dir: parent proc dir entry
1967  *      @c: I2O controller which should be added
1968  *
1969  *      Add the entries to the parent proc dir entry. Also each device is added
1970  *      to the controllers proc dir entry.
1971  *
1972  *      Returns 0 on success or negative error code on failure.
1973  */
1974 static int i2o_proc_iop_add(struct proc_dir_entry *dir,
1975                             struct i2o_controller *c)
1976 {
1977         struct proc_dir_entry *iopdir;
1978         struct i2o_device *dev;
1979
1980         osm_debug("adding IOP /proc/i2o/%s\n", c->name);
1981
1982         iopdir = proc_mkdir(c->name, dir);
1983         if (!iopdir)
1984                 return -1;
1985
1986         iopdir->data = c;
1987
1988         i2o_proc_create_entries(iopdir, i2o_proc_generic_iop_entries, c);
1989
1990         list_for_each_entry(dev, &c->devices, list)
1991             i2o_proc_device_add(iopdir, dev);
1992
1993         return 0;
1994 }
1995
1996 /**
1997  *      i2o_proc_iop_remove - Removes an I2O controller from the i2o proc tree
1998  *      @dir: parent proc dir entry
1999  *      @c: I2O controller which should be removed
2000  *
2001  *      Iterate over each i2o proc entry and search controller c. If it is found
2002  *      remove it from the tree.
2003  */
2004 static void i2o_proc_iop_remove(struct proc_dir_entry *dir,
2005                                 struct i2o_controller *c)
2006 {
2007         struct proc_dir_entry *pe, *tmp;
2008
2009         pe = dir->subdir;
2010         while (pe) {
2011                 tmp = pe->next;
2012                 if (pe->data == c) {
2013                         i2o_proc_subdir_remove(pe);
2014                         remove_proc_entry(pe->name, dir);
2015                 }
2016                 osm_debug("removing IOP /proc/i2o/%s\n", c->name);
2017                 pe = tmp;
2018         }
2019 }
2020
2021 /**
2022  *      i2o_proc_fs_create - Create the i2o proc fs.
2023  *
2024  *      Iterate over each I2O controller and create the entries for it.
2025  *
2026  *      Returns 0 on success or negative error code on failure.
2027  */
2028 static int __init i2o_proc_fs_create(void)
2029 {
2030         struct i2o_controller *c;
2031
2032         i2o_proc_dir_root = proc_mkdir("i2o", NULL);
2033         if (!i2o_proc_dir_root)
2034                 return -1;
2035
2036         list_for_each_entry(c, &i2o_controllers, list)
2037             i2o_proc_iop_add(i2o_proc_dir_root, c);
2038
2039         return 0;
2040 };
2041
2042 /**
2043  *      i2o_proc_fs_destroy - Cleanup the all i2o proc entries
2044  *
2045  *      Iterate over each I2O controller and remove the entries for it.
2046  *
2047  *      Returns 0 on success or negative error code on failure.
2048  */
2049 static int __exit i2o_proc_fs_destroy(void)
2050 {
2051         struct i2o_controller *c;
2052
2053         list_for_each_entry(c, &i2o_controllers, list)
2054             i2o_proc_iop_remove(i2o_proc_dir_root, c);
2055
2056         remove_proc_entry("i2o", NULL);
2057
2058         return 0;
2059 };
2060
2061 /**
2062  *      i2o_proc_init - Init function for procfs
2063  *
2064  *      Registers Proc OSM and creates procfs entries.
2065  *
2066  *      Returns 0 on success or negative error code on failure.
2067  */
2068 static int __init i2o_proc_init(void)
2069 {
2070         int rc;
2071
2072         printk(KERN_INFO OSM_DESCRIPTION " v" OSM_VERSION "\n");
2073
2074         rc = i2o_driver_register(&i2o_proc_driver);
2075         if (rc)
2076                 return rc;
2077
2078         rc = i2o_proc_fs_create();
2079         if (rc) {
2080                 i2o_driver_unregister(&i2o_proc_driver);
2081                 return rc;
2082         }
2083
2084         return 0;
2085 };
2086
2087 /**
2088  *      i2o_proc_exit - Exit function for procfs
2089  *
2090  *      Unregisters Proc OSM and removes procfs entries.
2091  */
2092 static void __exit i2o_proc_exit(void)
2093 {
2094         i2o_driver_unregister(&i2o_proc_driver);
2095         i2o_proc_fs_destroy();
2096 };
2097
2098 MODULE_AUTHOR("Deepak Saxena");
2099 MODULE_LICENSE("GPL");
2100 MODULE_DESCRIPTION(OSM_DESCRIPTION);
2101 MODULE_VERSION(OSM_VERSION);
2102
2103 module_init(i2o_proc_init);
2104 module_exit(i2o_proc_exit);