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