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