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);