Lines Matching +full:eee +full:- +full:broken +full:- +full:1000 +full:t
1 /*-
2 * SPDX-License-Identifier: BSD-2-Clause
7 * Copyright (c) 2001-2010 Adaptec, Inc.
8 * Copyright (c) 2010-2012 PMC-Sierra, Inc.
246 sc->hint_flags = device_get_flags(sc->aac_dev);
248 * Initialize per-controller queues.
255 sc->aac_state |= AAC_STATE_SUSPEND;
260 sc->msi_enabled = sc->msi_tupelo = FALSE;
267 mtx_init(&sc->aac_io_lock, "AACRAID I/O lock", NULL, MTX_DEF);
268 TAILQ_INIT(&sc->aac_container_tqh);
269 TAILQ_INIT(&sc->aac_ev_cmfree);
272 callout_init_mtx(&sc->aac_daemontime, &sc->aac_io_lock, 0);
280 if (!(sc->flags & AAC_FLAGS_SYNC_MODE)) {
299 unit = device_get_unit(sc->aac_dev);
300 sc->aac_dev_t = make_dev(&aacraid_cdevsw, unit, UID_ROOT, GID_OPERATOR,
302 sc->aac_dev_t->si_drv1 = sc;
306 &sc->aifthread, 0, 0, "aacraid%daif", unit))
309 /* Register the shutdown method to only be called post-dump */
310 if ((sc->eh = EVENTHANDLER_REGISTER(shutdown_final, aacraid_shutdown,
311 sc->aac_dev, SHUTDOWN_PRI_DEFAULT)) == NULL)
312 device_printf(sc->aac_dev,
316 mtx_lock(&sc->aac_io_lock);
328 mtx_unlock(&sc->aac_io_lock);
331 TAILQ_INIT(&sc->aac_sim_tqh);
333 /* Register with CAM for the non-DASD devices */
334 if ((sc->flags & AAC_FLAGS_ENABLE_CAM) != 0)
338 bus_attach_children(sc->aac_dev);
341 sc->aac_state &= ~AAC_STATE_SUSPEND;
346 mtx_lock(&sc->aac_io_lock);
347 callout_reset(&sc->aac_daemontime, 60 * hz, aac_daemon, sc);
348 mtx_unlock(&sc->aac_io_lock);
364 mtx_assert(&sc->aac_io_lock, MA_OWNED);
365 if (callout_pending(&sc->aac_daemontime) ||
366 callout_active(&sc->aac_daemontime) == 0)
371 fib = cm->cm_fib;
372 cm->cm_timestamp = time_uptime;
373 cm->cm_datalen = 0;
374 cm->cm_flags |= AAC_CMD_WAIT;
376 fib->Header.Size =
378 fib->Header.XferState =
387 fib->Header.Command = SendHostTime;
388 *(uint32_t *)fib->data = htole32(tv.tv_sec);
394 callout_schedule(&sc->aac_daemontime, 30 * 60 * hz);
401 switch (event->ev_type & AAC_EVENT_MASK) {
403 TAILQ_INSERT_TAIL(&sc->aac_ev_cmfree, event, ev_links);
406 device_printf(sc->aac_dev, "aac_add event: unknown event %d\n",
407 event->ev_type);
429 device_printf(sc->aac_dev,
431 return (-1);
433 fib = cm->cm_fib;
438 mi = (struct aac_mntinfo *)&fib->data[0];
439 /* 4KB support?, 64-bit LBA? */
440 if (sc->aac_support_opt2 & AAC_SUPPORTED_VARIABLE_BLOCK_SIZE)
441 mi->Command = VM_NameServeAllBlk;
442 else if (sc->flags & AAC_FLAGS_LBA_64BIT)
443 mi->Command = VM_NameServe64;
445 mi->Command = VM_NameServe;
446 mi->MntType = FT_FILESYS;
447 mi->MntCount = cid;
453 device_printf(sc->aac_dev, "Error probing container %d\n", cid);
454 return (-1);
457 cm->cm_timestamp = time_uptime;
458 cm->cm_datalen = 0;
460 fib->Header.Size =
462 fib->Header.XferState =
471 fib->Header.Command = ContainerCommand;
473 device_printf(sc->aac_dev, "Error probing container %d\n", cid);
475 return (-1);
478 bcopy(&fib->data[0], mir, sizeof(struct aac_mntinforesp));
483 if (mir->MntTable[0].VolType != CT_NONE &&
484 !(mir->MntTable[0].ContentState & AAC_FSCS_HIDDEN)) {
485 if (!(sc->aac_support_opt2 & AAC_SUPPORTED_VARIABLE_BLOCK_SIZE)) {
486 mir->MntTable[0].ObjExtension.BlockDevice.BlockSize = 0x200;
487 mir->MntTable[0].ObjExtension.BlockDevice.bdLgclPhysMap = 0;
489 ccfg = (struct aac_cnt_config *)&fib->data[0];
490 bzero(ccfg, sizeof (*ccfg) - CT_PACKET_SIZE);
491 ccfg->Command = VM_ContainerConfig;
492 ccfg->CTCommand.command = CT_CID_TO_32BITS_UID;
493 ccfg->CTCommand.param[0] = cid;
500 if (rval == 0 && ccfg->Command == ST_OK &&
501 ccfg->CTCommand.param[0] == CT_OK &&
502 mir->MntTable[0].VolType != CT_PASSTHRU)
503 *uid = ccfg->CTCommand.param[1];
505 fib->Header.Size =
507 fib->Header.XferState =
516 fib->Header.Command = ContainerCommand;
519 if (rval == 0 && ccfg->Command == ST_OK &&
520 ccfg->CTCommand.param[0] == CT_OK &&
521 mir->MntTable[0].VolType != CT_PASSTHRU)
522 *uid = ccfg->CTCommand.param[1];
545 if ((mir->Status == ST_OK) && (mir->MntTable[0].VolType != CT_NONE)) {
552 co->co_found = f;
553 bcopy(&mir->MntTable[0], &co->co_mntobj,
555 co->co_uid = uid;
556 TAILQ_INSERT_TAIL(&sc->aac_container_tqh, co, co_link);
571 * Create DMA tag for mapping buffers into controller-addressable space.
573 if (bus_dma_tag_create(sc->aac_parent_dmat, /* parent */
575 (sc->flags & AAC_FLAGS_SG_64BIT) ?
581 sc->aac_sg_tablesize, /* nsegments */
585 &sc->aac_io_lock, /* lockfuncarg */
586 &sc->aac_buffer_dmat)) {
587 device_printf(sc->aac_dev, "can't allocate buffer DMA tag\n");
592 * Create DMA tag for mapping FIBs into controller-addressable space..
594 if (sc->flags & AAC_FLAGS_NEW_COMM_TYPE1)
595 maxsize = sc->aac_max_fibs_alloc * (sc->aac_max_fib_size +
598 maxsize = sc->aac_max_fibs_alloc * (sc->aac_max_fib_size + 31);
599 if (bus_dma_tag_create(sc->aac_parent_dmat, /* parent */
601 (sc->flags & AAC_FLAGS_4GB_WINDOW) ?
611 &sc->aac_fib_dmat)) {
612 device_printf(sc->aac_dev, "can't allocate FIB DMA tag\n");
620 maxsize += sc->aac_max_fibs * sizeof(u_int32_t);
621 if (bus_dma_tag_create(sc->aac_parent_dmat, /* parent */
623 (sc->flags & AAC_FLAGS_4GB_WINDOW) ?
633 &sc->aac_common_dmat)) {
634 device_printf(sc->aac_dev,
635 "can't allocate common structure DMA tag\n");
638 if (bus_dmamem_alloc(sc->aac_common_dmat, (void **)&sc->aac_common,
639 BUS_DMA_NOWAIT, &sc->aac_common_dmamap)) {
640 device_printf(sc->aac_dev, "can't allocate common structure\n");
644 (void)bus_dmamap_load(sc->aac_common_dmat, sc->aac_common_dmamap,
645 sc->aac_common, maxsize,
647 bzero(sc->aac_common, maxsize);
650 TAILQ_INIT(&sc->aac_fibmap_tqh);
651 sc->aac_commands = malloc(sc->aac_max_fibs * sizeof(struct aac_command),
653 mtx_lock(&sc->aac_io_lock);
654 while (sc->total_fibs < sc->aac_max_fibs) {
658 mtx_unlock(&sc->aac_io_lock);
659 if (sc->total_fibs == 0)
678 if (sc->aac_dev_t != NULL)
679 destroy_dev(sc->aac_dev_t);
683 if (sc->aac_fib_dmat)
684 bus_dma_tag_destroy(sc->aac_fib_dmat);
686 free(sc->aac_commands, M_AACRAIDBUF);
689 if (sc->aac_common) {
690 bus_dmamap_unload(sc->aac_common_dmat, sc->aac_common_dmamap);
691 bus_dmamem_free(sc->aac_common_dmat, sc->aac_common,
692 sc->aac_common_dmamap);
694 if (sc->aac_common_dmat)
695 bus_dma_tag_destroy(sc->aac_common_dmat);
699 if (sc->aac_intr[i])
700 bus_teardown_intr(sc->aac_dev,
701 sc->aac_irq[i], sc->aac_intr[i]);
702 if (sc->aac_irq[i])
703 bus_release_resource(sc->aac_dev, SYS_RES_IRQ,
704 sc->aac_irq_rid[i], sc->aac_irq[i]);
708 if (sc->msi_enabled || sc->msi_tupelo)
709 pci_release_msi(sc->aac_dev);
711 /* destroy data-transfer DMA tag */
712 if (sc->aac_buffer_dmat)
713 bus_dma_tag_destroy(sc->aac_buffer_dmat);
716 if (sc->aac_parent_dmat)
717 bus_dma_tag_destroy(sc->aac_parent_dmat);
720 if (sc->aac_regs_res0 != NULL)
721 bus_release_resource(sc->aac_dev, SYS_RES_MEMORY,
722 sc->aac_regs_rid0, sc->aac_regs_res0);
723 if (sc->aac_regs_res1 != NULL)
724 bus_release_resource(sc->aac_dev, SYS_RES_MEMORY,
725 sc->aac_regs_rid1, sc->aac_regs_res1);
746 callout_drain(&sc->aac_daemontime);
748 while ((co = TAILQ_FIRST(&sc->aac_container_tqh)) != NULL) {
749 TAILQ_REMOVE(&sc->aac_container_tqh, co, co_link);
754 while ((sim = TAILQ_FIRST(&sc->aac_sim_tqh)) != NULL) {
755 TAILQ_REMOVE(&sc->aac_sim_tqh, sim, sim_link);
759 if (sc->aifflags & AAC_AIFFLAGS_RUNNING) {
760 sc->aifflags |= AAC_AIFFLAGS_EXIT;
761 wakeup(sc->aifthread);
762 tsleep(sc->aac_dev, PUSER | PCATCH, "aac_dch", 30 * hz);
765 if (sc->aifflags & AAC_AIFFLAGS_RUNNING)
771 EVENTHANDLER_DEREGISTER(shutdown_final, sc->eh);
775 mtx_destroy(&sc->aac_io_lock);
785 * Note that we can assume that the bioq on the controller is empty, as we won't
798 sc->aac_state |= AAC_STATE_SUSPEND;
802 * controller to convince it that we don't want to talk to it anymore.
805 device_printf(sc->aac_dev, "shutting down controller...");
807 mtx_lock(&sc->aac_io_lock);
809 cc = (struct aac_close_command *)&fib->data[0];
812 cc->Command = htole32(VM_CloseAll);
813 cc->ContainerId = htole32(0xfffffffe);
822 mtx_unlock(&sc->aac_io_lock);
838 sc->aac_state |= AAC_STATE_SUSPEND;
855 sc->aac_state &= ~AAC_STATE_SUSPEND;
875 sc = ctx->sc;
876 vector_no = ctx->vector_no;
879 mtx_lock(&sc->aac_io_lock);
881 if (sc->msi_enabled) {
909 if (sc->aac_sync_cm) {
910 cm = sc->aac_sync_cm;
912 cm->cm_flags |= AAC_CMD_COMPLETED;
913 aac_fib_header_toh(&cm->cm_fib->Header);
916 if (cm->cm_complete != NULL) {
917 cm->cm_complete(cm);
922 sc->flags &= ~AAC_QUEUE_FRZN;
923 sc->aac_sync_cm = NULL;
938 if (sc->flags & AAC_FLAGS_SYNC_MODE)
943 index = sc->aac_host_rrq_idx[vector_no];
947 handle = (le32toh(sc->aac_common->ac_host_rrq[index]) &
959 cm = sc->aac_commands + (handle - 1);
960 fib = cm->cm_fib;
961 aac_fib_header_toh(&fib->Header);
962 sc->aac_rrq_outstanding[vector_no]--;
964 noMoreAif = (fib->Header.XferState & AAC_FIBSTATE_NOMOREAIF) ? 1:0;
971 fib->Header.XferState |= AAC_FIBSTATE_DONEADAP;
972 *((u_int32_t *)(fib->data)) = htole32(ST_OK);
973 cm->cm_flags |= AAC_CMD_FASTRESP;
977 cm->cm_flags |= AAC_CMD_COMPLETED;
980 if (cm->cm_complete != NULL) {
981 cm->cm_complete(cm);
986 sc->flags &= ~AAC_QUEUE_FRZN;
989 sc->aac_common->ac_host_rrq[index++] = 0;
990 if (index == (vector_no + 1) * sc->aac_vector_cap)
991 index = vector_no * sc->aac_vector_cap;
992 sc->aac_host_rrq_idx[vector_no] = index;
994 if ((isAif && !noMoreAif) || sc->aif_pending)
1006 if ((sc->flags & AAC_QUEUE_FRZN) == 0)
1008 mtx_unlock(&sc->aac_io_lock);
1021 mtx_lock(&sc->aac_io_lock);
1022 sc->aifflags = AAC_AIFFLAGS_RUNNING;
1024 while ((sc->aifflags & AAC_AIFFLAGS_EXIT) == 0) {
1026 if ((sc->aifflags & AAC_AIFFLAGS_PENDING) == 0)
1027 retval = msleep(sc->aifthread, &sc->aac_io_lock, PRIBIO,
1033 if ((sc->aifflags & AAC_AIFFLAGS_ALLOCFIBS) != 0) {
1035 sc->aifflags &= ~AAC_AIFFLAGS_ALLOCFIBS;
1041 * This is pretty low-priority, so it's ok if it doesn't
1048 if (sc->aac_common->ac_printf[0] != 0)
1051 sc->aifflags &= ~AAC_AIFFLAGS_RUNNING;
1052 mtx_unlock(&sc->aac_io_lock);
1053 wakeup(sc->aac_dev);
1064 * to cancel a command that is in progress, we can't protect against the
1074 sc = cm->cm_sc;
1076 mtx_assert(&sc->aac_io_lock, MA_OWNED);
1081 error = msleep(cm, &sc->aac_io_lock, PRIBIO, "aacraid_wait", 0);
1100 if (sc->total_fibs < sc->aac_max_fibs) {
1101 sc->aifflags |= AAC_AIFFLAGS_ALLOCFIBS;
1102 wakeup(sc->aifthread);
1120 sc = cm->cm_sc;
1122 mtx_assert(&sc->aac_io_lock, MA_OWNED);
1125 cm->cm_sgtable = NULL;
1126 cm->cm_flags = 0;
1127 cm->cm_complete = NULL;
1128 cm->cm_ccb = NULL;
1129 cm->cm_passthr_dmat = 0;
1130 cm->cm_fib->Header.XferState = AAC_FIBSTATE_EMPTY;
1131 cm->cm_fib->Header.StructType = AAC_FIBTYPE_TFIB;
1132 cm->cm_fib->Header.Unused = 0;
1133 cm->cm_fib->Header.SenderSize = cm->cm_sc->aac_max_fib_size;
1140 cm->cm_fib->Header.u.ReceiverFibAddress = (u_int32_t)cm->cm_fibphys;
1141 cm->cm_fib->Header.Handle = 0;
1149 while ((event = TAILQ_FIRST(&sc->aac_ev_cmfree)) != NULL) {
1150 TAILQ_REMOVE(&sc->aac_ev_cmfree, event, ev_links);
1151 event->ev_callback(sc, event, event->ev_arg);
1181 mtx_assert(&sc->aac_io_lock, MA_OWNED);
1183 if (sc->total_fibs + sc->aac_max_fibs_alloc > sc->aac_max_fibs)
1190 mtx_unlock(&sc->aac_io_lock);
1192 if (bus_dmamem_alloc(sc->aac_fib_dmat, (void **)&fm->aac_fibs,
1193 BUS_DMA_NOWAIT, &fm->aac_fibmap)) {
1194 device_printf(sc->aac_dev,
1197 mtx_lock(&sc->aac_io_lock);
1201 maxsize = sc->aac_max_fib_size + 31;
1202 if (sc->flags & AAC_FLAGS_NEW_COMM_TYPE1)
1204 /* Ignore errors since this doesn't bounce */
1205 (void)bus_dmamap_load(sc->aac_fib_dmat, fm->aac_fibmap, fm->aac_fibs,
1206 sc->aac_max_fibs_alloc * maxsize,
1208 mtx_lock(&sc->aac_io_lock);
1211 bzero(fm->aac_fibs, sc->aac_max_fibs_alloc * maxsize);
1212 for (i = 0; i < sc->aac_max_fibs_alloc; i++) {
1213 cm = sc->aac_commands + sc->total_fibs;
1214 fm->aac_commands = cm;
1215 cm->cm_sc = sc;
1216 cm->cm_fib = (struct aac_fib *)
1217 ((u_int8_t *)fm->aac_fibs + i * maxsize);
1218 cm->cm_fibphys = fibphys + i * maxsize;
1219 if (sc->flags & AAC_FLAGS_NEW_COMM_TYPE1) {
1222 (cm->cm_fibphys + sizeof(struct aac_fib_xporthdr) + 31) & ~31;
1223 cm->cm_fib = (struct aac_fib *)
1224 ((u_int8_t *)cm->cm_fib + (fibphys_aligned - cm->cm_fibphys));
1225 cm->cm_fibphys = fibphys_aligned;
1228 fibphys_aligned = (cm->cm_fibphys + 31) & ~31;
1229 cm->cm_fib = (struct aac_fib *)
1230 ((u_int8_t *)cm->cm_fib + (fibphys_aligned - cm->cm_fibphys));
1231 cm->cm_fibphys = fibphys_aligned;
1233 cm->cm_index = sc->total_fibs;
1235 if ((error = bus_dmamap_create(sc->aac_buffer_dmat, 0,
1236 &cm->cm_datamap)) != 0)
1238 if (sc->aac_max_fibs <= 1 || sc->aac_max_fibs - sc->total_fibs > 1)
1240 sc->total_fibs++;
1244 TAILQ_INSERT_TAIL(&sc->aac_fibmap_tqh, fm, fm_link);
1245 fwprintf(sc, HBA_FLAGS_DBG_COMM_B, "total_fibs= %d\n", sc->total_fibs);
1249 bus_dmamap_unload(sc->aac_fib_dmat, fm->aac_fibmap);
1250 bus_dmamem_free(sc->aac_fib_dmat, fm->aac_fibs, fm->aac_fibmap);
1267 while ((fm = TAILQ_FIRST(&sc->aac_fibmap_tqh)) != NULL) {
1268 TAILQ_REMOVE(&sc->aac_fibmap_tqh, fm, fm_link);
1273 for (i = 0; i < sc->aac_max_fibs_alloc && sc->total_fibs--; i++) {
1274 cm = fm->aac_commands + i;
1275 bus_dmamap_destroy(sc->aac_buffer_dmat, cm->cm_datamap);
1277 bus_dmamap_unload(sc->aac_fib_dmat, fm->aac_fibmap);
1278 bus_dmamem_free(sc->aac_fib_dmat, fm->aac_fibs, fm->aac_fibmap);
1284 * Command-mapping helper function - populate this command's s/g table.
1295 sc = cm->cm_sc;
1296 fib = cm->cm_fib;
1298 mtx_assert(&sc->aac_io_lock, MA_OWNED);
1300 if ((sc->flags & AAC_FLAGS_SYNC_MODE) && sc->aac_sync_cm)
1304 if (cm->cm_sgtable != NULL) {
1305 if (fib->Header.Command == RawIo2) {
1311 raw = (struct aac_raw_io2 *)&fib->data[0];
1312 sg = (struct aac_sge_ieee1212 *)cm->cm_sgtable;
1313 raw->sgeCnt = nseg;
1322 raw->sgeFirstSize = cur_size;
1324 raw->sgeNominalSize = cur_size;
1327 cur_size != raw->sgeNominalSize) {
1337 for (i = min_size / PAGE_SIZE; i >= 1; --i) {
1340 for (j = 1; j < nseg - 1; ++j) {
1350 if (i>0 && nseg_new<=sc->aac_sg_tablesize &&
1351 !(sc->hint_flags & 4))
1355 raw->flags |= RIO2_SGL_CONFORMANT;
1363 fib->Header.Size += nseg *
1366 } else if (fib->Header.Command == RawIo) {
1368 sg = (struct aac_sg_tableraw *)cm->cm_sgtable;
1369 sg->SgCount = htole32(nseg);
1371 sg->SgEntryRaw[i].SgAddress = segs[i].ds_addr;
1372 sg->SgEntryRaw[i].SgByteCount = segs[i].ds_len;
1373 sg->SgEntryRaw[i].Next = 0;
1374 sg->SgEntryRaw[i].Prev = 0;
1375 sg->SgEntryRaw[i].Flags = 0;
1376 aac_sg_entryraw_tole(&sg->SgEntryRaw[i]);
1378 aac_raw_io_tole((struct aac_raw_io *)&fib->data[0]);
1380 fib->Header.Size += nseg*sizeof(struct aac_sg_entryraw);
1381 } else if ((cm->cm_sc->flags & AAC_FLAGS_SG_64BIT) == 0) {
1383 sg = cm->cm_sgtable;
1384 sg->SgCount = htole32(nseg);
1386 sg->SgEntry[i].SgAddress = segs[i].ds_addr;
1387 sg->SgEntry[i].SgByteCount = segs[i].ds_len;
1388 aac_sg_entry_tole(&sg->SgEntry[i]);
1391 fib->Header.Size += nseg*sizeof(struct aac_sg_entry);
1394 sg = (struct aac_sg_table64 *)cm->cm_sgtable;
1395 sg->SgCount = htole32(nseg);
1397 sg->SgEntry64[i].SgAddress = segs[i].ds_addr;
1398 sg->SgEntry64[i].SgByteCount = segs[i].ds_len;
1399 aac_sg_entry64_tole(&sg->SgEntry64[i]);
1402 fib->Header.Size += nseg*sizeof(struct aac_sg_entry64);
1411 cm->cm_fib->Header.SenderFibAddress = (cm->cm_index << 2);
1412 cm->cm_fib->Header.u.ReceiverFibAddress = (u_int32_t)cm->cm_fibphys;
1414 /* save a pointer to the command for speedy reverse-lookup */
1415 cm->cm_fib->Header.Handle += cm->cm_index + 1;
1417 if (cm->cm_passthr_dmat == 0) {
1418 if (cm->cm_flags & AAC_CMD_DATAIN)
1419 bus_dmamap_sync(sc->aac_buffer_dmat, cm->cm_datamap,
1421 if (cm->cm_flags & AAC_CMD_DATAOUT)
1422 bus_dmamap_sync(sc->aac_buffer_dmat, cm->cm_datamap,
1426 cm->cm_flags |= AAC_CMD_MAPPED;
1428 if (cm->cm_flags & AAC_CMD_WAIT) {
1429 aac_fib_header_tole(&fib->Header);
1431 cm->cm_fibphys, 0, 0, 0, NULL, NULL);
1432 } else if (sc->flags & AAC_FLAGS_SYNC_MODE) {
1434 sc->aac_sync_cm = cm;
1435 aac_fib_header_tole(&fib->Header);
1437 cm->cm_fibphys, 0, 0, 0, &wait, NULL);
1441 if (--count == 0) {
1443 sc->flags |= AAC_QUEUE_FRZN;
1464 for (i = 1, pos = 1; i < nseg - 1; ++i) {
1465 for (j = 0; j < raw->sge[i].length / (pages*PAGE_SIZE); ++j) {
1466 addr_low = raw->sge[i].addrLow + j * pages * PAGE_SIZE;
1468 sge[pos].addrHigh = raw->sge[i].addrHigh;
1469 if (addr_low < raw->sge[i].addrLow)
1476 sge[pos] = raw->sge[nseg-1];
1478 raw->sge[i] = sge[i];
1481 raw->sgeCnt = nseg_new;
1482 raw->flags |= RIO2_SGL_CONFORMANT;
1483 raw->sgeNominalSize = pages * PAGE_SIZE;
1488 * Unmap a command from controller-visible space.
1495 sc = cm->cm_sc;
1498 if (!(cm->cm_flags & AAC_CMD_MAPPED))
1501 if (cm->cm_datalen != 0 && cm->cm_passthr_dmat == 0) {
1502 if (cm->cm_flags & AAC_CMD_DATAIN)
1503 bus_dmamap_sync(sc->aac_buffer_dmat, cm->cm_datamap,
1505 if (cm->cm_flags & AAC_CMD_DATAOUT)
1506 bus_dmamap_sync(sc->aac_buffer_dmat, cm->cm_datamap,
1509 bus_dmamap_unload(sc->aac_buffer_dmat, cm->cm_datamap);
1511 cm->cm_flags &= ~AAC_CMD_MAPPED;
1529 sc->aac_common_busaddr = segs[0].ds_addr;
1547 device_printf(sc->aac_dev,
1560 waitCount--;
1571 device_printf(sc->aac_dev,
1582 if (sc->flags & AAC_FLAGS_PERC2QC) {
1585 device_printf(sc->aac_dev,
1591 major = (AAC_GET_MAILBOX(sc, 1) & 0xff) - 0x30;
1592 minor = (AAC_GET_MAILBOX(sc, 2) & 0xff) - 0x30;
1594 device_printf(sc->aac_dev,
1602 * work-arounds to enable. Some firmware revs don't support this
1607 device_printf(sc->aac_dev,
1614 sc->supported_options = options;
1615 sc->doorbell_mask = AAC_GET_MAILBOX(sc, 3);
1618 (sc->flags & AAC_FLAGS_NO4GB) == 0)
1619 sc->flags |= AAC_FLAGS_4GB_WINDOW;
1621 sc->flags |= AAC_FLAGS_ENABLE_CAM;
1624 && (sc->hint_flags & 0x1)) {
1625 device_printf(sc->aac_dev,
1626 "Enabling 64-bit address support\n");
1627 sc->flags |= AAC_FLAGS_SG_64BIT;
1629 if (sc->aac_if.aif_send_command) {
1631 sc->flags |= AAC_FLAGS_NEW_COMM | AAC_FLAGS_NEW_COMM_TYPE2;
1633 sc->flags |= AAC_FLAGS_NEW_COMM | AAC_FLAGS_NEW_COMM_TYPE1;
1636 sc->flags |= AAC_FLAGS_NEW_COMM | AAC_FLAGS_NEW_COMM_TYPE34;
1639 sc->flags |= AAC_FLAGS_ARRAY_64BIT;
1642 if (!(sc->flags & AAC_FLAGS_NEW_COMM)) {
1643 device_printf(sc->aac_dev, "Communication interface not supported!\n");
1647 if (sc->hint_flags & 2) {
1648 device_printf(sc->aac_dev,
1650 sc->flags |= AAC_FLAGS_SYNC_MODE;
1651 } else if (sc->flags & AAC_FLAGS_NEW_COMM_TYPE34) {
1652 device_printf(sc->aac_dev,
1654 sc->flags |= AAC_FLAGS_SYNC_MODE;
1657 /* Check for broken hardware that does a lower number of commands */
1658 sc->aac_max_fibs = (sc->flags & AAC_FLAGS_256FIBS ? 256:512);
1661 if (atu_size > rman_get_size(sc->aac_regs_res0)) {
1663 sc->aac_dev, SYS_RES_MEMORY,
1664 sc->aac_regs_rid0, sc->aac_regs_res0);
1665 sc->aac_regs_res0 = bus_alloc_resource_anywhere(
1666 sc->aac_dev, SYS_RES_MEMORY, &sc->aac_regs_rid0,
1668 if (sc->aac_regs_res0 == NULL) {
1669 sc->aac_regs_res0 = bus_alloc_resource_any(
1670 sc->aac_dev, SYS_RES_MEMORY,
1671 &sc->aac_regs_rid0, RF_ACTIVE);
1672 if (sc->aac_regs_res0 == NULL) {
1673 device_printf(sc->aac_dev,
1674 "couldn't allocate register window\n");
1678 sc->aac_btag0 = rman_get_bustag(sc->aac_regs_res0);
1679 sc->aac_bhandle0 = rman_get_bushandle(sc->aac_regs_res0);
1683 sc->aac_max_fib_size = sizeof(struct aac_fib);
1684 sc->aac_max_sectors = 128; /* 64KB */
1685 sc->aac_max_aif = 1;
1686 if (sc->flags & AAC_FLAGS_SG_64BIT)
1687 sc->aac_sg_tablesize = (AAC_FIB_DATASIZE
1688 - sizeof(struct aac_blockwrite64))
1691 sc->aac_sg_tablesize = (AAC_FIB_DATASIZE
1692 - sizeof(struct aac_blockwrite))
1697 sc->aac_max_fib_size = (options & 0xFFFF);
1698 sc->aac_max_sectors = (options >> 16) << 1;
1700 sc->aac_sg_tablesize = (options >> 16);
1702 sc->aac_max_fibs = ((options >> 16) & 0xFFFF);
1703 if (sc->aac_max_fibs == 0 || sc->aac_hwif != AAC_HWIF_SRCV)
1704 sc->aac_max_fibs = (options & 0xFFFF);
1706 sc->aac_max_aif = (options & 0xFFFF);
1708 sc->aac_max_msix =(sc->flags & AAC_FLAGS_NEW_COMM_TYPE2) ? options : 0;
1711 maxsize = sc->aac_max_fib_size + 31;
1712 if (sc->flags & AAC_FLAGS_NEW_COMM_TYPE1)
1715 sc->aac_max_fib_size -= (maxsize - PAGE_SIZE);
1718 sc->aac_max_fibs_alloc = PAGE_SIZE / maxsize;
1720 if (sc->aac_max_fib_size > sizeof(struct aac_fib)) {
1721 sc->flags |= AAC_FLAGS_RAW_IO;
1722 device_printf(sc->aac_dev, "Enable Raw I/O\n");
1724 if ((sc->flags & AAC_FLAGS_RAW_IO) &&
1725 (sc->flags & AAC_FLAGS_ARRAY_64BIT)) {
1726 sc->flags |= AAC_FLAGS_LBA_64BIT;
1727 device_printf(sc->aac_dev, "Enable 64-bit array\n");
1745 sc->aac_fibs_pushed_no = 0;
1746 for (i = 0; i < sc->aac_max_msix; i++)
1747 sc->aac_host_rrq_idx[i] = i * sc->aac_vector_cap;
1753 ip = &sc->aac_common->ac_init;
1754 ip->InitStructRevision = AAC_INIT_STRUCT_REVISION;
1755 if (sc->aac_max_fib_size > sizeof(struct aac_fib)) {
1756 ip->InitStructRevision = AAC_INIT_STRUCT_REVISION_4;
1757 sc->flags |= AAC_FLAGS_RAW_IO;
1759 ip->NoOfMSIXVectors = sc->aac_max_msix;
1761 ip->AdapterFibsPhysicalAddress = sc->aac_common_busaddr +
1763 ip->AdapterFibsVirtualAddress = 0;
1764 ip->AdapterFibsSize = AAC_ADAPTER_FIBS * sizeof(struct aac_fib);
1765 ip->AdapterFibAlign = sizeof(struct aac_fib);
1767 ip->PrintfBufferAddress = sc->aac_common_busaddr +
1769 ip->PrintfBufferSize = AAC_PRINTF_BUFSIZE;
1773 * broken firmware versions that do the page->byte conversion twice,
1777 ip->HostPhysMemPages = ctob(physmem) / AAC_PAGE_SIZE;
1778 if (sc->flags & AAC_FLAGS_BROKEN_MEMMAP) {
1779 ip->HostPhysMemPages =
1780 (ip->HostPhysMemPages + AAC_PAGE_SIZE) / AAC_PAGE_SIZE;
1782 ip->HostElapsedSeconds = time_uptime; /* reset later if invalid */
1784 ip->InitFlags = AAC_INITFLAGS_NEW_COMM_SUPPORTED;
1785 if (sc->flags & AAC_FLAGS_NEW_COMM_TYPE1) {
1786 ip->InitStructRevision = AAC_INIT_STRUCT_REVISION_6;
1787 ip->InitFlags |= (AAC_INITFLAGS_NEW_COMM_TYPE1_SUPPORTED |
1789 device_printf(sc->aac_dev, "New comm. interface type1 enabled\n");
1790 } else if (sc->flags & AAC_FLAGS_NEW_COMM_TYPE2) {
1791 ip->InitStructRevision = AAC_INIT_STRUCT_REVISION_7;
1792 ip->InitFlags |= (AAC_INITFLAGS_NEW_COMM_TYPE2_SUPPORTED |
1794 device_printf(sc->aac_dev, "New comm. interface type2 enabled\n");
1796 ip->MaxNumAif = sc->aac_max_aif;
1797 ip->HostRRQ_AddrLow =
1798 sc->aac_common_busaddr + offsetof(struct aac_common, ac_host_rrq);
1799 /* always 32-bit address */
1800 ip->HostRRQ_AddrHigh = 0;
1802 if (sc->aac_support_opt2 & AAC_SUPPORTED_POWER_MANAGEMENT) {
1803 ip->InitFlags |= AAC_INITFLAGS_DRIVER_SUPPORTS_PM;
1804 ip->InitFlags |= AAC_INITFLAGS_DRIVER_USES_UTC_TIME;
1805 device_printf(sc->aac_dev, "Power Management enabled\n");
1808 ip->MaxIoCommands = sc->aac_max_fibs;
1809 ip->MaxIoSize = AAC_MAXIO_SIZE(sc);
1810 ip->MaxFibSize = sc->aac_max_fib_size;
1815 * Do controller-type-specific initialisation
1823 sc->aac_common_busaddr +
1826 device_printf(sc->aac_dev,
1850 dev = sc->aac_dev;
1852 if (sc->flags & AAC_FLAGS_SYNC_MODE) {
1854 sc->aac_max_msix = 1;
1855 sc->aac_vector_cap = sc->aac_max_fibs;
1860 if (sc->aac_max_msix == 0) {
1861 if (sc->aac_hwif == AAC_HWIF_SRC) {
1864 device_printf(dev, "alloc msi failed - err=%d; "
1868 sc->msi_tupelo = TRUE;
1871 if (sc->msi_tupelo)
1876 sc->aac_max_msix = 1;
1877 sc->aac_vector_cap = sc->aac_max_fibs;
1885 if (msi_count > sc->aac_max_msix)
1886 msi_count = sc->aac_max_msix;
1888 device_printf(dev, "alloc msix failed - msi_count=%d, err=%d; "
1892 sc->msi_enabled = TRUE;
1893 device_printf(dev, "using MSI-X interrupts (%u vectors)\n",
1897 if (!sc->msi_enabled) {
1900 device_printf(dev, "alloc msi failed - err=%d; "
1904 sc->msi_enabled = TRUE;
1909 if (sc->msi_enabled) {
1915 sc->msi_enabled = FALSE;
1919 if (!sc->msi_enabled) {
1921 sc->aac_max_msix = 1;
1924 if (sc->aac_max_msix > msi_count)
1925 sc->aac_max_msix = msi_count;
1927 sc->aac_vector_cap = sc->aac_max_fibs / sc->aac_max_msix;
1930 sc->msi_enabled,sc->aac_vector_cap, sc->aac_max_fibs, sc->aac_max_msix);
1940 dev = sc->aac_dev;
1980 msi_count = sc->aac_max_msix;
1981 rid = ((sc->msi_enabled || sc->msi_tupelo)? 1:0);
1984 if ((res = bus_alloc_resource_any(sc->aac_dev,SYS_RES_IRQ, &rid,
1986 device_printf(sc->aac_dev,"can't allocate interrupt\n");
1989 sc->aac_irq_rid[i] = rid;
1990 sc->aac_irq[i] = res;
1991 if (aac_bus_setup_intr(sc->aac_dev, res,
1993 aacraid_new_intr_type1, &sc->aac_msix[i], &tag)) {
1994 device_printf(sc->aac_dev, "can't set up interrupt\n");
1997 sc->aac_msix[i].vector_no = i;
1998 sc->aac_msix[i].sc = sc;
1999 sc->aac_intr[i] = tag;
2013 mtx_lock(&sc->aac_io_lock);
2016 ccfg = (struct aac_cnt_config *)&fib->data[0];
2017 bzero(ccfg, sizeof (*ccfg) - CT_PACKET_SIZE);
2018 ccfg->Command = VM_ContainerConfig;
2019 ccfg->CTCommand.command = CT_GET_CONFIG_STATUS;
2020 ccfg->CTCommand.param[CNT_SIZE] = sizeof(struct aac_cf_status_hdr);
2027 cf_shdr = (struct aac_cf_status_hdr *)ccfg->CTCommand.data;
2028 if (rval == 0 && ccfg->Command == ST_OK &&
2029 ccfg->CTCommand.param[0] == CT_OK) {
2030 if (le32toh(cf_shdr->action) <= CFACT_PAUSE) {
2031 bzero(ccfg, sizeof (*ccfg) - CT_PACKET_SIZE);
2032 ccfg->Command = VM_ContainerConfig;
2033 ccfg->CTCommand.command = CT_COMMIT_CONFIG;
2040 if (rval == 0 && ccfg->Command == ST_OK &&
2041 ccfg->CTCommand.param[0] == CT_OK) {
2046 rval = -2;
2051 rval = -3;
2055 rval = -1;
2059 mtx_unlock(&sc->aac_io_lock);
2081 if (!sc->msi_enabled)
2110 return (-1);
2122 mtx_assert(&sc->aac_io_lock, MA_OWNED);
2130 fib->Header.XferState = AAC_FIBSTATE_HOSTOWNED |
2133 fib->Header.XferState |= xferstate;
2134 fib->Header.Command = command;
2135 fib->Header.StructType = AAC_FIBTYPE_TFIB;
2136 fib->Header.Size = sizeof(struct aac_fib_header) + datasize;
2137 fib->Header.SenderSize = sizeof(struct aac_fib);
2138 fib->Header.SenderFibAddress = 0; /* Not needed */
2139 ReceiverFibAddress = sc->aac_common_busaddr +
2141 fib->Header.u.ReceiverFibAddress = ReceiverFibAddress;
2142 aac_fib_header_tole(&fib->Header);
2150 aac_fib_header_toh(&fib->Header);
2154 aac_fib_header_toh(&fib->Header);
2175 deadline = time_uptime - AAC_CMD_TIMEOUT;
2176 TAILQ_FOREACH(cm, &sc->aac_busy, cm_link) {
2177 if (cm->cm_timestamp < deadline) {
2178 device_printf(sc->aac_dev,
2180 cm, (int)(time_uptime-cm->cm_timestamp));
2181 AAC_PRINT_FIB(sc, cm->cm_fib);
2227 if (sc->msi_enabled) {
2247 if (sc->msi_enabled) {
2316 (sc->msi_enabled ? AAC_INT_ENABLE_TYPE1_MSIX :
2393 if (sc->msi_enabled && cm->cm_fib->Header.Command != AifRequest &&
2394 sc->aac_max_msix > 1) {
2397 vector_no = sc->aac_fibs_pushed_no % sc->aac_max_msix;
2400 if (vector_no == sc->aac_max_msix)
2402 if (sc->aac_rrq_outstanding[vector_no] <
2403 sc->aac_vector_cap)
2412 sc->aac_rrq_outstanding[vector_no]++;
2413 if (sc->aac_fibs_pushed_no == 0xffffffff)
2414 sc->aac_fibs_pushed_no = 0;
2416 sc->aac_fibs_pushed_no++;
2418 cm->cm_fib->Header.Handle += (vector_no << 16);
2421 if (sc->flags & AAC_FLAGS_NEW_COMM_TYPE2) {
2423 fibsize = (cm->cm_fib->Header.Size + 127) / 128 - 1;
2425 address = cm->cm_fibphys;
2428 cm->cm_fib->Header.StructType = AAC_FIBTYPE_TFIB2;
2429 cm->cm_fib->Header.u.TimeStamp = 0L;
2431 cm->cm_fib->Header.StructType = AAC_FIBTYPE_TFIB2_64;
2432 cm->cm_fib->Header.u.SenderFibAddressHigh = high_addr;
2434 cm->cm_fib->Header.SenderFibAddress = (u_int32_t)address;
2438 cm->cm_fib->Header.Size + 127) / 128 - 1;
2441 ((unsigned char *)cm->cm_fib - sizeof(struct aac_fib_xporthdr));
2442 pFibX->Handle = cm->cm_fib->Header.Handle;
2443 pFibX->HostAddress = cm->cm_fibphys;
2444 pFibX->Size = cm->cm_fib->Header.Size;
2446 address = cm->cm_fibphys - sizeof(struct aac_fib_xporthdr);
2450 aac_fib_header_tole(&cm->cm_fib->Header);
2472 return(-1);
2497 mtx_lock(&sc->aac_io_lock);
2500 if (sc->supported_options & AAC_SUPPORTED_SUPPLEMENT_ADAPTER_INFO) {
2501 fib->data[0] = 0;
2503 device_printf(sc->aac_dev, "RequestSupplementAdapterInfo failed\n");
2507 supp_info = ((struct aac_supplement_adapter_info *)&fib->data[0]);
2508 adapter_type = (char *)supp_info->AdapterTypeText;
2509 sc->aac_feature_bits = le32toh(supp_info->FeatureBits);
2510 sc->aac_support_opt2 = le32toh(supp_info->SupportedOptions2);
2513 device_printf(sc->aac_dev, "%s, aacraid driver %d.%d.%d-%d\n",
2518 fib->data[0] = 0;
2520 device_printf(sc->aac_dev, "RequestAdapterInfo failed\n");
2522 mtx_unlock(&sc->aac_io_lock);
2527 info = (struct aac_adapter_info *)&fib->data[0];
2529 sc->aac_revision = info->KernelRevision;
2532 device_printf(sc->aac_dev, "%s %dMHz, %dMB memory "
2534 aac_describe_code(aac_cpu_variant, info->CpuVariant),
2535 info->ClockSpeed, info->TotalMem / (1024 * 1024),
2536 info->BufferMem / (1024 * 1024),
2537 info->ExecutionMem / (1024 * 1024),
2539 info->batteryPlatform));
2541 device_printf(sc->aac_dev,
2542 "Kernel %d.%d-%d, Build %d, S/N %6X\n",
2543 info->KernelRevision.external.comp.major,
2544 info->KernelRevision.external.comp.minor,
2545 info->KernelRevision.external.comp.dash,
2546 info->KernelRevision.buildNumber,
2547 (u_int32_t)(info->SerialNumber & 0xffffff));
2549 device_printf(sc->aac_dev, "Supported Options=%b\n",
2550 sc->supported_options,
2574 mtx_unlock(&sc->aac_io_lock);
2601 sc = dev->si_drv1;
2603 device_busy(sc->aac_dev);
2616 sc = dev->si_drv1;
2621 switch (as->as_item) {
2625 bcopy(&sc->aac_qstat[as->as_item], &as->as_qstat,
2686 * We don't trust the underland to tell us when to delete a
2719 sc = dev->si_drv1;
2722 mtx_lock(&sc->aac_io_lock);
2724 for (ctx = sc->fibctx; ctx; ctx = ctx->next) {
2725 if (ctx->ctx_idx != sc->aifq_idx || ctx->ctx_wrap) {
2731 mtx_unlock(&sc->aac_io_lock);
2735 selrecord(td, &sc->rcv_select);
2745 switch (event->ev_type) {
2747 mtx_assert(&sc->aac_io_lock, MA_OWNED);
2766 * - At least the FIB data part from userspace should already be in LE,
2769 * - SG tables are converted to BE by aacraid_map_command_sg(). This
2771 * - aacraid_wait_command() calls functions that convert the FIB header
2788 mtx_lock(&sc->aac_io_lock);
2796 mtx_unlock(&sc->aac_io_lock);
2799 event->ev_type = AAC_EVENT_CMFREE;
2800 event->ev_callback = aac_ioctl_event;
2801 event->ev_arg = &cm;
2803 msleep(cm, &sc->aac_io_lock, 0, "aacraid_ctlsfib", 0);
2805 mtx_unlock(&sc->aac_io_lock);
2808 * Fetch the FIB header, then re-copy to get data as well.
2810 if ((error = copyin(ufib, cm->cm_fib,
2813 size = cm->cm_fib->Header.Size + sizeof(struct aac_fib_header);
2814 if (size > sc->aac_max_fib_size) {
2815 device_printf(sc->aac_dev, "incoming FIB oversized (%d > %d)\n",
2816 size, sc->aac_max_fib_size);
2817 size = sc->aac_max_fib_size;
2819 if ((error = copyin(ufib, cm->cm_fib, size)) != 0)
2821 cm->cm_fib->Header.Size = size;
2822 cm->cm_timestamp = time_uptime;
2823 cm->cm_datalen = 0;
2828 mtx_lock(&sc->aac_io_lock);
2830 mtx_unlock(&sc->aac_io_lock);
2832 device_printf(sc->aac_dev,
2840 size = cm->cm_fib->Header.Size;
2841 if (size > sc->aac_max_fib_size) {
2842 device_printf(sc->aac_dev, "outbound FIB oversized (%d > %d)\n",
2843 size, sc->aac_max_fib_size);
2844 size = sc->aac_max_fib_size;
2846 error = copyout(cm->cm_fib, ufib, size);
2850 mtx_lock(&sc->aac_io_lock);
2852 mtx_unlock(&sc->aac_io_lock);
2878 mtx_lock(&sc->aac_io_lock);
2886 mtx_unlock(&sc->aac_io_lock);
2889 event->ev_type = AAC_EVENT_CMFREE;
2890 event->ev_callback = aac_ioctl_event;
2891 event->ev_arg = &cm;
2893 msleep(cm, &sc->aac_io_lock, 0, "aacraid_ctlsraw", 0);
2895 mtx_unlock(&sc->aac_io_lock);
2897 cm->cm_data = NULL;
2899 orig_map = cm->cm_datamap;
2901 fib = cm->cm_fib;
2902 srbcmd = (struct aac_srb *)fib->data;
2903 if ((error = copyin((void *)&user_srb->data_len, &fibsize,
2906 if (fibsize > (sc->aac_max_fib_size-sizeof(struct aac_fib_header))) {
2913 srbcmd->function = 0; /* SRBF_ExecuteScsi */
2914 srbcmd->retry_limit = 0; /* obsolete */
2917 if (srbcmd->sg_map.SgCount > 1) {
2923 srbcmd->sg_map.SgCount * sizeof(struct aac_sg_entry))) {
2924 struct aac_sg_entry *sgp = srbcmd->sg_map.SgEntry;
2933 srbcmd->sg_map.SgCount * sizeof(struct aac_sg_entry64))) {
2936 (struct aac_sg_entry64 *)srbcmd->sg_map.SgEntry;
2953 srbcmd->data_len = srb_sg_bytecount;
2954 if (srbcmd->sg_map.SgCount == 1)
2961 if (bus_dma_tag_create(sc->aac_parent_dmat, /* parent */
2963 (sc->flags & AAC_FLAGS_SG_64BIT) ?
2969 sc->aac_sg_tablesize, /* nsegments */
2973 &cm->cm_passthr_dmat)) {
2977 if (bus_dmamem_alloc(cm->cm_passthr_dmat, (void **)&cm->cm_data,
2978 BUS_DMA_NOWAIT, &cm->cm_datamap)) {
2983 cm->cm_datalen = srb_sg_bytecount;
2984 if (srbcmd->flags & AAC_SRB_FLAGS_DATA_IN)
2985 cm->cm_flags |= AAC_CMD_DATAIN;
2986 if (srbcmd->flags & AAC_SRB_FLAGS_DATA_OUT)
2987 cm->cm_flags |= AAC_CMD_DATAOUT;
2989 if (srbcmd->flags & AAC_SRB_FLAGS_DATA_OUT) {
2991 cm->cm_data, cm->cm_datalen)) != 0)
2994 bus_dmamap_sync(cm->cm_passthr_dmat, cm->cm_datamap,
3000 fib->Header.Size = sizeof(struct aac_fib_header) +
3002 fib->Header.XferState =
3011 fib->Header.Command = (sc->flags & AAC_FLAGS_SG_64BIT) ?
3013 cm->cm_sgtable = (struct aac_sg_table *)&srbcmd->sg_map;
3019 bus_dmamap_load(cm->cm_passthr_dmat,
3020 cm->cm_datamap, cm->cm_data,
3021 cm->cm_datalen,
3028 mtx_lock(&sc->aac_io_lock);
3029 while (!(cm->cm_flags & AAC_CMD_COMPLETED))
3030 msleep(cm, &sc->aac_io_lock, 0, "aacraid_ctlsrw2", 0);
3031 mtx_unlock(&sc->aac_io_lock);
3034 if (transfer_data && (le32toh(srbcmd->flags) & AAC_SRB_FLAGS_DATA_IN)) {
3035 if ((error = copyout(cm->cm_data,
3037 cm->cm_datalen)) != 0)
3040 bus_dmamap_sync(cm->cm_passthr_dmat, cm->cm_datamap,
3045 aac_srb_response_toh((struct aac_srb_response *)fib->data);
3046 error = copyout(fib->data, user_reply, sizeof(struct aac_srb_response));
3049 if (cm && cm->cm_data) {
3051 bus_dmamap_unload(cm->cm_passthr_dmat, cm->cm_datamap);
3052 bus_dmamem_free(cm->cm_passthr_dmat, cm->cm_data, cm->cm_datamap);
3053 cm->cm_datamap = orig_map;
3055 if (cm && cm->cm_passthr_dmat)
3056 bus_dma_tag_destroy(cm->cm_passthr_dmat);
3058 mtx_lock(&sc->aac_io_lock);
3060 mtx_unlock(&sc->aac_io_lock);
3077 sc->aif_pending = 1;
3080 sc->aif_pending = 0;
3083 fib = cm->cm_fib;
3084 fib->Header.Size = sizeof(struct aac_fib);
3085 fib->Header.XferState =
3094 fib->Header.Handle = 0x00800000;
3095 fib->Header.Command = AifRequest;
3096 ((struct aac_aif_command *)fib->data)->command = htole32(AifReqEvent);
3111 device_unbusy(sc->aac_dev);
3132 aif = (struct aac_aif_command*)&fib->data[0];
3136 switch (le32toh(aif->command)) {
3138 switch (le32toh(aif->data.EN.type)) {
3143 * doesn't tell us anything else! Re-enumerate the
3162 * co->co_found was already set to 0 in a
3169 &sc->aac_container_tqh,
3171 if (co->co_mntobj.ObjectId ==
3173 co->co_found = 1;
3200 * were not marked 'found'. Since the controller didn't
3203 * the co->co_found field.
3205 co = TAILQ_FIRST(&sc->aac_container_tqh);
3207 if (co->co_found == 0) {
3209 TAILQ_REMOVE(&sc->aac_container_tqh, co,
3215 co->co_found = 0;
3222 if (sc->cam_rescan_cb != NULL)
3223 sc->cam_rescan_cb(sc, 0,
3230 switch (le32toh(aif->data.EN.data.EEE.eventType)) {
3233 channel = le32toh(aif->data.EN.data.EEE.unitID);
3234 if (sc->cam_rescan_cb != NULL)
3235 sc->cam_rescan_cb(sc,
3245 channel = le32toh(aif->data.EN.data.ECE.container);
3246 if (sc->cam_rescan_cb != NULL)
3247 sc->cam_rescan_cb(sc, ((channel>>24) & 0xF) + 1,
3260 current = sc->aifq_idx;
3263 sc->aifq_filled = 1;
3264 bcopy(fib, &sc->aac_aifq[current], sizeof(struct aac_fib));
3266 aac_fib_header_tole(&sc->aac_aifq[current].Header);
3268 if (sc->aifq_filled) {
3269 for (ctx = sc->fibctx; ctx; ctx = ctx->next) {
3270 if (next == ctx->ctx_idx)
3271 ctx->ctx_wrap = 1;
3272 else if (current == ctx->ctx_idx && ctx->ctx_wrap)
3273 ctx->ctx_idx = next;
3276 sc->aifq_idx = next;
3278 if (sc->aac_state & AAC_STATE_AIF_SLEEPER)
3279 wakeup(sc->aac_aifq);
3281 selwakeuppri(&sc->rcv_select, PRIBIO);
3289 * our driver doesn't follow Adaptec's versioning system. Cheat by just
3346 mtx_lock(&sc->aac_io_lock);
3348 if (sc->fibctx == NULL)
3349 sc->fibctx = fibctx;
3351 for (ctx = sc->fibctx; ctx->next; ctx = ctx->next)
3353 ctx->next = fibctx;
3354 fibctx->prev = ctx;
3358 fibctx->unique = (*(u_int32_t *)&fibctx & 0xffffffff);
3359 ctx = sc->fibctx;
3361 if (ctx->unique == fibctx->unique) {
3362 fibctx->unique++;
3363 ctx = sc->fibctx;
3365 ctx = ctx->next;
3369 error = copyout(&fibctx->unique, (void *)arg, sizeof(u_int32_t));
3370 mtx_unlock(&sc->aac_io_lock);
3386 mtx_lock(&sc->aac_io_lock);
3387 for (ctx = sc->fibctx; ctx; ctx = ctx->next) {
3388 if (ctx->unique == *(uint32_t *)&arg) {
3389 if (ctx == sc->fibctx)
3390 sc->fibctx = NULL;
3392 ctx->prev->next = ctx->next;
3393 if (ctx->next)
3394 ctx->next->prev = ctx->prev;
3402 mtx_unlock(&sc->aac_io_lock);
3418 mtx_lock(&sc->aac_io_lock);
3432 for (ctx = sc->fibctx; ctx; ctx = ctx->next) {
3433 if (agf.AdapterFibContext == ctx->unique)
3437 mtx_unlock(&sc->aac_io_lock);
3444 sc->aac_state |= AAC_STATE_AIF_SLEEPER;
3446 mtx_unlock(&sc->aac_io_lock);
3447 error = tsleep(sc->aac_aifq, PRIBIO |
3449 mtx_lock(&sc->aac_io_lock);
3453 sc->aac_state &= ~AAC_STATE_AIF_SLEEPER;
3456 mtx_unlock(&sc->aac_io_lock);
3470 current = ctx->ctx_idx;
3471 if (current == sc->aifq_idx && !ctx->ctx_wrap) {
3476 copyout(&sc->aac_aifq[current], (void *)uptr, sizeof(struct aac_fib));
3478 device_printf(sc->aac_dev,
3481 ctx->ctx_wrap = 0;
3482 ctx->ctx_idx = (current + 1) % AAC_AIFQ_LENGTH;
3498 pciinf.bus = pci_get_bus(sc->aac_dev);
3499 pciinf.slot = pci_get_slot(sc->aac_dev);
3531 (sc->flags & AAC_FLAGS_LBA_64BIT) ? 1 : 0;
3537 (sc->flags & AAC_FLAGS_LBA_64BIT) ? 1 : 0;
3548 * the containers to have b:t:l numbers. Fake it.
3559 mtx_lock(&sc->aac_io_lock);
3563 mtx_unlock(&sc->aac_io_lock);
3568 if (id == -1) {
3569 mtx_unlock(&sc->aac_io_lock);
3573 TAILQ_FOREACH(co, &sc->aac_container_tqh, co_link) {
3574 if (co->co_mntobj.ObjectId == id)
3586 query_disk.Bus = device_get_unit(sc->aac_dev);
3595 mtx_unlock(&sc->aac_io_lock);
3608 device_printf(sc->aac_dev,
3612 child = device_add_child(sc->aac_dev, "aacraidp", DEVICE_UNIT_ANY);
3614 device_printf(sc->aac_dev,
3620 sim->TargetsPerBus = AAC_MAX_CONTAINERS;
3621 sim->BusNumber = 0;
3622 sim->BusType = CONTAINER_BUS;
3623 sim->InitiatorBusId = -1;
3624 sim->aac_sc = sc;
3625 sim->sim_dev = child;
3626 sim->aac_cam = NULL;
3630 TAILQ_INSERT_TAIL(&sc->aac_sim_tqh, sim, sim_link);
3633 mir->MntTable[0].VolType));
3635 bus_attach_children(sc->aac_dev);
3651 mtx_lock(&sc->aac_io_lock);
3653 c_cmd = (struct aac_ctcfg *)&fib->data[0];
3656 c_cmd->Command = VM_ContainerConfig;
3657 c_cmd->cmd = CT_GET_SCSI_METHOD;
3658 c_cmd->param = 0;
3664 device_printf(sc->aac_dev, "Error %d sending "
3667 mtx_unlock(&sc->aac_io_lock);
3671 c_resp = (struct aac_ctcfg_resp *)&fib->data[0];
3673 if (c_resp->Status != ST_OK) {
3674 device_printf(sc->aac_dev, "VM_ContainerConfig returned 0x%x\n",
3675 c_resp->Status);
3677 mtx_unlock(&sc->aac_io_lock);
3681 sc->scsi_method_id = c_resp->param;
3683 vmi = (struct aac_vmioctl *)&fib->data[0];
3686 vmi->Command = VM_Ioctl;
3687 vmi->ObjType = FT_DRIVE;
3688 vmi->MethId = sc->scsi_method_id;
3689 vmi->ObjId = 0;
3690 vmi->IoctlCmd = GetBusInfo;
3696 device_printf(sc->aac_dev, "Error %d sending VMIoctl command\n",
3699 mtx_unlock(&sc->aac_io_lock);
3703 vmi_resp = (struct aac_vmi_businf_resp *)&fib->data[0];
3705 if (vmi_resp->Status != ST_OK) {
3706 device_printf(sc->aac_dev, "VM_Ioctl returned %d\n",
3707 vmi_resp->Status);
3709 mtx_unlock(&sc->aac_io_lock);
3713 bcopy(&vmi_resp->BusInf, &businfo, sizeof(struct aac_getbusinf));
3715 mtx_unlock(&sc->aac_io_lock);
3724 device_printf(sc->aac_dev,
3729 child = device_add_child(sc->aac_dev, "aacraidp", DEVICE_UNIT_ANY);
3731 device_printf(sc->aac_dev,
3738 caminf->TargetsPerBus = businfo.TargetsPerBus;
3739 caminf->BusNumber = i+1;
3740 caminf->BusType = PASSTHROUGH_BUS;
3741 caminf->InitiatorBusId = -1;
3742 caminf->aac_sc = sc;
3743 caminf->sim_dev = child;
3744 caminf->aac_cam = NULL;
3748 TAILQ_INSERT_TAIL(&sc->aac_sim_tqh, caminf, sim_link);
3772 * Once do an IOP reset, basically have to re-initialize the card as
3788 mtx_assert(&sc->aac_io_lock, MA_OWNED);
3790 if (sc->aac_state & AAC_STATE_RESET) {
3791 device_printf(sc->aac_dev, "aac_reset_adapter() already in progress\n");
3794 sc->aac_state |= AAC_STATE_RESET;
3804 cm->cm_flags |= AAC_CMD_RESET;
3807 if (cm->cm_complete != NULL) {
3808 cm->cm_complete(cm);
3819 cm->cm_flags |= AAC_CMD_RESET;
3822 if (cm->cm_complete != NULL) {
3823 cm->cm_complete(cm);
3834 mtx_unlock(&sc->aac_io_lock);
3835 (void) aacraid_shutdown(sc->aac_dev);
3836 mtx_lock(&sc->aac_io_lock);
3840 if (sc->aac_support_opt2 & AAC_SUPPORTED_MU_RESET) {
3844 * 10000 * 100us = 1000,000us = 1000ms = 1s
3849 waitCount--;
3854 if (ret && !sc->doorbell_mask) {
3859 device_printf(sc->aac_dev,
3863 device_printf(sc->aac_dev,
3869 pc = (struct aac_pause_command *)&fib->data[0];
3870 pc->Command = VM_ContainerConfig;
3871 pc->Type = CT_PAUSE_IO;
3872 pc->Timeout = 1;
3873 pc->Min = 1;
3874 pc->NoRescan = 1;
3883 } else if (sc->doorbell_mask) {
3885 reset_mask = sc->doorbell_mask;
3888 (sc->aac_support_opt2 & AAC_SUPPORTED_DOORBELL_RESET)) {
3893 * 10000 * 100us = 1000,000us = 1000ms = 1s
3898 waitCount--;
3906 max_msix_orig = sc->aac_max_msix;
3907 msi_enabled_orig = sc->msi_enabled;
3908 sc->msi_enabled = FALSE;
3911 if (!(sc->flags & AAC_FLAGS_SYNC_MODE)) {
3912 sc->aac_max_msix = max_msix_orig;
3914 sc->msi_enabled = msi_enabled_orig;
3917 mtx_unlock(&sc->aac_io_lock);
3919 mtx_lock(&sc->aac_io_lock);
3923 sc->aac_state &= ~AAC_STATE_RESET;