aac.c revision 174412 
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
30#include <sys/cdefs.h>
31__FBSDID("$FreeBSD: head/sys/dev/aac/aac.c 174412 2007-12-07 18:05:41Z emaste $");
32
33/*
34 * Driver for the Adaptec 'FSA' family of PCI/SCSI RAID adapters.
35 */
36#define AAC_DRIVER_VERSION		0x02000000
37#define AAC_DRIVERNAME			"aac"
38
39#include "opt_aac.h"
40
41/* #include <stddef.h> */
42#include <sys/param.h>
43#include <sys/systm.h>
44#include <sys/malloc.h>
45#include <sys/kernel.h>
46#include <sys/kthread.h>
47#include <sys/sysctl.h>
48#include <sys/poll.h>
49#include <sys/ioccom.h>
50
51#include <sys/bus.h>
52#include <sys/conf.h>
53#include <sys/signalvar.h>
54#include <sys/time.h>
55#include <sys/eventhandler.h>
56#include <sys/rman.h>
57
58#include <machine/bus.h>
59#include <sys/bus_dma.h>
60#include <machine/resource.h>
61
62#include <dev/pci/pcireg.h>
63#include <dev/pci/pcivar.h>
64
65#include <dev/aac/aacreg.h>
66#include <sys/aac_ioctl.h>
67#include <dev/aac/aacvar.h>
68#include <dev/aac/aac_tables.h>
69
70static void	aac_startup(void *arg);
71static void	aac_add_container(struct aac_softc *sc,
72				  struct aac_mntinforesp *mir, int f);
73static void	aac_get_bus_info(struct aac_softc *sc);
74
75/* Command Processing */
76static void	aac_timeout(struct aac_softc *sc);
77static void	aac_complete(void *context, int pending);
78static int	aac_bio_command(struct aac_softc *sc, struct aac_command **cmp);
79static void	aac_bio_complete(struct aac_command *cm);
80static int	aac_wait_command(struct aac_command *cm);
81static void	aac_command_thread(struct aac_softc *sc);
82
83/* Command Buffer Management */
84static void	aac_map_command_sg(void *arg, bus_dma_segment_t *segs,
85				   int nseg, int error);
86static void	aac_map_command_helper(void *arg, bus_dma_segment_t *segs,
87				       int nseg, int error);
88static int	aac_alloc_commands(struct aac_softc *sc);
89static void	aac_free_commands(struct aac_softc *sc);
90static void	aac_unmap_command(struct aac_command *cm);
91
92/* Hardware Interface */
93static void	aac_common_map(void *arg, bus_dma_segment_t *segs, int nseg,
94			       int error);
95static int	aac_check_firmware(struct aac_softc *sc);
96static int	aac_init(struct aac_softc *sc);
97static int	aac_sync_command(struct aac_softc *sc, u_int32_t command,
98				 u_int32_t arg0, u_int32_t arg1, u_int32_t arg2,
99				 u_int32_t arg3, u_int32_t *sp);
100static int	aac_enqueue_fib(struct aac_softc *sc, int queue,
101				struct aac_command *cm);
102static int	aac_dequeue_fib(struct aac_softc *sc, int queue,
103				u_int32_t *fib_size, struct aac_fib **fib_addr);
104static int	aac_enqueue_response(struct aac_softc *sc, int queue,
105				     struct aac_fib *fib);
106
107/* Falcon/PPC interface */
108static int	aac_fa_get_fwstatus(struct aac_softc *sc);
109static void	aac_fa_qnotify(struct aac_softc *sc, int qbit);
110static int	aac_fa_get_istatus(struct aac_softc *sc);
111static void	aac_fa_clear_istatus(struct aac_softc *sc, int mask);
112static void	aac_fa_set_mailbox(struct aac_softc *sc, u_int32_t command,
113				   u_int32_t arg0, u_int32_t arg1,
114				   u_int32_t arg2, u_int32_t arg3);
115static int	aac_fa_get_mailbox(struct aac_softc *sc, int mb);
116static void	aac_fa_set_interrupts(struct aac_softc *sc, int enable);
117
118struct aac_interface aac_fa_interface = {
119	aac_fa_get_fwstatus,
120	aac_fa_qnotify,
121	aac_fa_get_istatus,
122	aac_fa_clear_istatus,
123	aac_fa_set_mailbox,
124	aac_fa_get_mailbox,
125	aac_fa_set_interrupts,
126	NULL, NULL, NULL
127};
128
129/* StrongARM interface */
130static int	aac_sa_get_fwstatus(struct aac_softc *sc);
131static void	aac_sa_qnotify(struct aac_softc *sc, int qbit);
132static int	aac_sa_get_istatus(struct aac_softc *sc);
133static void	aac_sa_clear_istatus(struct aac_softc *sc, int mask);
134static void	aac_sa_set_mailbox(struct aac_softc *sc, u_int32_t command,
135				   u_int32_t arg0, u_int32_t arg1,
136				   u_int32_t arg2, u_int32_t arg3);
137static int	aac_sa_get_mailbox(struct aac_softc *sc, int mb);
138static void	aac_sa_set_interrupts(struct aac_softc *sc, int enable);
139
140struct aac_interface aac_sa_interface = {
141	aac_sa_get_fwstatus,
142	aac_sa_qnotify,
143	aac_sa_get_istatus,
144	aac_sa_clear_istatus,
145	aac_sa_set_mailbox,
146	aac_sa_get_mailbox,
147	aac_sa_set_interrupts,
148	NULL, NULL, NULL
149};
150
151/* i960Rx interface */
152static int	aac_rx_get_fwstatus(struct aac_softc *sc);
153static void	aac_rx_qnotify(struct aac_softc *sc, int qbit);
154static int	aac_rx_get_istatus(struct aac_softc *sc);
155static void	aac_rx_clear_istatus(struct aac_softc *sc, int mask);
156static void	aac_rx_set_mailbox(struct aac_softc *sc, u_int32_t command,
157				   u_int32_t arg0, u_int32_t arg1,
158				   u_int32_t arg2, u_int32_t arg3);
159static int	aac_rx_get_mailbox(struct aac_softc *sc, int mb);
160static void	aac_rx_set_interrupts(struct aac_softc *sc, int enable);
161static int aac_rx_send_command(struct aac_softc *sc, struct aac_command *cm);
162static int aac_rx_get_outb_queue(struct aac_softc *sc);
163static void aac_rx_set_outb_queue(struct aac_softc *sc, int index);
164
165struct aac_interface aac_rx_interface = {
166	aac_rx_get_fwstatus,
167	aac_rx_qnotify,
168	aac_rx_get_istatus,
169	aac_rx_clear_istatus,
170	aac_rx_set_mailbox,
171	aac_rx_get_mailbox,
172	aac_rx_set_interrupts,
173	aac_rx_send_command,
174	aac_rx_get_outb_queue,
175	aac_rx_set_outb_queue
176};
177
178/* Rocket/MIPS interface */
179static int	aac_rkt_get_fwstatus(struct aac_softc *sc);
180static void	aac_rkt_qnotify(struct aac_softc *sc, int qbit);
181static int	aac_rkt_get_istatus(struct aac_softc *sc);
182static void	aac_rkt_clear_istatus(struct aac_softc *sc, int mask);
183static void	aac_rkt_set_mailbox(struct aac_softc *sc, u_int32_t command,
184				    u_int32_t arg0, u_int32_t arg1,
185				    u_int32_t arg2, u_int32_t arg3);
186static int	aac_rkt_get_mailbox(struct aac_softc *sc, int mb);
187static void	aac_rkt_set_interrupts(struct aac_softc *sc, int enable);
188static int aac_rkt_send_command(struct aac_softc *sc, struct aac_command *cm);
189static int aac_rkt_get_outb_queue(struct aac_softc *sc);
190static void aac_rkt_set_outb_queue(struct aac_softc *sc, int index);
191
192struct aac_interface aac_rkt_interface = {
193	aac_rkt_get_fwstatus,
194	aac_rkt_qnotify,
195	aac_rkt_get_istatus,
196	aac_rkt_clear_istatus,
197	aac_rkt_set_mailbox,
198	aac_rkt_get_mailbox,
199	aac_rkt_set_interrupts,
200	aac_rkt_send_command,
201	aac_rkt_get_outb_queue,
202	aac_rkt_set_outb_queue
203};
204
205/* Debugging and Diagnostics */
206static void	aac_describe_controller(struct aac_softc *sc);
207static char	*aac_describe_code(struct aac_code_lookup *table,
208				   u_int32_t code);
209
210/* Management Interface */
211static d_open_t		aac_open;
212static d_close_t	aac_close;
213static d_ioctl_t	aac_ioctl;
214static d_poll_t		aac_poll;
215static int		aac_ioctl_sendfib(struct aac_softc *sc, caddr_t ufib);
216static void		aac_handle_aif(struct aac_softc *sc,
217					   struct aac_fib *fib);
218static int		aac_rev_check(struct aac_softc *sc, caddr_t udata);
219static int		aac_open_aif(struct aac_softc *sc, caddr_t arg);
220static int		aac_close_aif(struct aac_softc *sc, caddr_t arg);
221static int		aac_getnext_aif(struct aac_softc *sc, caddr_t arg);
222static int		aac_return_aif(struct aac_softc *sc,
223					struct aac_fib_context *ctx, caddr_t uptr);
224static int		aac_query_disk(struct aac_softc *sc, caddr_t uptr);
225static int		aac_get_pci_info(struct aac_softc *sc, caddr_t uptr);
226static void		aac_ioctl_event(struct aac_softc *sc,
227				        struct aac_event *event, void *arg);
228
229static struct cdevsw aac_cdevsw = {
230	.d_version =	D_VERSION,
231	.d_flags =	D_NEEDGIANT,
232	.d_open =	aac_open,
233	.d_close =	aac_close,
234	.d_ioctl =	aac_ioctl,
235	.d_poll =	aac_poll,
236	.d_name =	"aac",
237};
238
239MALLOC_DEFINE(M_AACBUF, "aacbuf", "Buffers for the AAC driver");
240
241/* sysctl node */
242SYSCTL_NODE(_hw, OID_AUTO, aac, CTLFLAG_RD, 0, "AAC driver parameters");
243
244/*
245 * Device Interface
246 */
247
248/*
249 * Initialise the controller and softc
250 */
251int
252aac_attach(struct aac_softc *sc)
253{
254	int error, unit;
255
256	debug_called(1);
257
258	/*
259	 * Initialise per-controller queues.
260	 */
261	aac_initq_free(sc);
262	aac_initq_ready(sc);
263	aac_initq_busy(sc);
264	aac_initq_bio(sc);
265
266	/*
267	 * Initialise command-completion task.
268	 */
269	TASK_INIT(&sc->aac_task_complete, 0, aac_complete, sc);
270
271	/* mark controller as suspended until we get ourselves organised */
272	sc->aac_state |= AAC_STATE_SUSPEND;
273
274	/*
275	 * Check that the firmware on the card is supported.
276	 */
277	if ((error = aac_check_firmware(sc)) != 0)
278		return(error);
279
280	/*
281	 * Initialize locks
282	 */
283	mtx_init(&sc->aac_aifq_lock, "AAC AIF lock", NULL, MTX_DEF);
284	mtx_init(&sc->aac_io_lock, "AAC I/O lock", NULL, MTX_DEF);
285	mtx_init(&sc->aac_container_lock, "AAC container lock", NULL, MTX_DEF);
286	TAILQ_INIT(&sc->aac_container_tqh);
287	TAILQ_INIT(&sc->aac_ev_cmfree);
288
289	/*
290	 * Initialise the adapter.
291	 */
292	if ((error = aac_init(sc)) != 0)
293		return(error);
294
295	/*
296	 * Allocate and connect our interrupt.
297	 */
298	sc->aac_irq_rid = 0;
299	if ((sc->aac_irq = bus_alloc_resource_any(sc->aac_dev, SYS_RES_IRQ,
300			   			  &sc->aac_irq_rid,
301			   			  RF_SHAREABLE |
302						  RF_ACTIVE)) == NULL) {
303		device_printf(sc->aac_dev, "can't allocate interrupt\n");
304		return (EINVAL);
305	}
306	if (sc->flags & AAC_FLAGS_NEW_COMM) {
307		if (bus_setup_intr(sc->aac_dev, sc->aac_irq,
308				   INTR_MPSAFE|INTR_TYPE_BIO, NULL,
309				   aac_new_intr, sc, &sc->aac_intr)) {
310			device_printf(sc->aac_dev, "can't set up interrupt\n");
311			return (EINVAL);
312		}
313	} else {
314		if (bus_setup_intr(sc->aac_dev, sc->aac_irq,
315				   INTR_TYPE_BIO, aac_fast_intr, NULL,
316				   sc, &sc->aac_intr)) {
317			device_printf(sc->aac_dev,
318				      "can't set up FAST interrupt\n");
319			if (bus_setup_intr(sc->aac_dev, sc->aac_irq,
320					   INTR_MPSAFE|INTR_TYPE_BIO,
321					   NULL, (driver_intr_t *)aac_fast_intr,
322					   sc, &sc->aac_intr)) {
323				device_printf(sc->aac_dev,
324					     "can't set up MPSAFE interrupt\n");
325				return (EINVAL);
326			}
327		}
328	}
329
330	/*
331	 * Print a little information about the controller.
332	 */
333	aac_describe_controller(sc);
334
335	/*
336	 * Register to probe our containers later.
337	 */
338	sc->aac_ich.ich_func = aac_startup;
339	sc->aac_ich.ich_arg = sc;
340	if (config_intrhook_establish(&sc->aac_ich) != 0) {
341		device_printf(sc->aac_dev,
342			      "can't establish configuration hook\n");
343		return(ENXIO);
344	}
345
346	/*
347	 * Make the control device.
348	 */
349	unit = device_get_unit(sc->aac_dev);
350	sc->aac_dev_t = make_dev(&aac_cdevsw, unit, UID_ROOT, GID_OPERATOR,
351				 0640, "aac%d", unit);
352	(void)make_dev_alias(sc->aac_dev_t, "afa%d", unit);
353	(void)make_dev_alias(sc->aac_dev_t, "hpn%d", unit);
354	sc->aac_dev_t->si_drv1 = sc;
355
356	/* Create the AIF thread */
357	if (kproc_create((void(*)(void *))aac_command_thread, sc,
358		   &sc->aifthread, 0, 0, "aac%daif", unit))
359		panic("Could not create AIF thread\n");
360
361	/* Register the shutdown method to only be called post-dump */
362	if ((sc->eh = EVENTHANDLER_REGISTER(shutdown_final, aac_shutdown,
363	    sc->aac_dev, SHUTDOWN_PRI_DEFAULT)) == NULL)
364		device_printf(sc->aac_dev,
365			      "shutdown event registration failed\n");
366
367	/* Register with CAM for the non-DASD devices */
368	if ((sc->flags & AAC_FLAGS_ENABLE_CAM) != 0) {
369		TAILQ_INIT(&sc->aac_sim_tqh);
370		aac_get_bus_info(sc);
371	}
372
373	return(0);
374}
375
376void
377aac_add_event(struct aac_softc *sc, struct aac_event *event)
378{
379
380	switch (event->ev_type & AAC_EVENT_MASK) {
381	case AAC_EVENT_CMFREE:
382		TAILQ_INSERT_TAIL(&sc->aac_ev_cmfree, event, ev_links);
383		break;
384	default:
385		device_printf(sc->aac_dev, "aac_add event: unknown event %d\n",
386		    event->ev_type);
387		break;
388	}
389
390	return;
391}
392
393/*
394 * Probe for containers, create disks.
395 */
396static void
397aac_startup(void *arg)
398{
399	struct aac_softc *sc;
400	struct aac_fib *fib;
401	struct aac_mntinfo *mi;
402	struct aac_mntinforesp *mir = NULL;
403	int count = 0, i = 0;
404
405	debug_called(1);
406
407	sc = (struct aac_softc *)arg;
408
409	/* disconnect ourselves from the intrhook chain */
410	config_intrhook_disestablish(&sc->aac_ich);
411
412	mtx_lock(&sc->aac_io_lock);
413	aac_alloc_sync_fib(sc, &fib);
414	mi = (struct aac_mntinfo *)&fib->data[0];
415
416	/* loop over possible containers */
417	do {
418		/* request information on this container */
419		bzero(mi, sizeof(struct aac_mntinfo));
420		mi->Command = VM_NameServe;
421		mi->MntType = FT_FILESYS;
422		mi->MntCount = i;
423		if (aac_sync_fib(sc, ContainerCommand, 0, fib,
424				 sizeof(struct aac_mntinfo))) {
425			printf("error probing container %d", i);
426			continue;
427		}
428
429		mir = (struct aac_mntinforesp *)&fib->data[0];
430		/* XXX Need to check if count changed */
431		count = mir->MntRespCount;
432		aac_add_container(sc, mir, 0);
433		i++;
434	} while ((i < count) && (i < AAC_MAX_CONTAINERS));
435
436	aac_release_sync_fib(sc);
437	mtx_unlock(&sc->aac_io_lock);
438
439	/* poke the bus to actually attach the child devices */
440	if (bus_generic_attach(sc->aac_dev))
441		device_printf(sc->aac_dev, "bus_generic_attach failed\n");
442
443	/* mark the controller up */
444	sc->aac_state &= ~AAC_STATE_SUSPEND;
445
446	/* enable interrupts now */
447	AAC_UNMASK_INTERRUPTS(sc);
448}
449
450/*
451 * Create a device to respresent a new container
452 */
453static void
454aac_add_container(struct aac_softc *sc, struct aac_mntinforesp *mir, int f)
455{
456	struct aac_container *co;
457	device_t child;
458
459	/*
460	 * Check container volume type for validity.  Note that many of
461	 * the possible types may never show up.
462	 */
463	if ((mir->Status == ST_OK) && (mir->MntTable[0].VolType != CT_NONE)) {
464		co = (struct aac_container *)malloc(sizeof *co, M_AACBUF,
465		       M_NOWAIT | M_ZERO);
466		if (co == NULL)
467			panic("Out of memory?!\n");
468		debug(1, "id %x  name '%.16s'  size %u  type %d",
469		      mir->MntTable[0].ObjectId,
470		      mir->MntTable[0].FileSystemName,
471		      mir->MntTable[0].Capacity, mir->MntTable[0].VolType);
472
473		if ((child = device_add_child(sc->aac_dev, "aacd", -1)) == NULL)
474			device_printf(sc->aac_dev, "device_add_child failed\n");
475		else
476			device_set_ivars(child, co);
477		device_set_desc(child, aac_describe_code(aac_container_types,
478				mir->MntTable[0].VolType));
479		co->co_disk = child;
480		co->co_found = f;
481		bcopy(&mir->MntTable[0], &co->co_mntobj,
482		      sizeof(struct aac_mntobj));
483		mtx_lock(&sc->aac_container_lock);
484		TAILQ_INSERT_TAIL(&sc->aac_container_tqh, co, co_link);
485		mtx_unlock(&sc->aac_container_lock);
486	}
487}
488
489/*
490 * Free all of the resources associated with (sc)
491 *
492 * Should not be called if the controller is active.
493 */
494void
495aac_free(struct aac_softc *sc)
496{
497
498	debug_called(1);
499
500	/* remove the control device */
501	if (sc->aac_dev_t != NULL)
502		destroy_dev(sc->aac_dev_t);
503
504	/* throw away any FIB buffers, discard the FIB DMA tag */
505	aac_free_commands(sc);
506	if (sc->aac_fib_dmat)
507		bus_dma_tag_destroy(sc->aac_fib_dmat);
508
509	free(sc->aac_commands, M_AACBUF);
510
511	/* destroy the common area */
512	if (sc->aac_common) {
513		bus_dmamap_unload(sc->aac_common_dmat, sc->aac_common_dmamap);
514		bus_dmamem_free(sc->aac_common_dmat, sc->aac_common,
515				sc->aac_common_dmamap);
516	}
517	if (sc->aac_common_dmat)
518		bus_dma_tag_destroy(sc->aac_common_dmat);
519
520	/* disconnect the interrupt handler */
521	if (sc->aac_intr)
522		bus_teardown_intr(sc->aac_dev, sc->aac_irq, sc->aac_intr);
523	if (sc->aac_irq != NULL)
524		bus_release_resource(sc->aac_dev, SYS_RES_IRQ, sc->aac_irq_rid,
525				     sc->aac_irq);
526
527	/* destroy data-transfer DMA tag */
528	if (sc->aac_buffer_dmat)
529		bus_dma_tag_destroy(sc->aac_buffer_dmat);
530
531	/* destroy the parent DMA tag */
532	if (sc->aac_parent_dmat)
533		bus_dma_tag_destroy(sc->aac_parent_dmat);
534
535	/* release the register window mapping */
536	if (sc->aac_regs_resource != NULL)
537		bus_release_resource(sc->aac_dev, SYS_RES_MEMORY,
538				     sc->aac_regs_rid, sc->aac_regs_resource);
539}
540
541/*
542 * Disconnect from the controller completely, in preparation for unload.
543 */
544int
545aac_detach(device_t dev)
546{
547	struct aac_softc *sc;
548	struct aac_container *co;
549	struct aac_sim	*sim;
550	int error;
551
552	debug_called(1);
553
554	sc = device_get_softc(dev);
555
556	if (sc->aac_state & AAC_STATE_OPEN)
557		return(EBUSY);
558
559	/* Remove the child containers */
560	while ((co = TAILQ_FIRST(&sc->aac_container_tqh)) != NULL) {
561		error = device_delete_child(dev, co->co_disk);
562		if (error)
563			return (error);
564		TAILQ_REMOVE(&sc->aac_container_tqh, co, co_link);
565		free(co, M_AACBUF);
566	}
567
568	/* Remove the CAM SIMs */
569	while ((sim = TAILQ_FIRST(&sc->aac_sim_tqh)) != NULL) {
570		TAILQ_REMOVE(&sc->aac_sim_tqh, sim, sim_link);
571		error = device_delete_child(dev, sim->sim_dev);
572		if (error)
573			return (error);
574		free(sim, M_AACBUF);
575	}
576
577	if (sc->aifflags & AAC_AIFFLAGS_RUNNING) {
578		sc->aifflags |= AAC_AIFFLAGS_EXIT;
579		wakeup(sc->aifthread);
580		tsleep(sc->aac_dev, PUSER | PCATCH, "aacdch", 30 * hz);
581	}
582
583	if (sc->aifflags & AAC_AIFFLAGS_RUNNING)
584		panic("Cannot shutdown AIF thread\n");
585
586	if ((error = aac_shutdown(dev)))
587		return(error);
588
589	EVENTHANDLER_DEREGISTER(shutdown_final, sc->eh);
590
591	aac_free(sc);
592
593	mtx_destroy(&sc->aac_aifq_lock);
594	mtx_destroy(&sc->aac_io_lock);
595	mtx_destroy(&sc->aac_container_lock);
596
597	return(0);
598}
599
600/*
601 * Bring the controller down to a dormant state and detach all child devices.
602 *
603 * This function is called before detach or system shutdown.
604 *
605 * Note that we can assume that the bioq on the controller is empty, as we won't
606 * allow shutdown if any device is open.
607 */
608int
609aac_shutdown(device_t dev)
610{
611	struct aac_softc *sc;
612	struct aac_fib *fib;
613	struct aac_close_command *cc;
614
615	debug_called(1);
616
617	sc = device_get_softc(dev);
618
619	sc->aac_state |= AAC_STATE_SUSPEND;
620
621	/*
622	 * Send a Container shutdown followed by a HostShutdown FIB to the
623	 * controller to convince it that we don't want to talk to it anymore.
624	 * We've been closed and all I/O completed already
625	 */
626	device_printf(sc->aac_dev, "shutting down controller...");
627
628	mtx_lock(&sc->aac_io_lock);
629	aac_alloc_sync_fib(sc, &fib);
630	cc = (struct aac_close_command *)&fib->data[0];
631
632	bzero(cc, sizeof(struct aac_close_command));
633	cc->Command = VM_CloseAll;
634	cc->ContainerId = 0xffffffff;
635	if (aac_sync_fib(sc, ContainerCommand, 0, fib,
636	    sizeof(struct aac_close_command)))
637		printf("FAILED.\n");
638	else
639		printf("done\n");
640#if 0
641	else {
642		fib->data[0] = 0;
643		/*
644		 * XXX Issuing this command to the controller makes it shut down
645		 * but also keeps it from coming back up without a reset of the
646		 * PCI bus.  This is not desirable if you are just unloading the
647		 * driver module with the intent to reload it later.
648		 */
649		if (aac_sync_fib(sc, FsaHostShutdown, AAC_FIBSTATE_SHUTDOWN,
650		    fib, 1)) {
651			printf("FAILED.\n");
652		} else {
653			printf("done.\n");
654		}
655	}
656#endif
657
658	AAC_MASK_INTERRUPTS(sc);
659	aac_release_sync_fib(sc);
660	mtx_unlock(&sc->aac_io_lock);
661
662	return(0);
663}
664
665/*
666 * Bring the controller to a quiescent state, ready for system suspend.
667 */
668int
669aac_suspend(device_t dev)
670{
671	struct aac_softc *sc;
672
673	debug_called(1);
674
675	sc = device_get_softc(dev);
676
677	sc->aac_state |= AAC_STATE_SUSPEND;
678
679	AAC_MASK_INTERRUPTS(sc);
680	return(0);
681}
682
683/*
684 * Bring the controller back to a state ready for operation.
685 */
686int
687aac_resume(device_t dev)
688{
689	struct aac_softc *sc;
690
691	debug_called(1);
692
693	sc = device_get_softc(dev);
694
695	sc->aac_state &= ~AAC_STATE_SUSPEND;
696	AAC_UNMASK_INTERRUPTS(sc);
697	return(0);
698}
699
700/*
701 * Interrupt handler for NEW_COMM interface.
702 */
703void
704aac_new_intr(void *arg)
705{
706	struct aac_softc *sc;
707	u_int32_t index, fast;
708	struct aac_command *cm;
709	struct aac_fib *fib;
710	int i;
711
712	debug_called(2);
713
714	sc = (struct aac_softc *)arg;
715
716	mtx_lock(&sc->aac_io_lock);
717	while (1) {
718		index = AAC_GET_OUTB_QUEUE(sc);
719		if (index == 0xffffffff)
720			index = AAC_GET_OUTB_QUEUE(sc);
721		if (index == 0xffffffff)
722			break;
723		if (index & 2) {
724			if (index == 0xfffffffe) {
725				/* XXX This means that the controller wants
726				 * more work.  Ignore it for now.
727				 */
728				continue;
729			}
730			/* AIF */
731			fib = (struct aac_fib *)malloc(sizeof *fib, M_AACBUF,
732				   M_NOWAIT | M_ZERO);
733			if (fib == NULL) {
734				/* If we're really this short on memory,
735				 * hopefully breaking out of the handler will
736				 * allow something to get freed.  This
737				 * actually sucks a whole lot.
738				 */
739				break;
740			}
741			index &= ~2;
742			for (i = 0; i < sizeof(struct aac_fib)/4; ++i)
743				((u_int32_t *)fib)[i] = AAC_GETREG4(sc, index + i*4);
744			aac_handle_aif(sc, fib);
745			free(fib, M_AACBUF);
746
747			/*
748			 * AIF memory is owned by the adapter, so let it
749			 * know that we are done with it.
750			 */
751			AAC_SET_OUTB_QUEUE(sc, index);
752			AAC_CLEAR_ISTATUS(sc, AAC_DB_RESPONSE_READY);
753		} else {
754			fast = index & 1;
755			cm = sc->aac_commands + (index >> 2);
756			fib = cm->cm_fib;
757			if (fast) {
758				fib->Header.XferState |= AAC_FIBSTATE_DONEADAP;
759				*((u_int32_t *)(fib->data)) = AAC_ERROR_NORMAL;
760			}
761			aac_remove_busy(cm);
762 			aac_unmap_command(cm);
763			cm->cm_flags |= AAC_CMD_COMPLETED;
764
765			/* is there a completion handler? */
766			if (cm->cm_complete != NULL) {
767				cm->cm_complete(cm);
768			} else {
769				/* assume that someone is sleeping on this
770				 * command
771				 */
772				wakeup(cm);
773			}
774			sc->flags &= ~AAC_QUEUE_FRZN;
775		}
776	}
777	/* see if we can start some more I/O */
778	if ((sc->flags & AAC_QUEUE_FRZN) == 0)
779		aac_startio(sc);
780
781	mtx_unlock(&sc->aac_io_lock);
782}
783
784int
785aac_fast_intr(void *arg)
786{
787	struct aac_softc *sc;
788	u_int16_t reason;
789
790	debug_called(2);
791
792	sc = (struct aac_softc *)arg;
793
794	/*
795	 * Read the status register directly.  This is faster than taking the
796	 * driver lock and reading the queues directly.  It also saves having
797	 * to turn parts of the driver lock into a spin mutex, which would be
798	 * ugly.
799	 */
800	reason = AAC_GET_ISTATUS(sc);
801	AAC_CLEAR_ISTATUS(sc, reason);
802
803	/* handle completion processing */
804	if (reason & AAC_DB_RESPONSE_READY)
805		taskqueue_enqueue_fast(taskqueue_fast, &sc->aac_task_complete);
806
807	/* controller wants to talk to us */
808	if (reason & (AAC_DB_PRINTF | AAC_DB_COMMAND_READY)) {
809		/*
810		 * XXX Make sure that we don't get fooled by strange messages
811		 * that start with a NULL.
812		 */
813		if ((reason & AAC_DB_PRINTF) &&
814			(sc->aac_common->ac_printf[0] == 0))
815			sc->aac_common->ac_printf[0] = 32;
816
817		/*
818		 * This might miss doing the actual wakeup.  However, the
819		 * msleep that this is waking up has a timeout, so it will
820		 * wake up eventually.  AIFs and printfs are low enough
821		 * priority that they can handle hanging out for a few seconds
822		 * if needed.
823		 */
824		wakeup(sc->aifthread);
825	}
826	return (FILTER_HANDLED);
827}
828
829/*
830 * Command Processing
831 */
832
833/*
834 * Start as much queued I/O as possible on the controller
835 */
836void
837aac_startio(struct aac_softc *sc)
838{
839	struct aac_command *cm;
840	int error;
841
842	debug_called(2);
843
844	for (;;) {
845		/*
846		 * This flag might be set if the card is out of resources.
847		 * Checking it here prevents an infinite loop of deferrals.
848		 */
849		if (sc->flags & AAC_QUEUE_FRZN)
850			break;
851
852		/*
853		 * Try to get a command that's been put off for lack of
854		 * resources
855		 */
856		cm = aac_dequeue_ready(sc);
857
858		/*
859		 * Try to build a command off the bio queue (ignore error
860		 * return)
861		 */
862		if (cm == NULL)
863			aac_bio_command(sc, &cm);
864
865		/* nothing to do? */
866		if (cm == NULL)
867			break;
868
869		/* don't map more than once */
870		if (cm->cm_flags & AAC_CMD_MAPPED)
871			panic("aac: command %p already mapped", cm);
872
873		/*
874		 * Set up the command to go to the controller.  If there are no
875		 * data buffers associated with the command then it can bypass
876		 * busdma.
877		 */
878		if (cm->cm_datalen != 0) {
879			error = bus_dmamap_load(sc->aac_buffer_dmat,
880						cm->cm_datamap, cm->cm_data,
881						cm->cm_datalen,
882						aac_map_command_sg, cm, 0);
883			if (error == EINPROGRESS) {
884				debug(1, "freezing queue\n");
885				sc->flags |= AAC_QUEUE_FRZN;
886				error = 0;
887			} else if (error != 0)
888				panic("aac_startio: unexpected error %d from "
889				      "busdma\n", error);
890		} else
891			aac_map_command_sg(cm, NULL, 0, 0);
892	}
893}
894
895/*
896 * Handle notification of one or more FIBs coming from the controller.
897 */
898static void
899aac_command_thread(struct aac_softc *sc)
900{
901	struct aac_fib *fib;
902	u_int32_t fib_size;
903	int size, retval;
904
905	debug_called(2);
906
907	mtx_lock(&sc->aac_io_lock);
908	sc->aifflags = AAC_AIFFLAGS_RUNNING;
909
910	while ((sc->aifflags & AAC_AIFFLAGS_EXIT) == 0) {
911
912		retval = 0;
913		if ((sc->aifflags & AAC_AIFFLAGS_PENDING) == 0)
914			retval = msleep(sc->aifthread, &sc->aac_io_lock, PRIBIO,
915					"aifthd", AAC_PERIODIC_INTERVAL * hz);
916
917		/*
918		 * First see if any FIBs need to be allocated.  This needs
919		 * to be called without the driver lock because contigmalloc
920		 * will grab Giant, and would result in an LOR.
921		 */
922		if ((sc->aifflags & AAC_AIFFLAGS_ALLOCFIBS) != 0) {
923			mtx_unlock(&sc->aac_io_lock);
924			aac_alloc_commands(sc);
925			mtx_lock(&sc->aac_io_lock);
926			sc->aifflags &= ~AAC_AIFFLAGS_ALLOCFIBS;
927			aac_startio(sc);
928		}
929
930		/*
931		 * While we're here, check to see if any commands are stuck.
932		 * This is pretty low-priority, so it's ok if it doesn't
933		 * always fire.
934		 */
935		if (retval == EWOULDBLOCK)
936			aac_timeout(sc);
937
938		/* Check the hardware printf message buffer */
939		if (sc->aac_common->ac_printf[0] != 0)
940			aac_print_printf(sc);
941
942		/* Also check to see if the adapter has a command for us. */
943		if (sc->flags & AAC_FLAGS_NEW_COMM)
944			continue;
945		for (;;) {
946			if (aac_dequeue_fib(sc, AAC_HOST_NORM_CMD_QUEUE,
947					   &fib_size, &fib))
948				break;
949
950			AAC_PRINT_FIB(sc, fib);
951
952			switch (fib->Header.Command) {
953			case AifRequest:
954				aac_handle_aif(sc, fib);
955				break;
956			default:
957				device_printf(sc->aac_dev, "unknown command "
958					      "from controller\n");
959				break;
960			}
961
962			if ((fib->Header.XferState == 0) ||
963			    (fib->Header.StructType != AAC_FIBTYPE_TFIB)) {
964				break;
965			}
966
967			/* Return the AIF to the controller. */
968			if (fib->Header.XferState & AAC_FIBSTATE_FROMADAP) {
969				fib->Header.XferState |= AAC_FIBSTATE_DONEHOST;
970				*(AAC_FSAStatus*)fib->data = ST_OK;
971
972				/* XXX Compute the Size field? */
973				size = fib->Header.Size;
974				if (size > sizeof(struct aac_fib)) {
975					size = sizeof(struct aac_fib);
976					fib->Header.Size = size;
977				}
978				/*
979				 * Since we did not generate this command, it
980				 * cannot go through the normal
981				 * enqueue->startio chain.
982				 */
983				aac_enqueue_response(sc,
984						 AAC_ADAP_NORM_RESP_QUEUE,
985						 fib);
986			}
987		}
988	}
989	sc->aifflags &= ~AAC_AIFFLAGS_RUNNING;
990	mtx_unlock(&sc->aac_io_lock);
991	wakeup(sc->aac_dev);
992
993	kproc_exit(0);
994}
995
996/*
997 * Process completed commands.
998 */
999static void
1000aac_complete(void *context, int pending)
1001{
1002	struct aac_softc *sc;
1003	struct aac_command *cm;
1004	struct aac_fib *fib;
1005	u_int32_t fib_size;
1006
1007	debug_called(2);
1008
1009	sc = (struct aac_softc *)context;
1010
1011	mtx_lock(&sc->aac_io_lock);
1012
1013	/* pull completed commands off the queue */
1014	for (;;) {
1015		/* look for completed FIBs on our queue */
1016		if (aac_dequeue_fib(sc, AAC_HOST_NORM_RESP_QUEUE, &fib_size,
1017							&fib))
1018			break;	/* nothing to do */
1019
1020		/* get the command, unmap and hand off for processing */
1021		cm = sc->aac_commands + fib->Header.SenderData;
1022		if (cm == NULL) {
1023			AAC_PRINT_FIB(sc, fib);
1024			break;
1025		}
1026		aac_remove_busy(cm);
1027
1028 		aac_unmap_command(cm);
1029		cm->cm_flags |= AAC_CMD_COMPLETED;
1030
1031		/* is there a completion handler? */
1032		if (cm->cm_complete != NULL) {
1033			cm->cm_complete(cm);
1034		} else {
1035			/* assume that someone is sleeping on this command */
1036			wakeup(cm);
1037		}
1038	}
1039
1040	/* see if we can start some more I/O */
1041	sc->flags &= ~AAC_QUEUE_FRZN;
1042	aac_startio(sc);
1043
1044	mtx_unlock(&sc->aac_io_lock);
1045}
1046
1047/*
1048 * Handle a bio submitted from a disk device.
1049 */
1050void
1051aac_submit_bio(struct bio *bp)
1052{
1053	struct aac_disk *ad;
1054	struct aac_softc *sc;
1055
1056	debug_called(2);
1057
1058	ad = (struct aac_disk *)bp->bio_disk->d_drv1;
1059	sc = ad->ad_controller;
1060
1061	/* queue the BIO and try to get some work done */
1062	aac_enqueue_bio(sc, bp);
1063	aac_startio(sc);
1064}
1065
1066/*
1067 * Get a bio and build a command to go with it.
1068 */
1069static int
1070aac_bio_command(struct aac_softc *sc, struct aac_command **cmp)
1071{
1072	struct aac_command *cm;
1073	struct aac_fib *fib;
1074	struct aac_disk *ad;
1075	struct bio *bp;
1076
1077	debug_called(2);
1078
1079	/* get the resources we will need */
1080	cm = NULL;
1081	bp = NULL;
1082	if (aac_alloc_command(sc, &cm))	/* get a command */
1083		goto fail;
1084	if ((bp = aac_dequeue_bio(sc)) == NULL)
1085		goto fail;
1086
1087	/* fill out the command */
1088	cm->cm_data = (void *)bp->bio_data;
1089	cm->cm_datalen = bp->bio_bcount;
1090	cm->cm_complete = aac_bio_complete;
1091	cm->cm_private = bp;
1092	cm->cm_timestamp = time_uptime;
1093	cm->cm_queue = AAC_ADAP_NORM_CMD_QUEUE;
1094
1095	/* build the FIB */
1096	fib = cm->cm_fib;
1097	fib->Header.Size = sizeof(struct aac_fib_header);
1098	fib->Header.XferState =
1099		AAC_FIBSTATE_HOSTOWNED   |
1100		AAC_FIBSTATE_INITIALISED |
1101		AAC_FIBSTATE_EMPTY	 |
1102		AAC_FIBSTATE_FROMHOST	 |
1103		AAC_FIBSTATE_REXPECTED   |
1104		AAC_FIBSTATE_NORM	 |
1105		AAC_FIBSTATE_ASYNC	 |
1106		AAC_FIBSTATE_FAST_RESPONSE;
1107
1108	/* build the read/write request */
1109	ad = (struct aac_disk *)bp->bio_disk->d_drv1;
1110
1111	if (sc->flags & AAC_FLAGS_RAW_IO) {
1112		struct aac_raw_io *raw;
1113		raw = (struct aac_raw_io *)&fib->data[0];
1114		fib->Header.Command = RawIo;
1115		raw->BlockNumber = (u_int64_t)bp->bio_pblkno;
1116		raw->ByteCount = bp->bio_bcount;
1117		raw->ContainerId = ad->ad_container->co_mntobj.ObjectId;
1118		raw->BpTotal = 0;
1119		raw->BpComplete = 0;
1120		fib->Header.Size += sizeof(struct aac_raw_io);
1121		cm->cm_sgtable = (struct aac_sg_table *)&raw->SgMapRaw;
1122		if (bp->bio_cmd == BIO_READ) {
1123			raw->Flags = 1;
1124			cm->cm_flags |= AAC_CMD_DATAIN;
1125		} else {
1126			raw->Flags = 0;
1127			cm->cm_flags |= AAC_CMD_DATAOUT;
1128		}
1129	} else if ((sc->flags & AAC_FLAGS_SG_64BIT) == 0) {
1130		fib->Header.Command = ContainerCommand;
1131		if (bp->bio_cmd == BIO_READ) {
1132			struct aac_blockread *br;
1133			br = (struct aac_blockread *)&fib->data[0];
1134			br->Command = VM_CtBlockRead;
1135			br->ContainerId = ad->ad_container->co_mntobj.ObjectId;
1136			br->BlockNumber = bp->bio_pblkno;
1137			br->ByteCount = bp->bio_bcount;
1138			fib->Header.Size += sizeof(struct aac_blockread);
1139			cm->cm_sgtable = &br->SgMap;
1140			cm->cm_flags |= AAC_CMD_DATAIN;
1141		} else {
1142			struct aac_blockwrite *bw;
1143			bw = (struct aac_blockwrite *)&fib->data[0];
1144			bw->Command = VM_CtBlockWrite;
1145			bw->ContainerId = ad->ad_container->co_mntobj.ObjectId;
1146			bw->BlockNumber = bp->bio_pblkno;
1147			bw->ByteCount = bp->bio_bcount;
1148			bw->Stable = CUNSTABLE;
1149			fib->Header.Size += sizeof(struct aac_blockwrite);
1150			cm->cm_flags |= AAC_CMD_DATAOUT;
1151			cm->cm_sgtable = &bw->SgMap;
1152		}
1153	} else {
1154		fib->Header.Command = ContainerCommand64;
1155		if (bp->bio_cmd == BIO_READ) {
1156			struct aac_blockread64 *br;
1157			br = (struct aac_blockread64 *)&fib->data[0];
1158			br->Command = VM_CtHostRead64;
1159			br->ContainerId = ad->ad_container->co_mntobj.ObjectId;
1160			br->SectorCount = bp->bio_bcount / AAC_BLOCK_SIZE;
1161			br->BlockNumber = bp->bio_pblkno;
1162			br->Pad = 0;
1163			br->Flags = 0;
1164			fib->Header.Size += sizeof(struct aac_blockread64);
1165			cm->cm_flags |= AAC_CMD_DATAOUT;
1166			cm->cm_sgtable = (struct aac_sg_table *)&br->SgMap64;
1167		} else {
1168			struct aac_blockwrite64 *bw;
1169			bw = (struct aac_blockwrite64 *)&fib->data[0];
1170			bw->Command = VM_CtHostWrite64;
1171			bw->ContainerId = ad->ad_container->co_mntobj.ObjectId;
1172			bw->SectorCount = bp->bio_bcount / AAC_BLOCK_SIZE;
1173			bw->BlockNumber = bp->bio_pblkno;
1174			bw->Pad = 0;
1175			bw->Flags = 0;
1176			fib->Header.Size += sizeof(struct aac_blockwrite64);
1177			cm->cm_flags |= AAC_CMD_DATAIN;
1178			cm->cm_sgtable = (struct aac_sg_table *)&bw->SgMap64;
1179		}
1180	}
1181
1182	*cmp = cm;
1183	return(0);
1184
1185fail:
1186	if (bp != NULL)
1187		aac_enqueue_bio(sc, bp);
1188	if (cm != NULL)
1189		aac_release_command(cm);
1190	return(ENOMEM);
1191}
1192
1193/*
1194 * Handle a bio-instigated command that has been completed.
1195 */
1196static void
1197aac_bio_complete(struct aac_command *cm)
1198{
1199	struct aac_blockread_response *brr;
1200	struct aac_blockwrite_response *bwr;
1201	struct bio *bp;
1202	AAC_FSAStatus status;
1203
1204	/* fetch relevant status and then release the command */
1205	bp = (struct bio *)cm->cm_private;
1206	if (bp->bio_cmd == BIO_READ) {
1207		brr = (struct aac_blockread_response *)&cm->cm_fib->data[0];
1208		status = brr->Status;
1209	} else {
1210		bwr = (struct aac_blockwrite_response *)&cm->cm_fib->data[0];
1211		status = bwr->Status;
1212	}
1213	aac_release_command(cm);
1214
1215	/* fix up the bio based on status */
1216	if (status == ST_OK) {
1217		bp->bio_resid = 0;
1218	} else {
1219		bp->bio_error = EIO;
1220		bp->bio_flags |= BIO_ERROR;
1221		/* pass an error string out to the disk layer */
1222		bp->bio_driver1 = aac_describe_code(aac_command_status_table,
1223						    status);
1224	}
1225	aac_biodone(bp);
1226}
1227
1228/*
1229 * Submit a command to the controller, return when it completes.
1230 * XXX This is very dangerous!  If the card has gone out to lunch, we could
1231 *     be stuck here forever.  At the same time, signals are not caught
1232 *     because there is a risk that a signal could wakeup the sleep before
1233 *     the card has a chance to complete the command.  Since there is no way
1234 *     to cancel a command that is in progress, we can't protect against the
1235 *     card completing a command late and spamming the command and data
1236 *     memory.  So, we are held hostage until the command completes.
1237 */
1238static int
1239aac_wait_command(struct aac_command *cm)
1240{
1241	struct aac_softc *sc;
1242	int error;
1243
1244	debug_called(2);
1245
1246	sc = cm->cm_sc;
1247
1248	/* Put the command on the ready queue and get things going */
1249	cm->cm_queue = AAC_ADAP_NORM_CMD_QUEUE;
1250	aac_enqueue_ready(cm);
1251	aac_startio(sc);
1252	error = msleep(cm, &sc->aac_io_lock, PRIBIO, "aacwait", 0);
1253	return(error);
1254}
1255
1256/*
1257 *Command Buffer Management
1258 */
1259
1260/*
1261 * Allocate a command.
1262 */
1263int
1264aac_alloc_command(struct aac_softc *sc, struct aac_command **cmp)
1265{
1266	struct aac_command *cm;
1267
1268	debug_called(3);
1269
1270	if ((cm = aac_dequeue_free(sc)) == NULL) {
1271		if (sc->total_fibs < sc->aac_max_fibs) {
1272			sc->aifflags |= AAC_AIFFLAGS_ALLOCFIBS;
1273			wakeup(sc->aifthread);
1274		}
1275		return (EBUSY);
1276	}
1277
1278	*cmp = cm;
1279	return(0);
1280}
1281
1282/*
1283 * Release a command back to the freelist.
1284 */
1285void
1286aac_release_command(struct aac_command *cm)
1287{
1288	struct aac_event *event;
1289	struct aac_softc *sc;
1290
1291	debug_called(3);
1292
1293	/* (re)initialise the command/FIB */
1294	cm->cm_sgtable = NULL;
1295	cm->cm_flags = 0;
1296	cm->cm_complete = NULL;
1297	cm->cm_private = NULL;
1298	cm->cm_fib->Header.XferState = AAC_FIBSTATE_EMPTY;
1299	cm->cm_fib->Header.StructType = AAC_FIBTYPE_TFIB;
1300	cm->cm_fib->Header.Flags = 0;
1301	cm->cm_fib->Header.SenderSize = cm->cm_sc->aac_max_fib_size;
1302
1303	/*
1304	 * These are duplicated in aac_start to cover the case where an
1305	 * intermediate stage may have destroyed them.  They're left
1306	 * initialised here for debugging purposes only.
1307	 */
1308	cm->cm_fib->Header.ReceiverFibAddress = (u_int32_t)cm->cm_fibphys;
1309	cm->cm_fib->Header.SenderData = 0;
1310
1311	aac_enqueue_free(cm);
1312
1313	/*
1314	 * Dequeue all events so that there's no risk of events getting
1315	 * stranded.
1316	 */
1317	sc = cm->cm_sc;
1318	while ((event = TAILQ_FIRST(&sc->aac_ev_cmfree)) != NULL) {
1319		TAILQ_REMOVE(&sc->aac_ev_cmfree, event, ev_links);
1320		event->ev_callback(sc, event, event->ev_arg);
1321	}
1322}
1323
1324/*
1325 * Map helper for command/FIB allocation.
1326 */
1327static void
1328aac_map_command_helper(void *arg, bus_dma_segment_t *segs, int nseg, int error)
1329{
1330	uint64_t	*fibphys;
1331
1332	fibphys = (uint64_t *)arg;
1333
1334	debug_called(3);
1335
1336	*fibphys = segs[0].ds_addr;
1337}
1338
1339/*
1340 * Allocate and initialise commands/FIBs for this adapter.
1341 */
1342static int
1343aac_alloc_commands(struct aac_softc *sc)
1344{
1345	struct aac_command *cm;
1346	struct aac_fibmap *fm;
1347	uint64_t fibphys;
1348	int i, error;
1349
1350	debug_called(2);
1351
1352	if (sc->total_fibs + sc->aac_max_fibs_alloc > sc->aac_max_fibs)
1353		return (ENOMEM);
1354
1355	fm = malloc(sizeof(struct aac_fibmap), M_AACBUF, M_NOWAIT|M_ZERO);
1356	if (fm == NULL)
1357		return (ENOMEM);
1358
1359	/* allocate the FIBs in DMAable memory and load them */
1360	if (bus_dmamem_alloc(sc->aac_fib_dmat, (void **)&fm->aac_fibs,
1361			     BUS_DMA_NOWAIT, &fm->aac_fibmap)) {
1362		device_printf(sc->aac_dev,
1363			      "Not enough contiguous memory available.\n");
1364		free(fm, M_AACBUF);
1365		return (ENOMEM);
1366	}
1367
1368	/* Ignore errors since this doesn't bounce */
1369	(void)bus_dmamap_load(sc->aac_fib_dmat, fm->aac_fibmap, fm->aac_fibs,
1370			      sc->aac_max_fibs_alloc * sc->aac_max_fib_size,
1371			      aac_map_command_helper, &fibphys, 0);
1372
1373	/* initialise constant fields in the command structure */
1374	bzero(fm->aac_fibs, sc->aac_max_fibs_alloc * sc->aac_max_fib_size);
1375	for (i = 0; i < sc->aac_max_fibs_alloc; i++) {
1376		cm = sc->aac_commands + sc->total_fibs;
1377		fm->aac_commands = cm;
1378		cm->cm_sc = sc;
1379		cm->cm_fib = (struct aac_fib *)
1380			((u_int8_t *)fm->aac_fibs + i*sc->aac_max_fib_size);
1381		cm->cm_fibphys = fibphys + i*sc->aac_max_fib_size;
1382		cm->cm_index = sc->total_fibs;
1383
1384		if ((error = bus_dmamap_create(sc->aac_buffer_dmat, 0,
1385					       &cm->cm_datamap)) != 0)
1386			break;
1387		mtx_lock(&sc->aac_io_lock);
1388		aac_release_command(cm);
1389		sc->total_fibs++;
1390		mtx_unlock(&sc->aac_io_lock);
1391	}
1392
1393	if (i > 0) {
1394		mtx_lock(&sc->aac_io_lock);
1395		TAILQ_INSERT_TAIL(&sc->aac_fibmap_tqh, fm, fm_link);
1396		debug(1, "total_fibs= %d\n", sc->total_fibs);
1397		mtx_unlock(&sc->aac_io_lock);
1398		return (0);
1399	}
1400
1401	bus_dmamap_unload(sc->aac_fib_dmat, fm->aac_fibmap);
1402	bus_dmamem_free(sc->aac_fib_dmat, fm->aac_fibs, fm->aac_fibmap);
1403	free(fm, M_AACBUF);
1404	return (ENOMEM);
1405}
1406
1407/*
1408 * Free FIBs owned by this adapter.
1409 */
1410static void
1411aac_free_commands(struct aac_softc *sc)
1412{
1413	struct aac_fibmap *fm;
1414	struct aac_command *cm;
1415	int i;
1416
1417	debug_called(1);
1418
1419	while ((fm = TAILQ_FIRST(&sc->aac_fibmap_tqh)) != NULL) {
1420
1421		TAILQ_REMOVE(&sc->aac_fibmap_tqh, fm, fm_link);
1422		/*
1423		 * We check against total_fibs to handle partially
1424		 * allocated blocks.
1425		 */
1426		for (i = 0; i < sc->aac_max_fibs_alloc && sc->total_fibs--; i++) {
1427			cm = fm->aac_commands + i;
1428			bus_dmamap_destroy(sc->aac_buffer_dmat, cm->cm_datamap);
1429		}
1430		bus_dmamap_unload(sc->aac_fib_dmat, fm->aac_fibmap);
1431		bus_dmamem_free(sc->aac_fib_dmat, fm->aac_fibs, fm->aac_fibmap);
1432		free(fm, M_AACBUF);
1433	}
1434}
1435
1436/*
1437 * Command-mapping helper function - populate this command's s/g table.
1438 */
1439static void
1440aac_map_command_sg(void *arg, bus_dma_segment_t *segs, int nseg, int error)
1441{
1442	struct aac_softc *sc;
1443	struct aac_command *cm;
1444	struct aac_fib *fib;
1445	int i;
1446
1447	debug_called(3);
1448
1449	cm = (struct aac_command *)arg;
1450	sc = cm->cm_sc;
1451	fib = cm->cm_fib;
1452
1453	/* copy into the FIB */
1454	if (cm->cm_sgtable != NULL) {
1455		if (fib->Header.Command == RawIo) {
1456			struct aac_sg_tableraw *sg;
1457			sg = (struct aac_sg_tableraw *)cm->cm_sgtable;
1458			sg->SgCount = nseg;
1459			for (i = 0; i < nseg; i++) {
1460				sg->SgEntryRaw[i].SgAddress = segs[i].ds_addr;
1461				sg->SgEntryRaw[i].SgByteCount = segs[i].ds_len;
1462				sg->SgEntryRaw[i].Next = 0;
1463				sg->SgEntryRaw[i].Prev = 0;
1464				sg->SgEntryRaw[i].Flags = 0;
1465			}
1466			/* update the FIB size for the s/g count */
1467			fib->Header.Size += nseg*sizeof(struct aac_sg_entryraw);
1468		} else if ((cm->cm_sc->flags & AAC_FLAGS_SG_64BIT) == 0) {
1469			struct aac_sg_table *sg;
1470			sg = cm->cm_sgtable;
1471			sg->SgCount = nseg;
1472			for (i = 0; i < nseg; i++) {
1473				sg->SgEntry[i].SgAddress = segs[i].ds_addr;
1474				sg->SgEntry[i].SgByteCount = segs[i].ds_len;
1475			}
1476			/* update the FIB size for the s/g count */
1477			fib->Header.Size += nseg*sizeof(struct aac_sg_entry);
1478		} else {
1479			struct aac_sg_table64 *sg;
1480			sg = (struct aac_sg_table64 *)cm->cm_sgtable;
1481			sg->SgCount = nseg;
1482			for (i = 0; i < nseg; i++) {
1483				sg->SgEntry64[i].SgAddress = segs[i].ds_addr;
1484				sg->SgEntry64[i].SgByteCount = segs[i].ds_len;
1485			}
1486			/* update the FIB size for the s/g count */
1487			fib->Header.Size += nseg*sizeof(struct aac_sg_entry64);
1488		}
1489	}
1490
1491	/* Fix up the address values in the FIB.  Use the command array index
1492	 * instead of a pointer since these fields are only 32 bits.  Shift
1493	 * the SenderFibAddress over to make room for the fast response bit
1494	 * and for the AIF bit
1495	 */
1496	cm->cm_fib->Header.SenderFibAddress = (cm->cm_index << 2);
1497	cm->cm_fib->Header.ReceiverFibAddress = (u_int32_t)cm->cm_fibphys;
1498
1499	/* save a pointer to the command for speedy reverse-lookup */
1500	cm->cm_fib->Header.SenderData = cm->cm_index;
1501
1502	if (cm->cm_flags & AAC_CMD_DATAIN)
1503		bus_dmamap_sync(sc->aac_buffer_dmat, cm->cm_datamap,
1504				BUS_DMASYNC_PREREAD);
1505	if (cm->cm_flags & AAC_CMD_DATAOUT)
1506		bus_dmamap_sync(sc->aac_buffer_dmat, cm->cm_datamap,
1507				BUS_DMASYNC_PREWRITE);
1508	cm->cm_flags |= AAC_CMD_MAPPED;
1509
1510	if (sc->flags & AAC_FLAGS_NEW_COMM) {
1511		int count = 10000000L;
1512		while (AAC_SEND_COMMAND(sc, cm) != 0) {
1513			if (--count == 0) {
1514				aac_unmap_command(cm);
1515				sc->flags |= AAC_QUEUE_FRZN;
1516				aac_requeue_ready(cm);
1517			}
1518			DELAY(5);			/* wait 5 usec. */
1519		}
1520	} else {
1521		/* Put the FIB on the outbound queue */
1522		if (aac_enqueue_fib(sc, cm->cm_queue, cm) == EBUSY) {
1523			aac_unmap_command(cm);
1524			sc->flags |= AAC_QUEUE_FRZN;
1525			aac_requeue_ready(cm);
1526		}
1527	}
1528
1529	return;
1530}
1531
1532/*
1533 * Unmap a command from controller-visible space.
1534 */
1535static void
1536aac_unmap_command(struct aac_command *cm)
1537{
1538	struct aac_softc *sc;
1539
1540	debug_called(2);
1541
1542	sc = cm->cm_sc;
1543
1544	if (!(cm->cm_flags & AAC_CMD_MAPPED))
1545		return;
1546
1547	if (cm->cm_datalen != 0) {
1548		if (cm->cm_flags & AAC_CMD_DATAIN)
1549			bus_dmamap_sync(sc->aac_buffer_dmat, cm->cm_datamap,
1550					BUS_DMASYNC_POSTREAD);
1551		if (cm->cm_flags & AAC_CMD_DATAOUT)
1552			bus_dmamap_sync(sc->aac_buffer_dmat, cm->cm_datamap,
1553					BUS_DMASYNC_POSTWRITE);
1554
1555		bus_dmamap_unload(sc->aac_buffer_dmat, cm->cm_datamap);
1556	}
1557	cm->cm_flags &= ~AAC_CMD_MAPPED;
1558}
1559
1560/*
1561 * Hardware Interface
1562 */
1563
1564/*
1565 * Initialise the adapter.
1566 */
1567static void
1568aac_common_map(void *arg, bus_dma_segment_t *segs, int nseg, int error)
1569{
1570	struct aac_softc *sc;
1571
1572	debug_called(1);
1573
1574	sc = (struct aac_softc *)arg;
1575
1576	sc->aac_common_busaddr = segs[0].ds_addr;
1577}
1578
1579static int
1580aac_check_firmware(struct aac_softc *sc)
1581{
1582	u_int32_t major, minor, options = 0, atu_size = 0;
1583	int status;
1584
1585	debug_called(1);
1586
1587	/*
1588	 * Retrieve the firmware version numbers.  Dell PERC2/QC cards with
1589	 * firmware version 1.x are not compatible with this driver.
1590	 */
1591	if (sc->flags & AAC_FLAGS_PERC2QC) {
1592		if (aac_sync_command(sc, AAC_MONKER_GETKERNVER, 0, 0, 0, 0,
1593				     NULL)) {
1594			device_printf(sc->aac_dev,
1595				      "Error reading firmware version\n");
1596			return (EIO);
1597		}
1598
1599		/* These numbers are stored as ASCII! */
1600		major = (AAC_GET_MAILBOX(sc, 1) & 0xff) - 0x30;
1601		minor = (AAC_GET_MAILBOX(sc, 2) & 0xff) - 0x30;
1602		if (major == 1) {
1603			device_printf(sc->aac_dev,
1604			    "Firmware version %d.%d is not supported.\n",
1605			    major, minor);
1606			return (EINVAL);
1607		}
1608	}
1609
1610	/*
1611	 * Retrieve the capabilities/supported options word so we know what
1612	 * work-arounds to enable.  Some firmware revs don't support this
1613	 * command.
1614	 */
1615	if (aac_sync_command(sc, AAC_MONKER_GETINFO, 0, 0, 0, 0, &status)) {
1616		if (status != AAC_SRB_STS_INVALID_REQUEST) {
1617			device_printf(sc->aac_dev,
1618			     "RequestAdapterInfo failed\n");
1619			return (EIO);
1620		}
1621	} else {
1622		options = AAC_GET_MAILBOX(sc, 1);
1623		atu_size = AAC_GET_MAILBOX(sc, 2);
1624		sc->supported_options = options;
1625
1626		if ((options & AAC_SUPPORTED_4GB_WINDOW) != 0 &&
1627		    (sc->flags & AAC_FLAGS_NO4GB) == 0)
1628			sc->flags |= AAC_FLAGS_4GB_WINDOW;
1629		if (options & AAC_SUPPORTED_NONDASD)
1630			sc->flags |= AAC_FLAGS_ENABLE_CAM;
1631		if ((options & AAC_SUPPORTED_SGMAP_HOST64) != 0
1632		     && (sizeof(bus_addr_t) > 4)) {
1633			device_printf(sc->aac_dev,
1634			    "Enabling 64-bit address support\n");
1635			sc->flags |= AAC_FLAGS_SG_64BIT;
1636		}
1637		if ((options & AAC_SUPPORTED_NEW_COMM)
1638		 && sc->aac_if.aif_send_command)
1639			sc->flags |= AAC_FLAGS_NEW_COMM;
1640		if (options & AAC_SUPPORTED_64BIT_ARRAYSIZE)
1641			sc->flags |= AAC_FLAGS_ARRAY_64BIT;
1642	}
1643
1644	/* Check for broken hardware that does a lower number of commands */
1645	sc->aac_max_fibs = (sc->flags & AAC_FLAGS_256FIBS ? 256:512);
1646
1647	/* Remap mem. resource, if required */
1648	if ((sc->flags & AAC_FLAGS_NEW_COMM) &&
1649		atu_size > rman_get_size(sc->aac_regs_resource)) {
1650		bus_release_resource(
1651			sc->aac_dev, SYS_RES_MEMORY,
1652			sc->aac_regs_rid, sc->aac_regs_resource);
1653		sc->aac_regs_resource = bus_alloc_resource(
1654			sc->aac_dev, SYS_RES_MEMORY, &sc->aac_regs_rid,
1655			0ul, ~0ul, atu_size, RF_ACTIVE);
1656		if (sc->aac_regs_resource == NULL) {
1657			sc->aac_regs_resource = bus_alloc_resource_any(
1658				sc->aac_dev, SYS_RES_MEMORY,
1659				&sc->aac_regs_rid, RF_ACTIVE);
1660			if (sc->aac_regs_resource == NULL) {
1661				device_printf(sc->aac_dev,
1662				    "couldn't allocate register window\n");
1663				return (ENXIO);
1664			}
1665			sc->flags &= ~AAC_FLAGS_NEW_COMM;
1666		}
1667		sc->aac_btag = rman_get_bustag(sc->aac_regs_resource);
1668		sc->aac_bhandle = rman_get_bushandle(sc->aac_regs_resource);
1669	}
1670
1671	/* Read preferred settings */
1672	sc->aac_max_fib_size = sizeof(struct aac_fib);
1673	sc->aac_max_sectors = 128;				/* 64KB */
1674	if (sc->flags & AAC_FLAGS_SG_64BIT)
1675		sc->aac_sg_tablesize = (AAC_FIB_DATASIZE
1676		 - sizeof(struct aac_blockwrite64))
1677		 / sizeof(struct aac_sg_entry64);
1678	else
1679		sc->aac_sg_tablesize = (AAC_FIB_DATASIZE
1680		 - sizeof(struct aac_blockwrite))
1681		 / sizeof(struct aac_sg_entry);
1682
1683	if (!aac_sync_command(sc, AAC_MONKER_GETCOMMPREF, 0, 0, 0, 0, NULL)) {
1684		options = AAC_GET_MAILBOX(sc, 1);
1685		sc->aac_max_fib_size = (options & 0xFFFF);
1686		sc->aac_max_sectors = (options >> 16) << 1;
1687		options = AAC_GET_MAILBOX(sc, 2);
1688		sc->aac_sg_tablesize = (options >> 16);
1689		options = AAC_GET_MAILBOX(sc, 3);
1690		sc->aac_max_fibs = (options & 0xFFFF);
1691	}
1692	if (sc->aac_max_fib_size > PAGE_SIZE)
1693		sc->aac_max_fib_size = PAGE_SIZE;
1694	sc->aac_max_fibs_alloc = PAGE_SIZE / sc->aac_max_fib_size;
1695
1696	return (0);
1697}
1698
1699static int
1700aac_init(struct aac_softc *sc)
1701{
1702	struct aac_adapter_init	*ip;
1703	time_t then;
1704	u_int32_t code, qoffset;
1705	int error;
1706
1707	debug_called(1);
1708
1709	/*
1710	 * First wait for the adapter to come ready.
1711	 */
1712	then = time_uptime;
1713	do {
1714		code = AAC_GET_FWSTATUS(sc);
1715		if (code & AAC_SELF_TEST_FAILED) {
1716			device_printf(sc->aac_dev, "FATAL: selftest failed\n");
1717			return(ENXIO);
1718		}
1719		if (code & AAC_KERNEL_PANIC) {
1720			device_printf(sc->aac_dev,
1721				      "FATAL: controller kernel panic\n");
1722			return(ENXIO);
1723		}
1724		if (time_uptime > (then + AAC_BOOT_TIMEOUT)) {
1725			device_printf(sc->aac_dev,
1726				      "FATAL: controller not coming ready, "
1727					   "status %x\n", code);
1728			return(ENXIO);
1729		}
1730	} while (!(code & AAC_UP_AND_RUNNING));
1731
1732	error = ENOMEM;
1733	/*
1734	 * Create DMA tag for mapping buffers into controller-addressable space.
1735	 */
1736	if (bus_dma_tag_create(sc->aac_parent_dmat, 	/* parent */
1737			       1, 0, 			/* algnmnt, boundary */
1738			       (sc->flags & AAC_FLAGS_SG_64BIT) ?
1739			       BUS_SPACE_MAXADDR :
1740			       BUS_SPACE_MAXADDR_32BIT,	/* lowaddr */
1741			       BUS_SPACE_MAXADDR, 	/* highaddr */
1742			       NULL, NULL, 		/* filter, filterarg */
1743			       MAXBSIZE,		/* maxsize */
1744			       sc->aac_sg_tablesize,	/* nsegments */
1745			       MAXBSIZE,		/* maxsegsize */
1746			       BUS_DMA_ALLOCNOW,	/* flags */
1747			       busdma_lock_mutex,	/* lockfunc */
1748			       &sc->aac_io_lock,	/* lockfuncarg */
1749			       &sc->aac_buffer_dmat)) {
1750		device_printf(sc->aac_dev, "can't allocate buffer DMA tag\n");
1751		goto out;
1752	}
1753
1754	/*
1755	 * Create DMA tag for mapping FIBs into controller-addressable space..
1756	 */
1757	if (bus_dma_tag_create(sc->aac_parent_dmat,	/* parent */
1758			       1, 0, 			/* algnmnt, boundary */
1759			       (sc->flags & AAC_FLAGS_4GB_WINDOW) ?
1760			       BUS_SPACE_MAXADDR_32BIT :
1761			       0x7fffffff,		/* lowaddr */
1762			       BUS_SPACE_MAXADDR, 	/* highaddr */
1763			       NULL, NULL, 		/* filter, filterarg */
1764			       sc->aac_max_fibs_alloc *
1765			       sc->aac_max_fib_size,  /* maxsize */
1766			       1,			/* nsegments */
1767			       sc->aac_max_fibs_alloc *
1768			       sc->aac_max_fib_size,	/* maxsegsize */
1769			       0,			/* flags */
1770			       NULL, NULL,		/* No locking needed */
1771			       &sc->aac_fib_dmat)) {
1772		device_printf(sc->aac_dev, "can't allocate FIB DMA tag\n");;
1773		goto out;
1774	}
1775
1776	/*
1777	 * Create DMA tag for the common structure and allocate it.
1778	 */
1779	if (bus_dma_tag_create(sc->aac_parent_dmat, 	/* parent */
1780			       1, 0,			/* algnmnt, boundary */
1781			       (sc->flags & AAC_FLAGS_4GB_WINDOW) ?
1782			       BUS_SPACE_MAXADDR_32BIT :
1783			       0x7fffffff,		/* lowaddr */
1784			       BUS_SPACE_MAXADDR, 	/* highaddr */
1785			       NULL, NULL, 		/* filter, filterarg */
1786			       8192 + sizeof(struct aac_common), /* maxsize */
1787			       1,			/* nsegments */
1788			       BUS_SPACE_MAXSIZE_32BIT,	/* maxsegsize */
1789			       0,			/* flags */
1790			       NULL, NULL,		/* No locking needed */
1791			       &sc->aac_common_dmat)) {
1792		device_printf(sc->aac_dev,
1793			      "can't allocate common structure DMA tag\n");
1794		goto out;
1795	}
1796	if (bus_dmamem_alloc(sc->aac_common_dmat, (void **)&sc->aac_common,
1797			     BUS_DMA_NOWAIT, &sc->aac_common_dmamap)) {
1798		device_printf(sc->aac_dev, "can't allocate common structure\n");
1799		goto out;
1800	}
1801
1802	/*
1803	 * Work around a bug in the 2120 and 2200 that cannot DMA commands
1804	 * below address 8192 in physical memory.
1805	 * XXX If the padding is not needed, can it be put to use instead
1806	 * of ignored?
1807	 */
1808	(void)bus_dmamap_load(sc->aac_common_dmat, sc->aac_common_dmamap,
1809			sc->aac_common, 8192 + sizeof(*sc->aac_common),
1810			aac_common_map, sc, 0);
1811
1812	if (sc->aac_common_busaddr < 8192) {
1813		sc->aac_common = (struct aac_common *)
1814		    ((uint8_t *)sc->aac_common + 8192);
1815		sc->aac_common_busaddr += 8192;
1816	}
1817	bzero(sc->aac_common, sizeof(*sc->aac_common));
1818
1819	/* Allocate some FIBs and associated command structs */
1820	TAILQ_INIT(&sc->aac_fibmap_tqh);
1821	sc->aac_commands = malloc(sc->aac_max_fibs * sizeof(struct aac_command),
1822				  M_AACBUF, M_WAITOK|M_ZERO);
1823	while (sc->total_fibs < AAC_PREALLOCATE_FIBS) {
1824		if (aac_alloc_commands(sc) != 0)
1825			break;
1826	}
1827	if (sc->total_fibs == 0)
1828		goto out;
1829
1830	/*
1831	 * Fill in the init structure.  This tells the adapter about the
1832	 * physical location of various important shared data structures.
1833	 */
1834	ip = &sc->aac_common->ac_init;
1835	ip->InitStructRevision = AAC_INIT_STRUCT_REVISION;
1836	if (sc->aac_max_fib_size > sizeof(struct aac_fib)) {
1837		ip->InitStructRevision = AAC_INIT_STRUCT_REVISION_4;
1838		sc->flags |= AAC_FLAGS_RAW_IO;
1839	}
1840	ip->MiniPortRevision = AAC_INIT_STRUCT_MINIPORT_REVISION;
1841
1842	ip->AdapterFibsPhysicalAddress = sc->aac_common_busaddr +
1843					 offsetof(struct aac_common, ac_fibs);
1844	ip->AdapterFibsVirtualAddress = 0;
1845	ip->AdapterFibsSize = AAC_ADAPTER_FIBS * sizeof(struct aac_fib);
1846	ip->AdapterFibAlign = sizeof(struct aac_fib);
1847
1848	ip->PrintfBufferAddress = sc->aac_common_busaddr +
1849				  offsetof(struct aac_common, ac_printf);
1850	ip->PrintfBufferSize = AAC_PRINTF_BUFSIZE;
1851
1852	/*
1853	 * The adapter assumes that pages are 4K in size, except on some
1854 	 * broken firmware versions that do the page->byte conversion twice,
1855	 * therefore 'assuming' that this value is in 16MB units (2^24).
1856	 * Round up since the granularity is so high.
1857	 */
1858	ip->HostPhysMemPages = ctob(physmem) / AAC_PAGE_SIZE;
1859	if (sc->flags & AAC_FLAGS_BROKEN_MEMMAP) {
1860		ip->HostPhysMemPages =
1861		    (ip->HostPhysMemPages + AAC_PAGE_SIZE) / AAC_PAGE_SIZE;
1862	}
1863	ip->HostElapsedSeconds = time_uptime;	/* reset later if invalid */
1864
1865	ip->InitFlags = 0;
1866	if (sc->flags & AAC_FLAGS_NEW_COMM) {
1867		ip->InitFlags = INITFLAGS_NEW_COMM_SUPPORTED;
1868		device_printf(sc->aac_dev, "New comm. interface enabled\n");
1869	}
1870
1871	ip->MaxIoCommands = sc->aac_max_fibs;
1872	ip->MaxIoSize = sc->aac_max_sectors << 9;
1873	ip->MaxFibSize = sc->aac_max_fib_size;
1874
1875	/*
1876	 * Initialise FIB queues.  Note that it appears that the layout of the
1877	 * indexes and the segmentation of the entries may be mandated by the
1878	 * adapter, which is only told about the base of the queue index fields.
1879	 *
1880	 * The initial values of the indices are assumed to inform the adapter
1881	 * of the sizes of the respective queues, and theoretically it could
1882	 * work out the entire layout of the queue structures from this.  We
1883	 * take the easy route and just lay this area out like everyone else
1884	 * does.
1885	 *
1886	 * The Linux driver uses a much more complex scheme whereby several
1887	 * header records are kept for each queue.  We use a couple of generic
1888	 * list manipulation functions which 'know' the size of each list by
1889	 * virtue of a table.
1890	 */
1891	qoffset = offsetof(struct aac_common, ac_qbuf) + AAC_QUEUE_ALIGN;
1892	qoffset &= ~(AAC_QUEUE_ALIGN - 1);
1893	sc->aac_queues =
1894	    (struct aac_queue_table *)((uintptr_t)sc->aac_common + qoffset);
1895	ip->CommHeaderAddress = sc->aac_common_busaddr + qoffset;
1896
1897	sc->aac_queues->qt_qindex[AAC_HOST_NORM_CMD_QUEUE][AAC_PRODUCER_INDEX] =
1898		AAC_HOST_NORM_CMD_ENTRIES;
1899	sc->aac_queues->qt_qindex[AAC_HOST_NORM_CMD_QUEUE][AAC_CONSUMER_INDEX] =
1900		AAC_HOST_NORM_CMD_ENTRIES;
1901	sc->aac_queues->qt_qindex[AAC_HOST_HIGH_CMD_QUEUE][AAC_PRODUCER_INDEX] =
1902		AAC_HOST_HIGH_CMD_ENTRIES;
1903	sc->aac_queues->qt_qindex[AAC_HOST_HIGH_CMD_QUEUE][AAC_CONSUMER_INDEX] =
1904		AAC_HOST_HIGH_CMD_ENTRIES;
1905	sc->aac_queues->qt_qindex[AAC_ADAP_NORM_CMD_QUEUE][AAC_PRODUCER_INDEX] =
1906		AAC_ADAP_NORM_CMD_ENTRIES;
1907	sc->aac_queues->qt_qindex[AAC_ADAP_NORM_CMD_QUEUE][AAC_CONSUMER_INDEX] =
1908		AAC_ADAP_NORM_CMD_ENTRIES;
1909	sc->aac_queues->qt_qindex[AAC_ADAP_HIGH_CMD_QUEUE][AAC_PRODUCER_INDEX] =
1910		AAC_ADAP_HIGH_CMD_ENTRIES;
1911	sc->aac_queues->qt_qindex[AAC_ADAP_HIGH_CMD_QUEUE][AAC_CONSUMER_INDEX] =
1912		AAC_ADAP_HIGH_CMD_ENTRIES;
1913	sc->aac_queues->qt_qindex[AAC_HOST_NORM_RESP_QUEUE][AAC_PRODUCER_INDEX]=
1914		AAC_HOST_NORM_RESP_ENTRIES;
1915	sc->aac_queues->qt_qindex[AAC_HOST_NORM_RESP_QUEUE][AAC_CONSUMER_INDEX]=
1916		AAC_HOST_NORM_RESP_ENTRIES;
1917	sc->aac_queues->qt_qindex[AAC_HOST_HIGH_RESP_QUEUE][AAC_PRODUCER_INDEX]=
1918		AAC_HOST_HIGH_RESP_ENTRIES;
1919	sc->aac_queues->qt_qindex[AAC_HOST_HIGH_RESP_QUEUE][AAC_CONSUMER_INDEX]=
1920		AAC_HOST_HIGH_RESP_ENTRIES;
1921	sc->aac_queues->qt_qindex[AAC_ADAP_NORM_RESP_QUEUE][AAC_PRODUCER_INDEX]=
1922		AAC_ADAP_NORM_RESP_ENTRIES;
1923	sc->aac_queues->qt_qindex[AAC_ADAP_NORM_RESP_QUEUE][AAC_CONSUMER_INDEX]=
1924		AAC_ADAP_NORM_RESP_ENTRIES;
1925	sc->aac_queues->qt_qindex[AAC_ADAP_HIGH_RESP_QUEUE][AAC_PRODUCER_INDEX]=
1926		AAC_ADAP_HIGH_RESP_ENTRIES;
1927	sc->aac_queues->qt_qindex[AAC_ADAP_HIGH_RESP_QUEUE][AAC_CONSUMER_INDEX]=
1928		AAC_ADAP_HIGH_RESP_ENTRIES;
1929	sc->aac_qentries[AAC_HOST_NORM_CMD_QUEUE] =
1930		&sc->aac_queues->qt_HostNormCmdQueue[0];
1931	sc->aac_qentries[AAC_HOST_HIGH_CMD_QUEUE] =
1932		&sc->aac_queues->qt_HostHighCmdQueue[0];
1933	sc->aac_qentries[AAC_ADAP_NORM_CMD_QUEUE] =
1934		&sc->aac_queues->qt_AdapNormCmdQueue[0];
1935	sc->aac_qentries[AAC_ADAP_HIGH_CMD_QUEUE] =
1936		&sc->aac_queues->qt_AdapHighCmdQueue[0];
1937	sc->aac_qentries[AAC_HOST_NORM_RESP_QUEUE] =
1938		&sc->aac_queues->qt_HostNormRespQueue[0];
1939	sc->aac_qentries[AAC_HOST_HIGH_RESP_QUEUE] =
1940		&sc->aac_queues->qt_HostHighRespQueue[0];
1941	sc->aac_qentries[AAC_ADAP_NORM_RESP_QUEUE] =
1942		&sc->aac_queues->qt_AdapNormRespQueue[0];
1943	sc->aac_qentries[AAC_ADAP_HIGH_RESP_QUEUE] =
1944		&sc->aac_queues->qt_AdapHighRespQueue[0];
1945
1946	/*
1947	 * Do controller-type-specific initialisation
1948	 */
1949	switch (sc->aac_hwif) {
1950	case AAC_HWIF_I960RX:
1951		AAC_SETREG4(sc, AAC_RX_ODBR, ~0);
1952		break;
1953	case AAC_HWIF_RKT:
1954		AAC_SETREG4(sc, AAC_RKT_ODBR, ~0);
1955		break;
1956	default:
1957		break;
1958	}
1959
1960	/*
1961	 * Give the init structure to the controller.
1962	 */
1963	if (aac_sync_command(sc, AAC_MONKER_INITSTRUCT,
1964			     sc->aac_common_busaddr +
1965			     offsetof(struct aac_common, ac_init), 0, 0, 0,
1966			     NULL)) {
1967		device_printf(sc->aac_dev,
1968			      "error establishing init structure\n");
1969		error = EIO;
1970		goto out;
1971	}
1972
1973	error = 0;
1974out:
1975	return(error);
1976}
1977
1978/*
1979 * Send a synchronous command to the controller and wait for a result.
1980 * Indicate if the controller completed the command with an error status.
1981 */
1982static int
1983aac_sync_command(struct aac_softc *sc, u_int32_t command,
1984		 u_int32_t arg0, u_int32_t arg1, u_int32_t arg2, u_int32_t arg3,
1985		 u_int32_t *sp)
1986{
1987	time_t then;
1988	u_int32_t status;
1989
1990	debug_called(3);
1991
1992	/* populate the mailbox */
1993	AAC_SET_MAILBOX(sc, command, arg0, arg1, arg2, arg3);
1994
1995	/* ensure the sync command doorbell flag is cleared */
1996	AAC_CLEAR_ISTATUS(sc, AAC_DB_SYNC_COMMAND);
1997
1998	/* then set it to signal the adapter */
1999	AAC_QNOTIFY(sc, AAC_DB_SYNC_COMMAND);
2000
2001	/* spin waiting for the command to complete */
2002	then = time_uptime;
2003	do {
2004		if (time_uptime > (then + AAC_IMMEDIATE_TIMEOUT)) {
2005			debug(1, "timed out");
2006			return(EIO);
2007		}
2008	} while (!(AAC_GET_ISTATUS(sc) & AAC_DB_SYNC_COMMAND));
2009
2010	/* clear the completion flag */
2011	AAC_CLEAR_ISTATUS(sc, AAC_DB_SYNC_COMMAND);
2012
2013	/* get the command status */
2014	status = AAC_GET_MAILBOX(sc, 0);
2015	if (sp != NULL)
2016		*sp = status;
2017
2018	if (status != AAC_SRB_STS_SUCCESS)
2019		return (-1);
2020	return(0);
2021}
2022
2023int
2024aac_sync_fib(struct aac_softc *sc, u_int32_t command, u_int32_t xferstate,
2025		 struct aac_fib *fib, u_int16_t datasize)
2026{
2027	debug_called(3);
2028	mtx_assert(&sc->aac_io_lock, MA_OWNED);
2029
2030	if (datasize > AAC_FIB_DATASIZE)
2031		return(EINVAL);
2032
2033	/*
2034	 * Set up the sync FIB
2035	 */
2036	fib->Header.XferState = AAC_FIBSTATE_HOSTOWNED |
2037				AAC_FIBSTATE_INITIALISED |
2038				AAC_FIBSTATE_EMPTY;
2039	fib->Header.XferState |= xferstate;
2040	fib->Header.Command = command;
2041	fib->Header.StructType = AAC_FIBTYPE_TFIB;
2042	fib->Header.Size = sizeof(struct aac_fib) + datasize;
2043	fib->Header.SenderSize = sizeof(struct aac_fib);
2044	fib->Header.SenderFibAddress = 0;	/* Not needed */
2045	fib->Header.ReceiverFibAddress = sc->aac_common_busaddr +
2046					 offsetof(struct aac_common,
2047						  ac_sync_fib);
2048
2049	/*
2050	 * Give the FIB to the controller, wait for a response.
2051	 */
2052	if (aac_sync_command(sc, AAC_MONKER_SYNCFIB,
2053			     fib->Header.ReceiverFibAddress, 0, 0, 0, NULL)) {
2054		debug(2, "IO error");
2055		return(EIO);
2056	}
2057
2058	return (0);
2059}
2060
2061/*
2062 * Adapter-space FIB queue manipulation
2063 *
2064 * Note that the queue implementation here is a little funky; neither the PI or
2065 * CI will ever be zero.  This behaviour is a controller feature.
2066 */
2067static struct {
2068	int		size;
2069	int		notify;
2070} aac_qinfo[] = {
2071	{AAC_HOST_NORM_CMD_ENTRIES, AAC_DB_COMMAND_NOT_FULL},
2072	{AAC_HOST_HIGH_CMD_ENTRIES, 0},
2073	{AAC_ADAP_NORM_CMD_ENTRIES, AAC_DB_COMMAND_READY},
2074	{AAC_ADAP_HIGH_CMD_ENTRIES, 0},
2075	{AAC_HOST_NORM_RESP_ENTRIES, AAC_DB_RESPONSE_NOT_FULL},
2076	{AAC_HOST_HIGH_RESP_ENTRIES, 0},
2077	{AAC_ADAP_NORM_RESP_ENTRIES, AAC_DB_RESPONSE_READY},
2078	{AAC_ADAP_HIGH_RESP_ENTRIES, 0}
2079};
2080
2081/*
2082 * Atomically insert an entry into the nominated queue, returns 0 on success or
2083 * EBUSY if the queue is full.
2084 *
2085 * Note: it would be more efficient to defer notifying the controller in
2086 *	 the case where we may be inserting several entries in rapid succession,
2087 *	 but implementing this usefully may be difficult (it would involve a
2088 *	 separate queue/notify interface).
2089 */
2090static int
2091aac_enqueue_fib(struct aac_softc *sc, int queue, struct aac_command *cm)
2092{
2093	u_int32_t pi, ci;
2094	int error;
2095	u_int32_t fib_size;
2096	u_int32_t fib_addr;
2097
2098	debug_called(3);
2099
2100	fib_size = cm->cm_fib->Header.Size;
2101	fib_addr = cm->cm_fib->Header.ReceiverFibAddress;
2102
2103	/* get the producer/consumer indices */
2104	pi = sc->aac_queues->qt_qindex[queue][AAC_PRODUCER_INDEX];
2105	ci = sc->aac_queues->qt_qindex[queue][AAC_CONSUMER_INDEX];
2106
2107	/* wrap the queue? */
2108	if (pi >= aac_qinfo[queue].size)
2109		pi = 0;
2110
2111	/* check for queue full */
2112	if ((pi + 1) == ci) {
2113		error = EBUSY;
2114		goto out;
2115	}
2116
2117	/*
2118	 * To avoid a race with its completion interrupt, place this command on
2119	 * the busy queue prior to advertising it to the controller.
2120	 */
2121	aac_enqueue_busy(cm);
2122
2123	/* populate queue entry */
2124	(sc->aac_qentries[queue] + pi)->aq_fib_size = fib_size;
2125	(sc->aac_qentries[queue] + pi)->aq_fib_addr = fib_addr;
2126
2127	/* update producer index */
2128	sc->aac_queues->qt_qindex[queue][AAC_PRODUCER_INDEX] = pi + 1;
2129
2130	/* notify the adapter if we know how */
2131	if (aac_qinfo[queue].notify != 0)
2132		AAC_QNOTIFY(sc, aac_qinfo[queue].notify);
2133
2134	error = 0;
2135
2136out:
2137	return(error);
2138}
2139
2140/*
2141 * Atomically remove one entry from the nominated queue, returns 0 on
2142 * success or ENOENT if the queue is empty.
2143 */
2144static int
2145aac_dequeue_fib(struct aac_softc *sc, int queue, u_int32_t *fib_size,
2146		struct aac_fib **fib_addr)
2147{
2148	u_int32_t pi, ci;
2149	u_int32_t fib_index;
2150	int error;
2151	int notify;
2152
2153	debug_called(3);
2154
2155	/* get the producer/consumer indices */
2156	pi = sc->aac_queues->qt_qindex[queue][AAC_PRODUCER_INDEX];
2157	ci = sc->aac_queues->qt_qindex[queue][AAC_CONSUMER_INDEX];
2158
2159	/* check for queue empty */
2160	if (ci == pi) {
2161		error = ENOENT;
2162		goto out;
2163	}
2164
2165	/* wrap the pi so the following test works */
2166	if (pi >= aac_qinfo[queue].size)
2167		pi = 0;
2168
2169	notify = 0;
2170	if (ci == pi + 1)
2171		notify++;
2172
2173	/* wrap the queue? */
2174	if (ci >= aac_qinfo[queue].size)
2175		ci = 0;
2176
2177	/* fetch the entry */
2178	*fib_size = (sc->aac_qentries[queue] + ci)->aq_fib_size;
2179
2180	switch (queue) {
2181	case AAC_HOST_NORM_CMD_QUEUE:
2182	case AAC_HOST_HIGH_CMD_QUEUE:
2183		/*
2184		 * The aq_fib_addr is only 32 bits wide so it can't be counted
2185		 * on to hold an address.  For AIF's, the adapter assumes
2186		 * that it's giving us an address into the array of AIF fibs.
2187		 * Therefore, we have to convert it to an index.
2188		 */
2189		fib_index = (sc->aac_qentries[queue] + ci)->aq_fib_addr /
2190			sizeof(struct aac_fib);
2191		*fib_addr = &sc->aac_common->ac_fibs[fib_index];
2192		break;
2193
2194	case AAC_HOST_NORM_RESP_QUEUE:
2195	case AAC_HOST_HIGH_RESP_QUEUE:
2196	{
2197		struct aac_command *cm;
2198
2199		/*
2200		 * As above, an index is used instead of an actual address.
2201		 * Gotta shift the index to account for the fast response
2202		 * bit.  No other correction is needed since this value was
2203		 * originally provided by the driver via the SenderFibAddress
2204		 * field.
2205		 */
2206		fib_index = (sc->aac_qentries[queue] + ci)->aq_fib_addr;
2207		cm = sc->aac_commands + (fib_index >> 2);
2208		*fib_addr = cm->cm_fib;
2209
2210		/*
2211		 * Is this a fast response? If it is, update the fib fields in
2212		 * local memory since the whole fib isn't DMA'd back up.
2213		 */
2214		if (fib_index & 0x01) {
2215			(*fib_addr)->Header.XferState |= AAC_FIBSTATE_DONEADAP;
2216			*((u_int32_t*)((*fib_addr)->data)) = AAC_ERROR_NORMAL;
2217		}
2218		break;
2219	}
2220	default:
2221		panic("Invalid queue in aac_dequeue_fib()");
2222		break;
2223	}
2224
2225	/* update consumer index */
2226	sc->aac_queues->qt_qindex[queue][AAC_CONSUMER_INDEX] = ci + 1;
2227
2228	/* if we have made the queue un-full, notify the adapter */
2229	if (notify && (aac_qinfo[queue].notify != 0))
2230		AAC_QNOTIFY(sc, aac_qinfo[queue].notify);
2231	error = 0;
2232
2233out:
2234	return(error);
2235}
2236
2237/*
2238 * Put our response to an Adapter Initialed Fib on the response queue
2239 */
2240static int
2241aac_enqueue_response(struct aac_softc *sc, int queue, struct aac_fib *fib)
2242{
2243	u_int32_t pi, ci;
2244	int error;
2245	u_int32_t fib_size;
2246	u_int32_t fib_addr;
2247
2248	debug_called(1);
2249
2250	/* Tell the adapter where the FIB is */
2251	fib_size = fib->Header.Size;
2252	fib_addr = fib->Header.SenderFibAddress;
2253	fib->Header.ReceiverFibAddress = fib_addr;
2254
2255	/* get the producer/consumer indices */
2256	pi = sc->aac_queues->qt_qindex[queue][AAC_PRODUCER_INDEX];
2257	ci = sc->aac_queues->qt_qindex[queue][AAC_CONSUMER_INDEX];
2258
2259	/* wrap the queue? */
2260	if (pi >= aac_qinfo[queue].size)
2261		pi = 0;
2262
2263	/* check for queue full */
2264	if ((pi + 1) == ci) {
2265		error = EBUSY;
2266		goto out;
2267	}
2268
2269	/* populate queue entry */
2270	(sc->aac_qentries[queue] + pi)->aq_fib_size = fib_size;
2271	(sc->aac_qentries[queue] + pi)->aq_fib_addr = fib_addr;
2272
2273	/* update producer index */
2274	sc->aac_queues->qt_qindex[queue][AAC_PRODUCER_INDEX] = pi + 1;
2275
2276	/* notify the adapter if we know how */
2277	if (aac_qinfo[queue].notify != 0)
2278		AAC_QNOTIFY(sc, aac_qinfo[queue].notify);
2279
2280	error = 0;
2281
2282out:
2283	return(error);
2284}
2285
2286/*
2287 * Check for commands that have been outstanding for a suspiciously long time,
2288 * and complain about them.
2289 */
2290static void
2291aac_timeout(struct aac_softc *sc)
2292{
2293	struct aac_command *cm;
2294	time_t deadline;
2295	int timedout, code;
2296
2297	/*
2298	 * Traverse the busy command list, bitch about late commands once
2299	 * only.
2300	 */
2301	timedout = 0;
2302	deadline = time_uptime - AAC_CMD_TIMEOUT;
2303	TAILQ_FOREACH(cm, &sc->aac_busy, cm_link) {
2304		if ((cm->cm_timestamp  < deadline)
2305			/* && !(cm->cm_flags & AAC_CMD_TIMEDOUT) */) {
2306			cm->cm_flags |= AAC_CMD_TIMEDOUT;
2307			device_printf(sc->aac_dev,
2308				      "COMMAND %p TIMEOUT AFTER %d SECONDS\n",
2309				      cm, (int)(time_uptime-cm->cm_timestamp));
2310			AAC_PRINT_FIB(sc, cm->cm_fib);
2311			timedout++;
2312		}
2313	}
2314
2315	if (timedout) {
2316		code = AAC_GET_FWSTATUS(sc);
2317		if (code != AAC_UP_AND_RUNNING) {
2318			device_printf(sc->aac_dev, "WARNING! Controller is no "
2319				      "longer running! code= 0x%x\n", code);
2320		}
2321	}
2322	return;
2323}
2324
2325/*
2326 * Interface Function Vectors
2327 */
2328
2329/*
2330 * Read the current firmware status word.
2331 */
2332static int
2333aac_sa_get_fwstatus(struct aac_softc *sc)
2334{
2335	debug_called(3);
2336
2337	return(AAC_GETREG4(sc, AAC_SA_FWSTATUS));
2338}
2339
2340static int
2341aac_rx_get_fwstatus(struct aac_softc *sc)
2342{
2343	debug_called(3);
2344
2345	return(AAC_GETREG4(sc, AAC_RX_FWSTATUS));
2346}
2347
2348static int
2349aac_fa_get_fwstatus(struct aac_softc *sc)
2350{
2351	int val;
2352
2353	debug_called(3);
2354
2355	val = AAC_GETREG4(sc, AAC_FA_FWSTATUS);
2356	return (val);
2357}
2358
2359static int
2360aac_rkt_get_fwstatus(struct aac_softc *sc)
2361{
2362	debug_called(3);
2363
2364	return(AAC_GETREG4(sc, AAC_RKT_FWSTATUS));
2365}
2366
2367/*
2368 * Notify the controller of a change in a given queue
2369 */
2370
2371static void
2372aac_sa_qnotify(struct aac_softc *sc, int qbit)
2373{
2374	debug_called(3);
2375
2376	AAC_SETREG2(sc, AAC_SA_DOORBELL1_SET, qbit);
2377}
2378
2379static void
2380aac_rx_qnotify(struct aac_softc *sc, int qbit)
2381{
2382	debug_called(3);
2383
2384	AAC_SETREG4(sc, AAC_RX_IDBR, qbit);
2385}
2386
2387static void
2388aac_fa_qnotify(struct aac_softc *sc, int qbit)
2389{
2390	debug_called(3);
2391
2392	AAC_SETREG2(sc, AAC_FA_DOORBELL1, qbit);
2393	AAC_FA_HACK(sc);
2394}
2395
2396static void
2397aac_rkt_qnotify(struct aac_softc *sc, int qbit)
2398{
2399	debug_called(3);
2400
2401	AAC_SETREG4(sc, AAC_RKT_IDBR, qbit);
2402}
2403
2404/*
2405 * Get the interrupt reason bits
2406 */
2407static int
2408aac_sa_get_istatus(struct aac_softc *sc)
2409{
2410	debug_called(3);
2411
2412	return(AAC_GETREG2(sc, AAC_SA_DOORBELL0));
2413}
2414
2415static int
2416aac_rx_get_istatus(struct aac_softc *sc)
2417{
2418	debug_called(3);
2419
2420	return(AAC_GETREG4(sc, AAC_RX_ODBR));
2421}
2422
2423static int
2424aac_fa_get_istatus(struct aac_softc *sc)
2425{
2426	int val;
2427
2428	debug_called(3);
2429
2430	val = AAC_GETREG2(sc, AAC_FA_DOORBELL0);
2431	return (val);
2432}
2433
2434static int
2435aac_rkt_get_istatus(struct aac_softc *sc)
2436{
2437	debug_called(3);
2438
2439	return(AAC_GETREG4(sc, AAC_RKT_ODBR));
2440}
2441
2442/*
2443 * Clear some interrupt reason bits
2444 */
2445static void
2446aac_sa_clear_istatus(struct aac_softc *sc, int mask)
2447{
2448	debug_called(3);
2449
2450	AAC_SETREG2(sc, AAC_SA_DOORBELL0_CLEAR, mask);
2451}
2452
2453static void
2454aac_rx_clear_istatus(struct aac_softc *sc, int mask)
2455{
2456	debug_called(3);
2457
2458	AAC_SETREG4(sc, AAC_RX_ODBR, mask);
2459}
2460
2461static void
2462aac_fa_clear_istatus(struct aac_softc *sc, int mask)
2463{
2464	debug_called(3);
2465
2466	AAC_SETREG2(sc, AAC_FA_DOORBELL0_CLEAR, mask);
2467	AAC_FA_HACK(sc);
2468}
2469
2470static void
2471aac_rkt_clear_istatus(struct aac_softc *sc, int mask)
2472{
2473	debug_called(3);
2474
2475	AAC_SETREG4(sc, AAC_RKT_ODBR, mask);
2476}
2477
2478/*
2479 * Populate the mailbox and set the command word
2480 */
2481static void
2482aac_sa_set_mailbox(struct aac_softc *sc, u_int32_t command,
2483		u_int32_t arg0, u_int32_t arg1, u_int32_t arg2, u_int32_t arg3)
2484{
2485	debug_called(4);
2486
2487	AAC_SETREG4(sc, AAC_SA_MAILBOX, command);
2488	AAC_SETREG4(sc, AAC_SA_MAILBOX + 4, arg0);
2489	AAC_SETREG4(sc, AAC_SA_MAILBOX + 8, arg1);
2490	AAC_SETREG4(sc, AAC_SA_MAILBOX + 12, arg2);
2491	AAC_SETREG4(sc, AAC_SA_MAILBOX + 16, arg3);
2492}
2493
2494static void
2495aac_rx_set_mailbox(struct aac_softc *sc, u_int32_t command,
2496		u_int32_t arg0, u_int32_t arg1, u_int32_t arg2, u_int32_t arg3)
2497{
2498	debug_called(4);
2499
2500	AAC_SETREG4(sc, AAC_RX_MAILBOX, command);
2501	AAC_SETREG4(sc, AAC_RX_MAILBOX + 4, arg0);
2502	AAC_SETREG4(sc, AAC_RX_MAILBOX + 8, arg1);
2503	AAC_SETREG4(sc, AAC_RX_MAILBOX + 12, arg2);
2504	AAC_SETREG4(sc, AAC_RX_MAILBOX + 16, arg3);
2505}
2506
2507static void
2508aac_fa_set_mailbox(struct aac_softc *sc, u_int32_t command,
2509		u_int32_t arg0, u_int32_t arg1, u_int32_t arg2, u_int32_t arg3)
2510{
2511	debug_called(4);
2512
2513	AAC_SETREG4(sc, AAC_FA_MAILBOX, command);
2514	AAC_FA_HACK(sc);
2515	AAC_SETREG4(sc, AAC_FA_MAILBOX + 4, arg0);
2516	AAC_FA_HACK(sc);
2517	AAC_SETREG4(sc, AAC_FA_MAILBOX + 8, arg1);
2518	AAC_FA_HACK(sc);
2519	AAC_SETREG4(sc, AAC_FA_MAILBOX + 12, arg2);
2520	AAC_FA_HACK(sc);
2521	AAC_SETREG4(sc, AAC_FA_MAILBOX + 16, arg3);
2522	AAC_FA_HACK(sc);
2523}
2524
2525static void
2526aac_rkt_set_mailbox(struct aac_softc *sc, u_int32_t command, u_int32_t arg0,
2527		    u_int32_t arg1, u_int32_t arg2, u_int32_t arg3)
2528{
2529	debug_called(4);
2530
2531	AAC_SETREG4(sc, AAC_RKT_MAILBOX, command);
2532	AAC_SETREG4(sc, AAC_RKT_MAILBOX + 4, arg0);
2533	AAC_SETREG4(sc, AAC_RKT_MAILBOX + 8, arg1);
2534	AAC_SETREG4(sc, AAC_RKT_MAILBOX + 12, arg2);
2535	AAC_SETREG4(sc, AAC_RKT_MAILBOX + 16, arg3);
2536}
2537
2538/*
2539 * Fetch the immediate command status word
2540 */
2541static int
2542aac_sa_get_mailbox(struct aac_softc *sc, int mb)
2543{
2544	debug_called(4);
2545
2546	return(AAC_GETREG4(sc, AAC_SA_MAILBOX + (mb * 4)));
2547}
2548
2549static int
2550aac_rx_get_mailbox(struct aac_softc *sc, int mb)
2551{
2552	debug_called(4);
2553
2554	return(AAC_GETREG4(sc, AAC_RX_MAILBOX + (mb * 4)));
2555}
2556
2557static int
2558aac_fa_get_mailbox(struct aac_softc *sc, int mb)
2559{
2560	int val;
2561
2562	debug_called(4);
2563
2564	val = AAC_GETREG4(sc, AAC_FA_MAILBOX + (mb * 4));
2565	return (val);
2566}
2567
2568static int
2569aac_rkt_get_mailbox(struct aac_softc *sc, int mb)
2570{
2571	debug_called(4);
2572
2573	return(AAC_GETREG4(sc, AAC_RKT_MAILBOX + (mb * 4)));
2574}
2575
2576/*
2577 * Set/clear interrupt masks
2578 */
2579static void
2580aac_sa_set_interrupts(struct aac_softc *sc, int enable)
2581{
2582	debug(2, "%sable interrupts", enable ? "en" : "dis");
2583
2584	if (enable) {
2585		AAC_SETREG2((sc), AAC_SA_MASK0_CLEAR, AAC_DB_INTERRUPTS);
2586	} else {
2587		AAC_SETREG2((sc), AAC_SA_MASK0_SET, ~0);
2588	}
2589}
2590
2591static void
2592aac_rx_set_interrupts(struct aac_softc *sc, int enable)
2593{
2594	debug(2, "%sable interrupts", enable ? "en" : "dis");
2595
2596	if (enable) {
2597		if (sc->flags & AAC_FLAGS_NEW_COMM)
2598			AAC_SETREG4(sc, AAC_RX_OIMR, ~AAC_DB_INT_NEW_COMM);
2599		else
2600			AAC_SETREG4(sc, AAC_RX_OIMR, ~AAC_DB_INTERRUPTS);
2601	} else {
2602		AAC_SETREG4(sc, AAC_RX_OIMR, ~0);
2603	}
2604}
2605
2606static void
2607aac_fa_set_interrupts(struct aac_softc *sc, int enable)
2608{
2609	debug(2, "%sable interrupts", enable ? "en" : "dis");
2610
2611	if (enable) {
2612		AAC_SETREG2((sc), AAC_FA_MASK0_CLEAR, AAC_DB_INTERRUPTS);
2613		AAC_FA_HACK(sc);
2614	} else {
2615		AAC_SETREG2((sc), AAC_FA_MASK0, ~0);
2616		AAC_FA_HACK(sc);
2617	}
2618}
2619
2620static void
2621aac_rkt_set_interrupts(struct aac_softc *sc, int enable)
2622{
2623	debug(2, "%sable interrupts", enable ? "en" : "dis");
2624
2625	if (enable) {
2626		if (sc->flags & AAC_FLAGS_NEW_COMM)
2627			AAC_SETREG4(sc, AAC_RKT_OIMR, ~AAC_DB_INT_NEW_COMM);
2628		else
2629			AAC_SETREG4(sc, AAC_RKT_OIMR, ~AAC_DB_INTERRUPTS);
2630	} else {
2631		AAC_SETREG4(sc, AAC_RKT_OIMR, ~0);
2632	}
2633}
2634
2635/*
2636 * New comm. interface: Send command functions
2637 */
2638static int
2639aac_rx_send_command(struct aac_softc *sc, struct aac_command *cm)
2640{
2641	u_int32_t index, device;
2642
2643	debug(2, "send command (new comm.)");
2644
2645	index = AAC_GETREG4(sc, AAC_RX_IQUE);
2646	if (index == 0xffffffffL)
2647		index = AAC_GETREG4(sc, AAC_RX_IQUE);
2648	if (index == 0xffffffffL)
2649		return index;
2650	aac_enqueue_busy(cm);
2651	device = index;
2652	AAC_SETREG4(sc, device, (u_int32_t)(cm->cm_fibphys & 0xffffffffUL));
2653	device += 4;
2654	AAC_SETREG4(sc, device, (u_int32_t)(cm->cm_fibphys >> 32));
2655	device += 4;
2656	AAC_SETREG4(sc, device, cm->cm_fib->Header.Size);
2657	AAC_SETREG4(sc, AAC_RX_IQUE, index);
2658	return 0;
2659}
2660
2661static int
2662aac_rkt_send_command(struct aac_softc *sc, struct aac_command *cm)
2663{
2664	u_int32_t index, device;
2665
2666	debug(2, "send command (new comm.)");
2667
2668	index = AAC_GETREG4(sc, AAC_RKT_IQUE);
2669	if (index == 0xffffffffL)
2670		index = AAC_GETREG4(sc, AAC_RKT_IQUE);
2671	if (index == 0xffffffffL)
2672		return index;
2673	aac_enqueue_busy(cm);
2674	device = index;
2675	AAC_SETREG4(sc, device, (u_int32_t)(cm->cm_fibphys & 0xffffffffUL));
2676	device += 4;
2677	AAC_SETREG4(sc, device, (u_int32_t)(cm->cm_fibphys >> 32));
2678	device += 4;
2679	AAC_SETREG4(sc, device, cm->cm_fib->Header.Size);
2680	AAC_SETREG4(sc, AAC_RKT_IQUE, index);
2681	return 0;
2682}
2683
2684/*
2685 * New comm. interface: get, set outbound queue index
2686 */
2687static int
2688aac_rx_get_outb_queue(struct aac_softc *sc)
2689{
2690	debug_called(3);
2691
2692	return(AAC_GETREG4(sc, AAC_RX_OQUE));
2693}
2694
2695static int
2696aac_rkt_get_outb_queue(struct aac_softc *sc)
2697{
2698	debug_called(3);
2699
2700	return(AAC_GETREG4(sc, AAC_RKT_OQUE));
2701}
2702
2703static void
2704aac_rx_set_outb_queue(struct aac_softc *sc, int index)
2705{
2706	debug_called(3);
2707
2708	AAC_SETREG4(sc, AAC_RX_OQUE, index);
2709}
2710
2711static void
2712aac_rkt_set_outb_queue(struct aac_softc *sc, int index)
2713{
2714	debug_called(3);
2715
2716	AAC_SETREG4(sc, AAC_RKT_OQUE, index);
2717}
2718
2719/*
2720 * Debugging and Diagnostics
2721 */
2722
2723/*
2724 * Print some information about the controller.
2725 */
2726static void
2727aac_describe_controller(struct aac_softc *sc)
2728{
2729	struct aac_fib *fib;
2730	struct aac_adapter_info	*info;
2731	char *adapter_type = "Adaptec RAID controller";
2732
2733	debug_called(2);
2734
2735	mtx_lock(&sc->aac_io_lock);
2736	aac_alloc_sync_fib(sc, &fib);
2737
2738	if (sc->supported_options & AAC_SUPPORTED_SUPPLEMENT_ADAPTER_INFO) {
2739		fib->data[0] = 0;
2740		if (aac_sync_fib(sc, RequestSupplementAdapterInfo, 0, fib, 1))
2741			device_printf(sc->aac_dev,
2742			    "RequestSupplementAdapterInfo failed\n");
2743		else
2744			adapter_type = ((struct aac_supplement_adapter_info *)
2745			    &fib->data[0])->AdapterTypeText;
2746	}
2747	device_printf(sc->aac_dev, "%s, aac driver %d.%d.%d-%d\n",
2748		adapter_type,
2749		AAC_DRIVER_VERSION >> 24,
2750		(AAC_DRIVER_VERSION >> 16) & 0xFF,
2751		AAC_DRIVER_VERSION & 0xFF,
2752		AAC_DRIVER_BUILD);
2753
2754	fib->data[0] = 0;
2755	if (aac_sync_fib(sc, RequestAdapterInfo, 0, fib, 1)) {
2756		device_printf(sc->aac_dev, "RequestAdapterInfo failed\n");
2757		aac_release_sync_fib(sc);
2758		mtx_unlock(&sc->aac_io_lock);
2759		return;
2760	}
2761
2762	/* save the kernel revision structure for later use */
2763	info = (struct aac_adapter_info *)&fib->data[0];
2764	sc->aac_revision = info->KernelRevision;
2765
2766
2767	if (bootverbose) {
2768		device_printf(sc->aac_dev, "%s %dMHz, %dMB memory "
2769		    "(%dMB cache, %dMB execution), %s\n",
2770		    aac_describe_code(aac_cpu_variant, info->CpuVariant),
2771		    info->ClockSpeed, info->TotalMem / (1024 * 1024),
2772		    info->BufferMem / (1024 * 1024),
2773		    info->ExecutionMem / (1024 * 1024),
2774		    aac_describe_code(aac_battery_platform,
2775		    info->batteryPlatform));
2776
2777		device_printf(sc->aac_dev,
2778		    "Kernel %d.%d-%d, Build %d, S/N %6X\n",
2779		    info->KernelRevision.external.comp.major,
2780		    info->KernelRevision.external.comp.minor,
2781		    info->KernelRevision.external.comp.dash,
2782		    info->KernelRevision.buildNumber,
2783		    (u_int32_t)(info->SerialNumber & 0xffffff));
2784
2785		device_printf(sc->aac_dev, "Supported Options=%b\n",
2786			      sc->supported_options,
2787			      "\20"
2788			      "\1SNAPSHOT"
2789			      "\2CLUSTERS"
2790			      "\3WCACHE"
2791			      "\4DATA64"
2792			      "\5HOSTTIME"
2793			      "\6RAID50"
2794			      "\7WINDOW4GB"
2795			      "\10SCSIUPGD"
2796			      "\11SOFTERR"
2797			      "\12NORECOND"
2798			      "\13SGMAP64"
2799			      "\14ALARM"
2800			      "\15NONDASD"
2801			      "\16SCSIMGT"
2802			      "\17RAIDSCSI"
2803			      "\21ADPTINFO"
2804			      "\22NEWCOMM"
2805			      "\23ARRAY64BIT"
2806			      "\24HEATSENSOR");
2807	}
2808	aac_release_sync_fib(sc);
2809	mtx_unlock(&sc->aac_io_lock);
2810}
2811
2812/*
2813 * Look up a text description of a numeric error code and return a pointer to
2814 * same.
2815 */
2816static char *
2817aac_describe_code(struct aac_code_lookup *table, u_int32_t code)
2818{
2819	int i;
2820
2821	for (i = 0; table[i].string != NULL; i++)
2822		if (table[i].code == code)
2823			return(table[i].string);
2824	return(table[i + 1].string);
2825}
2826
2827/*
2828 * Management Interface
2829 */
2830
2831static int
2832aac_open(struct cdev *dev, int flags, int fmt, d_thread_t *td)
2833{
2834	struct aac_softc *sc;
2835
2836	debug_called(2);
2837
2838	sc = dev->si_drv1;
2839	sc->aac_open_cnt++;
2840	sc->aac_state |= AAC_STATE_OPEN;
2841
2842	return 0;
2843}
2844
2845static int
2846aac_close(struct cdev *dev, int flags, int fmt, d_thread_t *td)
2847{
2848	struct aac_softc *sc;
2849
2850	debug_called(2);
2851
2852	sc = dev->si_drv1;
2853	sc->aac_open_cnt--;
2854	/* Mark this unit as no longer open  */
2855	if (sc->aac_open_cnt == 0)
2856		sc->aac_state &= ~AAC_STATE_OPEN;
2857
2858	return 0;
2859}
2860
2861static int
2862aac_ioctl(struct cdev *dev, u_long cmd, caddr_t arg, int flag, d_thread_t *td)
2863{
2864	union aac_statrequest *as;
2865	struct aac_softc *sc;
2866	int error = 0;
2867
2868	debug_called(2);
2869
2870	as = (union aac_statrequest *)arg;
2871	sc = dev->si_drv1;
2872
2873	switch (cmd) {
2874	case AACIO_STATS:
2875		switch (as->as_item) {
2876		case AACQ_FREE:
2877		case AACQ_BIO:
2878		case AACQ_READY:
2879		case AACQ_BUSY:
2880			bcopy(&sc->aac_qstat[as->as_item], &as->as_qstat,
2881			      sizeof(struct aac_qstat));
2882			break;
2883		default:
2884			error = ENOENT;
2885			break;
2886		}
2887	break;
2888
2889	case FSACTL_SENDFIB:
2890		arg = *(caddr_t*)arg;
2891	case FSACTL_LNX_SENDFIB:
2892		debug(1, "FSACTL_SENDFIB");
2893		error = aac_ioctl_sendfib(sc, arg);
2894		break;
2895	case FSACTL_AIF_THREAD:
2896	case FSACTL_LNX_AIF_THREAD:
2897		debug(1, "FSACTL_AIF_THREAD");
2898		error = EINVAL;
2899		break;
2900	case FSACTL_OPEN_GET_ADAPTER_FIB:
2901		arg = *(caddr_t*)arg;
2902	case FSACTL_LNX_OPEN_GET_ADAPTER_FIB:
2903		debug(1, "FSACTL_OPEN_GET_ADAPTER_FIB");
2904		error = aac_open_aif(sc, arg);
2905		break;
2906	case FSACTL_GET_NEXT_ADAPTER_FIB:
2907		arg = *(caddr_t*)arg;
2908	case FSACTL_LNX_GET_NEXT_ADAPTER_FIB:
2909		debug(1, "FSACTL_GET_NEXT_ADAPTER_FIB");
2910		error = aac_getnext_aif(sc, arg);
2911		break;
2912	case FSACTL_CLOSE_GET_ADAPTER_FIB:
2913		arg = *(caddr_t*)arg;
2914	case FSACTL_LNX_CLOSE_GET_ADAPTER_FIB:
2915		debug(1, "FSACTL_CLOSE_GET_ADAPTER_FIB");
2916		error = aac_close_aif(sc, arg);
2917		break;
2918	case FSACTL_MINIPORT_REV_CHECK:
2919		arg = *(caddr_t*)arg;
2920	case FSACTL_LNX_MINIPORT_REV_CHECK:
2921		debug(1, "FSACTL_MINIPORT_REV_CHECK");
2922		error = aac_rev_check(sc, arg);
2923		break;
2924	case FSACTL_QUERY_DISK:
2925		arg = *(caddr_t*)arg;
2926	case FSACTL_LNX_QUERY_DISK:
2927		debug(1, "FSACTL_QUERY_DISK");
2928		error = aac_query_disk(sc, arg);
2929		break;
2930	case FSACTL_DELETE_DISK:
2931	case FSACTL_LNX_DELETE_DISK:
2932		/*
2933		 * We don't trust the underland to tell us when to delete a
2934		 * container, rather we rely on an AIF coming from the
2935		 * controller
2936		 */
2937		error = 0;
2938		break;
2939	case FSACTL_GET_PCI_INFO:
2940		arg = *(caddr_t*)arg;
2941	case FSACTL_LNX_GET_PCI_INFO:
2942		debug(1, "FSACTL_GET_PCI_INFO");
2943		error = aac_get_pci_info(sc, arg);
2944		break;
2945	default:
2946		debug(1, "unsupported cmd 0x%lx\n", cmd);
2947		error = EINVAL;
2948		break;
2949	}
2950	return(error);
2951}
2952
2953static int
2954aac_poll(struct cdev *dev, int poll_events, d_thread_t *td)
2955{
2956	struct aac_softc *sc;
2957	int revents;
2958
2959	sc = dev->si_drv1;
2960	revents = 0;
2961
2962	mtx_lock(&sc->aac_aifq_lock);
2963	if ((poll_events & (POLLRDNORM | POLLIN)) != 0) {
2964		if (sc->aifq_idx != 0 || sc->aifq_filled)
2965			revents |= poll_events & (POLLIN | POLLRDNORM);
2966	}
2967	mtx_unlock(&sc->aac_aifq_lock);
2968
2969	if (revents == 0) {
2970		if (poll_events & (POLLIN | POLLRDNORM))
2971			selrecord(td, &sc->rcv_select);
2972	}
2973
2974	return (revents);
2975}
2976
2977static void
2978aac_ioctl_event(struct aac_softc *sc, struct aac_event *event, void *arg)
2979{
2980
2981	switch (event->ev_type) {
2982	case AAC_EVENT_CMFREE:
2983		mtx_lock(&sc->aac_io_lock);
2984		if (aac_alloc_command(sc, (struct aac_command **)arg)) {
2985			aac_add_event(sc, event);
2986			mtx_unlock(&sc->aac_io_lock);
2987			return;
2988		}
2989		free(event, M_AACBUF);
2990		wakeup(arg);
2991		mtx_unlock(&sc->aac_io_lock);
2992		break;
2993	default:
2994		break;
2995	}
2996}
2997
2998/*
2999 * Send a FIB supplied from userspace
3000 */
3001static int
3002aac_ioctl_sendfib(struct aac_softc *sc, caddr_t ufib)
3003{
3004	struct aac_command *cm;
3005	int size, error;
3006
3007	debug_called(2);
3008
3009	cm = NULL;
3010
3011	/*
3012	 * Get a command
3013	 */
3014	mtx_lock(&sc->aac_io_lock);
3015	if (aac_alloc_command(sc, &cm)) {
3016		struct aac_event *event;
3017
3018		event = malloc(sizeof(struct aac_event), M_AACBUF,
3019		    M_NOWAIT | M_ZERO);
3020		if (event == NULL) {
3021			error = EBUSY;
3022			goto out;
3023		}
3024		event->ev_type = AAC_EVENT_CMFREE;
3025		event->ev_callback = aac_ioctl_event;
3026		event->ev_arg = &cm;
3027		aac_add_event(sc, event);
3028		msleep(&cm, &sc->aac_io_lock, 0, "sendfib", 0);
3029	}
3030	mtx_unlock(&sc->aac_io_lock);
3031
3032	/*
3033	 * Fetch the FIB header, then re-copy to get data as well.
3034	 */
3035	if ((error = copyin(ufib, cm->cm_fib,
3036			    sizeof(struct aac_fib_header))) != 0)
3037		goto out;
3038	size = cm->cm_fib->Header.Size + sizeof(struct aac_fib_header);
3039	if (size > sizeof(struct aac_fib)) {
3040		device_printf(sc->aac_dev, "incoming FIB oversized (%d > %zd)\n",
3041			      size, sizeof(struct aac_fib));
3042		size = sizeof(struct aac_fib);
3043	}
3044	if ((error = copyin(ufib, cm->cm_fib, size)) != 0)
3045		goto out;
3046	cm->cm_fib->Header.Size = size;
3047	cm->cm_timestamp = time_uptime;
3048
3049	/*
3050	 * Pass the FIB to the controller, wait for it to complete.
3051	 */
3052	mtx_lock(&sc->aac_io_lock);
3053	if ((error = aac_wait_command(cm)) != 0) {
3054		device_printf(sc->aac_dev,
3055			      "aac_wait_command return %d\n", error);
3056		goto out;
3057	}
3058	mtx_unlock(&sc->aac_io_lock);
3059
3060	/*
3061	 * Copy the FIB and data back out to the caller.
3062	 */
3063	size = cm->cm_fib->Header.Size;
3064	if (size > sizeof(struct aac_fib)) {
3065		device_printf(sc->aac_dev, "outbound FIB oversized (%d > %zd)\n",
3066			      size, sizeof(struct aac_fib));
3067		size = sizeof(struct aac_fib);
3068	}
3069	error = copyout(cm->cm_fib, ufib, size);
3070	mtx_lock(&sc->aac_io_lock);
3071
3072out:
3073	if (cm != NULL) {
3074		aac_release_command(cm);
3075	}
3076
3077	mtx_unlock(&sc->aac_io_lock);
3078	return(error);
3079}
3080
3081/*
3082 * Handle an AIF sent to us by the controller; queue it for later reference.
3083 * If the queue fills up, then drop the older entries.
3084 */
3085static void
3086aac_handle_aif(struct aac_softc *sc, struct aac_fib *fib)
3087{
3088	struct aac_aif_command *aif;
3089	struct aac_container *co, *co_next;
3090	struct aac_fib_context *ctx;
3091	struct aac_mntinfo *mi;
3092	struct aac_mntinforesp *mir = NULL;
3093	u_int16_t rsize;
3094	int next, current, found;
3095	int count = 0, added = 0, i = 0;
3096
3097	debug_called(2);
3098
3099	aif = (struct aac_aif_command*)&fib->data[0];
3100	aac_print_aif(sc, aif);
3101
3102	/* Is it an event that we should care about? */
3103	switch (aif->command) {
3104	case AifCmdEventNotify:
3105		switch (aif->data.EN.type) {
3106		case AifEnAddContainer:
3107		case AifEnDeleteContainer:
3108			/*
3109			 * A container was added or deleted, but the message
3110			 * doesn't tell us anything else!  Re-enumerate the
3111			 * containers and sort things out.
3112			 */
3113			aac_alloc_sync_fib(sc, &fib);
3114			mi = (struct aac_mntinfo *)&fib->data[0];
3115			do {
3116				/*
3117				 * Ask the controller for its containers one at
3118				 * a time.
3119				 * XXX What if the controller's list changes
3120				 * midway through this enumaration?
3121				 * XXX This should be done async.
3122				 */
3123				bzero(mi, sizeof(struct aac_mntinfo));
3124				mi->Command = VM_NameServe;
3125				mi->MntType = FT_FILESYS;
3126				mi->MntCount = i;
3127				rsize = sizeof(mir);
3128				if (aac_sync_fib(sc, ContainerCommand, 0, fib,
3129						 sizeof(struct aac_mntinfo))) {
3130					printf("Error probing container %d\n",
3131					      i);
3132					continue;
3133				}
3134				mir = (struct aac_mntinforesp *)&fib->data[0];
3135				/* XXX Need to check if count changed */
3136				count = mir->MntRespCount;
3137				/*
3138				 * Check the container against our list.
3139				 * co->co_found was already set to 0 in a
3140				 * previous run.
3141				 */
3142				if ((mir->Status == ST_OK) &&
3143				    (mir->MntTable[0].VolType != CT_NONE)) {
3144					found = 0;
3145					TAILQ_FOREACH(co,
3146						      &sc->aac_container_tqh,
3147						      co_link) {
3148						if (co->co_mntobj.ObjectId ==
3149						    mir->MntTable[0].ObjectId) {
3150							co->co_found = 1;
3151							found = 1;
3152							break;
3153						}
3154					}
3155					/*
3156					 * If the container matched, continue
3157					 * in the list.
3158					 */
3159					if (found) {
3160						i++;
3161						continue;
3162					}
3163
3164					/*
3165					 * This is a new container.  Do all the
3166					 * appropriate things to set it up.
3167					 */
3168					aac_add_container(sc, mir, 1);
3169					added = 1;
3170				}
3171				i++;
3172			} while ((i < count) && (i < AAC_MAX_CONTAINERS));
3173			aac_release_sync_fib(sc);
3174
3175			/*
3176			 * Go through our list of containers and see which ones
3177			 * were not marked 'found'.  Since the controller didn't
3178			 * list them they must have been deleted.  Do the
3179			 * appropriate steps to destroy the device.  Also reset
3180			 * the co->co_found field.
3181			 */
3182			co = TAILQ_FIRST(&sc->aac_container_tqh);
3183			while (co != NULL) {
3184				if (co->co_found == 0) {
3185					mtx_unlock(&sc->aac_io_lock);
3186					mtx_lock(&Giant);
3187					device_delete_child(sc->aac_dev,
3188							    co->co_disk);
3189					mtx_unlock(&Giant);
3190					mtx_lock(&sc->aac_io_lock);
3191					co_next = TAILQ_NEXT(co, co_link);
3192					mtx_lock(&sc->aac_container_lock);
3193					TAILQ_REMOVE(&sc->aac_container_tqh, co,
3194						     co_link);
3195					mtx_unlock(&sc->aac_container_lock);
3196					free(co, M_AACBUF);
3197					co = co_next;
3198				} else {
3199					co->co_found = 0;
3200					co = TAILQ_NEXT(co, co_link);
3201				}
3202			}
3203
3204			/* Attach the newly created containers */
3205			if (added) {
3206				mtx_unlock(&sc->aac_io_lock);
3207				mtx_lock(&Giant);
3208				bus_generic_attach(sc->aac_dev);
3209				mtx_unlock(&Giant);
3210				mtx_lock(&sc->aac_io_lock);
3211			}
3212
3213			break;
3214
3215		default:
3216			break;
3217		}
3218
3219	default:
3220		break;
3221	}
3222
3223	/* Copy the AIF data to the AIF queue for ioctl retrieval */
3224	mtx_lock(&sc->aac_aifq_lock);
3225	current = sc->aifq_idx;
3226	next = (current + 1) % AAC_AIFQ_LENGTH;
3227	if (next == 0)
3228		sc->aifq_filled = 1;
3229	bcopy(fib, &sc->aac_aifq[current], sizeof(struct aac_fib));
3230	/* modify AIF contexts */
3231	if (sc->aifq_filled) {
3232		for (ctx = sc->fibctx; ctx; ctx = ctx->next) {
3233			if (next == ctx->ctx_idx)
3234				ctx->ctx_wrap = 1;
3235			else if (current == ctx->ctx_idx && ctx->ctx_wrap)
3236				ctx->ctx_idx = next;
3237		}
3238	}
3239	sc->aifq_idx = next;
3240	/* On the off chance that someone is sleeping for an aif... */
3241	if (sc->aac_state & AAC_STATE_AIF_SLEEPER)
3242		wakeup(sc->aac_aifq);
3243	/* Wakeup any poll()ers */
3244	selwakeuppri(&sc->rcv_select, PRIBIO);
3245	mtx_unlock(&sc->aac_aifq_lock);
3246
3247	return;
3248}
3249
3250/*
3251 * Return the Revision of the driver to userspace and check to see if the
3252 * userspace app is possibly compatible.  This is extremely bogus since
3253 * our driver doesn't follow Adaptec's versioning system.  Cheat by just
3254 * returning what the card reported.
3255 */
3256static int
3257aac_rev_check(struct aac_softc *sc, caddr_t udata)
3258{
3259	struct aac_rev_check rev_check;
3260	struct aac_rev_check_resp rev_check_resp;
3261	int error = 0;
3262
3263	debug_called(2);
3264
3265	/*
3266	 * Copyin the revision struct from userspace
3267	 */
3268	if ((error = copyin(udata, (caddr_t)&rev_check,
3269			sizeof(struct aac_rev_check))) != 0) {
3270		return error;
3271	}
3272
3273	debug(2, "Userland revision= %d\n",
3274	      rev_check.callingRevision.buildNumber);
3275
3276	/*
3277	 * Doctor up the response struct.
3278	 */
3279	rev_check_resp.possiblyCompatible = 1;
3280	rev_check_resp.adapterSWRevision.external.ul =
3281	    sc->aac_revision.external.ul;
3282	rev_check_resp.adapterSWRevision.buildNumber =
3283	    sc->aac_revision.buildNumber;
3284
3285	return(copyout((caddr_t)&rev_check_resp, udata,
3286			sizeof(struct aac_rev_check_resp)));
3287}
3288
3289/*
3290 * Pass the fib context to the caller
3291 */
3292static int
3293aac_open_aif(struct aac_softc *sc, caddr_t arg)
3294{
3295	struct aac_fib_context *fibctx, *ctx;
3296	int error = 0;
3297
3298	debug_called(2);
3299
3300	fibctx = malloc(sizeof(struct aac_fib_context), M_AACBUF, M_NOWAIT|M_ZERO);
3301	if (fibctx == NULL)
3302		return (ENOMEM);
3303
3304	mtx_lock(&sc->aac_aifq_lock);
3305	/* all elements are already 0, add to queue */
3306	if (sc->fibctx == NULL)
3307		sc->fibctx = fibctx;
3308	else {
3309		for (ctx = sc->fibctx; ctx->next; ctx = ctx->next)
3310			;
3311		ctx->next = fibctx;
3312		fibctx->prev = ctx;
3313	}
3314
3315	/* evaluate unique value */
3316	fibctx->unique = (*(u_int32_t *)&fibctx & 0xffffffff);
3317	ctx = sc->fibctx;
3318	while (ctx != fibctx) {
3319		if (ctx->unique == fibctx->unique) {
3320			fibctx->unique++;
3321			ctx = sc->fibctx;
3322		} else {
3323			ctx = ctx->next;
3324		}
3325	}
3326	mtx_unlock(&sc->aac_aifq_lock);
3327
3328	error = copyout(&fibctx->unique, (void *)arg, sizeof(u_int32_t));
3329	if (error)
3330		aac_close_aif(sc, (caddr_t)ctx);
3331	return error;
3332}
3333
3334/*
3335 * Close the caller's fib context
3336 */
3337static int
3338aac_close_aif(struct aac_softc *sc, caddr_t arg)
3339{
3340	struct aac_fib_context *ctx;
3341
3342	debug_called(2);
3343
3344	mtx_lock(&sc->aac_aifq_lock);
3345	for (ctx = sc->fibctx; ctx; ctx = ctx->next) {
3346		if (ctx->unique == *(uint32_t *)&arg) {
3347			if (ctx == sc->fibctx)
3348				sc->fibctx = NULL;
3349			else {
3350				ctx->prev->next = ctx->next;
3351				if (ctx->next)
3352					ctx->next->prev = ctx->prev;
3353			}
3354			break;
3355		}
3356	}
3357	mtx_unlock(&sc->aac_aifq_lock);
3358	if (ctx)
3359		free(ctx, M_AACBUF);
3360
3361	return 0;
3362}
3363
3364/*
3365 * Pass the caller the next AIF in their queue
3366 */
3367static int
3368aac_getnext_aif(struct aac_softc *sc, caddr_t arg)
3369{
3370	struct get_adapter_fib_ioctl agf;
3371	struct aac_fib_context *ctx;
3372	int error;
3373
3374	debug_called(2);
3375
3376	if ((error = copyin(arg, &agf, sizeof(agf))) == 0) {
3377		for (ctx = sc->fibctx; ctx; ctx = ctx->next) {
3378			if (agf.AdapterFibContext == ctx->unique)
3379				break;
3380		}
3381		if (!ctx)
3382			return (EFAULT);
3383
3384		error = aac_return_aif(sc, ctx, agf.AifFib);
3385		if (error == EAGAIN && agf.Wait) {
3386			debug(2, "aac_getnext_aif(): waiting for AIF");
3387			sc->aac_state |= AAC_STATE_AIF_SLEEPER;
3388			while (error == EAGAIN) {
3389				error = tsleep(sc->aac_aifq, PRIBIO |
3390					       PCATCH, "aacaif", 0);
3391				if (error == 0)
3392					error = aac_return_aif(sc, ctx, agf.AifFib);
3393			}
3394			sc->aac_state &= ~AAC_STATE_AIF_SLEEPER;
3395		}
3396	}
3397	return(error);
3398}
3399
3400/*
3401 * Hand the next AIF off the top of the queue out to userspace.
3402 */
3403static int
3404aac_return_aif(struct aac_softc *sc, struct aac_fib_context *ctx, caddr_t uptr)
3405{
3406	int current, error;
3407
3408	debug_called(2);
3409
3410	mtx_lock(&sc->aac_aifq_lock);
3411	current = ctx->ctx_idx;
3412	if (current == sc->aifq_idx && !ctx->ctx_wrap) {
3413		/* empty */
3414		mtx_unlock(&sc->aac_aifq_lock);
3415		return (EAGAIN);
3416	}
3417	error =
3418		copyout(&sc->aac_aifq[current], (void *)uptr, sizeof(struct aac_fib));
3419	if (error)
3420		device_printf(sc->aac_dev,
3421		    "aac_return_aif: copyout returned %d\n", error);
3422	else {
3423		ctx->ctx_wrap = 0;
3424		ctx->ctx_idx = (current + 1) % AAC_AIFQ_LENGTH;
3425	}
3426	mtx_unlock(&sc->aac_aifq_lock);
3427	return(error);
3428}
3429
3430static int
3431aac_get_pci_info(struct aac_softc *sc, caddr_t uptr)
3432{
3433	struct aac_pci_info {
3434		u_int32_t bus;
3435		u_int32_t slot;
3436	} pciinf;
3437	int error;
3438
3439	debug_called(2);
3440
3441	pciinf.bus = pci_get_bus(sc->aac_dev);
3442	pciinf.slot = pci_get_slot(sc->aac_dev);
3443
3444	error = copyout((caddr_t)&pciinf, uptr,
3445			sizeof(struct aac_pci_info));
3446
3447	return (error);
3448}
3449
3450/*
3451 * Give the userland some information about the container.  The AAC arch
3452 * expects the driver to be a SCSI passthrough type driver, so it expects
3453 * the containers to have b:t:l numbers.  Fake it.
3454 */
3455static int
3456aac_query_disk(struct aac_softc *sc, caddr_t uptr)
3457{
3458	struct aac_query_disk query_disk;
3459	struct aac_container *co;
3460	struct aac_disk	*disk;
3461	int error, id;
3462
3463	debug_called(2);
3464
3465	disk = NULL;
3466
3467	error = copyin(uptr, (caddr_t)&query_disk,
3468		       sizeof(struct aac_query_disk));
3469	if (error)
3470		return (error);
3471
3472	id = query_disk.ContainerNumber;
3473	if (id == -1)
3474		return (EINVAL);
3475
3476	mtx_lock(&sc->aac_container_lock);
3477	TAILQ_FOREACH(co, &sc->aac_container_tqh, co_link) {
3478		if (co->co_mntobj.ObjectId == id)
3479			break;
3480		}
3481
3482	if (co == NULL) {
3483			query_disk.Valid = 0;
3484			query_disk.Locked = 0;
3485			query_disk.Deleted = 1;		/* XXX is this right? */
3486	} else {
3487		disk = device_get_softc(co->co_disk);
3488		query_disk.Valid = 1;
3489		query_disk.Locked =
3490		    (disk->ad_flags & AAC_DISK_OPEN) ? 1 : 0;
3491		query_disk.Deleted = 0;
3492		query_disk.Bus = device_get_unit(sc->aac_dev);
3493		query_disk.Target = disk->unit;
3494		query_disk.Lun = 0;
3495		query_disk.UnMapped = 0;
3496		sprintf(&query_disk.diskDeviceName[0], "%s%d",
3497		        disk->ad_disk->d_name, disk->ad_disk->d_unit);
3498	}
3499	mtx_unlock(&sc->aac_container_lock);
3500
3501	error = copyout((caddr_t)&query_disk, uptr,
3502			sizeof(struct aac_query_disk));
3503
3504	return (error);
3505}
3506
3507static void
3508aac_get_bus_info(struct aac_softc *sc)
3509{
3510	struct aac_fib *fib;
3511	struct aac_ctcfg *c_cmd;
3512	struct aac_ctcfg_resp *c_resp;
3513	struct aac_vmioctl *vmi;
3514	struct aac_vmi_businf_resp *vmi_resp;
3515	struct aac_getbusinf businfo;
3516	struct aac_sim *caminf;
3517	device_t child;
3518	int i, found, error;
3519
3520	mtx_lock(&sc->aac_io_lock);
3521	aac_alloc_sync_fib(sc, &fib);
3522	c_cmd = (struct aac_ctcfg *)&fib->data[0];
3523	bzero(c_cmd, sizeof(struct aac_ctcfg));
3524
3525	c_cmd->Command = VM_ContainerConfig;
3526	c_cmd->cmd = CT_GET_SCSI_METHOD;
3527	c_cmd->param = 0;
3528
3529	error = aac_sync_fib(sc, ContainerCommand, 0, fib,
3530	    sizeof(struct aac_ctcfg));
3531	if (error) {
3532		device_printf(sc->aac_dev, "Error %d sending "
3533		    "VM_ContainerConfig command\n", error);
3534		aac_release_sync_fib(sc);
3535		mtx_unlock(&sc->aac_io_lock);
3536		return;
3537	}
3538
3539	c_resp = (struct aac_ctcfg_resp *)&fib->data[0];
3540	if (c_resp->Status != ST_OK) {
3541		device_printf(sc->aac_dev, "VM_ContainerConfig returned 0x%x\n",
3542		    c_resp->Status);
3543		aac_release_sync_fib(sc);
3544		mtx_unlock(&sc->aac_io_lock);
3545		return;
3546	}
3547
3548	sc->scsi_method_id = c_resp->param;
3549
3550	vmi = (struct aac_vmioctl *)&fib->data[0];
3551	bzero(vmi, sizeof(struct aac_vmioctl));
3552
3553	vmi->Command = VM_Ioctl;
3554	vmi->ObjType = FT_DRIVE;
3555	vmi->MethId = sc->scsi_method_id;
3556	vmi->ObjId = 0;
3557	vmi->IoctlCmd = GetBusInfo;
3558
3559	error = aac_sync_fib(sc, ContainerCommand, 0, fib,
3560	    sizeof(struct aac_vmioctl));
3561	if (error) {
3562		device_printf(sc->aac_dev, "Error %d sending VMIoctl command\n",
3563		    error);
3564		aac_release_sync_fib(sc);
3565		mtx_unlock(&sc->aac_io_lock);
3566		return;
3567	}
3568
3569	vmi_resp = (struct aac_vmi_businf_resp *)&fib->data[0];
3570	if (vmi_resp->Status != ST_OK) {
3571		device_printf(sc->aac_dev, "VM_Ioctl returned %d\n",
3572		    vmi_resp->Status);
3573		aac_release_sync_fib(sc);
3574		mtx_unlock(&sc->aac_io_lock);
3575		return;
3576	}
3577
3578	bcopy(&vmi_resp->BusInf, &businfo, sizeof(struct aac_getbusinf));
3579	aac_release_sync_fib(sc);
3580	mtx_unlock(&sc->aac_io_lock);
3581
3582	found = 0;
3583	for (i = 0; i < businfo.BusCount; i++) {
3584		if (businfo.BusValid[i] != AAC_BUS_VALID)
3585			continue;
3586
3587		caminf = (struct aac_sim *)malloc( sizeof(struct aac_sim),
3588		    M_AACBUF, M_NOWAIT | M_ZERO);
3589		if (caminf == NULL) {
3590			device_printf(sc->aac_dev,
3591			    "No memory to add passthrough bus %d\n", i);
3592			break;
3593		};
3594
3595		child = device_add_child(sc->aac_dev, "aacp", -1);
3596		if (child == NULL) {
3597			device_printf(sc->aac_dev,
3598			    "device_add_child failed for passthrough bus %d\n",
3599			    i);
3600			free(caminf, M_AACBUF);
3601			break;
3602		}
3603
3604		caminf->TargetsPerBus = businfo.TargetsPerBus;
3605		caminf->BusNumber = i;
3606		caminf->InitiatorBusId = businfo.InitiatorBusId[i];
3607		caminf->aac_sc = sc;
3608		caminf->sim_dev = child;
3609
3610		device_set_ivars(child, caminf);
3611		device_set_desc(child, "SCSI Passthrough Bus");
3612		TAILQ_INSERT_TAIL(&sc->aac_sim_tqh, caminf, sim_link);
3613
3614		found = 1;
3615	}
3616
3617	if (found)
3618		bus_generic_attach(sc->aac_dev);
3619
3620	return;
3621}
3622