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);
473
|
This page was automatically generated by the
LXR engine.
|