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