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 I2O_MAX_MODULES 4
  31 // FIXME!
  32 #define FMT_U64_HEX "0x%08x%08x"
  33 #define U64_VAL(pu64) *((u32*)(pu64)+1), *((u32*)(pu64))
  34
  35 #include <linux/types.h>
  36 #include <linux/kernel.h>
  37 #include <linux/pci.h>
  38 #include <linux/i2o.h>
  39 #include <linux/proc_fs.h>
  40 #include <linux/seq_file.h>
  41 #include <linux/init.h>
  42 #include <linux/module.h>
  43 #include <linux/errno.h>
  44 #include <linux/spinlock.h>
  45 #include <linux/workqueue.h>
  46
  47 #include <asm/io.h>
  48 #include <asm/uaccess.h>
  49 #include <asm/byteorder.h>
  50
  51 /* Structure used to define /proc entries */
  52 typedef struct _i2o_proc_entry_t {
  53         char *name;             /* entry name */
  54         mode_t mode;            /* mode */
  55         struct file_operations *fops;   /* open function */
  56 } i2o_proc_entry;
  57
  58 /* global I2O /proc/i2o entry */
  59 static struct proc_dir_entry *i2o_proc_dir_root;
  60
  61 /* proc OSM driver struct */
  62 static struct i2o_driver i2o_proc_driver = {
  63         .name = "proc-osm",
  64 };
  65
  66 static int print_serial_number(struct seq_file *seq, u8 * serialno, int max_len)
  67 {
  68         int i;
  69
  70         /* 19990419 -sralston
  71          *      The I2O v1.5 (and v2.0 so far) "official specification"
  72          *      got serial numbers WRONG!
  73          *      Apparently, and despite what Section 3.4.4 says and
  74          *      Figure 3-35 shows (pg 3-39 in the pdf doc),
  75          *      the convention / consensus seems to be:
  76          *        + First byte is SNFormat
  77          *        + Second byte is SNLen (but only if SNFormat==7 (?))
  78          *        + (v2.0) SCSI+BS may use IEEE Registered (64 or 128 bit) format
  79          */
  80         switch (serialno[0]) {
  81         case I2O_SNFORMAT_BINARY:       /* Binary */
  82                 seq_printf(seq, "0x");
  83                 for (i = 0; i < serialno[1]; i++) {
  84                         seq_printf(seq, "%02X", serialno[2 + i]);
  85                 }
  86                 break;
  87
  88         case I2O_SNFORMAT_ASCII:        /* ASCII */
  89                 if (serialno[1] < ' ') {        /* printable or SNLen? */
  90                         /* sanity */
  91                         max_len =
  92                             (max_len < serialno[1]) ? max_len : serialno[1];
  93                         serialno[1 + max_len] = '\0';
  94
  95                         /* just print it */
  96                         seq_printf(seq, "%s", &serialno[2]);
  97                 } else {
  98                         /* print chars for specified length */
  99                         for (i = 0; i < serialno[1]; i++) {
 100                                 seq_printf(seq, "%c", serialno[2 + i]);
 101                         }
 102                 }
 103                 break;
 104
 105         case I2O_SNFORMAT_UNICODE:      /* UNICODE */
 106                 seq_printf(seq, "UNICODE Format.  Can't Display\n");
 107                 break;
 108
 109         case I2O_SNFORMAT_LAN48_MAC:    /* LAN-48 MAC Address */
 110                 seq_printf(seq,
 111                            "LAN-48 MAC address @ %02X:%02X:%02X:%02X:%02X:%02X",
 112                            serialno[2], serialno[3],
 113                            serialno[4], serialno[5], serialno[6], serialno[7]);
 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:?] %02X:%02X:%02X:%02X:%02X:%02X",
 126                            serialno[8], serialno[9],
 127                            serialno[2], serialno[3],
 128                            serialno[4], serialno[5], serialno[6], serialno[7]);
 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_PORT:
 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 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 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_PORT:
 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 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 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 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 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 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 #if 0
 942                 if (c->i2oversion == 0x02)
 943                         seq_printf(seq, "%-d", dst->module_state);
 944 #endif
 945
 946                 seq_printf(seq, "%-#7x", dst->i2o_vendor_id);
 947                 seq_printf(seq, "%-#8x", dst->module_id);
 948                 seq_printf(seq, "%-29s", chtostr(dst->module_name_version, 28));
 949                 seq_printf(seq, "%-9s", chtostr(dst->date, 8));
 950                 seq_printf(seq, "%8d ", dst->module_size);
 951                 seq_printf(seq, "%8d ", dst->mpb_size);
 952                 seq_printf(seq, "0x%04x", dst->module_flags);
 953 #if 0
 954                 if (c->i2oversion == 0x02)
 955                         seq_printf(seq, "%d", dst->notification_level);
 956 #endif
 957                 seq_printf(seq, "\n");
 958         }
 959
 960         kfree(result);
 961         return 0;
 962 }
 963
 964 /* Generic group F000h - Params Descriptor (table) */
 965 int i2o_seq_show_groups(struct seq_file *seq, void *v)
 966 {
 967         struct i2o_device *d = (struct i2o_device *)seq->private;
 968         int token;
 969         int i;
 970         u8 properties;
 971
 972         typedef struct _i2o_group_info {
 973                 u16 group_number;
 974                 u16 field_count;
 975                 u16 row_count;
 976                 u8 properties;
 977                 u8 reserved;
 978         } i2o_group_info;
 979
 980         struct {
 981                 u16 result_count;
 982                 u16 pad;
 983                 u16 block_size;
 984                 u8 block_status;
 985                 u8 error_info_size;
 986                 u16 row_count;
 987                 u16 more_flag;
 988                 i2o_group_info group[256];
 989         } *result;
 990
 991         result = kmalloc(sizeof(*result), GFP_KERNEL);
 992         if (!result)
 993                 return -ENOMEM;
 994
 995         token = i2o_parm_table_get(d, I2O_PARAMS_TABLE_GET, 0xF000, -1, NULL, 0,
 996                                    result, sizeof(*result));
 997
 998         if (token < 0) {
 999                 i2o_report_query_status(seq, token, "0xF000 Params Descriptor");
1000                 goto out;
1001         }
1002
1003         seq_printf(seq,
1004                    "#  Group   FieldCount RowCount Type   Add Del Clear\n");
1005
1006         for (i = 0; i < result->row_count; i++) {
1007                 seq_printf(seq, "%-3d", i);
1008                 seq_printf(seq, "0x%04X ", result->group[i].group_number);
1009                 seq_printf(seq, "%10d ", result->group[i].field_count);
1010                 seq_printf(seq, "%8d ", result->group[i].row_count);
1011
1012                 properties = result->group[i].properties;
1013                 if (properties & 0x1)
1014                         seq_printf(seq, "Table  ");
1015                 else
1016                         seq_printf(seq, "Scalar ");
1017                 if (properties & 0x2)
1018                         seq_printf(seq, " + ");
1019                 else
1020                         seq_printf(seq, " - ");
1021                 if (properties & 0x4)
1022                         seq_printf(seq, "  + ");
1023                 else
1024                         seq_printf(seq, "  - ");
1025                 if (properties & 0x8)
1026                         seq_printf(seq, "  + ");
1027                 else
1028                         seq_printf(seq, "  - ");
1029
1030                 seq_printf(seq, "\n");
1031         }
1032
1033         if (result->more_flag)
1034                 seq_printf(seq, "There is more...\n");
1035       out:
1036         kfree(result);
1037         return 0;
1038 }
1039
1040 /* Generic group F001h - Physical Device Table (table) */
1041 int i2o_seq_show_phys_device(struct seq_file *seq, void *v)
1042 {
1043         struct i2o_device *d = (struct i2o_device *)seq->private;
1044         int token;
1045         int i;
1046
1047         struct {
1048                 u16 result_count;
1049                 u16 pad;
1050                 u16 block_size;
1051                 u8 block_status;
1052                 u8 error_info_size;
1053                 u16 row_count;
1054                 u16 more_flag;
1055                 u32 adapter_id[64];
1056         } result;
1057
1058         token = i2o_parm_table_get(d, I2O_PARAMS_TABLE_GET, 0xF001, -1, NULL, 0,
1059                                    &result, sizeof(result));
1060
1061         if (token < 0) {
1062                 i2o_report_query_status(seq, token,
1063                                         "0xF001 Physical Device Table");
1064                 return 0;
1065         }
1066
1067         if (result.row_count)
1068                 seq_printf(seq, "#  AdapterId\n");
1069
1070         for (i = 0; i < result.row_count; i++) {
1071                 seq_printf(seq, "%-2d", i);
1072                 seq_printf(seq, "%#7x\n", result.adapter_id[i]);
1073         }
1074
1075         if (result.more_flag)
1076                 seq_printf(seq, "There is more...\n");
1077
1078         return 0;
1079 }
1080
1081 /* Generic group F002h - Claimed Table (table) */
1082 int i2o_seq_show_claimed(struct seq_file *seq, void *v)
1083 {
1084         struct i2o_device *d = (struct i2o_device *)seq->private;
1085         int token;
1086         int i;
1087
1088         struct {
1089                 u16 result_count;
1090                 u16 pad;
1091                 u16 block_size;
1092                 u8 block_status;
1093                 u8 error_info_size;
1094                 u16 row_count;
1095                 u16 more_flag;
1096                 u16 claimed_tid[64];
1097         } result;
1098
1099         token = i2o_parm_table_get(d, I2O_PARAMS_TABLE_GET, 0xF002, -1, NULL, 0,
1100                                    &result, sizeof(result));
1101
1102         if (token < 0) {
1103                 i2o_report_query_status(seq, token, "0xF002 Claimed Table");
1104                 return 0;
1105         }
1106
1107         if (result.row_count)
1108                 seq_printf(seq, "#  ClaimedTid\n");
1109
1110         for (i = 0; i < result.row_count; i++) {
1111                 seq_printf(seq, "%-2d", i);
1112                 seq_printf(seq, "%#7x\n", result.claimed_tid[i]);
1113         }
1114
1115         if (result.more_flag)
1116                 seq_printf(seq, "There is more...\n");
1117
1118         return 0;
1119 }
1120
1121 /* Generic group F003h - User Table (table) */
1122 int i2o_seq_show_users(struct seq_file *seq, void *v)
1123 {
1124         struct i2o_device *d = (struct i2o_device *)seq->private;
1125         int token;
1126         int i;
1127
1128         typedef struct _i2o_user_table {
1129                 u16 instance;
1130                 u16 user_tid;
1131                 u8 claim_type;
1132                 u8 reserved1;
1133                 u16 reserved2;
1134         } i2o_user_table;
1135
1136         struct {
1137                 u16 result_count;
1138                 u16 pad;
1139                 u16 block_size;
1140                 u8 block_status;
1141                 u8 error_info_size;
1142                 u16 row_count;
1143                 u16 more_flag;
1144                 i2o_user_table user[64];
1145         } *result;
1146
1147         result = kmalloc(sizeof(*result), GFP_KERNEL);
1148         if (!result)
1149                 return -ENOMEM;
1150
1151         token = i2o_parm_table_get(d, I2O_PARAMS_TABLE_GET, 0xF003, -1, NULL, 0,
1152                                    result, sizeof(*result));
1153
1154         if (token < 0) {
1155                 i2o_report_query_status(seq, token, "0xF003 User Table");
1156                 goto out;
1157         }
1158
1159         seq_printf(seq, "#  Instance UserTid ClaimType\n");
1160
1161         for (i = 0; i < result->row_count; i++) {
1162                 seq_printf(seq, "%-3d", i);
1163                 seq_printf(seq, "%#8x ", result->user[i].instance);
1164                 seq_printf(seq, "%#7x ", result->user[i].user_tid);
1165                 seq_printf(seq, "%#9x\n", result->user[i].claim_type);
1166         }
1167
1168         if (result->more_flag)
1169                 seq_printf(seq, "There is more...\n");
1170       out:
1171         kfree(result);
1172         return 0;
1173 }
1174
1175 /* Generic group F005h - Private message extensions (table) (optional) */
1176 int i2o_seq_show_priv_msgs(struct seq_file *seq, void *v)
1177 {
1178         struct i2o_device *d = (struct i2o_device *)seq->private;
1179         int token;
1180         int i;
1181
1182         typedef struct _i2o_private {
1183                 u16 ext_instance;
1184                 u16 organization_id;
1185                 u16 x_function_code;
1186         } i2o_private;
1187
1188         struct {
1189                 u16 result_count;
1190                 u16 pad;
1191                 u16 block_size;
1192                 u8 block_status;
1193                 u8 error_info_size;
1194                 u16 row_count;
1195                 u16 more_flag;
1196                 i2o_private extension[64];
1197         } result;
1198
1199         token = i2o_parm_table_get(d, I2O_PARAMS_TABLE_GET, 0xF000, -1, NULL, 0,
1200                                    &result, sizeof(result));
1201
1202         if (token < 0) {
1203                 i2o_report_query_status(seq, token,
1204                                         "0xF005 Private Message Extensions (optional)");
1205                 return 0;
1206         }
1207
1208         seq_printf(seq, "Instance#  OrgId  FunctionCode\n");
1209
1210         for (i = 0; i < result.row_count; i++) {
1211                 seq_printf(seq, "%0#9x ", result.extension[i].ext_instance);
1212                 seq_printf(seq, "%0#6x ", result.extension[i].organization_id);
1213                 seq_printf(seq, "%0#6x", result.extension[i].x_function_code);
1214
1215                 seq_printf(seq, "\n");
1216         }
1217
1218         if (result.more_flag)
1219                 seq_printf(seq, "There is more...\n");
1220
1221         return 0;
1222 }
1223
1224 /* Generic group F006h - Authorized User Table (table) */
1225 int i2o_seq_show_authorized_users(struct seq_file *seq, void *v)
1226 {
1227         struct i2o_device *d = (struct i2o_device *)seq->private;
1228         int token;
1229         int i;
1230
1231         struct {
1232                 u16 result_count;
1233                 u16 pad;
1234                 u16 block_size;
1235                 u8 block_status;
1236                 u8 error_info_size;
1237                 u16 row_count;
1238                 u16 more_flag;
1239                 u32 alternate_tid[64];
1240         } result;
1241
1242         token = i2o_parm_table_get(d, I2O_PARAMS_TABLE_GET, 0xF006, -1, NULL, 0,
1243                                    &result, sizeof(result));
1244
1245         if (token < 0) {
1246                 i2o_report_query_status(seq, token,
1247                                         "0xF006 Autohorized User Table");
1248                 return 0;
1249         }
1250
1251         if (result.row_count)
1252                 seq_printf(seq, "#  AlternateTid\n");
1253
1254         for (i = 0; i < result.row_count; i++) {
1255                 seq_printf(seq, "%-2d", i);
1256                 seq_printf(seq, "%#7x ", result.alternate_tid[i]);
1257         }
1258
1259         if (result.more_flag)
1260                 seq_printf(seq, "There is more...\n");
1261
1262         return 0;
1263 }
1264
1265 /* Generic group F100h - Device Identity (scalar) */
1266 int i2o_seq_show_dev_identity(struct seq_file *seq, void *v)
1267 {
1268         struct i2o_device *d = (struct i2o_device *)seq->private;
1269         static u32 work32[128]; // allow for "stuff" + up to 256 byte (max) serial number
1270         // == (allow) 512d bytes (max)
1271         static u16 *work16 = (u16 *) work32;
1272         int token;
1273
1274         token = i2o_parm_field_get(d, 0xF100, -1, &work32, sizeof(work32));
1275
1276         if (token < 0) {
1277                 i2o_report_query_status(seq, token, "0xF100 Device Identity");
1278                 return 0;
1279         }
1280
1281         seq_printf(seq, "Device Class  : %s\n", i2o_get_class_name(work16[0]));
1282         seq_printf(seq, "Owner TID     : %0#5x\n", work16[2]);
1283         seq_printf(seq, "Parent TID    : %0#5x\n", work16[3]);
1284         seq_printf(seq, "Vendor info   : %s\n",
1285                    chtostr((u8 *) (work32 + 2), 16));
1286         seq_printf(seq, "Product info  : %s\n",
1287                    chtostr((u8 *) (work32 + 6), 16));
1288         seq_printf(seq, "Description   : %s\n",
1289                    chtostr((u8 *) (work32 + 10), 16));
1290         seq_printf(seq, "Product rev.  : %s\n",
1291                    chtostr((u8 *) (work32 + 14), 8));
1292
1293         seq_printf(seq, "Serial number : ");
1294         print_serial_number(seq, (u8 *) (work32 + 16),
1295                             /* allow for SNLen plus
1296                              * possible trailing '\0'
1297                              */
1298                             sizeof(work32) - (16 * sizeof(u32)) - 2);
1299         seq_printf(seq, "\n");
1300
1301         return 0;
1302 }
1303
1304 int i2o_seq_show_dev_name(struct seq_file *seq, void *v)
1305 {
1306         struct i2o_device *d = (struct i2o_device *)seq->private;
1307
1308         seq_printf(seq, "%s\n", d->device.bus_id);
1309
1310         return 0;
1311 }
1312
1313 /* Generic group F101h - DDM Identity (scalar) */
1314 int i2o_seq_show_ddm_identity(struct seq_file *seq, void *v)
1315 {
1316         struct i2o_device *d = (struct i2o_device *)seq->private;
1317         int token;
1318
1319         struct {
1320                 u16 ddm_tid;
1321                 u8 module_name[24];
1322                 u8 module_rev[8];
1323                 u8 sn_format;
1324                 u8 serial_number[12];
1325                 u8 pad[256];    // allow up to 256 byte (max) serial number
1326         } result;
1327
1328         token = i2o_parm_field_get(d, 0xF101, -1, &result, sizeof(result));
1329
1330         if (token < 0) {
1331                 i2o_report_query_status(seq, token, "0xF101 DDM Identity");
1332                 return 0;
1333         }
1334
1335         seq_printf(seq, "Registering DDM TID : 0x%03x\n", result.ddm_tid);
1336         seq_printf(seq, "Module name         : %s\n",
1337                    chtostr(result.module_name, 24));
1338         seq_printf(seq, "Module revision     : %s\n",
1339                    chtostr(result.module_rev, 8));
1340
1341         seq_printf(seq, "Serial number       : ");
1342         print_serial_number(seq, result.serial_number, sizeof(result) - 36);
1343         /* allow for SNLen plus possible trailing '\0' */
1344
1345         seq_printf(seq, "\n");
1346
1347         return 0;
1348 }
1349
1350 /* Generic group F102h - User Information (scalar) */
1351 int i2o_seq_show_uinfo(struct seq_file *seq, void *v)
1352 {
1353         struct i2o_device *d = (struct i2o_device *)seq->private;
1354         int token;
1355
1356         struct {
1357                 u8 device_name[64];
1358                 u8 service_name[64];
1359                 u8 physical_location[64];
1360                 u8 instance_number[4];
1361         } result;
1362
1363         token = i2o_parm_field_get(d, 0xF102, -1, &result, sizeof(result));
1364
1365         if (token < 0) {
1366                 i2o_report_query_status(seq, token, "0xF102 User Information");
1367                 return 0;
1368         }
1369
1370         seq_printf(seq, "Device name     : %s\n",
1371                    chtostr(result.device_name, 64));
1372         seq_printf(seq, "Service name    : %s\n",
1373                    chtostr(result.service_name, 64));
1374         seq_printf(seq, "Physical name   : %s\n",
1375                    chtostr(result.physical_location, 64));
1376         seq_printf(seq, "Instance number : %s\n",
1377                    chtostr(result.instance_number, 4));
1378
1379         return 0;
1380 }
1381
1382 /* Generic group F103h - SGL Operating Limits (scalar) */
1383 int i2o_seq_show_sgl_limits(struct seq_file *seq, void *v)
1384 {
1385         struct i2o_device *d = (struct i2o_device *)seq->private;
1386         static u32 work32[12];
1387         static u16 *work16 = (u16 *) work32;
1388         static u8 *work8 = (u8 *) work32;
1389         int token;
1390
1391         token = i2o_parm_field_get(d, 0xF103, -1, &work32, sizeof(work32));
1392
1393         if (token < 0) {
1394                 i2o_report_query_status(seq, token,
1395                                         "0xF103 SGL Operating Limits");
1396                 return 0;
1397         }
1398
1399         seq_printf(seq, "SGL chain size        : %d\n", work32[0]);
1400         seq_printf(seq, "Max SGL chain size    : %d\n", work32[1]);
1401         seq_printf(seq, "SGL chain size target : %d\n", work32[2]);
1402         seq_printf(seq, "SGL frag count        : %d\n", work16[6]);
1403         seq_printf(seq, "Max SGL frag count    : %d\n", work16[7]);
1404         seq_printf(seq, "SGL frag count target : %d\n", work16[8]);
1405
1406 /* FIXME
1407         if (d->i2oversion == 0x02)
1408         {
1409 */
1410         seq_printf(seq, "SGL data alignment    : %d\n", work16[8]);
1411         seq_printf(seq, "SGL addr limit        : %d\n", work8[20]);
1412         seq_printf(seq, "SGL addr sizes supported : ");
1413         if (work8[21] & 0x01)
1414                 seq_printf(seq, "32 bit ");
1415         if (work8[21] & 0x02)
1416                 seq_printf(seq, "64 bit ");
1417         if (work8[21] & 0x04)
1418                 seq_printf(seq, "96 bit ");
1419         if (work8[21] & 0x08)
1420                 seq_printf(seq, "128 bit ");
1421         seq_printf(seq, "\n");
1422 /*
1423         }
1424 */
1425
1426         return 0;
1427 }
1428
1429 /* Generic group F200h - Sensors (scalar) */
1430 int i2o_seq_show_sensors(struct seq_file *seq, void *v)
1431 {
1432         struct i2o_device *d = (struct i2o_device *)seq->private;
1433         int token;
1434
1435         struct {
1436                 u16 sensor_instance;
1437                 u8 component;
1438                 u16 component_instance;
1439                 u8 sensor_class;
1440                 u8 sensor_type;
1441                 u8 scaling_exponent;
1442                 u32 actual_reading;
1443                 u32 minimum_reading;
1444                 u32 low2lowcat_treshold;
1445                 u32 lowcat2low_treshold;
1446                 u32 lowwarn2low_treshold;
1447                 u32 low2lowwarn_treshold;
1448                 u32 norm2lowwarn_treshold;
1449                 u32 lowwarn2norm_treshold;
1450                 u32 nominal_reading;
1451                 u32 hiwarn2norm_treshold;
1452                 u32 norm2hiwarn_treshold;
1453                 u32 high2hiwarn_treshold;
1454                 u32 hiwarn2high_treshold;
1455                 u32 hicat2high_treshold;
1456                 u32 hi2hicat_treshold;
1457                 u32 maximum_reading;
1458                 u8 sensor_state;
1459                 u16 event_enable;
1460         } result;
1461
1462         token = i2o_parm_field_get(d, 0xF200, -1, &result, sizeof(result));
1463
1464         if (token < 0) {
1465                 i2o_report_query_status(seq, token,
1466                                         "0xF200 Sensors (optional)");
1467                 return 0;
1468         }
1469
1470         seq_printf(seq, "Sensor instance       : %d\n", result.sensor_instance);
1471
1472         seq_printf(seq, "Component             : %d = ", result.component);
1473         switch (result.component) {
1474         case 0:
1475                 seq_printf(seq, "Other");
1476                 break;
1477         case 1:
1478                 seq_printf(seq, "Planar logic Board");
1479                 break;
1480         case 2:
1481                 seq_printf(seq, "CPU");
1482                 break;
1483         case 3:
1484                 seq_printf(seq, "Chassis");
1485                 break;
1486         case 4:
1487                 seq_printf(seq, "Power Supply");
1488                 break;
1489         case 5:
1490                 seq_printf(seq, "Storage");
1491                 break;
1492         case 6:
1493                 seq_printf(seq, "External");
1494                 break;
1495         }
1496         seq_printf(seq, "\n");
1497
1498         seq_printf(seq, "Component instance    : %d\n",
1499                    result.component_instance);
1500         seq_printf(seq, "Sensor class          : %s\n",
1501                    result.sensor_class ? "Analog" : "Digital");
1502
1503         seq_printf(seq, "Sensor type           : %d = ", result.sensor_type);
1504         switch (result.sensor_type) {
1505         case 0:
1506                 seq_printf(seq, "Other\n");
1507                 break;
1508         case 1:
1509                 seq_printf(seq, "Thermal\n");
1510                 break;
1511         case 2:
1512                 seq_printf(seq, "DC voltage (DC volts)\n");
1513                 break;
1514         case 3:
1515                 seq_printf(seq, "AC voltage (AC volts)\n");
1516                 break;
1517         case 4:
1518                 seq_printf(seq, "DC current (DC amps)\n");
1519                 break;
1520         case 5:
1521                 seq_printf(seq, "AC current (AC volts)\n");
1522                 break;
1523         case 6:
1524                 seq_printf(seq, "Door open\n");
1525                 break;
1526         case 7:
1527                 seq_printf(seq, "Fan operational\n");
1528                 break;
1529         }
1530
1531         seq_printf(seq, "Scaling exponent      : %d\n",
1532                    result.scaling_exponent);
1533         seq_printf(seq, "Actual reading        : %d\n", result.actual_reading);
1534         seq_printf(seq, "Minimum reading       : %d\n", result.minimum_reading);
1535         seq_printf(seq, "Low2LowCat treshold   : %d\n",
1536                    result.low2lowcat_treshold);
1537         seq_printf(seq, "LowCat2Low treshold   : %d\n",
1538                    result.lowcat2low_treshold);
1539         seq_printf(seq, "LowWarn2Low treshold  : %d\n",
1540                    result.lowwarn2low_treshold);
1541         seq_printf(seq, "Low2LowWarn treshold  : %d\n",
1542                    result.low2lowwarn_treshold);
1543         seq_printf(seq, "Norm2LowWarn treshold : %d\n",
1544                    result.norm2lowwarn_treshold);
1545         seq_printf(seq, "LowWarn2Norm treshold : %d\n",
1546                    result.lowwarn2norm_treshold);
1547         seq_printf(seq, "Nominal reading       : %d\n", result.nominal_reading);
1548         seq_printf(seq, "HiWarn2Norm treshold  : %d\n",
1549                    result.hiwarn2norm_treshold);
1550         seq_printf(seq, "Norm2HiWarn treshold  : %d\n",
1551                    result.norm2hiwarn_treshold);
1552         seq_printf(seq, "High2HiWarn treshold  : %d\n",
1553                    result.high2hiwarn_treshold);
1554         seq_printf(seq, "HiWarn2High treshold  : %d\n",
1555                    result.hiwarn2high_treshold);
1556         seq_printf(seq, "HiCat2High treshold   : %d\n",
1557                    result.hicat2high_treshold);
1558         seq_printf(seq, "High2HiCat treshold   : %d\n",
1559                    result.hi2hicat_treshold);
1560         seq_printf(seq, "Maximum reading       : %d\n", result.maximum_reading);
1561
1562         seq_printf(seq, "Sensor state          : %d = ", result.sensor_state);
1563         switch (result.sensor_state) {
1564         case 0:
1565                 seq_printf(seq, "Normal\n");
1566                 break;
1567         case 1:
1568                 seq_printf(seq, "Abnormal\n");
1569                 break;
1570         case 2:
1571                 seq_printf(seq, "Unknown\n");
1572                 break;
1573         case 3:
1574                 seq_printf(seq, "Low Catastrophic (LoCat)\n");
1575                 break;
1576         case 4:
1577                 seq_printf(seq, "Low (Low)\n");
1578                 break;
1579         case 5:
1580                 seq_printf(seq, "Low Warning (LoWarn)\n");
1581                 break;
1582         case 6:
1583                 seq_printf(seq, "High Warning (HiWarn)\n");
1584                 break;
1585         case 7:
1586                 seq_printf(seq, "High (High)\n");
1587                 break;
1588         case 8:
1589                 seq_printf(seq, "High Catastrophic (HiCat)\n");
1590                 break;
1591         }
1592
1593         seq_printf(seq, "Event_enable : 0x%02X\n", result.event_enable);
1594         seq_printf(seq, "    [%s] Operational state change. \n",
1595                    (result.event_enable & 0x01) ? "+" : "-");
1596         seq_printf(seq, "    [%s] Low catastrophic. \n",
1597                    (result.event_enable & 0x02) ? "+" : "-");
1598         seq_printf(seq, "    [%s] Low reading. \n",
1599                    (result.event_enable & 0x04) ? "+" : "-");
1600         seq_printf(seq, "    [%s] Low warning. \n",
1601                    (result.event_enable & 0x08) ? "+" : "-");
1602         seq_printf(seq,
1603                    "    [%s] Change back to normal from out of range state. \n",
1604                    (result.event_enable & 0x10) ? "+" : "-");
1605         seq_printf(seq, "    [%s] High warning. \n",
1606                    (result.event_enable & 0x20) ? "+" : "-");
1607         seq_printf(seq, "    [%s] High reading. \n",
1608                    (result.event_enable & 0x40) ? "+" : "-");
1609         seq_printf(seq, "    [%s] High catastrophic. \n",
1610                    (result.event_enable & 0x80) ? "+" : "-");
1611
1612         return 0;
1613 }
1614
1615 static int i2o_seq_open_hrt(struct inode *inode, struct file *file)
1616 {
1617         return single_open(file, i2o_seq_show_hrt, PDE(inode)->data);
1618 };
1619
1620 static int i2o_seq_open_lct(struct inode *inode, struct file *file)
1621 {
1622         return single_open(file, i2o_seq_show_lct, PDE(inode)->data);
1623 };
1624
1625 static int i2o_seq_open_status(struct inode *inode, struct file *file)
1626 {
1627         return single_open(file, i2o_seq_show_status, PDE(inode)->data);
1628 };
1629
1630 static int i2o_seq_open_hw(struct inode *inode, struct file *file)
1631 {
1632         return single_open(file, i2o_seq_show_hw, PDE(inode)->data);
1633 };
1634
1635 static int i2o_seq_open_ddm_table(struct inode *inode, struct file *file)
1636 {
1637         return single_open(file, i2o_seq_show_ddm_table, PDE(inode)->data);
1638 };
1639
1640 static int i2o_seq_open_driver_store(struct inode *inode, struct file *file)
1641 {
1642         return single_open(file, i2o_seq_show_driver_store, PDE(inode)->data);
1643 };
1644
1645 static int i2o_seq_open_drivers_stored(struct inode *inode, struct file *file)
1646 {
1647         return single_open(file, i2o_seq_show_drivers_stored, PDE(inode)->data);
1648 };
1649
1650 static int i2o_seq_open_groups(struct inode *inode, struct file *file)
1651 {
1652         return single_open(file, i2o_seq_show_groups, PDE(inode)->data);
1653 };
1654
1655 static int i2o_seq_open_phys_device(struct inode *inode, struct file *file)
1656 {
1657         return single_open(file, i2o_seq_show_phys_device, PDE(inode)->data);
1658 };
1659
1660 static int i2o_seq_open_claimed(struct inode *inode, struct file *file)
1661 {
1662         return single_open(file, i2o_seq_show_claimed, PDE(inode)->data);
1663 };
1664
1665 static int i2o_seq_open_users(struct inode *inode, struct file *file)
1666 {
1667         return single_open(file, i2o_seq_show_users, PDE(inode)->data);
1668 };
1669
1670 static int i2o_seq_open_priv_msgs(struct inode *inode, struct file *file)
1671 {
1672         return single_open(file, i2o_seq_show_priv_msgs, PDE(inode)->data);
1673 };
1674
1675 static int i2o_seq_open_authorized_users(struct inode *inode, struct file *file)
1676 {
1677         return single_open(file, i2o_seq_show_authorized_users,
1678                            PDE(inode)->data);
1679 };
1680
1681 static int i2o_seq_open_dev_identity(struct inode *inode, struct file *file)
1682 {
1683         return single_open(file, i2o_seq_show_dev_identity, PDE(inode)->data);
1684 };
1685
1686 static int i2o_seq_open_ddm_identity(struct inode *inode, struct file *file)
1687 {
1688         return single_open(file, i2o_seq_show_ddm_identity, PDE(inode)->data);
1689 };
1690
1691 static int i2o_seq_open_uinfo(struct inode *inode, struct file *file)
1692 {
1693         return single_open(file, i2o_seq_show_uinfo, PDE(inode)->data);
1694 };
1695
1696 static int i2o_seq_open_sgl_limits(struct inode *inode, struct file *file)
1697 {
1698         return single_open(file, i2o_seq_show_sgl_limits, PDE(inode)->data);
1699 };
1700
1701 static int i2o_seq_open_sensors(struct inode *inode, struct file *file)
1702 {
1703         return single_open(file, i2o_seq_show_sensors, PDE(inode)->data);
1704 };
1705
1706 static int i2o_seq_open_dev_name(struct inode *inode, struct file *file)
1707 {
1708         return single_open(file, i2o_seq_show_dev_name, PDE(inode)->data);
1709 };
1710
1711 static struct file_operations i2o_seq_fops_lct = {
1712         .open = i2o_seq_open_lct,
1713         .read = seq_read,
1714         .llseek = seq_lseek,
1715         .release = single_release,
1716 };
1717
1718 static struct file_operations i2o_seq_fops_hrt = {
1719         .open = i2o_seq_open_hrt,
1720         .read = seq_read,
1721         .llseek = seq_lseek,
1722         .release = single_release,
1723 };
1724
1725 static struct file_operations i2o_seq_fops_status = {
1726         .open = i2o_seq_open_status,
1727         .read = seq_read,
1728         .llseek = seq_lseek,
1729         .release = single_release,
1730 };
1731
1732 static struct file_operations i2o_seq_fops_hw = {
1733         .open = i2o_seq_open_hw,
1734         .read = seq_read,
1735         .llseek = seq_lseek,
1736         .release = single_release,
1737 };
1738
1739 static struct file_operations i2o_seq_fops_ddm_table = {
1740         .open = i2o_seq_open_ddm_table,
1741         .read = seq_read,
1742         .llseek = seq_lseek,
1743         .release = single_release,
1744 };
1745
1746 static struct file_operations i2o_seq_fops_driver_store = {
1747         .open = i2o_seq_open_driver_store,
1748         .read = seq_read,
1749         .llseek = seq_lseek,
1750         .release = single_release,
1751 };
1752
1753 static struct file_operations i2o_seq_fops_drivers_stored = {
1754         .open = i2o_seq_open_drivers_stored,
1755         .read = seq_read,
1756         .llseek = seq_lseek,
1757         .release = single_release,
1758 };
1759
1760 static struct file_operations i2o_seq_fops_groups = {
1761         .open = i2o_seq_open_groups,
1762         .read = seq_read,
1763         .llseek = seq_lseek,
1764         .release = single_release,
1765 };
1766
1767 static struct file_operations i2o_seq_fops_phys_device = {
1768         .open = i2o_seq_open_phys_device,
1769         .read = seq_read,
1770         .llseek = seq_lseek,
1771         .release = single_release,
1772 };
1773
1774 static struct file_operations i2o_seq_fops_claimed = {
1775         .open = i2o_seq_open_claimed,
1776         .read = seq_read,
1777         .llseek = seq_lseek,
1778         .release = single_release,
1779 };
1780
1781 static struct file_operations i2o_seq_fops_users = {
1782         .open = i2o_seq_open_users,
1783         .read = seq_read,
1784         .llseek = seq_lseek,
1785         .release = single_release,
1786 };
1787
1788 static struct file_operations i2o_seq_fops_priv_msgs = {
1789         .open = i2o_seq_open_priv_msgs,
1790         .read = seq_read,
1791         .llseek = seq_lseek,
1792         .release = single_release,
1793 };
1794
1795 static struct file_operations i2o_seq_fops_authorized_users = {
1796         .open = i2o_seq_open_authorized_users,
1797         .read = seq_read,
1798         .llseek = seq_lseek,
1799         .release = single_release,
1800 };
1801
1802 static struct file_operations i2o_seq_fops_dev_name = {
1803         .open = i2o_seq_open_dev_name,
1804         .read = seq_read,
1805         .llseek = seq_lseek,
1806         .release = single_release,
1807 };
1808
1809 static struct file_operations i2o_seq_fops_dev_identity = {
1810         .open = i2o_seq_open_dev_identity,
1811         .read = seq_read,
1812         .llseek = seq_lseek,
1813         .release = single_release,
1814 };
1815
1816 static struct file_operations i2o_seq_fops_ddm_identity = {
1817         .open = i2o_seq_open_ddm_identity,
1818         .read = seq_read,
1819         .llseek = seq_lseek,
1820         .release = single_release,
1821 };
1822
1823 static struct file_operations i2o_seq_fops_uinfo = {
1824         .open = i2o_seq_open_uinfo,
1825         .read = seq_read,
1826         .llseek = seq_lseek,
1827         .release = single_release,
1828 };
1829
1830 static struct file_operations i2o_seq_fops_sgl_limits = {
1831         .open = i2o_seq_open_sgl_limits,
1832         .read = seq_read,
1833         .llseek = seq_lseek,
1834         .release = single_release,
1835 };
1836
1837 static struct file_operations i2o_seq_fops_sensors = {
1838         .open = i2o_seq_open_sensors,
1839         .read = seq_read,
1840         .llseek = seq_lseek,
1841         .release = single_release,
1842 };
1843
1844 /*
1845  * IOP specific entries...write field just in case someone
1846  * ever wants one.
1847  */
1848 static i2o_proc_entry i2o_proc_generic_iop_entries[] = {
1849         {"hrt", S_IFREG | S_IRUGO, &i2o_seq_fops_hrt},
1850         {"lct", S_IFREG | S_IRUGO, &i2o_seq_fops_lct},
1851         {"status", S_IFREG | S_IRUGO, &i2o_seq_fops_status},
1852         {"hw", S_IFREG | S_IRUGO, &i2o_seq_fops_hw},
1853         {"ddm_table", S_IFREG | S_IRUGO, &i2o_seq_fops_ddm_table},
1854         {"driver_store", S_IFREG | S_IRUGO, &i2o_seq_fops_driver_store},
1855         {"drivers_stored", S_IFREG | S_IRUGO, &i2o_seq_fops_drivers_stored},
1856         {NULL, 0, NULL}
1857 };
1858
1859 /*
1860  * Device specific entries
1861  */
1862 static i2o_proc_entry generic_dev_entries[] = {
1863         {"groups", S_IFREG | S_IRUGO, &i2o_seq_fops_groups},
1864         {"phys_dev", S_IFREG | S_IRUGO, &i2o_seq_fops_phys_device},
1865         {"claimed", S_IFREG | S_IRUGO, &i2o_seq_fops_claimed},
1866         {"users", S_IFREG | S_IRUGO, &i2o_seq_fops_users},
1867         {"priv_msgs", S_IFREG | S_IRUGO, &i2o_seq_fops_priv_msgs},
1868         {"authorized_users", S_IFREG | S_IRUGO, &i2o_seq_fops_authorized_users},
1869         {"dev_identity", S_IFREG | S_IRUGO, &i2o_seq_fops_dev_identity},
1870         {"ddm_identity", S_IFREG | S_IRUGO, &i2o_seq_fops_ddm_identity},
1871         {"user_info", S_IFREG | S_IRUGO, &i2o_seq_fops_uinfo},
1872         {"sgl_limits", S_IFREG | S_IRUGO, &i2o_seq_fops_sgl_limits},
1873         {"sensors", S_IFREG | S_IRUGO, &i2o_seq_fops_sensors},
1874         {NULL, 0, NULL}
1875 };
1876
1877 /*
1878  *  Storage unit specific entries (SCSI Periph, BS) with device names
1879  */
1880 static i2o_proc_entry rbs_dev_entries[] = {
1881         {"dev_name", S_IFREG | S_IRUGO, &i2o_seq_fops_dev_name},
1882         {NULL, 0, NULL}
1883 };
1884
1885 /**
1886  *      i2o_proc_create_entries - Creates proc dir entries
1887  *      @dir: proc dir entry under which the entries should be placed
1888  *      @i2o_pe: pointer to the entries which should be added
1889  *      @data: pointer to I2O controller or device
1890  *
1891  *      Create proc dir entries for a I2O controller or I2O device.
1892  *
1893  *      Returns 0 on success or negative error code on failure.
1894  */
1895 static int i2o_proc_create_entries(struct proc_dir_entry *dir,
1896                                    i2o_proc_entry * i2o_pe, void *data)
1897 {
1898         struct proc_dir_entry *tmp;
1899
1900         while (i2o_pe->name) {
1901                 tmp = create_proc_entry(i2o_pe->name, i2o_pe->mode, dir);
1902                 if (!tmp)
1903                         return -1;
1904
1905                 tmp->data = data;
1906                 tmp->proc_fops = i2o_pe->fops;
1907
1908                 i2o_pe++;
1909         }
1910
1911         return 0;
1912 }
1913
1914 /**
1915  *      i2o_proc_subdir_remove - Remove child entries from a proc entry
1916  *      @dir: proc dir entry from which the childs should be removed
1917  *
1918  *      Iterate over each i2o proc entry under dir and remove it. If the child
1919  *      also has entries, remove them too.
1920  */
1921 static void i2o_proc_subdir_remove(struct proc_dir_entry *dir)
1922 {
1923         struct proc_dir_entry *pe, *tmp;
1924         pe = dir->subdir;
1925         while (pe) {
1926                 tmp = pe->next;
1927                 i2o_proc_subdir_remove(pe);
1928                 remove_proc_entry(pe->name, dir);
1929                 pe = tmp;
1930         }
1931 };
1932
1933 /**
1934  *      i2o_proc_device_add - Add an I2O device to the proc dir
1935  *      @dir: proc dir entry to which the device should be added
1936  *      @dev: I2O device which should be added
1937  *
1938  *      Add an I2O device to the proc dir entry dir and create the entries for
1939  *      the device depending on the class of the I2O device.
1940  */
1941 static void i2o_proc_device_add(struct proc_dir_entry *dir,
1942                                 struct i2o_device *dev)
1943 {
1944         char buff[10];
1945         struct proc_dir_entry *devdir;
1946         i2o_proc_entry *i2o_pe = NULL;
1947
1948         sprintf(buff, "%03x", dev->lct_data.tid);
1949
1950         pr_debug("Adding device /proc/i2o/iop%d/%s\n", dev->iop->unit, buff);
1951
1952         devdir = proc_mkdir(buff, dir);
1953         if (!devdir) {
1954                 printk(KERN_WARNING "i2o: Could not allocate procdir!\n");
1955                 return;
1956         }
1957
1958         devdir->data = dev;
1959
1960         i2o_proc_create_entries(devdir, generic_dev_entries, dev);
1961
1962         /* Inform core that we want updates about this device's status */
1963         switch (dev->lct_data.class_id) {
1964         case I2O_CLASS_SCSI_PERIPHERAL:
1965         case I2O_CLASS_RANDOM_BLOCK_STORAGE:
1966                 i2o_pe = rbs_dev_entries;
1967                 break;
1968         default:
1969                 break;
1970         }
1971         if (i2o_pe)
1972                 i2o_proc_create_entries(devdir, i2o_pe, dev);
1973 }
1974
1975 /**
1976  *      i2o_proc_iop_add - Add an I2O controller to the i2o proc tree
1977  *      @dir: parent proc dir entry
1978  *      @c: I2O controller which should be added
1979  *
1980  *      Add the entries to the parent proc dir entry. Also each device is added
1981  *      to the controllers proc dir entry.
1982  *
1983  *      Returns 0 on success or negative error code on failure.
1984  */
1985 static int i2o_proc_iop_add(struct proc_dir_entry *dir,
1986                             struct i2o_controller *c)
1987 {
1988         struct proc_dir_entry *iopdir;
1989         struct i2o_device *dev;
1990         char buff[10];
1991
1992         snprintf(buff, 10, "iop%d", c->unit);
1993
1994         pr_debug("Adding IOP /proc/i2o/%s\n", buff);
1995
1996         iopdir = proc_mkdir(buff, dir);
1997         if (!iopdir)
1998                 return -1;
1999
2000         iopdir->data = c;
2001
2002         i2o_proc_create_entries(iopdir, i2o_proc_generic_iop_entries, c);
2003
2004         list_for_each_entry(dev, &c->devices, list)
2005             i2o_proc_device_add(iopdir, dev);
2006
2007         return 0;
2008 }
2009
2010 /**
2011  *      i2o_proc_iop_remove - Removes an I2O controller from the i2o proc tree
2012  *      @dir: parent proc dir entry
2013  *      @c: I2O controller which should be removed
2014  *
2015  *      Iterate over each i2o proc entry and search controller c. If it is found
2016  *      remove it from the tree.
2017  */
2018 static void i2o_proc_iop_remove(struct proc_dir_entry *dir,
2019                                 struct i2o_controller *c)
2020 {
2021         struct proc_dir_entry *pe, *tmp;
2022
2023         pe = dir->subdir;
2024         while (pe) {
2025                 tmp = pe->next;
2026                 if (pe->data == c) {
2027                         i2o_proc_subdir_remove(pe);
2028                         remove_proc_entry(pe->name, dir);
2029                 }
2030                 pr_debug("Removing IOP /proc/i2o/iop%d\n", c->unit);
2031                 pe = tmp;
2032         }
2033 }
2034
2035 /**
2036  *      i2o_proc_fs_create - Create the i2o proc fs.
2037  *
2038  *      Iterate over each I2O controller and create the entries for it.
2039  *
2040  *      Returns 0 on success or negative error code on failure.
2041  */
2042 static int __init i2o_proc_fs_create(void)
2043 {
2044         struct i2o_controller *c;
2045
2046         i2o_proc_dir_root = proc_mkdir("i2o", NULL);
2047         if (!i2o_proc_dir_root)
2048                 return -1;
2049
2050         i2o_proc_dir_root->owner = THIS_MODULE;
2051
2052         list_for_each_entry(c, &i2o_controllers, list)
2053             i2o_proc_iop_add(i2o_proc_dir_root, c);
2054
2055         return 0;
2056 };
2057
2058 /**
2059  *      i2o_proc_fs_destroy - Cleanup the all i2o proc entries
2060  *
2061  *      Iterate over each I2O controller and remove the entries for it.
2062  *
2063  *      Returns 0 on success or negative error code on failure.
2064  */
2065 static int __exit i2o_proc_fs_destroy(void)
2066 {
2067         struct i2o_controller *c;
2068
2069         list_for_each_entry(c, &i2o_controllers, list)
2070             i2o_proc_iop_remove(i2o_proc_dir_root, c);
2071
2072         remove_proc_entry("i2o", NULL);
2073
2074         return 0;
2075 };
2076
2077 /**
2078  *      i2o_proc_init - Init function for procfs
2079  *
2080  *      Registers Proc OSM and creates procfs entries.
2081  *
2082  *      Returns 0 on success or negative error code on failure.
2083  */
2084 static int __init i2o_proc_init(void)
2085 {
2086         int rc;
2087
2088         rc = i2o_driver_register(&i2o_proc_driver);
2089         if (rc)
2090                 return rc;
2091
2092         rc = i2o_proc_fs_create();
2093         if (rc) {
2094                 i2o_driver_unregister(&i2o_proc_driver);
2095                 return rc;
2096         }
2097
2098         return 0;
2099 };
2100
2101 /**
2102  *      i2o_proc_exit - Exit function for procfs
2103  *
2104  *      Unregisters Proc OSM and removes procfs entries.
2105  */
2106 static void __exit i2o_proc_exit(void)
2107 {
2108         i2o_driver_unregister(&i2o_proc_driver);
2109         i2o_proc_fs_destroy();
2110 };
2111
2112 MODULE_AUTHOR("Deepak Saxena");
2113 MODULE_DESCRIPTION("I2O procfs Handler");
2114 MODULE_LICENSE("GPL");
2115
2116 module_init(i2o_proc_init);
2117 module_exit(i2o_proc_exit);