| Attached, is a list of all messages that a 4100/4000 SRM console might
print to the console display device (as of the V4.8-5 console release)
or internal RAM-based event log file. No distinction is made between
error and informational messages in the attached list, though generally
speaking:
* err_printf is always used for error messages (STDERR),
* printf is used for informational messages (STDOUT),
* qprintf is used to dump info/error messages to the event log (EL),
* pprintf is used for either informational or error messages, and
* fprintf is used for file printfs.
Many of the messages in the attached would never be used by the
4100/4000 console, but they are found in files shared with other
AlphaServer platforms. Only source files actually used to build the
AlphaServer 4100/4000 (V4.8-5) SRM console were searched.
Finally, an excerpt from generic_messages.c is included at the end of
this note. The console either prints directly (text included in print
statement) or indirectly (using message strings in the generic_messages
file, e.g. msg_bad_filename..)
File: alphamm.c
err_printf ("%X: PFN out of range\n", pfn);
File: ansi.c
printf ("il=%d pv=%d err=%d\n", as->il_overfl, as->pv_overfl, as->error);
printf ("%s ", state_strings [as->states [i]]);
printf ("c=%c pchar=%c\n", as->c, as->pchar);
printf ("pvc (%d) ", as->pvc);
printf ("%d ", as->pval [i]);
printf ("ilc (%d) ", as->ilc);
printf ("%02X ", as->ilist [i]);
printf ("%02X ", (unsigned int) *ip & 0x0000000ff);
printf ("%s", buf);
printf ("ESC: %02X\n", (unsigned int) as->c & 0xff);
printf ("CSI: %02X\n", (unsigned int) as->c & 0xff);
printf ("SS2: %02X\n", (unsigned int) as->c & 0xff);
printf ("SS3: %02X\n", (unsigned int) as->c & 0xff);
printf ("DEF: %02X\n", (unsigned int) as->c & 0xff);
err_printf( "KBIN assign failed. code = %X\n", errorcode);
File: atoi.c
printf ("%08X %s\n", atoi_test (argv [argix]), argv [argix]);
File: cb_sb_ee_log.c
err_printf(msg_insuff_params);
err_printf(msg_fname_unknown, argv[1]);
err_printf(msg_fname_unknown, argv[2]);
err_printf(msg_fname_unknown, argv[4]);
err_printf(msg_bad_open, device);
err_printf(msg_dep_devwriteerr,
err_printf(msg_fname_unknown,string);
err_printf(msg_fname_ununique,string);
err_printf(msg_fname_unknown, ser_num);
err_printf(msg_fname_unknown, ser_num);
err_printf(msg_fname_unknown, ser_num);
err_printf(msg_fname_unknown, ser_num);
err_printf(msg_fname_unknown, ser_num);
File: device.c
pprintf("strcmp :%s:%s:\n",c,pathname(dev,pt) );
pprintf("%s is not emulated\n", dev->tbl->mnemonic );
printf(" %s%d, hose %d, bus %d, slot %d", dev->tbl->mnemonic,
printf(" function %d\n", dev->function );
printf( poll_message );
printf(" %s%d - initialization failure\n",dev->tbl->mnemonic, dev->unit);
printf(" %s\n", pb->info );
err_printf("Missing config routine %s\n", dev->tbl->name);
printf( poll_message );
printf(" %s%d - initialization failure\n",dev->tbl->mnemonic, dev->unit);
printf(" %s\n", pb->info );
printf("Shutting down units on %s%d, slot %d, bus %d, hose %d...\n",
err_printf (status);
printf("No such device\n");
printf("Device not configurable\n");
printf("Shutting down units on %s%d, slot %d, bus %d hose %d...\n",
qprintf("Created device: %s\n", fullname);
err_printf(msg_invalid_unit);
err_printf(msg_unk_bootdev_class);
err_printf(msg_controller_not_found, iname);
err_printf(msg_invalid_slot);
err_printf(msg_invalid_hose);
err_printf(msg_invalid_devname, iname);
err_printf("Unknown protocol %s\n", protocol);
pprintf("file2dev: %s\n", fname);
pprintf("file2dev: %s\n", dname);
pprintf("dev2file: %s\n", dname);
pprintf("dev2file: %s\n", fname);
pprintf("configuring I/O adapters...\n");
pprintf(" pci_nvram0, hose %d, bus %d, slot %d\n", dev->hose, dev->bus, dev->slot);
File: dynamic.c
pprintf ("Not on a %d byte boundary\n", DYN$K_GRAN);
qprintf ("Zone %08X had %d bytes allocated when freed\n", zp, zp->allocated);
pprintf ("dyn$_expand: not on a %d byte boundary\n", DYN$K_GRAN);
pprintf ("dyn$_expand: size %d is not a multiple of %d\n", size, DYN$K_GRAN);
pprintf (msg_insuff_mem, size);
pprintf("Operator intervention required : increase heap_expand environment variable\n");
pprintf( "pid %x (%s) pc %08X requested %5d got %5d adr %08X\n",
pprintf ("%08X trapped by dyn$_malloc in %s at %08X\n",
err_printf ("process %s %08X freeing a null pointer\n",
pprintf ("%08X trapped by dyn$_free in %s at %08X\n",
err_printf ("Block %08X is not in any zone\n", p);
pprintf("pid %x (%s) pc %08X free adr %08X %d\n",
print = pprintf;
print = printf;
pprintf("Unable to initialize CONZONE. Insufficient memory.\n");
qprintf("Initializing CONZONE starting at address %x of size %x\n", i, j);
pprintf("Unable to malloc Conzone pointer\n");
File: entry.c
pprintf( "\nCPU %d restarting\n\n", id );
printf ("WARNING...\n CPU speed different than primary\n");
printf ("WARNING...\n CPU cache size different than primary\n");
pprintf( "\nCPU %d requesting primary to boot\n\n", id );
pprintf( "\nCPU %d booting\n\n", id );
pprintf ("booting not supported in loadable console\n");
pprintf( "boot failure\n" );
pprintf( "boot failure\n" );
File: filesys.c
qprintf ("calling module %s\n", dstp->name);
qprintf ("%08X exit status for %s_init\n", status, dstp->name);
qprintf ("exiting module %s\n", dstp->name);
qprintf (msg_init_port, dstp->name);
qprintf (msg_port_inited, dstp->name);
qprintf (msg_init_port, dstp->name);
qprintf (msg_port_inited, dstp->name);
pprintf ("waiting for %s to %s...\n", last_name, what);
err_printf( msg_write_prot, ip->name);
err_printf( msg_illegal_operation, ip->dva->name);
err_printf( status);
err_printf( msg_illegal_operation, dp->name);
err_printf( msg_write_prot, ip->name);
err_printf(status);
err_printf( msg_bad_open, pathname);
err_printf ("%s\n", fname);
err_printf ("poorly formed regular expression\n");
pprintf ("%d |%s| |%s| |%s| |%s|",
pprintf (" %s", ip->name);
err_printf ("info/next field for %s not allowed\n", ip->name);
err_printf ("%s has no 'next' field\n", ip->name);
File: flash_support.c
printf("Reading %d bytes from %x to %x\n", size, source, dest);
printf("Copying %d bytes from %x to %x\n", size, source, dest);
pprintf("flash_rom_read %x %x %x\n", dst, src, len);
printf("dst %x sector_number %x sectors %x\n", dst, sector_number,
printf("erasing sector %d from_addr %x\n", sector_number, from_addr);
printf("Updating sector = %d from %x %x on node %d\n", sector_number,
printf("sector_begin %x sector_end %x\n", from_sector_begin,
pprintf("FROM Control <7:3> %x %x\n",
printf("File\t\t= %.32s\n", (flash_ptr + tfr_file_spec));
printf("Creation Time\t= ");
printf("version\t\t= %c", *fsptr);
printf("%d.", *fsptr);
printf("%d-", *fsptr);
printf("%d\n", *fsptr);
printf("Invalid image\n");
printf("Id\t\t = %.4s\n", (flash_ptr + tfr_id));
printf("File\t\t = %.32s\n", (flash_ptr + tfr_file_spec));
printf("Creation Time = ");
printf("version\t\t = %c", *fsptr);
printf("%d.", *fsptr);
printf("%d-", *fsptr);
printf("%d\n", *fsptr);
printf("Header size\t= %d,\tchecksum = %08x\n", *fptr, j);
printf("Overall size\t= %d,\tchecksum = %08x\n", *fptr, j);
printf("Header checksum is incorrect, computed = %08x\n", cksum);
printf("Image %d, offset %x, size %d, address %x, checksum %08x\n",
printf("Overall checksum is incorrect, computed = %08x\n", cksum);
printf("Image %d Header\n", i);
printf(" pattern %08x, checksum %08x, Id %.4s\n", x1, x2, &x3);
printf(" copy size %d, copy checksum %08x\n", x4, x5);
printf(" load address %x, index ptr %x\n", x6, x7);
printf("Pattern is incorrectx\n");
printf("Header checksum is incorrect, computed = %08x\n",
printf("Copy checksum is incorrect, computed = %08x\n", cksum);
printf(" Index count %d\n", j);
printf(" Image %d, offset %x", k, ioffset);
printf(", Id %.4s, file: %.32s\n", x1, x2);
printf(" time ", x1, x2);
printf(", checksum %08x\n", x5);
printf(" original length %d, compressed length %d\n",
File: ie.c
qprintf("Dismissing OS generated interrupt during IO callback - vector %x0 \n", index);
fprintf (el_fp, "unexpected exception/interrupt through vector %X0\n", index);
pprintf ("unexpected exception/interrupt through vector %X0\n", index);
pprintf("\nNested exception - console restarting\n");
pprintf ("process %s, pcb = %08X\n\n", pcb->pcb$b_name, pcb);
pprintf (" pc: %08X %08X ps: %08X %08X\n",
pprintf (" r2: %08X %08X r5: %08X %08X\n",
pprintf (" r3: %08X %08X r6: %08X %08X\n",
pprintf (" r4: %08X %08X r7: %08X %08X\n",
pprintf( "\nexception context saved starting at %08X\n", acx );
pprintf ("\nGPRs:\n");
pprintf (" 0: %08X %08X 16: %08X %08X\n",
pprintf (" 1: %08X %08X 17: %08X %08X\n",
pprintf (" 2: %08X %08X 18: %08X %08X\n",
pprintf (" 3: %08X %08X 19: %08X %08X\n",
pprintf (" 4: %08X %08X 20: %08X %08X\n",
pprintf (" 5: %08X %08X 21: %08X %08X\n",
pprintf (" 6: %08X %08X 22: %08X %08X\n",
pprintf (" 7: %08X %08X 23: %08X %08X\n",
pprintf (" 8: %08X %08X 24: %08X %08X\n",
pprintf (" 9: %08X %08X 25: %08X %08X\n",
pprintf (" 10: %08X %08X 26: %08X %08X\n",
pprintf (" 11: %08X %08X 27: %08X %08X\n",
pprintf (" 12: %08X %08X 28: %08X %08X\n",
pprintf (" 13: %08X %08X 29: %08X %08X\n",
pprintf (" 14: %08X %08X 30: %08X %08X\n",
pprintf (" 15: %08X %08X\n",
pprintf( "dump of active call frames:\n" );
pprintf( "PC = %08X\n", pc );
pprintf( "PD = %08X", pd );
pprintf(" (%s)\n", sym);
pprintf( "PC = %08X (%s + %08X)\n", pc, pde->name, pc - pd->entry );
pprintf( "PC = %08X\n", pc );
pprintf( "PD = %08X\n", pd );
pprintf( "FP = %08X\n", fp );
pprintf( "SP = %08X\n", sp );
pprintf( "bad PD; base register is FP, but RSA is 0\n" );
pprintf( "bad PD; procedure is register based\n" );
pprintf( "R%d ", i );
pprintf( "F%d ", i );
pprintf( "saved starting at %08X\n\n", rsa );
pprintf( "R%-2d = %08X\n", i, regs[i] );
pprintf( "\nFP saved in R%d, PC saved in R%d\n", pd->save_fp, pd->save_ra );
pprintf( "bad PD; KIND = %d\n", pd->kind );
pprintf( "\n%s fault\n PCB = %08X (%s)\n PC = %08X (%s + %08X)\n VA = %08X %08X\n",
pprintf( "\n%s fault\n PCB = %08X (%s)\n PC = %08X\n VA = %08X %08X\n",
File: kernel.c
pprintf ("%*.*s", null_size, null_size, null_base);
pprintf ("<---output lost beginning here\n");
err_printf("starting console on CPU %d\n", id);
err_printf("console physical memory base is %x\n", phys_base);
qprintf("Starting console on CPU %d\n", id);
qprintf("halt code = %d\n", hcode);
qprintf(hlt_table[hcode - 1]);
qprintf("PC = %-16x\n", *(INT *) IMPURE->cns$exc_addr & ~3);
qprintf("impure area for CPU %d (at %x)\n", id, IMPURE);
qprintf("%x: %016x\n", p, *p);
qprintf("initialized idle PCB\n");
qprintf("initializing semaphores\n");
qprintf("initializing heap\n");
qprintf("initial heap %x\n", initial_heap_ptr);
qprintf("memory low limit = %x\n", memory_low_limit);
qprintf("heap = %x, %x\n", lower_heap_base, lower_heap_size);
qprintf("initializing driver structures\n");
qprintf("initializing idle process PID\n");
qprintf("initializing flash index\n");
err_printf("starting console on CPU %d\n", id);
qprintf("initializing file system\n");
qprintf("initializing timer data structures\n");
qprintf("lowering IPL\n");
qprintf ("%2x.",0xf4);
qprintf("entering idle loop\n");
qprintf("Jensen Exerciser %c%d.%d-%d, built on %s at %s by %s\n",
qprintf("%s Common Console %c%d.%d-%d, built on %s at %s\n",
pprintf("alpha handler NYI\n");
pprintf("Console entry breakpoint, type ;P to proceed\n");
pprintf("\nhalted CPU %d\n", id);
pprintf("CPU %d is not halted\n", i);
pprintf("\nhalt code = %d\n", haltcode);
pprintf(hlt_table[haltcode - 1]);
pprintf("PC = %-16x\n", *(INT *) impure->cns$exc_addr & ~3);
pprintf("\nYour system has halted due to an irrecoverable error. Record the\n");
pprintf("error halt code and PC and contact your Digital Services representative.\n");
pprintf("In addition, type INFO ");
pprintf("5");
pprintf("3");
pprintf(" and INFO 8 at the console and record the results.\n");
pprintf("CP - SAVE_TERM routine to be called\n");
pprintf("CP - SAVE_TERM exited with hlt_req = %x, r0 = %08x.%08x\n",
pprintf("CP - RESTORE_TERM routine to be called\n");
pprintf("CP - RESTORE_TERM exited with hlt_req = %x, r0 = %08x.%08x\n",
err_printf(msg_unicheck, message);
pprintf ("nested exceptions for PCB %x (%s)\n", pcb, pcb->pcb$b_name);
pprintf("CPU %d unable to complete console mode transition 1\n", j);
pprintf("CPU %d: begin = %d, end = %d, delta = %d\n", j, begin, current, elapsed);
pprintf("CPU %d unable to complete console mode transition 2\n", j);
pprintf("CPU %d: begin = %d, end = %d, delta = %d\n", j, begin, current, elapsed);
File: kernel_support.c
pprintf("Load of BOOT failed, FATAL\n");
pprintf("Load of ARC failed, FATAL\n");
pprintf("Load of BOOT failed, FATAL\n");
pprintf("[1]: pa: %x va: %x/%x \n",pa,va,*va);
pprintf("[2]: pa: %x va: %x/%x \n",pa,va,*va);
pprintf("map_via_crb: memory_high_limit not yet assigned value\n");
File: math.c
printf( "mysqrt results:\n");
printf( "%8d %6d\n", j, i);
printf( "%8.4f %8.4f\n", k, l);
printf( "\nVAX C sqrt results:\n");
printf( "%8d %6d\n", j, i);
printf( "%8.4f %8.4f\n", k, l);
File: ovly_util.c
qprintf("hf_init\n");
pprintf("\nOverlay name memadr topadr size ref\n");
pprintf("%-32.32s %8x %8x %6d %d\n",
qprintf("Overlay %s not found\n", name);
_pprintf("Load Overlay %s - mem %x ref %d\n",
err_printf("Overlays not valid, Must do an Init\n");
pprintf("Load Overlay %s, before setup\n", name);
_pprintf("Unload Overlay - %s mem %x ref %d\n",
_pprintf("Unload Overlay - %s mem %x ref %d\n", p_args3(symname,
_pprintf("Load Overlay %s - mem %x ref %d\n",
err_printf("Unable to malloc memory for Overlay %s\n", ovl_name);
err_printf("Unable to malloc memory for Decompression for %s\n",
_pprintf("Load Overlay %s - mem %x, off %x, buf %x\n",
err_printf("Load %s failed - mem %x, off %x, buf %x, status %x\n",
err_printf("? Overlay invalid version ?\n");
err_printf("? Overlay/Kernel global data mismatch ?\n");
err_printf("? Overlay/Kernel global entry mismatch ?\n");
err_printf("Unimplemented routine call\n");
err_printf(status);
err_printf("Overlay %s not found\n", ovl_name);
err_printf("Overlay %s not resident\n", ovl_name);
err_printf("Overlay %s not found\n", ovl_name);
err_printf("Overlay %s load failed\n", ovl_name);
err_printf("Can't open file %s\n", argv[1]);
err_printf("Unable to malloc memory for Image %s\n", argv[1]);
err_printf("Can't open file %s\n", argv[1]);
err_printf("Load - Unable to read image\n");
printf("Image %s loaded at %x\n", argv[1], ovly_image_address);
err_printf("Load: too many overlays\n");
err_printf("No DLL present\n");
_pprintf("Load Overlay %s - mem %x\n", p_args2(&dlp->name, adr));
err_printf("Unable to malloc memory for DLL %s\n", dlp->name);
err_printf("Unable to read DLL header\n");
err_printf("Unable to malloc memory for DLL %s\n", dlp->name);
err_printf("Load - Unable to read code\n");
err_printf("Unable to extend command table\n");
printf("command has no qualifiers\n");
printf(" %s\n", ct->ct_usage);
printf(" %.*s\n", uptr, ct->ct_usage);
err_printf("Unable to extend symbol table\n");
pprintf("Overlay symbols invalid version\n");
err_printf("Unable to extend driver startup table\n");
err_printf("Bus_table_add: bus %s not found\n", bus);
err_printf("Dev_table_add: device %s or bus %s not found\n", name, bus);
err_printf("Dev_table_remove: device %s or bus %s not found\n", name, bus);
pprintf("dev table add: %s %s setmode %x config %x extablish %x\n",
err_printf("Dev_table_add: device %s or bus %s not found\n", name, bus);
err_printf("Dev_table_remove: device %s or bus %s not found\n", name, bus);
qprintf("DDB Load, phase = %x\n", phase);
_pprintf("DDB Load %s\n", p_args1(dstp->name));
qprintf("DDB Startup, phase = %x\n", phase);
_pprintf("DDB Startup %s\n", p_args1(dstp->name));
qprintf("%08X exit status for %s_init\n", status,
qprintf("DDB Startup Driver: %s\n", driver);
qprintf(msg_init_port, dstp->name);
qprintf(msg_port_inited, dstp->name);
err_printf("Overlay %s not found\n", cb->name);
pprintf("adr = %x, dif = %x, %s\n", adr, diff, name);
File: parser.c
printf("%d, ", length);
printf("%02x ", *(parse_input_ptr + i));
printf(msg_par_itl); /* "Input too long\n" */
printf(msg_par_limd, lolim, hilim);
printf(msg_par_limx, lolim, hilim);
printf(msg_par_invnbr); /* "Invalid number\n" */
printf(msg_par_nbror); /* "Number out of range\n" */
printf(msg_par_keytl); /* "keyword too long\n" */
printf(msg_par_nohelp);
printf(msg_par_nohelp);
printf(" options are:\n");
printf("%s", bold_off);
printf("%s", keyadr);
printf("%s", bold_on);
printf("%s", keyadr);
printf("%s", bold_off);
printf("%s", bold_on);
printf("%.*s", abrv, keyadr);
printf("%s", bold_off);
printf("%s", keyadr + abrv);
printf("%s", bold_on);
printf("%s", keyadr);
printf("%s", keyadr + abrv);
File: process.c
qprintf ("starting pid %08X %10.10s from %s pcb = %08X\n",
qprintf ("Stack >75%% utilized - pid %08X %10.10s status %08X stack (%d/%d)\n",
qprintf ("stopping pid %08X %10.10s status %08X stack (%d/%d)\n",
printf (" ID PCB Pri CPU Time Affinity CPU Program State\n");
printf ("-------- -------- --- -------- -------- --- ---------- ------------------------\n");
printf ("%08x %08x %d %10d %08x %d %12.12s %s\n",
qprintf ("stack limit check on pid %08X, process %s\n",
printf ("\n\n ID PCB Program StackStart StackEnd Highwater Usage SP\n");
printf ("-------- -------- -------- ---------- --------- --------- ----- --\n");
printf ("%08x %08x %s %08x %08x %08x %x/%x %08x\n",
File: qscan.c
printf(" qualifiers are:\n");
printf("\t%s", qvs->id);
printf(" <decimal number>");
printf(" <string>");
printf(" <hex number>");
printf ("%08X\n", status);
printf ("%2d: %s\n", i, argv [i]);
printf ("%2d: %s\n", qmax, qstring);
pprintf ("%2d: %10.10s %s %s",
pprintf ("%d", qual->value.integer);
pprintf ("%X", qual->value.integer);
pprintf ("%s", qual->value.string);
pprintf ("???");
File: queue.c
printf ("%08X: %08X %08X\n\n", q, q->flink, q->blink);
printf ("%08X: %08X %08X\n", q, q->flink, q->blink);
printf ("%d\n", queue_validate_sorted (&h));
printf ("%d\n", queue_validate_sorted (&h));
File: random.c
printf ("%2d %016x %016x %016x\n", i, (UINT) a, (UINT) c, (UINT) m);
printf ("%2d %016x %016x\n", log_period, period, seed);
printf ("%d %d\n", c_lower, c_upper);
printf ("%2d %016x %016x %016x\n", log_m, a, c);
File: regexp.c
printf ("Poorly formed expression: %s\n", tests [i].expr);
printf ("Poorly formed regular expression\n");
printf (" %d %d |%s| %s\n", match_result, subset_result, symbol, argv [argix]);
File: secure.c
err_printf( msg_psswd_len_err, MIN_PWD_LEN, MAX_PWD_LEN );
err_printf( msg_val_err );
err_printf( msg_curr_psswd_err );
err_printf( msg_curr_psswd_err );
err_printf( msg_pwd_cleared );
File: semaphore.c
pprintf ("Semaphore %s at %08X is not aligned\n", name, s);
pprintf ("krn$_semrelease: semaphore %s has waiters\n", s->name);
pprintf ("krn$_semreinit: semaphore %s has waiters\n", s->name);
File: servers.c
qprintf( msg_mscp_bad_cmd_rsp, p->opcode, cb->sb->name );
File: strfunc.c
printf ("%d: |%s|\n", i, token);
File: symbols.c
printf ("%08X %08X %s\n", sp->v0, sp->v1, sp->mne);
printf ("%08X %s\n", sp->value, sp->mne);
File: timer.c
qprintf ("*** no timer interrupts on CPU %d ***\n", id);
qprintf("No timer interrupt, need to have the WATCH chip deliver\n");
qprintf ("CPU %d speed is %d.%02d ns (%dMHz)\n",
File: pci_routines.c
pprintf("pci_read.a: %016.16x \n", pci_ptr);
pprintf("pci_read.b: %016.16x/ %08x\n", pci_ptr, pci_data);
pprintf("pci_read.b: %016.16x/ ", pci_ptr);
pprintf(" %08x", *(adata+i));
pprintf("pci_write: %016.16x <-- %08x\n", pci_ptr, pci_data);
pprintf("pci_write: %016.16x <--", pci_ptr);
pprintf(" %08x", *(int *)(pci_data+(i*4)));
printf("datumsize %d not yet implemented\n", datumsize);
printf("datumsize %d not yet implemented\n", datumsize);
printf("datumsize %d not yet implemented\n", datumsize);
pprintf("incfgx - null PB\n");
printf("datumsize %d not yet implemented\n", datumsize);
printf("datumsize %d not yet implemented\n", datumsize);
pprintf("outcfgx - null PB\n");
pprintf("inmemx - null PB\n");
printf("datumsize %d not yet implemented\n", datumsize);
pprintf("outmemq : Not yet implemented\n");
pprintf("outmemx - null PB\n");
pprintf("outmemx - null PB\n");
pprintf("indmeml - null PB\n");
pprintf("indmemo null PB\n");
pprintf("indmemh null PB\n");
pprintf("outdmeml null PB\n");
pprintf("outdmemo null PB\n");
pprintf("outdmemo null PB\n");
printf("Failed to enable interrupt ( vector: %x )\n", vector );
printf("Failed to disable interrupt ( vector: %x )\n", vector );
printf("\nReset the system to reconfigure the PCI with the new parity setting\n");
File: rawhide.c
pprintf("breakpoint at PC %x desired, XDELTA not loaded\n",
qprintf("XDELTA not enabled.\n");
qprintf("Transferring to xdelta\n");
printf ("\nHalt Button is IN, BOOT NOT POSSIBLE\n\n");
pprintf ("\n mchk_code: %08x %08x\n",
pprintf ("\nEV5 IPRs:\n");
pprintf (" ei_addr: %08x %08x ei_stat: %08x %08x\n",
pprintf (" fill_syn: %08x %08x isr: %08x %08x\n",
pprintf ("\nIOD base address: %02x%08x WHOAMI: %08x\n",
pprintf (" PCI_REV: %08x MC_ERR0: %08x MC_ERR1 %08x\n",
pprintf (" CAP_ERR: %08x MDPA_STAT: %08x MDPA_SYN: %08x\n",
pprintf (" MDPB_STAT: %08x MDPB_SYN: %08x\n",
pprintf ("\n Power failure status: %08x", logout_frame->mchk$crd_iic_environ);
pprintf ("\n Type SHOW POWER to obtain more details.\n\n");
pprintf("\n\nProcess %s CPU%d: soft error detected, vector %04X0\n", pcb->pcb$b_name, id, exc);
pprintf("\n***CPU %02d: Unexpected Machine Check through vector %08X\n",
pprintf("\nConsole Crash... Type ;P to view stack contents\n");
qprintf( "IP interrupt on CPU %d\n", whoami( ) );
pprintf("\n\nA power, fan, or temperature environmental event has been detected.");
pprintf("\nUse the console's SHOW POWER command to obtain more detail.\n");
pprintf("\nI/O detected PCI bus data parity error on IOD%d\n", i);
pprintf("It is recommended that you set pci_parity off and reset your machine\n");
pprintf("\nProcess %s, pcb = %08X\n", pcb->pcb$b_name, pcb);
pprintf(" pc: %08X %08X ps: %08X %08X\n", acp->acx$q_pc[1],
pprintf(" r2: %08X %08X r5: %08X %08X\n", acp->acx$q_exc_r2[1],
pprintf(" r3: %08X %08X r6: %08X %08X\n", acp->acx$q_exc_r3[1],
pprintf(" r4: %08X %08X r7: %08X %08X\n", acp->acx$q_exc_r4[1],
pprintf ("\nIOD: %d base address: %02x%08x\n",
pprintf (" WHOAMI: %08x PCI_REV: %08x ENVIRON: %08x\n",
pprintf (" CAP_CTL: %08x HAE_MEM: %08x HAE_IO: %08x\n",
pprintf (" INT_CTL: %08x INT_REQ: %08x INT_MASK0: %08x\n",
pprintf (" INT_MASK1: %08x MC_ERR0: %08x MC_ERR1: %08x\n",
pprintf (" CAP_ERR: %08x PCI_ERR: %08x MDPA_STAT: %08x\n",
pprintf (" MDPA_SYN: %08x MDPB_STAT: %08x MDPB_SYN: %08x\n",
pprintf ("\nEV5 IPRs:\n");
pprintf (" exc_addr: %08x %08x exc_sum: %08x %08x\n",
pprintf (" exc_mask: %08x %08x isr: %08x %08x\n",
pprintf (" icsr: %08x %08x icpe_stat: %08x %08x\n",
pprintf (" dcpe_stat: %08x %08x va: %08x %08x\n",
pprintf (" mm_stat: %08x %08x sc_addr: %08x %08x\n",
pprintf (" sc_stat: %08x %08x bc_tag_addr: %08x %08x\n",
pprintf (" ei_addr: %08x %08x ei_stat: %08x %08x\n",
pprintf (" fill_syn: %08x %08x\n",
pprintf("NYI\n");
pprintf("Initializing...\n");
printf("%s\n",buf);
pprintf("CPU %d unable to acquire SCRATCH lock\n", id);
printf("dump_state%x\n",num);
printf("test_num %04d error_num: %04d\n", diag->diag$l_test_num,
printf("iter:%03d init_done:%01d start:%01d done:%01d\n",
printf("cleanup:%01d passed:%01d global_id:%02d local_id:%02d\n",
printf("pci_offset:%02d cpu_modules:%02d global_bus:%02d pcis:%02d\n",
printf("pb:%08x pci_mem:%08x scb_iod:%08x\n",
printf("%s: %08x ", IOD_csr_names[i],csr_data);
pprintf(" %d %4d MB %s\n", i, *(UINT*) dp->dm[i].size/0x100000, mem_type);
printf(" %d %4d MB %s\n", i, *(UINT*) dp->dm[i].size/0x100000, mem_type);
qprintf("expand memzone b %x s %x\n", *(UINT*) dp->dm[i].base , *(UINT*) dp->dm[i].size, 1);
qprintf("memzone: base = %x, mz_size = %x\n", mz_low,mz_size);
File: rawhide_modular.c
qprintf("initializing overlays\n");
qprintf("flash index count = %x, adr = %x\n", flash_index_count, from_adr);
qprintf("flash seq_minor = %x, var_major = %x\n", flash_seq_minor, flash_var_major);
pprintf("Load of HFDCMP failed, Fatal\n");
pprintf("\nhalt code = %d\n", halt_code);
pprintf("pcb %x\n", pcb);
pprintf("!!! Console entry context is not valid - Reset the system !!!\n");
pprintf("Load of XDELTA failed\n");
pprintf("Load of %s failed, FATAL\n", ovlt_ptr->name);
pprintf("data %x addr %x\n", value, pci_ptr);
qprintf("Load of OSF PAL failed\n");
qprintf("DLB at %x, heap size %x\n", adr, heap_size_val);
printf("%d-%s-%d %02d:%02d:%02d",
qprintf("find_image_dlb: adr %x, data %x\n", dlb_adr, *(int *)dlb_adr);
qprintf("dlb copy: memadr %x, dlb_adr %x, dlb_size %x\n", mem_adr, dlb_adr, dlb_size);
File: buf_driver.c
pprintf ("%08X %08X\n", buf_cacheblocks, buf_blocksize);
pprintf ("v=%d d=%d %08X %08X\n",
File: sym_driver.c
err_printf ("sym: info field must be present\n");
err_printf("sym: poorly formed regular expression\n");
File: tt_driver.c
pprintf ("\n*** ^P ***\n");
pprintf ("\n*** ^V ***\n");
pprintf (" ID PCB Pri CPU Time Affinity CPU Program State\n");
pprintf ("-------- -------- --- -------- -------- --- ---------- ------------------------\n");
pprintf ("%08x %08x %d %10d %08x %d %12.12s %s\n",
pprintf ("%s: %02x `%c'\n", ttpb->ip->name, c, c);
printf ("^O\n");
printf ("^O\n");
pprintf("Load of XDELTA failed\n");
printf ("\nTransferring to xdelta\n");
File: combo_driver.c
qprintf ("combott_lineset:line_param-0x%x, vms_rate - %d, char_size - %d, stop_bits_value - %d, parity_value - %d\n",
qprintf ("combott_lineset:after writing divisor regs\n");
qprintf ("combott_lineset:CP->port+DLL 0x%x, CP->port+DLM - 0x%x\n", (cp->port + DLL), (cp->port + DLM));
qprintf ("combott_lineset: LCR value - %x \n", lcr_save);
File: sromtt_driver.c
pprintf(" %02x ",sromtt_in);
File: pmem_driver.c
err_printf(msg_exdep_badadr);
err_printf(msg_exdep_badadr);
File: nvram_driver.c
qprintf( "access NVRAM\n" );
err_printf( "could not store %s, NVRAM full\n", name );
File: iic_driver.c
pprintf ("%s \n",itext[iop]);
pprintf ("%s address 0x%x buf1 0x%x\n",itext[iop],buf1[k]);
pprintf ("%s \n",itext[iop]);
pprintf ("%s call read address count %d \n",itext[iop],count);
pprintf ("%s buf 0x%x\n",itext[iop],buf[0]&0xff);
pprintf ("%s now idle \n",itext[iop]);
pprintf ("%s check for busy \n",itext[iop]);
pprintf ("%s not busy \n",itext[iop]);
pprintf ("%s node 0x%x \n",itext[iop],node );
pprintf ("%s start transfer timer \n",itext[iop]);
pprintf ("%s wait for transmission complete \n",itext[iop]);
pprintf ("%s transmission done \n",itext[iop]);
pprintf ("%s transmission timeout--issue stop-make idle \n",itext[iop]);
err_printf(msg_ex_cmd_timeout,name);
err_printf(msg_iic_bad_status,pb->status);
pprintf ("%s routine done status 0x%x\n",itext[iop],status);
pprintf ("%s entry \n",itext[iop]);
err_printf(msg_driver_stopped,"iic");
pprintf ("%s done \n",itext[iop]);
pprintf ("%s entry \n",itext[iop]);
pprintf ("%s done \n",itext[iop]);
pprintf ("%s mode 0x%x \n",itext[iop],mode);
pprintf ("%s stop - \n",itext[iop]);
pprintf ("%s turn on interrupts \n",itext[iop]);
printf(msg_bad_open,"iic_ocp0");
printf(msg_dep_devwriteerr,1,1,"iic_ocp0");
printf(msg_ex_devreaderr,1,1,"iic_ocp0");
printf(msg_data_comp_err,1,&buf[0],"iic_ocp0");
pprintf ("%s entry \n",itext[iop]);
err_printf(msg_bad_open,"iic");
err_printf(msg_bad_open,"iic");
pprintf ("%s iic_reset \n",itext[iop]);
pprintf ("%s initialize structures \n",itext[iop]);
pprintf(msg_iic_bad_int_set);
pprintf ("%s read verify node 0x%x \n",itext[iop],ilist->node);
pprintf ("%s node 0x%x status 0x%x data= 0x%x\n",itext[iop],ilist->node,status,buf[0]);
pprintf("Creating inode %s\n", ilist->name);
pprintf ("%s iic_reset \n",itext[iop]);
pprintf ("%s write pin \n",itext[iop]);
pprintf ("%s reset slave address 0x%x \n",itext[iop],
pprintf ("%s iic_reset done-enable serial communication \n",itext[iop]);
pprintf ("poll_rt: \n");
pprintf ("%s lost arbitration-make idle \n",itext[iop]);
pprintf ("%s service-dir=read \n",itext[iop]);
pprintf("slave write\n");
pprintf ("%s iic_service write\n",itext[iop]);
pprintf ("%s iic_service status 0x%x\n",itext[iop],status);
if(status.bits.bb) pprintf ("%s iic_service bus busy \n",itext[iop]);
if(status.bits.lab)pprintf ("%s iic_service lost arb \n",itext[iop]);
if(status.bits.aas)pprintf ("%s iic_service aas \n",itext[iop]);
if(status.bits.ado)pprintf ("%s iic_service last rec \n",itext[iop]);
if(status.bits.ber)pprintf ("%s iic_service bus error \n",itext[iop]);
if(status.bits.sts)pprintf ("%s external master stop \n",itext[iop]);
pprintf ("%s iic_service error-stop \n",itext[iop]);
pprintf ("%s iic_service status ok \n",itext[iop]);
pprintf ("%s iic_service transmit done-stop and post\n",itext[iop]);
pprintf ("%s iic_service write next byte 0x%x\n",
pprintf ("%s iic_service read \n",itext[iop]);
pprintf ("%s iic_service read status 0x%x\n",itext[iop],status);
if(status.bits.bb) pprintf ("%s iic_service bus busy \n",itext[iop]);
if(status.bits.lab)pprintf ("%s iic_service lost arb \n",itext[iop]);
if(status.bits.aas)pprintf ("%s iic_service aas \n",itext[iop]);
if(status.bits.ado)pprintf ("%s iic_service last rec \n",itext[iop]);
if(status.bits.ber)pprintf ("%s iic_service bus error \n",itext[iop]);
if(status.bits.sts)pprintf ("%s external master stop \n",itext[iop]);
pprintf ("%s iic_service data 0x%x\n",itext[iop],pb->buffer_addr[pb->rec_count]&0xff);
pprintf ("%s rec count 0x%x\n",itext[iop],pb->rec_count);
pprintf ("%s done-post error and make idle \n",itext[iop]);
pprintf ("%s done post and make idle count 0x%x\n",itext[iop],pb->count);
pprintf ("%s iic_s_read iic_service status_read \n",itext[iop]);
pprintf ("%s iic_service stop \n",itext[iop]);
pprintf ("%s wait for bus not busy \n",itext[iop]);
pprintf ("%s iic_busb bus not busy\n",itext[iop]);
err_printf(msg_iic_bus_timeout);
File: sable_ocp_driver.c
pprintf("Device Open Error: IIC_OCP0\n");
pprintf("read buffer = %x\n", read_buf[0]);
pprintf("sable_ocp_init: lcd_display = %x\n", lcd_display);
pprintf("read buffer = %x\n", read_buf[0]);
pprintf("read buffer = %x\n", read_buf[0]);
pprintf("sable_ocp_init: lcd_display = %x\n", lcd_display);
pprintf ("sable_ocp_read\n");
pprintf("Device Open Error: IIC_OCP0\n");
pprintf("Device Open Error: IIC_OCP1\n");
pprintf("number = %d\n", number);
pprintf("size = %d\n", size);
pprintf("string = %.16s\n", buf);
pprintf("sable_ocp_write: lcd_display = %x\n", lcd_display);
pprintf("data %d = %x\n", j, ocp_string[j]);
File: decode_alpha.c
printf("Status = %x, RetLen = %d\n", status, *RetLen);
printf("Inst = \t%s\n", OutBufDesc[1]);
printf("Instruction = %08x\n", MachineInstr);
printf("Format = %x\n", InstrFormat);
printf("Opcode = %x\n", Opcode);
printf("Ops = %x\n", Ops);
printf("ParseOps; code = %x, table = %x, length = %x\n", code, table,
printf("ParseMemoryOperand, OC = %x, MI = %x\n", OpcodeClass,
printf("ParseBranchOperand, OC = %x, MI = %x\n", OpcodeClass,
printf("ParseOperateOperand, MI = %x\n", MachineInstr);
printf("ParseFloatOperand, OC = %x, MI = %x\n", OpcodeClass, MachineInstr);
printf("ParseSyncOperand, MI = %x\n", MachineInstr);
printf("ParseMtmfOperand, MI = %x\n", MachineInstr);
pprintf ("%s\n", buf);
pprintf("No symbol found for %x\n", rtn);
pprintf("\n%s(%x,%x,%x,%x,%x,%x)\n", sym, p0, p1, p2, p3, p4, p5);
pprintf("%s return value = %x\n", sym, retval);
pprintf("No symbol found for %x\n", rtn);
pprintf("\n%s(%s)\n", sym,strptr);
pprintf ("call_cmd: can't allocate enough memory\n");
pprintf("%d - %s, ", i, argv[i]);
pprintf("%s return value = %x\n", sym, retval);
File: blex.c
err_printf ("tlist [%d] is broken\n", i);
err_printf ("%25.25s %2d %s\n",
err_printf ("exceeding %d tokens, continuing\n", yyl->tka);
printf ("%s", yyl->input_buf);
err_printf ("yy_lex pushback error\n");
err_printf ("nlist %d not valid (%d)\n", i, nlist [i].value);
printf ("^C\n");
printf("sh_tag: prec %x dp %x\n", p->prec, dp);
err_printf ("shell couldn't tag %d memory blocks\n", misses);
printf("sh_flush: dp %x\n", dp);
err_printf ("syntax error: '%s' unexpected on line %d, file %s\n",
for (i=0; i <= p->level; i++) err_printf (" ");
err_printf ("rule_%s\n", s);
err_printf(msg_cnsl_secure);
err_printf ("command list default rule taken\n");
err_printf ("andor default rule taken\n");
err_printf ("Poorly formed pattern in case statement");
err_printf ("can't create a pipe");
err_printf ("Can't open pipe %s\n", right->stdin_name);
err_printf ("%s ", argv [i]);
err_printf ("<%s >%s 2>&%s\n",
err_printf(msg_cnsl_secure);
err_printf ("%s: No such command\n", argv [0]);
err_printf(msg_cnsl_secure);
err_printf ("%s is not executable\n", argv [0]);
pprintf ("%d:", i);
pprintf (" /%s/", pingv [j]);
for (i=0; i<p->level; i++) err_printf (" ");
err_printf ("exec_%s", nlist [np->id].name);
err_printf (" %08X", (int) np->kids [i]);
err_printf(msg_cnsl_secure);
err_printf ("shell can't open %s\n", input_name);
err_printf ("shell can't open output file %s from command substitution\n", output_name);
File: date_cmd.c
printf ("%s\n", render_date (&toy, line));
err_printf ("date: date is not in the form [yyyy[mm[dd]]]hhmm[.ss]\n");
File: exdep.c
err_printf(msg_exdep_conflict);
err_printf (status);
err_printf (msg_exdep_conflict);
err_printf(msg_dep_param_missing);
err_printf (msg_extra_params);
err_printf(msg_dep_baddata);
err_printf(msg_exdep_badparam);
err_printf(msg_ex_devopenrderr, file);
err_printf(msg_dep_devopenwrerr, exdep->space);
err_printf(exdep->fp->status, exdep->address);
err_printf(msg_ex_devreaderr,
printf("%s", exdep->data);
err_printf(exdep->fp->status, exdep->address);
err_printf(msg_dep_devwriteerr,
File: help.c
printf("%s", advhlp);
printf ("The following help topics are available:\n\n");
printf ("%-15.15s ", helpbuf [i].topic);
printf ("NAME \n\t %s\n", helpbuf [i].topic);
printf ("FUNCTION\n\t %s\n", helpbuf [i].text);
printf ("SYNOPSIS\n\t %s\n\n", helpbuf [i].syn);
printf("%s doesn't match any topic. Type just \"help\" for a list of topics.\n", s);
printf(" %s\n", hp->text);
printf("NAME \n\t ");
printf("FUNCTION\n\t %s\n", hp->text);
printf("SYNOPSIS\n\t %s\n\n", hp->syn);
File: login_cmd.c
err_printf( msg_invld_psswd );
err_printf( msg_no_vldpsswd );
File: startstop.c
err_printf (status);
err_printf (msg_qual_conflict);
err_printf(status);
err_printf("invalid processor ID\n");
err_printf("invalid processor ID\n");
err_printf("CPU %d is halted\n", id);
err_printf (status);
err_printf(status);
err_printf(status);
err_printf("invalid processor ID\n");
err_printf("invalid processor ID\n");
err_printf("CPU %d is not halted\n", id);
err_printf(status);
err_printf("invalid processor ID\n");
printf("invalid processor ID\n");
printf("CPU %d is not halted\n", id);
err_printf (msg_ctx_invalid);
pprintf ("\ncontinuing CPU %d\n", id);
err_printf (status);
File: start_grom.c
printf("Not a Grom image\n");
printf("Decompress failed %x\n", status);
File: arc_cmd.c
printf( "\nAlphaBIOS does not support automatic invocation of ECU. Use the ALPHABIOS\n" );
printf( "command to manually invoke AlphaBIOS and page through the menus to run ECU.\n\n" );
pprintf("Starting AlphaBIOS\n");
pprintf( "Jumptoarc\n" );
pprintf( "arg 0 %8x - load addr\n",args[0]);
pprintf( "arg 1 %8x - size memory contiguous\n",args[1]);
pprintf( "arg 2 %8x - cycle count in picosec\n",args[2]);
pprintf( "arg 3 %8x - signature and ID\n",args[3]);
pprintf( "arg 4 %8x - active processor mask\n",args[4]);
pprintf( "arg 5 %8x - system context value\n",args[5]);
pprintf( "loading AlphaBIOS firmware\n" );
pprintf( "Open flash0\n" );
pprintf( "Failed to open flash0\n" );
pprintf( "Readed flash0\n" );
pprintf( "Incorrect ROM size\n" );
pprintf("AlphaBIOS Image invalid\n");
pprintf( "Compute checksum\n" );
pprintf("AlphaBIOS Image checksum error, actual %08x, computed %08x\n", cksum, checksum);
pprintf("descriptor %d\n", index);
pprintf(" base page %d %x\n", base_page, base_page);
pprintf(" page count %d %x\n", page_count, page_count);
pprintf(" page type %d\n", type);
pprintf(" page tested %d\n", tested);
pprintf("Maximum memory descriptor exceeded\n");
pprintf("cluster %d bpa %x total pages %d total tested pages %d base_page %d\n",
pprintf("%d good pages pn %d\n", page_count, page_number );
pprintf("%d bad pages pn %d\n", page_count, page_number );
pprintf("add p %d to mt %d\n", j, i);
pprintf("p start %x p count %x\n",p->memory_descriptor[j].base_page, p->memory_descriptor[j].page_count);
pprintf("add p %d to mt %d\n", j, i);
pprintf("p start %x p count %x\n",p->memory_descriptor[j].base_page, p->memory_descriptor[j].page_count);
pprintf( "JtoPAL\n" );
File: build_cmd.c
err_printf(msg_insuff_params);
err_printf(msg_fname_unknown, argv[1]);
err_printf(msg_fname_unknown, argv[2]);
err_printf(msg_bad_open, device);
err_printf(msg_dep_devwriteerr,
File: type_cmd.c
err_printf (status);
printf(msg_file_not_found, file);
printf("%s", line); /* print line */
File: allocfree.c
printf ("h %08X %d\n", hole_address, hole_size);
printf ("%s %08X %08X_%08X %08X_%08X %08X %08X %d\n",
printf ("%d unreported blocks\n", blocks_found - blocks);
pprintf ("adjaceny list not in ascending order\n");
pprintf ("free list not in ascending order\n");
printf ("corruption at address %08X in block %08X", ip, p);
printf (" repaired\n");
pprintf (msg_dyn_size, p);
pprintf ("broken ownership queue for block %08X\n", p);
printf("-v not supported\n");
printf ("validation error a=%08X m=%08X r=%08X \n",
err_printf (status);
err_printf ("Zone can't be extended\n");
err_printf ("Default zone extended at the expense of memzone.\nUse INIT before booting\n");
printf ("%08X %-10d %-7d %-10d %-7d %-10d %3d %% %-10d\n",
err_printf (status);
err_printf (msg_insuff_params);
err_printf (msg_extra_params);
printf ("00000000\n");
err_printf (msg_insuff_mem, size);
printf ("%08X\n", address);
File: bpt.c
pprintf("Load of XDELTA failed\n");
File: call.c
printf("routine symbol %s not found\n",argv[1]);
printf("routine symbols are not available\n");
printf("%s return value = %x\n", argv[1], retval);
File: cat.c
err_printf( status );
err_printf ("cat: can't allocate enough memory\n");
File: cmp.c
err_printf ("cmp: %m", status);
err_printf (msg_insuff_params);
printf (msg_cmp_length);
printf (msg_cmp_neq,
File: crc.c
printf ("%08X\n", check);
printf ("%08X %s\n", check, argv [argix]);
File: echo.c
err_printf (status);
printf ("%s%s", *++argv, (argc > 1) ? " " : "");
File: edit.c
fprintf( fp_err, t );
fprintf( fp_err, "editing `%s'\n", argv[i] );
err_printf( msg_nofile );
fprintf( fp_err, t );
fprintf( fp_err, "%d bytes read in\n", cur );
cur += fprintf( fp_out, "%s\n", db->lsp[i].text );
fprintf( fp_err, "%d bytes written out to %s\n", cur, fp_out->ip->name );
fprintf( fp_err, "missing line number\n" );
fprintf( fp_err, "%4d %s\n", db->lsp[i].lnum, db->lsp[i].text );
fprintf( fp_err, "Think \"BASIC line editor\", and see if that'll do the trick\n" );
File: eval.c
err_printf (status);
err_printf (msg_overflow);
if (qual [QB].present) printf ("%b ", (UINT) result);
if (qual [QO].present) printf ("%o ", (UINT) result);
if (qual [QD].present) printf ("%d ", (UINT) result);
if (qual [QX].present) printf ("%*.*X",
printf (status);
File: find_field.c
err_printf (status);
err_printf( msg_insuff_params);
printf ("%s\n", newbuf);
File: grep.c
err_printf ("not compiled: %s\n", line);
printf ("%4d: %s\n", line_number, line);
printf ("%s\n", line);
printf ("%d\n", lines_matched);
File: hd.c
err_printf(status);
printf("block %d\n", offset / 512);
File: information.c
printf("\t%2d. %s\n",i,itab[i].label);
printf("\nThis system utilizes two consoles, the SRM console for OpenVMS and Digital UNIX,\n");
printf("and AlphaBIOS for Windows NT support. The OS_TYPE environment variable is used\n");
printf("to select between the two consoles. If OS_TYPE is set to NT, the SRM console\n");
printf("auto-loads AlphaBIOS shortly after I/O configuration and testing. To skip the\n");
printf("AlphaBIOS auto-load, depress the front panel HALT button and reset your machine.\n");
printf("The CONSOLE environment variable is used to select between graphics and serial\n");
printf("display devices.\n\n");
printf("%s from page %x:%x (address range %016x:%016x) \n",
printf("\nHWRPB: %x MEMDSC:%x Cluster count: %d\n",HWRPB,memdsc,
printf("\nCLUSTER: %d ",i);
printf("Usage: Console\n");
printf("BITMAP_VA: n/a BITMAP_PA: n/a ");
printf("Usage: System\n");
printf("BITMAP_VA: %x BITMAP_PA: %16x ",
printf("Usage: Battery Backed Up Memory\n");
printf("BITMAP_VA: %x BITMAP_PA: %16x ",
printf("*** Unknown Cluster type ***\n");
printf("START_PFN: %x\n", *memdsc->CLUSTER[i].START_PFN);
printf("PFN_COUNT:%x TESTED_COUNT: %x\n",
printf("%20.20s",fieldname);
printf(" %08x",impadr[i]);
printf(" : %04x",offset+(i*4));
printf(" ");
printf(" cpu%02d ",j);
printf("per_cpu impure area ");
printf(" %08x", PAL$IMPURE_BASE + PAL$IMPURE_COMMON_SIZE +
printf(" ");
printf(" cpu%02d ",j);
printf("per_cpu logout area ");
printf(" %08x", SLOT$_PAL_LOGOUT + j * SLOT$_PAL_LOGOUT_LEN);
printf("%20.20s",fieldname);
printf(" %08x",mchkadr[i]);
printf(" : %04x",offset+(4*i)+mchk$crd_base);
printf("%20.20s",fieldname);
printf(" %08x",mchkadr[i]);
printf(" : %04x",offset+(4*i)+mchk$mchk_base);
printf("%20.20s",fieldname);
printf(" %08x",data_adr[i]);
printf(" ");
printf(" cpu%02d ",j);
printf("per_cpu slot adr ");
printf(" %08x",slot);
printf (" %08X %08X SCRATCH [%d]\n",
printf("___verylast: %08x\n",&___verylast);
printf("MIN_HEAP_SIZE : %08x\n",MIN_HEAP_SIZE);
printf("HEAP_SIZE : %08x\n",HEAP_SIZE);
printf("Extended heap size : %08x\n",size);
printf("memory_high_limit : %x\n",memory_high_limit);
printf("MAX_ELBUF : %08x\n",MAX_ELBUF);
printf("MODULAR : %08x\n",MODULAR);
printf("SECURE : %08x\n",SECURE);
printf("SYMBOLS: %08x\n",SYMBOLS);
printf("XDELTA_ON : %08x\n",XDELTA_ON);
printf("XDELTA_INITIAL : %08x\n",XDELTA_INITIAL);
printf("OS will be loaded at %08x\n",base);
printf("Console IPL is low (INTERRUPT mode)\n");
printf("Console IPL is high (POLLED mode)\n");
printf("Console UART is in INTERRUPT mode\n");
printf("Console UART is in POLLED mode\n");
printf("\nTT ports known:\n");
printf("\ttt port: %s mode:%s\n",ttpb->ip->name, cmode[ttpb->mode]);
printf("\nPOLLQ contains:\n");
printf("\tRoutine: %08x %s", pqp->routine, sym_table_lookup(pqp->routine));
printf(" tt port: %s\n",ttpb->ip->name);
printf("\nLast Console Entry Reason:\n");
printf(" cpu%02d entry reason:%x %s \n",j, hltcod, hlttxt[i].txt);
printf("BOOT_BSSPAGES: %d (decimal)\n",BOOT_BSSPAGES);
printf("BOOT_STACKPAGES: %d (decimal)\n",BOOT_STACKPAGES);
printf("BOOT_GUARDPAGES: %d (decimal)\n",BOOT_GUARDPAGES);
printf("BOOT_L1PAGES: %d (decimal)\n",BOOT_L1PAGES);
printf("BOOT_L2PAGES: %d (decimal)\n",BOOT_L2PAGES);
printf("BOOT_L30PAGES: %d (decimal)\n",BOOT_L30PAGES);
printf("BOOT_L31PAGES: %d (decimal)\n",BOOT_L31PAGES);
printf("BOOT_PTEPAGES: %d (decimal)\n",BOOT_PTEPAGES);
printf("l1pt = %08x\n",l1pt);
printf("l2p2 = %08x\n",l2pt);
printf("l3pt0 = %08x\n",l3pt0);
printf("l3pt1 = %08x\n",l3pt1);
printf("base = %08x\n",base);
printf("ptbr = %08x (%08x)\n",ptbr, ptbr<<13);
printf("Level %d page table\n",level);
printf("L%d %8x: %016x pfn:%x (%x), virt:%016x\n",
printf("(%x) %x/ %x = %s\n",&scbv[i],i,scbv[i].scbv$q_pd[0],
File: information_rawhide.c
pprintf ("\nIOD %d\n\n", pcia_pb.hose);
pprintf (" WHOAMI: %08x PCI_REV: %08x\n",
pprintf (" CAP_CTL: %08x HAE_MEM: %08x HAE_IO: %08x\n",
pprintf (" INT_CTL: %08x INT_REQ: %08x INT_MASK0: %08x\n",
pprintf (" INT_MASK1: %08x MC_ERR0: %08x MC_ERR1: %08x\n",
pprintf (" CAP_ERR: %08x PCI_ERR: %08x MDPA_STAT: %08x\n",
pprintf (" MDPA_SYN: %08x MDPB_STAT: %08x MDPB_SYN: %08x\n",
pprintf (" INT_TARG: %08x INT_ADR: %08x INT_ADR_EXT: %08x\n",
pprintf (" PERF_MON: %08x PERF_CONT: %08x CAP_DIAG: %08x\n",
pprintf (" DIAG_CHKA: %08x DIAG_CHKB: %08x SCRATCH: %08x\n",
pprintf (" W0_BASE: %08x W0_MASK: %08x T0_BASE: %08x\n",
pprintf (" W1_BASE: %08x W1_MASK: %08x T1_BASE: %08x\n",
pprintf (" W2_BASE: %08x W2_MASK: %08x T2_BASE: %08x\n",
pprintf (" W3_BASE: %08x W3_MASK: %08x T3_BASE: %08x\n",
pprintf (" W_DAC: %08x SG_TBIA: %08x HBASE: %08x\n",
File: line.c
err_printf( msg_extra_params);
File: ls.c
err_printf (status);
printf ("%s %m", *argv, status);
printf ("%s\n", fname);
File: more.c
err_printf (status);
err_printf ("more: can't open %s\n", argv [argix]);
printf ("%s", line);
printf ("--More-- (SPACE - next page, ENTER - next line, Q - quit)");
printf ("\033[2K\033[256D");
File: rm.c
err_printf (msg_not_removed, argv [argix]);
File: swap.c
printf ("%08X ",*(int *)swd);
File: flash_update.c
err_printf(status);
err_printf("\nAlphaBIOS image not valid\n");
err_printf("Invalid Image\n");
printf(msg_fe_no_int);
printf(msg_fe_lose_opstate);
printf(msg_fe_sev_min);
printf("\nFlash ROM updated\n");
err_printf("\nFailed to update Flash ROM\n");
pprintf("update_flash_from_memory w/ image_ptr=%x\n", image_ptr);
printf("Image %d, i_offset %x, i_size %d, f_offset %x\n", j,
printf("source address %x flash_offset %x source_size %x\n",
pprintf("fptr %x flash_offset %x size %x checksum %x\n", fptr,
pprintf("b_check %x\n", b_checksum);
pprintf("a_check %x\n", a_checksum);
pprintf("%s, image start %x image size %x grom checksum %x\n",
pprintf("flash checksum %x adr %x size %x\n",
err_printf("Checksum error on %s, image start %x image size %x\n",
err_printf("WARNING! %s has been corrupted\n",
err_printf("WARNING! %s has been corrupted\n",
pprintf("setup_arc_image: adr = %x, id = %x\n", adr, data);
pprintf("setup_arc_image: hlen = %x, dlen = %x, cksum = %x\n", hlength,
pprintf("setup_arc_image: checksum = %x\n", checksum);
err_printf("\nAlphaBIOS image checksum error\n");
pprintf("setup_arc_image: checksum = %x\n", checksum);
pprintf("setup_arc_image: trailer = %x, id = %x, offset = %x\n", adr,
err_printf("\nAlphaBIOS image trailer ID error\n");
err_printf("\nAlphaBIOS image trailer length error\n");
pprintf("setup_arc_image: offset = %x, length = %x\n", adr, data1);
File: validate.c
pprintf ("Q out of range (%08X <= %08X <= %08X)\n",
pprintf ("Q flink out of range (%08X <= %08X <= %08X)\n",
pprintf ("Q blink out of range (%08X <= %08X <= %08X)\n",
pprintf ("q->flink->blink != q\n %08X: %08X %08X\n %08X: %08X %08X\n",
pprintf ("Q number of elements out of range (%08X: %d <= %d <= %d)\n",
File: wc.c
printf(status);
printf("wc: can't open %s\n", argv[argix]);
printf("%8d ", s->lines);
printf("%8d ", s->words);
printf("%8d ", s->bytes);
printf("%s\n", name);
File: set_rawhide.c
printf("NYI\n");
printf(msg_insuff_params);
err_printf(msg_extra_params);
err_printf(msg_qual_conflict);
err_printf(rstat, argv[1]);
printf(msg_insuff_params);
printf("%s is not an envar\n", argv[1]);
printf("%s already exists, use the SET commmand instead\n",
err_printf(status, argv[1]);
err_printf("environment variable %s created\n", argv[1]);
printf(msg_invalid_cmd);
printf(msg_insuff_params);
printf(msg_invalid_option);
printf(ev_delete(argv[i], EV$K_USER), argv[i]);
printf(msg_invalid_cmd);
printf(ers00msg);
printf(msg_invalid_cmd);
printf(msg_ev_badvalue, argv[1]);
printf("Console is in ");
printf("basic");
printf("advanced");
printf("diagnostic");
printf(" mode\n");
printf(msg_sys_reset);
err_printf("Invalid command\n");
err_printf(status);
printf("set host <CPU ID>\n");
printf("invalid CPU ID\n");
printf("CPU %d is not halted\n", id);
err_printf(msg_missing_device);
err_printf(msg_no_device, argv[i]);
err_printf(msg_cmd_noparams);
err_printf(msg_cnsl_secure);
err_printf(msg_no_vldpsswd);
File: iobq_cmd.c
err_printf( msg_insuff_mem, p_estimate * sizeof( *clone) );
printf( msg_show_iob_hdr1);
printf( msg_show_iob_hdr2);
printf ("%08x %12.12s %-12.12s %6d %4d %4d %13d %13d\n",
printf ("iobq_count= %4d iobq addr= %08x fl,bl= %08x %08x\n pcbq addr= %08x fl,bl= %08x %08x\n",
err_printf( msg_insuff_mem, p_estimate * sizeof( *clone) );
printf (" bytes bytes\n");
printf (" Name read written sysqaddr fl bl pcbqaddr fl bl\n");
printf ("------------ ----- ------- -------- -- -- -------- -- --\n");
printf ("%*s %d %d %08x %08x %08x %08x %08x %08x\n",
File: show_rawhide.c
printf("Use show_status command\n");
printf(msg_invalid_option);
printf("%c", evp->attributes & EV$M_READ ? '-' : 'r');
printf("%c", evp->attributes & EV$M_WRITE ? '-' : 'w');
printf("%c", evp->attributes & EV$M_DELETE ? '-' : 'd');
printf(" ");
printf("%c", evp->attributes & EV$M_VOLATILE ? 'n' : 'v');
printf("%c", evp->attributes & EV$M_CLASS ? 'g' : 'l');
printf("%c", evp->attributes & EV$M_TYPE ? 'i' : 's');
printf(" ");
printf("%-20s\t%-16s%s\n", evp->name, evp->value.string,
printf("%-20s\t%-16x%x\n", evp->name, evp->value.integer,
printf("%-20s\t%x\n", evp->name, evp->value.integer);
printf(msg_invalid_cmd);
printf("Console is in ");
printf("basic");
printf("advanced");
printf("diagnostic");
printf(" mode\n");
printf("%s\n", ub->string);
printf("%s\n", pb->string);
printf("dev : %08x\n", dev);
printf(" ba : %08x\n", ban);
printf(" window ->name %s\n",w->name);
printf(" window ->count %x\n",w->count);
printf(" window ->size %x\n",w->size);
printf(" window ->dev[%x] %x\n",j, i[j]);
printf("next window entry \n");
err_printf("Error: Failed to read I2C EEPROM on %s\n", "iic_mthrbrd");
printf(" System Motherboard ");
printf("%-8s 0 %-04x mthrbrd0 %-9s\n",
printf(" 0 %-04x mthrbrd0\n", rev);
printf(" Digital Equipment Corporation\n");
printf(" AlphaServer %4s\n",modelnum);
printf("\n Console %c%d.%d-%d %s\n",
printf("\n Module Part # Type Rev Name Serial #\n");
printf("\n Module Type Rev Name \n");
printf(" %-21s %-8s %-4x %-04X %-9s %-10s",
printf(" %-21s %-4x %-04X %-9s", name,
printf(" (failed)");
printf(" %-21s N/A %-4x %-04X %-9s N/A ",
printf(" %-21s %-4x %-04X %-9s",
printf(" (failed)");
printf(" %-21s %-8s %-4x %-04X %-9s %-10s",
printf(" %-21s %-4x %-04x %-9s",
printf(" (failed)");
printf(" %-21s %-8s %-4x %-04X %-9s %-10s",
printf(" %-21s %-4x %-04x %-9s",
printf(" (failed)");
printf(" %-2x %-24s %-8x %-04X %-9s",
printf(" (failed)");
printf(" (failed)");
printf(" (failed)");
printf(" %-2x %-24s %-8x %-04X %-9s",
printf(" (failed)");
printf("\n Bus 0 %-s%-s", name, pt);
printf(" (PCI%-s)\n", pt);
printf(" Bus %d %s", sbus, pt );
printf(" (%-s, slot %d)\n", name, slot);
printf(" Slot Option Name Type Rev Name\n");
printf("%-8s ", k->part->info[0].part_num);
printf("%s", k->part->info[0].serial_num);
printf(" %-21s %-8s %-4x %-04X %-9s %-10s",
printf(" %-21s %-4x %-04X %-9s", name,
printf(" (failed)");
printf(" %-21s N/A %-4x %-04X %-9s N/A ",
printf(" %-21s %-4x %-04X %-9s",
printf(" (failed)");
printf(" %-21s %-8s %-4x %-04X %-9s %-10s",
printf(" %-21s %-4x %-04x %-9s",
printf(" (failed)");
printf(" %-21s %-8s %-4x %-04X %-9s %-10s",
printf(" %-21s %-4x %-04x %-9s",
printf(" (failed)");
printf(" Digital Equipment Corporation\n");
printf(" AlphaServer %4s\n",modelnum);
printf("\n Console %c%d.%d-%d %s\n",
printf("\n Module Part # Type Rev Name Serial #\n");
printf("\n Module Type Rev Name \n");
printf( "\n Slot\tOption\t\t\tHose %d, Bus %d, PCI\n", hose, bus );
printf( " %2d/%d\t", slot, function );
printf( " %2d\t", slot );
printf( "%-20.20s\t", pb->hardware_name );
printf( "%-20.20s\t%s\n", pb->name, pb->info );
printf(" good");
printf("* BAD *");
printf(" ");
printf("%s %2d %2d:%02d ",months[c[5]],c[4],c[3],c[2]);
printf("Temperature Failure");
printf("%sSystem Fan %s Failure",(found ? ", " : ""),fan_fail[fan]);
printf("%sCPU Fan %s Failure",(found ? ", " : ""),fan_fail[fan]);
printf("%sPower Supply %s Failure",(found ? ", " : ""),ps_fail[ps]);
if (!(found)) printf("Temperature, Fans, Power Supplies Normal");
printf("\n Status\n");
printf("Power Supply %d ", i);
else printf(" not present\n");
printf("System Fans ");
printf("System Fan %d ",i);
printf("CPU Fans ");
printf("CPU Fan %d ",i);
printf("Temperature "); /* Temperature */
printf("The system was last reset via a%s reset\n\n", reset_string);
printf("%d Environmental events are logged in nvram\n",
printf("\nTotal Environmental Events: %d (%d logged)\n\n",
printf("%d ",i+1);
printf("\nSlot Type MB Base");
printf("\n---- ---- ---- --------\n");
printf(" %d %5s %4d %x\n", i, mem_type, size, *(UINT*) dp->dm[i].base);
printf("\nTotal %4d\n", total_size);
err_printf(msg_insuff_params);
printf("name ");
printf("type memadr offset olength\n");
printf("%-32.32s %-4.4s %8x %8x %8x(%d)\n",
printf("\t\t\t\t\t\t Total %8x(%d)\n", total, total);
printf("\nPrimary CPU: %02d", primary_cpu);
printf("\nActive CPUs: ");
printf("%02d ",i);
printf("\nConfigured CPUs: ");
printf("%02d ",i);
printf("\nSROM Revision: ");
printf("%4s ",srev);
printf("\n\n");
File: show_hwrpb.c
printf ("HWRPB is at %x\n", hwrpbp);
printf ("%08X hwrpb\n", hwrpbp);
printf (" %3d %08X %08X Physical address of base of HWRPB\n", ofh(BASE), ph(BASE));
printf (" %3d %08X %08X Identifying string 'HWRPB'\n", ofh(IDENT), ph(IDENT));
printf (" %3d %08X %08X HWRPB version number\n", ofh(REVISION), ph(REVISION));
printf (" %3d %08X %08X HWPRB size\n", ofh(HWRPB_SIZE), ph(HWRPB_SIZE));
printf (" %3d %08X %08X ID of primary processor\n", ofh(PRIMARY), ph(PRIMARY));
printf (" %3d %08X %08X System page size in bytes\n", ofh(PAGESIZE), ph(PAGESIZE));
printf (" %3d %08X %08X Physical address size in bits\n", ofh(PA_SIZE), ph(PA_SIZE));
printf (" %3d %08X %08X Maximum ASN value\n", ofh(ASN_MAX), ph(ASN_MAX));
printf (" %3d %08X %08X System serial number\n", ofh(SERIALNUM), hwrpbp->SERIALNUM [0] [1], hwrpbp->SERIALNUM [0] [0]);
printf (" %3d %08X %08X\n", (offsetof(struct HWRPB, SERIALNUM)+8),hwrpbp->SERIALNUM [1] [1], hwrpbp->SERIALNUM [1] [0]);
printf (" %3d %08X %08X Alpha system type\n", ofh(SYSTYPE), ph(SYSTYPE));
printf (" %3d %08X %08X system subtype\n", ofh(SYSVAR), ph(SYSVAR));
printf (" %3d %08X %08X System revision\n", ofh(SYSREV), ph(SYSREV));
printf (" %3d %08X %08X Interval clock interrupt frequency\n", ofh(ICLK_FREQ), ph(ICLK_FREQ));
printf (" %3d %08X %08X Cycle Counter frequency\n", ofh(CC_FREQ), ph(CC_FREQ));
printf (" %3d %08X %08X Virtual page table base\n", ofh(VPTBR), ph(VPTBR));
printf (" %3d %08X %08X Reserved for architecture use, SBZ\n", ofh(RSVD_ARCH), ph(RSVD_ARCH));
printf (" %3d %08X %08X Offset to Translation Buffer Hint Block\n",ofh(THB_OFFSET), ph(THB_OFFSET));
printf (" %3d %08X %08X Number of processor supported\n", ofh(NPROC), ph(NPROC));
printf (" %3d %08X %08X Size of Per-CPU Slots in bytes\n", ofh(SLOT_SIZE), ph(SLOT_SIZE));
printf (" %3d %08X %08X Offset to Per-CPU Slots\n", ofh(SLOT_OFFSET), ph(SLOT_OFFSET));
printf (" %3d %08X %08X Number of CTBs in CTB table\n", ofh(NUM_CTBS), ph(NUM_CTBS));
printf (" %3d %08X %08X Size of largest CTB in CTB table\n", ofh(CTB_SIZE), ph(CTB_SIZE));
printf (" %3d %08X %08X Offset to Console Terminal Block\n", ofh(CTB_OFFSET), ph(CTB_OFFSET));
printf (" %3d %08X %08X Offset to Console Routine Block\n", ofh(CRB_OFFSET), ph(CRB_OFFSET));
printf (" %3d %08X %08X Offset to Memory Data Descriptors\n", ofh(MEM_OFFSET), ph(MEM_OFFSET));
printf (" %3d %08X %08X Offset to Configuration Data Table\n", ofh(CONFIG_OFFSET), ph(CONFIG_OFFSET));
printf (" %3d %08X %08X Offset to FRU Table\n", ofh(FRU_OFFSET), ph(FRU_OFFSET));
printf (" %3d %08X %08X Starting VA of SAVE_TERM routine\n", ofh(SAVE_TERM), ph(SAVE_TERM));
printf (" %3d %08X %08X Procedure Value of SAVE_TERM routine\n", ofh(SAVE_TERM_VALUE), ph(SAVE_TERM_VALUE));
printf (" %3d %08X %08X Starting VA of RESTORE_TERM routine\n", ofh(RESTORE_TERM), ph(RESTORE_TERM));
printf (" %3d %08X %08X Procedure Value of RESTORE_TERM routine\n",ofh(RESTORE_TERM_VALUE), ph(RESTORE_TERM_VALUE));
printf (" %3d %08X %08X VA of restart routine\n", ofh(RESTART), ph(RESTART));
printf (" %3d %08X %08X Restart procedure value\n", ofh(RESTART_VALUE), ph(RESTART_VALUE));
printf (" %3d %08X %08X Reserved to System Software\n", ofh(RSVD_SW), ph(RSVD_SW));
printf (" %3d %08X %08X Reserved to Hardware\n", ofh(RSVD_HW), ph(RSVD_HW));
printf (" %3d %08X %08X Checksum of HWRPB\n", ofh(CHKSUM), ph(CHKSUM));
printf (" %3d %08X %08X RX Ready bitmask\n", ofh(RXRDY), ph(RXRDY));
printf (" %3d %08X %08X TX Ready bitmask\n", ofh(TXRDY), ph(TXRDY));
printf (" %3d %08X %08X Offset to DSRDB\n", ofh(DSRDB_OFFSET), ph(DSRDB_OFFSET));
printf ("%08X slot at index %d\n", slot, index);
printf (" %08X %08X KSP\n", slot->HWPCB.VMS_HWPCB.KSP [1], slot->HWPCB.VMS_HWPCB.KSP [0]);
printf (" %08X %08X ESP\n", slot->HWPCB.VMS_HWPCB.ESP [1], slot->HWPCB.VMS_HWPCB.ESP [0]);
printf (" %08X %08X SSP\n", slot->HWPCB.VMS_HWPCB.SSP [1], slot->HWPCB.VMS_HWPCB.SSP [0]);
printf (" %08X %08X USP\n", slot->HWPCB.VMS_HWPCB.USP [1], slot->HWPCB.VMS_HWPCB.USP [0]);
printf (" %08X %08X PTBR\n", slot->HWPCB.VMS_HWPCB.PTBR [1], slot->HWPCB.VMS_HWPCB.PTBR [0]);
printf (" %08X %08X ASN\n", slot->HWPCB.VMS_HWPCB.ASN [1], slot->HWPCB.VMS_HWPCB.ASN [0]);
printf (" %08X %08X ASTEN_SR\n", slot->HWPCB.VMS_HWPCB.ASTEN_SR [1], slot->HWPCB.VMS_HWPCB.ASTEN_SR [0]);
printf (" %08X %08X FEN\n", slot->HWPCB.VMS_HWPCB.FEN [1], slot->HWPCB.VMS_HWPCB.FEN [0]);
printf (" %08X %08X CC\n", slot->HWPCB.VMS_HWPCB.CC [1], slot->HWPCB.VMS_HWPCB.CC [0]);
printf (" %08X %08X SCRATCH [%d]\n",slot->HWPCB.VMS_HWPCB.SCRATCH [1] [i], slot->HWPCB.VMS_HWPCB.SCRATCH [0] [i], i);
printf (" %d Boot in progress\n", slot->STATE.SLOT$V_BIP );
printf (" %d Restart capable\n", slot->STATE.SLOT$V_RC );
printf (" %d Processor available\n", slot->STATE.SLOT$V_PA );
printf (" %d Processor present\n", slot->STATE.SLOT$V_PP );
printf (" %d Operator halted\n", slot->STATE.SLOT$V_OH );
printf (" %d Context valid\n", slot->STATE.SLOT$V_CV );
printf (" %d Palcode valid\n", slot->STATE.SLOT$V_PV );
printf (" %d Palcode memory valid\n", slot->STATE.SLOT$V_PMV );
printf (" %d Palcode loaded\n", slot->STATE.SLOT$V_PL );
printf (" %d Reserved MBZ\n", slot->STATE.SLOT$V_RSVD_MBZ0 );
printf (" %d Halt requested \n", slot->STATE.SLOT$V_HALT_REQUESTED );
printf (" %d Reserved MBZ\n", slot->STATE.SLOT$V_RSVD_MBZ1 );
printf (" %d Reserved MBZ\n", slot->STATE.SLOT$L_RSVD_MBZ2 );
printf (" %08X %08X PAL_MEM_LEN \n", slot->PAL_MEM_LEN [1], slot->PAL_MEM_LEN [0]);
printf (" %08X %08X PAL_SCR_LEN \n", slot->PAL_SCR_LEN [1], slot->PAL_SCR_LEN [0]);
printf (" %08X %08X PAL_MEM_ADR \n", slot->PAL_MEM_ADR [1], slot->PAL_MEM_ADR [0]);
printf (" %08X %08X PAL_SCR_ADR \n", slot->PAL_SCR_ADR [1], slot->PAL_SCR_ADR [0]);
printf (" %08X %08X PAL_REV \n", slot->PAL_REV [1], slot->PAL_REV [0]);
printf (" %08X %08X CPU_TYPE \n", slot->CPU_TYPE [1], slot->CPU_TYPE [0]);
printf (" %08X %08X CPU_VAR \n", slot->CPU_VAR [1], slot->CPU_VAR [0]);
printf (" %08X %08X CPU_REV \n", slot->CPU_REV [1], slot->CPU_REV [0]);
printf (" %08X %08X SERIAL_NUM \n", slot->SERIAL_NUM [i] [1], slot->SERIAL_NUM [i] [0]);
printf (" %08X %08X PAL_LOGOUT \n", slot->PAL_LOGOUT [1], slot->PAL_LOGOUT [0]);
printf (" %08X %08X PAL_LOGOUT_LEN \n", slot->PAL_LOGOUT_LEN [1], slot->PAL_LOGOUT_LEN [0]);
printf (" %08X %08X HALT_PCBB \n", slot->HALT_PCBB [1], slot->HALT_PCBB [0]);
printf (" %08X %08X HALT_PC \n", slot->HALT_PC [1], slot->HALT_PC [0]);
printf (" %08X %08X HALT_PS \n", slot->HALT_PS [1], slot->HALT_PS [0]);
printf (" %08X %08X HALT_ARGLIST \n", slot->HALT_ARGLIST [1], slot->HALT_ARGLIST [0]);
printf (" %08X %08X HALT_RETURN \n", slot->HALT_RETURN [1], slot->HALT_RETURN [0]);
printf (" %08X %08X HALT_VALUE \n", slot->HALT_VALUE [1], slot->HALT_VALUE [0]);
printf (" %08X %08X HALTCODE \n", slot->HALTCODE [1], slot->HALTCODE [0]);
printf (" %08X %08X RSVD_SW \n", slot->RSVD_SW [1], slot->RSVD_SW [0]);
printf (" %08X RXLEN \n", slot->RXLEN);
printf (" %08X TXLEN \n", slot->TXLEN);
printf ("%08X console terminal block\n", ctb);
printf ("%08X console routine block\n", crb);
printf (" %08X %08X VDISPATCH\n", crb->CRB$Q_VDISPATCH [1], crb->CRB$Q_VDISPATCH [0]);
printf (" %08X %08X PDISPATCH\n", crb->CRB$Q_PDISPATCH [1], crb->CRB$Q_PDISPATCH [0]);
printf (" %08X %08X VFIXUP\n", crb->CRB$Q_VFIXUP [1], crb->CRB$Q_VFIXUP [0]);
printf (" %08X %08X PFIXUP\n", crb->CRB$Q_PFIXUP [1], crb->CRB$Q_PFIXUP [0]);
printf (" %08X %08X ENTRIES\n", crb->CRB$Q_ENTRIES [1], crb->CRB$Q_ENTRIES [0]);
printf (" %08X %08X PAGES\n", crb->CRB$Q_PAGES [1], crb->CRB$Q_PAGES [0]);
printf (" %08X %08X V_ADDRESS\n", crbe->CRB_ENTRY$Q_V_ADDRESS [1], crbe->CRB_ENTRY$Q_V_ADDRESS [0]);
printf (" %08X %08X P_ADDRESS\n", crbe->CRB_ENTRY$Q_P_ADDRESS [1], crbe->CRB_ENTRY$Q_P_ADDRESS [0]);
printf (" %08X %08X PAGE_COUNT\n", crbe->CRB_ENTRY$Q_PAGE_COUNT [1], crbe->CRB_ENTRY$Q_PAGE_COUNT [0]);
printf ("%08X memory descriptor\n", memdsc);
printf (" %08X %08X CHECKSUM\n", memdsc->CHECKSUM [1], memdsc->CHECKSUM [0]);
printf (" %08X %08X IMP_DATA_PA\n", memdsc->IMP_DATA_PA [1], memdsc->IMP_DATA_PA [0]);
printf (" %08X %08X CLUSTER_COUNT\n", memdsc->CLUSTER_COUNT [1], memdsc->CLUSTER_COUNT [0]);
printf (" %08X %08X START_PFN\n", memdsc->CLUSTER [i].START_PFN [1], memdsc->CLUSTER [i].START_PFN [0]);
printf (" %08X %08X PFN_COUNT\n", memdsc->CLUSTER [i].PFN_COUNT [1], memdsc->CLUSTER [i].PFN_COUNT [0]);
printf (" %08X %08X TEST_COUNT\n", memdsc->CLUSTER [i].TEST_COUNT [1], memdsc->CLUSTER [i].TEST_COUNT [0]);
printf (" %08X %08X BITMAP_VA\n", memdsc->CLUSTER [i].BITMAP_VA [1], memdsc->CLUSTER [i].BITMAP_VA [0]);
printf (" %08X %08X BITMAP_PA\n", memdsc->CLUSTER [i].BITMAP_PA [1], memdsc->CLUSTER [i].BITMAP_PA [0]);
printf (" %08X %08X BITMAP_CHKSUM\n", memdsc->CLUSTER [i].BITMAP_CHKSUM [1], memdsc->CLUSTER [i].BITMAP_CHKSUM [0]);
printf (" %08X %08X USAGE\n", memdsc->CLUSTER [i].USAGE [1], memdsc->CLUSTER [i].USAGE [0]);
printf (" %8d bad page(s)\n", bad);
printf ("%08X Dynamic System Recognition Data block\n", dsrdb);
printf (" %08X %08X SMM\n", dsrdb->SMM [1], dsrdb->SMM [0]);
printf (" %08X %08X Offset to LURT\n", dsrdb->LURT_OFFSET [1], dsrdb->LURT_OFFSET [0]);
printf (" %08X %08X Offset to Name Count\n", dsrdb->NAME_OFFSET [1], dsrdb->NAME_OFFSET [0]);
printf (" %08X %08X LURT Count\n", 0, lurt_count);
printf (" %08X %08X LURT Column %d\n",
printf (" %08X %08X Name Count\n", 0, name_count);
printf (" Platform Name = %s\n", name);
File: show_flash_rawhide.c
err_printf (status);
printf("Image 0\n");
printf("Image 1\n");
printf("Image 2\n");
printf("Image 3\n");
printf("\nFlash free space = %x(%d)\n", free_space, free_space);
err_printf("%d Errors Detected\n", error_count);
printf(" Pattern %08x, Checksum %08x, Id %.4s\n", x1, x2, &x3);
printf(" Copy Size %d, Copy Checksum %08x\n", x4, x5);
printf(" Load Address %x, Index Ptr %x\n", x6, x7);
printf(" Creation Time ");
err_printf("Pattern is incorrect\n");
err_printf("Header checksum is incorrect, computed = %08x\n", cksum);
err_printf("Copy checksum is incorrect, computed = %08x\n", cksum);
printf(" Index Count %d, ", j);
printf("Checksum %08x, ", x1);
printf("Version %c%d.%d-%d\n", x2, x3, x4, x5);
printf(" Image %d, Offset %x", k, ioffset);
printf(", Id %.4s, File: %.32s\n", &x1, fname);
printf(" Time ");
printf(", Checksum %08x\n", x4);
printf(" Original Length %d", x2);
printf(", Compressed Length %d\n", x5);
err_printf("Flash open failure\n");
err_printf("Flash read failure\n");
err_printf("AlphaBIOS image invalid\n");
err_printf("Flash read failure\n");
err_printf("AlphaBIOS image invalid\n");
printf("Id\t\t= %.4s\n", (ahp + arc_id));
printf("File\t\t= %s\n", (ahp + arc_file_spec));
printf("Creation Time\t= ");
printf("Version\t\t= %c", *fsptr);
printf("%d.", *fsptr);
printf("%d-", *fsptr);
printf("%d\n", *fsptr);
printf("Overall Size\t= %d, Checksum = %08x\n", x6, x3);
printf("Header Length = %d, Data Length = %d\n", x1, x2);
printf("Trailer id = %.4s, Trailer offset = %x\n", &arc_trailer[1], arc_trailer[0]);
err_printf("AlphaBIOS image checksum error, actual %08x, computed %08x\n", cksum, checksum);
File: show_map.c
printf ("ptbr 0x%x ptep0 0x%x \n",ptbr,ptep0);
printf ("p0p->pfn 0x%x ptpe1 0x%x \n",p0p->pfn,ptep1);
printf ("ptbr 0x%x ptep1 0x%x \n",ptbr,ptep1);
printf ("p1p->pfn 0x%x ptpe2 0x%x \n",p1p->pfn,ptep2);
printf ("p2p->pfn 0x%x ptpe3 0x%x \n",p2p->pfn,ptep3);
printf ("===\n");
printf ("pte %016X %016X va %016X pa %016X\n",
File: pi_driver.c
err_printf (status);
err_printf( status);
printf( msg_pi_bad_validate, 110);
printf( msg_pi_bad_validate, 120);
printf( msg_pi_bad_validate, 210);
printf( msg_pi_bad_validate, 220);
printf( msg_pi_bad_validate, status);
File: tee_driver.c
err_printf(msg_file_not_found, info );
err_printf(msg_file_not_found, next );
File: powerup_rawhide.c
qprintf("Loading startup overlays\n");
qprintf("Loading start2 overlays\n");
pprintf("user-selected memory test set to %s\n", evp_diags->value.string);
pprintf("skipping power-up I/O tests - disabled by user\n");
pprintf("\nOnly the first %d MBs of memory was tested, memory_test set to %s!!\n\n", size, evp_diags->value.string);
err_printf("\nPower-up tests have detected a problem with your system!\n");
err_printf("Reset the system and observe the OCP display and/or type\n");
err_printf("SHOW CONFIG and SHOW POWER to obtain more information.\n\n");
err_printf("\nYour system is configured with a mixture of B3002 and B3004 CPUs.\n");
err_printf("The CPU in slot %d must be a B3002 to guarantee proper operation!!!!\n\n", id);
err_printf("Error: VGA must be placed in PCI bus 0 only\n");
pprintf("CPU%d not started - disabled via CPU_ENABLED EV\n", i);
pprintf("CPU%d failed to set SEC_JUMP on CPU%d\n", id, i);
pprintf("Secondary CPU%d failed to join\n",i);
pprintf("CPU%02x: iod_diag timeout on %s\n", id, argvp[3]);
pprintf("CPU%02x: %s timeout\n", id, dargv[0]);
qprintf("Executing %s\n", dargv[0]);
qprintf("Executing %s on device %s\n", dargv[0], dargv[3]);
pprintf("Lookup of %s failed\n", dargv[0]);
printf("%s ",dargv[0]);
File: config_rawhide.c
qprintf("slot %d - MEM\n",dev->slot );
pprintf("sizing memory\n");
qprintf("slot %d - CPU\n",dev->slot);
qprintf("slot %d IOD (%x) - hose %d \n",dev->slot, dev->dtype, dev->hose);
printf("memconfig : Unknown device type %04X\n", dev->dtype);
pprintf("probing IOD%d hose %d \n", dev->hose, dev->hose);
pprintf("Error: Failed to write I2C EEPROM on %s\n", node_name);
pprintf("Error: Failed to read I2C EEPROM on %s\n", node_name);
File: memory_rawhide.c
pprintf("Error: First memory must occupy slot 0\n");
pprintf("Error: Memory slots must be populated contiguously\n");
pprintf("Error: Memory must be ordered largest, in lower slots, to smallest, in higher slots\n");
pprintf("Error: SIMM carrier in slot 2 or 3, or memory pair type not equal\n");
pprintf("Error: Illegal memory size code %x\n", code);
pprintf("Error: Slot %d memory pair size is not equal\n", i);
File: ev_action.c
err_printf("set language 0 and reset system for language menu selection\n");
err_printf("bad value - valid selections:\n");
err_printf(" %15x - %s\n",lt[i].code, lt[i].name);
err_printf("\n USE \"Num Lock\" TO ENABLE KEYPAD, THEN SELECT YOUR LANGUAGE\n");
err_printf("%2d) %s\n", i, lt[i].name);
err_printf("\n\n");
err_printf("Reset the system to implement this change.");
err_printf("\n\n");
err_printf( "device %s is ambiguous\n", device );
err_printf( "string is too long to add %s\n", device );
err_printf( "device %s is invalid\n", device );
err_printf( "string is too long\n" );
err_printf( "warning -- TEMPORARY change; make PERMANENT changes with the Baud Rate Switch\n" );
err_printf("Disabling the primary CPU may produce unpredictable system behavior!\n");
err_printf("Invalid CPU mask\n");
err_printf("Serial ROM must be at V2.0 or greater to support alternate baud rates.\n");
default: pprintf("Invalid baud rate\n");
err_printf(status);
err_printf(status);
err_printf( "string is too long\n" );
File: ev_driver.c
err_printf("ev_init_ev: ev_write failure\n");
err_printf("ev_init_ev: ev_locate failure\n");
err_printf("bad value - valid selections:\n");
err_printf(" %s\n",tptr->param);
File: diag_evs.c
printf("%10s = %s\n", diag_ev_table[code].kct_string,
printf("%10s = %s\n", diag_ev_table[code].kct_string,
printf("%10s = %s\n", diag_ev_table[code].kct_string,
printf("%10s = %x\n", diag_ev_table[code].kct_string, evp->value.integer);
printf("%10s = %s\n", diag_ev_table[code].kct_string, evp->value.string);
err_printf("bad value - valid selections:\n");
err_printf(" %s\n",ct->kct_string);
err_printf(msg_noev, diag_ev_table[code].kct_string);
err_printf(status, diag_ev_table[code].kct_string);
File: boot.c
printf("\nUnknown system state.\n");
printf("System must be reset prior to boot.\n\n");
printf("\nInconsistent boot driver state.\n");
printf("System will be reset prior to boot.\n\n");
printf("Innsufficient Heap for overlay decompression.\n");
printf("System will be reset prior to boot.\n");
err_printf( msg_noboot_params );
pprintf("\nboot disallowed: ");
err_printf("CPU Speed error\n");
err_printf("Unknown Board Type\n");
err_printf("%xh\n",dont_boot);
pprintf ("\n\tAttempts to boot without P2 installed = %d\n\n",p2_cnt);
printf( msg_no_boot );
err_printf( "warning -- main memory zone is not free\n" );
err_printf( status );
err_printf( "usage is boot <device> [-file <file>] [-flags <flags>]\n" );
printf( msg_boot_delay );
err_printf( "\nRetrying, type ^C to abort...\n\n" );
printf("Illegal memory configuration - booting disabled.\n");
printf("Illegal KN7CD/E configuration - booting disabled.\n");
printf( "(boot %s%s%s%s%s)\n", device,
err_printf( "failed to open %s\n", device );
printf( "\nTrying MOP boot.\n" );
printf( "\nTrying BOOTP boot.\n" );
printf( "unrecognized boot device type\n" );
err_printf( "bootstrap failure\n" );
printf( "bootstrap code read in\n" );
printf( "base = %x, image_start = %x, image_bytes = %x\n", base, image_start, image_bytes );
printf( "changing image_start to %x\n", image_start );
printf( "initializing HWRPB at %x\n", hwrpb );
printf( "initializing page table at %x\n", pt );
printf ("Exceeded the number of allocated PTEs, continuing anyway.\n");
printf( "initializing machine state\n" );
printf( "setting affinity to the primary CPU\n" );
printf( "jumping to bootstrap code\n" );
printf( "failed to read %s\n", device );
printf( "block 0 of %s is not a valid boot block\n", device );
printf( "block 0 of %s is a valid boot block\n", device );
printf( "reading %d blocks from %s\n", i, device );
printf( "failed to read %s\n", device );
printf( "failed to read %s\n", device );
printf( "failed to read %s\n", device );
printf( "%s is not an ANSI labeled tape\n", device );
printf( "reading file %s from %s\n", filename, device );
printf( "boot block format for %s\n", device );
printf( "record 0 of %s is not a valid boot block, must be data\n", device );
printf( "record 0 of %s is a valid boot block\n", device );
printf( "unrecognized tape format\n" );
printf( fp->status, 512 );
printf( "%d records read\n", n );
printf( "HDR1 record missing\n" );
printf( "found file %s\n", filename );
printf("fp:%x\n",fp);
printf(" fp->ip:%x\n",fp->ip);
printf(" fp->local_offset[0]:%x fp->local_offset[1]:%x\n",
printf(" fp->offset:%x \n", fp->offset);
printf(" fp->mode: %x\n", fp->mode);
printf(" fp->rap: %x\n", fp->rap);
printf(" fp->status: %x\n",fp->status);
printf(" fp->count: %x\n",fp->count);
printf(" fp->misc: %x\n", fp->misc);
printf("boot block : %08x\n",bb);
printf("inode : %08x\n",ip);
printf(" ip->%s : %s\n","name",ip->name);
printf("ddb : %08x\n",ddb);
printf(" ddb->%s : %s\n","name",ddb->name);
printf("SRM boot identifier: %s\n",&dname);
printf("boot adapter: %s%d rev %x in bus slot %d",
printf(" off of %s%d in TLSB slot %d\n",t->tbl->mnemonic,t->unit,t->slot);
File: call_backs.c
qprintf("cb_getc: unit %x fread %x %x\n", unit, i, string[0]);
qprintf("cb_getc: kbd_get %x\n", i);
qprintf("cb_getc: mouse_get %x\n", i);
qprintf("cb_puts: unit %x string %x i %x\n", unit, string[0], i);
qprintf("cb_puts: unit %x string %x i %x\n", unit, string[0], i);
pprintf("process keycode entered\n");
qprintf("cb_set_term_int: unit %x, rx_req %x tx_req %x\n",
qprintf("cb_set_term_int: ttfp %x\n", ttfp);
pprintf("cb_open: %s, %s\n", dname, fname);
pprintf("\ncb_open: failed %s, %s\n", dname, fname);
pprintf("cb_close\n");
pprintf("cb_read: dst = %x, lbn = %d, size = %d\n",
pprintf("cb_read, size:%d lbn:%d dst:%x fp:%x\n", size, lbn, dst,fp);
pprintf("cb_read, fp name:%s\n", fp->ip->name);
pprintf("call cb read driver routine, size:%d\n", k);
pprintf("cb_read exit: size = %x(%d)\n", size, size);
pprintf("cb_read exit, :%d\n", l);
pprintf("cb_write: src = %x, lbn = %d, size = %d\n",
pprintf("cb_write, size:%d fp:%x lbn:%d src:%x\n", size, fp, lbn, src);
pprintf("cb_write, fp name:%s\n", fp->ip->name);
pprintf("cb_write exit\n");
pprintf("set_env: %s, %s\n", name, value);
pprintf("get_env: %s, %s\n", name, &ev->value);
pprintf("get_env: %s failed\n", name);
pprintf("save_env:\n");
File: hwrpb.c
err_printf( msg_exdep_devseekerr,0,device_name);
err_printf( msg_ex_devreaderr, sizeof(struct IIC_EEPROM),0,device_name);
pprintf("[1]: pa: %x va: %x/%x \n",pa,va,*va);
pprintf("[2]: pa: %x va: %x/%x \n",pa,va,*va);
pprintf("map_via_crb: memory_high_limit not yet assigned value\n");
pprintf("hwrpb @ %08x, crb @ %08x\n", hwrpb, crb);
pprintf("warning -- HWRPB is invalid\n");
File: hwrpbtt_driver.c
pprintf( "\n%s\n", pb->slot->TX );
File: fru_table.c
pprintf("FRU table creation disabled\n");
pprintf("Building FRU table");
pprintf("new fru %x\n", fru_table_ptr );
pprintf("ft start 0x%x, ", ft);
pprintf("adding 0x%x bytes, ", size);
pprintf("total bytes 0x%x, ",fru_table_ptr->byte_count);
pprintf("ft end 0x%x\n", ft);
pprintf("build_tlv: %s of length:0x%x\n",string,length);
pprintf("\nBuild_Standard_FRU at 0x%x\n\n",f);
pprintf("\nBuild_Memory_FRU at 0x%x\n\n",f);
printf( "Address %x %x does not point to a valid resource or FRU\n", rh, *rh);
printf( "Address %x %x does not point to a valid resource\n", rh, *rh);
printf("Invalid resource type\n");
pprintf("FRU_TABLE_LOAD_ADDRESS: 0x%x\n", (int) fru_table_ptr + rh->fru_offset);
printf("Invalid FRU at %x %x\n", ft, *ft);
printf("TLV string length error %x %x\n", string_len, l);
printf("%s %s\n", name, s);
printf( "------------- RESOURCE -------------\n");
printf( "------------- Platform Resource -------------\n");
printf("environment variables\n\n");
printf( "------------- CPU Resource -------------\n");
printf( "------------- Powerup Log Resource -------------\n");
printf( "------------- Power Resource -------------\n");
printf( "------------- Cooling Resource -------------\n");
printf( "------------- Cache Resource -------------\n");
printf( "------------- Memory Resource -------------\n");
printf( "------------- SYS_BUS Resource -------------\n");
printf( "------------- IOD Resource -------------\n");
printf( "------------- PCI Resource -------------\n");
printf( "------------- EISA Resource -------------\n");
printf( "------------- XMI Resource -------------\n");
printf( "------------- FBUS Resource -------------\n");
pprintf("\nSHOWING a FRU at 0x%x\n\n",f);
printf( "------------- FRU -------------\n");
pprintf("\nSHOWING Memory FRU at 0x%x\n\n",mf);
File: fru_table_rawhide.c
pprintf("adding Powerup Log resource %x\n", powerup_log);
pprintf("adding Power resource %x\n", power);
pprintf("adding CPU resource %x\n", cpu);
pprintf("adding Cache resource %x\n", cache);
pprintf("adding MEMORY resource %x\n", m);
pprintf("adding IOD resource %x\n", iod);
pprintf("adding EISA resource %x\n", pceb);
pprintf("adding PCI resource %x\n", pci);
pprintf("PCB bus %d\n", sdev->bus );
File: arcfw_cmd.c
err_printf (status);
err_printf("No EISA bus found.\n");
err_printf("No EISA bus found.\n");
err_printf(msg_invalid_option);
err_printf(msg_insuff_params);
err_printf(status);
printf("\nInvalid date. The correct date must be entered before continuing.\n");
File: arcboot.c
printf ("memory descriptors\n");
printf("Transferring control...\n");
pprintf("\n\nProgram Terminated...\n");
pprintf("Control returned to system firmware.\n\n");
printf ("can't find %s\n", arc_name);
printf ("%s -> %s\n", arc_name, native_name);
printf("Loading image...\n");
printf ("Can't find %s\n", native_name );
printf ("%s -> %s\n", native_name, arc_name );
printf("Loading image...\n");
printf ("%m: %s\n", arc_to_msg [status], path);
err_printf ("can't allocate %d pages for page tables\n", num_pages);
err_printf ("can't allocate space for a user scb, continuing anyway\n");
qprintf ("arc_evclone didn't find %s\n", s);
printf ("%s\n", s);
for (i=0; i<argc-1; i++) printf ("%2d %s\n", i, argv [i]);
err_printf( "warning -- main memory zone is not free\n" );
err_printf( status );
File: arc_load.c
err_printf ("can't read image header from file %s\n", ImagePath);
err_printf ("Bad image header on %s\n", ImagePath);
err_printf ("unknown section type\n");
pprintf ("from %08X for %08X bytes at %08X (%08x) (%s)\n",
err_printf ("Unknown relocation type\n");
File: eisa_config_rawhide.c
pprintf(" probing EISA Bridge, bus 1\n");
pprintf(" bus %d slot %d - %s\n", dev->bus, dev->slot, xptr->name);
pprintf ("cvt: %08x %s\n",id,idc);
File: eisa_bus_sniff.c
err_printf("could not open jflash\n");
err_printf("could not open eerom\n");
err_printf("EISA Data in non-volatile storage is corrupt\n");
err_printf("Environment Data in non-volatile storage is corrupt\n");
err_printf("EISA Data in non-volatile storage is corrupt\n");
pprintf (
err_printf (
err_printf (
err_printf("cfg data offset = %04x\n",offset);
err_printf("length[%d] = %04x\n",key,length[key]);
err_printf("eisa_slot[%d].slot_id = %s\n",
err_printf("eisa_slot[%d].p_cfg = %08x\n",
err_printf("slot_number =%d\n",slot_number);
err_printf("id = %s\n",id);
err_printf("ECU error, slot %d, found %s, expected nothing\n",
err_printf("id_info = %02x\n",id_info);
err_printf("configuring virtual slot\n");
err_printf("ECU error, slot %d, found %s, expected %s\n",
err_printf("Slot: %d num_functions = %02x\n",SlotNumber,num_functions);
err_printf("Function = %d\n",Function);
err_printf("*FunctionInfo = %02x\n",*FunctionInfo);
err_printf("freeform\n");
err_printf("ASC_ENTRY: %s\n",&local_ptr[CFG_ASC_BLK_OFS]);
err_printf("CfgOK\n");
err_printf("memory starting addr = %08x\n",Addr);
err_printf(" memory size = %08x\n",Size);
err_printf("marking MemoryBad start: %08x, end: %08x\n",
err_printf("? ERROR: Index = 0x%x, which is greater than 0x%x.\n",
err_printf("IrqBlock[%d] = %04x\n",Index,IrqBlock[Index]);
err_printf("IrqBit = %04x\n",IrqBit);
err_printf("int1_edge_level = %02x\n",inportb(0,0x26));
err_printf("int2_edge_level = %02x\n",inportb(0,0x27));
err_printf("dma channel = %d\n",DmaNumber);
err_printf("DMA ext write mode reg = %02x\n",Register);
err_printf("IoPort = %04x",IoPort);
err_printf(" ByteValue:%02x",ByteValue);
err_printf(" ByteMask:%02x",ByteMask);
err_printf(" ByteValue:%02x\n",ByteValue);
err_printf(" ShortValue:%02x",ShortValue);
err_printf(" ShortMask:%02x",ShortMask);
err_printf(" ShortValue:%02x\n",ShortValue);
err_printf(" WordValue:%02x",WordValue);
err_printf(" WordMask:%02x",WordMask);
err_printf(" WordValue:%02x\n",WordValue);
err_printf("Cfg port init error\n");
err_printf("\nEISA Configuration Error\nRun the EISA Configuration Utility\n\n");
err_printf("Slot (%d) %s Error\n",SlotNumber,
File: floppy.c
printf("malloc: %s %x,%d\n", sym, addr, size);
printf("malloc_opt: %s %x,%d\n", sym, addr, size);
printf("free: %s %x\n", sym, ptr);
err_printf("offset must be a multiple of the sector size\n");
File: pci_config.c
err_printf( "skipping PCI bus %d due to detected interference\n", pci_bus );
err_printf("device %x size %x hose %d slot %d bus %d address space request too large\n",
if (space == PCI_SMEM) err_printf("PCI sparse memory");
if (space == PCI_IO) err_printf("PCI IO");
if (space == PCI_DMEM) err_printf("PCI dense memory");
err_printf(" space exceeded\n");
pprintf("\n\n -------------------------------------------------\n\n");
if (space == PCI_SMEM) pprintf("Sparse Memory\n");
if (space == PCI_IO) pprintf("IO\n");
if (space == PCI_DMEM) pprintf("Dense Memory\n");
pprintf("hose %x slot %x bus %x device %x\n\n", ndev->hose, ndev->slot, ndev->bus, ndev->dtype);
pprintf (" %d %x %d %x %x\n", q->info, q->size, q->reg, q->dev->dtype, q->base_address);
pprintf("Bridge - slot: %x prim_bus: %x sec_bus: %x sub_bus %x\n", k->slot, bah->prim_bus, bah->sec_bus,
pprintf(" Sparse Memory Range: %x - %x\n", bah->range[PCI_SMEM].base[0], bah->range[PCI_SMEM].limit[0]);
pprintf(" Dense Memory Range: %x - %x\n", bah->range[PCI_DMEM].base[0], bah->range[PCI_DMEM].limit[0]);
pprintf (" %d %x %d %x %x\n", q->info, q->size, q->reg, q->dev->dtype, q->base_address);
pprintf(" ");
pprintf(" probing PCI-PCI Bridge, bus %d\n", sbus);
pprintf(" ");
pprintf(" bus %d slot %d ", ndev->bus, ndev->slot);
pprintf("function %d - ", ndev->function);
pprintf("- ");
pprintf("%s\n", xptr->name);
pprintf("%s Controller\n", &device_name[0] );
err_printf( "PCI device in hose %d slot %d incorrectly decodes Type 1 configuration cycles,\n", hose, j );
err_printf( "may interfere with subordinate PCI buses.\n");
File: pci_exdep.c
printf("%x<4:3> = %d (byte access)\n", pci_ptr, access);
printf("%x<6:5> = %d (byte %d valid)\n", pci_ptr, valid ,valid);
printf("%x<4:3> = %d (word access)\n", pci_ptr, access);
printf("%x<6:5> = %d (bytes 2,3 valid)\n", pci_ptr, valid);
printf("%x<6:5> = %d (bytes 1,0 valid)\n", pci_ptr, valid);
printf("%x<4:3> = %d (long access)\n", pci_ptr, access);
printf("%x<6:5> = %d (all bytes valid)\n", pci_ptr, valid);
err_printf (status);
printf("conflicting qualifiers\n");
printf("%s\n", shell_command);
printf("too many args\n");
printf("Hose %x Bus %x Slot %x Function %x Offset %x\n", pb.hose, pb.bus, pb.slot, pb.function, offset);
printf("parameter value out of range\n");
printf("too many args\n");
printf("parameter out of range\n");
printf("parameter out of range\n");
printf("parameter out of range\n");
printf("parameter out of range\n");
printf("Address space: %x Access Length: %x Write: %x Who: %x\n", command & 0x3, command % 0xc, command & 0x4000,
printf("Hose: %x Mask: %x\n", hose, mask);
printf("Address: %x", address);
printf(" Data: %x\n", data);
printf("MBX data returned: %x\n", mbx->rdata);
File: pci_nvram_driver.c
printf("start pci_nvram_config\n");
qprintf("Testing PCI NVRAM module\n");
printf("set up addr and size\n");
printf("pb->nvram_mem_base: %x\n",pb->nvram_mem_base);
printf("pb->nvram_size: %x\n",pb->nvram_size);
printf("pb->pb.csr: %x\n",pb->pb.csr);
printf("%x = %08x\n", (i*4), incfgl(pb, (i*4)));
err_printf(msg_cmm_wrn_presto_valid);
qprintf("PCI NVRAM tests ");
qprintf("passed\n");
qprintf("failed\n");
printf("diag_status: %x \n",pb->diag_status);
printf("%x = %08x\n", (i*4), incfgl(pb, (i*4)));
printf("end pci_nvram_config\n");
printf("cookie_value = %x\n",cookie_value);
printf("start pci_nvram_zero_sram\n");
printf("loop_len = %x\n",loop_len);
printf("addr = %08x\n",addr);
printf("end pci_nvram_zero_sram\n");
pprintf("1 incfgl(pb, BATT_CSR) = %x\n",incfgl(pb, BATT_CSR));
printf("failure1 incfgl(pb, BATT_CSR) = %x\n",
pprintf("2 incfgl(pb, BATT_CSR) = %x\n",incfgl(pb, BATT_CSR));
pprintf("3 incfgl(pb, BATT_CSR) = %x\n",incfgl(pb, BATT_CSR));
pprintf("4 incfgl(pb, BATT_CSR) = %x\n",incfgl(pb, BATT_CSR));
err_printf("\n*** Error PCI NVRAM - Battery Test ***\n");
err_printf("Battery missing or Insulator installed\n\n");
pprintf("5 incfgl(pb, BATT_CSR) = %x\n",incfgl(pb, BATT_CSR));
pprintf("6 incfgl(pb, BATT_CSR) = %x\n",incfgl(pb, BATT_CSR));
pprintf("7 incfgl(pb, BATT_CSR) = %x\n",incfgl(pb, BATT_CSR));
printf("j = %x\n",j);
printf("failure2 incfgl(pb, BATT_CSR) = %x\n",
printf("(PRESTO_BATT_ENAB>>i)&1 = %x\n",(PRESTO_BATT_ENAB>>i) & 1);
printf("(PRESTO_BATT_ENAB>>i)&1<<1 = %x\n",
printf("incfgl(pb, BATT_CSR) = %x\n",
printf("failure3 incfgl(pb, BATT_CSR) = %x\n",
printf("start pci_nvram_sram_diag\n");
printf("start_addr = %x\n",start_addr);
printf("loop_len = %x\n",loop_len);
printf("%08x = %016x\n",addr, write_data);
printf("%08x = %016x\n",addr, read_data);
err_printf("\n*** Error PCI NVRAM - Memory Test ***\n");
err_printf("PCI memory address %08x\n", addr);
err_printf("expected data %016x\n", write_data);
err_printf("received data %016x\n\n", read_data);
printf("end pci_nvram_sram_diag\n");
printf("start pci_nvram_dma_diag\n");
printf("main_mem_buff = %08x\n",main_mem_buff);
printf("DMA_BUFF_SIZE = %08x\n",DMA_BUFF_SIZE);
printf("DMA_QW_SIZE = %08x\n",DMA_QW_SIZE);
printf("slave_addr = %08x\n",slave_addr);
printf("nvram_buff = %08x\n",nvram_buff);
printf("master_addr = %08x\n",master_addr);
printf("dma countdown was %d\n",i);
err_printf("\n*** Error PCI NVRAM - DMA Test ***\n");
err_printf("DMA transfer timed out\n\n");
printf("%08x: %016x\n",(main_mem_buff+i),read_data);
err_printf("\n*** Error PCI NVRAM - DMA Test ***\n");
err_printf("Main memory address %08x\n", main_mem_buff+i);
err_printf("expected data %016x\n", write_data);
err_printf("received data %016x\n\n", read_data);
printf("zero the nvram SRAM\n");
printf("dma countdown was %d\n",i);
err_printf("\n*** Error PCI NVRAM - DMA Test ***\n");
err_printf("DMA transfer timed out\n\n");
printf("%08x: %016x\n",(nvram_buff+(i*4)),read_data);
err_printf("\n*** Error PCI NVRAM - DMA Test ***\n");
err_printf("PCI memory address %08x\n", nvram_buff+(i*4));
err_printf("expected data %016x\n", write_data);
err_printf("received data %016x\n\n", read_data);
printf("end pci_nvram_dma_diag\n");
File: prcache.c
printf("cbus_presto_installed = %x\n",cbus_presto_installed);
printf("eisa_presto_installed = %x\n",eisa_presto_installed);
printf("pci_presto_installed = %x\n",pci_presto_installed);
printf("total_installed = %x\n",total_installed);
printf("No NVRAM Disk Cache installed\n");
printf("Multiple NVRAM Disk Caches installed\n");
printf("Please specify: ");
printf("CBUS or ");
printf("EISA or ");
printf("PCI ");
printf("No %s NVRAM Disk Cache installed\n",nvr.presto_bus);
printf("%s NVRAM Disk Cache failed powerup test\n",nvr.presto_bus);
printf("%s NVRAM Disk Cache is not configured\n",nvr.presto_bus);
printf("%s NVRAM Disk Cache installed\n",nvr.presto_bus);
printf("This command will zero the %s NVRAM Disk Cache\n",
printf("clearing disk cache\n");
printf("%s NVRAM Disk Cache unchanged\n",nvr.presto_bus);
printf("disable battery disk cache\n");
File: prcache_pci.c
pprintf("pci_nvram_find\n");
pprintf("pci_nvram_configured\n");
pprintf("pci_nvram_test_status\n");
pprintf("start pci_nvram_zero\n");
pprintf("loop_len = %x\n",loop_len);
pprintf("addr = %x\n",addr);
pprintf("end pci_nvram_zero\n");
pprintf("pci_nvram_bat_enable\n");
pprintf("pci_nvram_diap_status\n");
printf("%s NVRAM Disk Cache: ",dev_bus);
printf("failed\n");
printf("passed\n");
printf("Size: %3dMB\n", pb->nvram_size/0x100000);
printf("%s Memory Address: %08x\n", dev_bus,pb->nvram_mem_base);
printf("System ID: ");
printf("%08x\n", ssn);
printf("??????\n");
printf("State: ");
printf(msg_presto_valid);
printf(msg_presto_not_valid);
printf("Battery Status: ");
printf("failed\n");
printf("good ");
printf("(Charged)\n");
printf("(Charging)\n");
printf("Battery Disconnect Circuit Status: ");
printf("enabled\n");
printf("disabled\n");
pprintf("Found %d nvrams\n",nvcnt);
pprintf("nvr_pb.pb.hose : %d\n", nvr_pb.pb.hose);
pprintf("nvr_pb.pb.slot : %d\n", nvr_pb.pb.slot);
pprintf("nvr_pb.nvram_size : %x\n", nvr_pb.nvram_size);
pprintf("nvr_pb.nvram_mem_base : %x\n", nvr_pb.nvram_mem_base);
File: kbd_driver.c
err_printf("mouse_rxoff: failed to disable interrupts\n");
err_printf("mouse_rxon: failed to enable interrupts\n");
err_printf("kbd_rxoff: failed to disable interrupts\n");
err_printf("kbd_rxon: failed to enable interrupts\n");
pprintf("\nkbd_process - scan code = %x(%d) ",c,c);
pprintf(" %d(%x)",i,(*bptr & 0xff));
pprintf("keyboard_interrupt: failed to disable interrupts\n");
pprintf("mouse_interrupt: failed to disable interrupts\n");
qprintf("initializing keyboard\n");
err_printf("\n** keyboard error **\n");
err_printf("\n** mouse error **\n");
err_printf("\n** no keyboard interrupts received **\n");
err_printf("\n** no mouse interrupts received **\n");
err_printf("kbd0: no such device\n");
err_printf("KBD: failed to disable interrupts\n");
err_printf("mouse0: no such device\n");
err_printf("MOUSE: failed to disable interrupts\n");
err_printf("** keyboard enable int error **\n");
err_printf("** mouse enable int error **\n");
err_printf("** keyboard error **\n");
err_printf("** mouse error **\n");
err_printf("** no keyboard interrupts received **\n");
err_printf("** no mouse interrupts received **\n");
err_printf("*** keyboard not plugged in...\n");
qprintf("*** keyboard not plugged in...\n");
err_printf("kbd test %d failed\n", status);
qprintf("kbd test %d failed\n", status);
err_printf("mouse test %d failed\n", status);
qprintf("kbd_reinit\n");
err_printf(msg_no_kbd_use_serial);
printf("Console in graphics mode\n");
File: tga_turbo.c
err_printf("TGA not initialized\n");
pprintf("Invalid selection\n");
err_printf("No TGA in system\n");
err_printf("TGA: failed to disable interrupts\n");
err_printf("TGA not initialized\n");
pprintf("tga_int_handler\n");
pprintf("TGA not emulated\n");
err_printf("Unknown Graphics module type\n");
err_printf("Unknown RAMDAC\n");
err_printf("TGA WaitEndFrame failure\n");
err_printf("TGA WaitEndFrame failure\n");
File: vga_bios_driver.c
qprintf("Initializing VGA\n");
qprintf("Initialize VGA hardware\n");
err_printf("VGA Bios failed, status = %x\n", x86_status);
pprintf ("Set loc x: %d y: %d\n",chs->ds.CursorXPosition,
pprintf ("ch: %02x att: %02x xpos: %d ypos: %d\n",char_index,attribute,xpos,ypos);
qprintf("Starting Bios Emulator\n");
qprintf("Loading X86 & X86A\n");
qprintf("Created x86_process: pid %x\n", x86_pid);
qprintf("Completed Bios Emulation, status = %x\n", x86_status);
qprintf("Stopping X86 Bios\n");
qprintf("Completed VGA\n");
File: vga_cmds.c
err_printf("VGA not initialized\n");
pprintf("Invalid selection\n");
File: aputchar.c
printf ("CSI %c %d %d\n",chs->as.buf [chs->as.bufix-1],chs->as.pval[0],
printf ("ESC %c\n",(char)final);
printf ("ERASE: final: %c p0: %d\n",final,chs->as.pval [0] );
File: para_driver.c
err_printf("Printer error \n");
err_printf("Printer offline \n");
err_printf("Printer paper empty \n");
File: scsi.c
err_printf( msg_bad_request, inode->name );
err_printf( msg_write_prot, inode->name );
err_printf( msg_bad_request, inode->name );
err_printf( msg_bad_device, inode->name );
err_printf( msg_bad_inode, inode->name );
fprintf( el_fp, msg_scsi_bad_su, name );
fprintf( el_fp, msg_scsi_bad_ms, name );
err_printf( msg_scsi_not_512, name );
err_printf( msg_scsi_bad_rc, name );
err_printf( msg_scsi_bad_rewind, name );
err_printf( msg_scsi_bad_read, name );
err_printf( msg_scsi_bad_write, name );
err_printf( msg_scsi_bad_read, name );
err_printf( msg_scsi_bad_write, name );
err_printf( msg_scsi_bad_write, name );
fprintf( el_fp, msg_scsi_ill_dev_typ, t, sb->name );
fprintf( el_fp, msg_dev_found, inode->name, ub->info, sb->name );
printf( "%-18s %-24s %5s %5s\n", ub->inode->name, ub->alias, ub->info, ub->version );
fprintf( el_fp, msg_dev_lost, inode->name, ub->info, sb->name );
err_printf( msg_scsi_ill_err_cod, dat_in[0], name );
fprintf( el_fp, msg_scsi_sense_key, "No Sense",
fprintf( el_fp, msg_scsi_sense_key, "Recovered Error",
fprintf( el_fp, msg_scsi_sense_key, "Not Ready",
err_printf( msg_not_ready, name );
err_printf( msg_no_media, name );
err_printf( msg_not_ready, name );
fprintf( el_fp, msg_scsi_sense_key, "Medium Error",
fprintf( el_fp, msg_scsi_sense_key, "Hardware Error",
fprintf( el_fp, msg_scsi_sense_key, "Illegal Request",
fprintf( el_fp, msg_scsi_sense_key, "Unit Attention",
fprintf( el_fp, msg_scsi_sense_key, "Data Protect",
fprintf( el_fp, msg_scsi_sense_key, "Blank Check",
err_printf( msg_scsi_sense_key_x, t,
err_printf( msg_scsi_bad_status, sts[0], sb->name );
err_printf( msg_scsi_retries_gone, sb->name );
err_printf( msg_scsi_send_fail, sb->name );
fprintf( el_fp, msg_scsi_send_fail, sb->name );
File: nport_q.c
pprintf("N_Port Queue Pointer: %x\n",n_qp);
pprintf(" N_CARRIER *head_ptr: %x\n",n_qp->head_ptr);
pprintf(" rsvd0: %x\n", n_qp->rsvd0);
pprintf(" N_CARRIER *tail_ptr: %x\n",n_qp->tail_ptr);
pprintf(" rsvd1: %x\n", n_qp->rsvd1);
pprintf("N_Port Queue Carrier: %x\n",n_carrier);
pprintf(" struct n_carrier *next_ptr: %x\n", n_carrier->next_ptr);
pprintf(" int rsvd0: %x\n",n_carrier->rsvd0);
pprintf(" N_Q_BUF_HEAD *q_buf_ptr: %X\n",n_carrier->q_buf_ptr);
pprintf(" int rsvd1: %x\n",n_carrier->rsvd1);
pprintf(" N_Q_BUF_HEAD: *q_buf_token: %x\n",n_carrier->q_buf_token);
pprintf(" int rsvd2: %x\n",n_carrier->rsvd2);
pprintf(" struct n_carrier *car_token: %x\n",n_carrier->car_token);
pprintf(" int rsvd3: %x\n",n_carrier->rsvd3);
pprintf(" N_Port Queue Buffer: %x\n",n_q_buf_head);
pprintf(" struct n_q_buf_head *token : %x\n",n_q_buf_head->token);
pprintf(" unsigned int rsvd : %x\n",n_q_buf_head->rsvd);
pprintf(" unsigned char opc : %x : %s\n",n_q_buf_head->opc,
pprintf(" unsigned char chnl_idx : %x\n",n_q_buf_head->chnl_idx);
pprintf(" unsigned short int flags : %x\n",n_q_buf_head->flags);
pprintf(" unsigned short int status : %x\n",n_q_buf_head->status);
pprintf(" unsigned char i_opc : %x : %s\n",n_q_buf_head->i_opc,
pprintf(" unsigned char i_flags : %x\n",n_q_buf_head->i_flags);
pprintf(" unsigned short dst_xport : %x\n",n_q_buf_head->dst_xport);
pprintf(" unsigned short src_xport : %x\n",n_q_buf_head->src_xport);
pprintf(" unsigned int rsvd1 : %x\n",n_q_buf_head->rsvd1);
File: simport.c
err_printf("error initializing %s, ASR = %x",pb->pb.name,asr);
err_printf("pb->ab = %08x\n",
err_printf("pb->ab->DACQ.tail_ptr = %08x\n",
err_printf("pb->ab->DACQ.head_ptr->next_ptr = %08x\n",
err_printf("pb->ab->ADRQ.head_ptr = %08x\n",
err_printf("pb->ab->ADRQ.tail_ptr = %08x\n",
err_printf("pb->ab->ADRQ.head_ptr->next_ptr = %08x\n",
err_printf("pb->ab->DAFQ.head_ptr = %08x\n",
err_printf("pb->ab->DAFQ.tail_ptr = %08x\n",
err_printf("pb->ab->DAFQ.head_ptr->next_ptr = %08x\n",
err_printf("pb->ab->ADFQ.head_ptr = %08x\n",
err_printf("pb->ab->ADFQ.tail_ptr = %08x\n",
err_printf("pb->ab->ADFQ.head_ptr->next_ptr = %08x\n",
qprintf("sim_set_adapter_state failed\n");
qprintf("sim_set_parameters failed\n");
qprintf("second sim_set_adapter_state failed\n");
qprintf("sim_set_channel_state failed\n");
pprintf("queue_insert\n");
pprintf("queue_remove\n");
pprintf("sim_set_adapter_state\n");
pprintf("sim_adapter_state_set_response\n");
pprintf("sim_set_parameters\n");
qprintf("must send Set Adapter State cmd.\n");
pprintf("sim_set_channel_state\n");
pprintf("sim_channel_state_set_response\n");
pprintf("sim_set_device_state\n");
qprintf("SIMPORT set device state command timed out\n");
pprintf("sim_device_state_set_response\n");
qprintf("SIMPort command verify adapter sanity timed out\n");
qprintf("SIMPort command read counters timed out\n");
printf("Time since counters zero'ed: %d msec \n",
printf("Host bus faults: %d\n", counters->BusFaults);
printf("SCSI Commands send: %d\n", counters->SCSIComSent);
printf("SCSI Commands received: %d\n",counters->SCSIComRecv);
printf("Total Data Phase bytes sent: %d\n",counters->DataSent);
printf("Total Data Phase bytes rec'd: %d\n",counters->DataRecv);
printf("SCSI bus resets: %d\n",counters->SCSIBusResets);
printf("Device resets sent: %d\n",counters->BDRsSent);
printf("Sel/Resel timeouts: %d\n", counters->SelTimeouts);
printf("Parity Errors: %d\n", counters->ParityErrs);
printf("Unsol. reselect: %d\n", counters->UnsolReselect);
printf("Bad messages rec'd: %d\n", counters->BadMessages);
printf("Message rejects rec'd: %d\n", counters->MessReject);
printf("Unexpect. Disconnects: %d\n", counters->UnexpDiscon);
printf("Phase mismatches: %d\n", counters->UnexpPhase);
printf("Handshake-to-handshake TO: %d\n",counters->SyncViol);
printf("Adapter specific counter[i]:%d\n",
pprintf("sim_execute_scsi_io\n");
qprintf("CAM command EXECUTE_SCSI_IO timed out\n");
printf("Path Inquiry data: \n");
printf("Version: %d\n",pi->version);
printf("SCSI capabilities...\n");
printf("\t soft reset \n");
printf("\t tagged queueing \n");
printf("\t linked commands \n");
printf("\t synchronous transfers \n");
printf("\t wide bus 16 \n");
printf("\t wide bus 32 \n");
printf("\t modify data pointers \n");
printf("Target mode support...\n");
printf("\t group 7 cmds \n");
printf("\t group 6 cmds \n");
printf("\t terminate I/O process \n");
printf("\t target mode disconnects \n");
printf("\t phase cognizant mode \n");
printf("\t host target mode \n");
printf("HBA engine count:%04x\n",pi->eng_count);
printf("private data area size:%d \n",pi->priv_data_size);
printf("asynch event capabilities: \n");
printf("\t unsolicited SCSI bus reset \n");
printf("\t unsolicited reselection \n");
printf("\t SCSI AEN \n");
printf("\t sent bus device reset to target \n");
printf("\t SIM module registered \n");
printf("\t SIM module de-registered \n");
printf("\t new devices found during rescan \n");
printf("highest path id:%02x \n",pi->high_path_id);
printf("initiator SCSI id:%02x \n",pi->init_id);
printf("SIM-supplier vendor id: \n");
printf("\t%08x\n",pi->sim_ven_id[i]);
printf("host bus adapter-supplier vendor id: \n");
printf("\t%08x\n",pi->hba_ven_id[i]);
qprintf("error, qc->status = %x, qc->func_code = %x\n",qc->status,qc->func_code);
pprintf("cam_wait_for_cmd_done\n");
pprintf("sim_proc_adrq\n");
qprintf("unsolic. msg: %02x\n",qc->func_code);
qprintf("unknown unsolicited msg:%08x\n", qc->func_code);
qprintf("asr error: %08x\n",asr);
qprintf("asr error: %08x\n",asr);
qprintf("SIMport Adapter error: asr = %x, afpr = %x\n",asr,afpr);
pprintf("amcsr_lo = %x\n",val);
pprintf("abbrr_lo = %x\n",val);
pprintf("dafqir_lo = %x\n",val);
pprintf("dacqir_lo = %x\n",val);
pprintf("asr_lo = %x\n",val);
pprintf("afar_lo = %x\n",val);
pprintf("afpr_lo = %x\n",val);
pprintf("sim r %x %x\n", csr, value);
pprintf("sim w %x %x\n", csr, value);
File: mscp_laser.c
qprintf("malloc: %s %x,%d\n", sym, addr, size);
printf("malloc: %s %x,%d\n", sym, addr, size);
err_printf("MSCP FATAL ERROR: malloc %s %d\n", sym, size);
qprintf("free: %s %x\n", sym, adr);
printf("free: %s %x\n", sym, adr);
err_printf("MSCP: Attempting to reestablish connection\n");
err_printf("MSCP: Continuing\n");
err_printf(msg_bad_request, inode->name);
err_printf(msg_bad_inode, inode->name);
err_printf("MSCP: Attempting to reestablish connection\n");
err_printf("MSCP: Continuing\n");
err_printf(msg_bad_request, inode->name);
err_printf(msg_bad_inode, inode->name);
err_printf(msg_no_device, inode->name);
err_printf(msg_mscp_not_multihost, inode->name);
err_printf(msg_mscp_not_exclusive, inode->name);
err_printf(msg_bad_device, inode->name);
err_printf(msg_bad_inode, inode->name);
err_printf(msg_mscp_no_conn, cb->sb->name);
err_printf(msg_mscp_no_conn, cb->sb->name);
err_printf(msg_mscp_bad_status, q->status.major, q->status.minor);
err_printf(msg_mscp_bad_available, ub->inode->name);
err_printf(msg_mscp_no_conn, cb->sb->name);
err_printf(msg_no_media, ub->inode->name);
err_printf(msg_mscp_bad_status, q->status.major, q->status.minor);
err_printf(msg_mscp_bad_online, ub->inode->name);
err_printf(msg_mscp_no_conn, cb->sb->name);
err_printf(msg_no_media, ub->inode->name);
err_printf(msg_mscp_bad_status, q->status.major, q->status.minor);
err_printf(msg_mscp_bad_read, ub->inode->name);
err_printf(msg_mscp_no_conn, cb->sb->name);
err_printf(msg_no_media, ub->inode->name);
err_printf(msg_write_prot, ub->inode->name);
err_printf(msg_mscp_bad_status, q->status.major, q->status.minor);
err_printf(msg_mscp_bad_write, ub->inode->name);
printf("unit unavailable: %s%s%d.%d.%d.%d.%d\n",
err_printf(msg_mscp_no_conn, cb->sb->name);
err_printf(msg_mscp_no_conn, cb->sb->name);
printf("%s\n", ub->string);
printf("%-18s %-24s %5s", ub->inode->name, ub->alias, ub->type);
printf(" MstSS");
printf(" MemSS");
printf(" %s%s%d.%d.%d.%d.%d", driver,
pprintf("\nDumping ub : %08x\n", ub);
pprintf("\nDumping rsp : %08x\n", rsp);
File: cdp_turbo.c
err_printf(status);
printf("\nDrive parameters changed\n");
err_printf(status, name);
printf("Found %s%d, slot %d, hose %d...\n", dev->tbl->mnemonic,
printf("\n%s:\n\n", cdp_sb->name);
printf("%-16s %-8s %16s %3d %5d $%d$%sA%d\n", cdp_sb->name,
printf("%-16s %-8s %16s %3d %5d %s$%sA%d\n", cdp_sb->name,
printf(msg_cdp_nn_too_long);
printf(msg_cdp_nn_not_alpha);
printf(msg_cdp_nn_not_alnum);
printf(msg_cdp_ac_value);
printf(msg_cdp_un_value);
printf(msg_cdp_no_write);
fprintf(cdp_ipipe, "set nodename %s\r", nodename);
fprintf(cdp_ipipe, "set forcenam 0\r");
fprintf(cdp_ipipe, "set allclass %d\r", a);
fprintf(cdp_ipipe, "set forceuni 1\r");
fprintf(cdp_ipipe, "set unitnum 0\r");
fprintf(cdp_ipipe, "set forceuni 0\r");
fprintf(cdp_ipipe, "set unitnum %d\r", u);
fprintf(cdp_ipipe, "write\r");
fprintf(cdp_ipipe, "yes\r");
fprintf(cdp_ipipe, "exit\r\32");
fprintf(cdp_ipipe, "show %s\r", ic);
printf("%s --> %s", cdp_sb->name, buffer);
printf("%s", buf);
printf("%s", buf);
File: dup.c
qprintf( msg_dup_cmd_tmo_fatal, cb->sb->name );
err_printf( msg_no_vc, sb->name );
err_printf( msg_dup_no_conn, sb->name );
printf( "starting %s on %s (%s)\n",
qprintf( "starting %s on %s (%s)\n",
qprintf( msg_dup_bad_cmd_rsp, p->opcode, cb->sb->name );
err_printf( msg_dup_no_conn, cb->sb->name );
err_printf( msg_dup_bad_status, q->status.major, q->status.minor );
err_printf( msg_dup_bad_get_cont, cb->sb->name );
err_printf( msg_dup_no_conn, cb->sb->name );
err_printf( msg_dup_bad_status, q->status.major, q->status.minor );
err_printf( msg_dup_bad_exe_local, cb->sb->name );
err_printf( msg_dup_bad_status, q->status.major, q->status.minor );
err_printf( msg_dup_bad_send, cb->sb->name );
err_printf( msg_dup_bad_status, q->status.major, q->status.minor );
err_printf( msg_dup_bad_receive, cb->sb->name );
err_printf( msg_dup_bad_status, q->status.major, q->status.minor );
err_printf( msg_dup_bad_send, cb->sb->name );
err_printf( msg_dup_no_conn, port );
qprintf( "%s --> %s\n", port, prompt );
qprintf( "%s --> %s\n", port, prompt );
qprintf( "%s --> %s\n", port, prompt );
err_printf( msg_dup_ill_msg_typ, type, port );
err_printf( msg_dup_no_conn, port );
printf( "%s\n", prompt );
printf( "%s\n", prompt );
err_printf( msg_dup_no_conn, port );
err_printf( msg_dup_ill_msg_typ, type, port );
err_printf( msg_dup_no_conn, port );
qprintf( "%s --> %s\n", port, prompt + 2 );
qprintf( "%s --> %s\n", port, prompt + 2 );
qprintf( "%s --> %s\n", port, prompt + 2 );
err_printf( msg_dup_ill_msg_typ, type, port );
err_printf( msg_dup_no_conn, port );
printf( "%s\n", prompt + 2 );
printf( "%s\n", prompt + 2 );
err_printf( msg_dup_no_conn, port );
err_printf( msg_dup_ill_msg_typ, type, port );
err_printf( msg_dup_no_conn, port );
File: fat_driver.c
qprintf ("%d estimated fat table width\n", estimated_width);
pprintf("FAT: null file name.\n");
pprintf ("%s\n", line);
pprintf ("%02X ", id [i] & 0xff);\
pprintf("This is a %d-bit FAT.\n", fats->fatbits);
pprintf ("%04X:%04X", i, getfat (fats, i));
pprintf (" ");
pprintf("vbo[%d] = %08x\tlbo[%d] = %08x\n",i,sp->mcb.vbo[i],i,
pprintf("vbo[%d] = %08x\n", i+1, sp->mcb.vbo[i+1]);
File: iso9660_driver.c
err_printf( "file %s not found\n", info );
qprintf( "volume descriptor type = %x\n", vd->VD$B_VOLUME_DESCRIPTOR_TYPE );
qprintf( "volume descriptor version = %x\n", vd->VD$B_VOLUME_DESCRIPTOR_VERS );
qprintf( "primary volume logical block size = %d\n", od->size );
qprintf( "open file `%s'\n", fname );
qprintf( "lookup `%s'\n", fname );
qprintf( "trying to find `%s'\n", fname );
qprintf( "comparing with `%.*s'\n",
qprintf( "curr_lbn = %d, last_lbn = %d, bib = %d, ffb = %d\n",
qprintf( "scanning directory `%s', looking for `%s'\n", dname, fname );
qprintf( "t1fname = `%s'\n", t1fname );
qprintf( "t2fname = `%s'\n", t2fname );
qprintf( "t3fname = `%s'\n", t3fname );
qprintf( "tfname = `%s'\n", tfname );
qprintf( "new tfname = `%s'\n", tfname );
qprintf( "compiling `%s'\n", fname );
qprintf( "tfname = `%s'\n", tfname );
qprintf( "getting header for root directory\n" );
qprintf( "getting header for `%.*s'\n",
qprintf( "reading %x bytes at LBN %x\n", od->size, lbn );
qprintf( "volume descriptor type = %x\n", vd->VD$B_VOLUME_DESCRIPTOR_TYPE );
qprintf( "volume descriptor version = %x\n", vd->VD$B_VOLUME_DESCRIPTOR_VERS );
File: ods2_driver.c
err_printf( "file %s not found\n", info );
qprintf( "volume structure level = %x\n", hm->HM2$B_STRUCLEV );
qprintf( "index bitmap starting LBN = %x\n", hm->HM2$L_IBMAPLBN );
qprintf( "index bitmap size = %x\n", hm->HM2$W_IBMAPSIZE );
qprintf( "maximum files on volume = %x\n", hm->HM2$L_MAXFILES );
qprintf( "cluster size = %x\n", hm->HM2$W_CLUSTER );
qprintf( "file structure level = %x\n", fh->FH2$B_STRUCLEV );
qprintf( "file ID = (%d,%d,%d)\n",
qprintf( "open file `%s'\n", fname );
qprintf( "file found, file ID = (%d,%d,%d)\n",
qprintf( "lookup `%s'\n", fname );
err_printf( "not a directory! file ID = (%d,%d,%d)\n",
qprintf( "trying to find `%s'\n", fname );
qprintf( "version = %d, neg = %d\n", ver, neg );
qprintf( "matched! version = %d, file ID = (%d,%d,%d)\n",
qprintf( "comparing with `%s'\n", tfname + 1 );
qprintf( "matched! version = %d, file ID = (%d,%d,%d)\n",
qprintf( "curr_vbn = %d, last_vbn = %d, bib = %d, ffb = %d\n",
qprintf( "scanning directory `%s', looking for `%s'\n", dname, fname );
qprintf( "t1fname = `%s'\n", t1fname );
qprintf( "t2fname = `%s'\n", t2fname );
qprintf( "t3fname = `%s'\n", t3fname );
qprintf( "version = %d, neg = %d\n", ver, neg );
qprintf( "tfname = `%s'\n", tfname + 1 );
qprintf( "compiling `%s'\n", fname );
qprintf( "tfname = `%s'\n", tfname );
qprintf( "getting header for (%d,%d,%d)\n",
qprintf( "converting VBN to LBN, VBN = %x\n", in_vbn );
qprintf( "retrieval pointer type = %x\n", fm->FM2$V_FORMAT );
qprintf( "count = %x, LBN = %x\n", n, lbn );
qprintf( "LBN = %x\n", *out_lbn );
File: cipca_driver.c
pprintf("Failied cixcd_init_adapter\n");
err_printf("CIPCA setmode error - illegal mode.\n");
err_printf("CIPCA setmode error - illegal mode.\n");
printf("%-18s %-7s %s\n", pb->pb.port_name, pb->pb.alias, pb->pb.info);
pprintf("poll in prog on node %d\n",i);
pprintf("[1]Poll: %d %s\n",
pprintf("[2]Poll: %d %s\n",
pprintf("[1]Poll: %d %s\n",
pprintf("[2]Poll: %d %s\n",
pprintf("Data Structure Error - AFAR:%x CASR1:%x\n",
pprintf("cipca: datagram free queue exhausted. Replenishing.\n",
pprintf("Dismissing the misc int\n");
fprintf(el_fp,"%s rev_hw:%x (REV:%c) rev_fw:%4.4s\n",
printf("CIPCA failed to disable port %s\n", pb->pb.port_name);
printf("CIPCA failed to enable port %s\n", pb->pb.port_name);
if (tq->sem.count) pprintf("Timed out waiting to enter DISABLED state\n");
pprintf("CIPCA does not have PORT INIT COMPLETE\n");
pprintf("CIPCA failed to init nport queues %s\n", pb->pb.port_name);
printf("CIPCA failed to init BDLT %s\n", pb->pb.port_name);
fprintf(el_fp,"CIPCA %s is CI node %d\n",
pprintf("CIPCA in wrong state to be enabled\n");
if (tq->sem.count) pprintf("Timed out waiting to enter ENABLED state\n");
pprintf("Adapter is ENABLED\n",p_args0);
pprintf("Adapter did not ENABLE\n",p_args0);
pprintf("CIPCA does not have PORT ENABLED COMPLETE\n");
pprintf("CIPCA %s is CI node %d is ENABLED\n",
pprintf("CIPCA_interrupt casr0:%x posting misc\n",value);
pprintf("CIPCA erroneous interrupt, psr = %08x\n", p_args1(csr_data));
pprintf("Launching zero checker\n");
pprintf("cipca driver failed to read os_type environment variable\n");
pprintf("os_type: %s - console CIPCA driver not started\n",
pprintf("addr %x : %x\n",addr, *(addr));
if (tq->sem.count) pprintf("Timed out waiting for INIT after adprst. NODESTS : %x\n", ndsts.i);
pprintf("pb at %x:\n",pb);
pprintf("CIPCA interrupt polled, pb = %x...\n", p_args1(pb));
pprintf("interrupt CASR:%x\n",value);
pprintf("posting completion routine\n");
pprintf("posting misc routine\n");
pprintf("CIPCA erroneous interrupt, psr = %08x\n", p_args1(csr_data));
pprintf("mscp_destroy_poll: p %x flink %x cb %x sb %x pb %x\n",
pprintf("mscp_destroy_poll: remq p = %x slot:%d hose:%d bus:%x\n",
pprintf("stopper\n", p_args0);
pprintf("%d ",i);
pprintf("%d ",i);
File: cipca_support.c
printf("%04d %c%x %08x %08x %08x %08x %08x %08x %08x %08x\n",
pprintf("cipca_dev:%x\n",cipca_dev[0]);
pprintf("sb:%x\n",pb->pb.sb[cixcd_node]);
pprintf("ci_sa_scs_send_appl_msg: cb->owed_credits:%x\n",
pprintf("ci_sa_scs_send_appl_msg: credits:%x\n",credits);
printf("n cixcd_sa_ppd_alloc buffer removal error.\n");
pprintf("%s New node %d %s %4.4s %4.4s %4.4s\n",
pprintf("ci_sa_ppd_send_scs_msg - p:%x\n",p);
printf(msg_ci_bad_path,pb->pb.string,'A',sb->node_id);
printf(msg_ci_bad_path,pb->pb.string,'B',sb->node_id);
pprintf("Illegal node found:%d for cluster size %d\n",
pprintf("ci_pb: %x\n",&(pb->pb));
pprintf(" unsigned long int node_id: %x\n",pb->node_id);
pprintf(" unsigned long int vector: %x\n",pb->vector);
pprintf(" unsigned long int vector2: %x\n",pb->vector2);
pprintf(" unsigned long int hard_base: %x\n",pb->hard_base);
pprintf(" unsigned long int soft_base: %x\n",pb->soft_base);
pprintf(" unsigned long int mem_base: %x\n",pb->mem_base);
pprintf(" unsigned long int poll: %x\n",pb->poll);
pprintf(" unsigned long int interrupt: %x\n",pb->interrupt);
pprintf(" struct kfmsa_blk *blk_ptr: %x\n",pb->blk_ptr);
pprintf(" struct SEMAPHORE *adap_s: %x\n",pb->adap_s);
pprintf(" NPORT_AB *ab: %x\n",pb->ab);
pprintf(" N_QP ddfq: %x\n", &pb->ddfq);
pprintf(" int ddfq_entries: %x\n",pb->ddfq_entries);
pprintf(" N_Q_BUFFER *N_buffer_blk: %x\n",pb->N_buffer_blk);
pprintf(" N_CARRIER *N_carrier_blk: %x\n",pb->N_carrier_blk);
pprintf(" BDL_PTR *bdlt_ptr_blk: %x\n",pb->bdlt_ptr_blk);
pprintf( "BDL *bdl_blk: %x\n",pb->bdl_blk);
pprintf(" N_CARRIER *car: %x\n",pb->car);
pprintf(" struct MBX *mbx: %x\n",pb->mbx);
pprintf(" int (*poke)(): %s\n",pb->poke);
pprintf(" ADAPTER_STATE adapter_state: %x\n",&pb->adapter_state);
pprintf("\t setmode: %x\n",pb->setmode);
pprintf("\t ref: %x\n",pb->ref);
pprintf("\t state: %x\n",pb->state);
pprintf("\t mode: %x\n",pb->mode);
pprintf("\t desired_mode: %x\n",pb->desired_mode);
pprintf("\t hose: %x\n",pb->hose);
pprintf("\t bus: %x\n",pb->bus);
pprintf("\t slot: %x\n",pb->slot);
pprintf("\t function: %x\n",pb->function);
pprintf("\t channel: %x\n",pb->channel);
pprintf("\t protocol: %x\n",pb->protocol);
pprintf("\t controller: %x\n",pb->controller);
pprintf("\t port_name: %s\n", pb->port_name);
pprintf("\t type: %x\n",pb->type);
pprintf("\t csr: %x\n",pb->csr);
pprintf("\t vector: %x\n",pb->vector);
pprintf("\t device: %s\n",pb->device);
pprintf("\t misc: %x\n",pb->misc);
pprintf("\t pdm: %x\n",pb->pdm);
pprintf("\t config_device: %x\n",pb->config_device);
pprintf("\t order: %x\n",pb->order);
pprintf("\t sb: %x\n",pb->sb);
pprintf("\t num_sb: %x\n",pb->num_sb);
pprintf("\t name: %s\n",pb->name);
pprintf("\t alias: %s\n",pb->alias);
pprintf("\t info: %s\n",pb->info);
pprintf("\t version: %s\n",pb->version);
pprintf("\t string: %s\n",pb->string);
pprintf("\t id: %s\n",pb->id);
pprintf("\t e_memq: %x\n", pb->e_memq);
pprintf("\t status: %x\n",pb->status);
pprintf("\t pq: %x\n",pb->pq);
pprintf("\t parent: %x\n",pb->parent);
pprintf("cixcd_blk : %x\n",blk_ptr);
pprintf(" u_int hose: %x\n",blk_ptr->hose);
pprintf(" u_int slot: %x\n",blk_ptr->slot);
pprintf(" u_int controller: %x\n",blk_ptr->controller);
pprintf(" u_int hard_base: %x\n",blk_ptr->hard_base);
pprintf(" u_int soft_base: %x\n",blk_ptr->soft_base);
pprintf(" u_int mem_base: %x\n",blk_ptr->mem_base);
pprintf(" u_int vect1: %x\n",blk_ptr->vect1);
pprintf(" u_int vect2: %x\n",blk_ptr->vect2);
pprintf(" u_int completion_pid: %x\n",blk_ptr->completion_pid);
pprintf(" u_int p_misc_pid: %x\n",blk_ptr->p_misc_pid);
pprintf(" u_int refcnt: %x\n",blk_ptr->refcnt);
pprintf(" struct pb *pb: %x\n",blk_ptr->pb);
pprintf(" struct SEMAPHORE completion_compl_s: %x\n",&blk_ptr->cixcd_completion_compl_s);
pprintf(" struct SEMAPHORE misc_compl_s: %x\n",&blk_ptr->cixcd_misc_compl_s);
pprintf(" struct SEMAPHORE completion_s: %x\n",&blk_ptr->cixcd_completion_s);
pprintf(" struct SEMAPHORE misc_s: %x\n",&blk_ptr->cixcd_misc_s);
pprintf(" struct SEMAPHORE adap_s: %x\n",&blk_ptr->cixcd_adap_s);
pprintf(" struct MBX *mbx_int: %x\n",blk_ptr->mbx_int);
pprintf(" NPORT_AB *ab: %x\n",blk_ptr->ab);
pprintf("TYPE_PTR : %x\n", type_ptr);
pprintf(" unsigned int type : 2 :%x\n",type_ptr->type);
pprintf(" unsigned int : 3 :\n");
pprintf(" unsigned int pa : 27 :%x\n",type_ptr->pa );
pprintf(" unsigned int pa_e : 16 :%x\n",type_ptr->pa_e );
pprintf(" unsigned int count : 16 :%x\n",type_ptr->count );
pprintf("PA_PTR : %x\n",pa_ptr);
pprintf("unsigned int : 5 :\n");
pprintf("unsigned int pa : 27 :%x\n", pa_ptr->pa );
pprintf("unsigned int pa_e : 16 :%x\n", pa_ptr->pa_e);
pprintf("unsigned int : 16 :\n");
pprintf("AMPB_PTR : %x\n",ampb_ptr);
pprintf(" unsigned int v : 1 :%x\n",ampb_ptr->v );
pprintf(" unsigned int : 4 :\n");
pprintf(" unsigned int pa : 27 :%x\n",ampb_ptr->pa );
pprintf(" unsigned int pa_e : 16 :%x\n",ampb_ptr->pa_e );
pprintf(" unsigned int : 16 :\n");
pprintf("BUF_NAME : %x\n",buffer_name);
pprintf(" unsigned int bdl_idx : 8 :%x\n",buffer_name->bdl_idx );
pprintf(" unsigned int bdlt_idx : 12 :%x\n",buffer_name->bdlt_idx);
pprintf(" unsigned int key : 12 :%x\n",buffer_name->key);
pprintf("Buffer Descriptor Leaf DBL : %x\n",bdl);
pprintf(" unsigned int page_offset : 13 :%x\n",bdl->page_offset );
pprintf(" unsigned int : 3 :\n");
pprintf(" unsigned int v : 1 :%x\n",bdl->v);
pprintf(" unsigned int ro : 1 :%x\n",bdl->ro);
pprintf(" unsigned int : 14 :\n");
pprintf(" BUF_NAME buf_name :%x\n",&bdl->buf_name);
pprintf(" unsigned int buf_len :%x\n",bdl->buf_len);
pprintf(" unsigned int : 32 :\n");
pprintf(" TYPE_PTR root0 :%x\n",&bdl->root0);
pprintf(" TYPE_PTR root1 :%x\n",&bdl->root1);
pprintf("Pointer to Buffer Descriptor Leaf: %x\n",bdl_ptr);
pprintf(" unsigned int v : 1 :%x\n",bdl_ptr->v );
pprintf(" unsigned int : 12 :\n");
pprintf(" unsigned long int bdl_ptr : 19 :%x\n",bdl_ptr->bdl_ptr );
pprintf(" unsigned long int bdl_ptr_e : 16 :%x\n",bdl_ptr->bdl_ptr_e );
pprintf(" unsigned long int : 16 :\n");
pprintf(" unsigned char soft[8] :%x\n",bdl_ptr->soft );
pprintf("N_Port command flags:%x\n",n_flags);
pprintf(" unsigned short int i : %x\n",n_flags->i);
pprintf(" --unsigned int r : 1 Generate response : %x\n",n_flags->f.r);
pprintf(" --unsigned int i : 1 Suppress interrupts : %x\n",n_flags->f.i);
pprintf(" --union f_d_ca : 1 : %x\n",n_flags->f.f_d_ca);
pprintf(" --unsigned int : 1 Should Be Zero \n");
pprintf(" --unsigned int sw : 4 Reserved for software : %x\n",n_flags->f.sw);
pprintf(" --unsigned int gn : 3 Virtual Circuit Generation Number : %x\n",n_flags->f.gn);
pprintf(" --unsigned int m : 3 Packet Multiple : %x\n",n_flags->f.m);
pprintf(" --unsigned int ps : 2 Path Select : %x\n",n_flags->f.ps);
pprintf("N_STATUS : %x\n",n_status);
pprintf(" unsigned short int i : %x\n",n_status->i);
pprintf(" or \n");
pprintf(" --unsigned int fail : 1 : %x\n",n_status->l.fail);
pprintf(" --unsigned int type : 7 : %x %s\n",n_status->l.type,
pprintf(" --unsigned int ptha : 2 Path A status : %x\n",n_status->l.ptha);
pprintf(" --unsigned int pthb : 2 Path B status : %x\n",n_status->l.pthb);
pprintf(" --unsigned int ca : 1 Counted events for All addresses : %x\n", n_status->l.ca);
pprintf(" --unsigned int : 3 Should Be Zero \n");
pprintf(" or \n");
pprintf(" --unsigned int fail : 1 : %x\n",n_status->r.fail);
pprintf(" --unsigned int type : 7 : %x %s\n",n_status->r.type,
pprintf(" --unsigned int rp : 2 Receive path : %x\n",n_status->r.rp);
pprintf("N_Q_BUFFER : %x\n",n_q_buffer);
pprintf(" N_Q_BUF_HEAD a :%x\n",&n_q_buffer->a );
pprintf(" unsigned char b[N_Q_BODY_SIZ] / %X[%x]\n",n_q_buffer->b,N_Q_BODY_SIZ );
pprintf("Adapter Parameter Block N_APB:%x\n",n_apb);
pprintf(" unsigned short int vcdt_len :%x\n",n_apb->vcdt_len );
pprintf(" unsigned short int ibuf_len :%x\n",n_apb->ibuf_len);
pprintf(" unsigned short int rampb :%x\n", n_apb->rampb);
pprintf(" unsigned short int type :%x\n", n_apb->type);
pprintf(" unsigned char imp_spec[8] :%x\n",n_apb->imp_spec );
pprintf(" unsigned char sbz[16] :%2x\n",n_apb->sbz );
pprintf("Nport Channel Parameter Block : %x\n",n_cpb);
pprintf(" unsigned short int xp_addr :%x\n", n_cpb->xp_addr);
pprintf(" unsigned char max_pgrp :%x\n", n_cpb->max_pgrp);
pprintf(" unsigned char max_mem :%x\n", n_cpb->max_mem);
pprintf(" int sbz :%x\n", n_cpb->sbz );
pprintf(" unsigned short int dlink_type :%x\n", n_cpb->dlink_type);
pprintf(" unsigned char dlink_param[6] : %x %x %x %x %x %x\n",
pprintf(" char imp_spec[16] :%x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x\n",
pprintf(" Nport Channel Command Queues : %x\n",n_ccq);
pprintf(" N_QP dccq3 head :%x\n",n_ccq->dccq3.head_ptr );
pprintf(" dccq3 tail :%x\n",n_ccq->dccq3.tail_ptr );
pprintf(" N_QP dccq2 head :%x\n",n_ccq->dccq2.head_ptr );
pprintf(" dccq2 tail :%x\n",n_ccq->dccq2.tail_ptr );
pprintf(" N_QP dccq1 head :%x\n",n_ccq->dccq1.head_ptr );
pprintf(" dccq1 tail :%x\n",n_ccq->dccq1.tail_ptr );
pprintf(" N_QP dccq0 head :%x\n",n_ccq->dccq0.head_ptr );
pprintf(" dccq0 tail :%x\n",n_ccq->dccq0.tail_ptr );
pprintf(" N_QP cccq3 head :%x\n",n_ccq->dccq3.head_ptr );
pprintf(" cccq3 tail :%x\n",n_ccq->dccq3.tail_ptr );
pprintf(" N_QP cccq2 head :%x\n",n_ccq->dccq2.head_ptr );
pprintf(" cccq2 tail :%x\n",n_ccq->dccq2.tail_ptr );
pprintf(" N_QP cccq1 head :%x\n",n_ccq->dccq1.head_ptr );
pprintf(" cccq1 tail :%x\n",n_ccq->dccq1.tail_ptr );
pprintf(" N_QP cccq0 head :%x\n",n_ccq->dccq0.head_ptr );
pprintf(" cccq0 tail :%x\n",n_ccq->dccq0.tail_ptr );
pprintf("N_Port Adapter Block : %x\n", nport_ab);
pprintf(" N_CCQ cq[MAX_CHAN] :%x[%x]\n",&nport_ab->cq,MAX_CHAN );
pprintf(" PRINTING ONLY cq[0] : \n"); dump_n_ccq(&nport_ab->cq[0]);
pprintf(" N_QP adrq head:%x\n", nport_ab->adrq.head_ptr);
pprintf(" adrq tail:%x\n", nport_ab->adrq.tail_ptr);
pprintf(" N_QP dadfq head:%x\n",nport_ab->dadfq.head_ptr );
pprintf(" dadfq tail:%x\n",nport_ab->dadfq.tail_ptr );
pprintf(" N_QP addfq head:%x\n",nport_ab->addfq.head_ptr );
pprintf(" addfq tail:%x\n",nport_ab->addfq.tail_ptr );
pprintf(" N_QP damfq head:%x\n",nport_ab->damfq.head_ptr );
pprintf(" damfq tail:%x\n",nport_ab->damfq.tail_ptr );
pprintf(" N_QP admfq head:%x\n",nport_ab->admfq.head_ptr );
pprintf(" admfq tail:%x\n",nport_ab->admfq.tail_ptr );
pprintf(" N_QP aadfq head:%x\n",nport_ab->aadfq.head_ptr );
pprintf(" aadfq tail:%x\n",nport_ab->aadfq.tail_ptr );
pprintf(" N_QP aamfq head:%x\n",nport_ab->aamfq.head_ptr );
pprintf(" aamfq tail:%x\n",nport_ab->aamfq.tail_ptr );
pprintf(" BDL_PTR *bdlt_base :%x\n", nport_ab->bdlt_base);
pprintf(" unsigned int rsvd0 :%x\n",nport_ab->rsvd0 );
pprintf(" unsigned int bdlt_len :%x\n", nport_ab->bdlt_len);
pprintf(" unsigned int keep_alive :%x\n",nport_ab->keep_alive );
pprintf(" unsigned int dqe_len :%x\n", nport_ab->dqe_len);
pprintf(" unsigned int mqe_len :%x\n", nport_ab->mqe_len);
pprintf(" unsigned int int_holdoff :%x\n", nport_ab->int_holdoff);
pprintf(" long int rsvd1 :%x\n", nport_ab->rsvd1);
pprintf(" AMPB_PTR ampb_base :%x\n", &nport_ab->ampb_base);
pprintf(" unsigned int ampb_len :%x\n", nport_ab->ampb_len);
pprintf(" unsigned int rsvd3 :%x\n", nport_ab->rsvd3);
pprintf(" unsigned char rsvd[32] :%x[32]\n",nport_ab->rsvd );
pprintf(" N_APB apb :%x\n",&nport_ab->apb );
pprintf(" N_CPB cpb[MAX_CHAN] :%x[%x]\n", &nport_ab->cpb,MAX_CHAN);
pprintf("Virtual Circuit Descriptor : %x\n",vcd);
pprintf(" unsigned int ns : 3 :%x\n",vcd->ns );
pprintf(" unsigned int nr : 3 :%x\n",vcd->nr );
pprintf(" unsigned int rdp : 1 :%x\n",vcd->rdp );
pprintf(" unsigned int fsn : 1 :%x\n",vcd->fsn );
pprintf(" unsigned int eas : 1 :%x\n",vcd->eas );
pprintf(" unsigned int psts : 2 :%x\n",vcd->psts );
pprintf(" unsigned int nadp : 1 :%x\n",vcd->nadp );
pprintf(" unsigned int dqi : 1 :%x\n",vcd->dqi );
pprintf(" unsigned int : 2 :n" );
pprintf(" unsigned int cst : 1 :%x\n",vcd->cst );
pprintf(" unsigned int : 10 :\n" );
pprintf(" unsigned int gn : 3 :%x\n",vcd->gn );
pprintf(" unsigned int : 1 :\n" );
pprintf(" unsigned int snd_st : 3 :%x\n",vcd->snd_st );
pprintf(" unsigned int : 5 :\n" );
pprintf(" unsigned int rcv_st : 2 :%x\n",vcd->rcv_st );
pprintf(" unsigned int : 22 :\n" );
pprintf("N_SETCKT : %x\n",n_setckt);
pprintf(" VCD mask :%x\n", n_setckt->mask);
pprintf(" VCD m_value :%x\n", n_setckt->m_value);
pprintf("N_CKTSET : %x\n",n_cktset);
pprintf(" VCD mask :%x\n", *(unsigned __int64*)(&n_cktset->mask));
pprintf(" VCD m_value :%x\n", *(unsigned __int64*)(&n_cktset->m_value));
pprintf(" VCD in_vcd :%x\n", *(unsigned __int64*)(&n_cktset->in_vcd));
pprintf(" unsigned short int vcd_res :%x\n",n_cktset->vcd_res );
pprintf(" unsigned short int rseq_res :%x\n", n_cktset->rseq_res);
pprintf(" unsigned short int sbz :%x\n", n_cktset->sbz);
pprintf("N_CHNV : %x\n",n_chnv);
pprintf(" unsigned int dqii : 1 :%x\n",n_chnv->dqii );
pprintf(" unsigned int dqid : 1 :%x\n",n_chnv->dqid );
pprintf(" unsigned int dqia : 1 :%x\n",n_chnv->dqia );
pprintf(" unsigned int : 29 :\n" );
pprintf(" unsigned int rsvd :%x\n",n_chnv->rsvd );
pprintf("N_SETCHNL : %x\n",n_setchnl);
pprintf(" N_CHNV mask :%x\n",&n_setchnl->mask );
pprintf(" N_CHNV m_value :%x\n",&n_setchnl->m_value );
pprintf("N_CHNLSET : %x\n",n_chnlset);
pprintf(" N_CHNV mask :%x\n",&n_chnlset->mask );
pprintf(" N_CHNV m_value :%x\n", &n_chnlset->m_value);
pprintf(" N_CHNV in_chnlst :%x\n", &n_chnlset->in_chnlst);
pprintf(" unsigned short int vcd_res :%x\n", n_chnlset->vcd_res);
pprintf("N_PURGQ : %x\n",n_purgq);
pprintf(" unsigned char cmdq_mask :%x\n",n_purgq->cmdq_mask );
pprintf("N_QPURG : %x\n",n_qpurg);
pprintf(" unsigned char cmdq_mask :%x\n",n_qpurg->cmdq_mask );
pprintf("adprst (%x) : %s\n",adprst,"WO");
pprintf("clrinta (%x) : %s\n",clrinta,"WO");
pprintf("clrintb (%x) : %s\n",clrintb,"WO");
pprintf("aitcr (%x) : %s\n",aitcr,"WO");
pprintf("nodests (%x) : %x\n",nodests,rl(nodests));
pprintf("intena (%x) : %x\n",intena,rl(intena));
pprintf("abbr (%x) : %x\n",abbr,rl(abbr));
pprintf("ccq2ir (%x) : %s\n",ccq2ir,"WO");
pprintf("ccq1ir (%x) : %s\n",ccq1ir,"WO");
pprintf("ccq0ir (%x) : %s\n",ccq0ir,"WO");
pprintf("adfqir (%x) : %s\n",adfqir,"WO");
pprintf("amfqir (%x) : %s\n",amfqir,"WO");
pprintf("casr0 (%x) : %x\n",casr0,rl(casr0));
pprintf("casr1 (%x) : %x\n",casr1,rl(casr1));
pprintf("cafar0 (%x) : %x\n",cafar0,rl(cafar0));
pprintf("casrcr (%x) : %s\n",casrcr,"WO");
pprintf("cicr (%x) : %s\n",cicr,"WO");
pprintf("cecr (%x) : %s\n",cecr,"WO");
pprintf("amtcr (%x) : %s\n",amtcr,"WO");
pprintf("amtecr (%x) : %s\n",amtecr,"WO");
pprintf("amcsr (%x) : %x\n",amcsr,rl(amcsr));
pprintf("accx (%x) : %x\n",accx,rl(accx));
pprintf("mrev (%x) : %x\n",amtecr,rl(mrev));
pprintf("musr (%x) : %x\n",musr,rl(musr));
pprintf("amtecr (%x) : %s\n",amtecr,"WO");
pprintf("sb:%x %s %s node_id:%x \n",sb,sb->name,
pprintf("\t pdevice:%x verbose:%x dqi:%x\n",
pprintf("\t stallvc:%x vc:%x ackrec:%x\n",sb->stallvc,sb->vc,
pprintf("In the NPORT overlay; need the call between\n");
pprintf("In the NPORT overlay; need the call between\n");
File: cipca_common.c
printf("%04d %c%x %08x %08x %08x %08x %08x %08x %08x %08x\n",
pprintf("cixcd_get_nbuf: ddfq carrier removal failure car %x, buff %x, num ddfq entries %x\n",
pprintf("num_ptrs:%x \n", num_ptrs);
pprintf("num_bdl:%x \n", num_bdl);
pprintf("bld_ptr:%x \n", bdl_ptr);
pprintf("page0:%x \n",page0);
pprintf("next_page:%x \n",next_page);
pprintf("page_offset:%x \n",page_offset);
pprintf("num_pages:%x \n",num_pages);
pprintf("page_cross:%x \n",page_cross);
pprintf("bdl:%x \n",bdl);
pprintf("i:%x j:%x \n",i,j);
pprintf("sizeof BDL:%x\n",sizeof(BDL) );
pprintf("sizeof BDL_PTR: %x\n",sizeof(BDL_PTR) );
pprintf("inconsistant ddfq_entries count current:%x limit:%x\n",
pprintf("%s %d\n",qtype,cnt);
printf(" write_csr: %s\tadr = %x, data = %08x\n", name, csr, value);
File: cipca_response.c
pprintf("q->credit:%x cb->owed_credits:%x\n",
File: cipca_io.c
pprintf("id: %x %s %s offset:%x\n",
pprintf("Failed to find csr: %x\n", csr);
pprintf("cipca_write_csr blank pb\n");
pprintf("HARD:outmeml(%x,%x,%x);\n",blk_ptr->pb,adr,val);
pprintf("SOFT:outmeml(%x,%x,%x);\n",blk_ptr->pb,adr,val);
pprintf("MEM:outmeml(%x,%x,%x);\n",blk_ptr->pb,adr,val);
pprintf("CFG write: Not yet implemented\n",p_args0);
pprintf("EMUL - %s no CIPCA parallel\n",csrtbl[i].csrnam);
pprintf("Not yet implemented\n");
pprintf("Failed to find csr: %x\n", csr);
pprintf("cipca_read_csr blank pb\n");
pprintf("HARD: %x = inmeml(%x,%x);\n",retval,blk_ptr->pb,adr);
pprintf("SOFT: %x = inmeml(%x,%x);\n",retval,blk_ptr->pb,adr);
pprintf("MEM: %x = inmeml(%x,%x);\n",retval,blk_ptr->pb,adr);
pprintf("CFG write: Not yet implemented\n");
pprintf("EMUL - %s no CIPCA parallel\n",csrtbl[i].csrnam);
pprintf("Not yet implemented\n");
pprintf("No CIXCD found\n");
printf(" RUBY CIXCD read: \t base=%x offset = %x, data = %08x\n",
pprintf("No CIXCD found\n");
printf(" RUBY CIXCD write: \t base=%x offset = %x, data = %08x\n",
File: dac960_driver.c
pprintf("RAID controller is not emulated\n");
fprintf( el_fp, "issuing ENQUIRY on %s\n", pb->pb.name );
fprintf( el_fp, "ENQUIRY failed with status %04x on %s\n", mbx.status, pb->pb.name );
fprintf( el_fp, "%s firmware version V%d.%d\n",
fprintf( el_fp, "%s drives = %d, optimal = %d, degraded = %d, failed = %d\n",
fprintf( el_fp, "SCSI drive at channel %d, target %d dead on %s\n",
fprintf( el_fp, "issuing NVRAM_CONFIG on %s\n", pb->pb.name );
fprintf( el_fp, "NVRAM_CONFIG failed with status %04x on %s\n", mbx.status, pb->pb.name );
qprintf( "memory parity error on %s\n", pb->pb.name );
qprintf( "memory error on %s\n", pb->pb.name );
qprintf( "BMIC error on %s\n", pb->pb.name );
qprintf( "firmware checksum error on %s\n", pb->pb.name );
qprintf( "configuration checksum error on %s\n", pb->pb.name );
qprintf( "configuration mismatch error on %s\n", pb->pb.name );
qprintf( "SCSI drive at channel %d, target %d not responding on %s\n", rb( CHN ), rb( TGT ), pb->pb.name );
qprintf( "SCSI drive at channel %d, target %d misconnected on %s\n", rb( CHN ), rb( TGT ), pb->pb.name );
qprintf( "hardware error on %s\n", pb->pb.name );
qprintf( "waiting for drives to spin up on %s\n", pb->pb.name );
qprintf( "adapter not responding on %s\n", pb->pb.name );
fprintf( el_fp, msg_dev_found, inode->name, ub->info, sb->name );
printf( "%-18s %-8s %20s %5s\n", ub->inode->name, ub->alias, ub->info, ub->version );
fprintf( el_fp, "device %s status is %s\n", inode->name, status );
fprintf( el_fp, "DCDB (%02x) to channel %d, target %d failed with status %04x (%02x) on %s\n",
fprintf( el_fp, "DCDB (INQUIRY) to channel %d, target %d failed with status %04x on %s\n",
fprintf( el_fp, "DCDB (INQUIRY) to channel %d, target %d succeeded on %s\n",
fprintf( el_fp, "DEVICE_STATE to channel %d, target %d failed with status %04x on %s\n",
fprintf( el_fp, "device at channel %d, target %d not part of a RAID set on %s\n",
err_printf( msg_bad_request, inode->name );
err_printf( "READ/WRITE failed with status %04x on %s\n", mbx.status, pb->pb.name );
printf( "\n\n" );
printf( "%s, %s at Hose %d, Bus %d, Slot %d (%s)\n",
printf( "ENQUIRY failed with status %04x\n", mbx.status );
printf( "Firmware Version V%d.%d\n",
printf( "Number of Drives = %d (Optimal = %d, Degraded = %d, Failed = %d)\n",
printf( "NVRAM_CONFIG failed with status %04x\n", mbx.status );
printf( "Channel %d, Target %d\t\t%24s %4s %s\n",
printf( "%s\n", ub->string );
printf( " Channel %d, Target %d, %d MB (LBNs %d to %d)\n",
printf( "ENQUIRY failed with status %04x\n", mbx.status );
printf( "Firmware Version V%d.%d\n",
printf( "Number of Drives = %d (Optimal = %d, Degraded = %d, Failed = %d)\n",
printf( "NVRAM_CONFIG failed with status %04x\n", mbx.status );
printf( "Channel %d, Target %d\t\t%24s %4s %s\n",
printf( "%s\n", ub->string );
printf( " Channel %d, Target %d, %d MB (LBNs %d to %d)\n",
printf( "DCDB (INQUIRY) to channel %d, target %d failed with status %04x\n",
File: defpa_driver.c
err_printf("DEFPA cannot enable loopback - port is in use.\n");
err_printf("DEFPA Error: setmode - illegal mode.\n");
printf("%-18s %02X-%02X-%02X-%02X-%02X-%02X\n", pb->ip->name, pb->sa[0],
err_printf("DEFPA Error: Failed to get csr base\n");
err_printf("DEFPA: failed to set interrupt vector\n");
err_printf("DEFPA: failed to enable interrupt\n");
err_printf("DEFPA Error: %s can not be started\n", file_name);
err_printf("DEFPA Error: please check FDDI connection\n");
pprintf("\nDEFPA FATAL ERROR: %s - %s\n", pb->ip->name, msg);
pprintf("Callback rcvd\n", p_args0);
err_printf(msg_pdq_msg1, pb->name);
pprintf("defaa_sendpkt\n");
err_printf(msg_pdq_msg4, pb->ip->name, rcv_frame->rcv_descriptor);
pprintf("fw_rcv_data_pkt\n");
err_printf("DEFPA: frame too big for caller buffer\n");
pprintf("DEFPA: Parity error in the host bus interface\n");
pprintf("DEFPA: Parity error in packet memory\n");
pprintf("DEFPA: NXM error in adapter\n");
pprintf("DEFPA: Xmt_Data_Flush\n");
pprintf("DEFPA: State Change\n");
pprintf("DEFPA: CSR_Cmd_Done\n");
err_printf(msg_pdq_msg7, ip->name, rsp->header.status,
pprintf("STATUS CHARS GET\n");
pprintf("header.status: %x\n", rsp->header.status);
pprintf("header.cmd_type: %x\n", rsp->header.cmd_type);
pprintf("station_type: %x\n", rsp->station_type);
pprintf("smt_ver_id: %x\n", rsp->smt_ver_id);
pprintf("smt_ver_id_max: %x\n", rsp->smt_ver_id_max);
pprintf("smt_ver_id_min: %x\n", rsp->smt_ver_id_min);
pprintf("station_state: %x\n", rsp->station_state);
pprintf("link_addr.lwrd_0:%x\n", rsp->link_addr.lwrd_0);
pprintf("link_addr.lwrd_1:%x\n", rsp->link_addr.lwrd_1);
pprintf("t_req: %x\n", rsp->t_req);
pprintf("tvx: %x\n", rsp->tvx);
pprintf("token_timeout: %x\n", rsp->token_timeout);
pprintf("purger_enb: %x\n", rsp->purger_enb);
pprintf("link_state: %x\n", rsp->link_state);
pprintf("tneg: %x\n", rsp->tneg);
pprintf("dup_addr_flag: %x\n", rsp->dup_addr_flag);
pprintf("una.lwrd_0: %x\n", rsp->una.lwrd_0);
pprintf("una.lwrd_1: %x\n", rsp->una.lwrd_1);
pprintf("una_old.lwrd_0: %x\n", rsp->una_old.lwrd_0);
pprintf("una_old.lwrd_1: %x\n", rsp->una_old.lwrd_1);
pprintf("un_dup_addr_flag:%x\n", rsp->un_dup_addr_flag);
pprintf("dna.lwrd_0: %x\n", rsp->dna.lwrd_0);
pprintf("dna.lwrd_1: %x\n", rsp->dna.lwrd_1);
pprintf("dna_old.lwrd_0: %x\n", rsp->dna_old.lwrd_0);
pprintf("dna_old.lwrd_1: %x\n", rsp->dna_old.lwrd_1);
pprintf("purger_state: %x\n", rsp->purger_state);
pprintf("fci_mode: %x\n", rsp->fci_mode);
pprintf("error_reason: %x\n", rsp->error_reason);
pprintf("loopback: %x\n", rsp->loopback);
pprintf("ring_latency: %x\n", rsp->ring_latency);
pprintf("last_dir_beacon_sa.lwrd_0: \t%x\n", rsp->last_dir_beacon_sa.lwrd_0);
pprintf("last_dir_beacon_sa.lwrd_1: \t%x\n", rsp->last_dir_beacon_sa.lwrd_1);
pprintf("last_dir_beacon_una.lwrd_0:\t%x\n", rsp->last_dir_beacon_una.lwrd_0);
pprintf("last_dir_beacon_una.lwrd_1:\t%x\n", rsp->last_dir_beacon_una.lwrd_1);
pprintf("phy_type[%d]:\t%x\n", i, rsp->phy_type[i]);
pprintf("pmd_type[%d]:\t%x\n", i, rsp->pmd_type[i]);
pprintf("lem_threshold[%d]:%x\n", i, rsp->lem_threshold[i]);
pprintf("phy_state[%d]:\t%x\n", i, rsp->phy_state[i]);
pprintf("nbor_phy_type[%d]:%x\n", i, rsp->nbor_phy_type[i]);
pprintf("link_error_est[%d]:%x\n", i, rsp->link_error_est[i]);
pprintf("broken_reason[%d]:%x\n", i, rsp->broken_reason[i]);
pprintf("reject_reason[%d]:%x\n", i, rsp->reject_reason[i]);
pprintf("cntr_interval: %x\n", rsp->cntr_interval);
pprintf("module_rev: %x\n", rsp->module_rev);
pprintf("firmware_rev: %x\n", rsp->firmware_rev);
pprintf("mop_device_type: %x\n", rsp->mop_device_type);
pprintf("phy_led[%d]:\t%x\n", i, rsp->phy_led[i]);
pprintf("flush_time:\t%x\n", rsp->flush_time);
err_printf(msg_pdq_msg8, pb->name, rsp->header.status);
err_printf(msg_pdq_msg9, ip->name);
err_printf(msg_pdq_msg10, ip->name);
err_printf(msg_pdq_msg11, ip->name);
err_printf(msg_pdq_msg12, pb->name, data);
err_printf(msg_pdq_msg13, pb->name);
pprintf("Descriptor Block Address MAP\n");
pprintf(" &pb->emp->db.rcv_data: %x\n", &pb->emp->db.rcv_data);
pprintf(" &pb->emp->db.xmt_data: %x\n", &pb->emp->db.xmt_data);
pprintf(" &pb->emp->db.smt_host: %x\n", &pb->emp->db.smt_host);
pprintf(" &pb->emp->db.unsol: %x\n", &pb->emp->db.unsol);
pprintf(" &pb->emp->db.cmd_rsp: %x\n", &pb->emp->db.cmd_rsp);
pprintf(" &pb->emp->db.cmd_req: %x\n", &pb->emp->db.cmd_req);
pprintf("Consumer Block Address MAP\n");
pprintf(" &pb->emp->cb.xmt_rcv_data: %x\n", &pb->emp->cb.xmt_rcv_data);
pprintf(" &pb->emp->cb.smt_host: %x\n", &pb->emp->cb.smt_host);
pprintf(" &pb->emp->cb.unsol: %x\n", &pb->emp->cb.unsol);
pprintf(" &pb->emp->cb.cmd_rsp: %x\n", &pb->emp->cb.cmd_rsp);
pprintf(" &pb->emp->cb.cmd_req: %x\n", &pb->emp->cb.cmd_req);
pprintf("Transmit Data Buffer Address MAP\n");
pprintf(" &pb->emp->XmtBuf: %x\n", &pb->emp->XmtBuf);
pprintf("Receive Data Buffer Address MAP\n");
pprintf(" &pb->emp->RcvBuf: %x\n", &pb->emp->RcvBuf);
pprintf("Command Response Buffer Address MAP\n");
pprintf(" &pb->emp->CmdRspBuf: %x\n", &pb->emp->CmdRspBuf);
pprintf("Command Request Buffer Address MAP\n");
pprintf(" &pb->emp->CmdReqBuf: %x\n", &pb->emp->CmdReqBuf);
pprintf("Unsolicited Buffer Address MAP\n");
pprintf(" &pb->emp->UnsolBuf: %x\n", &pb->emp->UnsolBuf);
pprintf("DEFPA Base Address MAP\n");
pprintf(" pb->emp+pb->cbp_offset: %x\n", (u_int) pb->emp + pb->cbp_offset);
pprintf(" pb->emp+pb->xmt_offset: %x\n", (u_int) pb->emp + pb->xmt_offset);
pprintf(" pb->emp+pb->rcv_offset: %x\n", (u_int) pb->emp + pb->rcv_offset);
pprintf(" pb->emp+pb->CmdRsp_offset: %x\n", (u_int) pb->emp + pb->CmdRsp_offset);
pprintf(" pb->emp+pb->CmdReq_offset: %x\n", (u_int) pb->emp + pb->CmdReq_offset);
pprintf(" pb->emp+pb->unsol_offset: %x\n", (u_int) pb->emp + pb->unsol_offset);
pprintf("DEFPA CONFIG Address MAP\n");
pprintf(" Device/Vendor Id: %x\n", (u_int) VEND_DEV_ID);
pprintf(" Status/Command: %x\n", (u_int) COM_STAT);
pprintf(" Class/Rev: %x\n", (u_int) REV_ID);
pprintf(" Hdr/Latency: %x\n", (u_int) CACHE_LINE_SIZE);
pprintf(" Base Adr Mem: %x\n", (u_int) BASE_ADDR0);
pprintf(" Base Adr I/O: %x\n", (u_int) BASE_ADDR1);
pprintf(" Base Adr PMem: %x\n", (u_int) BASE_ADDR2);
pprintf(" Int Pin/Line: %x\n", (u_int) INT_LINE);
pprintf("DEFPA Register Address MAP\n");
pprintf(" PDQ_PortReset: %x\n", (u_int) PDQ_PortReset);
pprintf(" PDQ_HostData: %x\n", (u_int) PDQ_HostData);
pprintf(" PDQ_PortControl: %x\n", (u_int) PDQ_PortControl);
pprintf(" PDQ_PortDataA: %x\n", (u_int) PDQ_PortDataA);
pprintf(" PDQ_PortDataB: %x\n", (u_int) PDQ_PortDataB);
pprintf(" PDQ_PortStatus: %x\n", (u_int) PDQ_PortStatus);
pprintf(" PDQ_HostIntType0: %x\n", (u_int) PDQ_HostIntType0);
pprintf(" PDQ_HostIntEnbX: %x\n", (u_int) PDQ_HostIntEnbX);
pprintf(" PDQ_Type2Prod: %x\n", (u_int) PDQ_Type2Prod);
pprintf(" PDQ_rsvd1: %x\n", (u_int) PDQ_rsvd1);
pprintf(" PDQ_CmdRspProd: %x\n", (u_int) PDQ_CmdRspProd);
pprintf(" PDQ_CmdReqProd: %x\n", (u_int) PDQ_CmdReqProd);
pprintf(" PDQ_HostSmtProd: %x\n", (u_int) PDQ_HostSmtProd);
pprintf(" PDQ_UnsolProd: %x\n", (u_int) PDQ_UnsolProd);
pprintf(" PFI_ModeControl: %x\n", (u_int) PFI_ModeControl);
pprintf(" PFI_Status: %x\n", (u_int) PFI_Status);
pprintf("DEFPA csrs\n");
pprintf(msg_pdq_msg22, VEND_DEV_ID, incfgl(pb, VEND_DEV_ID));
pprintf(msg_pdq_msg22, COM_STAT, incfgl(pb, COM_STAT));
pprintf(msg_pdq_msg22, REV_ID, incfgl(pb, REV_ID));
pprintf(msg_pdq_msg22, CACHE_LINE_SIZE, incfgl(pb, CACHE_LINE_SIZE));
pprintf(msg_pdq_msg22, BASE_ADDR0, incfgl(pb, BASE_ADDR0));
pprintf(msg_pdq_msg22, BASE_ADDR1, incfgl(pb, BASE_ADDR1));
pprintf(msg_pdq_msg22, BASE_ADDR2, incfgl(pb, BASE_ADDR2));
pprintf(msg_pdq_msg22, INT_LINE, incfgl(pb, INT_LINE));
pprintf(msg_pdq_msg22, PDQ_PortReset, rpci(pb, PDQ_PortReset));
pprintf(msg_pdq_msg22, PDQ_HostData, rpci(pb, PDQ_HostData));
pprintf(msg_pdq_msg22, PDQ_PortControl, rpci(pb, PDQ_PortControl));
pprintf(msg_pdq_msg22, PDQ_PortDataA, rpci(pb, PDQ_PortDataA));
pprintf(msg_pdq_msg22, PDQ_PortDataB, rpci(pb, PDQ_PortDataB));
pprintf(msg_pdq_msg22, PDQ_PortStatus, rpci(pb, PDQ_PortStatus));
pprintf(msg_pdq_msg22, PDQ_HostIntType0, rpci(pb, PDQ_HostIntType0));
pprintf(msg_pdq_msg22, PDQ_HostIntEnbX, rpci(pb, PDQ_HostIntEnbX));
pprintf(msg_pdq_msg22, PDQ_Type2Prod, rpci(pb, PDQ_Type2Prod));
pprintf(msg_pdq_msg22, PDQ_CmdRspProd, rpci(pb, PDQ_CmdRspProd));
pprintf(msg_pdq_msg22, PDQ_CmdReqProd, rpci(pb, PDQ_CmdReqProd));
pprintf(msg_pdq_msg22, PDQ_HostSmtProd, rpci(pb, PDQ_HostSmtProd));
pprintf(msg_pdq_msg22, PDQ_UnsolProd, rpci(pb, PDQ_UnsolProd));
pprintf(msg_pdq_msg22, PFI_ModeControl, rpci(pb, PFI_ModeControl));
pprintf(msg_pdq_msg22, PFI_Status, rpci(pb, PFI_Status));
pprintf("dump_mem\n");
pprintf("Host Copy of Producer Index CONTENTS\n");
pprintf(" pi->XmtDataCompletionIndex: %x\n", pi->XmtDataCompletionIndex);
pprintf(" pi->RcvDataCompletionIndex: %x\n", pi->RcvDataCompletionIndex);
pprintf(" pi->SMTCompletionIndex: %x\n", pi->SMTCompletionIndex);
pprintf(" pi->UnsolCompletionIndex: %x\n", pi->UnsolCompletionIndex);
pprintf(" pi->CmdRspCompletionIndex: %x\n", pi->CmdRspCompletionIndex);
pprintf(" pi->CmdReqCompletionIndex: %x\n", pi->CmdReqCompletionIndex);
pprintf(" pi->XmtDataProducer: %x\n", pi->XmtDataProducer);
pprintf(" pi->RcvDataProducer: %x\n", pi->RcvDataProducer);
pprintf(" pi->SMTProducer: %x\n", pi->SMTProducer);
pprintf(" pi->UnsolProducer: %x\n", pi->UnsolProducer);
pprintf(" pi->CmdRspProducer: %x\n", pi->CmdRspProducer);
pprintf(" pi->CmdReqProducer: %x\n", pi->CmdReqProducer);
pprintf("Receive, Descriptor Block memory CONTENTS\n");
pprintf(" &pb->emp->db.rcv_data[%d].long_1: %x %08x\n", i, &pb->emp->db.rcv_data[i].long_1, lwbuf);
pprintf(" &pb->emp->db.rcv_data[%d].buff_lo: %x %08x\n", i, &pb->emp->db.rcv_data[i].buff_lo, lwbuf);
pprintf("Transmit Descriptor Block memory CONTENTS\n");
pprintf(" &pb->emp->db.xmt_data[%d].long_1: %x %08x\n", i, &pb->emp->db.xmt_data[i].long_1, lwbuf);
pprintf(" &pb->emp->db.xmt_data[%d].buff_lo: %x %08x\n", i, &pb->emp->db.xmt_data[i].buff_lo, lwbuf);
File: dv_driver.c
err_printf("offset must be a multiple of the sector size\n");
err_printf( msg_bad_request, ip->name );
err_printf("Cannot access data beyond an offset of %d\n",
err_printf("Offset requested was %d\n",*fp->offset);
qprintf("IDE bad sector encountered or read unsuccessful\n");
qprintf("IDE bad sector encountered or write unsuccessful\n");
qprintf("floppy drive unit is not present \n");
qprintf("did not seek to cylinder 0\n");
qprintf("instead seeked to cylinder %d\n",pb->results[drive_num][2]);
qprintf("or retries used up\n");
qprintf("timeout occurred in sending configure cmd\n");
qprintf("timeout occurred in sending seek cmd\n");
qprintf("timeout occurred in sending r/w data cmd\n");
qprintf("IDE command not successfully terminated\n");
qprintf("ST0 = %02x\n",pb->results[unit_num][0]);
qprintf("Invalid IDE command\n");
qprintf("ST0 = %02x\n",pb->results[unit_num][0]);
qprintf("SR0 = C0\n");
qprintf("Error, ST0 =%02x\n",pb->results[unit_num][0]);
qprintf("Missing address mark\n");
err_printf("Disk is write protected\n");
qprintf("Could not find sector\n");
qprintf("Soft error: data overrun or underrun\n");
qprintf("Tried to read beyond final sector of track\n");
qprintf("CRC error\n");
qprintf("Bad track\n");
qprintf("timeout in sending IDE command %02x\n", buffer[0]);
qprintf("timeout in reading IDE status\n");
qprintf("Invalid opcode \n");
err_printf("setmode error - illegal mode.\n");
printf( "%s\n", pb->ub[unit_num]->string);
qprintf("interrupt due to reset never occurred \n");
File: kzpsa_driver.c
err_printf("*** KZPSA BIST failed, %s error. ***\n", err_string);
err_printf("KZPSA: adapter init failed\n");
err_printf("KZPSA: can't initialize SCSI channel\n");
err_printf("can't initialize KZPSA SCSI adapter\n");
err_printf("KZPSA: failed to send to %s\n", sb->name);
err_printf("KZPSA error on %s, cmd = %x, sts = %x, camh->status = %x\n",
err_printf("KZPSA: setmode - start, failed, status = %m\n",
err_printf("KZPSA: setmode error - illegal mode\n");
qprintf("%s\n", pb->pb.pb.string);
printf("%s\n", p_args1(pb->pb.pb.string));
qprintf("KZPSA h/s/b/f/c/config_device/vec %d/%d/%d/%d/%d/%x/%x\n",
err_printf("KZPSA: Failed to get csr base\n");
err_printf("KZPSA: can't initialize SCSI adapter\n");
err_printf("KZPSA: failed to set interrupt\n");
err_printf("KZPSA: failed to enable interrupt\n");
err_printf(msg_ev_badvalue, name);
err_printf("kzpsa on-board flash not written\n");
File: kzpsa_flash.c
err_printf(status);
printf("%s", kzpsa_help);
err_printf(msg_qual_conflict);
err_printf("offset must be between 00 and %02x\n",
err_printf("value too large\n");
err_printf("bit must be between 0 and 7\n");
err_printf("KZPSA: %s FLASH is invalid, using defaults\n", device_name);
printf("%s present FLASH\n", device_name);
printf("%s Bus Id = %d, Fast = %x, TermPwr = %x\n",
err_printf("*** KZPSA: %s on-board flash not written ***\n",
printf("%s updated FLASH\n", device_name);
printf("%08x ", i * 2);
printf(" %02x %02x", *pc++, *pc++);
err_printf("*** KZPSA: FLASH is not intact ***\n");
err_printf("*** KZPSA: on-board flash not written ***\n");
err_printf("KZPSA: flash unlock confirmation timeout...\n");
err_printf("continuing update anyway.\n");
err_printf("KZPSA: flash lock confirmation timeout\n");
File: isp1020_driver.c
err_printf( msg_ev_badvalue, name );
fprintf( el_fp, "breaking virtual connection with sb %08x\n", sb );
fprintf( el_fp, "clearing interrupt vector %08x\n", pb->pb.vector);
fprintf( el_fp, "free all semaphores\n");
fprintf( el_fp, "free all dynamic memory\n");
printf("Invalid unit number\n");
fprintf( el_fp, "resetting the SCSI bus on %s\n", pb->pb.name );
pprintf("ISP1020 COMMAND BLOCK %x %x\n", command-pb->command, command);
pprintf(" entry type %x\n", command->entry_type);
pprintf(" entry count %x\n", command->entry_count);
pprintf(" entry unused %x\n", command->entry_unused);
pprintf(" entry flags %x\n", command->entry_flags);
pprintf(" handle %x\n", command->handle);
pprintf(" lun %x\n", command->lun);
pprintf(" target %x\n", command->target);
pprintf(" cdb length %x\n", command->cdb_length);
pprintf(" control flags %x\n", command->control_flags);
pprintf(" reserved %x\n", command->reserved);
pprintf(" timeout %x\n", command->timeout);
pprintf(" data count %x\n", command->data_count);
pprintf(" data address %x\n", command->data_address);
pprintf(" data length %x\n", command->data_length);
pprintf(" cdb[%d] %x\n", i, command->cdb[i]);
pprintf("\nDATA IN\n");
pprintf(" %x\n", dat_in[i]);
pprintf("\nDATA OUT\n");
pprintf(" %x\n", dat_out[i]);
pprintf("ISP1020 STATUS BLOCK %x %x\n", status-pb->status, status);
pprintf(" entry type %x\n", status->entry_type);
pprintf(" entry count %x\n", status->entry_count);
pprintf(" entry unused %x\n", status->entry_unused);
pprintf(" entry flags %x\n", status->entry_flags);
pprintf(" handle %x\n", status->handle);
pprintf(" scsi status %x\n", status->scsi_status);
pprintf(" completion status %x\n", status->completion_status);
pprintf(" state flags %x\n", status->state_flags);
pprintf(" status flags %x\n", status->status_flags);
pprintf(" time %x\n", status->time);
pprintf(" request sense length %x\n", status->request_sense_length);
pprintf(" residual length %x\n", status->residual_length);
pprintf(" request sense[%d] %x\n", i, status->request_sense[i]);
fprintf( el_fp, "I/O failed on %s\n", sb->name );
fprintf( el_fp, "mailbox I/O failed on %s, status = %04x\n",
pprintf("CSR READ: pb %x pb->pb.csr %x offset %x value %x\n", pb,pb->pb.csr,offset,value);
pprintf("CSR WRITE: pb %x pb->pb.csr %x offset %x value %x\n", pb,pb->pb.csr,offset,value);
err_printf( "NVRAM programming failed on %s\n", pb->pb.name );
File: pue_driver.c
printf("malloc: %s %x,%d\n", sym, addr, size);
err_printf("KFPSA FATAL ERROR: malloc %s %d\n", sym, size);
printf("free: %s %x\n", sym, adr);
err_printf("KFPSA setmode - start, failed, status = %m\n",
err_printf("KFPSA setmode error - illegal mode.\n");
printf("%-18s %-7s %s\n", pb->n810pb.pb.port_name, alias, info);
File: scs.c
fprintf( el_fp, "SCS Connect Response received in wrong state\n" );
fprintf( el_fp, "SCS Accept Request received in wrong state\n" );
fprintf( el_fp, "SCS Accept Response received in wrong state\n" );
fprintf( el_fp, "SCS Disconnect Request received in wrong state\n" );
fprintf( el_fp, "SCS Disconnect Response received in wrong state\n" );
fprintf( el_fp, "SCS Application Message received in wrong state\n" );
fprintf( el_fp, "unrecognized SCS message (%04x) received\n", p->mtype );
File: n810_driver.c
err_printf( msg_ev_badvalue, name );
pprintf("NCR810 PCI to SCSI adapter is not emulated\n");
File: n810_driver.c
err_printf( msg_ev_badvalue, name );
pprintf("NCR810 PCI to SCSI adapter is not emulated\n");
File: pke_driver.c
fprintf( el_fp, "port %s initialized, scripts are at %x\n",
fprintf( el_fp, "resetting the SCSI bus on %s\n", pb->pb.name );
fprintf( el_fp, "attempting to send to %s\n", sb->name );
fprintf( el_fp, "failed to send to %s\n", sb->name );
fprintf( el_fp, "attempting SDTR with %s\n", sb->name );
fprintf( el_fp, "command timeout on %s, dstat = %02x, sist0 = %02x, sist1 = %02x\n",
fprintf( el_fp, "device at %s is not SCSI\n", sb->name );
fprintf( el_fp, "selection timeout on %s, dstat = %02x, sist0 = %02x, sist1 = %02x\n",
fprintf( el_fp, "SDTR with %s completed\n", sb->name );
fprintf( el_fp, "modify data pointer received on %s\n", sb->name );
fprintf( el_fp, "SDTR with %s rejected\n",
fprintf( el_fp, "message %02x/%02x/%02x... received from %s\n",
fprintf( el_fp, "message %02x/%02x received from %s\n",
fprintf( el_fp, "message %02x received from %s\n",
fprintf( el_fp, "while connected to %s, dsps = %d\n",
fprintf( el_fp, "failed to flush %s, dsps = %d\n",
fprintf( el_fp, "bad phase mismatch on %s, dcmd/dbc = %08x\n",
fprintf( el_fp, "selection timeout on %s, dstat = %02x, sist0 = %02x, sist1 = %02x\n",
fprintf( el_fp, "bad interrupt received on %s, dstat = %02x, sist0 = %02x, sist1 = %02x\n",
fprintf( el_fp, "ssi on %s, dsp = %x %08x/%08x %08x/%08x\n",
File: ether.c
err_printf(msg_mop_inf_ld_com);
err_printf(msg_mop_inf_hst_name, mp->dl.host_sys_name);
err_printf(msg_mop_inf_hst_addr, mp->dl.host_sys_addr[0],
err_printf(msg_net_003);
pprintf("\nTRANSMIT ETHERNET FRAME FORMAT: buf %x size %d\n", enet_frame, frame_size);
pprintf("dest_addr: %02X-%02X-%02X-%02X-%02X-%02X\n",
pprintf("source_addr: %02X-%02X-%02X-%02X-%02X-%02X\n",
pprintf("protocol_type_0: %x\n", enet_frame->protocol_type_0);
pprintf("protocol_type_1: %x\n", enet_frame->protocol_type_1);
pprintf("data[%d] = %08x\n", i, lw_data[i]);
pprintf("\nTRANSMIT IEEE FRAME FORMAT: buf %x size %d\n", ieee_frame, frame_size);
pprintf("dest_addr: %02X-%02X-%02X-%02X-%02X-%02X\n",
pprintf("source_addr: %02X-%02X-%02X-%02X-%02X-%02X\n",
pprintf("len[0]: %x\n", ieee_frame->len[0]);
pprintf("len[1]: %x\n", ieee_frame->len[1]);
pprintf("dsap: %x\n", ieee_frame->dsap);
pprintf("ssap: %x\n", ieee_frame->ssap);
pprintf("cntr: %x\n", ieee_frame->cntr);
pprintf("pid: %02X-%02X-%02X-%02X-%02X\n", ieee_frame->pid_0,
pprintf("data[%d] = %08x\n", i, lw_data[i]);
pprintf("\nTRANSMIT: FDDI FRAME pid %x %s %s\n", pcb->pcb$l_pid, pcb->pcb$b_name, ip->name);
pprintf("xmtbuf = %x, size = %x(%d)\n", fddi_xmt_frame, frame_size + 2, frame_size + 2);
pprintf("prh_0: %02x\n", fddi_xmt_frame->prh_0); /* Unrestricted token use */
pprintf("prh_1: %02x\n", fddi_xmt_frame->prh_1); /* Unrestricted token release */
pprintf("prh_2: %02x\n", fddi_xmt_frame->prh_2); /* mbz */
pprintf("fc: %02x\n", fddi_xmt_frame->fc); /* FC = 0x54 LLC */
pprintf("dest_addr: %02X-%02X-%02X-%02X-%02X-%02X\n",
pprintf("source_addr: %02X-%02X-%02X-%02X-%02X-%02X\n",
pprintf("dsap: %02x\n", fddi_xmt_frame->dsap);
pprintf("ssap: %02x\n", fddi_xmt_frame->ssap);
pprintf("cntr: %02x\n", fddi_xmt_frame->cntr);
pprintf("pid: %02X-%02X-%02X-%02X-%02X\n", fddi_xmt_frame->pid_0,
pprintf("data[%d] = %08x\n", i, lw_data[i]);
pprintf("rcv_reformat: ip %x msgbuf %x size %x(%d) pktadr %x pktlen %x\n",
pprintf("FDDI rcv frame size: %d data_size: %d\n", rcv_frame_size,
pprintf("\nRECEIVE: FDDI FRAME pid %x %s %s\n", pcb->pcb$l_pid, pcb->pcb$b_name, ip->name);
pprintf("prh_0: %02x\n", fddi_rcv_frame->prh_0); /* Unrestricted token use */
pprintf("prh_1: %02x\n", fddi_rcv_frame->prh_1); /* Unrestricted token release and */
pprintf("prh_2: %02x\n", fddi_rcv_frame->prh_2); /* mbz */
pprintf("fc: %02x\n", fddi_rcv_frame->fc); /* FC = 0x54 LLC */
pprintf("dest_addr: %02X-%02X-%02X-%02X-%02X-%02X\n",
pprintf("source_addr: %02X-%02X-%02X-%02X-%02X-%02X\n",
pprintf("dsap: %x\n", fddi_rcv_frame->dsap);
pprintf("ssap: %x\n", fddi_rcv_frame->ssap);
pprintf("cntr: %x\n", fddi_rcv_frame->cntr);
pprintf("pid: %02X-%02X-%02X-%02X-%02X\n", fddi_rcv_frame->pid_0,
pprintf("data[%d] = %x\n", i, lw_data[i]);
pprintf("\nRECEIVE ETHERNET FRAME FORMAT: buf %x size %d\n", *pktadr, *pktlen);
pprintf("dest_addr: %02X-%02X-%02X-%02X-%02X-%02X\n",
pprintf("source_addr: %02X-%02X-%02X-%02X-%02X-%02X\n",
pprintf("protocol_type_0: %x\n", enet_frame->protocol_type_0);
pprintf("protocol_type_1: %x\n", enet_frame->protocol_type_1);
pprintf("data[%d] = %08x\n", i, lw_data[i]);
pprintf("\nRECEIVE IEEE FRAME FORMAT: buf %x size %d\n", *pktadr, *pktlen);
pprintf("dest_addr: %02X-%02X-%02X-%02X-%02X-%02X\n",
pprintf("source_addr: %02X-%02X-%02X-%02X-%02X-%02X\n",
pprintf("len[0]: %x\n", ieee_frame->len[0]);
pprintf("len[1]: %x\n", ieee_frame->len[1]);
pprintf("dsap: %x\n", ieee_frame->dsap);
pprintf("ssap: %x\n", ieee_frame->ssap);
pprintf("cntr: %x\n", ieee_frame->cntr);
pprintf("pid: %02X-%02X-%02X-%02X-%02X\n", ieee_frame->pid_0,
pprintf("data[%d] = %08x\n", i, lw_data[i]);
File: inet_driver.c
pprintf( "malloc %08x %d\n", t, size );
pprintf( "free %08x\n", t );
err_printf( "\'%s\' is not a legal parameter for bootp.\n", info );
printf("\nBroadcasting BOOTP Request...\n");
printf("\nBroadcasting BOOTP Request for file: %s\n",pkt->file);
err_printf( "Retrying bootp; next attempt in %d seconds.\n", i );
pprintf( "sending packet at time %d; next retry at %d; delay is %d\n",
pprintf( "bootp_read()...\n" );
pprintf( "bootp_write()...\n" );
err_printf( "Cannot both read and write tftp.\n" );
printf("Received BOOTP Packet File Name is: %s\n",pie->bootp.file);
err_printf("Bad file name.\n");
printf( "local inet address: %s\n", buf );
printf( "remote inet address: %s\n", buf );
printf( "TFTP Read File Name: %s\n", filename );
if( p != req_pkt + pkt_leng ) pprintf( "bad packet size!!! \n" );
printf("?? %.4s_def_subnetmask not defined.\n", net->ip->name );
printf("Invalid subnet mask in BOOTP information\n");
printf("netmask = %s\n",netmask_str);
printf("Server is on same subnet as client.\n");
printf("Server not found. Boot failed\n");
printf("Server is NOT on same subnet as client...\n");
printf(" Router used = %s\n",gateway_str);
err_printf( "Tftp error %d: %s.\n", req->error - 1, req->offset );
err_printf( "Tftp writes not supported.\n" );
pprintf( "tftp_read() size %d number %d\n", size, number);
pprintf( "total %d rd_size %d last %d size %d\n",
pprintf( "freepkt %08x\n", req->pkt );
err_printf( "Tftp error %d: %s.\n",
err_printf( "Writes to tftp not supported.\n" );
err_printf( "Udp_send failed.\n" );
pprintf( "sum of udp pseudo-header is %04x\n", sum );
pprintf( "hostid: %08x dst: %08x src: %08x broadcast: %08x\n",
pprintf( "ip protocol is %02x\n", ip.ip_p );
pprintf( "ip_receive() discarded packet for error %d\n", err );
pprintf( "freepkt %08x\n", msg );
pprintf( "udp_receive() discarded packet for error %d\n", err );
pprintf( "freepkt %08x\n", msg );
pprintf( "searching bootp request list for xid %08x net %s\n", bootp_xid, fp->ip->name );
pprintf( "bootp request: xid %08x net %s\n", p->xid, p->pie->ip->name);
pprintf( "freepkt %08x\n", pkt );
pprintf( "bootp_receive() discarded packet for error %d\n", err );
pprintf( "freepkt %08x\n", pkt );
pprintf("tftp opcode is %04x\n", ntohs( tftp.op ) );
pprintf("received block is %d; expected block %d\n",
pprintf( "tftp_receive() discarded packet for error %d\n", err );
pprintf( "freepkt %08x\n", msg );
err_printf( "Arp_resolve: sorry, we are hardwired for ethernet.\n" );
pprintf( "freepkt %08x\n", msg );
pprintf( "freepkt %08x\n", msg );
pprintf("couldn't open net %s\n", next);
pprintf("%s is not a network.\n", next);
pprintf( "inetaddr_validate: %s\n", *dda );
err_printf( "'%s' is not supported;", buf );
err_printf( " supported protocols are '%s' and '%s'.\n",
pprintf( "string2inetaddr: %s", s );
pprintf( "byte %d overflowed\n", i );
pprintf( "expected a dot after byte %d\n", i );
pprintf( "excess chars at end\n" );
pprintf( "inet_cksum: buf:%08x bufsize: %d\n", buf, bufsize );
if ((i%LINESIZE)==0) pprintf("%-4d ",i);
pprintf("%02x",(((char*)p)[i])&0xff);
pprintf("%c", ((i+1)%LINESIZE) ? ' ' : '\n');
File: mop_driver.c
printf(msg_ez_inf_mop_blk);
printf(msg_ez_inf_net_lst,mb->ndb_count);
File: mopdl_driver.c
err_printf(msg_mop_wrn_out_o_seq_plxf);
err_printf(msg_mop_det_sv_msg, mp->dl.seq, px->MOP$B_PLX_LOAD_NUM);
err_printf(msg_mop_wrn_out_o_seq_mlxf);
err_printf(msg_mop_det_sv_msg, mp->dl.seq, mx->MOP$B_MLX_LOAD_NUM);
err_printf(msg_mop_wrn_out_o_seq_ml);
err_printf(msg_mop_det_sv_msg, mp->dl.seq, ml->MOP$B_MLD_LOAD_NUM);
err_printf(msg_mop_inf_ld_com);
err_printf(msg_mop_inf_hst_name, mp->dl.host_sys_name);
err_printf(msg_mop_inf_hst_addr, mp->dl.host_sys_addr[0],
err_printf(msg_net_003);
File: moplp_driver.c
err_printf(msg_mop_err_lp_to1,i,mp->lp.mo[i].count,
printf(msg_mop_inf_reply,source[0],source[1],source[2],
File: moprc_driver.c
err_printf(msg_moprc_inf_rc_rel,mi->source[0],mi->source[1],
err_printf(msg_moprc_inf_rc_res,mi->source[0],mi->source[1],
err_printf("index_out: %d c_sent: %d\n",mp->rc.tx_index_out,mp->rc.tx_sent);
err_printf("flags: %02x size: %d\n",cra->MOP$B_CRA_FLAGS,mi->size);
err_printf(" index_in: %d\n",mp->rc.rx_index_in);
err_printf("index_in: %d c: %c\n",mp->rc.tx_index_in,c);
err_printf("index_in: %d index_out: %d c: %c\n",mp->rc.rx_index_in,
err_printf(msg_moprc_001,pwd[2],pwd[1],pwd[0]);
File: ni_datalink.c
pprintf("Message Recieved\n");
printf("allocate msg: %08x inp: %08x\n", msg, inp);
printf("Freeing address: %08x\n", msg);
printf("msg: %08x inp: %08x\n", *msg, *inp);
printf("An unsupported message was received.\n");
pprintf(" %08x", *ptr_out--);
pprintf(" :%08x\n", ++ptr_out);
printf("%s %02x-%02x-%02x-%02x-%02x-%02x\n", name, enet[0], enet[1],
printf(msg_ez_inf_mop_cnt);
printf(msg_ez_inf_t_s_0, tz / MOP$K_1S_BY_1MS);
printf(msg_ez_inf_tx);
printf(msg_ez_inf_b_f, mc->MOP_V4CNT_TX_BYTES.l,
printf(msg_ez_inf_df_oc_mc, mc->MOP_V4CNT_TX_INIT_DEFERRED.l,
printf(msg_ez_inf_tx_f);
printf(msg_ez_inf_ec_cc_sc, mc->MOP_V4CNT_TX_FAIL_EXCESS_COLLS.l, mc->
printf(msg_ez_inf_oc_lf_rd, mc->MOP_V4CNT_TX_FAIL_OPEN_CIRCUIT.l, mc->
printf(msg_ez_inf_cd, mc->MOP_V4CNT_FAIL_COLLIS_DETECT.l);
printf(msg_ez_inf_rx);
printf(msg_ez_inf_b_f, mc->MOP_V4CNT_RX_BYTES.l,
printf(msg_ez_inf_mb_mf, mc->MOP_V4CNT_RX_MCAST_BYTES.l,
printf(msg_ez_inf_rx_f);
printf(msg_ez_inf_bc_fe, mc->MOP_V4CNT_RX_FAIL_BLOCK_CHECK.l,
printf(msg_ez_inf_ud_do_ns, mc->MOP_V4CNT_UNKNOWN_DESTINATION.l,
printf(msg_ez_inf_nub, mc->MOP_V4CNT_NO_USER_BUFFER.l);
err_printf(msg_ez_inf_add_sz, pkt, size);
err_printf("%02x %s", lptr[i], (i % 20 == 19 ? "\n" : ""));
pprintf(msg_ez_inf_add_sz, pkt, size);
pprintf("%02x %s", lptr[i], (i % 20 == 19 ? "\n" : ""));
err_printf(msg_ndl_err_002, s1);
err_printf(msg_ndl_err_003);
err_printf(s2, p0, p1, p2, p3, p4, p5);
File: ew_driver.c
err_printf("No vector found port %s is running polled!\n",
pprintf("Station Address: %02x-%02x-%02x-%02x-%02x-%02x\n", tupb->sa[0],
printf("TULIP CSRS:\n");
printf(" Register Base: %08x\n\n", tupb->pb.csr);
printf(" EISA ID: %08x\n\n",
printf(" EBC: %02x REG0: %02x REG1: %02x REG2: %02x REG3: %02x\n\n",
printf(" CFID: %08x CFCS: %08x CFRV: %08x\n",
printf(" CFLT: %08x CBIO: %08x\n\n", RD_TULIP_CSR_LONG(tupb,
printf(" CSR0: %08x CSR1: %08x CSR2: %08x\n",
printf(" CSR3: %08x CSR4: %08x CSR5: %08x\n",
printf(" CSR6: %08x CSR7: %08x CSR8: %08x\n",
printf(" CSR9: %08x CSR10:%08x CSR11:%08x\n",
printf(" CSR12:%08x CSR13:%08x CSR14:%08x\n",
printf(" CSR15:%08x\n", RD_TULIP_CSR_LONG(tupb, TU_CSR15_ADDR));
pprintf("TU PCI Bus Error :CSR5: %08x\n", csr5);
pprintf("TU Abnormal Interrupt, CSR5: %08x\n", csr5);
printf("Status counts:\n");
printf("ti: %d tps: %d tu: %d tjt: %d unf: %d ri: %d ru: %d\n", tupb->ti,
printf("rps: %d rwt: %d at: %d fd: %d lnf: %d se: %d tbf: %d\n", tupb->rps,
printf("tto: %d lkf: %d ato: %d nc: %d oc: %d\n", tupb->tto, tupb->lkf,
err_printf("Change mode to auto negotiate \n");
err_printf("Auto Negotiation not supported. ");
err_printf("Change mode to ");
err_printf("Full Duplex, ");
err_printf("Twisted Pair.\n");
err_printf("Change mode to ");
err_printf("BNC.\n");
err_printf("AUI.\n");
err_printf("Change mode to "); /* 6 */
err_printf("FAST.\n");
err_printf("Change mode to ");
err_printf("FAST Full Duplex.\n");
err_printf("Change mode to ");
err_printf("Auto-Sensing.\n");
err_printf("Switching network %s to Twisted pair.\n", tupb->pb.name);
err_printf("Switching network %s to Twisted Pair Full Duplex.\n",
err_printf("Switching network %s to AUI Thick.\n", tupb->pb.name);
err_printf("Switching network %s to AUI BNC.\n", tupb->pb.name);
err_printf("Switching network %s to Twisted pair.\n", tupb->pb.name);
fprintf(el_fp,"\n%s BNC port\n",&tu_card_name[1]);
fprintf(el_fp,"\n%s BNC port\n",&tu_card_name[1]);
printf("%-18s %02X-%02X-%02X-%02X-%02X-%02X", pb->ip->name, pb->sa[0],
printf("\t%s\n", tu_modes[pb->mode]);
err_printf("TULIP cannot enable loopback - port is in use.\n");
pprintf("Tulip is not emulated\n");
err_printf("TULIP Error: setmode - illegal mode.\n");
printf("ew%c0: link %s %s: %s duplex\n",
printf("%-18s %02X-%02X-%02X-%02X-%02X-%02X", pb->ip->name, pb->sa[0],
printf("\t%s\n", tu_modes[pb->mode]);
err_printf("TULIP cannot enable loopback - port is in use.\n");
err_printf("TULIP Error: setmode - illegal mode.\n");
File: diag_support.c
err_printf(msg_insuff_mem, sizeof(diag_common));
err_printf (status);
err_printf (msg_quals);
err_printf(msg_insuff_mem, DYN$K_GRAN);
err_printf(msg_d_inv_test);
err_printf(msg_d_inv_test);
err_printf(msg_insuff_mem, MAX_NAME);
err_printf(msg_d_inv_grp);
err_printf(msg_d_bad_group, quals[QG].value.string);
err_printf(msg_d_inv_test_grp, quals[QG].value.string);
err_printf(msg_insuff_mem,
printf(msg_d_end_of_pass,
printf(msg_d_startup,
printf(msg_d_status,
printf(msg_d_test_trace,
err_printf(msg_nodis);
printf(msg_d_completion,
err_printf("%c", 7);
err_printf("\n\n%m %m error%m%m\n***\t%m: %m\n***\tSW Failure Point: %d\n***\tError Vector: %08x\n\n%m %s\n%-12.12s %08.8x %14.14s %4.4d %4.4d %4.4d %4.4d %8.8s\n",
pprintf ("*** Warning: Using old error message format!!!\n");
err_printf(msg_d_error,
err_printf(msg_d_error,
err_printf(msg_d_err_end);
err_printf("%m %s\n", msg_d_header, ddate);
err_printf("Expected value:\t %16x\n", expect);
err_printf("Received value:\t %16x\n", rcvd);
err_printf("Failing addr:\t %16x\n", address);
File: exer.c
printf( "back from wait tqe, value:%d, mask:%d, kids_mask:%d, time:%d\n",
printf( "killpending or time==0; time:%d\n", time);
printf( "out of interval loop; kill_sent:%d, time:%d\n", kill_sent, time);
printf( " ... and killpending is set\n");
printf( msg_exer_hd2);
printf( msg_exer_hd3);
printf(msg_exer_counts, exer_args.pkt_sz, *(UINT *) &iob.io_count,
printf( "pkt_sz %d bytes_to_proc %d\n", *pkt_sz, *bytes_to_process);
err_printf( status);
err_printf( msg_insuff_mem, pkt_sz);
printf(msg_dsk_ex_begin_dest, pcb->pcb$b_dev_name, pcb->pcb$l_pid);
printf(msg_dsk_ex_begin, pcb->pcb$b_dev_name, pcb->pcb$l_pid);
err_printf( "%c",c);
err_printf( msg_ex_devreaderr, bytes_rd,
err_printf( msg_dep_devwriteerr,
err_printf( msg_sz_mismatch,
err_printf( msg_data_comp_err,
err_printf( msg_expect_buf );
err_printf( msg_receive_buf );
err_printf( msg_bad_action);
printf( msg_exer_finis, fp->ip->name);
printf(msg_dsk_ex_done, pcb->pcb$b_dev_name, pcb->pcb$l_pid);
File: memtest.c
err_printf(msg_insuff_mem,sizeof(externals));
err_printf(msg_noev, "d_verbose");
err_printf(msg_insuff_mem,sizeof(struct IOB));
err_printf(msg_start_gt_end);
printf("zone : %x\n",zp);
err_printf(msg_mem_adr_align);
err_printf(msg_mem_len_align);
err_printf(msg_mem_len_gt_bs);
printf("eptr->start_addr : %x\n",eptr->start_addr);
printf("victim_addr : %x\n",victim_addr);
err_printf(msg_d_no_malloc, eptr->block_size, gptr->diag$l_failadr);
err_printf(msg_d_no_malloc, eptr->block_size, gptr->diag$l_failadr+get_bcache_size());
err_printf(msg_d_no_malloc, eptr->block_size,
printf("rand_block\n");
printf("eptr->len : %x\n",eptr->len);
printf("eptr->block_size : %x\n",eptr->block_size);
printf("eptr->start_addr : %x\n",eptr->start_addr);
printf("num_of_blks: %x\n",num_of_blks);
printf("lp_cnt: %x\n",lp_cnt);
printf("passcount: %x\n",passcount);
printf("last addr : %x\n",begin_addr+eptr->len-eptr->block_size);
printf("rand_index : %d\n",rand_index);
printf("eptr->start_addr : %x\n",eptr->start_addr);
printf("j : %x\n",j);
printf("i : %x\n",i);
printf("last addr : %x\n",begin_addr+eptr->len-eptr->block_size);
printf("seed : %x\n",seed);
printf("out of range = %x\n",eptr->start_addr);
err_printf(msg_noev, "d_verbose");
printf(msg_mem_ex_done, eptr->cpu_name, pcb->pcb$l_pid);
err_printf("Expected value:\t %16x\n", expect);
err_printf("Received value:\t %16x\n", rcvd);
err_printf("Failing addr: \t %16x\n", address);
err_printf("Failing SIMM module J%d\n",(28-(i/8)*8)+(i%8));
printf("data expected: %x\n",data);
printf("read data: %x\n",read_data);
printf("addr: %x\n",addr);
File: memtest_gray_qw.c
printf("eptr->block_size : %x\n",eptr->block_size);
printf("eptr->len : %x\n",eptr->len);
printf("eptr->incr : %x\n",eptr->incr);
printf("eptr->start_addr : %x\n",eptr->start_addr);
printf("Number of clock ticks: %d\n",stop_time);
printf("loop_len : %x\n",loop_len);
printf("addr : %16x\n",no_sign_ext_addr);
printf("Number of clock ticks: %d\n",stop_time);
printf("bytes_read : %x\n",*iob_ptr->bytes_read);
printf("bytes_written : %x\n",*iob_ptr->bytes_written);
File: memtest_march.c
printf("Number of clock ticks: %d\n",stop_time);
File: memtest_random.c
printf("eptr->block_size : %x\n",eptr->block_size);
printf("eptr->start_addr : %x\n",eptr->start_addr);
printf("Number of clock ticks: %d\n",stop_time);
File: memtest_victim.c
printf("Number of clock ticks: %d\n",stop_time);
File: net.c
err_printf(msg_insuff_params);
err_printf(status);
err_printf(msg_missing_device);
pprintf ("%s\n", dname);
err_printf(msg_rb_inc_pwd);
pprintf("Message Transmitted\n");
printf(msg_net_001, file_specifier);
printf(msg_net_002, load_address);
err_printf(msg_net_003);
printf(msg_net_004);
printf(msg_net_005, mp->dl.offset + load_address);
printf(msg_net_006, mp->dl.image_size);
printf(msg_net_007, mp->dl.tgt_sys_name);
printf(msg_net_008, mp->dl.tgt_sys_addr[0], mp->dl.tgt_sys_addr[1],
printf(msg_net_009, mp->dl.host_sys_name);
printf(msg_net_010, mp->dl.host_sys_addr[0],
File: nettest.c
err_printf(msg_missing_device);
err_printf(msg_moplp_err_run, eptr->pf[i]->ip->name);
pprintf("start of net_loop_test\n");
File: iod_diag.c
pprintf("This diagnostic is only run in diag mode\n");
err_printf(msg_missing_device);
err_printf(msg_no_device, pcb->pcb$b_dev_name);
printf("Not yet implemented\n");
printf("Not yet implemented\n");
qprintf("iod_diag on %s terminated\n",pcb->pcb$b_dev_name);
pprintf("%s power-up tests\n",stat_string);
qprintf("%s power-up tests\n",stat_string);
err_printf("Expected value:\t %016x\n", expect);
err_printf("Received value:\t %016x\n", rcvd);
err_printf("Failing addr:\t %016x\n", address);
err_printf(msg_mop_err_b_index);
err_printf(msg_mop_err_b_index);
err_printf(msg_mop_err_b_index);
err_printf(msg_mop_err_b_index);
err_printf(msg_mop_err_b_index);
File: raw_8242_diag.c
pprintf("This diagnostic is only run in diag mode\n");
err_printf (msg_nokbtests);
pprintf ("SendMk42Cmd: %2x\n", cmd);
pprintf ("Mk42 1st Status Reg: %2x\n", s);
pprintf ("SendCmd Failure Port64: %2x\n",
pprintf ("SendMk42CmdData: %2x Cmd Data: %2x\n",
pprintf ("1st Wait for !IBF, Port64: %2x\n", s);
pprintf ("2nd Wait for !IBF, Port64: %2x\n", s);
pprintf ("SendCmdData Failure Port64: %2x\n",
pprintf ("SendKbCmd: %2x\n",
pprintf ("Mk42 1st Status Reg: %2x\n", s);
pprintf ("SendKbCmd Failure Port64: %2x\n",
pprintf ("SendKbCmdData: %2x Cmd Data: %2x\n",
pprintf ("Mk42 1st Status Reg: %2x\n", s);
pprintf ("Mk42 2nd Status Reg: %2x\n", s);
pprintf ("SendKbCmdData Failure Port64: %2x\n",
pprintf ("SendAuxCmd: %2x\n",
pprintf ("Mk42 1st Status Reg: %2x\n", s);
pprintf ("SendAuxCmd Failure Port64: %2x\n",
pprintf ("SendAuxCmdData: %2x CmdData: %2x\n",
pprintf ("Mk42 1st Status Reg: %2x\n", s);
pprintf ("Mk42 2nd Status Reg: %2x\n", s);
pprintf ("SendAuxCmdData Failure Port64: %2x\n",
pprintf ("Input Port60: %2x\n\n", eptr->b_rcvd);
err_printf(msg_d_load_only, "i8242_diag", 1);
pprintf ("%s %x\n", i8242_ram_strings[ram_index], eptr->b_rcvd);
err_printf(msg_d_load_only, "i8242_diag", 2);
err_printf(msg_d_load_only, "i8242_diag", 5);
err_printf(msg_d_load_only, "i8242_diag", 8);
pprintf ("\nMk42 Interactive Keyboard Test, Type %d Characters\n", LoopCnt);
pprintf ("KeyBoard Data Read: %x\n", eptr->b_rcvd);
err_printf(msg_d_load_only, "i8242_diag", 9);
pprintf ("\nMk42 Interactive Auxiliary Test, Input %d Characters\n", LoopCnt);
pprintf ("Auxiliary Device Data Read: %x\n", eptr->b_rcvd);
err_printf(msg_d_load_only, "i8242_diag", 10);
File: raw_ds1287_diag.c
pprintf("This diagnostic is only run in diag mode\n");
pprintf ("RTC Config Reg Adrs: %x Write Data: %x \tRead Data: %x\n",
pprintf ("RTC Config RAM Adrs: %x Write Data: %x Read Data: %x\r",
err_printf(msg_d_load_only, "ds1287_diag", 1);
pprintf ("%s RegValue: %x\n",
err_printf(msg_d_load_only, "ds1287_diag", 2);
pprintf ("RTC Adrs: %x Write Data: %x \tRead Data: %x\r",
File: raw_esc_diag.c
pprintf("This diagnostic is only run in diag mode\n");
err_printf(msg_d_load_only, "esc_diag", 1);
pprintf ("%s ConfigAdrs: %x\t ConfigValue: %x\n",
err_printf(msg_d_load_only, "esc_diag", 2);
pprintf (sio_formats[SIO$Fmt_3], config_adrs, eptr->wbyte, eptr->rbyte);
pprintf (sio_formats[SIO$Fmt_3], config_adrs, idata, eptr->rbyte);
err_printf(msg_d_load_only, "esc_diag", 4);
pprintf ("%s RegAdrs: %x\t RegValue: %04x\n",
err_printf(msg_d_load_only, "esc_diag", 5);
pprintf (sio_formats[SIO$Fmt_4], esc_offset, eptr->wbyte, eptr->rbyte);
File: raw_ncr810_diag.c
pprintf("\n ** NCR810_eot s/w reset ** \n");
pprintf("This diagnostic is only run in diag mode\n");
err_printf(msg_d_load_only, "ncr810_diag", 1);
pprintf ("%s ConfigValue: %x\n",
err_printf(msg_d_load_only, "ncr810_diag", 2);
pprintf ("NCR810 Config Adrs: %x Write Data: %x Read Data: %x\r",
pprintf ("%s RegValue: %x\n",
err_printf(msg_d_load_only, "ncr810_diag", 5);
pprintf ("NCR810 CSR Adrs: %x Write Data: %x Read Data: %x\r",
err_printf(msg_d_load_only, "ncr810_diag", 7);
pprintf ("SCSI DATA LINE TEST: Write Data: %x Read Data: %x\n",
pprintf ("SCSI CONTROL LINE TEST: Write Data: %x Read Data: %x\n",
File: raw_pc87312_diag.c
pprintf("This diagnostic is only run in diag mode\n");
err_printf(msg_d_load_only, "combo_diag", 1);
pprintf ("Combo Chip %s ConfigValue: %2x\n",
err_printf(msg_d_load_only, "combo_diag", 2);
pprintf ("Combo Config Adrs: %x Write Data: %x Read Data: %x\r",
pprintf ("Combo CSR Adrs: %x WData: %x IData: %x\r",
err_printf(msg_d_load_only, "combo_diag", 4);
pprintf ("IRQ->DCD->DDCD: MCR: %02x MSR: %02x\n",
pprintf ("OUT1->RI->TERI: MCR: %02x MSR: %02x\n",
pprintf ("RTS->CTS->DCTS: MCR: %02x MSR: %02x\n",
pprintf ("DTR->DSR->DDSR: MCR: %02x MSR: %02x\n",
pprintf ("DTR->DSR: MCR: %02x MSR: %02x\n",
pprintf ("RTS->CTS: MCR: %02x MSR: %02x\n",
pprintf ("LoopBack Write Data: %2x Read Data: %2x\r",
pprintf ("\nIIR: %2x\n", eisa_inportb(UartBase+UART_IIR));
pprintf ("MCR: %2x IIR: %2x IER: %2x MSR: %2x\n",
pprintf ("\nIIR: %2x\n", eisa_inportb(UartBase+UART_IIR));
pprintf ("MCR: %2x IIR: %2x IER: %2x MSR: %2x\n",
pprintf ("\nIIR: %2x\n", eisa_inportb(UartBase+UART_IIR));
pprintf ("MCR: %2x IIR: %2x IER: %2x MSR: %2x\n",
pprintf ("\nIIR: %2x\n", eisa_inportb(UartBase+UART_IIR));
pprintf ("MCR: %2x IIR: %2x IER: %2x MSR: %2x\n",
err_printf(msg_d_load_only, "combo_diag", 5);
pprintf ("%s %s RegAdrs: %x RegValue: %2x\n",
pprintf ("%s %s RegAdrs: %x RegValue: %2x\n",
err_printf(msg_d_load_only, "combo_diag", 6);
pprintf ("\nWrite Read Testing %s\n", UartNum);
pprintf (sio_formats[SIO$Fmt_7],
pprintf ("Resetting %s Wdata: %x Idata: %x\n", UartNum, 0xFF, eptr->rbyte );
err_printf(msg_d_load_only, "combo_diag", 8);
err_printf (msg_noloopback);
pprintf ("External Loopback Testing UART0\n");
err_printf(msg_d_load_only, "combo_diag", 11);
err_printf (msg_noloopback);
err_printf(msg_d_load_only, "combo_diag", 12);
err_printf(msg_d_load_only, "combo_diag", 13);
err_printf(msg_d_load_only, "combo_diag", 14);
pprintf ("Printer Port %s RegValue: %2x\n",
err_printf(msg_d_load_only, "combo_diag", 15);
pprintf (sio_formats[SIO$Fmt_8],
err_printf(msg_d_load_only, "combo_diag", 17);
pprintf (sio_formats[SIO$Fmt_8],
err_printf (msg_noloopback);
pprintf ("All Ones ExtLoop: Wrote: %2x Read: %2x\n",
pprintf ("All Zeros ExtLoop: Wrote: %2x Read: %2x\n",
pprintf ("CTR<0>STB --> STR<4>SLCT: Wrote: %2x Read: %2x\n",
pprintf ("CTR<1>AFD --> STR<5>PE: Wrote: %2x Read: %2x\n",
pprintf ("CTR<2>INIT --> STR<6>ACK: Wrote: %2x Read: %2x\n",
pprintf ("CTR<3>SLIN --> STR<7>BUSY: Wrote: %2x Read: %2x\n",
pprintf ("DTR<0> --> STR<3>ERR: Wrote: %2x Read: %2x\n",
err_printf(msg_d_load_only, "combo_diag", 19);
err_printf (msg_noloopback);
err_printf(msg_d_load_only, "combo_diag", 20);
pprintf ("FDC Command %s, Results", cmd_name);
pprintf (" Result Phase[%x] = %x ", i, ResultsArray[i]);
err_printf(msg_d_load_only, "combo_diag", 21);
pprintf ("FDC %s RegAdrs: %x RegValue: %2x\n",
err_printf(msg_d_load_only, "combo_diag", 22);
pprintf (sio_formats[SIO$Fmt_9],
err_printf(msg_d_load_only, "combo_diag", 24);
err_printf(msg_d_load_only, "combo_diag", 25);
File: raw_pceb_diag.c
pprintf("This diagnostic is only run in diag mode\n");
err_printf(msg_d_load_only, "pceb_diag", 1);
pprintf ("%s ConfigValue: %08x\n",
err_printf(msg_d_load_only, "pceb_diag", 2);
pprintf (sio_formats[SIO$Fmt_5],
pprintf (sio_formats[SIO$Fmt_5],
err_printf(msg_d_load_only, "pceb_diag", 4);
pprintf ("%s RegValue: %x\n",
err_printf(msg_d_load_only, "pceb_diag", 5);
err_printf(msg_d_load_only, "pceb_diag", 7);
File: saddle_common.c
err_printf("\nExpected value:\t %08x\n", expect);
err_printf("Received value:\t %08x\n", rcvd);
err_printf("\nExpected value:\t %08x\n", expect);
err_printf("Received value:\t %08x\n", rcvd);
err_printf("Failing addr:\t %x\n", address);
err_printf("Expected value:\t %16x\n", expect);
err_printf("Received value:\t %16x\n", rcvd);
err_printf("Failing addr:\t %x\n", address);
printf (message);
printf (msg_pleaseyesno);
pprintf("%s\n",stat_string);
qprintf("%s\n",stat_string);
File: turbo_mc_diag_ovly.c
pprintf(" %s%d, hose %d, bus %d, slot %d\n", dev->tbl->mnemonic, dev->unit, dev->hose, dev->bus, dev->slot);
File: mc_driver.c
printf("%s FailPct : %d\n FailAdrs: %08x\n Expected: %08x\n Actual : %08x\n",
printf(mc_dump_header);
printf("%s - %08x %08x %08x %08x %08x %08x\n", mcpb->short_name,
printf(mc_testing);
err_printf(mc_config_err1);
err_printf(mc_config_err2,2);
err_printf(mc_config_err3);
err_printf(mc_config_err1);
err_printf(mc_testing_failed, mcpb->short_name, 12);
err_printf(mc_testing_failed, mcpb->short_name, 3);
err_printf(mc_detect_error);
printf("Adapter %s, Passed \n", mcpb->short_name);
err_printf(msg_no_device, argv[1]);
printf("MC_CABLE already running\n");
printf("To exit MC_CABLE, type <CTRL/C>\n");
printf("%s is offline\n", mcpb->short_name);
printf("%s node id %d is online\n", mcpb->short_name,
err_printf(mc_detect_error);
printf(mc_node_respond, "No ", j,
printf(mc_node_respond, "", j,
err_printf(mc_config_err1);
err_printf(mc_config_err2,(mcpb->pb.bus) ? 3 : 1);
err_printf(mc_config_err3);
err_printf(mc_config_err1);
File: turbo_pcimc_ovly.c
err_printf("Couldn't reserve the memory needed for this overlay.\n");
err_printf("Reset the system, SET MODE DIAG, and load again.\n");
printf("You must first SET MODE DIAG before loading this overlay\n");
File: pcimc_driver.c
dtprintf("MC-fopen info: %s, Next: %s Mode: %s %s\n", info, next, mode,
dtprintf("MC-fclose %s\n", ip->name);
int printflag = 0;
printflag = 1;
err_printf(msg_exdep_badincsize);
err_printf("Invalid MC Offset %x\n Use MC Offset 0-0x07ffffff\n",
printf("MC-Write: Address: %x#16\n", offset);
printf("pct_burst %d\n", (size * number)/ObjSize$K_LW);
printf("pct_data %d; %08x#16\n", i, *(unsigned long *) (buf +
printf("pct_mask %d; 1111#2\n", i);
dtprintf("Entering pcimc_initcsrs %s\n", mcpb->name);
dtprintf("Entering pcimc_initpb %s\n", ip->name);
pprintf("PCIMC FATAL ERROR pb vector = %x\n", mcpb->pb.vector);
pprintf("PCIMC FATAL ERROR could not set vector = %x\n",
dtprintf("Entering pcimc_init\n");
File: pcimc_cmds.c
printf("\nConfiguration Registers %s\n", mcpb->name);
printf(cfg, 0, incfgl(mcpb, PCIMC_CONFIG00));
printf(cfg, 4, incfgl(mcpb, PCIMC_CONFIG04));
printf(cfg, 8, incfgl(mcpb, PCIMC_CONFIG08));
printf(cfg, 0xc, incfgl(mcpb, PCIMC_CONFIG0C));
printf(cfg, 0x10, incfgl(mcpb, PCIMC_CONFIG10));
printf(cfg, 0x2c, incfgl(mcpb, PCIMC_CONFIG2C));
printf(cfg, 0x3c, incfgl(mcpb, PCIMC_CONFIG3C));
printf("\nMemory Mapped CSR Registers %s\n", mcpb->name);
printf("\tLCSR : Adrs: %08x Data: %08x\n", mcpb->lcsr,
printf("\tPRBAR : Adrs: %08x Data: %08x\n", mcpb->prbar,
printf("\tMCERR : Adrs: %08x Data: %08x\n", mcpb->mcerr,
printf("\tMCPORT: Adrs: %08x Data: %08x\n", mcpb->mcport,
err_printf(mcmsg_fopen_err, argv[1]);
printf("\nMC LINK ADAPTER OK %s\n\n", mcpb->name);
printf("\t MC2 MODULE\n\n");
printf("\t MC1 Module\n\n");
printf("\t MCPORT Register Value:\t %x\n", i);
printf("\t Virtual Hub 0 Mode:\t %d\n", virhubmode);
printf("\t Virtual Hub Configuration\n");
printf("\t Link Hub OK:\t\t %d \n", i >> 30 & 0x1);
printf("\t Link Hub On-Line:\t %d\n", i >> 29 & 0x1);
printf("\t Hub Type:\t\t %x\n", mcpb->pcimc_HubType);
printf("\t MC-NodeId:\t\t %x\n", mcpb->pcimc_NodeID);
err_printf(mcmsg_invalid_quals);
err_printf(mcmsg_name_req);
err_printf(mcmsg_fopen_err, argv[1]);
printf("%s Adapter Revision %x Virtual Hub 0 Mode\n",
printf("%s Adapter Revision %x VH1 Mode\n",
printf("%s Adapter Revision %x Standard Mode\n",
err_printf(mcmsg_invalid_quals);
printf("%s Adapter Revision %x Virtual Hub 0 Mode\n",
printf("%s Adapter Revision %x VH1 Mode\n", mcpb->name,
printf("%s Adapter Revision %x Standard Mode\n",
printf("Elapsed Time: %d %02d:%02d:%02d\n\n", days, hours, minutes,
printf("NodeID[%d] %-17.17s PingStatus: %-12.12s PongStatus: %s\n",
printf("PingSizeErr 256HW: %-3d 128HW: %-3d 64HW: %-3d 32HW: %-3d 16HW: %-3d\n",
printf(" 8HW: %-3d 4HW: %-3d 2HW: %-3d 1HW: %-3d CurrentXferSize: %3d HW\n",
printf("PongSizeErr 256HW: %-3d 128HW: %-3d 64HW: %-3d 32HW: %-3d 16HW: %-3d\n",
printf(" 8HW: %-3d 4HW: %-3d 2HW: %-3d 1HW: %-3d CurrentXferSize: %3d HW\n",
printf("NodeID[%d].PingNid : %-2d PingWaits: %-3d PingErrCnt: %-4d PingPid: %x\n",
printf("NodeID[%d].PongNid : %-2d PongRetry: %-3d PongErrCnt: %-4d PongPid: %x\n",
printf("NodeID[%d].PingPage: %-4d PingRd: %-16d PingWrt: %d\n", i,
printf("NodeID[%d].PongPage: %-4d PongRd: %-16d PongWrt: %d \n\n",
printf("NodeID[%d].Total Int: %20d State Change Intr: %d\n", i,
printf(" Pong Intr: %20d\n Ping Intr: %20d\n\n",
printf("\t%s NodeId: %d\n\n", mcpb->name, mcpb->pcimc_NodeID);
err_printf(mcmsg_invalid_quals);
err_printf(mcmsg_name_req);
err_printf(mcmsg_fopen_err, argv[1]);
err_printf(mcmsg_invalid_quals);
err_printf(mcmsg_name_req);
err_printf(mcmsg_fopen_err, argv[1]);
err_printf(mcmsg_invalid_quals);
err_printf(mcmsg_name_req);
err_printf(mcmsg_fopen_err, argv[1]);
printf("\nSync Config40 %08x\n",
printf("%s FailPg : %d\n FailAdrs: %08x\n Expected: %016x\n Actual : %016x\n",
printf("Sync Config40 %08x\n",
printf("%s FailPage: %d \nFailAdrs: %08x \nExpected: %08x \nActual : %08x\n",
printf("Sync Config40 %08x\n",
printf("%s FailPage: %d \nFailAdrs: %08x \nExpected: %08x \nActual : %08x\n",
printf(mcmsg_pass, pass++);
printf("Pct entry: %d Address of PCT entry: %08x: Data: %08x\n",
err_printf(mcmsg_invalid_quals);
err_printf(mcmsg_name_req);
err_printf("Destination MC-NodeID required, use -nid\n");
err_printf(mcmsg_fopen_err, argv[1]);
printf("There was %d.%d MBytes/Second written\n", data / 1000,
printf("%s MC-Ack Timeout Failure\n", mcpb->name);
printf("%s MC-Ack Successful\n", mcpb->name);
printf("\nThis Nodes MC-NodeId: %x\n\n", mcpb->pcimc_NodeID);
printf("MC-Ack Byte: %d\tMC-Ack Data: --\n", i);
printf("MC-Ack Byte: %d\tMC-Ack Data: %x\n", i,
printf("MC-Rcv Interrupt Counter: %d\n",
printf("%s MC-Rcv Interrupt Failed\n", mcpb->name);
printf("\nSync Config40 %08x\n",
printf("%s MC-Loopback Data Compare Error:\nFailAdrs: %08x\nExpected: %08x\nActual : %08x\n",
printf("\nSync Config40 %08x\n", incfgl(mcpb, 0x40));
printf("%s MC-Loopback Timeout:\nFailAdrs: %08x\nExpected: %08x\nActual : %08x\n",
printf(mcmsg_pass, pass++);
printf("Pass Complete\n");
err_printf(mcmsg_invalid_quals);
err_printf(mcmsg_name_req);
err_printf(mcmsg_fopen_err, argv[1]);
printf("\nSync Config40 %08x\n",
printf("%s MC-Transmit Compare Error:\nFailAdrs: %08x\nExpected: %08x\nActual : %08x\n",
printf(mcmsg_pass, pass++);
printf("HostMemMC: %x MCPage: %d MCPct: %d mcoffset: %d MCData: %08x\n",
printf("Pass Complete\n");
File: lfu_modular.c
printf(msg_extra_params);
printf(msg_lfu_banner);
printf(status);
printf(msg_extra_params);
printf(msg_extra_params);
printf("\n%-15s", argv[1]);
printf(msg_lfu_no_support);
printf(msg_lfu_update_warn1);
printf("\nConfirm update on: ");
printf(" ");
printf(msg_lfu_exit_error);
printf("\n modify attribute command failed for:\n %s\n",
printf("Invalid Selection\n");
printf(display_table1);
printf(display_table2);
printf(display_table3);
printf(display_table4);
printf(" Type Help <command> for additional information\n");
printf(help_table1, str1, str2, str3, str3, str3,str3,str3,str3,str3,str3);
printf(help_table2);
printf(help_table3);
printf(help_table4);
printf(help_table5);
printf(help_table6);
printf(help_table7);
printf(help_table8);
printf(help_table9);
printf(msg_lfu_list_header);
printf("%-20s", fname); /* report filename if its there */
printf("Missing file\n");
printf("Invalid image\n");
printf(str, fw);
printf(msg_lfu_verify_bad);
err_printf(msg_lfu_no_firm);
err_printf(msg_lfu_firm_opn_err, fname);
printf(msg_lfu_verify_bad);
printf(msg_lfu_verify_bad);
printf(msg_lfu_verify, fw);
printf(msg_lfu_verify_good);
printf(msg_lfu_verify_bad);
err_printf(msg_lfu_no_firm);
err_printf(msg_lfu_firm_opn_err, fname);
printf(msg_lfu_firm_bad, fname);
err_printf(msg_lfu_firm_opn_err, new_name);
printf(msg_lfu_firm_bad, fname);
printf(msg_lfu_update_older_rev, firm_fw, fw);
printf(msg_lfu_update_warn2);
printf(msg_lfu_update, firm_fw);
printf(msg_lfu_update_failed);
printf(msg_lfu_verify, fw);
printf(msg_lfu_verify_good);
printf(msg_lfu_verify_bad);
printf("%-15.14s", report_name);
printf("%35s%-20s", "", fname);
printf("Invalid image\n");
printf(" ");
printf("%s\n", fw);
printf(msg_lfu_no_cd);
printf(msg_lfu_no_cd);
printf(lfu_prompt4, optio, optcp);
printf(lfu_prompt3, optfw);
printf("Copying %s from %s ", inlist, device);
printf("Copying %s from %s ", inlist, device);
printf("Copying %s from %s ", list, device);
printf("No valid device selected\n");
printf("Couldn't read %s\n", file_string);
printf("Copying %s from %s ", stradr, device);
printf("Couldn't read %s\n", file_string);
err_printf("get_option_firmware: can't allocate enough memory\n");
err_printf("Failed to decompress %s\n", &dlp->name);
File: lfu_grom.c
printf("GROM: adr %x size %x(%d)\n", grom_base, grom_len, grom_len);
err_printf("FATAL error, Grom not valid\n");
printf("GROM CNSL Image: offset %x size %x(%d) address %x",
printf(" cksum %x max %x(%d)\n", image_cksum, rom_max_size, rom_max_size);
err_printf(msg_insuff_mem, grom_flash_len);
err_printf(msg_insuff_mem, newrom_overlay_table_length);
printf("Copy grom header to new rom: new %x grom %x size %x\n",
printf("Copy header to new rom: new %x grom %x size %x",
printf(" image base %x\n", newrom_image_base);
err_printf(msg_insuff_mem, newindex_len);
printf("newindex_iptr %x\n", newindex_iptr);
printf("Copy index to new rom: new %x index %x size %x\n",
printf("New CNSL image: base %x size %x(%d) iptr %x\n",
err_printf("FATAL error, New Grom not valid\n");
printf("ROM Image: adr %x size %x(%d) image %x, iblock %x, ctime %x\n",
printf(" Index count %d, ", j);
printf("Checksum %08x, ", *fiptr);
printf("Version %c", *fsptr);
printf("%d.", *fsptr);
printf("%d-", *fsptr);
printf("%d\n", *fsptr);
printf(" Creation time ");
printf("\n\n");
printf(" Image %d, Offset %x", k, ioffset);
printf(", Id %.4s, File: %.32s\n", x1, x2);
printf(" Time ", x1, x2);
printf(", Checksum %08x\n", x5);
printf(" Original Length %d", x3);
printf(", Compressed Length %d\n", x6);
printf("Build required image: base %x image %x offset %x\n",
err_printf("Overlay %s not found in Grom image\n", tp->name);
printf("File: %s size %x(%d) index %d new %x grom %x\n",
printf(" index_ptr %x offset %x\n", (int) newindex_iptr -
printf(" next offset %x\n", newrom_offset);
printf("copyblock size %x(%d) index %d new %x grom %x\n",
printf(" index_ptr %x offset %x\n",
printf(" next offset %x\n", newrom_offset);
printf("display_rom: index count %x base %x offset %x",
printf(" offset %x header_adr %x size %x\n", rom_header_adr,
err_printf("%d overlays, exceeded rom space by %x(%d) bytes\n",
printf("%d overlays %x(%d) free bytes\n", rom_index_count, free, free);
printf("ROM IMAGE:");
printf(" Version %c", *fsptr);
printf("%d.", *fsptr);
printf("%d-", *fsptr);
printf("%d", *fsptr);
printf(" Creation time ");
printf("Overlay %s not found in grom image\n", name);
printf("Required overlay %s, removal not allowed\n",
printf("Overlay %s not in list\n", name);
printf("Available overlays:\n");
err_printf("Overlay %s not found in Grom image\n", rp->name);
err_printf("Overlay %s not found in Grom image\n", rp->name);
printf("setup dst: dev %s\n", dstp->device);
printf("DST: %s %s %s\n", dstp->name, dstp->device,
err_printf("Can't find overlay %s\n", name);
err_printf("Can't find overlay %s\n", addit_ptr);
printf(" Image %d, Offset %x", k, ioffset);
printf(", Id %.4s, File: %.32s\n", x1, x2);
printf(" Time ", x1, x2);
printf(", Checksum %08x\n", x5);
printf(" Original Length %d", x3);
printf(", Compressed Length %d\n", x6);
printf("%d overlays, exceeded rom space by %x(%d) bytes\n\n", count,
printf("%d overlays %x(%d) free bytes\n\n", count, free, free);
File: lfu_rawhide.c
err_printf("Image is not LFU\n");
printf("\nStarting Firmware Update Utility\n");
err_printf("Memzone exists after boot, Impossible\n");
printf("\nUnpacking firmware files\n");
printf(" %-12s adr = %7x len = %x(%d)\n", &dlp->name, fw_address, dlp->len, dlp->len);
err_printf("Failed to decompress %s\n", &dlp->name);
printf("\nModify attributes failed for: ");
printf("%s\n", report_name);
err_printf("\nInvalid ARC image\n");
err_printf("\nARC Image checksum error, actual = %08x, computed = %08x\n",
File: test.c
printf("Runtime value must be greater than 30 seconds\n");
printf("Runtime value must be less than 99999999 seconds\n");
printf("Illegal wildcard\n");
printf("Illegal device\n");
printf(msg_bad_filename);
fprintf(fout, "%s\n", argv[1]);
printf("No such device\n");
printf("TIOP exerciser forces bus errors during testing.\n");
printf("System will be reset...\n");
fprintf(fout, "%s\n", name);
printf("Script doesn't exist - %s\n", script_ptr);
printf("Testing aborted. Shutting down tests.\n");
printf("Please wait..\n");
File: Generic_messages.c
char msg_invalid_devname[] = "invalid device name: %s\n";
char msg_invalid_unit[] = "invalid unit for device\n";
char msg_invalid_slot[] = "invalid slot for device\n";
char msg_invalid_hose[] = "invalid hose for device\n";
char msg_hose_sizing [] = "Hose sizing error\n\n";
char msg_unk_bootdev_class[] = "unknown boot device class\n";
char msg_controller_not_found[] = "could not find controller for device %s\n";
char msg_overflow [] = "numeric value too large\n";
char msg_unicheck [] = "%s: multiple cpus can respond.\nChange affinity mask using SA command or &p operator.\n";
char msg_not_enabled [] = "processor not enabled to leave console mode\n";
char msg_not_in_console [] = "not modified - all processors must be in console mode\n";
char msg_shell_nocmd [] = "no shell command\n";
char msg_shell_noex [] = "not executable\n";
char msg_qscan_noqual [] = "unrecognized qualifiers\n";
char msg_qscan_conv [] = "qualifier conversion error\n";
char msg_qscan_misc [] = "qualifier value not found\n";
char msg_qscan_valerr [] = "qualifier conversion specification not recognized\n";
char msg_poorly_formed_exp [] = "poorly formed regular expression\n";
char msg_mem_adr_align [] = "start address not hexaword aligned\n";
char msg_mem_len_align [] = "length not hexaword aligned\n";
char msg_cmp_seek [] = "cmp: seek error\n";
char msg_cmp_length [] = "cmp: files not equal length\n";
char msg_cmp_neq [] = "cmp: files not equal at offset %08X %02X %02X\n";
char msg_ctx_invalid [] = "Slot context is not valid\n";
char msg_sort_scratch [] = "sort: internal scratch space exceeded\n";
char msg_success [] = "";
char msg_failure [] = "";
char msg_killed [] = "";
char msg_fatal [] = "fatal error\n";
char msg_nofile [] = "no such file\n";
char msg_file_not_found [] = "file %s not found\n";
char msg_ambig_file [] = "ambiguous filename\n";
char msg_not_removed [] = "rm: %s not removed\n";
char msg_bad_open [] = "file open failed for %s\n";
char msg_bad_stat [] = "bad file status for file %s\n";
char msg_no_fp_slot [] = "no open file slot\n";
char msg_no_ip_slot [] = "no more inodes\n";
char msg_no_create [] = "can't create file\n";
char msg_file_in_use [] = "file is in use\n";
char msg_file_full [] = "file system is full\n";
char msg_bad_access_mode [] = "invalid access mode\n";
char msg_bad_filename [] = "invalid file name\n";
char msg_no_infonext [] = "info/next fields not allowed\n";
char msg_nomsg [] = "no such message\n";
char msg_noprocess [] = "no such process\n";
char msg_termtimeout [] = "terminal timeout\n";
char msg_extra_params [] = "too many parameters\n";
char msg_insuff_params [] = "insufficient parameters\n";
char msg_insuff_mem [] = "insufficient dynamic memory for a request of %d bytes\n";
char msg_no_free [] = "Can't free memory\n";
char msg_qual_conflict [] = "conflicting qualifiers\n";
char msg_data_comp_err [] = "data compare error for %d bytes at location %08X from device %s\n";
char msg_exer_hd2 [] = "\npacket IOs elapsed idle\n";
char msg_exer_hd3 [] = " size IOs bytes read bytes written /sec bytes/sec seconds secs\n";
char msg_exer_counts [] = "%6d %12d %14d %14d %6d %9d %6d %6d\n";
char msg_exer_finis [] = "\n%s exer completed\n";
char msg_bad_action [] = "illegal action string character\n";
char msg_expect_buf [] = "expected buffer contents: \n";
char msg_receive_buf [] = "\nreceived buffer contents: \n";
char msg_mem_comp [] = "* Memory error at address:%x Wrote:%x Read:%x\n";
char msg_illegal_operation [] = "illegal operation on driver %s\n";
char msg_exdep_conflict [] = "conflicting qualifiers - command ignored\n";
char msg_exdep_badadr [] = "Illegal target address\n";
char msg_exdep_badparam [] = "Too many command parameters\n";
char msg_exdep_badincsize [] = "Illegal value for data size increment\n";
char msg_exdep_outrange [] = "%s out of range\n";
char msg_dep_param_missing [] = "Required parameters were not specified\n";
char msg_dep_datatoobig [] = "Deposit data too large for specified data type\n";
char msg_dep_baddata [] = "Illegal data parameter\n";
char msg_ex_devopenrderr [] = "Error opening device %s for read access\n";
char msg_dep_devopenwrerr [] = "Error opening device %s for write access\n";
char msg_exdep_devseekerr [] = "Error in seek to location %08X on device %s\n";
char msg_ex_devreaderr [] = "Error in read of %d bytes at location %08X from device %s\n";
char msg_dep_devwriteerr [] = "Error in write of %d bytes to location %08X on device %s\n";
char msg_ipr_noread [] = "IPR is not readable\n";
char msg_ipr_nowrite [] = "IPR is not writeable\n";
char msg_ipr_nonexist [] = "Illegal IPR\n";
char msg_no_vc [] = "no VC exists to %s\n";
char msg_dev_found [] = "device %s (%s) found on %s\n";
char msg_dev_lost [] = "device %s (%s) lost on %s\n";
char msg_rec_underflow [] = "record too short (%d bytes expected)\n";
char msg_rec_overflow [] = "record too long (%d bytes expected)\n";
char msg_eof [] = "end of file encountered\n";
char msg_eot [] = "end of tape encountered\n";
char msg_bad_inode [] = "file %s no longer exists\n";
char msg_bad_device [] = "device %s no longer valid\n";
char msg_no_media [] = "%s has no media present or is disabled via the RUN/STOP switch\n";
char msg_not_ready [] = "%s is not ready\n";
char msg_write_prot [] = "%s is write protected\n";
char msg_bad_request [] = "I/O request to %s is invalid (check type, offset, and size)\n";
char msg_mscp_no_conn [] = "no MSCP connection exists to %s\n";
char msg_mscp_bad_status [] = "bad MSCP status (%d|%d) received\n";
char msg_mscp_cmd_tmo_check [] = "MSCP command timeout, getting status from %s\n";
char msg_mscp_cmd_tmo_fatal [] = "MSCP command timeout, fatal error on %s\n";
char msg_mscp_no_progress [] = "MSCP command timeout, no progress on %s\n";
char msg_mscp_bad_cmd_rsp [] = "bad MSCP command/response (%02x) from %s\n";
char msg_mscp_bad_available [] = "failed to send Available to %s\n";
char msg_mscp_bad_online [] = "failed to send Online to %s\n";
char msg_mscp_bad_read [] = "failed to send Read to %s\n";
char msg_mscp_bad_write [] = "failed to send Write to %s\n";
char msg_dup_no_conn [] = "no DUP connection exists to %s\n";
char msg_dup_bad_status [] = "bad DUP status (%d|%d) received\n";
char msg_dup_cmd_tmo_fatal [] = "DUP command timeout, fatal error on %s\n";
char msg_dup_bad_cmd_rsp [] = "bad DUP command/response (%02x) from %s\n";
char msg_dup_ill_msg_typ [] = "illegal Send Data (Immediate) message type (%d) received from %s\n";
char msg_dup_bad_get_cont [] = "failed to send Get Controller Status to %s\n";
char msg_dup_bad_exe_local [] = "failed to send Execute Local Program to %s\n";
char msg_dup_bad_send [] = "failed to send Send Data (Immediate) to %s\n";
char msg_dup_bad_receive [] = "failed to send Receive Data to %s\n";
char msg_scsi_bad_status [] = "bad SCSI status (%02x) received from %s\n";
char msg_scsi_retries_gone [] = "retries to %s exhausted\n";
char msg_scsi_send_fail [] = "failed to send command to %s\n";
char msg_scsi_bad_check [] = "invalid or fatal SCSI Check Condition reported\n";
char msg_scsi_not_512 [] = "block size is not 512 bytes for %s\n";
char msg_scsi_ill_dev_typ [] = "illegal Inquiry device type (%d) from %s\n";
char msg_scsi_ill_err_cod [] = "illegal Request Sense error code (%02x) from %s\n";
char msg_scsi_sense_key [] = "sense key = '%s' (%02x|%02x) from %s\n";
char msg_scsi_sense_key_x [] = "sense key = %02x (%02x|%02x) from %s\n";
char msg_scsi_bad_su [] = "failed to send Start Unit to %s\n";
char msg_scsi_bad_ms [] = "failed to send Mode Select to %s\n";
char msg_scsi_bad_rc [] = "failed to send Read Capacity to %s\n";
char msg_scsi_bad_rewind [] = "failed to send Rewind to %s\n";
char msg_scsi_bad_read [] = "failed to send Read to %s\n";
char msg_scsi_bad_write [] = "failed to send Write to %s\n";
char msg_rd_bad_validate [] = "RD driver failure (%d)\n";
char msg_pi_bad_validate [] = "PI driver failure (%d)\n";
char msg_dyn_free_lnk [] = "bad free list detected at %08x\n";
char msg_dyn_adj_lnk [] = "bad adjacency list detected at %08x\n";
char msg_dyn_free_seq [] = "free list not in ascending order at %08x\n";
char msg_dyn_adj_seq [] = "adjacency list not sequential at %08x\n";
char msg_dyn_size [] = "non negative size at %08x\n";
char msg_dyn_badzone [] = "%08X is not a valid zone address. Use dynamic to list valid zones.\n";
char msg_mem_len_gt_bs [] = "Length cannot be larger than block size.";
char msg_start_gt_end [] = "Start address cannot be larger than end address.";
char msg_noev [] = "%s does not exist\n";
char msg_d_z_warn [] = "-z will not safely malloc memory. Continue [Y, (N)]? ";
char msg_d_no_malloc [] = "Unable to allocate memory of length %x at starting address %x\n";
char msg_malloc_fail [] = "Malloc of %x bytes failed\n";
char msg_d_ext_err_exp [] = "Expected value:\t %08x";
char msg_d_ext_err_rcd [] = "Received value:\t %08x";
char msg_ev_prot [] = "%s protected from attempted operation\n";
char msg_ev_badname [] = "bad name - %s not created\n";
char msg_ev_badvalue [] = "bad value - %s not modified\n";
char msg_destruct_prompt [] = "\nDestructive test specified. Continue [Y, (N)]? ";
char msg_destruct [] = "diagnostic aborted because of destructive test\n";
char msg_nodis [] = "diagnostic aborted due to missing dispatch table\n";
char msg_quals [] = "diagnostic aborted due to invalid command line qualifiers\n";
char msg_eval_overflow [] = "expression evaluator overflow\n";
char msg_eval_underflow [] = "expression evaluator underflow\n";
char msg_eval_values [] = "values left on expression stack\n";
char msg_radix [] = "illegal digit for specified radix\n";
char msg_show_iob_hdr1 [] = " ID Program Device Pass Hard/Soft Bytes Written Bytes Read \n";
char msg_show_iob_hdr2 [] = "-------- ------------ ------------ ------ --------- ------------- -------------\n";
char msg_d_header [] = "Diagnostic Name ID Device Pass Test Hard/Soft";
char msg_d_err [] = "*** Error -";
char msg_d_hard [] = "*** Hard Error -";
char msg_d_soft [] = "*** Soft Error -";
char msg_d_fatal [] = "*** Fatal Error -";
char msg_d_pass [] = "* End of Run - Passed *";
char msg_d_fail [] = "* End of Run - Failed *";
char msg_d_err_end [] = "\n*** End of Error ***\n\n";
char msg_d_completion [] = "\n\nTesting Complete\n\n%m %s\n%-12.12s %08.8x %14.14s %4.4d %4.4d %4.4d %8.8s\n\n%-m\n";
char msg_d_end_of_pass [] = "%-12.12s %08.8x %14.14s %4.4d %4.4d %4.4d %8.8s\n";
char msg_d_startup [] = "%m %s\n%-12.12s %08.8x %14.14s 0 0 0 %8.8s\n";
char msg_d_status [] = "%m %s\n%-12.12s %08.8x %14.14s %4.4d %4.4d %4.4d %4.4d %8.8s\n\n";
char msg_d_test_trace [] = "%-12.12s %08.8x %14.14s %4.4d %4.4d %4.4d %4.4d %8.8s\n";
char msg_d_error [] = "\n%m Error #%-d - %m\n%m %s\n%-12.12s %08.8x %14.14s %4.4d %4.4d %4.4d %4.4d %8.8s\n";
char msg_d_validate [] = "External loopback error, no packet received";
char msg_d_no_dev_name [] = "No device name was entered for IOB search\n";
char msg_d_inv_test [] = "Invalid test selection\n";
char msg_d_inv_grp [] = "Invalid group selection\n";
char msg_d_inv_test_grp [] = "Invalid test selection for group entered\n";
char msg_d_no_iob_found [] = "No IOB was found corresponding to device %s\n";
char msg_d_exp_rcd [] = "Expected value:%x Received value: %x\n";
char msg_d_ext_err_fa [] = "Failing addr:\t %x\n";
char msg_d_ext_node_num [] = "Error detected by node:\t %d\n";
char msg_d_shared_read [] = "Shared cache data read mismatch\n";
char msg_d_arith_trap [] = "Arithmetic exception encountered \n";
char msg_d_unx_excep [] = "Unexpected exception encountered\n";
char msg_d_ex_excep [] = "Expected exception did not occur\n";
char msg_d_sbew_excep [] = "Expected SBE on WR exception did not occur\n";
char msg_d_sber_excep [] = "Expected SBE on RD exception did not occur\n";
char msg_d_dbew_excep [] = "Expected DBE on WR exception did not occur\n";
char msg_d_dber_excep [] = "Expected DBE on RD exception did not occur\n";
char msg_d_unexpec_mchk [] = "Unexpected Machine Check\n";
char msg_d_data_comp_err [] = "Data compare error\n";
char msg_d_timeout_err [] = "Synchronization timeout occurred\n";
char msg_d_bad_group [] = "D_GROUP set to %s -- No tests found in that group\n";
char msg_d_scram [] = "Script RAM failure\n";
char msg_d_scram_parity [] = "Script RAM initialize parity failure\n";
char msg_d_scram_data_line [] = "Script RAM data line failure\n";
char msg_d_scram_adr_line [] = "Script RAM cell or address line failure\n";
char msg_d_ncr [] = "Storage Bus %c failure\n";
char msg_d_ncr_host_data_line [] = "%s host data lines failure\n";
char msg_d_ncr_host_adr_line [] = "%s host address lines failure\n";
char msg_d_ncr_scsi_bus [] = "%s SCSI bus failure\n";
char msg_d_ncr_dma_err [] = "DMA failure, script source addr:%x, destination addr:%x\n";
char msg_d_ncr_dstat_sir [] = "DMA completed but DSTAT:SIR is stuck\n";
char msg_d_ncr_id [] = "%s set bus ID failure\n";
char msg_d_ncr_bus_arb [] = "Warning: %s, loopback connector attached OR\nSCSI bus failure, could not acquire bus; Control Lines:%x Data lines:%x\n";
char msg_d_ncr_cant_test [] = "Warning: %s not tested\n";
char msg_d_load_only [] = "%s test %d is only run in the 'loadable' console environment\n";
char msg_ex_shutdown_fail [] = "%s port shutdown failed.\n";
char msg_ex_reset_retrying [] = "%s node reset failed - retrying...\n";
char msg_ex_reset_fail [] = "%s node reset failed.\n";
char msg_ex_init_timeout [] = "%s port initialization failed - timeout on XPST_uninitialized\n";
char msg_ex_init_fail [] = "%s port initialization failed.\n";
char msg_ex_buflen_err [] = "%s:Buffer length error.\n";
char msg_ex_addr_inval [] = "%s:Buffer address invalid.\n";
char msg_ex_addr_xlate_err [] = "%s:Address translation error.\n";
char msg_ex_bufxfer_fail [] = "%s:Buffer transfer failed.\n";
char msg_ex_inval_cmd [] = "%s:Invalid command.\n";
char msg_ex_inval_opc [] = "%s:Invalid opcode.\n";
char msg_ex_excd_srcaddr [] = "%s:Invalid command - exceeded maximum number of source addresses\n";
char msg_ex_excd_dstaddr [] = "%s:Invalid command - exceeded maximum number of destination/multicast addresses\n";
char msg_ex_frmlen_err [] = "%s:Frame length error.\n";
char msg_ex_loss_carrier [] = "%s:Transmit failed - loss of carrier.\n";
char msg_ex_tx_retries_exh [] = "%s:Transmit failed - retries exhausted.\n";
char msg_ex_late_coll [] = "%s:Transmit failed - late collision.\n";
char msg_ex_tx_timeout [] = "%s:Transmit failed - transmit timeout.\n";
char msg_ex_tx_fail [] = "%s:Transmit failed.\n";
char msg_ex_frmlen_incnsstnt [] = "%s:Frame length inconsistent.\n";
char msg_ex_frmlen_toobig [] = "%s:Frame length > 1518 bytes (1518 bytes delivered).\n";
char msg_ex_rx_crc_err [] = "%s:Invalid packet - CRC error.\n";
char msg_ex_invalid_pkt [] = "%s:Invalid packet.\n";
char msg_ex_cmd_timeout [] = "%s command timeout!\n";
char msg_ex_err_ustart [] = "Error sending USTART command to %s.\n";
char msg_ex_err_ustop [] = "Error sending USTOP command to %s.\n";
char msg_ex_err_rdcntr [] = "Error sending RDCNTR command to %s.\n";
char msg_ex_err_mode [] = "Attempt to set %s into an illegal mode.\n";
char msg_ex_err_param [] = "Error sending PARAM command to %s.\n";
char msg_ex_err_n_env_var [] = "Couldn't read env variable: %s\n";
char msg_ex_noerror [] = "%s:No error.\n";
char msg_ex_stfailed [] = "%s:Module selftest failed.\n";
char msg_ex_bad_pdb_adr [] = "%s:Invalid PDB address.\n";
char msg_ex_bad_pdb_fld [] = "%s:Invalid PDB field.\n";
char msg_ex_bad_eeprom [] = "%s:XNA EEPROM not valid.\n";
char msg_ex_not_uninit [] = "%s:Initialization attempted when port not in uninitialized state.\n";
char msg_ex_bad_cmdring [] = "%s:Invalid command ring.\n";
char msg_ex_bad_rcvring [] = "%s:Invalid receive ring.\n";
char msg_ex_pwrfail [] = "%s:Power failure.\n";
char msg_no_kbd_use_serial [] = "Keyboard error; using serial port terminal\n";
char msg_ex_fw_excption [] = "%s:Unexpected XNA firmware exception.\n";
char msg_ex_xmi_fail [] = "%s:Unrecoverable XMI failure.\n";
char msg_ex_fatal_fw [] = "%s:Fatal XNA firmware internal error.\n";
char msg_ex_keep_alive_fail [] = "%s:Fatal XNA firmware error - keep-alive counter.\n";
char msg_ex_fw_upd_done [] = "%s:XNA firmware update complete.\n";
char msg_init_port [] = "Initializing driver %s.\n";
char msg_port_noerror[] = "%s: No error.\n";
char msg_port_inited [] = "Driver %s initialized.\n";
char msg_port_reset_retrying [] = "%s node reset failed - retrying...\n";
char msg_port_reset_fail [] = "%s node reset failed.\n";
char msg_port_xpst_timeout [] = "%s port initialization failed - timeout on XPST_uninitialized\n";
char msg_port_init_fail [] = "%s port initialization failed.\n";
char msg_port_shutdown_fail [] = "%s port shutdown failed.\n";
char msg_port_cmd_timeout [] = "%s command timeout!\n";
char msg_port_err_param [] = "Error sending PARAM command to %s.\n";
char msg_port_err_rdcntr [] = "Error sending RDCNTR command to %s.\n";
char msg_port_err_ustart [] = "Error sending USTART command to %s.\n";
char msg_port_err_ustop [] = "Error sending USTOP command to %s.\n";
char msg_port_err_mode [] = "Attempt to set %s into an illegal mode.\n";
char msg_port_err_n_env_var [] = "Couldn't read env variable: %s\n";
char msg_port_state_resetting [] = "Resetting";
char msg_port_state_uninit [] = "Uninitialized";
char msg_port_state_init [] = "Initialized";
char msg_port_state_running [] = "Running";
char msg_port_state_maint [] = "Maintenance";
char msg_port_state_halted [] = "Halted";
char msg_port_fail_enter_state [] = "%s: Failed to enter %m state.\n";;
char msg_port_stfailed [] = "%s: Port init failed: adapter failed self-test.\n";
char msg_port_bad_pdb_adr [] = "%s: Port init failed: invalid PDB address.\n";
char msg_port_bad_pdb_fld [] = "%s: Port init failed: invalid PDB field.\n";
char msg_port_bad_eeprom [] = "%s: EEPROM contents are invalid.\n";
char msg_port_not_uninit [] = "%s: Initialization attempted when port not in the Uninitialized state.\n";
char msg_port_bad_cmdring [] = "%s: Invalid command ring.\n";
char msg_port_bad_rcvring [] = "%s: Invalid receive ring.\n";
char msg_port_xmi_fail [] = "%s: Unrecoverable XMI failure, including memory error.\n";
char msg_port_pwrfail [] = "%s: Power failure.\n";
char msg_port_fatal_fw [] = "%s: Fatal firmware internal error.\n";
char msg_port_nhalt_issued [] = "%s: Node Halt issued.\n";
char msg_port_fatal_hw [] = "%s: Fatal hardware internal error.\n";
char msg_port_inval_state [] = "%s: Invalid adapter state.\n";
char msg_port_wd_to_err [] = "%s: Watchdog timeout error.\n";
char msg_port_bus_flt [] = "%s: Bus Fault.\n";
char msg_port_unexpected_int [] = "%s: Unexpected interrupt - port state = %m.\n";
char msg_port_unexplained_int [] = "%s: Unexplained interrupt!\n";
char msg_port_buflen_err [] = "%s: Buffer length error.\n";
char msg_port_bufxfer_fail [] = "%s: Buffer transfer failed.\n";
char msg_port_inval_cmd [] = "%s: Invalid command.\n";
char msg_port_inval_opc [] = "%s: Invalid opcode.\n";
char msg_ez_err_xmt_to [] = "Transmit time out\n";
char msg_ez_err_n_xmt_des [] = "Transmits hung, check termination.\n";
char msg_ez_err_setup_to [] = "Setup frame timed out\n";
char msg_ez_err_diag_to [] = "Diagnostic framed time out\n";
char msg_ez_err_setup_des [] = "Setup descriptor error. SDES0: %08x\n";
char msg_ez_err_init_tl [] = "Initialization took to long\n";
char msg_d_self_test [] = "%s self test failed\n";
char msg_ez_err_self_test [] = "XGEC self test failed. status: %01x\n";
char msg_ez_err_unk_start_md [] = "Unknown start mode\n";
char msg_ez_err_nisa_null [] = "Network station address is a Null address\n";
char msg_ez_err_nisa_bad_chk [] = "Network station address ROM has a bad checksum\n";
char msg_ez_err_nisa_n_rpt [] = "Network station address is not repeated\n";
char msg_ez_err_bad_patt [] = "Pattern ff0055aa does not exist in station address ROM\n";
char msg_ez_inf_dev_spec [] = "\nDEVICE SPECIFIC:\n";
char msg_ez_inf_mop_blk [] = "\nMOP BLOCK:\n";
char msg_ez_inf_net_lst [] = " Network list size: %d\n";
char msg_ez_err_n_env_var [] = "Couldn't read env variable: %s\n";
char msg_ez_err_mode_n_chg [] = "Mode not changed\n";
char msg_ez_inf_mop_cnt [] = "\nMOP COUNTERS:\n";
char msg_ez_inf_t_s_0 [] = "Time since zeroed (Secs): %d\n";
char msg_ez_inf_b_f [] = " Bytes: %d Frames: %d\n";
char msg_ez_inf_df_oc_mc [] = " Deferred: %d One collision: %d Multi collisions: %d\n";
char msg_ez_inf_tx_f [] = "TX Failures:\n";
char msg_ez_inf_ec_cc_sc [] = " Excessive collisions: %d Carrier check: %d Short circuit: %d\n";
char msg_ez_inf_oc_lf_rd [] = " Open circuit: %d Long frame: %d Remote defer: %d\n";
char msg_ez_inf_cd [] = " Collision detect: %d\n";
char msg_ez_inf_tx [] = "\nTX:\n";
char msg_ez_inf_rx [] = "\nRX:\n";
char msg_ez_inf_mb_mf [] = " Multicast bytes: %d Multicast frames: %d\n";
char msg_ez_inf_rx_f [] = "RX Failures:\n";
char msg_ez_inf_bc_fe [] = " Block check: %d Framing error: %d Long frame: %d\n";
char msg_ez_inf_ud_do_ns [] = " Unknown destination: %d Data overrun: %d No system buffer: %d\n";
char msg_ez_inf_nub [] = " No user buffers: %d\n";
char msg_ez_inf_add_sz [] = "Packet address: %08x size: %d\n";
char msg_ez_err_pdes [] = "Processing a descriptor the XGEC owns\n";
char msg_ez_inf_001 [] = " TI: %d RI: %d RU: %d ME: %d TW: %d RW: %d BO: %d\n";
char msg_ez_inf_002 [] = " HF: %d UF: %d TN: %d LE: %d TO: %d RWT: %d RHF: %d TC: %d\n";
char msg_ez_inf_003 [] = "\nPORT INFO:\n";
char msg_ez_inf_004 [] = "tx full: %d tx index in: %d tx index out: %d\n";
char msg_ez_inf_005 [] = "rx index in: %d\n";
char msg_ez_inf_006 [] = "NICSRS:\n";
char msg_ez_inf_007 [] = " csr0: %08x ";
char msg_ez_inf_008 [] = " csr1: %08x ";
char msg_ez_inf_009 [] = " csr2: %08x ";
char msg_ez_inf_010 [] = " csr3: %08x\n";
char msg_ez_inf_011 [] = " csr4: %08x ";
char msg_ez_inf_012 [] = " csr5: %08x ";
char msg_ez_inf_013 [] = " csr6: %08x ";
char msg_ez_inf_014 [] = " csr7: %08x\n";
char msg_ez_inf_015 [] = " csr9: %08x ";
char msg_ez_inf_016 [] = " csr10: %08x ";
char msg_ez_inf_017 [] = " csr11: %08x ";
char msg_ez_inf_018 [] = " csr12: %08x\n";
char msg_ez_inf_019 [] = " csr13: %08x ";
char msg_ez_inf_020 [] = " csr14: %08x ";
char msg_ez_inf_021 [] = " csr15: %08x\n";
char msg_mbx_busy [] = "\n*** unable to write to mailbox pointer register\n";
char msg_mbx_prev_trans_t_o [] = "\n*** previous mailbox IO timeout, don flag not set\n";
char msg_mbx_trans_t_o [] = "\n*** mailbox IO timeout, done flag not set on hose %d\n";
char msg_mbx_trans_err [] = "\n*** Mailbox transaction error, ";
char msg_mbx_status [] = "mailbox status %08x %08x\n";
char msg_mbx_ctr_rbadr [] = "mailbox control %08x %08x, remote bus address %08x %08x\n";
char msg_mbx_rdata [] = "mailbox read data field %08x %08x\n";
char msg_mbx_wdata [] = "mailbox write data field %08x %08x\n";
char msg_mbx_err_info [] = "device = %s pcb = %x (%s) mailbox = %x\n";
char msg_lbus_reset [] = "lbus has just been reset & enabled\n";
char msg_ndl_err_001 [] = "Invalid enet address: %s\n";
char msg_ndl_err_002 [] = "\n*** Error (%s), ";
char msg_ndl_err_003 [] = "\n*** Error, ";
char msg_mop_err_n_dl_cd [] = "Unrecognized D/L message code from: %02x-%02x-%02x-%02x-%02x-%02x\n";
char msg_mop_inf_cntrs [] = "Counters\n";
char msg_mop_err_n_cn_cd [] = "Unrecognized Console message from : %02x-%02x-%02x-%02x-%02x-%02x\n";
char msg_mop_wrn_out_o_seq_ml [] = "Out of sequence message (MEM_LOAD)\n";
char msg_mop_det_sv_msg [] = "Saved: %d message: %d\n";
char msg_mop_wrn_out_o_seq_mlxf [] = "Out of sequence message (MEM_LOAD_W_XFER)\n";
char msg_mop_wrn_out_o_seq_plxf [] = "Out of sequence message (PARAM_LOAD_W_XFER)\n";
char msg_mop_err_n_net_fl [] = "Couldn't read the network file\n";
char msg_mop_err_nr_net_fl [] = "Couldn't write the network file\n";
char msg_mop_det_good_data [] = "Good data:\n";
char msg_mop_det_bad_data [] = "Bad data:\n";
char msg_mop_err_mem_comp [] = "Memory compare error\n";
char msg_mop_inf_tgt_name [] = "Target name: %s\n";
char msg_mop_inf_ld_com [] = "Network load complete.\n";
char msg_mop_inf_hst_name [] = "Host name: %s\n";
char msg_mop_inf_retry_net [] = "Retrying...\n";
char msg_mop_err_rd_lp_fl [] = "Read error loop_file\n";
char msg_mop_err_wt_net_db [] = "Write of network database failed\n";
char msg_mop_wrn_pkt_late [] = "packet came too late\n";
char msg_mop_wrn_n_msg_in_slt [] = "No valid message in slot: %d\n";
char msg_mop_err_n_pre_msg [] = "Couldn't get a preallocated message\n";
char msg_mop_err_lp_to [] = "Mop loop message timed out from: %02x-%02x-%02x-%02x-%02x-%02x\n";
char msg_mop_err_lp_to1 [] = "*** List index: %d received count: %d expected count %d\n\n";
char msg_mop_det_msg_src [] = "Message source: ";
char msg_mop_err_rply_size [] = "Reply size isn't correct\n";
char msg_mop_det_mos_rps [] = "mo size %d reply size: %d\n";
char msg_mop_det_msg_n_vld [] = "Message entry not valid\n";
char msg_mop_err_b_src [] = "Source wasn't correct\n";
char msg_mop_err_b_index [] = "Index too large\n";
char msg_mop_inf_tgt_addr [] = "Target address: %02x-%02x-%02x-%02x-%02x-%02x\n";
char msg_mop_inf_hst_addr [] = "Host address: %02x-%02x-%02x-%02x-%02x-%02x\n\n";
char msg_moprc_err_rc_already_res [] = "Remote console already reserved.\n";
char msg_moprc_err_rc_n_res [] = "Remote console is not reserved\n";
char msg_moprc_inf_rc_rel [] = "\nRemote console released from: %02x-%02x-%02x-%02x-%02x-%02x\n";
char msg_moprc_err_rc_b_ver [] = "Incorrect remote console verification.\n";
char msg_moprc_inf_rc_res [] = "\nRemote console reserved from: %02x-%02x-%02x-%02x-%02x-%02x\n";
char msg_moprc_err_cd_kl_sh [] = "Couldn't kill RC shell.\n";
char msg_moplp_err_crc [] = "CRC error: rec: %d saved crc: %08x rcvd crc: %08x\n";
char msg_moplp_err_run [] = "loopback test already running on port %s\n";
char msg_mop_err_001 [] = "FDDI not supported\n";
char msg_net_001 [] = "Opening file: %s\n";
char msg_net_002 [] = "loading at address: %08x\n";
char msg_net_003 [] = "File not loaded.\n";
char msg_net_004 [] = "\nLoad complete!\n";
char msg_net_005 [] = "Image loaded at address: %08x\n";
char msg_net_006 [] = "Image size: %d\n";
char msg_net_007 [] = "Target Name: %s\n";
char msg_net_008 [] = "Target address: %02x-%02x-%02x-%02x-%02x-%02x\n";
char msg_net_009 [] = "Host name: %s\n";
char msg_net_010 [] = "Host address: %02x-%02x-%02x-%02x-%02x-%02x\n";
char msg_moprc_001 [] = "proc=%08X verif_h=%08X verif_l=%08X \n";
char msg_ea_err_n_io [] = "Couldn't find an io module in the system\n";
char msg_ea_inf_ti_ri [] = " TI: %d RI: %d\n";
char msg_vmem_rsvdreg [] = "Virtual address %08X is in the reserved region\n";
char msg_vmem_lenvio [] = "Length violation found while converting virtual address %08X\n";
char msg_vmem_ptenonsys [] = "Process Page Table Entry at %08X is not in system space\n";
char msg_vmem_invalpfn [] = "Invalid Page Table Entry for virtual address %08X\n";
char msg_vmem_accvio [] = "Access violation found for virtual address %08X\n";
char msg_vmem_devopenrderr [] = "Error opening pmem device for read access from vmem driver\n";
char msg_vmem_devopenwrerr [] = "Error opening pmem device for write access from vmem driver\n";
char msg_vmem_devseekerr [] = "Error seeking to physical address %08X from vmem driver\n";
char msg_why [] = "why not?\n";
char msg_wait_sem_err [] = "error: wait condition still true after semaphore %s has been posted!\n";
char msg_invl_inode [] = "inconsistency in %s_validate of inode entry\n";
char msg_invl_ddb [] = "inconsistency in %s_validate of ddb entry\n";
char msg_dmag_mis [] = "missing qualifier(s): %s\n";
char msg_dmag_inv [] = "%s : invalid dma command\n";
char msg_dmag_amb [] = "%s : ambiguous dma command\n";
char msg_dmag_ctx_open_fail [] = "error: cannot open dma_gen context file %s\n";
char msg_dmag_link_err [] = "warning -- dma_state %04X:\nno write buffer in linked dma_state %04X\n";
char msg_dmag_link_bc_err [] = "warning -- dma_state %04X:\nbyte count (%d) != byte count (%d) of linked state %04X\n";
char msg_dmag_link_ld_err [] = "warning -- dma_state %04X:\nlane_deselect (%02X) != lane_deselect (%02X) of linked state %04X\n";
char msg_dmag_insuff_pram [] = "warning - dma_state %04X:\ninsufficient packet ram available for a request of %d longwords\n";
char msg_dmag_insuff_data [] = "warning - dma_state %04X:\ndata for crc generation (%d bytes) < transaction byte_count (%d bytes)\n";
char msg_dmag_null_bc [] = "error: invalid beat_count (%d) - minimal beat_count for read transaction = 2 \n";
char msg_dma_mode [] = "dma in %s mode \n";
char msg_dma_inv_trans [] = "invalid transition : dma in %s mode \n";
char msg_dma_not_interactive [] = "dma not in INTERACTIVE mode\n";
char msg_dma_started [] = "dma started\n";
char msg_dma_already_started [] = "dma already started\n";
char msg_dma_stopped [] = "dma stopped\n";
char msg_dma_already_stopped [] = "dma already stopped\n";
char msg_fbe_master_disable [] = "invalid command while master disable\n";
char msg_hlt_hw [] = "operator initiated halt\n";
char msg_hlt_ksnv [] = "kernel stack not valid halt\n";
char msg_hlt_scbb [] = "invalid SCBB\n";
char msg_hlt_ptbr [] = "invalid PTBR\n";
char msg_hlt_sw [] = "HALT instruction executed\n";
char msg_hlt_dblerr [] = "double error halt\n";
char msg_hlt_pal_mchk [] = "machine check while in PAL mode\n";
char msg_cdp_nn_too_long [] = "warning -- Node Name should not exceed 6 characters\n";
char msg_cdp_nn_not_alpha [] = "warning -- Node Name should begin with A-Z\n";
char msg_cdp_nn_not_alnum [] = "warning -- Node Name should contain only A-Z and 0-9\n";
char msg_cdp_ac_value [] = "warning -- Allocation Class should be between 0 and 255\n";
char msg_cdp_un_value [] = "warning -- Unit Number should be between 0 and 4095\n";
char msg_cdp_no_write [] = "warning -- changes will not be saved\n";
char msg_sethost_not_supported [] = "target %s does not support SET HOST\n";
char msg_sethost_timeout [] = "remote host response timeout error\n";
char msg_no_device [] = "device %s not found\n";
char msg_missing_device [] = "device name or port name must be given\n";
char msg_dev_unsupported [] = "Device %s not supported\n";
char msg_pkz_timo [] = "%s: adapter / command timed out\n";
char msg_pkz_wrongstate [] = "%s: adapter is in the wrong state\n";
char msg_pkz_badreg [] = "%s: internal error - bad register code\n";
char msg_pkz_toobig [] = "%s: data transfer too big\n";
char msg_pkz_illopcode [] = "%s: illegal operation code\n";
char msg_pkz_badarg [] = "%s: bad argument to I/O call\n";
char msg_pkz_badcmd [] = "%s: illegal command packet\n";
char msg_pkz_nobuf [] = "%s: could not allocate command buffer\n";
char msg_pkz_rip [] = "%s: Adapter reset in progress\n";
char msg_fe_pgm_banner [] = "\t\t\tFEPROM UPDATE UTILITY\n";
char msg_fe_caution [] = "\t\t\t-----> CAUTION <-----\n";
char msg_fe_caution2 [] = "\tEXECUTING THIS PROGRAM WILL CHANGE YOUR CURRENT ROM!\n\n";
char msg_fe_pgm [] = "\t\t\tFEPROM UPDATE UTILITY\n\t\t\t-----> CAUTION <-----\n\tEXECUTING THIS PROGRAM WILL CHANGE YOUR CURRENT ROM!\n\n";
char msg_fe_areyousure [] = "Do you really want to continue [Y/N] ? : ";
char msg_noupdates [] = "No updates performed\n";
char msg_pleaseyesno [] = "Please answer yes or no\n";
char msg_diffsize [] = "The loaded image is not the same size (%d) as the target device (%d)\n";
char msg_conscheck [] = "Consistency checks failed, continuing anyway.\n";
char msg_goodupdate [] = "Update successful\n";
char msg_badupdate [] = "Update encountered errors\n";
char msg_fe_usr_abort [] = "\nUser aborted program\n\n";
char msg_fe_no_int [] = "\n\tDO NOT ATTEMPT TO INTERRUPT PROGRAM EXECUTION!\n";
char msg_fe_lose_opstate [] = "\tDOING SO MAY RESULT IN LOSS OF OPERABLE STATE.\n\n";
char msg_fe_sev_min [] = "The program will take at most several minutes.\n";
char msg_fe_prog_unipgm [] = "Starting uniform programming to 0's of block...\n\t";
char msg_fe_prog_erase [] = "Erasing block...\n\t";
char msg_fe_prog_reprog [] = "Programming block...\n\t";
char msg_fe_block_address [] = "%05x ";
char msg_fe_loop_count [] = "\n\tRepeat count (hex): %08x\n";
char msg_fe_wrong_sig [] = "Signatures incompatible. Expected sig: %s, Boot image sig: %s\n";
char msg_fe_pgm_success [] = "\nFEPROM update was successful!\n";
char msg_fe_too_big [] = "\nNew ROM image too big !\n";
char msg_fe_bad_chksum [] = "Bad Checksum in byte %d\n";
char msg_fe_unipgm_err [] = "\nROM uniform programming error\n";
char msg_fe_erase_err [] = "\nROM erase error (%d error count)\n";
char msg_fe_pgm_err [] = "\nROM programming error (%d error count)\n";
char msg_fe_spec_file [] = "must specify filename or target and version\n";
char msg_fe_bad_device [] = "\nfirmware upgrade for device %s is not supported\n";
char msg_fe_verify_err [] = "\nfirmware upgrade verify error\n";
char msg_fe_total_errs [] = "\nerror count : %d\n";
char msg_rb_err_fmt [] = "%s incorrect format (pp-vvvvvvvv-vvvvvvvv) - %s not modified\n";
char msg_rb_err_enbl [] = "%s rm boot message enable - %s not modified\n";
char msg_rb_err_pwd_fail [] = "error - %s rm boot password initialization failed!\n";
char msg_rb_err_pwd_init [] = "rm boot password is not initialized - %s not modified\n";
char msg_rb_err_fltr_init [] = "%s filter is not initialized - %s not modified\n";
char msg_rb_err_inv_fltr [] = "%s is in inverse filtering mode - %s not modified\n";
char msg_rb_err_pr_fltr [] = "%s is in promiscuous mode - %s not modified\n";
char msg_rb_inc_pwd [] = "incorrect password format (pp-vvvvvvvv-vvvvvvvv)\n";
char msg_not_swapped [] = "not all bytes swapped\n";
char msg_mop_inf_reply [] = "Loop Reply from: %02x-%02x-%02x-%02x-%02x-%02x\n";
char msg_ci_bad_path[] = "%s: CI failure on path %c failure to node %d\n";
char msg_ext_message [] = "";
char msg_input [] = "";
char msg_mod [] = "";
char msg_shell_nopipe [] = "";
char msg_in_len [] = "";
char msg_buf_cmp_err [] = "";
char msg_qscan_eol [] = "";
char msg_dma_in_use [] = "";
char msg_csr_in_use [] = "";
char msg_number [] = "";
char msg_iec [] = "";
char msg_queue_to [] = "";
char msg_out_offset [] = "";
char msg_imh [] = "";
char msg_in_offset [] = "";
char msg_ctrlc [] = "";
char msg_nl_ddb [] = "";
char msg_lt_brckt_expected [] = "";
char msg_ics [] = "";
char msg_loop [] = "";
char msg_node [] = "";
char msg_tmb [] = "";
char msg_scsi_retry [] = "";
char msg_exdep_badgpr [] = "";
char msg_mop_err_cd_kl_rc_t [] = "";
char msg_rem [] = "";
char msg_ilv_badsyntax [] = "";
char msg_exdep_devreaderr [] = "";
char msg_size [] = "";
char msg_wait_to [] = "";
char msg_dyn_poison [] = "";
char msg_rcvd [] = "";
char msg_destructive_prompt [] = "";
char msg_timeout [] = "";
char msg_read_err [] = "";
char msg_out_len [] = "";
char msg_bad_devicename [] = "";
char msg_nl_inode [] = "";
char msg_post_cnt [] = "";
char msg_hyphen_prefix [] = "";
char msg_halt [] = "";
char msg_lost_arb [] = "";
char msg_buf_size [] = "";
char msg_buf_cmp_ext [] = "";
char msg_ez_err_n_dev [] = "";
char msg_post [] = "";
char msg_cnt [] = "";
char msg_list [] = "";
char msg_null_terminated [] = "";
char msg_qscan_allocerr [] = "";
char msg_hyphen_suffix [] = "";
char msg_par_invnbr [] = "Invalid number\n";
char msg_par_itl [] = "Input too long\n";
char msg_par_keytl [] = "keyword too long\n";
char msg_par_limd [] = "Low limit = %d, High limit = %d\n";
char msg_par_limx [] = "Low limit = %x, High limit = %x\n";
char msg_par_nbror [] = "Number out of range\n";
char msg_par_nohelp [] = "No additional help available\n";
char msg_invalid_option [] = "Invalid command option\n";
char msg_invalid_cmd [] = "Invalid command\n";
char msg_illegal_cmd_syntx [] = "Illegal command syntax\n";
char msg_cmm_badram [] = "";
char msg_cmm_bad_bank [] = "";
char msg_cmm_skip [] = "";
char msg_cmm_start [] = "Starting Memory Diagnostics\n";
char msg_cmm_complete [] = "Memory Diagnostics completed\n";
char msg_cmm_brds_enab [] = "%d boards enabled\n";
char msg_cmm_diag_bypass [] = "Memory Diagnostics bypassed\n";
char msg_cmm_presto [] = "Prestoserve module in slot %d\n";
char msg_cmm_wrn_presto_valid [] = "* Warning * Prestoserve module NVRAM valid\n";
char msg_cmm_presto_clean [] = "Prestoserve module NVRAM not valid\n";
char msg_cmm_err_presto_batt [] = " NVRAM battery failure\n";
char msg_cmm_test_cmic [] = "Testing CMIC on Memory Module %x\n";
char msg_cmm_sbuff_off [] = "Turning off the stream buffers\n";
char msg_cmm_sbuff_on [] = "Turning on the stream buffers\n";
char msg_cmm_test_cmm_bank [] = "Testing Memory Module %x bank %x\n";
char msg_cmm_test_cmm_mb [] = "Testing 1st %dMB(s) on memory module %x\n";
char msg_cmm_test_cmm_para [] = "Testing all memory banks in parallel\n";
char msg_cmm_test_bank [] = "Testing Memory bank %x\n";
char msg_cmm_mem_size [] = "Memory size = %x\n";
char msg_cmm_config_mem_size [] = "Configured memory size = %x\n";
char msg_cmm_cons_lrgr_cache [] = "* Warning * Console image larger than Bcache\n";
char msg_cmm_mem_config_skip [] = "Memory Configuration skipped\n";
char msg_cmm_init_mem [] = "Initializing all available memory\n";
char msg_show_mem_hrd1 [] = "Module Size Base Addr Intlv Mode Intlv Unit\n";
char msg_show_mem_hrd2 [] = "------ ----- --------- ---------- ----------\n";
char msg_show_mem_frmt [] = " %d %3dMB %08x %d-Way %d\n";
char msg_show_mem_presto_frmt [] = " %d %3dMB %08x %d-way NVRAM";
char msg_presto_valid [] = " - valid\n";
char msg_presto_not_valid [] = " - not valid\n";
char msg_show_mem_brd_fail [] = " %d %3dMB Failed testing\n";
char msg_show_mem_presto_brd_fail [] = " %d %3dMB NVRAM Failed testing\n";
char msg_show_mem_brd_notconfig [] = " %d %3dMB Not Configured\n";
char msg_show_mem_presto_notconfig [] = " %d %3dMB NVRAM Not Configured\n";
char msg_show_mem_brd_not_inst [] = " %d Not Installed\n";
char msg_show_mem_sb_hrd1 [] = "Module Size Base Addr Intlv Mode Intlv Unit Status\n";
char msg_show_mem_sb_hrd2 [] = "------ ----- --------- ---------- ---------- ------\n";
char msg_show_mem_sb_frmt [] = " %d %3dMB %08x %d-Way %d ";
char msg_show_mem_sb_brd_fail [] = " %d %3dMB Failed\n";
char msg_show_mem_sb_brd_notconfig [] = " %d %3dMB Not Configured\n";
char msg_show_mem_sb_brd_not_inst [] = " %d Not Installed\n";
char msg_show_mem_bad_pages [] = "Total Bad Pages %d\n";
char msg_dram_err_exceed [] = "*** Error DRAM %d in bank %d on module %d exceeded threshold\n";
char msg_bank_err_exceed [] = "*** Error bank %d on module %d exceeded threshold\n";
char msg_brd_err_exceed [] = "*** Error module %d exceeded threshold\n";
char msg_cmm_err_banks_bad [] = "*** Error %d bad banks on module %d\n";
char msg_cmm_fail_num [] = "Failure Number: %d\n";
char msg_cmm_fail_brd [] = "Failing Board: %d\n";
char msg_cmm_fail_addr_offset [] = "Failing RAM Address Offset: %x\n";
char msg_cmm_fail_ram_num [] = "Failing RAM Number: ";
char msg_cmm_fail_dev_num [] = "Failing Device Number: ";
char msg_cmm_fail_bit_mask [] = "Failing Bitmask: %04b\n";
char msg_cmm_fail_err_flag [] = "Multi-bit Error Flag: %b\n";
char msg_cmm_fail_err_type [] = "Error Type %02b\n";
char msg_cmm_fail_edc_patt_num [] = "Pattern Number %d\n";
char msg_cmm_err_edc_data [] = "*** Error EDC data failure\n";
char msg_cmm_d_exp_rcd [] = "Expected value:%08x%08x Received value: %016x\n";
char msg_cmm_err_edc_latch [] = "*** Error %s latch data failure\n";
char msg_cmm_err_edc_int [] = "*** Error Interrupt failure\n";
char msg_no_file_slot [] = "";
char msg_mopdl_001 [] = "";
char msg_fbus_busy [] = "fbus busy\n";
char msg_sunday [] = "Sunday";
char msg_monday [] = "Monday";
char msg_tuesday [] = "Tuesday";
char msg_wednesday [] = "Wednesday";
char msg_thursday [] = "Thursday";
char msg_friday [] = "Friday";
char msg_saturday [] = "Saturday";
char msg_january [] = "January";
char msg_february [] = "February";
char msg_march [] = "March";
char msg_april [] = "April";
char msg_may [] = "May";
char msg_june [] = "June";
char msg_july [] = "July";
char msg_august [] = "August";
char msg_september [] = "September";
char msg_october [] = "October";
char msg_november [] = "November";
char msg_december [] = "December";
char msg_sz_mismatch [] = "Buffer counts differ - buf1:%d, buf2:%d, location:%x\n";
char msg_fbus_nxm [] = "non-existent F-bus address\n";
char msg_inv_param [] = "\nInvalid parameter specified\n";
char msg_devreaderr [] = "Error in read from device %s\n";
char msg_psc_statuserr [] = "\nPSC command status error status = %02x\n";
char msg_psc_eventlogh [] = "\nPSC Event Log\n";
char msg_psc_eventloge [] = "PSC Event %02x\n";
char msg_psc_statushead [] = "\nPSC Model %c%c%c%c%c-%c%c Version: %c%d.%d\n\n";
char msg_psc_powerstatus [] = "Power Status:\n";
char msg_psc_tempstatus [] = "Temperature Sensor: %m\n";
char msg_ok [] = "ok";
char msg_failed [] = "Failed";
char msg_psc_temp [] = "Temperature: ";
char msg_psc_greenz [] = "Green Zone\n";
char msg_psc_yellowz [] = "Yellow Zone\n";
char msg_psc_redz [] = "Red Zone\n";
char msg_psc_invalid_ev [] = "Invalid(%02x)\n";
char msg_psc_upsstatus [] = "\nUPS Status:\n";
char msg_psc_upspresent [] = "\nUPS%mpresent\n";
char msg_psc_upsavai [] = "\nUPS%mavailable\n";
char msg_psc_blank [] = " ";
char msg_psc_not [] = " not ";
char msg_psc_off [] = "off";
char msg_psc_on [] = "on";
char msg_psc_weak [] = "weak";
char msg_psc_upsonline [] = "\nUPS %m-line\n";
char msg_psc_upsonbatt [] = "\nUPS %m battery\n";
char msg_psc_upsbattery [] = "\nUPS battery %m\n";
char msg_psc_ldc_status [] = "\nLDC Status\n\n";
char msg_psc_notpresent [] = "Not Present\n";
char msg_psc_disabled [] = "Disabled\n";
char msg_psc_enabled [] = "Enabled\n";
char msg_psc_lastpwd [] = "\nLast Power Down Due to: ";
char msg_psc_acrmvd [] = "AC Power Removed\n";
char msg_psc_ocprqst [] = "OCP Requested DC Off\n";
char msg_psc_pcbrqst [] = "PCB Requested DC Off\n";
char msg_psc_hostrqst [] = "Host Requested power to be cycled\n";
char msg_psc_acinp [] = "AC input current out of bounds\n";
char msg_psc_unkncause [] = "Unknown Cause\n";
char msg_psc_parametric [] = "\nPSC PARAMETRIC Values\n";
char msg_psc_unknresp [] = "\nUnknown PSC Response Packet Received: %02x\n";
char msg_psc_2_1v [] = "2.1V\t\t";
char msg_psc_3_3v [] = "3.3V\t\t";
char msg_psc_5_1v [] = "5.1V\t\t";
char msg_psc_12_1v [] = "12.1V\t\t";
char msg_psc_fan_v [] = "Fan Voltage(V)\t";
char msg_psc_fan1_s [] = "FAN 1 Speed(RPM)";
char msg_psc_fan2_s [] = "FAN 2 Speed(RPM)";
char msg_psc_fan3_s [] = "FAN 3 Speed(RPM)";
char msg_psc_fan4_s [] = "FAN 4 Speed(RPM)";
char msg_psc_ldc [] = "LDC %c:\t";
char msg_fname_unknown [] = "Unknown Parameter Entered: %s\n";
char msg_fname_ununique [] = "Non-unique Parameter entered: %s\n";
char msg_scsi_up_err [] = "Upper SCSI Continuity Card Missing (connector J6)\n";
char msg_scsi_low_err [] = "Lower SCSI Continuity Card Missing (connector J7)\n";
char msg_toy_error [] = "TOY Clock Valid bit not set\n";
char msg_iic_bad_status [] = "\nIIC bus Status (%02x) error\n";
char msg_iic_bad_int_set [] = "\nInterrupt Set Failed";
char msg_iic_bus_timeout [] = "\nIIC Bus Busy Timeout\n";
char msg_iic_reg [] = "\nRegister: %s\n";
char msg_psc_parm_v [] = "%m\t%02d.%02d\n";
char msg_driver_stopped [] = "\n%m driver not enabled, use 'start -driver' or 'init' to enable\n";
char msg_no_auto_action [] = "\nHalt Button is IN, AUTO_ACTION ignored\n\n";
char msg_no_boot [] = "\nHalt Button is IN, BOOT NOT POSSIBLE\n\n";
char msg_boot_delay [] = "\nWaiting until most devices come online\n";
char msg_fbus_stmd_invld [] = "Invalid data width for partial transfer - use fbus_setmode first";
char msg_cnsl_secure [] = "Console is secure. Please login.\n";
char msg_invld_psswd [] = "Invalid password\n";
char msg_val_err [] = "Validation error\n";
char msg_psswd_len_err [] = "Password length must be between %d and %d characters\n";
char msg_curr_psswd_err[] = "Current password incorrect\n";
char msg_cmd_noparams[] = "Set Password does not allow parameters on the command line\n";
char msg_noboot_params[] = "Console is secure - parameters are not allowed.\n";
char msg_no_vldpsswd [] = "Secure not set. Please set the password.\n";
char msg_pwd_cleared [] = "Password successfully cleared.\n";
char msg_no_help [] = "You must login to the console to view help.\n";
char msg_pdq_msg1 [] = "%s PortControlCommand failed\n";
char msg_pdq_msg2 [] = "%s StateExpt = 4 StateRcv = %1x \n";
char msg_pdq_msg3 [] = "%s No available transmit descriptor\n";
char msg_pdq_msg4 [] = "%s pdq_fmc_descr_m_fsb_error Status: %x\n";
char msg_pdq_msg5 [] = "%s pdq_state_k_halted\n";
char msg_pdq_msg6 [] = "%s pollCmdRspQueue Failed\n";
char msg_pdq_msg7 [] = "Statuscharsget error: %s: Status: %x Cmd_Type: %x\n";
char msg_pdq_msg8 [] = "Charsset: %s rsp->header.status: %x\n";
char msg_pdq_msg9 [] = "CountersGet1 charsset: %s rsp->header.status\n";
char msg_pdq_msg10 [] = "%s rsp->header.status error\n";
char msg_pdq_msg11 [] = "%s pdq_state_k_link_unavail\n";
char msg_pdq_msg12 [] = "%s StateExpt = 3 StateRcv = %1x \n";
char msg_pdq_msg13 [] = "%s softreset Failed\n";
char msg_pdq_msg14 [] = "Port %s Not Started Yet\n";
char msg_pdq_msg15 [] = "%02X-%02X-%02X-%02X-%02X-%02X";
char msg_pdq_msg22 [] = "\t%x: \t%x\n";
char msg_pdq_msg70 [] = "%-24s %-8s %24s";
char msg_dsk_ex_begin [] = "Starting device exerciser on %s (id #%x) in READ-ONLY mode \n";
char msg_dsk_ex_begin_dest [] = "Starting device exerciser on %s (id #%x) in WRITE-READ mode\n";
char msg_dsk_ex_done [] = "Stopping device exerciser on %s (id #%x)\n";
|