1 /*- 2 * Copyright (c) 2000 Michael Smith 3 * Copyright (c) 2001 Scott Long 4 * Copyright (c) 2000 BSDi 5 * Copyright (c) 2001 Adaptec, Inc. 6 * All rights reserved. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 20 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 27 * SUCH DAMAGE. 28 * 29 * $FreeBSD$ 30 */ 31 32 /* 33 * Debugging support. 34 */ 35 36 #include <sys/param.h> 37 #include <sys/systm.h> 38 #include <sys/kernel.h> 39 40 #include <dev/aac/aac_compat.h> 41 #include <sys/bus.h> 42 #include <sys/devicestat.h> 43 #include <sys/disk.h> 44 45 #include <machine/resource.h> 46 #include <machine/bus.h> 47 48 #include <dev/aac/aacreg.h> 49 #include <dev/aac/aac_ioctl.h> 50 #include <dev/aac/aacvar.h> 51 52 #ifdef AAC_DEBUG 53 void aac_printstate0(void); 54 void aac_intr0(void); 55 56 /****************************************************************************** 57 * Dump the command queue indices 58 */ 59 void 60 aac_print_queues(struct aac_softc *sc) 61 { 62 device_printf(sc->aac_dev, "FIB queue header at %p queues at %p\n", 63 &sc->aac_queues->qt_qindex[AAC_HOST_NORM_CMD_QUEUE][0], 64 &sc->aac_queues->qt_HostNormCmdQueue[0]); 65 device_printf(sc->aac_dev, "HOST_NORM_CMD %d/%d (%d)\n", 66 sc->aac_queues->qt_qindex[AAC_HOST_NORM_CMD_QUEUE][AAC_PRODUCER_INDEX], 67 sc->aac_queues->qt_qindex[AAC_HOST_NORM_CMD_QUEUE][AAC_CONSUMER_INDEX], 68 AAC_HOST_NORM_CMD_ENTRIES); 69 device_printf(sc->aac_dev, "HOST_HIGH_CMD %d/%d (%d)\n", 70 sc->aac_queues->qt_qindex[AAC_HOST_HIGH_CMD_QUEUE][AAC_PRODUCER_INDEX], 71 sc->aac_queues->qt_qindex[AAC_HOST_HIGH_CMD_QUEUE][AAC_CONSUMER_INDEX], 72 AAC_HOST_HIGH_CMD_ENTRIES); 73 device_printf(sc->aac_dev, "ADAP_NORM_CMD %d/%d (%d)\n", 74 sc->aac_queues->qt_qindex[AAC_ADAP_NORM_CMD_QUEUE][AAC_PRODUCER_INDEX], 75 sc->aac_queues->qt_qindex[AAC_ADAP_NORM_CMD_QUEUE][AAC_CONSUMER_INDEX], 76 AAC_ADAP_NORM_CMD_ENTRIES); 77 device_printf(sc->aac_dev, "ADAP_HIGH_CMD %d/%d (%d)\n", 78 sc->aac_queues->qt_qindex[AAC_ADAP_HIGH_CMD_QUEUE][AAC_PRODUCER_INDEX], 79 sc->aac_queues->qt_qindex[AAC_ADAP_HIGH_CMD_QUEUE][AAC_CONSUMER_INDEX], 80 AAC_ADAP_HIGH_CMD_ENTRIES); 81 device_printf(sc->aac_dev, "HOST_NORM_RESP %d/%d (%d)\n", 82 sc->aac_queues->qt_qindex[AAC_HOST_NORM_RESP_QUEUE][AAC_PRODUCER_INDEX], 83 sc->aac_queues->qt_qindex[AAC_HOST_NORM_RESP_QUEUE][AAC_CONSUMER_INDEX], 84 AAC_HOST_NORM_RESP_ENTRIES); 85 device_printf(sc->aac_dev, "HOST_HIGH_RESP %d/%d (%d)\n", 86 sc->aac_queues->qt_qindex[AAC_HOST_HIGH_RESP_QUEUE][AAC_PRODUCER_INDEX], 87 sc->aac_queues->qt_qindex[AAC_HOST_HIGH_RESP_QUEUE][AAC_CONSUMER_INDEX], 88 AAC_HOST_HIGH_RESP_ENTRIES); 89 device_printf(sc->aac_dev, "ADAP_NORM_RESP %d/%d (%d)\n", 90 sc->aac_queues->qt_qindex[AAC_ADAP_NORM_RESP_QUEUE][AAC_PRODUCER_INDEX], 91 sc->aac_queues->qt_qindex[AAC_ADAP_NORM_RESP_QUEUE][AAC_CONSUMER_INDEX], 92 AAC_ADAP_NORM_RESP_ENTRIES); 93 device_printf(sc->aac_dev, "ADAP_HIGH_RESP %d/%d (%d)\n", 94 sc->aac_queues->qt_qindex[AAC_ADAP_HIGH_RESP_QUEUE][AAC_PRODUCER_INDEX], 95 sc->aac_queues->qt_qindex[AAC_ADAP_HIGH_RESP_QUEUE][AAC_CONSUMER_INDEX], 96 AAC_ADAP_HIGH_RESP_ENTRIES); 97 device_printf(sc->aac_dev, "AACQ_FREE %d/%d\n", 98 sc->aac_qstat[AACQ_FREE].q_length, sc->aac_qstat[AACQ_FREE].q_max); 99 device_printf(sc->aac_dev, "AACQ_BIO %d/%d\n", 100 sc->aac_qstat[AACQ_BIO].q_length, sc->aac_qstat[AACQ_BIO].q_max); 101 device_printf(sc->aac_dev, "AACQ_READY %d/%d\n", 102 sc->aac_qstat[AACQ_READY].q_length, sc->aac_qstat[AACQ_READY].q_max); 103 device_printf(sc->aac_dev, "AACQ_BUSY %d/%d\n", 104 sc->aac_qstat[AACQ_BUSY].q_length, sc->aac_qstat[AACQ_BUSY].q_max); 105 device_printf(sc->aac_dev, "AACQ_COMPLETE %d/%d\n", 106 sc->aac_qstat[AACQ_COMPLETE].q_length, 107 sc->aac_qstat[AACQ_COMPLETE].q_max); 108 } 109 110 /****************************************************************************** 111 * Print the command queue states for controller 0 (callable from DDB) 112 */ 113 void 114 aac_printstate0(void) 115 { 116 struct aac_softc *sc = devclass_get_softc(aac_devclass, 0); 117 118 aac_print_queues(sc); 119 switch (sc->aac_hwif) { 120 case AAC_HWIF_I960RX: 121 device_printf(sc->aac_dev, "IDBR 0x%08x IIMR 0x%08x IISR 0x%08x\n", 122 AAC_GETREG4(sc, AAC_RX_IDBR), AAC_GETREG4(sc, AAC_RX_IIMR), 123 AAC_GETREG4(sc, AAC_RX_IISR)); 124 device_printf(sc->aac_dev, "ODBR 0x%08x OIMR 0x%08x OISR 0x%08x\n", 125 AAC_GETREG4(sc, AAC_RX_ODBR), AAC_GETREG4(sc, AAC_RX_OIMR), 126 AAC_GETREG4(sc, AAC_RX_OISR)); 127 AAC_SETREG4(sc, AAC_RX_OIMR, 0/*~(AAC_DB_COMMAND_READY | 128 AAC_DB_RESPONSE_READY | AAC_DB_PRINTF)*/); 129 device_printf(sc->aac_dev, "ODBR 0x%08x OIMR 0x%08x OISR 0x%08x\n", 130 AAC_GETREG4(sc, AAC_RX_ODBR), AAC_GETREG4(sc, AAC_RX_OIMR), 131 AAC_GETREG4(sc, AAC_RX_OISR)); 132 break; 133 case AAC_HWIF_STRONGARM: 134 /* XXX implement */ 135 } 136 } 137 138 /****************************************************************************** 139 * simulate an interrupt for controller 0 140 */ 141 void 142 aac_intr0(void) 143 { 144 struct aac_softc *sc = devclass_get_softc(aac_devclass, 0); 145 146 aac_intr(sc); 147 } 148 149 /****************************************************************************** 150 * Panic in a slightly informative fashion 151 */ 152 void 153 aac_panic(struct aac_softc *sc, char *reason) 154 { 155 aac_print_queues(sc); 156 panic(reason); 157 } 158 159 /****************************************************************************** 160 * Print a FIB 161 */ 162 void 163 aac_print_fib(struct aac_softc *sc, struct aac_fib *fib, char *caller) 164 { 165 device_printf(sc->aac_dev, "%s: FIB @ %p\n", caller, fib); 166 device_printf(sc->aac_dev, " XferState %b\n", fib->Header.XferState, "\20" 167 "\1HOSTOWNED" 168 "\2ADAPTEROWNED" 169 "\3INITIALISED" 170 "\4EMPTY" 171 "\5FROMPOOL" 172 "\6FROMHOST" 173 "\7FROMADAP" 174 "\10REXPECTED" 175 "\11RNOTEXPECTED" 176 "\12DONEADAP" 177 "\13DONEHOST" 178 "\14HIGH" 179 "\15NORM" 180 "\16ASYNC" 181 "\17PAGEFILEIO" 182 "\20SHUTDOWN" 183 "\21LAZYWRITE" 184 "\22ADAPMICROFIB" 185 "\23BIOSFIB" 186 "\24FAST_RESPONSE" 187 "\25APIFIB\n"); 188 device_printf(sc->aac_dev, " Command %d\n", fib->Header.Command); 189 device_printf(sc->aac_dev, " StructType %d\n", 190 fib->Header.StructType); 191 device_printf(sc->aac_dev, " Flags 0x%x\n", fib->Header.Flags); 192 device_printf(sc->aac_dev, " Size %d\n", fib->Header.Size); 193 device_printf(sc->aac_dev, " SenderSize %d\n", 194 fib->Header.SenderSize); 195 device_printf(sc->aac_dev, " SenderAddress 0x%x\n", 196 fib->Header.SenderFibAddress); 197 device_printf(sc->aac_dev, " ReceiverAddress 0x%x\n", 198 fib->Header.ReceiverFibAddress); 199 device_printf(sc->aac_dev, " SenderData 0x%x\n", 200 fib->Header.SenderData); 201 switch(fib->Header.Command) { 202 case ContainerCommand: 203 { 204 struct aac_blockread *br = (struct aac_blockread *)fib->data; 205 struct aac_blockwrite *bw = (struct aac_blockwrite *)fib->data; 206 struct aac_sg_table *sg = NULL; 207 int i; 208 if (br->Command == VM_CtBlockRead) { 209 device_printf(sc->aac_dev, " BlockRead: container %d 0x%x/%d\n", 210 br->ContainerId, br->BlockNumber, br->ByteCount); 211 sg = &br->SgMap; 212 } 213 if (bw->Command == VM_CtBlockWrite) { 214 device_printf(sc->aac_dev, " BlockWrite: container %d 0x%x/%d " 215 "(%s)\n", bw->ContainerId, bw->BlockNumber, 216 bw->ByteCount, bw->Stable == CSTABLE ? "stable" : 217 "unstable"); 218 sg = &bw->SgMap; 219 } 220 if (sg != NULL) { 221 device_printf(sc->aac_dev, " %d s/g entries\n", sg->SgCount); 222 for (i = 0; i < sg->SgCount; i++) 223 device_printf(sc->aac_dev, " 0x%08x/%d\n", 224 sg->SgEntry[i].SgAddress, 225 sg->SgEntry[i].SgByteCount); 226 } 227 break; 228 } 229 default: 230 device_printf(sc->aac_dev, " %16D\n", fib->data, " "); 231 device_printf(sc->aac_dev, " %16D\n", fib->data + 16, " "); 232 break; 233 } 234 } 235 236 /****************************************************************************** 237 * Describe an AIF we have received. 238 */ 239 void 240 aac_print_aif(struct aac_softc *sc, struct aac_aif_command *aif) 241 { 242 switch(aif->command) { 243 case AifCmdEventNotify: 244 device_printf(sc->aac_dev, "EventNotify (%d)\n", aif->seqNumber); 245 switch(aif->data.EN.type) { 246 case AifEnGeneric: /* Generic notification */ 247 device_printf(sc->aac_dev, "(Generic) %.*s\n", 248 (int)sizeof(aif->data.EN.data.EG), 249 aif->data.EN.data.EG.text); 250 break; 251 case AifEnTaskComplete: /* Task has completed */ 252 device_printf(sc->aac_dev, "(TaskComplete)\n"); 253 break; 254 case AifEnConfigChange: /* Adapter configuration change 255 * occurred */ 256 device_printf(sc->aac_dev, "(ConfigChange)\n"); 257 break; 258 case AifEnContainerChange: /* Adapter specific container 259 * configuration change */ 260 device_printf(sc->aac_dev, "(ContainerChange) container %d,%d\n", 261 aif->data.EN.data.ECC.container[0], 262 aif->data.EN.data.ECC.container[1]); 263 break; 264 case AifEnDeviceFailure: /* SCSI device failed */ 265 device_printf(sc->aac_dev, "(DeviceFailure) handle %d\n", 266 aif->data.EN.data.EDF.deviceHandle); /* XXX 267 * interpret */ 268 break; 269 case AifEnMirrorFailover: /* Mirror failover started */ 270 device_printf(sc->aac_dev, "(MirrorFailover) container %d failed, " 271 "migrating from slice %d to %d\n", 272 aif->data.EN.data.EMF.container, 273 aif->data.EN.data.EMF.failedSlice, 274 aif->data.EN.data.EMF.creatingSlice); 275 break; 276 case AifEnContainerEvent: /* Significant container 277 * event */ 278 device_printf(sc->aac_dev, "(ContainerEvent) container %d event " 279 "%d\n", aif->data.EN.data.ECE.container, 280 aif->data.EN.data.ECE.eventType); /* XXX 281 * interpret? */ 282 break; 283 case AifEnFileSystemChange: /* File system changed */ 284 device_printf(sc->aac_dev, "(FileSystemChange)\n"); 285 break; 286 case AifEnConfigPause: /* Container pause event */ 287 device_printf(sc->aac_dev, "(ConfigPause)\n"); 288 break; 289 case AifEnConfigResume: /* Container resume event */ 290 device_printf(sc->aac_dev, "(ConfigResume)\n"); 291 break; 292 case AifEnFailoverChange: /* Failover space assignment 293 * changed */ 294 device_printf(sc->aac_dev, "(FailoverChange)\n"); 295 break; 296 case AifEnRAID5RebuildDone: /* RAID5 rebuild finished */ 297 device_printf(sc->aac_dev, "(RAID5RebuildDone)\n"); 298 break; 299 case AifEnEnclosureManagement: /* Enclosure management event */ 300 device_printf(sc->aac_dev, "(EnclosureManagement) EMPID %d unit %d " 301 "event %d\n", aif->data.EN.data.EEE.empID, 302 aif->data.EN.data.EEE.unitID, 303 aif->data.EN.data.EEE.eventType); 304 break; 305 case AifEnBatteryEvent: /* Significant NV battery 306 * event */ 307 device_printf(sc->aac_dev, "(BatteryEvent) %d (state was %d, " 308 "is %d\n", aif->data.EN.data.EBE.transition_type, 309 aif->data.EN.data.EBE.current_state, /* XXX */ 310 aif->data.EN.data.EBE.prior_state); /* interpret? */ 311 break; 312 case AifEnAddContainer: /* A new container was 313 * created. */ 314 device_printf(sc->aac_dev, "(AddContainer)\n"); 315 break; 316 case AifEnDeleteContainer: /* A container was deleted. */ 317 device_printf(sc->aac_dev, "(DeleteContainer)\n"); 318 break; 319 case AifEnBatteryNeedsRecond: /* The battery needs 320 * reconditioning */ 321 device_printf(sc->aac_dev, "(BatteryNeedsRecond)\n"); 322 break; 323 case AifEnClusterEvent: /* Some cluster event */ 324 device_printf(sc->aac_dev, "(ClusterEvent) event %d\n", 325 aif->data.EN.data.ECLE.eventType); 326 break; 327 case AifEnDiskSetEvent: /* A disk set event occured. */ 328 device_printf(sc->aac_dev, "(DiskSetEvent) event %d diskset %lld " 329 "creator %lld\n", aif->data.EN.data.EDS.eventType, 330 aif->data.EN.data.EDS.DsNum, 331 aif->data.EN.data.EDS.CreatorId); 332 break; 333 case AifDenMorphComplete: /* A morph operation 334 * completed */ 335 device_printf(sc->aac_dev, "(MorphComplete)\n"); 336 break; 337 case AifDenVolumeExtendComplete: /* A volume expand operation 338 * completed */ 339 device_printf(sc->aac_dev, "(VolumeExtendComplete)\n"); 340 break; 341 default: 342 device_printf(sc->aac_dev, "(%d)\n", aif->data.EN.type); 343 break; 344 } 345 break; 346 case AifCmdJobProgress: 347 { 348 char *status; 349 switch(aif->data.PR[0].status) { 350 case AifJobStsSuccess: 351 status = "success"; break; 352 case AifJobStsFinished: 353 status = "finished"; break; 354 case AifJobStsAborted: 355 status = "aborted"; break; 356 case AifJobStsFailed: 357 status = "failed"; break; 358 case AifJobStsSuspended: 359 status = "suspended"; break; 360 case AifJobStsRunning: 361 status = "running"; break; 362 default: 363 status = "unknown status"; break; 364 } 365 366 device_printf(sc->aac_dev, "JobProgress (%d) - %s (%d, %d)\n", 367 aif->seqNumber, status, aif->data.PR[0].currentTick, 368 aif->data.PR[0].finalTick); 369 switch(aif->data.PR[0].jd.type) { 370 case AifJobScsiZero: /* SCSI dev clear operation */ 371 device_printf(sc->aac_dev, "(ScsiZero) handle %d\n", 372 aif->data.PR[0].jd.client.scsi_dh); 373 break; 374 case AifJobScsiVerify: /* SCSI device Verify operation 375 * NO REPAIR */ 376 device_printf(sc->aac_dev, "(ScsiVerify) handle %d\n", 377 aif->data.PR[0].jd.client.scsi_dh); 378 break; 379 case AifJobScsiExercise: /* SCSI device Exercise 380 * operation */ 381 device_printf(sc->aac_dev, "(ScsiExercise) handle %d\n", 382 aif->data.PR[0].jd.client.scsi_dh); 383 break; 384 case AifJobScsiVerifyRepair: /* SCSI device Verify operation 385 * WITH repair */ 386 device_printf(sc->aac_dev, "(ScsiVerifyRepair) handle %d\n", 387 aif->data.PR[0].jd.client.scsi_dh); 388 break; 389 case AifJobCtrZero: /* Container clear operation */ 390 device_printf(sc->aac_dev, "(ConatainerZero) container %d\n", 391 aif->data.PR[0].jd.client.container.src); 392 break; 393 case AifJobCtrCopy: /* Container copy operation */ 394 device_printf(sc->aac_dev, "(ConatainerCopy) container %d to %d\n", 395 aif->data.PR[0].jd.client.container.src, 396 aif->data.PR[0].jd.client.container.dst); 397 break; 398 case AifJobCtrCreateMirror: /* Container Create Mirror 399 * operation */ 400 device_printf(sc->aac_dev, "(ConatainerCreateMirror) container " 401 "%d\n", aif->data.PR[0].jd.client.container.src); 402 /* XXX two containers? */ 403 break; 404 case AifJobCtrMergeMirror: /* Container Merge Mirror 405 * operation */ 406 device_printf(sc->aac_dev, "(ConatainerMergeMirror) container %d\n", 407 aif->data.PR[0].jd.client.container.src); 408 /* XXX two containers? */ 409 break; 410 case AifJobCtrScrubMirror: /* Container Scrub Mirror 411 * operation */ 412 device_printf(sc->aac_dev, "(ConatainerScrubMirror) container %d\n", 413 aif->data.PR[0].jd.client.container.src); 414 break; 415 case AifJobCtrRebuildRaid5: /* Container Rebuild Raid5 416 * operation */ 417 device_printf(sc->aac_dev, "(ConatainerRebuildRaid5) container " 418 "%d\n", aif->data.PR[0].jd.client.container.src); 419 break; 420 case AifJobCtrScrubRaid5: /* Container Scrub Raid5 421 * operation */ 422 device_printf(sc->aac_dev, "(ConatainerScrubRaid5) container %d\n", 423 aif->data.PR[0].jd.client.container.src); 424 break; 425 case AifJobCtrMorph: /* Container morph operation */ 426 device_printf(sc->aac_dev, "(ConatainerMorph) container %d\n", 427 aif->data.PR[0].jd.client.container.src); 428 /* XXX two containers? */ 429 break; 430 case AifJobCtrPartCopy: /* Container Partition copy 431 * operation */ 432 device_printf(sc->aac_dev, "(ConatainerPartCopy) container %d to " 433 "%d\n", aif->data.PR[0].jd.client.container.src, 434 aif->data.PR[0].jd.client.container.dst); 435 break; 436 case AifJobCtrRebuildMirror: /* Container Rebuild Mirror 437 * operation */ 438 device_printf(sc->aac_dev, "(ConatainerRebuildMirror) container " 439 "%d\n", aif->data.PR[0].jd.client.container.src); 440 break; 441 case AifJobCtrCrazyCache: /* crazy cache */ 442 device_printf(sc->aac_dev, "(ConatainerCrazyCache) container %d\n", 443 aif->data.PR[0].jd.client.container.src); 444 /* XXX two containers? */ 445 break; 446 case AifJobFsCreate: /* File System Create 447 * operation */ 448 device_printf(sc->aac_dev, "(FsCreate)\n"); 449 break; 450 case AifJobFsVerify: /* File System Verify 451 * operation */ 452 device_printf(sc->aac_dev, "(FsVerivy)\n"); 453 break; 454 case AifJobFsExtend: /* File System Extend 455 * operation */ 456 device_printf(sc->aac_dev, "(FsExtend)\n"); 457 break; 458 case AifJobApiFormatNTFS: /* Format a drive to NTFS */ 459 device_printf(sc->aac_dev, "(FormatNTFS)\n"); 460 break; 461 case AifJobApiFormatFAT: /* Format a drive to FAT */ 462 device_printf(sc->aac_dev, "(FormatFAT)\n"); 463 break; 464 case AifJobApiUpdateSnapshot: /* update the read/write half 465 * of a snapshot */ 466 device_printf(sc->aac_dev, "(UpdateSnapshot)\n"); 467 break; 468 case AifJobApiFormatFAT32: /* Format a drive to FAT32 */ 469 device_printf(sc->aac_dev, "(FormatFAT32)\n"); 470 break; 471 case AifJobCtlContinuousCtrVerify: /* Adapter operation */ 472 device_printf(sc->aac_dev, "(ContinuousCtrVerify)\n"); 473 break; 474 default: 475 device_printf(sc->aac_dev, "(%d)\n", aif->data.PR[0].jd.type); 476 break; 477 } 478 break; 479 } 480 case AifCmdAPIReport: 481 device_printf(sc->aac_dev, "APIReport (%d)\n", aif->seqNumber); 482 break; 483 case AifCmdDriverNotify: 484 device_printf(sc->aac_dev, "DriverNotify (%d)\n", aif->seqNumber); 485 break; 486 default: 487 device_printf(sc->aac_dev, "AIF %d (%d)\n", aif->command, 488 aif->seqNumber); 489 break; 490 } 491 } 492 #endif 493