Lines Matching +full:spare +full:- +full:regs
1 /*-
2 * SPDX-License-Identifier: BSD-2-Clause
4 * Copyright (c) 2004-2005 HighPoint Technologies, Inc.
164 * Parameters: pMvSataAdapter - pointer to the RR18xx controller this
166 * channelNum - channel number.
173 pAdapter->mvSataAdapter.sataChannel[channelNum] = NULL;
178 PVBus _vbus_p = pVDev->pVBus;
179 IAL_ADAPTER_T *pAdapter = (IAL_ADAPTER_T *)_vbus_p->OsExt;
181 pVDev->u.disk.df_on_line = 0;
182 pVDev->vf_online = 0;
183 if (pVDev->pfnDeviceFailed)
184 CallWhenIdle(_VBUS_P (DPC_PROC)pVDev->pfnDeviceFailed, pVDev);
189 if (pAdapter->ver_601==2 && !pAdapter->beeping) {
190 pAdapter->beeping = 1;
191 BeepOn(pAdapter->mvSataAdapter.adapterIoBaseAddress);
192 set_fail_led(&pAdapter->mvSataAdapter, pVDev->u.disk.mv->channelNumber, 1);
202 PDevice pDevice = &pCmd->pVDevice->u.disk;
203 MV_SATA_ADAPTER * pSataAdapter = pDevice->mv->mvSataAdapter;
205 if (!pDevice->df_on_line) {
207 pCmd->Result = RETURN_BAD_DEVICE;
208 CallAfterReturn(_VBUS_P (DPC_PROC)pCmd->pfnCompletion, pCmd);
212 if (pCmd->RetryCount++>5) {
213 hpt_printk(("too many retries on channel(%d)\n", pDevice->mv->channelNumber));
215 failDevice(pCmd->pVDevice);
216 pCmd->Result = RETURN_IDE_ERROR;
217 CallAfterReturn(_VBUS_P (DPC_PROC)pCmd->pfnCompletion, pCmd);
222 if (MvSataResetChannel(pSataAdapter, pDevice->mv->channelNumber))
227 hpt_printk(("Retry on channel(%d)\n", pDevice->mv->channelNumber));
238 * pAdapter - pointer to the emulated adapter data structure
239 * channelNum - channel number.
252 pAdapter->mvSataAdapter.adapterId, channelNum);
253 return -1;
256 pMvSataChannel = &gMvSataChannels[pAdapter->mvSataAdapter.adapterId][channelNum];
257 pAdapter->mvSataAdapter.sataChannel[channelNum] = pMvSataChannel;
258 pMvSataChannel->channelNumber = channelNum;
259 pMvSataChannel->lba48Address = MV_FALSE;
260 pMvSataChannel->maxReadTransfer = MV_FALSE;
262 pMvSataChannel->requestQueue = (struct mvDmaRequestQueueEntry *)
263 (pAdapter->requestsArrayBaseAlignedAddr + (channelNum * MV_EDMA_REQUEST_QUEUE_SIZE));
264 req_dma_addr = pAdapter->requestsArrayBaseDmaAlignedAddr + (channelNum * MV_EDMA_REQUEST_QUEUE_SIZE);
273 " dma_addr=%llx channel=%d\n", pAdapter->mvSataAdapter.adapterId,
275 return -1;
277 pMvSataChannel->requestQueuePciLowAddress = req_dma_addr;
278 pMvSataChannel->requestQueuePciHiAddress = 0;
280 pAdapter->mvSataAdapter.adapterId, channelNum,
281 pMvSataChannel->requestQueue));
282 pMvSataChannel->responseQueue = (struct mvDmaResponseQueueEntry *)
283 (pAdapter->responsesArrayBaseAlignedAddr + (channelNum * MV_EDMA_RESPONSE_QUEUE_SIZE));
284 rsp_dma_addr = pAdapter->responsesArrayBaseDmaAlignedAddr + (channelNum * MV_EDMA_RESPONSE_QUEUE_SIZE);
291 pAdapter->mvSataAdapter.adapterId, channelNum, (HPT_U64)(ULONG_PTR)rsp_dma_addr);
292 return -1;
294 pMvSataChannel->responseQueuePciLowAddress = rsp_dma_addr;
295 pMvSataChannel->responseQueuePciHiAddress = 0;
297 pAdapter->mvSataAdapter.adapterId, channelNum,
298 pMvSataChannel->responseQueue));
300 pAdapter->mvChannel[channelNum].online = MV_TRUE;
313 * Returns: =0 ->success, < 0 ->failure.
319 MV_U16 *iden = pMvSataChannel->identifyDevice;
325 return -1;
329 KdPrint(("%25s - %s\n", "Capabilities", "LBA supported"));
335 return -1;
339 KdPrint(("%25s - %s\n", "Capabilities", "DMA supported"));
345 return -1;
347 KdPrint(("%25s - 0x%02x\n", "PIO modes supported",
354 return -1;
360 KdPrint(("%25s - %s\n", "LBA48 addressing", "supported"));
361 pMvSataChannel->lba48Address = MV_TRUE;
365 KdPrint(("%25s - %s\n", "LBA48 addressing", "Not supported"));
366 pMvSataChannel->lba48Address = MV_FALSE;
374 PVDevice pVDev = &pAdapter->VDevices[channel];
375 MV_SATA_CHANNEL *pMvSataChannel = pAdapter->mvSataAdapter.sataChannel[channel];
376 MV_U16_PTR IdentifyData = pMvSataChannel->identifyDevice;
378 pMvSataChannel->outstandingCommands = 0;
380 pVDev->u.disk.mv = pMvSataChannel;
381 pVDev->u.disk.df_on_line = 1;
382 pVDev->u.disk.pVBus = &pAdapter->VBus;
383 pVDev->pVBus = &pAdapter->VBus;
386 if (pMvSataChannel->lba48Address == MV_TRUE)
387 pVDev->u.disk.dDeRealCapacity = ((IdentifyData[101]<<16) | IdentifyData[100]) - 1;
391 pVDev->u.disk.dDeRealCapacity =
394 (IdentifyData[58]<<16 | IdentifyData[57])) - 1;
396 pVDev->u.disk.dDeRealCapacity =
397 (IdentifyData[61]<<16 | IdentifyData[60]) - 1;
399 pVDev->u.disk.bDeUsable_Mode = pVDev->u.disk.bDeModeSetting =
400 pAdapter->mvChannel[channel].maxPioModeSupported - MV_ATA_TRANSFER_PIO_0;
402 if (pAdapter->mvChannel[channel].maxUltraDmaModeSupported!=0xFF) {
403 pVDev->u.disk.bDeUsable_Mode = pVDev->u.disk.bDeModeSetting =
404 pAdapter->mvChannel[channel].maxUltraDmaModeSupported - MV_ATA_TRANSFER_UDMA_0 + 8;
411 MV_SATA_ADAPTER *pMvSataAdapter = &pAdapter->mvSataAdapter;
412 MV_SATA_CHANNEL *pMvSataChannel = pMvSataAdapter->sataChannel[channelIndex];
418 pVDev = &(pAdapter->VDevices[channelIndex]);
421 pVDev->VDeviceType = pVDev->u.disk.df_atapi? VD_ATAPI :
422 pVDev->u.disk.df_removable_drive? VD_REMOVABLE : VD_SINGLE_DISK;
424 pVDev->VDeviceCapacity = pVDev->u.disk.dDeRealCapacity-SAVE_FOR_RAID_INFO;
425 pVDev->pfnSendCommand = pfnSendCommand[pVDev->VDeviceType];
426 pVDev->pfnDeviceFailed = pfnDeviceFailed[pVDev->VDeviceType];
427 pVDev->vf_online = 1;
430 if(pVDev->pParent)
433 for(iMember = 0; iMember < pVDev->pParent->u.array.bArnMember; iMember++)
434 if((PVDevice)pVDev->pParent->u.array.pMember[iMember] == pVDev)
435 pVDev->pParent->u.array.pMember[iMember] = NULL;
436 pVDev->pParent = NULL;
444 if (pAdapter->beeping) {
445 pAdapter->beeping = 0;
446 BeepOff(pAdapter->mvSataAdapter.adapterIoBaseAddress);
453 pVDev = &(pAdapter->VDevices[channelIndex]);
461 MV_SATA_ADAPTER *pMvSataAdapter = &pAdapter->mvSataAdapter;
462 MV_SATA_CHANNEL *pMvSataChannel = pMvSataAdapter->sataChannel[channelNum];
463 MV_CHANNEL *pChannelInfo = &(pAdapter->mvChannel[channelNum]);
466 KdPrint(("RR18xx [%d]: start channel (%d)", pMvSataAdapter->adapterId,
474 pMvSataAdapter->adapterId, channelNum);
475 return -1;
481 /* If failed, try again - this is when trying to hardreset a channel */
487 pMvSataAdapter->adapterId, channelNum);
488 return -1;
496 , pMvSataAdapter->adapterId, channelNum);
497 return -1;
502 , pMvSataAdapter->adapterId, channelNum);
503 return -1;
508 if (pMvSataChannel->identifyDevice[86] & 4)
511 pMvSataAdapter->adapterId));
517 " failed\n", pMvSataAdapter->adapterId, channelNum);
518 return -1;
523 if (pMvSataChannel->identifyDevice[82] & 0x20)
525 if (!(pMvSataChannel->identifyDevice[85] & 0x20)) /* if not enabled by default */
532 pMvSataAdapter->adapterId, channelNum);
533 return -1;
537 pMvSataAdapter->adapterId, channelNum));
542 pMvSataAdapter->adapterId, channelNum));
546 if (pMvSataChannel->identifyDevice[85] & 0x20)
549 pMvSataAdapter->adapterId, channelNum));
555 pMvSataAdapter->adapterId, channelNum);
556 return -1;
560 pMvSataAdapter->adapterId, channelNum));
566 pMvSataAdapter->adapterId));
573 pMvSataAdapter->adapterId, channelNum);
574 return -1;
577 if (pMvSataChannel->identifyDevice[IDEN_PIO_MODE_SPPORTED] & 1)
581 else if (pMvSataChannel->identifyDevice[IDEN_PIO_MODE_SPPORTED] & 2)
592 pMvSataAdapter->adapterId));
593 pAdapter->mvChannel[channelNum].maxPioModeSupported = pioMode;
599 pMvSataAdapter->adapterId, channelNum);
600 return -1;
604 if (pMvSataChannel->identifyDevice[IDEN_UDMA_MODE] & 0x40)
608 else if (pMvSataChannel->identifyDevice[IDEN_UDMA_MODE] & 0x20)
612 else if (pMvSataChannel->identifyDevice[IDEN_UDMA_MODE] & 0x10)
616 else if (pMvSataChannel->identifyDevice[IDEN_UDMA_MODE] & 8)
620 else if (pMvSataChannel->identifyDevice[IDEN_UDMA_MODE] & 4)
626 pMvSataAdapter->adapterId, udmaMode & 0xf));
627 pChannelInfo->maxUltraDmaModeSupported = udmaMode;
634 pMvSataAdapter->adapterId, channelNum);
635 return -1;
637 if (pChannelInfo->maxUltraDmaModeSupported == 0xFF)
644 pChannelInfo->maxUltraDmaModeSupported,
647 if (pChannelInfo->maxUltraDmaModeSupported > MV_ATA_TRANSFER_UDMA_0)
651 MV_REG_WRITE_BYTE(pMvSataAdapter->adapterIoBaseAddress,
652 pMvSataChannel->eDmaRegsOffset +
662 pChannelInfo->maxUltraDmaModeSupported--;
672 if (pMvSataChannel->identifyDevice[82] & 0x40)
674 if (!(pMvSataChannel->identifyDevice[85] & 0x40)) /* if not enabled by default */
681 pMvSataAdapter->adapterId, channelNum);
682 return -1;
686 pMvSataAdapter->adapterId, channelNum));
691 pMvSataAdapter->adapterId, channelNum));
695 if (pMvSataChannel->identifyDevice[86] & 0x20)
698 pMvSataAdapter->adapterId, channelNum));
704 pMvSataAdapter->adapterId, channelNum);
705 return -1;
709 pMvSataAdapter->adapterId, channelNum));
716 pMvSataAdapter->adapterId,
722 pMvSataAdapter->adapterId, channelNum);
723 return -1;
730 pMvSataAdapter->adapterId, channelNum);
731 return -1;
734 pMvSataAdapter->adapterId, channelNum);
746 MV_SATA_ADAPTER *pMvSataAdapter = &pAdapter->mvSataAdapter;
749 mtx_assert(&pAdapter->lock, MA_OWNED);
750 /* mvOsSemTake(&pMvSataAdapter->semaphore); */
753 switch(pAdapter->sataEvents[channelIndex])
760 pMvSataAdapter->adapterId, channelIndex));
765 pMvSataAdapter->adapterId, channelIndex);
774 pMvSataAdapter->adapterId, channelIndex);
782 pAdapter->sataEvents[channelIndex] = SATA_EVENT_NO_CHANGE;
790 pMvSataAdapter->adapterId, channelIndex));
792 if(pMvSataAdapter->sataChannel[channelIndex])
794 _VBUS_INST(&pAdapter->VBus)
800 pMvSataAdapter->sataChannel[channelIndex] = NULL;
802 pMvSataAdapter->adapterId, channelIndex));
803 if (pAdapter->outstandingCommands==0 && DPC_Request_Nums==0)
809 pMvSataAdapter->adapterId, channelIndex));
811 pAdapter->sataEvents[channelIndex] = SATA_EVENT_NO_CHANGE;
821 /* mvOsSemRelease(&pMvSataAdapter->semaphore); */
843 IAL_ADAPTER_T *pAdapter = pMvSataAdapter->IALData;
853 pAdapter->sataEvents[channel] = SATA_EVENT_CHANNEL_CONNECTED;
855 pMvSataAdapter->adapterId, channel));
857 callout_reset(&pAdapter->event_timer_connect, 10 * hz, hptmv_handle_event_connect, pAdapter);
861 pAdapter->sataEvents[channel] = SATA_EVENT_CHANNEL_DISCONNECTED;
863 pMvSataAdapter->adapterId, channel));
866 /*callout_reset(&pAdapter->event_timer_disconnect, 10 * hz, hptmv_handle_event_disconnect, pAdapter); */
875 pMvSataAdapter->adapterId );
886 pMvSataAdapter->adapterId, eventType);
895 pAdapter->requestsArrayBaseAddr = (MV_U8 *)contigmalloc(REQUESTS_ARRAY_SIZE,
897 if (pAdapter->requestsArrayBaseAddr == NULL)
900 " queues\n", pAdapter->mvSataAdapter.adapterId);
901 return -1;
903 pAdapter->requestsArrayBaseDmaAddr = fOsPhysicalAddress(pAdapter->requestsArrayBaseAddr);
904 pAdapter->requestsArrayBaseAlignedAddr = pAdapter->requestsArrayBaseAddr;
905 pAdapter->requestsArrayBaseAlignedAddr += MV_EDMA_REQUEST_QUEUE_SIZE;
906 pAdapter->requestsArrayBaseAlignedAddr = (MV_U8 *)
907 (((ULONG_PTR)pAdapter->requestsArrayBaseAlignedAddr) & ~(ULONG_PTR)(MV_EDMA_REQUEST_QUEUE_SIZE - 1));
908 pAdapter->requestsArrayBaseDmaAlignedAddr = pAdapter->requestsArrayBaseDmaAddr;
909 pAdapter->requestsArrayBaseDmaAlignedAddr += MV_EDMA_REQUEST_QUEUE_SIZE;
910 pAdapter->requestsArrayBaseDmaAlignedAddr &= ~(ULONG_PTR)(MV_EDMA_REQUEST_QUEUE_SIZE - 1);
912 if ((pAdapter->requestsArrayBaseDmaAlignedAddr - pAdapter->requestsArrayBaseDmaAddr) !=
913 (pAdapter->requestsArrayBaseAlignedAddr - pAdapter->requestsArrayBaseAddr))
916 pAdapter->mvSataAdapter.adapterId);
917 free(pAdapter->requestsArrayBaseAddr, M_DEVBUF);
918 return -1;
921 pAdapter->responsesArrayBaseAddr = (MV_U8 *)contigmalloc(RESPONSES_ARRAY_SIZE,
923 if (pAdapter->responsesArrayBaseAddr == NULL)
926 " queues\n", pAdapter->mvSataAdapter.adapterId);
927 free(pAdapter->requestsArrayBaseAddr, M_DEVBUF);
928 return -1;
930 pAdapter->responsesArrayBaseDmaAddr = fOsPhysicalAddress(pAdapter->responsesArrayBaseAddr);
931 pAdapter->responsesArrayBaseAlignedAddr = pAdapter->responsesArrayBaseAddr;
932 pAdapter->responsesArrayBaseAlignedAddr += MV_EDMA_RESPONSE_QUEUE_SIZE;
933 pAdapter->responsesArrayBaseAlignedAddr = (MV_U8 *)
934 (((ULONG_PTR)pAdapter->responsesArrayBaseAlignedAddr) & ~(ULONG_PTR)(MV_EDMA_RESPONSE_QUEUE_SIZE - 1));
935 pAdapter->responsesArrayBaseDmaAlignedAddr = pAdapter->responsesArrayBaseDmaAddr;
936 pAdapter->responsesArrayBaseDmaAlignedAddr += MV_EDMA_RESPONSE_QUEUE_SIZE;
937 pAdapter->responsesArrayBaseDmaAlignedAddr &= ~(ULONG_PTR)(MV_EDMA_RESPONSE_QUEUE_SIZE - 1);
939 if ((pAdapter->responsesArrayBaseDmaAlignedAddr - pAdapter->responsesArrayBaseDmaAddr) !=
940 (pAdapter->responsesArrayBaseAlignedAddr - pAdapter->responsesArrayBaseAddr))
943 pAdapter->mvSataAdapter.adapterId);
944 free(pAdapter->requestsArrayBaseAddr, M_DEVBUF);
945 free(pAdapter->responsesArrayBaseAddr, M_DEVBUF);
946 return -1;
954 free(pAdapter->requestsArrayBaseAddr, M_DEVBUF);
955 free(pAdapter->responsesArrayBaseAddr, M_DEVBUF);
962 if (pAdapter->pFreePRDLink) {
963 KdPrint(("pAdapter->pFreePRDLink:%p\n",pAdapter->pFreePRDLink));
964 ret = pAdapter->pFreePRDLink;
965 pAdapter->pFreePRDLink = *(void**)ret;
974 *(void**)PRDTable = pAdapter->pFreePRDLink;
975 pAdapter->pFreePRDLink = PRDTable;
988 pPhysical = &(pAdapter->VDevices[i]);
990 while (pLogical->pParent) pLogical = pLogical->pParent;
991 if (pLogical->vf_online==0) {
992 pPhysical->vf_bootmark = pLogical->vf_bootmark = 0;
995 if (pLogical->VDeviceType==VD_SPARE || pPhysical!=fGetFirstChild(pLogical))
998 pVBus = &pAdapter->VBus;
1002 while(j<MAX_VDEVICE_PER_VBUS && pVBus->pVDevice[j]) j++;
1004 pVBus->pVDevice[j] = pLogical;
1005 pLogical->pVBus = pVBus;
1007 if (j>0 && pLogical->vf_bootmark) {
1008 if (pVBus->pVDevice[0]->vf_bootmark) {
1012 do { pVBus->pVDevice[j] = pVBus->pVDevice[j-1]; } while (--j);
1013 pVBus->pVDevice[0] = pLogical;
1024 IAL_ADAPTER_T *pAdapter = (IAL_ADAPTER_T *)pArray->pVBus->OsExt;
1025 LBA_T capacity = LongDiv(pArray->VDeviceCapacity, pArray->u.array.bArnMember-1);
1032 pVDevice = &pAdapter->VDevices[i];
1035 thiscap = pArray->vf_format_v2? pVDevice->u.disk.dDeRealCapacity : pVDevice->VDeviceCapacity;
1036 /* find the smallest usable spare disk */
1037 if (pVDevice->VDeviceType==VD_SPARE &&
1038 pVDevice->u.disk.df_on_line &&
1042 maxcap = pVDevice->VDeviceCapacity;
1055 return mvReadWrite(pDev->mv, Lba, Cmd, tmpBuffer);
1060 MV_SATA_CHANNEL *pSataChannel = pDev->mv;
1061 MV_SATA_ADAPTER *pSataAdapter = pSataChannel->mvSataAdapter;
1062 MV_U8 channelIndex = pSataChannel->channelNumber;
1064 /* 508x don't use MW-DMA? */
1066 pDev->bDeModeSetting = NewMode;
1070 mvMode = MV_ATA_TRANSFER_UDMA_0 + (NewMode-8);
1093 MV_SATA_CHANNEL *pSataChannel = pDev->mv;
1094 MV_SATA_ADAPTER *pSataAdapter = pSataChannel->mvSataAdapter;
1095 MV_U8 channelIndex = pSataChannel->channelNumber;
1096 IAL_ADAPTER_T *pAdapter = pSataAdapter->IALData;
1097 MV_CHANNEL *channelInfo = &(pAdapter->mvChannel[channelIndex]);
1098 int dmaActive = pSataChannel->queueCommandsEnabled;
1107 if (pSataChannel->queuedDMA == MV_EDMA_MODE_NOT_QUEUED &&
1108 (pSataChannel->identifyDevice[IDEN_SUPPORTED_COMMANDS2] & (0x2))) {
1109 UCHAR depth = ((pSataChannel->identifyDevice[IDEN_QUEUE_DEPTH]) & 0x1f) + 1;
1110 channelInfo->queueDepth = (depth==32)? 31 : depth;
1117 if (pSataChannel->queuedDMA != MV_EDMA_MODE_NOT_QUEUED) {
1118 channelInfo->queueDepth = 2;
1136 MV_SATA_CHANNEL *pSataChannel = pDev->mv;
1137 MV_SATA_ADAPTER *pSataAdapter = pSataChannel->mvSataAdapter;
1138 MV_U8 channelIndex = pSataChannel->channelNumber;
1139 IAL_ADAPTER_T *pAdapter = pSataAdapter->IALData;
1140 MV_CHANNEL *channelInfo = &(pAdapter->mvChannel[channelIndex]);
1141 int dmaActive = pSataChannel->queueCommandsEnabled;
1149 if ((pSataChannel->identifyDevice[82] & (0x20))) {
1154 channelInfo->writeCacheEnabled = MV_TRUE;
1162 channelInfo->writeCacheEnabled = MV_FALSE;
1175 MV_SATA_CHANNEL *pSataChannel = pDev->mv;
1176 MV_SATA_ADAPTER *pSataAdapter = pSataChannel->mvSataAdapter;
1177 MV_U8 channelIndex = pSataChannel->channelNumber;
1178 IAL_ADAPTER_T *pAdapter = pSataAdapter->IALData;
1179 MV_CHANNEL *channelInfo = &(pAdapter->mvChannel[channelIndex]);
1180 int dmaActive = pSataChannel->queueCommandsEnabled;
1188 if ((pSataChannel->identifyDevice[82] & (0x40))) {
1193 channelInfo->readAheadEnabled = MV_TRUE;
1201 channelInfo->readAheadEnabled = MV_FALSE;
1220 pVDev->VDeviceType = pDev->df_atapi? VD_ATAPI :
1221 pDev->df_removable_drive? VD_REMOVABLE : VD_SINGLE_DISK;
1222 pVDev->vf_online = 1;
1223 pVDev->VDeviceCapacity = pDev->dDeRealCapacity;
1224 pVDev->pfnSendCommand = pfnSendCommand[pVDev->VDeviceType];
1225 pVDev->pfnDeviceFailed = pfnDeviceFailed[pVDev->VDeviceType];
1232 PBUS_DMAMAP p = pAdapter->pbus_dmamap_list;
1234 pAdapter->pbus_dmamap_list = p-> next;
1241 p->next = p->pAdapter->pbus_dmamap_list;
1242 p->pAdapter->pbus_dmamap_list = p;
1249 PVBus _vbus_p = &pAdapter->VBus;
1255 mtx_init(&pAdapter->lock, "hptsleeplock", NULL, MTX_DEF);
1256 callout_init_mtx(&pAdapter->event_timer_connect, &pAdapter->lock, 0);
1257 callout_init_mtx(&pAdapter->event_timer_disconnect, &pAdapter->lock, 0);
1260 pAdapter->next = 0;
1267 pCurAdapter->next = pAdapter;
1272 pAdapter->outstandingCommands = 0;
1274 pMvSataAdapter = &(pAdapter->mvSataAdapter);
1275 _vbus_p->OsExt = (void *)pAdapter;
1276 pMvSataAdapter->IALData = pAdapter;
1278 if (bus_dma_tag_create(bus_get_dma_tag(pAdapter->hpt_dev),/* parent */
1284 PAGE_SIZE * (MAX_SG_DESCRIPTORS-1), /* maxsize */
1289 &pAdapter->lock, /* lockfuncarg */
1290 &pAdapter->io_dma_parent /* tag */))
1304 if (!(pAdapter->mem_res = bus_alloc_resource_any(pAdapter->hpt_dev,
1307 !(pMvSataAdapter->adapterIoBaseAddress = rman_get_virtual(pAdapter->mem_res)))
1315 KdPrint(("RR18xx: io base address 0x%p\n", pMvSataAdapter->adapterIoBaseAddress));
1318 pMvSataAdapter->adapterId = num_adapters++;
1320 pMvSataAdapter->pciConfigRevisionId = pci_read_config(pAdapter->hpt_dev, PCIR_REVID, 1);
1321 pMvSataAdapter->pciConfigDeviceId = pci_get_device(pAdapter->hpt_dev);
1324 pMvSataAdapter->intCoalThre[0]= 1;
1325 pMvSataAdapter->intCoalThre[1]= 1;
1326 pMvSataAdapter->intTimeThre[0] = 1;
1327 pMvSataAdapter->intTimeThre[1] = 1;
1328 pMvSataAdapter->pciCommand = 0x0107E371;
1329 pMvSataAdapter->pciSerrMask = 0xd77fe6ul;
1330 pMvSataAdapter->pciInterruptMask = 0xd77fe6ul;
1331 pMvSataAdapter->mvSataEventNotify = hptmv_event_notify;
1336 pMvSataAdapter->adapterId);
1338 bus_release_resource(pAdapter->hpt_dev, SYS_RES_MEMORY, rid, pAdapter->mem_res);
1342 pAdapter->ver_601 = pMvSataAdapter->pcbVersion;
1351 pAdapter->pCommandBlocks =
1353 KdPrint(("pCommandBlocks:%p\n",pAdapter->pCommandBlocks));
1354 if (!pAdapter->pCommandBlocks) {
1360 FreeCommand(_VBUS_P &(pAdapter->pCommandBlocks[i]));
1364 pAdapter->pbus_dmamap = (PBUS_DMAMAP)malloc (sizeof(struct _BUS_DMAMAP) * MAX_QUEUE_COMM, M_DEVBUF, M_NOWAIT);
1365 if(!pAdapter->pbus_dmamap) {
1367 free(pAdapter->pCommandBlocks, M_DEVBUF);
1371 memset((void *)pAdapter->pbus_dmamap, 0, sizeof(struct _BUS_DMAMAP) * MAX_QUEUE_COMM);
1372 pAdapter->pbus_dmamap_list = 0;
1374 PBUS_DMAMAP pmap = &(pAdapter->pbus_dmamap[i]);
1375 pmap->pAdapter = pAdapter;
1378 if(bus_dmamap_create(pAdapter->io_dma_parent, 0, &pmap->dma_map)) {
1380 free(pAdapter->pCommandBlocks, M_DEVBUF);
1381 free(pAdapter->pbus_dmamap, M_DEVBUF);
1384 callout_init_mtx(&pmap->timeout, &pAdapter->lock, 0);
1388 pAdapter->pFreePRDLink = 0;
1390 pAdapter->prdTableAddr = (PUCHAR)contigmalloc(
1393 KdPrint(("prdTableAddr:%p\n",pAdapter->prdTableAddr));
1394 if (!pAdapter->prdTableAddr) {
1398 pAdapter->prdTableAlignedAddr = (PUCHAR)(((ULONG_PTR)pAdapter->prdTableAddr + 0x1f) & ~(ULONG_PTR)0x1fL);
1400 PUCHAR PRDTable = pAdapter->prdTableAlignedAddr;
1403 /* KdPrint(("i=%d,pAdapter->pFreePRDLink=%p\n",i,pAdapter->pFreePRDLink)); */
1414 pAdapter->mvChannel[channel].online = MV_FALSE;
1419 pMvSataAdapter->adapterId, channel));
1426 " %d\n",pMvSataAdapter->adapterId, channel);
1434 " channel=%d\n",pMvSataAdapter->adapterId,
1438 pAdapter->mvChannel[channel].online = MV_TRUE;
1445 KdPrint(("pAdapter->mvChannel[channel].online:%x, channel:%d\n",
1446 pAdapter->mvChannel[channel].online, channel));
1450 for(i = MAX_ARRAY_DEVICE - 1; i >= 0; i--) {
1458 MV_SATA_CHANNEL *pMvSataChannel = pMvSataAdapter->sataChannel[channel];
1461 IdeRegisterVDevice(&pAdapter->VDevices[channel].u.disk);
1467 _vbus_p->nInstances = 1;
1471 pVDev = _vbus_p->pVDevice[channel];
1472 if (pVDev && pVDev->vf_online)
1479 printf("RR18xx: RAID5 write-back %s\n", _vbus_(r5).enable_write_back? "enabled" : "disabled");
1489 IAL_ADAPTER_T *pAdapter = (IAL_ADAPTER_T *)pMvSataAdapter->IALData;
1499 pMvSataAdapter->adapterId, channel);
1501 return -1;
1508 pMvSataAdapter->adapterId, channel);
1510 return -1;
1516 pMvSataAdapter->adapterId, channel);
1518 return -1;
1545 pAdapter->mvChannel[channel].maxPioModeSupported, 0, 0, 0) == MV_FALSE) ||
1548 pAdapter->mvChannel[channel].maxUltraDmaModeSupported, 0, 0, 0) == MV_FALSE) )
1552 return -1;
1559 return -1;
1568 MV_SATA_ADAPTER *pMvSataAdapter = &((IAL_ADAPTER_T *)_vbus_p->OsExt)->mvSataAdapter;
1571 if (pMvSataAdapter->sataChannel[channel] && pMvSataAdapter->sataChannel[channel]->outstandingCommands)
1582 MV_SATA_ADAPTER *pMvSataAdapter = &((IAL_ADAPTER_T *)_vbus_p->OsExt)->mvSataAdapter;
1594 pMvSataChannel = pMvSataAdapter->sataChannel[channel];
1595 if (pMvSataChannel && pMvSataChannel->outstandingCommands)
1597 while (pMvSataChannel->outstandingCommands) {
1650 _VBUS_INST(pCmd->pVDevice->pVBus)
1652 if (pCmd->uScratch.sata_param.prdAddr)
1653 FreePRDTable(pMvSataAdapter->IALData,pCmd->uScratch.sata_param.prdAddr);
1658 pCmd->Result = RETURN_SUCCESS;
1661 pCmd->Result = RETURN_BUS_RESET;
1665 pMvSataAdapter->adapterId, channelNum, responseFlags);
1668 MV_ERROR("ATA regs: error %x, sector count %x, LBA low %x, LBA mid %x,"
1670 registerStruct->errorRegister,
1671 registerStruct->sectorCountRegister,
1672 registerStruct->lbaLowRegister,
1673 registerStruct->lbaMidRegister,
1674 registerStruct->lbaHighRegister,
1675 registerStruct->deviceRegister,
1676 registerStruct->statusRegister);
1680 pCmd->uScratch.sata_param.responseFlags = responseFlags;
1681 pCmd->uScratch.sata_param.bIdeStatus = registerStruct->statusRegister;
1682 pCmd->uScratch.sata_param.errorRegister = registerStruct->errorRegister;
1683 pCmd->pVDevice->u.disk.QueueLength--;
1692 if (pCmd->uCmd.Ide.Command == IDE_COMMAND_VERIFY && pCmd->uScratch.sata_param.cmd_priv > 1) {
1693 pCmd->uScratch.sata_param.cmd_priv --;
1696 pCmd->pVDevice->u.disk.QueueLength--;
1697 CallAfterReturn(_VBUS_P (DPC_PROC)pCmd->pfnCompletion, pCmd);
1707 PVDevice pVDevice = pCmd->pVDevice;
1708 PDevice pDevice = &pVDevice->u.disk;
1709 LBA_T Lba = pCmd->uCmd.Ide.Lba;
1710 USHORT nSector = pCmd->uCmd.Ide.nSectors;
1723 if (!pDevice->df_on_line) {
1725 pCmd->Result = RETURN_BAD_DEVICE;
1726 CallAfterReturn(_VBUS_P (DPC_PROC)pCmd->pfnCompletion, pCmd);
1730 pDevice->HeadPosition = pCmd->uCmd.Ide.Lba + pCmd->uCmd.Ide.nSectors;
1731 pMvSataChannel = pDevice->mv;
1732 pMvSataAdapter = pMvSataChannel->mvSataAdapter;
1733 channel = pMvSataChannel->channelNumber;
1736 Lba += pDevice->dDeHiddenLba;
1738 if (Lba+nSector-1 > pDevice->dDeRealCapacity) {
1739 pCmd->Result = RETURN_INVALID_REQUEST;
1740 CallAfterReturn(_VBUS_P (DPC_PROC)pCmd->pfnCompletion, pCmd);
1746 * Some Seagate drives report error if you use a 28-bit command
1749 is48bit = pMvSataChannel->lba48Address;
1751 switch (pCmd->uCmd.Ide.Command)
1755 if (pDevice->bDeModeSetting<8) goto pio;
1758 pUdmaParams->isEXT = is48bit;
1759 pUdmaParams->numOfSectors = nSector;
1760 pUdmaParams->lowLBAAddress = Lba;
1761 pUdmaParams->highLBAAddress = 0;
1762 pUdmaParams->prdHighAddr = 0;
1763 pUdmaParams->callBack = CommandCompletionCB;
1764 pUdmaParams->commandId = (MV_VOID_PTR )pCmd;
1765 if(pCmd->uCmd.Ide.Command == IDE_COMMAND_READ)
1766 pUdmaParams->readWrite = MV_UDMA_TYPE_READ;
1768 pUdmaParams->readWrite = MV_UDMA_TYPE_WRITE;
1770 if (pCmd->pSgTable && pCmd->cf_physical_sg) {
1771 FPSCAT_GATH sg1=tmpSg, sg2=pCmd->pSgTable;
1772 do { *sg1++=*sg2; } while ((sg2++->wSgFlag & SG_FLAG_EOT)==0);
1775 if (!pCmd->pfnBuildSgl || !pCmd->pfnBuildSgl(_VBUS_P pCmd, tmpSg, 0)) {
1780 if (pCmd->pSgTable && pCmd->cf_physical_sg==0) {
1781 FPSCAT_GATH sg1=tmpSg, sg2=pCmd->pSgTable;
1782 do { *sg1++=*sg2; } while ((sg2++->wSgFlag & SG_FLAG_EOT)==0);
1785 if (!pCmd->pfnBuildSgl || !pCmd->pfnBuildSgl(_VBUS_P pCmd, tmpSg, 1)) {
1786 pCmd->Result = RETURN_NEED_LOGICAL_SG;
1792 ULONG size = tmpSg->wSgSize? tmpSg->wSgSize : 0x10000;
1793 ULONG_PTR addr = tmpSg->dSgAddress;
1795 pCmd->Result = RETURN_INVALID_REQUEST;
1799 (pCmd->cf_data_out)?MV_NON_UDMA_PROTOCOL_PIO_DATA_OUT:MV_NON_UDMA_PROTOCOL_PIO_DATA_IN,
1809 (MV_U8)(is48bit ? (pCmd->cf_data_in?IDE_COMMAND_READ_EXT:IDE_COMMAND_WRITE_EXT):pCmd->uCmd.Ide.Command)
1812 pCmd->Result = RETURN_IDE_ERROR;
1818 while ((tmpSg++->wSgFlag & SG_FLAG_EOT)==0);
1819 pCmd->Result = RETURN_SUCCESS;
1822 CallAfterReturn(_VBUS_P (DPC_PROC)pCmd->pfnCompletion, pCmd);
1827 pPRDTable = (MV_SATA_EDMA_PRD_ENTRY *) AllocatePRDTable(pMvSataAdapter->IALData);
1830 pCmd->Result = RETURN_DEVICE_BUSY;
1831 CallAfterReturn(_VBUS_P (DPC_PROC)pCmd->pfnCompletion, pCmd);
1837 pPRDTable[i].highBaseAddr = (sizeof(tmpSg->dSgAddress)>4 ? (MV_U32)(tmpSg->dSgAddress>>32) : 0);
1838 pPRDTable[i].flags = (MV_U16)tmpSg->wSgFlag;
1839 pPRDTable[i].byteCount = (MV_U16)tmpSg->wSgSize;
1840 pPRDTable[i].lowBaseAddr = (MV_U32)tmpSg->dSgAddress;
1843 }while((tmpSg++->wSgFlag & SG_FLAG_EOT)==0);
1845 pUdmaParams->prdLowAddr = (ULONG)fOsPhysicalAddress(pPRDTable);
1846 if ((pUdmaParams->numOfSectors == 256) && (pMvSataChannel->lba48Address == MV_FALSE)) {
1847 pUdmaParams->numOfSectors = 0;
1850 pCmd->uScratch.sata_param.prdAddr = (PVOID)pPRDTable;
1861 "LBA[31:0](0x%08x)\n", pUdmaParams->lowLBAAddress);
1862 pCmd->Result = RETURN_IDE_ERROR;
1867 pMvSataAdapter->adapterId, channel);
1869 pCmd->Result = RETURN_IDE_ERROR;
1874 pMvSataAdapter->adapterId, channel);
1875 pCmd->Result = RETURN_DEVICE_BUSY;
1880 pMvSataAdapter, pMvSataAdapter->sataChannel[channel]);
1881 pCmd->Result = RETURN_IDE_ERROR;
1886 pCmd->Result = RETURN_IDE_ERROR;
1889 FreePRDTable(pMvSataAdapter->IALData,pPRDTable);
1890 CallAfterReturn(_VBUS_P (DPC_PROC)pCmd->pfnCompletion, pCmd);
1892 pDevice->QueueLength++;
1897 pNoUdmaParams->bufPtr = NULL;
1898 pNoUdmaParams->callBack = CommandCompletionCB;
1899 pNoUdmaParams->commandId = (MV_VOID_PTR)pCmd;
1900 pNoUdmaParams->count = 0;
1901 pNoUdmaParams->features = 0;
1902 pNoUdmaParams->protocolType = MV_NON_UDMA_PROTOCOL_NON_DATA;
1904 pCmd->uScratch.sata_param.cmd_priv = 1;
1905 if (pMvSataChannel->lba48Address == MV_TRUE){
1906 pNoUdmaParams->command = MV_ATA_COMMAND_READ_VERIFY_SECTORS_EXT;
1907 pNoUdmaParams->isEXT = MV_TRUE;
1908 pNoUdmaParams->lbaHigh = (MV_U16)((Lba & 0xff0000) >> 16);
1909 pNoUdmaParams->lbaMid = (MV_U16)((Lba & 0xff00) >> 8);
1910 pNoUdmaParams->lbaLow =
1912 pNoUdmaParams->sectorCount = nSector;
1913 pNoUdmaParams->device = 0x40;
1921 pNoUdmaParams->command = MV_ATA_COMMAND_READ_VERIFY_SECTORS;
1922 pNoUdmaParams->isEXT = MV_FALSE;
1923 pNoUdmaParams->lbaHigh = (MV_U16)((Lba & 0xff0000) >> 16);
1924 pNoUdmaParams->lbaMid = (MV_U16)((Lba & 0xff00) >> 8);
1925 pNoUdmaParams->lbaLow = (MV_U16)(Lba & 0xff);
1926 pNoUdmaParams->sectorCount = 0xff & nSector;
1927 pNoUdmaParams->device = (MV_U8)(0x40 |
1929 pNoUdmaParams->callBack = CommandCompletionCB;
1938 pCmd->Result = RETURN_INVALID_REQUEST;
1939 CallAfterReturn(_VBUS_P (DPC_PROC)pCmd->pfnCompletion, pCmd);
1983 pAdapter->hpt_dev = dev;
1990 if ((pAdapter->hpt_irq = bus_alloc_resource_any(pAdapter->hpt_dev, SYS_RES_IRQ, &rid, RF_SHAREABLE | RF_ACTIVE)) == NULL)
1996 if (bus_setup_intr(pAdapter->hpt_dev, pAdapter->hpt_irq,
1998 NULL, hpt_intr, pAdapter, &pAdapter->hpt_intr))
2007 ccb->ccb_h.pinfo.priority = 1;
2008 ccb->ccb_h.pinfo.index = CAM_UNQUEUED_INDEX;
2023 pAdapter, device_get_unit(pAdapter->hpt_dev),
2024 &pAdapter->lock, 1, 8, devq);
2030 mtx_lock(&pAdapter->lock);
2034 mtx_unlock(&pAdapter->lock);
2039 if(xpt_create_path(&pAdapter->path, /*periph */ NULL,
2045 mtx_unlock(&pAdapter->lock);
2049 mtx_unlock(&pAdapter->lock);
2051 xpt_setup_ccb(&(ccb->ccb_h), pAdapter->path, /*priority*/5);
2052 ccb->ccb_h.func_code = XPT_SASYNC_CB;
2053 ccb->csa.event_enable = AC_LOST_DEVICE;
2054 ccb->csa.callback = hpt_async;
2055 ccb->csa.callback_arg = hpt_vsim;
2096 mtx_lock(&pAdapter->lock);
2098 mtx_unlock(&pAdapter->lock);
2105 mtx_assert(&pAdapter->lock, MA_OWNED);
2106 /* KdPrintI(("----- Entering Isr() -----\n")); */
2107 if (mvSataInterruptServiceRoutine(&pAdapter->mvSataAdapter) == MV_TRUE)
2109 _VBUS_INST(&pAdapter->VBus)
2113 /* KdPrintI(("----- Leaving Isr() -----\n")); */
2145 PVDevice pVDev = pAdapter->VBus.pVDevice[i];
2157 mtx_lock(&pAdapter->lock);
2159 mtx_unlock(&pAdapter->lock);
2161 *otherwise "shutdown -p now" will make file system corrupted */
2169 _VBUS_INST(&pAdapter->VBus)
2178 if ((pArray=ArrayTables(i))->u.array.dArStamp==0)
2180 else if (pArray->u.array.rf_auto_rebuild) {
2182 pArray->u.array.rf_auto_rebuild = 0;
2190 while(pAdapter->pending_Q!= NULL)
2192 _VBUS_INST(&pAdapter->VBus)
2193 union ccb *ccb = (union ccb *)pAdapter->pending_Q->ccb_h.ccb_ccb_ptr;
2194 hpt_free_ccb(&pAdapter->pending_Q, ccb);
2202 PBUS_DMAMAP pmap = (PBUS_DMAMAP)ccb->ccb_adapter;
2203 IAL_ADAPTER_T * pAdapter = pmap->pAdapter;
2204 KdPrintI(("ccb_done: ccb %p status %x\n", ccb, ccb->ccb_h.status));
2209 pAdapter->outstandingCommands--;
2211 if (pAdapter->outstandingCommands == 0)
2222 * Parameters: sim - Pointer to SIM object
2223 * ccb - Pointer to SCSI command structure.
2231 _VBUS_INST(&pAdapter->VBus)
2233 mtx_assert(&pAdapter->lock, MA_OWNED);
2234 CAM_DEBUG(ccb->ccb_h.path, CAM_DEBUG_TRACE, ("hpt_action\n"));
2235 KdPrint(("hpt_action(%lx,%lx{%x})\n", (u_long)sim, (u_long)ccb, ccb->ccb_h.func_code));
2237 switch (ccb->ccb_h.func_code)
2241 /* ccb->ccb_h.path_id is not our bus id - don't check it */
2243 if (ccb->ccb_h.target_lun) {
2244 ccb->ccb_h.status = CAM_LUN_INVALID;
2248 if (ccb->ccb_h.target_id >= MAX_VDEVICE_PER_VBUS ||
2249 pAdapter->VBus.pVDevice[ccb->ccb_h.target_id]==0) {
2250 ccb->ccb_h.status = CAM_TID_INVALID;
2255 if (pAdapter->outstandingCommands==0 && DPC_Request_Nums==0)
2260 ccb->ccb_adapter = pmap;
2261 memset((void *)pmap->psg, 0, sizeof(pmap->psg));
2264 hpt_queue_ccb(&pAdapter->pending_Q, ccb);
2282 ccb->ccb_h.status = CAM_REQ_INVALID;
2289 ccb->ccb_h.status = CAM_FUNC_NOTAVAIL;
2294 cam_calc_geometry(&ccb->ccg, 1);
2300 struct ccb_pathinq *cpi = &ccb->cpi;
2302 cpi->version_num = 1; /* XXX??? */
2303 cpi->hba_inquiry = PI_SDTR_ABLE;
2304 cpi->target_sprt = 0;
2306 cpi->hba_misc = PIM_NOBUSRESET;
2307 cpi->hba_eng_cnt = 0;
2309 cpi->max_target = MAX_VDEVICE_PER_VBUS;
2310 cpi->max_lun = 0;
2311 cpi->initiator_id = MAX_VDEVICE_PER_VBUS;
2313 cpi->bus_id = cam_sim_bus(sim);
2314 cpi->base_transfer_speed = 3300;
2315 strlcpy(cpi->sim_vid, "FreeBSD", SIM_IDLEN);
2316 strlcpy(cpi->hba_vid, "HPT ", HBA_IDLEN);
2317 strlcpy(cpi->dev_name, cam_sim_name(sim), DEV_IDLEN);
2318 cpi->unit_number = cam_sim_unit(sim);
2319 cpi->transport = XPORT_SPI;
2320 cpi->transport_version = 2;
2321 cpi->protocol = PROTO_SCSI;
2322 cpi->protocol_version = SCSI_REV_2;
2323 cpi->ccb_h.status = CAM_REQ_CMP;
2330 ccb->ccb_h.status = CAM_REQ_INVALID;
2342 ccb->ccb_h.ccb_ccb_ptr = ccb;
2344 ccb->ccb_h.ccb_ccb_ptr = (*ccb_Q)->ccb_h.ccb_ccb_ptr;
2345 (*ccb_Q)->ccb_h.ccb_ccb_ptr = (char *)ccb;
2359 if(ccb->ccb_h.ccb_ccb_ptr == ccb) /*it means SCpnt is the last one in CURRCMDs*/
2362 while(TempCCB->ccb_h.ccb_ccb_ptr != (char *)ccb)
2363 TempCCB = (union ccb *)TempCCB->ccb_h.ccb_ccb_ptr;
2365 TempCCB->ccb_h.ccb_ccb_ptr = ccb->ccb_h.ccb_ccb_ptr;
2392 mtx_lock(&p.pAdapter->lock);
2394 DPC_Request_Nums--;
2397 if (p.pAdapter->outstandingCommands == 0) {
2398 _VBUS_INST(&p.pAdapter->VBus);
2403 mtx_unlock(&p.pAdapter->lock);
2407 if (SIGISMEMBER(curproc->p_siglist, SIGSTOP)) {
2418 mtx_lock(&pAdapter->lock);
2419 _vbus_p = &pAdapter->VBus;
2423 if ((pArray=ArrayTables(i))->u.array.dArStamp==0)
2425 else if (pArray->u.array.rf_rebuilding ||
2426 pArray->u.array.rf_verifying ||
2427 pArray->u.array.rf_initializing)
2429 pArray->u.array.rf_abort_rebuild = 1;
2432 mtx_unlock(&pAdapter->lock);
2433 pAdapter = pAdapter->next;
2444 if (SIGISMEMBER(curproc->p_siglist, SIGSTOP))
2449 pause("-", 2*hz); /* wait for something to do */
2469 for (pAdapTemp = gIal_Adapter; pAdapTemp; pAdapTemp = pAdapTemp->next) {
2471 _VBUS_INST(&pAdapTemp->VBus)
2476 if ((pVDev=ArrayTables(i))->u.array.dArStamp==0)
2479 if (pVDev->u.array.rf_need_rebuild && !pVDev->u.array.rf_rebuilding)
2481 (UCHAR)((pVDev->u.array.CriticalMembers || pVDev->VDeviceType == VD_RAID_1)? DUPLICATE : REBUILD_PARITY));
2502 union ccb *ccb = (union ccb *)pCmd->pOrgCommand;
2505 pSg->dSgAddress = (ULONG_PTR)(UCHAR *)ccb->csio.data_ptr;
2506 pSg->wSgSize = ccb->csio.dxfer_len;
2507 pSg->wSgFlag = SG_FLAG_EOT;
2533 IDENTIFY_DATA2 *pIdentify = (IDENTIFY_DATA2*)pVDev->u.disk.mv->identifyDevice;
2535 inquiryData->DeviceType = T_DIRECT; /*DIRECT_ACCESS_DEVICE*/
2536 inquiryData->AdditionalLength = (UCHAR)(sizeof(INQUIRYDATA) - 5);
2538 inquiryData->CommandQueue = 1;
2541 switch(pVDev->VDeviceType) {
2546 if ((pVDev->u.disk.df_removable_drive) || (pIdentify->GeneralConfiguration & 0x80))
2547 inquiryData->RemovableMedia = 1;
2551 inquiryData->VendorId[i] = ((PUCHAR)pIdentify->ModelNumber)[i + 1];
2552 inquiryData->VendorId[i+1] = ((PUCHAR)pIdentify->ModelNumber)[i];
2557 for (i = 0; i < 4; i++) inquiryData->ProductId[12+i] = ' ';
2562 inquiryData->ProductRevisionLevel[i] = ((PUCHAR)pIdentify->FirmwareRevision)[i+1];
2563 inquiryData->ProductRevisionLevel[i+1] = ((PUCHAR)pIdentify->FirmwareRevision)[i];
2567 memcpy(&inquiryData->VendorId, "RR18xx ", 8);
2569 switch(pVDev->VDeviceType){
2571 if ((pVDev->u.array.pMember[0] && mIsArray(pVDev->u.array.pMember[0])) ||
2572 (pVDev->u.array.pMember[1] && mIsArray(pVDev->u.array.pMember[1])))
2573 memcpy(&inquiryData->ProductId, "RAID 1/0 Array ", 16);
2575 memcpy(&inquiryData->ProductId, "RAID 0 Array ", 16);
2578 if ((pVDev->u.array.pMember[0] && mIsArray(pVDev->u.array.pMember[0])) ||
2579 (pVDev->u.array.pMember[1] && mIsArray(pVDev->u.array.pMember[1])))
2580 memcpy(&inquiryData->ProductId, "RAID 0/1 Array ", 16);
2582 memcpy(&inquiryData->ProductId, "RAID 1 Array ", 16);
2585 memcpy(&inquiryData->ProductId, "RAID 5 Array ", 16);
2588 memcpy(&inquiryData->ProductId, "JBOD Array ", 16);
2592 memcpy(&inquiryData->ProductRevisionLevel, "3.00", 4);
2600 PBUS_DMAMAP pmap = (PBUS_DMAMAP)((union ccb *)arg)->ccb_adapter;
2601 IAL_ADAPTER_T *pAdapter = pmap->pAdapter;
2602 _VBUS_INST(&pAdapter->VBus)
2604 mtx_assert(&pAdapter->lock, MA_OWNED);
2612 union ccb *ccb = pCmd->pOrgCommand;
2613 struct ccb_hdr *ccb_h = &ccb->ccb_h;
2614 PBUS_DMAMAP pmap = (PBUS_DMAMAP) ccb->ccb_adapter;
2615 IAL_ADAPTER_T *pAdapter = pmap->pAdapter;
2616 PVDevice pVDev = pAdapter->VBus.pVDevice[ccb_h->target_id];
2617 FPSCAT_GATH psg = pCmd->pSgTable;
2619 _VBUS_INST(pVDev->pVBus)
2621 HPT_ASSERT(pCmd->cf_physical_sg);
2630 psg->dSgAddress = (ULONG_PTR)(UCHAR *)segs[idx].ds_addr;
2631 psg->wSgSize = segs[idx].ds_len;
2632 psg->wSgFlag = (idx == nsegs-1)? SG_FLAG_EOT: 0;
2633 /* KdPrint(("psg[%d]:add=%p,size=%x,flag=%x\n", idx, psg->dSgAddress,psg->wSgSize,psg->wSgFlag)); */
2635 /* psg[-1].wSgFlag = SG_FLAG_EOT; */
2637 if (pCmd->cf_data_in) {
2638 bus_dmamap_sync(pAdapter->io_dma_parent, pmap->dma_map,
2641 else if (pCmd->cf_data_out) {
2642 bus_dmamap_sync(pAdapter->io_dma_parent, pmap->dma_map,
2647 callout_reset(&pmap->timeout, 20 * hz, hpt_timeout, ccb);
2648 pVDev->pfnSendCommand(_VBUS_P pCmd);
2657 PBUS_DMAMAP pmap = (PBUS_DMAMAP)ccb->ccb_adapter;
2658 IAL_ADAPTER_T *pAdapter = pmap->pAdapter;
2659 struct ccb_hdr *ccb_h = &ccb->ccb_h;
2660 struct ccb_scsiio *csio = &ccb->csio;
2661 PVDevice pVDev = pAdapter->VBus.pVDevice[ccb_h->target_id];
2663 KdPrintI(("OsSendCommand: ccb %p cdb %x-%x-%x\n",
2665 *(ULONG *)&ccb->csio.cdb_io.cdb_bytes[0],
2666 *(ULONG *)&ccb->csio.cdb_io.cdb_bytes[4],
2667 *(ULONG *)&ccb->csio.cdb_io.cdb_bytes[8]
2670 pAdapter->outstandingCommands++;
2672 if (pVDev == NULL || pVDev->vf_online == 0) {
2673 ccb->ccb_h.status = CAM_REQ_INVALID;
2678 switch(ccb->csio.cdb_io.cdb_bytes[0])
2684 ccb->ccb_h.status = CAM_REQ_CMP;
2688 ZeroMemory(ccb->csio.data_ptr, ccb->csio.dxfer_len);
2689 SetInquiryData((PINQUIRYDATA)ccb->csio.data_ptr, pVDev);
2690 ccb_h->status = CAM_REQ_CMP;
2695 UCHAR *rbuf=csio->data_ptr;
2698 if (pVDev->VDeviceCapacity > 0xfffffffful) {
2701 cap = pVDev->VDeviceCapacity - 1;
2708 /* Claim 512 byte blocks (big-endian). */
2714 ccb_h->status = CAM_REQ_CMP;
2720 UCHAR *rbuf = csio->data_ptr;
2721 LBA_T cap = pVDev->VDeviceCapacity - 1;
2736 ccb_h->status = CAM_REQ_CMP;
2751 _VBUS_INST(pVDev->pVBus)
2756 CdbLength = csio->cdb_len;
2757 if ((ccb->ccb_h.flags & CAM_CDB_POINTER) != 0)
2759 if ((ccb->ccb_h.flags & CAM_CDB_PHYS) == 0)
2761 bcopy(csio->cdb_io.cdb_ptr, Cdb, CdbLength);
2766 ccb->ccb_h.status = CAM_REQ_INVALID;
2772 bcopy(csio->cdb_io.cdb_bytes, Cdb, CdbLength);
2775 pCmd->pOrgCommand = ccb;
2776 pCmd->pVDevice = pVDev;
2777 pCmd->pfnCompletion = fOsCommandDone;
2778 pCmd->pfnBuildSgl = fOsBuildSgl;
2779 pCmd->pSgTable = pmap->psg;
2786 pCmd->uCmd.Ide.Lba = ((ULONG)Cdb[1] << 16) | ((ULONG)Cdb[2] << 8) | (ULONG)Cdb[3];
2787 pCmd->uCmd.Ide.nSectors = (USHORT) Cdb[4];
2792 pCmd->uCmd.Ide.Lba =
2801 pCmd->uCmd.Ide.nSectors = (USHORT)Cdb[12] << 8 | (USHORT)Cdb[13];
2805 pCmd->uCmd.Ide.Lba = (ULONG)Cdb[5] | ((ULONG)Cdb[4] << 8) | ((ULONG)Cdb[3] << 16) | ((ULONG)Cdb[2] << 24);
2806 pCmd->uCmd.Ide.nSectors = (USHORT) Cdb[8] | ((USHORT)Cdb[7]<<8);
2815 pCmd->uCmd.Ide.Command = IDE_COMMAND_READ;
2816 pCmd->cf_data_in = 1;
2822 pCmd->uCmd.Ide.Command = IDE_COMMAND_WRITE;
2823 pCmd->cf_data_out = 1;
2827 pCmd->uCmd.Ide.Command = IDE_COMMAND_VERIFY;
2831 pCmd->cf_physical_sg = 1;
2832 error = bus_dmamap_load_ccb(pAdapter->io_dma_parent,
2833 pmap->dma_map,
2842 ccb->ccb_h.status = CAM_REQ_CMP_ERR;
2844 pAdapter->outstandingCommands--;
2845 if (pAdapter->outstandingCommands == 0)
2853 ccb->ccb_h.status = CAM_REQ_INVALID;
2865 union ccb *ccb = pCmd->pOrgCommand;
2866 PBUS_DMAMAP pmap = (PBUS_DMAMAP)ccb->ccb_adapter;
2867 IAL_ADAPTER_T *pAdapter = pmap->pAdapter;
2869 KdPrint(("fOsCommandDone(pcmd=%p, result=%d)\n", pCmd, pCmd->Result));
2871 callout_stop(&pmap->timeout);
2873 switch(pCmd->Result) {
2875 ccb->ccb_h.status = CAM_REQ_CMP;
2878 ccb->ccb_h.status = CAM_DEV_NOT_THERE;
2881 ccb->ccb_h.status = CAM_BUSY;
2884 ccb->ccb_h.status = CAM_REQ_INVALID;
2887 ccb->ccb_h.status = CAM_SEL_TIMEOUT;
2890 ccb->ccb_h.status = CAM_BUSY;
2893 ccb->ccb_h.status = CAM_SCSI_STATUS_ERROR;
2897 if (pCmd->cf_data_in) {
2898 bus_dmamap_sync(pAdapter->io_dma_parent, pmap->dma_map, BUS_DMASYNC_POSTREAD);
2900 else if (pCmd->cf_data_out) {
2901 bus_dmamap_sync(pAdapter->io_dma_parent, pmap->dma_map, BUS_DMASYNC_POSTWRITE);
2904 bus_dmamap_unload(pAdapter->io_dma_parent, pmap->dma_map);
2920 return -1;