57 SM_DBG2((
"smRegisterDevice: start\n"));
59 if (smDeviceHandle ==
agNULL)
61 SM_DBG1((
"smRegisterDevice: smDeviceHandle is NULL!!!\n"));
67 SM_DBG1((
"smRegisterDevice: agDevHandle is NULL!!!\n"));
71 oneDeviceData =
smAddToSharedcontext(smRoot, agDevHandle, smDeviceHandle, agExpDevHandle, phyID);
72 if (oneDeviceData !=
agNULL)
93 SM_DBG2((
"smDeregisterDevice: start\n"));
95 if (smDeviceHandle ==
agNULL)
97 SM_DBG1((
"smDeregisterDevice: smDeviceHandle is NULL!!!\n"));
101 if (agDevHandle ==
agNULL)
103 SM_DBG1((
"smDeregisterDevice: agDevHandle is NULL!!!\n"));
131 bit32 memAllocStatus;
138 SM_DBG1((
"smIOAbort: start\n"));
139 SM_DBG2((
"smIOAbort: tasktag %p\n", tasktag));
145 agRoot = smAllShared->agRoot;
148 if (smIORequestBody ==
agNULL)
150 SM_DBG1((
"smIOAbort: smIORequestBody is NULL!!!\n"));
159 SM_DBG2((
"smIOAbort: External, OS generated\n"));
164 SM_DBG2((
"smIOAbort: Internal, SM generated\n"));
178 (
void **)&smAbortIORequestBody,
188 SM_DBG1((
"smIOAbort: tdsmAllocMemory failed...!!!\n"));
192 if (smAbortIORequestBody ==
agNULL)
195 SM_DBG1((
"smIOAbort: tdsmAllocMemory returned NULL smAbortIORequestBody!!!\n"));
209 agAbortIORequest = &(smAbortIORequestBody->
agIORequest);
210 agAbortIORequest->
osData = (
void *) smAbortIORequestBody;
229 SM_DBG1((
"smIOAbort: failed to call saSATAAbort, status=%d!!!\n",
status));
256 bit32 memAllocStatus;
260 SM_DBG2((
"smIOAbortAll: start\n"));
262 agRoot = smAllShared->agRoot;
264 if (smDeviceHandle ==
agNULL)
266 SM_DBG1((
"smIOAbortAll: smDeviceHandle is NULL!!!\n"));
271 if (oneDeviceData ==
agNULL)
273 SM_DBG1((
"smIOAbortAll: oneDeviceData is NULL!!!\n"));
278 SM_DBG1((
"smIOAbortAll: oneDeviceData is not valid, did %d !!!\n", oneDeviceData->
id));
283 if (agDevHandle ==
agNULL)
285 SM_DBG1((
"smIOAbortAll: agDevHandle is NULL!!!\n"));
300 (
void **)&smAbortIORequestBody,
310 SM_DBG1((
"smIOAbortAll: tdsmAllocMemory failed...!!!\n"));
314 if (smAbortIORequestBody ==
agNULL)
317 SM_DBG1((
"smIOAbortAll: tdsmAllocMemory returned NULL smAbortIORequestBody!!!\n"));
328 smAbortIORequestBody->
smDevHandle = smDeviceHandle;
331 agAbortIORequest = &(smAbortIORequestBody->
agIORequest);
332 agAbortIORequest->
osData = (
void *) smAbortIORequestBody;
340 SM_DBG1((
"smIOAbortAll: failed to call saSATAAbort, status=%d!!!\n",
status));
358 bit32 interruptContext
366 SM_DBG2((
"smSuperIOStart: start\n"));
369 if (oneDeviceData ==
agNULL)
371 SM_DBG1((
"smSuperIOStart: oneDeviceData is NULL!!!\n"));
376 SM_DBG1((
"smSuperIOStart: oneDeviceData is not valid, did %d !!!\n", oneDeviceData->
id));
381 if (smIORequestBody ==
agNULL)
383 SM_DBG1((
"smSuperIOStart: smIORequestBody is NULL!!!\n"));
389 SM_DBG3((
"smSuperIOStart: io ID %d!!!\n", smIORequestBody->
id ));
429 satIOContext->
OrgTL = 0;
471 bit32 interruptContext
479 SM_DBG2((
"smIOStart: start\n"));
482 if (oneDeviceData ==
agNULL)
484 SM_DBG1((
"smIOStart: oneDeviceData is NULL!!!\n"));
489 SM_DBG1((
"smIOStart: oneDeviceData is not valid, did %d !!!\n", oneDeviceData->
id));
494 if (smIORequestBody ==
agNULL)
496 SM_DBG1((
"smIOStart: smIORequestBody is NULL!!!\n"));
502 SM_DBG3((
"smIOStart: io ID %d!!!\n", smIORequestBody->
id ));
532 satIOContext->
OrgTL = 0;
534 status =
smsatIOStart(smRoot, smIORequest, smDeviceHandle, smSCSIRequest, satIOContext);
561 SM_DBG1((
"smTaskManagement: start\n"));
568 if ( (
lun->lun[0] |
lun->lun[1] |
lun->lun[2] |
lun->lun[3] |
569 lun->lun[4] |
lun->lun[5] |
lun->lun[6] |
lun->lun[7] ) != 0 )
571 SM_DBG1((
"smTaskManagement: *** REJECT *** LUN not zero, did %d!!!\n",
590 SM_DBG1((
"smTaskManagement: LUN reset or device reset expander attached!!!\n"));
601 SM_DBG1((
"smTaskManagement: LUN reset or device reset directly attached\n"));
605 if (smIORequestBody ==
agNULL)
607 SM_DBG1((
"smTaskManagement: smIORequestBody is NULL!!!\n"));
618 agContext->
osData = currentTaskTag;
623 oneDeviceData->
phyID,
652 if (smIORequestBody ==
agNULL)
654 SM_DBG1((
"smTaskManagement: smIORequestBody is NULL!!!\n"));
690 SM_DBG2((
"smDequeueIO: start\n"));
695 SM_DBG1((
"smDequeueIO: empty freeIOList!!!\n"));
708 SM_DBG1((
"smDequeueIO: wrong. already in USE ID %d!!!!\n", smIORequestBody->
id));
713 SM_DBG2((
"smDequeueIO: io ID %d!\n", smIORequestBody->
id));
718 SM_DBG1((
"smDequeueIO: io ID %d, flink is NULL!!!\n", smIORequestBody->
id));
722 SM_DBG1((
"smDequeueIO: io ID %d, blink is NULL!!!\n", smIORequestBody->
id));
725 return smIORequestBody;
745 bit32 memAllocStatus;
749 SM_DBG2((
"smsatAbort: start\n"));
751 if (satIOContext ==
agNULL)
753 SM_DBG1((
"smsatAbort: satIOContext is NULL, wrong!!!\n"));
772 (
void **)&smIORequestBody,
782 SM_DBG1((
"smsatAbort: ostiAllocMemory failed...\n"));
786 if (smIORequestBody ==
agNULL)
789 SM_DBG1((
"smsatAbort: ostiAllocMemory returned NULL smIORequestBody\n"));
800 agAbortIORequest = &(smIORequestBody->
agIORequest);
801 agAbortIORequest->
osData = (
void *) smIORequestBody;
810 SM_DBG1((
"satAbort: end!!!\n"));
829 SM_DBG1((
"smsatStartCheckPowerMode: start\n"));
833 SM_DBG6((
"smsatStartCheckPowerMode: before alloc\n"));
842 SM_DBG6((
"smsatStartCheckPowerMode: before after\n"));
846 SM_DBG1((
"smsatStartCheckPowerMode: can't alloacate!!!\n"));
857 SM_DBG6((
"smsatStartCheckPowerMode: TD satIOContext %p \n", satIOContext));
858 SM_DBG6((
"smsatStartCheckPowerMode: SM satNewIOContext %p \n", satNewIOContext));
859 SM_DBG6((
"smsatStartCheckPowerMode: TD smScsiXchg %p \n", satIOContext->
smScsiXchg));
860 SM_DBG6((
"smsatStartCheckPowerMode: SM smScsiXchg %p \n", satNewIOContext->
smScsiXchg));
864 SM_DBG2((
"smsatStartCheckPowerMode: satNewIOContext %p \n", satNewIOContext));
874 SM_DBG1((
"smsatStartCheckPowerMode: failed in sending!!!\n"));
886 SM_DBG6((
"smsatStartCheckPowerMode: end\n"));
905 SM_DBG1((
"smsatStartResetDevice: start\n"));
909 SM_DBG6((
"smsatStartResetDevice: before alloc\n"));
918 SM_DBG6((
"smsatStartResetDevice: before after\n"));
922 SM_DBG1((
"smsatStartResetDevice: can't alloacate!!!\n"));
933 SM_DBG6((
"smsatStartResetDevice: TD satIOContext %p \n", satIOContext));
934 SM_DBG6((
"smsatStartResetDevice: SM satNewIOContext %p \n", satNewIOContext));
935 SM_DBG6((
"smsatStartResetDevice: TD smScsiXchg %p \n", satIOContext->
smScsiXchg));
936 SM_DBG6((
"smsatStartResetDevice: SM smScsiXchg %p \n", satNewIOContext->
smScsiXchg));
940 SM_DBG6((
"smsatStartResetDevice: satNewIOContext %p \n", satNewIOContext));
962 SM_DBG1((
"smsatStartResetDevice: failed in sending!!!\n"));
974 SM_DBG6((
"smsatStartResetDevice: end\n"));
996 SM_DBG1((
"smsatTmAbortTask: start\n"));
1013 if ( satTempIOContext !=
agNULL)
1019 elementHdr = elementHdr->
flink;
1024 if ( smIOReq == taskTag)
1028 SM_DBG1((
"smsatTmAbortTask: found matching tag.\n"));
1040 SM_DBG1((
"smsatTmAbortTask: *** REJECT *** no match!!!\n"));
1044 if (smIORequestBody)
1057 SM_DBG1((
"smsatTmAbortTask: smIORequestBody is NULL!!!\n"));
1063 if (satTempIOContext ==
agNULL)
1065 SM_DBG1((
"smsatTmAbortTask: satTempIOContext is NULL!!!\n"));
1092 SM_DBG1((
"smsatTmAbortTask: calling satStartCheckPowerMode!!!\n"));
1104 SM_DBG1((
"smsatTmAbortTask: calling satStartResetDevice!!!\n"));
1133 SM_DBG1((
"smsatTaskManagement: start\n"));
1139 satIOContext->
pFis =
1150 satIOContext->
OrgTL = 0;
1153 satIOContext->
TMF = task;
1170 SM_DBG1((
"smsatTaskManagement: UNSUPPORTED TM task=0x%x!!!\n", task ));
1198 bit32 memAllocStatus;
1199 bit32 expectedRspLen = 0;
1209 bit32 agRequestType;
1211 SM_DBG2((
"smPhyControlSend: start\n"));
1215 if (agExpDevHandle ==
agNULL)
1217 SM_DBG1((
"smPhyControlSend: agExpDevHandle is NULL!!!\n"));
1221 SM_DBG5((
"smPhyControlSend: phyID %d\n", oneDeviceData->
phyID));
1233 (
void **)&smSMPRequestBody,
1243 SM_DBG1((
"smPhyControlSend: tdsmAllocMemory failed...!!!\n"));
1247 if (smSMPRequestBody ==
agNULL)
1249 SM_DBG1((
"smPhyControlSend: tdsmAllocMemory returned NULL smSMPRequestBody!!!\n"));
1270 if (CurrentTaskTag !=
agNULL)
1272 CurrentTaskTag->
smData = smSMPRequestBody;
1276 smSMPRequestBody->
retries = 0;
1278#ifdef TD_INTERNAL_DEBUG
1279 SM_DBG4((
"smPhyControlSend: SMPRequestbody %p\n", smSMPRequestBody));
1284 agIORequest->
osData = (
void *) smSMPRequestBody;
1289 agSMPFrame = &(agSASRequestBody->
smpFrame);
1291 SM_DBG3((
"smPhyControlSend: agIORequest %p\n", agIORequest));
1292 SM_DBG3((
"smPhyControlSend: SMPRequestbody %p\n", smSMPRequestBody));
1296 pSmpBody = (
bit8 *)&smpPhyControlReq;
1304 SM_DBG3((
"smPhyControlSend: DIRECT smp payload\n"));
1324#if defined (INITIATOR_DRIVER) && defined (TARGET_DRIVER)
1336 SM_DBG1((
"smPhyControlSend: INDIRECT smp payload, not supported!!!\n"));
1349 SM_DBG3((
"smPhyControlSend: DIRECT smp payload\n"));
1350 agSMPFrame->
flag = 0;
1370#if defined (INITIATOR_DRIVER) && defined (TARGET_DRIVER)
1397 SM_DBG1((
"smPhyControlSend: saSMPStart is busy!!!\n"));
1408 SM_DBG1((
"smPhyControlSend: saSMPStart is failed. status %d!!!\n",
status));
1434 SM_DBG3((
"smEnqueueIO: start\n"));
1442 SM_DBG2((
"smEnqueueIO: external command!!!, io ID %d!!!\n", smIORequestBody->
id));
1446 SM_DBG1((
"smEnqueueIO: external command!!!, io ID %d, flink is NULL!!!\n", smIORequestBody->
id));
1450 SM_DBG1((
"smEnqueueIO: external command!!!, io ID %d, blink is NULL!!!\n", smIORequestBody->
id));
1455 SM_DBG2((
"smEnqueueIO: internal command!!!, io ID %d!!!\n", smIORequestBody->
id));
1459 SM_DBG1((
"smEnqueueIO: internal command!!!, io ID %d, flink is NULL!!!\n", smIORequestBody->
id));
1463 SM_DBG1((
"smEnqueueIO: internal command!!!, io ID %d, blink is NULL!!!\n", smIORequestBody->
id));
1469 SM_DBG1((
"smEnqueueIO: smIORequest is NULL, io ID %d!!!\n", smIORequestBody->
id));
1482 SM_DBG2((
"smEnqueueIO: check!!!, io ID %d!!!\n", smIORequestBody->
id));
1496 SM_DBG3((
"smsatFreeIntIoResource: start\n"));
1500 SM_DBG2((
"smsatFreeIntIoResource: allowed call\n"));
1534 SM_DBG3((
"smsatFreeIntIoResource: satDevData %p satIntIo id %d\n", satDevData, satIntIo->
id));
1551 bit32 dmaAllocLength,
1555 bit32 memAllocStatus;
1557 SM_DBG3((
"smsatAllocIntIoResource: start\n"));
1558 SM_DBG3((
"smsatAllocIntIoResource: satIntIo %p\n", satIntIo));
1559 if (satDevData ==
agNULL)
1561 SM_DBG1((
"smsatAllocIntIoResource: ***** ASSERT satDevData is null!!!\n"));
1573 SM_DBG1((
"smsatAllocIntIoResource() no more internal free link!!!\n"));
1580 SM_DBG1((
"smsatAllocIntIoResource() FAIL to alloc satIntIo!!!\n"));
1585 SM_DBG3((
"smsatAllocIntIoResource: satDevData %p satIntIo id %d\n", satDevData, satIntIo->
id));
1600 SM_DBG3((
"smsatAllocIntIoResource: satDevData %p satIntIo id %d\n", satDevData, satIntIo->
id));
1632 SM_DBG1((
"smsatAllocIntIoResource() FAIL to alloc mem for Req Body!!!\n"));
1647 if (dmaAllocLength != 0)
1664 SM_DBG1((
"smsatAllocIntIoResource() FAIL to alloc mem for DMA mem!!!\n"));
1735 if (dmaAllocLength != 0)
1766 SM_DBG5((
"smsatAllocIntIoResource: return satIntIo %p\n", satIntIo));
1785 SM_DBG2((
"smAddToSharedcontext: start\n"));
1788 DeviceListList = smAllShared->MainDeviceList.
flink;
1789 while (DeviceListList != &(smAllShared->MainDeviceList))
1792 if (oneDeviceData ==
agNULL)
1794 SM_DBG1((
"smAddToSharedcontext: oneDeviceData is NULL!!!\n"));
1799 SM_DBG2((
"smAddToSharedcontext: did %d\n", oneDeviceData->
id));
1803 DeviceListList = DeviceListList->
flink;
1807 if (new_device ==
agTRUE)
1809 SM_DBG2((
"smAddToSharedcontext: new device\n"));
1814 SM_DBG1((
"smAddToSharedcontext: empty DeviceData FreeLink!!!\n"));
1822 oneDeviceData->
smRoot = smRoot;
1825 smDeviceHandle->
smData = oneDeviceData;
1827 if (agExpDevHandle ==
agNULL)
1836 oneDeviceData->
phyID = phyID;
1844 SM_DBG2((
"smAddToSharedcontext: new case did %d\n", oneDeviceData->
id));
1848 SM_DBG2((
"smAddToSharedcontext: old device\n"));
1849 oneDeviceData->
smRoot = smRoot;
1852 smDeviceHandle->
smData = oneDeviceData;
1854 if (agExpDevHandle ==
agNULL)
1863 oneDeviceData->
phyID = phyID;
1867 SM_DBG2((
"smAddToSharedcontext: old case did %d\n", oneDeviceData->
id));
1870 return oneDeviceData;
1884 SM_DBG2((
"smRemoveFromSharedcontext: start\n"));
1892 if (oneDeviceData ==
agNULL)
1909 SM_DBG1((
"smRemoveFromSharedcontext: did %d bad case!!!\n", oneDeviceData->
id));
1927 SM_DBG2((
"smFindInSharedcontext: start\n"));
1932 SM_DBG1((
"smFindInSharedcontext: empty MainDeviceList!!!\n"));
1941 DeviceListList = smAllShared->MainDeviceList.
flink;
1942 while (DeviceListList != &(smAllShared->MainDeviceList))
1945 if (oneDeviceData ==
agNULL)
1947 SM_DBG1((
"smFindInSharedcontext: oneDeviceData is NULL!!!\n"));
1950 if ((oneDeviceData->
agDevHandle == agDevHandle) &&
1954 SM_DBG2((
"smFindInSharedcontext: found, did %d\n", oneDeviceData->
id));
1955 return oneDeviceData;
1957 DeviceListList = DeviceListList->
flink;
1959 SM_DBG2((
"smFindInSharedcontext: not found\n"));
1975 SM_DBG3((
"smsatPrepareNewIO: start\n"));
2003 return satNewIOContext;
2013 SM_DBG3((
"smsatSetDevInfo: start\n"));
2030 SM_DBG3((
"smsatSetDevInfo: device supports NCQ\n"));
2035 SM_DBG3((
"smsatSetDevInfo: no NCQ\n"));
2043 SM_DBG3((
"smsatSetDevInfo: support 48 bit addressing\n"));
2048 SM_DBG3((
"smsatSetDevInfo: NO 48 bit addressing\n"));
2055 SM_DBG3((
"smsatSetDevInfo: SMART self-test supported \n"));
2060 SM_DBG3((
"smsatSetDevInfo: no SMART self-test suppored\n"));
2067 SM_DBG3((
"smsatSetDevInfo: SMART feature set supported \n"));
2072 SM_DBG3((
"smsatSetDevInfo: no SMART feature set suppored\n"));
2079 SM_DBG3((
"smsatSetDevInfo: SMART enabled \n"));
2084 SM_DBG3((
"smsatSetDevInfo: no SMART enabled\n"));
2093 SM_DBG3((
"smsatSetDevInfo: Removable Media supported \n"));
2098 SM_DBG3((
"smsatSetDevInfo: no Removable Media suppored\n"));
2105 SM_DBG3((
"smsatSetDevInfo: Removable Media enabled\n"));
2110 SM_DBG3((
"smsatSetDevInfo: no Removable Media enabled\n"));
2117 SM_DBG3((
"smsatSetDevInfo: DMA supported \n"));
2122 SM_DBG3((
"smsatSetDevInfo: no DMA suppored\n"));
2129 SM_DBG3((
"satSetDevInfo: DMADIR enabled\n"));
2134 SM_DBG3((
"satSetDevInfo: DMADIR disabled\n"));
2142 SM_DBG3((
"smsatSetDevInfo: DMA enabled \n"));
2171 SM_DBG3((
"smsatSetDevInfo: no DMA enabled\n"));
2188 SM_DBG3((
"smsatSetDevInfo: Read Look-ahead is supported\n"));
2193 SM_DBG3((
"smsatSetDevInfo: Read Look-ahead is not supported\n"));
2200 SM_DBG3((
"smsatSetDevInfo: Volatile Write Cache is supported\n"));
2205 SM_DBG3((
"smsatSetDevInfo: Volatile Write Cache is not supported\n"));
2212 SM_DBG3((
"smsatSetDevInfo: write cache enabled\n"));
2217 SM_DBG3((
"smsatSetDevInfo: no write cache enabled\n"));
2224 SM_DBG3((
"smsatSetDevInfo: look ahead enabled\n"));
2229 SM_DBG3((
"smsatSetDevInfo: no look ahead enabled\n"));
2236 SM_DBG3((
"smsatSetDevInfo: device supports WWN\n"));
2241 SM_DBG3((
"smsatSetDevInfo: no WWN\n"));
2248 SM_DBG3((
"smsatSetDevInfo: device supports DMA Setup Auto-Activate\n"));
2253 SM_DBG3((
"smsatSetDevInfo: no DMA Setup Auto-Activate\n"));
2258 if (SATAIdData->
word77 & 0x10)
2260 SM_DBG3((
"smsatSetDevInfo: device supports NCQ Queue Management Command\n"));
2265 SM_DBG3((
"smsatSetDevInfo: no NCQ Queue Management Command\n"));
2280 pLun = &scsiCmnd->
lun;
2290 SM_DBG5((
"smsatInquiryStandard: start\n"));
2294 SM_DBG1((
"smsatInquiryStandard: pInquiry is NULL, wrong\n"));
2299 SM_DBG5((
"smsatInquiryStandard: pInquiry is NOT NULL\n"));
2304 if ( ((pLun->
lun[0] | pLun->
lun[1] | pLun->
lun[2] | pLun->
lun[3] |
2305 pLun->
lun[4] | pLun->
lun[5] | pLun->
lun[6] | pLun->
lun[7] ) != 0) )
2446 SM_DBG5((
"smsatInquiryStandard: end\n"));
2457 SM_DBG5((
"smsatInquiryPage0: start\n"));
2466 pInquiry[3] = 8 - 3;
2494 SM_DBG5((
"smsatInquiryPage83: start\n"));
2561 pInquiry[16] = 0x61;
2562 pInquiry[17] = 0x93;
2563 pInquiry[18] = 0x00;
2564 pInquiry[19] = 0x08;
2570 pInquiry[20] = ((oneDeviceData->
sasAddressHi) & 0xFF000000 ) >> 24;
2571 pInquiry[21] = ((oneDeviceData->
sasAddressHi) & 0xFF0000 ) >> 16;
2572 pInquiry[22] = ((oneDeviceData->
sasAddressHi) & 0xFF00 ) >> 8;
2574 pInquiry[24] = ((oneDeviceData->
sasAddressLo) & 0xFF000000 ) >> 24;
2575 pInquiry[25] = ((oneDeviceData->
sasAddressLo) & 0xFF0000 ) >> 16;
2576 pInquiry[26] = ((oneDeviceData->
sasAddressLo) & 0xFF00 ) >> 8;
2604 pInquiry[16] = (
bit8)((pSimpleData->
word[27]) >> 8);
2605 pInquiry[17] = (
bit8)((pSimpleData->
word[27]) & 0x00ff);
2606 pInquiry[18] = (
bit8)((pSimpleData->
word[28]) >> 8);
2607 pInquiry[19] = (
bit8)((pSimpleData->
word[28]) & 0x00ff);
2608 pInquiry[20] = (
bit8)((pSimpleData->
word[29]) >> 8);
2609 pInquiry[21] = (
bit8)((pSimpleData->
word[29]) & 0x00ff);
2610 pInquiry[22] = (
bit8)((pSimpleData->
word[30]) >> 8);
2611 pInquiry[23] = (
bit8)((pSimpleData->
word[30]) & 0x00ff);
2612 pInquiry[24] = (
bit8)((pSimpleData->
word[31]) >> 8);
2613 pInquiry[25] = (
bit8)((pSimpleData->
word[31]) & 0x00ff);
2614 pInquiry[26] = (
bit8)((pSimpleData->
word[32]) >> 8);
2615 pInquiry[27] = (
bit8)((pSimpleData->
word[32]) & 0x00ff);
2616 pInquiry[28] = (
bit8)((pSimpleData->
word[33]) >> 8);
2617 pInquiry[29] = (
bit8)((pSimpleData->
word[33]) & 0x00ff);
2618 pInquiry[30] = (
bit8)((pSimpleData->
word[34]) >> 8);
2619 pInquiry[31] = (
bit8)((pSimpleData->
word[34]) & 0x00ff);
2620 pInquiry[32] = (
bit8)((pSimpleData->
word[35]) >> 8);
2621 pInquiry[33] = (
bit8)((pSimpleData->
word[35]) & 0x00ff);
2622 pInquiry[34] = (
bit8)((pSimpleData->
word[36]) >> 8);
2623 pInquiry[35] = (
bit8)((pSimpleData->
word[36]) & 0x00ff);
2624 pInquiry[36] = (
bit8)((pSimpleData->
word[37]) >> 8);
2625 pInquiry[37] = (
bit8)((pSimpleData->
word[37]) & 0x00ff);
2626 pInquiry[38] = (
bit8)((pSimpleData->
word[38]) >> 8);
2627 pInquiry[39] = (
bit8)((pSimpleData->
word[38]) & 0x00ff);
2628 pInquiry[40] = (
bit8)((pSimpleData->
word[39]) >> 8);
2629 pInquiry[41] = (
bit8)((pSimpleData->
word[39]) & 0x00ff);
2630 pInquiry[42] = (
bit8)((pSimpleData->
word[40]) >> 8);
2631 pInquiry[43] = (
bit8)((pSimpleData->
word[40]) & 0x00ff);
2632 pInquiry[44] = (
bit8)((pSimpleData->
word[41]) >> 8);
2633 pInquiry[45] = (
bit8)((pSimpleData->
word[41]) & 0x00ff);
2634 pInquiry[46] = (
bit8)((pSimpleData->
word[42]) >> 8);
2635 pInquiry[47] = (
bit8)((pSimpleData->
word[42]) & 0x00ff);
2636 pInquiry[48] = (
bit8)((pSimpleData->
word[43]) >> 8);
2637 pInquiry[49] = (
bit8)((pSimpleData->
word[43]) & 0x00ff);
2638 pInquiry[50] = (
bit8)((pSimpleData->
word[44]) >> 8);
2639 pInquiry[51] = (
bit8)((pSimpleData->
word[44]) & 0x00ff);
2640 pInquiry[52] = (
bit8)((pSimpleData->
word[45]) >> 8);
2641 pInquiry[53] = (
bit8)((pSimpleData->
word[45]) & 0x00ff);
2642 pInquiry[54] = (
bit8)((pSimpleData->
word[46]) >> 8);
2643 pInquiry[55] = (
bit8)((pSimpleData->
word[46]) & 0x00ff);
2645 pInquiry[56] = (
bit8)((pSimpleData->
word[10]) >> 8);
2646 pInquiry[57] = (
bit8)((pSimpleData->
word[10]) & 0x00ff);
2647 pInquiry[58] = (
bit8)((pSimpleData->
word[11]) >> 8);
2648 pInquiry[59] = (
bit8)((pSimpleData->
word[11]) & 0x00ff);
2649 pInquiry[60] = (
bit8)((pSimpleData->
word[12]) >> 8);
2650 pInquiry[61] = (
bit8)((pSimpleData->
word[12]) & 0x00ff);
2651 pInquiry[62] = (
bit8)((pSimpleData->
word[13]) >> 8);
2652 pInquiry[63] = (
bit8)((pSimpleData->
word[13]) & 0x00ff);
2653 pInquiry[64] = (
bit8)((pSimpleData->
word[14]) >> 8);
2654 pInquiry[65] = (
bit8)((pSimpleData->
word[14]) & 0x00ff);
2655 pInquiry[66] = (
bit8)((pSimpleData->
word[15]) >> 8);
2656 pInquiry[67] = (
bit8)((pSimpleData->
word[15]) & 0x00ff);
2657 pInquiry[68] = (
bit8)((pSimpleData->
word[16]) >> 8);
2658 pInquiry[69] = (
bit8)((pSimpleData->
word[16]) & 0x00ff);
2659 pInquiry[70] = (
bit8)((pSimpleData->
word[17]) >> 8);
2660 pInquiry[71] = (
bit8)((pSimpleData->
word[17]) & 0x00ff);
2661 pInquiry[72] = (
bit8)((pSimpleData->
word[18]) >> 8);
2662 pInquiry[73] = (
bit8)((pSimpleData->
word[18]) & 0x00ff);
2663 pInquiry[74] = (
bit8)((pSimpleData->
word[19]) >> 8);
2664 pInquiry[75] = (
bit8)((pSimpleData->
word[19]) & 0x00ff);
2688 pInquiry[16] = (
bit8)((pSimpleData->
word[27]) >> 8);
2689 pInquiry[17] = (
bit8)((pSimpleData->
word[27]) & 0x00ff);
2690 pInquiry[18] = (
bit8)((pSimpleData->
word[28]) >> 8);
2691 pInquiry[19] = (
bit8)((pSimpleData->
word[28]) & 0x00ff);
2692 pInquiry[20] = (
bit8)((pSimpleData->
word[29]) >> 8);
2693 pInquiry[21] = (
bit8)((pSimpleData->
word[29]) & 0x00ff);
2694 pInquiry[22] = (
bit8)((pSimpleData->
word[30]) >> 8);
2695 pInquiry[23] = (
bit8)((pSimpleData->
word[30]) & 0x00ff);
2696 pInquiry[24] = (
bit8)((pSimpleData->
word[31]) >> 8);
2697 pInquiry[25] = (
bit8)((pSimpleData->
word[31]) & 0x00ff);
2698 pInquiry[26] = (
bit8)((pSimpleData->
word[32]) >> 8);
2699 pInquiry[27] = (
bit8)((pSimpleData->
word[32]) & 0x00ff);
2700 pInquiry[28] = (
bit8)((pSimpleData->
word[33]) >> 8);
2701 pInquiry[29] = (
bit8)((pSimpleData->
word[33]) & 0x00ff);
2702 pInquiry[30] = (
bit8)((pSimpleData->
word[34]) >> 8);
2703 pInquiry[31] = (
bit8)((pSimpleData->
word[34]) & 0x00ff);
2704 pInquiry[32] = (
bit8)((pSimpleData->
word[35]) >> 8);
2705 pInquiry[33] = (
bit8)((pSimpleData->
word[35]) & 0x00ff);
2706 pInquiry[34] = (
bit8)((pSimpleData->
word[36]) >> 8);
2707 pInquiry[35] = (
bit8)((pSimpleData->
word[36]) & 0x00ff);
2708 pInquiry[36] = (
bit8)((pSimpleData->
word[37]) >> 8);
2709 pInquiry[37] = (
bit8)((pSimpleData->
word[37]) & 0x00ff);
2710 pInquiry[38] = (
bit8)((pSimpleData->
word[38]) >> 8);
2711 pInquiry[39] = (
bit8)((pSimpleData->
word[38]) & 0x00ff);
2712 pInquiry[40] = (
bit8)((pSimpleData->
word[39]) >> 8);
2713 pInquiry[41] = (
bit8)((pSimpleData->
word[39]) & 0x00ff);
2714 pInquiry[42] = (
bit8)((pSimpleData->
word[40]) >> 8);
2715 pInquiry[43] = (
bit8)((pSimpleData->
word[40]) & 0x00ff);
2716 pInquiry[44] = (
bit8)((pSimpleData->
word[41]) >> 8);
2717 pInquiry[45] = (
bit8)((pSimpleData->
word[41]) & 0x00ff);
2718 pInquiry[46] = (
bit8)((pSimpleData->
word[42]) >> 8);
2719 pInquiry[47] = (
bit8)((pSimpleData->
word[42]) & 0x00ff);
2720 pInquiry[48] = (
bit8)((pSimpleData->
word[43]) >> 8);
2721 pInquiry[49] = (
bit8)((pSimpleData->
word[43]) & 0x00ff);
2722 pInquiry[50] = (
bit8)((pSimpleData->
word[44]) >> 8);
2723 pInquiry[51] = (
bit8)((pSimpleData->
word[44]) & 0x00ff);
2724 pInquiry[52] = (
bit8)((pSimpleData->
word[45]) >> 8);
2725 pInquiry[53] = (
bit8)((pSimpleData->
word[45]) & 0x00ff);
2726 pInquiry[54] = (
bit8)((pSimpleData->
word[46]) >> 8);
2727 pInquiry[55] = (
bit8)((pSimpleData->
word[46]) & 0x00ff);
2729 pInquiry[56] = (
bit8)((pSimpleData->
word[10]) >> 8);
2730 pInquiry[57] = (
bit8)((pSimpleData->
word[10]) & 0x00ff);
2731 pInquiry[58] = (
bit8)((pSimpleData->
word[11]) >> 8);
2732 pInquiry[59] = (
bit8)((pSimpleData->
word[11]) & 0x00ff);
2733 pInquiry[60] = (
bit8)((pSimpleData->
word[12]) >> 8);
2734 pInquiry[61] = (
bit8)((pSimpleData->
word[12]) & 0x00ff);
2735 pInquiry[62] = (
bit8)((pSimpleData->
word[13]) >> 8);
2736 pInquiry[63] = (
bit8)((pSimpleData->
word[13]) & 0x00ff);
2737 pInquiry[64] = (
bit8)((pSimpleData->
word[14]) >> 8);
2738 pInquiry[65] = (
bit8)((pSimpleData->
word[14]) & 0x00ff);
2739 pInquiry[66] = (
bit8)((pSimpleData->
word[15]) >> 8);
2740 pInquiry[67] = (
bit8)((pSimpleData->
word[15]) & 0x00ff);
2741 pInquiry[68] = (
bit8)((pSimpleData->
word[16]) >> 8);
2742 pInquiry[69] = (
bit8)((pSimpleData->
word[16]) & 0x00ff);
2743 pInquiry[70] = (
bit8)((pSimpleData->
word[17]) >> 8);
2744 pInquiry[71] = (
bit8)((pSimpleData->
word[17]) & 0x00ff);
2745 pInquiry[72] = (
bit8)((pSimpleData->
word[18]) >> 8);
2746 pInquiry[73] = (
bit8)((pSimpleData->
word[18]) & 0x00ff);
2747 pInquiry[74] = (
bit8)((pSimpleData->
word[19]) >> 8);
2748 pInquiry[75] = (
bit8)((pSimpleData->
word[19]) & 0x00ff);
2750 pInquiry[76] = 0x61;
2751 pInquiry[77] = 0x93;
2752 pInquiry[78] = 0x00;
2753 pInquiry[79] = 0x08;
2755 SM_DBG5((
"smsatInquiryPage83: NO WWN sasAddressHi 0x%08x\n", oneDeviceData->
sasAddressHi));
2756 SM_DBG5((
"smsatInquiryPage83: No WWN sasAddressLo 0x%08x\n", oneDeviceData->
sasAddressLo));
2759 pInquiry[80] = ((oneDeviceData->
sasAddressHi) & 0xFF000000 ) >> 24;
2760 pInquiry[81] = ((oneDeviceData->
sasAddressHi) & 0xFF0000 ) >> 16;
2761 pInquiry[82] = ((oneDeviceData->
sasAddressHi) & 0xFF00 ) >> 8;
2763 pInquiry[84] = ((oneDeviceData->
sasAddressLo) & 0xFF000000 ) >> 24;
2764 pInquiry[85] = ((oneDeviceData->
sasAddressLo) & 0xFF0000 ) >> 16;
2765 pInquiry[86] = ((oneDeviceData->
sasAddressLo) & 0xFF00 ) >> 8;
2794 SM_DBG5((
"smsatInquiryPage89: start\n"));
2809 sm_strncpy((
char*)&pInquiry[8],
"PMC-SIERRA", 8);
2812 sm_strncpy((
char*)&pInquiry[16],
"Tachyon-SPC ", 16);
2820 pInquiry[36] = 0x34;
2836 pInquiry[40] = 0x01;
2837 pInquiry[41] = 0x00;
2838 pInquiry[42] = 0x00;
2839 pInquiry[43] = 0x00;
2840 pInquiry[44] = 0x00;
2841 pInquiry[45] = 0x00;
2842 pInquiry[46] = 0x00;
2843 pInquiry[47] = 0x00;
2844 pInquiry[48] = 0x01;
2845 pInquiry[49] = 0x00;
2849 pInquiry[40] = 0x01;
2850 pInquiry[41] = 0x00;
2851 pInquiry[42] = 0x00;
2852 pInquiry[43] = 0x00;
2853 pInquiry[44] = 0x00;
2854 pInquiry[45] = 0x00;
2855 pInquiry[46] = 0x00;
2856 pInquiry[47] = 0x00;
2857 pInquiry[48] = 0x01;
2858 pInquiry[49] = 0x00;
2862 pInquiry[50] = 0x00;
2863 pInquiry[51] = 0x00;
2864 pInquiry[52] = 0x00;
2865 pInquiry[53] = 0x00;
2866 pInquiry[54] = 0x00;
2867 pInquiry[55] = 0x00;
2872 pInquiry[56] = 0xEC;
2876 pInquiry[56] = 0xA1;
2904 SM_DBG5((
"smsatInquiryPage89: start\n"));
2948 SM_DBG5((
"smsatInquiryPageB1: start\n"));
2963 pInquiry[4] = (
bit8) ((pSimpleData->
word[217]) >> 8);
2964 pInquiry[5] = (
bit8) ((pSimpleData->
word[217]) & 0xFF);
2970 pInquiry[7] = (
bit8) ((pSimpleData->
word[168]) & 0xF);
2989 bit32 interruptContext
2992 SM_DBG5((
"smsatDefaultTranslation: start\n"));
3020 SM_DBG1((
"smsatDefaultTranslation: NM_ATA_ERROR ataError= 0x%x, smIORequest=%p!!!\n",
3021 ataError, smIORequest));
3031 SM_DBG1((
"smsatDefaultTranslation: UNC_ATA_ERROR ataError= 0x%x, smIORequest=%p!!!\n",
3032 ataError, smIORequest));
3042 SM_DBG1((
"smsatDefaultTranslation: IDNF_ATA_ERROR ataError= 0x%x, smIORequest=%p!!!\n",
3043 ataError, smIORequest));
3053 SM_DBG1((
"smsatDefaultTranslation: MC_ATA_ERROR ataError= 0x%x, smIORequest=%p!!!\n",
3054 ataError, smIORequest));
3064 SM_DBG1((
"smsatDefaultTranslation: MCR_ATA_ERROR ataError= 0x%x, smIORequest=%p!!!\n",
3065 ataError, smIORequest));
3075 SM_DBG1((
"smsatDefaultTranslation: ICRC_ATA_ERROR ataError= 0x%x, smIORequest=%p!!!\n",
3076 ataError, smIORequest));
3086 SM_DBG1((
"smsatDefaultTranslation: ABRT_ATA_ERROR ataError= 0x%x, smIORequest=%p!!!\n",
3087 ataError, smIORequest));
3097 SM_DBG1((
"smsatDefaultTranslation: **** UNEXPECTED ATA_ERROR **** ataError= 0x%x, smIORequest=%p!!!\n",
3098 ataError, smIORequest));
3121 SM_DBG1((
"smsatDefaultTranslation: *** UNEXPECTED ATA status 0x%x *** smIORequest=%p!!!\n",
3122 ataStatus, smIORequest));
3154 SM_DBG2((
"smIDStart: start, smIORequest %p\n", smIORequest));
3157 if (oneDeviceData ==
agNULL)
3159 SM_DBG1((
"smIDStart: oneDeviceData is NULL!!!\n"));
3164 SM_DBG1((
"smIDStart: oneDeviceData is not valid, did %d !!!\n", oneDeviceData->
id));
3170 if (smIORequestBody ==
agNULL)
3172 SM_DBG1((
"smIDStart: smIORequestBody is NULL!!!\n"));
3178 SM_DBG3((
"smIDStart: io ID %d!!!\n", smIORequestBody->
id ));
3192 SM_DBG3((
"smIDStart: smIORequestBody %p smIORequestBody->smIORequest %p!!!\n", smIORequestBody, smIORequestBody->
smIORequest));
3193 SM_DBG1((
"smIDStart: did %d\n", oneDeviceData->
id));
3203 SM_DBG1((
"smIDStart: smsatIDSubStart failure %d!!!\n",
status));
3206 SM_DBG2((
"smIDStart: exit\n"));
3229 SM_DBG2((
"smsatIDSubStart: start\n"));
3242 SM_DBG1((
"smsatIDSubStart: can't alloacate!!!\n"));
3270 SM_DBG6((
"smsatIDSubStart: SM satIOContext %p \n", satIOContext));
3271 SM_DBG6((
"smsatIDSubStart: SM satNewIOContext %p \n", satNewIOContext));
3277 SM_DBG3((
"smsatIDSubStart: satNewIOContext %p smIORequestBody %p\n", satNewIOContext, smIORequestBody));
3287 SM_DBG1((
"smsatIDSubStart: failed in sending %d!!!\n",
status));
3297 SM_DBG2((
"smsatIDSubStart: end\n"));
3314 bit32 agRequestType;
3317#ifdef SM_INTERNAL_DEBUG
3323 fis = satIOContext->
pFis;
3324 SM_DBG2((
"smsatIDStart: start\n"));
3325#ifdef SM_INTERNAL_DEBUG
3333 SM_DBG2((
"smsatIDStart: IDENTIFY_PACKET_DEVICE\n"));
3338 SM_DBG2((
"smsatIDStart: IDENTIFY_DEVICE\n"));
3365 satIOContext->
reqType = agRequestType;
3367#ifdef SM_INTERNAL_DEBUG
3399 SM_DBG2((
"smsatIOStart: start\n"));
3404 if ( ((pLun->
lun[0] | pLun->
lun[1] | pLun->
lun[2] | pLun->
lun[3] |
3405 pLun->
lun[4] | pLun->
lun[5] | pLun->
lun[6] | pLun->
lun[7] ) != 0) &&
3409 SM_DBG1((
"smsatIOStart: *** REJECT *** LUN not zero, cdb[0]=0x%x did %d !!!\n",
3410 scsiCmnd->
cdb[0], pSatDevData->
id));
3434 SM_DBG1((
"smsatIOStart: invalid identify device data did %d !!!\n", pSatDevData->
id));
3448 SM_DBG1((
"smsatIOStart: IN RECOVERY STATE cdb[0]=0x%x did=%d !!!\n",
3449 scsiCmnd->
cdb[0], pSatDevData->
id));
3463 return smsatReportLun(smRoot, smIORequest, smDeviceHandle, smSCSIRequest, satIOContext);
3467 return smsatPacket(smRoot, smIORequest, smDeviceHandle, smSCSIRequest, satIOContext);
3473 switch(scsiCmnd->
cdb[0])
3500 SM_DBG5((
"smsatIOStart: SCSIOPC_READ_12\n"));
3525 SM_DBG5((
"smsatIOStart: SCSIOPC_WRITE_12 \n"));
3534 SM_DBG5((
"smsatIOStart: SCSIOPC_WRITE_16 \n"));
3551 SM_DBG5((
"smsatIOStart: SCSIOPC_VERIFY_12\n"));
3560 SM_DBG5((
"smsatIOStart: SCSIOPC_VERIFY_16\n"));
3634 SM_DBG5((
"smsatIOStart: SCSIOPC_FORMAT_UNIT\n"));
3643 SM_DBG5((
"smsatIOStart: SCSIOPC_SEND_DIAGNOSTIC\n"));
3652 SM_DBG5((
"smsatIOStart: SCSIOPC_START_STOP_UNIT\n"));
3661 SM_DBG5((
"smsatIOStart: SCSIOPC_WRITE_SAME_10\n"));
3670 SM_DBG5((
"smsatIOStart: SCSIOPC_WRITE_SAME_16\n"));
3679 SM_DBG5((
"smsatIOStart: SCSIOPC_LOG_SENSE\n"));
3688 SM_DBG5((
"smsatIOStart: SCSIOPC_MODE_SELECT_6\n"));
3697 SM_DBG5((
"smsatIOStart: SCSIOPC_MODE_SELECT_10\n"));
3707 SM_DBG5((
"smsatIOStart: SCSIOPC_SYNCHRONIZE_CACHE_10\n"));
3718 SM_DBG5((
"smsatIOStart: SCSIOPC_SYNCHRONIZE_CACHE_16\n"));
3727 SM_DBG5((
"smsatIOStart: SCSIOPC_WRITE_AND_VERIFY_10\n"));
3736 SM_DBG5((
"smsatIOStart: SCSIOPC_WRITE_AND_VERIFY_12\n"));
3745 SM_DBG5((
"smsatIOStart: SCSIOPC_WRITE_AND_VERIFY_16\n"));
3755 SM_DBG5((
"smsatIOStart: SCSIOPC_READ_MEDIA_SERIAL_NUMBER\n"));
3765 SM_DBG5((
"smsatIOStart: SCSIOPC_READ_BUFFER\n"));
3775 SM_DBG5((
"smsatIOStart: SCSIOPC_WRITE_BUFFER\n"));
3785 SM_DBG5((
"smsatIOStart: SCSIOPC_REASSIGN_BLOCKS\n"));
3796 SM_DBG5((
"smsatIOStart: SCSIOPC_ATA_PASS_THROUGH\n"));
3806 SM_DBG1((
"smsatIOStart: unsupported SCSI cdb[0]=0x%x did=%d !!!\n",
3807 scsiCmnd->
cdb[0], pSatDevData->
id));
3832 SM_DBG1((
"smsatIOStart: BUSY did %d!!!\n", pSatDevData->
id));
3833 SM_DBG2((
"smsatIOStart: LL is busy or target queue is full\n"));
3862 SM_DBG2((
"smsatSetSensePayload: start\n"));
3867 for (i=0;i< senseLength;i++)
3869 ((
bit8*)pSense)[i] = 0;
3881 pSense->
info[0] = (
bit8)((SnsInfo >> 24) & 0xff);
3882 pSense->
info[1] = (
bit8)((SnsInfo >> 16) & 0xff);
3883 pSense->
info[2] = (
bit8)((SnsInfo >> 8) & 0xff);
3884 pSense->
info[3] = (
bit8)((SnsInfo) & 0xff);
3904 if (satIOContext !=
agNULL)
3910 SM_DBG1((
"smsatSetSensePayload: satIOContext is NULL!!!\n"));
3918 SM_DBG3((
"smsatSetSensePayload: extend 0x%x Sector_Cnt_Upper_Nonzero 0x%x LBA_Upper_Nonzero 0x%x\n",
3920 SM_DBG3((
"smsatSetSensePayload: tmp 0x%x\n", tmp));
3957 if ( (pSignature)[0] == 0x01 && (pSignature)[1] == 0x01
3958 && (pSignature)[2] == 0x00 && (pSignature)[3] == 0x00
3959 && (pSignature)[4] == 0xA0 )
3963 else if ( (pSignature)[0] == 0x01 && (pSignature)[1] == 0x01
3964 && (pSignature)[2] == 0x00 && (pSignature)[3] == 0x00
3965 && (pSignature)[4] == 0x00 )
3969 else if ( (pSignature)[0] == 0x01 && (pSignature)[1] == 0x01
3970 && (pSignature)[2] == 0x14 && (pSignature)[3] == 0xEB
3971 && ( (pSignature)[4] == 0x00 || (pSignature)[4] == 0x10) )
3975 else if ( (pSignature)[0] == 0x01 && (pSignature)[1] == 0x01
3976 && (pSignature)[2] == 0x69 && (pSignature)[3] == 0x96
3977 && (pSignature)[4] == 0x00 )
3981 else if ( (pSignature)[0] == 0x01 && (pSignature)[1] == 0x01
3982 && (pSignature)[2] == 0x3C && (pSignature)[3] == 0xC3
3983 && (pSignature)[4] == 0x00 )
3987 else if ( (pSignature)[0] == 0xFF && (pSignature)[1] == 0xFF
3988 && (pSignature)[2] == 0xFF && (pSignature)[3] == 0xFF
3989 && (pSignature)[4] == 0xFF )
4032 scsiCmnd = &smScsiRequest->
scsiCmnd;
4033 fis = satIOContext->
pFis;
4035 SM_DBG3((
"smsatPacket: start, SCSI CDB is 0x%X %X %X %X %X %X %X %X %X %X %X %X\n",
4036 scsiCmnd->
cdb[0],scsiCmnd->
cdb[1],scsiCmnd->
cdb[2],scsiCmnd->
cdb[3],
4037 scsiCmnd->
cdb[4],scsiCmnd->
cdb[5],scsiCmnd->
cdb[6],scsiCmnd->
cdb[7],
4038 scsiCmnd->
cdb[8],scsiCmnd->
cdb[9],scsiCmnd->
cdb[10],scsiCmnd->
cdb[11]));
4102 satIOContext->
reqType = agRequestType;
4110 SM_DBG3((
"smsatPacket: return\n"));
4142 bit32 agRequestType;
4145 fis = satIOContext->
pFis;
4146 SM_DBG2((
"smsatSetFeaturesPIO: start\n"));
4177 satIOContext->
reqType = agRequestType;
4185 SM_DBG2((
"smsatSetFeaturesPIO: return\n"));
4189 SM_DBG1((
"smsatSetFeaturesPIO: incorrect smIORequest\n"));
4228 scsiCmnd = &smScsiRequest->
scsiCmnd;
4229 fis = satIOContext->
pFis;
4232 scsiCmnd->
cdb[1] = 0;
4233 scsiCmnd->
cdb[2] = 0;
4234 scsiCmnd->
cdb[3] = 0;
4236 scsiCmnd->
cdb[5] = 0;
4237 SM_DBG3((
"smsatRequestSenseForATAPI: start, SCSI CDB is 0x%X %X %X %X %X %X %X %X %X %X %X %X\n",
4238 scsiCmnd->
cdb[0],scsiCmnd->
cdb[1],scsiCmnd->
cdb[2],scsiCmnd->
cdb[3],
4239 scsiCmnd->
cdb[4],scsiCmnd->
cdb[5],scsiCmnd->
cdb[6],scsiCmnd->
cdb[7],
4240 scsiCmnd->
cdb[8],scsiCmnd->
cdb[9],scsiCmnd->
cdb[10],scsiCmnd->
cdb[11]));
4287 satIOContext->
reqType = agRequestType;
4295 SM_DBG3((
"smsatRequestSenseForATAPI: return\n"));
4326 bit32 agRequestType;
4329 fis = satIOContext->
pFis;
4330 SM_DBG3((
"smsatDeviceReset: start\n"));
4361 satIOContext->
reqType = agRequestType;
4369 SM_DBG3((
"smsatDeviceReset: return\n"));
4403 bit32 agRequestType;
4406 fis = satIOContext->
pFis;
4407 SM_DBG3((
"smsatExecuteDeviceDiagnostic: start\n"));
4438 satIOContext->
reqType = agRequestType;
4446 SM_DBG3((
"smsatExecuteDeviceDiagnostic: return\n"));
4461 SM_DBG2((
"smsatSetDeferredSensePayload: start\n"));
4484 pSense = satIOContext->
pSense;
4486 scsiCmnd = &smScsiRequest->
scsiCmnd;
4487 fis = satIOContext->
pFis;
4489 SM_DBG2((
"smsatRead6: start\n"));
4513 SM_DBG1((
"smsatRead6: return control!!!\n"));
4518 lba = (((scsiCmnd->
cdb[1]) & 0x1f) << (8*2))
4519 + (scsiCmnd->
cdb[2] << 8) + scsiCmnd->
cdb[3];
4520 tl = scsiCmnd->
cdb[4];
4553 SM_DBG1((
"smsatRead6: return LBA out of range!!!\n"));
4565 SM_DBG5((
"smsatRead6: case 2\n"));
4600 SM_DBG5((
"smsatRead6: case 1\n"));
4640 SM_DBG5((
"smsatRead6: case 3\n"));
4674 SM_DBG5((
"smsatRead6: case 4\n"));
4714 SM_DBG1((
"smsatRead6: case 5 !!! error NCQ but 28 bit address support!!!\n"));
4731 SM_DBG5((
"smsatRead6: case 5\n"));
4772 satIOContext->
reqType = agRequestType;
4806 SM_DBG2((
"smsatRead10: start\n"));
4807 SM_DBG2((
"smsatRead10: pSatDevData did=%d\n", pSatDevData->
id));
4828 SM_DBG1((
"smsatRead10: return FUA_NV!!!\n"));
4852 SM_DBG1((
"smsatRead10: return control!!!\n"));
4864 LBA[4] = scsiCmnd->
cdb[2];
4865 LBA[5] = scsiCmnd->
cdb[3];
4866 LBA[6] = scsiCmnd->
cdb[4];
4867 LBA[7] = scsiCmnd->
cdb[5];
4875 TL[6] = scsiCmnd->
cdb[7];
4876 TL[7] = scsiCmnd->
cdb[8];
4880 lba = (scsiCmnd->
cdb[2] << 24) + (scsiCmnd->
cdb[3] << 16)
4881 + (scsiCmnd->
cdb[4] << 8) + scsiCmnd->
cdb[5];
4882 tl = (scsiCmnd->
cdb[7] << 8) + scsiCmnd->
cdb[8];
4907 SM_DBG1((
"smsatRead10: return LBA out of range, not EXT!!!\n"));
4931 SM_DBG1((
"smsatRead10: return LBA out of range, EXT!!!\n"));
4956 SM_DBG1((
"smsatRead10: case 5 !!! error NCQ but 28 bit address support!!!\n"));
4974 SM_DBG6((
"smsatRead10: case 5\n"));
5011 SM_DBG5((
"smsatRead10: case 3\n"));
5040 SM_DBG5((
"smsatRead10: case 4\n"));
5094 SM_DBG5((
"smsatRead10: case 2\n"));
5105 (
bit8)((0x4 << 4) | (scsiCmnd->
cdb[2] & 0xF));
5126 SM_DBG5((
"smsatRead10: case 1\n"));
5136 (
bit8)((0x4 << 4) | (scsiCmnd->
cdb[2] & 0xF));
5156 satIOContext->
OrgTL = tl;
5174 satIOContext->
LoopNum = LoopNum;
5180 SM_DBG5((
"smsatRead10: NON CHAINED data\n"));
5185 SM_DBG2((
"smsatRead10: CHAINED data!!!\n"));
5237 satIOContext->
reqType = agRequestType;
5245 SM_DBG5((
"smsatRead10: return\n"));
5272 pSense = satIOContext->
pSense;
5274 scsiCmnd = &smScsiRequest->
scsiCmnd;
5275 fis = satIOContext->
pFis;
5277 SM_DBG5((
"smsatRead12: start\n"));
5297 SM_DBG1((
"smsatRead12: return FUA_NV!!!\n"));
5321 SM_DBG1((
"smsatRead12: return control!!!\n"));
5333 LBA[4] = scsiCmnd->
cdb[2];
5334 LBA[5] = scsiCmnd->
cdb[3];
5335 LBA[6] = scsiCmnd->
cdb[4];
5336 LBA[7] = scsiCmnd->
cdb[5];
5342 TL[4] = scsiCmnd->
cdb[6];
5343 TL[5] = scsiCmnd->
cdb[7];
5344 TL[6] = scsiCmnd->
cdb[8];
5345 TL[7] = scsiCmnd->
cdb[9];
5369 SM_DBG1((
"smsatRead12: return LBA out of range, not EXT!!!\n"));
5393 SM_DBG1((
"smsatRead12: return LBA out of range, EXT!!!\n"));
5420 SM_DBG5((
"smsatRead12: case 2\n"));
5431 (
bit8)((0x4 << 4) | (scsiCmnd->
cdb[2] & 0xF));
5452 SM_DBG5((
"smsatRead12: case 1\n"));
5462 (
bit8)((0x4 << 4) | (scsiCmnd->
cdb[2] & 0xF));
5485 SM_DBG5((
"smsatRead12: case 3\n"));
5514 SM_DBG5((
"smsatRead12: case 4\n"));
5568 SM_DBG1((
"smsatRead12: case 5 !!! error NCQ but 28 bit address support!!!\n"));
5586 SM_DBG6((
"smsatRead12: case 5\n"));
5620 satIOContext->
OrgTL = tl;
5642 satIOContext->
LoopNum = LoopNum;
5646 SM_DBG5((
"smsatRead12: NON CHAINED data\n"));
5651 SM_DBG1((
"smsatRead12: CHAINED data\n"));
5677 satIOContext->
reqType = agRequestType;
5685 SM_DBG5((
"smsatRead12: return\n"));
5712 pSense = satIOContext->
pSense;
5714 scsiCmnd = &smScsiRequest->
scsiCmnd;
5715 fis = satIOContext->
pFis;
5717 SM_DBG5((
"smsatRead16: start\n"));
5737 SM_DBG1((
"smsatRead16: return FUA_NV!!!\n"));
5761 SM_DBG1((
"smsatRead16: return control!!!\n"));
5771 LBA[0] = scsiCmnd->
cdb[2];
5772 LBA[1] = scsiCmnd->
cdb[3];
5773 LBA[2] = scsiCmnd->
cdb[4];
5774 LBA[3] = scsiCmnd->
cdb[5];
5775 LBA[4] = scsiCmnd->
cdb[6];
5776 LBA[5] = scsiCmnd->
cdb[7];
5777 LBA[6] = scsiCmnd->
cdb[8];
5778 LBA[7] = scsiCmnd->
cdb[9];
5784 TL[4] = scsiCmnd->
cdb[10];
5785 TL[5] = scsiCmnd->
cdb[11];
5786 TL[6] = scsiCmnd->
cdb[12];
5787 TL[7] = scsiCmnd->
cdb[13];
5813 SM_DBG1((
"smsatRead16: return LBA out of range, not EXT!!!\n"));
5845 SM_DBG1((
"smsatRead16: return LBA out of range, EXT!!!\n"));
5872 SM_DBG5((
"smsatRead16: case 2\n"));
5883 (
bit8)((0x4 << 4) | (scsiCmnd->
cdb[6] & 0xF));
5904 SM_DBG5((
"smsatRead16: case 1\n"));
5914 (
bit8)((0x4 << 4) | (scsiCmnd->
cdb[6] & 0xF));
5937 SM_DBG5((
"smsatRead16: case 3\n"));
5966 SM_DBG5((
"smsatRead16: case 4\n"));
6020 SM_DBG1((
"smsatRead16: case 5 !!! error NCQ but 28 bit address support!!!\n"));
6038 SM_DBG6((
"smsatRead16: case 5\n"));
6072 satIOContext->
OrgTL = tl;
6093 satIOContext->
LoopNum = LoopNum;
6097 SM_DBG5((
"smsatRead16: NON CHAINED data\n"));
6102 SM_DBG1((
"smsatRead16: CHAINED data!!!\n"));
6128 satIOContext->
reqType = agRequestType;
6136 SM_DBG5((
"smsatRead16: return\n"));
6160 pSense = satIOContext->
pSense;
6162 scsiCmnd = &smScsiRequest->
scsiCmnd;
6163 fis = satIOContext->
pFis;
6165 SM_DBG5((
"smsatWrite6: start\n"));
6186 SM_DBG1((
"smsatWrite6: return control!!!\n"));
6192 lba = (((scsiCmnd->
cdb[1]) & 0x1f) << (8*2))
6193 + (scsiCmnd->
cdb[2] << 8) + scsiCmnd->
cdb[3];
6194 tl = scsiCmnd->
cdb[4];
6228 SM_DBG1((
"smsatWrite6: return LBA out of range!!!\n"));
6240 SM_DBG5((
"smsatWrite6: case 2\n"));
6275 SM_DBG5((
"smsatWrite6: case 1\n"));
6315 SM_DBG5((
"smsatWrite6: case 3\n"));
6349 SM_DBG5((
"smsatWrite6: case 4\n"));
6389 SM_DBG5((
"smsatWrite6: case 5 !!! error NCQ but 28 bit address support!!!\n"));
6406 SM_DBG5((
"smsatWrite6: case 5\n"));
6447 satIOContext->
reqType = agRequestType;
6479 SM_DBG2((
"smsatWrite10: start\n"));
6499 SM_DBG1((
"smsatWrite10: return FUA_NV!!!\n"));
6523 SM_DBG1((
"smsatWrite10: return control!!!\n"));
6535 LBA[4] = scsiCmnd->
cdb[2];
6536 LBA[5] = scsiCmnd->
cdb[3];
6537 LBA[6] = scsiCmnd->
cdb[4];
6538 LBA[7] = scsiCmnd->
cdb[5];
6546 TL[6] = scsiCmnd->
cdb[7];
6547 TL[7] = scsiCmnd->
cdb[8];
6552 lba = (scsiCmnd->
cdb[2] << (24)) + (scsiCmnd->
cdb[3] << (16))
6553 + (scsiCmnd->
cdb[4] << 8) + scsiCmnd->
cdb[5];
6554 tl = (scsiCmnd->
cdb[7] << 8) + scsiCmnd->
cdb[8];
6576 SM_DBG1((
"smsatWrite10: return LBA out of range, not EXT!!!\n"));
6577 SM_DBG1((
"smsatWrite10: cdb 0x%x 0x%x 0x%x 0x%x!!!\n",scsiCmnd->
cdb[2], scsiCmnd->
cdb[3],
6578 scsiCmnd->
cdb[4], scsiCmnd->
cdb[5]));
6603 SM_DBG1((
"smsatWrite10: return LBA out of range, EXT!!!\n"));
6630 SM_DBG1((
"smsatWrite10: case 5 !!! error NCQ but 28 bit address support!!!\n"));
6647 SM_DBG6((
"smsatWrite10: case 5\n"));
6685 SM_DBG5((
"smsatWrite10: case 3\n"));
6715 SM_DBG5((
"smsatWrite10: case 4\n"));
6746 SM_DBG5((
"smsatWrite10: case 2\n"));
6777 SM_DBG5((
"smsatWrite10: case 1\n"));
6807 satIOContext->
OrgTL = tl;
6825 satIOContext->
LoopNum = LoopNum;
6830 SM_DBG5((
"smsatWrite10: NON CHAINED data\n"));
6837 SM_DBG2((
"smsatWrite10: CHAINED data!!!\n"));
6891 satIOContext->
reqType = agRequestType;
6923 pSense = satIOContext->
pSense;
6925 scsiCmnd = &smScsiRequest->
scsiCmnd;
6926 fis = satIOContext->
pFis;
6928 SM_DBG5((
"smsatWrite12: start\n"));
6948 SM_DBG1((
"smsatWrite12: return FUA_NV!!!\n"));
6973 SM_DBG1((
"smsatWrite10: return control!!!\n"));
6986 LBA[4] = scsiCmnd->
cdb[2];
6987 LBA[5] = scsiCmnd->
cdb[3];
6988 LBA[6] = scsiCmnd->
cdb[4];
6989 LBA[7] = scsiCmnd->
cdb[5];
6995 TL[4] = scsiCmnd->
cdb[6];
6996 TL[5] = scsiCmnd->
cdb[7];
6997 TL[6] = scsiCmnd->
cdb[8];
6998 TL[7] = scsiCmnd->
cdb[9];
7027 SM_DBG1((
"smsatWrite12: return LBA out of range, not EXT!!!\n"));
7051 SM_DBG1((
"smsatWrite12: return LBA out of range, EXT!!!\n"));
7071 SM_DBG5((
"smsatWrite10: case 2\n"));
7102 SM_DBG5((
"smsatWrite10: case 1\n"));
7135 SM_DBG5((
"smsatWrite10: case 3\n"));
7165 SM_DBG5((
"smsatWrite10: case 4\n"));
7196 SM_DBG5((
"smsatWrite10: case 5 !!! error NCQ but 28 bit address support!!!\n"));
7213 SM_DBG6((
"smsatWrite10: case 5\n"));
7246 satIOContext->
OrgTL = tl;
7271 satIOContext->
LoopNum = LoopNum;
7276 SM_DBG5((
"smsatWrite10: NON CHAINED data\n"));
7283 SM_DBG1((
"smsatWrite10: CHAINED data\n"));
7313 satIOContext->
reqType = agRequestType;
7345 pSense = satIOContext->
pSense;
7347 scsiCmnd = &smScsiRequest->
scsiCmnd;
7348 fis = satIOContext->
pFis;
7350 SM_DBG5((
"smsatWrite16: start\n"));
7370 SM_DBG1((
"smsatWrite16: return FUA_NV!!!\n"));
7394 SM_DBG1((
"smsatWrite16: return control!!!\n"));
7404 LBA[0] = scsiCmnd->
cdb[2];
7405 LBA[1] = scsiCmnd->
cdb[3];
7406 LBA[2] = scsiCmnd->
cdb[4];
7407 LBA[3] = scsiCmnd->
cdb[5];
7408 LBA[4] = scsiCmnd->
cdb[6];
7409 LBA[5] = scsiCmnd->
cdb[7];
7410 LBA[6] = scsiCmnd->
cdb[8];
7411 LBA[7] = scsiCmnd->
cdb[9];
7417 TL[4] = scsiCmnd->
cdb[10];
7418 TL[5] = scsiCmnd->
cdb[11];
7419 TL[6] = scsiCmnd->
cdb[12];
7420 TL[7] = scsiCmnd->
cdb[13];
7446 SM_DBG1((
"smsatWrite16: return LBA out of range, not EXT!!!\n"));
7470 SM_DBG1((
"smsatWrite16: return LBA out of range, EXT!!!\n"));
7496 SM_DBG5((
"smsatWrite16: case 2\n"));
7527 SM_DBG5((
"smsatWrite16: case 1\n"));
7560 SM_DBG5((
"smsatWrite16: case 3\n"));
7590 SM_DBG5((
"smsatWrite16: case 4\n"));
7621 SM_DBG5((
"smsatWrite16: case 5 !!! error NCQ but 28 bit address support!!!\n"));
7638 SM_DBG6((
"smsatWrite16: case 5\n"));
7671 satIOContext->
OrgTL = tl;
7696 satIOContext->
LoopNum = LoopNum;
7701 SM_DBG5((
"smsatWrite16: NON CHAINED data\n"));
7708 SM_DBG1((
"smsatWrite16: CHAINED data!!!\n"));
7738 satIOContext->
reqType = agRequestType;
7775 pSense = satIOContext->
pSense;
7776 scsiCmnd = &smScsiRequest->
scsiCmnd;
7778 fis = satIOContext->
pFis;
7779 SM_DBG5((
"smsatVerify10: start\n"));
7800 SM_DBG1((
"smsatVerify10: no byte checking!!!\n"));
7823 SM_DBG1((
"smsatVerify10: return control!!!\n"));
7836 LBA[4] = scsiCmnd->
cdb[2];
7837 LBA[5] = scsiCmnd->
cdb[3];
7838 LBA[6] = scsiCmnd->
cdb[4];
7839 LBA[7] = scsiCmnd->
cdb[5];
7847 TL[6] = scsiCmnd->
cdb[7];
7848 TL[7] = scsiCmnd->
cdb[8];
7852 lba = (scsiCmnd->
cdb[2] << (8*3)) + (scsiCmnd->
cdb[3] << (8*2))
7853 + (scsiCmnd->
cdb[4] << 8) + scsiCmnd->
cdb[5];
7854 tl = (scsiCmnd->
cdb[7] << 8) + scsiCmnd->
cdb[8];
7863 SM_DBG1((
"smsatVerify10: return LBA out of range, not EXT!!!\n"));
7864 SM_DBG1((
"smsatVerify10: cdb 0x%x 0x%x 0x%x 0x%x!!!\n",scsiCmnd->
cdb[2], scsiCmnd->
cdb[3],
7865 scsiCmnd->
cdb[4], scsiCmnd->
cdb[5]));
7890 SM_DBG1((
"smsatVerify10: return LBA out of range, EXT!!!\n"));
7912 SM_DBG5((
"smsatVerify10: SAT_READ_VERIFY_SECTORS_EXT\n"));
7938 SM_DBG5((
"smsatVerify10: SAT_READ_VERIFY_SECTORS\n"));
7964 satIOContext->
OrgTL = tl;
7982 SM_DBG1((
"smsatVerify10: error case 1!!!\n"));
7986 satIOContext->
LoopNum = LoopNum;
7990 SM_DBG5((
"smsatVerify10: NON CHAINED data\n"));
7997 SM_DBG1((
"smsatVerify10: CHAINED data!!!\n"));
8010 SM_DBG1((
"smsatVerify10: error case 2!!!\n"));
8022 satIOContext->
reqType = agRequestType;
8058 pSense = satIOContext->
pSense;
8059 scsiCmnd = &smScsiRequest->
scsiCmnd;
8061 fis = satIOContext->
pFis;
8062 SM_DBG5((
"smsatVerify12: start\n"));
8085 SM_DBG1((
"smsatVerify12: no byte checking!!!\n"));
8108 SM_DBG1((
"smsatVerify12: return control!!!\n"));
8120 LBA[4] = scsiCmnd->
cdb[2];
8121 LBA[5] = scsiCmnd->
cdb[3];
8122 LBA[6] = scsiCmnd->
cdb[4];
8123 LBA[7] = scsiCmnd->
cdb[5];
8129 TL[4] = scsiCmnd->
cdb[6];
8130 TL[5] = scsiCmnd->
cdb[7];
8131 TL[6] = scsiCmnd->
cdb[8];
8132 TL[7] = scsiCmnd->
cdb[9];
8145 SM_DBG1((
"smsatVerify12: return LBA out of range, not EXT!!!\n"));
8146 SM_DBG1((
"smsatVerify12: cdb 0x%x 0x%x 0x%x 0x%x!!!\n",scsiCmnd->
cdb[2], scsiCmnd->
cdb[3],
8147 scsiCmnd->
cdb[4], scsiCmnd->
cdb[5]));
8172 SM_DBG1((
"smsatVerify12: return LBA out of range, EXT!!!\n"));
8194 SM_DBG5((
"smsatVerify12: SAT_READ_VERIFY_SECTORS_EXT\n"));
8220 SM_DBG5((
"smsatVerify12: SAT_READ_VERIFY_SECTORS\n"));
8246 satIOContext->
OrgTL = tl;
8264 SM_DBG1((
"smsatVerify12: error case 1!!!\n"));
8268 satIOContext->
LoopNum = LoopNum;
8272 SM_DBG5((
"smsatVerify12: NON CHAINED data\n"));
8279 SM_DBG1((
"smsatVerify12: CHAINED data!!!\n"));
8292 SM_DBG1((
"smsatVerify12: error case 2!!!\n"));
8304 satIOContext->
reqType = agRequestType;
8340 pSense = satIOContext->
pSense;
8341 scsiCmnd = &smScsiRequest->
scsiCmnd;
8343 fis = satIOContext->
pFis;
8344 SM_DBG5((
"smsatVerify16: start\n"));
8364 SM_DBG1((
"smsatVerify16: no byte checking!!!\n"));
8383 SM_DBG1((
"smsatVerify16: return control!!!\n"));
8390 LBA[0] = scsiCmnd->
cdb[2];
8391 LBA[1] = scsiCmnd->
cdb[3];
8392 LBA[2] = scsiCmnd->
cdb[4];
8393 LBA[3] = scsiCmnd->
cdb[5];
8394 LBA[4] = scsiCmnd->
cdb[6];
8395 LBA[5] = scsiCmnd->
cdb[7];
8396 LBA[6] = scsiCmnd->
cdb[8];
8397 LBA[7] = scsiCmnd->
cdb[9];
8403 TL[4] = scsiCmnd->
cdb[10];
8404 TL[5] = scsiCmnd->
cdb[11];
8405 TL[6] = scsiCmnd->
cdb[12];
8406 TL[7] = scsiCmnd->
cdb[13];
8417 SM_DBG1((
"smsatVerify16: return LBA out of range, not EXT!!!\n"));
8438 SM_DBG1((
"smsatVerify16: return LBA out of range, EXT!!!\n"));
8457 SM_DBG5((
"smsatVerify16: SAT_READ_VERIFY_SECTORS_EXT\n"));
8482 SM_DBG5((
"smsatVerify16: SAT_READ_VERIFY_SECTORS\n"));
8508 satIOContext->
OrgTL = tl;
8526 SM_DBG1((
"smsatVerify16: error case 1!!!\n"));
8530 satIOContext->
LoopNum = LoopNum;
8534 SM_DBG5((
"smsatVerify16: NON CHAINED data\n"));
8541 SM_DBG1((
"smsatVerify16: CHAINED data!!!\n"));
8554 SM_DBG1((
"smsatVerify16: error case 2!!!\n"));
8566 satIOContext->
reqType = agRequestType;
8586 bit32 agRequestType;
8592 pSense = satIOContext->
pSense;
8594 scsiCmnd = &smScsiRequest->
scsiCmnd;
8595 fis = satIOContext->
pFis;
8597 SM_DBG5((
"smsatTestUnitReady: start\n"));
8618 SM_DBG1((
"smsatTestUnitReady: return control!!!\n"));
8639 SM_DBG1((
"smsatTestUnitReady: stop state!!!\n"));
8648 SM_DBG1((
"smsatTestUnitReady: FORMAT_IN_PROGRESS!!!\n"));
8664 SM_DBG1((
"smsatTestUnitReady: format in progress!!!\n"));
8689 SM_DBG1((
"smsatTestUnitReady: previous command ended in error!!!\n"));
8699 SM_DBG5((
"smsatTestUnitReady: sending get media status cmnd\n"));
8727 satIOContext->
reqType = agRequestType;
8741 SM_DBG5((
"smsatTestUnitReady: sending check power mode cmnd\n"));
8765 bit32 agRequestType;
8768 fis = satIOContext->
pFis;
8769 SM_DBG5((
"smsatTestUnitReady_1: start\n"));
8800 satIOContext->
reqType = agRequestType;
8808 SM_DBG5((
"smsatTestUnitReady_1: return\n"));
8830 pSense = satIOContext->
pSense;
8831 scsiCmnd = &smScsiRequest->
scsiCmnd;
8833 SM_DBG5((
"smsatInquiry: start\n"));
8834 SM_DBG5((
"smsatInquiry: pSatDevData did %d\n", pSatDevData->
id));
8852 SM_DBG1((
"smsatInquiry: return control!!!\n"));
8860 (scsiCmnd->
cdb[2] != 0)
8875 SM_DBG1((
"smsatInquiry: return EVPD and PAGE CODE!!!\n"));
8878 SM_DBG6((
"smsatInquiry: allocation length 0x%x %d\n", ((scsiCmnd->
cdb[3]) << 8) + scsiCmnd->
cdb[4], ((scsiCmnd->
cdb[3]) << 8) + scsiCmnd->
cdb[4]));
8894 SM_DBG6((
"smsatInquiry: calling satInquiryIntCB\n"));
8923 SM_DBG5((
"smsatStartIDDev: start\n"));
8927 SM_DBG6((
"smsatStartIDDev: before alloc\n"));
8936 SM_DBG6((
"smsatStartIDDev: before after\n"));
8940 SM_DBG1((
"smsatStartIDDev: can't alloacate!!!\n"));
8967 SM_DBG6((
"smsatStartIDDev: OS satIOContext %p \n", satIOContext));
8968 SM_DBG6((
"smsatStartIDDev: TD satNewIOContext %p \n", satNewIOContext));
8974 SM_DBG1((
"smsatStartIDDev: satNewIOContext %p smIORequestBody %p!!!\n", satNewIOContext, smIORequestBody));
8984 SM_DBG1((
"smsatStartIDDev: failed in sending!!!\n"));
8995 SM_DBG6((
"smsatStartIDDev: end\n"));
9010 bit32 agRequestType;
9013#ifdef SM_INTERNAL_DEBUG
9019 fis = satIOContext->
pFis;
9020 SM_DBG6((
"smsatSendIDDev: start\n"));
9021 SM_DBG6((
"smsatSendIDDev: did %d\n", pSatDevData->
id));
9022#ifdef SM_INTERNAL_DEBUG
9056 satIOContext->
reqType = agRequestType;
9058#ifdef SM_INTERNAL_DEBUG
9089 bit32 agRequestType;
9098 bit32 allocationLen = 0;
9100 pSense = satIOContext->
pSense;
9102 scsiCmnd = &smScsiRequest->
scsiCmnd;
9103 fis = satIOContext->
pFis;
9105 allocationLen = scsiCmnd->
cdb[4];
9107 SM_DBG5((
"smsatRequestSense: start\n"));
9129 SM_DBG1((
"smsatRequestSense: return control!!!\n"));
9155 SM_DBG1((
"smsatRequestSense: DESC bit is set, which we don't support!!!\n"));
9190 satIOContext->
reqType = agRequestType;
9198 SM_DBG4((
"smsatRequestSense: if return, status %d\n",
status));
9206 SM_DBG4((
"smsatRequestSense: before satIntIo %p\n", satIntIo));
9214 SM_DBG4((
"smsatRequestSense: after satIntIo %p\n", satIntIo));
9235 SM_DBG1((
"smsatRequestSense: else fail 1!!!\n"));
9247 SM_DBG4((
"smsatRequestSense: satIntIo is NULL\n"));
9251 SM_DBG4((
"smsatRequestSense: satIntIo is NOT NULL\n"));
9309 SM_DBG1((
"smsatRequestSense: else fail 2!!!\n"));
9312 SM_DBG4((
"smsatRequestSense: else return success\n"));
9330 bit32 agRequestType;
9333 fis = satIOContext->
pFis;
9334 SM_DBG5((
"smsatRequestSense_1: start\n"));
9365 satIOContext->
reqType = agRequestType;
9368 SM_DBG4((
"smsatRequestSense_1: smSgl1.len %d\n", smScsiRequest->
smSgl1.
len));
9399 bit32 allocationLen;
9401 bit32 pageSupported;
9414 pSense = satIOContext->
pSense;
9415 scsiCmnd = &smScsiRequest->
scsiCmnd;
9420 SM_DBG5((
"smsatModeSense6: start\n"));
9437 SM_DBG1((
"smsatModeSense6: return control!!!\n"));
9458 SM_DBG1((
"smsatModeSense6: return due to PC value pc 0x%x!!!\n", PC >> 6));
9465 SM_DBG5((
"smsatModeSense6: page=0x%x\n", page));
9467 allocationLen = scsiCmnd->
cdb[4];
9491 SM_DBG1((
"smsatModeSense6 *** ERROR *** not supported page 0x%x did %d!!!\n",
9492 page, pSatDevData->
id));
9529 SM_DBG1((
"smsatModeSense6: default error page %d!!!\n", page));
9535 SM_DBG5((
"smsatModeSense6: MODESENSE_RETURN_ALL_PAGES\n"));
9536 AllPages[0] = (
bit8)(lenRead - 1);
9555 AllPages[10] = 0x02;
9556 AllPages[11] = 0x00;
9559 AllPages[12] = 0x01;
9560 AllPages[13] = 0x0A;
9561 AllPages[14] = 0x40;
9562 AllPages[15] = 0x00;
9563 AllPages[16] = 0x00;
9564 AllPages[17] = 0x00;
9565 AllPages[18] = 0x00;
9566 AllPages[19] = 0x00;
9567 AllPages[20] = 0x00;
9568 AllPages[21] = 0x00;
9569 AllPages[22] = 0x00;
9570 AllPages[23] = 0x00;
9572 AllPages[24] = 0x08;
9573 AllPages[25] = 0x12;
9576 AllPages[26] = 0x04;
9580 AllPages[26] = 0x00;
9583 AllPages[27] = 0x00;
9584 AllPages[28] = 0x00;
9585 AllPages[29] = 0x00;
9586 AllPages[30] = 0x00;
9587 AllPages[31] = 0x00;
9588 AllPages[32] = 0x00;
9589 AllPages[33] = 0x00;
9590 AllPages[34] = 0x00;
9591 AllPages[35] = 0x00;
9594 AllPages[36] = 0x00;
9598 AllPages[36] = 0x20;
9600 AllPages[37] = 0x00;
9601 AllPages[38] = 0x00;
9602 AllPages[39] = 0x00;
9603 AllPages[40] = 0x00;
9604 AllPages[41] = 0x00;
9605 AllPages[42] = 0x00;
9606 AllPages[43] = 0x00;
9608 AllPages[44] = 0x0A;
9609 AllPages[45] = 0x0A;
9610 AllPages[46] = 0x02;
9613 AllPages[47] = 0x12;
9617 AllPages[47] = 0x02;
9619 AllPages[48] = 0x00;
9620 AllPages[49] = 0x00;
9621 AllPages[50] = 0x00;
9622 AllPages[51] = 0x00;
9623 AllPages[52] = 0xFF;
9624 AllPages[53] = 0xFF;
9625 AllPages[54] = 0x00;
9626 AllPages[55] = 0x00;
9628 AllPages[56] = 0x1C;
9629 AllPages[57] = 0x0A;
9632 AllPages[58] = 0x00;
9636 AllPages[58] = 0x08;
9638 AllPages[59] = 0x00;
9639 AllPages[60] = 0x00;
9640 AllPages[61] = 0x00;
9641 AllPages[62] = 0x00;
9642 AllPages[63] = 0x00;
9643 AllPages[64] = 0x00;
9644 AllPages[65] = 0x00;
9645 AllPages[66] = 0x00;
9646 AllPages[67] = 0x00;
9648 sm_memcpy(pModeSense, &AllPages, lenRead);
9652 SM_DBG5((
"smsatModeSense6: MODESENSE_CONTROL_PAGE\n"));
9696 sm_memcpy(pModeSense, &Control, lenRead);
9701 SM_DBG5((
"smsatModeSense6: MODESENSE_READ_WRITE_ERROR_RECOVERY_PAGE\n"));
9703 RWErrorRecovery[1] = 0x00;
9704 RWErrorRecovery[2] = 0x00;
9705 RWErrorRecovery[3] = 0x08;
9711 RWErrorRecovery[4] = 0x04;
9713 RWErrorRecovery[5] = 0x00;
9714 RWErrorRecovery[6] = 0x00;
9715 RWErrorRecovery[7] = 0x00;
9717 RWErrorRecovery[8] = 0x00;
9719 RWErrorRecovery[9] = 0x00;
9720 RWErrorRecovery[10] = 0x02;
9721 RWErrorRecovery[11] = 0x00;
9725 RWErrorRecovery[12] = 0x01;
9726 RWErrorRecovery[13] = 0x0A;
9727 RWErrorRecovery[14] = 0x40;
9728 RWErrorRecovery[15] = 0x00;
9729 RWErrorRecovery[16] = 0x00;
9730 RWErrorRecovery[17] = 0x00;
9731 RWErrorRecovery[18] = 0x00;
9732 RWErrorRecovery[19] = 0x00;
9733 RWErrorRecovery[20] = 0x00;
9734 RWErrorRecovery[21] = 0x00;
9735 RWErrorRecovery[22] = 0x00;
9736 RWErrorRecovery[23] = 0x00;
9738 sm_memcpy(pModeSense, &RWErrorRecovery, lenRead);
9743 SM_DBG5((
"smsatModeSense6: MODESENSE_CACHING\n"));
9747 SM_DBG5((
"smsatModeSense6: linux 2.6.8.24 support\n"));
9749 Caching[0] = 0x20 - 1;
9825 sm_memcpy(pModeSense, &Caching, lenRead);
9830 SM_DBG5((
"smsatModeSense6: MODESENSE_INFORMATION_EXCEPTION_CONTROL_PAGE\n"));
9832 InfoExceptionCtrl[1] = 0x00;
9833 InfoExceptionCtrl[2] = 0x00;
9834 InfoExceptionCtrl[3] = 0x08;
9840 InfoExceptionCtrl[4] = 0x04;
9842 InfoExceptionCtrl[5] = 0x00;
9843 InfoExceptionCtrl[6] = 0x00;
9844 InfoExceptionCtrl[7] = 0x00;
9846 InfoExceptionCtrl[8] = 0x00;
9848 InfoExceptionCtrl[9] = 0x00;
9849 InfoExceptionCtrl[10] = 0x02;
9850 InfoExceptionCtrl[11] = 0x00;
9854 InfoExceptionCtrl[12] = 0x1C;
9855 InfoExceptionCtrl[13] = 0x0A;
9858 InfoExceptionCtrl[14] = 0x00;
9862 InfoExceptionCtrl[14] = 0x08;
9864 InfoExceptionCtrl[15] = 0x00;
9865 InfoExceptionCtrl[16] = 0x00;
9866 InfoExceptionCtrl[17] = 0x00;
9867 InfoExceptionCtrl[18] = 0x00;
9868 InfoExceptionCtrl[19] = 0x00;
9869 InfoExceptionCtrl[20] = 0x00;
9870 InfoExceptionCtrl[21] = 0x00;
9871 InfoExceptionCtrl[22] = 0x00;
9872 InfoExceptionCtrl[23] = 0x00;
9873 sm_memcpy(pModeSense, &InfoExceptionCtrl, lenRead);
9879 SM_DBG1((
"smsatModeSense6: Error page %d!!!\n", page));
9898 if (allocationLen > lenRead)
9900 SM_DBG6((
"smsatModeSense6 reporting underrun lenRead=0x%x allocationLen=0x%x\n", lenRead, allocationLen));
9907 allocationLen - lenRead,
9939 bit32 allocationLen;
9941 bit32 pageSupported;
9955 pSense = satIOContext->
pSense;
9956 scsiCmnd = &smScsiRequest->
scsiCmnd;
9959 SM_DBG5((
"smsatModeSense10: start\n"));
9979 SM_DBG1((
"smsatModeSense10: return control!!!\n"));
10004 SM_DBG1((
"smsatModeSense10: return due to PC value pc 0x%x!!!\n", PC));
10013 SM_DBG5((
"smsatModeSense10: page=0x%x, did %d\n", page, pSatDevData->
id));
10014 allocationLen = (scsiCmnd->
cdb[7] << 8) + scsiCmnd->
cdb[8];
10035 if (pageSupported ==
agFALSE)
10037 SM_DBG1((
"smsatModeSense10 *** ERROR *** not supported page 0x%x did %d!!!\n", page, pSatDevData->
id));
10106 SM_DBG1((
"smsatModeSense10: default error page %d!!!\n", page));
10112 SM_DBG5((
"smsatModeSense10: MODESENSE_RETURN_ALL_PAGES\n"));
10114 AllPages[1] = (
bit8)(lenRead - 2);
10115 AllPages[2] = 0x00;
10116 AllPages[3] = 0x00;
10119 AllPages[4] = 0x00;
10120 AllPages[4] = (
bit8)(AllPages[4] | 0x1);
10124 AllPages[4] = 0x00;
10126 AllPages[5] = 0x00;
10127 AllPages[6] = 0x00;
10130 AllPages[7] = 0x10;
10134 AllPages[7] = 0x08;
10144 AllPages[8] = 0x04;
10146 AllPages[9] = 0x00;
10147 AllPages[10] = 0x00;
10148 AllPages[11] = 0x00;
10149 AllPages[12] = 0x00;
10150 AllPages[13] = 0x00;
10151 AllPages[14] = 0x00;
10152 AllPages[15] = 0x00;
10154 AllPages[16] = 0x00;
10155 AllPages[17] = 0x00;
10156 AllPages[18] = 0x00;
10157 AllPages[19] = 0x00;
10159 AllPages[20] = 0x00;
10160 AllPages[21] = 0x00;
10161 AllPages[22] = 0x02;
10162 AllPages[23] = 0x00;
10167 AllPages[8] = 0x04;
10169 AllPages[9] = 0x00;
10170 AllPages[10] = 0x00;
10171 AllPages[11] = 0x00;
10173 AllPages[12] = 0x00;
10175 AllPages[13] = 0x00;
10176 AllPages[14] = 0x02;
10177 AllPages[15] = 0x00;
10189 AllPages[
index+0] = 0x01;
10190 AllPages[
index+1] = 0x0A;
10191 AllPages[
index+2] = 0x40;
10192 AllPages[
index+3] = 0x00;
10193 AllPages[
index+4] = 0x00;
10194 AllPages[
index+5] = 0x00;
10195 AllPages[
index+6] = 0x00;
10196 AllPages[
index+7] = 0x00;
10197 AllPages[
index+8] = 0x00;
10198 AllPages[
index+9] = 0x00;
10199 AllPages[
index+10] = 0x00;
10200 AllPages[
index+11] = 0x00;
10207 AllPages[
index+12] = 0x08;
10208 AllPages[
index+13] = 0x12;
10211 AllPages[
index+14] = 0x04;
10215 AllPages[
index+14] = 0x00;
10218 AllPages[
index+15] = 0x00;
10219 AllPages[
index+16] = 0x00;
10220 AllPages[
index+17] = 0x00;
10221 AllPages[
index+18] = 0x00;
10222 AllPages[
index+19] = 0x00;
10223 AllPages[
index+20] = 0x00;
10224 AllPages[
index+21] = 0x00;
10225 AllPages[
index+22] = 0x00;
10226 AllPages[
index+23] = 0x00;
10229 AllPages[
index+24] = 0x00;
10233 AllPages[
index+24] = 0x20;
10235 AllPages[
index+25] = 0x00;
10236 AllPages[
index+26] = 0x00;
10237 AllPages[
index+27] = 0x00;
10238 AllPages[
index+28] = 0x00;
10239 AllPages[
index+29] = 0x00;
10240 AllPages[
index+30] = 0x00;
10241 AllPages[
index+31] = 0x00;
10247 AllPages[
index+32] = 0x0A;
10248 AllPages[
index+33] = 0x0A;
10249 AllPages[
index+34] = 0x02;
10252 AllPages[
index+35] = 0x12;
10256 AllPages[
index+35] = 0x02;
10258 AllPages[
index+36] = 0x00;
10259 AllPages[
index+37] = 0x00;
10260 AllPages[
index+38] = 0x00;
10261 AllPages[
index+39] = 0x00;
10262 AllPages[
index+40] = 0xFF;
10263 AllPages[
index+41] = 0xFF;
10264 AllPages[
index+42] = 0x00;
10265 AllPages[
index+43] = 0x00;
10271 AllPages[
index+44] = 0x1C;
10272 AllPages[
index+45] = 0x0A;
10275 AllPages[
index+46] = 0x00;
10279 AllPages[
index+46] = 0x08;
10281 AllPages[
index+47] = 0x00;
10282 AllPages[
index+48] = 0x00;
10283 AllPages[
index+49] = 0x00;
10284 AllPages[
index+50] = 0x00;
10285 AllPages[
index+51] = 0x00;
10286 AllPages[
index+52] = 0x00;
10287 AllPages[
index+53] = 0x00;
10288 AllPages[
index+54] = 0x00;
10289 AllPages[
index+55] = 0x00;
10291 sm_memcpy(pModeSense, &AllPages, lenRead);
10295 SM_DBG5((
"smsatModeSense10: MODESENSE_CONTROL_PAGE\n"));
10297 Control[1] = (
bit8)(lenRead - 2);
10303 Control[4] = (
bit8)(Control[4] | 0x1);
10330 Control[10] = 0x00;
10331 Control[11] = 0x00;
10332 Control[12] = 0x00;
10333 Control[13] = 0x00;
10334 Control[14] = 0x00;
10335 Control[15] = 0x00;
10337 Control[16] = 0x00;
10338 Control[17] = 0x00;
10339 Control[18] = 0x00;
10340 Control[19] = 0x00;
10342 Control[20] = 0x00;
10343 Control[21] = 0x00;
10344 Control[22] = 0x02;
10345 Control[23] = 0x00;
10353 Control[10] = 0x00;
10354 Control[11] = 0x00;
10356 Control[12] = 0x00;
10358 Control[13] = 0x00;
10359 Control[14] = 0x02;
10360 Control[15] = 0x00;
10374 Control[
index+0] = 0x0A;
10375 Control[
index+1] = 0x0A;
10376 Control[
index+2] = 0x02;
10379 Control[
index+3] = 0x12;
10383 Control[
index+3] = 0x02;
10385 Control[
index+4] = 0x00;
10386 Control[
index+5] = 0x00;
10387 Control[
index+6] = 0x00;
10388 Control[
index+7] = 0x00;
10389 Control[
index+8] = 0xFF;
10390 Control[
index+9] = 0xFF;
10391 Control[
index+10] = 0x00;
10392 Control[
index+11] = 0x00;
10394 sm_memcpy(pModeSense, &Control, lenRead);
10398 SM_DBG5((
"smsatModeSense10: MODESENSE_READ_WRITE_ERROR_RECOVERY_PAGE\n"));
10399 RWErrorRecovery[0] = 0;
10400 RWErrorRecovery[1] = (
bit8)(lenRead - 2);
10401 RWErrorRecovery[2] = 0x00;
10402 RWErrorRecovery[3] = 0x00;
10405 RWErrorRecovery[4] = 0x00;
10406 RWErrorRecovery[4] = (
bit8)(RWErrorRecovery[4] | 0x1);
10410 RWErrorRecovery[4] = 0x00;
10412 RWErrorRecovery[5] = 0x00;
10413 RWErrorRecovery[6] = 0x00;
10416 RWErrorRecovery[7] = 0x10;
10420 RWErrorRecovery[7] = 0x08;
10430 RWErrorRecovery[8] = 0x04;
10432 RWErrorRecovery[9] = 0x00;
10433 RWErrorRecovery[10] = 0x00;
10434 RWErrorRecovery[11] = 0x00;
10435 RWErrorRecovery[12] = 0x00;
10436 RWErrorRecovery[13] = 0x00;
10437 RWErrorRecovery[14] = 0x00;
10438 RWErrorRecovery[15] = 0x00;
10440 RWErrorRecovery[16] = 0x00;
10441 RWErrorRecovery[17] = 0x00;
10442 RWErrorRecovery[18] = 0x00;
10443 RWErrorRecovery[19] = 0x00;
10445 RWErrorRecovery[20] = 0x00;
10446 RWErrorRecovery[21] = 0x00;
10447 RWErrorRecovery[22] = 0x02;
10448 RWErrorRecovery[23] = 0x00;
10453 RWErrorRecovery[8] = 0x04;
10455 RWErrorRecovery[9] = 0x00;
10456 RWErrorRecovery[10] = 0x00;
10457 RWErrorRecovery[11] = 0x00;
10459 RWErrorRecovery[12] = 0x00;
10461 RWErrorRecovery[13] = 0x00;
10462 RWErrorRecovery[14] = 0x02;
10463 RWErrorRecovery[15] = 0x00;
10477 RWErrorRecovery[
index+0] = 0x01;
10478 RWErrorRecovery[
index+1] = 0x0A;
10479 RWErrorRecovery[
index+2] = 0x40;
10480 RWErrorRecovery[
index+3] = 0x00;
10481 RWErrorRecovery[
index+4] = 0x00;
10482 RWErrorRecovery[
index+5] = 0x00;
10483 RWErrorRecovery[
index+6] = 0x00;
10484 RWErrorRecovery[
index+7] = 0x00;
10485 RWErrorRecovery[
index+8] = 0x00;
10486 RWErrorRecovery[
index+9] = 0x00;
10487 RWErrorRecovery[
index+10] = 0x00;
10488 RWErrorRecovery[
index+11] = 0x00;
10490 sm_memcpy(pModeSense, &RWErrorRecovery, lenRead);
10494 SM_DBG5((
"smsatModeSense10: MODESENSE_CACHING\n"));
10496 Caching[1] = (
bit8)(lenRead - 2);
10502 Caching[4] = (
bit8)(Caching[4] | 0x1);
10529 Caching[10] = 0x00;
10530 Caching[11] = 0x00;
10531 Caching[12] = 0x00;
10532 Caching[13] = 0x00;
10533 Caching[14] = 0x00;
10534 Caching[15] = 0x00;
10536 Caching[16] = 0x00;
10537 Caching[17] = 0x00;
10538 Caching[18] = 0x00;
10539 Caching[19] = 0x00;
10541 Caching[20] = 0x00;
10542 Caching[21] = 0x00;
10543 Caching[22] = 0x02;
10544 Caching[23] = 0x00;
10552 Caching[10] = 0x00;
10553 Caching[11] = 0x00;
10555 Caching[12] = 0x00;
10557 Caching[13] = 0x00;
10558 Caching[14] = 0x02;
10559 Caching[15] = 0x00;
10574 Caching[
index+0] = 0x08;
10575 Caching[
index+1] = 0x12;
10578 Caching[
index+2] = 0x04;
10582 Caching[
index+2] = 0x00;
10585 Caching[
index+3] = 0x00;
10586 Caching[
index+4] = 0x00;
10587 Caching[
index+5] = 0x00;
10588 Caching[
index+6] = 0x00;
10589 Caching[
index+7] = 0x00;
10590 Caching[
index+8] = 0x00;
10591 Caching[
index+9] = 0x00;
10592 Caching[
index+10] = 0x00;
10593 Caching[
index+11] = 0x00;
10596 Caching[
index+12] = 0x00;
10600 Caching[
index+12] = 0x20;
10602 Caching[
index+13] = 0x00;
10603 Caching[
index+14] = 0x00;
10604 Caching[
index+15] = 0x00;
10605 Caching[
index+16] = 0x00;
10606 Caching[
index+17] = 0x00;
10607 Caching[
index+18] = 0x00;
10608 Caching[
index+19] = 0x00;
10609 sm_memcpy(pModeSense, &Caching, lenRead);
10614 SM_DBG5((
"smsatModeSense10: MODESENSE_INFORMATION_EXCEPTION_CONTROL_PAGE\n"));
10615 InfoExceptionCtrl[0] = 0;
10616 InfoExceptionCtrl[1] = (
bit8)(lenRead - 2);
10617 InfoExceptionCtrl[2] = 0x00;
10618 InfoExceptionCtrl[3] = 0x00;
10621 InfoExceptionCtrl[4] = 0x00;
10622 InfoExceptionCtrl[4] = (
bit8)(InfoExceptionCtrl[4] | 0x1);
10626 InfoExceptionCtrl[4] = 0x00;
10628 InfoExceptionCtrl[5] = 0x00;
10629 InfoExceptionCtrl[6] = 0x00;
10632 InfoExceptionCtrl[7] = 0x10;
10636 InfoExceptionCtrl[7] = 0x08;
10646 InfoExceptionCtrl[8] = 0x04;
10648 InfoExceptionCtrl[9] = 0x00;
10649 InfoExceptionCtrl[10] = 0x00;
10650 InfoExceptionCtrl[11] = 0x00;
10651 InfoExceptionCtrl[12] = 0x00;
10652 InfoExceptionCtrl[13] = 0x00;
10653 InfoExceptionCtrl[14] = 0x00;
10654 InfoExceptionCtrl[15] = 0x00;
10656 InfoExceptionCtrl[16] = 0x00;
10657 InfoExceptionCtrl[17] = 0x00;
10658 InfoExceptionCtrl[18] = 0x00;
10659 InfoExceptionCtrl[19] = 0x00;
10661 InfoExceptionCtrl[20] = 0x00;
10662 InfoExceptionCtrl[21] = 0x00;
10663 InfoExceptionCtrl[22] = 0x02;
10664 InfoExceptionCtrl[23] = 0x00;
10669 InfoExceptionCtrl[8] = 0x04;
10671 InfoExceptionCtrl[9] = 0x00;
10672 InfoExceptionCtrl[10] = 0x00;
10673 InfoExceptionCtrl[11] = 0x00;
10675 InfoExceptionCtrl[12] = 0x00;
10677 InfoExceptionCtrl[13] = 0x00;
10678 InfoExceptionCtrl[14] = 0x02;
10679 InfoExceptionCtrl[15] = 0x00;
10693 InfoExceptionCtrl[
index+0] = 0x1C;
10694 InfoExceptionCtrl[
index+1] = 0x0A;
10697 InfoExceptionCtrl[
index+2] = 0x00;
10701 InfoExceptionCtrl[
index+2] = 0x08;
10703 InfoExceptionCtrl[
index+3] = 0x00;
10704 InfoExceptionCtrl[
index+4] = 0x00;
10705 InfoExceptionCtrl[
index+5] = 0x00;
10706 InfoExceptionCtrl[
index+6] = 0x00;
10707 InfoExceptionCtrl[
index+7] = 0x00;
10708 InfoExceptionCtrl[
index+8] = 0x00;
10709 InfoExceptionCtrl[
index+9] = 0x00;
10710 InfoExceptionCtrl[
index+10] = 0x00;
10711 InfoExceptionCtrl[
index+11] = 0x00;
10712 sm_memcpy(pModeSense, &InfoExceptionCtrl, lenRead);
10718 SM_DBG1((
"smsatModeSense10: Error page %d!!!\n", page));
10736 if (allocationLen > lenRead)
10738 SM_DBG1((
"smsatModeSense10: reporting underrun lenRead=0x%x allocationLen=0x%x smIORequest=%p\n", lenRead, allocationLen, smIORequest));
10745 allocationLen - lenRead,
10777 bit8 dataBuffer[8] = {0};
10778 bit32 allocationLen;
10787 pSense = satIOContext->
pSense;
10789 scsiCmnd = &smScsiRequest->
scsiCmnd;
10794 SM_DBG5((
"smsatReadCapacity10: start\n"));
10815 SM_DBG1((
"smsatReadCapacity10: return control!!!\n"));
10823 if ((scsiCmnd->
cdb[2] || scsiCmnd->
cdb[3] || scsiCmnd->
cdb[4] || scsiCmnd->
cdb[5]))
10825 SM_DBG1((
"smsatReadCapacity10: *** ERROR *** logical address non zero, did %d!!!\n",
10851 SM_DBG1((
"smsatReadCapacity10: *** ERROR *** PMI is not zero, did %d\n",
10893 dataBuffer[0] = 0xFF;
10894 dataBuffer[1] = 0xFF;
10895 dataBuffer[2] = 0xFF;
10896 dataBuffer[3] = 0xFF;
10897 SM_DBG1((
"smsatReadCapacity10: returns 0xFFFFFFFF!!!\n"));
10901 lastLba = (((pSATAIdData->
maxLBA16_31) << 16) ) |
10903 lastLba = lastLba - 1;
10911 dataBuffer[0] = (
bit8)((lastLba >> 24) & 0xFF);
10912 dataBuffer[1] = (
bit8)((lastLba >> 16) & 0xFF);
10913 dataBuffer[2] = (
bit8)((lastLba >> 8) & 0xFF);
10914 dataBuffer[3] = (
bit8)((lastLba ) & 0xFF);
10916 SM_DBG3((
"smsatReadCapacity10: lastLba is 0x%x %d\n", lastLba, lastLba));
10917 SM_DBG3((
"smsatReadCapacity10: LBA 0 is 0x%x %d\n", dataBuffer[0], dataBuffer[0]));
10918 SM_DBG3((
"smsatReadCapacity10: LBA 1 is 0x%x %d\n", dataBuffer[1], dataBuffer[1]));
10919 SM_DBG3((
"smsatReadCapacity10: LBA 2 is 0x%x %d\n", dataBuffer[2], dataBuffer[2]));
10920 SM_DBG3((
"smsatReadCapacity10: LBA 3 is 0x%x %d\n", dataBuffer[3], dataBuffer[3]));
10934 lastLba = lastLba - 1;
10936 dataBuffer[0] = (
bit8)((lastLba >> 24) & 0xFF);
10937 dataBuffer[1] = (
bit8)((lastLba >> 16) & 0xFF);
10938 dataBuffer[2] = (
bit8)((lastLba >> 8) & 0xFF);
10939 dataBuffer[3] = (
bit8)((lastLba ) & 0xFF);
10942 if (((pSATAIdData->
word104_107[2]) & 0x1000) == 0)
10944 SM_DBG5((
"smsatReadCapacity10: Default Block Length is 512\n"));
10948 dataBuffer[4] = 0x00;
10949 dataBuffer[5] = 0x00;
10950 dataBuffer[6] = 0x02;
10951 dataBuffer[7] = 0x00;
10958 word117_118 = (word118 << 16) + word117;
10959 word117_118 = word117_118 * 2;
10960 dataBuffer[4] = (
bit8)((word117_118 >> 24) & 0xFF);
10961 dataBuffer[5] = (
bit8)((word117_118 >> 16) & 0xFF);
10962 dataBuffer[6] = (
bit8)((word117_118 >> 8) & 0xFF);
10963 dataBuffer[7] = (
bit8)(word117_118 & 0xFF);
10965 SM_DBG1((
"smsatReadCapacity10: Nondefault word118 %d 0x%x !!!\n", word118, word118));
10966 SM_DBG1((
"smsatReadCapacity10: Nondefault word117 %d 0x%x !!!\n", word117, word117));
10967 SM_DBG1((
"smsatReadCapacity10: Nondefault Block Length is %d 0x%x !!!\n",word117_118, word117_118));
10976 pSatDevData->
satMaxLBA[4] = dataBuffer[0];
10977 pSatDevData->
satMaxLBA[5] = dataBuffer[1];
10978 pSatDevData->
satMaxLBA[6] = dataBuffer[2];
10979 pSatDevData->
satMaxLBA[7] = dataBuffer[3];
10982 SM_DBG4((
"smsatReadCapacity10: 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x , did %d\n",
10983 dataBuffer[0], dataBuffer[1], dataBuffer[2], dataBuffer[3],
10984 dataBuffer[4], dataBuffer[5], dataBuffer[6], dataBuffer[7],
10987 sm_memcpy(pVirtAddr, dataBuffer,
MIN(allocationLen, 8));
11014 bit8 dataBuffer[32] = {0};
11019 bit32 allocationLen;
11020 bit32 readCapacityLen = 32;
11023 pSense = satIOContext->
pSense;
11025 scsiCmnd = &smScsiRequest->
scsiCmnd;
11029 SM_DBG5((
"smsatReadCapacity16: start\n"));
11032 allocationLen = (((
bit32)scsiCmnd->
cdb[10]) << 24) |
11033 (((
bit32)scsiCmnd->
cdb[11]) << 16) |
11034 (((
bit32)scsiCmnd->
cdb[12]) << 8 ) |
11039 if (allocationLen < readCapacityLen)
11041 SM_DBG1((
"smsatReadCapacity16: *** ERROR *** insufficient len=0x%x readCapacityLen=0x%x!!!\n", allocationLen, readCapacityLen));
11081 SM_DBG1((
"smsatReadCapacity16: return control!!!\n"));
11088 if ((scsiCmnd->
cdb[2] || scsiCmnd->
cdb[3] || scsiCmnd->
cdb[4] || scsiCmnd->
cdb[5]) ||
11089 (scsiCmnd->
cdb[6] || scsiCmnd->
cdb[7] || scsiCmnd->
cdb[8] || scsiCmnd->
cdb[9]) )
11091 SM_DBG1((
"smsatReadCapacity16: *** ERROR *** logical address non zero, did %d\n",
11117 SM_DBG1((
"smsatReadCapacity16: *** ERROR *** PMI is not zero, did %d\n",
11154 lastLbaLo = lastLbaLo - 1;
11156 dataBuffer[4] = (
bit8)((lastLbaLo >> 24) & 0xFF);
11157 dataBuffer[5] = (
bit8)((lastLbaLo >> 16) & 0xFF);
11158 dataBuffer[6] = (
bit8)((lastLbaLo >> 8) & 0xFF);
11159 dataBuffer[7] = (
bit8)((lastLbaLo ) & 0xFF);
11176 lastLbaLo = lastLbaLo - 1;
11178 dataBuffer[4] = (
bit8)((lastLbaLo >> 24) & 0xFF);
11179 dataBuffer[5] = (
bit8)((lastLbaLo >> 16) & 0xFF);
11180 dataBuffer[6] = (
bit8)((lastLbaLo >> 8) & 0xFF);
11181 dataBuffer[7] = (
bit8)((lastLbaLo ) & 0xFF);
11188 dataBuffer[8] = 0x00;
11189 dataBuffer[9] = 0x00;
11190 dataBuffer[10] = 0x02;
11191 dataBuffer[11] = 0x00;
11195 pSatDevData->
satMaxLBA[0] = dataBuffer[0];
11196 pSatDevData->
satMaxLBA[1] = dataBuffer[1];
11197 pSatDevData->
satMaxLBA[2] = dataBuffer[2];
11198 pSatDevData->
satMaxLBA[3] = dataBuffer[3];
11199 pSatDevData->
satMaxLBA[4] = dataBuffer[4];
11200 pSatDevData->
satMaxLBA[5] = dataBuffer[5];
11201 pSatDevData->
satMaxLBA[6] = dataBuffer[6];
11202 pSatDevData->
satMaxLBA[7] = dataBuffer[7];
11204 SM_DBG5((
"smsatReadCapacity16: 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x , did %d\n",
11205 dataBuffer[0], dataBuffer[1], dataBuffer[2], dataBuffer[3],
11206 dataBuffer[4], dataBuffer[5], dataBuffer[6], dataBuffer[7],
11207 dataBuffer[8], dataBuffer[9], dataBuffer[10], dataBuffer[11],
11210 if (allocationLen > 0xC)
11212 for(i=12;i<=31;i++)
11214 dataBuffer[i] = 0x00;
11218 sm_memcpy(pVirtAddr, dataBuffer,
MIN(allocationLen, readCapacityLen));
11222 if (allocationLen > readCapacityLen)
11225 SM_DBG1((
"smsatReadCapacity16: reporting underrun readCapacityLen=0x%x allocationLen=0x%x !!!\n", readCapacityLen, allocationLen));
11232 allocationLen - readCapacityLen,
11262 bit8 dataBuffer[16] = {0};
11263 bit32 allocationLen;
11264 bit32 reportLunLen;
11267#ifdef TD_DEBUG_ENABLE
11271 pSense = satIOContext->
pSense;
11273 scsiCmnd = &smScsiRequest->
scsiCmnd;
11274#ifdef TD_DEBUG_ENABLE
11277 SM_DBG5((
"smsatReportLun: start\n"));
11280 allocationLen = (((
bit32)scsiCmnd->
cdb[6]) << 24) |
11281 (((
bit32)scsiCmnd->
cdb[7]) << 16) |
11282 (((
bit32)scsiCmnd->
cdb[8]) << 8 ) |
11286 if (allocationLen < reportLunLen)
11288 SM_DBG1((
"smsatReportLun: *** ERROR *** insufficient len=0x%x did %d\n",
11289 reportLunLen, pSatDevData->
id));
11305 pReportLun->
len[0] = 0;
11306 pReportLun->
len[1] = 0;
11307 pReportLun->
len[2] = 0;
11324 if (allocationLen > reportLunLen)
11327 SM_DBG1((
"smsatReportLun: reporting underrun reportLunLen=0x%x allocationLen=0x%x !!!\n", reportLunLen, allocationLen));
11334 allocationLen - reportLunLen,
11373 pSense = satIOContext->
pSense;
11374 scsiCmnd = &smScsiRequest->
scsiCmnd;
11375 SM_DBG5((
"smsatFormatUnit: start\n"));
11396 SM_DBG1((
"smsatFormatUnit: return opcode!!!\n"));
11434 SM_DBG1((
"smsatFormatUnit: return defect list format!!!\n"));
11457 SM_DBG1((
"smsatFormatUnit: return cmplist!!!\n"));
11479 SM_DBG1((
"smsatFormatUnit: return control!!!\n"));
11504 SM_DBG5((
"smsatFormatUnit: return defect list case 1\n"));
11546 SM_DBG5((
"smsatFormatUnit: return defect list case 2\n"));
11565 SM_DBG5((
"smsatFormatUnit: return last\n"));
11579 bit32 agRequestType;
11586 pSense = satIOContext->
pSense;
11588 scsiCmnd = &smScsiRequest->
scsiCmnd;
11589 fis = satIOContext->
pFis;
11591 SM_DBG5((
"smsatSendDiagnostic: start\n"));
11609 ( (scsiCmnd->
cdb[3] != 0) || (scsiCmnd->
cdb[4] != 0) )
11627 SM_DBG1((
"smsatSendDiagnostic: return PF, DEVOFFL, UNITOFFL, PARAM LIST!!!\n"));
11650 SM_DBG1((
"smsatSendDiagnostic: return control!!!\n"));
11654 parmLen = (scsiCmnd->
cdb[3] << 8) + scsiCmnd->
cdb[4];
11678 SM_DBG1((
"smsatSendDiagnostic: return Table 29 case 1!!!\n"));
11703 SM_DBG5((
"smsatSendDiagnostic: return Table 29 case 2\n"));
11786 satIOContext->
reqType = agRequestType;
11795 SM_DBG5((
"smsatSendDiagnostic: return Table 29 case 4\n"));
11832 satIOContext->
reqType = agRequestType;
11841 SM_DBG5((
"smsatSendDiagnostic: return Table 29 case 5\n"));
11897 satIOContext->
reqType = agRequestType;
11906 SM_DBG5((
"smsatSendDiagnostic: return Table 28 case 1\n"));
11947 satIOContext->
reqType = agRequestType;
11956 SM_DBG5((
"smsatSendDiagnostic: return Table 28 case 2\n"));
11978 SM_DBG1((
"smsatSendDiagnostic: case 4, non zero ParmLen %d!!!\n", parmLen));
12012 satIOContext->
reqType = agRequestType;
12021 SM_DBG5((
"smsatSendDiagnostic: send SAT_SMART_EXEUTE_OFF_LINE_IMMEDIATE case 3\n"));
12022 SM_DBG5((
"smsatSendDiagnostic: Table 28 case 4\n"));
12043 SM_DBG1((
"smsatSendDiagnostic: case 4, no pending diagnostic in background!!!\n"));
12044 SM_DBG5((
"smsatSendDiagnostic: Table 28 case 4\n"));
12077 satIOContext->
reqType = agRequestType;
12086 SM_DBG5((
"smsatSendDiagnostic: return Table 28 case 5\n"));
12117 satIOContext->
reqType = agRequestType;
12126 SM_DBG5((
"smsatSendDiagnostic: return Table 28 case 6\n"));
12145 SM_DBG5((
"smsatSendDiagnostic: return Table 28 case 0,3,7 and default\n"));
12160 SM_DBG5((
"smsatSendDiagnostic: return last\n"));
12175 bit32 agRequestType;
12181 pSense = satIOContext->
pSense;
12183 scsiCmnd = &smScsiRequest->
scsiCmnd;
12184 fis = satIOContext->
pFis;
12186 SM_DBG5((
"smsatStartStopUnit: start\n"));
12207 SM_DBG1((
"smsatStartStopUnit: return control!!!\n"));
12226 SM_DBG5((
"smsatStartStopUnit: return table48 case 1-1\n"));
12286 satIOContext->
reqType = agRequestType;
12295 SM_DBG5((
"smsatStartStopUnit: return table48 case 1\n"));
12313 SM_DBG5((
"smsatStartStopUnit: return table48 case 2 1\n"));
12376 satIOContext->
reqType = agRequestType;
12384 SM_DBG5((
"smsatStartStopUnit: return table48 case 2 2\n"));
12405 SM_DBG5((
"smsatStartStopUnit: return table48 case 3 1\n"));
12441 satIOContext->
reqType = agRequestType;
12469 SM_DBG5((
"smsatStartStopUnit: return Table 29 case 3 2\n"));
12492 SM_DBG5((
"smsatStartStopUnit: return Table 29 case 4\n"));
12516 pSense = satIOContext->
pSense;
12518 scsiCmnd = &smScsiRequest->
scsiCmnd;
12519 fis = satIOContext->
pFis;
12521 SM_DBG5((
"smsatWriteSame10: start\n"));
12542 SM_DBG1((
"smsatWriteSame10: return control!!!\n"));
12552 SM_DBG5((
"smsatWriteSame10: case 1\n"));
12580 SM_DBG1((
"smsatWriteSame10: return internal checking!!!\n"));
12585 lba = (scsiCmnd->
cdb[2] << (8*3)) + (scsiCmnd->
cdb[3] << (8*2))
12586 + (scsiCmnd->
cdb[4] << 8) + scsiCmnd->
cdb[5];
12587 tl = (scsiCmnd->
cdb[7] << 8) + scsiCmnd->
cdb[8];
12621 SM_DBG1((
"smsatWriteSame10: return LBA out of range!!!\n"));
12634 SM_DBG1((
"smsatWriteSame10: case 1-2 !!! error due to writesame10!!!\n"));
12657 SM_DBG1((
"smsatWriteSame10: case 1-1 !!! error due to writesame10!!!\n"));
12684 SM_DBG5((
"smsatWriteSame10: case 1-3\n"));
12708 SM_DBG1((
"smsatWriteSame10: case 3 !!! warning can't fit sectors!!!\n"));
12740 SM_DBG5((
"smsatWriteSame10: case 1-4\n"));
12763 SM_DBG1((
"smsatWriteSame10: case 4 !!! warning can't fit sectors!!!\n"));
12798 SM_DBG1((
"smsatWriteSame10: case 1-5 !!! error NCQ but 28 bit address support!!!\n"));
12815 SM_DBG5((
"smsatWriteSame10: case 1-5\n"));
12832 SM_DBG1((
"smsatWriteSame10: case 4 !!! warning can't fit sectors!!!\n"));
12880 satIOContext->
reqType = agRequestType;
12910 SM_DBG5((
"smsatWriteSame10: return Table 62 case 2\n"));
12916 SM_DBG5((
"smsatWriteSame10: Table 62 case 3\n"));
12939 SM_DBG5((
"smsatWriteSame10: return Table 62 case 4\n"));
12958 pSense = satIOContext->
pSense;
12960 SM_DBG5((
"smsatWriteSame16: start\n"));
12977 SM_DBG1((
"smsatWriteSame16: return internal checking!!!\n"));
12991 bit32 agRequestType;
12998 bit16 AllocLen = 0;
12999 bit8 AllLogPages[8];
13002 pSense = satIOContext->
pSense;
13004 scsiCmnd = &smScsiRequest->
scsiCmnd;
13005 fis = satIOContext->
pFis;
13008 SM_DBG5((
"smsatLogSense: start\n"));
13030 SM_DBG1((
"smsatLogSense: return control!!!\n"));
13035 AllocLen = ((scsiCmnd->
cdb[7] << 8) + scsiCmnd->
cdb[8]);
13044 SM_DBG1((
"smsatLogSense: AllocLen is 4!!!\n"));
13048 SM_DBG5((
"smsatLogSense: case LOGSENSE_SUPPORTED_LOG_PAGES\n"));
13067 AllLogPages[1] = 0;
13072 AllLogPages[2] = 0;
13073 AllLogPages[3] = 1;
13077 AllLogPages[2] = 0;
13078 AllLogPages[3] = 2;
13082 AllLogPages[2] = 0;
13083 AllLogPages[3] = 3;
13086 SM_DBG1((
"smsatLogSense: error unallowed flag value %d!!!\n", flag));
13089 sm_memcpy(pLogPage, &AllLogPages, lenRead);
13092 SM_DBG5((
"smsatLogSense: case LOGSENSE_SUPPORTED_LOG_PAGES\n"));
13095 AllLogPages[1] = 0;
13097 AllLogPages[2] = 0x01;
13098 AllLogPages[3] = 0x90;
13099 sm_memcpy(pLogPage, &AllLogPages, lenRead);
13103 SM_DBG5((
"smsatLogSense: case LOGSENSE_SUPPORTED_LOG_PAGES\n"));
13106 AllLogPages[1] = 0;
13107 AllLogPages[2] = 0;
13109 sm_memcpy(pLogPage, &AllLogPages, lenRead);
13146 SM_DBG5((
"smsatLogSense: case 1\n"));
13163 AllLogPages[0] = 0;
13164 AllLogPages[1] = 0;
13169 AllLogPages[2] = 0;
13170 AllLogPages[3] = 1;
13171 AllLogPages[4] = 0x00;
13172 lenRead = (
bit8)(
MIN(AllocLen, 5));
13176 AllLogPages[2] = 0;
13177 AllLogPages[3] = 2;
13178 AllLogPages[4] = 0x00;
13179 AllLogPages[5] = 0x10;
13180 lenRead = (
bit8)(
MIN(AllocLen, 6));
13184 AllLogPages[2] = 0;
13185 AllLogPages[3] = 3;
13186 AllLogPages[4] = 0x00;
13187 AllLogPages[5] = 0x10;
13188 AllLogPages[6] = 0x2F;
13189 lenRead = (
bit8)(
MIN(AllocLen, 7));
13192 SM_DBG1((
"smsatLogSense: error unallowed flag value %d!!!\n", flag));
13196 sm_memcpy(pLogPage, &AllLogPages, lenRead);
13199 if (AllocLen > lenRead )
13201 SM_DBG1((
"smsatLogSense: reporting underrun lenRead=0x%x AllocLen=0x%x!!!\n", lenRead, AllocLen));
13207 AllocLen - lenRead,
13223 SM_DBG5((
"smsatLogSense: case 2\n"));
13227 SM_DBG5((
"smsatLogSense: case 2 no SMART Self Test\n"));
13248 SM_DBG5((
"smsatLogSense: case 2 calling satSMARTEnable\n"));
13266 SM_DBG5((
"smsatLogSense: case 2-1 sends READ LOG EXT\n"));
13280 SM_DBG5((
"smsatLogSense: case 2-2 sends SMART READ LOG\n"));
13296 SM_DBG5((
"smsatLogSense: case 3\n"));
13338 SM_DBG5((
"smsatLogSense: case 3 sends SMART RETURN STATUS\n"));
13368 satIOContext->
reqType = agRequestType;
13421 SM_DBG5((
"smsatLogSenseAllocate: start\n"));
13443 SM_DBG1((
"smsatLogSenseAllocate: fail in allocation!!!\n"));
13523 bit32 agRequestType;
13526 fis = satIOContext->
pFis;
13527 SM_DBG5((
"smsatSMARTEnable: start\n"));
13558 satIOContext->
reqType = agRequestType;
13580 bit32 agRequestType;
13583 fis = satIOContext->
pFis;
13584 SM_DBG5((
"smsatLogSense_2: start\n"));
13615 satIOContext->
reqType = agRequestType;
13635 bit32 agRequestType;
13638 fis = satIOContext->
pFis;
13639 SM_DBG5((
"smsatLogSense_3: start\n"));
13665 satIOContext->
reqType = agRequestType;
13685 bit32 agRequestType;
13691 bit32 StartingIndex = 0;
13694 bit32 parameterListLen = 0;
13696 pSense = satIOContext->
pSense;
13698 scsiCmnd = &smScsiRequest->
scsiCmnd;
13699 fis = satIOContext->
pFis;
13702 SM_DBG5((
"smsatModeSelect6: start\n"));
13723 SM_DBG1((
"smsatModeSelect6: return control!!!\n"));
13745 SM_DBG1((
"smsatModeSelect6: PF bit check!!!\n"));
13749 parameterListLen = scsiCmnd->
cdb[4];
13751 if ((0 == parameterListLen) || (
agNULL == pLogPage))
13763 if (pLogPage[3] == 8)
13766 PageCode = (
bit8)(pLogPage[12] & 0x3F);
13767 StartingIndex = 12;
13769 else if (pLogPage[3] == 0)
13772 PageCode = (
bit8)(pLogPage[4] & 0x3F);
13786 SM_DBG1((
"smsatModeSelect6: return mode parameter block descriptor 0x%x!!!\n", pLogPage[3]));
13810 SM_DBG1((
"smsatModeSelect6: Control mode page!!!\n"));
13812 if ( pLogPage[StartingIndex+1] != 0x0A ||
13813 pLogPage[StartingIndex+2] != 0x02 ||
13814 (pSatDevData->
satNCQ ==
agTRUE && pLogPage[StartingIndex+3] != 0x12) ||
13815 (pSatDevData->
satNCQ ==
agFALSE && pLogPage[StartingIndex+3] != 0x02) ||
13816 (pLogPage[StartingIndex+4] &
BIT3_MASK) != 0x00 ||
13817 (pLogPage[StartingIndex+4] &
BIT4_MASK) != 0x00 ||
13818 (pLogPage[StartingIndex+4] &
BIT5_MASK) != 0x00 ||
13820 (pLogPage[StartingIndex+5] &
BIT0_MASK) != 0x00 ||
13821 (pLogPage[StartingIndex+5] &
BIT1_MASK) != 0x00 ||
13822 (pLogPage[StartingIndex+5] &
BIT2_MASK) != 0x00 ||
13823 (pLogPage[StartingIndex+5] &
BIT6_MASK) != 0x00 ||
13825 pLogPage[StartingIndex+8] != 0xFF ||
13826 pLogPage[StartingIndex+9] != 0xFF ||
13827 pLogPage[StartingIndex+10] != 0x00 ||
13828 pLogPage[StartingIndex+11] != 0x00
13850 SM_DBG1((
"smsatModeSelect6: unexpected values!!!\n"));
13866 SM_DBG1((
"smsatModeSelect6: Read-Write Error Recovery mode page!!!\n"));
13874 (pLogPage[StartingIndex + 10]) ||
13875 (pLogPage[StartingIndex + 11])
13878 SM_DBG5((
"smsatModeSelect6: return check condition\n"));
13898 SM_DBG5((
"smsatModeSelect6: return GOOD \n"));
13913 SM_DBG5((
"smsatModeSelect6: Caching mode page\n"));
13914 if ( (pLogPage[StartingIndex + 2] & 0xFB) ||
13915 (pLogPage[StartingIndex + 3]) ||
13916 (pLogPage[StartingIndex + 4]) ||
13917 (pLogPage[StartingIndex + 5]) ||
13918 (pLogPage[StartingIndex + 6]) ||
13919 (pLogPage[StartingIndex + 7]) ||
13920 (pLogPage[StartingIndex + 8]) ||
13921 (pLogPage[StartingIndex + 9]) ||
13922 (pLogPage[StartingIndex + 10]) ||
13923 (pLogPage[StartingIndex + 11]) ||
13925 (pLogPage[StartingIndex + 12] & 0xC1) ||
13926 (pLogPage[StartingIndex + 13]) ||
13927 (pLogPage[StartingIndex + 14]) ||
13928 (pLogPage[StartingIndex + 15])
13931 SM_DBG1((
"smsatModeSelect6: return check condition!!!\n"));
13955 SM_DBG5((
"smsatModeSelect6: disable write cache\n"));
13985 satIOContext->
reqType = agRequestType;
13996 SM_DBG5((
"smsatModeSelect6: enable write cache\n"));
14026 satIOContext->
reqType = agRequestType;
14039 SM_DBG5((
"smsatModeSelect6: Informational Exception Control mode page\n"));
14045 SM_DBG1((
"smsatModeSelect6: return check condition!!! \n"));
14066 if ( !(pLogPage[StartingIndex + 2] & 0x08) )
14068 SM_DBG5((
"smsatModeSelect6: enable information exceptions reporting\n"));
14098 satIOContext->
reqType = agRequestType;
14109 SM_DBG5((
"smsatModeSelect6: disable information exceptions reporting\n"));
14139 satIOContext->
reqType = agRequestType;
14152 SM_DBG1((
"smsatModeSelect6: Error unknown page code 0x%x!!!\n", pLogPage[12]));
14182 bit32 agRequestType;
14188 bit16 BlkDescLen = 0;
14189 bit32 StartingIndex = 0;
14192 bit32 parameterListLen = 0;
14194 pSense = satIOContext->
pSense;
14196 scsiCmnd = &smScsiRequest->
scsiCmnd;
14197 fis = satIOContext->
pFis;
14200 SM_DBG5((
"smsatModeSelect10: start\n"));
14221 SM_DBG1((
"smsatModeSelect10: return control!!!\n"));
14243 SM_DBG1((
"smsatModeSelect10: PF bit check!!!\n"));
14247 parameterListLen = ((scsiCmnd->
cdb[7]) << 8) + scsiCmnd->
cdb[8];
14249 if ((0 == parameterListLen) || (
agNULL == pLogPage))
14260 BlkDescLen = (
bit8)((pLogPage[6] << 8) + pLogPage[7]);
14266 PageCode = (
bit8)(pLogPage[16] & 0x3F);
14267 StartingIndex = 16;
14272 PageCode = (
bit8)(pLogPage[24] & 0x3F);
14273 StartingIndex = 24;
14275 else if (BlkDescLen == 0)
14277 PageCode = (
bit8)(pLogPage[8] & 0x3F);
14291 SM_DBG1((
"smsatModeSelect10: return mode parameter block descriptor 0x%x!!!\n", BlkDescLen));
14312 if (StartingIndex == 8)
14316 else if(StartingIndex == 16)
14341 SM_DBG5((
"smsatModeSelect10: Control mode page\n"));
14346 if ( pLogPage[StartingIndex+1] != 0x0A ||
14347 pLogPage[StartingIndex+2] != 0x02 ||
14348 (pSatDevData->
satNCQ ==
agTRUE && pLogPage[StartingIndex+3] != 0x12) ||
14349 (pSatDevData->
satNCQ ==
agFALSE && pLogPage[StartingIndex+3] != 0x02) ||
14350 (pLogPage[StartingIndex+4] &
BIT3_MASK) != 0x00 ||
14351 (pLogPage[StartingIndex+4] &
BIT4_MASK) != 0x00 ||
14352 (pLogPage[StartingIndex+4] &
BIT5_MASK) != 0x00 ||
14354 (pLogPage[StartingIndex+5] &
BIT0_MASK) != 0x00 ||
14355 (pLogPage[StartingIndex+5] &
BIT1_MASK) != 0x00 ||
14356 (pLogPage[StartingIndex+5] &
BIT2_MASK) != 0x00 ||
14357 (pLogPage[StartingIndex+5] &
BIT6_MASK) != 0x00 ||
14359 pLogPage[StartingIndex+8] != 0xFF ||
14360 pLogPage[StartingIndex+9] != 0xFF ||
14361 pLogPage[StartingIndex+10] != 0x00 ||
14362 pLogPage[StartingIndex+11] != 0x00
14384 SM_DBG1((
"smsatModeSelect10: unexpected values!!!\n"));
14400 SM_DBG5((
"smsatModeSelect10: Read-Write Error Recovery mode page\n"));
14408 (pLogPage[StartingIndex + 10]) ||
14409 (pLogPage[StartingIndex + 11])
14412 SM_DBG1((
"smsatModeSelect10: return check condition!!!\n"));
14432 SM_DBG2((
"smsatModeSelect10: return GOOD \n"));
14447 SM_DBG5((
"smsatModeSelect10: Caching mode page\n"));
14448 if ( (pLogPage[StartingIndex + 2] & 0xFB) ||
14449 (pLogPage[StartingIndex + 3]) ||
14450 (pLogPage[StartingIndex + 4]) ||
14451 (pLogPage[StartingIndex + 5]) ||
14452 (pLogPage[StartingIndex + 6]) ||
14453 (pLogPage[StartingIndex + 7]) ||
14454 (pLogPage[StartingIndex + 8]) ||
14455 (pLogPage[StartingIndex + 9]) ||
14456 (pLogPage[StartingIndex + 10]) ||
14457 (pLogPage[StartingIndex + 11]) ||
14459 (pLogPage[StartingIndex + 12] & 0xC1) ||
14460 (pLogPage[StartingIndex + 13]) ||
14461 (pLogPage[StartingIndex + 14]) ||
14462 (pLogPage[StartingIndex + 15])
14465 SM_DBG1((
"smsatModeSelect10: return check condition!!!\n"));
14489 SM_DBG5((
"smsatModeSelect10: disable write cache\n"));
14519 satIOContext->
reqType = agRequestType;
14530 SM_DBG5((
"smsatModeSelect10: enable write cache\n"));
14560 satIOContext->
reqType = agRequestType;
14573 SM_DBG5((
"smsatModeSelect10: Informational Exception Control mode page\n"));
14579 SM_DBG1((
"smsatModeSelect10: return check condition!!!\n"));
14602 SM_DBG5((
"smsatModeSelect10: enable information exceptions reporting\n"));
14632 satIOContext->
reqType = agRequestType;
14643 SM_DBG5((
"smsatModeSelect10: disable information exceptions reporting\n"));
14673 satIOContext->
reqType = agRequestType;
14686 SM_DBG1((
"smsatModeSelect10: Error unknown page code 0x%x!!!\n", pLogPage[12]));
14715 bit32 agRequestType;
14721 pSense = satIOContext->
pSense;
14723 scsiCmnd = &smScsiRequest->
scsiCmnd;
14724 fis = satIOContext->
pFis;
14726 SM_DBG5((
"smsatSynchronizeCache10: start\n"));
14747 SM_DBG1((
"smsatSynchronizeCache10: return control!!!\n"));
14754 SM_DBG1((
"smsatSynchronizeCache10: GOOD status due to IMMED bit!!!\n"));
14768 SM_DBG5((
"smsatSynchronizeCache10: sends FLUSH CACHE EXT\n"));
14792 SM_DBG5((
"smsatSynchronizeCache10: sends FLUSH CACHE\n"));
14824 satIOContext->
reqType = agRequestType;
14846 bit32 agRequestType;
14852 pSense = satIOContext->
pSense;
14854 scsiCmnd = &smScsiRequest->
scsiCmnd;
14855 fis = satIOContext->
pFis;
14857 SM_DBG5((
"smsatSynchronizeCache10: start\n"));
14878 SM_DBG1((
"smsatSynchronizeCache10: return control!!!\n"));
14886 SM_DBG1((
"smsatSynchronizeCache10: GOOD status due to IMMED bit!!!\n"));
14900 SM_DBG5((
"smsatSynchronizeCache10: sends FLUSH CACHE EXT\n"));
14924 SM_DBG5((
"smsatSynchronizeCache10: sends FLUSH CACHE\n"));
14956 satIOContext->
reqType = agRequestType;
14994 pSense = satIOContext->
pSense;
14996 scsiCmnd = &smScsiRequest->
scsiCmnd;
14997 fis = satIOContext->
pFis;
14999 SM_DBG5((
"smsatWriteAndVerify10: start\n"));
15019 SM_DBG1((
"smsatWriteAndVerify10: BYTCHK bit checking!!!\n"));
15043 SM_DBG1((
"smsatWriteAndVerify10: return control!!!\n"));
15055 LBA[4] = scsiCmnd->
cdb[2];
15056 LBA[5] = scsiCmnd->
cdb[3];
15057 LBA[6] = scsiCmnd->
cdb[4];
15058 LBA[7] = scsiCmnd->
cdb[5];
15066 TL[6] = scsiCmnd->
cdb[7];
15067 TL[7] = scsiCmnd->
cdb[8];
15071 lba = (scsiCmnd->
cdb[2] << (8*3)) + (scsiCmnd->
cdb[3] << (8*2))
15072 + (scsiCmnd->
cdb[4] << 8) + scsiCmnd->
cdb[5];
15073 tl = (scsiCmnd->
cdb[7] << 8) + scsiCmnd->
cdb[8];
15093 SM_DBG1((
"smsatWriteAndVerify10: return LBA out of range!!!\n"));
15117 SM_DBG1((
"smsatWriteAndVerify10: return LBA out of range, EXT!!!\n"));
15144 SM_DBG5((
"smsatWriteAndVerify10: case 2\n"));
15175 SM_DBG5((
"smsatWriteAndVerify10: case 1\n"));
15209 SM_DBG5((
"smsatWriteAndVerify10: case 3\n"));
15239 SM_DBG5((
"smsatWriteAndVerify10: case 4\n"));
15269 SM_DBG1((
"smsatWriteAndVerify10: case 5 !!! error NCQ but 28 bit address support!!!\n"));
15286 SM_DBG5((
"smsatWriteAndVerify10: case 5\n"));
15319 satIOContext->
OrgTL = tl;
15344 satIOContext->
LoopNum = LoopNum;
15349 SM_DBG5((
"smsatWriteAndVerify10: NON CHAINED data\n"));
15356 SM_DBG1((
"smsatWriteAndVerify10: CHAINED data!!!\n"));
15386 satIOContext->
reqType = agRequestType;
15423 pSense = satIOContext->
pSense;
15425 scsiCmnd = &smScsiRequest->
scsiCmnd;
15426 fis = satIOContext->
pFis;
15428 SM_DBG5((
"smsatWriteAndVerify12: start\n"));
15448 SM_DBG1((
"smsatWriteAndVerify12: BYTCHK bit checking!!!\n"));
15471 SM_DBG1((
"smsatWriteAndVerify12: return control!!!\n"));
15483 LBA[4] = scsiCmnd->
cdb[2];
15484 LBA[5] = scsiCmnd->
cdb[3];
15485 LBA[6] = scsiCmnd->
cdb[4];
15486 LBA[7] = scsiCmnd->
cdb[5];
15492 TL[4] = scsiCmnd->
cdb[6];
15493 TL[5] = scsiCmnd->
cdb[7];
15494 TL[6] = scsiCmnd->
cdb[8];
15495 TL[7] = scsiCmnd->
cdb[9];
15523 SM_DBG1((
"smsatWriteAndVerify12: return LBA out of range, not EXT!!!\n"));
15548 SM_DBG1((
"smsatWriteAndVerify12: return LBA out of range, EXT!!!\n"));
15568 SM_DBG5((
"smsatWriteAndVerify12: case 2\n"));
15599 SM_DBG5((
"smsatWriteAndVerify12: case 1\n"));
15632 SM_DBG5((
"smsatWriteAndVerify12: case 3\n"));
15662 SM_DBG5((
"smsatWriteAndVerify12: case 4\n"));
15693 SM_DBG1((
"smsatWriteAndVerify12: case 5 !!! error NCQ but 28 bit address support!!!\n"));
15710 SM_DBG6((
"smsatWriteAndVerify12: case 5\n"));
15744 satIOContext->
OrgTL = tl;
15769 satIOContext->
LoopNum = LoopNum;
15775 SM_DBG5((
"smsatWriteAndVerify12: NON CHAINED data\n"));
15782 SM_DBG1((
"smsatWriteAndVerify12: CHAINED data!!!\n"));
15812 satIOContext->
reqType = agRequestType;
15848 pSense = satIOContext->
pSense;
15850 scsiCmnd = &smScsiRequest->
scsiCmnd;
15851 fis = satIOContext->
pFis;
15853 SM_DBG5((
"smsatWriteAndVerify16: start\n"));
15873 SM_DBG1((
"smsatWriteAndVerify16: BYTCHK bit checking!!!\n"));
15897 SM_DBG1((
"smsatWriteAndVerify16: return control!!!\n"));
15906 LBA[0] = scsiCmnd->
cdb[2];
15907 LBA[1] = scsiCmnd->
cdb[3];
15908 LBA[2] = scsiCmnd->
cdb[4];
15909 LBA[3] = scsiCmnd->
cdb[5];
15910 LBA[4] = scsiCmnd->
cdb[6];
15911 LBA[5] = scsiCmnd->
cdb[7];
15912 LBA[6] = scsiCmnd->
cdb[8];
15913 LBA[7] = scsiCmnd->
cdb[9];
15919 TL[4] = scsiCmnd->
cdb[10];
15920 TL[5] = scsiCmnd->
cdb[11];
15921 TL[6] = scsiCmnd->
cdb[12];
15922 TL[7] = scsiCmnd->
cdb[13];
15947 SM_DBG1((
"smsatWriteAndVerify16: return LBA out of range, not EXT!!!\n"));
15971 SM_DBG1((
"smsatWriteAndVerify16: return LBA out of range, EXT!!!\n"));
15998 SM_DBG5((
"smsatWriteAndVerify16: case 2\n"));
16029 SM_DBG5((
"smsatWriteAndVerify16: case 1\n"));
16062 SM_DBG5((
"smsatWriteAndVerify16: case 3\n"));
16092 SM_DBG5((
"smsatWriteAndVerify16: case 4\n"));
16123 SM_DBG1((
"smsatWriteAndVerify16: case 5 !!! error NCQ but 28 bit address support!!!\n"));
16140 SM_DBG6((
"smsatWriteAndVerify16: case 5\n"));
16173 satIOContext->
OrgTL = tl;
16198 satIOContext->
LoopNum = LoopNum;
16203 SM_DBG5((
"smsatWriteAndVerify16: NON CHAINED data\n"));
16210 SM_DBG1((
"smsatWriteAndVerify16: CHAINED data!!!\n"));
16240 satIOContext->
reqType = agRequestType;
16266 bit8 *pSerialNumber;
16267 bit8 MediaSerialNumber[64] = {0};
16268 bit32 allocationLen = 0;
16270 pSense = satIOContext->
pSense;
16272 scsiCmnd = &smScsiRequest->
scsiCmnd;
16273 fis = satIOContext->
pFis;
16277 SM_DBG5((
"smsatReadMediaSerialNumber: start\n"));
16298 SM_DBG1((
"smsatReadMediaSerialNumber: return control!!!\n"));
16302 allocationLen = (((
bit32)scsiCmnd->
cdb[6]) << 24) |
16303 (((
bit32)scsiCmnd->
cdb[7]) << 16) |
16304 (((
bit32)scsiCmnd->
cdb[8]) << 8 ) |
16307 if (allocationLen == 4)
16311 SM_DBG1((
"smsatReadMediaSerialNumber: Media serial number returning only length!!!\n"));
16313 MediaSerialNumber[0] = 0;
16314 MediaSerialNumber[1] = 0;
16315 MediaSerialNumber[2] = 0;
16316 MediaSerialNumber[3] = 0x3C;
16321 MediaSerialNumber[0] = 0;
16322 MediaSerialNumber[1] = 0;
16323 MediaSerialNumber[2] = 0x1;
16324 MediaSerialNumber[3] = 0xfc;
16327 sm_memcpy(pSerialNumber, MediaSerialNumber, 4);
16350 MediaSerialNumber[0] = 0;
16351 MediaSerialNumber[1] = 0;
16352 MediaSerialNumber[2] = 0;
16353 MediaSerialNumber[3] = 0x3C;
16356 smhexdump(
"smsatReadMediaSerialNumber", (
bit8*)MediaSerialNumber, 2*30 + 4);
16358 sm_memcpy(pSerialNumber, MediaSerialNumber,
MIN(allocationLen, 64));
16374 SM_DBG1((
"smsatReadMediaSerialNumber: Media serial number is NOT valid!!!\n"));
16425 satIOContext->
reqType = agRequestType;
16464 bit32 bufferOffset;
16470 pSense = satIOContext->
pSense;
16471 scsiCmnd = &smScsiRequest->
scsiCmnd;
16472 fis = satIOContext->
pFis;
16475 SM_DBG5((
"smsatReadBuffer: start\n"));
16496 SM_DBG1((
"smsatReadBuffer: return control!!!\n"));
16500 bufferOffset = (scsiCmnd->
cdb[3] << (8*2)) + (scsiCmnd->
cdb[4] << 8) + scsiCmnd->
cdb[5];
16501 tl = (scsiCmnd->
cdb[6] << (8*2)) + (scsiCmnd->
cdb[7] << 8) + scsiCmnd->
cdb[8];
16504 bufferID = scsiCmnd->
cdb[2];
16508 if (bufferID == 0 && bufferOffset == 0 && tl == 512)
16534 satIOContext->
reqType = agRequestType;
16544 if (bufferID == 0 && bufferOffset == 0 && tl != 512)
16561 SM_DBG1((
"smsatReadBuffer: allocation length is not 512; it is %d!!!\n", tl));
16565 if (bufferID == 0 && bufferOffset != 0)
16582 SM_DBG1((
"smsatReadBuffer: buffer offset is not 0; it is %d!!!\n", bufferOffset));
16586 SM_DBG1((
"smsatReadBuffer: unsupported case 1!!!\n"));
16624 SM_DBG1((
"smsatReadBuffer: tl < 4; tl is %d!!!\n", tl));
16686 SM_DBG1((
"smsatReadBuffer: unsupported mode %d!!!\n", mode));
16723 bit32 bufferOffset;
16729 pSense = satIOContext->
pSense;
16730 scsiCmnd = &smScsiRequest->
scsiCmnd;
16732 fis = satIOContext->
pFis;
16736 SM_DBG5((
"smsatWriteBuffer: start\n"));
16757 SM_DBG1((
"smsatWriteBuffer: return control!!!\n"));
16761 bufferOffset = (scsiCmnd->
cdb[3] << (8*2)) + (scsiCmnd->
cdb[4] << 8) + scsiCmnd->
cdb[5];
16762 parmLen = (scsiCmnd->
cdb[6] << (8*2)) + (scsiCmnd->
cdb[7] << 8) + scsiCmnd->
cdb[8];
16765 bufferID = scsiCmnd->
cdb[2];
16772 if (bufferID == 0 && bufferOffset == 0 && parmLen == 512)
16774 SM_DBG1((
"smsatWriteBuffer: sending ATA WRITE BUFFER!!!\n"));
16800 satIOContext->
reqType = agRequestType;
16820 if ( (bufferID == 0 && bufferOffset != 0) ||
16821 (bufferID == 0 && parmLen != 512)
16839 SM_DBG1((
"smsatWriteBuffer: wrong buffer offset %d or parameter length parmLen %d!!!\n", bufferOffset, parmLen));
16844 SM_DBG1((
"smsatWriteBuffer: unsupported case 1!!!\n"));
16866 SM_DBG1((
"smsatWriteBuffer: not yet supported mode %d!!!\n", mode));
16886 SM_DBG1((
"smsatWriteBuffer: unsupported mode %d!!!\n", mode));
16920 bit32 agRequestType;
16928 bit32 defectListLen;
16930 bit32 startingIndex;
16932 pSense = satIOContext->
pSense;
16934 scsiCmnd = &smScsiRequest->
scsiCmnd;
16935 fis = satIOContext->
pFis;
16938 SM_DBG5((
"smsatReassignBlocks: start\n"));
16959 SM_DBG1((
"smsatReassignBlocks: return control!!!\n"));
16973 defectListLen = (pParmList[2] << 8) + pParmList[3];
16977 defectListLen = (pParmList[0] << (8*3)) + (pParmList[1] << (8*2))
16978 + (pParmList[2] << 8) + pParmList[3];
16981 satIOContext->
ParmLen = defectListLen + 4 ;
16987 LBA[4] = pParmList[startingIndex];
16988 LBA[5] = pParmList[startingIndex+1];
16989 LBA[6] = pParmList[startingIndex+2];
16990 LBA[7] = pParmList[startingIndex+3];
16991 startingIndex = startingIndex + 4;
16995 LBA[0] = pParmList[startingIndex];
16996 LBA[1] = pParmList[startingIndex+1];
16997 LBA[2] = pParmList[startingIndex+2];
16998 LBA[3] = pParmList[startingIndex+3];
16999 LBA[4] = pParmList[startingIndex+4];
17000 LBA[5] = pParmList[startingIndex+5];
17001 LBA[6] = pParmList[startingIndex+6];
17002 LBA[7] = pParmList[startingIndex+7];
17003 startingIndex = startingIndex + 8;
17006 smhexdump(
"smsatReassignBlocks Parameter list", (
bit8 *)pParmList, 4 + defectListLen);
17046 fis->
d.
device = (
bit8)((0x4 << 4) | (LBA[4] & 0xF));
17053 satIOContext->
ParmIndex = startingIndex;
17064 satIOContext->
reqType = agRequestType;
17094 bit32 DenomTL = 0xFF;
17095 bit32 Remainder = 0;
17098 SM_DBG2((
"smsatRead_1: start\n"));
17100 fis = satIOContext->
pFis;
17106 switch (satOrgIOContext->
ATACmd)
17124 SM_DBG1((
"smsatRead_1: error incorrect ata command 0x%x!!!\n", satIOContext->
ATACmd));
17129 Remainder = satOrgIOContext->
OrgTL % DenomTL;
17133 LBA[0] = (
bit8)((lba & 0xFF000000) >> (8 * 3));
17134 LBA[1] = (
bit8)((lba & 0xFF0000) >> (8 * 2));
17135 LBA[2] = (
bit8)((lba & 0xFF00) >> 8);
17136 LBA[3] = (
bit8)(lba & 0xFF);
17138 switch (satOrgIOContext->
ATACmd)
17149 (
bit8)((0x4 << 4) | (LBA[0] & 0xF));
17155 if (satOrgIOContext->
LoopNum == 1)
17182 (
bit8)((0x4 << 4) | (LBA[0] & 0xF));
17187 if (satOrgIOContext->
LoopNum == 1)
17217 if (satOrgIOContext->
LoopNum == 1)
17249 if (satOrgIOContext->
LoopNum == 1)
17283 if (satOrgIOContext->
LoopNum == 1)
17303 SM_DBG1((
"smsatRead_1: error incorrect ata command 0x%x!!!\n", satIOContext->
ATACmd));
17339 satIOContext->
reqType = agRequestType;
17347 SM_DBG5((
"smsatRead_1: return\n"));
17370 bit32 DenomTL = 0xFF;
17371 bit32 Remainder = 0;
17374 SM_DBG2((
"smsatWrite_1: start\n"));
17376 fis = satIOContext->
pFis;
17382 switch (satOrgIOContext->
ATACmd)
17403 SM_DBG1((
"smsatWrite_1: error incorrect ata command 0x%x!!!\n", satIOContext->
ATACmd));
17408 Remainder = satOrgIOContext->
OrgTL % DenomTL;
17413 LBA[0] = (
bit8)((lba & 0xFF000000) >> (8 * 3));
17414 LBA[1] = (
bit8)((lba & 0xFF0000) >> (8 * 2));
17415 LBA[2] = (
bit8)((lba & 0xFF00) >> 8);
17416 LBA[3] = (
bit8)(lba & 0xFF);
17418 switch (satOrgIOContext->
ATACmd)
17430 fis->
d.
device = (
bit8)((0x4 << 4) | (LBA[0] & 0xF));
17436 if (satOrgIOContext->
LoopNum == 1)
17463 fis->
d.
device = (
bit8)((0x4 << 4) | (LBA[0] & 0xF));
17469 if (satOrgIOContext->
LoopNum == 1)
17499 if (satOrgIOContext->
LoopNum == 1)
17531 if (satOrgIOContext->
LoopNum == 1)
17566 if (satOrgIOContext->
LoopNum == 1)
17587 SM_DBG1((
"smsatWrite_1: error incorrect ata command 0x%x!!!\n", satIOContext->
ATACmd));
17623 satIOContext->
reqType = agRequestType;
17631 SM_DBG5((
"smsatWrite_1: return\n"));
17649 bit32 agRequestType;
17653 pSense = satIOContext->
pSense;
17654 scsiCmnd = &smScsiRequest->
scsiCmnd;
17656 fis = satIOContext->
pFis;
17658 SM_DBG1((
"smsatPassthrough: START!!!\n"));
17662 ataPassThroughHdr.
opc = scsiCmnd->
cdb[0];
17663 ataPassThroughHdr.
mulCount = scsiCmnd->
cdb[1] >> 5;
17664 ataPassThroughHdr.
proto = (scsiCmnd->
cdb[1] >> 1) & 0x0F;
17665 ataPassThroughHdr.
extend = scsiCmnd->
cdb[1] & 1;
17666 ataPassThroughHdr.
offline = scsiCmnd->
cdb[2] >> 6;
17667 ataPassThroughHdr.
ckCond = (scsiCmnd->
cdb[2] >> 5) & 1;
17668 ataPassThroughHdr.
tType = (scsiCmnd->
cdb[2] >> 4) & 1;
17669 ataPassThroughHdr.
tDir = (scsiCmnd->
cdb[2] >> 3) & 1;
17670 ataPassThroughHdr.
byteBlock = (scsiCmnd->
cdb[2] >> 2) & 1;
17671 ataPassThroughHdr.
tlength = scsiCmnd->
cdb[2] & 0x3;
17673 switch(ataPassThroughHdr.
proto)
17708 SM_DBG1((
"smsatPassthrough SCSI_SNSCODE_INVALID_FIELD_IN_CDB\n"));
17726 if(scsiCmnd->
cdb[0] == 0xA1)
17728 SM_DBG1((
"smsatPassthrough A1h: COMMAND: %x FEATURE: %x \n",scsiCmnd->
cdb[9],scsiCmnd->
cdb[3]));
17755 satIOContext->
reqType = agRequestType;
17764 else if(scsiCmnd->
cdb[0] == 0x85)
17766 SM_DBG1((
"smsatPassthrough 85h: COMMAND: %x FEATURE: %x \n",scsiCmnd->
cdb[14],scsiCmnd->
cdb[4]));
17771 if(1 == ataPassThroughHdr.
extend)
17799 satIOContext->
reqType = agRequestType;
17810 SM_DBG1((
"smsatPassthrough : INVALD PASSTHROUGH!!!\n"));
17823 SM_DBG1((
"smsatPassthrough : return control!!!\n"));
17845 scsiCmnd = &smScsiRequest->
scsiCmnd;
17846 fis = satIOContext->
pFis;
17847 SM_DBG5((
"smsatNonChainedWriteNVerify_Verify: start\n"));
17879 satIOContext->
reqType = agRequestType;
17888 SM_DBG1((
"smsatNonChainedWriteNVerify_Verify: return status %d!!!\n",
status));
17894 SM_DBG1((
"smsatNonChainedWriteNVerify_Verify: can't fit in SAT_READ_VERIFY_SECTORS!!!\n"));
17924 scsiCmnd = &smScsiRequest->
scsiCmnd;
17925 fis = satIOContext->
pFis;
17927 SM_DBG5((
"smsatChainedWriteNVerify_Start_Verify: start\n"));
17931 LBA[0] = scsiCmnd->
cdb[2];
17932 LBA[1] = scsiCmnd->
cdb[3];
17933 LBA[2] = scsiCmnd->
cdb[4];
17934 LBA[3] = scsiCmnd->
cdb[5];
17935 TL[0] = scsiCmnd->
cdb[6];
17936 TL[1] = scsiCmnd->
cdb[7];
17937 TL[2] = scsiCmnd->
cdb[7];
17938 TL[3] = scsiCmnd->
cdb[8];
17943 SM_DBG5((
"smsatChainedWriteNVerify_Start_Verify: SAT_READ_VERIFY_SECTORS_EXT\n"));
17969 SM_DBG5((
"smsatChainedWriteNVerify_Start_Verify: SAT_READ_VERIFY_SECTORS\n"));
17995 satIOContext->
OrgTL = tl;
18013 SM_DBG1((
"smsatChainedWriteNVerify_Start_Verify: error case 1!!!\n"));
18017 satIOContext->
LoopNum = LoopNum;
18021 SM_DBG5((
"smsatChainedWriteNVerify_Start_Verify: NON CHAINED data\n"));
18028 SM_DBG1((
"smsatChainedWriteNVerify_Start_Verify: CHAINED data!!!\n"));
18041 SM_DBG1((
"smsatChainedWriteNVerify_Start_Verify: error case 2!!!\n"));
18053 satIOContext->
reqType = agRequestType;
18084 bit32 DenomTL = 0xFF;
18085 bit32 Remainder = 0;
18088 SM_DBG1((
"smsatChainedWriteNVerify_Write: start\n"));
18090 fis = satIOContext->
pFis;
18097 switch (satOrgIOContext->
ATACmd)
18118 SM_DBG1((
"satChainedWriteNVerify_Write: error incorrect ata command 0x%x!!!\n", satIOContext->
ATACmd));
18123 Remainder = satOrgIOContext->
OrgTL % DenomTL;
18127 LBA[0] = (
bit8)((lba & 0xF000) >> (8 * 3));
18128 LBA[1] = (
bit8)((lba & 0xF00) >> (8 * 2));
18129 LBA[2] = (
bit8)((lba & 0xF0) >> 8);
18130 LBA[3] = (
bit8)(lba & 0xF);
18132 switch (satOrgIOContext->
ATACmd)
18144 fis->
d.
device = (
bit8)((0x4 << 4) | (LBA[0] & 0xF));
18150 if (satOrgIOContext->
LoopNum == 1)
18177 fis->
d.
device = (
bit8)((0x4 << 4) | (LBA[0] & 0xF));
18183 if (satOrgIOContext->
LoopNum == 1)
18213 if (satOrgIOContext->
LoopNum == 1)
18245 if (satOrgIOContext->
LoopNum == 1)
18280 if (satOrgIOContext->
LoopNum == 1)
18301 SM_DBG1((
"satChainedWriteNVerify_Write: error incorrect ata command 0x%x!!!\n", satIOContext->
ATACmd));
18315 satIOContext->
reqType = agRequestType;
18323 SM_DBG5((
"satChainedWriteNVerify_Write: return\n"));
18341 bit32 DenomTL = 0xFF;
18342 bit32 Remainder = 0;
18345 SM_DBG2((
"smsatChainedWriteNVerify_Verify: start\n"));
18346 fis = satIOContext->
pFis;
18349 switch (satOrgIOContext->
ATACmd)
18358 SM_DBG1((
"smsatChainedWriteNVerify_Verify: error incorrect ata command 0x%x!!!\n", satIOContext->
ATACmd));
18363 Remainder = satOrgIOContext->
OrgTL % DenomTL;
18367 LBA[0] = (
bit8)((lba & 0xF000) >> (8 * 3));
18368 LBA[1] = (
bit8)((lba & 0xF00) >> (8 * 2));
18369 LBA[2] = (
bit8)((lba & 0xF0) >> 8);
18370 LBA[3] = (
bit8)(lba & 0xF);
18372 switch (satOrgIOContext->
ATACmd)
18384 fis->
d.
device = (
bit8)((0x4 << 4) | (LBA[0] & 0xF));
18390 if (satOrgIOContext->
LoopNum == 1)
18420 if (satOrgIOContext->
LoopNum == 1)
18440 SM_DBG1((
"smsatChainedWriteNVerify_Verify: error incorrect ata command 0x%x!!!\n", satIOContext->
ATACmd));
18454 satIOContext->
reqType = agRequestType;
18462 SM_DBG5((
"smsatChainedWriteNVerify_Verify: return\n"));
18480 bit32 DenomTL = 0xFF;
18481 bit32 Remainder = 0;
18484 SM_DBG2((
"smsatChainedVerify: start\n"));
18485 fis = satIOContext->
pFis;
18488 switch (satOrgIOContext->
ATACmd)
18497 SM_DBG1((
"satChainedVerify: error incorrect ata command 0x%x!!!\n", satIOContext->
ATACmd));
18502 Remainder = satOrgIOContext->
OrgTL % DenomTL;
18506 LBA[0] = (
bit8)((lba & 0xF000) >> (8 * 3));
18507 LBA[1] = (
bit8)((lba & 0xF00) >> (8 * 2));
18508 LBA[2] = (
bit8)((lba & 0xF0) >> 8);
18509 LBA[3] = (
bit8)(lba & 0xF);
18511 switch (satOrgIOContext->
ATACmd)
18523 fis->
d.
device = (
bit8)((0x4 << 4) | (LBA[0] & 0xF));
18529 if (satOrgIOContext->
LoopNum == 1)
18559 if (satOrgIOContext->
LoopNum == 1)
18579 SM_DBG1((
"satChainedVerify: error incorrect ata command 0x%x!!!\n", satIOContext->
ATACmd));
18593 satIOContext->
reqType = agRequestType;
18601 SM_DBG5((
"satChainedVerify: return\n"));
18620 bit32 agRequestType;
18622 bit8 lba1, lba2 ,lba3, lba4;
18624 SM_DBG5((
"smsatWriteSame10_1: start\n"));
18625 fis = satIOContext->
pFis;
18627 lba1 = (
bit8)((lba & 0xFF000000) >> (8*3));
18628 lba2 = (
bit8)((lba & 0x00FF0000) >> (8*2));
18629 lba3 = (
bit8)((lba & 0x0000FF00) >> (8*1));
18631 lba4 = (
bit8)(lba & 0x000000FF);
18658 satIOContext->
reqType = agRequestType;
18664 SM_DBG5((
"smsatWriteSame10_1 return status %d\n",
status));
18684 bit32 agRequestType;
18686 bit8 lba1, lba2 ,lba3, lba4;
18688 SM_DBG5((
"smsatWriteSame10_2: start\n"));
18689 fis = satIOContext->
pFis;
18691 lba1 = (
bit8)((lba & 0xFF000000) >> (8*3));
18692 lba2 = (
bit8)((lba & 0x00FF0000) >> (8*2));
18693 lba3 = (
bit8)((lba & 0x0000FF00) >> (8*1));
18695 lba4 = (
bit8)(lba & 0x000000FF);
18722 satIOContext->
reqType = agRequestType;
18728 SM_DBG5((
"smsatWriteSame10_2 return status %d\n",
status));
18748 bit32 agRequestType;
18750 bit8 lba1, lba2 ,lba3, lba4;
18752 SM_DBG5((
"smsatWriteSame10_3: start\n"));
18753 fis = satIOContext->
pFis;
18755 lba1 = (
bit8)((lba & 0xFF000000) >> (8*3));
18756 lba2 = (
bit8)((lba & 0x00FF0000) >> (8*2));
18757 lba3 = (
bit8)((lba & 0x0000FF00) >> (8*1));
18759 lba4 = (
bit8)(lba & 0x000000FF);
18792 satIOContext->
reqType = agRequestType;
18799 SM_DBG5((
"smsatWriteSame10_3 return status %d\n",
status));
18817 bit32 agRequestType;
18820 SM_DBG5((
"smsatStartStopUnit_1: start\n"));
18821 fis = satIOContext->
pFis;
18850 satIOContext->
reqType = agRequestType;
18858 SM_DBG5((
"smsatStartStopUnit_1 return status %d\n",
status));
18876 bit32 agRequestType;
18880 SM_DBG5((
"smsatSendDiagnostic_1: start\n"));
18882 fis = satIOContext->
pFis;
18941 satIOContext->
reqType = agRequestType;
18967 bit32 agRequestType;
18971 SM_DBG5((
"smsatSendDiagnostic_2: start\n"));
18974 fis = satIOContext->
pFis;
19032 satIOContext->
reqType = agRequestType;
19055 bit32 agRequestType;
19058 bit32 StartingIndex = 0;
19060 fis = satIOContext->
pFis;
19062 SM_DBG5((
"smsatModeSelect6n10_1: start\n"));
19064 if (pLogPage[3] == 8)
19067 StartingIndex = 12;
19078 SM_DBG5((
"smsatModeSelect6n10_1: enable read look-ahead feature\n"));
19108 satIOContext->
reqType = agRequestType;
19119 SM_DBG5((
"smsatModeSelect6n10_1: disable read look-ahead feature\n"));
19149 satIOContext->
reqType = agRequestType;
19171 bit32 agRequestType;
19176 fis = satIOContext->
pFis;
19178 SM_DBG5((
"smsatLogSense_1: start\n"));
19183 SM_DBG5((
"smsatLogSense_1: case 2-1 sends READ LOG EXT\n"));
19213 satIOContext->
reqType = agRequestType;
19225 SM_DBG5((
"smsatLogSense_1: case 2-2 sends SMART READ LOG\n"));
19255 satIOContext->
reqType = agRequestType;
19282 bit32 agRequestType;
19287 pSense = satIOContext->
pSense;
19289 fis = satIOContext->
pFis;
19290 SM_DBG5((
"smsatReassignBlocks_2: start\n"));
19297 SM_DBG5((
"smsatReassignBlocks_2: case 2\n"));
19307 fis->
d.
device = (
bit8)((0x4 << 4) | (LBA[4] & 0xF));
19328 SM_DBG5((
"smsatReassignBlocks_2: case 1\n"));
19338 fis->
d.
device = (
bit8)((0x4 << 4) | (LBA[4] & 0xF));
19361 SM_DBG5((
"smsatReassignBlocks_2: case 3\n"));
19391 SM_DBG5((
"smsatReassignBlocks_2: case 4\n"));
19421 SM_DBG5((
"smsatReassignBlocks_2: case 5 !!! error NCQ but 28 bit address support \n"));
19438 SM_DBG6((
"satWrite10: case 5\n"));
19472 satIOContext->
reqType = agRequestType;
19497 bit32 agRequestType;
19504 bit32 startingIndex;
19507 scsiCmnd = &smScsiRequest->
scsiCmnd;
19508 fis = satIOContext->
pFis;
19510 SM_DBG5((
"smsatReassignBlocks_1: start\n"));
19513 startingIndex = satOrgIOContext->
ParmIndex;
19516 LBA[4] = pParmList[startingIndex];
19517 LBA[5] = pParmList[startingIndex+1];
19518 LBA[6] = pParmList[startingIndex+2];
19519 LBA[7] = pParmList[startingIndex+3];
19520 startingIndex = startingIndex + 4;
19524 LBA[0] = pParmList[startingIndex];
19525 LBA[1] = pParmList[startingIndex+1];
19526 LBA[2] = pParmList[startingIndex+2];
19527 LBA[3] = pParmList[startingIndex+3];
19528 LBA[4] = pParmList[startingIndex+4];
19529 LBA[5] = pParmList[startingIndex+5];
19530 LBA[6] = pParmList[startingIndex+6];
19531 LBA[7] = pParmList[startingIndex+7];
19532 startingIndex = startingIndex + 8;
19573 fis->
d.
device = (
bit8)((0x4 << 4) | (LBA[4] & 0xF));
19580 satOrgIOContext->
ParmIndex = startingIndex;
19591 satIOContext->
reqType = agRequestType;
19612 bit32 agRequestType;
19615 fis = satIOContext->
pFis;
19616 SM_DBG1((
"smsatSendReadLogExt: start\n"));
19644 satIOContext->
reqType = agRequestType;
19652 SM_DBG1((
"smsatSendReadLogExt: end status %d!!!\n",
status));
19671 bit32 agRequestType;
19674 fis = satIOContext->
pFis;
19675 SM_DBG1((
"smsatCheckPowerMode: start\n"));
19706 satIOContext->
reqType = agRequestType;
19714 SM_DBG5((
"smsatCheckPowerMode: return\n"));
19729 bit32 agRequestType;
19731#ifdef TD_DEBUG_ENABLE
19736 fis = satIOContext->
pFis;
19737 SM_DBG1((
"smsatResetDevice: start\n"));
19738#ifdef TD_DEBUG_ENABLE
19742 SM_DBG5((
"smsatResetDevice: satIOContext %p smIORequestBody %p\n", satIOContext, smIORequestBody));
19771 satIOContext->
reqType = agRequestType;
19773#ifdef SM_INTERNAL_DEBUG
19775#ifdef TD_DEBUG_ENABLE
19800 bit32 agRequestType;
19802#ifdef TD_DEBUG_ENABLE
19807 fis = satIOContext->
pFis;
19808 SM_DBG1((
"smsatDeResetDevice: start\n"));
19809#ifdef TD_DEBUG_ENABLE
19813 SM_DBG5((
"smsatDeResetDevice: satIOContext %p smIORequestBody %p\n", satIOContext, smIORequestBody));
19842 satIOContext->
reqType = agRequestType;
19844#ifdef SM_INTERNAL_DEBUG
19846#ifdef TD_DEBUG_ENABLE
19872 bit32 agRequestType;
19875 fis = satIOContext->
pFis;
19876 SM_DBG2((
"smsatSetFeaturesAA: start\n"));
19908 satIOContext->
reqType = agRequestType;
19919 SM_DBG1((
"smsatSetFeaturesAA: incorrect smIORequest\n"));
19921 SM_DBG2((
"smsatSetFeatures: return\n"));
19937 bit32 agRequestType;
19942 fis = satIOContext->
pFis;
19943 SM_DBG2((
"smsatSetFeaturesDMA: start\n"));
19975 satIOContext->
reqType = agRequestType;
19986 SM_DBG1((
"smsatSetFeaturesDMA: incorrect smIORequest\n"));
19989 SM_DBG2((
"smsatSetFeaturesDMA: return\n"));
20005 bit32 agRequestType;
20008 fis = satIOContext->
pFis;
20009 SM_DBG2((
"smsatSetFeaturesReadLookAhead: start\n"));
20041 satIOContext->
reqType = agRequestType;
20052 SM_DBG1((
"smsatSetFeaturesReadLookAhead: incorrect smIORequest\n"));
20055 SM_DBG2((
"smsatSetFeaturesReadLookAhead: return\n"));
20071 bit32 agRequestType;
20074 fis = satIOContext->
pFis;
20075 SM_DBG2((
"smsatSetFeaturesVolatileWriteCache: start\n"));
20106 satIOContext->
reqType = agRequestType;
20116 SM_DBG1((
"smsatSetFeaturesVolatileWriteCache: incorrect smIORequest\n"));
20118 SM_DBG2((
"smsatSetFeaturesVolatileWriteCache: return\n"));
20157#ifdef CCFLAG_OPTIMIZE_SAT_LOCK
20168 for ( i = 0; i < pSatDevData->
satNCQMaxIO; i ++ )
20195 if ( tag < pSatDevData->satNCQMaxIO )
20205 SM_DBG1((
"smsatTagRelease: tag %d >= satNCQMaxIO %d!!!!\n", tag, pSatDevData->
satNCQMaxIO));
20219 SM_DBG5((
"smsatComputeCDB10LBA: start\n"));
20221 scsiCmnd = &(smScsiRequest->
scsiCmnd);
20223 lba = (scsiCmnd->
cdb[2] << (8*3)) + (scsiCmnd->
cdb[3] << (8*2))
20224 + (scsiCmnd->
cdb[4] << 8) + scsiCmnd->
cdb[5];
20237 SM_DBG5((
"smsatComputeCDB10TL: start\n"));
20239 scsiCmnd = &(smScsiRequest->
scsiCmnd);
20241 tl = (scsiCmnd->
cdb[7] << 8) + scsiCmnd->
cdb[8];
20252 SM_DBG5((
"smsatComputeCDB12LBA: start\n"));
20254 scsiCmnd = &(smScsiRequest->
scsiCmnd);
20256 lba = (scsiCmnd->
cdb[2] << (8*3)) + (scsiCmnd->
cdb[3] << (8*2))
20257 + (scsiCmnd->
cdb[4] << 8) + scsiCmnd->
cdb[5];
20270 SM_DBG5((
"smsatComputeCDB12TL: start\n"));
20272 scsiCmnd = &(smScsiRequest->
scsiCmnd);
20274 tl = (scsiCmnd->
cdb[6] << (8*3)) + (scsiCmnd->
cdb[7] << (8*2))
20275 + (scsiCmnd->
cdb[8] << 8) + scsiCmnd->
cdb[9];
20291 SM_DBG5((
"smsatComputeCDB16LBA: start\n"));
20293 scsiCmnd = &(smScsiRequest->
scsiCmnd);
20295 lba = (scsiCmnd->
cdb[6] << (8*3)) + (scsiCmnd->
cdb[7] << (8*2))
20296 + (scsiCmnd->
cdb[8] << 8) + scsiCmnd->
cdb[9];
20309 SM_DBG5((
"smsatComputeCDB16TL: start\n"));
20311 scsiCmnd = &(smScsiRequest->
scsiCmnd);
20313 tl = (scsiCmnd->
cdb[10] << (8*3)) + (scsiCmnd->
cdb[11] << (8*2))
20314 + (scsiCmnd->
cdb[12] << 8) + scsiCmnd->
cdb[13];
20329 SM_DBG5((
"smsatComputeLoopNum: start\n"));
20331 if (a < b || a == 0)
20337 if (a == b || a == 0)
20372 bit8 final_satMaxLBA[9];
20374 bit8 temp_satMaxLBA[8];
20405 if (lba[i] > limit[i])
20407 SM_DBG1((
"smsatCheckLimit: LBA check True at %d\n", i));
20411 else if (lba[i] < limit[i])
20413 SM_DBG5((
"smsatCheckLimit: LBA check False at %d\n", i));
20425 SM_DBG1((
"smsatCheckLimit: return LBA check True\n"));
20433 sm_memset(final_ans, 0,
sizeof(final_ans));
20438 ans[i] = (
bit16)(lba[i] + tl[i]);
20441 ans[i] = (
bit16)(ans[i] + ((ans[i+1] & 0xFF00) >> 8));
20448 final_ans[0] = (
bit8)(((ans[0] & 0xFF00) >> 8));
20452 final_ans[i] = (
bit8)(ans[i-1] & 0xFF);
20458 sm_memset(Bit28max, 0,
sizeof(Bit28max));
20459 Bit28max[4] = 0x10;
20462 if (final_ans[0] != 0 || final_ans[1] != 0 || final_ans[2] != 0
20463 || final_ans[3] != 0 || final_ans[4] != 0)
20465 SM_DBG1((
"smsatCheckLimit: before 28Bit addressing TRUE\n"));
20472 if (final_ans[i] > Bit28max[i-1])
20474 SM_DBG1((
"smsatCheckLimit: 28Bit addressing TRUE at %d\n", i));
20478 else if (final_ans[i] < Bit28max[i-1])
20480 SM_DBG5((
"smsatCheckLimit: 28Bit addressing FALSE at %d\n", i));
20493 sm_memset(Bit48max, 0,
sizeof(Bit48max));
20497 if (final_ans[0] != 0 || final_ans[1] != 0)
20499 SM_DBG1((
"smsatCheckLimit: before 48Bit addressing TRUE\n"));
20506 if (final_ans[i] > Bit48max[i-1])
20508 SM_DBG1((
"smsatCheckLimit: 48Bit addressing TRUE at %d\n", i));
20512 else if (final_ans[i] < Bit48max[i-1])
20514 SM_DBG5((
"smsatCheckLimit: 48Bit addressing FALSE at %d\n", i));
20525 if (rangeCheck ==
agTRUE)
20527 SM_DBG1((
"smsatCheckLimit: return rangeCheck True\n"));
20534 sm_memset(temp_satMaxLBA, 0,
sizeof(temp_satMaxLBA));
20536 sm_memset(final_satMaxLBA, 0,
sizeof(final_satMaxLBA));
20545 ans[i] = (
bit16)(temp_satMaxLBA[i] + oneTL[i]);
20548 ans[i] = (
bit16)(ans[i] + ((ans[i+1] & 0xFF00) >> 8));
20555 final_satMaxLBA[0] = (
bit8)(((ans[0] & 0xFF00) >> 8));
20559 final_satMaxLBA[i] = (
bit8)(ans[i-1] & 0xFF);
20565 if (final_ans[i] > final_satMaxLBA[i])
20567 SM_DBG1((
"smsatCheckLimit: Read Capacity 10 TRUE at %d\n", i));
20571 else if (final_ans[i] < final_satMaxLBA[i])
20573 SM_DBG5((
"smsatCheckLimit: Read Capacity 10 FALSE at %d\n", i));
20584 SM_DBG1((
"smsatCheckLimit: after Read Capacity 10 TRUE\n"));
20588 SM_DBG5((
"smsatCheckLimit: after Read Capacity 10 FALSE\n"));
20595 if (final_ans[i] > final_satMaxLBA[i])
20597 SM_DBG1((
"smsatCheckLimit: Read Capacity 16 TRUE at %d\n", i));
20601 else if (final_ans[i] < final_satMaxLBA[i])
20603 SM_DBG5((
"smsatCheckLimit: Read Capacity 16 FALSE at %d\n", i));
20614 SM_DBG1((
"smsatCheckLimit: after Read Capacity 16 TRUE\n"));
20618 SM_DBG5((
"smsatCheckLimit: after Read Capacity 16 FALSE\n"));
20623 SM_DBG5((
"smsatCheckLimit: unknown pSatDevData->ReadCapacity %d\n", pSatDevData->
ReadCapacity));
20626 if (ReadCapCheck ==
agTRUE)
20628 SM_DBG1((
"smsatCheckLimit: return ReadCapCheck True\n"));
20633 ret = (lbaCheck | rangeCheck | ReadCapCheck);
20636 SM_DBG1((
"smsatCheckLimit: final check TRUE\n"));
20640 SM_DBG5((
"smsatCheckLimit: final check FALSE\n"));
20655#ifdef TD_DEBUG_ENABLE
20659 for (i=0;i<idx;i++)
20661#ifdef TD_DEBUG_ENABLE
20664 SM_DBG3((
"smsatPrintSgl: agSgl %d upperAddr 0x%08x lowerAddr 0x%08x len 0x%08x ext 0x%08x\n",
20690 bit32 splitDiffByte = 0;
20691 bit32 splitDiffExtra = 0;
20692 bit32 splitIdx = 0;
20693 bit32 UpperAddr, LowerAddr;
20694 bit32 tmpLowerAddr;
20695 void *sglVirtualAddr;
20696 void *sglSplitVirtualAddr;
20698 scsiCmnd = &smScsiRequest->
scsiCmnd;
20699 SM_DBG3((
"smsatSplitSGL: start\n"));
20701 if (smScsiRequest->
smSgl1.
type == 0x80000000)
20705 SM_DBG3((
"smsatSplitSGL: Not first time\n"));
20719 SM_DBG1((
"smsatSplitSGL: error!\n"));
20734 SM_DBG3((
"smsatSplitSGL: first time\n"));
20747 SM_DBG3((
"smsatSplitSGL: split case\n"));
20752 splitLen = splitLen + agSgl->
len;
20753 if (splitLen >= split)
20755 splitDiffExtra = splitLen - split;
20756 splitDiffByte = agSgl->
len - splitDiffExtra;
20762 SM_DBG3((
"smsatSplitSGL: splitIdx %d\n", splitIdx));
20763 SM_DBG3((
"smsatSplitSGL: splitDiffByte 0x%8x\n", splitDiffByte));
20764 SM_DBG3((
"smsatSplitSGL: splitDiffExtra 0x%8x \n", splitDiffExtra));
20770 tmpLowerAddr = LowerAddr + splitDiffByte;
20771 if (tmpLowerAddr < LowerAddr)
20773 UpperAddr = UpperAddr + 1;
20775 SM_DBG3((
"smsatSplitSGL: UpperAddr 0x%08x tmpLowerAddr 0x%08x\n", UpperAddr, tmpLowerAddr));
20776 agSgl->
len = splitDiffByte;
20783 satIOContext->
LowerAddr = tmpLowerAddr;
20784 satIOContext->
SplitIdx = splitIdx;
20787 satIOContext->
OrgTL = satIOContext->
OrgTL - 0x100;
20794 SM_DBG3((
"smsatSplitSGL: no split case\n"));
20797 for (i=0;i< smScsiRequest->
smSgl1.
len;i++)
20800 totalLen = totalLen + (agSgl->
len);
20809 SM_DBG1((
"not exntened esgl\n"));
#define MIN(a, b)
MIN macro.
#define SATA_ATAPI_DEVICE
struct smpReqPhyControl_s smpReqPhyControl_t
#define SMP_PHY_CONTROL_HARD_RESET
#define SATA_SEMB_WO_SEP_DEVICE
#define SMP_DIRECT_PAYLOAD_LIMIT
#define osti_memset(s, c, n)
The file defines the constants, data structure, and functions defined by LL API.
#define AGSA_PHY_HARD_RESET
#define AGSA_SATA_PROTOCOL_SRST_DEASSERT
#define AGSA_SATA_PROTOCOL_DEV_RESET
#define AGSA_SATA_PROTOCOL_H2D_PKT
#define AGSA_SATA_PROTOCOL_PIO_READ
#define AGSA_SATA_ATAP_EXECDEVDIAG
#define AGSA_SATA_PROTOCOL_DMA_READ
#define AGSA_SATA_PROTOCOL_FPDMA_WRITE
#define AGSA_SMP_INIT_REQ
#define AGSA_SATA_PROTOCOL_PIO_WRITE
#define AGSA_SATA_PROTOCOL_SRST_ASSERT
#define AGSA_SATA_PROTOCOL_FPDMA_READ
#define AGSA_SATA_PROTOCOL_NON_DATA
#define SA_DS_IN_RECOVERY
#define AGSA_SATA_PROTOCOL_DMA_WRITE
#define AGSA_SATA_PROTOCOL_D2H_PKT
The file defines the declaration of tSDK APIs.
GLOBAL bit32 saSATAAbort(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 queueNum, agsaDevHandle_t *agDevHandle, bit32 flag, void *abortParam, ossaGenericAbortCB_t agCB)
Abort SATA command.
GLOBAL bit32 saLocalPhyControl(agsaRoot_t *agRoot, agsaContext_t *agContext, bit32 queueNum, bit32 phyId, bit32 phyOperation, ossaLocalPhyControlCB_t agCB)
Initiate a Local PHY control command.
GLOBAL bit32 saSMPStart(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 queueNum, agsaDevHandle_t *agDevHandle, bit32 agRequestType, agsaSASRequestBody_t *agRequestBody, ossaSMPCompletedCB_t agCB)
Start SMP request.
GLOBAL bit32 saSetDeviceState(agsaRoot_t *agRoot, agsaContext_t *agContext, bit32 queueNum, agsaDevHandle_t *agDevHandle, bit32 newDeviceState)
Set Device State.
The file defines the declaration of OS APIs.
#define SAT_DEV_STATE_FORMAT_IN_PROGRESS
#define BIT48_ADDRESS_TL_LIMIT
#define MODE_SENSE10_CONTROL_PAGE_LLBAA_LEN
#define MODE_SENSE10_CACHING_LEN
#define SCSI_FORMAT_UNIT_FOV_MASK
#define MODE_SENSE10_READ_WRITE_ERROR_RECOVERY_PAGE_LEN
#define SCSIOPC_MODE_SELECT_10
#define SCSI_MODE_SELECT6_DTE_MASK
#define MODESELECT_CONTROL_PAGE
#define SCSIOPC_REQUEST_SENSE
#define SCSI_SNSCODE_HARDWARE_IMPENDING_FAILURE
#define MODESENSE_CONTROL_PAGE
#define SCSI_WRITE_N_VERIFY10_FUA_MASK
#define SCSI_FORMAT_UNIT_DCRT_MASK
#define SCSI_SNSCODE_UNRECOVERED_READ_ERROR
#define SAT_WRITE_DMA_FUA_EXT
#define SCSI_MODE_SELECT6_PF_MASK
#define MODESENSE_READ_WRITE_ERROR_RECOVERY_PAGE
#define LOGSENSE_SELFTEST_RESULTS_PAGE
#define MODESENSE_INFORMATION_EXCEPTION_CONTROL_PAGE
#define WRITE_BUFFER_DL_MICROCODE_SAVE_MODE
#define MODE_SENSE10_READ_WRITE_ERROR_RECOVERY_PAGE_LLBAA_LEN
#define SCSIOPC_WRITE_AND_VERIFY_12
#define SCSI_UNITOFFL_MASK
#define SCSI_MODE_SELECT10_LONGLBA_MASK
#define SCSI_MODE_SELECT10_TEST_MASK
#define SCSI_SNSCODE_RECORD_NOT_FOUND
#define SCSI_SNSCODE_LOGICAL_NOT_SUPPORTED
#define SCSI_MODE_SENSE10_PC_MASK
#define SCSI_SNSCODE_LOGICAL_UNIT_NOT_READY_FORMAT_IN_PROGRESS
#define SCSI_SNSCODE_OPERATOR_MEDIUM_REMOVAL_REQUEST
#define SCSI_SNSKEY_NO_SENSE
#define SCSI_MODE_SELECT6_EER_MASK
#define SCSI_MODE_SELECT10_DEXCPT_MASK
#define SCSI_MODE_SELECT10_PERF_MASK
#define SCSI_SEND_DIAGNOSTIC_SELFTEST_MASK
#define SCSI_SNSCODE_LOGICAL_UNIT_FAILURE
#define SCSI_SNSCODE_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE
#define SCSI_FORMAT_UNIT_CMPLIST_MASK
#define SCSI_MODE_SELECT10_WCE_MASK
#define SAT_WRITE_DMA_EXT
#define SCSI_VERIFY_BYTCHK_MASK
#define SCSI_WRITE_N_VERIFY_BYTCHK_MASK
#define ABRT_ATA_ERROR_MASK
#define MODESELECT_READ_WRITE_ERROR_RECOVERY_PAGE
#define SM_TARGET_WARM_RESET
#define SCSI_SNSCODE_NO_ADDITIONAL_INFO
#define SCSIOPC_VERIFY_16
#define SCSI_MODE_SELECT10_DTE_MASK
#define SAT_SMART_ENABLE_OPERATIONS
#define SCSI_REASSIGN_BLOCKS_LONGLIST_MASK
#define LOGSENSE_SUPPORTED_LOG_PAGES
#define SCSI_SNSCODE_WRITE_ERROR_AUTO_REALLOCATION_FAILED
#define SCSI_MODE_SELECT10_EER_MASK
#define SCSI_FORMAT_UNIT_IP_MASK
#define SAT_IDENTIFY_PACKET_DEVICE
#define SCSI_SYNC_CACHE_IMMED_MASK
#define SCSIOPC_ATA_PASS_THROUGH16
#define SCSI_SNSCODE_INTERNAL_TARGET_FAILURE
#define READ_BUFFER_DESCRIPTOR_MODE
#define AG_SAT_VENDOR_ID_STRING
#define MODESELECT_CACHING
#define SCSI_MODE_SENSE10_LLBAA_MASK
#define ERR_ATA_STATUS_MASK
#define SCSI_MODE_SELECT10_PER_MASK
#define SCSIOPC_READ_CAPACITY_10
#define SAT_IDENTIFY_DEVICE
#define MODE_SENSE6_INFORMATION_EXCEPTION_CONTROL_PAGE_LEN
#define SM_LOGICAL_UNIT_RESET
#define SAT_READ_FPDMA_QUEUED
#define SCSI_WRITE_SAME_LBDATA_MASK
#define SCSI_SNSKEY_ABORTED_COMMAND
#define SAT_READ_VERIFY_SECTORS_EXT
#define READ_BUFFER_DATA_MODE
#define SCSIOPC_VERIFY_12
#define SAT_WRITE_FPDMA_QUEUED
#define SCSIOPC_WRITE_SAME_10
#define SCSIOPC_VERIFY_10
#define SCSIOPC_SYNCHRONIZE_CACHE_16
#define SCSI_SNSCODE_MEDIUM_NOT_PRESENT
#define SAT_DEV_STATE_NORMAL
#define SCSI_FORMAT_UNIT_DEFECT_LIST_FORMAT_MASK
#define SCSI_MODE_SELECT6_AWRE_MASK
#define SCSI_MODE_SELECT10_RC_MASK
#define UNC_ATA_ERROR_MASK
#define SCSI_SEND_DIAGNOSTIC_TEST_CODE_MASK
#define NM_ATA_ERROR_MASK
#define MODESENSE_RETURN_ALL_PAGES
#define SCSI_LOG_SENSE_PAGE_CODE_MASK
#define SCSIOPC_MODE_SELECT_6
#define SCSI_FORMAT_UNIT_IMMED_MASK
#define SCSIOPC_READ_MEDIA_SERIAL_NUMBER
#define SCSIOPC_MODE_SENSE_6
#define ATA_REMOVABLE_MEDIA_DEVICE_MASK
#define SCSI_READ_CAPACITY10_PMI_MASK
#define MODE_SENSE6_READ_WRITE_ERROR_RECOVERY_PAGE_LEN
#define SAT_WRITE_SECTORS_EXT
#define SAT_SMART_RETURN_STATUS
#define MODE_SENSE10_INFORMATION_EXCEPTION_CONTROL_PAGE_LLBAA_LEN
#define SCSIOPC_START_STOP_UNIT
#define SCSI_WRITE_SAME_PBDATA_MASK
#define MODE_SENSE6_CONTROL_PAGE_LEN
#define LOGSENSE_INFORMATION_EXCEPTIONS_PAGE
#define SAT_DEV_STATE_IN_RECOVERY
#define SCSIOPC_READ_BUFFER
#define SAT_SMART_DISABLE_OPERATIONS
#define SCSI_MODE_SELECT6_RC_MASK
#define SAT_READ_SECTORS_EXT
#define SCSIOPC_READ_CAPACITY_16
#define SCSIOPC_REASSIGN_BLOCKS
#define SCSI_FORMAT_UNIT_LONGLIST_MASK
#define SCSIOPC_WRITE_AND_VERIFY_16
#define SCSI_WRITE12_FUA_MASK
#define SAT_WRITE_SECTORS
#define SCSI_MODE_SELECT10_AWRE_MASK
#define SAT_SMART_EXEUTE_OFF_LINE_IMMEDIATE
#define NON_BIT48_ADDRESS_TL_LIMIT
#define SCSI_READ_BUFFER_MODE_MASK
#define SCSI_MODE_SELECT10_PF_MASK
#define MCR_ATA_ERROR_MASK
#define MODESELECT_INFORMATION_EXCEPTION_CONTROL_PAGE
#define SCSI_SNSCODE_ATA_PASS_THROUGH_INFORMATION_AVAILABLE
#define SCSI_MODE_SELECT6_DCR_MASK
#define IDNF_ATA_ERROR_MASK
#define SAT_CHECK_POWER_MODE
#define SCSIOPC_WRITE_BUFFER
#define SCSI_SNSKEY_HARDWARE_ERROR
#define SCSI_WRITE16_FUA_MASK
#define MODE_SENSE10_CONTROL_PAGE_LEN
#define SCSI_MODE_SENSE6_PAGE_CODE_MASK
#define MODE_SENSE10_CACHING_LLBAA_LEN
#define SCSIOPC_SEND_DIAGNOSTIC
#define SCSI_MODE_SELECT6_DRA_MASK
#define SCSIOPC_ATA_PASS_THROUGH12
#define SENSE_DATA_LENGTH
#define SCSI_MODE_SELECT6_WCE_MASK
#define SCSI_MODE_SELECT6_PERF_MASK
#define SCSI_DEVOFFL_MASK
#define SCSI_MODE_SELECT10_DCR_MASK
#define SCSIOPC_WRITE_AND_VERIFY_10
#define MODE_SENSE10_INFORMATION_EXCEPTION_CONTROL_PAGE_LEN
#define SCSI_MODE_SENSE10_PAGE_CODE_MASK
#define SCSI_MODE_SELECT6_PER_MASK
#define SCSI_SNSCODE_INFORMATION_UNIT_CRC_ERROR
#define DF_ATA_STATUS_MASK
#define SCSI_MODE_SELECT6_TEST_MASK
#define SCSI_SNSCODE_NOT_READY_TO_READY_CHANGE
#define SCSIOPC_FORMAT_UNIT
#define SCSI_WRITE10_FUA_MASK
#define SCSIOPC_MODE_SENSE_10
#define SCSI_READ12_FUA_MASK
#define SCSI_READ_CAPACITY16_PMI_MASK
#define MODE_SENSE10_RETURN_ALL_PAGES_LLBAA_LEN
#define INFORMATION_EXCEPTIONS_LOG_PAGE_LENGTH
#define SCSI_SNSCODE_INVALID_FIELD_PARAMETER_LIST
#define SCSIOPC_TEST_UNIT_READY
#define MODESENSE_CACHING
#define SCSIOPC_WRITE_SAME_16
#define SCSI_SNSKEY_MEDIUM_ERROR
#define READ_BUFFER_DESCRIPTOR_MODE_DATA_LEN
#define SCSI_SNSCODE_INVALID_COMMAND
#define SCSI_MODE_SENSE6_PC_MASK
#define SCSI_SNSCODE_INVALID_FIELD_IN_CDB
#define WRITE_BUFFER_DATA_MODE
#define SCSI_READ10_FUA_MASK
#define SCSIOPC_REPORT_LUN
#define SCSIOPC_SYNCHRONIZE_CACHE_10
#define SAT_READ_VERIFY_SECTORS
#define SCSI_SNSCODE_LOGICAL_UNIT_NOT_READY_INITIALIZING_COMMAND_REQUIRED
#define SAT_GET_MEDIA_STATUS
#define SCSIOPC_LOG_SENSE
#define SCSI_REASSIGN_BLOCKS_LONGLBA_MASK
#define MODE_SENSE6_RETURN_ALL_PAGES_LEN
#define MC_ATA_ERROR_MASK
#define ICRC_ATA_ERROR_MASK
#define SATA_PAGE89_INQUIRY_SIZE
#define SCSI_READ16_FUA_MASK
#define SAT_EXECUTE_DEVICE_DIAGNOSTIC
#define SCSI_SNSKEY_UNIT_ATTENTION
#define SCSI_SNSCODE_ATA_DEVICE_FEATURE_NOT_ENABLED
#define SAT_SMART_READ_LOG
#define MODE_SENSE10_RETURN_ALL_PAGES_LEN
#define SCSI_SNSKEY_NOT_READY
#define SCSI_FORMAT_UNIT_FMTDATA_MASK
#define MODE_SENSE6_CACHING_LEN
#define SCSI_SNSKEY_ILLEGAL_REQUEST
#define MODESENSE_VENDOR_SPECIFIC_PAGE
#define SAT_FLUSH_CACHE_EXT
osGLOBAL void smDeviceDataReInit(smRoot_t *smRoot, smDeviceData_t *oneDeviceData)
FORCEINLINE void smIOReInit(smRoot_t *smRoot, smIORequestBody_t *smIORequestBody)
#define SMLIST_DEQUEUE_FROM_HEAD(atHeadHdr, listHdr)
#define SMLIST_ENQUEUE_AT_HEAD(toAddHdr, listHdr)
#define SMLIST_ENQUEUE_AT_TAIL(toAddHdr, listHdr)
#define SMLIST_OBJECT_BASE(baseType, fieldName, fieldPtr)
#define SMLIST_EMPTY(listHdr)
#define SMLIST_DEQUEUE_THIS(hdr)
osGLOBAL void smhexdump(const char *ptitle, bit8 *pbuf, size_t len)
osGLOBAL char * sm_strncpy(char *dst, const char *src, bit32 len)
FORCEINLINE void * sm_memset(void *s, int c, bit32 n)
FORCEINLINE void * sm_memcpy(void *dst, const void *src, bit32 count)
osGLOBAL void smLocalPhyControlCB(agsaRoot_t *agRoot, agsaContext_t *agContext, bit32 phyId, bit32 phyOperation, bit32 status, void *parm)
osGLOBAL void smsatReadMediaSerialNumberCB(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, agsaFisHeader_t *agFirstDword, bit32 agIOInfoLen, agsaFrameHandle_t agFrameHandle, void *ioContext)
osGLOBAL FORCEINLINE void smsatNonChainedDataIOCB(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, agsaFisHeader_t *agFirstDword, bit32 agIOInfoLen, void *agParam, void *ioContext)
osGLOBAL FORCEINLINE bit32 smsataLLIOStart(smRoot_t *smRoot, smIORequest_t *smIORequest, smDeviceHandle_t *smDeviceHandle, smScsiInitiatorRequest_t *smScsiRequest, smSatIOContext_t *satIOContext)
osGLOBAL void smsatExecuteDeviceDiagnosticCB(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, agsaFisHeader_t *agFirstDword, bit32 agIOInfoLen, void *agParam, void *ioContext)
osGLOBAL void smsatSetFeaturesVolatileWriteCacheCB(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, agsaFisHeader_t *agFirstDword, bit32 agIOInfoLen, void *agParam, void *ioContext)
osGLOBAL void smsatWriteBufferCB(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, agsaFisHeader_t *agFirstDword, bit32 agIOInfoLen, agsaFrameHandle_t agFrameHandle, void *ioContext)
osGLOBAL void smaSATAAbortCB(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 flag, bit32 status)
osGLOBAL void smsatChainedWriteNVerifyCB(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, agsaFisHeader_t *agFirstDword, bit32 agIOInfoLen, void *agParam, void *ioContext)
osGLOBAL void smsatStartStopUnitCB(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, agsaFisHeader_t *agFirstDword, bit32 agIOInfoLen, agsaFrameHandle_t agFrameHandle, void *ioContext)
osGLOBAL void smsatSetFeaturesDMACB(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, agsaFisHeader_t *agFirstDword, bit32 agIOInfoLen, void *agParam, void *ioContext)
osGLOBAL FORCEINLINE void smsatChainedDataIOCB(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, agsaFisHeader_t *agFirstDword, bit32 agIOInfoLen, void *agParam, void *ioContext)
osGLOBAL void smsatCheckPowerModeCB(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, agsaFisHeader_t *agFirstDword, bit32 agIOInfoLen, agsaFrameHandle_t agFrameHandle, void *ioContext)
osGLOBAL void smsatDeResetDeviceCB(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, agsaFisHeader_t *agFirstDword, bit32 agIOInfoLen, agsaFrameHandle_t agFrameHandle, void *ioContext)
osGLOBAL void smsatRequestSenseCB(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, agsaFisHeader_t *agFirstDword, bit32 agIOInfoLen, void *agParam, void *ioContext)
osGLOBAL void smsatModeSelect6n10CB(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, agsaFisHeader_t *agFirstDword, bit32 agIOInfoLen, agsaFrameHandle_t agFrameHandle, void *ioContext)
osGLOBAL void smsatNonChainedVerifyCB(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, agsaFisHeader_t *agFirstDword, bit32 agIOInfoLen, agsaFrameHandle_t agFrameHandle, void *ioContext)
osGLOBAL void smsatReadLogExtCB(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, agsaFisHeader_t *agFirstDword, bit32 agIOInfoLen, void *agParam, void *ioContext)
osGLOBAL void smsatTestUnitReadyCB(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, agsaFisHeader_t *agFirstDword, bit32 agIOInfoLen, agsaFrameHandle_t agFrameHandle, void *ioContext)
osGLOBAL void smsatDeviceResetCB(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, agsaFisHeader_t *agFirstDword, bit32 agIOInfoLen, void *agParam, void *ioContext)
osGLOBAL void smsatChainedVerifyCB(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, agsaFisHeader_t *agFirstDword, bit32 agIOInfoLen, agsaFrameHandle_t agFrameHandle, void *ioContext)
osGLOBAL void smsatResetDeviceCB(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, agsaFisHeader_t *agFirstDword, bit32 agIOInfoLen, agsaFrameHandle_t agFrameHandle, void *ioContext)
osGLOBAL void smsatSetFeaturesAACB(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, agsaFisHeader_t *agFirstDword, bit32 agIOInfoLen, void *agParam, void *ioContext)
osGLOBAL void smsatInquiryIntCB(smRoot_t *smRoot, smIORequest_t *smIORequest, smDeviceHandle_t *smDeviceHandle, smScsiInitiatorRequest_t *smScsiRequest, smSatIOContext_t *satIOContext)
osGLOBAL void smsatInquiryCB(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, agsaFisHeader_t *agFirstDword, bit32 agIOInfoLen, void *agParam, void *ioContext)
osGLOBAL void smsatPacketCB(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, agsaFisHeader_t *agFirstDword, bit32 agIOInfoLen, void *agParam, void *ioContext)
osGLOBAL void smsatNonChainedWriteNVerifyCB(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, agsaFisHeader_t *agFirstDword, bit32 agIOInfoLen, void *agParam, void *ioContext)
osGLOBAL void smsatSetFeaturesPIOCB(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, agsaFisHeader_t *agFirstDword, bit32 agIOInfoLen, void *agParam, void *ioContext)
osGLOBAL void smsatSendDiagnosticCB(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, agsaFisHeader_t *agFirstDword, bit32 agIOInfoLen, agsaFrameHandle_t agFrameHandle, void *ioContext)
osGLOBAL void smSMPCompletedCB(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, bit32 agIOInfoLen, agsaFrameHandle_t agFrameHandle)
osGLOBAL void smsatLogSenseCB(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, agsaFisHeader_t *agFirstDword, bit32 agIOInfoLen, void *agParam, void *ioCotext)
osGLOBAL void smsatSMARTEnableCB(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, agsaFisHeader_t *agFirstDword, bit32 agIOInfoLen, agsaFrameHandle_t agFrameHandle, void *ioContext)
osGLOBAL void smsatReadBufferCB(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, agsaFisHeader_t *agFirstDword, bit32 agIOInfoLen, agsaFrameHandle_t agFrameHandle, void *ioContext)
osGLOBAL void smSMPCompleted(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, bit32 agIOInfoLen, agsaFrameHandle_t agFrameHandle)
osGLOBAL void smsatSynchronizeCache10n16CB(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, agsaFisHeader_t *agFirstDword, bit32 agIOInfoLen, agsaFrameHandle_t agFrameHandle, void *ioContext)
osGLOBAL void smsatPassthroughCB(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, agsaFisHeader_t *agFirstDword, bit32 agIOInfoLen, void *agParam, void *ioContext)
osGLOBAL void smsatWriteSame10CB(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, agsaFisHeader_t *agFirstDword, bit32 agIOInfoLen, agsaFrameHandle_t agFrameHandle, void *ioContext)
osGLOBAL void smsatReassignBlocksCB(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, agsaFisHeader_t *agFirstDword, bit32 agIOInfoLen, agsaFrameHandle_t agFrameHandle, void *ioContext)
osGLOBAL void smsatRequestSenseForATAPICB(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, agsaFisHeader_t *agFirstDword, bit32 agIOInfoLen, void *agParam, void *ioContext)
osGLOBAL void smsatSetFeaturesReadLookAheadCB(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, agsaFisHeader_t *agFirstDword, bit32 agIOInfoLen, void *agParam, void *ioContext)
osGLOBAL void smsatIDStartCB(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, agsaFisHeader_t *agFirstDword, bit32 agIOInfoLen, void *agParam, void *ioContext)
osGLOBAL bit32 smsatPassthrough(smRoot_t *smRoot, smIORequest_t *smIORequest, smDeviceHandle_t *smDeviceHandle, smScsiInitiatorRequest_t *smScsiRequest, smSatIOContext_t *satIOContext)
osGLOBAL bit32 smsatTestUnitReady(smRoot_t *smRoot, smIORequest_t *smIORequest, smDeviceHandle_t *smDeviceHandle, smScsiInitiatorRequest_t *smScsiRequest, smSatIOContext_t *satIOContext)
osGLOBAL bit32 smsatComputeCDB12TL(smSatIOContext_t *satIOContext)
osGLOBAL void smsatInquiryStandard(bit8 *pInquiry, agsaSATAIdentifyData_t *pSATAIdData, smIniScsiCmnd_t *scsiCmnd)
osGLOBAL bit32 smsatStartIDDev(smRoot_t *smRoot, smIORequest_t *smIORequest, smDeviceHandle_t *smDeviceHandle, smScsiInitiatorRequest_t *smScsiRequest, smSatIOContext_t *satIOContext)
osGLOBAL bit32 smsatFormatUnit(smRoot_t *smRoot, smIORequest_t *smIORequest, smDeviceHandle_t *smDeviceHandle, smScsiInitiatorRequest_t *smScsiRequest, smSatIOContext_t *satIOContext)
osGLOBAL FORCEINLINE bit32 smsatWrite10(smRoot_t *smRoot, smIORequest_t *smIORequest, smDeviceHandle_t *smDeviceHandle, smScsiInitiatorRequest_t *smScsiRequest, smSatIOContext_t *satIOContext)
osGLOBAL bit32 smsatReassignBlocks(smRoot_t *smRoot, smIORequest_t *smIORequest, smDeviceHandle_t *smDeviceHandle, smScsiInitiatorRequest_t *smScsiRequest, smSatIOContext_t *satIOContext)
osGLOBAL bit32 smsatRead12(smRoot_t *smRoot, smIORequest_t *smIORequest, smDeviceHandle_t *smDeviceHandle, smScsiInitiatorRequest_t *smScsiRequest, smSatIOContext_t *satIOContext)
osGLOBAL bit32 smsatModeSense6(smRoot_t *smRoot, smIORequest_t *smIORequest, smDeviceHandle_t *smDeviceHandle, smScsiInitiatorRequest_t *smScsiRequest, smSatIOContext_t *satIOContext)
FORCEINLINE void smsatFreeIntIoResource(smRoot_t *smRoot, smDeviceData_t *satDevData, smSatInternalIo_t *satIntIo)
osGLOBAL bit32 smsatNonChainedWriteNVerify_Verify(smRoot_t *smRoot, smIORequest_t *smIORequest, smDeviceHandle_t *smDeviceHandle, smScsiInitiatorRequest_t *smScsiRequest, smSatIOContext_t *satIOContext)
osGLOBAL bit32 smsatLogSenseAllocate(smRoot_t *smRoot, smIORequest_t *smIORequest, smDeviceHandle_t *smDeviceHandle, smScsiInitiatorRequest_t *smSCSIRequest, smSatIOContext_t *satIOContext, bit32 payloadSize, bit32 flag)
osGLOBAL bit32 smSuperIOStart(smRoot_t *smRoot, smIORequest_t *smIORequest, smDeviceHandle_t *smDeviceHandle, smSuperScsiInitiatorRequest_t *smSCSIRequest, bit32 AddrHi, bit32 AddrLo, bit32 interruptContext)
osGLOBAL bit32 smsatWriteBuffer(smRoot_t *smRoot, smIORequest_t *smIORequest, smDeviceHandle_t *smDeviceHandle, smScsiInitiatorRequest_t *smScsiRequest, smSatIOContext_t *satIOContext)
osGLOBAL void smsatAbort(smRoot_t *smRoot, agsaRoot_t *agRoot, smSatIOContext_t *satIOContext)
osGLOBAL bit32 smDeregisterDevice(smRoot_t *smRoot, agsaDevHandle_t *agDevHandle, smDeviceHandle_t *smDeviceHandle)
osGLOBAL bit32 smsatReassignBlocks_1(smRoot_t *smRoot, smIORequest_t *smIORequest, smDeviceHandle_t *smDeviceHandle, smScsiInitiatorRequest_t *smScsiRequest, smSatIOContext_t *satIOContext, smSatIOContext_t *satOrgIOContext)
GLOBAL bit32 smsatRead6(smRoot_t *smRoot, smIORequest_t *smIORequest, smDeviceHandle_t *smDeviceHandle, smScsiInitiatorRequest_t *smScsiRequest, smSatIOContext_t *satIOContext)
osGLOBAL bit32 smsatInquiry(smRoot_t *smRoot, smIORequest_t *smIORequest, smDeviceHandle_t *smDeviceHandle, smScsiInitiatorRequest_t *smScsiRequest, smSatIOContext_t *satIOContext)
osGLOBAL void smsatPrintSgl(smRoot_t *smRoot, agsaEsgl_t *agEsgl, bit32 idx)
osGLOBAL void smsatSetDevInfo(smDeviceData_t *oneDeviceData, agsaSATAIdentifyData_t *SATAIdData)
osGLOBAL bit32 smsatChainedVerify(smRoot_t *smRoot, smIORequest_t *smIORequest, smDeviceHandle_t *smDeviceHandle, smScsiInitiatorRequest_t *smScsiRequest, smSatIOContext_t *satIOContext)
osGLOBAL bit32 smsatLogSense_2(smRoot_t *smRoot, smIORequest_t *smIORequest, smDeviceHandle_t *smDeviceHandle, smScsiInitiatorRequest_t *smScsiRequest, smSatIOContext_t *satIOContext)
osGLOBAL bit32 smsatModeSelect6n10_1(smRoot_t *smRoot, smIORequest_t *smIORequest, smDeviceHandle_t *smDeviceHandle, smScsiInitiatorRequest_t *smScsiRequest, smSatIOContext_t *satIOContext)
osGLOBAL bit32 smsatRead16(smRoot_t *smRoot, smIORequest_t *smIORequest, smDeviceHandle_t *smDeviceHandle, smScsiInitiatorRequest_t *smScsiRequest, smSatIOContext_t *satIOContext)
osGLOBAL bit32 smsatDeResetDevice(smRoot_t *smRoot, smIORequest_t *smIORequest, smDeviceHandle_t *smDeviceHandle, smScsiInitiatorRequest_t *smScsiRequest, smSatIOContext_t *satIOContext)
osGLOBAL void smsatInquiryPage83(bit8 *pInquiry, agsaSATAIdentifyData_t *pSATAIdData, smDeviceData_t *oneDeviceData)
osGLOBAL bit32 smsatRequestSense_1(smRoot_t *smRoot, smIORequest_t *smIORequest, smDeviceHandle_t *smDeviceHandle, smScsiInitiatorRequest_t *smScsiRequest, smSatIOContext_t *satIOContext)
osGLOBAL bit32 smsatSynchronizeCache16(smRoot_t *smRoot, smIORequest_t *smIORequest, smDeviceHandle_t *smDeviceHandle, smScsiInitiatorRequest_t *smScsiRequest, smSatIOContext_t *satIOContext)
FORCEINLINE bit32 smsatTagRelease(smRoot_t *smRoot, smDeviceData_t *pSatDevData, bit8 tag)
osGLOBAL bit32 smsatSendDiagnostic(smRoot_t *smRoot, smIORequest_t *smIORequest, smDeviceHandle_t *smDeviceHandle, smScsiInitiatorRequest_t *smScsiRequest, smSatIOContext_t *satIOContext)
osGLOBAL bit32 smsatTestUnitReady_1(smRoot_t *smRoot, smIORequest_t *smIORequest, smDeviceHandle_t *smDeviceHandle, smScsiInitiatorRequest_t *smScsiRequest, smSatIOContext_t *satIOContext)
osGLOBAL bit32 smsatRequestSenseForATAPI(smRoot_t *smRoot, smIORequest_t *smIORequest, smDeviceHandle_t *smDeviceHandle, smScsiInitiatorRequest_t *smScsiRequest, smSatIOContext_t *satIOContext)
SAT implementation for SCSI REQUEST SENSE to ATAPI device.
osGLOBAL bit32 smsatTmAbortTask(smRoot_t *smRoot, smIORequest_t *currentTaskTag, smDeviceHandle_t *smDeviceHandle, smScsiInitiatorRequest_t *smScsiRequest, smSatIOContext_t *satIOContext, smIORequest_t *taskTag)
osGLOBAL bit32 smsatStartStopUnit(smRoot_t *smRoot, smIORequest_t *smIORequest, smDeviceHandle_t *smDeviceHandle, smScsiInitiatorRequest_t *smScsiRequest, smSatIOContext_t *satIOContext)
osGLOBAL bit32 smsatVerify10(smRoot_t *smRoot, smIORequest_t *smIORequest, smDeviceHandle_t *smDeviceHandle, smScsiInitiatorRequest_t *smScsiRequest, smSatIOContext_t *satIOContext)
osGLOBAL bit32 smsatExecuteDeviceDiagnostic(smRoot_t *smRoot, smIORequest_t *smIORequest, smDeviceHandle_t *smDeviceHandle, smScsiInitiatorRequest_t *smScsiRequest, smSatIOContext_t *satIOContext)
SAT implementation for smsatExecuteDeviceDiagnostic.
osGLOBAL bit32 smsatChainedWriteNVerify_Write(smRoot_t *smRoot, smIORequest_t *smIORequest, smDeviceHandle_t *smDeviceHandle, smScsiInitiatorRequest_t *smScsiRequest, smSatIOContext_t *satIOContext)
osGLOBAL bit32 smsatIDSubStart(smRoot_t *smRoot, smIORequest_t *smIORequest, smDeviceHandle_t *smDeviceHandle, smScsiInitiatorRequest_t *smSCSIRequest, smSatIOContext_t *satIOContext)
osGLOBAL bit32 smsatChainedWriteNVerify_Start_Verify(smRoot_t *smRoot, smIORequest_t *smIORequest, smDeviceHandle_t *smDeviceHandle, smScsiInitiatorRequest_t *smScsiRequest, smSatIOContext_t *satIOContext)
osGLOBAL void smsatSetDeferredSensePayload(smScsiRspSense_t *pSense, bit8 SnsKey, bit32 SnsInfo, bit16 SnsCode, smSatIOContext_t *satIOContext)
GLOBAL bit32 smsatDecodeSATADeviceType(bit8 *pSignature)
osGLOBAL bit32 smsatWriteSame16(smRoot_t *smRoot, smIORequest_t *smIORequest, smDeviceHandle_t *smDeviceHandle, smScsiInitiatorRequest_t *smScsiRequest, smSatIOContext_t *satIOContext)
osGLOBAL bit32 smsatRequestSense(smRoot_t *smRoot, smIORequest_t *smIORequest, smDeviceHandle_t *smDeviceHandle, smScsiInitiatorRequest_t *smScsiRequest, smSatIOContext_t *satIOContext)
osGLOBAL bit32 smIOAbortAll(smRoot_t *smRoot, smDeviceHandle_t *smDeviceHandle)
osGLOBAL FORCEINLINE bit32 smsatComputeLoopNum(bit32 a, bit32 b)
osGLOBAL bit32 smsatStartCheckPowerMode(smRoot_t *smRoot, smIORequest_t *currentTaskTag, smDeviceHandle_t *smDeviceHandle, smScsiInitiatorRequest_t *smScsiRequest, smSatIOContext_t *satIOContext)
osGLOBAL bit32 smsatSetFeaturesAA(smRoot_t *smRoot, smIORequest_t *smIORequest, smDeviceHandle_t *smDeviceHandle, smScsiInitiatorRequest_t *smScsiRequest, smSatIOContext_t *satIOContext)
osGLOBAL bit32 smsatModeSense10(smRoot_t *smRoot, smIORequest_t *smIORequest, smDeviceHandle_t *smDeviceHandle, smScsiInitiatorRequest_t *smScsiRequest, smSatIOContext_t *satIOContext)
osGLOBAL bit32 smsatWrite16(smRoot_t *smRoot, smIORequest_t *smIORequest, smDeviceHandle_t *smDeviceHandle, smScsiInitiatorRequest_t *smScsiRequest, smSatIOContext_t *satIOContext)
osGLOBAL bit32 smsatSendDiagnostic_1(smRoot_t *smRoot, smIORequest_t *smIORequest, smDeviceHandle_t *smDeviceHandle, smScsiInitiatorRequest_t *smScsiRequest, smSatIOContext_t *satIOContext)
osGLOBAL bit32 smsatPacket(smRoot_t *smRoot, smIORequest_t *smIORequest, smDeviceHandle_t *smDeviceHandle, smScsiInitiatorRequest_t *smScsiRequest, smSatIOContext_t *satIOContext)
SAT implementation for ATAPI Packet Command.
osGLOBAL FORCEINLINE bit32 smsatCheckLimit(bit8 *lba, bit8 *tl, int flag, smDeviceData_t *pSatDevData)
osGLOBAL bit32 smsatSMARTEnable(smRoot_t *smRoot, smIORequest_t *smIORequest, smDeviceHandle_t *smDeviceHandle, smScsiInitiatorRequest_t *smScsiRequest, smSatIOContext_t *satIOContext)
osGLOBAL FORCEINLINE bit32 smsatIOStart(smRoot_t *smRoot, smIORequest_t *smIORequest, smDeviceHandle_t *smDeviceHandle, smScsiInitiatorRequest_t *smSCSIRequest, smSatIOContext_t *satIOContext)
osGLOBAL FORCEINLINE BOOLEAN smsatBitTest(smRoot_t *smRoot, bit8 *data, bit32 index)
osGLOBAL bit32 smsatStartStopUnit_1(smRoot_t *smRoot, smIORequest_t *smIORequest, smDeviceHandle_t *smDeviceHandle, smScsiInitiatorRequest_t *smScsiRequest, smSatIOContext_t *satIOContext)
osGLOBAL bit32 smsatChainedWriteNVerify_Verify(smRoot_t *smRoot, smIORequest_t *smIORequest, smDeviceHandle_t *smDeviceHandle, smScsiInitiatorRequest_t *smScsiRequest, smSatIOContext_t *satIOContext)
osGLOBAL bit32 smsatComputeCDB16TL(smSatIOContext_t *satIOContext)
osGLOBAL bit32 smsatCheckPowerMode(smRoot_t *smRoot, smIORequest_t *smIORequest, smDeviceHandle_t *smDeviceHandle, smScsiInitiatorRequest_t *smScsiRequest, smSatIOContext_t *satIOContext)
osGLOBAL bit32 smRemoveFromSharedcontext(smRoot_t *smRoot, agsaDevHandle_t *agDevHandle, smDeviceHandle_t *smDeviceHandle)
osGLOBAL bit32 smsatReadBuffer(smRoot_t *smRoot, smIORequest_t *smIORequest, smDeviceHandle_t *smDeviceHandle, smScsiInitiatorRequest_t *smScsiRequest, smSatIOContext_t *satIOContext)
osGLOBAL smDeviceData_t * smFindInSharedcontext(smRoot_t *smRoot, agsaDevHandle_t *agDevHandle)
osGLOBAL bit32 smsatWriteSame10_2(smRoot_t *smRoot, smIORequest_t *smIORequest, smDeviceHandle_t *smDeviceHandle, smScsiInitiatorRequest_t *smScsiRequest, smSatIOContext_t *satIOContext, bit32 lba)
osGLOBAL void smsatInquiryPage89(bit8 *pInquiry, agsaSATAIdentifyData_t *pSATAIdData, smDeviceData_t *oneDeviceData, bit32 len)
osGLOBAL void smsatDefaultTranslation(smRoot_t *smRoot, smIORequest_t *smIORequest, smSatIOContext_t *satIOContext, smScsiRspSense_t *pSense, bit8 ataStatus, bit8 ataError, bit32 interruptContext)
osGLOBAL bit32 smsatWriteAndVerify10(smRoot_t *smRoot, smIORequest_t *smIORequest, smDeviceHandle_t *smDeviceHandle, smScsiInitiatorRequest_t *smScsiRequest, smSatIOContext_t *satIOContext)
osGLOBAL FORCEINLINE void smsatBitSet(smRoot_t *smRoot, bit8 *data, bit32 index)
osGLOBAL bit32 smsatWriteSame10_1(smRoot_t *smRoot, smIORequest_t *smIORequest, smDeviceHandle_t *smDeviceHandle, smScsiInitiatorRequest_t *smScsiRequest, smSatIOContext_t *satIOContext, bit32 lba)
osGLOBAL bit32 smsatSynchronizeCache10(smRoot_t *smRoot, smIORequest_t *smIORequest, smDeviceHandle_t *smDeviceHandle, smScsiInitiatorRequest_t *smScsiRequest, smSatIOContext_t *satIOContext)
osGLOBAL smIORequestBody_t * smDequeueIO(smRoot_t *smRoot)
osGLOBAL bit32 smsatIDStart(smRoot_t *smRoot, smIORequest_t *smIORequest, smDeviceHandle_t *smDeviceHandle, smScsiInitiatorRequest_t *smSCSIRequest, smSatIOContext_t *satIOContext)
osGLOBAL bit32 smsatWrite12(smRoot_t *smRoot, smIORequest_t *smIORequest, smDeviceHandle_t *smDeviceHandle, smScsiInitiatorRequest_t *smScsiRequest, smSatIOContext_t *satIOContext)
osGLOBAL bit32 smsatComputeCDB16LBA(smSatIOContext_t *satIOContext)
osGLOBAL bit32 smIDStart(smRoot_t *smRoot, smIORequest_t *smIORequest, smDeviceHandle_t *smDeviceHandle)
osGLOBAL bit32 smsatReassignBlocks_2(smRoot_t *smRoot, smIORequest_t *smIORequest, smDeviceHandle_t *smDeviceHandle, smScsiInitiatorRequest_t *smScsiRequest, smSatIOContext_t *satIOContext, bit8 *LBA)
osGLOBAL smDeviceData_t * smAddToSharedcontext(smRoot_t *smRoot, agsaDevHandle_t *agDevHandle, smDeviceHandle_t *smDeviceHandle, agsaDevHandle_t *agExpDevHandle, bit32 phyID)
osGLOBAL bit32 smIOAbort(smRoot_t *smRoot, smIORequest_t *tasktag)
osGLOBAL void smEnqueueIO(smRoot_t *smRoot, smSatIOContext_t *satIOContext)
FORCEINLINE bit32 smIOStart(smRoot_t *smRoot, smIORequest_t *smIORequest, smDeviceHandle_t *smDeviceHandle, smScsiInitiatorRequest_t *smSCSIRequest, bit32 interruptContext)
osGLOBAL bit32 smsatWrite_1(smRoot_t *smRoot, smIORequest_t *smIORequest, smDeviceHandle_t *smDeviceHandle, smScsiInitiatorRequest_t *smScsiRequest, smSatIOContext_t *satIOContext)
osGLOBAL void smsatInquiryPage80(bit8 *pInquiry, agsaSATAIdentifyData_t *pSATAIdData)
osGLOBAL bit32 smsatWriteAndVerify16(smRoot_t *smRoot, smIORequest_t *smIORequest, smDeviceHandle_t *smDeviceHandle, smScsiInitiatorRequest_t *smScsiRequest, smSatIOContext_t *satIOContext)
osGLOBAL bit32 smsatSendDiagnostic_2(smRoot_t *smRoot, smIORequest_t *smIORequest, smDeviceHandle_t *smDeviceHandle, smScsiInitiatorRequest_t *smScsiRequest, smSatIOContext_t *satIOContext)
osGLOBAL void smsatInquiryPage0(bit8 *pInquiry, agsaSATAIdentifyData_t *pSATAIdData)
osGLOBAL bit32 smsatSendIDDev(smRoot_t *smRoot, smIORequest_t *smIORequest, smDeviceHandle_t *smDeviceHandle, smScsiInitiatorRequest_t *smScsiRequest, smSatIOContext_t *satIOContext)
osGLOBAL bit32 smsatSetFeaturesPIO(smRoot_t *smRoot, smIORequest_t *smIORequest, smDeviceHandle_t *smDeviceHandle, smScsiInitiatorRequest_t *smScsiRequest, smSatIOContext_t *satIOContext)
SAT implementation for smsatSetFeaturePIO.
osGLOBAL bit32 smsatWriteSame10_3(smRoot_t *smRoot, smIORequest_t *smIORequest, smDeviceHandle_t *smDeviceHandle, smScsiInitiatorRequest_t *smScsiRequest, smSatIOContext_t *satIOContext, bit32 lba)
osGLOBAL smSatInternalIo_t * smsatAllocIntIoResource(smRoot_t *smRoot, smIORequest_t *smIORequest, smDeviceData_t *satDevData, bit32 dmaAllocLength, smSatInternalIo_t *satIntIo)
osGLOBAL bit32 smsatWriteAndVerify12(smRoot_t *smRoot, smIORequest_t *smIORequest, smDeviceHandle_t *smDeviceHandle, smScsiInitiatorRequest_t *smScsiRequest, smSatIOContext_t *satIOContext)
osGLOBAL bit32 smsatComputeCDB12LBA(smSatIOContext_t *satIOContext)
osGLOBAL bit32 smsatSetFeaturesDMA(smRoot_t *smRoot, smIORequest_t *smIORequest, smDeviceHandle_t *smDeviceHandle, smScsiInitiatorRequest_t *smScsiRequest, smSatIOContext_t *satIOContext)
osGLOBAL bit32 smsatSetFeaturesReadLookAhead(smRoot_t *smRoot, smIORequest_t *smIORequest, smDeviceHandle_t *smDeviceHandle, smScsiInitiatorRequest_t *smScsiRequest, smSatIOContext_t *satIOContext)
osGLOBAL bit32 smsatSetFeaturesVolatileWriteCache(smRoot_t *smRoot, smIORequest_t *smIORequest, smDeviceHandle_t *smDeviceHandle, smScsiInitiatorRequest_t *smScsiRequest, smSatIOContext_t *satIOContext)
osGLOBAL bit32 smsatWriteSame10(smRoot_t *smRoot, smIORequest_t *smIORequest, smDeviceHandle_t *smDeviceHandle, smScsiInitiatorRequest_t *smScsiRequest, smSatIOContext_t *satIOContext)
osGLOBAL bit32 smsatRead_1(smRoot_t *smRoot, smIORequest_t *smIORequest, smDeviceHandle_t *smDeviceHandle, smScsiInitiatorRequest_t *smScsiRequest, smSatIOContext_t *satIOContext)
osGLOBAL bit32 smTaskManagement(smRoot_t *smRoot, smDeviceHandle_t *smDeviceHandle, bit32 task, smLUN_t *lun, smIORequest_t *taskTag, smIORequest_t *currentTaskTag)
osGLOBAL bit32 smsatReadMediaSerialNumber(smRoot_t *smRoot, smIORequest_t *smIORequest, smDeviceHandle_t *smDeviceHandle, smScsiInitiatorRequest_t *smScsiRequest, smSatIOContext_t *satIOContext)
osGLOBAL bit32 smsatReportLun(smRoot_t *smRoot, smIORequest_t *smIORequest, smDeviceHandle_t *smDeviceHandle, smScsiInitiatorRequest_t *smScsiRequest, smSatIOContext_t *satIOContext)
osGLOBAL bit32 smsatWrite6(smRoot_t *smRoot, smIORequest_t *smIORequest, smDeviceHandle_t *smDeviceHandle, smScsiInitiatorRequest_t *smScsiRequest, smSatIOContext_t *satIOContext)
FORCEINLINE bit32 smsatTagAlloc(smRoot_t *smRoot, smDeviceData_t *pSatDevData, bit8 *pTag)
osGLOBAL FORCEINLINE void smsatBitClear(smRoot_t *smRoot, bit8 *data, bit32 index)
osGLOBAL void smsatSplitSGL(smRoot_t *smRoot, smIORequest_t *smIORequest, smDeviceHandle_t *smDeviceHandle, smScsiInitiatorRequest_t *smScsiRequest, smSatIOContext_t *satIOContext, bit32 split, bit32 tl, bit32 flag)
osGLOBAL bit32 smsatReadCapacity16(smRoot_t *smRoot, smIORequest_t *smIORequest, smDeviceHandle_t *smDeviceHandle, smScsiInitiatorRequest_t *smScsiRequest, smSatIOContext_t *satIOContext)
osGLOBAL bit32 smsatSendReadLogExt(smRoot_t *smRoot, smIORequest_t *smIORequest, smDeviceHandle_t *smDeviceHandle, smScsiInitiatorRequest_t *smScsiRequest, smSatIOContext_t *satIOContext)
osGLOBAL bit32 smsatVerify12(smRoot_t *smRoot, smIORequest_t *smIORequest, smDeviceHandle_t *smDeviceHandle, smScsiInitiatorRequest_t *smScsiRequest, smSatIOContext_t *satIOContext)
osGLOBAL bit32 smsatLogSense(smRoot_t *smRoot, smIORequest_t *smIORequest, smDeviceHandle_t *smDeviceHandle, smScsiInitiatorRequest_t *smScsiRequest, smSatIOContext_t *satIOContext)
osGLOBAL bit32 smsatLogSense_3(smRoot_t *smRoot, smIORequest_t *smIORequest, smDeviceHandle_t *smDeviceHandle, smScsiInitiatorRequest_t *smScsiRequest, smSatIOContext_t *satIOContext)
osGLOBAL bit32 smsatModeSelect6(smRoot_t *smRoot, smIORequest_t *smIORequest, smDeviceHandle_t *smDeviceHandle, smScsiInitiatorRequest_t *smScsiRequest, smSatIOContext_t *satIOContext)
osGLOBAL bit32 smRegisterDevice(smRoot_t *smRoot, agsaDevHandle_t *agDevHandle, smDeviceHandle_t *smDeviceHandle, agsaDevHandle_t *agExpDevHandle, bit32 phyID, bit32 DeviceType)
osGLOBAL bit32 smsatReadCapacity10(smRoot_t *smRoot, smIORequest_t *smIORequest, smDeviceHandle_t *smDeviceHandle, smScsiInitiatorRequest_t *smScsiRequest, smSatIOContext_t *satIOContext)
osGLOBAL bit32 smsatComputeCDB10LBA(smSatIOContext_t *satIOContext)
osGLOBAL bit32 smsatVerify16(smRoot_t *smRoot, smIORequest_t *smIORequest, smDeviceHandle_t *smDeviceHandle, smScsiInitiatorRequest_t *smScsiRequest, smSatIOContext_t *satIOContext)
osGLOBAL bit32 smsatModeSelect10(smRoot_t *smRoot, smIORequest_t *smIORequest, smDeviceHandle_t *smDeviceHandle, smScsiInitiatorRequest_t *smScsiRequest, smSatIOContext_t *satIOContext)
osGLOBAL FORCEINLINE bit32 smsatRead10(smRoot_t *smRoot, smIORequest_t *smIORequest, smDeviceHandle_t *smDeviceHandle, smScsiInitiatorRequest_t *smScsiRequest, smSatIOContext_t *satIOContext)
osGLOBAL bit32 smsatResetDevice(smRoot_t *smRoot, smIORequest_t *smIORequest, smDeviceHandle_t *smDeviceHandle, smScsiInitiatorRequest_t *smScsiRequest, smSatIOContext_t *satIOContext)
osGLOBAL bit32 smsatStartResetDevice(smRoot_t *smRoot, smIORequest_t *currentTaskTag, smDeviceHandle_t *smDeviceHandle, smScsiInitiatorRequest_t *smScsiRequest, smSatIOContext_t *satIOContext)
osGLOBAL bit32 smsatLogSense_1(smRoot_t *smRoot, smIORequest_t *smIORequest, smDeviceHandle_t *smDeviceHandle, smScsiInitiatorRequest_t *smScsiRequest, smSatIOContext_t *satIOContext)
osGLOBAL bit32 smsatDeviceReset(smRoot_t *smRoot, smIORequest_t *smIORequest, smDeviceHandle_t *smDeviceHandle, smScsiInitiatorRequest_t *smScsiRequest, smSatIOContext_t *satIOContext)
SAT implementation for smsatDeviceReset.
osGLOBAL smSatIOContext_t * smsatPrepareNewIO(smSatInternalIo_t *satNewIntIo, smIORequest_t *smOrgIORequest, smDeviceData_t *satDevData, smIniScsiCmnd_t *scsiCmnd, smSatIOContext_t *satOrgIOContext)
osGLOBAL void smsatInquiryPageB1(bit8 *pInquiry, agsaSATAIdentifyData_t *pSATAIdData)
osGLOBAL bit32 smsatTaskManagement(smRoot_t *smRoot, smDeviceHandle_t *smDeviceHandle, bit32 task, smLUN_t *lun, smIORequest_t *taskTag, smIORequest_t *currentTaskTag, smIORequestBody_t *smIORequestBody)
osGLOBAL void smsatSetSensePayload(smScsiRspSense_t *pSense, bit8 SnsKey, bit32 SnsInfo, bit16 SnsCode, smSatIOContext_t *satIOContext)
osGLOBAL bit32 smPhyControlSend(smRoot_t *smRoot, smDeviceData_t *oneDeviceData, bit8 phyOp, smIORequest_t *CurrentTaskTag, bit32 queueNumber)
osGLOBAL bit32 smsatComputeCDB10TL(smSatIOContext_t *satIOContext)
struct smSMPRequestBody_s smSMPRequestBody_t
struct smIORequestBody_s smIORequestBody_t
data structure stores OS specific and LL specific context
smIORequest_t * satTmTaskTag
bit32 satDeviceFaultState
smDeviceHandle_t * smDevHandle
smList_t satFreeIntIoLinkList
agsaSATAIdentifyData_t satIdentifyData
agsaContext_t agDeviceResetContext
agsaDevHandle_t * agDevHandle
bit32 volatile satPendingNONNCQIO
bit32 satLookAheadEnabled
bit32 volatile satPendingNCQIO
agsaDevHandle_t * agExpDevHandle
bit32 satReadLookAheadSupport
smList_t satActiveIntIoLinkList
bit32 freeSATAFDMATagBitmap
bit32 satVolatileWriteCacheSupport
bit32 volatile satPendingIO
bit32 satWriteCacheEnabled
bit32 satRemovableMediaEnabled
bit32 satMaxUserAddrSectors
smDeviceHandle_t * smDevHandle
smSenseData_t smSenseData
struct smIORequestBody_s::@5::@7 SATA
union smIORequestBody_s::@6 IOType
smIORequest_t * smIOToBeAbortedRequest
agsaSATAInitiatorRequest_t agSATARequestBody
smScsiRspSense_t sensePayload
struct smIORequestBody_s::@6::@9 InitiatorTMIO
agsaIORequest_t agIORequest
union smIORequestBody_s::@5 transport
smIORequest_t * smIORequest
smSatIOContext_t satIOContext
smIntContext_t smAllShared
agsaSASRequestBody_t agSASRequestBody
smDeviceHandle_t * smDevHandle
smDeviceData_t * smDeviceData
smIORequest_t * CurrentTaskTag
agsaIORequest_t agIORequest
smSMPCompleted_t SMPCompletionFunc
bit8 smpPayload[SMP_DIRECT_PAYLOAD_LIMIT]
struct smSatIOContext_s * satOrgIOContext
smSatInternalIo_t * satIntIoContext
struct smSatIOContext_s * satToBeAbortedIOContext
smScsiRspSense_t * pSense
bit8 Sector_Cnt_Upper_Nonzero
smDeviceHandle_t * psmDeviceHandle
smIniScsiCmnd_t * pScsiCmnd
smSatCompleteCbPtr_t satCompleteCB
smSenseData_t * pSmSenseData
agsaFisRegHostToDevice_t * pFis
smDeviceData_t * pSatDevData
smIORequest_t satIntSmIORequest
smScsiInitiatorRequest_t satIntSmScsiXchg
smIORequest_t * satOrgSmIORequest
smDataDirection_t dataDirection
osGLOBAL FORCEINLINE bit32 tdsmRotateQnumber(smRoot_t *smRoot, smDeviceHandle_t *smDeviceHandle)
osGLOBAL bit32 tdsmFreeMemory(smRoot_t *smRoot, void *osDMAHandle, bit32 allocLength)
osGLOBAL FORCEINLINE bit8 tdsmBitScanForward(smRoot_t *smRoot, bit32 *Index, bit32 Mask)
osGLOBAL FORCEINLINE void tdsmSingleThreadedEnter(smRoot_t *smRoot, bit32 syncLockId)
osGLOBAL FORCEINLINE void tdsmIOCompletedCB(smRoot_t *smRoot, smIORequest_t *smIORequest, bit32 status, bit32 statusDetail, smSenseData_t *senseData, bit32 interruptContext)
osGLOBAL FORCEINLINE void tdsmSingleThreadedLeave(smRoot_t *smRoot, bit32 syncLockId)
osGLOBAL bit32 tdsmAllocMemory(smRoot_t *smRoot, void **osMemHandle, void **virtPtr, bit32 *physAddrUpper, bit32 *physAddrLower, bit32 alignment, bit32 allocLength, smBOOLEAN isCacheable)
#define SCSI_STAT_CHECK_CONDITION
#define AG_LOGICAL_UNIT_RESET
union data structure specifies a request
agsaFisRegHostToDevice_t fisRegHostToDev