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