MP Implementation 1/2: Get the APIC code working again, sweetly integrate the
[dragonfly.git] / sys / dev / raid / aac / aacvar.h
1 /*-
2  * Copyright (c) 2000 Michael Smith
3  * Copyright (c) 2001 Scott Long
4  * Copyright (c) 2000 BSDi
5  * Copyright (c) 2001 Adaptec, Inc.
6  * All rights reserved.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in the
15  *    documentation and/or other materials provided with the distribution.
16  *
17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27  * SUCH DAMAGE.
28  *
29  *      $FreeBSD: src/sys/dev/aac/aacvar.h,v 1.4.2.7 2003/04/08 13:22:08 scottl Exp $
30  *      $DragonFly: src/sys/dev/raid/aac/aacvar.h,v 1.4 2003/07/06 21:23:47 dillon Exp $
31  */
32
33 /*
34  * Driver Parameter Definitions
35  */
36
37 /*
38  * The firmware interface allows for a 16-bit s/g list length.  We limit 
39  * ourselves to a reasonable maximum and ensure alignment.
40  */
41 #define AAC_MAXSGENTRIES        64      /* max S/G entries, limit 65535 */              
42
43 /*
44  * We allocate a small set of FIBs for the adapter to use to send us messages.
45  */
46 #define AAC_ADAPTER_FIBS        8
47
48 /*
49  * FIBs are allocated up-front, and the pool isn't grown.  We should allocate
50  * enough here to let us keep the adapter busy without wasting large amounts
51  * of kernel memory.  The current interface implementation limits us to 512
52  * FIBs queued for the adapter at any one time.
53  */
54 #define AAC_FIB_COUNT           128
55
56 /*
57  * The controller reports status events in AIFs.  We hang on to a number of
58  * these in order to pass them out to user-space management tools.
59  */
60 #define AAC_AIFQ_LENGTH         64
61
62 /*
63  * Firmware messages are passed in the printf buffer.
64  */
65 #define AAC_PRINTF_BUFSIZE      256
66
67 /*
68  * We wait this many seconds for the adapter to come ready if it is still 
69  * booting
70  */
71 #define AAC_BOOT_TIMEOUT        (3 * 60)
72
73 /*
74  * Timeout for immediate commands.
75  */
76 #define AAC_IMMEDIATE_TIMEOUT   30              /* seconds */
77
78 /*
79  * Timeout for normal commands
80  */
81 #define AAC_CMD_TIMEOUT         30              /* seconds */
82
83 /*
84  * Rate at which we periodically check for timed out commands and kick the
85  * controller.
86  */
87 #define AAC_PERIODIC_INTERVAL   20              /* seconds */
88
89 /*
90  * Character device major numbers.
91  */
92 #define AAC_DISK_MAJOR  200
93
94 /*
95  * Driver Variable Definitions
96  */
97
98 #if __FreeBSD_version >= 500005
99 # include <sys/taskqueue.h>
100 #endif
101
102 /*
103  * Per-container data structure
104  */
105 struct aac_container
106 {
107         struct aac_mntobj               co_mntobj;
108         device_t                        co_disk;
109         int                             co_found;
110         TAILQ_ENTRY(aac_container)      co_link;
111 };
112
113 /*
114  * Per-disk structure
115  */
116 struct aac_disk 
117 {
118         device_t                        ad_dev;
119         dev_t                           ad_dev_t;
120         struct aac_softc                *ad_controller;
121         struct aac_container            *ad_container;
122         struct disk                     ad_disk;
123         struct devstat                  ad_stats;
124         struct disklabel                ad_label;
125         int                             ad_flags;
126 #define AAC_DISK_OPEN   (1<<0)
127         int                             ad_cylinders;
128         int                             ad_heads;
129         int                             ad_sectors;
130         u_int32_t                       ad_size;
131         int                             unit;
132 };
133
134 /*
135  * Per-command control structure.
136  */
137 struct aac_command
138 {
139         TAILQ_ENTRY(aac_command) cm_link;       /* list linkage */
140
141         struct aac_softc        *cm_sc;         /* controller that owns us */
142
143         struct aac_fib          *cm_fib;        /* FIB associated with this
144                                                  * command */
145         u_int32_t               cm_fibphys;     /* bus address of the FIB */
146         struct bio              *cm_data;       /* pointer to data in kernel
147                                                  * space */
148         u_int32_t               cm_datalen;     /* data length */
149         bus_dmamap_t            cm_datamap;     /* DMA map for bio data */
150         struct aac_sg_table     *cm_sgtable;    /* pointer to s/g table in
151                                                  * command */
152         int                     cm_flags;
153 #define AAC_CMD_MAPPED          (1<<0)          /* command has had its data
154                                                  * mapped */
155 #define AAC_CMD_DATAIN          (1<<1)          /* command involves data moving
156                                                  * from controller to host */
157 #define AAC_CMD_DATAOUT         (1<<2)          /* command involves data moving
158                                                  * from host to controller */
159 #define AAC_CMD_COMPLETED       (1<<3)          /* command has been completed */
160 #define AAC_CMD_TIMEDOUT        (1<<4)          /* command taken too long */
161 #define AAC_ON_AACQ_FREE        (1<<5)
162 #define AAC_ON_AACQ_READY       (1<<6)
163 #define AAC_ON_AACQ_BUSY        (1<<7)
164 #define AAC_ON_AACQ_COMPLETE    (1<<8)
165 #define AAC_ON_AACQ_MASK        ((1<<5)|(1<<6)|(1<<7)|(1<<8))
166
167         void                    (* cm_complete)(struct aac_command *cm);
168         void                    *cm_private;
169         time_t                  cm_timestamp;   /* command creation time */
170         int                     cm_queue;
171 };
172
173 /*
174  * We gather a number of adapter-visible items into a single structure.
175  *
176  * The ordering of this strucure may be important; we copy the Linux driver:
177  *
178  * Adapter FIBs
179  * Init struct
180  * Queue headers (Comm Area)
181  * Printf buffer
182  *
183  * In addition, we add:
184  * Sync Fib
185  */
186 struct aac_common {
187         /* fibs for the controller to send us messages */
188         struct aac_fib          ac_fibs[AAC_ADAPTER_FIBS];
189
190         /* the init structure */
191         struct aac_adapter_init ac_init;
192
193         /* arena within which the queue structures are kept */
194         u_int8_t                ac_qbuf[sizeof(struct aac_queue_table) +
195                                 AAC_QUEUE_ALIGN];
196
197         /* buffer for text messages from the controller */
198         char                    ac_printf[AAC_PRINTF_BUFSIZE];
199         
200         /* fib for synchronous commands */
201         struct aac_fib          ac_sync_fib;
202 };
203
204 /*
205  * Interface operations
206  */
207 struct aac_interface 
208 {
209         int     (*aif_get_fwstatus)(struct aac_softc *sc);
210         void    (*aif_qnotify)(struct aac_softc *sc, int qbit);
211         int     (*aif_get_istatus)(struct aac_softc *sc);
212         void    (*aif_clr_istatus)(struct aac_softc *sc, int mask);
213         void    (*aif_set_mailbox)(struct aac_softc *sc, u_int32_t command,
214                                    u_int32_t arg0, u_int32_t arg1,
215                                    u_int32_t arg2, u_int32_t arg3);
216         int     (*aif_get_mailbox)(struct aac_softc *sc, int mb);
217         void    (*aif_set_interrupts)(struct aac_softc *sc, int enable);
218 };
219 extern struct aac_interface     aac_rx_interface;
220 extern struct aac_interface     aac_sa_interface;
221 extern struct aac_interface     aac_fa_interface;
222
223 #define AAC_GET_FWSTATUS(sc)            ((sc)->aac_if.aif_get_fwstatus((sc)))
224 #define AAC_QNOTIFY(sc, qbit)           ((sc)->aac_if.aif_qnotify((sc), (qbit)))
225 #define AAC_GET_ISTATUS(sc)             ((sc)->aac_if.aif_get_istatus((sc)))
226 #define AAC_CLEAR_ISTATUS(sc, mask)     ((sc)->aac_if.aif_clr_istatus((sc), \
227                                         (mask)))
228 #define AAC_SET_MAILBOX(sc, command, arg0, arg1, arg2, arg3) \
229         ((sc)->aac_if.aif_set_mailbox((sc), (command), (arg0), (arg1), (arg2), \
230         (arg3)))
231 #define AAC_GET_MAILBOX(sc, mb)         ((sc)->aac_if.aif_get_mailbox((sc), \
232                                         (mb)))
233 #define AAC_MASK_INTERRUPTS(sc)         ((sc)->aac_if.aif_set_interrupts((sc), \
234                                         0))
235 #define AAC_UNMASK_INTERRUPTS(sc)       ((sc)->aac_if.aif_set_interrupts((sc), \
236                                         1))
237
238 #define AAC_SETREG4(sc, reg, val)       bus_space_write_4(sc->aac_btag, \
239                                         sc->aac_bhandle, reg, val)
240 #define AAC_GETREG4(sc, reg)            bus_space_read_4 (sc->aac_btag, \
241                                         sc->aac_bhandle, reg)
242 #define AAC_SETREG2(sc, reg, val)       bus_space_write_2(sc->aac_btag, \
243                                         sc->aac_bhandle, reg, val)
244 #define AAC_GETREG2(sc, reg)            bus_space_read_2 (sc->aac_btag, \
245                                         sc->aac_bhandle, reg)
246 #define AAC_SETREG1(sc, reg, val)       bus_space_write_1(sc->aac_btag, \
247                                         sc->aac_bhandle, reg, val)
248 #define AAC_GETREG1(sc, reg)            bus_space_read_1 (sc->aac_btag, \
249                                         sc->aac_bhandle, reg)
250
251 TAILQ_HEAD(aac_container_tq, aac_container);
252
253 /* Define the OS version specific locks */
254 #if __FreeBSD_version >= 500005
255 #include <sys/lock.h>
256 #include <sys/mutex.h>
257 typedef struct mtx aac_lock_t;
258 #define AAC_LOCK_INIT(l, s)     mtx_init(l, s, MTX_DEF)
259 #define AAC_LOCK_ACQUIRE(l)     mtx_lock(l)
260 #define AAC_LOCK_RELEASE(l)     mtx_unlock(l)
261 #else
262 typedef struct lwkt_token aac_lock_t;
263 #define AAC_LOCK_INIT(l, s)     lwkt_inittoken(l)
264 #define AAC_LOCK_ACQUIRE(l)     lwkt_gettoken(l)
265 #define AAC_LOCK_RELEASE(l)     lwkt_reltoken(l)
266 #endif
267
268 #if __FreeBSD_version >= 500005
269 #include <sys/selinfo.h>
270 #else
271 #include <sys/select.h>
272 #endif
273
274 /*
275  * Per-controller structure.
276  */
277 struct aac_softc 
278 {
279         /* bus connections */
280         device_t                aac_dev;
281         struct resource         *aac_regs_resource;     /* register interface
282                                                          * window */
283         int                     aac_regs_rid;           /* resource ID */
284         bus_space_handle_t      aac_bhandle;            /* bus space handle */
285         bus_space_tag_t         aac_btag;               /* bus space tag */
286         bus_dma_tag_t           aac_parent_dmat;        /* parent DMA tag */
287         bus_dma_tag_t           aac_buffer_dmat;        /* data buffer/command
288                                                          * DMA tag */
289         struct resource         *aac_irq;               /* interrupt */
290         int                     aac_irq_rid;
291         void                    *aac_intr;              /* interrupt handle */
292
293         /* controller features, limits and status */
294         int                     aac_state;
295 #define AAC_STATE_SUSPEND       (1<<0)
296 #define AAC_STATE_OPEN          (1<<1)
297 #define AAC_STATE_INTERRUPTS_ON (1<<2)
298 #define AAC_STATE_AIF_SLEEPER   (1<<3)
299         struct FsaRevision              aac_revision;
300
301         /* controller hardware interface */
302         int                     aac_hwif;
303 #define AAC_HWIF_I960RX         0
304 #define AAC_HWIF_STRONGARM      1
305 #define AAC_HWIF_FALCON         2
306 #define AAC_HWIF_UNKNOWN        -1
307         bus_dma_tag_t           aac_common_dmat;        /* common structure
308                                                          * DMA tag */
309         bus_dmamap_t            aac_common_dmamap;      /* common structure
310                                                          * DMA map */
311         struct aac_common       *aac_common;
312         u_int32_t               aac_common_busaddr;
313         struct aac_interface    aac_if;
314
315         /* command/fib resources */
316         bus_dma_tag_t           aac_fib_dmat;   /* DMA tag for allocing FIBs */
317         struct aac_fib          *aac_fibs;
318         bus_dmamap_t            aac_fibmap;
319         u_int32_t               aac_fibphys;
320         struct aac_command      aac_command[AAC_FIB_COUNT];
321
322         /* command management */
323         TAILQ_HEAD(,aac_command) aac_free;      /* command structures 
324                                                  * available for reuse */
325         TAILQ_HEAD(,aac_command) aac_ready;     /* commands on hold for
326                                                  * controller resources */
327         TAILQ_HEAD(,aac_command) aac_busy;
328         TAILQ_HEAD(,aac_command) aac_complete;  /* commands which have been
329                                                  * returned by the controller */
330         struct bio_queue_head   aac_bioq;
331         struct aac_queue_table  *aac_queues;
332         struct aac_queue_entry  *aac_qentries[AAC_QUEUE_COUNT];
333
334         struct aac_qstat        aac_qstat[AACQ_COUNT];  /* queue statistics */
335
336         /* connected containters */
337         struct aac_container_tq aac_container_tqh;
338         aac_lock_t              aac_container_lock;
339
340         /* Protect the sync fib */
341 #define AAC_SYNC_LOCK_FORCE     (1 << 0)
342         aac_lock_t              aac_sync_lock;
343
344         /* delayed activity infrastructure */
345 #if __FreeBSD_version >= 500005
346         struct task             aac_task_complete;      /* deferred-completion
347                                                          * task */
348 #endif
349         struct intr_config_hook aac_ich;
350
351         /* management interface */
352         dev_t                   aac_dev_t;
353         aac_lock_t              aac_aifq_lock;
354         struct aac_aif_command  aac_aifq[AAC_AIFQ_LENGTH];
355         int                     aac_aifq_head;
356         int                     aac_aifq_tail;
357         struct selinfo          rcv_select;
358         struct thread           *aifthread;
359         int                     aifflags;
360 #define AAC_AIFFLAGS_RUNNING    (1 << 0)
361 #define AAC_AIFFLAGS_PENDING    (1 << 1)
362 #define AAC_AIFFLAGS_EXIT       (1 << 2)
363 #define AAC_AIFFLAGS_EXITED     (1 << 3)
364         u_int32_t               flags;
365 #define AAC_FLAGS_PERC2QC       (1 << 0)
366 #define AAC_FLAGS_ENABLE_CAM    (1 << 1)        /* No SCSI passthrough */
367 #define AAC_FLAGS_CAM_NORESET   (1 << 2)        /* Fake SCSI resets */
368 #define AAC_FLAGS_CAM_PASSONLY  (1 << 3)        /* Only create pass devices */
369 #define AAC_FLAGS_4GB_WINDOW    (1 << 5)        /* Device can access host mem
370                                                  * 2GB-4GB range */
371 #define AAC_FLAGS_NO4GB         (1 << 6)        /* Can't access host mem >2GB */
372 #define AAC_FLAGS_256FIBS       (1 << 7)        /* Can only do 256 commands */
373   
374         u_int32_t               supported_options;
375         u_int32_t               scsi_method_id;
376 };
377
378
379 /*
380  * Public functions
381  */
382 extern void             aac_free(struct aac_softc *sc);
383 extern int              aac_attach(struct aac_softc *sc);
384 extern int              aac_detach(device_t dev);
385 extern int              aac_shutdown(device_t dev);
386 extern int              aac_suspend(device_t dev); 
387 extern int              aac_resume(device_t dev);
388 extern void             aac_intr(void *arg);
389 extern devclass_t       aac_devclass;
390 extern void             aac_submit_bio(struct bio *bp);
391 extern void             aac_biodone(struct bio *bp);
392 extern int              aac_dump_enqueue(struct aac_disk *ad, u_int32_t lba,
393                                          void *data, int nblks);
394 extern void             aac_dump_complete(struct aac_softc *sc);
395 extern void             aac_startio(struct aac_softc *sc);
396 extern int              aac_alloc_command(struct aac_softc *sc,
397                                           struct aac_command **cmp);
398 extern void             aac_release_command(struct aac_command *cm);
399 extern int              aac_alloc_sync_fib(struct aac_softc *sc,
400                                          struct aac_fib **fib, int flags);
401 extern void             aac_release_sync_fib(struct aac_softc *sc);
402 extern int              aac_sync_fib(struct aac_softc *sc, u_int32_t command,
403                                      u_int32_t xferstate, struct aac_fib *fib,
404                                      u_int16_t datasize);
405
406 /*
407  * Debugging levels:
408  *  0 - quiet, only emit warnings
409  *  1 - noisy, emit major function points and things done
410  *  2 - extremely noisy, emit trace items in loops, etc.
411  */
412 #ifdef AAC_DEBUG
413 # define debug(level, fmt, args...)                                     \
414         do {                                                            \
415         if (level <=AAC_DEBUG) printf("%s: " fmt "\n", __FUNCTION__ , ##args); \
416         } while (0)
417 # define debug_called(level)                                            \
418         do {                                                            \
419         if (level <= AAC_DEBUG) printf(__FUNCTION__ ": called\n");      \
420         } while (0)
421
422 extern void     aac_print_queues(struct aac_softc *sc);
423 extern void     aac_panic(struct aac_softc *sc, char *reason);
424 extern void     aac_print_fib(struct aac_softc *sc, struct aac_fib *fib,
425                               char *caller);
426 extern void     aac_print_aif(struct aac_softc *sc,
427                               struct aac_aif_command *aif);
428
429 # define AAC_PRINT_FIB(sc, fib) aac_print_fib(sc, fib, __FUNCTION__)
430
431 #else
432 # define debug(level, fmt, args...)
433 # define debug_called(level)
434
435 # define aac_print_queues(sc)
436 # define aac_panic(sc, reason)
437
438 # define AAC_PRINT_FIB(sc, fib)
439 # define aac_print_aif(sc, aac_aif_command)
440 #endif
441
442 struct aac_code_lookup {
443         char    *string;
444         u_int32_t       code;
445 };
446
447 /*
448  * Queue primitives for driver queues.
449  */
450 #define AACQ_ADD(sc, qname)                                     \
451         do {                                                    \
452                 struct aac_qstat *qs;                           \
453                                                                 \
454                 qs = &(sc)->aac_qstat[qname];                   \
455                                                                 \
456                 qs->q_length++;                                 \
457                 if (qs->q_length > qs->q_max)                   \
458                         qs->q_max = qs->q_length;               \
459         } while (0)
460
461 #define AACQ_REMOVE(sc, qname)    (sc)->aac_qstat[qname].q_length--
462 #define AACQ_INIT(sc, qname)                            \
463         do {                                            \
464                 sc->aac_qstat[qname].q_length = 0;      \
465                 sc->aac_qstat[qname].q_max = 0;         \
466         } while (0)
467
468
469 #define AACQ_COMMAND_QUEUE(name, index)                                 \
470 static __inline void                                                    \
471 aac_initq_ ## name (struct aac_softc *sc)                               \
472 {                                                                       \
473         TAILQ_INIT(&sc->aac_ ## name);                                  \
474         AACQ_INIT(sc, index);                                           \
475 }                                                                       \
476 static __inline void                                                    \
477 aac_enqueue_ ## name (struct aac_command *cm)                           \
478 {                                                                       \
479         int s;                                                          \
480                                                                         \
481         s = splbio();                                                   \
482         if ((cm->cm_flags & AAC_ON_AACQ_MASK) != 0) {                   \
483                 printf("command %p is on another queue, flags = %#x\n", \
484                        cm, cm->cm_flags);                               \
485                 panic("command is on another queue");                   \
486         }                                                               \
487         TAILQ_INSERT_TAIL(&cm->cm_sc->aac_ ## name, cm, cm_link);       \
488         cm->cm_flags |= AAC_ON_ ## index;                               \
489         AACQ_ADD(cm->cm_sc, index);                                     \
490         splx(s);                                                        \
491 }                                                                       \
492 static __inline void                                                    \
493 aac_requeue_ ## name (struct aac_command *cm)                           \
494 {                                                                       \
495         int s;                                                          \
496                                                                         \
497         s = splbio();                                                   \
498         if ((cm->cm_flags & AAC_ON_AACQ_MASK) != 0) {                   \
499                 printf("command %p is on another queue, flags = %#x\n", \
500                        cm, cm->cm_flags);                               \
501                 panic("command is on another queue");                   \
502         }                                                               \
503         TAILQ_INSERT_HEAD(&cm->cm_sc->aac_ ## name, cm, cm_link);       \
504         cm->cm_flags |= AAC_ON_ ## index;                               \
505         AACQ_ADD(cm->cm_sc, index);                                     \
506         splx(s);                                                        \
507 }                                                                       \
508 static __inline struct aac_command *                                    \
509 aac_dequeue_ ## name (struct aac_softc *sc)                             \
510 {                                                                       \
511         struct aac_command *cm;                                         \
512         int s;                                                          \
513                                                                         \
514         s = splbio();                                                   \
515         if ((cm = TAILQ_FIRST(&sc->aac_ ## name)) != NULL) {            \
516                 if ((cm->cm_flags & AAC_ON_ ## index) == 0) {           \
517                         printf("command %p not in queue, flags = %#x, " \
518                                "bit = %#x\n", cm, cm->cm_flags,         \
519                                AAC_ON_ ## index);                       \
520                         panic("command not in queue");                  \
521                 }                                                       \
522                 TAILQ_REMOVE(&sc->aac_ ## name, cm, cm_link);           \
523                 cm->cm_flags &= ~AAC_ON_ ## index;                      \
524                 AACQ_REMOVE(sc, index);                                 \
525         }                                                               \
526         splx(s);                                                        \
527         return(cm);                                                     \
528 }                                                                       \
529 static __inline void                                                    \
530 aac_remove_ ## name (struct aac_command *cm)                            \
531 {                                                                       \
532         int s;                                                          \
533                                                                         \
534         s = splbio();                                                   \
535         if ((cm->cm_flags & AAC_ON_ ## index) == 0) {                   \
536                 printf("command %p not in queue, flags = %#x, "         \
537                        "bit = %#x\n", cm, cm->cm_flags,                 \
538                        AAC_ON_ ## index);                               \
539                 panic("command not in queue");                          \
540         }                                                               \
541         TAILQ_REMOVE(&cm->cm_sc->aac_ ## name, cm, cm_link);            \
542         cm->cm_flags &= ~AAC_ON_ ## index;                              \
543         AACQ_REMOVE(cm->cm_sc, index);                                  \
544         splx(s);                                                        \
545 }                                                                       \
546 struct hack
547
548 AACQ_COMMAND_QUEUE(free, AACQ_FREE);
549 AACQ_COMMAND_QUEUE(ready, AACQ_READY);
550 AACQ_COMMAND_QUEUE(busy, AACQ_BUSY);
551 AACQ_COMMAND_QUEUE(complete, AACQ_COMPLETE);
552
553 /*
554  * outstanding bio queue
555  */
556 static __inline void
557 aac_initq_bio(struct aac_softc *sc)
558 {
559         bioq_init(&sc->aac_bioq);
560         AACQ_INIT(sc, AACQ_BIO);
561 }
562
563 static __inline void
564 aac_enqueue_bio(struct aac_softc *sc, struct bio *bp)
565 {
566         int s;
567
568         s = splbio();
569         bioq_insert_tail(&sc->aac_bioq, bp);
570         AACQ_ADD(sc, AACQ_BIO);
571         splx(s);
572 }
573
574 static __inline struct bio *
575 aac_dequeue_bio(struct aac_softc *sc)
576 {
577         int s;
578         struct bio *bp;
579
580         s = splbio();
581         if ((bp = bioq_first(&sc->aac_bioq)) != NULL) {
582                 bioq_remove(&sc->aac_bioq, bp);
583                 AACQ_REMOVE(sc, AACQ_BIO);
584         }
585         splx(s);
586         return(bp);
587 }
588
589 static __inline void
590 aac_print_printf(struct aac_softc *sc)
591 {
592         /*
593          * XXX We have the ability to read the length of the printf string
594          * from out of the mailboxes.
595          */
596         device_printf(sc->aac_dev, "**Monitor** %.*s", AAC_PRINTF_BUFSIZE,
597                       sc->aac_common->ac_printf);
598         AAC_QNOTIFY(sc, AAC_DB_PRINTF);
599 }