[SCSI] mpt fusion: fix up msi_enable in mpt_suspend
[linux-2.6.git] / drivers / message / i2o / debug.c
1 #include <linux/module.h>
2 #include <linux/kernel.h>
3 #include <linux/pci.h>
4 #include <linux/i2o.h>
5
6 static void i2o_report_util_cmd(u8 cmd);
7 static void i2o_report_exec_cmd(u8 cmd);
8 static void i2o_report_fail_status(u8 req_status, u32 * msg);
9 static void i2o_report_common_status(u8 req_status);
10 static void i2o_report_common_dsc(u16 detailed_status);
11
12 /*
13  * Used for error reporting/debugging purposes.
14  * Report Cmd name, Request status, Detailed Status.
15  */
16 void i2o_report_status(const char *severity, const char *str,
17                        struct i2o_message *m)
18 {
19         u32 *msg = (u32 *) m;
20         u8 cmd = (msg[1] >> 24) & 0xFF;
21         u8 req_status = (msg[4] >> 24) & 0xFF;
22         u16 detailed_status = msg[4] & 0xFFFF;
23
24         if (cmd == I2O_CMD_UTIL_EVT_REGISTER)
25                 return;         // No status in this reply
26
27         printk("%s%s: ", severity, str);
28
29         if (cmd < 0x1F)         // Utility cmd
30                 i2o_report_util_cmd(cmd);
31
32         else if (cmd >= 0xA0 && cmd <= 0xEF)    // Executive cmd
33                 i2o_report_exec_cmd(cmd);
34         else
35                 printk("Cmd = %0#2x, ", cmd);   // Other cmds
36
37         if (msg[0] & MSG_FAIL) {
38                 i2o_report_fail_status(req_status, msg);
39                 return;
40         }
41
42         i2o_report_common_status(req_status);
43
44         if (cmd < 0x1F || (cmd >= 0xA0 && cmd <= 0xEF))
45                 i2o_report_common_dsc(detailed_status);
46         else
47                 printk(" / DetailedStatus = %0#4x.\n",
48                        detailed_status);
49 }
50
51 /* Used to dump a message to syslog during debugging */
52 void i2o_dump_message(struct i2o_message *m)
53 {
54 #ifdef DEBUG
55         u32 *msg = (u32 *) m;
56         int i;
57         printk(KERN_INFO "Dumping I2O message size %d @ %p\n",
58                msg[0] >> 16 & 0xffff, msg);
59         for (i = 0; i < ((msg[0] >> 16) & 0xffff); i++)
60                 printk(KERN_INFO "  msg[%d] = %0#10x\n", i, msg[i]);
61 #endif
62 }
63
64 /*
65  * Used for error reporting/debugging purposes.
66  * Following fail status are common to all classes.
67  * The preserved message must be handled in the reply handler.
68  */
69 static void i2o_report_fail_status(u8 req_status, u32 * msg)
70 {
71         static char *FAIL_STATUS[] = {
72                 "0x80",         /* not used */
73                 "SERVICE_SUSPENDED",    /* 0x81 */
74                 "SERVICE_TERMINATED",   /* 0x82 */
75                 "CONGESTION",
76                 "FAILURE",
77                 "STATE_ERROR",
78                 "TIME_OUT",
79                 "ROUTING_FAILURE",
80                 "INVALID_VERSION",
81                 "INVALID_OFFSET",
82                 "INVALID_MSG_FLAGS",
83                 "FRAME_TOO_SMALL",
84                 "FRAME_TOO_LARGE",
85                 "INVALID_TARGET_ID",
86                 "INVALID_INITIATOR_ID",
87                 "INVALID_INITIATOR_CONTEX",     /* 0x8F */
88                 "UNKNOWN_FAILURE"       /* 0xFF */
89         };
90
91         if (req_status == I2O_FSC_TRANSPORT_UNKNOWN_FAILURE)
92                 printk("TRANSPORT_UNKNOWN_FAILURE (%0#2x).\n",
93                        req_status);
94         else
95                 printk("TRANSPORT_%s.\n",
96                        FAIL_STATUS[req_status & 0x0F]);
97
98         /* Dump some details */
99
100         printk(KERN_ERR "  InitiatorId = %d, TargetId = %d\n",
101                (msg[1] >> 12) & 0xFFF, msg[1] & 0xFFF);
102         printk(KERN_ERR "  LowestVersion = 0x%02X, HighestVersion = 0x%02X\n",
103                (msg[4] >> 8) & 0xFF, msg[4] & 0xFF);
104         printk(KERN_ERR "  FailingHostUnit = 0x%04X,  FailingIOP = 0x%03X\n",
105                msg[5] >> 16, msg[5] & 0xFFF);
106
107         printk(KERN_ERR "  Severity:  0x%02X\n", (msg[4] >> 16) & 0xFF);
108         if (msg[4] & (1 << 16))
109                 printk(KERN_DEBUG "(FormatError), "
110                        "this msg can never be delivered/processed.\n");
111         if (msg[4] & (1 << 17))
112                 printk(KERN_DEBUG "(PathError), "
113                        "this msg can no longer be delivered/processed.\n");
114         if (msg[4] & (1 << 18))
115                 printk(KERN_DEBUG "(PathState), "
116                        "the system state does not allow delivery.\n");
117         if (msg[4] & (1 << 19))
118                 printk(KERN_DEBUG
119                        "(Congestion), resources temporarily not available;"
120                        "do not retry immediately.\n");
121 }
122
123 /*
124  * Used for error reporting/debugging purposes.
125  * Following reply status are common to all classes.
126  */
127 static void i2o_report_common_status(u8 req_status)
128 {
129         static char *REPLY_STATUS[] = {
130                 "SUCCESS",
131                 "ABORT_DIRTY",
132                 "ABORT_NO_DATA_TRANSFER",
133                 "ABORT_PARTIAL_TRANSFER",
134                 "ERROR_DIRTY",
135                 "ERROR_NO_DATA_TRANSFER",
136                 "ERROR_PARTIAL_TRANSFER",
137                 "PROCESS_ABORT_DIRTY",
138                 "PROCESS_ABORT_NO_DATA_TRANSFER",
139                 "PROCESS_ABORT_PARTIAL_TRANSFER",
140                 "TRANSACTION_ERROR",
141                 "PROGRESS_REPORT"
142         };
143
144         if (req_status >= ARRAY_SIZE(REPLY_STATUS))
145                 printk("RequestStatus = %0#2x", req_status);
146         else
147                 printk("%s", REPLY_STATUS[req_status]);
148 }
149
150 /*
151  * Used for error reporting/debugging purposes.
152  * Following detailed status are valid  for executive class,
153  * utility class, DDM class and for transaction error replies.
154  */
155 static void i2o_report_common_dsc(u16 detailed_status)
156 {
157         static char *COMMON_DSC[] = {
158                 "SUCCESS",
159                 "0x01",         // not used
160                 "BAD_KEY",
161                 "TCL_ERROR",
162                 "REPLY_BUFFER_FULL",
163                 "NO_SUCH_PAGE",
164                 "INSUFFICIENT_RESOURCE_SOFT",
165                 "INSUFFICIENT_RESOURCE_HARD",
166                 "0x08",         // not used
167                 "CHAIN_BUFFER_TOO_LARGE",
168                 "UNSUPPORTED_FUNCTION",
169                 "DEVICE_LOCKED",
170                 "DEVICE_RESET",
171                 "INAPPROPRIATE_FUNCTION",
172                 "INVALID_INITIATOR_ADDRESS",
173                 "INVALID_MESSAGE_FLAGS",
174                 "INVALID_OFFSET",
175                 "INVALID_PARAMETER",
176                 "INVALID_REQUEST",
177                 "INVALID_TARGET_ADDRESS",
178                 "MESSAGE_TOO_LARGE",
179                 "MESSAGE_TOO_SMALL",
180                 "MISSING_PARAMETER",
181                 "TIMEOUT",
182                 "UNKNOWN_ERROR",
183                 "UNKNOWN_FUNCTION",
184                 "UNSUPPORTED_VERSION",
185                 "DEVICE_BUSY",
186                 "DEVICE_NOT_AVAILABLE"
187         };
188
189         if (detailed_status > I2O_DSC_DEVICE_NOT_AVAILABLE)
190                 printk(" / DetailedStatus = %0#4x.\n",
191                        detailed_status);
192         else
193                 printk(" / %s.\n", COMMON_DSC[detailed_status]);
194 }
195
196 /*
197  * Used for error reporting/debugging purposes
198  */
199 static void i2o_report_util_cmd(u8 cmd)
200 {
201         switch (cmd) {
202         case I2O_CMD_UTIL_NOP:
203                 printk("UTIL_NOP, ");
204                 break;
205         case I2O_CMD_UTIL_ABORT:
206                 printk("UTIL_ABORT, ");
207                 break;
208         case I2O_CMD_UTIL_CLAIM:
209                 printk("UTIL_CLAIM, ");
210                 break;
211         case I2O_CMD_UTIL_RELEASE:
212                 printk("UTIL_CLAIM_RELEASE, ");
213                 break;
214         case I2O_CMD_UTIL_CONFIG_DIALOG:
215                 printk("UTIL_CONFIG_DIALOG, ");
216                 break;
217         case I2O_CMD_UTIL_DEVICE_RESERVE:
218                 printk("UTIL_DEVICE_RESERVE, ");
219                 break;
220         case I2O_CMD_UTIL_DEVICE_RELEASE:
221                 printk("UTIL_DEVICE_RELEASE, ");
222                 break;
223         case I2O_CMD_UTIL_EVT_ACK:
224                 printk("UTIL_EVENT_ACKNOWLEDGE, ");
225                 break;
226         case I2O_CMD_UTIL_EVT_REGISTER:
227                 printk("UTIL_EVENT_REGISTER, ");
228                 break;
229         case I2O_CMD_UTIL_LOCK:
230                 printk("UTIL_LOCK, ");
231                 break;
232         case I2O_CMD_UTIL_LOCK_RELEASE:
233                 printk("UTIL_LOCK_RELEASE, ");
234                 break;
235         case I2O_CMD_UTIL_PARAMS_GET:
236                 printk("UTIL_PARAMS_GET, ");
237                 break;
238         case I2O_CMD_UTIL_PARAMS_SET:
239                 printk("UTIL_PARAMS_SET, ");
240                 break;
241         case I2O_CMD_UTIL_REPLY_FAULT_NOTIFY:
242                 printk("UTIL_REPLY_FAULT_NOTIFY, ");
243                 break;
244         default:
245                 printk("Cmd = %0#2x, ", cmd);
246         }
247 }
248
249 /*
250  * Used for error reporting/debugging purposes
251  */
252 static void i2o_report_exec_cmd(u8 cmd)
253 {
254         switch (cmd) {
255         case I2O_CMD_ADAPTER_ASSIGN:
256                 printk("EXEC_ADAPTER_ASSIGN, ");
257                 break;
258         case I2O_CMD_ADAPTER_READ:
259                 printk("EXEC_ADAPTER_READ, ");
260                 break;
261         case I2O_CMD_ADAPTER_RELEASE:
262                 printk("EXEC_ADAPTER_RELEASE, ");
263                 break;
264         case I2O_CMD_BIOS_INFO_SET:
265                 printk("EXEC_BIOS_INFO_SET, ");
266                 break;
267         case I2O_CMD_BOOT_DEVICE_SET:
268                 printk("EXEC_BOOT_DEVICE_SET, ");
269                 break;
270         case I2O_CMD_CONFIG_VALIDATE:
271                 printk("EXEC_CONFIG_VALIDATE, ");
272                 break;
273         case I2O_CMD_CONN_SETUP:
274                 printk("EXEC_CONN_SETUP, ");
275                 break;
276         case I2O_CMD_DDM_DESTROY:
277                 printk("EXEC_DDM_DESTROY, ");
278                 break;
279         case I2O_CMD_DDM_ENABLE:
280                 printk("EXEC_DDM_ENABLE, ");
281                 break;
282         case I2O_CMD_DDM_QUIESCE:
283                 printk("EXEC_DDM_QUIESCE, ");
284                 break;
285         case I2O_CMD_DDM_RESET:
286                 printk("EXEC_DDM_RESET, ");
287                 break;
288         case I2O_CMD_DDM_SUSPEND:
289                 printk("EXEC_DDM_SUSPEND, ");
290                 break;
291         case I2O_CMD_DEVICE_ASSIGN:
292                 printk("EXEC_DEVICE_ASSIGN, ");
293                 break;
294         case I2O_CMD_DEVICE_RELEASE:
295                 printk("EXEC_DEVICE_RELEASE, ");
296                 break;
297         case I2O_CMD_HRT_GET:
298                 printk("EXEC_HRT_GET, ");
299                 break;
300         case I2O_CMD_ADAPTER_CLEAR:
301                 printk("EXEC_IOP_CLEAR, ");
302                 break;
303         case I2O_CMD_ADAPTER_CONNECT:
304                 printk("EXEC_IOP_CONNECT, ");
305                 break;
306         case I2O_CMD_ADAPTER_RESET:
307                 printk("EXEC_IOP_RESET, ");
308                 break;
309         case I2O_CMD_LCT_NOTIFY:
310                 printk("EXEC_LCT_NOTIFY, ");
311                 break;
312         case I2O_CMD_OUTBOUND_INIT:
313                 printk("EXEC_OUTBOUND_INIT, ");
314                 break;
315         case I2O_CMD_PATH_ENABLE:
316                 printk("EXEC_PATH_ENABLE, ");
317                 break;
318         case I2O_CMD_PATH_QUIESCE:
319                 printk("EXEC_PATH_QUIESCE, ");
320                 break;
321         case I2O_CMD_PATH_RESET:
322                 printk("EXEC_PATH_RESET, ");
323                 break;
324         case I2O_CMD_STATIC_MF_CREATE:
325                 printk("EXEC_STATIC_MF_CREATE, ");
326                 break;
327         case I2O_CMD_STATIC_MF_RELEASE:
328                 printk("EXEC_STATIC_MF_RELEASE, ");
329                 break;
330         case I2O_CMD_STATUS_GET:
331                 printk("EXEC_STATUS_GET, ");
332                 break;
333         case I2O_CMD_SW_DOWNLOAD:
334                 printk("EXEC_SW_DOWNLOAD, ");
335                 break;
336         case I2O_CMD_SW_UPLOAD:
337                 printk("EXEC_SW_UPLOAD, ");
338                 break;
339         case I2O_CMD_SW_REMOVE:
340                 printk("EXEC_SW_REMOVE, ");
341                 break;
342         case I2O_CMD_SYS_ENABLE:
343                 printk("EXEC_SYS_ENABLE, ");
344                 break;
345         case I2O_CMD_SYS_MODIFY:
346                 printk("EXEC_SYS_MODIFY, ");
347                 break;
348         case I2O_CMD_SYS_QUIESCE:
349                 printk("EXEC_SYS_QUIESCE, ");
350                 break;
351         case I2O_CMD_SYS_TAB_SET:
352                 printk("EXEC_SYS_TAB_SET, ");
353                 break;
354         default:
355                 printk("Cmd = %#02x, ", cmd);
356         }
357 }
358
359 void i2o_debug_state(struct i2o_controller *c)
360 {
361         printk(KERN_INFO "%s: State = ", c->name);
362         switch (((i2o_status_block *) c->status_block.virt)->iop_state) {
363         case 0x01:
364                 printk("INIT\n");
365                 break;
366         case 0x02:
367                 printk("RESET\n");
368                 break;
369         case 0x04:
370                 printk("HOLD\n");
371                 break;
372         case 0x05:
373                 printk("READY\n");
374                 break;
375         case 0x08:
376                 printk("OPERATIONAL\n");
377                 break;
378         case 0x10:
379                 printk("FAILED\n");
380                 break;
381         case 0x11:
382                 printk("FAULTED\n");
383                 break;
384         default:
385                 printk("%x (unknown !!)\n",
386                        ((i2o_status_block *) c->status_block.virt)->iop_state);
387         }
388 };
389
390 void i2o_dump_hrt(struct i2o_controller *c)
391 {
392         u32 *rows = (u32 *) c->hrt.virt;
393         u8 *p = (u8 *) c->hrt.virt;
394         u8 *d;
395         int count;
396         int length;
397         int i;
398         int state;
399
400         if (p[3] != 0) {
401                 printk(KERN_ERR
402                        "%s: HRT table for controller is too new a version.\n",
403                        c->name);
404                 return;
405         }
406
407         count = p[0] | (p[1] << 8);
408         length = p[2];
409
410         printk(KERN_INFO "%s: HRT has %d entries of %d bytes each.\n",
411                c->name, count, length << 2);
412
413         rows += 2;
414
415         for (i = 0; i < count; i++) {
416                 printk(KERN_INFO "Adapter %08X: ", rows[0]);
417                 p = (u8 *) (rows + 1);
418                 d = (u8 *) (rows + 2);
419                 state = p[1] << 8 | p[0];
420
421                 printk("TID %04X:[", state & 0xFFF);
422                 state >>= 12;
423                 if (state & (1 << 0))
424                         printk("H");    /* Hidden */
425                 if (state & (1 << 2)) {
426                         printk("P");    /* Present */
427                         if (state & (1 << 1))
428                                 printk("C");    /* Controlled */
429                 }
430                 if (state > 9)
431                         printk("*");    /* Hard */
432
433                 printk("]:");
434
435                 switch (p[3] & 0xFFFF) {
436                 case 0:
437                         /* Adapter private bus - easy */
438                         printk("Local bus %d: I/O at 0x%04X Mem 0x%08X", p[2],
439                                d[1] << 8 | d[0], *(u32 *) (d + 4));
440                         break;
441                 case 1:
442                         /* ISA bus */
443                         printk("ISA %d: CSN %d I/O at 0x%04X Mem 0x%08X", p[2],
444                                d[2], d[1] << 8 | d[0], *(u32 *) (d + 4));
445                         break;
446
447                 case 2: /* EISA bus */
448                         printk("EISA %d: Slot %d I/O at 0x%04X Mem 0x%08X",
449                                p[2], d[3], d[1] << 8 | d[0], *(u32 *) (d + 4));
450                         break;
451
452                 case 3: /* MCA bus */
453                         printk("MCA %d: Slot %d I/O at 0x%04X Mem 0x%08X", p[2],
454                                d[3], d[1] << 8 | d[0], *(u32 *) (d + 4));
455                         break;
456
457                 case 4: /* PCI bus */
458                         printk("PCI %d: Bus %d Device %d Function %d", p[2],
459                                d[2], d[1], d[0]);
460                         break;
461
462                 case 0x80:      /* Other */
463                 default:
464                         printk("Unsupported bus type.");
465                         break;
466                 }
467                 printk("\n");
468                 rows += length;
469         }
470 }
471
472 EXPORT_SYMBOL(i2o_dump_message);