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