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