2 * Copyright (c) 2000 Michael Smith
3 * Copyright (c) 2001 Scott Long
4 * Copyright (c) 2000 BSDi
5 * Copyright (c) 2001 Adaptec, Inc.
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
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.
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
29 * $FreeBSD: src/sys/dev/aac/aac.c,v 1.9.2.14 2003/04/08 13:22:08 scottl Exp $
30 * $DragonFly: src/sys/dev/raid/aac/aac.c,v 1.31 2007/06/04 17:21:57 dillon Exp $
34 * Driver for the Adaptec 'FSA' family of PCI/SCSI RAID adapters.
39 /* #include <stddef.h> */
40 #include <sys/param.h>
41 #include <sys/systm.h>
42 #include <sys/malloc.h>
43 #include <sys/kernel.h>
44 #include <sys/kthread.h>
45 #include <sys/sysctl.h>
47 #if defined(__FreeBSD__) && __FreeBSD_version >= 500005
48 #include <sys/selinfo.h>
50 #include <sys/select.h>
53 #include "aac_compat.h"
57 #include <sys/devicestat.h>
59 #include <sys/signalvar.h>
61 #include <sys/eventhandler.h>
64 #include "aac_ioctl.h"
66 #include "aac_tables.h"
69 static void aac_startup(void *arg
);
70 static void aac_add_container(struct aac_softc
*sc
,
71 struct aac_mntinforesp
*mir
, int f
);
72 static void aac_get_bus_info(struct aac_softc
*sc
);
74 /* Command Processing */
75 static void aac_timeout(void *ssc
);
76 static int aac_start(struct aac_command
*cm
);
77 static void aac_complete(void *context
, int pending
);
78 static int aac_bio_command(struct aac_softc
*sc
, struct aac_command
**cmp
);
79 static void aac_bio_complete(struct aac_command
*cm
);
80 static int aac_wait_command(struct aac_command
*cm
, int timeout
);
81 static void aac_host_command(struct aac_softc
*sc
);
82 static void aac_host_response(struct aac_softc
*sc
);
84 /* Command Buffer Management */
85 static void aac_map_command_helper(void *arg
, bus_dma_segment_t
*segs
,
87 static int aac_alloc_commands(struct aac_softc
*sc
);
88 static void aac_free_commands(struct aac_softc
*sc
);
89 static void aac_map_command(struct aac_command
*cm
);
90 static void aac_unmap_command(struct aac_command
*cm
);
92 /* Hardware Interface */
93 static void aac_common_map(void *arg
, bus_dma_segment_t
*segs
, int nseg
,
95 static int aac_check_firmware(struct aac_softc
*sc
);
96 static int aac_init(struct aac_softc
*sc
);
97 static 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
);
100 static int aac_enqueue_fib(struct aac_softc
*sc
, int queue
,
101 struct aac_command
*cm
);
102 static int aac_dequeue_fib(struct aac_softc
*sc
, int queue
,
103 u_int32_t
*fib_size
, struct aac_fib
**fib_addr
);
104 static int aac_enqueue_response(struct aac_softc
*sc
, int queue
,
105 struct aac_fib
*fib
);
107 /* Falcon/PPC interface */
108 static int aac_fa_get_fwstatus(struct aac_softc
*sc
);
109 static void aac_fa_qnotify(struct aac_softc
*sc
, int qbit
);
110 static int aac_fa_get_istatus(struct aac_softc
*sc
);
111 static void aac_fa_clear_istatus(struct aac_softc
*sc
, int mask
);
112 static 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
);
115 static int aac_fa_get_mailbox(struct aac_softc
*sc
, int mb
);
116 static void aac_fa_set_interrupts(struct aac_softc
*sc
, int enable
);
118 struct aac_interface aac_fa_interface
= {
122 aac_fa_clear_istatus
,
125 aac_fa_set_interrupts
128 /* StrongARM interface */
129 static int aac_sa_get_fwstatus(struct aac_softc
*sc
);
130 static void aac_sa_qnotify(struct aac_softc
*sc
, int qbit
);
131 static int aac_sa_get_istatus(struct aac_softc
*sc
);
132 static void aac_sa_clear_istatus(struct aac_softc
*sc
, int mask
);
133 static void aac_sa_set_mailbox(struct aac_softc
*sc
, u_int32_t command
,
134 u_int32_t arg0
, u_int32_t arg1
,
135 u_int32_t arg2
, u_int32_t arg3
);
136 static int aac_sa_get_mailbox(struct aac_softc
*sc
, int mb
);
137 static void aac_sa_set_interrupts(struct aac_softc
*sc
, int enable
);
139 struct aac_interface aac_sa_interface
= {
143 aac_sa_clear_istatus
,
146 aac_sa_set_interrupts
149 /* i960Rx interface */
150 static int aac_rx_get_fwstatus(struct aac_softc
*sc
);
151 static void aac_rx_qnotify(struct aac_softc
*sc
, int qbit
);
152 static int aac_rx_get_istatus(struct aac_softc
*sc
);
153 static void aac_rx_clear_istatus(struct aac_softc
*sc
, int mask
);
154 static void aac_rx_set_mailbox(struct aac_softc
*sc
, u_int32_t command
,
155 u_int32_t arg0
, u_int32_t arg1
,
156 u_int32_t arg2
, u_int32_t arg3
);
157 static int aac_rx_get_mailbox(struct aac_softc
*sc
, int mb
);
158 static void aac_rx_set_interrupts(struct aac_softc
*sc
, int enable
);
160 struct aac_interface aac_rx_interface
= {
164 aac_rx_clear_istatus
,
167 aac_rx_set_interrupts
170 /* Debugging and Diagnostics */
171 static void aac_describe_controller(struct aac_softc
*sc
);
172 static char *aac_describe_code(struct aac_code_lookup
*table
,
175 /* Management Interface */
176 static d_open_t aac_open
;
177 static d_close_t aac_close
;
178 static d_ioctl_t aac_ioctl
;
179 static d_poll_t aac_poll
;
180 static int aac_ioctl_sendfib(struct aac_softc
*sc
, caddr_t ufib
);
181 static void aac_handle_aif(struct aac_softc
*sc
,
182 struct aac_fib
*fib
);
183 static int aac_rev_check(struct aac_softc
*sc
, caddr_t udata
);
184 static int aac_getnext_aif(struct aac_softc
*sc
, caddr_t arg
);
185 static int aac_return_aif(struct aac_softc
*sc
, caddr_t uptr
);
186 static int aac_query_disk(struct aac_softc
*sc
, caddr_t uptr
);
188 #define AAC_CDEV_MAJOR 150
190 static struct dev_ops aac_ops
= {
191 { "aac", AAC_CDEV_MAJOR
, 0 },
193 .d_close
= aac_close
,
194 .d_ioctl
= aac_ioctl
,
198 DECLARE_DUMMY_MODULE(aac
);
200 MALLOC_DEFINE(M_AACBUF
, "aacbuf", "Buffers for the AAC driver");
203 SYSCTL_NODE(_hw
, OID_AUTO
, aac
, CTLFLAG_RD
, 0, "AAC driver parameters");
210 * Initialise the controller and softc
213 aac_attach(struct aac_softc
*sc
)
218 callout_init(&sc
->aac_watchdog
);
221 * Initialise per-controller queues.
226 aac_initq_complete(sc
);
229 #if defined(__FreeBSD__) && __FreeBSD_version >= 500005
231 * Initialise command-completion task.
233 TASK_INIT(&sc
->aac_task_complete
, 0, aac_complete
, sc
);
236 /* disable interrupts before we enable anything */
237 AAC_MASK_INTERRUPTS(sc
);
239 /* mark controller as suspended until we get ourselves organised */
240 sc
->aac_state
|= AAC_STATE_SUSPEND
;
243 * Check that the firmware on the card is supported.
245 if ((error
= aac_check_firmware(sc
)) != 0)
248 /* Init the sync fib lock */
249 AAC_LOCK_INIT(&sc
->aac_sync_lock
, "AAC sync FIB lock");
252 * Initialise the adapter.
254 if ((error
= aac_init(sc
)) != 0)
258 * Print a little information about the controller.
260 aac_describe_controller(sc
);
263 * Register to probe our containers later.
265 TAILQ_INIT(&sc
->aac_container_tqh
);
266 AAC_LOCK_INIT(&sc
->aac_container_lock
, "AAC container lock");
269 * Lock for the AIF queue
271 AAC_LOCK_INIT(&sc
->aac_aifq_lock
, "AAC AIF lock");
273 sc
->aac_ich
.ich_func
= aac_startup
;
274 sc
->aac_ich
.ich_arg
= sc
;
275 sc
->aac_ich
.ich_desc
= "aac";
276 if (config_intrhook_establish(&sc
->aac_ich
) != 0) {
277 device_printf(sc
->aac_dev
,
278 "can't establish configuration hook\n");
283 * Make the control device.
285 unit
= device_get_unit(sc
->aac_dev
);
286 dev_ops_add(&aac_ops
, -1, unit
);
287 sc
->aac_dev_t
= make_dev(&aac_ops
, unit
, UID_ROOT
, GID_WHEEL
, 0644,
289 #if defined(__FreeBSD__) && __FreeBSD_version > 500005
290 (void)make_dev_alias(sc
->aac_dev_t
, "afa%d", unit
);
291 (void)make_dev_alias(sc
->aac_dev_t
, "hpn%d", unit
);
293 sc
->aac_dev_t
->si_drv1
= sc
;
294 reference_dev(sc
->aac_dev_t
);
296 /* Create the AIF thread */
297 #if defined(__FreeBSD__) && __FreeBSD_version > 500005
298 if (kthread_create((void(*)(void *))aac_host_command
, sc
,
299 &sc
->aifthread
, 0, "aac%daif", unit
))
301 if (kthread_create((void(*)(void *))aac_host_command
, sc
,
302 &sc
->aifthread
, "aac%daif", unit
))
304 panic("Could not create AIF thread\n");
306 /* Register the shutdown method to only be called post-dump */
307 if ((EVENTHANDLER_REGISTER(shutdown_post_sync
, aac_shutdown
, sc
->aac_dev
,
308 SHUTDOWN_PRI_DEFAULT
)) == NULL
)
309 device_printf(sc
->aac_dev
, "shutdown event registration failed\n");
311 /* Register with CAM for the non-DASD devices */
312 if ((sc
->flags
& AAC_FLAGS_ENABLE_CAM
) != 0)
313 aac_get_bus_info(sc
);
319 * Probe for containers, create disks.
322 aac_startup(void *arg
)
324 struct aac_softc
*sc
;
326 struct aac_mntinfo
*mi
;
327 struct aac_mntinforesp
*mir
= NULL
;
328 int count
= 0, i
= 0;
332 sc
= (struct aac_softc
*)arg
;
334 /* disconnect ourselves from the intrhook chain */
335 config_intrhook_disestablish(&sc
->aac_ich
);
337 aac_alloc_sync_fib(sc
, &fib
, 0);
338 mi
= (struct aac_mntinfo
*)&fib
->data
[0];
340 /* loop over possible containers */
342 /* request information on this container */
343 bzero(mi
, sizeof(struct aac_mntinfo
));
344 mi
->Command
= VM_NameServe
;
345 mi
->MntType
= FT_FILESYS
;
347 if (aac_sync_fib(sc
, ContainerCommand
, 0, fib
,
348 sizeof(struct aac_mntinfo
))) {
349 device_printf(sc
->aac_dev
,
350 "error probing container %d", i
);
355 mir
= (struct aac_mntinforesp
*)&fib
->data
[0];
356 /* XXX Need to check if count changed */
357 count
= mir
->MntRespCount
;
358 aac_add_container(sc
, mir
, 0);
360 } while ((i
< count
) && (i
< AAC_MAX_CONTAINERS
));
362 aac_release_sync_fib(sc
);
364 /* poke the bus to actually attach the child devices */
365 if (bus_generic_attach(sc
->aac_dev
))
366 device_printf(sc
->aac_dev
, "bus_generic_attach failed\n");
368 /* mark the controller up */
369 sc
->aac_state
&= ~AAC_STATE_SUSPEND
;
371 /* enable interrupts now */
372 AAC_UNMASK_INTERRUPTS(sc
);
374 /* enable the timeout watchdog */
375 callout_reset(&sc
->aac_watchdog
, AAC_PERIODIC_INTERVAL
* hz
,
380 * Create a device to respresent a new container
383 aac_add_container(struct aac_softc
*sc
, struct aac_mntinforesp
*mir
, int f
)
385 struct aac_container
*co
;
389 * Check container volume type for validity. Note that many of
390 * the possible types may never show up.
392 if ((mir
->Status
== ST_OK
) && (mir
->MntTable
[0].VolType
!= CT_NONE
)) {
393 MALLOC(co
, struct aac_container
*, sizeof *co
, M_AACBUF
,
395 debug(1, "id %x name '%.16s' size %u type %d",
396 mir
->MntTable
[0].ObjectId
,
397 mir
->MntTable
[0].FileSystemName
,
398 mir
->MntTable
[0].Capacity
, mir
->MntTable
[0].VolType
);
400 if ((child
= device_add_child(sc
->aac_dev
, "aacd", -1)) == NULL
)
401 device_printf(sc
->aac_dev
, "device_add_child failed\n");
403 device_set_ivars(child
, co
);
404 device_set_desc(child
, aac_describe_code(aac_container_types
,
405 mir
->MntTable
[0].VolType
));
408 bcopy(&mir
->MntTable
[0], &co
->co_mntobj
,
409 sizeof(struct aac_mntobj
));
410 AAC_LOCK_ACQUIRE(&sc
->aac_container_lock
);
411 TAILQ_INSERT_TAIL(&sc
->aac_container_tqh
, co
, co_link
);
412 AAC_LOCK_RELEASE(&sc
->aac_container_lock
);
417 * Free all of the resources associated with (sc)
419 * Should not be called if the controller is active.
422 aac_free(struct aac_softc
*sc
)
426 /* remove the control device */
427 if (sc
->aac_dev_t
!= NULL
)
428 destroy_dev(sc
->aac_dev_t
);
430 /* throw away any FIB buffers, discard the FIB DMA tag */
431 if (sc
->aac_fibs
!= NULL
)
432 aac_free_commands(sc
);
433 if (sc
->aac_fib_dmat
)
434 bus_dma_tag_destroy(sc
->aac_fib_dmat
);
436 /* destroy the common area */
437 if (sc
->aac_common
) {
438 bus_dmamap_unload(sc
->aac_common_dmat
, sc
->aac_common_dmamap
);
439 bus_dmamem_free(sc
->aac_common_dmat
, sc
->aac_common
,
440 sc
->aac_common_dmamap
);
442 if (sc
->aac_common_dmat
)
443 bus_dma_tag_destroy(sc
->aac_common_dmat
);
445 /* disconnect the interrupt handler */
447 bus_teardown_intr(sc
->aac_dev
, sc
->aac_irq
, sc
->aac_intr
);
448 if (sc
->aac_irq
!= NULL
)
449 bus_release_resource(sc
->aac_dev
, SYS_RES_IRQ
, sc
->aac_irq_rid
,
452 /* destroy data-transfer DMA tag */
453 if (sc
->aac_buffer_dmat
)
454 bus_dma_tag_destroy(sc
->aac_buffer_dmat
);
456 /* destroy the parent DMA tag */
457 if (sc
->aac_parent_dmat
)
458 bus_dma_tag_destroy(sc
->aac_parent_dmat
);
460 /* release the register window mapping */
461 if (sc
->aac_regs_resource
!= NULL
) {
462 bus_release_resource(sc
->aac_dev
, SYS_RES_MEMORY
,
463 sc
->aac_regs_rid
, sc
->aac_regs_resource
);
465 dev_ops_remove(&aac_ops
, -1, device_get_unit(sc
->aac_dev
));
469 * Disconnect from the controller completely, in preparation for unload.
472 aac_detach(device_t dev
)
474 struct aac_softc
*sc
;
481 sc
= device_get_softc(dev
);
483 callout_stop(&sc
->aac_watchdog
);
485 if (sc
->aac_state
& AAC_STATE_OPEN
)
489 if (sc
->aifflags
& AAC_AIFFLAGS_RUNNING
) {
490 sc
->aifflags
|= AAC_AIFFLAGS_EXIT
;
491 wakeup(sc
->aifthread
);
492 tsleep(sc
->aac_dev
, PCATCH
, "aacdch", 30 * hz
);
495 if (sc
->aifflags
& AAC_AIFFLAGS_RUNNING
)
496 panic("Cannot shutdown AIF thread\n");
498 if ((error
= aac_shutdown(dev
)))
510 * Bring the controller down to a dormant state and detach all child devices.
512 * This function is called before detach or system shutdown.
514 * Note that we can assume that the bioq on the controller is empty, as we won't
515 * allow shutdown if any device is open.
518 aac_shutdown(device_t dev
)
520 struct aac_softc
*sc
;
522 struct aac_close_command
*cc
;
526 sc
= device_get_softc(dev
);
530 sc
->aac_state
|= AAC_STATE_SUSPEND
;
533 * Send a Container shutdown followed by a HostShutdown FIB to the
534 * controller to convince it that we don't want to talk to it anymore.
535 * We've been closed and all I/O completed already
537 device_printf(sc
->aac_dev
, "shutting down controller...");
539 aac_alloc_sync_fib(sc
, &fib
, AAC_SYNC_LOCK_FORCE
);
540 cc
= (struct aac_close_command
*)&fib
->data
[0];
542 bzero(cc
, sizeof(struct aac_close_command
));
543 cc
->Command
= VM_CloseAll
;
544 cc
->ContainerId
= 0xffffffff;
545 if (aac_sync_fib(sc
, ContainerCommand
, 0, fib
,
546 sizeof(struct aac_close_command
)))
547 kprintf("FAILED.\n");
551 * XXX Issuing this command to the controller makes it shut down
552 * but also keeps it from coming back up without a reset of the
553 * PCI bus. This is not desirable if you are just unloading the
554 * driver module with the intent to reload it later.
556 if (aac_sync_fib(sc
, FsaHostShutdown
, AAC_FIBSTATE_SHUTDOWN
,
558 kprintf("FAILED.\n");
564 AAC_MASK_INTERRUPTS(sc
);
571 * Bring the controller to a quiescent state, ready for system suspend.
574 aac_suspend(device_t dev
)
576 struct aac_softc
*sc
;
580 sc
= device_get_softc(dev
);
584 sc
->aac_state
|= AAC_STATE_SUSPEND
;
586 AAC_MASK_INTERRUPTS(sc
);
592 * Bring the controller back to a state ready for operation.
595 aac_resume(device_t dev
)
597 struct aac_softc
*sc
;
601 sc
= device_get_softc(dev
);
603 sc
->aac_state
&= ~AAC_STATE_SUSPEND
;
604 AAC_UNMASK_INTERRUPTS(sc
);
614 struct aac_softc
*sc
;
616 u_int32_t
*resp_queue
;
620 sc
= (struct aac_softc
*)arg
;
623 * Optimize the common case of adapter response interrupts.
624 * We must read from the card prior to processing the responses
625 * to ensure the clear is flushed prior to accessing the queues.
626 * Reading the queues from local memory might save us a PCI read.
628 resp_queue
= sc
->aac_queues
->qt_qindex
[AAC_HOST_NORM_RESP_QUEUE
];
629 if (resp_queue
[AAC_PRODUCER_INDEX
] != resp_queue
[AAC_CONSUMER_INDEX
])
630 reason
= AAC_DB_RESPONSE_READY
;
632 reason
= AAC_GET_ISTATUS(sc
);
633 AAC_CLEAR_ISTATUS(sc
, reason
);
634 (void)AAC_GET_ISTATUS(sc
);
636 /* It's not ok to return here because of races with the previous step */
637 if (reason
& AAC_DB_RESPONSE_READY
)
638 aac_host_response(sc
);
640 /* controller wants to talk to the log */
641 if (reason
& AAC_DB_PRINTF
)
642 aac_print_printf(sc
);
644 /* controller has a message for us? */
645 if (reason
& AAC_DB_COMMAND_READY
) {
646 /* XXX What happens if the thread is already awake? */
647 if (sc
->aifflags
& AAC_AIFFLAGS_RUNNING
) {
648 sc
->aifflags
|= AAC_AIFFLAGS_PENDING
;
649 wakeup(sc
->aifthread
);
659 * Start as much queued I/O as possible on the controller
662 aac_startio(struct aac_softc
*sc
)
664 struct aac_command
*cm
;
670 * Try to get a command that's been put off for lack of
673 cm
= aac_dequeue_ready(sc
);
676 * Try to build a command off the bio queue (ignore error
680 aac_bio_command(sc
, &cm
);
686 /* try to give the command to the controller */
687 if (aac_start(cm
) == EBUSY
) {
688 /* put it on the ready queue for later */
689 aac_requeue_ready(cm
);
696 * Deliver a command to the controller; allocate controller resources at the
697 * last moment when possible.
700 aac_start(struct aac_command
*cm
)
702 struct aac_softc
*sc
;
709 /* get the command mapped */
712 /* fix up the address values in the FIB */
713 cm
->cm_fib
->Header
.SenderFibAddress
= (u_int32_t
)cm
->cm_fib
;
714 cm
->cm_fib
->Header
.ReceiverFibAddress
= cm
->cm_fibphys
;
716 /* save a pointer to the command for speedy reverse-lookup */
717 cm
->cm_fib
->Header
.SenderData
= (u_int32_t
)cm
; /* XXX 64-bit physical
719 /* put the FIB on the outbound queue */
720 error
= aac_enqueue_fib(sc
, cm
->cm_queue
, cm
);
725 * Handle notification of one or more FIBs coming from the controller.
728 aac_host_command(struct aac_softc
*sc
)
736 sc
->aifflags
|= AAC_AIFFLAGS_RUNNING
;
738 while (!(sc
->aifflags
& AAC_AIFFLAGS_EXIT
)) {
739 if (!(sc
->aifflags
& AAC_AIFFLAGS_PENDING
))
740 tsleep(sc
->aifthread
, 0, "aifthd", 15 * hz
);
742 sc
->aifflags
&= ~AAC_AIFFLAGS_PENDING
;
744 if (aac_dequeue_fib(sc
, AAC_HOST_NORM_CMD_QUEUE
,
746 break; /* nothing to do */
748 AAC_PRINT_FIB(sc
, fib
);
750 switch (fib
->Header
.Command
) {
752 aac_handle_aif(sc
, fib
);
755 device_printf(sc
->aac_dev
, "unknown command "
756 "from controller\n");
760 /* Return the AIF to the controller. */
761 if ((fib
->Header
.XferState
== 0) ||
762 (fib
->Header
.StructType
!= AAC_FIBTYPE_TFIB
))
765 if (fib
->Header
.XferState
& AAC_FIBSTATE_FROMADAP
) {
766 fib
->Header
.XferState
|= AAC_FIBSTATE_DONEHOST
;
767 *(AAC_FSAStatus
*)fib
->data
= ST_OK
;
769 /* XXX Compute the Size field? */
770 size
= fib
->Header
.Size
;
771 if (size
> sizeof(struct aac_fib
)) {
772 size
= sizeof(struct aac_fib
);
773 fib
->Header
.Size
= size
;
776 * Since we did not generate this command, it
777 * cannot go through the normal
778 * enqueue->startio chain.
780 aac_enqueue_response(sc
,
781 AAC_ADAP_NORM_RESP_QUEUE
,
786 sc
->aifflags
&= ~AAC_AIFFLAGS_RUNNING
;
789 #if defined(__FreeBSD__) && __FreeBSD_version > 500005
796 * Handle notification of one or more FIBs completed by the controller
799 aac_host_response(struct aac_softc
*sc
)
801 struct aac_command
*cm
;
808 /* look for completed FIBs on our queue */
809 if (aac_dequeue_fib(sc
, AAC_HOST_NORM_RESP_QUEUE
, &fib_size
,
811 break; /* nothing to do */
813 /* get the command, unmap and queue for later processing */
814 cm
= (struct aac_command
*)fib
->Header
.SenderData
;
816 AAC_PRINT_FIB(sc
, fib
);
819 aac_unmap_command(cm
); /* XXX defer? */
820 aac_enqueue_complete(cm
);
824 /* handle completion processing */
825 #if defined(__FreeBSD__) && __FreeBSD_version >= 500005
826 taskqueue_enqueue(taskqueue_swi
, &sc
->aac_task_complete
);
833 * Process completed commands.
836 aac_complete(void *context
, int pending
)
838 struct aac_softc
*sc
;
839 struct aac_command
*cm
;
843 sc
= (struct aac_softc
*)context
;
845 /* pull completed commands off the queue */
847 cm
= aac_dequeue_complete(sc
);
850 cm
->cm_flags
|= AAC_CMD_COMPLETED
;
852 /* is there a completion handler? */
853 if (cm
->cm_complete
!= NULL
) {
856 /* assume that someone is sleeping on this command */
861 /* see if we can start some more I/O */
866 * Handle a bio submitted from a disk device.
869 aac_submit_bio(struct aac_disk
*ad
, struct bio
*bio
)
871 struct aac_softc
*sc
;
875 bio
->bio_driver_info
= ad
;
876 sc
= ad
->ad_controller
;
878 /* queue the BIO and try to get some work done */
879 aac_enqueue_bio(sc
, bio
);
884 * Get a bio and build a command to go with it.
887 aac_bio_command(struct aac_softc
*sc
, struct aac_command
**cmp
)
889 struct aac_command
*cm
;
891 struct aac_blockread
*br
;
892 struct aac_blockwrite
*bw
;
899 /* get the resources we will need */
901 if ((bio
= aac_dequeue_bio(sc
)) == NULL
)
903 if (aac_alloc_command(sc
, &cm
)) /* get a command */
906 /* fill out the command */
908 cm
->cm_data
= (void *)bp
->b_data
;
909 cm
->cm_datalen
= bp
->b_bcount
;
910 cm
->cm_complete
= aac_bio_complete
;
911 cm
->cm_private
= bio
;
912 cm
->cm_timestamp
= time_second
;
913 cm
->cm_queue
= AAC_ADAP_NORM_CMD_QUEUE
;
917 fib
->Header
.XferState
=
918 AAC_FIBSTATE_HOSTOWNED
|
919 AAC_FIBSTATE_INITIALISED
|
921 AAC_FIBSTATE_FROMHOST
|
922 AAC_FIBSTATE_REXPECTED
|
925 AAC_FIBSTATE_FAST_RESPONSE
;
926 fib
->Header
.Command
= ContainerCommand
;
927 fib
->Header
.Size
= sizeof(struct aac_fib_header
);
929 /* build the read/write request */
930 ad
= (struct aac_disk
*)bio
->bio_driver_info
;
931 if (bp
->b_cmd
== BUF_CMD_READ
) {
932 br
= (struct aac_blockread
*)&fib
->data
[0];
933 br
->Command
= VM_CtBlockRead
;
934 br
->ContainerId
= ad
->ad_container
->co_mntobj
.ObjectId
;
935 br
->BlockNumber
= bio
->bio_offset
/ AAC_BLOCK_SIZE
;
936 br
->ByteCount
= bp
->b_bcount
;
937 fib
->Header
.Size
+= sizeof(struct aac_blockread
);
938 cm
->cm_sgtable
= &br
->SgMap
;
939 cm
->cm_flags
|= AAC_CMD_DATAIN
;
941 bw
= (struct aac_blockwrite
*)&fib
->data
[0];
942 bw
->Command
= VM_CtBlockWrite
;
943 bw
->ContainerId
= ad
->ad_container
->co_mntobj
.ObjectId
;
944 bw
->BlockNumber
= bio
->bio_offset
/ AAC_BLOCK_SIZE
;
945 bw
->ByteCount
= bp
->b_bcount
;
946 bw
->Stable
= CUNSTABLE
; /* XXX what's appropriate here? */
947 fib
->Header
.Size
+= sizeof(struct aac_blockwrite
);
948 cm
->cm_flags
|= AAC_CMD_DATAOUT
;
949 cm
->cm_sgtable
= &bw
->SgMap
;
957 aac_enqueue_bio(sc
, bio
);
959 aac_release_command(cm
);
964 * Handle a bio-instigated command that has been completed.
967 aac_bio_complete(struct aac_command
*cm
)
969 struct aac_blockread_response
*brr
;
970 struct aac_blockwrite_response
*bwr
;
974 AAC_FSAStatus status
;
976 /* fetch relevant status and then release the command */
977 bio
= (struct bio
*)cm
->cm_private
;
979 if (bp
->b_cmd
== BUF_CMD_READ
) {
980 brr
= (struct aac_blockread_response
*)&cm
->cm_fib
->data
[0];
981 status
= brr
->Status
;
983 bwr
= (struct aac_blockwrite_response
*)&cm
->cm_fib
->data
[0];
984 status
= bwr
->Status
;
986 aac_release_command(cm
);
988 /* fix up the bio based on status */
989 if (status
== ST_OK
) {
994 bp
->b_flags
|= B_ERROR
;
995 /* pass an error string out to the disk layer */
996 code
= aac_describe_code(aac_command_status_table
, status
);
998 aac_biodone(bio
, code
);
1002 * Dump a block of data to the controller. If the queue is full, tell the
1003 * caller to hold off and wait for the queue to drain.
1006 aac_dump_enqueue(struct aac_disk
*ad
, u_int64_t lba
, void *data
, int dumppages
)
1008 struct aac_softc
*sc
;
1009 struct aac_command
*cm
;
1010 struct aac_fib
*fib
;
1011 struct aac_blockwrite
*bw
;
1013 sc
= ad
->ad_controller
;
1016 KKASSERT(lba
<= 0x100000000ULL
);
1018 if (aac_alloc_command(sc
, &cm
))
1021 /* fill out the command */
1023 cm
->cm_datalen
= dumppages
* PAGE_SIZE
;
1024 cm
->cm_complete
= NULL
;
1025 cm
->cm_private
= NULL
;
1026 cm
->cm_timestamp
= time_second
;
1027 cm
->cm_queue
= AAC_ADAP_NORM_CMD_QUEUE
;
1031 fib
->Header
.XferState
=
1032 AAC_FIBSTATE_HOSTOWNED
|
1033 AAC_FIBSTATE_INITIALISED
|
1034 AAC_FIBSTATE_FROMHOST
|
1035 AAC_FIBSTATE_REXPECTED
|
1037 fib
->Header
.Command
= ContainerCommand
;
1038 fib
->Header
.Size
= sizeof(struct aac_fib_header
);
1040 bw
= (struct aac_blockwrite
*)&fib
->data
[0];
1041 bw
->Command
= VM_CtBlockWrite
;
1042 bw
->ContainerId
= ad
->ad_container
->co_mntobj
.ObjectId
;
1043 bw
->BlockNumber
= lba
;
1044 bw
->ByteCount
= dumppages
* PAGE_SIZE
;
1045 bw
->Stable
= CUNSTABLE
; /* XXX what's appropriate here? */
1046 fib
->Header
.Size
+= sizeof(struct aac_blockwrite
);
1047 cm
->cm_flags
|= AAC_CMD_DATAOUT
;
1048 cm
->cm_sgtable
= &bw
->SgMap
;
1050 return (aac_start(cm
));
1054 * Wait for the card's queue to drain when dumping. Also check for monitor
1058 aac_dump_complete(struct aac_softc
*sc
)
1060 struct aac_fib
*fib
;
1061 struct aac_command
*cm
;
1063 u_int32_t pi
, ci
, fib_size
;
1066 reason
= AAC_GET_ISTATUS(sc
);
1067 if (reason
& AAC_DB_RESPONSE_READY
) {
1068 AAC_CLEAR_ISTATUS(sc
, AAC_DB_RESPONSE_READY
);
1070 if (aac_dequeue_fib(sc
,
1071 AAC_HOST_NORM_RESP_QUEUE
,
1074 cm
= (struct aac_command
*)
1075 fib
->Header
.SenderData
;
1077 AAC_PRINT_FIB(sc
, fib
);
1079 aac_remove_busy(cm
);
1080 aac_unmap_command(cm
);
1081 aac_enqueue_complete(cm
);
1082 aac_release_command(cm
);
1086 if (reason
& AAC_DB_PRINTF
) {
1087 AAC_CLEAR_ISTATUS(sc
, AAC_DB_PRINTF
);
1088 aac_print_printf(sc
);
1090 pi
= sc
->aac_queues
->qt_qindex
[AAC_ADAP_NORM_CMD_QUEUE
][
1091 AAC_PRODUCER_INDEX
];
1092 ci
= sc
->aac_queues
->qt_qindex
[AAC_ADAP_NORM_CMD_QUEUE
][
1093 AAC_CONSUMER_INDEX
];
1100 * Submit a command to the controller, return when it completes.
1101 * XXX This is very dangerous! If the card has gone out to lunch, we could
1102 * be stuck here forever. At the same time, signals are not caught
1103 * because there is a risk that a signal could wakeup the tsleep before
1104 * the card has a chance to complete the command. The passed in timeout
1105 * is ignored for the same reason. Since there is no way to cancel a
1106 * command in progress, we should probably create a 'dead' queue where
1107 * commands go that have been interrupted/timed-out/etc, that keeps them
1108 * out of the free pool. That way, if the card is just slow, it won't
1109 * spam the memory of a command that has been recycled.
1112 aac_wait_command(struct aac_command
*cm
, int timeout
)
1118 /* Put the command on the ready queue and get things going */
1119 cm
->cm_queue
= AAC_ADAP_NORM_CMD_QUEUE
;
1120 aac_enqueue_ready(cm
);
1121 aac_startio(cm
->cm_sc
);
1123 while (!(cm
->cm_flags
& AAC_CMD_COMPLETED
) && (error
!= EWOULDBLOCK
)) {
1124 error
= tsleep(cm
, 0, "aacwait", 0);
1131 *Command Buffer Management
1135 * Allocate a command.
1138 aac_alloc_command(struct aac_softc
*sc
, struct aac_command
**cmp
)
1140 struct aac_command
*cm
;
1144 if ((cm
= aac_dequeue_free(sc
)) == NULL
)
1152 * Release a command back to the freelist.
1155 aac_release_command(struct aac_command
*cm
)
1159 /* (re)initialise the command/FIB */
1160 cm
->cm_sgtable
= NULL
;
1162 cm
->cm_complete
= NULL
;
1163 cm
->cm_private
= NULL
;
1164 cm
->cm_fib
->Header
.XferState
= AAC_FIBSTATE_EMPTY
;
1165 cm
->cm_fib
->Header
.StructType
= AAC_FIBTYPE_TFIB
;
1166 cm
->cm_fib
->Header
.Flags
= 0;
1167 cm
->cm_fib
->Header
.SenderSize
= sizeof(struct aac_fib
);
1170 * These are duplicated in aac_start to cover the case where an
1171 * intermediate stage may have destroyed them. They're left
1172 * initialised here for debugging purposes only.
1174 cm
->cm_fib
->Header
.SenderFibAddress
= (u_int32_t
)cm
->cm_fib
;
1175 cm
->cm_fib
->Header
.ReceiverFibAddress
= (u_int32_t
)cm
->cm_fibphys
;
1176 cm
->cm_fib
->Header
.SenderData
= 0;
1178 aac_enqueue_free(cm
);
1182 * Map helper for command/FIB allocation.
1185 aac_map_command_helper(void *arg
, bus_dma_segment_t
*segs
, int nseg
, int error
)
1187 struct aac_softc
*sc
;
1189 sc
= (struct aac_softc
*)arg
;
1193 sc
->aac_fibphys
= segs
[0].ds_addr
;
1197 * Allocate and initialise commands/FIBs for this adapter.
1200 aac_alloc_commands(struct aac_softc
*sc
)
1202 struct aac_command
*cm
;
1207 /* allocate the FIBs in DMAable memory and load them */
1208 if (bus_dmamem_alloc(sc
->aac_fib_dmat
, (void **)&sc
->aac_fibs
,
1209 BUS_DMA_NOWAIT
, &sc
->aac_fibmap
)) {
1213 bus_dmamap_load(sc
->aac_fib_dmat
, sc
->aac_fibmap
, sc
->aac_fibs
,
1214 AAC_FIB_COUNT
* sizeof(struct aac_fib
),
1215 aac_map_command_helper
, sc
, 0);
1217 /* initialise constant fields in the command structure */
1218 bzero(sc
->aac_fibs
, AAC_FIB_COUNT
* sizeof(struct aac_fib
));
1219 for (i
= 0; i
< AAC_FIB_COUNT
; i
++) {
1220 cm
= &sc
->aac_command
[i
];
1222 cm
->cm_fib
= sc
->aac_fibs
+ i
;
1223 cm
->cm_fibphys
= sc
->aac_fibphys
+ (i
* sizeof(struct aac_fib
));
1225 if (!bus_dmamap_create(sc
->aac_buffer_dmat
, 0, &cm
->cm_datamap
))
1226 aac_release_command(cm
);
1232 * Free FIBs owned by this adapter.
1235 aac_free_commands(struct aac_softc
*sc
)
1241 for (i
= 0; i
< AAC_FIB_COUNT
; i
++)
1242 bus_dmamap_destroy(sc
->aac_buffer_dmat
,
1243 sc
->aac_command
[i
].cm_datamap
);
1245 bus_dmamap_unload(sc
->aac_fib_dmat
, sc
->aac_fibmap
);
1246 bus_dmamem_free(sc
->aac_fib_dmat
, sc
->aac_fibs
, sc
->aac_fibmap
);
1250 * Command-mapping helper function - populate this command's s/g table.
1253 aac_map_command_sg(void *arg
, bus_dma_segment_t
*segs
, int nseg
, int error
)
1255 struct aac_command
*cm
;
1256 struct aac_fib
*fib
;
1257 struct aac_sg_table
*sg
;
1262 cm
= (struct aac_command
*)arg
;
1265 /* find the s/g table */
1266 sg
= cm
->cm_sgtable
;
1268 /* copy into the FIB */
1271 for (i
= 0; i
< nseg
; i
++) {
1272 sg
->SgEntry
[i
].SgAddress
= segs
[i
].ds_addr
;
1273 sg
->SgEntry
[i
].SgByteCount
= segs
[i
].ds_len
;
1275 /* update the FIB size for the s/g count */
1276 fib
->Header
.Size
+= nseg
* sizeof(struct aac_sg_entry
);
1282 * Map a command into controller-visible space.
1285 aac_map_command(struct aac_command
*cm
)
1287 struct aac_softc
*sc
;
1293 /* don't map more than once */
1294 if (cm
->cm_flags
& AAC_CMD_MAPPED
)
1297 if (cm
->cm_datalen
!= 0) {
1298 bus_dmamap_load(sc
->aac_buffer_dmat
, cm
->cm_datamap
,
1299 cm
->cm_data
, cm
->cm_datalen
,
1300 aac_map_command_sg
, cm
, 0);
1302 if (cm
->cm_flags
& AAC_CMD_DATAIN
)
1303 bus_dmamap_sync(sc
->aac_buffer_dmat
, cm
->cm_datamap
,
1304 BUS_DMASYNC_PREREAD
);
1305 if (cm
->cm_flags
& AAC_CMD_DATAOUT
)
1306 bus_dmamap_sync(sc
->aac_buffer_dmat
, cm
->cm_datamap
,
1307 BUS_DMASYNC_PREWRITE
);
1309 cm
->cm_flags
|= AAC_CMD_MAPPED
;
1313 * Unmap a command from controller-visible space.
1316 aac_unmap_command(struct aac_command
*cm
)
1318 struct aac_softc
*sc
;
1324 if (!(cm
->cm_flags
& AAC_CMD_MAPPED
))
1327 if (cm
->cm_datalen
!= 0) {
1328 if (cm
->cm_flags
& AAC_CMD_DATAIN
)
1329 bus_dmamap_sync(sc
->aac_buffer_dmat
, cm
->cm_datamap
,
1330 BUS_DMASYNC_POSTREAD
);
1331 if (cm
->cm_flags
& AAC_CMD_DATAOUT
)
1332 bus_dmamap_sync(sc
->aac_buffer_dmat
, cm
->cm_datamap
,
1333 BUS_DMASYNC_POSTWRITE
);
1335 bus_dmamap_unload(sc
->aac_buffer_dmat
, cm
->cm_datamap
);
1337 cm
->cm_flags
&= ~AAC_CMD_MAPPED
;
1341 * Hardware Interface
1345 * Initialise the adapter.
1348 aac_common_map(void *arg
, bus_dma_segment_t
*segs
, int nseg
, int error
)
1350 struct aac_softc
*sc
;
1354 sc
= (struct aac_softc
*)arg
;
1356 sc
->aac_common_busaddr
= segs
[0].ds_addr
;
1360 aac_check_firmware(struct aac_softc
*sc
)
1362 u_int32_t major
, minor
, options
;
1367 * Retrieve the firmware version numbers. Dell PERC2/QC cards with
1368 * firmware version 1.x are not compatible with this driver.
1370 if (sc
->flags
& AAC_FLAGS_PERC2QC
) {
1371 if (aac_sync_command(sc
, AAC_MONKER_GETKERNVER
, 0, 0, 0, 0,
1373 device_printf(sc
->aac_dev
,
1374 "Error reading firmware version\n");
1378 /* These numbers are stored as ASCII! */
1379 major
= (AAC_GET_MAILBOX(sc
, 1) & 0xff) - 0x30;
1380 minor
= (AAC_GET_MAILBOX(sc
, 2) & 0xff) - 0x30;
1382 device_printf(sc
->aac_dev
,
1383 "Firmware version %d.%d is not supported.\n",
1390 * Retrieve the capabilities/supported options word so we know what
1391 * work-arounds to enable.
1393 if (aac_sync_command(sc
, AAC_MONKER_GETINFO
, 0, 0, 0, 0, NULL
)) {
1394 device_printf(sc
->aac_dev
, "RequestAdapterInfo failed\n");
1397 options
= AAC_GET_MAILBOX(sc
, 1);
1398 sc
->supported_options
= options
;
1400 if ((options
& AAC_SUPPORTED_4GB_WINDOW
) != 0 &&
1401 (sc
->flags
& AAC_FLAGS_NO4GB
) == 0)
1402 sc
->flags
|= AAC_FLAGS_4GB_WINDOW
;
1403 if (options
& AAC_SUPPORTED_NONDASD
)
1404 sc
->flags
|= AAC_FLAGS_ENABLE_CAM
;
1410 aac_init(struct aac_softc
*sc
)
1412 struct aac_adapter_init
*ip
;
1421 * First wait for the adapter to come ready.
1425 code
= AAC_GET_FWSTATUS(sc
);
1426 if (code
& AAC_SELF_TEST_FAILED
) {
1427 device_printf(sc
->aac_dev
, "FATAL: selftest failed\n");
1430 if (code
& AAC_KERNEL_PANIC
) {
1431 device_printf(sc
->aac_dev
,
1432 "FATAL: controller kernel panic\n");
1435 if (time_second
> (then
+ AAC_BOOT_TIMEOUT
)) {
1436 device_printf(sc
->aac_dev
,
1437 "FATAL: controller not coming ready, "
1438 "status %x\n", code
);
1441 } while (!(code
& AAC_UP_AND_RUNNING
));
1445 * Create DMA tag for mapping buffers into controller-addressable space.
1447 if (bus_dma_tag_create(sc
->aac_parent_dmat
, /* parent */
1448 1, 0, /* algnmnt, boundary */
1449 BUS_SPACE_MAXADDR_32BIT
, /* lowaddr */
1450 BUS_SPACE_MAXADDR
, /* highaddr */
1451 NULL
, NULL
, /* filter, filterarg */
1452 MAXBSIZE
, /* maxsize */
1453 AAC_MAXSGENTRIES
, /* nsegments */
1454 MAXBSIZE
, /* maxsegsize */
1455 BUS_DMA_ALLOCNOW
, /* flags */
1456 &sc
->aac_buffer_dmat
)) {
1457 device_printf(sc
->aac_dev
, "can't allocate buffer DMA tag\n");
1462 * Create DMA tag for mapping FIBs into controller-addressable space..
1464 if (bus_dma_tag_create(sc
->aac_parent_dmat
, /* parent */
1465 1, 0, /* algnmnt, boundary */
1466 (sc
->flags
& AAC_FLAGS_4GB_WINDOW
) ?
1467 BUS_SPACE_MAXADDR_32BIT
:
1468 0x7fffffff, /* lowaddr */
1469 BUS_SPACE_MAXADDR
, /* highaddr */
1470 NULL
, NULL
, /* filter, filterarg */
1472 sizeof(struct aac_fib
), /* maxsize */
1475 sizeof(struct aac_fib
), /* maxsegsize */
1476 BUS_DMA_ALLOCNOW
, /* flags */
1477 &sc
->aac_fib_dmat
)) {
1478 device_printf(sc
->aac_dev
, "can't allocate FIB DMA tag\n");
1483 * Create DMA tag for the common structure and allocate it.
1485 if (bus_dma_tag_create(sc
->aac_parent_dmat
, /* parent */
1486 1, 0, /* algnmnt, boundary */
1487 (sc
->flags
& AAC_FLAGS_4GB_WINDOW
) ?
1488 BUS_SPACE_MAXADDR_32BIT
:
1489 0x7fffffff, /* lowaddr */
1490 BUS_SPACE_MAXADDR
, /* highaddr */
1491 NULL
, NULL
, /* filter, filterarg */
1492 8192 + sizeof(struct aac_common
), /* maxsize */
1494 BUS_SPACE_MAXSIZE_32BIT
, /* maxsegsize */
1495 BUS_DMA_ALLOCNOW
, /* flags */
1496 &sc
->aac_common_dmat
)) {
1497 device_printf(sc
->aac_dev
,
1498 "can't allocate common structure DMA tag\n");
1501 if (bus_dmamem_alloc(sc
->aac_common_dmat
, (void **)&sc
->aac_common
,
1502 BUS_DMA_NOWAIT
, &sc
->aac_common_dmamap
)) {
1503 device_printf(sc
->aac_dev
, "can't allocate common structure\n");
1507 * Work around a bug in the 2120 and 2200 that cannot DMA commands
1508 * below address 8192 in physical memory.
1509 * XXX If the padding is not needed, can it be put to use instead
1512 bus_dmamap_load(sc
->aac_common_dmat
, sc
->aac_common_dmamap
,
1513 sc
->aac_common
, 8192 + sizeof(*sc
->aac_common
),
1514 aac_common_map
, sc
, 0);
1516 if (sc
->aac_common_busaddr
< 8192) {
1518 (struct aac_common
*)((uint8_t *)sc
->aac_common
+ 8192);
1519 sc
->aac_common_busaddr
+= 8192;
1521 bzero(sc
->aac_common
, sizeof(*sc
->aac_common
));
1523 /* Allocate some FIBs and associated command structs */
1524 if (aac_alloc_commands(sc
) != 0)
1528 * Fill in the init structure. This tells the adapter about the
1529 * physical location of various important shared data structures.
1531 ip
= &sc
->aac_common
->ac_init
;
1532 ip
->InitStructRevision
= AAC_INIT_STRUCT_REVISION
;
1533 ip
->MiniPortRevision
= AAC_INIT_STRUCT_MINIPORT_REVISION
;
1535 ip
->AdapterFibsPhysicalAddress
= sc
->aac_common_busaddr
+
1536 offsetof(struct aac_common
, ac_fibs
);
1537 ip
->AdapterFibsVirtualAddress
= (aac_phys_addr_t
)&sc
->aac_common
->ac_fibs
[0];
1538 ip
->AdapterFibsSize
= AAC_ADAPTER_FIBS
* sizeof(struct aac_fib
);
1539 ip
->AdapterFibAlign
= sizeof(struct aac_fib
);
1541 ip
->PrintfBufferAddress
= sc
->aac_common_busaddr
+
1542 offsetof(struct aac_common
, ac_printf
);
1543 ip
->PrintfBufferSize
= AAC_PRINTF_BUFSIZE
;
1545 /* The adapter assumes that pages are 4K in size */
1546 /* XXX why should the adapter care? */
1547 ip
->HostPhysMemPages
= ctob((int)Maxmem
) / AAC_PAGE_SIZE
;
1548 ip
->HostElapsedSeconds
= time_second
; /* reset later if invalid */
1551 * Initialise FIB queues. Note that it appears that the layout of the
1552 * indexes and the segmentation of the entries may be mandated by the
1553 * adapter, which is only told about the base of the queue index fields.
1555 * The initial values of the indices are assumed to inform the adapter
1556 * of the sizes of the respective queues, and theoretically it could
1557 * work out the entire layout of the queue structures from this. We
1558 * take the easy route and just lay this area out like everyone else
1561 * The Linux driver uses a much more complex scheme whereby several
1562 * header records are kept for each queue. We use a couple of generic
1563 * list manipulation functions which 'know' the size of each list by
1564 * virtue of a table.
1566 qaddr
= &sc
->aac_common
->ac_qbuf
[0] + AAC_QUEUE_ALIGN
;
1567 qaddr
-= (u_int32_t
)qaddr
% AAC_QUEUE_ALIGN
;
1568 sc
->aac_queues
= (struct aac_queue_table
*)qaddr
;
1569 ip
->CommHeaderAddress
= sc
->aac_common_busaddr
+
1570 ((u_int32_t
)sc
->aac_queues
-
1571 (u_int32_t
)sc
->aac_common
);
1572 bzero(sc
->aac_queues
, sizeof(struct aac_queue_table
));
1574 sc
->aac_queues
->qt_qindex
[AAC_HOST_NORM_CMD_QUEUE
][AAC_PRODUCER_INDEX
] =
1575 AAC_HOST_NORM_CMD_ENTRIES
;
1576 sc
->aac_queues
->qt_qindex
[AAC_HOST_NORM_CMD_QUEUE
][AAC_CONSUMER_INDEX
] =
1577 AAC_HOST_NORM_CMD_ENTRIES
;
1578 sc
->aac_queues
->qt_qindex
[AAC_HOST_HIGH_CMD_QUEUE
][AAC_PRODUCER_INDEX
] =
1579 AAC_HOST_HIGH_CMD_ENTRIES
;
1580 sc
->aac_queues
->qt_qindex
[AAC_HOST_HIGH_CMD_QUEUE
][AAC_CONSUMER_INDEX
] =
1581 AAC_HOST_HIGH_CMD_ENTRIES
;
1582 sc
->aac_queues
->qt_qindex
[AAC_ADAP_NORM_CMD_QUEUE
][AAC_PRODUCER_INDEX
] =
1583 AAC_ADAP_NORM_CMD_ENTRIES
;
1584 sc
->aac_queues
->qt_qindex
[AAC_ADAP_NORM_CMD_QUEUE
][AAC_CONSUMER_INDEX
] =
1585 AAC_ADAP_NORM_CMD_ENTRIES
;
1586 sc
->aac_queues
->qt_qindex
[AAC_ADAP_HIGH_CMD_QUEUE
][AAC_PRODUCER_INDEX
] =
1587 AAC_ADAP_HIGH_CMD_ENTRIES
;
1588 sc
->aac_queues
->qt_qindex
[AAC_ADAP_HIGH_CMD_QUEUE
][AAC_CONSUMER_INDEX
] =
1589 AAC_ADAP_HIGH_CMD_ENTRIES
;
1590 sc
->aac_queues
->qt_qindex
[AAC_HOST_NORM_RESP_QUEUE
][AAC_PRODUCER_INDEX
]=
1591 AAC_HOST_NORM_RESP_ENTRIES
;
1592 sc
->aac_queues
->qt_qindex
[AAC_HOST_NORM_RESP_QUEUE
][AAC_CONSUMER_INDEX
]=
1593 AAC_HOST_NORM_RESP_ENTRIES
;
1594 sc
->aac_queues
->qt_qindex
[AAC_HOST_HIGH_RESP_QUEUE
][AAC_PRODUCER_INDEX
]=
1595 AAC_HOST_HIGH_RESP_ENTRIES
;
1596 sc
->aac_queues
->qt_qindex
[AAC_HOST_HIGH_RESP_QUEUE
][AAC_CONSUMER_INDEX
]=
1597 AAC_HOST_HIGH_RESP_ENTRIES
;
1598 sc
->aac_queues
->qt_qindex
[AAC_ADAP_NORM_RESP_QUEUE
][AAC_PRODUCER_INDEX
]=
1599 AAC_ADAP_NORM_RESP_ENTRIES
;
1600 sc
->aac_queues
->qt_qindex
[AAC_ADAP_NORM_RESP_QUEUE
][AAC_CONSUMER_INDEX
]=
1601 AAC_ADAP_NORM_RESP_ENTRIES
;
1602 sc
->aac_queues
->qt_qindex
[AAC_ADAP_HIGH_RESP_QUEUE
][AAC_PRODUCER_INDEX
]=
1603 AAC_ADAP_HIGH_RESP_ENTRIES
;
1604 sc
->aac_queues
->qt_qindex
[AAC_ADAP_HIGH_RESP_QUEUE
][AAC_CONSUMER_INDEX
]=
1605 AAC_ADAP_HIGH_RESP_ENTRIES
;
1606 sc
->aac_qentries
[AAC_HOST_NORM_CMD_QUEUE
] =
1607 &sc
->aac_queues
->qt_HostNormCmdQueue
[0];
1608 sc
->aac_qentries
[AAC_HOST_HIGH_CMD_QUEUE
] =
1609 &sc
->aac_queues
->qt_HostHighCmdQueue
[0];
1610 sc
->aac_qentries
[AAC_ADAP_NORM_CMD_QUEUE
] =
1611 &sc
->aac_queues
->qt_AdapNormCmdQueue
[0];
1612 sc
->aac_qentries
[AAC_ADAP_HIGH_CMD_QUEUE
] =
1613 &sc
->aac_queues
->qt_AdapHighCmdQueue
[0];
1614 sc
->aac_qentries
[AAC_HOST_NORM_RESP_QUEUE
] =
1615 &sc
->aac_queues
->qt_HostNormRespQueue
[0];
1616 sc
->aac_qentries
[AAC_HOST_HIGH_RESP_QUEUE
] =
1617 &sc
->aac_queues
->qt_HostHighRespQueue
[0];
1618 sc
->aac_qentries
[AAC_ADAP_NORM_RESP_QUEUE
] =
1619 &sc
->aac_queues
->qt_AdapNormRespQueue
[0];
1620 sc
->aac_qentries
[AAC_ADAP_HIGH_RESP_QUEUE
] =
1621 &sc
->aac_queues
->qt_AdapHighRespQueue
[0];
1624 * Do controller-type-specific initialisation
1626 switch (sc
->aac_hwif
) {
1627 case AAC_HWIF_I960RX
:
1628 AAC_SETREG4(sc
, AAC_RX_ODBR
, ~0);
1633 * Give the init structure to the controller.
1635 if (aac_sync_command(sc
, AAC_MONKER_INITSTRUCT
,
1636 sc
->aac_common_busaddr
+
1637 offsetof(struct aac_common
, ac_init
), 0, 0, 0,
1639 device_printf(sc
->aac_dev
,
1640 "error establishing init structure\n");
1651 * Send a synchronous command to the controller and wait for a result.
1654 aac_sync_command(struct aac_softc
*sc
, u_int32_t command
,
1655 u_int32_t arg0
, u_int32_t arg1
, u_int32_t arg2
, u_int32_t arg3
,
1663 /* populate the mailbox */
1664 AAC_SET_MAILBOX(sc
, command
, arg0
, arg1
, arg2
, arg3
);
1666 /* ensure the sync command doorbell flag is cleared */
1667 AAC_CLEAR_ISTATUS(sc
, AAC_DB_SYNC_COMMAND
);
1669 /* then set it to signal the adapter */
1670 AAC_QNOTIFY(sc
, AAC_DB_SYNC_COMMAND
);
1672 /* spin waiting for the command to complete */
1675 if (time_second
> (then
+ AAC_IMMEDIATE_TIMEOUT
)) {
1676 debug(1, "timed out");
1679 } while (!(AAC_GET_ISTATUS(sc
) & AAC_DB_SYNC_COMMAND
));
1681 /* clear the completion flag */
1682 AAC_CLEAR_ISTATUS(sc
, AAC_DB_SYNC_COMMAND
);
1684 /* get the command status */
1685 status
= AAC_GET_MAILBOX(sc
, 0);
1692 * Grab the sync fib area.
1695 aac_alloc_sync_fib(struct aac_softc
*sc
, struct aac_fib
**fib
, int flags
)
1699 * If the force flag is set, the system is shutting down, or in
1700 * trouble. Ignore the mutex.
1702 if (!(flags
& AAC_SYNC_LOCK_FORCE
))
1703 AAC_LOCK_ACQUIRE(&sc
->aac_sync_lock
);
1705 *fib
= &sc
->aac_common
->ac_sync_fib
;
1711 * Release the sync fib area.
1714 aac_release_sync_fib(struct aac_softc
*sc
)
1717 AAC_LOCK_RELEASE(&sc
->aac_sync_lock
);
1721 * Send a synchronous FIB to the controller and wait for a result.
1724 aac_sync_fib(struct aac_softc
*sc
, u_int32_t command
, u_int32_t xferstate
,
1725 struct aac_fib
*fib
, u_int16_t datasize
)
1729 if (datasize
> AAC_FIB_DATASIZE
)
1733 * Set up the sync FIB
1735 fib
->Header
.XferState
= AAC_FIBSTATE_HOSTOWNED
|
1736 AAC_FIBSTATE_INITIALISED
|
1738 fib
->Header
.XferState
|= xferstate
;
1739 fib
->Header
.Command
= command
;
1740 fib
->Header
.StructType
= AAC_FIBTYPE_TFIB
;
1741 fib
->Header
.Size
= sizeof(struct aac_fib
) + datasize
;
1742 fib
->Header
.SenderSize
= sizeof(struct aac_fib
);
1743 fib
->Header
.SenderFibAddress
= (u_int32_t
)fib
;
1744 fib
->Header
.ReceiverFibAddress
= sc
->aac_common_busaddr
+
1745 offsetof(struct aac_common
,
1749 * Give the FIB to the controller, wait for a response.
1751 if (aac_sync_command(sc
, AAC_MONKER_SYNCFIB
,
1752 fib
->Header
.ReceiverFibAddress
, 0, 0, 0, NULL
)) {
1753 debug(2, "IO error");
1761 * Adapter-space FIB queue manipulation
1763 * Note that the queue implementation here is a little funky; neither the PI or
1764 * CI will ever be zero. This behaviour is a controller feature.
1770 {AAC_HOST_NORM_CMD_ENTRIES
, AAC_DB_COMMAND_NOT_FULL
},
1771 {AAC_HOST_HIGH_CMD_ENTRIES
, 0},
1772 {AAC_ADAP_NORM_CMD_ENTRIES
, AAC_DB_COMMAND_READY
},
1773 {AAC_ADAP_HIGH_CMD_ENTRIES
, 0},
1774 {AAC_HOST_NORM_RESP_ENTRIES
, AAC_DB_RESPONSE_NOT_FULL
},
1775 {AAC_HOST_HIGH_RESP_ENTRIES
, 0},
1776 {AAC_ADAP_NORM_RESP_ENTRIES
, AAC_DB_RESPONSE_READY
},
1777 {AAC_ADAP_HIGH_RESP_ENTRIES
, 0}
1781 * Atomically insert an entry into the nominated queue, returns 0 on success or
1782 * EBUSY if the queue is full.
1784 * Note: it would be more efficient to defer notifying the controller in
1785 * the case where we may be inserting several entries in rapid succession,
1786 * but implementing this usefully may be difficult (it would involve a
1787 * separate queue/notify interface).
1790 aac_enqueue_fib(struct aac_softc
*sc
, int queue
, struct aac_command
*cm
)
1799 fib_size
= cm
->cm_fib
->Header
.Size
;
1800 fib_addr
= cm
->cm_fib
->Header
.ReceiverFibAddress
;
1804 /* get the producer/consumer indices */
1805 pi
= sc
->aac_queues
->qt_qindex
[queue
][AAC_PRODUCER_INDEX
];
1806 ci
= sc
->aac_queues
->qt_qindex
[queue
][AAC_CONSUMER_INDEX
];
1808 /* wrap the queue? */
1809 if (pi
>= aac_qinfo
[queue
].size
)
1812 /* check for queue full */
1813 if ((pi
+ 1) == ci
) {
1818 * To avoid a race with its completion interrupt, place this command on
1819 * the busy queue prior to advertising it to the controller.
1821 aac_enqueue_busy(cm
);
1825 /* populate queue entry */
1826 (sc
->aac_qentries
[queue
] + pi
)->aq_fib_size
= fib_size
;
1827 (sc
->aac_qentries
[queue
] + pi
)->aq_fib_addr
= fib_addr
;
1829 /* update producer index */
1830 sc
->aac_queues
->qt_qindex
[queue
][AAC_PRODUCER_INDEX
] = pi
+ 1;
1832 /* notify the adapter if we know how */
1833 if (aac_qinfo
[queue
].notify
!= 0)
1834 AAC_QNOTIFY(sc
, aac_qinfo
[queue
].notify
);
1844 * Atomically remove one entry from the nominated queue, returns 0 on
1845 * success or ENOENT if the queue is empty.
1848 aac_dequeue_fib(struct aac_softc
*sc
, int queue
, u_int32_t
*fib_size
,
1849 struct aac_fib
**fib_addr
)
1859 /* get the producer/consumer indices */
1860 pi
= sc
->aac_queues
->qt_qindex
[queue
][AAC_PRODUCER_INDEX
];
1861 ci
= sc
->aac_queues
->qt_qindex
[queue
][AAC_CONSUMER_INDEX
];
1863 /* check for queue empty */
1869 /* wrap the pi so the following test works */
1870 if (pi
>= aac_qinfo
[queue
].size
)
1877 /* wrap the queue? */
1878 if (ci
>= aac_qinfo
[queue
].size
)
1881 /* fetch the entry */
1882 *fib_size
= (sc
->aac_qentries
[queue
] + ci
)->aq_fib_size
;
1883 *fib_addr
= (struct aac_fib
*)(sc
->aac_qentries
[queue
] +
1887 * Is this a fast response? If it is, update the fib fields in
1888 * local memory so the whole fib doesn't have to be DMA'd back up.
1890 if (*(uintptr_t *)fib_addr
& 0x01) {
1891 *(uintptr_t *)fib_addr
&= ~0x01;
1892 (*fib_addr
)->Header
.XferState
|= AAC_FIBSTATE_DONEADAP
;
1893 *((u_int32_t
*)((*fib_addr
)->data
)) = AAC_ERROR_NORMAL
;
1895 /* update consumer index */
1896 sc
->aac_queues
->qt_qindex
[queue
][AAC_CONSUMER_INDEX
] = ci
+ 1;
1898 /* if we have made the queue un-full, notify the adapter */
1899 if (notify
&& (aac_qinfo
[queue
].notify
!= 0))
1900 AAC_QNOTIFY(sc
, aac_qinfo
[queue
].notify
);
1909 * Put our response to an Adapter Initialed Fib on the response queue
1912 aac_enqueue_response(struct aac_softc
*sc
, int queue
, struct aac_fib
*fib
)
1921 /* Tell the adapter where the FIB is */
1922 fib_size
= fib
->Header
.Size
;
1923 fib_addr
= fib
->Header
.SenderFibAddress
;
1924 fib
->Header
.ReceiverFibAddress
= fib_addr
;
1928 /* get the producer/consumer indices */
1929 pi
= sc
->aac_queues
->qt_qindex
[queue
][AAC_PRODUCER_INDEX
];
1930 ci
= sc
->aac_queues
->qt_qindex
[queue
][AAC_CONSUMER_INDEX
];
1932 /* wrap the queue? */
1933 if (pi
>= aac_qinfo
[queue
].size
)
1936 /* check for queue full */
1937 if ((pi
+ 1) == ci
) {
1942 /* populate queue entry */
1943 (sc
->aac_qentries
[queue
] + pi
)->aq_fib_size
= fib_size
;
1944 (sc
->aac_qentries
[queue
] + pi
)->aq_fib_addr
= fib_addr
;
1946 /* update producer index */
1947 sc
->aac_queues
->qt_qindex
[queue
][AAC_PRODUCER_INDEX
] = pi
+ 1;
1949 /* notify the adapter if we know how */
1950 if (aac_qinfo
[queue
].notify
!= 0)
1951 AAC_QNOTIFY(sc
, aac_qinfo
[queue
].notify
);
1961 * Check for commands that have been outstanding for a suspiciously long time,
1962 * and complain about them.
1965 aac_timeout(void *xsc
)
1967 struct aac_softc
*sc
= xsc
;
1968 struct aac_command
*cm
;
1972 /* simulate an interrupt to handle possibly-missed interrupts */
1974 * XXX This was done to work around another bug which has since been
1975 * fixed. It is dangerous anyways because you don't want multiple
1976 * threads in the interrupt handler at the same time! If calling
1977 * is deamed neccesary in the future, proper mutexes must be used.
1983 /* kick the I/O queue to restart it in the case of deadlock */
1988 * traverse the busy command list, bitch about late commands once
1992 deadline
= time_second
- AAC_CMD_TIMEOUT
;
1994 TAILQ_FOREACH(cm
, &sc
->aac_busy
, cm_link
) {
1995 if ((cm
->cm_timestamp
< deadline
)
1996 /* && !(cm->cm_flags & AAC_CMD_TIMEDOUT) */) {
1997 cm
->cm_flags
|= AAC_CMD_TIMEDOUT
;
1998 device_printf(sc
->aac_dev
,
1999 "COMMAND %p TIMEOUT AFTER %d SECONDS\n",
2000 cm
, (int)(time_second
-cm
->cm_timestamp
));
2001 AAC_PRINT_FIB(sc
, cm
->cm_fib
);
2006 code
= AAC_GET_FWSTATUS(sc
);
2007 if (code
!= AAC_UP_AND_RUNNING
) {
2008 device_printf(sc
->aac_dev
, "WARNING! Controller is no "
2009 "longer running! code= 0x%x\n", code
);
2015 /* reset the timer for next time */
2016 callout_reset(&sc
->aac_watchdog
, AAC_PERIODIC_INTERVAL
* hz
,
2021 * Interface Function Vectors
2025 * Read the current firmware status word.
2028 aac_sa_get_fwstatus(struct aac_softc
*sc
)
2032 return(AAC_GETREG4(sc
, AAC_SA_FWSTATUS
));
2036 aac_rx_get_fwstatus(struct aac_softc
*sc
)
2040 return(AAC_GETREG4(sc
, AAC_RX_FWSTATUS
));
2044 aac_fa_get_fwstatus(struct aac_softc
*sc
)
2050 val
= AAC_GETREG4(sc
, AAC_FA_FWSTATUS
);
2055 * Notify the controller of a change in a given queue
2059 aac_sa_qnotify(struct aac_softc
*sc
, int qbit
)
2063 AAC_SETREG2(sc
, AAC_SA_DOORBELL1_SET
, qbit
);
2067 aac_rx_qnotify(struct aac_softc
*sc
, int qbit
)
2071 AAC_SETREG4(sc
, AAC_RX_IDBR
, qbit
);
2075 aac_fa_qnotify(struct aac_softc
*sc
, int qbit
)
2079 AAC_SETREG2(sc
, AAC_FA_DOORBELL1
, qbit
);
2084 * Get the interrupt reason bits
2087 aac_sa_get_istatus(struct aac_softc
*sc
)
2091 return(AAC_GETREG2(sc
, AAC_SA_DOORBELL0
));
2095 aac_rx_get_istatus(struct aac_softc
*sc
)
2099 return(AAC_GETREG4(sc
, AAC_RX_ODBR
));
2103 aac_fa_get_istatus(struct aac_softc
*sc
)
2109 val
= AAC_GETREG2(sc
, AAC_FA_DOORBELL0
);
2114 * Clear some interrupt reason bits
2117 aac_sa_clear_istatus(struct aac_softc
*sc
, int mask
)
2121 AAC_SETREG2(sc
, AAC_SA_DOORBELL0_CLEAR
, mask
);
2125 aac_rx_clear_istatus(struct aac_softc
*sc
, int mask
)
2129 AAC_SETREG4(sc
, AAC_RX_ODBR
, mask
);
2133 aac_fa_clear_istatus(struct aac_softc
*sc
, int mask
)
2137 AAC_SETREG2(sc
, AAC_FA_DOORBELL0_CLEAR
, mask
);
2142 * Populate the mailbox and set the command word
2145 aac_sa_set_mailbox(struct aac_softc
*sc
, u_int32_t command
,
2146 u_int32_t arg0
, u_int32_t arg1
, u_int32_t arg2
, u_int32_t arg3
)
2150 AAC_SETREG4(sc
, AAC_SA_MAILBOX
, command
);
2151 AAC_SETREG4(sc
, AAC_SA_MAILBOX
+ 4, arg0
);
2152 AAC_SETREG4(sc
, AAC_SA_MAILBOX
+ 8, arg1
);
2153 AAC_SETREG4(sc
, AAC_SA_MAILBOX
+ 12, arg2
);
2154 AAC_SETREG4(sc
, AAC_SA_MAILBOX
+ 16, arg3
);
2158 aac_rx_set_mailbox(struct aac_softc
*sc
, u_int32_t command
,
2159 u_int32_t arg0
, u_int32_t arg1
, u_int32_t arg2
, u_int32_t arg3
)
2163 AAC_SETREG4(sc
, AAC_RX_MAILBOX
, command
);
2164 AAC_SETREG4(sc
, AAC_RX_MAILBOX
+ 4, arg0
);
2165 AAC_SETREG4(sc
, AAC_RX_MAILBOX
+ 8, arg1
);
2166 AAC_SETREG4(sc
, AAC_RX_MAILBOX
+ 12, arg2
);
2167 AAC_SETREG4(sc
, AAC_RX_MAILBOX
+ 16, arg3
);
2171 aac_fa_set_mailbox(struct aac_softc
*sc
, u_int32_t command
,
2172 u_int32_t arg0
, u_int32_t arg1
, u_int32_t arg2
, u_int32_t arg3
)
2176 AAC_SETREG4(sc
, AAC_FA_MAILBOX
, command
);
2178 AAC_SETREG4(sc
, AAC_FA_MAILBOX
+ 4, arg0
);
2180 AAC_SETREG4(sc
, AAC_FA_MAILBOX
+ 8, arg1
);
2182 AAC_SETREG4(sc
, AAC_FA_MAILBOX
+ 12, arg2
);
2184 AAC_SETREG4(sc
, AAC_FA_MAILBOX
+ 16, arg3
);
2189 * Fetch the immediate command status word
2192 aac_sa_get_mailbox(struct aac_softc
*sc
, int mb
)
2196 return(AAC_GETREG4(sc
, AAC_SA_MAILBOX
+ (mb
* 4)));
2200 aac_rx_get_mailbox(struct aac_softc
*sc
, int mb
)
2204 return(AAC_GETREG4(sc
, AAC_RX_MAILBOX
+ (mb
* 4)));
2208 aac_fa_get_mailbox(struct aac_softc
*sc
, int mb
)
2214 val
= AAC_GETREG4(sc
, AAC_FA_MAILBOX
+ (mb
* 4));
2219 * Set/clear interrupt masks
2222 aac_sa_set_interrupts(struct aac_softc
*sc
, int enable
)
2224 debug(2, "%sable interrupts", enable
? "en" : "dis");
2227 AAC_SETREG2((sc
), AAC_SA_MASK0_CLEAR
, AAC_DB_INTERRUPTS
);
2229 AAC_SETREG2((sc
), AAC_SA_MASK0_SET
, ~0);
2234 aac_rx_set_interrupts(struct aac_softc
*sc
, int enable
)
2236 debug(2, "%sable interrupts", enable
? "en" : "dis");
2239 AAC_SETREG4(sc
, AAC_RX_OIMR
, ~AAC_DB_INTERRUPTS
);
2241 AAC_SETREG4(sc
, AAC_RX_OIMR
, ~0);
2246 aac_fa_set_interrupts(struct aac_softc
*sc
, int enable
)
2248 debug(2, "%sable interrupts", enable
? "en" : "dis");
2251 AAC_SETREG2((sc
), AAC_FA_MASK0_CLEAR
, AAC_DB_INTERRUPTS
);
2254 AAC_SETREG2((sc
), AAC_FA_MASK0
, ~0);
2260 * Debugging and Diagnostics
2264 * Print some information about the controller.
2267 aac_describe_controller(struct aac_softc
*sc
)
2269 struct aac_fib
*fib
;
2270 struct aac_adapter_info
*info
;
2274 aac_alloc_sync_fib(sc
, &fib
, 0);
2277 if (aac_sync_fib(sc
, RequestAdapterInfo
, 0, fib
, 1)) {
2278 device_printf(sc
->aac_dev
, "RequestAdapterInfo failed\n");
2279 aac_release_sync_fib(sc
);
2282 info
= (struct aac_adapter_info
*)&fib
->data
[0];
2284 device_printf(sc
->aac_dev
, "%s %dMHz, %dMB cache memory, %s\n",
2285 aac_describe_code(aac_cpu_variant
, info
->CpuVariant
),
2286 info
->ClockSpeed
, info
->BufferMem
/ (1024 * 1024),
2287 aac_describe_code(aac_battery_platform
,
2288 info
->batteryPlatform
));
2290 /* save the kernel revision structure for later use */
2291 sc
->aac_revision
= info
->KernelRevision
;
2292 device_printf(sc
->aac_dev
, "Kernel %d.%d-%d, Build %d, S/N %6X\n",
2293 info
->KernelRevision
.external
.comp
.major
,
2294 info
->KernelRevision
.external
.comp
.minor
,
2295 info
->KernelRevision
.external
.comp
.dash
,
2296 info
->KernelRevision
.buildNumber
,
2297 (u_int32_t
)(info
->SerialNumber
& 0xffffff));
2299 aac_release_sync_fib(sc
);
2301 if (1 || bootverbose
) {
2302 device_printf(sc
->aac_dev
, "Supported Options=%b\n",
2303 sc
->supported_options
,
2322 * Look up a text description of a numeric error code and return a pointer to
2326 aac_describe_code(struct aac_code_lookup
*table
, u_int32_t code
)
2330 for (i
= 0; table
[i
].string
!= NULL
; i
++)
2331 if (table
[i
].code
== code
)
2332 return(table
[i
].string
);
2333 return(table
[i
+ 1].string
);
2337 * Management Interface
2341 aac_open(struct dev_open_args
*ap
)
2343 cdev_t dev
= ap
->a_head
.a_dev
;
2344 struct aac_softc
*sc
;
2350 /* Check to make sure the device isn't already open */
2351 if (sc
->aac_state
& AAC_STATE_OPEN
) {
2354 sc
->aac_state
|= AAC_STATE_OPEN
;
2360 aac_close(struct dev_close_args
*ap
)
2362 cdev_t dev
= ap
->a_head
.a_dev
;
2363 struct aac_softc
*sc
;
2369 /* Mark this unit as no longer open */
2370 sc
->aac_state
&= ~AAC_STATE_OPEN
;
2376 aac_ioctl(struct dev_ioctl_args
*ap
)
2378 cdev_t dev
= ap
->a_head
.a_dev
;
2379 caddr_t arg
= ap
->a_data
;
2380 struct aac_softc
*sc
= dev
->si_drv1
;
2386 if (ap
->a_cmd
== AACIO_STATS
) {
2387 union aac_statrequest
*as
= (union aac_statrequest
*)arg
;
2389 switch (as
->as_item
) {
2395 bcopy(&sc
->aac_qstat
[as
->as_item
], &as
->as_qstat
,
2396 sizeof(struct aac_qstat
));
2405 arg
= *(caddr_t
*)arg
;
2407 switch (ap
->a_cmd
) {
2408 /* AACIO_STATS already handled above */
2409 case FSACTL_SENDFIB
:
2410 debug(1, "FSACTL_SENDFIB");
2411 error
= aac_ioctl_sendfib(sc
, arg
);
2413 case FSACTL_AIF_THREAD
:
2414 debug(1, "FSACTL_AIF_THREAD");
2417 case FSACTL_OPEN_GET_ADAPTER_FIB
:
2418 debug(1, "FSACTL_OPEN_GET_ADAPTER_FIB");
2420 * Pass the caller out an AdapterFibContext.
2422 * Note that because we only support one opener, we
2423 * basically ignore this. Set the caller's context to a magic
2424 * number just in case.
2426 * The Linux code hands the driver a pointer into kernel space,
2427 * and then trusts it when the caller hands it back. Aiee!
2428 * Here, we give it the proc pointer of the per-adapter aif
2429 * thread. It's only used as a sanity check in other calls.
2431 i
= (int)sc
->aifthread
;
2432 error
= copyout(&i
, arg
, sizeof(i
));
2434 case FSACTL_GET_NEXT_ADAPTER_FIB
:
2435 debug(1, "FSACTL_GET_NEXT_ADAPTER_FIB");
2436 error
= aac_getnext_aif(sc
, arg
);
2438 case FSACTL_CLOSE_GET_ADAPTER_FIB
:
2439 debug(1, "FSACTL_CLOSE_GET_ADAPTER_FIB");
2440 /* don't do anything here */
2442 case FSACTL_MINIPORT_REV_CHECK
:
2443 debug(1, "FSACTL_MINIPORT_REV_CHECK");
2444 error
= aac_rev_check(sc
, arg
);
2446 case FSACTL_QUERY_DISK
:
2447 debug(1, "FSACTL_QUERY_DISK");
2448 error
= aac_query_disk(sc
, arg
);
2450 case FSACTL_DELETE_DISK
:
2452 * We don't trust the underland to tell us when to delete a
2453 * container, rather we rely on an AIF coming from the
2459 debug(1, "unsupported cmd 0x%lx\n", ap
->a_cmd
);
2467 aac_poll(struct dev_poll_args
*ap
)
2469 cdev_t dev
= ap
->a_head
.a_dev
;
2470 struct aac_softc
*sc
;
2476 AAC_LOCK_ACQUIRE(&sc
->aac_aifq_lock
);
2477 if ((ap
->a_events
& (POLLRDNORM
| POLLIN
)) != 0) {
2478 if (sc
->aac_aifq_tail
!= sc
->aac_aifq_head
)
2479 revents
|= ap
->a_events
& (POLLIN
| POLLRDNORM
);
2481 AAC_LOCK_RELEASE(&sc
->aac_aifq_lock
);
2484 if (ap
->a_events
& (POLLIN
| POLLRDNORM
))
2485 selrecord(curthread
, &sc
->rcv_select
);
2487 ap
->a_events
= revents
;
2492 * Send a FIB supplied from userspace
2495 aac_ioctl_sendfib(struct aac_softc
*sc
, caddr_t ufib
)
2497 struct aac_command
*cm
;
2507 if (aac_alloc_command(sc
, &cm
)) {
2513 * Fetch the FIB header, then re-copy to get data as well.
2515 if ((error
= copyin(ufib
, cm
->cm_fib
,
2516 sizeof(struct aac_fib_header
))) != 0)
2518 size
= cm
->cm_fib
->Header
.Size
+ sizeof(struct aac_fib_header
);
2519 if (size
> sizeof(struct aac_fib
)) {
2520 device_printf(sc
->aac_dev
, "incoming FIB oversized (%d > %d)\n",
2521 size
, sizeof(struct aac_fib
));
2522 size
= sizeof(struct aac_fib
);
2524 if ((error
= copyin(ufib
, cm
->cm_fib
, size
)) != 0)
2526 cm
->cm_fib
->Header
.Size
= size
;
2527 cm
->cm_timestamp
= time_second
;
2530 * Pass the FIB to the controller, wait for it to complete.
2532 if ((error
= aac_wait_command(cm
, 30)) != 0) { /* XXX user timeout? */
2533 kprintf("aac_wait_command return %d\n", error
);
2538 * Copy the FIB and data back out to the caller.
2540 size
= cm
->cm_fib
->Header
.Size
;
2541 if (size
> sizeof(struct aac_fib
)) {
2542 device_printf(sc
->aac_dev
, "outbound FIB oversized (%d > %d)\n",
2543 size
, sizeof(struct aac_fib
));
2544 size
= sizeof(struct aac_fib
);
2546 error
= copyout(cm
->cm_fib
, ufib
, size
);
2550 aac_release_command(cm
);
2556 * Handle an AIF sent to us by the controller; queue it for later reference.
2557 * If the queue fills up, then drop the older entries.
2560 aac_handle_aif(struct aac_softc
*sc
, struct aac_fib
*fib
)
2562 struct aac_aif_command
*aif
;
2563 struct aac_container
*co
, *co_next
;
2564 struct aac_mntinfo
*mi
;
2565 struct aac_mntinforesp
*mir
= NULL
;
2568 int count
= 0, added
= 0, i
= 0;
2572 aif
= (struct aac_aif_command
*)&fib
->data
[0];
2573 aac_print_aif(sc
, aif
);
2575 /* Is it an event that we should care about? */
2576 switch (aif
->command
) {
2577 case AifCmdEventNotify
:
2578 switch (aif
->data
.EN
.type
) {
2579 case AifEnAddContainer
:
2580 case AifEnDeleteContainer
:
2582 * A container was added or deleted, but the message
2583 * doesn't tell us anything else! Re-enumerate the
2584 * containers and sort things out.
2586 aac_alloc_sync_fib(sc
, &fib
, 0);
2587 mi
= (struct aac_mntinfo
*)&fib
->data
[0];
2590 * Ask the controller for its containers one at
2592 * XXX What if the controller's list changes
2593 * midway through this enumaration?
2594 * XXX This should be done async.
2596 bzero(mi
, sizeof(struct aac_mntinfo
));
2597 mi
->Command
= VM_NameServe
;
2598 mi
->MntType
= FT_FILESYS
;
2600 rsize
= sizeof(mir
);
2601 if (aac_sync_fib(sc
, ContainerCommand
, 0, fib
,
2602 sizeof(struct aac_mntinfo
))) {
2603 device_printf(sc
->aac_dev
,
2604 "Error probing container %d\n", i
);
2608 mir
= (struct aac_mntinforesp
*)&fib
->data
[0];
2609 /* XXX Need to check if count changed */
2610 count
= mir
->MntRespCount
;
2613 * Check the container against our list.
2614 * co->co_found was already set to 0 in a
2617 if ((mir
->Status
== ST_OK
) &&
2618 (mir
->MntTable
[0].VolType
!= CT_NONE
)) {
2621 &sc
->aac_container_tqh
,
2623 if (co
->co_mntobj
.ObjectId
==
2624 mir
->MntTable
[0].ObjectId
) {
2631 * If the container matched, continue
2640 * This is a new container. Do all the
2641 * appropriate things to set it up. */
2642 aac_add_container(sc
, mir
, 1);
2646 } while ((i
< count
) && (i
< AAC_MAX_CONTAINERS
));
2647 aac_release_sync_fib(sc
);
2650 * Go through our list of containers and see which ones
2651 * were not marked 'found'. Since the controller didn't
2652 * list them they must have been deleted. Do the
2653 * appropriate steps to destroy the device. Also reset
2654 * the co->co_found field.
2656 co
= TAILQ_FIRST(&sc
->aac_container_tqh
);
2657 while (co
!= NULL
) {
2658 if (co
->co_found
== 0) {
2659 device_delete_child(sc
->aac_dev
,
2661 co_next
= TAILQ_NEXT(co
, co_link
);
2662 AAC_LOCK_ACQUIRE(&sc
->
2663 aac_container_lock
);
2664 TAILQ_REMOVE(&sc
->aac_container_tqh
, co
,
2666 AAC_LOCK_RELEASE(&sc
->
2667 aac_container_lock
);
2672 co
= TAILQ_NEXT(co
, co_link
);
2676 /* Attach the newly created containers */
2678 bus_generic_attach(sc
->aac_dev
);
2690 /* Copy the AIF data to the AIF queue for ioctl retrieval */
2691 AAC_LOCK_ACQUIRE(&sc
->aac_aifq_lock
);
2692 next
= (sc
->aac_aifq_head
+ 1) % AAC_AIFQ_LENGTH
;
2693 if (next
!= sc
->aac_aifq_tail
) {
2694 bcopy(aif
, &sc
->aac_aifq
[next
], sizeof(struct aac_aif_command
));
2695 sc
->aac_aifq_head
= next
;
2697 /* On the off chance that someone is sleeping for an aif... */
2698 if (sc
->aac_state
& AAC_STATE_AIF_SLEEPER
)
2699 wakeup(sc
->aac_aifq
);
2700 /* token may have been lost */
2701 /* Wakeup any poll()ers */
2702 selwakeup(&sc
->rcv_select
);
2703 /* token may have been lost */
2705 AAC_LOCK_RELEASE(&sc
->aac_aifq_lock
);
2711 * Return the Revision of the driver to userspace and check to see if the
2712 * userspace app is possibly compatible. This is extremely bogus since
2713 * our driver doesn't follow Adaptec's versioning system. Cheat by just
2714 * returning what the card reported.
2717 aac_rev_check(struct aac_softc
*sc
, caddr_t udata
)
2719 struct aac_rev_check rev_check
;
2720 struct aac_rev_check_resp rev_check_resp
;
2726 * Copyin the revision struct from userspace
2728 if ((error
= copyin(udata
, (caddr_t
)&rev_check
,
2729 sizeof(struct aac_rev_check
))) != 0) {
2733 debug(2, "Userland revision= %d\n",
2734 rev_check
.callingRevision
.buildNumber
);
2737 * Doctor up the response struct.
2739 rev_check_resp
.possiblyCompatible
= 1;
2740 rev_check_resp
.adapterSWRevision
.external
.ul
=
2741 sc
->aac_revision
.external
.ul
;
2742 rev_check_resp
.adapterSWRevision
.buildNumber
=
2743 sc
->aac_revision
.buildNumber
;
2745 return(copyout((caddr_t
)&rev_check_resp
, udata
,
2746 sizeof(struct aac_rev_check_resp
)));
2750 * Pass the caller the next AIF in their queue
2753 aac_getnext_aif(struct aac_softc
*sc
, caddr_t arg
)
2755 struct get_adapter_fib_ioctl agf
;
2760 if ((error
= copyin(arg
, &agf
, sizeof(agf
))) == 0) {
2763 * Check the magic number that we gave the caller.
2765 if (agf
.AdapterFibContext
!= (int)sc
->aifthread
) {
2770 error
= aac_return_aif(sc
, agf
.AifFib
);
2772 if ((error
== EAGAIN
) && (agf
.Wait
)) {
2773 sc
->aac_state
|= AAC_STATE_AIF_SLEEPER
;
2774 while (error
== EAGAIN
) {
2775 error
= tsleep(sc
->aac_aifq
,
2776 PCATCH
, "aacaif", 0);
2778 error
= aac_return_aif(sc
,
2781 sc
->aac_state
&= ~AAC_STATE_AIF_SLEEPER
;
2790 * Hand the next AIF off the top of the queue out to userspace.
2792 * YYY token could be lost during copyout
2795 aac_return_aif(struct aac_softc
*sc
, caddr_t uptr
)
2801 AAC_LOCK_ACQUIRE(&sc
->aac_aifq_lock
);
2802 if (sc
->aac_aifq_tail
== sc
->aac_aifq_head
) {
2805 error
= copyout(&sc
->aac_aifq
[sc
->aac_aifq_tail
], uptr
,
2806 sizeof(struct aac_aif_command
));
2808 kprintf("aac_return_aif: copyout returned %d\n", error
);
2810 sc
->aac_aifq_tail
= (sc
->aac_aifq_tail
+ 1) %
2813 AAC_LOCK_RELEASE(&sc
->aac_aifq_lock
);
2818 * Give the userland some information about the container. The AAC arch
2819 * expects the driver to be a SCSI passthrough type driver, so it expects
2820 * the containers to have b:t:l numbers. Fake it.
2823 aac_query_disk(struct aac_softc
*sc
, caddr_t uptr
)
2825 struct aac_query_disk query_disk
;
2826 struct aac_container
*co
;
2827 struct aac_disk
*disk
;
2834 error
= copyin(uptr
, (caddr_t
)&query_disk
,
2835 sizeof(struct aac_query_disk
));
2839 id
= query_disk
.ContainerNumber
;
2843 AAC_LOCK_ACQUIRE(&sc
->aac_container_lock
);
2844 TAILQ_FOREACH(co
, &sc
->aac_container_tqh
, co_link
) {
2845 if (co
->co_mntobj
.ObjectId
== id
)
2850 query_disk
.Valid
= 0;
2851 query_disk
.Locked
= 0;
2852 query_disk
.Deleted
= 1; /* XXX is this right? */
2854 disk
= device_get_softc(co
->co_disk
);
2855 query_disk
.Valid
= 1;
2857 (disk
->ad_flags
& AAC_DISK_OPEN
) ? 1 : 0;
2858 query_disk
.Deleted
= 0;
2859 query_disk
.Bus
= device_get_unit(sc
->aac_dev
);
2860 query_disk
.Target
= disk
->unit
;
2862 query_disk
.UnMapped
= 0;
2863 bcopy(disk
->ad_dev_t
->si_name
,
2864 &query_disk
.diskDeviceName
[0], 10);
2866 AAC_LOCK_RELEASE(&sc
->aac_container_lock
);
2868 error
= copyout((caddr_t
)&query_disk
, uptr
,
2869 sizeof(struct aac_query_disk
));
2875 aac_get_bus_info(struct aac_softc
*sc
)
2877 struct aac_fib
*fib
;
2878 struct aac_ctcfg
*c_cmd
;
2879 struct aac_ctcfg_resp
*c_resp
;
2880 struct aac_vmioctl
*vmi
;
2881 struct aac_vmi_businf_resp
*vmi_resp
;
2882 struct aac_getbusinf businfo
;
2883 struct aac_cam_inf
*caminf
;
2885 int i
, found
, error
;
2887 aac_alloc_sync_fib(sc
, &fib
, 0);
2888 c_cmd
= (struct aac_ctcfg
*)&fib
->data
[0];
2889 bzero(c_cmd
, sizeof(struct aac_ctcfg
));
2891 c_cmd
->Command
= VM_ContainerConfig
;
2892 c_cmd
->cmd
= CT_GET_SCSI_METHOD
;
2895 error
= aac_sync_fib(sc
, ContainerCommand
, 0, fib
,
2896 sizeof(struct aac_ctcfg
));
2898 device_printf(sc
->aac_dev
, "Error %d sending "
2899 "VM_ContainerConfig command\n", error
);
2900 aac_release_sync_fib(sc
);
2904 c_resp
= (struct aac_ctcfg_resp
*)&fib
->data
[0];
2905 if (c_resp
->Status
!= ST_OK
) {
2906 device_printf(sc
->aac_dev
, "VM_ContainerConfig returned 0x%x\n",
2908 aac_release_sync_fib(sc
);
2912 sc
->scsi_method_id
= c_resp
->param
;
2914 vmi
= (struct aac_vmioctl
*)&fib
->data
[0];
2915 bzero(vmi
, sizeof(struct aac_vmioctl
));
2917 vmi
->Command
= VM_Ioctl
;
2918 vmi
->ObjType
= FT_DRIVE
;
2919 vmi
->MethId
= sc
->scsi_method_id
;
2921 vmi
->IoctlCmd
= GetBusInfo
;
2923 error
= aac_sync_fib(sc
, ContainerCommand
, 0, fib
,
2924 sizeof(struct aac_vmioctl
));
2926 device_printf(sc
->aac_dev
, "Error %d sending VMIoctl command\n",
2928 aac_release_sync_fib(sc
);
2932 vmi_resp
= (struct aac_vmi_businf_resp
*)&fib
->data
[0];
2933 if (vmi_resp
->Status
!= ST_OK
) {
2934 debug(1, "VM_Ioctl returned %d\n", vmi_resp
->Status
);
2935 aac_release_sync_fib(sc
);
2939 bcopy(&vmi_resp
->BusInf
, &businfo
, sizeof(struct aac_getbusinf
));
2940 aac_release_sync_fib(sc
);
2943 for (i
= 0; i
< businfo
.BusCount
; i
++) {
2944 if (businfo
.BusValid
[i
] != AAC_BUS_VALID
)
2947 MALLOC(caminf
, struct aac_cam_inf
*,
2948 sizeof(struct aac_cam_inf
), M_AACBUF
, M_INTWAIT
| M_ZERO
);
2950 child
= device_add_child(sc
->aac_dev
, "aacp", -1);
2951 if (child
== NULL
) {
2952 device_printf(sc
->aac_dev
, "device_add_child failed\n");
2956 caminf
->TargetsPerBus
= businfo
.TargetsPerBus
;
2957 caminf
->BusNumber
= i
;
2958 caminf
->InitiatorBusId
= businfo
.InitiatorBusId
[i
];
2959 caminf
->aac_sc
= sc
;
2961 device_set_ivars(child
, caminf
);
2962 device_set_desc(child
, "SCSI Passthrough Bus");
2968 bus_generic_attach(sc
->aac_dev
);