Lines Matching refs:sc
73 static void aac_add_container(struct aac_softc *sc,
75 static void aac_get_bus_info(struct aac_softc *sc);
79 static void aac_timeout(struct aac_softc *sc);
81 static int aac_bio_command(struct aac_softc *sc, struct aac_command **cmp);
84 static void aac_command_thread(struct aac_softc *sc);
91 static int aac_alloc_commands(struct aac_softc *sc);
92 static void aac_free_commands(struct aac_softc *sc);
96 static int aac_alloc(struct aac_softc *sc);
99 static int aac_check_firmware(struct aac_softc *sc);
100 static int aac_init(struct aac_softc *sc);
101 static int aac_sync_command(struct aac_softc *sc, u_int32_t command,
104 static int aac_setup_intr(struct aac_softc *sc);
105 static int aac_enqueue_fib(struct aac_softc *sc, int queue,
107 static int aac_dequeue_fib(struct aac_softc *sc, int queue,
109 static int aac_enqueue_response(struct aac_softc *sc, int queue,
113 static int aac_sa_get_fwstatus(struct aac_softc *sc);
114 static void aac_sa_qnotify(struct aac_softc *sc, int qbit);
115 static int aac_sa_get_istatus(struct aac_softc *sc);
116 static void aac_sa_clear_istatus(struct aac_softc *sc, int mask);
117 static void aac_sa_set_mailbox(struct aac_softc *sc, u_int32_t command,
120 static int aac_sa_get_mailbox(struct aac_softc *sc, int mb);
121 static void aac_sa_set_interrupts(struct aac_softc *sc, int enable);
135 static int aac_rx_get_fwstatus(struct aac_softc *sc);
136 static void aac_rx_qnotify(struct aac_softc *sc, int qbit);
137 static int aac_rx_get_istatus(struct aac_softc *sc);
138 static void aac_rx_clear_istatus(struct aac_softc *sc, int mask);
139 static void aac_rx_set_mailbox(struct aac_softc *sc, u_int32_t command,
142 static int aac_rx_get_mailbox(struct aac_softc *sc, int mb);
143 static void aac_rx_set_interrupts(struct aac_softc *sc, int enable);
144 static int aac_rx_send_command(struct aac_softc *sc, struct aac_command *cm);
145 static int aac_rx_get_outb_queue(struct aac_softc *sc);
146 static void aac_rx_set_outb_queue(struct aac_softc *sc, int index);
162 static int aac_rkt_get_fwstatus(struct aac_softc *sc);
163 static void aac_rkt_qnotify(struct aac_softc *sc, int qbit);
164 static int aac_rkt_get_istatus(struct aac_softc *sc);
165 static void aac_rkt_clear_istatus(struct aac_softc *sc, int mask);
166 static void aac_rkt_set_mailbox(struct aac_softc *sc, u_int32_t command,
169 static int aac_rkt_get_mailbox(struct aac_softc *sc, int mb);
170 static void aac_rkt_set_interrupts(struct aac_softc *sc, int enable);
171 static int aac_rkt_send_command(struct aac_softc *sc, struct aac_command *cm);
172 static int aac_rkt_get_outb_queue(struct aac_softc *sc);
173 static void aac_rkt_set_outb_queue(struct aac_softc *sc, int index);
189 static void aac_describe_controller(struct aac_softc *sc);
198 static int aac_ioctl_sendfib(struct aac_softc *sc, caddr_t ufib);
199 static int aac_ioctl_send_raw_srb(struct aac_softc *sc, caddr_t arg);
200 static void aac_handle_aif(struct aac_softc *sc,
202 static int aac_rev_check(struct aac_softc *sc, caddr_t udata);
203 static int aac_open_aif(struct aac_softc *sc, caddr_t arg);
204 static int aac_close_aif(struct aac_softc *sc, caddr_t arg);
205 static int aac_getnext_aif(struct aac_softc *sc, caddr_t arg);
206 static int aac_return_aif(struct aac_softc *sc,
208 static int aac_query_disk(struct aac_softc *sc, caddr_t uptr);
209 static int aac_get_pci_info(struct aac_softc *sc, caddr_t uptr);
210 static int aac_supported_features(struct aac_softc *sc, caddr_t uptr);
211 static void aac_ioctl_event(struct aac_softc *sc,
214 aac_get_container_info(struct aac_softc *sc, struct aac_fib *fib, int cid);
238 aac_attach(struct aac_softc *sc)
242 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
247 aac_initq_free(sc);
248 aac_initq_ready(sc);
249 aac_initq_busy(sc);
250 aac_initq_bio(sc);
255 TASK_INIT(&sc->aac_task_complete, 0, aac_complete, sc);
258 sc->aac_state |= AAC_STATE_SUSPEND;
263 if ((error = aac_check_firmware(sc)) != 0)
269 mtx_init(&sc->aac_aifq_lock, "AAC AIF lock", NULL, MTX_DEF);
270 mtx_init(&sc->aac_io_lock, "AAC I/O lock", NULL, MTX_DEF);
271 mtx_init(&sc->aac_container_lock, "AAC container lock", NULL, MTX_DEF);
272 TAILQ_INIT(&sc->aac_container_tqh);
273 TAILQ_INIT(&sc->aac_ev_cmfree);
276 callout_init_mtx(&sc->aac_daemontime, &sc->aac_io_lock, 0);
281 if ((error = aac_alloc(sc)) != 0)
283 if ((error = aac_init(sc)) != 0)
289 if ((error = aac_setup_intr(sc)) != 0)
295 aac_describe_controller(sc);
300 SYSCTL_ADD_INT(device_get_sysctl_ctx(sc->aac_dev),
301 SYSCTL_CHILDREN(device_get_sysctl_tree(sc->aac_dev)),
303 &sc->aac_revision.buildNumber, 0,
309 sc->aac_ich.ich_func = aac_startup;
310 sc->aac_ich.ich_arg = sc;
311 if (config_intrhook_establish(&sc->aac_ich) != 0) {
312 device_printf(sc->aac_dev,
320 unit = device_get_unit(sc->aac_dev);
321 sc->aac_dev_t = make_dev(&aac_cdevsw, unit, UID_ROOT, GID_OPERATOR,
323 (void)make_dev_alias(sc->aac_dev_t, "afa%d", unit);
324 (void)make_dev_alias(sc->aac_dev_t, "hpn%d", unit);
325 sc->aac_dev_t->si_drv1 = sc;
328 if (kproc_create((void(*)(void *))aac_command_thread, sc,
329 &sc->aifthread, 0, 0, "aac%daif", unit))
333 if ((sc->eh = EVENTHANDLER_REGISTER(shutdown_final, aac_shutdown,
334 sc->aac_dev, SHUTDOWN_PRI_DEFAULT)) == NULL)
335 device_printf(sc->aac_dev,
339 if ((sc->flags & AAC_FLAGS_ENABLE_CAM) != 0) {
340 TAILQ_INIT(&sc->aac_sim_tqh);
341 aac_get_bus_info(sc);
344 mtx_lock(&sc->aac_io_lock);
345 callout_reset(&sc->aac_daemontime, 60 * hz, aac_daemon, sc);
346 mtx_unlock(&sc->aac_io_lock);
355 struct aac_softc *sc;
358 sc = arg;
359 mtx_assert(&sc->aac_io_lock, MA_OWNED);
361 if (callout_pending(&sc->aac_daemontime) ||
362 callout_active(&sc->aac_daemontime) == 0)
365 aac_alloc_sync_fib(sc, &fib);
367 aac_sync_fib(sc, SendHostTime, 0, fib, sizeof(uint32_t));
368 aac_release_sync_fib(sc);
369 callout_schedule(&sc->aac_daemontime, 30 * 60 * hz);
373 aac_add_event(struct aac_softc *sc, struct aac_event *event)
378 TAILQ_INSERT_TAIL(&sc->aac_ev_cmfree, event, ev_links);
381 device_printf(sc->aac_dev, "aac_add event: unknown event %d\n",
391 aac_get_container_info(struct aac_softc *sc, struct aac_fib *fib, int cid)
397 mi->Command = (sc->flags & AAC_FLAGS_LBA_64BIT) ?
402 if (aac_sync_fib(sc, ContainerCommand, 0, fib,
404 device_printf(sc->aac_dev, "Error probing container %d\n", cid);
417 struct aac_softc *sc;
422 sc = (struct aac_softc *)arg;
423 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
425 mtx_lock(&sc->aac_io_lock);
426 aac_alloc_sync_fib(sc, &fib);
430 if ((mir = aac_get_container_info(sc, fib, i)) == NULL)
434 aac_add_container(sc, mir, 0);
438 aac_release_sync_fib(sc);
439 mtx_unlock(&sc->aac_io_lock);
442 sc->aac_state &= ~AAC_STATE_SUSPEND;
445 if (bus_generic_attach(sc->aac_dev))
446 device_printf(sc->aac_dev, "bus_generic_attach failed\n");
449 config_intrhook_disestablish(&sc->aac_ich);
452 AAC_UNMASK_INTERRUPTS(sc);
459 aac_add_container(struct aac_softc *sc, struct aac_mntinforesp *mir, int f)
473 fwprintf(sc, HBA_FLAGS_DBG_INIT_B, "id %x name '%.16s' size %u type %d",
478 if ((child = device_add_child(sc->aac_dev, "aacd", -1)) == NULL)
479 device_printf(sc->aac_dev, "device_add_child failed\n");
488 mtx_lock(&sc->aac_container_lock);
489 TAILQ_INSERT_TAIL(&sc->aac_container_tqh, co, co_link);
490 mtx_unlock(&sc->aac_container_lock);
495 * Allocate resources associated with (sc)
498 aac_alloc(struct aac_softc *sc)
501 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
506 if (bus_dma_tag_create(sc->aac_parent_dmat, /* parent */
508 (sc->flags & AAC_FLAGS_SG_64BIT) ?
513 sc->aac_max_sectors << 9, /* maxsize */
514 sc->aac_sg_tablesize, /* nsegments */
518 &sc->aac_io_lock, /* lockfuncarg */
519 &sc->aac_buffer_dmat)) {
520 device_printf(sc->aac_dev, "can't allocate buffer DMA tag\n");
527 if (bus_dma_tag_create(sc->aac_parent_dmat, /* parent */
529 (sc->flags & AAC_FLAGS_4GB_WINDOW) ?
534 sc->aac_max_fibs_alloc *
535 sc->aac_max_fib_size, /* maxsize */
537 sc->aac_max_fibs_alloc *
538 sc->aac_max_fib_size, /* maxsize */
541 &sc->aac_fib_dmat)) {
542 device_printf(sc->aac_dev, "can't allocate FIB DMA tag\n");
549 if (bus_dma_tag_create(sc->aac_parent_dmat, /* parent */
551 (sc->flags & AAC_FLAGS_4GB_WINDOW) ?
561 &sc->aac_common_dmat)) {
562 device_printf(sc->aac_dev,
566 if (bus_dmamem_alloc(sc->aac_common_dmat, (void **)&sc->aac_common,
567 BUS_DMA_NOWAIT, &sc->aac_common_dmamap)) {
568 device_printf(sc->aac_dev, "can't allocate common structure\n");
578 (void)bus_dmamap_load(sc->aac_common_dmat, sc->aac_common_dmamap,
579 sc->aac_common, 8192 + sizeof(*sc->aac_common),
580 aac_common_map, sc, 0);
582 if (sc->aac_common_busaddr < 8192) {
583 sc->aac_common = (struct aac_common *)
584 ((uint8_t *)sc->aac_common + 8192);
585 sc->aac_common_busaddr += 8192;
587 bzero(sc->aac_common, sizeof(*sc->aac_common));
590 TAILQ_INIT(&sc->aac_fibmap_tqh);
591 sc->aac_commands = malloc(sc->aac_max_fibs * sizeof(struct aac_command),
593 while (sc->total_fibs < sc->aac_max_fibs) {
594 if (aac_alloc_commands(sc) != 0)
597 if (sc->total_fibs == 0)
604 * Free all of the resources associated with (sc)
609 aac_free(struct aac_softc *sc)
612 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
615 if (sc->aac_dev_t != NULL)
616 destroy_dev(sc->aac_dev_t);
619 aac_free_commands(sc);
620 if (sc->aac_fib_dmat)
621 bus_dma_tag_destroy(sc->aac_fib_dmat);
623 free(sc->aac_commands, M_AACBUF);
626 if (sc->aac_common) {
627 bus_dmamap_unload(sc->aac_common_dmat, sc->aac_common_dmamap);
628 bus_dmamem_free(sc->aac_common_dmat, sc->aac_common,
629 sc->aac_common_dmamap);
631 if (sc->aac_common_dmat)
632 bus_dma_tag_destroy(sc->aac_common_dmat);
635 if (sc->aac_intr)
636 bus_teardown_intr(sc->aac_dev, sc->aac_irq, sc->aac_intr);
637 if (sc->aac_irq != NULL) {
638 bus_release_resource(sc->aac_dev, SYS_RES_IRQ,
639 rman_get_rid(sc->aac_irq), sc->aac_irq);
640 pci_release_msi(sc->aac_dev);
644 if (sc->aac_buffer_dmat)
645 bus_dma_tag_destroy(sc->aac_buffer_dmat);
648 if (sc->aac_parent_dmat)
649 bus_dma_tag_destroy(sc->aac_parent_dmat);
652 if (sc->aac_regs_res0 != NULL)
653 bus_release_resource(sc->aac_dev, SYS_RES_MEMORY,
654 rman_get_rid(sc->aac_regs_res0), sc->aac_regs_res0);
655 if (sc->aac_hwif == AAC_HWIF_NARK && sc->aac_regs_res1 != NULL)
656 bus_release_resource(sc->aac_dev, SYS_RES_MEMORY,
657 rman_get_rid(sc->aac_regs_res1), sc->aac_regs_res1);
666 struct aac_softc *sc;
671 sc = device_get_softc(dev);
672 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
674 callout_drain(&sc->aac_daemontime);
676 mtx_lock(&sc->aac_io_lock);
677 while (sc->aifflags & AAC_AIFFLAGS_RUNNING) {
678 sc->aifflags |= AAC_AIFFLAGS_EXIT;
679 wakeup(sc->aifthread);
680 msleep(sc->aac_dev, &sc->aac_io_lock, PUSER, "aacdch", 0);
682 mtx_unlock(&sc->aac_io_lock);
683 KASSERT((sc->aifflags & AAC_AIFFLAGS_RUNNING) == 0,
687 while ((co = TAILQ_FIRST(&sc->aac_container_tqh)) != NULL) {
691 TAILQ_REMOVE(&sc->aac_container_tqh, co, co_link);
696 while ((sim = TAILQ_FIRST(&sc->aac_sim_tqh)) != NULL) {
697 TAILQ_REMOVE(&sc->aac_sim_tqh, sim, sim_link);
707 EVENTHANDLER_DEREGISTER(shutdown_final, sc->eh);
709 aac_free(sc);
711 mtx_destroy(&sc->aac_aifq_lock);
712 mtx_destroy(&sc->aac_io_lock);
713 mtx_destroy(&sc->aac_container_lock);
729 struct aac_softc *sc;
733 sc = device_get_softc(dev);
734 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
736 sc->aac_state |= AAC_STATE_SUSPEND;
743 device_printf(sc->aac_dev, "shutting down controller...");
745 mtx_lock(&sc->aac_io_lock);
746 aac_alloc_sync_fib(sc, &fib);
752 if (aac_sync_fib(sc, ContainerCommand, 0, fib,
766 if (aac_sync_fib(sc, FsaHostShutdown, AAC_FIBSTATE_SHUTDOWN,
775 AAC_MASK_INTERRUPTS(sc);
776 aac_release_sync_fib(sc);
777 mtx_unlock(&sc->aac_io_lock);
788 struct aac_softc *sc;
790 sc = device_get_softc(dev);
792 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
793 sc->aac_state |= AAC_STATE_SUSPEND;
795 AAC_MASK_INTERRUPTS(sc);
805 struct aac_softc *sc;
807 sc = device_get_softc(dev);
809 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
810 sc->aac_state &= ~AAC_STATE_SUSPEND;
811 AAC_UNMASK_INTERRUPTS(sc);
821 struct aac_softc *sc;
827 sc = (struct aac_softc *)arg;
829 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
830 mtx_lock(&sc->aac_io_lock);
832 index = AAC_GET_OUTB_QUEUE(sc);
834 index = AAC_GET_OUTB_QUEUE(sc);
857 ((u_int32_t *)fib)[i] = AAC_MEM1_GETREG4(sc, index + i*4);
858 aac_handle_aif(sc, fib);
865 AAC_SET_OUTB_QUEUE(sc, index);
866 AAC_CLEAR_ISTATUS(sc, AAC_DB_RESPONSE_READY);
869 cm = sc->aac_commands + (index >> 2);
888 sc->flags &= ~AAC_QUEUE_FRZN;
892 if ((sc->flags & AAC_QUEUE_FRZN) == 0)
893 aac_startio(sc);
895 mtx_unlock(&sc->aac_io_lock);
904 struct aac_softc *sc;
907 sc = (struct aac_softc *)arg;
909 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
916 reason = AAC_GET_ISTATUS(sc);
917 AAC_CLEAR_ISTATUS(sc, reason);
921 taskqueue_enqueue(taskqueue_fast, &sc->aac_task_complete);
930 (sc->aac_common->ac_printf[0] == 0))
931 sc->aac_common->ac_printf[0] = 32;
940 wakeup(sc->aifthread);
953 aac_startio(struct aac_softc *sc)
958 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
965 if (sc->flags & AAC_QUEUE_FRZN)
972 cm = aac_dequeue_ready(sc);
979 aac_bio_command(sc, &cm);
997 sc->aac_buffer_dmat, cm->cm_datamap,
1001 error = bus_dmamap_load(sc->aac_buffer_dmat,
1005 fwprintf(sc, HBA_FLAGS_DBG_COMM_B, "freezing queue\n");
1006 sc->flags |= AAC_QUEUE_FRZN;
1019 aac_command_thread(struct aac_softc *sc)
1025 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
1027 mtx_lock(&sc->aac_io_lock);
1028 sc->aifflags = AAC_AIFFLAGS_RUNNING;
1030 while ((sc->aifflags & AAC_AIFFLAGS_EXIT) == 0) {
1033 if ((sc->aifflags & AAC_AIFFLAGS_PENDING) == 0)
1034 retval = msleep(sc->aifthread, &sc->aac_io_lock, PRIBIO,
1042 if ((sc->aifflags & AAC_AIFFLAGS_ALLOCFIBS) != 0) {
1043 mtx_unlock(&sc->aac_io_lock);
1044 aac_alloc_commands(sc);
1045 mtx_lock(&sc->aac_io_lock);
1046 sc->aifflags &= ~AAC_AIFFLAGS_ALLOCFIBS;
1047 aac_startio(sc);
1056 aac_timeout(sc);
1059 if (sc->aac_common->ac_printf[0] != 0)
1060 aac_print_printf(sc);
1063 if (sc->flags & AAC_FLAGS_NEW_COMM)
1066 if (aac_dequeue_fib(sc, AAC_HOST_NORM_CMD_QUEUE,
1070 AAC_PRINT_FIB(sc, fib);
1074 aac_handle_aif(sc, fib);
1077 device_printf(sc->aac_dev, "unknown command "
1103 aac_enqueue_response(sc,
1109 sc->aifflags &= ~AAC_AIFFLAGS_RUNNING;
1110 mtx_unlock(&sc->aac_io_lock);
1111 wakeup(sc->aac_dev);
1122 struct aac_softc *sc;
1127 sc = (struct aac_softc *)context;
1128 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
1130 mtx_lock(&sc->aac_io_lock);
1135 if (aac_dequeue_fib(sc, AAC_HOST_NORM_RESP_QUEUE, &fib_size,
1140 cm = sc->aac_commands + fib->Header.SenderData;
1142 AAC_PRINT_FIB(sc, fib);
1146 device_printf(sc->aac_dev,
1165 sc->flags &= ~AAC_QUEUE_FRZN;
1166 aac_startio(sc);
1168 mtx_unlock(&sc->aac_io_lock);
1178 struct aac_softc *sc;
1181 sc = ad->ad_controller;
1182 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
1185 aac_enqueue_bio(sc, bp);
1186 aac_startio(sc);
1193 aac_bio_command(struct aac_softc *sc, struct aac_command **cmp)
1200 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
1205 if (aac_alloc_command(sc, &cm)) /* get a command */
1207 if ((bp = aac_dequeue_bio(sc)) == NULL)
1233 if (sc->flags & AAC_FLAGS_RAW_IO) {
1251 } else if ((sc->flags & AAC_FLAGS_SG_64BIT) == 0) {
1309 aac_enqueue_bio(sc, bp);
1360 struct aac_softc *sc;
1363 sc = cm->cm_sc;
1364 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
1368 aac_startio(sc);
1369 error = msleep(cm, &sc->aac_io_lock, PRIBIO, "aacwait", 0);
1381 aac_alloc_command(struct aac_softc *sc, struct aac_command **cmp)
1385 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
1387 if ((cm = aac_dequeue_free(sc)) == NULL) {
1388 if (sc->total_fibs < sc->aac_max_fibs) {
1389 mtx_lock(&sc->aac_io_lock);
1390 sc->aifflags |= AAC_AIFFLAGS_ALLOCFIBS;
1391 mtx_unlock(&sc->aac_io_lock);
1392 wakeup(sc->aifthread);
1408 struct aac_softc *sc;
1410 sc = cm->cm_sc;
1411 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
1435 if ((event = TAILQ_FIRST(&sc->aac_ev_cmfree)) != NULL) {
1436 TAILQ_REMOVE(&sc->aac_ev_cmfree, event, ev_links);
1437 event->ev_callback(sc, event, event->ev_arg);
1458 aac_alloc_commands(struct aac_softc *sc)
1465 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
1467 if (sc->total_fibs + sc->aac_max_fibs_alloc > sc->aac_max_fibs)
1475 if (bus_dmamem_alloc(sc->aac_fib_dmat, (void **)&fm->aac_fibs,
1477 device_printf(sc->aac_dev,
1484 (void)bus_dmamap_load(sc->aac_fib_dmat, fm->aac_fibmap, fm->aac_fibs,
1485 sc->aac_max_fibs_alloc * sc->aac_max_fib_size,
1489 bzero(fm->aac_fibs, sc->aac_max_fibs_alloc * sc->aac_max_fib_size);
1490 for (i = 0; i < sc->aac_max_fibs_alloc; i++) {
1491 cm = sc->aac_commands + sc->total_fibs;
1493 cm->cm_sc = sc;
1495 ((u_int8_t *)fm->aac_fibs + i*sc->aac_max_fib_size);
1496 cm->cm_fibphys = fibphys + i*sc->aac_max_fib_size;
1497 cm->cm_index = sc->total_fibs;
1499 if ((error = bus_dmamap_create(sc->aac_buffer_dmat, 0,
1502 mtx_lock(&sc->aac_io_lock);
1504 sc->total_fibs++;
1505 mtx_unlock(&sc->aac_io_lock);
1509 mtx_lock(&sc->aac_io_lock);
1510 TAILQ_INSERT_TAIL(&sc->aac_fibmap_tqh, fm, fm_link);
1511 fwprintf(sc, HBA_FLAGS_DBG_COMM_B, "total_fibs= %d\n", sc->total_fibs);
1512 mtx_unlock(&sc->aac_io_lock);
1516 bus_dmamap_unload(sc->aac_fib_dmat, fm->aac_fibmap);
1517 bus_dmamem_free(sc->aac_fib_dmat, fm->aac_fibs, fm->aac_fibmap);
1526 aac_free_commands(struct aac_softc *sc)
1532 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
1534 while ((fm = TAILQ_FIRST(&sc->aac_fibmap_tqh)) != NULL) {
1536 TAILQ_REMOVE(&sc->aac_fibmap_tqh, fm, fm_link);
1541 for (i = 0; i < sc->aac_max_fibs_alloc && sc->total_fibs--; i++) {
1543 bus_dmamap_destroy(sc->aac_buffer_dmat, cm->cm_datamap);
1545 bus_dmamap_unload(sc->aac_fib_dmat, fm->aac_fibmap);
1546 bus_dmamem_free(sc->aac_fib_dmat, fm->aac_fibs, fm->aac_fibmap);
1557 struct aac_softc *sc;
1563 sc = cm->cm_sc;
1565 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
1617 bus_dmamap_sync(sc->aac_buffer_dmat, cm->cm_datamap,
1620 bus_dmamap_sync(sc->aac_buffer_dmat, cm->cm_datamap,
1624 if (sc->flags & AAC_FLAGS_NEW_COMM) {
1626 while (AAC_SEND_COMMAND(sc, cm) != 0) {
1629 sc->flags |= AAC_QUEUE_FRZN;
1636 if (aac_enqueue_fib(sc, cm->cm_queue, cm) == EBUSY) {
1638 sc->flags |= AAC_QUEUE_FRZN;
1650 struct aac_softc *sc;
1652 sc = cm->cm_sc;
1653 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
1660 bus_dmamap_sync(sc->aac_buffer_dmat, cm->cm_datamap,
1663 bus_dmamap_sync(sc->aac_buffer_dmat, cm->cm_datamap,
1666 bus_dmamap_unload(sc->aac_buffer_dmat, cm->cm_datamap);
1681 struct aac_softc *sc;
1683 sc = (struct aac_softc *)arg;
1684 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
1686 sc->aac_common_busaddr = segs[0].ds_addr;
1690 aac_check_firmware(struct aac_softc *sc)
1696 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
1702 code = AAC_GET_FWSTATUS(sc);
1704 device_printf(sc->aac_dev, "FATAL: selftest failed\n");
1708 device_printf(sc->aac_dev,
1713 device_printf(sc->aac_dev,
1724 if (sc->flags & AAC_FLAGS_PERC2QC) {
1725 if (aac_sync_command(sc, AAC_MONKER_GETKERNVER, 0, 0, 0, 0,
1727 device_printf(sc->aac_dev,
1733 major = (AAC_GET_MAILBOX(sc, 1) & 0xff) - 0x30;
1734 minor = (AAC_GET_MAILBOX(sc, 2) & 0xff) - 0x30;
1736 device_printf(sc->aac_dev,
1748 if (aac_sync_command(sc, AAC_MONKER_GETINFO, 0, 0, 0, 0, &status)) {
1750 device_printf(sc->aac_dev,
1755 options = AAC_GET_MAILBOX(sc, 1);
1756 atu_size = AAC_GET_MAILBOX(sc, 2);
1757 sc->supported_options = options;
1760 (sc->flags & AAC_FLAGS_NO4GB) == 0)
1761 sc->flags |= AAC_FLAGS_4GB_WINDOW;
1763 sc->flags |= AAC_FLAGS_ENABLE_CAM;
1766 device_printf(sc->aac_dev,
1768 sc->flags |= AAC_FLAGS_SG_64BIT;
1771 && sc->aac_if->aif_send_command)
1772 sc->flags |= AAC_FLAGS_NEW_COMM;
1774 sc->flags |= AAC_FLAGS_ARRAY_64BIT;
1778 sc->aac_max_fibs = (sc->flags & AAC_FLAGS_256FIBS ? 256:512);
1781 if ((sc->flags & AAC_FLAGS_NEW_COMM) &&
1782 atu_size > rman_get_size(sc->aac_regs_res1)) {
1783 rid = rman_get_rid(sc->aac_regs_res1);
1784 bus_release_resource(sc->aac_dev, SYS_RES_MEMORY, rid,
1785 sc->aac_regs_res1);
1786 sc->aac_regs_res1 = bus_alloc_resource_anywhere(sc->aac_dev,
1788 if (sc->aac_regs_res1 == NULL) {
1789 sc->aac_regs_res1 = bus_alloc_resource_any(
1790 sc->aac_dev, SYS_RES_MEMORY, &rid, RF_ACTIVE);
1791 if (sc->aac_regs_res1 == NULL) {
1792 device_printf(sc->aac_dev,
1796 sc->flags &= ~AAC_FLAGS_NEW_COMM;
1798 sc->aac_btag1 = rman_get_bustag(sc->aac_regs_res1);
1799 sc->aac_bhandle1 = rman_get_bushandle(sc->aac_regs_res1);
1801 if (sc->aac_hwif == AAC_HWIF_NARK) {
1802 sc->aac_regs_res0 = sc->aac_regs_res1;
1803 sc->aac_btag0 = sc->aac_btag1;
1804 sc->aac_bhandle0 = sc->aac_bhandle1;
1809 sc->aac_max_fib_size = sizeof(struct aac_fib);
1810 sc->aac_max_sectors = 128; /* 64KB */
1811 if (sc->flags & AAC_FLAGS_SG_64BIT)
1812 sc->aac_sg_tablesize = (AAC_FIB_DATASIZE
1816 sc->aac_sg_tablesize = (AAC_FIB_DATASIZE
1820 if (!aac_sync_command(sc, AAC_MONKER_GETCOMMPREF, 0, 0, 0, 0, NULL)) {
1821 options = AAC_GET_MAILBOX(sc, 1);
1822 sc->aac_max_fib_size = (options & 0xFFFF);
1823 sc->aac_max_sectors = (options >> 16) << 1;
1824 options = AAC_GET_MAILBOX(sc, 2);
1825 sc->aac_sg_tablesize = (options >> 16);
1826 options = AAC_GET_MAILBOX(sc, 3);
1827 sc->aac_max_fibs = (options & 0xFFFF);
1829 if (sc->aac_max_fib_size > PAGE_SIZE)
1830 sc->aac_max_fib_size = PAGE_SIZE;
1831 sc->aac_max_fibs_alloc = PAGE_SIZE / sc->aac_max_fib_size;
1833 if (sc->aac_max_fib_size > sizeof(struct aac_fib)) {
1834 sc->flags |= AAC_FLAGS_RAW_IO;
1835 device_printf(sc->aac_dev, "Enable Raw I/O\n");
1837 if ((sc->flags & AAC_FLAGS_RAW_IO) &&
1838 (sc->flags & AAC_FLAGS_ARRAY_64BIT)) {
1839 sc->flags |= AAC_FLAGS_LBA_64BIT;
1840 device_printf(sc->aac_dev, "Enable 64-bit array\n");
1847 aac_init(struct aac_softc *sc)
1853 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
1859 ip = &sc->aac_common->ac_init;
1861 if (sc->aac_max_fib_size > sizeof(struct aac_fib)) {
1863 sc->flags |= AAC_FLAGS_RAW_IO;
1867 ip->AdapterFibsPhysicalAddress = sc->aac_common_busaddr +
1873 ip->PrintfBufferAddress = sc->aac_common_busaddr +
1884 if (sc->flags & AAC_FLAGS_BROKEN_MEMMAP) {
1891 if (sc->flags & AAC_FLAGS_NEW_COMM) {
1893 device_printf(sc->aac_dev, "New comm. interface enabled\n");
1896 ip->MaxIoCommands = sc->aac_max_fibs;
1897 ip->MaxIoSize = sc->aac_max_sectors << 9;
1898 ip->MaxFibSize = sc->aac_max_fib_size;
1918 sc->aac_queues =
1919 (struct aac_queue_table *)((uintptr_t)sc->aac_common + qoffset);
1920 ip->CommHeaderAddress = sc->aac_common_busaddr + qoffset;
1922 sc->aac_queues->qt_qindex[AAC_HOST_NORM_CMD_QUEUE][AAC_PRODUCER_INDEX] =
1924 sc->aac_queues->qt_qindex[AAC_HOST_NORM_CMD_QUEUE][AAC_CONSUMER_INDEX] =
1926 sc->aac_queues->qt_qindex[AAC_HOST_HIGH_CMD_QUEUE][AAC_PRODUCER_INDEX] =
1928 sc->aac_queues->qt_qindex[AAC_HOST_HIGH_CMD_QUEUE][AAC_CONSUMER_INDEX] =
1930 sc->aac_queues->qt_qindex[AAC_ADAP_NORM_CMD_QUEUE][AAC_PRODUCER_INDEX] =
1932 sc->aac_queues->qt_qindex[AAC_ADAP_NORM_CMD_QUEUE][AAC_CONSUMER_INDEX] =
1934 sc->aac_queues->qt_qindex[AAC_ADAP_HIGH_CMD_QUEUE][AAC_PRODUCER_INDEX] =
1936 sc->aac_queues->qt_qindex[AAC_ADAP_HIGH_CMD_QUEUE][AAC_CONSUMER_INDEX] =
1938 sc->aac_queues->qt_qindex[AAC_HOST_NORM_RESP_QUEUE][AAC_PRODUCER_INDEX]=
1940 sc->aac_queues->qt_qindex[AAC_HOST_NORM_RESP_QUEUE][AAC_CONSUMER_INDEX]=
1942 sc->aac_queues->qt_qindex[AAC_HOST_HIGH_RESP_QUEUE][AAC_PRODUCER_INDEX]=
1944 sc->aac_queues->qt_qindex[AAC_HOST_HIGH_RESP_QUEUE][AAC_CONSUMER_INDEX]=
1946 sc->aac_queues->qt_qindex[AAC_ADAP_NORM_RESP_QUEUE][AAC_PRODUCER_INDEX]=
1948 sc->aac_queues->qt_qindex[AAC_ADAP_NORM_RESP_QUEUE][AAC_CONSUMER_INDEX]=
1950 sc->aac_queues->qt_qindex[AAC_ADAP_HIGH_RESP_QUEUE][AAC_PRODUCER_INDEX]=
1952 sc->aac_queues->qt_qindex[AAC_ADAP_HIGH_RESP_QUEUE][AAC_CONSUMER_INDEX]=
1954 sc->aac_qentries[AAC_HOST_NORM_CMD_QUEUE] =
1955 &sc->aac_queues->qt_HostNormCmdQueue[0];
1956 sc->aac_qentries[AAC_HOST_HIGH_CMD_QUEUE] =
1957 &sc->aac_queues->qt_HostHighCmdQueue[0];
1958 sc->aac_qentries[AAC_ADAP_NORM_CMD_QUEUE] =
1959 &sc->aac_queues->qt_AdapNormCmdQueue[0];
1960 sc->aac_qentries[AAC_ADAP_HIGH_CMD_QUEUE] =
1961 &sc->aac_queues->qt_AdapHighCmdQueue[0];
1962 sc->aac_qentries[AAC_HOST_NORM_RESP_QUEUE] =
1963 &sc->aac_queues->qt_HostNormRespQueue[0];
1964 sc->aac_qentries[AAC_HOST_HIGH_RESP_QUEUE] =
1965 &sc->aac_queues->qt_HostHighRespQueue[0];
1966 sc->aac_qentries[AAC_ADAP_NORM_RESP_QUEUE] =
1967 &sc->aac_queues->qt_AdapNormRespQueue[0];
1968 sc->aac_qentries[AAC_ADAP_HIGH_RESP_QUEUE] =
1969 &sc->aac_queues->qt_AdapHighRespQueue[0];
1974 switch (sc->aac_hwif) {
1976 AAC_MEM0_SETREG4(sc, AAC_RX_ODBR, ~0);
1979 AAC_MEM0_SETREG4(sc, AAC_RKT_ODBR, ~0);
1988 if (aac_sync_command(sc, AAC_MONKER_INITSTRUCT,
1989 sc->aac_common_busaddr +
1992 device_printf(sc->aac_dev,
2004 aac_setup_intr(struct aac_softc *sc)
2007 if (sc->flags & AAC_FLAGS_NEW_COMM) {
2008 if (bus_setup_intr(sc->aac_dev, sc->aac_irq,
2010 aac_new_intr, sc, &sc->aac_intr)) {
2011 device_printf(sc->aac_dev, "can't set up interrupt\n");
2015 if (bus_setup_intr(sc->aac_dev, sc->aac_irq,
2017 sc, &sc->aac_intr)) {
2018 device_printf(sc->aac_dev,
2031 aac_sync_command(struct aac_softc *sc, u_int32_t command,
2038 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2041 AAC_SET_MAILBOX(sc, command, arg0, arg1, arg2, arg3);
2044 AAC_CLEAR_ISTATUS(sc, AAC_DB_SYNC_COMMAND);
2047 AAC_QNOTIFY(sc, AAC_DB_SYNC_COMMAND);
2053 fwprintf(sc, HBA_FLAGS_DBG_ERROR_B, "timed out");
2056 } while (!(AAC_GET_ISTATUS(sc) & AAC_DB_SYNC_COMMAND));
2059 AAC_CLEAR_ISTATUS(sc, AAC_DB_SYNC_COMMAND);
2062 status = AAC_GET_MAILBOX(sc, 0);
2072 aac_sync_fib(struct aac_softc *sc, u_int32_t command, u_int32_t xferstate,
2075 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2076 mtx_assert(&sc->aac_io_lock, MA_OWNED);
2093 fib->Header.ReceiverFibAddress = sc->aac_common_busaddr +
2100 if (aac_sync_command(sc, AAC_MONKER_SYNCFIB,
2102 fwprintf(sc, HBA_FLAGS_DBG_ERROR_B, "IO error");
2139 aac_enqueue_fib(struct aac_softc *sc, int queue, struct aac_command *cm)
2146 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2152 pi = sc->aac_queues->qt_qindex[queue][AAC_PRODUCER_INDEX];
2153 ci = sc->aac_queues->qt_qindex[queue][AAC_CONSUMER_INDEX];
2172 (sc->aac_qentries[queue] + pi)->aq_fib_size = fib_size;
2173 (sc->aac_qentries[queue] + pi)->aq_fib_addr = fib_addr;
2176 sc->aac_queues->qt_qindex[queue][AAC_PRODUCER_INDEX] = pi + 1;
2180 AAC_QNOTIFY(sc, aac_qinfo[queue].notify);
2193 aac_dequeue_fib(struct aac_softc *sc, int queue, u_int32_t *fib_size,
2201 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2204 pi = sc->aac_queues->qt_qindex[queue][AAC_PRODUCER_INDEX];
2205 ci = sc->aac_queues->qt_qindex[queue][AAC_CONSUMER_INDEX];
2226 *fib_size = (sc->aac_qentries[queue] + ci)->aq_fib_size;
2237 fib_index = (sc->aac_qentries[queue] + ci)->aq_fib_addr /
2239 *fib_addr = &sc->aac_common->ac_fibs[fib_index];
2254 fib_index = (sc->aac_qentries[queue] + ci)->aq_fib_addr;
2255 cm = sc->aac_commands + (fib_index >> 2);
2274 sc->aac_queues->qt_qindex[queue][AAC_CONSUMER_INDEX] = ci + 1;
2278 AAC_QNOTIFY(sc, aac_qinfo[queue].notify);
2289 aac_enqueue_response(struct aac_softc *sc, int queue, struct aac_fib *fib)
2296 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2304 pi = sc->aac_queues->qt_qindex[queue][AAC_PRODUCER_INDEX];
2305 ci = sc->aac_queues->qt_qindex[queue][AAC_CONSUMER_INDEX];
2318 (sc->aac_qentries[queue] + pi)->aq_fib_size = fib_size;
2319 (sc->aac_qentries[queue] + pi)->aq_fib_addr = fib_addr;
2322 sc->aac_queues->qt_qindex[queue][AAC_PRODUCER_INDEX] = pi + 1;
2326 AAC_QNOTIFY(sc, aac_qinfo[queue].notify);
2339 aac_timeout(struct aac_softc *sc)
2351 TAILQ_FOREACH(cm, &sc->aac_busy, cm_link) {
2355 device_printf(sc->aac_dev,
2359 AAC_PRINT_FIB(sc, cm->cm_fib);
2365 code = AAC_GET_FWSTATUS(sc);
2367 device_printf(sc->aac_dev, "WARNING! Controller is no "
2381 aac_sa_get_fwstatus(struct aac_softc *sc)
2383 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2385 return(AAC_MEM0_GETREG4(sc, AAC_SA_FWSTATUS));
2389 aac_rx_get_fwstatus(struct aac_softc *sc)
2391 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2393 return(AAC_MEM0_GETREG4(sc, sc->flags & AAC_FLAGS_NEW_COMM ?
2398 aac_rkt_get_fwstatus(struct aac_softc *sc)
2400 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2402 return(AAC_MEM0_GETREG4(sc, sc->flags & AAC_FLAGS_NEW_COMM ?
2411 aac_sa_qnotify(struct aac_softc *sc, int qbit)
2413 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2415 AAC_MEM0_SETREG2(sc, AAC_SA_DOORBELL1_SET, qbit);
2419 aac_rx_qnotify(struct aac_softc *sc, int qbit)
2421 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2423 AAC_MEM0_SETREG4(sc, AAC_RX_IDBR, qbit);
2427 aac_rkt_qnotify(struct aac_softc *sc, int qbit)
2429 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2431 AAC_MEM0_SETREG4(sc, AAC_RKT_IDBR, qbit);
2438 aac_sa_get_istatus(struct aac_softc *sc)
2440 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2442 return(AAC_MEM0_GETREG2(sc, AAC_SA_DOORBELL0));
2446 aac_rx_get_istatus(struct aac_softc *sc)
2448 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2450 return(AAC_MEM0_GETREG4(sc, AAC_RX_ODBR));
2454 aac_rkt_get_istatus(struct aac_softc *sc)
2456 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2458 return(AAC_MEM0_GETREG4(sc, AAC_RKT_ODBR));
2465 aac_sa_clear_istatus(struct aac_softc *sc, int mask)
2467 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2469 AAC_MEM0_SETREG2(sc, AAC_SA_DOORBELL0_CLEAR, mask);
2473 aac_rx_clear_istatus(struct aac_softc *sc, int mask)
2475 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2477 AAC_MEM0_SETREG4(sc, AAC_RX_ODBR, mask);
2481 aac_rkt_clear_istatus(struct aac_softc *sc, int mask)
2483 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2485 AAC_MEM0_SETREG4(sc, AAC_RKT_ODBR, mask);
2492 aac_sa_set_mailbox(struct aac_softc *sc, u_int32_t command,
2495 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2497 AAC_MEM1_SETREG4(sc, AAC_SA_MAILBOX, command);
2498 AAC_MEM1_SETREG4(sc, AAC_SA_MAILBOX + 4, arg0);
2499 AAC_MEM1_SETREG4(sc, AAC_SA_MAILBOX + 8, arg1);
2500 AAC_MEM1_SETREG4(sc, AAC_SA_MAILBOX + 12, arg2);
2501 AAC_MEM1_SETREG4(sc, AAC_SA_MAILBOX + 16, arg3);
2505 aac_rx_set_mailbox(struct aac_softc *sc, u_int32_t command,
2508 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2510 AAC_MEM1_SETREG4(sc, AAC_RX_MAILBOX, command);
2511 AAC_MEM1_SETREG4(sc, AAC_RX_MAILBOX + 4, arg0);
2512 AAC_MEM1_SETREG4(sc, AAC_RX_MAILBOX + 8, arg1);
2513 AAC_MEM1_SETREG4(sc, AAC_RX_MAILBOX + 12, arg2);
2514 AAC_MEM1_SETREG4(sc, AAC_RX_MAILBOX + 16, arg3);
2518 aac_rkt_set_mailbox(struct aac_softc *sc, u_int32_t command, u_int32_t arg0,
2521 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2523 AAC_MEM1_SETREG4(sc, AAC_RKT_MAILBOX, command);
2524 AAC_MEM1_SETREG4(sc, AAC_RKT_MAILBOX + 4, arg0);
2525 AAC_MEM1_SETREG4(sc, AAC_RKT_MAILBOX + 8, arg1);
2526 AAC_MEM1_SETREG4(sc, AAC_RKT_MAILBOX + 12, arg2);
2527 AAC_MEM1_SETREG4(sc, AAC_RKT_MAILBOX + 16, arg3);
2534 aac_sa_get_mailbox(struct aac_softc *sc, int mb)
2536 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2538 return(AAC_MEM1_GETREG4(sc, AAC_SA_MAILBOX + (mb * 4)));
2542 aac_rx_get_mailbox(struct aac_softc *sc, int mb)
2544 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2546 return(AAC_MEM1_GETREG4(sc, AAC_RX_MAILBOX + (mb * 4)));
2550 aac_rkt_get_mailbox(struct aac_softc *sc, int mb)
2552 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2554 return(AAC_MEM1_GETREG4(sc, AAC_RKT_MAILBOX + (mb * 4)));
2561 aac_sa_set_interrupts(struct aac_softc *sc, int enable)
2563 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "%sable interrupts", enable ? "en" : "dis");
2566 AAC_MEM0_SETREG2((sc), AAC_SA_MASK0_CLEAR, AAC_DB_INTERRUPTS);
2568 AAC_MEM0_SETREG2((sc), AAC_SA_MASK0_SET, ~0);
2573 aac_rx_set_interrupts(struct aac_softc *sc, int enable)
2575 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "%sable interrupts", enable ? "en" : "dis");
2578 if (sc->flags & AAC_FLAGS_NEW_COMM)
2579 AAC_MEM0_SETREG4(sc, AAC_RX_OIMR, ~AAC_DB_INT_NEW_COMM);
2581 AAC_MEM0_SETREG4(sc, AAC_RX_OIMR, ~AAC_DB_INTERRUPTS);
2583 AAC_MEM0_SETREG4(sc, AAC_RX_OIMR, ~0);
2588 aac_rkt_set_interrupts(struct aac_softc *sc, int enable)
2590 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "%sable interrupts", enable ? "en" : "dis");
2593 if (sc->flags & AAC_FLAGS_NEW_COMM)
2594 AAC_MEM0_SETREG4(sc, AAC_RKT_OIMR, ~AAC_DB_INT_NEW_COMM);
2596 AAC_MEM0_SETREG4(sc, AAC_RKT_OIMR, ~AAC_DB_INTERRUPTS);
2598 AAC_MEM0_SETREG4(sc, AAC_RKT_OIMR, ~0);
2606 aac_rx_send_command(struct aac_softc *sc, struct aac_command *cm)
2610 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "send command (new comm.)");
2612 index = AAC_MEM0_GETREG4(sc, AAC_RX_IQUE);
2614 index = AAC_MEM0_GETREG4(sc, AAC_RX_IQUE);
2619 AAC_MEM1_SETREG4(sc, device, (u_int32_t)(cm->cm_fibphys & 0xffffffffUL));
2621 AAC_MEM1_SETREG4(sc, device, (u_int32_t)(cm->cm_fibphys >> 32));
2623 AAC_MEM1_SETREG4(sc, device, cm->cm_fib->Header.Size);
2624 AAC_MEM0_SETREG4(sc, AAC_RX_IQUE, index);
2629 aac_rkt_send_command(struct aac_softc *sc, struct aac_command *cm)
2633 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "send command (new comm.)");
2635 index = AAC_MEM0_GETREG4(sc, AAC_RKT_IQUE);
2637 index = AAC_MEM0_GETREG4(sc, AAC_RKT_IQUE);
2642 AAC_MEM1_SETREG4(sc, device, (u_int32_t)(cm->cm_fibphys & 0xffffffffUL));
2644 AAC_MEM1_SETREG4(sc, device, (u_int32_t)(cm->cm_fibphys >> 32));
2646 AAC_MEM1_SETREG4(sc, device, cm->cm_fib->Header.Size);
2647 AAC_MEM0_SETREG4(sc, AAC_RKT_IQUE, index);
2655 aac_rx_get_outb_queue(struct aac_softc *sc)
2657 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2659 return(AAC_MEM0_GETREG4(sc, AAC_RX_OQUE));
2663 aac_rkt_get_outb_queue(struct aac_softc *sc)
2665 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2667 return(AAC_MEM0_GETREG4(sc, AAC_RKT_OQUE));
2671 aac_rx_set_outb_queue(struct aac_softc *sc, int index)
2673 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2675 AAC_MEM0_SETREG4(sc, AAC_RX_OQUE, index);
2679 aac_rkt_set_outb_queue(struct aac_softc *sc, int index)
2681 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2683 AAC_MEM0_SETREG4(sc, AAC_RKT_OQUE, index);
2694 aac_describe_controller(struct aac_softc *sc)
2700 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2702 mtx_lock(&sc->aac_io_lock);
2703 aac_alloc_sync_fib(sc, &fib);
2706 if (aac_sync_fib(sc, RequestAdapterInfo, 0, fib, 1)) {
2707 device_printf(sc->aac_dev, "RequestAdapterInfo failed\n");
2708 aac_release_sync_fib(sc);
2709 mtx_unlock(&sc->aac_io_lock);
2715 sc->aac_revision = info->KernelRevision;
2718 device_printf(sc->aac_dev, "%s %dMHz, %dMB memory "
2727 device_printf(sc->aac_dev,
2735 device_printf(sc->aac_dev, "Supported Options=%b\n",
2736 sc->supported_options,
2759 if (sc->supported_options & AAC_SUPPORTED_SUPPLEMENT_ADAPTER_INFO) {
2761 if (aac_sync_fib(sc, RequestSupplementAdapterInfo, 0, fib, 1))
2762 device_printf(sc->aac_dev,
2768 device_printf(sc->aac_dev, "%s, aac driver %d.%d.%d-%d\n",
2773 aac_release_sync_fib(sc);
2774 mtx_unlock(&sc->aac_io_lock);
2799 struct aac_softc *sc;
2801 sc = dev->si_drv1;
2802 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2803 device_busy(sc->aac_dev);
2804 devfs_set_cdevpriv(sc, aac_cdevpriv_dtor);
2813 struct aac_softc *sc;
2817 sc = dev->si_drv1;
2818 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2827 bcopy(&sc->aac_qstat[as->as_item], &as->as_qstat,
2841 fwprintf(sc, HBA_FLAGS_DBG_IOCTL_COMMANDS_B, "FSACTL_SENDFIB");
2842 error = aac_ioctl_sendfib(sc, arg);
2847 fwprintf(sc, HBA_FLAGS_DBG_IOCTL_COMMANDS_B, "FSACTL_SEND_RAW_SRB");
2848 error = aac_ioctl_send_raw_srb(sc, arg);
2852 fwprintf(sc, HBA_FLAGS_DBG_IOCTL_COMMANDS_B, "FSACTL_AIF_THREAD");
2858 fwprintf(sc, HBA_FLAGS_DBG_IOCTL_COMMANDS_B, "FSACTL_OPEN_GET_ADAPTER_FIB");
2859 error = aac_open_aif(sc, arg);
2864 fwprintf(sc, HBA_FLAGS_DBG_IOCTL_COMMANDS_B, "FSACTL_GET_NEXT_ADAPTER_FIB");
2865 error = aac_getnext_aif(sc, arg);
2870 fwprintf(sc, HBA_FLAGS_DBG_IOCTL_COMMANDS_B, "FSACTL_CLOSE_GET_ADAPTER_FIB");
2871 error = aac_close_aif(sc, arg);
2876 fwprintf(sc, HBA_FLAGS_DBG_IOCTL_COMMANDS_B, "FSACTL_MINIPORT_REV_CHECK");
2877 error = aac_rev_check(sc, arg);
2882 fwprintf(sc, HBA_FLAGS_DBG_IOCTL_COMMANDS_B, "FSACTL_QUERY_DISK");
2883 error = aac_query_disk(sc, arg);
2897 fwprintf(sc, HBA_FLAGS_DBG_IOCTL_COMMANDS_B, "FSACTL_GET_PCI_INFO");
2898 error = aac_get_pci_info(sc, arg);
2903 fwprintf(sc, HBA_FLAGS_DBG_IOCTL_COMMANDS_B, "FSACTL_GET_FEATURES");
2904 error = aac_supported_features(sc, arg);
2907 fwprintf(sc, HBA_FLAGS_DBG_IOCTL_COMMANDS_B, "unsupported cmd 0x%lx\n", cmd);
2917 struct aac_softc *sc;
2921 sc = dev->si_drv1;
2924 mtx_lock(&sc->aac_aifq_lock);
2926 for (ctx = sc->fibctx; ctx; ctx = ctx->next) {
2927 if (ctx->ctx_idx != sc->aifq_idx || ctx->ctx_wrap) {
2933 mtx_unlock(&sc->aac_aifq_lock);
2937 selrecord(td, &sc->rcv_select);
2944 aac_ioctl_event(struct aac_softc *sc, struct aac_event *event, void *arg)
2949 mtx_assert(&sc->aac_io_lock, MA_OWNED);
2950 if (aac_alloc_command(sc, (struct aac_command **)arg)) {
2951 aac_add_event(sc, event);
2966 aac_ioctl_sendfib(struct aac_softc *sc, caddr_t ufib)
2971 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2978 mtx_lock(&sc->aac_io_lock);
2979 if (aac_alloc_command(sc, &cm)) {
2986 mtx_unlock(&sc->aac_io_lock);
2992 aac_add_event(sc, event);
2993 msleep(&cm, &sc->aac_io_lock, 0, "sendfib", 0);
2995 mtx_unlock(&sc->aac_io_lock);
3004 if (size > sc->aac_max_fib_size) {
3005 device_printf(sc->aac_dev, "incoming FIB oversized (%d > %d)\n",
3006 size, sc->aac_max_fib_size);
3007 size = sc->aac_max_fib_size;
3017 mtx_lock(&sc->aac_io_lock);
3019 mtx_unlock(&sc->aac_io_lock);
3021 device_printf(sc->aac_dev,
3030 if (size > sc->aac_max_fib_size) {
3031 device_printf(sc->aac_dev, "outbound FIB oversized (%d > %d)\n",
3032 size, sc->aac_max_fib_size);
3033 size = sc->aac_max_fib_size;
3039 mtx_lock(&sc->aac_io_lock);
3041 mtx_unlock(&sc->aac_io_lock);
3050 aac_ioctl_send_raw_srb(struct aac_softc *sc, caddr_t arg)
3062 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
3069 mtx_lock(&sc->aac_io_lock);
3070 if (aac_alloc_command(sc, &cm)) {
3075 mtx_unlock(&sc->aac_io_lock);
3081 aac_add_event(sc, event);
3082 msleep(cm, &sc->aac_io_lock, 0, "aacraw", 0);
3084 mtx_unlock(&sc->aac_io_lock);
3092 if (fibsize > (sc->aac_max_fib_size - sizeof(struct aac_fib_header))) {
3134 (sc->flags & AAC_FLAGS_SG_64BIT) == 0) {
3179 fib->Header.Command = (sc->flags & AAC_FLAGS_SG_64BIT) != 0 ?
3182 mtx_lock(&sc->aac_io_lock);
3184 mtx_unlock(&sc->aac_io_lock);
3196 mtx_lock(&sc->aac_io_lock);
3198 mtx_unlock(&sc->aac_io_lock);
3209 struct aac_softc *sc;
3211 sc = arg;
3212 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
3214 device_unbusy(sc->aac_dev);
3223 aac_handle_aif(struct aac_softc *sc, struct aac_fib *fib)
3233 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
3236 aac_print_aif(sc, aif);
3249 aac_alloc_sync_fib(sc, &fib);
3258 if ((mir = aac_get_container_info(sc, fib, i)) == NULL)
3271 &sc->aac_container_tqh,
3293 aac_add_container(sc, mir, 1);
3298 aac_release_sync_fib(sc);
3307 co = TAILQ_FIRST(&sc->aac_container_tqh);
3310 mtx_unlock(&sc->aac_io_lock);
3312 device_delete_child(sc->aac_dev,
3315 mtx_lock(&sc->aac_io_lock);
3317 mtx_lock(&sc->aac_container_lock);
3318 TAILQ_REMOVE(&sc->aac_container_tqh, co,
3320 mtx_unlock(&sc->aac_container_lock);
3331 mtx_unlock(&sc->aac_io_lock);
3333 bus_generic_attach(sc->aac_dev);
3335 mtx_lock(&sc->aac_io_lock);
3345 if (sc->cam_rescan_cb != NULL)
3346 sc->cam_rescan_cb(sc,
3356 if (sc->cam_rescan_cb != NULL)
3357 sc->cam_rescan_cb(sc, (channel >> 24) & 0xF,
3370 mtx_lock(&sc->aac_aifq_lock);
3371 current = sc->aifq_idx;
3374 sc->aifq_filled = 1;
3375 bcopy(fib, &sc->aac_aifq[current], sizeof(struct aac_fib));
3377 if (sc->aifq_filled) {
3378 for (ctx = sc->fibctx; ctx; ctx = ctx->next) {
3385 sc->aifq_idx = next;
3387 if (sc->aac_state & AAC_STATE_AIF_SLEEPER)
3388 wakeup(sc->aac_aifq);
3390 selwakeuppri(&sc->rcv_select, PRIBIO);
3391 mtx_unlock(&sc->aac_aifq_lock);
3401 aac_rev_check(struct aac_softc *sc, caddr_t udata)
3407 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
3417 fwprintf(sc, HBA_FLAGS_DBG_IOCTL_COMMANDS_B, "Userland revision= %d\n",
3443 aac_open_aif(struct aac_softc *sc, caddr_t arg)
3448 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
3454 mtx_lock(&sc->aac_aifq_lock);
3456 if (sc->fibctx == NULL)
3457 sc->fibctx = fibctx;
3459 for (ctx = sc->fibctx; ctx->next; ctx = ctx->next)
3467 ctx = sc->fibctx;
3471 ctx = sc->fibctx;
3476 mtx_unlock(&sc->aac_aifq_lock);
3480 aac_close_aif(sc, (caddr_t)ctx);
3488 aac_close_aif(struct aac_softc *sc, caddr_t arg)
3492 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
3494 mtx_lock(&sc->aac_aifq_lock);
3495 for (ctx = sc->fibctx; ctx; ctx = ctx->next) {
3497 if (ctx == sc->fibctx)
3498 sc->fibctx = NULL;
3507 mtx_unlock(&sc->aac_aifq_lock);
3518 aac_getnext_aif(struct aac_softc *sc, caddr_t arg)
3524 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
3539 for (ctx = sc->fibctx; ctx; ctx = ctx->next) {
3546 error = aac_return_aif(sc, ctx, agf.AifFib);
3548 fwprintf(sc, HBA_FLAGS_DBG_AIF_B, "aac_getnext_aif(): waiting for AIF");
3549 sc->aac_state |= AAC_STATE_AIF_SLEEPER;
3551 error = tsleep(sc->aac_aifq, PRIBIO |
3554 error = aac_return_aif(sc, ctx, agf.AifFib);
3556 sc->aac_state &= ~AAC_STATE_AIF_SLEEPER;
3566 aac_return_aif(struct aac_softc *sc, struct aac_fib_context *ctx, caddr_t uptr)
3570 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
3572 mtx_lock(&sc->aac_aifq_lock);
3574 if (current == sc->aifq_idx && !ctx->ctx_wrap) {
3576 mtx_unlock(&sc->aac_aifq_lock);
3580 copyout(&sc->aac_aifq[current], (void *)uptr, sizeof(struct aac_fib));
3582 device_printf(sc->aac_dev,
3588 mtx_unlock(&sc->aac_aifq_lock);
3593 aac_get_pci_info(struct aac_softc *sc, caddr_t uptr)
3601 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
3603 pciinf.bus = pci_get_bus(sc->aac_dev);
3604 pciinf.slot = pci_get_slot(sc->aac_dev);
3613 aac_supported_features(struct aac_softc *sc, caddr_t uptr)
3618 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
3636 (sc->flags & AAC_FLAGS_LBA_64BIT) ? 1 : 0;
3641 (sc->flags & AAC_FLAGS_LBA_64BIT) ? 1 : 0;
3655 aac_query_disk(struct aac_softc *sc, caddr_t uptr)
3662 fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
3675 mtx_lock(&sc->aac_container_lock);
3676 TAILQ_FOREACH(co, &sc->aac_container_tqh, co_link) {
3691 query_disk.Bus = device_get_unit(sc->aac_dev);
3698 mtx_unlock(&sc->aac_container_lock);
3707 aac_get_bus_info(struct aac_softc *sc)
3719 mtx_lock(&sc->aac_io_lock);
3720 aac_alloc_sync_fib(sc, &fib);
3728 error = aac_sync_fib(sc, ContainerCommand, 0, fib,
3731 device_printf(sc->aac_dev, "Error %d sending "
3733 aac_release_sync_fib(sc);
3734 mtx_unlock(&sc->aac_io_lock);
3740 device_printf(sc->aac_dev, "VM_ContainerConfig returned 0x%x\n",
3742 aac_release_sync_fib(sc);
3743 mtx_unlock(&sc->aac_io_lock);
3747 sc->scsi_method_id = c_resp->param;
3754 vmi->MethId = sc->scsi_method_id;
3758 error = aac_sync_fib(sc, ContainerCommand, 0, fib,
3761 device_printf(sc->aac_dev, "Error %d sending VMIoctl command\n",
3763 aac_release_sync_fib(sc);
3764 mtx_unlock(&sc->aac_io_lock);
3770 device_printf(sc->aac_dev, "VM_Ioctl returned %d\n",
3772 aac_release_sync_fib(sc);
3773 mtx_unlock(&sc->aac_io_lock);
3778 aac_release_sync_fib(sc);
3779 mtx_unlock(&sc->aac_io_lock);
3789 device_printf(sc->aac_dev,
3794 child = device_add_child(sc->aac_dev, "aacp", -1);
3796 device_printf(sc->aac_dev,
3806 caminf->aac_sc = sc;
3811 TAILQ_INSERT_TAIL(&sc->aac_sim_tqh, caminf, sim_link);
3817 bus_generic_attach(sc->aac_dev);