root/dev/ic/aac.c

DEFINITIONS

1. aac_attach
2. aac_create_thread
3. aac_startup
4. aac_add_container
5. aac_free
6. aac_detach
7. aac_shutdown
8. aac_suspend
9. aac_resume
10. aac_intr
11. aac_startio
12. aac_map_command
13. aac_command_thread
14. aac_complete
15. aac_bio_command
16. aac_bio_complete
17. aac_wait_command
18. aac_alloc_command
19. aac_release_command
20. aac_alloc_commands
21. aac_free_commands
22. aac_map_command_sg
23. aac_unmap_command
24. aac_check_firmware
25. aac_init
26. aac_sync_command
27. aac_alloc_sync_fib
28. aac_release_sync_fib
29. aac_sync_fib
30. aac_enqueue_fib
31. aac_dequeue_fib
32. aac_enqueue_response
33. aac_command_timeout
34. aac_timeout
35. aac_sa_get_fwstatus
36. aac_rx_get_fwstatus
37. aac_fa_get_fwstatus
38. aac_rkt_get_fwstatus
39. aac_sa_qnotify
40. aac_rx_qnotify
41. aac_fa_qnotify
42. aac_rkt_qnotify
43. aac_sa_get_istatus
44. aac_rx_get_istatus
45. aac_fa_get_istatus
46. aac_rkt_get_istatus
47. aac_sa_clear_istatus
48. aac_rx_clear_istatus
49. aac_fa_clear_istatus
50. aac_rkt_clear_istatus
51. aac_sa_set_mailbox
52. aac_rx_set_mailbox
53. aac_fa_set_mailbox
54. aac_rkt_set_mailbox
55. aac_sa_get_mailbox
56. aac_rx_get_mailbox
57. aac_fa_get_mailbox
58. aac_rkt_get_mailbox
59. aac_sa_set_interrupts
60. aac_rx_set_interrupts
61. aac_fa_set_interrupts
62. aac_rkt_set_interrupts
63. aac_eval_mapping
64. aac_copy_internal_data
65. aac_internal_cache_cmd
66. aacminphys
67. aac_raw_scsi_cmd
68. aac_scsi_cmd
69. aac_describe_controller
70. aac_describe_code
71. aac_print_fib
72. aac_print_aif

    1 /*      $OpenBSD: aac.c,v 1.35 2007/03/20 10:30:32 mickey Exp $ */
    3 /*-
    4  * Copyright (c) 2000 Michael Smith
    5  * Copyright (c) 2001 Scott Long
    6  * Copyright (c) 2000 BSDi
    7  * Copyright (c) 2001 Adaptec, Inc.
    8  * Copyright (c) 2000 Niklas Hallqvist
    9  * Copyright (c) 2004 Nathan Binkert
   10  * All rights reserved.
   11  *
   12  * Redistribution and use in source and binary forms, with or without
   13  * modification, are permitted provided that the following conditions
   14  * are met:
   15  * 1. Redistributions of source code must retain the above copyright
   16  *    notice, this list of conditions and the following disclaimer.
   17  * 2. Redistributions in binary form must reproduce the above copyright
   18  *    notice, this list of conditions and the following disclaimer in the
   19  *    documentation and/or other materials provided with the distribution.
   20  *
   21  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
   22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
   25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   31  * SUCH DAMAGE.
   32  *
   33  *      $FreeBSD: /c/ncvs/src/sys/dev/aac/aac.c,v 1.1 2000/09/13 03:20:34 msmith Exp $
   34  */
   36 /*
   37  * Driver for the Adaptec 'FSA' family of PCI/SCSI RAID adapters.
   38  */
   40 /*
   41  * This driver would not have rewritten for OpenBSD if it was not for the
   42  * hardware donation from Nocom.  I want to thank them for their support.
   43  * Of course, credit should go to Mike Smith for the original work he did
   44  * in the FreeBSD driver where I found lots of reusable code and inspiration.
   45  * - Niklas Hallqvist
   46  */
   48 #include <sys/param.h>
   49 #include <sys/systm.h>
   50 #include <sys/buf.h>
   51 #include <sys/device.h>
   52 #include <sys/kernel.h>
   53 #include <sys/kthread.h>
   54 #include <sys/malloc.h>
   55 #include <sys/rwlock.h>
   56 #include <sys/time.h>
   58 #include <machine/bus.h>
   60 #include <uvm/uvm_extern.h>
   62 #include <scsi/scsi_all.h>
   63 #include <scsi/scsi_disk.h>
   64 #include <scsi/scsiconf.h>
   66 #include <dev/ic/aacreg.h>
   67 #include <dev/ic/aacvar.h>
   68 #include <dev/ic/aac_tables.h>
   70 /* Geometry constants. */
   71 #define AAC_MAXCYLS             1024
   72 #define AAC_HEADS               64
   73 #define AAC_SECS                32      /* mapping 64*32 */
   74 #define AAC_MEDHEADS            127
   75 #define AAC_MEDSECS             63      /* mapping 127*63 */
   76 #define AAC_BIGHEADS            255
   77 #define AAC_BIGSECS             63      /* mapping 255*63 */
   78 #define AAC_SECS32              0x1f    /* round capacity */
   80 struct scsi_xfer;
   82 void    aac_copy_internal_data(struct scsi_xfer *, u_int8_t *, size_t);
   83 char   *aac_describe_code(struct aac_code_lookup *, u_int32_t);
   84 void    aac_describe_controller(struct aac_softc *);
   85 int     aac_enqueue_fib(struct aac_softc *, int, struct aac_command *);
   86 int     aac_dequeue_fib(struct aac_softc *, int, u_int32_t *,
   87                         struct aac_fib **);
   88 int     aac_enqueue_response(struct aac_softc *sc, int queue,
   89                              struct aac_fib *fib);
   91 void    aac_eval_mapping(u_int32_t, int *, int *, int *);
   92 void    aac_print_printf(struct aac_softc *);
   93 int     aac_init(struct aac_softc *);
   94 int     aac_check_firmware(struct aac_softc *);
   95 void    aac_internal_cache_cmd(struct scsi_xfer *);
   97 /* Command Processing */
   98 void    aac_timeout(struct aac_softc *);
   99 void    aac_command_timeout(struct aac_command *);
  100 int     aac_map_command(struct aac_command *);
  101 void    aac_complete(void *);
  102 int     aac_bio_command(struct aac_softc *, struct aac_command **);
  103 void    aac_bio_complete(struct aac_command *);
  104 int     aac_wait_command(struct aac_command *, int);
  105 void    aac_create_thread(void *);
  106 void    aac_command_thread(void *);
  108 /* Command Buffer Management */
  109 void    aac_map_command_sg(void *, bus_dma_segment_t *, int, int);
  110 int     aac_alloc_commands(struct aac_softc *);
  111 void    aac_free_commands(struct aac_softc *);
  112 void    aac_unmap_command(struct aac_command *);
  114 int     aac_raw_scsi_cmd(struct scsi_xfer *);
  115 int     aac_scsi_cmd(struct scsi_xfer *);
  116 void    aac_startio(struct aac_softc *);
  117 void    aac_startup(struct aac_softc *);
  118 void    aac_add_container(struct aac_softc *, struct aac_mntinforesp *, int);
  119 void    aac_shutdown(void *);
  120 int     aac_sync_command(struct aac_softc *, u_int32_t, u_int32_t,
u_int32_t, u_int32_t, u_int32_t, u_int32_t *);
  123 struct cfdriver aac_cd = {
NULL, "aac", DV_DULL
  125 };
  127 struct scsi_adapter aac_switch = {
aac_scsi_cmd, aacminphys, 0, 0,
  129 };
  131 struct scsi_adapter aac_raw_switch = {
aac_raw_scsi_cmd, aacminphys, 0, 0,
  133 };
  135 struct scsi_device aac_dev = {
NULL, NULL, NULL, NULL
  137 };
  139 /* Falcon/PPC interface */
  140 int     aac_fa_get_fwstatus(struct aac_softc *);
  141 void    aac_fa_qnotify(struct aac_softc *, int);
  142 int     aac_fa_get_istatus(struct aac_softc *);
  143 void    aac_fa_clear_istatus(struct aac_softc *, int);
  144 void    aac_fa_set_mailbox(struct aac_softc *, u_int32_t, u_int32_t, u_int32_t,
u_int32_t, u_int32_t);
  146 int     aac_fa_get_mailbox(struct aac_softc *, int);
  147 void    aac_fa_set_interrupts(struct aac_softc *, int);
  149 struct aac_interface aac_fa_interface = {
aac_fa_get_fwstatus,
aac_fa_qnotify,
aac_fa_get_istatus,
aac_fa_clear_istatus,
aac_fa_set_mailbox,
aac_fa_get_mailbox,
aac_fa_set_interrupts
  157 };
  159 /* StrongARM interface */
  160 int     aac_sa_get_fwstatus(struct aac_softc *);
  161 void    aac_sa_qnotify(struct aac_softc *, int);
  162 int     aac_sa_get_istatus(struct aac_softc *);
  163 void    aac_sa_clear_istatus(struct aac_softc *, int);
  164 void    aac_sa_set_mailbox(struct aac_softc *, u_int32_t, u_int32_t,
u_int32_t, u_int32_t, u_int32_t);
  166 int     aac_sa_get_mailbox(struct aac_softc *, int);
  167 void    aac_sa_set_interrupts(struct aac_softc *, int);
  169 struct aac_interface aac_sa_interface = {
aac_sa_get_fwstatus,
aac_sa_qnotify,
aac_sa_get_istatus,
aac_sa_clear_istatus,
aac_sa_set_mailbox,
aac_sa_get_mailbox,
aac_sa_set_interrupts
  177 };
  179 /* i960Rx interface */    
  180 int     aac_rx_get_fwstatus(struct aac_softc *);
  181 void    aac_rx_qnotify(struct aac_softc *, int);
  182 int     aac_rx_get_istatus(struct aac_softc *);
  183 void    aac_rx_clear_istatus(struct aac_softc *, int);
  184 void    aac_rx_set_mailbox(struct aac_softc *, u_int32_t, u_int32_t,
u_int32_t, u_int32_t, u_int32_t);
  186 int     aac_rx_get_mailbox(struct aac_softc *, int);
  187 void    aac_rx_set_interrupts(struct aac_softc *, int);
  189 struct aac_interface aac_rx_interface = {
aac_rx_get_fwstatus,
aac_rx_qnotify,
aac_rx_get_istatus,
aac_rx_clear_istatus,
aac_rx_set_mailbox,
aac_rx_get_mailbox,
aac_rx_set_interrupts
  197 };
  199 /* Rocket/MIPS interface */     
  200 int     aac_rkt_get_fwstatus(struct aac_softc *);
  201 void    aac_rkt_qnotify(struct aac_softc *, int);
  202 int     aac_rkt_get_istatus(struct aac_softc *);
  203 void    aac_rkt_clear_istatus(struct aac_softc *, int);
  204 void    aac_rkt_set_mailbox(struct aac_softc *, u_int32_t,
u_int32_t, u_int32_t,
u_int32_t, u_int32_t);
  207 int     aac_rkt_get_mailbox(struct aac_softc *, int);
  208 void    aac_rkt_set_interrupts(struct aac_softc *, int);
  210 struct aac_interface aac_rkt_interface = {
aac_rkt_get_fwstatus,
aac_rkt_qnotify,
aac_rkt_get_istatus,
aac_rkt_clear_istatus,
aac_rkt_set_mailbox,
aac_rkt_get_mailbox,
aac_rkt_set_interrupts
  218 };
  220 #ifdef AAC_DEBUG
  221 int     aac_debug = AAC_DEBUG;
  222 #endif
  224 int
aac_attach(struct aac_softc *sc)
  226 {
  227         struct scsibus_attach_args saa;
  228         int error;
  230         /*
  231          * Initialise per-controller queues.
  232          */
aac_initq_free(sc);
aac_initq_ready(sc);
aac_initq_busy(sc);
aac_initq_bio(sc);
  238         /* disable interrupts before we enable anything */
AAC_MASK_INTERRUPTS(sc);
  241         /* mark controller as suspended until we get ourselves organised */
sc->aac_state |= AAC_STATE_SUSPEND;
  244         /*
  245          * Check that the firmware on the card is supported.
  246          */
error = aac_check_firmware(sc);
  248         if (error)
  249                 return (error);
  251         /*
  252          * Initialize locks
  253          */
AAC_LOCK_INIT(&sc->aac_sync_lock, "AAC sync FIB lock");
AAC_LOCK_INIT(&sc->aac_aifq_lock, "AAC AIF lock");
AAC_LOCK_INIT(&sc->aac_io_lock, "AAC I/O lock");
AAC_LOCK_INIT(&sc->aac_container_lock, "AAC container lock");
TAILQ_INIT(&sc->aac_container_tqh);
  260         /* Initialize the local AIF queue pointers */
sc->aac_aifq_head = sc->aac_aifq_tail = AAC_AIFQ_LENGTH;
  263         /*
  264          * Initialise the adapter.
  265          */
error = aac_init(sc);
  267         if (error)
  268                 return (error);
  270         /* Fill in the prototype scsi_link. */
sc->aac_link.adapter_softc = sc;
sc->aac_link.adapter = &aac_switch;
sc->aac_link.device = &aac_dev;
sc->aac_link.openings = (sc->total_fibs - 8) / 
  275             (sc->aac_container_count ? sc->aac_container_count : 1);
sc->aac_link.adapter_buswidth = AAC_MAX_CONTAINERS;
sc->aac_link.adapter_target = AAC_MAX_CONTAINERS;
bzero(&saa, sizeof(saa));
saa.saa_sc_link = &sc->aac_link;
config_found(&sc->aac_dev, &saa, scsiprint);
  284         /* Create the AIF thread */
sc->aifthread = 0;
sc->aifflags = 0;
kthread_create_deferred(aac_create_thread, sc);
  289 #if 0
  290         /* Register the shutdown method to only be called post-dump */
sc->aac_sdh = shutdownhook_establish(aac_shutdown, (void *)sc);
  292 #endif
  294         return (0);
  295 }
  297 void
aac_create_thread(void *arg)
  299 {
  300         struct aac_softc *sc = arg;
  302         if (kthread_create(aac_command_thread, sc, &sc->aifthread, "%s",
sc->aac_dev.dv_xname)) {
  304                 /* TODO disable aac */
printf("%s: failed to create kernel thread, disabled",
sc->aac_dev.dv_xname);
  307         }
AAC_DPRINTF(AAC_D_MISC, ("%s: aac_create_thread\n",
sc->aac_dev.dv_xname));
  311 }
  313 /*
  314  * Probe for containers, create disks.
  315  */
  316 void
aac_startup(struct aac_softc *sc)
  318 {
  319         struct aac_fib *fib;
  320         struct aac_mntinfo *mi;
  321         struct aac_mntinforesp *mir = NULL;
  322         int count = 0, i = 0;
aac_alloc_sync_fib(sc, &fib, 0);
mi = (struct aac_mntinfo *)&fib->data[0];
AAC_DPRINTF(AAC_D_MISC, ("%s: aac startup\n", sc->aac_dev.dv_xname));
sc->aac_container_count = 0;
  331         /* loop over possible containers */
  332         do {
  333                 /* request information on this container */
bzero(mi, sizeof(struct aac_mntinfo));
mi->Command = VM_NameServe;
mi->MntType = FT_FILESYS;
mi->MntCount = i;
  338                 if (aac_sync_fib(sc, ContainerCommand, 0, fib,
  339                                  sizeof(struct aac_mntinfo))) {
printf("%s: error probing container %d\n",
sc->aac_dev.dv_xname, i);
  342                         continue;
  343                 }
mir = (struct aac_mntinforesp *)&fib->data[0];
  346                 /* XXX Need to check if count changed */
count = mir->MntRespCount;
  349 #if 0
aac_add_container(sc, mir, 0);
  351 #else
  352                 /* 
  353                  * Check container volume type for validity.  Note
  354                  * that many of the possible types may never show up.
  355                  */
  356                 if (mir->Status == ST_OK && 
mir->MntTable[0].VolType != CT_NONE) {
  358                         int drv_cyls, drv_hds, drv_secs;
AAC_DPRINTF(AAC_D_MISC,
  361                             ("%s: %d: id %x  name '%.16s'  size %u  type %d\n",
sc->aac_dev.dv_xname, i,
mir->MntTable[0].ObjectId,
mir->MntTable[0].FileSystemName,
mir->MntTable[0].Capacity,
mir->MntTable[0].VolType));
sc->aac_container_count++;
sc->aac_hdr[i].hd_present = 1;
sc->aac_hdr[i].hd_size = mir->MntTable[0].Capacity;
  372                         /*
  373                          * Evaluate mapping (sectors per head, heads per cyl)
  374                          */
sc->aac_hdr[i].hd_size &= ~AAC_SECS32;
aac_eval_mapping(sc->aac_hdr[i].hd_size, &drv_cyls,
  377                                          &drv_hds, &drv_secs);
sc->aac_hdr[i].hd_heads = drv_hds;
sc->aac_hdr[i].hd_secs = drv_secs;
  380                         /* Round the size */
sc->aac_hdr[i].hd_size = drv_cyls * drv_hds * drv_secs;
sc->aac_hdr[i].hd_devtype = mir->MntTable[0].VolType;
  385                         /* XXX Save the name too for use in IDENTIFY later */
  386                 }
  387 #endif
i++;
  390         } while ((i < count) && (i < AAC_MAX_CONTAINERS));
aac_release_sync_fib(sc);
  394 #if 0
  395         /* poke the bus to actually attach the child devices */
  396         if (bus_generic_attach(sc->aac_dev))
printf("%s: bus_generic_attach failed\n",
sc->aac_dev.dv_xname);
  399 #endif
  402         /* mark the controller up */
sc->aac_state &= ~AAC_STATE_SUSPEND;
  405         /* enable interrupts now */
AAC_UNMASK_INTERRUPTS(sc);
  407 }
  409 #if 0
  410 /*
  411  * Create a device to respresent a new container
  412  */
  413 void
aac_add_container(struct aac_softc *sc, struct aac_mntinforesp *mir, int f)
  415 {
  416         struct aac_container *co;
device_t child;
  419         /* 
  420          * Check container volume type for validity.  Note that many of
  421          * the possible types may never show up.
  422          */
  423         if ((mir->Status == ST_OK) && (mir->MntTable[0].VolType != CT_NONE)) {
co = (struct aac_container *)malloc(sizeof *co, M_DEVBUF,
M_NOWAIT);
  426                 if (co == NULL)
panic("Out of memory?!\n");
bzero(co, sizeof *co);
AAC_DPRINTF(AAC_D_MISC,
  430                             ("%s: id %x  name '%.16s'  size %u  type %d\n", 
sc->aac_dev.dv_xname,
mir->MntTable[0].ObjectId,
mir->MntTable[0].FileSystemName,
mir->MntTable[0].Capacity,
mir->MntTable[0].VolType);
  437                 if ((child = device_add_child(sc->aac_dev, "aacd", -1)) == NULL)
printf("%s: device_add_child failed\n",
sc->aac_dev.dv_xname);
  440                 else
device_set_ivars(child, co);
device_set_desc(child, aac_describe_code(aac_container_types,
mir->MntTable[0].VolType));
co->co_disk = child;
co->co_found = f;
bcopy(&mir->MntTable[0], &co->co_mntobj,
  447                       sizeof(struct aac_mntobj));
AAC_LOCK_ACQUIRE(&sc->aac_container_lock);
TAILQ_INSERT_TAIL(&sc->aac_container_tqh, co, co_link);
AAC_LOCK_RELEASE(&sc->aac_container_lock);
  451         }
  452 }
  453 #endif
  455 #if 0
  456 /*
  457  * Free all of the resources associated with (sc)
  458  *
  459  * Should not be called if the controller is active.
  460  */
  461 void
aac_free(struct aac_softc *sc)
  463 {
debug_called(1);
  467         /* remove the control device */
  468         if (sc->aac_dev_t != NULL)
destroy_dev(sc->aac_dev_t);
  471         /* throw away any FIB buffers, discard the FIB DMA tag */
aac_free_commands(sc);
  473         if (sc->aac_fib_dmat)
bus_dma_tag_destroy(sc->aac_fib_dmat);
free(sc->aac_commands, M_AACBUF);
  478         /* destroy the common area */
  479         if (sc->aac_common) {
bus_dmamap_unload(sc->aac_common_dmat, sc->aac_common_dmamap);
bus_dmamem_free(sc->aac_common_dmat, sc->aac_common,
sc->aac_common_dmamap);
  483         }
  484         if (sc->aac_common_dmat)
bus_dma_tag_destroy(sc->aac_common_dmat);
  487         /* disconnect the interrupt handler */
  488         if (sc->aac_intr)
bus_teardown_intr(sc->aac_dev, sc->aac_irq, sc->aac_intr);
  490         if (sc->aac_irq != NULL)
bus_release_resource(sc->aac_dev, SYS_RES_IRQ, sc->aac_irq_rid,
sc->aac_irq);
  494         /* destroy data-transfer DMA tag */
  495         if (sc->aac_buffer_dmat)
bus_dma_tag_destroy(sc->aac_buffer_dmat);
  498         /* destroy the parent DMA tag */
  499         if (sc->aac_parent_dmat)
bus_dma_tag_destroy(sc->aac_parent_dmat);
  502         /* release the register window mapping */
  503         if (sc->aac_regs_resource != NULL)
bus_release_resource(sc->aac_dev, SYS_RES_MEMORY,
sc->aac_regs_rid, sc->aac_regs_resource);
  506 }
  508 /*
  509  * Disconnect from the controller completely, in preparation for unload.
  510  */
  511 int
  512 aac_detach(device_t dev)
  513 {
  514         struct aac_softc *sc;
  515         struct aac_container *co;
  516         struct aac_sim  *sim;
  517         int error;
debug_called(1);
sc = device_get_softc(dev);
  523         if (sc->aac_state & AAC_STATE_OPEN)
  524                 return(EBUSY);
  526         /* Remove the child containers */
  527         while ((co = TAILQ_FIRST(&sc->aac_container_tqh)) != NULL) {
error = device_delete_child(dev, co->co_disk);
  529                 if (error)
  530                         return (error);
TAILQ_REMOVE(&sc->aac_container_tqh, co, co_link);
free(co, M_AACBUF);
  533         }
  535         /* Remove the CAM SIMs */
  536         while ((sim = TAILQ_FIRST(&sc->aac_sim_tqh)) != NULL) {
TAILQ_REMOVE(&sc->aac_sim_tqh, sim, sim_link);
error = device_delete_child(dev, sim->sim_dev);
  539                 if (error)
  540                         return (error);
free(sim, M_AACBUF);
  542         }
  544         if (sc->aifflags & AAC_AIFFLAGS_RUNNING) {
sc->aifflags |= AAC_AIFFLAGS_EXIT;
wakeup(sc->aifthread);
tsleep(sc->aac_dev, PUSER | PCATCH, "aacdch", 30 * hz);
  548         }
  550         if (sc->aifflags & AAC_AIFFLAGS_RUNNING)
panic("Cannot shutdown AIF thread\n");
  553         if ((error = aac_shutdown(dev)))
  554                 return(error);
EVENTHANDLER_DEREGISTER(shutdown_final, sc->eh);
aac_free(sc);
  560         return(0);
  561 }
  563 /*
  564  * Bring the controller down to a dormant state and detach all child devices.
  565  *
  566  * This function is called before detach or system shutdown.
  567  *
  568  * Note that we can assume that the bioq on the controller is empty, as we won't
  569  * allow shutdown if any device is open.
  570  */
  571 int
aac_shutdown(device_t dev)
  573 {
  574         struct aac_softc *sc;
  575         struct aac_fib *fib;
  576         struct aac_close_command *cc;
debug_called(1);
sc = device_get_softc(dev);
sc->aac_state |= AAC_STATE_SUSPEND;
  584         /* 
  585          * Send a Container shutdown followed by a HostShutdown FIB to the
  586          * controller to convince it that we don't want to talk to it anymore.
  587          * We've been closed and all I/O completed already
  588          */
device_printf(sc->aac_dev, "shutting down controller...");
aac_alloc_sync_fib(sc, &fib, AAC_SYNC_LOCK_FORCE);
cc = (struct aac_close_command *)&fib->data[0];
bzero(cc, sizeof(struct aac_close_command));
cc->Command = VM_CloseAll;
cc->ContainerId = 0xffffffff;
  597         if (aac_sync_fib(sc, ContainerCommand, 0, fib,
  598             sizeof(struct aac_close_command)))
printf("FAILED.\n");
  600         else
printf("done\n");
  602         else {
fib->data[0] = 0;
  604                 /*
  605                  * XXX Issuing this command to the controller makes it
  606                  * shut down but also keeps it from coming back up
  607                  * without a reset of the PCI bus.  This is not
  608                  * desirable if you are just unloading the driver
  609                  * module with the intent to reload it later.
  610                  */
  611                 if (aac_sync_fib(sc, FsaHostShutdown, AAC_FIBSTATE_SHUTDOWN,
fib, 1)) {
printf("FAILED.\n");
  614                 } else {
printf("done.\n");
  616                 }
  617         }
AAC_MASK_INTERRUPTS(sc);
  621         return(0);
  622 }
  624 /*
  625  * Bring the controller to a quiescent state, ready for system suspend.
  626  */
  627 int
  628 aac_suspend(device_t dev)
  629 {
  630         struct aac_softc *sc;
debug_called(1);
sc = device_get_softc(dev);
sc->aac_state |= AAC_STATE_SUSPEND;
AAC_MASK_INTERRUPTS(sc);
  639         return(0);
  640 }
  642 /*
  643  * Bring the controller back to a state ready for operation.
  644  */
  645 int
  646 aac_resume(device_t dev)
  647 {
  648         struct aac_softc *sc;
debug_called(1);
sc = device_get_softc(dev);
sc->aac_state &= ~AAC_STATE_SUSPEND;
AAC_UNMASK_INTERRUPTS(sc);
  656         return(0);
  657 }
  658 #endif
  660 /*
  661  * Take an interrupt.
  662  */
  663 int
aac_intr(void *arg)
  665 {
  666         struct aac_softc *sc = arg;
u_int16_t reason;
  670         /*
  671          * Read the status register directly.  This is faster than taking the
  672          * driver lock and reading the queues directly.  It also saves having
  673          * to turn parts of the driver lock into a spin mutex, which would be
  674          * ugly.
  675          */
reason = AAC_GET_ISTATUS(sc);
AAC_CLEAR_ISTATUS(sc, reason);
  678         (void)AAC_GET_ISTATUS(sc);
  680         if (reason == 0)
  681                 return (0);
AAC_DPRINTF(AAC_D_INTR, ("%s: intr: sc=%p: reason=%#x\n",
sc->aac_dev.dv_xname, sc, reason));
  686         /* controller wants to talk to us */
  687         if (reason & (AAC_DB_PRINTF | AAC_DB_COMMAND_READY |
AAC_DB_RESPONSE_READY)) {
  690                 if (reason & AAC_DB_RESPONSE_READY) {
  691                         /* handle completion processing */
  692                         if (sc->aifflags & AAC_AIFFLAGS_RUNNING) {
sc->aifflags |= AAC_AIFFLAGS_COMPLETE;
  694                         } else {
AAC_LOCK_ACQUIRE(&sc->aac_io_lock);
aac_complete(sc);
AAC_LOCK_RELEASE(&sc->aac_io_lock);
  698                         }
  699                 }
  702                 /*
  703                  * XXX Make sure that we don't get fooled by strange messages
  704                  * that start with a NULL.
  705                  */
  706                 if (reason & AAC_DB_PRINTF)
  707                         if (sc->aac_common->ac_printf[0] == 0)
sc->aac_common->ac_printf[0] = 32;
  710                 /*
  711                  * This might miss doing the actual wakeup.  However, the
  712                  * msleep that this is waking up has a timeout, so it will
  713                  * wake up eventually.  AIFs and printfs are low enough
  714                  * priority that they can handle hanging out for a few seconds
  715                  * if needed.
  716                  */
  717                 if (sc->aifthread)
wakeup(sc->aifthread);
  720         }
  722         return (1);
  723 }
  725 /*
  726  * Command Processing
  727  */
  729 /*
  730  * Start as much queued I/O as possible on the controller
  731  */
  732 void
aac_startio(struct aac_softc *sc)
  734 {
  735         struct aac_command *cm;
AAC_DPRINTF(AAC_D_CMD, ("%s: start command", sc->aac_dev.dv_xname));
  739         if (sc->flags & AAC_QUEUE_FRZN) {
AAC_DPRINTF(AAC_D_CMD, (": queue frozen"));
  741                 return;
  742         }
AAC_DPRINTF(AAC_D_CMD, ("\n"));
  746         for (;;) {
  747                 /*
  748                  * Try to get a command that's been put off for lack of 
  749                  * resources
  750                  */
cm = aac_dequeue_ready(sc);
  753                 /*
  754                  * Try to build a command off the bio queue (ignore error 
  755                  * return)
  756                  */
  757                 if (cm == NULL) {
AAC_DPRINTF(AAC_D_CMD, ("\n"));
aac_bio_command(sc, &cm);
AAC_DPRINTF(AAC_D_CMD, ("%s: start done bio",
sc->aac_dev.dv_xname));
  762                 }
  764                 /* nothing to do? */
  765                 if (cm == NULL)
  766                         break;
  768                 /*
  769                  * Try to give the command to the controller.  Any error is
  770                  * catastrophic since it means that bus_dmamap_load() failed.
  771                  */
  772                 if (aac_map_command(cm) != 0)
panic("aac: error mapping command %p\n", cm);
AAC_DPRINTF(AAC_D_CMD, ("\n%s: another command",
sc->aac_dev.dv_xname));
  777         }
AAC_DPRINTF(AAC_D_CMD, ("\n"));
  780 }
  782 /*
  783  * Deliver a command to the controller; allocate controller resources at the
  784  * last moment when possible.
  785  */
  786 int
aac_map_command(struct aac_command *cm)
  788 {
  789         struct aac_softc *sc = cm->cm_sc;
  790         int error = 0;
AAC_DPRINTF(AAC_D_CMD, (": map command"));
  794         /* don't map more than once */
  795         if (cm->cm_flags & AAC_CMD_MAPPED)
panic("aac: command %p already mapped", cm);
  798         if (cm->cm_datalen != 0) {
error = bus_dmamap_load(sc->aac_dmat, cm->cm_datamap,
cm->cm_data, cm->cm_datalen, NULL,
BUS_DMA_NOWAIT);
  802                 if (error)
  803                         return (error);
aac_map_command_sg(cm, cm->cm_datamap->dm_segs,
cm->cm_datamap->dm_nsegs, 0);
  807         } else {
aac_map_command_sg(cm, NULL, 0, 0);
  809         }
  811         return (error);
  812 }
  814 /*
  815  * Handle notification of one or more FIBs coming from the controller.
  816  */
  817 void
aac_command_thread(void *arg)
  819 {
  820         struct aac_softc *sc = arg;
  821         struct aac_fib *fib;
u_int32_t fib_size;
  823         int size, retval;
AAC_DPRINTF(AAC_D_THREAD, ("%s: aac_command_thread: starting\n",
sc->aac_dev.dv_xname));
AAC_LOCK_ACQUIRE(&sc->aac_io_lock);
sc->aifflags = AAC_AIFFLAGS_RUNNING;
  830         while ((sc->aifflags & AAC_AIFFLAGS_EXIT) == 0) {
AAC_DPRINTF(AAC_D_THREAD,
  833                     ("%s: aac_command_thread: aifflags=%#x\n",
sc->aac_dev.dv_xname, sc->aifflags));
retval = 0;
  837                 if ((sc->aifflags & AAC_AIFFLAGS_PENDING) == 0) {
AAC_DPRINTF(AAC_D_THREAD,
  839                                     ("%s: command thread sleeping\n",
sc->aac_dev.dv_xname));
AAC_LOCK_RELEASE(&sc->aac_io_lock);
retval = tsleep(sc->aifthread, PRIBIO, "aifthd",
AAC_PERIODIC_INTERVAL * hz);
AAC_LOCK_ACQUIRE(&sc->aac_io_lock);
  845                 }
  847                 if ((sc->aifflags & AAC_AIFFLAGS_COMPLETE) != 0) {
aac_complete(sc);
sc->aifflags &= ~AAC_AIFFLAGS_COMPLETE;
  850                 }
  852                 /*
  853                  * While we're here, check to see if any commands are stuck.
  854                  * This is pretty low-priority, so it's ok if it doesn't
  855                  * always fire.
  856                  */
  857                 if (retval == EWOULDBLOCK)
aac_timeout(sc);
  860                 /* Check the hardware printf message buffer */
  861                 if (sc->aac_common->ac_printf[0] != 0)
aac_print_printf(sc);
  864                 /* Also check to see if the adapter has a command for us. */
  865                 while (aac_dequeue_fib(sc, AAC_HOST_NORM_CMD_QUEUE,
  866                                        &fib_size, &fib) == 0) {
AAC_PRINT_FIB(sc, fib);
  870                         switch (fib->Header.Command) {
  871                         case AifRequest:
  872                                 //aac_handle_aif(sc, fib);
  873                                 break;
  874                         default:
printf("%s: unknown command from controller\n",
sc->aac_dev.dv_xname);
  877                                 break;
  878                         }
  880                         if ((fib->Header.XferState == 0) ||
  881                             (fib->Header.StructType != AAC_FIBTYPE_TFIB))
  882                                 break;
  884                         /* Return the AIF to the controller. */
  885                         if (fib->Header.XferState & AAC_FIBSTATE_FROMADAP) {
fib->Header.XferState |= AAC_FIBSTATE_DONEHOST;
  887                                 *(AAC_FSAStatus*)fib->data = ST_OK;
  889                                 /* XXX Compute the Size field? */
size = fib->Header.Size;
  891                                 if (size > sizeof(struct aac_fib)) {
size = sizeof(struct aac_fib);
fib->Header.Size = size;
  894                                 }
  896                                 /*
  897                                  * Since we did not generate this command, it
  898                                  * cannot go through the normal
  899                                  * enqueue->startio chain.
  900                                  */
aac_enqueue_response(sc,
AAC_ADAP_NORM_RESP_QUEUE,
fib);
  904                         }
  905                 }
  906         }
sc->aifflags &= ~AAC_AIFFLAGS_RUNNING;
AAC_LOCK_RELEASE(&sc->aac_io_lock);
  910 #if 0
  911         /*
  912          * if we ever implement detach, we should have detach tsleep
  913          * to wait for this thread to finish
  914          */
wakeup(sc->aac_dev);
  916 #endif
AAC_DPRINTF(AAC_D_THREAD, ("%s: aac_command_thread: exiting\n",
sc->aac_dev.dv_xname));
kthread_exit(0);
  921 }
  923 /*
  924  * Process completed commands.
  925  */
  926 void
aac_complete(void *context)
  928 {
  929         struct aac_softc *sc = (struct aac_softc *)context;
  930         struct aac_command *cm;
  931         struct aac_fib *fib;
u_int32_t fib_size;
AAC_DPRINTF(AAC_D_CMD, ("%s: complete", sc->aac_dev.dv_xname));
  936         /* pull completed commands off the queue */
  937         for (;;) {
  938                 /* look for completed FIBs on our queue */
  939                 if (aac_dequeue_fib(sc, AAC_HOST_NORM_RESP_QUEUE, &fib_size,
  940                                     &fib))
  941                         break;  /* nothing to do */
  943                 /* get the command, unmap and hand off for processing */
cm = sc->aac_commands + fib->Header.SenderData;
  945                 if (cm == NULL) {
AAC_PRINT_FIB(sc, fib);
  947                         break;
  948                 }
aac_remove_busy(cm);
aac_unmap_command(cm);
cm->cm_flags |= AAC_CMD_COMPLETED;
  954                 /* is there a completion handler? */
  955                 if (cm->cm_complete != NULL) {
cm->cm_complete(cm);
  957                 } else {
  958                         /* assume that someone is sleeping on this command */
wakeup(cm);
  960                 }
  961         }
AAC_DPRINTF(AAC_D_CMD, ("\n"));
  964         /* see if we can start some more I/O */
sc->flags &= ~AAC_QUEUE_FRZN;
aac_startio(sc);
  967 }
  969 /*
  970  * Get a bio and build a command to go with it.
  971  */
  972 int
aac_bio_command(struct aac_softc *sc, struct aac_command **cmp)
  974 {
  975         struct aac_command *cm;
  976         struct aac_fib *fib;
  977         struct scsi_xfer *xs;
u_int8_t opcode = 0;
AAC_DPRINTF(AAC_D_CMD, ("%s: bio command", sc->aac_dev.dv_xname));
  982         /* get the resources we will need */
  983         if ((cm = aac_dequeue_bio(sc)) == NULL)
  984                 goto fail;
xs = cm->cm_private;
  987         /* build the FIB */
fib = cm->cm_fib;
fib->Header.Size = sizeof(struct aac_fib_header);
fib->Header.XferState =  
AAC_FIBSTATE_HOSTOWNED   | 
AAC_FIBSTATE_INITIALISED | 
AAC_FIBSTATE_EMPTY       | 
AAC_FIBSTATE_FROMHOST    |
AAC_FIBSTATE_REXPECTED   |
AAC_FIBSTATE_NORM        |
AAC_FIBSTATE_ASYNC       |
AAC_FIBSTATE_FAST_RESPONSE;
 1000         switch(xs->cmd->opcode) {
 1001         case READ_COMMAND:
 1002         case READ_BIG:
opcode = READ_COMMAND;
 1004                 break;
 1005         case WRITE_COMMAND:
 1006         case WRITE_BIG:
opcode = WRITE_COMMAND;
 1008                 break;
 1009         default:
panic("%s: invalid opcode %#x\n", sc->aac_dev.dv_xname,
xs->cmd->opcode);
 1012         }
 1014         /* build the read/write request */
 1015         if ((sc->flags & AAC_FLAGS_SG_64BIT) == 0) {
fib->Header.Command = ContainerCommand;
 1017                 if (opcode == READ_COMMAND) {
 1018                         struct aac_blockread *br;
br = (struct aac_blockread *)&fib->data[0];
br->Command = VM_CtBlockRead;
br->ContainerId = xs->sc_link->target;
br->BlockNumber = cm->cm_blkno;
br->ByteCount = cm->cm_bcount * AAC_BLOCK_SIZE;
fib->Header.Size += sizeof(struct aac_blockread);
cm->cm_sgtable = &br->SgMap;
cm->cm_flags |= AAC_CMD_DATAIN;
 1027                 } else {
 1028                         struct aac_blockwrite *bw;
bw = (struct aac_blockwrite *)&fib->data[0];
bw->Command = VM_CtBlockWrite;
bw->ContainerId = xs->sc_link->target;
bw->BlockNumber = cm->cm_blkno;
bw->ByteCount = cm->cm_bcount * AAC_BLOCK_SIZE;
bw->Stable = CUNSTABLE;
fib->Header.Size += sizeof(struct aac_blockwrite);
cm->cm_flags |= AAC_CMD_DATAOUT;
cm->cm_sgtable = &bw->SgMap;
 1038                 }
 1039         } else {
fib->Header.Command = ContainerCommand64;
 1041                 if (opcode == READ_COMMAND) {
 1042                         struct aac_blockread64 *br;
br = (struct aac_blockread64 *)&fib->data[0];
br->Command = VM_CtHostRead64;
br->ContainerId = xs->sc_link->target;
br->BlockNumber = cm->cm_blkno;
br->SectorCount = cm->cm_bcount;
br->Pad = 0;
br->Flags = 0;
fib->Header.Size += sizeof(struct aac_blockread64);
cm->cm_flags |= AAC_CMD_DATAOUT;
 1052                         (struct aac_sg_table64 *)cm->cm_sgtable = &br->SgMap64;
 1053                 } else {
 1054                         struct aac_blockwrite64 *bw;
bw = (struct aac_blockwrite64 *)&fib->data[0];
bw->Command = VM_CtHostWrite64;
bw->ContainerId = xs->sc_link->target;
bw->BlockNumber = cm->cm_blkno;
bw->SectorCount = cm->cm_bcount;
bw->Pad = 0;
bw->Flags = 0;
fib->Header.Size += sizeof(struct aac_blockwrite64);
cm->cm_flags |= AAC_CMD_DATAIN;
 1064                         (struct aac_sg_table64 *)cm->cm_sgtable = &bw->SgMap64;
 1065                 }
 1066         }
 1068         *cmp = cm;
AAC_DPRINTF(AAC_D_CMD, ("\n"));
 1070         return(0);
fail:
AAC_DPRINTF(AAC_D_CMD, ("\n"));
 1074         return(ENOMEM);
 1075 }
 1077 /*
 1078  * Handle a bio-instigated command that has been completed.
 1079  */
 1080 void
aac_bio_complete(struct aac_command *cm)
 1082 {
 1083         struct aac_blockread_response *brr;
 1084         struct aac_blockwrite_response *bwr;
 1085         struct scsi_xfer *xs = (struct scsi_xfer *)cm->cm_private;
AAC_FSAStatus status;
 1087         int s;
AAC_DPRINTF(AAC_D_CMD,
 1090                     ("%s: bio complete\n", cm->cm_sc->aac_dev.dv_xname));
 1092         /* fetch relevant status and then release the command */
 1093         if (xs->flags & SCSI_DATA_IN) {
brr = (struct aac_blockread_response *)&cm->cm_fib->data[0];
status = brr->Status;
 1096         } else {
bwr = (struct aac_blockwrite_response *)&cm->cm_fib->data[0];
status = bwr->Status;
 1099         }
s = splbio();
aac_release_command(cm);
xs->error = status == ST_OK? XS_NOERROR : XS_DRIVER_STUFFUP;
xs->resid = 0;
xs->flags |= ITSDONE;
scsi_done(xs);
splx(s);
 1109 }
 1111 /*
 1112  * Submit a command to the controller, return when it completes.
 1113  * XXX This is very dangerous!  If the card has gone out to lunch, we could
 1114  *     be stuck here forever.  At the same time, signals are not caught
 1115  *     because there is a risk that a signal could wakeup the tsleep before
 1116  *     the card has a chance to complete the command.  The passed in timeout
 1117  *     is ignored for the same reason.  Since there is no way to cancel a
 1118  *     command in progress, we should probably create a 'dead' queue where
 1119  *     commands go that have been interrupted/timed-out/etc, that keeps them
 1120  *     out of the free pool.  That way, if the card is just slow, it won't
 1121  *     spam the memory of a command that has been recycled.
 1122  */
 1123 int
aac_wait_command(struct aac_command *cm, int timeout)
 1125 {
 1126         struct aac_softc *sc = cm->cm_sc;
 1127         int error = 0;
AAC_DPRINTF(AAC_D_CMD, (": wait for command"));
 1131         /* Put the command on the ready queue and get things going */
cm->cm_queue = AAC_ADAP_NORM_CMD_QUEUE;
aac_enqueue_ready(cm);
AAC_DPRINTF(AAC_D_CMD, ("\n"));
aac_startio(sc);
 1136         while (!(cm->cm_flags & AAC_CMD_COMPLETED) && (error != EWOULDBLOCK)) {
AAC_DPRINTF(AAC_D_MISC, ("%s: sleeping until command done\n",
sc->aac_dev.dv_xname));
AAC_LOCK_RELEASE(&sc->aac_io_lock);
error = tsleep(cm, PRIBIO, "aacwait", timeout);
AAC_LOCK_ACQUIRE(&sc->aac_io_lock);
 1142         }
 1143         return (error);
 1144 }
 1146 /*
 1147  *Command Buffer Management
 1148  */
 1150 /*
 1151  * Allocate a command.
 1152  */
 1153 int
aac_alloc_command(struct aac_softc *sc, struct aac_command **cmp)
 1155 {
 1156         struct aac_command *cm;
AAC_DPRINTF(AAC_D_CMD, (": allocate command"));
 1159         if ((cm = aac_dequeue_free(sc)) == NULL) {
AAC_DPRINTF(AAC_D_CMD, (" failed"));
 1161                 return (EBUSY);
 1162         }
 1164         *cmp = cm;
 1165         return(0);
 1166 }
 1168 /*
 1169  * Release a command back to the freelist.
 1170  */
 1171 void
aac_release_command(struct aac_command *cm)
 1173 {
AAC_DPRINTF(AAC_D_CMD, (": release command"));
 1176         /* (re)initialise the command/FIB */
cm->cm_sgtable = NULL;
cm->cm_flags = 0;
cm->cm_complete = NULL;
cm->cm_private = NULL;
cm->cm_fib->Header.XferState = AAC_FIBSTATE_EMPTY;
cm->cm_fib->Header.StructType = AAC_FIBTYPE_TFIB;
cm->cm_fib->Header.Flags = 0;
cm->cm_fib->Header.SenderSize = sizeof(struct aac_fib);
 1186         /* 
 1187          * These are duplicated in aac_start to cover the case where an
 1188          * intermediate stage may have destroyed them.  They're left
 1189          * initialised here for debugging purposes only.
 1190          */
cm->cm_fib->Header.ReceiverFibAddress = (u_int32_t)cm->cm_fibphys;
cm->cm_fib->Header.SenderData = 0;
aac_enqueue_free(cm);
 1195 }
 1197 /*
 1198  * Allocate and initialise commands/FIBs for this adapter.
 1199  */
 1200 int
aac_alloc_commands(struct aac_softc *sc)
 1202 {
 1203         struct aac_command *cm;
 1204         struct aac_fibmap *fm;
 1205         int i, error;
 1207         if (sc->total_fibs + AAC_FIB_COUNT > sc->aac_max_fibs)
 1208                 return (ENOMEM);
fm = malloc(sizeof(struct aac_fibmap), M_DEVBUF, M_NOWAIT);
 1211         if (fm == NULL)
 1212                 goto exit;
bzero(fm, sizeof(struct aac_fibmap));
 1215         /* allocate the FIBs in DMAable memory and load them */
 1216         if (bus_dmamem_alloc(sc->aac_dmat, AAC_FIBMAP_SIZE, PAGE_SIZE, 0,
 1217             &fm->aac_seg, 1, &fm->aac_nsegs, BUS_DMA_NOWAIT)) {
printf("%s: can't alloc FIBs\n", sc->aac_dev.dv_xname);
error = ENOBUFS;
 1220                 goto exit_alloc;
 1221         }
 1223         if (bus_dmamem_map(sc->aac_dmat, &fm->aac_seg, 1,
AAC_FIBMAP_SIZE, (caddr_t *)&fm->aac_fibs, BUS_DMA_NOWAIT)) {
printf("%s: can't map FIB structure\n", sc->aac_dev.dv_xname);
error = ENOBUFS;
 1227                 goto exit_map;
 1228         }
 1230         if (bus_dmamap_create(sc->aac_dmat, AAC_FIBMAP_SIZE, 1,
AAC_FIBMAP_SIZE, 0, BUS_DMA_NOWAIT, &fm->aac_fibmap)) {
printf("%s: can't create dma map\n", sc->aac_dev.dv_xname);
error = ENOBUFS;
 1234                 goto exit_create;
 1235         }
 1237         if (bus_dmamap_load(sc->aac_dmat, fm->aac_fibmap, fm->aac_fibs, 
AAC_FIBMAP_SIZE, NULL, BUS_DMA_NOWAIT)) {
printf("%s: can't load dma map\n", sc->aac_dev.dv_xname);
error = ENOBUFS;
 1241                 goto exit_load;
 1242         }
 1244         /* initialise constant fields in the command structure */
AAC_LOCK_ACQUIRE(&sc->aac_io_lock);
bzero(fm->aac_fibs, AAC_FIB_COUNT * sizeof(struct aac_fib));
 1247         for (i = 0; i < AAC_FIB_COUNT; i++) {
cm = sc->aac_commands + sc->total_fibs;
fm->aac_commands = cm;
cm->cm_sc = sc;
cm->cm_fib = fm->aac_fibs + i;
cm->cm_fibphys = fm->aac_fibmap->dm_segs[0].ds_addr +
 1253                         (i * sizeof(struct aac_fib));
cm->cm_index = sc->total_fibs;
 1256                 if (bus_dmamap_create(sc->aac_dmat, MAXBSIZE, AAC_MAXSGENTRIES,
MAXBSIZE, 0, BUS_DMA_NOWAIT, &cm->cm_datamap)) {
 1258                         break;
 1259                 }
aac_release_command(cm);
sc->total_fibs++;
 1262         }
 1264         if (i > 0) {
TAILQ_INSERT_TAIL(&sc->aac_fibmap_tqh, fm, fm_link);
AAC_DPRINTF(AAC_D_MISC, ("%s: total_fibs= %d\n",
sc->aac_dev.dv_xname,
sc->total_fibs));
AAC_LOCK_RELEASE(&sc->aac_io_lock);
 1270                 return (0);
 1271         } 
exit_load:
bus_dmamap_destroy(sc->aac_dmat, fm->aac_fibmap);
exit_create:
bus_dmamem_unmap(sc->aac_dmat, (caddr_t)fm->aac_fibs, AAC_FIBMAP_SIZE);
exit_map:
bus_dmamem_free(sc->aac_dmat, &fm->aac_seg, fm->aac_nsegs);
exit_alloc:
free(fm, M_DEVBUF);
exit:
AAC_LOCK_RELEASE(&sc->aac_io_lock);
 1283         return (error);
 1284 }
 1286 /*
 1287  * Free FIBs owned by this adapter.
 1288  */
 1289 void
aac_free_commands(struct aac_softc *sc)
 1291 {
 1292         struct aac_fibmap *fm;
 1293         struct aac_command *cm;
 1294         int i;
 1296         while ((fm = TAILQ_FIRST(&sc->aac_fibmap_tqh)) != NULL) {
TAILQ_REMOVE(&sc->aac_fibmap_tqh, fm, fm_link);
 1300                 /*
 1301                  * We check against total_fibs to handle partially
 1302                  * allocated blocks.
 1303                  */
 1304                 for (i = 0; i < AAC_FIB_COUNT && sc->total_fibs--; i++) {
cm = fm->aac_commands + i;
bus_dmamap_destroy(sc->aac_dmat, cm->cm_datamap);
 1307                 }
bus_dmamap_unload(sc->aac_dmat, fm->aac_fibmap);
bus_dmamap_destroy(sc->aac_dmat, fm->aac_fibmap);
bus_dmamem_unmap(sc->aac_dmat, (caddr_t)fm->aac_fibs,
AAC_FIBMAP_SIZE);
bus_dmamem_free(sc->aac_dmat, &fm->aac_seg, fm->aac_nsegs);
free(fm, M_DEVBUF);
 1315         }
 1316 }
 1319 /*
 1320  * Command-mapping helper function - populate this command's s/g table.
 1321  */
 1322 void
aac_map_command_sg(void *arg, bus_dma_segment_t *segs, int nseg, int error)
 1324 {
 1325         struct aac_command *cm = arg;
 1326         struct aac_softc *sc = cm->cm_sc;
 1327         struct aac_fib *fib = cm->cm_fib;
 1328         int i;
 1330         /* copy into the FIB */
 1331         if (cm->cm_sgtable != NULL) {
 1332                 if ((cm->cm_sc->flags & AAC_FLAGS_SG_64BIT) == 0) {
 1333                         struct aac_sg_table *sg = cm->cm_sgtable;
sg->SgCount = nseg;
 1335                         for (i = 0; i < nseg; i++) {
sg->SgEntry[i].SgAddress = segs[i].ds_addr;
sg->SgEntry[i].SgByteCount = segs[i].ds_len;
 1338                         }
 1339                         /* update the FIB size for the s/g count */
fib->Header.Size += nseg * sizeof(struct aac_sg_entry);
 1341                 } else {
 1342                         struct aac_sg_table64 *sg;
sg = (struct aac_sg_table64 *)cm->cm_sgtable;
sg->SgCount = nseg;
 1345                         for (i = 0; i < nseg; i++) {
sg->SgEntry64[i].SgAddress = segs[i].ds_addr;
sg->SgEntry64[i].SgByteCount = segs[i].ds_len;
 1348                         }
 1349                         /* update the FIB size for the s/g count */
fib->Header.Size += nseg*sizeof(struct aac_sg_entry64);
 1351                 }
 1352         }
 1354         /* Fix up the address values in the FIB.  Use the command array index
 1355          * instead of a pointer since these fields are only 32 bits.  Shift
 1356          * the SenderFibAddress over to make room for the fast response bit.
 1357          */
cm->cm_fib->Header.SenderFibAddress = (cm->cm_index << 1);
cm->cm_fib->Header.ReceiverFibAddress = cm->cm_fibphys;
 1361         /* save a pointer to the command for speedy reverse-lookup */
cm->cm_fib->Header.SenderData = cm->cm_index;
 1364         if (cm->cm_flags & AAC_CMD_DATAIN)
bus_dmamap_sync(sc->aac_dmat, cm->cm_datamap, 0,
cm->cm_datamap->dm_mapsize,
BUS_DMASYNC_PREREAD);
 1368         if (cm->cm_flags & AAC_CMD_DATAOUT)
bus_dmamap_sync(sc->aac_dmat, cm->cm_datamap, 0,
cm->cm_datamap->dm_mapsize,
BUS_DMASYNC_PREWRITE);
cm->cm_flags |= AAC_CMD_MAPPED;
 1374         /* put the FIB on the outbound queue */
 1375         if (aac_enqueue_fib(sc, cm->cm_queue, cm) == EBUSY) {
aac_remove_busy(cm);
aac_unmap_command(cm);
aac_requeue_ready(cm);
 1379         }
 1380 }
 1382 /*
 1383  * Unmap a command from controller-visible space.
 1384  */
 1385 void
aac_unmap_command(struct aac_command *cm)
 1387 {
 1388         struct aac_softc *sc = cm->cm_sc;
 1390         if (!(cm->cm_flags & AAC_CMD_MAPPED))
 1391                 return;
 1393         if (cm->cm_datalen != 0) {
 1394                 if (cm->cm_flags & AAC_CMD_DATAIN)
bus_dmamap_sync(sc->aac_dmat, cm->cm_datamap, 0,
cm->cm_datamap->dm_mapsize,
BUS_DMASYNC_POSTREAD);
 1398                 if (cm->cm_flags & AAC_CMD_DATAOUT)
bus_dmamap_sync(sc->aac_dmat, cm->cm_datamap, 0,
cm->cm_datamap->dm_mapsize,
BUS_DMASYNC_POSTWRITE);
bus_dmamap_unload(sc->aac_dmat, cm->cm_datamap);
 1404         }
cm->cm_flags &= ~AAC_CMD_MAPPED;
 1406 }
 1408 /*
 1409  * Hardware Interface
 1410  */
 1412 /*
 1413  * Initialise the adapter.
 1414  */
 1415 int
aac_check_firmware(struct aac_softc *sc)
 1417 {
u_int32_t major, minor, options;
 1420         /*
 1421          * Retrieve the firmware version numbers.  Dell PERC2/QC cards with
 1422          * firmware version 1.x are not compatible with this driver.
 1423          */
 1424         if (sc->flags & AAC_FLAGS_PERC2QC) {
 1425                 if (aac_sync_command(sc, AAC_MONKER_GETKERNVER, 0, 0, 0, 0,
NULL)) {
printf("%s: Error reading firmware version\n",
sc->aac_dev.dv_xname);
 1429                         return (EIO);
 1430                 }
 1432                 /* These numbers are stored as ASCII! */
major = (AAC_GET_MAILBOX(sc, 1) & 0xff) - 0x30;
minor = (AAC_GET_MAILBOX(sc, 2) & 0xff) - 0x30;
 1435                 if (major == 1) {
printf("%s: Firmware version %d.%d is not supported\n",
sc->aac_dev.dv_xname, major, minor);
 1438                         return (EINVAL);
 1439                 }
 1440         }
 1442         /*
 1443          * Retrieve the capabilities/supported options word so we know what
 1444          * work-arounds to enable.
 1445          */
 1446         if (aac_sync_command(sc, AAC_MONKER_GETINFO, 0, 0, 0, 0, NULL)) {
printf("%s: RequestAdapterInfo failed\n",
sc->aac_dev.dv_xname);
 1449                 return (EIO);
 1450         }
options = AAC_GET_MAILBOX(sc, 1);
sc->supported_options = options;
 1454         if ((options & AAC_SUPPORTED_4GB_WINDOW) != 0 &&
 1455             (sc->flags & AAC_FLAGS_NO4GB) == 0)
sc->flags |= AAC_FLAGS_4GB_WINDOW;
 1457         if (options & AAC_SUPPORTED_NONDASD)
sc->flags |= AAC_FLAGS_ENABLE_CAM;
 1459         if ((options & AAC_SUPPORTED_SGMAP_HOST64) != 0
 1460              && (sizeof(bus_addr_t) > 4)) {
printf("%s: Enabling 64-bit address support\n",
sc->aac_dev.dv_xname);
sc->flags |= AAC_FLAGS_SG_64BIT;
 1464         }
 1466         /* Check for broken hardware that does a lower number of commands */
 1467         if ((sc->flags & AAC_FLAGS_256FIBS) == 0)
sc->aac_max_fibs = AAC_MAX_FIBS;
 1469         else
sc->aac_max_fibs = 256;
 1472         return (0);
 1473 }
 1475 int
aac_init(struct aac_softc *sc)
 1477 {
bus_dma_segment_t seg;
 1479         int nsegs;
 1480         int i, error;
 1481         int state = 0;
 1482         struct aac_adapter_init *ip;
time_t then;
u_int32_t code, qoffset;
 1486         /*
 1487          * First wait for the adapter to come ready.
 1488          */
then = time_uptime;
 1490         for (i = 0; i < AAC_BOOT_TIMEOUT * 1000; i++) {
code = AAC_GET_FWSTATUS(sc);
 1492                 if (code & AAC_SELF_TEST_FAILED) {
printf("%s: FATAL: selftest failed\n",
sc->aac_dev.dv_xname);
 1495                         return (ENXIO);
 1496                 }
 1497                 if (code & AAC_KERNEL_PANIC) {
printf("%s: FATAL: controller kernel panic\n",
sc->aac_dev.dv_xname);
 1500                         return (ENXIO);
 1501                 }
 1502                 if (code & AAC_UP_AND_RUNNING)
 1503                         break;
DELAY(1000);
 1505         }
 1506         if (i == AAC_BOOT_TIMEOUT * 1000) {
printf("%s: FATAL: controller not coming ready, status %x\n",
sc->aac_dev.dv_xname, code);
 1509                 return (ENXIO);
 1510         }
 1512         /*
 1513          * Work around a bug in the 2120 and 2200 that cannot DMA commands
 1514          * below address 8192 in physical memory.
 1515          * XXX If the padding is not needed, can it be put to use instead
 1516          * of ignored?
 1517          */
 1518         if (bus_dmamem_alloc(sc->aac_dmat, AAC_COMMON_ALLOCSIZE, PAGE_SIZE, 0,
 1519                              &seg, 1, &nsegs, BUS_DMA_NOWAIT)) {
printf("%s: can't allocate common structure\n",
sc->aac_dev.dv_xname);
 1522                 return (ENOMEM);
 1523         }
state++;
 1526         if (bus_dmamem_map(sc->aac_dmat, &seg, nsegs, AAC_COMMON_ALLOCSIZE,
 1527                            (caddr_t *)&sc->aac_common, BUS_DMA_NOWAIT)) {
printf("%s: can't map common structure\n",
sc->aac_dev.dv_xname);
error = ENOMEM;
 1531                 goto bail_out;
 1532         }
state++;
 1535         if (bus_dmamap_create(sc->aac_dmat, AAC_COMMON_ALLOCSIZE, 1,
AAC_COMMON_ALLOCSIZE, 0, BUS_DMA_NOWAIT, &sc->aac_common_map)) {
printf("%s: can't create dma map\n", sc->aac_dev.dv_xname);
error = ENOBUFS;
 1539                 goto bail_out;
 1540         }
state++;
 1543         if (bus_dmamap_load(sc->aac_dmat, sc->aac_common_map, sc->aac_common, 
AAC_COMMON_ALLOCSIZE, NULL, BUS_DMA_NOWAIT)) {
printf("%s: can't load dma map\n", sc->aac_dev.dv_xname);
error = ENOBUFS;
 1547                 goto bail_out;
 1548         }
state++;
sc->aac_common_busaddr = sc->aac_common_map->dm_segs[0].ds_addr;
 1553         if (sc->aac_common_busaddr < 8192) {
 1554                 (uint8_t *)sc->aac_common += 8192;
sc->aac_common_busaddr += 8192;
 1556         }
bzero(sc->aac_common, sizeof *sc->aac_common);
 1559         /* Allocate some FIBs and associated command structs */
TAILQ_INIT(&sc->aac_fibmap_tqh);
sc->aac_commands = malloc(AAC_MAX_FIBS * sizeof(struct aac_command),
M_DEVBUF, M_WAITOK);
bzero(sc->aac_commands, AAC_MAX_FIBS * sizeof(struct aac_command));
 1564         while (sc->total_fibs < AAC_MAX_FIBS) {
 1565                 if (aac_alloc_commands(sc) != 0)
 1566                         break;
 1567         }
 1568         if (sc->total_fibs == 0)
 1569                 goto out;
 1571         /*
 1572          * Fill in the init structure.  This tells the adapter about the
 1573          * physical location of various important shared data structures.
 1574          */
ip = &sc->aac_common->ac_init;
ip->InitStructRevision = AAC_INIT_STRUCT_REVISION;
ip->MiniPortRevision = AAC_INIT_STRUCT_MINIPORT_REVISION;
ip->AdapterFibsPhysicalAddress = sc->aac_common_busaddr +
offsetof(struct aac_common, ac_fibs);
ip->AdapterFibsVirtualAddress = 0;
ip->AdapterFibsSize = AAC_ADAPTER_FIBS * sizeof(struct aac_fib);
ip->AdapterFibAlign = sizeof(struct aac_fib);
ip->PrintfBufferAddress = sc->aac_common_busaddr +
offsetof(struct aac_common, ac_printf);
ip->PrintfBufferSize = AAC_PRINTF_BUFSIZE;
 1589         /* 
 1590          * The adapter assumes that pages are 4K in size, except on some
 1591          * broken firmware versions that do the page->byte conversion twice,
 1592          * therefore 'assuming' that this value is in 16MB units (2^24).
 1593          * Round up since the granularity is so high.
 1594          */
ip->HostPhysMemPages = ctob(physmem) / AAC_PAGE_SIZE;
 1596         if (sc->flags & AAC_FLAGS_BROKEN_MEMMAP) {
ip->HostPhysMemPages =
 1598                     (ip->HostPhysMemPages + AAC_PAGE_SIZE) / AAC_PAGE_SIZE;
 1599         }
ip->HostElapsedSeconds = time_uptime; /* reset later if invalid */
 1602         /*
 1603          * Initialise FIB queues.  Note that it appears that the layout of the
 1604          * indexes and the segmentation of the entries may be mandated by the
 1605          * adapter, which is only told about the base of the queue index fields.
 1606          *
 1607          * The initial values of the indices are assumed to inform the adapter
 1608          * of the sizes of the respective queues, and theoretically it could 
 1609          * work out the entire layout of the queue structures from this.  We
 1610          * take the easy route and just lay this area out like everyone else
 1611          * does.
 1612          *
 1613          * The Linux driver uses a much more complex scheme whereby several 
 1614          * header records are kept for each queue.  We use a couple of generic 
 1615          * list manipulation functions which 'know' the size of each list by
 1616          * virtue of a table.
 1617          */
qoffset = offsetof(struct aac_common, ac_qbuf) + AAC_QUEUE_ALIGN;
qoffset &= ~(AAC_QUEUE_ALIGN - 1);
sc->aac_queues =
 1621             (struct aac_queue_table *)((caddr_t)sc->aac_common + qoffset);
ip->CommHeaderAddress = sc->aac_common_busaddr + qoffset;
sc->aac_queues->qt_qindex[AAC_HOST_NORM_CMD_QUEUE][AAC_PRODUCER_INDEX] =
AAC_HOST_NORM_CMD_ENTRIES;
sc->aac_queues->qt_qindex[AAC_HOST_NORM_CMD_QUEUE][AAC_CONSUMER_INDEX] =
AAC_HOST_NORM_CMD_ENTRIES;
sc->aac_queues->qt_qindex[AAC_HOST_HIGH_CMD_QUEUE][AAC_PRODUCER_INDEX] =
AAC_HOST_HIGH_CMD_ENTRIES;
sc->aac_queues->qt_qindex[AAC_HOST_HIGH_CMD_QUEUE][AAC_CONSUMER_INDEX] =
AAC_HOST_HIGH_CMD_ENTRIES;
sc->aac_queues->qt_qindex[AAC_ADAP_NORM_CMD_QUEUE][AAC_PRODUCER_INDEX] =
AAC_ADAP_NORM_CMD_ENTRIES;
sc->aac_queues->qt_qindex[AAC_ADAP_NORM_CMD_QUEUE][AAC_CONSUMER_INDEX] =
AAC_ADAP_NORM_CMD_ENTRIES;
sc->aac_queues->qt_qindex[AAC_ADAP_HIGH_CMD_QUEUE][AAC_PRODUCER_INDEX] =
AAC_ADAP_HIGH_CMD_ENTRIES;
sc->aac_queues->qt_qindex[AAC_ADAP_HIGH_CMD_QUEUE][AAC_CONSUMER_INDEX] =
AAC_ADAP_HIGH_CMD_ENTRIES;
sc->aac_queues->qt_qindex[AAC_HOST_NORM_RESP_QUEUE][AAC_PRODUCER_INDEX]=
AAC_HOST_NORM_RESP_ENTRIES;
sc->aac_queues->qt_qindex[AAC_HOST_NORM_RESP_QUEUE][AAC_CONSUMER_INDEX]=
AAC_HOST_NORM_RESP_ENTRIES;
sc->aac_queues->qt_qindex[AAC_HOST_HIGH_RESP_QUEUE][AAC_PRODUCER_INDEX]=
AAC_HOST_HIGH_RESP_ENTRIES;
sc->aac_queues->qt_qindex[AAC_HOST_HIGH_RESP_QUEUE][AAC_CONSUMER_INDEX]=
AAC_HOST_HIGH_RESP_ENTRIES;
sc->aac_queues->qt_qindex[AAC_ADAP_NORM_RESP_QUEUE][AAC_PRODUCER_INDEX]=
AAC_ADAP_NORM_RESP_ENTRIES;
sc->aac_queues->qt_qindex[AAC_ADAP_NORM_RESP_QUEUE][AAC_CONSUMER_INDEX]=
AAC_ADAP_NORM_RESP_ENTRIES;
sc->aac_queues->qt_qindex[AAC_ADAP_HIGH_RESP_QUEUE][AAC_PRODUCER_INDEX]=
AAC_ADAP_HIGH_RESP_ENTRIES;
sc->aac_queues->qt_qindex[AAC_ADAP_HIGH_RESP_QUEUE][AAC_CONSUMER_INDEX]=
AAC_ADAP_HIGH_RESP_ENTRIES;
sc->aac_qentries[AAC_HOST_NORM_CMD_QUEUE] =
 1657                 &sc->aac_queues->qt_HostNormCmdQueue[0];
sc->aac_qentries[AAC_HOST_HIGH_CMD_QUEUE] =
 1659                 &sc->aac_queues->qt_HostHighCmdQueue[0];
sc->aac_qentries[AAC_ADAP_NORM_CMD_QUEUE] =
 1661                 &sc->aac_queues->qt_AdapNormCmdQueue[0];
sc->aac_qentries[AAC_ADAP_HIGH_CMD_QUEUE] =
 1663                 &sc->aac_queues->qt_AdapHighCmdQueue[0];
sc->aac_qentries[AAC_HOST_NORM_RESP_QUEUE] =
 1665                 &sc->aac_queues->qt_HostNormRespQueue[0];
sc->aac_qentries[AAC_HOST_HIGH_RESP_QUEUE] =
 1667                 &sc->aac_queues->qt_HostHighRespQueue[0];
sc->aac_qentries[AAC_ADAP_NORM_RESP_QUEUE] =
 1669                 &sc->aac_queues->qt_AdapNormRespQueue[0];
sc->aac_qentries[AAC_ADAP_HIGH_RESP_QUEUE] =
 1671                 &sc->aac_queues->qt_AdapHighRespQueue[0];
 1673         /*
 1674          * Do controller-type-specific initialisation
 1675          */
 1676         switch (sc->aac_hwif) {
 1677         case AAC_HWIF_I960RX:
AAC_SETREG4(sc, AAC_RX_ODBR, ~0);
 1679                 break;
 1680         case AAC_HWIF_RKT:
AAC_SETREG4(sc, AAC_RKT_ODBR, ~0);
 1682                 break;
 1683         default:
 1684                 break;
 1685         }
 1687         /*
 1688          * Give the init structure to the controller.
 1689          */
 1690         if (aac_sync_command(sc, AAC_MONKER_INITSTRUCT, 
sc->aac_common_busaddr +
offsetof(struct aac_common, ac_init), 0, 0, 0,
NULL)) {
printf("%s: error establishing init structure\n",
sc->aac_dev.dv_xname);
error = EIO;
 1697                 goto bail_out;
 1698         }
aac_describe_controller(sc);
aac_startup(sc);
 1703         return (0);
bail_out:
 1706         if (state > 3)
bus_dmamap_unload(sc->aac_dmat, sc->aac_common_map);
 1708         if (state > 2)
bus_dmamap_destroy(sc->aac_dmat, sc->aac_common_map);
 1710         if (state > 1)
bus_dmamem_unmap(sc->aac_dmat, (caddr_t)sc->aac_common,
 1712                     sizeof *sc->aac_common);
 1713         if (state > 0)
bus_dmamem_free(sc->aac_dmat, &seg, 1);
out:
 1717         return (error);
 1718 }
 1720 /*
 1721  * Send a synchronous command to the controller and wait for a result.
 1722  */
 1723 int
aac_sync_command(struct aac_softc *sc, u_int32_t command, u_int32_t arg0,
u_int32_t arg1, u_int32_t arg2, u_int32_t arg3, u_int32_t *sp)
 1726 {
 1727 //      time_t then;
 1728         int i;
u_int32_t status;
u_int16_t reason;
 1732         /* populate the mailbox */
AAC_SET_MAILBOX(sc, command, arg0, arg1, arg2, arg3);
 1735         /* ensure the sync command doorbell flag is cleared */
AAC_CLEAR_ISTATUS(sc, AAC_DB_SYNC_COMMAND);
 1738         /* then set it to signal the adapter */
AAC_QNOTIFY(sc, AAC_DB_SYNC_COMMAND);
 1741 #if 0
 1742         /* spin waiting for the command to complete */
then = time_uptime;
 1744         do {
 1745                 if (time_uptime > (then + AAC_IMMEDIATE_TIMEOUT)) {
AAC_DPRINTF(AAC_D_MISC, ("timed out"));
 1747                         return(EIO);
 1748                 }
 1749         } while (!(AAC_GET_ISTATUS(sc) & AAC_DB_SYNC_COMMAND));
 1750 #else
DELAY(AAC_SYNC_DELAY);
 1753         /* spin waiting for the command to complete */
 1754         for (i = 0; i < AAC_IMMEDIATE_TIMEOUT * 1000; i++) {
reason = AAC_GET_ISTATUS(sc);
 1756                 if (reason & AAC_DB_SYNC_COMMAND)
 1757                         break;
reason = AAC_GET_ISTATUS(sc);
 1759                 if (reason & AAC_DB_SYNC_COMMAND)
 1760                         break;
reason = AAC_GET_ISTATUS(sc);
 1762                 if (reason & AAC_DB_SYNC_COMMAND)
 1763                         break;
DELAY(1000);
 1765         }
 1766         if (i == AAC_IMMEDIATE_TIMEOUT * 1000) {
printf("aac_sync_command: failed, reason=%#x\n", reason);
 1768                 return (EIO);
 1769         }
 1770 #endif
 1772         /* clear the completion flag */
AAC_CLEAR_ISTATUS(sc, AAC_DB_SYNC_COMMAND);
 1775         /* get the command status */
status = AAC_GET_MAILBOX(sc, 0);
 1778         if (sp != NULL)
 1779                 *sp = status;
 1781         return(0);
 1782 }
 1784 /*
 1785  * Grab the sync fib area.
 1786  */
 1787 int
aac_alloc_sync_fib(struct aac_softc *sc, struct aac_fib **fib, int flags)
 1789 {
 1791         /*
 1792          * If the force flag is set, the system is shutting down, or in
 1793          * trouble.  Ignore the mutex.
 1794          */
 1795         if (!(flags & AAC_SYNC_LOCK_FORCE))
AAC_LOCK_ACQUIRE(&sc->aac_sync_lock);
 1798         *fib = &sc->aac_common->ac_sync_fib;
 1800         return (1);
 1801 }
 1803 /*
 1804  * Release the sync fib area.
 1805  */
 1806 void
aac_release_sync_fib(struct aac_softc *sc)
 1808 {
AAC_LOCK_RELEASE(&sc->aac_sync_lock);
 1810 }
 1812 /*
 1813  * Send a synchronous FIB to the controller and wait for a result.
 1814  */
 1815 int
aac_sync_fib(struct aac_softc *sc, u_int32_t command, u_int32_t xferstate, 
 1817              struct aac_fib *fib, u_int16_t datasize)
 1818 {
 1820         if (datasize > AAC_FIB_DATASIZE) {
printf("aac_sync_fib 1: datasize=%d AAC_FIB_DATASIZE %lu\n",
datasize, AAC_FIB_DATASIZE);
 1823                 return(EINVAL);
 1824         }
 1826         /*
 1827          * Set up the sync FIB
 1828          */
fib->Header.XferState = AAC_FIBSTATE_HOSTOWNED |
AAC_FIBSTATE_INITIALISED |
AAC_FIBSTATE_EMPTY;
fib->Header.XferState |= xferstate;
fib->Header.Command = command;
fib->Header.StructType = AAC_FIBTYPE_TFIB;
fib->Header.Size = sizeof(struct aac_fib) + datasize;
fib->Header.SenderSize = sizeof(struct aac_fib);
fib->Header.SenderFibAddress = 0;       /* Not needed */
fib->Header.ReceiverFibAddress = sc->aac_common_busaddr +
offsetof(struct aac_common,
ac_sync_fib);
 1842         /*
 1843          * Give the FIB to the controller, wait for a response.
 1844          */
 1845         if (aac_sync_command(sc, AAC_MONKER_SYNCFIB,
fib->Header.ReceiverFibAddress, 0, 0, 0, NULL)) {
AAC_DPRINTF(AAC_D_IO, ("%s: aac_sync_fib: IO error\n",
sc->aac_dev.dv_xname));
printf("aac_sync_fib 2\n");
 1850                 return(EIO);
 1851         }
 1853         return (0);
 1854 }
 1856 /*****************************************************************************
 1857  * Adapter-space FIB queue manipulation
 1858  *
 1859  * Note that the queue implementation here is a little funky; neither the PI or
 1860  * CI will ever be zero.  This behaviour is a controller feature.
 1861  */
 1862 static struct {
 1863         int size;
 1864         int notify;
 1865 } aac_qinfo[] = {
 1866         { AAC_HOST_NORM_CMD_ENTRIES, AAC_DB_COMMAND_NOT_FULL },
 1867         { AAC_HOST_HIGH_CMD_ENTRIES, 0 },
 1868         { AAC_ADAP_NORM_CMD_ENTRIES, AAC_DB_COMMAND_READY },
 1869         { AAC_ADAP_HIGH_CMD_ENTRIES, 0 },
 1870         { AAC_HOST_NORM_RESP_ENTRIES, AAC_DB_RESPONSE_NOT_FULL },
 1871         { AAC_HOST_HIGH_RESP_ENTRIES, 0 },
 1872         { AAC_ADAP_NORM_RESP_ENTRIES, AAC_DB_RESPONSE_READY },
 1873         { AAC_ADAP_HIGH_RESP_ENTRIES, 0 }
 1874 };
 1876 /*
 1877  * Atomically insert an entry into the nominated queue, returns 0 on success
 1878  * or EBUSY if the queue is full.
 1879  *
 1880  * Note: it would be more efficient to defer notifying the controller in
 1881  *       the case where we may be inserting several entries in rapid
 1882  *       succession, but implementing this usefully may be difficult
 1883  *       (it would involve a separate queue/notify interface).
 1884  */
 1885 int
aac_enqueue_fib(struct aac_softc *sc, int queue, struct aac_command *cm)
 1887 {
u_int32_t pi, ci;
 1889         int error;
u_int32_t fib_size;
u_int32_t fib_addr;
fib_size = cm->cm_fib->Header.Size;
fib_addr = cm->cm_fib->Header.ReceiverFibAddress;
 1896         /* get the producer/consumer indices */
pi = sc->aac_queues->qt_qindex[queue][AAC_PRODUCER_INDEX];
ci = sc->aac_queues->qt_qindex[queue][AAC_CONSUMER_INDEX];
 1900         /* wrap the queue? */
 1901         if (pi >= aac_qinfo[queue].size)
pi = 0;
 1904         /* check for queue full */
 1905         if ((pi + 1) == ci) {
error = EBUSY;
 1907                 goto out;
 1908         }
 1910         /* populate queue entry */
 1911         (sc->aac_qentries[queue] + pi)->aq_fib_size = fib_size;
 1912         (sc->aac_qentries[queue] + pi)->aq_fib_addr = fib_addr;
 1914         /* update producer index */
sc->aac_queues->qt_qindex[queue][AAC_PRODUCER_INDEX] = pi + 1;
 1917         /*
 1918          * To avoid a race with its completion interrupt, place this command on
 1919          * the busy queue prior to advertising it to the controller.
 1920          */
aac_enqueue_busy(cm);
 1923         /* notify the adapter if we know how */
 1924         if (aac_qinfo[queue].notify != 0)
AAC_QNOTIFY(sc, aac_qinfo[queue].notify);
error = 0;
out:
 1930         return (error);
 1931 }
 1933 /*
 1934  * Atomically remove one entry from the nominated queue, returns 0 on success
 1935  * or ENOENT if the queue is empty.
 1936  */
 1937 int
aac_dequeue_fib(struct aac_softc *sc, int queue, u_int32_t *fib_size,
 1939                 struct aac_fib **fib_addr)
 1940 {
u_int32_t pi, ci;
u_int32_t fib_index;
 1943         int notify;
 1944         int error;
 1946         /* get the producer/consumer indices */
pi = sc->aac_queues->qt_qindex[queue][AAC_PRODUCER_INDEX];
ci = sc->aac_queues->qt_qindex[queue][AAC_CONSUMER_INDEX];
 1950         /* check for queue empty */
 1951         if (ci == pi) {
error = ENOENT;
 1953                 goto out;
 1954         }
 1956         /* wrap the pi so the following test works */
 1957         if (pi >= aac_qinfo[queue].size)
pi = 0;
notify = 0;
 1961         if (ci == pi + 1)
notify++;
 1964         /* wrap the queue? */
 1965         if (ci >= aac_qinfo[queue].size)
ci = 0;
 1968         /* fetch the entry */
 1969         *fib_size = (sc->aac_qentries[queue] + ci)->aq_fib_size;
 1971         switch (queue) {
 1972         case AAC_HOST_NORM_CMD_QUEUE:
 1973         case AAC_HOST_HIGH_CMD_QUEUE:
 1974                 /*
 1975                  * The aq_fib_addr is only 32 bits wide so it can't be counted
 1976                  * on to hold an address.  For AIF's, the adapter assumes
 1977                  * that it's giving us an address into the array of AIF fibs.
 1978                  * Therefore, we have to convert it to an index.
 1979                  */
fib_index = (sc->aac_qentries[queue] + ci)->aq_fib_addr /
 1981                         sizeof(struct aac_fib);
 1982                 *fib_addr = &sc->aac_common->ac_fibs[fib_index];
 1983                 break;
 1985         case AAC_HOST_NORM_RESP_QUEUE:
 1986         case AAC_HOST_HIGH_RESP_QUEUE:
 1987         {
 1988                 struct aac_command *cm;
 1990                 /*
 1991                  * As above, an index is used instead of an actual address.
 1992                  * Gotta shift the index to account for the fast response
 1993                  * bit.  No other correction is needed since this value was
 1994                  * originally provided by the driver via the SenderFibAddress
 1995                  * field.
 1996                  */
fib_index = (sc->aac_qentries[queue] + ci)->aq_fib_addr;
cm = sc->aac_commands + (fib_index >> 1);
 1999                 *fib_addr = cm->cm_fib;
 2001                 /*
 2002                  * Is this a fast response? If it is, update the fib fields in
 2003                  * local memory since the whole fib isn't DMA'd back up.
 2004                  */
 2005                 if (fib_index & 0x01) {
 2006                         (*fib_addr)->Header.XferState |= AAC_FIBSTATE_DONEADAP;
 2007                         *((u_int32_t*)((*fib_addr)->data)) = AAC_ERROR_NORMAL;
 2008                 }
 2009                 break;
 2010         }
 2011         default:
panic("Invalid queue in aac_dequeue_fib()");
 2013                 break;
 2014         }
 2017         /* update consumer index */
sc->aac_queues->qt_qindex[queue][AAC_CONSUMER_INDEX] = ci + 1;
 2020         /* if we have made the queue un-full, notify the adapter */
 2021         if (notify && (aac_qinfo[queue].notify != 0))
AAC_QNOTIFY(sc, aac_qinfo[queue].notify);
error = 0;
out:
 2026         return (error);
 2027 }
 2029 /*
 2030  * Put our response to an Adapter Initialed Fib on the response queue
 2031  */
 2032 int
aac_enqueue_response(struct aac_softc *sc, int queue, struct aac_fib *fib)
 2034 {
u_int32_t pi, ci;
 2036         int error;
u_int32_t fib_size;
u_int32_t fib_addr;
 2040         /* Tell the adapter where the FIB is */
fib_size = fib->Header.Size; 
fib_addr = fib->Header.SenderFibAddress;
fib->Header.ReceiverFibAddress = fib_addr;
 2045         /* get the producer/consumer indices */
pi = sc->aac_queues->qt_qindex[queue][AAC_PRODUCER_INDEX];
ci = sc->aac_queues->qt_qindex[queue][AAC_CONSUMER_INDEX];
 2049         /* wrap the queue? */
 2050         if (pi >= aac_qinfo[queue].size)
pi = 0;
 2053         /* check for queue full */
 2054         if ((pi + 1) == ci) {
error = EBUSY;
 2056                 goto out;
 2057         }
 2059         /* populate queue entry */
 2060         (sc->aac_qentries[queue] + pi)->aq_fib_size = fib_size;
 2061         (sc->aac_qentries[queue] + pi)->aq_fib_addr = fib_addr;
 2063         /* update producer index */
sc->aac_queues->qt_qindex[queue][AAC_PRODUCER_INDEX] = pi + 1;
 2066         /* notify the adapter if we know how */
 2067         if (aac_qinfo[queue].notify != 0)
AAC_QNOTIFY(sc, aac_qinfo[queue].notify);
error = 0;
out:
 2073         return(error);
 2074 }
 2076 void
aac_command_timeout(struct aac_command *cm)
 2078 {
 2079         struct aac_softc *sc = cm->cm_sc;
printf("%s: COMMAND %p (flags=%#x) TIMEOUT AFTER %d SECONDS\n",
sc->aac_dev.dv_xname, cm, cm->cm_flags,
 2083                (int)(time_uptime - cm->cm_timestamp));
 2085         if (cm->cm_flags & AAC_CMD_TIMEDOUT)
 2086                 return;
cm->cm_flags |= AAC_CMD_TIMEDOUT;
AAC_PRINT_FIB(sc, cm->cm_fib);
 2092         if (cm->cm_flags & AAC_ON_AACQ_BIO) {
 2093                 struct scsi_xfer *xs = cm->cm_private;
 2094                 int s = splbio();
xs->error = XS_DRIVER_STUFFUP;
xs->flags |= ITSDONE;
scsi_done(xs);
splx(s);
aac_remove_bio(cm);
aac_unmap_command(cm);
 2102         }
 2103 }
 2105 void
aac_timeout(struct aac_softc *sc)
 2107 {
 2108         struct aac_command *cm;
time_t deadline;
 2111         /*
 2112          * Traverse the busy command list and timeout any commands
 2113          * that are past their deadline.
 2114          */
deadline = time_uptime - AAC_CMD_TIMEOUT;
TAILQ_FOREACH(cm, &sc->aac_busy, cm_link) {
 2117                 if (cm->cm_timestamp  < deadline)
aac_command_timeout(cm);
 2119         }
 2120 }
 2122 /*
 2123  * Interface Function Vectors
 2124  */
 2126 /*
 2127  * Read the current firmware status word.
 2128  */
 2129 int
aac_sa_get_fwstatus(struct aac_softc *sc)
 2131 {
 2132         return (AAC_GETREG4(sc, AAC_SA_FWSTATUS));
 2133 }
 2135 int
aac_rx_get_fwstatus(struct aac_softc *sc)
 2137 {
 2138         return (AAC_GETREG4(sc, AAC_RX_FWSTATUS));
 2139 }
 2141 int
aac_fa_get_fwstatus(struct aac_softc *sc)
 2143 {
 2144         return (AAC_GETREG4(sc, AAC_FA_FWSTATUS));
 2145 }
 2147 int
aac_rkt_get_fwstatus(struct aac_softc *sc)
 2149 {
 2150         return(AAC_GETREG4(sc, AAC_RKT_FWSTATUS));
 2151 }
 2153 /*
 2154  * Notify the controller of a change in a given queue
 2155  */
 2157 void
aac_sa_qnotify(struct aac_softc *sc, int qbit)
 2159 {
AAC_SETREG2(sc, AAC_SA_DOORBELL1_SET, qbit);
 2161 }
 2163 void
aac_rx_qnotify(struct aac_softc *sc, int qbit)
 2165 {
AAC_SETREG4(sc, AAC_RX_IDBR, qbit);
 2167 }
 2169 void
aac_fa_qnotify(struct aac_softc *sc, int qbit)
 2171 {
AAC_SETREG2(sc, AAC_FA_DOORBELL1, qbit);
AAC_FA_HACK(sc);
 2174 }
 2176 void
aac_rkt_qnotify(struct aac_softc *sc, int qbit)
 2178 {
AAC_SETREG4(sc, AAC_RKT_IDBR, qbit);
 2180 }
 2182 /*
 2183  * Get the interrupt reason bits
 2184  */
 2185 int
aac_sa_get_istatus(struct aac_softc *sc)
 2187 {
 2188         return (AAC_GETREG2(sc, AAC_SA_DOORBELL0));
 2189 }
 2191 int
aac_rx_get_istatus(struct aac_softc *sc)
 2193 {
 2194         return (AAC_GETREG4(sc, AAC_RX_ODBR));
 2195 }
 2197 int
aac_fa_get_istatus(struct aac_softc *sc)
 2199 {
 2200         return (AAC_GETREG2(sc, AAC_FA_DOORBELL0));
 2201 }
 2203 int
aac_rkt_get_istatus(struct aac_softc *sc)
 2205 {
 2206         return(AAC_GETREG4(sc, AAC_RKT_ODBR));
 2207 }
 2209 /*
 2210  * Clear some interrupt reason bits
 2211  */
 2212 void
aac_sa_clear_istatus(struct aac_softc *sc, int mask)
 2214 {
AAC_SETREG2(sc, AAC_SA_DOORBELL0_CLEAR, mask);
 2216 }
 2218 void
aac_rx_clear_istatus(struct aac_softc *sc, int mask)
 2220 {
AAC_SETREG4(sc, AAC_RX_ODBR, mask);
 2222 }
 2224 void
aac_fa_clear_istatus(struct aac_softc *sc, int mask)
 2226 {
AAC_SETREG2(sc, AAC_FA_DOORBELL0_CLEAR, mask);
AAC_FA_HACK(sc);
 2229 }
 2231 void
aac_rkt_clear_istatus(struct aac_softc *sc, int mask)
 2233 {
AAC_SETREG4(sc, AAC_RKT_ODBR, mask);
 2235 }
 2237 /*
 2238  * Populate the mailbox and set the command word
 2239  */
 2240 void
aac_sa_set_mailbox(struct aac_softc *sc, u_int32_t command, u_int32_t arg0,
u_int32_t arg1, u_int32_t arg2, u_int32_t arg3)
 2243 {
AAC_SETREG4(sc, AAC_SA_MAILBOX, command);
AAC_SETREG4(sc, AAC_SA_MAILBOX + 4, arg0);
AAC_SETREG4(sc, AAC_SA_MAILBOX + 8, arg1);
AAC_SETREG4(sc, AAC_SA_MAILBOX + 12, arg2);
AAC_SETREG4(sc, AAC_SA_MAILBOX + 16, arg3);
 2249 }
 2251 void
aac_rx_set_mailbox(struct aac_softc *sc, u_int32_t command, u_int32_t arg0,
u_int32_t arg1, u_int32_t arg2, u_int32_t arg3)
 2254 {
AAC_SETREG4(sc, AAC_RX_MAILBOX, command);
AAC_SETREG4(sc, AAC_RX_MAILBOX + 4, arg0);
AAC_SETREG4(sc, AAC_RX_MAILBOX + 8, arg1);
AAC_SETREG4(sc, AAC_RX_MAILBOX + 12, arg2);
AAC_SETREG4(sc, AAC_RX_MAILBOX + 16, arg3);
 2260 }
 2262 void
aac_fa_set_mailbox(struct aac_softc *sc, u_int32_t command, u_int32_t arg0,
u_int32_t arg1, u_int32_t arg2, u_int32_t arg3)
 2265 {
AAC_SETREG4(sc, AAC_FA_MAILBOX, command);
AAC_FA_HACK(sc);
AAC_SETREG4(sc, AAC_FA_MAILBOX + 4, arg0);
AAC_FA_HACK(sc);
AAC_SETREG4(sc, AAC_FA_MAILBOX + 8, arg1);
AAC_FA_HACK(sc);
AAC_SETREG4(sc, AAC_FA_MAILBOX + 12, arg2);
AAC_FA_HACK(sc);
AAC_SETREG4(sc, AAC_FA_MAILBOX + 16, arg3);
AAC_FA_HACK(sc);
 2276 }
 2278 void
aac_rkt_set_mailbox(struct aac_softc *sc, u_int32_t command, u_int32_t arg0,
u_int32_t arg1, u_int32_t arg2, u_int32_t arg3)
 2281 {
AAC_SETREG4(sc, AAC_RKT_MAILBOX, command);
AAC_SETREG4(sc, AAC_RKT_MAILBOX + 4, arg0);
AAC_SETREG4(sc, AAC_RKT_MAILBOX + 8, arg1);
AAC_SETREG4(sc, AAC_RKT_MAILBOX + 12, arg2);
AAC_SETREG4(sc, AAC_RKT_MAILBOX + 16, arg3);
 2287 }
 2289 /*
 2290  * Fetch the immediate command status word
 2291  */
 2292 int
aac_sa_get_mailbox(struct aac_softc *sc, int mb)
 2294 {
 2295         return (AAC_GETREG4(sc, AAC_SA_MAILBOX + (mb * 4)));
 2296 }
 2298 int
aac_rx_get_mailbox(struct aac_softc *sc, int mb)
 2300 {
 2301         return (AAC_GETREG4(sc, AAC_RX_MAILBOX + (mb * 4)));
 2302 }
 2304 int
aac_fa_get_mailbox(struct aac_softc *sc, int mb)
 2306 {
 2307         return (AAC_GETREG4(sc, AAC_FA_MAILBOX + (mb * 4)));
 2308 }
 2310 int
aac_rkt_get_mailbox(struct aac_softc *sc, int mb)
 2312 {
 2313         return(AAC_GETREG4(sc, AAC_RKT_MAILBOX + (mb * 4)));
 2314 }
 2316 /*
 2317  * Set/clear interrupt masks
 2318  */
 2319 void
aac_sa_set_interrupts(struct aac_softc *sc, int enable)
 2321 {
AAC_DPRINTF(AAC_D_INTR, ("%s: %sable interrupts\n",
sc->aac_dev.dv_xname, enable ? "en" : "dis"));
 2325         if (enable)
AAC_SETREG2((sc), AAC_SA_MASK0_CLEAR, AAC_DB_INTERRUPTS);
 2327         else
AAC_SETREG2((sc), AAC_SA_MASK0_SET, ~0);
 2329 }
 2331 void
aac_rx_set_interrupts(struct aac_softc *sc, int enable)
 2333 {
AAC_DPRINTF(AAC_D_INTR, ("%s: %sable interrupts",
sc->aac_dev.dv_xname, enable ? "en" : "dis"));
 2337         if (enable)
AAC_SETREG4(sc, AAC_RX_OIMR, ~AAC_DB_INTERRUPTS);
 2339         else
AAC_SETREG4(sc, AAC_RX_OIMR, ~0);
 2341 }
 2343 void
aac_fa_set_interrupts(struct aac_softc *sc, int enable)
 2345 {
AAC_DPRINTF(AAC_D_INTR, ("%s: %sable interrupts",
sc->aac_dev.dv_xname, enable ? "en" : "dis"));
 2349         if (enable) {
AAC_SETREG2((sc), AAC_FA_MASK0_CLEAR, AAC_DB_INTERRUPTS);
AAC_FA_HACK(sc);
 2352         } else {
AAC_SETREG2((sc), AAC_FA_MASK0, ~0);
AAC_FA_HACK(sc);
 2355         }
 2356 }
 2358 void
aac_rkt_set_interrupts(struct aac_softc *sc, int enable)
 2360 {
AAC_DPRINTF(AAC_D_INTR, ("%s: %sable interrupts",
sc->aac_dev.dv_xname, enable ? "en" : "dis"));
 2364         if (enable)
AAC_SETREG4(sc, AAC_RKT_OIMR, ~AAC_DB_INTERRUPTS);
 2366         else
AAC_SETREG4(sc, AAC_RKT_OIMR, ~0);
 2368 }
 2370 void
aac_eval_mapping(size, cyls, heads, secs)
u_int32_t size;
 2373         int *cyls, *heads, *secs;
 2374 {
 2375         *cyls = size / AAC_HEADS / AAC_SECS;
 2376         if (*cyls < AAC_MAXCYLS) {
 2377                 *heads = AAC_HEADS;
 2378                 *secs = AAC_SECS;
 2379         } else {
 2380                 /* Too high for 64 * 32 */
 2381                 *cyls = size / AAC_MEDHEADS / AAC_MEDSECS;
 2382                 if (*cyls < AAC_MAXCYLS) {
 2383                         *heads = AAC_MEDHEADS;
 2384                         *secs = AAC_MEDSECS;
 2385                 } else {
 2386                         /* Too high for 127 * 63 */
 2387                         *cyls = size / AAC_BIGHEADS / AAC_BIGSECS;
 2388                         *heads = AAC_BIGHEADS;
 2389                         *secs = AAC_BIGSECS;
 2390                 }
 2391         }
 2392 }
 2394 void
aac_copy_internal_data(struct scsi_xfer *xs, u_int8_t *data, size_t size)
 2396 {
 2397         struct aac_softc *sc = xs->sc_link->adapter_softc;
size_t copy_cnt;
AAC_DPRINTF(AAC_D_MISC, ("%s: aac_copy_internal_data\n",
sc->aac_dev.dv_xname));
 2403         if (!xs->datalen)
printf("%s: uio move not yet supported\n",
sc->aac_dev.dv_xname);
 2406         else {
copy_cnt = MIN(size, xs->datalen);
bcopy(data, xs->data, copy_cnt);
 2409         }
 2410 }
 2412 /* Emulated SCSI operation on cache device */
 2413 void
aac_internal_cache_cmd(struct scsi_xfer *xs)
 2415 {
 2416         struct scsi_link *link = xs->sc_link;
 2417         struct aac_softc *sc = link->adapter_softc;
 2418         struct scsi_inquiry_data inq;
 2419         struct scsi_sense_data sd;
 2420         struct scsi_read_cap_data rcd;
u_int8_t target = link->target;
AAC_DPRINTF(AAC_D_CMD, ("aac_internal_cache_cmd: ",
sc->aac_dev.dv_xname));
 2426         switch (xs->cmd->opcode) {
 2427         case TEST_UNIT_READY:
 2428         case START_STOP:
 2429 #if 0
 2430         case VERIFY:
 2431 #endif
AAC_DPRINTF(AAC_D_CMD, ("opc %#x tgt %d ", xs->cmd->opcode,
target));
 2434                 break;
 2436         case REQUEST_SENSE:
AAC_DPRINTF(AAC_D_CMD, ("REQUEST SENSE tgt %d ", target));
bzero(&sd, sizeof sd);
sd.error_code = 0x70;
sd.segment = 0;
sd.flags = SKEY_NO_SENSE;
aac_enc32(sd.info, 0);
sd.extra_len = 0;
aac_copy_internal_data(xs, (u_int8_t *)&sd, sizeof sd);
 2445                 break;
 2447         case INQUIRY:
AAC_DPRINTF(AAC_D_CMD, ("INQUIRY tgt %d devtype %x ", target,
sc->aac_hdr[target].hd_devtype));
bzero(&inq, sizeof inq);
 2451                 /* XXX How do we detect removable/CD-ROM devices?  */
inq.device = T_DIRECT;
inq.dev_qual2 = 0;
inq.version = 2;
inq.response_format = 2;
inq.additional_length = 32;
strlcpy(inq.vendor, "Adaptec", sizeof inq.vendor);
snprintf(inq.product, sizeof inq.product, "Container #%02d",
target);
strlcpy(inq.revision, "   ", sizeof inq.revision);
aac_copy_internal_data(xs, (u_int8_t *)&inq, sizeof inq);
 2462                 break;
 2464         case READ_CAPACITY:
AAC_DPRINTF(AAC_D_CMD, ("READ CAPACITY tgt %d ", target));
bzero(&rcd, sizeof rcd);
_lto4b(sc->aac_hdr[target].hd_size - 1, rcd.addr);
_lto4b(AAC_BLOCK_SIZE, rcd.length);
aac_copy_internal_data(xs, (u_int8_t *)&rcd, sizeof rcd);
 2470                 break;
 2472         default:
AAC_DPRINTF(AAC_D_CMD, ("\n"));
printf("aac_internal_cache_cmd got bad opcode: %#x\n",
xs->cmd->opcode);
xs->error = XS_DRIVER_STUFFUP;
 2477                 return;
 2478         }
xs->error = XS_NOERROR;
 2481 }
 2483 void
aacminphys(struct buf *bp)
 2485 {
 2486 #if 0
u_int8_t *buf = bp->b_data;
paddr_t pa;
 2489         long off;
 2490 #endif
AAC_DPRINTF(AAC_D_MISC, ("aacminphys(0x%x)\n", bp));
 2494 #if 0   /* As this is way more than MAXPHYS it's really not necessary. */
 2495         if (bp->b_bcount > ((AAC_MAXOFFSETS - 1) * PAGE_SIZE))
bp->b_bcount = ((AAC_MAXOFFSETS - 1) * PAGE_SIZE);
 2497 #endif
 2499 #if 0
 2500         for (off = PAGE_SIZE, pa = vtophys(buf); off < bp->b_bcount;
off += PAGE_SIZE)
 2502                 if (pa + off != vtophys(buf + off)) {
bp->b_bcount = off;
 2504                         break;
 2505                 }
 2506 #endif
minphys(bp);
 2508 }
 2510 int
aac_raw_scsi_cmd(struct scsi_xfer *xs)
 2512 {
 2513 #ifdef AAC_DEBUG
 2514         struct aac_softc *sc = xs->sc_link->adapter_softc;
 2515 #endif
AAC_DPRINTF(AAC_D_CMD, ("%s: aac_raw_scsi_cmd\n",
sc->aac_dev.dv_xname));
 2519         /* XXX Not yet implemented */
xs->error = XS_DRIVER_STUFFUP;
 2521         return (COMPLETE);
 2522 }
 2524 int
aac_scsi_cmd(struct scsi_xfer *xs)
 2526 {
 2527         struct scsi_link *link = xs->sc_link;
 2528         struct aac_softc *sc = link->adapter_softc;
u_int8_t target = link->target;
 2530         struct aac_command *cm;
u_int32_t blockno, blockcnt;
 2532         struct scsi_rw *rw;
 2533         struct scsi_rw_big *rwb;
 2534         int retval = SUCCESSFULLY_QUEUED;
 2535         int s = splbio();
xs->error = XS_NOERROR;
 2539         if (target >= AAC_MAX_CONTAINERS || !sc->aac_hdr[target].hd_present ||
link->lun != 0) {
 2541                 /*
 2542                  * XXX Should be XS_SENSE but that would require setting up a
 2543                  * faked sense too.
 2544                  */
xs->error = XS_DRIVER_STUFFUP;
xs->flags |= ITSDONE;
scsi_done(xs);
splx(s);
 2549                 return (COMPLETE);
 2550         }
AAC_DPRINTF(AAC_D_CMD, ("%s: aac_scsi_cmd: ", sc->aac_dev.dv_xname));
xs->error = XS_NOERROR;
cm = NULL;
link = xs->sc_link;
target = link->target;
 2559         switch (xs->cmd->opcode) {
 2560         case TEST_UNIT_READY:
 2561         case REQUEST_SENSE:
 2562         case INQUIRY:
 2563         case START_STOP:
 2564         case READ_CAPACITY:
 2565 #if 0
 2566         case VERIFY:
 2567 #endif
aac_internal_cache_cmd(xs);
xs->flags |= ITSDONE;
scsi_done(xs);
 2571                 goto ready;
 2573         case PREVENT_ALLOW:
AAC_DPRINTF(AAC_D_CMD, ("PREVENT/ALLOW "));
 2575                 /* XXX Not yet implemented */
xs->error = XS_NOERROR;
xs->flags |= ITSDONE;
scsi_done(xs);
 2579                 goto ready;
 2581         case SYNCHRONIZE_CACHE:
AAC_DPRINTF(AAC_D_CMD, ("SYNCHRONIZE_CACHE "));
 2583                 /* XXX Not yet implemented */
xs->error = XS_NOERROR;
xs->flags |= ITSDONE;
scsi_done(xs);
 2587                 goto ready;
 2589         default:
AAC_DPRINTF(AAC_D_CMD, ("unknown opc %#x ", xs->cmd->opcode));
 2591                 /* XXX Not yet implemented */
xs->error = XS_DRIVER_STUFFUP;
xs->flags |= ITSDONE;
scsi_done(xs);
 2595                 goto ready;
 2597         case READ_COMMAND:
 2598         case READ_BIG:
 2599         case WRITE_COMMAND:
 2600         case WRITE_BIG:
AAC_DPRINTF(AAC_D_CMD, ("rw opc %#x ", xs->cmd->opcode));
 2603                 /* A read or write operation. */
 2604                 if (xs->cmdlen == 6) {
rw = (struct scsi_rw *)xs->cmd;
blockno = _3btol(rw->addr) & 
 2607                                 (SRW_TOPADDR << 16 | 0xffff);
blockcnt = rw->length ? rw->length : 0x100;
 2609                 } else {
rwb = (struct scsi_rw_big *)xs->cmd;
blockno = _4btol(rwb->addr);
blockcnt = _2btol(rwb->length);
 2613                 }
AAC_DPRINTF(AAC_D_CMD, ("blkno=%d bcount=%d ",
xs->cmd->opcode, blockno, blockcnt));
 2618                 if (blockno >= sc->aac_hdr[target].hd_size ||
blockno + blockcnt > sc->aac_hdr[target].hd_size) {
AAC_DPRINTF(AAC_D_CMD, ("\n"));
printf("%s: out of bounds %u-%u >= %u\n",
sc->aac_dev.dv_xname, blockno,
blockcnt, sc->aac_hdr[target].hd_size);
 2624                         /*
 2625                          * XXX Should be XS_SENSE but that
 2626                          * would require setting up a faked
 2627                          * sense too.
 2628                          */
xs->error = XS_DRIVER_STUFFUP;
xs->flags |= ITSDONE;
scsi_done(xs);
 2632                         goto ready;
 2633                 }
 2635                 if (aac_alloc_command(sc, &cm)) {
AAC_DPRINTF(AAC_D_CMD,
 2637                                     (": out of commands, try later\n"));
 2638                         /*
 2639                          * We are out of commands, try again
 2640                          * in a little while.
 2641                          */
splx(s);
 2643                         return (TRY_AGAIN_LATER);
 2644                 }
 2646                 /* fill out the command */
cm->cm_data = (void *)xs->data;
cm->cm_datalen = xs->datalen;
cm->cm_complete = aac_bio_complete;
cm->cm_private = xs;
cm->cm_timestamp = time_uptime;
cm->cm_queue = AAC_ADAP_NORM_CMD_QUEUE;
cm->cm_blkno = blockno;
cm->cm_bcount = blockcnt;
AAC_DPRINTF(AAC_D_CMD, ("\n"));
aac_enqueue_bio(cm);
aac_startio(sc);
 2660                 /* XXX what if enqueue did not start a transfer? */
 2661                 if (xs->flags & SCSI_POLL) {
 2662                         if (!aac_wait_command(cm, xs->timeout))
 2663                         {
printf("%s: command timed out\n",
sc->aac_dev.dv_xname);
splx(s);
 2667                                 return (TRY_AGAIN_LATER);
 2668                         }
xs->flags |= ITSDONE;
scsi_done(xs);
 2671                 }
 2672         }
ready:
 2675         /*
 2676          * Don't process the queue if we are polling.
 2677          */
 2678         if (xs->flags & SCSI_POLL)
retval = COMPLETE;
splx(s);
AAC_DPRINTF(AAC_D_CMD, ("%s: scsi_cmd complete\n",
sc->aac_dev.dv_xname));
 2684         return (retval);
 2685 }
 2687 /*
 2688  * Debugging and Diagnostics
 2689  */
 2691 /*
 2692  * Print some information about the controller.
 2693  */
 2694 void
aac_describe_controller(struct aac_softc *sc)
 2696 {
 2697         struct aac_fib *fib;
 2698         struct aac_adapter_info *info;
aac_alloc_sync_fib(sc, &fib, 0);
fib->data[0] = 0;
 2703         if (aac_sync_fib(sc, RequestAdapterInfo, 0, fib, 1)) {
printf("%s: RequestAdapterInfo failed 2\n",
sc->aac_dev.dv_xname);
aac_release_sync_fib(sc);
 2707                 return;
 2708         }
info = (struct aac_adapter_info *)&fib->data[0];   
printf("%s: %s %dMHz, %dMB cache memory, %s\n", sc->aac_dev.dv_xname,
aac_describe_code(aac_cpu_variant, info->CpuVariant),
info->ClockSpeed, info->BufferMem / (1024 * 1024), 
aac_describe_code(aac_battery_platform, info->batteryPlatform));
 2716         /* save the kernel revision structure for later use */
sc->aac_revision = info->KernelRevision;
printf("%s: Kernel %d.%d-%d, Build %d, S/N %6X\n",
sc->aac_dev.dv_xname,
info->KernelRevision.external.comp.major,
info->KernelRevision.external.comp.minor,
info->KernelRevision.external.comp.dash,
info->KernelRevision.buildNumber,
 2724                (u_int32_t)(info->SerialNumber & 0xffffff));
aac_release_sync_fib(sc);
 2728 #if 0
 2729         if (1 || bootverbose) {
device_printf(sc->aac_dev, "Supported Options=%b\n",
sc->supported_options,
 2732                               "\20"
 2733                               "\1SNAPSHOT"
 2734                               "\2CLUSTERS"
 2735                               "\3WCACHE"
 2736                               "\4DATA64"
 2737                               "\5HOSTTIME"
 2738                               "\6RAID50"
 2739                               "\7WINDOW4GB"
 2740                               "\10SCSIUPGD"
 2741                               "\11SOFTERR"
 2742                               "\12NORECOND"
 2743                               "\13SGMAP64"
 2744                               "\14ALARM"
 2745                               "\15NONDASD");
 2746         }
 2747 #endif
 2748 }
 2750 /*
 2751  * Look up a text description of a numeric error code and return a pointer to
 2752  * same.
 2753  */
 2754 char *
aac_describe_code(struct aac_code_lookup *table, u_int32_t code)
 2756 {
 2757         int i;
 2759         for (i = 0; table[i].string != NULL; i++)
 2760                 if (table[i].code == code)
 2761                         return(table[i].string);
 2762         return(table[i + 1].string);
 2763 }
 2765 #ifdef AAC_DEBUG
 2766 /*
 2767  * Print a FIB
 2768  */
 2769 void
aac_print_fib(struct aac_softc *sc, struct aac_fib *fib, const char *caller)
 2771 {
printf("%s: FIB @ %p\n", caller, fib);
printf("  XferState %b\n", fib->Header.XferState, "\20"
 2774             "\1HOSTOWNED"
 2775             "\2ADAPTEROWNED"
 2776             "\3INITIALISED"
 2777             "\4EMPTY"
 2778             "\5FROMPOOL"
 2779             "\6FROMHOST"
 2780             "\7FROMADAP"
 2781             "\10REXPECTED"
 2782             "\11RNOTEXPECTED"
 2783             "\12DONEADAP"
 2784             "\13DONEHOST"
 2785             "\14HIGH"
 2786             "\15NORM"
 2787             "\16ASYNC"
 2788             "\17PAGEFILEIO"
 2789             "\20SHUTDOWN"
 2790             "\21LAZYWRITE"
 2791             "\22ADAPMICROFIB"
 2792             "\23BIOSFIB"
 2793             "\24FAST_RESPONSE"
 2794             "\25APIFIB\n");
printf("  Command         %d\n", fib->Header.Command);
printf("  StructType      %d\n", fib->Header.StructType);
printf("  Flags           0x%x\n", fib->Header.Flags);
printf("  Size            %d\n", fib->Header.Size);
printf("  SenderSize      %d\n", fib->Header.SenderSize);
printf("  SenderAddress   0x%x\n", fib->Header.SenderFibAddress);
printf("  ReceiverAddress 0x%x\n", fib->Header.ReceiverFibAddress);
printf("  SenderData      0x%x\n", fib->Header.SenderData);
 2803         switch(fib->Header.Command) {
 2804         case ContainerCommand: {
 2805                 struct aac_blockread *br = (struct aac_blockread *)fib->data;
 2806                 struct aac_blockwrite *bw = (struct aac_blockwrite *)fib->data;
 2807                 struct aac_sg_table *sg = NULL;
 2808                 int i;
 2810                 if (br->Command == VM_CtBlockRead) {
printf("  BlockRead: container %d  0x%x/%d\n", 
br->ContainerId, br->BlockNumber, br->ByteCount);
sg = &br->SgMap;
 2814                 }
 2815                 if (bw->Command == VM_CtBlockWrite) {
printf("  BlockWrite: container %d  0x%x/%d (%s)\n", 
bw->ContainerId, bw->BlockNumber, bw->ByteCount,
bw->Stable == CSTABLE ? "stable" : "unstable");
sg = &bw->SgMap;
 2820                 }
 2821                 if (sg != NULL) {
printf("  %d s/g entries\n", sg->SgCount);
 2823                         for (i = 0; i < sg->SgCount; i++)
printf("  0x%08x/%d\n",
sg->SgEntry[i].SgAddress,
sg->SgEntry[i].SgByteCount);
 2827                 }
 2828                 break;
 2829         }
 2830         default:
printf("   %16D\n", fib->data, " ");
printf("   %16D\n", fib->data + 16, " ");
 2833         break;
 2834         }
 2835 }
 2837 /*
 2838  * Describe an AIF we have received.
 2839  */
 2840 void
aac_print_aif(struct aac_softc *sc, struct aac_aif_command *aif)
 2842 {
printf("%s: print_aif: ", sc->aac_dev.dv_xname);
 2845         switch(aif->command) {
 2846         case AifCmdEventNotify:
printf("EventNotify(%d)\n", aif->seqNumber);
 2849                 switch(aif->data.EN.type) {
 2850                 case AifEnGeneric:
 2851                         /* Generic notification */
printf("\t(Generic) %.*s\n", 
 2853                                (int)sizeof(aif->data.EN.data.EG),
aif->data.EN.data.EG.text);
 2855                         break;
 2856                 case AifEnTaskComplete:
 2857                         /* Task has completed */
printf("\t(TaskComplete)\n");
 2859                         break;
 2860                 case AifEnConfigChange:
 2861                         /* Adapter configuration change occurred */
printf("\t(ConfigChange)\n");
 2863                         break;
 2864                 case AifEnContainerChange:
 2865                         /* Adapter specific container configuration change */
printf("\t(ContainerChange) container %d,%d\n", 
aif->data.EN.data.ECC.container[0], 
aif->data.EN.data.ECC.container[1]);
 2869                         break;
 2870                 case AifEnDeviceFailure:
 2871                         /* SCSI device failed */
printf("\t(DeviceFailure) handle %d\n", 
aif->data.EN.data.EDF.deviceHandle);
 2874                         break;
 2875                 case AifEnMirrorFailover:
 2876                         /* Mirror failover started */
printf("\t(MirrorFailover) container %d failed, "
 2878                                "migrating from slice %d to %d\n",
aif->data.EN.data.EMF.container, 
aif->data.EN.data.EMF.failedSlice, 
aif->data.EN.data.EMF.creatingSlice);
 2882                         break;
 2883                 case AifEnContainerEvent:
 2884                         /* Significant container event */
printf("\t(ContainerEvent) container %d event %d\n",
aif->data.EN.data.ECE.container,
aif->data.EN.data.ECE.eventType);        
 2888                         break;
 2889                 case AifEnFileSystemChange:
 2890                         /* File system changed */
printf("\t(FileSystemChange)\n");
 2892                         break;
 2893                 case AifEnConfigPause:
 2894                         /* Container pause event */
printf("\t(ConfigPause)\n");
 2896                         break;
 2897                 case AifEnConfigResume:
 2898                         /* Container resume event */
printf("\t(ConfigResume)\n");
 2900                         break;
 2901                 case AifEnFailoverChange:
 2902                         /* Failover space assignment changed */
printf("\t(FailoverChange)\n");
 2904                         break;
 2905                 case AifEnRAID5RebuildDone:
 2906                         /* RAID5 rebuild finished */
printf("\t(RAID5RebuildDone)\n");
 2908                         break;
 2909                 case AifEnEnclosureManagement:
 2910                         /* Enclosure management event */
printf("\t(EnclosureManagement) EMPID %d unit %d "
 2912                                "event %d\n",
aif->data.EN.data.EEE.empID,
aif->data.EN.data.EEE.unitID, 
aif->data.EN.data.EEE.eventType);
 2916                         break;
 2917                 case AifEnBatteryEvent:
 2918                         /* Significant NV battery event */
printf("\t(BatteryEvent) %d (state was %d, is %d\n",
aif->data.EN.data.EBE.transition_type,
aif->data.EN.data.EBE.current_state,
aif->data.EN.data.EBE.prior_state);
 2923                         break;
 2924                 case AifEnAddContainer:
 2925                         /* A new container was created. */
printf("\t(AddContainer)\n");
 2927                         break;          
 2928                 case AifEnDeleteContainer:
 2929                         /* A container was deleted. */
printf("\t(DeleteContainer)\n");
 2931                         break;
 2932                 case AifEnBatteryNeedsRecond:
 2933                         /* The battery needs reconditioning */
printf("\t(BatteryNeedsRecond)\n");
 2935                         break;
 2936                 case AifEnClusterEvent:
 2937                         /* Some cluster event */
printf("\t(ClusterEvent) event %d\n", 
aif->data.EN.data.ECLE.eventType);
 2940                         break;
 2941                 case AifEnDiskSetEvent:
 2942                         /* A disk set event occured. */
printf("(DiskSetEvent) event %d "
 2944                                "diskset %lld creator %lld\n",
aif->data.EN.data.EDS.eventType, 
aif->data.EN.data.EDS.DsNum, 
aif->data.EN.data.EDS.CreatorId);
 2948                         break;
 2949                 case AifDenMorphComplete:
 2950                         /* A morph operation completed */
printf("\t(MorphComplete)\n");
 2952                         break;
 2953                 case AifDenVolumeExtendComplete:
 2954                         /* A volume expand operation completed */
printf("\t(VolumeExtendComplete)\n");
 2956                         break;
 2957                 default:
printf("\t(%d)\n", aif->data.EN.type);
 2959                         break;
 2960                 }
 2961                 break;
 2962         case AifCmdJobProgress:
 2963         {
 2964                 char    *status;
 2965                 switch(aif->data.PR[0].status) {
 2966                 case AifJobStsSuccess:
status = "success"; break;
 2968                 case AifJobStsFinished:
status = "finished"; break;
 2970                 case AifJobStsAborted:
status = "aborted"; break;
 2972                 case AifJobStsFailed:
status = "failed"; break;
 2974                 case AifJobStsSuspended:
status = "suspended"; break;
 2976                 case AifJobStsRunning:
status = "running"; break;
 2978                 default:
status = "unknown status"; break;
 2980                 }               
printf("JobProgress (%d) - %s (%d, %d)\n",
aif->seqNumber, status, 
aif->data.PR[0].currentTick,
aif->data.PR[0].finalTick);
 2987                 switch(aif->data.PR[0].jd.type) {
 2988                 case AifJobScsiZero:
 2989                         /* SCSI dev clear operation */
printf("\t(ScsiZero) handle %d\n",
aif->data.PR[0].jd.client.scsi_dh);
 2992                         break;
 2993                 case AifJobScsiVerify:
 2994                         /* SCSI device Verify operation NO REPAIR */
printf("\t(ScsiVerify) handle %d\n",
aif->data.PR[0].jd.client.scsi_dh);
 2997                         break;
 2998                 case AifJobScsiExercise:
 2999                         /* SCSI device Exercise operation */
printf("\t(ScsiExercise) handle %d\n",
aif->data.PR[0].jd.client.scsi_dh);
 3002                         break;
 3003                 case AifJobScsiVerifyRepair:
 3004                         /* SCSI device Verify operation WITH repair */
printf("\t(ScsiVerifyRepair) handle %d\n",
aif->data.PR[0].jd.client.scsi_dh);
 3007                         break;
 3008                 case AifJobCtrZero:
 3009                         /* Container clear operation */
printf("\t(ContainerZero) container %d\n", 
aif->data.PR[0].jd.client.container.src);
 3012                         break;
 3013                 case AifJobCtrCopy:
 3014                         /* Container copy operation */
printf("\t(ContainerCopy) container %d to %d\n", 
aif->data.PR[0].jd.client.container.src,
aif->data.PR[0].jd.client.container.dst);
 3018                         break;
 3019                 case AifJobCtrCreateMirror:
 3020                         /* Container Create Mirror operation */
printf("\t(ContainerCreateMirror) container %d\n",
aif->data.PR[0].jd.client.container.src);
 3023                         /* XXX two containers? */
 3024                         break;
 3025                 case AifJobCtrMergeMirror:
 3026                         /* Container Merge Mirror operation */
printf("\t(ContainerMergeMirror) container %d\n",
aif->data.PR[0].jd.client.container.src);
 3029                         /* XXX two containers? */
 3030                         break;
 3031                 case AifJobCtrScrubMirror:
 3032                         /* Container Scrub Mirror operation */
printf("\t(ContainerScrubMirror) container %d\n",
aif->data.PR[0].jd.client.container.src);
 3035                         break;
 3036                 case AifJobCtrRebuildRaid5:
 3037                         /* Container Rebuild Raid5 operation */
printf("\t(ContainerRebuildRaid5) container %d\n",
aif->data.PR[0].jd.client.container.src);
 3040                         break;
 3041                 case AifJobCtrScrubRaid5:
 3042                         /* Container Scrub Raid5 operation */
printf("\t(ContainerScrubRaid5) container %d\n", 
aif->data.PR[0].jd.client.container.src);
 3045                         break;
 3046                 case AifJobCtrMorph:
 3047                         /* Container morph operation */
printf("\t(ContainerMorph) container %d\n",
aif->data.PR[0].jd.client.container.src);
 3050                         /* XXX two containers? */
 3051                         break;
 3052                 case AifJobCtrPartCopy:
 3053                         /* Container Partition copy operation */
printf("\t(ContainerPartCopy) container %d to %d\n",
aif->data.PR[0].jd.client.container.src,
aif->data.PR[0].jd.client.container.dst);
 3057                         break;
 3058                 case AifJobCtrRebuildMirror:
 3059                         /* Container Rebuild Mirror operation */
printf("\t(ContainerRebuildMirror) container %d\n",
aif->data.PR[0].jd.client.container.src);
 3062                         break;
 3063                 case AifJobCtrCrazyCache:
 3064                         /* crazy cache */
printf("\t(ContainerCrazyCache) container %d\n", 
aif->data.PR[0].jd.client.container.src);
 3067                         /* XXX two containers? */
 3068                         break;
 3069                 case AifJobFsCreate:
 3070                         /* File System Create operation */
printf("\t(FsCreate)\n");
 3072                         break;
 3073                 case AifJobFsVerify:
 3074                         /* File System Verify operation */
printf("\t(FsVerivy)\n");
 3076                         break;
 3077                 case AifJobFsExtend:
 3078                         /* File System Extend operation */
printf("\t(FsExtend)\n");
 3080                         break;
 3081                 case AifJobApiFormatNTFS:
 3082                         /* Format a drive to NTFS */
printf("\t(FormatNTFS)\n");
 3084                         break;
 3085                 case AifJobApiFormatFAT:
 3086                         /* Format a drive to FAT */
printf("\t(FormatFAT)\n");
 3088                         break;
 3089                 case AifJobApiUpdateSnapshot:
 3090                         /* update the read/write half of a snapshot */
printf("\t(UpdateSnapshot)\n");
 3092                         break;
 3093                 case AifJobApiFormatFAT32:
 3094                         /* Format a drive to FAT32 */
printf("\t(FormatFAT32)\n");
 3096                         break;
 3097                 case AifJobCtlContinuousCtrVerify:
 3098                         /* Adapter operation */
printf("\t(ContinuousCtrVerify)\n");
 3100                         break;
 3101                 default:
printf("\t(%d)\n", aif->data.PR[0].jd.type);
 3103                         break;
 3104                 }
 3105                 break;
 3106         }
 3107         case AifCmdAPIReport:
printf("APIReport (%d)\n", aif->seqNumber);
 3109                 break;
 3110         case AifCmdDriverNotify:
printf("DriverNotify (%d)\n", aif->seqNumber);
 3112                 break;
 3113         default:
printf("AIF %d (%d)\n", aif->command, aif->seqNumber);
 3115                 break;
 3116         }
 3117 }
 3118 #endif