Something went wrong. Try again.
Reactos
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442244324442445244624472448244924502451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481248224832484248524862487248824892490249124922493249424952496249724982499250025012502250325042505250625072508250925102511251225132514251525162517251825192520252125222523252425252526252725282529253025312532253325342535253625372538253925402541254225432544254525462547254825492550255125522553255425552556255725582559256025612562256325642565256625672568256925702571257225732574257525762577257825792580258125822583258425852586258725882589259025912592259325942595259625972598259926002601260226032604260526062607260826092610261126122613261426152616261726182619262026212622262326242625262626272628262926302631263226332634263526362637263826392640264126422643264426452646264726482649265026512652265326542655265626572658265926602661266226632664266526662667266826692670267126722673267426752676267726782679268026812682268326842685268626872688268926902691269226932694269526962697269826992700270127022703270427052706270727082709271027112712/*++
Copyright (c) 2008-2019 Alexandr A. Telyatnikov (Alter)
Module Name: id_probe.cpp
Abstract: This module handles SATA- and AHCI-related staff
Author: Alexander A. Telyatnikov (Alter)
Environment: kernel mode only
Notes:
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
Revision History:
SATA support AHCI support
Licence: GPLv2
--*/
#include "stdafx.h"
UCHARNTAPIUniataSataConnect( IN PVOID HwDeviceExtension, IN ULONG lChannel, // logical channel IN ULONG pm_port /* for port multipliers */ ){ PHW_DEVICE_EXTENSION deviceExtension = (PHW_DEVICE_EXTENSION)HwDeviceExtension; //ULONG Channel = deviceExtension->Channel + lChannel; PHW_CHANNEL chan = &deviceExtension->chan[lChannel]; SATA_SSTATUS_REG SStatus; ULONG i;/* UCHAR signatureLow, signatureHigh;*/ UCHAR Status;
KdPrint2((PRINT_PREFIX "UniataSataConnect:\n"));
if(!UniataIsSATARangeAvailable(deviceExtension, lChannel)) { KdPrint2((PRINT_PREFIX " no I/O range\n")); return IDE_STATUS_IDLE; }
/* clear SATA error register, some controllers need this */ UniataSataWritePort4(chan, IDX_SATA_SError, UniataSataReadPort4(chan, IDX_SATA_SError, pm_port), pm_port); /* wait up to 1 second for "connect well" */ for(i=0; i<100; i++) { SStatus.Reg = UniataSataReadPort4(chan, IDX_SATA_SStatus, pm_port); if(SStatus.SPD == SStatus_SPD_Gen1 || SStatus.SPD == SStatus_SPD_Gen2 || SStatus.SPD == SStatus_SPD_Gen3) { // SATA sets actual transfer rate in LunExt on init. // There is no run-time SATA rate adjustment yet. // On the other hand, we may turn SATA device in PIO mode // TODO: make separate states for interface speed and transfer mode (DMA vs PIO) chan->lun[0]->LimitedTransferMode = chan->lun[0]->PhyTransferMode = chan->lun[0]->TransferMode = ATA_SA150 + (UCHAR)(SStatus.SPD - 1);
KdPrint2((PRINT_PREFIX "SATA TransferMode %#x\n", chan->lun[0]->TransferMode)); if(chan->MaxTransferMode < chan->lun[0]->TransferMode) { KdPrint2((PRINT_PREFIX "SATA upd chan TransferMode\n")); chan->MaxTransferMode = chan->lun[0]->TransferMode; } if(deviceExtension->MaxTransferMode < chan->lun[0]->TransferMode) { KdPrint2((PRINT_PREFIX "SATA upd controller TransferMode\n")); deviceExtension->MaxTransferMode = chan->lun[0]->TransferMode; }
break; } AtapiStallExecution(10000); } if(i >= 100) { KdPrint2((PRINT_PREFIX "UniataSataConnect: SStatus %8.8x\n", SStatus.Reg)); return IDE_STATUS_WRONG; } /* clear SATA error register */ UniataSataWritePort4(chan, IDX_SATA_SError, UniataSataReadPort4(chan, IDX_SATA_SError, pm_port), pm_port);
Status = WaitOnBaseBusyLong(chan); if(Status & IDE_STATUS_BUSY) { return Status; }/* signatureLow = AtapiReadPort1(chan, &deviceExtension->BaseIoAddress1[lChannel].i.CylinderLow); signatureHigh = AtapiReadPort1(chan, &deviceExtension->baseIoAddress1[lChannel].i.CylinderHigh);
if (signatureLow == ATAPI_MAGIC_LSB && signatureHigh == ATAPI_MAGIC_MSB) { }*/ KdPrint2((PRINT_PREFIX "UniataSataConnect: OK, ATA status %#x\n", Status)); return IDE_STATUS_IDLE;} // end UniataSataConnect()
UCHARNTAPIUniataSataPhyEnable( IN PVOID HwDeviceExtension, IN ULONG lChannel, // logical channel IN ULONG pm_port, /* for port multipliers */ IN BOOLEAN doReset ){ PHW_DEVICE_EXTENSION deviceExtension = (PHW_DEVICE_EXTENSION)HwDeviceExtension; PHW_CHANNEL chan = &deviceExtension->chan[lChannel]; SATA_SCONTROL_REG SControl; int loop, retry;
KdPrint2((PRINT_PREFIX "UniataSataPhyEnable:\n"));
if(!UniataIsSATARangeAvailable(deviceExtension, lChannel)) { KdPrint2((PRINT_PREFIX " no I/O range\n")); return IDE_STATUS_IDLE; }
SControl.Reg = UniataSataReadPort4(chan, IDX_SATA_SControl, pm_port); KdPrint2((PRINT_PREFIX "SControl %#x\n", SControl.Reg)); if(SControl.DET == SControl_DET_Idle) { if(!doReset) { return UniataSataConnect(HwDeviceExtension, lChannel, pm_port); } }
for (retry = 0; retry < 10; retry++) { KdPrint2((PRINT_PREFIX "UniataSataPhyEnable: retry init %d\n", retry)); for (loop = 0; loop < 10; loop++) { SControl.Reg = 0; SControl.DET = SControl_DET_Init; UniataSataWritePort4(chan, IDX_SATA_SControl, SControl.Reg, pm_port); AtapiStallExecution(100); SControl.Reg = UniataSataReadPort4(chan, IDX_SATA_SControl, pm_port); KdPrint2((PRINT_PREFIX " SControl %8.8x\n", SControl.Reg)); if(SControl.DET == SControl_DET_Init) { break; } } AtapiStallExecution(5000); KdPrint2((PRINT_PREFIX "UniataSataPhyEnable: retry idle %d\n", retry)); for (loop = 0; loop < 10; loop++) { SControl.Reg = 0; SControl.DET = SControl_DET_DoNothing; SControl.IPM = SControl_IPM_NoPartialSlumber; UniataSataWritePort4(chan, IDX_SATA_SControl, SControl.Reg, pm_port); AtapiStallExecution(100); SControl.Reg = UniataSataReadPort4(chan, IDX_SATA_SControl, pm_port); KdPrint2((PRINT_PREFIX " SControl %8.8x\n", SControl.Reg)); if(SControl.DET == SControl_DET_Idle) { return UniataSataConnect(HwDeviceExtension, lChannel, pm_port); } } }
KdPrint2((PRINT_PREFIX "UniataSataPhyEnable: failed\n")); return IDE_STATUS_WRONG;} // end UniataSataPhyEnable()
BOOLEANNTAPIUniataSataClearErr( IN PVOID HwDeviceExtension, IN ULONG lChannel, // logical channel IN BOOLEAN do_connect, IN ULONG pm_port /* for port multipliers */ ){ PHW_DEVICE_EXTENSION deviceExtension = (PHW_DEVICE_EXTENSION)HwDeviceExtension; PHW_CHANNEL chan = &deviceExtension->chan[lChannel]; //ULONG ChipFlags = deviceExtension->HwFlags & CHIPFLAG_MASK; SATA_SSTATUS_REG SStatus; SATA_SERROR_REG SError;
if(UniataIsSATARangeAvailable(deviceExtension, lChannel)) { //if(ChipFlags & UNIATA_SATA) {
SStatus.Reg = UniataSataReadPort4(chan, IDX_SATA_SStatus, pm_port); SError.Reg = UniataSataReadPort4(chan, IDX_SATA_SError, pm_port);
if(SStatus.Reg) { KdPrint2((PRINT_PREFIX " SStatus %#x\n", SStatus.Reg)); } if(SError.Reg) { KdPrint2((PRINT_PREFIX " SError %#x\n", SError.Reg)); /* clear error bits/interrupt */ UniataSataWritePort4(chan, IDX_SATA_SError, SError.Reg, pm_port);
if(do_connect) { /* if we have a connection event deal with it */ if(SError.DIAG.N) { KdPrint2((PRINT_PREFIX " catch SATA connect/disconnect\n")); if(SStatus.SPD >= SStatus_SPD_Gen1) { UniataSataEvent(deviceExtension, lChannel, UNIATA_SATA_EVENT_ATTACH, pm_port); } else { UniataSataEvent(deviceExtension, lChannel, UNIATA_SATA_EVENT_DETACH, pm_port); } return TRUE; } } //return TRUE; } } return FALSE;} // end UniataSataClearErr()
BOOLEANNTAPIUniataSataEvent( IN PVOID HwDeviceExtension, IN ULONG lChannel, // logical channel IN ULONG Action, IN ULONG pm_port /* for port multipliers */ ){ PHW_DEVICE_EXTENSION deviceExtension = (PHW_DEVICE_EXTENSION)HwDeviceExtension; UCHAR Status; ULONG DeviceNumber = (pm_port ? 1 : 0);
if(!UniataIsSATARangeAvailable(deviceExtension, lChannel)) { return FALSE; }
switch(Action) { case UNIATA_SATA_EVENT_ATTACH: KdPrint2((PRINT_PREFIX " CONNECTED\n")); Status = UniataSataConnect(HwDeviceExtension, lChannel, pm_port); KdPrint2((PRINT_PREFIX " Status %#x\n", Status)); if(Status != IDE_STATUS_IDLE) { return FALSE; } CheckDevice(HwDeviceExtension, lChannel, DeviceNumber /*dev*/, FALSE); return TRUE; break; case UNIATA_SATA_EVENT_DETACH: KdPrint2((PRINT_PREFIX " DISCONNECTED\n")); UniataForgetDevice(deviceExtension->chan[lChannel].lun[DeviceNumber]); return TRUE; break; } return FALSE;} // end UniataSataEvent()
ULONGNTAPIUniataSataReadPort4( IN PHW_CHANNEL chan, IN ULONG io_port_ndx, IN ULONG pm_port /* for port multipliers */ ){ if(chan && (io_port_ndx < IDX_MAX_REG) && chan->RegTranslation[io_port_ndx].Proc) {
KdPrint3((PRINT_PREFIX " UniataSataReadPort4 %#x[%d]\n", io_port_ndx, pm_port));
PHW_DEVICE_EXTENSION deviceExtension = chan->DeviceExtension; PVOID HwDeviceExtension = (PVOID)deviceExtension; ULONG slotNumber = deviceExtension->slotNumber; ULONG SystemIoBusNumber = deviceExtension->SystemIoBusNumber; ULONG VendorID = deviceExtension->DevID & 0xffff; ULONG offs; ULONG p;
switch(VendorID) { case ATA_INTEL_ID: { p = pm_port ? 1 : 0; if(deviceExtension->HwFlags & ICH5) { offs = 0x50+chan->lun[p]->SATA_lun_map*0x10; KdPrint3((PRINT_PREFIX " ICH5 way, offs %#x\n", offs)); switch(io_port_ndx) { case IDX_SATA_SStatus: offs += 0; break; case IDX_SATA_SError: offs += 1*4; break; case IDX_SATA_SControl: offs += 2*4; break; default: return -1; } SetPciConfig4(0xa0, offs); GetPciConfig4(0xa4, offs); return offs; } else if(deviceExtension->HwFlags & ICH7) { offs = 0x100+chan->lun[p]->SATA_lun_map*0x80; KdPrint3((PRINT_PREFIX " ICH7 way, offs %#x\n", offs)); switch(io_port_ndx) { case IDX_SATA_SStatus: offs += IDX_AHCI_P_SStatus; break; case IDX_SATA_SError: offs += IDX_AHCI_P_SError; break; case IDX_SATA_SControl: offs += IDX_AHCI_P_SControl; break; default: return -1; } return AtapiReadPortEx4(NULL, (ULONGIO_PTR)(&deviceExtension->BaseIoAddressSATA_0), offs); } else { offs = ((deviceExtension->Channel+chan->lChannel)*2+p) * 0x100; KdPrint3((PRINT_PREFIX " def way, offs %#x\n", offs)); switch(io_port_ndx) { case IDX_SATA_SStatus: offs += 0; break; case IDX_SATA_SControl: offs += 1; break; case IDX_SATA_SError: offs += 2; break; default: return -1; } AtapiWritePort4(chan, IDX_INDEXED_ADDR, offs); return AtapiReadPort4(chan, IDX_INDEXED_DATA); } } // ATA_INTEL_ID } // end switch(VendorID) return -1; } return AtapiReadPort4(chan, io_port_ndx);} // end UniataSataReadPort4()
VOIDNTAPIUniataSataWritePort4( IN PHW_CHANNEL chan, IN ULONG io_port_ndx, IN ULONG data, IN ULONG pm_port /* for port multipliers */ ){ if(chan && (io_port_ndx < IDX_MAX_REG) && chan->RegTranslation[io_port_ndx].Proc) {
KdPrint3((PRINT_PREFIX " UniataSataWritePort4 %#x[%d]\n", io_port_ndx, pm_port));
PHW_DEVICE_EXTENSION deviceExtension = chan->DeviceExtension; PVOID HwDeviceExtension = (PVOID)deviceExtension; ULONG slotNumber = deviceExtension->slotNumber; ULONG SystemIoBusNumber = deviceExtension->SystemIoBusNumber; ULONG VendorID = deviceExtension->DevID & 0xffff; ULONG offs; ULONG p;
switch(VendorID) { case ATA_INTEL_ID: { p = pm_port ? 1 : 0; if(deviceExtension->HwFlags & ICH5) { offs = 0x50+chan->lun[p]->SATA_lun_map*0x10; KdPrint3((PRINT_PREFIX " ICH5 way, offs %#x\n", offs)); switch(io_port_ndx) { case IDX_SATA_SStatus: offs += 0; break; case IDX_SATA_SError: offs += 1*4; break; case IDX_SATA_SControl: offs += 2*4; break; default: return; } SetPciConfig4(0xa0, offs); SetPciConfig4(0xa4, data); return; } else if(deviceExtension->HwFlags & ICH7) { offs = 0x100+chan->lun[p]->SATA_lun_map*0x80; KdPrint3((PRINT_PREFIX " ICH7 way, offs %#x\n", offs)); switch(io_port_ndx) { case IDX_SATA_SStatus: offs += IDX_AHCI_P_SStatus; break; case IDX_SATA_SError: offs += IDX_AHCI_P_SError; break; case IDX_SATA_SControl: offs += IDX_AHCI_P_SControl; break; default: return; } AtapiWritePortEx4(NULL, (ULONGIO_PTR)(&deviceExtension->BaseIoAddressSATA_0), offs, data); return; } else { offs = ((deviceExtension->Channel+chan->lChannel)*2+p) * 0x100; KdPrint3((PRINT_PREFIX " def way, offs %#x\n", offs)); switch(io_port_ndx) { case IDX_SATA_SStatus: offs += 0; break; case IDX_SATA_SControl: offs += 1; break; case IDX_SATA_SError: offs += 2; break; default: return; } AtapiWritePort4(chan, IDX_INDEXED_ADDR, offs); AtapiWritePort4(chan, IDX_INDEXED_DATA, data); } } // ATA_INTEL_ID } // end switch(VendorID) return; } AtapiWritePort4(chan, io_port_ndx, data);} // end UniataSataWritePort4()
BOOLEANNTAPIUniataSataReadPM( IN PHW_CHANNEL chan, IN ULONG DeviceNumber, IN ULONG Reg, OUT PULONG result ){ if(chan->DeviceExtension->HwFlags & UNIATA_AHCI) { return UniataAhciReadPM(chan, DeviceNumber, Reg, result); } return FALSE;} // end UniataSataReadPM()
UCHARNTAPIUniataSataWritePM( IN PHW_CHANNEL chan, IN ULONG DeviceNumber, IN ULONG Reg, IN ULONG value ){ if(chan->DeviceExtension->HwFlags & UNIATA_AHCI) { return UniataAhciWritePM(chan, DeviceNumber, Reg, value); } return IDE_STATUS_WRONG;} // end UniataSataWritePM()
ULONGNTAPIUniataSataSoftReset( IN PVOID HwDeviceExtension, IN ULONG lChannel, IN ULONG DeviceNumber ){ PHW_DEVICE_EXTENSION deviceExtension = (PHW_DEVICE_EXTENSION)HwDeviceExtension;
if(deviceExtension->HwFlags & UNIATA_AHCI) { return UniataAhciSoftReset(HwDeviceExtension, lChannel, DeviceNumber); } return 0xffffffff;} // end UniataSataSoftReset()
VOIDUniataSataIdentifyPM( IN PHW_CHANNEL chan ){ ULONG PM_DeviceId; ULONG PM_RevId; ULONG PM_Ports; UCHAR i; ULONG signature; PHW_LU_EXTENSION LunExt;
KdPrint((PRINT_PREFIX "UniataSataIdentifyPM:\n"));
chan->PmLunMap = 0;
/* get PM vendor & product data */ if(!UniataSataReadPM(chan, AHCI_DEV_SEL_PM, 0, &PM_DeviceId)) { KdPrint2((PRINT_PREFIX " error getting PM vendor data\n")); return; } /* get PM revision data */ if(!UniataSataReadPM(chan, AHCI_DEV_SEL_PM, 1, &PM_RevId)) { KdPrint2((PRINT_PREFIX " error getting PM revison data\n")); return; } /* get number of HW ports on the PM */ if(!UniataSataReadPM(chan, AHCI_DEV_SEL_PM, 2, &PM_Ports)) { KdPrint2((PRINT_PREFIX " error getting PM port info\n")); return; }
PM_Ports &= 0x0000000f;
switch(PM_DeviceId) { case 0x37261095: /* This PM declares 6 ports, while only 5 of them are real. * Port 5 is enclosure management bridge port, which has implementation * problems, causing probe faults. Hide it for now. */ KdPrint2((PRINT_PREFIX " SiI 3726 (rev=%#x) Port Multiplier with %d (5) ports\n", PM_RevId, PM_Ports)); PM_Ports = 5; break; case 0x47261095: /* This PM declares 7 ports, while only 5 of them are real. * Port 5 is some fake "Config Disk" with 640 sectors size, * port 6 is enclosure management bridge port. * Both fake ports has implementation problems, causing * probe faults. Hide them for now. */ KdPrint2((PRINT_PREFIX " SiI 4726 (rev=%#x) Port Multiplier with %d (5) ports\n", PM_RevId, PM_Ports)); PM_Ports = 5; break; default: KdPrint2((PRINT_PREFIX " Port Multiplier (id=%08x rev=%#x) with %d ports\n", PM_DeviceId, PM_RevId, PM_Ports)); break; }
// reset for(i=0; i<PM_Ports; i++) {
LunExt = chan->lun[i];
KdPrint2((PRINT_PREFIX " Port %d\n", i)); if(UniataSataPhyEnable(chan->DeviceExtension, chan->lChannel, i, UNIATA_SATA_RESET_ENABLE) != IDE_STATUS_IDLE) { LunExt->DeviceFlags &= ~DFLAGS_DEVICE_PRESENT; continue; } /* * XXX: I have no idea how to properly wait for PMP port hardreset * completion. Without this delay soft reset does not completes * successfully. */ AtapiStallExecution(1000000);
signature = UniataSataSoftReset(chan->DeviceExtension, chan->lChannel, i); KdPrint2((PRINT_PREFIX " signature %#x\n", signature));
LunExt->DeviceFlags |= DFLAGS_DEVICE_PRESENT; chan->PmLunMap |= (1 << i); /* figure out whats there */ switch (signature >> 16) { case 0x0000: LunExt->DeviceFlags &= ~DFLAGS_ATAPI_DEVICE; continue; case 0xeb14: LunExt->DeviceFlags |= DFLAGS_ATAPI_DEVICE; continue; }
}
} // end UniataSataIdentifyPM()
#ifdef _DEBUGVOIDNTAPIUniataDumpAhciRegs( IN PHW_DEVICE_EXTENSION deviceExtension ){ ULONG j; ULONG xReg;
KdPrint2((PRINT_PREFIX " AHCI Base: %#x MemIo %d Proc %d\n", deviceExtension->BaseIoAHCI_0.Addr, deviceExtension->BaseIoAHCI_0.MemIo, deviceExtension->BaseIoAHCI_0.Proc));
for(j=0; j<=IDX_AHCI_VS; j+=sizeof(ULONG)) { xReg = AtapiReadPortEx4(NULL, (ULONGIO_PTR)&deviceExtension->BaseIoAHCI_0, j); KdPrint2((PRINT_PREFIX " AHCI_%#x (%#x) = %#x\n", j, (deviceExtension->BaseIoAHCI_0.Addr+j), xReg)); } return;} // end UniataDumpAhciRegs()
VOIDNTAPIUniataDumpAhciPortRegs( IN PHW_CHANNEL chan ){ ULONG j; ULONG xReg;
KdPrint2((PRINT_PREFIX " AHCI port %d Base: %#x MemIo %d Proc %d\n", chan->lChannel, chan->BaseIoAHCI_Port.Addr, chan->BaseIoAHCI_Port.MemIo, chan->BaseIoAHCI_Port.Proc));
for(j=0; j<=IDX_AHCI_P_SNTF; j+=sizeof(ULONG)) { xReg = AtapiReadPortEx4(NULL, (ULONGIO_PTR)&chan->BaseIoAHCI_Port, j); KdPrint2((PRINT_PREFIX " AHCI%d_%#x (%#x) = %#x\n", chan->lChannel, j, (chan->BaseIoAHCI_Port.Addr+j), xReg)); } return;} // end UniataDumpAhciPortRegs()#endif //_DEBUG
BOOLEANNTAPIUniataAhciInit( IN PVOID HwDeviceExtension ){ PHW_DEVICE_EXTENSION deviceExtension = (PHW_DEVICE_EXTENSION)HwDeviceExtension; ULONG c, i; PHW_CHANNEL chan; ULONG offs;#ifdef __REACTOS__ ULONG_PTR BaseMemAddress;#else ULONG BaseMemAddress;#endif ULONG PI; ULONG CAP; ULONG CAP2; ULONG BOHC; ULONG GHC; BOOLEAN MemIo = FALSE;
KdPrint2((PRINT_PREFIX " UniataAhciInit:\n"));
#ifdef _DEBUG UniataDumpAhciRegs(deviceExtension);#endif //_DEBUG
CAP2 = UniataAhciReadHostPort4(deviceExtension, IDX_AHCI_CAP2); if(CAP2 & AHCI_CAP2_BOH) { BOHC = UniataAhciReadHostPort4(deviceExtension, IDX_AHCI_BOHC); KdPrint2((PRINT_PREFIX " stage 1 BOHC %#x\n", BOHC)); UniataAhciWriteHostPort4(deviceExtension, IDX_AHCI_BOHC, BOHC | AHCI_BOHC_OOS); for(i=0; i<50; i++) { AtapiStallExecution(500); BOHC = UniataAhciReadHostPort4(deviceExtension, IDX_AHCI_BOHC); KdPrint2((PRINT_PREFIX " BOHC %#x\n", BOHC)); if(BOHC & AHCI_BOHC_BB) { break; } if(!(BOHC & AHCI_BOHC_BOS)) { break; } } KdPrint2((PRINT_PREFIX " stage 2 BOHC %#x\n", BOHC)); if(BOHC & AHCI_BOHC_BB) { for(i=0; i<2000; i++) { AtapiStallExecution(1000); BOHC = UniataAhciReadHostPort4(deviceExtension, IDX_AHCI_BOHC); KdPrint2((PRINT_PREFIX " BOHC %#x\n", BOHC)); if(!(BOHC & AHCI_BOHC_BOS)) { break; } } } KdPrint2((PRINT_PREFIX " final BOHC %#x\n", BOHC)); }
/* disable AHCI interrupts, for MSI compatibility issue see http://www.intel.com/Assets/PDF/specupdate/307014.pdf 26. AHCI Reset and MSI Request */
KdPrint2((PRINT_PREFIX " get GHC\n")); /* enable AHCI mode */ GHC = UniataAhciReadHostPort4(deviceExtension, IDX_AHCI_GHC); if(!(GHC & AHCI_GHC_AE)) { KdPrint2((PRINT_PREFIX " enable AHCI mode, disable intr, GHC %#x\n", GHC)); UniataAhciWriteHostPort4(deviceExtension, IDX_AHCI_GHC, (GHC | AHCI_GHC_AE) & ~AHCI_GHC_IE); } else { KdPrint2((PRINT_PREFIX " disable intr, GHC %#x\n", GHC)); UniataAhciWriteHostPort4(deviceExtension, IDX_AHCI_GHC, GHC & ~AHCI_GHC_IE); } AtapiStallExecution(100);
/* read GHC again and reset AHCI controller */ GHC = UniataAhciReadHostPort4(deviceExtension, IDX_AHCI_GHC); KdPrint2((PRINT_PREFIX " reset AHCI controller, GHC %#x\n", GHC)); UniataAhciWriteHostPort4(deviceExtension, IDX_AHCI_GHC, GHC | AHCI_GHC_HR);
for(i=0; i<1000; i++) { AtapiStallExecution(1000); GHC = UniataAhciReadHostPort4(deviceExtension, IDX_AHCI_GHC); KdPrint2((PRINT_PREFIX " AHCI GHC %#x\n", GHC)); if(!(GHC & AHCI_GHC_HR)) { break; } } if(GHC & AHCI_GHC_HR) { KdPrint2((PRINT_PREFIX " AHCI reset failed\n")); return FALSE; }
/* re-enable AHCI mode */ /* Linux: Some controllers need AHCI_EN to be written multiple times. * Try a few times before giving up. */ GHC = UniataAhciReadHostPort4(deviceExtension, IDX_AHCI_GHC); for(i=0; i<5; i++) { if(!(GHC & AHCI_GHC_AE)) { KdPrint2((PRINT_PREFIX " re-enable AHCI mode, GHC %#x\n", GHC)); UniataAhciWriteHostPort4(deviceExtension, IDX_AHCI_GHC, GHC | AHCI_GHC_AE); AtapiStallExecution(1000); GHC = UniataAhciReadHostPort4(deviceExtension, IDX_AHCI_GHC); } else { break; } } KdPrint2((PRINT_PREFIX " AHCI GHC %#x\n", GHC)); if(!(GHC & AHCI_GHC_AE)) { KdPrint2((PRINT_PREFIX " Can't enable AHCI mode\n")); return FALSE; }
deviceExtension->AHCI_CAP = CAP = UniataAhciReadHostPort4(deviceExtension, IDX_AHCI_CAP); KdPrint2((PRINT_PREFIX " AHCI CAP %#x\n", CAP)); if(CAP & AHCI_CAP_S64A) { KdPrint2((PRINT_PREFIX " AHCI 64bit\n")); deviceExtension->Host64 = TRUE; } KdPrint2((PRINT_PREFIX " AHCI %d CMD slots\n", (CAP & AHCI_CAP_NCS_MASK) >> 8 )); if(CAP & AHCI_CAP_PMD) { KdPrint2((PRINT_PREFIX " AHCI multi-block PIO\n")); } if(CAP & AHCI_CAP_SAM) { KdPrint2((PRINT_PREFIX " AHCI legasy SATA\n")); }
/* get the number of HW channels */ PI = UniataAhciReadHostPort4(deviceExtension, IDX_AHCI_PI); deviceExtension->AHCI_PI = PI; KdPrint2((PRINT_PREFIX " AHCI PI %#x\n", PI)); KdPrint2((PRINT_PREFIX " AHCI PI mask %#x\n", deviceExtension->AHCI_PI_mask)); deviceExtension->AHCI_PI = PI = PI & deviceExtension->AHCI_PI_mask; KdPrint2((PRINT_PREFIX " masked AHCI PI %#x\n", PI));
CAP2 = UniataAhciReadHostPort4(deviceExtension, IDX_AHCI_CAP2); if(CAP2 & AHCI_CAP2_BOH) { KdPrint2((PRINT_PREFIX " retry BOHC\n")); BOHC = UniataAhciReadHostPort4(deviceExtension, IDX_AHCI_BOHC); KdPrint2((PRINT_PREFIX " BOHC %#x\n", BOHC)); UniataAhciWriteHostPort4(deviceExtension, IDX_AHCI_BOHC, BOHC | AHCI_BOHC_OOS); } /* clear interrupts */ UniataAhciWriteHostPort4(deviceExtension, IDX_AHCI_IS, UniataAhciReadHostPort4(deviceExtension, IDX_AHCI_IS));
/* enable AHCI interrupts */ UniataAhciWriteHostPort4(deviceExtension, IDX_AHCI_GHC, UniataAhciReadHostPort4(deviceExtension, IDX_AHCI_GHC) | AHCI_GHC_IE);
BaseMemAddress = deviceExtension->BaseIoAHCI_0.Addr; MemIo = deviceExtension->BaseIoAHCI_0.MemIo;
deviceExtension->MaxTransferMode = ATA_SA150+(((CAP & AHCI_CAP_ISS_MASK) >> 20)-1); KdPrint2((PRINT_PREFIX " SATA Gen %d\n", ((CAP & AHCI_CAP_ISS_MASK) >> 20) ));
for(c=0; c<deviceExtension->NumberChannels; c++) { chan = &deviceExtension->chan[c]; offs = sizeof(IDE_AHCI_REGISTERS) + c*sizeof(IDE_AHCI_PORT_REGISTERS);
KdPrint2((PRINT_PREFIX " chan %d, offs %#x\n", c, offs));
chan->MaxTransferMode = deviceExtension->MaxTransferMode;
AtapiSetupLunPtrs(chan, deviceExtension, c);
chan->BaseIoAHCI_Port = deviceExtension->BaseIoAHCI_0; chan->BaseIoAHCI_Port.Addr = BaseMemAddress + offs;
chan->RegTranslation[IDX_IO1_i_Status ].Addr = BaseMemAddress + offs + FIELD_OFFSET(IDE_AHCI_PORT_REGISTERS, TFD.STS); chan->RegTranslation[IDX_IO1_i_Status ].MemIo = MemIo; chan->RegTranslation[IDX_IO2_AltStatus] = chan->RegTranslation[IDX_IO1_i_Status]; chan->RegTranslation[IDX_IO1_i_Error ].Addr = BaseMemAddress + offs + FIELD_OFFSET(IDE_AHCI_PORT_REGISTERS, TFD.ERR); chan->RegTranslation[IDX_IO1_i_Error ].MemIo = MemIo; chan->RegTranslation[IDX_IO1_i_CylinderLow ].Addr = BaseMemAddress + offs + FIELD_OFFSET(IDE_AHCI_PORT_REGISTERS, SIG.LbaLow); chan->RegTranslation[IDX_IO1_i_CylinderLow ].MemIo = MemIo; chan->RegTranslation[IDX_IO1_i_CylinderHigh].Addr = BaseMemAddress + offs + FIELD_OFFSET(IDE_AHCI_PORT_REGISTERS, SIG.LbaHigh); chan->RegTranslation[IDX_IO1_i_CylinderHigh].MemIo = MemIo; chan->RegTranslation[IDX_IO1_i_BlockCount ].Addr = BaseMemAddress + offs + FIELD_OFFSET(IDE_AHCI_PORT_REGISTERS, SIG.SectorCount); chan->RegTranslation[IDX_IO1_i_BlockCount ].MemIo = MemIo;
UniataInitSyncBaseIO(chan);
chan->RegTranslation[IDX_SATA_SStatus].Addr = BaseMemAddress + offs + FIELD_OFFSET(IDE_AHCI_PORT_REGISTERS, SSTS); chan->RegTranslation[IDX_SATA_SStatus].MemIo = MemIo; chan->RegTranslation[IDX_SATA_SError].Addr = BaseMemAddress + offs + FIELD_OFFSET(IDE_AHCI_PORT_REGISTERS, SERR); chan->RegTranslation[IDX_SATA_SError].MemIo = MemIo; chan->RegTranslation[IDX_SATA_SControl].Addr = BaseMemAddress + offs + FIELD_OFFSET(IDE_AHCI_PORT_REGISTERS, SCTL); chan->RegTranslation[IDX_SATA_SControl].MemIo = MemIo; chan->RegTranslation[IDX_SATA_SActive].Addr = BaseMemAddress + offs + FIELD_OFFSET(IDE_AHCI_PORT_REGISTERS, SACT); chan->RegTranslation[IDX_SATA_SActive].MemIo = MemIo;
AtapiDmaAlloc(HwDeviceExtension, NULL, c);
if(!UniataAhciChanImplemented(deviceExtension, c)) { KdPrint2((PRINT_PREFIX " chan %d not implemented\n", c)); continue; }
UniataAhciResume(chan);
chan->ChannelCtrlFlags |= CTRFLAGS_NO_SLAVE; }
return TRUE;} // end UniataAhciInit()
BOOLEANNTAPIUniAtaAhciValidateVersion( IN PHW_DEVICE_EXTENSION deviceExtension, IN ULONG version, IN BOOLEAN Strict ){ switch(version) { case 0x00000000: case 0xffffffff: KdPrint((" wrong AHCI revision %#x\n", version)); return FALSE; case 0x00000905: case 0x00010000: case 0x00010100: case 0x00010200: case 0x00010300: case 0x00010301: break; default: KdPrint2((PRINT_PREFIX " Unknown AHCI revision\n")); if(AtapiRegCheckDevValue(deviceExtension, CHAN_NOT_SPECIFIED, DEVNUM_NOT_SPECIFIED, L"CheckAhciRevision", Strict)) { KdPrint((" AHCI revision excluded %#x\n", version)); return FALSE; } } return TRUE;} // end UniAtaAhciValidateVersion()
BOOLEANNTAPIUniataAhciDetect( IN PVOID HwDeviceExtension, IN PPCI_COMMON_CONFIG pciData, // optional IN OUT PPORT_CONFIGURATION_INFORMATION ConfigInfo ){ PHW_DEVICE_EXTENSION deviceExtension = (PHW_DEVICE_EXTENSION)HwDeviceExtension; //ULONG slotNumber = deviceExtension->slotNumber; ULONG SystemIoBusNumber = deviceExtension->SystemIoBusNumber; ULONG version; ULONG i, n; ULONG PI; //ULONG PI_ex_mask=0; ULONG CAP; ULONG CAP2; ULONG GHC, GHC0;#ifdef _DEBUG ULONG BOHC; ULONG v_Mn, v_Mj;#endif //_DEBUG ULONG NumberChannels; ULONG_PTR BaseMemAddress; BOOLEAN MemIo = FALSE; BOOLEAN found = FALSE; ULONG BarId=5;
KdPrint2((PRINT_PREFIX " UniataAhciDetect:\n"));
if(AtapiRegCheckDevValue(deviceExtension, CHAN_NOT_SPECIFIED, DEVNUM_NOT_SPECIFIED, L"IgnoreAhci", 0)) { KdPrint((" AHCI excluded\n")); return FALSE; } switch(deviceExtension->DevID) { case 0xa01c0031: KdPrint2((PRINT_PREFIX " Cavium uses BAR(0)\n")); BarId = 0; break; } BaseMemAddress = AtapiGetIoRange(HwDeviceExtension, ConfigInfo, pciData, SystemIoBusNumber, BarId, 0, 0x10); if(!BaseMemAddress) { KdPrint2((PRINT_PREFIX " AHCI init failed - no IoRange\n")); return FALSE; } if((*ConfigInfo->AccessRanges)[BarId].RangeInMemory) { KdPrint2((PRINT_PREFIX "MemIo\n")); MemIo = TRUE; } deviceExtension->BaseIoAHCI_0.Addr = BaseMemAddress; deviceExtension->BaseIoAHCI_0.MemIo = MemIo;
#ifdef _DEBUG UniataDumpAhciRegs(deviceExtension);#endif //_DEBUG
GHC = UniataAhciReadHostPort4(deviceExtension, IDX_AHCI_GHC); if(GHC & AHCI_GHC_HR) { KdPrint2((PRINT_PREFIX " AHCI in reset state\n")); return FALSE; }
/* check AHCI mode. Save state and try enable */ GHC0 = GHC = UniataAhciReadHostPort4(deviceExtension, IDX_AHCI_GHC); KdPrint2((PRINT_PREFIX " check AHCI mode, GHC %#x\n", GHC));
version = UniataAhciReadHostPort4(deviceExtension, IDX_AHCI_VS);
if(!(GHC & AHCI_GHC_AE)) { KdPrint2((PRINT_PREFIX " Non-AHCI GHC (!AE), check revision %#x\n", version)); if(!UniAtaAhciValidateVersion(deviceExtension, version, FALSE)) { KdPrint2((PRINT_PREFIX " Non-AHCI\n")); goto exit_detect; } KdPrint2((PRINT_PREFIX " try enable\n")); UniataAhciWriteHostPort4(deviceExtension, IDX_AHCI_GHC, (GHC | AHCI_GHC_AE) & ~AHCI_GHC_IE); GHC = UniataAhciReadHostPort4(deviceExtension, IDX_AHCI_GHC);
KdPrint2((PRINT_PREFIX " re-check AHCI mode, GHC %#x\n", GHC)); if(!(GHC & AHCI_GHC_AE)) { KdPrint2((PRINT_PREFIX " Non-AHCI GHC (!AE)\n")); goto exit_detect; } }
CAP = UniataAhciReadHostPort4(deviceExtension, IDX_AHCI_CAP); CAP2 = UniataAhciReadHostPort4(deviceExtension, IDX_AHCI_CAP2); KdPrint2((PRINT_PREFIX " AHCI CAP %#x, CAP2 %#x, ver %#x\n", CAP, CAP2, version)); if(CAP & AHCI_CAP_S64A) { KdPrint2((PRINT_PREFIX " 64bit")); //deviceExtension->Host64 = TRUE; // this is just DETECT, do not update anything }#ifdef _DEBUG if(CAP2 & AHCI_CAP2_BOH) { BOHC = UniataAhciReadHostPort4(deviceExtension, IDX_AHCI_BOHC); KdPrint2((PRINT_PREFIX " BOHC %#x", BOHC)); }#endif //_DEBUG if(CAP & AHCI_CAP_NCQ) { KdPrint2((PRINT_PREFIX " NCQ")); } if(CAP & AHCI_CAP_SNTF) { KdPrint2((PRINT_PREFIX " SNTF")); } if(CAP & AHCI_CAP_CCC) { KdPrint2((PRINT_PREFIX " CCC")); } KdPrint2((PRINT_PREFIX "\n"));
/* get the number of HW channels */
/* CAP.NOP sometimes indicate the index of the last enabled * port, at other times, that of the last possible port, so * determining the maximum port number requires looking at * both CAP.NOP and PI. */ PI = UniataAhciReadHostPort4(deviceExtension, IDX_AHCI_PI); deviceExtension->AHCI_PI = deviceExtension->AHCI_PI_mask = PI; KdPrint2((PRINT_PREFIX " AHCI PI %#x\n", PI));
for(i=PI, n=0; i; n++, i=i>>1) { if(AtapiRegCheckDevValue(deviceExtension, n, DEVNUM_NOT_SPECIFIED, L"Exclude", 0)) { KdPrint2((PRINT_PREFIX "Channel %d excluded\n", n)); deviceExtension->AHCI_PI &= ~((ULONG)1 << n); deviceExtension->AHCI_PI_mask &= ~((ULONG)1 << n); //PI_ex_mask |= ((ULONG)1 << n); } } deviceExtension->AHCI_PI_mask = AtapiRegCheckDevValue(deviceExtension, CHAN_NOT_SPECIFIED, DEVNUM_NOT_SPECIFIED, L"PortMask", deviceExtension->AHCI_PI_mask); KdPrint2((PRINT_PREFIX "Force PortMask %#x\n", deviceExtension->AHCI_PI_mask));
for(i=PI, n=0; i; n++, i=i>>1); NumberChannels = max((CAP & AHCI_CAP_NOP_MASK)+1, n);
if(!PI && ((CAP & AHCI_CAP_NOP_MASK)+1)) { /* Enable ports. * The spec says that BIOS sets up bits corresponding to * available ports. On platforms where this information * is missing, the driver can define available ports on its own. */ KdPrint2((PRINT_PREFIX "PI=0 -> Enable ports (mask) %#x\n", deviceExtension->AHCI_PI_mask)); n = NumberChannels; deviceExtension->AHCI_PI = ((ULONG)1 << n)-1;
if(deviceExtension->AHCI_PI_mask) { // we have some forced port mask PI = deviceExtension->AHCI_PI_mask; } else { // construct mask PI = deviceExtension->AHCI_PI = (((ULONG)1 << n)-1); deviceExtension->AHCI_PI_mask = (((ULONG)1 << n)-1); } KdPrint2((PRINT_PREFIX "Enable ports final PI %#x\n", PI)); UniataAhciWriteHostPort4(deviceExtension, IDX_AHCI_PI, PI); }
KdPrint2((PRINT_PREFIX " CommandSlots %d\n", (CAP & AHCI_CAP_NCS_MASK)>>8 )); KdPrint2((PRINT_PREFIX " Detected Channels %d / %d\n", NumberChannels, n));
switch(deviceExtension->DevID) { case 0x2361197b: KdPrint2((PRINT_PREFIX " JMicron JMB361 -> 1\n")); NumberChannels = 1; break; case ATA_M88SE6111: KdPrint2((PRINT_PREFIX " Marvell M88SE6111 -> 1\n")); NumberChannels = 1; break; case ATA_M88SE6121: KdPrint2((PRINT_PREFIX " Marvell M88SE6121 -> 2\n")); NumberChannels = min(NumberChannels, 2); break; case ATA_M88SE6141: case ATA_M88SE6145: case ATA_M88SE9123: KdPrint2((PRINT_PREFIX " Marvell M88SE614x/9123 -> 4\n")); NumberChannels = min(NumberChannels, 4); break; } // switch()
if(!NumberChannels) { KdPrint2((PRINT_PREFIX " Non-AHCI - NumberChannels=0\n")); found = FALSE; goto exit_detect; } KdPrint2((PRINT_PREFIX " Adjusted Channels %d\n", NumberChannels));
#ifdef _DEBUG v_Mj = ((version >> 20) & 0xf0) + ((version >> 16) & 0x0f); v_Mn = ((version >> 4) & 0xf0) + (version & 0x0f);
KdPrint2((PRINT_PREFIX " AHCI version %x.%02x controller with %d ports (mask %#x) detected\n", v_Mj, v_Mn, NumberChannels, PI)); KdPrint((" AHCI SATA Gen %d\n", (((CAP & AHCI_CAP_ISS_MASK) >> 20)) ));#endif //_DEBUG
if(CAP & AHCI_CAP_SPM) { KdPrint2((PRINT_PREFIX " PM supported\n")); if(AtapiRegCheckDevValue(deviceExtension, CHAN_NOT_SPECIFIED, DEVNUM_NOT_SPECIFIED, L"IgnoreAhciPM", 1 /* DEBUG */)) { KdPrint2((PRINT_PREFIX "SATA/AHCI w/o PM, max luns 1\n")); deviceExtension->NumberLuns = 1; //chan->ChannelCtrlFlags |= CTRFLAGS_NO_SLAVE; } else { KdPrint2((PRINT_PREFIX "SATA/AHCI -> possible PM, max luns %d\n", SATA_MAX_PM_UNITS)); deviceExtension->NumberLuns = SATA_MAX_PM_UNITS; //deviceExtension->NumberLuns = 1; } } else { KdPrint2((PRINT_PREFIX " PM not supported -> 1 lun/chan\n")); deviceExtension->NumberLuns = 1; }
if(!UniAtaAhciValidateVersion(deviceExtension, version, TRUE)) { goto exit_detect; }
deviceExtension->HwFlags |= UNIATA_SATA | UNIATA_AHCI; if(deviceExtension->NumberChannels < NumberChannels) { deviceExtension->NumberChannels = NumberChannels; } deviceExtension->DmaSegmentLength = 0x3fffff+1; // 4MB deviceExtension->DmaSegmentAlignmentMask = -1; // no restrictions
deviceExtension->BusMaster = DMA_MODE_AHCI; deviceExtension->MaxTransferMode = max(deviceExtension->MaxTransferMode, ATA_SA150+(((CAP & AHCI_CAP_ISS_MASK) >> 20)-1) );
found = TRUE;
exit_detect: UniataAhciWriteHostPort4(deviceExtension, IDX_AHCI_GHC, GHC0); KdPrint((" AHCI detect status %d\n", found));
return found;} // end UniataAhciDetect()
UCHARNTAPIUniataAhciStatus( IN PVOID HwDeviceExtension, IN ULONG lChannel, IN ULONG DeviceNumber ){ PHW_DEVICE_EXTENSION deviceExtension = (PHW_DEVICE_EXTENSION)HwDeviceExtension; PHW_CHANNEL chan = &deviceExtension->chan[lChannel]; ULONG Channel = deviceExtension->Channel + lChannel; ULONG hIS; ULONG CI, ACT; AHCI_IS_REG IS; SATA_SSTATUS_REG SStatus; SATA_SERROR_REG SError; //ULONG offs = sizeof(IDE_AHCI_REGISTERS) + Channel*sizeof(IDE_AHCI_PORT_REGISTERS); ULONG tag=0;
KdPrint(("UniataAhciStatus(%d-%d):\n", lChannel, Channel));
hIS = UniataAhciReadHostPort4(deviceExtension, IDX_AHCI_IS); KdPrint((" hIS %#x\n", hIS)); hIS &= (1 << Channel); if(!hIS) { return INTERRUPT_REASON_IGNORE; } IS.Reg = UniataAhciReadChannelPort4(chan, IDX_AHCI_P_IS); CI = UniataAhciReadChannelPort4(chan, IDX_AHCI_P_CI); ACT = UniataAhciReadChannelPort4(chan, IDX_AHCI_P_ACT); SStatus.Reg = AtapiReadPort4(chan, IDX_SATA_SStatus); SError.Reg = AtapiReadPort4(chan, IDX_SATA_SError);
/* clear interrupt(s) */ UniataAhciWriteHostPort4(deviceExtension, IDX_AHCI_IS, hIS); UniataAhciWriteChannelPort4(chan, IDX_AHCI_P_IS, IS.Reg); AtapiWritePort4(chan, IDX_SATA_SError, SError.Reg);
KdPrint((" AHCI: is=%08x ss=%08x serror=%08x CI=%08x, ACT=%08x\n", IS.Reg, SStatus.Reg, SError.Reg, CI, ACT));
/* do we have cold connect surprise */ if(IS.CPDS) { }
/* check for and handle connect events */ if(IS.PCS) { UniataSataEvent(HwDeviceExtension, lChannel, UNIATA_SATA_EVENT_ATTACH); } if(IS.PRCS) { UniataSataEvent(HwDeviceExtension, lChannel, UNIATA_SATA_EVENT_DETACH); } chan->AhciCompleteCI = (chan->AhciPrevCI ^ CI) & chan->AhciPrevCI; // only 1->0 states chan->AhciPrevCI = CI; chan->AhciLastSError = SError.Reg; KdPrint((" AHCI: complete mask %#x\n", chan->AhciCompleteCI)); chan->AhciLastIS = IS.Reg; if(CI & (1 << tag)) {#ifdef _DEBUG UniataDumpAhciPortRegs(chan);#endif //_DEBUG //deviceExtension->ExpectingInterrupt++; // will be updated in ISR on ReturnEnableInterrupts if(IS.Reg & (ATA_AHCI_P_IX_OF | ATA_AHCI_P_IX_INF | ATA_AHCI_P_IX_IF | ATA_AHCI_P_IX_HBD | ATA_AHCI_P_IX_HBF | ATA_AHCI_P_IX_TFE)) { KdPrint((" AHCI: unexpected, error\n")); } else { KdPrint((" AHCI: unexpected, incomplete command or error ?\n"));/* ULONG TFD;
TFD = UniataAhciReadChannelPort4(chan, IDX_AHCI_P_TFD); KdPrint2((" TFD %#x\n", TFD)); if(TFD & IDE_STATUS_BUSY) { KdPrint2((" Seems to be interrupt on error\n")); return INTERRUPT_REASON_OUR; }*/ return INTERRUPT_REASON_UNEXPECTED; } } return INTERRUPT_REASON_OUR;
} // end UniataAhciStatus()
VOIDNTAPIUniataAhciSnapAtaRegs( IN PHW_CHANNEL chan, IN ULONG DeviceNumber, IN OUT PIDEREGS_EX regs ){ ULONG TFD, SIG;
regs->bDriveHeadReg = IDE_DRIVE_SELECT_1; TFD = UniataAhciReadChannelPort4(chan, IDX_AHCI_P_TFD); regs->bCommandReg = (UCHAR)(TFD & 0xff); regs->bFeaturesReg = (UCHAR)((TFD >> 8) & 0xff);
SIG = UniataAhciReadChannelPort4(chan, IDX_AHCI_P_SIG); regs->bSectorCountReg = (UCHAR)(SIG & 0xff); regs->bSectorNumberReg = (UCHAR)((SIG >> 8) & 0xff); regs->bCylLowReg = (UCHAR)((SIG >> 16) & 0xff); regs->bCylHighReg = (UCHAR)((SIG >> 24) & 0xff); regs->bOpFlags = 0;
return;} // end UniataAhciSnapAtaRegs()
ULONGNTAPIUniataAhciSetupFIS_H2D( IN PHW_DEVICE_EXTENSION deviceExtension, IN ULONG DeviceNumber, IN ULONG lChannel, OUT PUCHAR fis, IN UCHAR command, IN ULONGLONG lba, IN USHORT count, IN USHORT feature ){ //ULONG i; PUCHAR plba; BOOLEAN need48; PHW_CHANNEL chan = &deviceExtension->chan[lChannel];
KdPrint2((PRINT_PREFIX " AHCI setup FIS %x, ch %d, dev %d\n", fis, lChannel, DeviceNumber)); //i = 0; plba = (PUCHAR)&lba;
RtlZeroMemory(fis, 20);
fis[0] = AHCI_FIS_TYPE_ATA_H2D; /* host to device */ fis[1] = 0x80 | ((UCHAR)DeviceNumber & 0x0f); /* command FIS (note PM goes here) */ fis[IDX_AHCI_o_DriveSelect] = IDE_DRIVE_SELECT_1 | ((AtaCommandFlags[command] & (ATA_CMD_FLAG_LBAIOsupp | ATA_CMD_FLAG_48)) ? IDE_USE_LBA : 0); fis[IDX_AHCI_o_Control] = IDE_DC_A_4BIT;
// IDE_COMMAND_ATAPI_IDENTIFY should be processed as regular ATA command, // the rest of ATAPI requests are processed via IDE_COMMAND_ATAPI_PACKET if(/*(chan->lun[DeviceNumber]->DeviceFlags & DFLAGS_ATAPI_DEVICE) && */ command == IDE_COMMAND_ATAPI_PACKET) { fis[IDX_AHCI_o_Command] = IDE_COMMAND_ATAPI_PACKET; if(feature & ATA_F_DMA) { fis[IDX_AHCI_o_Feature] = (UCHAR)(feature & 0xff); } else { fis[IDX_AHCI_o_CylinderLow] = (UCHAR)(count & 0xff); fis[IDX_AHCI_o_CylinderHigh] = (UCHAR)(count>>8) & 0xff; } //fis[IDX_AHCI_o_Control] |= IDE_DC_A_4BIT; } else {
if(((AtaCommandFlags[command] & (ATA_CMD_FLAG_LBAIOsupp|ATA_CMD_FLAG_FUA)) == ATA_CMD_FLAG_LBAIOsupp) && CheckIfBadBlock(chan->lun[DeviceNumber], lba, count)) { KdPrint3((PRINT_PREFIX ": artificial bad block, lba %#I64x count %#x\n", lba, count)); return 0; }
need48 = UniAta_need_lba48(command, lba, count, chan->lun[DeviceNumber]->IdentifyData.FeaturesSupport.Address48);
/* translate command into 48bit version */ if(need48) { if(AtaCommandFlags[command] & ATA_CMD_FLAG_48supp) { command = AtaCommands48[command]; } else { KdPrint2((PRINT_PREFIX " unhandled LBA48 command\n")); return 0; } }
fis[IDX_AHCI_o_Command] = command; fis[IDX_AHCI_o_Feature] = (UCHAR)feature;
fis[IDX_AHCI_o_BlockNumber] = plba[0]; fis[IDX_AHCI_o_CylinderLow] = plba[1]; fis[IDX_AHCI_o_CylinderHigh] = plba[2];
fis[IDX_AHCI_o_BlockCount] = (UCHAR)count & 0xff;
if(need48) { //i++; fis[IDX_AHCI_o_Control] |= IDE_DC_USE_HOB;
fis[IDX_AHCI_o_BlockNumberExp] = plba[3]; fis[IDX_AHCI_o_CylinderLowExp] = plba[4]; fis[IDX_AHCI_o_CylinderHighExp] = plba[5];
fis[IDX_AHCI_o_BlockCountExp] = (UCHAR)(count>>8) & 0xff;
fis[IDX_AHCI_o_FeatureExp] = (UCHAR)(feature>>8) & 0xff;
chan->ChannelCtrlFlags |= CTRFLAGS_LBA48; } else { fis[IDX_AHCI_o_DriveSelect] |= /*IDE_DRIVE_1 |*/ (plba[3] & 0x0f); chan->ChannelCtrlFlags &= ~CTRFLAGS_LBA48; }
//fis[14] = 0x00;
}
//KdDump(fis, 20);
return 20;} // end UniataAhciSetupFIS_H2D()
ULONGNTAPIUniataAhciSetupFIS_H2D_Direct( IN PHW_DEVICE_EXTENSION deviceExtension, IN ULONG DeviceNumber, IN ULONG lChannel, OUT PUCHAR fis, IN PIDEREGS_EX regs ){ //ULONG i; //PUCHAR plba; BOOLEAN need48; PHW_CHANNEL chan = &deviceExtension->chan[lChannel]; UCHAR command;
command = regs->bCommandReg;
KdPrint2((PRINT_PREFIX " AHCI setup FIS Direct %x, ch %d, dev %d\n", fis, lChannel, DeviceNumber)); //i = 0; //plba = (PUCHAR)&lba;
RtlZeroMemory(fis, 20);
fis[0] = AHCI_FIS_TYPE_ATA_H2D; /* host to device */ fis[1] = 0x80 | ((UCHAR)DeviceNumber & 0x0f); /* command FIS (note PM goes here) */ fis[IDX_AHCI_o_DriveSelect] = IDE_DRIVE_SELECT_1 | ((AtaCommandFlags[command] & (ATA_CMD_FLAG_LBAIOsupp | ATA_CMD_FLAG_48)) ? IDE_USE_LBA : 0); fis[IDX_AHCI_o_Control] = IDE_DC_A_4BIT;
// IDE_COMMAND_ATAPI_IDENTIFY should be processed as regular ATA command, // the rest of ATAPI requests are processed via IDE_COMMAND_ATAPI_PACKET if(/*(chan->lun[DeviceNumber]->DeviceFlags & DFLAGS_ATAPI_DEVICE) && */ command == IDE_COMMAND_ATAPI_PACKET) {/* fis[IDX_AHCI_o_Command] = IDE_COMMAND_ATAPI_PACKET; if(feature & ATA_F_DMA) { fis[IDX_AHCI_o_Feature] = (UCHAR)(feature & 0xff); } else { fis[IDX_AHCI_o_CylinderLow] = (UCHAR)(count & 0xff); fis[IDX_AHCI_o_CylinderHigh] = (UCHAR)(count>>8) & 0xff; }*/ return 0; //fis[IDX_AHCI_o_Control] |= IDE_DC_A_4BIT; } else {
need48 = (regs->bOpFlags & ATA_FLAGS_48BIT_COMMAND) && chan->lun[DeviceNumber]->IdentifyData.FeaturesSupport.Address48;
/* translate command into 48bit version */ if(need48) { if(AtaCommandFlags[command] & ATA_CMD_FLAG_48supp) { command = AtaCommands48[command]; } else { KdPrint2((PRINT_PREFIX " unhandled LBA48 command\n")); return 0; } }
fis[IDX_AHCI_o_Command] = command; fis[IDX_AHCI_o_Feature] = regs->bFeaturesReg;
fis[IDX_AHCI_o_BlockNumber] = regs->bSectorNumberReg; fis[IDX_AHCI_o_CylinderLow] = regs->bCylLowReg; fis[IDX_AHCI_o_CylinderHigh] = regs->bCylHighReg;
fis[IDX_AHCI_o_BlockCount] = regs->bSectorCountReg;
if(need48) { //i++; fis[IDX_AHCI_o_Control] |= IDE_DC_USE_HOB;
fis[IDX_AHCI_o_BlockNumberExp] = regs->bSectorNumberRegH; fis[IDX_AHCI_o_CylinderLowExp] = regs->bCylLowRegH; fis[IDX_AHCI_o_CylinderHighExp] = regs->bCylHighRegH;
fis[IDX_AHCI_o_BlockCountExp] = regs->bSectorCountRegH;
fis[IDX_AHCI_o_FeatureExp] = regs->bFeaturesRegH;
chan->ChannelCtrlFlags |= CTRFLAGS_LBA48; } else { //fis[IDX_AHCI_o_DriveSelect] |= /*IDE_DRIVE_1 |*/ (plba[3] & 0x0f); chan->ChannelCtrlFlags &= ~CTRFLAGS_LBA48; } fis[IDX_AHCI_o_DriveSelect] |= regs->bDriveHeadReg & 0x0f; }
KdDump(fis, 20);
return 20;} // end UniataAhciSetupFIS_H2D_Direct()
UCHARNTAPIUniataAhciWaitCommandReady( IN PHW_CHANNEL chan, IN ULONG timeout ){ AHCI_IS_REG IS; //ULONG ACT; ULONG CI=0; ULONG i; ULONG SError; ULONG tag=0;
timeout *= 5;
for (i=0; i<timeout; i++) { CI = UniataAhciReadChannelPort4(chan, IDX_AHCI_P_CI); //ACT = UniataAhciReadChannelPort4(chan, IDX_AHCI_P_ACT); if (!(( CI >> tag) & 0x01)) { break; } IS.Reg = UniataAhciReadChannelPort4(chan, IDX_AHCI_P_IS); //KdPrint((" IS %#x\n", IS.Reg)); if(IS.Reg) { break; } SError = AtapiReadPort4(chan, IDX_SATA_SError); if(SError) { KdPrint((" AHCI: error %#x\n", SError)); i = timeout; break; } AtapiStallExecution(200); } KdPrint((" CI %#x\n", CI));
//SStatus.Reg = AtapiReadPort4(chan, IDX_SATA_SStatus); //SError.Reg = AtapiReadPort4(chan, IDX_SATA_SError);
/* clear interrupt(s) */ IS.Reg = UniataAhciReadChannelPort4(chan, IDX_AHCI_P_IS); KdPrint((" IS %#x\n", IS.Reg)); UniataAhciWriteChannelPort4(chan, IDX_AHCI_P_IS, IS.Reg);
if (timeout && (i >= timeout)) {#ifdef _DEBUG ULONG TFD;
SError = AtapiReadPort4(chan, IDX_SATA_SError); KdPrint((" AHCI: timeout, SError %#x\n", SError));
TFD = UniataAhciReadChannelPort4(chan, IDX_AHCI_P_TFD); KdPrint2((" TFD %#x\n", TFD));#endif //_DEBUG
return IDE_STATUS_WRONG; }
return IDE_STATUS_IDLE;} // end UniataAhciWaitCommandReady()
UCHARNTAPIUniataAhciSendCommand( IN PVOID HwDeviceExtension, IN ULONG lChannel, IN ULONG DeviceNumber, IN USHORT ahci_flags, IN ULONG timeout ){ PHW_DEVICE_EXTENSION deviceExtension = (PHW_DEVICE_EXTENSION)HwDeviceExtension; PHW_CHANNEL chan = &deviceExtension->chan[lChannel]; //ULONG Channel = deviceExtension->Channel + lChannel; //ULONG hIS; //ULONG SError; //SATA_SSTATUS_REG SStatus; //SATA_SERROR_REG SError; //ULONG offs = sizeof(IDE_AHCI_REGISTERS) + Channel*sizeof(IDE_AHCI_PORT_REGISTERS); //ULONGIO_PTR base; ULONG tag=0;
PIDE_AHCI_CMD_LIST AHCI_CL = &(chan->AhciCtlBlock->cmd_list[tag]);
KdPrint(("UniataAhciSendCommand: lChan %d\n", chan->lChannel));
AHCI_CL->prd_length = 0; //AHCI_CL->cmd_flags = (20 / sizeof(ULONG)) | ahci_flags | (DeviceNumber << 12); AHCI_CL->cmd_flags = UniAtaAhciAdjustIoFlags(0, ahci_flags, 20, DeviceNumber);
AHCI_CL->bytecount = 0; AHCI_CL->cmd_table_phys = chan->AHCI_CTL_PhAddr + FIELD_OFFSET(IDE_AHCI_CHANNEL_CTL_BLOCK, cmd); if(AHCI_CL->cmd_table_phys & AHCI_CMD_ALIGNEMENT_MASK) { KdPrint2((PRINT_PREFIX " AHCI CMD address is not aligned (mask %#x)\n", (ULONG)AHCI_CMD_ALIGNEMENT_MASK)); }
//UniataAhciWriteChannelPort4(chan, IDX_AHCI_P_ACT, 0x01 << tag); UniataAhciWriteChannelPort4(chan, IDX_AHCI_P_CI, 1 << tag);
return UniataAhciWaitCommandReady(chan, timeout);
} // end UniataAhciSendCommand()
UCHARNTAPIUniataAhciSendPIOCommand( IN PVOID HwDeviceExtension, IN ULONG lChannel, IN ULONG DeviceNumber, IN PSCSI_REQUEST_BLOCK Srb, IN PUCHAR data, IN ULONG length, /* bytes */ IN UCHAR command, IN ULONGLONG lba, IN USHORT bcount, /* block count, just ATA register */ IN USHORT feature, IN USHORT ahci_flags, IN ULONG wait_flags, IN ULONG timeout ){ PHW_DEVICE_EXTENSION deviceExtension = (PHW_DEVICE_EXTENSION)HwDeviceExtension; PHW_CHANNEL chan = &deviceExtension->chan[lChannel]; UCHAR statusByte; PATA_REQ AtaReq; ULONG fis_size; //ULONG tag=0; //PIDE_AHCI_CMD AHCI_CMD = &(chan->AhciCtlBlock->cmd); PIDE_AHCI_CMD AHCI_CMD = NULL;
//PIDE_AHCI_CMD_LIST AHCI_CL = &(chan->AhciCtlBlock->cmd_list[tag]);
KdPrint2((PRINT_PREFIX "UniataAhciSendPIOCommand: cntrlr %#x:%#x dev %#x, cmd %#x, lba %#I64x bcount %#x feature %#x, buff %#x, len %#x, WF %#x \n", deviceExtension->DevIndex, lChannel, DeviceNumber, command, lba, bcount, feature, data, length, wait_flags ));
if(length/DEV_BSIZE != bcount) { KdPrint((" length/DEV_BSIZE != bcount\n")); }
#ifdef _DEBUG //UniataDumpAhciPortRegs(chan);#endif // _DEBUG
if(!Srb) { Srb = BuildAhciInternalSrb(HwDeviceExtension, DeviceNumber, lChannel, data, length); if(!Srb) { KdPrint((" !Srb\n")); return IDE_STATUS_WRONG; } //UniataAhciSetupCmdPtr(AtaReq); // must be called before DMA setup //should be already called on init } AtaReq = (PATA_REQ)(Srb->SrbExtension); //KdPrint((" Srb %#x, AtaReq %#x\n", Srb, AtaReq));
AHCI_CMD = AtaReq->ahci.ahci_cmd_ptr;
fis_size = UniataAhciSetupFIS_H2D(deviceExtension, DeviceNumber, lChannel, &(AHCI_CMD->cfis[0]), command, lba, bcount, feature );
if(!fis_size) { KdPrint2(("!fis_size\n")); return IDE_STATUS_WRONG; }
//KdPrint2(("UniAtaAhciAdjustIoFlags(command, ahci_flags, fis_size, DeviceNumber)\n")); ahci_flags = UniAtaAhciAdjustIoFlags(command, ahci_flags, fis_size, DeviceNumber); KdPrint2(("ahci_flags %#x\n", ahci_flags));
if(data) { if(ahci_flags & ATA_AHCI_CMD_WRITE) { AtaReq->Flags &= ~REQ_FLAG_READ; Srb->SrbFlags |= SRB_FLAGS_DATA_OUT; KdPrint((" assume OUT\n")); } else { AtaReq->Flags |= REQ_FLAG_READ; Srb->SrbFlags |= SRB_FLAGS_DATA_IN; KdPrint((" assume IN\n")); } if(!AtapiDmaSetup(HwDeviceExtension, DeviceNumber, lChannel, // logical channel, Srb, data, length)) { KdPrint2((" can't setup buffer\n")); return IDE_STATUS_WRONG; } }
AtaReq->ahci.io_cmd_flags = ahci_flags;
#ifdef _DEBUG //UniataDumpAhciPortRegs(chan);#endif // _DEBUG
UniataAhciBeginTransaction(HwDeviceExtension, lChannel, DeviceNumber, Srb);
#ifdef _DEBUG //UniataDumpAhciPortRegs(chan);#endif // _DEBUG
if(wait_flags == ATA_IMMEDIATE) { statusByte = 0; KdPrint2((" return imemdiately\n")); } else { statusByte = UniataAhciWaitCommandReady(chan, timeout); UniataAhciStatus(HwDeviceExtension, lChannel, DeviceNumber); UniataAhciEndTransaction(HwDeviceExtension, lChannel, DeviceNumber, Srb); }
return statusByte;
} // end UniataAhciSendPIOCommand()
UCHARNTAPIUniataAhciSendPIOCommandDirect( IN PVOID HwDeviceExtension, IN ULONG lChannel, IN ULONG DeviceNumber, IN PSCSI_REQUEST_BLOCK Srb, IN PIDEREGS_EX regs, IN ULONG wait_flags, IN ULONG timeout ){ PHW_DEVICE_EXTENSION deviceExtension = (PHW_DEVICE_EXTENSION)HwDeviceExtension; PHW_CHANNEL chan = &deviceExtension->chan[lChannel]; UCHAR statusByte; PATA_REQ AtaReq; ULONG fis_size; //ULONG tag=0; //PIDE_AHCI_CMD AHCI_CMD = &(chan->AhciCtlBlock->cmd); PIDE_AHCI_CMD AHCI_CMD = NULL; USHORT ahci_flags=0;// USHORT bcount=0;
//PIDE_AHCI_CMD_LIST AHCI_CL = &(chan->AhciCtlBlock->cmd_list[tag]);
KdPrint2((PRINT_PREFIX "UniataAhciSendPIOCommand: cntrlr %#x:%#x dev %#x, buff %#x, len %#x, WF %#x \n", deviceExtension->DevIndex, lChannel, DeviceNumber, Srb->DataBuffer, Srb->DataTransferLength, wait_flags ));
// if(Srb->DataTransferLength/DEV_BSIZE != bcount) {// KdPrint((" length/DEV_BSIZE != bcount\n"));// }
#ifdef _DEBUG //UniataDumpAhciPortRegs(chan);#endif // _DEBUG
if(!Srb) { KdPrint((" !Srb\n")); return IDE_STATUS_WRONG; //UniataAhciSetupCmdPtr(AtaReq); // must be called before DMA setup //should be already called on init } AtaReq = (PATA_REQ)(Srb->SrbExtension); //KdPrint((" Srb %#x, AtaReq %#x\n", Srb, AtaReq));
AHCI_CMD = AtaReq->ahci.ahci_cmd_ptr; if(!AHCI_CMD) { KdPrint((" !AHCI_CMD\n")); return IDE_STATUS_WRONG; }
if(Srb->DataTransferLength) { if(Srb->SrbFlags & SRB_FLAGS_DATA_OUT) { ahci_flags |= ATA_AHCI_CMD_WRITE; AtaReq->Flags &= ~REQ_FLAG_READ; } else { AtaReq->Flags |= REQ_FLAG_READ; } }
fis_size = UniataAhciSetupFIS_H2D_Direct(deviceExtension, DeviceNumber, lChannel, &(AHCI_CMD->cfis[0]), regs);
if(!fis_size) { KdPrint2(("!fis_size\n")); return IDE_STATUS_WRONG; }
//KdPrint2(("UniAtaAhciAdjustIoFlags(command, ahci_flags, fis_size, DeviceNumber)\n")); ahci_flags = UniAtaAhciAdjustIoFlags(regs->bCommandReg, ahci_flags, fis_size, DeviceNumber); KdPrint2(("ahci_flags %#x\n", ahci_flags));
if(Srb->DataTransferLength) { if(!AtapiDmaSetup(HwDeviceExtension, DeviceNumber, lChannel, // logical channel, Srb, (PUCHAR)(Srb->DataBuffer), Srb->DataTransferLength)) { KdPrint2((" can't setup buffer\n")); return IDE_STATUS_WRONG; } }
AtaReq->ahci.io_cmd_flags = ahci_flags;
#ifdef _DEBUG //UniataDumpAhciPortRegs(chan);#endif // _DEBUG
UniataAhciBeginTransaction(HwDeviceExtension, lChannel, DeviceNumber, Srb);
#ifdef _DEBUG //UniataDumpAhciPortRegs(chan);#endif // _DEBUG
if(wait_flags == ATA_IMMEDIATE) { statusByte = 0; KdPrint2((" return imemdiately\n")); } else { statusByte = UniataAhciWaitCommandReady(chan, timeout); UniataAhciStatus(HwDeviceExtension, lChannel, DeviceNumber); UniataAhciEndTransaction(HwDeviceExtension, lChannel, DeviceNumber, Srb); }
return statusByte;
} // end UniataAhciSendPIOCommandDirect()
BOOLEANNTAPIUniataAhciAbortOperation( IN PHW_CHANNEL chan ){ /* kick controller into sane state */ if(!UniataAhciStop(chan)) { return FALSE; } if(!UniataAhciStopFR(chan)) { return FALSE; } if(!UniataAhciCLO(chan)) { return FALSE; } UniataAhciStartFR(chan); UniataAhciStart(chan);
return TRUE;} // end UniataAhciAbortOperation()
ULONGNTAPIUniataAhciSoftReset( IN PVOID HwDeviceExtension, IN ULONG lChannel, IN ULONG DeviceNumber ){ PHW_DEVICE_EXTENSION deviceExtension = (PHW_DEVICE_EXTENSION)HwDeviceExtension; PHW_CHANNEL chan = &deviceExtension->chan[lChannel]; //ULONG Channel = deviceExtension->Channel + lChannel; //ULONG hIS; //ULONG CI; //AHCI_IS_REG IS; //ULONG tag=0;
KdPrint(("UniataAhciSoftReset: lChan %d\n", chan->lChannel));
PIDE_AHCI_CMD AHCI_CMD = &(chan->AhciCtlBlock->cmd); PUCHAR RCV_FIS = &(chan->AhciCtlBlock->rcv_fis.rfis[0]);
/* kick controller into sane state */ if(!UniataAhciAbortOperation(chan)) { KdPrint2((" abort failed\n")); return (ULONG)(-1); }
/* pull reset active */ RtlZeroMemory(AHCI_CMD->cfis, sizeof(AHCI_CMD->cfis)); AHCI_CMD->cfis[0] = AHCI_FIS_TYPE_ATA_H2D; AHCI_CMD->cfis[1] = (UCHAR)DeviceNumber & 0x0f; //AHCI_CMD->cfis[7] = IDE_USE_LBA | IDE_DRIVE_SELECT; AHCI_CMD->cfis[15] = (IDE_DC_A_4BIT | IDE_DC_RESET_CONTROLLER);
if(UniataAhciSendCommand(HwDeviceExtension, lChannel, DeviceNumber, ATA_AHCI_CMD_RESET | ATA_AHCI_CMD_CLR_BUSY, 100) == IDE_STATUS_WRONG) { KdPrint2((" timeout\n")); return (ULONG)(-1); } AtapiStallExecution(50);
/* pull reset inactive */ RtlZeroMemory(AHCI_CMD->cfis, sizeof(AHCI_CMD->cfis)); AHCI_CMD->cfis[0] = AHCI_FIS_TYPE_ATA_H2D; AHCI_CMD->cfis[1] = (UCHAR)DeviceNumber & 0x0f; //AHCI_CMD->cfis[7] = IDE_USE_LBA | IDE_DRIVE_SELECT; AHCI_CMD->cfis[15] = (IDE_DC_A_4BIT); if(UniataAhciSendCommand(HwDeviceExtension, lChannel, DeviceNumber, 0, 3000) == IDE_STATUS_WRONG) { KdPrint2((" timeout (2)\n")); return (ULONG)(-1); }
UniataAhciWaitReady(chan, 1);
KdDump(RCV_FIS, sizeof(chan->AhciCtlBlock->rcv_fis.rfis));
if(deviceExtension->HwFlags & UNIATA_AHCI_ALT_SIG) { ULONG signature; signature = UniataAhciReadChannelPort4(chan, IDX_AHCI_P_SIG); KdPrint((" alt sig: %#x\n", signature)); return signature; }
return UniataAhciUlongFromRFIS(RCV_FIS);
} // end UniataAhciSoftReset()
ULONGNTAPIUniataAhciWaitReady( IN PHW_CHANNEL chan, IN ULONG timeout ){ ULONG TFD; ULONG i;
KdPrint2(("UniataAhciWaitReady: lChan %d\n", chan->lChannel));
//base = (ULONGIO_PTR)(&deviceExtension->BaseIoAHCI_0 + offs);
TFD = UniataAhciReadChannelPort4(chan, IDX_AHCI_P_TFD); for(i=0; i<timeout && (TFD & (IDE_STATUS_DRQ | IDE_STATUS_BUSY)); i++) { AtapiStallExecution(1000); TFD = UniataAhciReadChannelPort4(chan, IDX_AHCI_P_TFD); }
KdPrint2((" TFD %#x\n", TFD));
return TFD;
} // end UniataAhciWaitReady()
ULONGNTAPIUniataAhciHardReset( IN PVOID HwDeviceExtension, IN ULONG lChannel, OUT PULONG signature ){ PHW_DEVICE_EXTENSION deviceExtension = (PHW_DEVICE_EXTENSION)HwDeviceExtension; PHW_CHANNEL chan = &deviceExtension->chan[lChannel]; //ULONG Channel = deviceExtension->Channel + lChannel; ULONG TFD;
KdPrint(("UniataAhciHardReset: lChan %d\n", chan->lChannel));
(*signature) = 0xffffffff;
UniataAhciStop(chan); if(UniataSataPhyEnable(HwDeviceExtension, lChannel, 0/* dev0*/, UNIATA_SATA_RESET_ENABLE) == IDE_STATUS_WRONG) { KdPrint((" no PHY\n")); return IDE_STATUS_WRONG; }
/* Wait for clearing busy status. */ TFD = UniataAhciWaitReady(chan, 15000); if(TFD & (IDE_STATUS_DRQ | IDE_STATUS_BUSY)) { KdPrint((" busy: TFD %#x\n", TFD)); return TFD; } KdPrint((" TFD %#x\n", TFD));
#ifdef _DEBUG UniataDumpAhciPortRegs(chan);#endif // _DEBUG
(*signature) = UniataAhciReadChannelPort4(chan, IDX_AHCI_P_SIG); KdPrint((" sig: %#x\n", *signature));
UniataAhciStart(chan);
return 0;
} // end UniataAhciHardReset()
VOIDNTAPIUniataAhciReset( IN PVOID HwDeviceExtension, IN ULONG lChannel ){ PHW_DEVICE_EXTENSION deviceExtension = (PHW_DEVICE_EXTENSION)HwDeviceExtension; PHW_CHANNEL chan = &deviceExtension->chan[lChannel]; //ULONG Channel = deviceExtension->Channel + lChannel; //ULONG offs = sizeof(IDE_AHCI_REGISTERS) + Channel*sizeof(IDE_AHCI_PORT_REGISTERS); ULONG CAP; //ULONGIO_PTR base; ULONG signature; ULONG i; ULONG VendorID = deviceExtension->DevID & 0xffff;
KdPrint(("UniataAhciReset: lChan %d\n", chan->lChannel));
//base = (ULONGIO_PTR)(&deviceExtension->BaseIoAHCI_0 + offs);
/* Disable port interrupts */ UniataAhciWriteChannelPort4(chan, IDX_AHCI_P_IE, 0);
if(UniataAhciHardReset(HwDeviceExtension, lChannel, &signature)) {
KdPrint((" No devices in all LUNs\n")); for (i=0; i<deviceExtension->NumberLuns; i++) { // Zero device fields to ensure that if earlier devices were found, // but not claimed, the fields are cleared. UniataForgetDevice(chan->lun[i]); }
/* enable wanted port interrupts */ UniataAhciWriteChannelPort4(chan, IDX_AHCI_P_IE, ATA_AHCI_P_IX_CPD | ATA_AHCI_P_IX_PRC | ATA_AHCI_P_IX_PC); return; }
/* enable wanted port interrupts */ UniataAhciWriteChannelPort4(chan, IDX_AHCI_P_IE, (ATA_AHCI_P_IX_CPD | ATA_AHCI_P_IX_TFE | ATA_AHCI_P_IX_HBF | ATA_AHCI_P_IX_HBD | ATA_AHCI_P_IX_IF | ATA_AHCI_P_IX_OF | ((/*ch->pm_level == */0) ? (ATA_AHCI_P_IX_PRC | ATA_AHCI_P_IX_PC) : 0) | ATA_AHCI_P_IX_DP | ATA_AHCI_P_IX_UF | ATA_AHCI_P_IX_SDB | ATA_AHCI_P_IX_DS | ATA_AHCI_P_IX_PS | ATA_AHCI_P_IX_DHR) );
/* * Only probe for PortMultiplier if HW has support. * Ignore Marvell, which is not working, */ CAP = UniataAhciReadHostPort4(deviceExtension, IDX_AHCI_CAP); if ((CAP & AHCI_CAP_SPM) && (VendorID != ATA_MARVELL_ID)) { KdPrint((" check PM\n")); signature = UniataAhciSoftReset(HwDeviceExtension, lChannel, AHCI_DEV_SEL_PM); /* Workaround for some ATI chips, failing to soft-reset * when port multiplicator supported, but absent. * XXX: We can also check PxIS.IPMS==1 here to be sure. */ if (signature == 0xffffffff) { KdPrint((" re-check PM\n")); signature = UniataAhciSoftReset(HwDeviceExtension, lChannel, 0); } } else { signature = UniataAhciSoftReset(HwDeviceExtension, lChannel, 0); }
KdPrint((" signature %#x\n", signature)); chan->lun[0]->DeviceFlags &= ~(DFLAGS_ATAPI_DEVICE | DFLAGS_DEVICE_PRESENT | CTRFLAGS_AHCI_PM); switch (signature >> 16) { case 0x0000: KdPrint((" ATA dev\n")); chan->lun[0]->DeviceFlags |= DFLAGS_DEVICE_PRESENT; chan->PmLunMap = 0; break; case 0x9669: KdPrint((" PM\n")); if(deviceExtension->NumberLuns > 1) { chan->ChannelCtrlFlags |= CTRFLAGS_AHCI_PM; UniataSataIdentifyPM(chan); } else { KdPrint((" no PM supported (1 lun/chan)\n")); } break; case 0xeb14: KdPrint((" ATAPI dev\n")); chan->lun[0]->DeviceFlags |= (DFLAGS_ATAPI_DEVICE | DFLAGS_DEVICE_PRESENT); chan->PmLunMap = 0; break; default: /* SOS XXX */ KdPrint((" default to ATA ???\n")); chan->lun[0]->DeviceFlags |= DFLAGS_DEVICE_PRESENT; chan->PmLunMap = 0; }
return;
} // end UniataAhciReset()
VOIDNTAPIUniataAhciStartFR( IN PHW_CHANNEL chan ){ ULONG CMD;
KdPrint2(("UniataAhciStartFR: lChan %d\n", chan->lChannel));
CMD = UniataAhciReadChannelPort4(chan, IDX_AHCI_P_CMD); KdPrint2((" CMD %#x\n", CMD)); UniataAhciWriteChannelPort4(chan, IDX_AHCI_P_CMD, CMD | ATA_AHCI_P_CMD_FRE); UniataAhciReadChannelPort4(chan, IDX_AHCI_P_CMD); /* flush */
return;} // end UniataAhciStartFR()
BOOLEANNTAPIUniataAhciStopFR( IN PHW_CHANNEL chan ){ ULONG CMD; ULONG i;
KdPrint2(("UniataAhciStopFR: lChan %d\n", chan->lChannel));
CMD = UniataAhciReadChannelPort4(chan, IDX_AHCI_P_CMD); KdPrint2((" CMD %#x\n", CMD)); UniataAhciWriteChannelPort4(chan, IDX_AHCI_P_CMD, CMD & ~ATA_AHCI_P_CMD_FRE);
for(i=0; i<1000; i++) { CMD = UniataAhciReadChannelPort4(chan, IDX_AHCI_P_CMD); if(!(CMD & ATA_AHCI_P_CMD_FR)) { KdPrint2((" final CMD %#x\n", CMD)); return TRUE; } AtapiStallExecution(1000); } KdPrint2((" CMD %#x\n", CMD)); KdPrint((" SError %#x\n", AtapiReadPort4(chan, IDX_SATA_SError))); KdPrint2(("UniataAhciStopFR: timeout\n")); return FALSE;} // end UniataAhciStopFR()
VOIDNTAPIUniataAhciStart( IN PHW_CHANNEL chan ){ ULONG IS, CMD; SATA_SERROR_REG SError;
KdPrint2(("UniataAhciStart: lChan %d\n", chan->lChannel));
/* clear SATA error register */ SError.Reg = AtapiReadPort4(chan, IDX_SATA_SError);
/* clear any interrupts pending on this channel */ IS = UniataAhciReadChannelPort4(chan, IDX_AHCI_P_IS); UniataAhciWriteChannelPort4(chan, IDX_AHCI_P_IS, IS);
KdPrint2((" SError %#x, IS %#x\n", SError.Reg, IS));
CMD = UniataAhciReadChannelPort4(chan, IDX_AHCI_P_CMD); KdPrint2((" CMD %#x\n", CMD)); UniataAhciWriteChannelPort4(chan, IDX_AHCI_P_CMD, CMD | ATA_AHCI_P_CMD_ST | ((chan->ChannelCtrlFlags & CTRFLAGS_AHCI_PM) ? ATA_AHCI_P_CMD_PMA : 0)); UniataAhciReadChannelPort4(chan, IDX_AHCI_P_CMD); /* flush */
return;} // end UniataAhciStart()
BOOLEANNTAPIUniataAhciCLO( IN PHW_CHANNEL chan ){ //PHW_DEVICE_EXTENSION deviceExtension = (PHW_DEVICE_EXTENSION)HwDeviceExtension; //PHW_CHANNEL chan = &deviceExtension->chan[lChannel]; ULONG CAP, CMD; //SATA_SERROR_REG SError; ULONG i;
KdPrint2(("UniataAhciCLO: lChan %d\n", chan->lChannel));
/* issue Command List Override if supported */ //CAP = UniataAhciReadHostPort4(deviceExtension, IDX_AHCI_CAP); CAP = chan->DeviceExtension->AHCI_CAP; if(!(CAP & AHCI_CAP_SCLO)) { return TRUE; } KdPrint2((" send CLO\n")); CMD = UniataAhciReadChannelPort4(chan, IDX_AHCI_P_CMD); CMD |= ATA_AHCI_P_CMD_CLO; UniataAhciWriteChannelPort4(chan, IDX_AHCI_P_CMD, CMD);
for(i=0; i<1000; i++) { CMD = UniataAhciReadChannelPort4(chan, IDX_AHCI_P_CMD); if(!(CMD & ATA_AHCI_P_CMD_CLO)) { KdPrint2((" final CMD %#x\n", CMD)); return TRUE; } AtapiStallExecution(1000); } KdPrint2((" CMD %#x\n", CMD)); KdPrint2(("UniataAhciCLO: timeout\n")); return FALSE;} // end UniataAhciCLO()
BOOLEANNTAPIUniataAhciStop( IN PHW_CHANNEL chan ){ ULONG CMD; //SATA_SERROR_REG SError; ULONG i;
KdPrint2(("UniataAhciStop: lChan %d\n", chan->lChannel));
/* issue Command List Override if supported */ CMD = UniataAhciReadChannelPort4(chan, IDX_AHCI_P_CMD); CMD &= ~ATA_AHCI_P_CMD_ST; UniataAhciWriteChannelPort4(chan, IDX_AHCI_P_CMD, CMD);
for(i=0; i<1000; i++) { CMD = UniataAhciReadChannelPort4(chan, IDX_AHCI_P_CMD); if(!(CMD & ATA_AHCI_P_CMD_CR)) { KdPrint2((" final CMD %#x\n", CMD)); return TRUE; } AtapiStallExecution(1000); } KdPrint2((" CMD %#x\n", CMD)); KdPrint((" SError %#x\n", AtapiReadPort4(chan, IDX_SATA_SError))); KdPrint2(("UniataAhciStop: timeout\n")); return FALSE;} // end UniataAhciStop()
UCHARNTAPIUniataAhciBeginTransaction( IN PVOID HwDeviceExtension, IN ULONG lChannel, IN ULONG DeviceNumber, IN PSCSI_REQUEST_BLOCK Srb ){ PHW_DEVICE_EXTENSION deviceExtension = (PHW_DEVICE_EXTENSION)HwDeviceExtension; PHW_CHANNEL chan = &deviceExtension->chan[lChannel]; //ULONG Channel = deviceExtension->Channel + lChannel; //ULONG hIS; ULONG CMD, CMD0; //AHCI_IS_REG IS; PATA_REQ AtaReq = (PATA_REQ)(Srb->SrbExtension); //SATA_SSTATUS_REG SStatus; //SATA_SERROR_REG SError; //ULONG offs = sizeof(IDE_AHCI_REGISTERS) + Channel*sizeof(IDE_AHCI_PORT_REGISTERS); //ULONGIO_PTR base; ULONG tag=0; //ULONG i;
PIDE_AHCI_CMD_LIST AHCI_CL = &(chan->AhciCtlBlock->cmd_list[tag]);
KdPrint2(("UniataAhciBeginTransaction: lChan %d, AtaReq %#x\n", chan->lChannel, AtaReq));
if(Srb->DataTransferLength && (!AtaReq->dma_entries || AtaReq->dma_entries >= (USHORT)0xffff)) { KdPrint2(("UniataAhciBeginTransaction wrong DMA tab len %x\n", AtaReq->dma_entries)); return 0; }
AHCI_CL->prd_length = (USHORT)(AtaReq->dma_entries); AHCI_CL->cmd_flags = AtaReq->ahci.io_cmd_flags; AHCI_CL->bytecount = 0; if(AtaReq->ahci.ahci_base64) { KdPrint2((PRINT_PREFIX " AHCI AtaReq CMD %#x (ph %#x)\n", AtaReq->ahci.ahci_cmd_ptr, (ULONG)(AtaReq->ahci.ahci_base64))); AHCI_CL->cmd_table_phys = AtaReq->ahci.ahci_base64; } else if(AtaReq->ahci.ahci_cmd_ptr) { KdPrint2((PRINT_PREFIX " AHCI AtaReq->Chan CMD %#x (ph %#x) -> %#x (ph %#x)\n", AtaReq->ahci.ahci_cmd_ptr, (ULONG)(AtaReq->ahci.ahci_base64), &(chan->AhciCtlBlock->cmd), chan->AHCI_CTL_PhAddr + FIELD_OFFSET(IDE_AHCI_CHANNEL_CTL_BLOCK, cmd) )); RtlCopyMemory(&(chan->AhciCtlBlock->cmd), AtaReq->ahci.ahci_cmd_ptr, FIELD_OFFSET(IDE_AHCI_CMD, prd_tab)+AHCI_CL->prd_length*sizeof(IDE_AHCI_PRD_ENTRY)); AHCI_CL->cmd_table_phys = chan->AHCI_CTL_PhAddr + FIELD_OFFSET(IDE_AHCI_CHANNEL_CTL_BLOCK, cmd); } else { KdPrint2((PRINT_PREFIX " no AHCI CMD\n")); //AHCI_CL->cmd_table_phys = chan->AHCI_CTL_PhAddr + FIELD_OFFSET(IDE_AHCI_CHANNEL_CTL_BLOCK, cmd); return 0; } if(AHCI_CL->cmd_table_phys & AHCI_CMD_ALIGNEMENT_MASK) { KdPrint2((PRINT_PREFIX " AHCI CMD address is not aligned (mask %#x)\n", (ULONG)AHCI_CMD_ALIGNEMENT_MASK)); return 0; }
#ifdef _DEBUG KdPrint2((" prd_length %#x, flags %#x, base %I64x\n", AHCI_CL->prd_length, AHCI_CL->cmd_flags, AHCI_CL->cmd_table_phys));#endif // _DEBUG
CMD0 = CMD = UniataAhciReadChannelPort4(chan, IDX_AHCI_P_CMD); KdPrint2((" CMD %#x\n", CMD)); // switch controller to ATAPI mode for ATA_PACKET commands only if(ATAPI_DEVICE(chan, DeviceNumber) && AtaReq->ahci.ahci_cmd_ptr->cfis[2] == IDE_COMMAND_ATAPI_PACKET) { KdPrint2((" ATAPI\n")); CMD |= ATA_AHCI_P_CMD_ATAPI; KdDump(&(AtaReq->ahci.ahci_cmd_ptr->acmd), 16); } else { CMD &= ~ATA_AHCI_P_CMD_ATAPI; } if(CMD0 != CMD) { KdPrint2((" send CMD %#x, entries %#x\n", CMD, AHCI_CL->prd_length)); UniataAhciWriteChannelPort4(chan, IDX_AHCI_P_CMD, CMD); CMD0 = UniataAhciReadChannelPort4(chan, IDX_AHCI_P_CMD); /* flush */ }
/* issue command to controller */ //UniataAhciWriteChannelPort4(chan, IDX_AHCI_P_ACT, 0x01 << tag); // Used for NCQ KdPrint2((" Set CI\n")); UniataAhciWriteChannelPort4(chan, IDX_AHCI_P_CI, 0x01 << tag); chan->AhciPrevCI |= 0x01 << tag;
//CMD0 = CMD; CMD |= ATA_AHCI_P_CMD_ST | ((chan->ChannelCtrlFlags & CTRFLAGS_AHCI_PM) ? ATA_AHCI_P_CMD_PMA : 0); if(CMD != CMD0) { KdPrint2((" Send CMD START (%#x != %#x)\n", CMD, CMD0)); UniataAhciWriteChannelPort4(chan, IDX_AHCI_P_CMD, CMD); CMD0 = UniataAhciReadChannelPort4(chan, IDX_AHCI_P_CMD); /* flush */ } else { KdPrint2((" No CMD START, already active\n")); }
if(!ATAPI_DEVICE(chan, DeviceNumber)) { // TODO: check if we send ATAPI_RESET and wait for ready of so. if(AtaReq->ahci.ahci_cmd_ptr->cfis[2] == IDE_COMMAND_ATAPI_RESET) { ULONG TFD; ULONG i;
for(i=0; i<1000000; i++) { TFD = UniataAhciReadChannelPort4(chan, IDX_AHCI_P_TFD); if(!(TFD & IDE_STATUS_BUSY)) { break; } } if(TFD & IDE_STATUS_BUSY) { KdPrint2((" timeout\n")); } if(TFD & IDE_STATUS_ERROR) { KdPrint2((" ERROR %#x\n", (UCHAR)(TFD >> 8))); } AtaReq->ahci.in_status = TFD;
return IDE_STATUS_SUCCESS; } }
return IDE_STATUS_IDLE;
} // end UniataAhciBeginTransaction()
UCHARNTAPIUniataAhciEndTransaction( IN PVOID HwDeviceExtension, IN ULONG lChannel, IN ULONG DeviceNumber, IN PSCSI_REQUEST_BLOCK Srb ){ PHW_DEVICE_EXTENSION deviceExtension = (PHW_DEVICE_EXTENSION)HwDeviceExtension; PHW_CHANNEL chan = &deviceExtension->chan[lChannel]; //ULONG Channel = deviceExtension->Channel + lChannel; //ULONG hIS; ULONG CI, ACT; PATA_REQ AtaReq = (PATA_REQ)(Srb->SrbExtension); ULONG TFD; PUCHAR RCV_FIS = &(chan->AhciCtlBlock->rcv_fis.rfis[0]); ULONG tag=0; //ULONG i; PIDE_AHCI_CMD_LIST AHCI_CL = &(chan->AhciCtlBlock->cmd_list[tag]); //PHW_LU_EXTENSION LunExt;
KdPrint2(("UniataAhciEndTransaction: lChan %d\n", chan->lChannel));
//LunExt = chan->lun[DeviceNumber];
TFD = UniataAhciReadChannelPort4(chan, IDX_AHCI_P_TFD); KdPrint2((" TFD %#x\n", TFD));
if(TFD & IDE_STATUS_ERROR) { AtaReq->ahci.in_error = (UCHAR)(TFD >> 8); KdPrint2((" ERROR %#x\n", AtaReq->ahci.in_error)); } else { AtaReq->ahci.in_error = 0; } AtaReq->ahci.in_status = TFD;
//if (request->flags & ATA_R_CONTROL) {
AtaReq->ahci.in_bcount = (ULONG)(RCV_FIS[12]) | ((ULONG)(RCV_FIS[13]) << 8); AtaReq->ahci.in_lba = (ULONG)(RCV_FIS[4]) | ((ULONGLONG)(RCV_FIS[5]) << 8) | ((ULONGLONG)(RCV_FIS[6]) << 16); if(chan->ChannelCtrlFlags & CTRFLAGS_LBA48) { AtaReq->ahci.in_lba |= ((ULONGLONG)(RCV_FIS[8]) << 24) | ((ULONGLONG)(RCV_FIS[9]) << 32) | ((ULONGLONG)(RCV_FIS[10]) << 40); } else { AtaReq->ahci.in_lba |= ((ULONGLONG)(RCV_FIS[8]) << 24) | ((ULONGLONG)(RCV_FIS[9]) << 32) | ((ULONGLONG)(RCV_FIS[7] & 0x0f) << 24); } AtaReq->WordsTransfered = AHCI_CL->bytecount/2;
/* if(LunExt->DeviceFlags & DFLAGS_ATAPI_DEVICE) { KdPrint2(("RCV:\n")); KdDump(RCV_FIS, 24); KdPrint2(("PIO:\n")); KdDump(&(chan->AhciCtlBlock->rcv_fis.psfis[0]), 24);
KdPrint2(("len: %d vs %d\n", AHCI_CL->bytecount, (ULONG)RCV_FIS[5] | ((ULONG)RCV_FIS[6] << 8) )); if(!AHCI_CL->bytecount) { AtaReq->WordsTransfered = ((ULONG)RCV_FIS[5] | ((ULONG)RCV_FIS[6] << 8)) / 2; } }*/ ACT = UniataAhciReadChannelPort4(chan, IDX_AHCI_P_ACT); CI = UniataAhciReadChannelPort4(chan, IDX_AHCI_P_CI); if(CI & (1 << tag)) { // clear CI KdPrint2((" Incomplete command, CI %#x, ACT %#x\n", CI, ACT)); KdPrint2((" FIS status %#x, error %#x\n", RCV_FIS[2], RCV_FIS[3]));
#ifdef _DEBUG UniataDumpAhciPortRegs(chan);#endif if(!UniataAhciAbortOperation(chan)) { KdPrint2((" Abort failed, need RESET\n")); }#ifdef _DEBUG UniataDumpAhciPortRegs(chan);#endif chan->AhciPrevCI = CI & ~((ULONG)1 << tag); if(chan->AhciPrevCI) { KdPrint2((" Need command list restart, CI %#x\n", chan->AhciPrevCI)); } } else { chan->AhciPrevCI &= ~((ULONG)1 << tag); RtlZeroMemory(AHCI_CL, sizeof(IDE_AHCI_CMD_LIST)); } //}
return 0;
} // end UniataAhciEndTransaction()
VOIDNTAPIUniataAhciResume( IN PHW_CHANNEL chan ){ ULONGLONG base;
KdPrint2(("UniataAhciResume: lChan %d\n", chan->lChannel));
#ifdef _DEBUG //UniataDumpAhciPortRegs(chan);#endif // _DEBUG
/* Disable port interrupts */ UniataAhciWriteChannelPort4(chan, IDX_AHCI_P_IE, 0);
/* setup work areas */ base = chan->AHCI_CTL_PhAddr; if(!base) { KdPrint2((PRINT_PREFIX " AHCI buffer allocation failed\n")); return; } KdPrint2((PRINT_PREFIX " AHCI CLB setup\n")); if(base & AHCI_CLB_ALIGNEMENT_MASK) { KdPrint2((PRINT_PREFIX " AHCI CLB address is not aligned (mask %#x)\n", (ULONG)AHCI_FIS_ALIGNEMENT_MASK)); } UniataAhciWriteChannelPort4(chan, IDX_AHCI_P_CLB, (ULONG)(base & 0xffffffff)); UniataAhciWriteChannelPort4(chan, IDX_AHCI_P_CLB + 4, (ULONG)((base >> 32) & 0xffffffff));
KdPrint2((PRINT_PREFIX " AHCI RCV FIS setup\n")); base = chan->AHCI_CTL_PhAddr + FIELD_OFFSET(IDE_AHCI_CHANNEL_CTL_BLOCK, rcv_fis); if(base & AHCI_FIS_ALIGNEMENT_MASK) { KdPrint2((PRINT_PREFIX " AHCI FIS address is not aligned (mask %#x)\n", (ULONG)AHCI_FIS_ALIGNEMENT_MASK)); } UniataAhciWriteChannelPort4(chan, IDX_AHCI_P_FB, (ULONG)(base & 0xffffffff)); UniataAhciWriteChannelPort4(chan, IDX_AHCI_P_FB + 4, (ULONG)((base >> 32) & 0xffffffff));
/* activate the channel and power/spin up device */ UniataAhciWriteChannelPort4(chan, IDX_AHCI_P_CMD, (ATA_AHCI_P_CMD_ACTIVE | ATA_AHCI_P_CMD_POD | ATA_AHCI_P_CMD_SUD | (((chan->ChannelCtrlFlags & CTRFLAGS_AHCI_PM)) ? ATA_AHCI_P_CMD_ALPE : 0) | (((chan->ChannelCtrlFlags & CTRFLAGS_AHCI_PM2)) ? ATA_AHCI_P_CMD_ASP : 0 )) ); UniataAhciReadChannelPort4(chan, IDX_AHCI_P_CMD); /* flush */
#ifdef _DEBUG //UniataDumpAhciPortRegs(chan);#endif // _DEBUG
UniataAhciStartFR(chan); UniataAhciStart(chan);
#ifdef _DEBUG UniataDumpAhciPortRegs(chan);#endif // _DEBUG
return;} // end UniataAhciResume()
#if 0VOIDNTAPIUniataAhciSuspend( IN PHW_CHANNEL chan ){ ULONGLONG base; SATA_SCONTROL_REG SControl;
KdPrint2(("UniataAhciSuspend:\n"));
/* Disable port interrupts */ UniataAhciWriteChannelPort4(chan, IDX_AHCI_P_IE, 0);
/* Reset command register. */ UniataAhciStop(chan); UniataAhciStopFR(chan); UniataAhciWriteChannelPort4(chan, IDX_AHCI_P_CMD, 0); UniataAhciReadChannelPort4(chan, IDX_AHCI_P_CMD); /* flush */
/* Allow everything including partial and slumber modes. */ UniataSataWritePort4(chan, IDX_SATA_SControl, 0, 0);
/* Request slumber mode transition and give some time to get there. */ UniataAhciWriteChannelPort4(chan, IDX_AHCI_P_CMD, ATA_AHCI_P_CMD_SLUMBER); AtapiStallExecution(100);
/* Disable PHY. */ SControl.Reg = 0; SControl.DET = SStatus_DET_Offline; UniataSataWritePort4(chan, IDX_SATA_SControl, SControl.Reg, 0);
return;} // end UniataAhciSuspend()#endif
BOOLEANNTAPIUniataAhciReadPM( IN PHW_CHANNEL chan, IN ULONG DeviceNumber, IN ULONG Reg, OUT PULONG result ){ //ULONG Channel = deviceExtension->Channel + lChannel; //ULONG hIS; //ULONG CI; //AHCI_IS_REG IS; //ULONG tag=0; PIDE_AHCI_CMD AHCI_CMD = &(chan->AhciCtlBlock->cmd); PUCHAR RCV_FIS = &(chan->AhciCtlBlock->rcv_fis.rfis[0]);
KdPrint(("UniataAhciReadPM: lChan %d [%#x]\n", chan->lChannel, DeviceNumber));
if(DeviceNumber == DEVNUM_NOT_SPECIFIED) { (*result) = UniataSataReadPort4(chan, Reg, 0); return TRUE; } if(DeviceNumber < AHCI_DEV_SEL_PM) { switch(Reg) { case IDX_SATA_SStatus: Reg = 0; break; case IDX_SATA_SError: Reg = 1; break; case IDX_SATA_SControl: Reg = 2; break; default: return FALSE; } }
RtlZeroMemory(AHCI_CMD->cfis, sizeof(AHCI_CMD->cfis)); AHCI_CMD->cfis[0] = AHCI_FIS_TYPE_ATA_H2D; AHCI_CMD->cfis[1] = AHCI_FIS_COMM_PM; AHCI_CMD->cfis[2] = IDE_COMMAND_READ_PM; AHCI_CMD->cfis[3] = (UCHAR)Reg; AHCI_CMD->cfis[7] = (UCHAR)(IDE_USE_LBA | DeviceNumber); AHCI_CMD->cfis[15] = IDE_DC_A_4BIT;
if(UniataAhciSendCommand(chan->DeviceExtension, chan->lChannel, DeviceNumber, 0, 10) == IDE_STATUS_WRONG) { KdPrint2((" PM read failed\n")); return FALSE; }
KdDump(RCV_FIS, sizeof(chan->AhciCtlBlock->rcv_fis.rfis));
(*result) = UniataAhciUlongFromRFIS(RCV_FIS); return TRUE;
} // end UniataAhciReadPM()
UCHARNTAPIUniataAhciWritePM( IN PHW_CHANNEL chan, IN ULONG DeviceNumber, IN ULONG Reg, IN ULONG value ){ //ULONG Channel = deviceExtension->Channel + lChannel; //ULONG hIS; //ULONG CI; //AHCI_IS_REG IS; //ULONG tag=0; ULONG TFD; PIDE_AHCI_CMD AHCI_CMD = &(chan->AhciCtlBlock->cmd); //PUCHAR RCV_FIS = &(chan->AhciCtlBlock->rcv_fis.rfis[0]);
KdPrint(("UniataAhciWritePM: lChan %d [%#x] %#x\n", chan->lChannel, DeviceNumber, value));
if(DeviceNumber == DEVNUM_NOT_SPECIFIED) { UniataSataWritePort4(chan, Reg, value, 0); return 0; } if(DeviceNumber < AHCI_DEV_SEL_PM) { switch(Reg) { case IDX_SATA_SStatus: Reg = 0; break; case IDX_SATA_SError: Reg = 1; break; case IDX_SATA_SControl: Reg = 2; break; default: return IDE_STATUS_WRONG; } }
RtlZeroMemory(AHCI_CMD->cfis, sizeof(AHCI_CMD->cfis)); AHCI_CMD->cfis[0] = AHCI_FIS_TYPE_ATA_H2D; AHCI_CMD->cfis[1] = AHCI_FIS_COMM_PM; AHCI_CMD->cfis[2] = IDE_COMMAND_WRITE_PM; AHCI_CMD->cfis[3] = (UCHAR)Reg; AHCI_CMD->cfis[7] = (UCHAR)(IDE_USE_LBA | DeviceNumber);
AHCI_CMD->cfis[12] = (UCHAR)(value & 0xff); AHCI_CMD->cfis[4] = (UCHAR)((value >> 8) & 0xff); AHCI_CMD->cfis[5] = (UCHAR)((value >> 16) & 0xff); AHCI_CMD->cfis[6] = (UCHAR)((value >> 24) & 0xff);
AHCI_CMD->cfis[15] = IDE_DC_A_4BIT;
if(UniataAhciSendCommand(chan->DeviceExtension, chan->lChannel, DeviceNumber, 0, 100) == IDE_STATUS_WRONG) { KdPrint2((" PM write failed\n")); return IDE_STATUS_WRONG; }
TFD = UniataAhciReadChannelPort4(chan, IDX_AHCI_P_TFD);
if(TFD & IDE_STATUS_ERROR) { KdPrint2((" ERROR %#x\n", (UCHAR)(TFD >> 8))); } return (UCHAR)(TFD >> 8);
} // end UniataAhciWritePM()
VOIDUniataAhciSetupCmdPtr(IN OUT PATA_REQ AtaReq ){ union { PUCHAR prd_base; ULONGLONG prd_base64; }; union { PUCHAR prd_base0; ULONGLONG prd_base64_0; };#ifdef _DEBUG ULONG d;#endif // _DEBUG
prd_base64_0 = prd_base64 = 0; prd_base = (PUCHAR)(&AtaReq->ahci_cmd0); prd_base0 = prd_base;
prd_base64 = (prd_base64 + max(FIELD_OFFSET(ATA_REQ, ahci_cmd0), AHCI_CMD_ALIGNEMENT_MASK+1)) & ~AHCI_CMD_ALIGNEMENT_MASK;
#ifdef _DEBUG d = (ULONG)(prd_base64 - prd_base64_0); KdPrint2((PRINT_PREFIX " AtaReq %#x: cmd aligned %I64x, d=%x\n", AtaReq, prd_base64, d));#endif // _DEBUG
AtaReq->ahci.ahci_cmd_ptr = (PIDE_AHCI_CMD)prd_base64; KdPrint2((PRINT_PREFIX " ahci_cmd_ptr %#x\n", AtaReq->ahci.ahci_cmd_ptr));} // end UniataAhciSetupCmdPtr()
PSCSI_REQUEST_BLOCKNTAPIBuildAhciInternalSrb ( IN PVOID HwDeviceExtension, IN ULONG DeviceNumber, IN ULONG lChannel, IN PUCHAR Buffer, IN ULONG Length ){ PHW_DEVICE_EXTENSION deviceExtension = (PHW_DEVICE_EXTENSION)HwDeviceExtension; PHW_CHANNEL chan = &deviceExtension->chan[lChannel]; PSCSI_REQUEST_BLOCK srb;// PCDB cdb; PATA_REQ AtaReq = chan->AhciInternalAtaReq;
KdPrint(("BuildAhciInternalSrb: lChan %d [%#x]\n", lChannel, DeviceNumber));
if(!AtaReq) { KdPrint2((PRINT_PREFIX " !chan->AhciInternalAtaReq\n")); return NULL; }
//RtlZeroMemory((PCHAR) AtaReq, sizeof(ATA_REQ)); //RtlZeroMemory((PCHAR) AtaReq, FIELD_OFFSET(ATA_REQ, ahci)); UniAtaClearAtaReq(AtaReq);
srb = chan->AhciInternalSrb;
RtlZeroMemory((PCHAR) srb, sizeof(SCSI_REQUEST_BLOCK));
srb->PathId = (UCHAR)lChannel; srb->TargetId = (UCHAR)DeviceNumber; srb->Function = SRB_FUNCTION_EXECUTE_SCSI; srb->Length = sizeof(SCSI_REQUEST_BLOCK);
// Set flags to disable synchronous negociation. //srb->SrbFlags = SRB_FLAGS_DATA_IN | SRB_FLAGS_DISABLE_SYNCH_TRANSFER;
// Set timeout to 4 seconds. srb->TimeOutValue = 4;
srb->CdbLength = 6; srb->DataBuffer = Buffer; srb->DataTransferLength = Length; srb->SrbExtension = AtaReq;
AtaReq->Srb = srb; AtaReq->DataBuffer = (PUSHORT)Buffer; AtaReq->TransferLength = Length;
//if(!AtaReq->ahci.ahci_cmd_ptr) { //UniataAhciSetupCmdPtr(AtaReq); //AtaReq->ahci.ahci_cmd_ptr = &(chan->AhciCtlBlock->cmd); //AtaReq->ahci.ahci_base64 = chan->AHCI_CTL_PhAddr + FIELD_OFFSET(IDE_AHCI_CHANNEL_CTL_BLOCK, cmd); //} //AtaReq->ahci.ahci_cmd_ptr = &(AtaReq->ahci_cmd0); //AtaReq->ahci.ahci_base64 = NULL; // indicate that we should copy command to proper place
KdPrint2((PRINT_PREFIX " Srb %#x, AtaReq %#x, CMD %#x ph %I64x\n", srb, AtaReq, AtaReq->ahci.ahci_cmd_ptr, AtaReq->ahci.ahci_base64));
/* // Set CDB operation code. cdb = (PCDB)srb->Cdb; cdb->CDB6INQUIRY.OperationCode = SCSIOP_REQUEST_SENSE; cdb->CDB6INQUIRY.AllocationLength = sizeof(SENSE_DATA);*/ return srb;} // end BuildAhciInternalSrb()