linux/drivers/message/i2o/i2o_proc.c
<<
>>
Prefs
   1/*
   2 *      procfs handler for Linux I2O subsystem
   3 *
   4 *      (c) Copyright 1999      Deepak Saxena
   5 *
   6 *      Originally written by Deepak Saxena(deepak@plexity.net)
   7 *
   8 *      This program is free software; you can redistribute it and/or modify it
   9 *      under the terms of the GNU General Public License as published by the
  10 *      Free Software Foundation; either version 2 of the License, or (at your
  11 *      option) any later version.
  12 *
  13 *      This is an initial test release. The code is based on the design of the
  14 *      ide procfs system (drivers/block/ide-proc.c). Some code taken from
  15 *      i2o-core module by Alan Cox.
  16 *
  17 *      DISCLAIMER: This code is still under development/test and may cause
  18 *      your system to behave unpredictably.  Use at your own discretion.
  19 *
  20 *
  21 *      Fixes/additions:
  22 *              Juha Sievänen (Juha.Sievanen@cs.Helsinki.FI),
  23 *              Auvo Häkkinen (Auvo.Hakkinen@cs.Helsinki.FI)
  24 *              University of Helsinki, Department of Computer Science
  25 *                      LAN entries
  26 *              Markus Lidel <Markus.Lidel@shadowconnect.com>
  27 *                      Changes for new I2O API
  28 */
  29
  30#define OSM_NAME        "proc-osm"
  31#define OSM_VERSION     "1.316"
  32#define OSM_DESCRIPTION "I2O ProcFS OSM"
  33
  34#define I2O_MAX_MODULES 4
  35// FIXME!
  36#define FMT_U64_HEX "0x%08x%08x"
  37#define U64_VAL(pu64) *((u32*)(pu64)+1), *((u32*)(pu64))
  38
  39#include <linux/types.h>
  40#include <linux/kernel.h>
  41#include <linux/pci.h>
  42#include <linux/i2o.h>
  43#include <linux/slab.h>
  44#include <linux/proc_fs.h>
  45#include <linux/seq_file.h>
  46#include <linux/init.h>
  47#include <linux/module.h>
  48#include <linux/errno.h>
  49#include <linux/spinlock.h>
  50#include <linux/workqueue.h>
  51
  52#include <asm/io.h>
  53#include <asm/uaccess.h>
  54#include <asm/byteorder.h>
  55
  56/* Structure used to define /proc entries */
  57typedef 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 */
  64static struct proc_dir_entry *i2o_proc_dir_root;
  65
  66/* proc OSM driver struct */
  67static struct i2o_driver i2o_proc_driver = {
  68        .name = OSM_NAME,
  69};
  70
  71static 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 */
 164static 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
 242static 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
 258static char *chtostr(char *tmp, u8 *chars, int n)
 259{
 260        tmp[0] = 0;
 261        return strncat(tmp, (char *)chars, n);
 262}
 263
 264static 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
 281static char *bus_strings[] = {
 282        "Local Bus",
 283        "ISA",
 284        "EISA",
 285        "PCI",
 286        "PCMCIA",
 287        "NUBUS",
 288        "CARDBUS"
 289};
 290
 291static 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
 380static 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
 510static 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
 707static 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) */
 764static 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) */
 841static 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) */
 864static 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) */
 945static 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) */
1021static 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) */
1062static 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) */
1102static 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) */
1156static 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) */
1205static 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) */
1246static 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
1285static 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) */
1295static 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) */
1334static 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) */
1368static 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) */
1415static 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
1600static 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
1605static 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
1610static 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
1615static 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
1620static 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
1625static 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
1630static 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
1635static 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
1640static 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
1645static 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
1650static 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
1655static 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
1660static 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
1666static 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
1671static 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
1676static 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
1681static 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
1686static 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
1691static 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
1696static 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
1703static 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
1710static 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
1717static 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
1724static 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
1731static 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
1738static 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
1745static 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
1752static 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
1759static 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
1766static 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
1773static 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
1780static 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
1787static 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
1794static 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
1801static 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
1808static 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
1815static 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
1822static 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 */
1833static 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 */
1847static 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 */
1865static 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 */
1880static 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 */
1905static 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 */
1947static 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 */
1974static 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 */
1995static 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 */
2009static 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 */
2033static void __exit i2o_proc_exit(void)
2034{
2035        i2o_driver_unregister(&i2o_proc_driver);
2036        i2o_proc_fs_destroy();
2037};
2038
2039MODULE_AUTHOR("Deepak Saxena");
2040MODULE_LICENSE("GPL");
2041MODULE_DESCRIPTION(OSM_DESCRIPTION);
2042MODULE_VERSION(OSM_VERSION);
2043
2044module_init(i2o_proc_init);
2045module_exit(i2o_proc_exit);
2046