1#include <linux/module.h> 2#include <linux/kernel.h> 3#include <linux/pci.h> 4#include <linux/i2o.h> 5 6static void i2o_report_util_cmd(u8 cmd); 7static void i2o_report_exec_cmd(u8 cmd); 8static void i2o_report_fail_status(u8 req_status, u32 * msg); 9static void i2o_report_common_status(u8 req_status); 10static 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 */ 16void 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(KERN_DEBUG "%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(KERN_DEBUG "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(KERN_DEBUG " / DetailedStatus = %0#4x.\n", 48 detailed_status); 49} 50 51/* Used to dump a message to syslog during debugging */ 52void 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 */ 69static 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(KERN_DEBUG "TRANSPORT_UNKNOWN_FAILURE (%0#2x).\n", 93 req_status); 94 else 95 printk(KERN_DEBUG "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 ", (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 */ 127static 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(KERN_DEBUG "RequestStatus = %0#2x", req_status); 146 else 147 printk(KERN_DEBUG "%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 */ 155static 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(KERN_DEBUG " / DetailedStatus = %0#4x.\n", 191 detailed_status); 192 else 193 printk(KERN_DEBUG " / %s.\n", COMMON_DSC[detailed_status]); 194} 195 196/* 197 * Used for error reporting/debugging purposes 198 */ 199static void i2o_report_util_cmd(u8 cmd) 200{ 201 switch (cmd) { 202 case I2O_CMD_UTIL_NOP: 203 printk(KERN_DEBUG "UTIL_NOP, "); 204 break; 205 case I2O_CMD_UTIL_ABORT: 206 printk(KERN_DEBUG "UTIL_ABORT, "); 207 break; 208 case I2O_CMD_UTIL_CLAIM: 209 printk(KERN_DEBUG "UTIL_CLAIM, "); 210 break; 211 case I2O_CMD_UTIL_RELEASE: 212 printk(KERN_DEBUG "UTIL_CLAIM_RELEASE, "); 213 break; 214 case I2O_CMD_UTIL_CONFIG_DIALOG: 215 printk(KERN_DEBUG "UTIL_CONFIG_DIALOG, "); 216 break; 217 case I2O_CMD_UTIL_DEVICE_RESERVE: 218 printk(KERN_DEBUG "UTIL_DEVICE_RESERVE, "); 219 break; 220 case I2O_CMD_UTIL_DEVICE_RELEASE: 221 printk(KERN_DEBUG "UTIL_DEVICE_RELEASE, "); 222 break; 223 case I2O_CMD_UTIL_EVT_ACK: 224 printk(KERN_DEBUG "UTIL_EVENT_ACKNOWLEDGE, "); 225 break; 226 case I2O_CMD_UTIL_EVT_REGISTER: 227 printk(KERN_DEBUG "UTIL_EVENT_REGISTER, "); 228 break; 229 case I2O_CMD_UTIL_LOCK: 230 printk(KERN_DEBUG "UTIL_LOCK, "); 231 break; 232 case I2O_CMD_UTIL_LOCK_RELEASE: 233 printk(KERN_DEBUG "UTIL_LOCK_RELEASE, "); 234 break; 235 case I2O_CMD_UTIL_PARAMS_GET: 236 printk(KERN_DEBUG "UTIL_PARAMS_GET, "); 237 break; 238 case I2O_CMD_UTIL_PARAMS_SET: 239 printk(KERN_DEBUG "UTIL_PARAMS_SET, "); 240 break; 241 case I2O_CMD_UTIL_REPLY_FAULT_NOTIFY: 242 printk(KERN_DEBUG "UTIL_REPLY_FAULT_NOTIFY, "); 243 break; 244 default: 245 printk(KERN_DEBUG "Cmd = %0#2x, ", cmd); 246 } 247} 248 249/* 250 * Used for error reporting/debugging purposes 251 */ 252static void i2o_report_exec_cmd(u8 cmd) 253{ 254 switch (cmd) { 255 case I2O_CMD_ADAPTER_ASSIGN: 256 printk(KERN_DEBUG "EXEC_ADAPTER_ASSIGN, "); 257 break; 258 case I2O_CMD_ADAPTER_READ: 259 printk(KERN_DEBUG "EXEC_ADAPTER_READ, "); 260 break; 261 case I2O_CMD_ADAPTER_RELEASE: 262 printk(KERN_DEBUG "EXEC_ADAPTER_RELEASE, "); 263 break; 264 case I2O_CMD_BIOS_INFO_SET: 265 printk(KERN_DEBUG "EXEC_BIOS_INFO_SET, "); 266 break; 267 case I2O_CMD_BOOT_DEVICE_SET: 268 printk(KERN_DEBUG "EXEC_BOOT_DEVICE_SET, "); 269 break; 270 case I2O_CMD_CONFIG_VALIDATE: 271 printk(KERN_DEBUG "EXEC_CONFIG_VALIDATE, "); 272 break; 273 case I2O_CMD_CONN_SETUP: 274 printk(KERN_DEBUG "EXEC_CONN_SETUP, "); 275 break; 276 case I2O_CMD_DDM_DESTROY: 277 printk(KERN_DEBUG "EXEC_DDM_DESTROY, "); 278 break; 279 case I2O_CMD_DDM_ENABLE: 280 printk(KERN_DEBUG "EXEC_DDM_ENABLE, "); 281 break; 282 case I2O_CMD_DDM_QUIESCE: 283 printk(KERN_DEBUG "EXEC_DDM_QUIESCE, "); 284 break; 285 case I2O_CMD_DDM_RESET: 286 printk(KERN_DEBUG "EXEC_DDM_RESET, "); 287 break; 288 case I2O_CMD_DDM_SUSPEND: 289 printk(KERN_DEBUG "EXEC_DDM_SUSPEND, "); 290 break; 291 case I2O_CMD_DEVICE_ASSIGN: 292 printk(KERN_DEBUG "EXEC_DEVICE_ASSIGN, "); 293 break; 294 case I2O_CMD_DEVICE_RELEASE: 295 printk(KERN_DEBUG "EXEC_DEVICE_RELEASE, "); 296 break; 297 case I2O_CMD_HRT_GET: 298 printk(KERN_DEBUG "EXEC_HRT_GET, "); 299 break; 300 case I2O_CMD_ADAPTER_CLEAR: 301 printk(KERN_DEBUG "EXEC_IOP_CLEAR, "); 302 break; 303 case I2O_CMD_ADAPTER_CONNECT: 304 printk(KERN_DEBUG "EXEC_IOP_CONNECT, "); 305 break; 306 case I2O_CMD_ADAPTER_RESET: 307 printk(KERN_DEBUG "EXEC_IOP_RESET, "); 308 break; 309 case I2O_CMD_LCT_NOTIFY: 310 printk(KERN_DEBUG "EXEC_LCT_NOTIFY, "); 311 break; 312 case I2O_CMD_OUTBOUND_INIT: 313 printk(KERN_DEBUG "EXEC_OUTBOUND_INIT, "); 314 break; 315 case I2O_CMD_PATH_ENABLE: 316 printk(KERN_DEBUG "EXEC_PATH_ENABLE, "); 317 break; 318 case I2O_CMD_PATH_QUIESCE: 319 printk(KERN_DEBUG "EXEC_PATH_QUIESCE, "); 320 break; 321 case I2O_CMD_PATH_RESET: 322 printk(KERN_DEBUG "EXEC_PATH_RESET, "); 323 break; 324 case I2O_CMD_STATIC_MF_CREATE: 325 printk(KERN_DEBUG "EXEC_STATIC_MF_CREATE, "); 326 break; 327 case I2O_CMD_STATIC_MF_RELEASE: 328 printk(KERN_DEBUG "EXEC_STATIC_MF_RELEASE, "); 329 break; 330 case I2O_CMD_STATUS_GET: 331 printk(KERN_DEBUG "EXEC_STATUS_GET, "); 332 break; 333 case I2O_CMD_SW_DOWNLOAD: 334 printk(KERN_DEBUG "EXEC_SW_DOWNLOAD, "); 335 break; 336 case I2O_CMD_SW_UPLOAD: 337 printk(KERN_DEBUG "EXEC_SW_UPLOAD, "); 338 break; 339 case I2O_CMD_SW_REMOVE: 340 printk(KERN_DEBUG "EXEC_SW_REMOVE, "); 341 break; 342 case I2O_CMD_SYS_ENABLE: 343 printk(KERN_DEBUG "EXEC_SYS_ENABLE, "); 344 break; 345 case I2O_CMD_SYS_MODIFY: 346 printk(KERN_DEBUG "EXEC_SYS_MODIFY, "); 347 break; 348 case I2O_CMD_SYS_QUIESCE: 349 printk(KERN_DEBUG "EXEC_SYS_QUIESCE, "); 350 break; 351 case I2O_CMD_SYS_TAB_SET: 352 printk(KERN_DEBUG "EXEC_SYS_TAB_SET, "); 353 break; 354 default: 355 printk(KERN_DEBUG "Cmd = %#02x, ", cmd); 356 } 357} 358 359void 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(KERN_DEBUG "INIT\n"); 365 break; 366 case 0x02: 367 printk(KERN_DEBUG "RESET\n"); 368 break; 369 case 0x04: 370 printk(KERN_DEBUG "HOLD\n"); 371 break; 372 case 0x05: 373 printk(KERN_DEBUG "READY\n"); 374 break; 375 case 0x08: 376 printk(KERN_DEBUG "OPERATIONAL\n"); 377 break; 378 case 0x10: 379 printk(KERN_DEBUG "FAILED\n"); 380 break; 381 case 0x11: 382 printk(KERN_DEBUG "FAULTED\n"); 383 break; 384 default: 385 printk(KERN_DEBUG "%x (unknown !!)\n", 386 ((i2o_status_block *) c->status_block.virt)->iop_state); 387 } 388}; 389 390void 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 472EXPORT_SYMBOL(i2o_dump_message); 473