1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 22 /* Copyright 2009 QLogic Corporation */ 23 24 /* 25 * Copyright 2009 Sun Microsystems, Inc. All rights reserved. 26 * Use is subject to license terms. 27 */ 28 29 #pragma ident "Copyright 2009 QLogic Corporation; ql_debug.c" 30 31 /* 32 * Qlogic ISP22xx/ISP23xx/ISP24xx FCA driver source 33 * 34 * *********************************************************************** 35 * * ** 36 * * NOTICE ** 37 * * COPYRIGHT (C) 1996-2009 QLOGIC CORPORATION ** 38 * * ALL RIGHTS RESERVED ** 39 * * ** 40 * *********************************************************************** 41 * 42 */ 43 44 #include <ql_apps.h> 45 #include <ql_api.h> 46 #include <ql_debug.h> 47 48 static int ql_flash_errlog_store(ql_adapter_state_t *, uint32_t *); 49 int ql_validate_trace_desc(ql_adapter_state_t *ha); 50 char *ql_find_trace_start(ql_adapter_state_t *ha); 51 52 /* 53 * Global Data. 54 */ 55 uint32_t el_message_number = 0; 56 uint32_t ql_enable_ellock = 0; 57 58 extern int getpcstack(pc_t *, int); 59 extern char *kobj_getsymname(uintptr_t, ulong_t *); 60 61 /* 62 * ql_dump_buffer 63 * Outputs buffer. 64 * 65 * Input: 66 * string: Null terminated string (no newline at end). 67 * buffer: buffer address. 68 * wd_size: word size 8 bits 69 * count: number of words. 70 */ 71 void 72 ql_dump_buffer(uint8_t *b8, uint8_t wd_size, uint32_t count) 73 { 74 uint32_t cnt; 75 char str[256], *sp; 76 uint32_t *b32 = (uint32_t *)b8; 77 uint16_t *b16 = (uint16_t *)b8; 78 79 sp = &str[0]; 80 81 switch (wd_size) { 82 case 32: 83 cmn_err(CE_CONT, " 0 4 8 C\n"); 84 cmn_err(CE_CONT, "----------------------------------------\n"); 85 86 for (cnt = 1; cnt <= count; cnt++) { 87 (void) sprintf(sp, "%10x", *b32++); 88 sp += 10; 89 if (cnt % 4 == 0) { 90 cmn_err(CE_CONT, "%s\n", str); 91 sp = &str[0]; 92 } 93 } 94 break; 95 case 16: 96 cmn_err(CE_CONT, " 0 2 4 6 8 A C" 97 " E\n"); 98 cmn_err(CE_CONT, "------------------------------------------" 99 "------\n"); 100 101 for (cnt = 1; cnt <= count; cnt++) { 102 (void) sprintf(sp, "%6x", *b16++); 103 sp += 6; 104 if (cnt % 8 == 0) { 105 cmn_err(CE_CONT, "%s\n", str); 106 sp = &str[0]; 107 } 108 } 109 break; 110 case 8: 111 cmn_err(CE_CONT, " 0 1 2 3 4 5 6 7 8 9 " 112 "A B C D E F\n"); 113 cmn_err(CE_CONT, "---------------------------------" 114 "-------------------------------\n"); 115 116 for (cnt = 1; cnt <= count; cnt++) { 117 (void) sprintf(sp, "%4x", *b8++); 118 sp += 4; 119 if (cnt % 16 == 0) { 120 cmn_err(CE_CONT, "%s\n", str); 121 sp = &str[0]; 122 } 123 } 124 break; 125 default: 126 break; 127 } 128 if (sp != &str[0]) { 129 cmn_err(CE_CONT, "%s\n", str); 130 } 131 } 132 133 /* 134 * ql_el_msg 135 * Extended logging message 136 * 137 * Input: 138 * ha: adapter state pointer. 139 * fn: function name. 140 * ce: level 141 * ...: Variable argument list. 142 * 143 * Context: 144 * Kernel/Interrupt context. 145 */ 146 void 147 ql_el_msg(ql_adapter_state_t *ha, const char *fn, int ce, ...) 148 { 149 uint32_t el_msg_num; 150 char *s, *fmt = 0, *fmt1 = 0; 151 char fmt2[256]; 152 int rval, tmp; 153 int tracing = 0; 154 va_list vl; 155 156 /* Tracing is the default but it can be disabled. */ 157 if ((CFG_IST(ha, CFG_DISABLE_EXTENDED_LOGGING_TRACE) == 0) && 158 (rval = ql_validate_trace_desc(ha) == DDI_SUCCESS)) { 159 tracing = 1; 160 161 TRACE_BUFFER_LOCK(ha); 162 163 /* 164 * Ensure enough space for the string. Wrap to 165 * start when default message allocation size 166 * would overrun the end. 167 */ 168 if ((ha->el_trace_desc->next + EL_BUFFER_RESERVE) >= 169 ha->el_trace_desc->trace_buffer_size) { 170 fmt = ha->el_trace_desc->trace_buffer; 171 ha->el_trace_desc->next = 0; 172 } else { 173 fmt = ha->el_trace_desc->trace_buffer + 174 ha->el_trace_desc->next; 175 } 176 } 177 /* if no buffer use the stack */ 178 if (fmt == NULL) { 179 fmt = fmt2; 180 } 181 182 va_start(vl, ce); 183 184 s = va_arg(vl, char *); 185 186 if (ql_enable_ellock) { 187 /* 188 * Used when messages are *maybe* being lost. Adds 189 * a unique number to the message so one can see if 190 * any messages have been dropped. NB: This slows 191 * down the driver, which may make the issue disappear. 192 */ 193 GLOBAL_EL_LOCK(); 194 el_msg_num = ++el_message_number; 195 GLOBAL_EL_UNLOCK(); 196 197 rval = (int)snprintf(fmt, (size_t)EL_BUFFER_RESERVE, 198 QL_BANG "QEL%d %s(%d,%d): %s, ", el_msg_num, QL_NAME, 199 ha->instance, ha->vp_index, fn); 200 fmt1 = fmt + rval; 201 tmp = (int)vsnprintf(fmt1, 202 (size_t)(uint32_t)((int)EL_BUFFER_RESERVE - rval), s, vl); 203 rval += tmp; 204 } else { 205 rval = (int)snprintf(fmt, (size_t)EL_BUFFER_RESERVE, 206 QL_BANG "QEL %s(%d,%d): %s, ", QL_NAME, ha->instance, 207 ha->vp_index, fn); 208 fmt1 = fmt + rval; 209 tmp = (int)vsnprintf(fmt1, 210 (size_t)(uint32_t)((int)EL_BUFFER_RESERVE - rval), s, vl); 211 rval += tmp; 212 } 213 214 /* 215 * Calculate the offset where the next message will go, 216 * skipping the NULL. 217 */ 218 if (tracing) { 219 uint16_t next = (uint16_t)(rval += 1); 220 ha->el_trace_desc->next += next; 221 TRACE_BUFFER_UNLOCK(ha); 222 } 223 224 if (CFG_IST(ha, CFG_ENABLE_EXTENDED_LOGGING)) { 225 cmn_err(ce, fmt); 226 } 227 228 va_end(vl); 229 } 230 231 /* 232 * ql_el_msg 233 * Extended logging message 234 * 235 * Input: 236 * ha: adapter state pointer. 237 * fn: function name. 238 * ce: level 239 * ...: Variable argument list. 240 * 241 * Context: 242 * Kernel/Interrupt context. 243 */ 244 void 245 ql_dbg_msg(const char *fn, int ce, ...) 246 { 247 uint32_t el_msg_num; 248 char *s; 249 char fmt[256]; 250 va_list vl; 251 252 va_start(vl, ce); 253 254 s = va_arg(vl, char *); 255 256 if (ql_enable_ellock) { 257 /* 258 * Used when messages are *maybe* being lost. Adds 259 * a unique number to the message to one can see if 260 * any messages have been dropped. NB: This slows 261 * down the driver, which may make the issue disappear. 262 */ 263 GLOBAL_EL_LOCK(); 264 el_msg_num = ++el_message_number; 265 GLOBAL_EL_UNLOCK(); 266 (void) snprintf(fmt, EL_BUFFER_RESERVE, "QLP%d: %s %s, %s", 267 el_msg_num, QL_NAME, fn, s); 268 } else { 269 (void) snprintf(fmt, EL_BUFFER_RESERVE, "QLP: %s %s, %s", 270 QL_NAME, fn, s); 271 } 272 273 vcmn_err(ce, fmt, vl); 274 275 va_end(vl); 276 } 277 278 /* 279 * ql_stacktrace 280 * Prints out current stack 281 * 282 * Input: 283 * ha: adapter state pointer. 284 * 285 * Context: 286 * Kernel/Interrupt context. 287 */ 288 void 289 ql_stacktrace(ql_adapter_state_t *ha) 290 { 291 int depth, i; 292 pc_t pcstack[DEBUG_STK_DEPTH]; 293 char *sym = NULL; 294 ulong_t off; 295 296 depth = getpcstack(&pcstack[0], DEBUG_STK_DEPTH); 297 298 cmn_err(CE_CONT, "%s(%d,%d): ---------- \n", QL_NAME, ha->instance, 299 ha->vp_index); 300 for (i = 0; i < MIN(depth, DEBUG_STK_DEPTH); i++) { 301 sym = kobj_getsymname((uintptr_t)pcstack[i], &off); 302 303 if (sym == NULL) { 304 cmn_err(CE_CONT, "%s(%d,%d): sym is NULL\n", QL_NAME, 305 ha->instance, ha->vp_index); 306 } else { 307 cmn_err(CE_CONT, "%s(%d,%d): %s+%lx\n", QL_NAME, 308 ha->instance, ha->vp_index, sym ? sym : "?", off); 309 } 310 } 311 cmn_err(CE_CONT, "%s(%d,%d): ---------- \n", QL_NAME, ha->instance, 312 ha->vp_index); 313 } 314 315 /* 316 * ql_flash_errlog 317 * Adds error to flash error log. 318 * Entry Layout: 319 * uint32_t TimeStamp; 320 * uint16_t CodeData[4]; 321 * 322 * Input: 323 * ha: adapter state pointer. 324 * code: Error code 325 * d1-d3: Error code data 326 * 327 * Returns: 328 * ql local function return status code. 329 * 330 * Context: 331 * Kernel/Interrupt context. 332 */ 333 int 334 ql_flash_errlog(ql_adapter_state_t *ha, uint16_t code, uint16_t d1, 335 uint16_t d2, uint16_t d3) 336 { 337 char *s; 338 uint32_t marker[2], fdata[2], faddr; 339 int rval; 340 341 QL_PRINT_3(CE_CONT, "(%d): started\n", ha->instance); 342 343 if (ha->flash_errlog_start == 0) { 344 return (QL_NOT_SUPPORTED); 345 } 346 347 EL(ha, "code=%xh, d1=%xh, d2=%xh, d3=%xh\n", code, d1, d2, d3); 348 349 /* 350 * If marker not already found, locate or write marker. 351 */ 352 if (!(ha->flags & FLASH_ERRLOG_MARKER)) { 353 354 /* Create marker. */ 355 marker[0] = CHAR_TO_LONG(ha->fw_subminor_version, 356 ha->fw_minor_version, ha->fw_major_version, 'S'); 357 358 /* 359 * Version should be of the format: YYYYMMDD-v.vv 360 */ 361 if ((strlen(QL_VERSION) > 9) && (QL_VERSION[8] == '-')) { 362 s = &QL_VERSION[9]; 363 } else { 364 s = QL_VERSION; 365 } 366 367 for (marker[1] = 0; *s != '\0'; s++) { 368 if (*s >= '0' && *s <= '9') { 369 marker[1] <<= 4; 370 marker[1] |= *s - '0'; 371 } else if (*s != '.') { 372 break; 373 } 374 } 375 376 /* Locate marker. */ 377 ha->flash_errlog_ptr = ha->flash_errlog_start; 378 for (;;) { 379 faddr = ha->flash_data_addr | ha->flash_errlog_ptr; 380 (void) ql_24xx_read_flash(ha, faddr++, &fdata[0]); 381 (void) ql_24xx_read_flash(ha, faddr++, &fdata[1]); 382 if (fdata[0] == 0xffffffff && fdata[1] == 0xffffffff) { 383 break; 384 } 385 (void) ql_24xx_read_flash(ha, faddr++, &fdata[0]); 386 (void) ql_24xx_read_flash(ha, faddr++, &fdata[1]); 387 ha->flash_errlog_ptr += FLASH_ERRLOG_ENTRY_SIZE; 388 if (ha->flash_errlog_ptr >= 389 ha->flash_errlog_start + FLASH_ERRLOG_SIZE) { 390 EL(ha, "log full\n"); 391 return (QL_MEMORY_FULL); 392 } 393 if (fdata[0] == marker[0] && fdata[1] == marker[1]) { 394 ha->flags |= FLASH_ERRLOG_MARKER; 395 break; 396 } 397 } 398 399 /* No marker, write it. */ 400 if (!(ha->flags & FLASH_ERRLOG_MARKER)) { 401 ha->flags |= FLASH_ERRLOG_MARKER; 402 rval = ql_flash_errlog_store(ha, marker); 403 if (rval != QL_SUCCESS) { 404 EL(ha, "failed marker write=%xh\n", rval); 405 return (rval); 406 } 407 } 408 } 409 410 /* 411 * Store error. 412 */ 413 fdata[0] = SHORT_TO_LONG(d1, code); 414 fdata[1] = SHORT_TO_LONG(d3, d2); 415 rval = ql_flash_errlog_store(ha, fdata); 416 if (rval != QL_SUCCESS) { 417 EL(ha, "failed error write=%xh\n", rval); 418 } else { 419 /*EMPTY*/ 420 QL_PRINT_3(CE_CONT, "(%d): done\n", ha->instance); 421 } 422 423 return (rval); 424 } 425 426 /* 427 * ql_flash_errlog_store 428 * Stores error to flash. 429 * Entry Layout: 430 * uint32_t TimeStamp; 431 * uint16_t CodeData[4]; 432 * 433 * Input: 434 * ha: adapter state pointer. 435 * fdata: Error code plus data. 436 * ha->flash_errlog_ptr: Current Flash error pointer. 437 * 438 * Output: 439 * ha->flash_errlog_ptr: updated pointer. 440 * 441 * Returns: 442 * ql local function return status code. 443 * 444 * Context: 445 * Kernel/Interrupt context. 446 */ 447 static int 448 ql_flash_errlog_store(ql_adapter_state_t *ha, uint32_t *fdata) 449 { 450 int rval; 451 uint64_t time; 452 uint32_t d1, d2, faddr; 453 454 QL_PRINT_3(CE_CONT, "(%d): started\n", ha->instance); 455 456 /* Locate first empty entry */ 457 for (;;) { 458 if (ha->flash_errlog_ptr >= 459 ha->flash_errlog_start + FLASH_ERRLOG_SIZE) { 460 EL(ha, "log full\n"); 461 return (QL_MEMORY_FULL); 462 } 463 464 faddr = ha->flash_data_addr | ha->flash_errlog_ptr; 465 ha->flash_errlog_ptr += FLASH_ERRLOG_ENTRY_SIZE; 466 (void) ql_24xx_read_flash(ha, faddr, &d1); 467 (void) ql_24xx_read_flash(ha, faddr + 1, &d2); 468 if (d1 == 0xffffffff && d2 == 0xffffffff) { 469 (void) drv_getparm(TIME, &time); 470 471 /* Enable flash write. */ 472 if ((rval = ql_24xx_unprotect_flash(ha)) != 473 QL_SUCCESS) { 474 EL(ha, "unprotect_flash failed, rval=%xh\n", 475 rval); 476 return (rval); 477 } 478 479 (void) ql_24xx_write_flash(ha, faddr++, LSD(time)); 480 (void) ql_24xx_write_flash(ha, faddr++, MSD(time)); 481 (void) ql_24xx_write_flash(ha, faddr++, *fdata++); 482 (void) ql_24xx_write_flash(ha, faddr++, *fdata); 483 484 /* Enable flash write-protection. */ 485 ql_24xx_protect_flash(ha); 486 break; 487 } 488 } 489 490 QL_PRINT_3(CE_CONT, "(%d): done\n", ha->instance); 491 492 return (QL_SUCCESS); 493 } 494 495 /* 496 * ql_dump_el_trace_buffer 497 * Outputs extended logging trace buffer. 498 * 499 * Input: 500 * ha: adapter state pointer. 501 */ 502 void 503 ql_dump_el_trace_buffer(ql_adapter_state_t *ha) 504 { 505 char *dump_start = NULL; 506 char *dump_current = NULL; 507 char *trace_start; 508 char *trace_end; 509 int wrapped = 0; 510 int rval; 511 512 TRACE_BUFFER_LOCK(ha); 513 514 rval = ql_validate_trace_desc(ha); 515 if (rval != 0) { 516 cmn_err(CE_CONT, "%s(%d) Dump EL trace - invalid desc\n", 517 QL_NAME, ha->instance); 518 } else if ((dump_start = ql_find_trace_start(ha)) != NULL) { 519 dump_current = dump_start; 520 trace_start = ha->el_trace_desc->trace_buffer; 521 trace_end = trace_start + 522 ha->el_trace_desc->trace_buffer_size; 523 524 cmn_err(CE_CONT, "%s(%d) Dump EL trace - start %p %p\n", 525 QL_NAME, ha->instance, 526 (void *)dump_start, (void *)trace_start); 527 528 while (((uintptr_t)dump_current - (uintptr_t)trace_start) <= 529 (uintptr_t)ha->el_trace_desc->trace_buffer_size) { 530 /* Show it... */ 531 cmn_err(CE_CONT, "%p - %s", (void *)dump_current, 532 dump_current); 533 /* Make the next the current */ 534 dump_current += (strlen(dump_current) + 1); 535 /* check for wrap */ 536 if ((dump_current + EL_BUFFER_RESERVE) >= trace_end) { 537 dump_current = trace_start; 538 wrapped = 1; 539 } else if (wrapped) { 540 /* Don't go past next. */ 541 if ((trace_start + ha->el_trace_desc->next) <= 542 dump_current) { 543 break; 544 } 545 } else if (*dump_current == '\0') { 546 break; 547 } 548 } 549 } 550 TRACE_BUFFER_UNLOCK(ha); 551 } 552 553 /* 554 * ql_validate_trace_desc 555 * Ensures the extended logging trace descriptor is good 556 * 557 * Input: 558 * ha: adapter state pointer. 559 * 560 * Returns: 561 * ql local function return status code. 562 */ 563 int 564 ql_validate_trace_desc(ql_adapter_state_t *ha) 565 { 566 int rval = DDI_SUCCESS; 567 568 if (ha->el_trace_desc == NULL) { 569 rval = DDI_FAILURE; 570 } else if (ha->el_trace_desc->trace_buffer == NULL) { 571 rval = DDI_FAILURE; 572 } 573 return (rval); 574 } 575 576 /* 577 * ql_find_trace_start 578 * Locate the oldest extended logging trace entry. 579 * 580 * Input: 581 * ha: adapter state pointer. 582 * 583 * Returns: 584 * Pointer to a string. 585 * 586 * Context: 587 * Kernel/Interrupt context. 588 */ 589 char * 590 ql_find_trace_start(ql_adapter_state_t *ha) 591 { 592 char *trace_start = 0; 593 char *trace_next = 0; 594 595 trace_next = ha->el_trace_desc->trace_buffer + ha->el_trace_desc->next; 596 597 /* 598 * if the buffer has not wrapped next will point at a null so 599 * start is the beginning of the buffer. if next points at a char 600 * then we must traverse the buffer until a null is detected and 601 * that will be the beginning of the oldest whole object in the buffer 602 * which is the start. 603 */ 604 605 if ((trace_next + EL_BUFFER_RESERVE) >= 606 (ha->el_trace_desc->trace_buffer + 607 ha->el_trace_desc->trace_buffer_size)) { 608 trace_start = ha->el_trace_desc->trace_buffer; 609 } else if (*trace_next != '\0') { 610 trace_start = trace_next + (strlen(trace_next) + 1); 611 } else { 612 trace_start = ha->el_trace_desc->trace_buffer; 613 } 614 return (trace_start); 615 } 616