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