mpt3sas_scsih.c 230 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150215121522153215421552156215721582159216021612162216321642165216621672168216921702171217221732174217521762177217821792180218121822183218421852186218721882189219021912192219321942195219621972198219922002201220222032204220522062207220822092210221122122213221422152216221722182219222022212222222322242225222622272228222922302231223222332234223522362237223822392240224122422243224422452246224722482249225022512252225322542255225622572258225922602261226222632264226522662267226822692270227122722273227422752276227722782279228022812282228322842285228622872288228922902291229222932294229522962297229822992300230123022303230423052306230723082309231023112312231323142315231623172318231923202321232223232324232523262327232823292330233123322333233423352336233723382339234023412342234323442345234623472348234923502351235223532354235523562357235823592360236123622363236423652366236723682369237023712372237323742375237623772378237923802381238223832384238523862387238823892390239123922393239423952396239723982399240024012402240324042405240624072408240924102411241224132414241524162417241824192420242124222423242424252426242724282429243024312432243324342435243624372438243924402441244224432444244524462447244824492450245124522453245424552456245724582459246024612462246324642465246624672468246924702471247224732474247524762477247824792480248124822483248424852486248724882489249024912492249324942495249624972498249925002501250225032504250525062507250825092510251125122513251425152516251725182519252025212522252325242525252625272528252925302531253225332534253525362537253825392540254125422543254425452546254725482549255025512552255325542555255625572558255925602561256225632564256525662567256825692570257125722573257425752576257725782579258025812582258325842585258625872588258925902591259225932594259525962597259825992600260126022603260426052606260726082609261026112612261326142615261626172618261926202621262226232624262526262627262826292630263126322633263426352636263726382639264026412642264326442645264626472648264926502651265226532654265526562657265826592660266126622663266426652666266726682669267026712672267326742675267626772678267926802681268226832684268526862687268826892690269126922693269426952696269726982699270027012702270327042705270627072708270927102711271227132714271527162717271827192720272127222723272427252726272727282729273027312732273327342735273627372738273927402741274227432744274527462747274827492750275127522753275427552756275727582759276027612762276327642765276627672768276927702771277227732774277527762777277827792780278127822783278427852786278727882789279027912792279327942795279627972798279928002801280228032804280528062807280828092810281128122813281428152816281728182819282028212822282328242825282628272828282928302831283228332834283528362837283828392840284128422843284428452846284728482849285028512852285328542855285628572858285928602861286228632864286528662867286828692870287128722873287428752876287728782879288028812882288328842885288628872888288928902891289228932894289528962897289828992900290129022903290429052906290729082909291029112912291329142915291629172918291929202921292229232924292529262927292829292930293129322933293429352936293729382939294029412942294329442945294629472948294929502951295229532954295529562957295829592960296129622963296429652966296729682969297029712972297329742975297629772978297929802981298229832984298529862987298829892990299129922993299429952996299729982999300030013002300330043005300630073008300930103011301230133014301530163017301830193020302130223023302430253026302730283029303030313032303330343035303630373038303930403041304230433044304530463047304830493050305130523053305430553056305730583059306030613062306330643065306630673068306930703071307230733074307530763077307830793080308130823083308430853086308730883089309030913092309330943095309630973098309931003101310231033104310531063107310831093110311131123113311431153116311731183119312031213122312331243125312631273128312931303131313231333134313531363137313831393140314131423143314431453146314731483149315031513152315331543155315631573158315931603161316231633164316531663167316831693170317131723173317431753176317731783179318031813182318331843185318631873188318931903191319231933194319531963197319831993200320132023203320432053206320732083209321032113212321332143215321632173218321932203221322232233224322532263227322832293230323132323233323432353236323732383239324032413242324332443245324632473248324932503251325232533254325532563257325832593260326132623263326432653266326732683269327032713272327332743275327632773278327932803281328232833284328532863287328832893290329132923293329432953296329732983299330033013302330333043305330633073308330933103311331233133314331533163317331833193320332133223323332433253326332733283329333033313332333333343335333633373338333933403341334233433344334533463347334833493350335133523353335433553356335733583359336033613362336333643365336633673368336933703371337233733374337533763377337833793380338133823383338433853386338733883389339033913392339333943395339633973398339934003401340234033404340534063407340834093410341134123413341434153416341734183419342034213422342334243425342634273428342934303431343234333434343534363437343834393440344134423443344434453446344734483449345034513452345334543455345634573458345934603461346234633464346534663467346834693470347134723473347434753476347734783479348034813482348334843485348634873488348934903491349234933494349534963497349834993500350135023503350435053506350735083509351035113512351335143515351635173518351935203521352235233524352535263527352835293530353135323533353435353536353735383539354035413542354335443545354635473548354935503551355235533554355535563557355835593560356135623563356435653566356735683569357035713572357335743575357635773578357935803581358235833584358535863587358835893590359135923593359435953596359735983599360036013602360336043605360636073608360936103611361236133614361536163617361836193620362136223623362436253626362736283629363036313632363336343635363636373638363936403641364236433644364536463647364836493650365136523653365436553656365736583659366036613662366336643665366636673668366936703671367236733674367536763677367836793680368136823683368436853686368736883689369036913692369336943695369636973698369937003701370237033704370537063707370837093710371137123713371437153716371737183719372037213722372337243725372637273728372937303731373237333734373537363737373837393740374137423743374437453746374737483749375037513752375337543755375637573758375937603761376237633764376537663767376837693770377137723773377437753776377737783779378037813782378337843785378637873788378937903791379237933794379537963797379837993800380138023803380438053806380738083809381038113812381338143815381638173818381938203821382238233824382538263827382838293830383138323833383438353836383738383839384038413842384338443845384638473848384938503851385238533854385538563857385838593860386138623863386438653866386738683869387038713872387338743875387638773878387938803881388238833884388538863887388838893890389138923893389438953896389738983899390039013902390339043905390639073908390939103911391239133914391539163917391839193920392139223923392439253926392739283929393039313932393339343935393639373938393939403941394239433944394539463947394839493950395139523953395439553956395739583959396039613962396339643965396639673968396939703971397239733974397539763977397839793980398139823983398439853986398739883989399039913992399339943995399639973998399940004001400240034004400540064007400840094010401140124013401440154016401740184019402040214022402340244025402640274028402940304031403240334034403540364037403840394040404140424043404440454046404740484049405040514052405340544055405640574058405940604061406240634064406540664067406840694070407140724073407440754076407740784079408040814082408340844085408640874088408940904091409240934094409540964097409840994100410141024103410441054106410741084109411041114112411341144115411641174118411941204121412241234124412541264127412841294130413141324133413441354136413741384139414041414142414341444145414641474148414941504151415241534154415541564157415841594160416141624163416441654166416741684169417041714172417341744175417641774178417941804181418241834184418541864187418841894190419141924193419441954196419741984199420042014202420342044205420642074208420942104211421242134214421542164217421842194220422142224223422442254226422742284229423042314232423342344235423642374238423942404241424242434244424542464247424842494250425142524253425442554256425742584259426042614262426342644265426642674268426942704271427242734274427542764277427842794280428142824283428442854286428742884289429042914292429342944295429642974298429943004301430243034304430543064307430843094310431143124313431443154316431743184319432043214322432343244325432643274328432943304331433243334334433543364337433843394340434143424343434443454346434743484349435043514352435343544355435643574358435943604361436243634364436543664367436843694370437143724373437443754376437743784379438043814382438343844385438643874388438943904391439243934394439543964397439843994400440144024403440444054406440744084409441044114412441344144415441644174418441944204421442244234424442544264427442844294430443144324433443444354436443744384439444044414442444344444445444644474448444944504451445244534454445544564457445844594460446144624463446444654466446744684469447044714472447344744475447644774478447944804481448244834484448544864487448844894490449144924493449444954496449744984499450045014502450345044505450645074508450945104511451245134514451545164517451845194520452145224523452445254526452745284529453045314532453345344535453645374538453945404541454245434544454545464547454845494550455145524553455445554556455745584559456045614562456345644565456645674568456945704571457245734574457545764577457845794580458145824583458445854586458745884589459045914592459345944595459645974598459946004601460246034604460546064607460846094610461146124613461446154616461746184619462046214622462346244625462646274628462946304631463246334634463546364637463846394640464146424643464446454646464746484649465046514652465346544655465646574658465946604661466246634664466546664667466846694670467146724673467446754676467746784679468046814682468346844685468646874688468946904691469246934694469546964697469846994700470147024703470447054706470747084709471047114712471347144715471647174718471947204721472247234724472547264727472847294730473147324733473447354736473747384739474047414742474347444745474647474748474947504751475247534754475547564757475847594760476147624763476447654766476747684769477047714772477347744775477647774778477947804781478247834784478547864787478847894790479147924793479447954796479747984799480048014802480348044805480648074808480948104811481248134814481548164817481848194820482148224823482448254826482748284829483048314832483348344835483648374838483948404841484248434844484548464847484848494850485148524853485448554856485748584859486048614862486348644865486648674868486948704871487248734874487548764877487848794880488148824883488448854886488748884889489048914892489348944895489648974898489949004901490249034904490549064907490849094910491149124913491449154916491749184919492049214922492349244925492649274928492949304931493249334934493549364937493849394940494149424943494449454946494749484949495049514952495349544955495649574958495949604961496249634964496549664967496849694970497149724973497449754976497749784979498049814982498349844985498649874988498949904991499249934994499549964997499849995000500150025003500450055006500750085009501050115012501350145015501650175018501950205021502250235024502550265027502850295030503150325033503450355036503750385039504050415042504350445045504650475048504950505051505250535054505550565057505850595060506150625063506450655066506750685069507050715072507350745075507650775078507950805081508250835084508550865087508850895090509150925093509450955096509750985099510051015102510351045105510651075108510951105111511251135114511551165117511851195120512151225123512451255126512751285129513051315132513351345135513651375138513951405141514251435144514551465147514851495150515151525153515451555156515751585159516051615162516351645165516651675168516951705171517251735174517551765177517851795180518151825183518451855186518751885189519051915192519351945195519651975198519952005201520252035204520552065207520852095210521152125213521452155216521752185219522052215222522352245225522652275228522952305231523252335234523552365237523852395240524152425243524452455246524752485249525052515252525352545255525652575258525952605261526252635264526552665267526852695270527152725273527452755276527752785279528052815282528352845285528652875288528952905291529252935294529552965297529852995300530153025303530453055306530753085309531053115312531353145315531653175318531953205321532253235324532553265327532853295330533153325333533453355336533753385339534053415342534353445345534653475348534953505351535253535354535553565357535853595360536153625363536453655366536753685369537053715372537353745375537653775378537953805381538253835384538553865387538853895390539153925393539453955396539753985399540054015402540354045405540654075408540954105411541254135414541554165417541854195420542154225423542454255426542754285429543054315432543354345435543654375438543954405441544254435444544554465447544854495450545154525453545454555456545754585459546054615462546354645465546654675468546954705471547254735474547554765477547854795480548154825483548454855486548754885489549054915492549354945495549654975498549955005501550255035504550555065507550855095510551155125513551455155516551755185519552055215522552355245525552655275528552955305531553255335534553555365537553855395540554155425543554455455546554755485549555055515552555355545555555655575558555955605561556255635564556555665567556855695570557155725573557455755576557755785579558055815582558355845585558655875588558955905591559255935594559555965597559855995600560156025603560456055606560756085609561056115612561356145615561656175618561956205621562256235624562556265627562856295630563156325633563456355636563756385639564056415642564356445645564656475648564956505651565256535654565556565657565856595660566156625663566456655666566756685669567056715672567356745675567656775678567956805681568256835684568556865687568856895690569156925693569456955696569756985699570057015702570357045705570657075708570957105711571257135714571557165717571857195720572157225723572457255726572757285729573057315732573357345735573657375738573957405741574257435744574557465747574857495750575157525753575457555756575757585759576057615762576357645765576657675768576957705771577257735774577557765777577857795780578157825783578457855786578757885789579057915792579357945795579657975798579958005801580258035804580558065807580858095810581158125813581458155816581758185819582058215822582358245825582658275828582958305831583258335834583558365837583858395840584158425843584458455846584758485849585058515852585358545855585658575858585958605861586258635864586558665867586858695870587158725873587458755876587758785879588058815882588358845885588658875888588958905891589258935894589558965897589858995900590159025903590459055906590759085909591059115912591359145915591659175918591959205921592259235924592559265927592859295930593159325933593459355936593759385939594059415942594359445945594659475948594959505951595259535954595559565957595859595960596159625963596459655966596759685969597059715972597359745975597659775978597959805981598259835984598559865987598859895990599159925993599459955996599759985999600060016002600360046005600660076008600960106011601260136014601560166017601860196020602160226023602460256026602760286029603060316032603360346035603660376038603960406041604260436044604560466047604860496050605160526053605460556056605760586059606060616062606360646065606660676068606960706071607260736074607560766077607860796080608160826083608460856086608760886089609060916092609360946095609660976098609961006101610261036104610561066107610861096110611161126113611461156116611761186119612061216122612361246125612661276128612961306131613261336134613561366137613861396140614161426143614461456146614761486149615061516152615361546155615661576158615961606161616261636164616561666167616861696170617161726173617461756176617761786179618061816182618361846185618661876188618961906191619261936194619561966197619861996200620162026203620462056206620762086209621062116212621362146215621662176218621962206221622262236224622562266227622862296230623162326233623462356236623762386239624062416242624362446245624662476248624962506251625262536254625562566257625862596260626162626263626462656266626762686269627062716272627362746275627662776278627962806281628262836284628562866287628862896290629162926293629462956296629762986299630063016302630363046305630663076308630963106311631263136314631563166317631863196320632163226323632463256326632763286329633063316332633363346335633663376338633963406341634263436344634563466347634863496350635163526353635463556356635763586359636063616362636363646365636663676368636963706371637263736374637563766377637863796380638163826383638463856386638763886389639063916392639363946395639663976398639964006401640264036404640564066407640864096410641164126413641464156416641764186419642064216422642364246425642664276428642964306431643264336434643564366437643864396440644164426443644464456446644764486449645064516452645364546455645664576458645964606461646264636464646564666467646864696470647164726473647464756476647764786479648064816482648364846485648664876488648964906491649264936494649564966497649864996500650165026503650465056506650765086509651065116512651365146515651665176518651965206521652265236524652565266527652865296530653165326533653465356536653765386539654065416542654365446545654665476548654965506551655265536554655565566557655865596560656165626563656465656566656765686569657065716572657365746575657665776578657965806581658265836584658565866587658865896590659165926593659465956596659765986599660066016602660366046605660666076608660966106611661266136614661566166617661866196620662166226623662466256626662766286629663066316632663366346635663666376638663966406641664266436644664566466647664866496650665166526653665466556656665766586659666066616662666366646665666666676668666966706671667266736674667566766677667866796680668166826683668466856686668766886689669066916692669366946695669666976698669967006701670267036704670567066707670867096710671167126713671467156716671767186719672067216722672367246725672667276728672967306731673267336734673567366737673867396740674167426743674467456746674767486749675067516752675367546755675667576758675967606761676267636764676567666767676867696770677167726773677467756776677767786779678067816782678367846785678667876788678967906791679267936794679567966797679867996800680168026803680468056806680768086809681068116812681368146815681668176818681968206821682268236824682568266827682868296830683168326833683468356836683768386839684068416842684368446845684668476848684968506851685268536854685568566857685868596860686168626863686468656866686768686869687068716872687368746875687668776878687968806881688268836884688568866887688868896890689168926893689468956896689768986899690069016902690369046905690669076908690969106911691269136914691569166917691869196920692169226923692469256926692769286929693069316932693369346935693669376938693969406941694269436944694569466947694869496950695169526953695469556956695769586959696069616962696369646965696669676968696969706971697269736974697569766977697869796980698169826983698469856986698769886989699069916992699369946995699669976998699970007001700270037004700570067007700870097010701170127013701470157016701770187019702070217022702370247025702670277028702970307031703270337034703570367037703870397040704170427043704470457046704770487049705070517052705370547055705670577058705970607061706270637064706570667067706870697070707170727073707470757076707770787079708070817082708370847085708670877088708970907091709270937094709570967097709870997100710171027103710471057106710771087109711071117112711371147115711671177118711971207121712271237124712571267127712871297130713171327133713471357136713771387139714071417142714371447145714671477148714971507151715271537154715571567157715871597160716171627163716471657166716771687169717071717172717371747175717671777178717971807181718271837184718571867187718871897190719171927193719471957196719771987199720072017202720372047205720672077208720972107211721272137214721572167217721872197220722172227223722472257226722772287229723072317232723372347235723672377238723972407241724272437244724572467247724872497250725172527253725472557256725772587259726072617262726372647265726672677268726972707271727272737274727572767277727872797280728172827283728472857286728772887289729072917292729372947295729672977298729973007301730273037304730573067307730873097310731173127313731473157316731773187319732073217322732373247325732673277328732973307331733273337334733573367337733873397340734173427343734473457346734773487349735073517352735373547355735673577358735973607361736273637364736573667367736873697370737173727373737473757376737773787379738073817382738373847385738673877388738973907391739273937394739573967397739873997400740174027403740474057406740774087409741074117412741374147415741674177418741974207421742274237424742574267427742874297430743174327433743474357436743774387439744074417442744374447445744674477448744974507451745274537454745574567457745874597460746174627463746474657466746774687469747074717472747374747475747674777478747974807481748274837484748574867487748874897490749174927493749474957496749774987499750075017502750375047505750675077508750975107511751275137514751575167517751875197520752175227523752475257526752775287529753075317532753375347535753675377538753975407541754275437544754575467547754875497550755175527553755475557556755775587559756075617562756375647565756675677568756975707571757275737574757575767577757875797580758175827583758475857586758775887589759075917592759375947595759675977598759976007601760276037604760576067607760876097610761176127613761476157616761776187619762076217622762376247625762676277628762976307631763276337634763576367637763876397640764176427643764476457646764776487649765076517652765376547655765676577658765976607661766276637664766576667667766876697670767176727673767476757676767776787679768076817682768376847685768676877688768976907691769276937694769576967697769876997700770177027703770477057706770777087709771077117712771377147715771677177718771977207721772277237724772577267727772877297730773177327733773477357736773777387739774077417742774377447745774677477748774977507751775277537754775577567757775877597760776177627763776477657766776777687769777077717772777377747775777677777778777977807781778277837784778577867787778877897790779177927793779477957796779777987799780078017802780378047805780678077808780978107811781278137814781578167817781878197820782178227823782478257826782778287829783078317832783378347835783678377838783978407841784278437844784578467847784878497850785178527853785478557856785778587859786078617862786378647865786678677868786978707871787278737874787578767877787878797880788178827883788478857886788778887889789078917892789378947895789678977898789979007901790279037904790579067907790879097910791179127913791479157916791779187919792079217922792379247925792679277928792979307931793279337934793579367937793879397940794179427943794479457946794779487949795079517952795379547955795679577958795979607961796279637964796579667967796879697970797179727973797479757976797779787979798079817982798379847985798679877988798979907991799279937994799579967997799879998000800180028003800480058006800780088009801080118012801380148015801680178018801980208021802280238024802580268027802880298030803180328033803480358036803780388039804080418042804380448045804680478048804980508051805280538054805580568057805880598060806180628063806480658066806780688069807080718072807380748075807680778078807980808081808280838084808580868087808880898090809180928093809480958096809780988099810081018102810381048105810681078108810981108111811281138114811581168117811881198120812181228123812481258126812781288129813081318132813381348135813681378138813981408141814281438144814581468147814881498150815181528153815481558156815781588159816081618162816381648165816681678168816981708171817281738174
  1. /*
  2. * Scsi Host Layer for MPT (Message Passing Technology) based controllers
  3. *
  4. * This code is based on drivers/scsi/mpt3sas/mpt3sas_scsih.c
  5. * Copyright (C) 2012-2013 LSI Corporation
  6. * (mailto:DL-MPTFusionLinux@lsi.com)
  7. *
  8. * This program is free software; you can redistribute it and/or
  9. * modify it under the terms of the GNU General Public License
  10. * as published by the Free Software Foundation; either version 2
  11. * of the License, or (at your option) any later version.
  12. *
  13. * This program is distributed in the hope that it will be useful,
  14. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  16. * GNU General Public License for more details.
  17. *
  18. * NO WARRANTY
  19. * THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR
  20. * CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT
  21. * LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
  22. * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is
  23. * solely responsible for determining the appropriateness of using and
  24. * distributing the Program and assumes all risks associated with its
  25. * exercise of rights under this Agreement, including but not limited to
  26. * the risks and costs of program errors, damage to or loss of data,
  27. * programs or equipment, and unavailability or interruption of operations.
  28. * DISCLAIMER OF LIABILITY
  29. * NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY
  30. * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  31. * DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND
  32. * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
  33. * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  34. * USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
  35. * HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
  36. * You should have received a copy of the GNU General Public License
  37. * along with this program; if not, write to the Free Software
  38. * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
  39. * USA.
  40. */
  41. #include <linux/module.h>
  42. #include <linux/kernel.h>
  43. #include <linux/init.h>
  44. #include <linux/errno.h>
  45. #include <linux/blkdev.h>
  46. #include <linux/sched.h>
  47. #include <linux/workqueue.h>
  48. #include <linux/delay.h>
  49. #include <linux/pci.h>
  50. #include <linux/interrupt.h>
  51. #include <linux/aer.h>
  52. #include <linux/raid_class.h>
  53. #include "mpt3sas_base.h"
  54. MODULE_AUTHOR(MPT3SAS_AUTHOR);
  55. MODULE_DESCRIPTION(MPT3SAS_DESCRIPTION);
  56. MODULE_LICENSE("GPL");
  57. MODULE_VERSION(MPT3SAS_DRIVER_VERSION);
  58. #define RAID_CHANNEL 1
  59. /* forward proto's */
  60. static void _scsih_expander_node_remove(struct MPT3SAS_ADAPTER *ioc,
  61. struct _sas_node *sas_expander);
  62. static void _firmware_event_work(struct work_struct *work);
  63. static void _scsih_remove_device(struct MPT3SAS_ADAPTER *ioc,
  64. struct _sas_device *sas_device);
  65. static int _scsih_add_device(struct MPT3SAS_ADAPTER *ioc, u16 handle,
  66. u8 retry_count, u8 is_pd);
  67. static u8 _scsih_check_for_pending_tm(struct MPT3SAS_ADAPTER *ioc, u16 smid);
  68. static void _scsih_scan_start(struct Scsi_Host *shost);
  69. static int _scsih_scan_finished(struct Scsi_Host *shost, unsigned long time);
  70. /* global parameters */
  71. LIST_HEAD(mpt3sas_ioc_list);
  72. /* local parameters */
  73. static u8 scsi_io_cb_idx = -1;
  74. static u8 tm_cb_idx = -1;
  75. static u8 ctl_cb_idx = -1;
  76. static u8 base_cb_idx = -1;
  77. static u8 port_enable_cb_idx = -1;
  78. static u8 transport_cb_idx = -1;
  79. static u8 scsih_cb_idx = -1;
  80. static u8 config_cb_idx = -1;
  81. static int mpt_ids;
  82. static u8 tm_tr_cb_idx = -1 ;
  83. static u8 tm_tr_volume_cb_idx = -1 ;
  84. static u8 tm_sas_control_cb_idx = -1;
  85. /* command line options */
  86. static u32 logging_level;
  87. MODULE_PARM_DESC(logging_level,
  88. " bits for enabling additional logging info (default=0)");
  89. static ushort max_sectors = 0xFFFF;
  90. module_param(max_sectors, ushort, 0);
  91. MODULE_PARM_DESC(max_sectors, "max sectors, range 64 to 32767 default=32767");
  92. static int missing_delay[2] = {-1, -1};
  93. module_param_array(missing_delay, int, NULL, 0);
  94. MODULE_PARM_DESC(missing_delay, " device missing delay , io missing delay");
  95. /* scsi-mid layer global parmeter is max_report_luns, which is 511 */
  96. #define MPT3SAS_MAX_LUN (16895)
  97. static int max_lun = MPT3SAS_MAX_LUN;
  98. module_param(max_lun, int, 0);
  99. MODULE_PARM_DESC(max_lun, " max lun, default=16895 ");
  100. /* diag_buffer_enable is bitwise
  101. * bit 0 set = TRACE
  102. * bit 1 set = SNAPSHOT
  103. * bit 2 set = EXTENDED
  104. *
  105. * Either bit can be set, or both
  106. */
  107. static int diag_buffer_enable = -1;
  108. module_param(diag_buffer_enable, int, 0);
  109. MODULE_PARM_DESC(diag_buffer_enable,
  110. " post diag buffers (TRACE=1/SNAPSHOT=2/EXTENDED=4/default=0)");
  111. static int disable_discovery = -1;
  112. module_param(disable_discovery, int, 0);
  113. MODULE_PARM_DESC(disable_discovery, " disable discovery ");
  114. /* permit overriding the host protection capabilities mask (EEDP/T10 PI) */
  115. static int prot_mask = -1;
  116. module_param(prot_mask, int, 0);
  117. MODULE_PARM_DESC(prot_mask, " host protection capabilities mask, def=7 ");
  118. /* raid transport support */
  119. static struct raid_template *mpt3sas_raid_template;
  120. /**
  121. * struct sense_info - common structure for obtaining sense keys
  122. * @skey: sense key
  123. * @asc: additional sense code
  124. * @ascq: additional sense code qualifier
  125. */
  126. struct sense_info {
  127. u8 skey;
  128. u8 asc;
  129. u8 ascq;
  130. };
  131. #define MPT3SAS_PROCESS_TRIGGER_DIAG (0xFFFB)
  132. #define MPT3SAS_TURN_ON_FAULT_LED (0xFFFC)
  133. #define MPT3SAS_PORT_ENABLE_COMPLETE (0xFFFD)
  134. #define MPT3SAS_ABRT_TASK_SET (0xFFFE)
  135. #define MPT3SAS_REMOVE_UNRESPONDING_DEVICES (0xFFFF)
  136. /**
  137. * struct fw_event_work - firmware event struct
  138. * @list: link list framework
  139. * @work: work object (ioc->fault_reset_work_q)
  140. * @cancel_pending_work: flag set during reset handling
  141. * @ioc: per adapter object
  142. * @device_handle: device handle
  143. * @VF_ID: virtual function id
  144. * @VP_ID: virtual port id
  145. * @ignore: flag meaning this event has been marked to ignore
  146. * @event: firmware event MPI2_EVENT_XXX defined in mpt2_ioc.h
  147. * @event_data: reply event data payload follows
  148. *
  149. * This object stored on ioc->fw_event_list.
  150. */
  151. struct fw_event_work {
  152. struct list_head list;
  153. struct work_struct work;
  154. u8 cancel_pending_work;
  155. struct delayed_work delayed_work;
  156. struct MPT3SAS_ADAPTER *ioc;
  157. u16 device_handle;
  158. u8 VF_ID;
  159. u8 VP_ID;
  160. u8 ignore;
  161. u16 event;
  162. void *event_data;
  163. };
  164. /* raid transport support */
  165. static struct raid_template *mpt3sas_raid_template;
  166. /**
  167. * struct _scsi_io_transfer - scsi io transfer
  168. * @handle: sas device handle (assigned by firmware)
  169. * @is_raid: flag set for hidden raid components
  170. * @dir: DMA_TO_DEVICE, DMA_FROM_DEVICE,
  171. * @data_length: data transfer length
  172. * @data_dma: dma pointer to data
  173. * @sense: sense data
  174. * @lun: lun number
  175. * @cdb_length: cdb length
  176. * @cdb: cdb contents
  177. * @timeout: timeout for this command
  178. * @VF_ID: virtual function id
  179. * @VP_ID: virtual port id
  180. * @valid_reply: flag set for reply message
  181. * @sense_length: sense length
  182. * @ioc_status: ioc status
  183. * @scsi_state: scsi state
  184. * @scsi_status: scsi staus
  185. * @log_info: log information
  186. * @transfer_length: data length transfer when there is a reply message
  187. *
  188. * Used for sending internal scsi commands to devices within this module.
  189. * Refer to _scsi_send_scsi_io().
  190. */
  191. struct _scsi_io_transfer {
  192. u16 handle;
  193. u8 is_raid;
  194. enum dma_data_direction dir;
  195. u32 data_length;
  196. dma_addr_t data_dma;
  197. u8 sense[SCSI_SENSE_BUFFERSIZE];
  198. u32 lun;
  199. u8 cdb_length;
  200. u8 cdb[32];
  201. u8 timeout;
  202. u8 VF_ID;
  203. u8 VP_ID;
  204. u8 valid_reply;
  205. /* the following bits are only valid when 'valid_reply = 1' */
  206. u32 sense_length;
  207. u16 ioc_status;
  208. u8 scsi_state;
  209. u8 scsi_status;
  210. u32 log_info;
  211. u32 transfer_length;
  212. };
  213. /*
  214. * The pci device ids are defined in mpi/mpi2_cnfg.h.
  215. */
  216. static DEFINE_PCI_DEVICE_TABLE(scsih_pci_table) = {
  217. /* Fury ~ 3004 and 3008 */
  218. { MPI2_MFGPAGE_VENDORID_LSI, MPI25_MFGPAGE_DEVID_SAS3004,
  219. PCI_ANY_ID, PCI_ANY_ID },
  220. { MPI2_MFGPAGE_VENDORID_LSI, MPI25_MFGPAGE_DEVID_SAS3008,
  221. PCI_ANY_ID, PCI_ANY_ID },
  222. /* Invader ~ 3108 */
  223. { MPI2_MFGPAGE_VENDORID_LSI, MPI25_MFGPAGE_DEVID_SAS3108_1,
  224. PCI_ANY_ID, PCI_ANY_ID },
  225. { MPI2_MFGPAGE_VENDORID_LSI, MPI25_MFGPAGE_DEVID_SAS3108_2,
  226. PCI_ANY_ID, PCI_ANY_ID },
  227. { MPI2_MFGPAGE_VENDORID_LSI, MPI25_MFGPAGE_DEVID_SAS3108_5,
  228. PCI_ANY_ID, PCI_ANY_ID },
  229. { MPI2_MFGPAGE_VENDORID_LSI, MPI25_MFGPAGE_DEVID_SAS3108_6,
  230. PCI_ANY_ID, PCI_ANY_ID },
  231. {0} /* Terminating entry */
  232. };
  233. MODULE_DEVICE_TABLE(pci, scsih_pci_table);
  234. /**
  235. * _scsih_set_debug_level - global setting of ioc->logging_level.
  236. *
  237. * Note: The logging levels are defined in mpt3sas_debug.h.
  238. */
  239. static int
  240. _scsih_set_debug_level(const char *val, struct kernel_param *kp)
  241. {
  242. int ret = param_set_int(val, kp);
  243. struct MPT3SAS_ADAPTER *ioc;
  244. if (ret)
  245. return ret;
  246. pr_info("setting logging_level(0x%08x)\n", logging_level);
  247. list_for_each_entry(ioc, &mpt3sas_ioc_list, list)
  248. ioc->logging_level = logging_level;
  249. return 0;
  250. }
  251. module_param_call(logging_level, _scsih_set_debug_level, param_get_int,
  252. &logging_level, 0644);
  253. /**
  254. * _scsih_srch_boot_sas_address - search based on sas_address
  255. * @sas_address: sas address
  256. * @boot_device: boot device object from bios page 2
  257. *
  258. * Returns 1 when there's a match, 0 means no match.
  259. */
  260. static inline int
  261. _scsih_srch_boot_sas_address(u64 sas_address,
  262. Mpi2BootDeviceSasWwid_t *boot_device)
  263. {
  264. return (sas_address == le64_to_cpu(boot_device->SASAddress)) ? 1 : 0;
  265. }
  266. /**
  267. * _scsih_srch_boot_device_name - search based on device name
  268. * @device_name: device name specified in INDENTIFY fram
  269. * @boot_device: boot device object from bios page 2
  270. *
  271. * Returns 1 when there's a match, 0 means no match.
  272. */
  273. static inline int
  274. _scsih_srch_boot_device_name(u64 device_name,
  275. Mpi2BootDeviceDeviceName_t *boot_device)
  276. {
  277. return (device_name == le64_to_cpu(boot_device->DeviceName)) ? 1 : 0;
  278. }
  279. /**
  280. * _scsih_srch_boot_encl_slot - search based on enclosure_logical_id/slot
  281. * @enclosure_logical_id: enclosure logical id
  282. * @slot_number: slot number
  283. * @boot_device: boot device object from bios page 2
  284. *
  285. * Returns 1 when there's a match, 0 means no match.
  286. */
  287. static inline int
  288. _scsih_srch_boot_encl_slot(u64 enclosure_logical_id, u16 slot_number,
  289. Mpi2BootDeviceEnclosureSlot_t *boot_device)
  290. {
  291. return (enclosure_logical_id == le64_to_cpu(boot_device->
  292. EnclosureLogicalID) && slot_number == le16_to_cpu(boot_device->
  293. SlotNumber)) ? 1 : 0;
  294. }
  295. /**
  296. * _scsih_is_boot_device - search for matching boot device.
  297. * @sas_address: sas address
  298. * @device_name: device name specified in INDENTIFY fram
  299. * @enclosure_logical_id: enclosure logical id
  300. * @slot_number: slot number
  301. * @form: specifies boot device form
  302. * @boot_device: boot device object from bios page 2
  303. *
  304. * Returns 1 when there's a match, 0 means no match.
  305. */
  306. static int
  307. _scsih_is_boot_device(u64 sas_address, u64 device_name,
  308. u64 enclosure_logical_id, u16 slot, u8 form,
  309. Mpi2BiosPage2BootDevice_t *boot_device)
  310. {
  311. int rc = 0;
  312. switch (form) {
  313. case MPI2_BIOSPAGE2_FORM_SAS_WWID:
  314. if (!sas_address)
  315. break;
  316. rc = _scsih_srch_boot_sas_address(
  317. sas_address, &boot_device->SasWwid);
  318. break;
  319. case MPI2_BIOSPAGE2_FORM_ENCLOSURE_SLOT:
  320. if (!enclosure_logical_id)
  321. break;
  322. rc = _scsih_srch_boot_encl_slot(
  323. enclosure_logical_id,
  324. slot, &boot_device->EnclosureSlot);
  325. break;
  326. case MPI2_BIOSPAGE2_FORM_DEVICE_NAME:
  327. if (!device_name)
  328. break;
  329. rc = _scsih_srch_boot_device_name(
  330. device_name, &boot_device->DeviceName);
  331. break;
  332. case MPI2_BIOSPAGE2_FORM_NO_DEVICE_SPECIFIED:
  333. break;
  334. }
  335. return rc;
  336. }
  337. /**
  338. * _scsih_get_sas_address - set the sas_address for given device handle
  339. * @handle: device handle
  340. * @sas_address: sas address
  341. *
  342. * Returns 0 success, non-zero when failure
  343. */
  344. static int
  345. _scsih_get_sas_address(struct MPT3SAS_ADAPTER *ioc, u16 handle,
  346. u64 *sas_address)
  347. {
  348. Mpi2SasDevicePage0_t sas_device_pg0;
  349. Mpi2ConfigReply_t mpi_reply;
  350. u32 ioc_status;
  351. *sas_address = 0;
  352. if (handle <= ioc->sas_hba.num_phys) {
  353. *sas_address = ioc->sas_hba.sas_address;
  354. return 0;
  355. }
  356. if ((mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0,
  357. MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, handle))) {
  358. pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n", ioc->name,
  359. __FILE__, __LINE__, __func__);
  360. return -ENXIO;
  361. }
  362. ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & MPI2_IOCSTATUS_MASK;
  363. if (ioc_status == MPI2_IOCSTATUS_SUCCESS) {
  364. *sas_address = le64_to_cpu(sas_device_pg0.SASAddress);
  365. return 0;
  366. }
  367. /* we hit this becuase the given parent handle doesn't exist */
  368. if (ioc_status == MPI2_IOCSTATUS_CONFIG_INVALID_PAGE)
  369. return -ENXIO;
  370. /* else error case */
  371. pr_err(MPT3SAS_FMT
  372. "handle(0x%04x), ioc_status(0x%04x), failure at %s:%d/%s()!\n",
  373. ioc->name, handle, ioc_status,
  374. __FILE__, __LINE__, __func__);
  375. return -EIO;
  376. }
  377. /**
  378. * _scsih_determine_boot_device - determine boot device.
  379. * @ioc: per adapter object
  380. * @device: either sas_device or raid_device object
  381. * @is_raid: [flag] 1 = raid object, 0 = sas object
  382. *
  383. * Determines whether this device should be first reported device to
  384. * to scsi-ml or sas transport, this purpose is for persistent boot device.
  385. * There are primary, alternate, and current entries in bios page 2. The order
  386. * priority is primary, alternate, then current. This routine saves
  387. * the corresponding device object and is_raid flag in the ioc object.
  388. * The saved data to be used later in _scsih_probe_boot_devices().
  389. */
  390. static void
  391. _scsih_determine_boot_device(struct MPT3SAS_ADAPTER *ioc,
  392. void *device, u8 is_raid)
  393. {
  394. struct _sas_device *sas_device;
  395. struct _raid_device *raid_device;
  396. u64 sas_address;
  397. u64 device_name;
  398. u64 enclosure_logical_id;
  399. u16 slot;
  400. /* only process this function when driver loads */
  401. if (!ioc->is_driver_loading)
  402. return;
  403. /* no Bios, return immediately */
  404. if (!ioc->bios_pg3.BiosVersion)
  405. return;
  406. if (!is_raid) {
  407. sas_device = device;
  408. sas_address = sas_device->sas_address;
  409. device_name = sas_device->device_name;
  410. enclosure_logical_id = sas_device->enclosure_logical_id;
  411. slot = sas_device->slot;
  412. } else {
  413. raid_device = device;
  414. sas_address = raid_device->wwid;
  415. device_name = 0;
  416. enclosure_logical_id = 0;
  417. slot = 0;
  418. }
  419. if (!ioc->req_boot_device.device) {
  420. if (_scsih_is_boot_device(sas_address, device_name,
  421. enclosure_logical_id, slot,
  422. (ioc->bios_pg2.ReqBootDeviceForm &
  423. MPI2_BIOSPAGE2_FORM_MASK),
  424. &ioc->bios_pg2.RequestedBootDevice)) {
  425. dinitprintk(ioc, pr_info(MPT3SAS_FMT
  426. "%s: req_boot_device(0x%016llx)\n",
  427. ioc->name, __func__,
  428. (unsigned long long)sas_address));
  429. ioc->req_boot_device.device = device;
  430. ioc->req_boot_device.is_raid = is_raid;
  431. }
  432. }
  433. if (!ioc->req_alt_boot_device.device) {
  434. if (_scsih_is_boot_device(sas_address, device_name,
  435. enclosure_logical_id, slot,
  436. (ioc->bios_pg2.ReqAltBootDeviceForm &
  437. MPI2_BIOSPAGE2_FORM_MASK),
  438. &ioc->bios_pg2.RequestedAltBootDevice)) {
  439. dinitprintk(ioc, pr_info(MPT3SAS_FMT
  440. "%s: req_alt_boot_device(0x%016llx)\n",
  441. ioc->name, __func__,
  442. (unsigned long long)sas_address));
  443. ioc->req_alt_boot_device.device = device;
  444. ioc->req_alt_boot_device.is_raid = is_raid;
  445. }
  446. }
  447. if (!ioc->current_boot_device.device) {
  448. if (_scsih_is_boot_device(sas_address, device_name,
  449. enclosure_logical_id, slot,
  450. (ioc->bios_pg2.CurrentBootDeviceForm &
  451. MPI2_BIOSPAGE2_FORM_MASK),
  452. &ioc->bios_pg2.CurrentBootDevice)) {
  453. dinitprintk(ioc, pr_info(MPT3SAS_FMT
  454. "%s: current_boot_device(0x%016llx)\n",
  455. ioc->name, __func__,
  456. (unsigned long long)sas_address));
  457. ioc->current_boot_device.device = device;
  458. ioc->current_boot_device.is_raid = is_raid;
  459. }
  460. }
  461. }
  462. /**
  463. * mpt3sas_scsih_sas_device_find_by_sas_address - sas device search
  464. * @ioc: per adapter object
  465. * @sas_address: sas address
  466. * Context: Calling function should acquire ioc->sas_device_lock
  467. *
  468. * This searches for sas_device based on sas_address, then return sas_device
  469. * object.
  470. */
  471. struct _sas_device *
  472. mpt3sas_scsih_sas_device_find_by_sas_address(struct MPT3SAS_ADAPTER *ioc,
  473. u64 sas_address)
  474. {
  475. struct _sas_device *sas_device;
  476. list_for_each_entry(sas_device, &ioc->sas_device_list, list)
  477. if (sas_device->sas_address == sas_address)
  478. return sas_device;
  479. list_for_each_entry(sas_device, &ioc->sas_device_init_list, list)
  480. if (sas_device->sas_address == sas_address)
  481. return sas_device;
  482. return NULL;
  483. }
  484. /**
  485. * _scsih_sas_device_find_by_handle - sas device search
  486. * @ioc: per adapter object
  487. * @handle: sas device handle (assigned by firmware)
  488. * Context: Calling function should acquire ioc->sas_device_lock
  489. *
  490. * This searches for sas_device based on sas_address, then return sas_device
  491. * object.
  492. */
  493. static struct _sas_device *
  494. _scsih_sas_device_find_by_handle(struct MPT3SAS_ADAPTER *ioc, u16 handle)
  495. {
  496. struct _sas_device *sas_device;
  497. list_for_each_entry(sas_device, &ioc->sas_device_list, list)
  498. if (sas_device->handle == handle)
  499. return sas_device;
  500. list_for_each_entry(sas_device, &ioc->sas_device_init_list, list)
  501. if (sas_device->handle == handle)
  502. return sas_device;
  503. return NULL;
  504. }
  505. /**
  506. * _scsih_sas_device_remove - remove sas_device from list.
  507. * @ioc: per adapter object
  508. * @sas_device: the sas_device object
  509. * Context: This function will acquire ioc->sas_device_lock.
  510. *
  511. * Removing object and freeing associated memory from the ioc->sas_device_list.
  512. */
  513. static void
  514. _scsih_sas_device_remove(struct MPT3SAS_ADAPTER *ioc,
  515. struct _sas_device *sas_device)
  516. {
  517. unsigned long flags;
  518. if (!sas_device)
  519. return;
  520. spin_lock_irqsave(&ioc->sas_device_lock, flags);
  521. list_del(&sas_device->list);
  522. kfree(sas_device);
  523. spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
  524. }
  525. /**
  526. * _scsih_device_remove_by_handle - removing device object by handle
  527. * @ioc: per adapter object
  528. * @handle: device handle
  529. *
  530. * Return nothing.
  531. */
  532. static void
  533. _scsih_device_remove_by_handle(struct MPT3SAS_ADAPTER *ioc, u16 handle)
  534. {
  535. struct _sas_device *sas_device;
  536. unsigned long flags;
  537. if (ioc->shost_recovery)
  538. return;
  539. spin_lock_irqsave(&ioc->sas_device_lock, flags);
  540. sas_device = _scsih_sas_device_find_by_handle(ioc, handle);
  541. if (sas_device)
  542. list_del(&sas_device->list);
  543. spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
  544. if (sas_device)
  545. _scsih_remove_device(ioc, sas_device);
  546. }
  547. /**
  548. * mpt3sas_device_remove_by_sas_address - removing device object by sas address
  549. * @ioc: per adapter object
  550. * @sas_address: device sas_address
  551. *
  552. * Return nothing.
  553. */
  554. void
  555. mpt3sas_device_remove_by_sas_address(struct MPT3SAS_ADAPTER *ioc,
  556. u64 sas_address)
  557. {
  558. struct _sas_device *sas_device;
  559. unsigned long flags;
  560. if (ioc->shost_recovery)
  561. return;
  562. spin_lock_irqsave(&ioc->sas_device_lock, flags);
  563. sas_device = mpt3sas_scsih_sas_device_find_by_sas_address(ioc,
  564. sas_address);
  565. if (sas_device)
  566. list_del(&sas_device->list);
  567. spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
  568. if (sas_device)
  569. _scsih_remove_device(ioc, sas_device);
  570. }
  571. /**
  572. * _scsih_sas_device_add - insert sas_device to the list.
  573. * @ioc: per adapter object
  574. * @sas_device: the sas_device object
  575. * Context: This function will acquire ioc->sas_device_lock.
  576. *
  577. * Adding new object to the ioc->sas_device_list.
  578. */
  579. static void
  580. _scsih_sas_device_add(struct MPT3SAS_ADAPTER *ioc,
  581. struct _sas_device *sas_device)
  582. {
  583. unsigned long flags;
  584. dewtprintk(ioc, pr_info(MPT3SAS_FMT
  585. "%s: handle(0x%04x), sas_addr(0x%016llx)\n",
  586. ioc->name, __func__, sas_device->handle,
  587. (unsigned long long)sas_device->sas_address));
  588. spin_lock_irqsave(&ioc->sas_device_lock, flags);
  589. list_add_tail(&sas_device->list, &ioc->sas_device_list);
  590. spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
  591. if (!mpt3sas_transport_port_add(ioc, sas_device->handle,
  592. sas_device->sas_address_parent)) {
  593. _scsih_sas_device_remove(ioc, sas_device);
  594. } else if (!sas_device->starget) {
  595. /*
  596. * When asyn scanning is enabled, its not possible to remove
  597. * devices while scanning is turned on due to an oops in
  598. * scsi_sysfs_add_sdev()->add_device()->sysfs_addrm_start()
  599. */
  600. if (!ioc->is_driver_loading) {
  601. mpt3sas_transport_port_remove(ioc,
  602. sas_device->sas_address,
  603. sas_device->sas_address_parent);
  604. _scsih_sas_device_remove(ioc, sas_device);
  605. }
  606. }
  607. }
  608. /**
  609. * _scsih_sas_device_init_add - insert sas_device to the list.
  610. * @ioc: per adapter object
  611. * @sas_device: the sas_device object
  612. * Context: This function will acquire ioc->sas_device_lock.
  613. *
  614. * Adding new object at driver load time to the ioc->sas_device_init_list.
  615. */
  616. static void
  617. _scsih_sas_device_init_add(struct MPT3SAS_ADAPTER *ioc,
  618. struct _sas_device *sas_device)
  619. {
  620. unsigned long flags;
  621. dewtprintk(ioc, pr_info(MPT3SAS_FMT
  622. "%s: handle(0x%04x), sas_addr(0x%016llx)\n", ioc->name,
  623. __func__, sas_device->handle,
  624. (unsigned long long)sas_device->sas_address));
  625. spin_lock_irqsave(&ioc->sas_device_lock, flags);
  626. list_add_tail(&sas_device->list, &ioc->sas_device_init_list);
  627. _scsih_determine_boot_device(ioc, sas_device, 0);
  628. spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
  629. }
  630. /**
  631. * _scsih_raid_device_find_by_id - raid device search
  632. * @ioc: per adapter object
  633. * @id: sas device target id
  634. * @channel: sas device channel
  635. * Context: Calling function should acquire ioc->raid_device_lock
  636. *
  637. * This searches for raid_device based on target id, then return raid_device
  638. * object.
  639. */
  640. static struct _raid_device *
  641. _scsih_raid_device_find_by_id(struct MPT3SAS_ADAPTER *ioc, int id, int channel)
  642. {
  643. struct _raid_device *raid_device, *r;
  644. r = NULL;
  645. list_for_each_entry(raid_device, &ioc->raid_device_list, list) {
  646. if (raid_device->id == id && raid_device->channel == channel) {
  647. r = raid_device;
  648. goto out;
  649. }
  650. }
  651. out:
  652. return r;
  653. }
  654. /**
  655. * _scsih_raid_device_find_by_handle - raid device search
  656. * @ioc: per adapter object
  657. * @handle: sas device handle (assigned by firmware)
  658. * Context: Calling function should acquire ioc->raid_device_lock
  659. *
  660. * This searches for raid_device based on handle, then return raid_device
  661. * object.
  662. */
  663. static struct _raid_device *
  664. _scsih_raid_device_find_by_handle(struct MPT3SAS_ADAPTER *ioc, u16 handle)
  665. {
  666. struct _raid_device *raid_device, *r;
  667. r = NULL;
  668. list_for_each_entry(raid_device, &ioc->raid_device_list, list) {
  669. if (raid_device->handle != handle)
  670. continue;
  671. r = raid_device;
  672. goto out;
  673. }
  674. out:
  675. return r;
  676. }
  677. /**
  678. * _scsih_raid_device_find_by_wwid - raid device search
  679. * @ioc: per adapter object
  680. * @handle: sas device handle (assigned by firmware)
  681. * Context: Calling function should acquire ioc->raid_device_lock
  682. *
  683. * This searches for raid_device based on wwid, then return raid_device
  684. * object.
  685. */
  686. static struct _raid_device *
  687. _scsih_raid_device_find_by_wwid(struct MPT3SAS_ADAPTER *ioc, u64 wwid)
  688. {
  689. struct _raid_device *raid_device, *r;
  690. r = NULL;
  691. list_for_each_entry(raid_device, &ioc->raid_device_list, list) {
  692. if (raid_device->wwid != wwid)
  693. continue;
  694. r = raid_device;
  695. goto out;
  696. }
  697. out:
  698. return r;
  699. }
  700. /**
  701. * _scsih_raid_device_add - add raid_device object
  702. * @ioc: per adapter object
  703. * @raid_device: raid_device object
  704. *
  705. * This is added to the raid_device_list link list.
  706. */
  707. static void
  708. _scsih_raid_device_add(struct MPT3SAS_ADAPTER *ioc,
  709. struct _raid_device *raid_device)
  710. {
  711. unsigned long flags;
  712. dewtprintk(ioc, pr_info(MPT3SAS_FMT
  713. "%s: handle(0x%04x), wwid(0x%016llx)\n", ioc->name, __func__,
  714. raid_device->handle, (unsigned long long)raid_device->wwid));
  715. spin_lock_irqsave(&ioc->raid_device_lock, flags);
  716. list_add_tail(&raid_device->list, &ioc->raid_device_list);
  717. spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
  718. }
  719. /**
  720. * _scsih_raid_device_remove - delete raid_device object
  721. * @ioc: per adapter object
  722. * @raid_device: raid_device object
  723. *
  724. */
  725. static void
  726. _scsih_raid_device_remove(struct MPT3SAS_ADAPTER *ioc,
  727. struct _raid_device *raid_device)
  728. {
  729. unsigned long flags;
  730. spin_lock_irqsave(&ioc->raid_device_lock, flags);
  731. list_del(&raid_device->list);
  732. kfree(raid_device);
  733. spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
  734. }
  735. /**
  736. * mpt3sas_scsih_expander_find_by_handle - expander device search
  737. * @ioc: per adapter object
  738. * @handle: expander handle (assigned by firmware)
  739. * Context: Calling function should acquire ioc->sas_device_lock
  740. *
  741. * This searches for expander device based on handle, then returns the
  742. * sas_node object.
  743. */
  744. struct _sas_node *
  745. mpt3sas_scsih_expander_find_by_handle(struct MPT3SAS_ADAPTER *ioc, u16 handle)
  746. {
  747. struct _sas_node *sas_expander, *r;
  748. r = NULL;
  749. list_for_each_entry(sas_expander, &ioc->sas_expander_list, list) {
  750. if (sas_expander->handle != handle)
  751. continue;
  752. r = sas_expander;
  753. goto out;
  754. }
  755. out:
  756. return r;
  757. }
  758. /**
  759. * mpt3sas_scsih_expander_find_by_sas_address - expander device search
  760. * @ioc: per adapter object
  761. * @sas_address: sas address
  762. * Context: Calling function should acquire ioc->sas_node_lock.
  763. *
  764. * This searches for expander device based on sas_address, then returns the
  765. * sas_node object.
  766. */
  767. struct _sas_node *
  768. mpt3sas_scsih_expander_find_by_sas_address(struct MPT3SAS_ADAPTER *ioc,
  769. u64 sas_address)
  770. {
  771. struct _sas_node *sas_expander, *r;
  772. r = NULL;
  773. list_for_each_entry(sas_expander, &ioc->sas_expander_list, list) {
  774. if (sas_expander->sas_address != sas_address)
  775. continue;
  776. r = sas_expander;
  777. goto out;
  778. }
  779. out:
  780. return r;
  781. }
  782. /**
  783. * _scsih_expander_node_add - insert expander device to the list.
  784. * @ioc: per adapter object
  785. * @sas_expander: the sas_device object
  786. * Context: This function will acquire ioc->sas_node_lock.
  787. *
  788. * Adding new object to the ioc->sas_expander_list.
  789. *
  790. * Return nothing.
  791. */
  792. static void
  793. _scsih_expander_node_add(struct MPT3SAS_ADAPTER *ioc,
  794. struct _sas_node *sas_expander)
  795. {
  796. unsigned long flags;
  797. spin_lock_irqsave(&ioc->sas_node_lock, flags);
  798. list_add_tail(&sas_expander->list, &ioc->sas_expander_list);
  799. spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
  800. }
  801. /**
  802. * _scsih_is_end_device - determines if device is an end device
  803. * @device_info: bitfield providing information about the device.
  804. * Context: none
  805. *
  806. * Returns 1 if end device.
  807. */
  808. static int
  809. _scsih_is_end_device(u32 device_info)
  810. {
  811. if (device_info & MPI2_SAS_DEVICE_INFO_END_DEVICE &&
  812. ((device_info & MPI2_SAS_DEVICE_INFO_SSP_TARGET) |
  813. (device_info & MPI2_SAS_DEVICE_INFO_STP_TARGET) |
  814. (device_info & MPI2_SAS_DEVICE_INFO_SATA_DEVICE)))
  815. return 1;
  816. else
  817. return 0;
  818. }
  819. /**
  820. * _scsih_scsi_lookup_get - returns scmd entry
  821. * @ioc: per adapter object
  822. * @smid: system request message index
  823. *
  824. * Returns the smid stored scmd pointer.
  825. */
  826. static struct scsi_cmnd *
  827. _scsih_scsi_lookup_get(struct MPT3SAS_ADAPTER *ioc, u16 smid)
  828. {
  829. return ioc->scsi_lookup[smid - 1].scmd;
  830. }
  831. /**
  832. * _scsih_scsi_lookup_get_clear - returns scmd entry
  833. * @ioc: per adapter object
  834. * @smid: system request message index
  835. *
  836. * Returns the smid stored scmd pointer.
  837. * Then will derefrence the stored scmd pointer.
  838. */
  839. static inline struct scsi_cmnd *
  840. _scsih_scsi_lookup_get_clear(struct MPT3SAS_ADAPTER *ioc, u16 smid)
  841. {
  842. unsigned long flags;
  843. struct scsi_cmnd *scmd;
  844. spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
  845. scmd = ioc->scsi_lookup[smid - 1].scmd;
  846. ioc->scsi_lookup[smid - 1].scmd = NULL;
  847. spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
  848. return scmd;
  849. }
  850. /**
  851. * _scsih_scsi_lookup_find_by_scmd - scmd lookup
  852. * @ioc: per adapter object
  853. * @smid: system request message index
  854. * @scmd: pointer to scsi command object
  855. * Context: This function will acquire ioc->scsi_lookup_lock.
  856. *
  857. * This will search for a scmd pointer in the scsi_lookup array,
  858. * returning the revelent smid. A returned value of zero means invalid.
  859. */
  860. static u16
  861. _scsih_scsi_lookup_find_by_scmd(struct MPT3SAS_ADAPTER *ioc, struct scsi_cmnd
  862. *scmd)
  863. {
  864. u16 smid;
  865. unsigned long flags;
  866. int i;
  867. spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
  868. smid = 0;
  869. for (i = 0; i < ioc->scsiio_depth; i++) {
  870. if (ioc->scsi_lookup[i].scmd == scmd) {
  871. smid = ioc->scsi_lookup[i].smid;
  872. goto out;
  873. }
  874. }
  875. out:
  876. spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
  877. return smid;
  878. }
  879. /**
  880. * _scsih_scsi_lookup_find_by_target - search for matching channel:id
  881. * @ioc: per adapter object
  882. * @id: target id
  883. * @channel: channel
  884. * Context: This function will acquire ioc->scsi_lookup_lock.
  885. *
  886. * This will search for a matching channel:id in the scsi_lookup array,
  887. * returning 1 if found.
  888. */
  889. static u8
  890. _scsih_scsi_lookup_find_by_target(struct MPT3SAS_ADAPTER *ioc, int id,
  891. int channel)
  892. {
  893. u8 found;
  894. unsigned long flags;
  895. int i;
  896. spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
  897. found = 0;
  898. for (i = 0 ; i < ioc->scsiio_depth; i++) {
  899. if (ioc->scsi_lookup[i].scmd &&
  900. (ioc->scsi_lookup[i].scmd->device->id == id &&
  901. ioc->scsi_lookup[i].scmd->device->channel == channel)) {
  902. found = 1;
  903. goto out;
  904. }
  905. }
  906. out:
  907. spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
  908. return found;
  909. }
  910. /**
  911. * _scsih_scsi_lookup_find_by_lun - search for matching channel:id:lun
  912. * @ioc: per adapter object
  913. * @id: target id
  914. * @lun: lun number
  915. * @channel: channel
  916. * Context: This function will acquire ioc->scsi_lookup_lock.
  917. *
  918. * This will search for a matching channel:id:lun in the scsi_lookup array,
  919. * returning 1 if found.
  920. */
  921. static u8
  922. _scsih_scsi_lookup_find_by_lun(struct MPT3SAS_ADAPTER *ioc, int id,
  923. unsigned int lun, int channel)
  924. {
  925. u8 found;
  926. unsigned long flags;
  927. int i;
  928. spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
  929. found = 0;
  930. for (i = 0 ; i < ioc->scsiio_depth; i++) {
  931. if (ioc->scsi_lookup[i].scmd &&
  932. (ioc->scsi_lookup[i].scmd->device->id == id &&
  933. ioc->scsi_lookup[i].scmd->device->channel == channel &&
  934. ioc->scsi_lookup[i].scmd->device->lun == lun)) {
  935. found = 1;
  936. goto out;
  937. }
  938. }
  939. out:
  940. spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
  941. return found;
  942. }
  943. static void
  944. _scsih_adjust_queue_depth(struct scsi_device *sdev, int qdepth)
  945. {
  946. struct Scsi_Host *shost = sdev->host;
  947. int max_depth;
  948. struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
  949. struct MPT3SAS_DEVICE *sas_device_priv_data;
  950. struct MPT3SAS_TARGET *sas_target_priv_data;
  951. struct _sas_device *sas_device;
  952. unsigned long flags;
  953. max_depth = shost->can_queue;
  954. /* limit max device queue for SATA to 32 */
  955. sas_device_priv_data = sdev->hostdata;
  956. if (!sas_device_priv_data)
  957. goto not_sata;
  958. sas_target_priv_data = sas_device_priv_data->sas_target;
  959. if (!sas_target_priv_data)
  960. goto not_sata;
  961. if ((sas_target_priv_data->flags & MPT_TARGET_FLAGS_VOLUME))
  962. goto not_sata;
  963. spin_lock_irqsave(&ioc->sas_device_lock, flags);
  964. sas_device = mpt3sas_scsih_sas_device_find_by_sas_address(ioc,
  965. sas_device_priv_data->sas_target->sas_address);
  966. if (sas_device && sas_device->device_info &
  967. MPI2_SAS_DEVICE_INFO_SATA_DEVICE)
  968. max_depth = MPT3SAS_SATA_QUEUE_DEPTH;
  969. spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
  970. not_sata:
  971. if (!sdev->tagged_supported)
  972. max_depth = 1;
  973. if (qdepth > max_depth)
  974. qdepth = max_depth;
  975. scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), qdepth);
  976. }
  977. /**
  978. * _scsih_change_queue_depth - setting device queue depth
  979. * @sdev: scsi device struct
  980. * @qdepth: requested queue depth
  981. * @reason: SCSI_QDEPTH_DEFAULT/SCSI_QDEPTH_QFULL/SCSI_QDEPTH_RAMP_UP
  982. * (see include/scsi/scsi_host.h for definition)
  983. *
  984. * Returns queue depth.
  985. */
  986. static int
  987. _scsih_change_queue_depth(struct scsi_device *sdev, int qdepth, int reason)
  988. {
  989. if (reason == SCSI_QDEPTH_DEFAULT || reason == SCSI_QDEPTH_RAMP_UP)
  990. _scsih_adjust_queue_depth(sdev, qdepth);
  991. else if (reason == SCSI_QDEPTH_QFULL)
  992. scsi_track_queue_full(sdev, qdepth);
  993. else
  994. return -EOPNOTSUPP;
  995. if (sdev->inquiry_len > 7)
  996. sdev_printk(KERN_INFO, sdev, "qdepth(%d), tagged(%d), " \
  997. "simple(%d), ordered(%d), scsi_level(%d), cmd_que(%d)\n",
  998. sdev->queue_depth, sdev->tagged_supported, sdev->simple_tags,
  999. sdev->ordered_tags, sdev->scsi_level,
  1000. (sdev->inquiry[7] & 2) >> 1);
  1001. return sdev->queue_depth;
  1002. }
  1003. /**
  1004. * _scsih_change_queue_type - changing device queue tag type
  1005. * @sdev: scsi device struct
  1006. * @tag_type: requested tag type
  1007. *
  1008. * Returns queue tag type.
  1009. */
  1010. static int
  1011. _scsih_change_queue_type(struct scsi_device *sdev, int tag_type)
  1012. {
  1013. if (sdev->tagged_supported) {
  1014. scsi_set_tag_type(sdev, tag_type);
  1015. if (tag_type)
  1016. scsi_activate_tcq(sdev, sdev->queue_depth);
  1017. else
  1018. scsi_deactivate_tcq(sdev, sdev->queue_depth);
  1019. } else
  1020. tag_type = 0;
  1021. return tag_type;
  1022. }
  1023. /**
  1024. * _scsih_target_alloc - target add routine
  1025. * @starget: scsi target struct
  1026. *
  1027. * Returns 0 if ok. Any other return is assumed to be an error and
  1028. * the device is ignored.
  1029. */
  1030. static int
  1031. _scsih_target_alloc(struct scsi_target *starget)
  1032. {
  1033. struct Scsi_Host *shost = dev_to_shost(&starget->dev);
  1034. struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
  1035. struct MPT3SAS_TARGET *sas_target_priv_data;
  1036. struct _sas_device *sas_device;
  1037. struct _raid_device *raid_device;
  1038. unsigned long flags;
  1039. struct sas_rphy *rphy;
  1040. sas_target_priv_data = kzalloc(sizeof(struct scsi_target), GFP_KERNEL);
  1041. if (!sas_target_priv_data)
  1042. return -ENOMEM;
  1043. starget->hostdata = sas_target_priv_data;
  1044. sas_target_priv_data->starget = starget;
  1045. sas_target_priv_data->handle = MPT3SAS_INVALID_DEVICE_HANDLE;
  1046. /* RAID volumes */
  1047. if (starget->channel == RAID_CHANNEL) {
  1048. spin_lock_irqsave(&ioc->raid_device_lock, flags);
  1049. raid_device = _scsih_raid_device_find_by_id(ioc, starget->id,
  1050. starget->channel);
  1051. if (raid_device) {
  1052. sas_target_priv_data->handle = raid_device->handle;
  1053. sas_target_priv_data->sas_address = raid_device->wwid;
  1054. sas_target_priv_data->flags |= MPT_TARGET_FLAGS_VOLUME;
  1055. raid_device->starget = starget;
  1056. }
  1057. spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
  1058. return 0;
  1059. }
  1060. /* sas/sata devices */
  1061. spin_lock_irqsave(&ioc->sas_device_lock, flags);
  1062. rphy = dev_to_rphy(starget->dev.parent);
  1063. sas_device = mpt3sas_scsih_sas_device_find_by_sas_address(ioc,
  1064. rphy->identify.sas_address);
  1065. if (sas_device) {
  1066. sas_target_priv_data->handle = sas_device->handle;
  1067. sas_target_priv_data->sas_address = sas_device->sas_address;
  1068. sas_device->starget = starget;
  1069. sas_device->id = starget->id;
  1070. sas_device->channel = starget->channel;
  1071. if (test_bit(sas_device->handle, ioc->pd_handles))
  1072. sas_target_priv_data->flags |=
  1073. MPT_TARGET_FLAGS_RAID_COMPONENT;
  1074. if (sas_device->fast_path)
  1075. sas_target_priv_data->flags |= MPT_TARGET_FASTPATH_IO;
  1076. }
  1077. spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
  1078. return 0;
  1079. }
  1080. /**
  1081. * _scsih_target_destroy - target destroy routine
  1082. * @starget: scsi target struct
  1083. *
  1084. * Returns nothing.
  1085. */
  1086. static void
  1087. _scsih_target_destroy(struct scsi_target *starget)
  1088. {
  1089. struct Scsi_Host *shost = dev_to_shost(&starget->dev);
  1090. struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
  1091. struct MPT3SAS_TARGET *sas_target_priv_data;
  1092. struct _sas_device *sas_device;
  1093. struct _raid_device *raid_device;
  1094. unsigned long flags;
  1095. struct sas_rphy *rphy;
  1096. sas_target_priv_data = starget->hostdata;
  1097. if (!sas_target_priv_data)
  1098. return;
  1099. if (starget->channel == RAID_CHANNEL) {
  1100. spin_lock_irqsave(&ioc->raid_device_lock, flags);
  1101. raid_device = _scsih_raid_device_find_by_id(ioc, starget->id,
  1102. starget->channel);
  1103. if (raid_device) {
  1104. raid_device->starget = NULL;
  1105. raid_device->sdev = NULL;
  1106. }
  1107. spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
  1108. goto out;
  1109. }
  1110. spin_lock_irqsave(&ioc->sas_device_lock, flags);
  1111. rphy = dev_to_rphy(starget->dev.parent);
  1112. sas_device = mpt3sas_scsih_sas_device_find_by_sas_address(ioc,
  1113. rphy->identify.sas_address);
  1114. if (sas_device && (sas_device->starget == starget) &&
  1115. (sas_device->id == starget->id) &&
  1116. (sas_device->channel == starget->channel))
  1117. sas_device->starget = NULL;
  1118. spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
  1119. out:
  1120. kfree(sas_target_priv_data);
  1121. starget->hostdata = NULL;
  1122. }
  1123. /**
  1124. * _scsih_slave_alloc - device add routine
  1125. * @sdev: scsi device struct
  1126. *
  1127. * Returns 0 if ok. Any other return is assumed to be an error and
  1128. * the device is ignored.
  1129. */
  1130. static int
  1131. _scsih_slave_alloc(struct scsi_device *sdev)
  1132. {
  1133. struct Scsi_Host *shost;
  1134. struct MPT3SAS_ADAPTER *ioc;
  1135. struct MPT3SAS_TARGET *sas_target_priv_data;
  1136. struct MPT3SAS_DEVICE *sas_device_priv_data;
  1137. struct scsi_target *starget;
  1138. struct _raid_device *raid_device;
  1139. struct _sas_device *sas_device;
  1140. unsigned long flags;
  1141. sas_device_priv_data = kzalloc(sizeof(struct scsi_device), GFP_KERNEL);
  1142. if (!sas_device_priv_data)
  1143. return -ENOMEM;
  1144. sas_device_priv_data->lun = sdev->lun;
  1145. sas_device_priv_data->flags = MPT_DEVICE_FLAGS_INIT;
  1146. starget = scsi_target(sdev);
  1147. sas_target_priv_data = starget->hostdata;
  1148. sas_target_priv_data->num_luns++;
  1149. sas_device_priv_data->sas_target = sas_target_priv_data;
  1150. sdev->hostdata = sas_device_priv_data;
  1151. if ((sas_target_priv_data->flags & MPT_TARGET_FLAGS_RAID_COMPONENT))
  1152. sdev->no_uld_attach = 1;
  1153. shost = dev_to_shost(&starget->dev);
  1154. ioc = shost_priv(shost);
  1155. if (starget->channel == RAID_CHANNEL) {
  1156. spin_lock_irqsave(&ioc->raid_device_lock, flags);
  1157. raid_device = _scsih_raid_device_find_by_id(ioc,
  1158. starget->id, starget->channel);
  1159. if (raid_device)
  1160. raid_device->sdev = sdev; /* raid is single lun */
  1161. spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
  1162. }
  1163. if (!(sas_target_priv_data->flags & MPT_TARGET_FLAGS_VOLUME)) {
  1164. spin_lock_irqsave(&ioc->sas_device_lock, flags);
  1165. sas_device = mpt3sas_scsih_sas_device_find_by_sas_address(ioc,
  1166. sas_target_priv_data->sas_address);
  1167. if (sas_device && (sas_device->starget == NULL)) {
  1168. sdev_printk(KERN_INFO, sdev,
  1169. "%s : sas_device->starget set to starget @ %d\n",
  1170. __func__, __LINE__);
  1171. sas_device->starget = starget;
  1172. }
  1173. spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
  1174. }
  1175. return 0;
  1176. }
  1177. /**
  1178. * _scsih_slave_destroy - device destroy routine
  1179. * @sdev: scsi device struct
  1180. *
  1181. * Returns nothing.
  1182. */
  1183. static void
  1184. _scsih_slave_destroy(struct scsi_device *sdev)
  1185. {
  1186. struct MPT3SAS_TARGET *sas_target_priv_data;
  1187. struct scsi_target *starget;
  1188. struct Scsi_Host *shost;
  1189. struct MPT3SAS_ADAPTER *ioc;
  1190. struct _sas_device *sas_device;
  1191. unsigned long flags;
  1192. if (!sdev->hostdata)
  1193. return;
  1194. starget = scsi_target(sdev);
  1195. sas_target_priv_data = starget->hostdata;
  1196. sas_target_priv_data->num_luns--;
  1197. shost = dev_to_shost(&starget->dev);
  1198. ioc = shost_priv(shost);
  1199. if (!(sas_target_priv_data->flags & MPT_TARGET_FLAGS_VOLUME)) {
  1200. spin_lock_irqsave(&ioc->sas_device_lock, flags);
  1201. sas_device = mpt3sas_scsih_sas_device_find_by_sas_address(ioc,
  1202. sas_target_priv_data->sas_address);
  1203. if (sas_device && !sas_target_priv_data->num_luns)
  1204. sas_device->starget = NULL;
  1205. spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
  1206. }
  1207. kfree(sdev->hostdata);
  1208. sdev->hostdata = NULL;
  1209. }
  1210. /**
  1211. * _scsih_display_sata_capabilities - sata capabilities
  1212. * @ioc: per adapter object
  1213. * @handle: device handle
  1214. * @sdev: scsi device struct
  1215. */
  1216. static void
  1217. _scsih_display_sata_capabilities(struct MPT3SAS_ADAPTER *ioc,
  1218. u16 handle, struct scsi_device *sdev)
  1219. {
  1220. Mpi2ConfigReply_t mpi_reply;
  1221. Mpi2SasDevicePage0_t sas_device_pg0;
  1222. u32 ioc_status;
  1223. u16 flags;
  1224. u32 device_info;
  1225. if ((mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0,
  1226. MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, handle))) {
  1227. pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
  1228. ioc->name, __FILE__, __LINE__, __func__);
  1229. return;
  1230. }
  1231. ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
  1232. MPI2_IOCSTATUS_MASK;
  1233. if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
  1234. pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
  1235. ioc->name, __FILE__, __LINE__, __func__);
  1236. return;
  1237. }
  1238. flags = le16_to_cpu(sas_device_pg0.Flags);
  1239. device_info = le32_to_cpu(sas_device_pg0.DeviceInfo);
  1240. sdev_printk(KERN_INFO, sdev,
  1241. "atapi(%s), ncq(%s), asyn_notify(%s), smart(%s), fua(%s), "
  1242. "sw_preserve(%s)\n",
  1243. (device_info & MPI2_SAS_DEVICE_INFO_ATAPI_DEVICE) ? "y" : "n",
  1244. (flags & MPI2_SAS_DEVICE0_FLAGS_SATA_NCQ_SUPPORTED) ? "y" : "n",
  1245. (flags & MPI2_SAS_DEVICE0_FLAGS_SATA_ASYNCHRONOUS_NOTIFY) ? "y" :
  1246. "n",
  1247. (flags & MPI2_SAS_DEVICE0_FLAGS_SATA_SMART_SUPPORTED) ? "y" : "n",
  1248. (flags & MPI2_SAS_DEVICE0_FLAGS_SATA_FUA_SUPPORTED) ? "y" : "n",
  1249. (flags & MPI2_SAS_DEVICE0_FLAGS_SATA_SW_PRESERVE) ? "y" : "n");
  1250. }
  1251. /*
  1252. * raid transport support -
  1253. * Enabled for SLES11 and newer, in older kernels the driver will panic when
  1254. * unloading the driver followed by a load - I beleive that the subroutine
  1255. * raid_class_release() is not cleaning up properly.
  1256. */
  1257. /**
  1258. * _scsih_is_raid - return boolean indicating device is raid volume
  1259. * @dev the device struct object
  1260. */
  1261. static int
  1262. _scsih_is_raid(struct device *dev)
  1263. {
  1264. struct scsi_device *sdev = to_scsi_device(dev);
  1265. return (sdev->channel == RAID_CHANNEL) ? 1 : 0;
  1266. }
  1267. /**
  1268. * _scsih_get_resync - get raid volume resync percent complete
  1269. * @dev the device struct object
  1270. */
  1271. static void
  1272. _scsih_get_resync(struct device *dev)
  1273. {
  1274. struct scsi_device *sdev = to_scsi_device(dev);
  1275. struct MPT3SAS_ADAPTER *ioc = shost_priv(sdev->host);
  1276. static struct _raid_device *raid_device;
  1277. unsigned long flags;
  1278. Mpi2RaidVolPage0_t vol_pg0;
  1279. Mpi2ConfigReply_t mpi_reply;
  1280. u32 volume_status_flags;
  1281. u8 percent_complete;
  1282. u16 handle;
  1283. percent_complete = 0;
  1284. handle = 0;
  1285. spin_lock_irqsave(&ioc->raid_device_lock, flags);
  1286. raid_device = _scsih_raid_device_find_by_id(ioc, sdev->id,
  1287. sdev->channel);
  1288. if (raid_device) {
  1289. handle = raid_device->handle;
  1290. percent_complete = raid_device->percent_complete;
  1291. }
  1292. spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
  1293. if (!handle)
  1294. goto out;
  1295. if (mpt3sas_config_get_raid_volume_pg0(ioc, &mpi_reply, &vol_pg0,
  1296. MPI2_RAID_VOLUME_PGAD_FORM_HANDLE, handle,
  1297. sizeof(Mpi2RaidVolPage0_t))) {
  1298. pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
  1299. ioc->name, __FILE__, __LINE__, __func__);
  1300. percent_complete = 0;
  1301. goto out;
  1302. }
  1303. volume_status_flags = le32_to_cpu(vol_pg0.VolumeStatusFlags);
  1304. if (!(volume_status_flags &
  1305. MPI2_RAIDVOL0_STATUS_FLAG_RESYNC_IN_PROGRESS))
  1306. percent_complete = 0;
  1307. out:
  1308. raid_set_resync(mpt3sas_raid_template, dev, percent_complete);
  1309. }
  1310. /**
  1311. * _scsih_get_state - get raid volume level
  1312. * @dev the device struct object
  1313. */
  1314. static void
  1315. _scsih_get_state(struct device *dev)
  1316. {
  1317. struct scsi_device *sdev = to_scsi_device(dev);
  1318. struct MPT3SAS_ADAPTER *ioc = shost_priv(sdev->host);
  1319. static struct _raid_device *raid_device;
  1320. unsigned long flags;
  1321. Mpi2RaidVolPage0_t vol_pg0;
  1322. Mpi2ConfigReply_t mpi_reply;
  1323. u32 volstate;
  1324. enum raid_state state = RAID_STATE_UNKNOWN;
  1325. u16 handle = 0;
  1326. spin_lock_irqsave(&ioc->raid_device_lock, flags);
  1327. raid_device = _scsih_raid_device_find_by_id(ioc, sdev->id,
  1328. sdev->channel);
  1329. if (raid_device)
  1330. handle = raid_device->handle;
  1331. spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
  1332. if (!raid_device)
  1333. goto out;
  1334. if (mpt3sas_config_get_raid_volume_pg0(ioc, &mpi_reply, &vol_pg0,
  1335. MPI2_RAID_VOLUME_PGAD_FORM_HANDLE, handle,
  1336. sizeof(Mpi2RaidVolPage0_t))) {
  1337. pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
  1338. ioc->name, __FILE__, __LINE__, __func__);
  1339. goto out;
  1340. }
  1341. volstate = le32_to_cpu(vol_pg0.VolumeStatusFlags);
  1342. if (volstate & MPI2_RAIDVOL0_STATUS_FLAG_RESYNC_IN_PROGRESS) {
  1343. state = RAID_STATE_RESYNCING;
  1344. goto out;
  1345. }
  1346. switch (vol_pg0.VolumeState) {
  1347. case MPI2_RAID_VOL_STATE_OPTIMAL:
  1348. case MPI2_RAID_VOL_STATE_ONLINE:
  1349. state = RAID_STATE_ACTIVE;
  1350. break;
  1351. case MPI2_RAID_VOL_STATE_DEGRADED:
  1352. state = RAID_STATE_DEGRADED;
  1353. break;
  1354. case MPI2_RAID_VOL_STATE_FAILED:
  1355. case MPI2_RAID_VOL_STATE_MISSING:
  1356. state = RAID_STATE_OFFLINE;
  1357. break;
  1358. }
  1359. out:
  1360. raid_set_state(mpt3sas_raid_template, dev, state);
  1361. }
  1362. /**
  1363. * _scsih_set_level - set raid level
  1364. * @sdev: scsi device struct
  1365. * @volume_type: volume type
  1366. */
  1367. static void
  1368. _scsih_set_level(struct scsi_device *sdev, u8 volume_type)
  1369. {
  1370. enum raid_level level = RAID_LEVEL_UNKNOWN;
  1371. switch (volume_type) {
  1372. case MPI2_RAID_VOL_TYPE_RAID0:
  1373. level = RAID_LEVEL_0;
  1374. break;
  1375. case MPI2_RAID_VOL_TYPE_RAID10:
  1376. level = RAID_LEVEL_10;
  1377. break;
  1378. case MPI2_RAID_VOL_TYPE_RAID1E:
  1379. level = RAID_LEVEL_1E;
  1380. break;
  1381. case MPI2_RAID_VOL_TYPE_RAID1:
  1382. level = RAID_LEVEL_1;
  1383. break;
  1384. }
  1385. raid_set_level(mpt3sas_raid_template, &sdev->sdev_gendev, level);
  1386. }
  1387. /**
  1388. * _scsih_get_volume_capabilities - volume capabilities
  1389. * @ioc: per adapter object
  1390. * @sas_device: the raid_device object
  1391. *
  1392. * Returns 0 for success, else 1
  1393. */
  1394. static int
  1395. _scsih_get_volume_capabilities(struct MPT3SAS_ADAPTER *ioc,
  1396. struct _raid_device *raid_device)
  1397. {
  1398. Mpi2RaidVolPage0_t *vol_pg0;
  1399. Mpi2RaidPhysDiskPage0_t pd_pg0;
  1400. Mpi2SasDevicePage0_t sas_device_pg0;
  1401. Mpi2ConfigReply_t mpi_reply;
  1402. u16 sz;
  1403. u8 num_pds;
  1404. if ((mpt3sas_config_get_number_pds(ioc, raid_device->handle,
  1405. &num_pds)) || !num_pds) {
  1406. dfailprintk(ioc, pr_warn(MPT3SAS_FMT
  1407. "failure at %s:%d/%s()!\n", ioc->name, __FILE__, __LINE__,
  1408. __func__));
  1409. return 1;
  1410. }
  1411. raid_device->num_pds = num_pds;
  1412. sz = offsetof(Mpi2RaidVolPage0_t, PhysDisk) + (num_pds *
  1413. sizeof(Mpi2RaidVol0PhysDisk_t));
  1414. vol_pg0 = kzalloc(sz, GFP_KERNEL);
  1415. if (!vol_pg0) {
  1416. dfailprintk(ioc, pr_warn(MPT3SAS_FMT
  1417. "failure at %s:%d/%s()!\n", ioc->name, __FILE__, __LINE__,
  1418. __func__));
  1419. return 1;
  1420. }
  1421. if ((mpt3sas_config_get_raid_volume_pg0(ioc, &mpi_reply, vol_pg0,
  1422. MPI2_RAID_VOLUME_PGAD_FORM_HANDLE, raid_device->handle, sz))) {
  1423. dfailprintk(ioc, pr_warn(MPT3SAS_FMT
  1424. "failure at %s:%d/%s()!\n", ioc->name, __FILE__, __LINE__,
  1425. __func__));
  1426. kfree(vol_pg0);
  1427. return 1;
  1428. }
  1429. raid_device->volume_type = vol_pg0->VolumeType;
  1430. /* figure out what the underlying devices are by
  1431. * obtaining the device_info bits for the 1st device
  1432. */
  1433. if (!(mpt3sas_config_get_phys_disk_pg0(ioc, &mpi_reply,
  1434. &pd_pg0, MPI2_PHYSDISK_PGAD_FORM_PHYSDISKNUM,
  1435. vol_pg0->PhysDisk[0].PhysDiskNum))) {
  1436. if (!(mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply,
  1437. &sas_device_pg0, MPI2_SAS_DEVICE_PGAD_FORM_HANDLE,
  1438. le16_to_cpu(pd_pg0.DevHandle)))) {
  1439. raid_device->device_info =
  1440. le32_to_cpu(sas_device_pg0.DeviceInfo);
  1441. }
  1442. }
  1443. kfree(vol_pg0);
  1444. return 0;
  1445. }
  1446. /**
  1447. * _scsih_enable_tlr - setting TLR flags
  1448. * @ioc: per adapter object
  1449. * @sdev: scsi device struct
  1450. *
  1451. * Enabling Transaction Layer Retries for tape devices when
  1452. * vpd page 0x90 is present
  1453. *
  1454. */
  1455. static void
  1456. _scsih_enable_tlr(struct MPT3SAS_ADAPTER *ioc, struct scsi_device *sdev)
  1457. {
  1458. /* only for TAPE */
  1459. if (sdev->type != TYPE_TAPE)
  1460. return;
  1461. if (!(ioc->facts.IOCCapabilities & MPI2_IOCFACTS_CAPABILITY_TLR))
  1462. return;
  1463. sas_enable_tlr(sdev);
  1464. sdev_printk(KERN_INFO, sdev, "TLR %s\n",
  1465. sas_is_tlr_enabled(sdev) ? "Enabled" : "Disabled");
  1466. return;
  1467. }
  1468. /**
  1469. * _scsih_slave_configure - device configure routine.
  1470. * @sdev: scsi device struct
  1471. *
  1472. * Returns 0 if ok. Any other return is assumed to be an error and
  1473. * the device is ignored.
  1474. */
  1475. static int
  1476. _scsih_slave_configure(struct scsi_device *sdev)
  1477. {
  1478. struct Scsi_Host *shost = sdev->host;
  1479. struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
  1480. struct MPT3SAS_DEVICE *sas_device_priv_data;
  1481. struct MPT3SAS_TARGET *sas_target_priv_data;
  1482. struct _sas_device *sas_device;
  1483. struct _raid_device *raid_device;
  1484. unsigned long flags;
  1485. int qdepth;
  1486. u8 ssp_target = 0;
  1487. char *ds = "";
  1488. char *r_level = "";
  1489. u16 handle, volume_handle = 0;
  1490. u64 volume_wwid = 0;
  1491. qdepth = 1;
  1492. sas_device_priv_data = sdev->hostdata;
  1493. sas_device_priv_data->configured_lun = 1;
  1494. sas_device_priv_data->flags &= ~MPT_DEVICE_FLAGS_INIT;
  1495. sas_target_priv_data = sas_device_priv_data->sas_target;
  1496. handle = sas_target_priv_data->handle;
  1497. /* raid volume handling */
  1498. if (sas_target_priv_data->flags & MPT_TARGET_FLAGS_VOLUME) {
  1499. spin_lock_irqsave(&ioc->raid_device_lock, flags);
  1500. raid_device = _scsih_raid_device_find_by_handle(ioc, handle);
  1501. spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
  1502. if (!raid_device) {
  1503. dfailprintk(ioc, pr_warn(MPT3SAS_FMT
  1504. "failure at %s:%d/%s()!\n", ioc->name, __FILE__,
  1505. __LINE__, __func__));
  1506. return 1;
  1507. }
  1508. if (_scsih_get_volume_capabilities(ioc, raid_device)) {
  1509. dfailprintk(ioc, pr_warn(MPT3SAS_FMT
  1510. "failure at %s:%d/%s()!\n", ioc->name, __FILE__,
  1511. __LINE__, __func__));
  1512. return 1;
  1513. }
  1514. /* RAID Queue Depth Support
  1515. * IS volume = underlying qdepth of drive type, either
  1516. * MPT3SAS_SAS_QUEUE_DEPTH or MPT3SAS_SATA_QUEUE_DEPTH
  1517. * IM/IME/R10 = 128 (MPT3SAS_RAID_QUEUE_DEPTH)
  1518. */
  1519. if (raid_device->device_info &
  1520. MPI2_SAS_DEVICE_INFO_SSP_TARGET) {
  1521. qdepth = MPT3SAS_SAS_QUEUE_DEPTH;
  1522. ds = "SSP";
  1523. } else {
  1524. qdepth = MPT3SAS_SATA_QUEUE_DEPTH;
  1525. if (raid_device->device_info &
  1526. MPI2_SAS_DEVICE_INFO_SATA_DEVICE)
  1527. ds = "SATA";
  1528. else
  1529. ds = "STP";
  1530. }
  1531. switch (raid_device->volume_type) {
  1532. case MPI2_RAID_VOL_TYPE_RAID0:
  1533. r_level = "RAID0";
  1534. break;
  1535. case MPI2_RAID_VOL_TYPE_RAID1E:
  1536. qdepth = MPT3SAS_RAID_QUEUE_DEPTH;
  1537. if (ioc->manu_pg10.OEMIdentifier &&
  1538. (le32_to_cpu(ioc->manu_pg10.GenericFlags0) &
  1539. MFG10_GF0_R10_DISPLAY) &&
  1540. !(raid_device->num_pds % 2))
  1541. r_level = "RAID10";
  1542. else
  1543. r_level = "RAID1E";
  1544. break;
  1545. case MPI2_RAID_VOL_TYPE_RAID1:
  1546. qdepth = MPT3SAS_RAID_QUEUE_DEPTH;
  1547. r_level = "RAID1";
  1548. break;
  1549. case MPI2_RAID_VOL_TYPE_RAID10:
  1550. qdepth = MPT3SAS_RAID_QUEUE_DEPTH;
  1551. r_level = "RAID10";
  1552. break;
  1553. case MPI2_RAID_VOL_TYPE_UNKNOWN:
  1554. default:
  1555. qdepth = MPT3SAS_RAID_QUEUE_DEPTH;
  1556. r_level = "RAIDX";
  1557. break;
  1558. }
  1559. sdev_printk(KERN_INFO, sdev,
  1560. "%s: handle(0x%04x), wwid(0x%016llx), pd_count(%d), type(%s)\n",
  1561. r_level, raid_device->handle,
  1562. (unsigned long long)raid_device->wwid,
  1563. raid_device->num_pds, ds);
  1564. _scsih_change_queue_depth(sdev, qdepth, SCSI_QDEPTH_DEFAULT);
  1565. /* raid transport support */
  1566. _scsih_set_level(sdev, raid_device->volume_type);
  1567. return 0;
  1568. }
  1569. /* non-raid handling */
  1570. if (sas_target_priv_data->flags & MPT_TARGET_FLAGS_RAID_COMPONENT) {
  1571. if (mpt3sas_config_get_volume_handle(ioc, handle,
  1572. &volume_handle)) {
  1573. dfailprintk(ioc, pr_warn(MPT3SAS_FMT
  1574. "failure at %s:%d/%s()!\n", ioc->name,
  1575. __FILE__, __LINE__, __func__));
  1576. return 1;
  1577. }
  1578. if (volume_handle && mpt3sas_config_get_volume_wwid(ioc,
  1579. volume_handle, &volume_wwid)) {
  1580. dfailprintk(ioc, pr_warn(MPT3SAS_FMT
  1581. "failure at %s:%d/%s()!\n", ioc->name,
  1582. __FILE__, __LINE__, __func__));
  1583. return 1;
  1584. }
  1585. }
  1586. spin_lock_irqsave(&ioc->sas_device_lock, flags);
  1587. sas_device = mpt3sas_scsih_sas_device_find_by_sas_address(ioc,
  1588. sas_device_priv_data->sas_target->sas_address);
  1589. if (!sas_device) {
  1590. spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
  1591. dfailprintk(ioc, pr_warn(MPT3SAS_FMT
  1592. "failure at %s:%d/%s()!\n", ioc->name, __FILE__, __LINE__,
  1593. __func__));
  1594. return 1;
  1595. }
  1596. sas_device->volume_handle = volume_handle;
  1597. sas_device->volume_wwid = volume_wwid;
  1598. if (sas_device->device_info & MPI2_SAS_DEVICE_INFO_SSP_TARGET) {
  1599. qdepth = MPT3SAS_SAS_QUEUE_DEPTH;
  1600. ssp_target = 1;
  1601. ds = "SSP";
  1602. } else {
  1603. qdepth = MPT3SAS_SATA_QUEUE_DEPTH;
  1604. if (sas_device->device_info & MPI2_SAS_DEVICE_INFO_STP_TARGET)
  1605. ds = "STP";
  1606. else if (sas_device->device_info &
  1607. MPI2_SAS_DEVICE_INFO_SATA_DEVICE)
  1608. ds = "SATA";
  1609. }
  1610. sdev_printk(KERN_INFO, sdev, "%s: handle(0x%04x), " \
  1611. "sas_addr(0x%016llx), phy(%d), device_name(0x%016llx)\n",
  1612. ds, handle, (unsigned long long)sas_device->sas_address,
  1613. sas_device->phy, (unsigned long long)sas_device->device_name);
  1614. sdev_printk(KERN_INFO, sdev,
  1615. "%s: enclosure_logical_id(0x%016llx), slot(%d)\n",
  1616. ds, (unsigned long long)
  1617. sas_device->enclosure_logical_id, sas_device->slot);
  1618. spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
  1619. if (!ssp_target)
  1620. _scsih_display_sata_capabilities(ioc, handle, sdev);
  1621. _scsih_change_queue_depth(sdev, qdepth, SCSI_QDEPTH_DEFAULT);
  1622. if (ssp_target) {
  1623. sas_read_port_mode_page(sdev);
  1624. _scsih_enable_tlr(ioc, sdev);
  1625. }
  1626. return 0;
  1627. }
  1628. /**
  1629. * _scsih_bios_param - fetch head, sector, cylinder info for a disk
  1630. * @sdev: scsi device struct
  1631. * @bdev: pointer to block device context
  1632. * @capacity: device size (in 512 byte sectors)
  1633. * @params: three element array to place output:
  1634. * params[0] number of heads (max 255)
  1635. * params[1] number of sectors (max 63)
  1636. * params[2] number of cylinders
  1637. *
  1638. * Return nothing.
  1639. */
  1640. static int
  1641. _scsih_bios_param(struct scsi_device *sdev, struct block_device *bdev,
  1642. sector_t capacity, int params[])
  1643. {
  1644. int heads;
  1645. int sectors;
  1646. sector_t cylinders;
  1647. ulong dummy;
  1648. heads = 64;
  1649. sectors = 32;
  1650. dummy = heads * sectors;
  1651. cylinders = capacity;
  1652. sector_div(cylinders, dummy);
  1653. /*
  1654. * Handle extended translation size for logical drives
  1655. * > 1Gb
  1656. */
  1657. if ((ulong)capacity >= 0x200000) {
  1658. heads = 255;
  1659. sectors = 63;
  1660. dummy = heads * sectors;
  1661. cylinders = capacity;
  1662. sector_div(cylinders, dummy);
  1663. }
  1664. /* return result */
  1665. params[0] = heads;
  1666. params[1] = sectors;
  1667. params[2] = cylinders;
  1668. return 0;
  1669. }
  1670. /**
  1671. * _scsih_response_code - translation of device response code
  1672. * @ioc: per adapter object
  1673. * @response_code: response code returned by the device
  1674. *
  1675. * Return nothing.
  1676. */
  1677. static void
  1678. _scsih_response_code(struct MPT3SAS_ADAPTER *ioc, u8 response_code)
  1679. {
  1680. char *desc;
  1681. switch (response_code) {
  1682. case MPI2_SCSITASKMGMT_RSP_TM_COMPLETE:
  1683. desc = "task management request completed";
  1684. break;
  1685. case MPI2_SCSITASKMGMT_RSP_INVALID_FRAME:
  1686. desc = "invalid frame";
  1687. break;
  1688. case MPI2_SCSITASKMGMT_RSP_TM_NOT_SUPPORTED:
  1689. desc = "task management request not supported";
  1690. break;
  1691. case MPI2_SCSITASKMGMT_RSP_TM_FAILED:
  1692. desc = "task management request failed";
  1693. break;
  1694. case MPI2_SCSITASKMGMT_RSP_TM_SUCCEEDED:
  1695. desc = "task management request succeeded";
  1696. break;
  1697. case MPI2_SCSITASKMGMT_RSP_TM_INVALID_LUN:
  1698. desc = "invalid lun";
  1699. break;
  1700. case 0xA:
  1701. desc = "overlapped tag attempted";
  1702. break;
  1703. case MPI2_SCSITASKMGMT_RSP_IO_QUEUED_ON_IOC:
  1704. desc = "task queued, however not sent to target";
  1705. break;
  1706. default:
  1707. desc = "unknown";
  1708. break;
  1709. }
  1710. pr_warn(MPT3SAS_FMT "response_code(0x%01x): %s\n",
  1711. ioc->name, response_code, desc);
  1712. }
  1713. /**
  1714. * _scsih_tm_done - tm completion routine
  1715. * @ioc: per adapter object
  1716. * @smid: system request message index
  1717. * @msix_index: MSIX table index supplied by the OS
  1718. * @reply: reply message frame(lower 32bit addr)
  1719. * Context: none.
  1720. *
  1721. * The callback handler when using scsih_issue_tm.
  1722. *
  1723. * Return 1 meaning mf should be freed from _base_interrupt
  1724. * 0 means the mf is freed from this function.
  1725. */
  1726. static u8
  1727. _scsih_tm_done(struct MPT3SAS_ADAPTER *ioc, u16 smid, u8 msix_index, u32 reply)
  1728. {
  1729. MPI2DefaultReply_t *mpi_reply;
  1730. if (ioc->tm_cmds.status == MPT3_CMD_NOT_USED)
  1731. return 1;
  1732. if (ioc->tm_cmds.smid != smid)
  1733. return 1;
  1734. mpt3sas_base_flush_reply_queues(ioc);
  1735. ioc->tm_cmds.status |= MPT3_CMD_COMPLETE;
  1736. mpi_reply = mpt3sas_base_get_reply_virt_addr(ioc, reply);
  1737. if (mpi_reply) {
  1738. memcpy(ioc->tm_cmds.reply, mpi_reply, mpi_reply->MsgLength*4);
  1739. ioc->tm_cmds.status |= MPT3_CMD_REPLY_VALID;
  1740. }
  1741. ioc->tm_cmds.status &= ~MPT3_CMD_PENDING;
  1742. complete(&ioc->tm_cmds.done);
  1743. return 1;
  1744. }
  1745. /**
  1746. * mpt3sas_scsih_set_tm_flag - set per target tm_busy
  1747. * @ioc: per adapter object
  1748. * @handle: device handle
  1749. *
  1750. * During taskmangement request, we need to freeze the device queue.
  1751. */
  1752. void
  1753. mpt3sas_scsih_set_tm_flag(struct MPT3SAS_ADAPTER *ioc, u16 handle)
  1754. {
  1755. struct MPT3SAS_DEVICE *sas_device_priv_data;
  1756. struct scsi_device *sdev;
  1757. u8 skip = 0;
  1758. shost_for_each_device(sdev, ioc->shost) {
  1759. if (skip)
  1760. continue;
  1761. sas_device_priv_data = sdev->hostdata;
  1762. if (!sas_device_priv_data)
  1763. continue;
  1764. if (sas_device_priv_data->sas_target->handle == handle) {
  1765. sas_device_priv_data->sas_target->tm_busy = 1;
  1766. skip = 1;
  1767. ioc->ignore_loginfos = 1;
  1768. }
  1769. }
  1770. }
  1771. /**
  1772. * mpt3sas_scsih_clear_tm_flag - clear per target tm_busy
  1773. * @ioc: per adapter object
  1774. * @handle: device handle
  1775. *
  1776. * During taskmangement request, we need to freeze the device queue.
  1777. */
  1778. void
  1779. mpt3sas_scsih_clear_tm_flag(struct MPT3SAS_ADAPTER *ioc, u16 handle)
  1780. {
  1781. struct MPT3SAS_DEVICE *sas_device_priv_data;
  1782. struct scsi_device *sdev;
  1783. u8 skip = 0;
  1784. shost_for_each_device(sdev, ioc->shost) {
  1785. if (skip)
  1786. continue;
  1787. sas_device_priv_data = sdev->hostdata;
  1788. if (!sas_device_priv_data)
  1789. continue;
  1790. if (sas_device_priv_data->sas_target->handle == handle) {
  1791. sas_device_priv_data->sas_target->tm_busy = 0;
  1792. skip = 1;
  1793. ioc->ignore_loginfos = 0;
  1794. }
  1795. }
  1796. }
  1797. /**
  1798. * mpt3sas_scsih_issue_tm - main routine for sending tm requests
  1799. * @ioc: per adapter struct
  1800. * @device_handle: device handle
  1801. * @channel: the channel assigned by the OS
  1802. * @id: the id assigned by the OS
  1803. * @lun: lun number
  1804. * @type: MPI2_SCSITASKMGMT_TASKTYPE__XXX (defined in mpi2_init.h)
  1805. * @smid_task: smid assigned to the task
  1806. * @timeout: timeout in seconds
  1807. * @serial_number: the serial_number from scmd
  1808. * @m_type: TM_MUTEX_ON or TM_MUTEX_OFF
  1809. * Context: user
  1810. *
  1811. * A generic API for sending task management requests to firmware.
  1812. *
  1813. * The callback index is set inside `ioc->tm_cb_idx`.
  1814. *
  1815. * Return SUCCESS or FAILED.
  1816. */
  1817. int
  1818. mpt3sas_scsih_issue_tm(struct MPT3SAS_ADAPTER *ioc, u16 handle, uint channel,
  1819. uint id, uint lun, u8 type, u16 smid_task, ulong timeout,
  1820. unsigned long serial_number, enum mutex_type m_type)
  1821. {
  1822. Mpi2SCSITaskManagementRequest_t *mpi_request;
  1823. Mpi2SCSITaskManagementReply_t *mpi_reply;
  1824. u16 smid = 0;
  1825. u32 ioc_state;
  1826. unsigned long timeleft;
  1827. struct scsiio_tracker *scsi_lookup = NULL;
  1828. int rc;
  1829. if (m_type == TM_MUTEX_ON)
  1830. mutex_lock(&ioc->tm_cmds.mutex);
  1831. if (ioc->tm_cmds.status != MPT3_CMD_NOT_USED) {
  1832. pr_info(MPT3SAS_FMT "%s: tm_cmd busy!!!\n",
  1833. __func__, ioc->name);
  1834. rc = FAILED;
  1835. goto err_out;
  1836. }
  1837. if (ioc->shost_recovery || ioc->remove_host ||
  1838. ioc->pci_error_recovery) {
  1839. pr_info(MPT3SAS_FMT "%s: host reset in progress!\n",
  1840. __func__, ioc->name);
  1841. rc = FAILED;
  1842. goto err_out;
  1843. }
  1844. ioc_state = mpt3sas_base_get_iocstate(ioc, 0);
  1845. if (ioc_state & MPI2_DOORBELL_USED) {
  1846. dhsprintk(ioc, pr_info(MPT3SAS_FMT
  1847. "unexpected doorbell active!\n", ioc->name));
  1848. rc = mpt3sas_base_hard_reset_handler(ioc, CAN_SLEEP,
  1849. FORCE_BIG_HAMMER);
  1850. rc = (!rc) ? SUCCESS : FAILED;
  1851. goto err_out;
  1852. }
  1853. if ((ioc_state & MPI2_IOC_STATE_MASK) == MPI2_IOC_STATE_FAULT) {
  1854. mpt3sas_base_fault_info(ioc, ioc_state &
  1855. MPI2_DOORBELL_DATA_MASK);
  1856. rc = mpt3sas_base_hard_reset_handler(ioc, CAN_SLEEP,
  1857. FORCE_BIG_HAMMER);
  1858. rc = (!rc) ? SUCCESS : FAILED;
  1859. goto err_out;
  1860. }
  1861. smid = mpt3sas_base_get_smid_hpr(ioc, ioc->tm_cb_idx);
  1862. if (!smid) {
  1863. pr_err(MPT3SAS_FMT "%s: failed obtaining a smid\n",
  1864. ioc->name, __func__);
  1865. rc = FAILED;
  1866. goto err_out;
  1867. }
  1868. if (type == MPI2_SCSITASKMGMT_TASKTYPE_ABORT_TASK)
  1869. scsi_lookup = &ioc->scsi_lookup[smid_task - 1];
  1870. dtmprintk(ioc, pr_info(MPT3SAS_FMT
  1871. "sending tm: handle(0x%04x), task_type(0x%02x), smid(%d)\n",
  1872. ioc->name, handle, type, smid_task));
  1873. ioc->tm_cmds.status = MPT3_CMD_PENDING;
  1874. mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
  1875. ioc->tm_cmds.smid = smid;
  1876. memset(mpi_request, 0, sizeof(Mpi2SCSITaskManagementRequest_t));
  1877. memset(ioc->tm_cmds.reply, 0, sizeof(Mpi2SCSITaskManagementReply_t));
  1878. mpi_request->Function = MPI2_FUNCTION_SCSI_TASK_MGMT;
  1879. mpi_request->DevHandle = cpu_to_le16(handle);
  1880. mpi_request->TaskType = type;
  1881. mpi_request->TaskMID = cpu_to_le16(smid_task);
  1882. int_to_scsilun(lun, (struct scsi_lun *)mpi_request->LUN);
  1883. mpt3sas_scsih_set_tm_flag(ioc, handle);
  1884. init_completion(&ioc->tm_cmds.done);
  1885. mpt3sas_base_put_smid_hi_priority(ioc, smid);
  1886. timeleft = wait_for_completion_timeout(&ioc->tm_cmds.done, timeout*HZ);
  1887. if (!(ioc->tm_cmds.status & MPT3_CMD_COMPLETE)) {
  1888. pr_err(MPT3SAS_FMT "%s: timeout\n",
  1889. ioc->name, __func__);
  1890. _debug_dump_mf(mpi_request,
  1891. sizeof(Mpi2SCSITaskManagementRequest_t)/4);
  1892. if (!(ioc->tm_cmds.status & MPT3_CMD_RESET)) {
  1893. rc = mpt3sas_base_hard_reset_handler(ioc, CAN_SLEEP,
  1894. FORCE_BIG_HAMMER);
  1895. rc = (!rc) ? SUCCESS : FAILED;
  1896. ioc->tm_cmds.status = MPT3_CMD_NOT_USED;
  1897. mpt3sas_scsih_clear_tm_flag(ioc, handle);
  1898. goto err_out;
  1899. }
  1900. }
  1901. if (ioc->tm_cmds.status & MPT3_CMD_REPLY_VALID) {
  1902. mpt3sas_trigger_master(ioc, MASTER_TRIGGER_TASK_MANAGMENT);
  1903. mpi_reply = ioc->tm_cmds.reply;
  1904. dtmprintk(ioc, pr_info(MPT3SAS_FMT "complete tm: " \
  1905. "ioc_status(0x%04x), loginfo(0x%08x), term_count(0x%08x)\n",
  1906. ioc->name, le16_to_cpu(mpi_reply->IOCStatus),
  1907. le32_to_cpu(mpi_reply->IOCLogInfo),
  1908. le32_to_cpu(mpi_reply->TerminationCount)));
  1909. if (ioc->logging_level & MPT_DEBUG_TM) {
  1910. _scsih_response_code(ioc, mpi_reply->ResponseCode);
  1911. if (mpi_reply->IOCStatus)
  1912. _debug_dump_mf(mpi_request,
  1913. sizeof(Mpi2SCSITaskManagementRequest_t)/4);
  1914. }
  1915. }
  1916. switch (type) {
  1917. case MPI2_SCSITASKMGMT_TASKTYPE_ABORT_TASK:
  1918. rc = SUCCESS;
  1919. if (scsi_lookup->scmd == NULL)
  1920. break;
  1921. rc = FAILED;
  1922. break;
  1923. case MPI2_SCSITASKMGMT_TASKTYPE_TARGET_RESET:
  1924. if (_scsih_scsi_lookup_find_by_target(ioc, id, channel))
  1925. rc = FAILED;
  1926. else
  1927. rc = SUCCESS;
  1928. break;
  1929. case MPI2_SCSITASKMGMT_TASKTYPE_ABRT_TASK_SET:
  1930. case MPI2_SCSITASKMGMT_TASKTYPE_LOGICAL_UNIT_RESET:
  1931. if (_scsih_scsi_lookup_find_by_lun(ioc, id, lun, channel))
  1932. rc = FAILED;
  1933. else
  1934. rc = SUCCESS;
  1935. break;
  1936. case MPI2_SCSITASKMGMT_TASKTYPE_QUERY_TASK:
  1937. rc = SUCCESS;
  1938. break;
  1939. default:
  1940. rc = FAILED;
  1941. break;
  1942. }
  1943. mpt3sas_scsih_clear_tm_flag(ioc, handle);
  1944. ioc->tm_cmds.status = MPT3_CMD_NOT_USED;
  1945. if (m_type == TM_MUTEX_ON)
  1946. mutex_unlock(&ioc->tm_cmds.mutex);
  1947. return rc;
  1948. err_out:
  1949. if (m_type == TM_MUTEX_ON)
  1950. mutex_unlock(&ioc->tm_cmds.mutex);
  1951. return rc;
  1952. }
  1953. /**
  1954. * _scsih_tm_display_info - displays info about the device
  1955. * @ioc: per adapter struct
  1956. * @scmd: pointer to scsi command object
  1957. *
  1958. * Called by task management callback handlers.
  1959. */
  1960. static void
  1961. _scsih_tm_display_info(struct MPT3SAS_ADAPTER *ioc, struct scsi_cmnd *scmd)
  1962. {
  1963. struct scsi_target *starget = scmd->device->sdev_target;
  1964. struct MPT3SAS_TARGET *priv_target = starget->hostdata;
  1965. struct _sas_device *sas_device = NULL;
  1966. unsigned long flags;
  1967. char *device_str = NULL;
  1968. if (!priv_target)
  1969. return;
  1970. device_str = "volume";
  1971. scsi_print_command(scmd);
  1972. if (priv_target->flags & MPT_TARGET_FLAGS_VOLUME) {
  1973. starget_printk(KERN_INFO, starget,
  1974. "%s handle(0x%04x), %s wwid(0x%016llx)\n",
  1975. device_str, priv_target->handle,
  1976. device_str, (unsigned long long)priv_target->sas_address);
  1977. } else {
  1978. spin_lock_irqsave(&ioc->sas_device_lock, flags);
  1979. sas_device = mpt3sas_scsih_sas_device_find_by_sas_address(ioc,
  1980. priv_target->sas_address);
  1981. if (sas_device) {
  1982. if (priv_target->flags &
  1983. MPT_TARGET_FLAGS_RAID_COMPONENT) {
  1984. starget_printk(KERN_INFO, starget,
  1985. "volume handle(0x%04x), "
  1986. "volume wwid(0x%016llx)\n",
  1987. sas_device->volume_handle,
  1988. (unsigned long long)sas_device->volume_wwid);
  1989. }
  1990. starget_printk(KERN_INFO, starget,
  1991. "handle(0x%04x), sas_address(0x%016llx), phy(%d)\n",
  1992. sas_device->handle,
  1993. (unsigned long long)sas_device->sas_address,
  1994. sas_device->phy);
  1995. starget_printk(KERN_INFO, starget,
  1996. "enclosure_logical_id(0x%016llx), slot(%d)\n",
  1997. (unsigned long long)sas_device->enclosure_logical_id,
  1998. sas_device->slot);
  1999. }
  2000. spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
  2001. }
  2002. }
  2003. /**
  2004. * _scsih_abort - eh threads main abort routine
  2005. * @scmd: pointer to scsi command object
  2006. *
  2007. * Returns SUCCESS if command aborted else FAILED
  2008. */
  2009. static int
  2010. _scsih_abort(struct scsi_cmnd *scmd)
  2011. {
  2012. struct MPT3SAS_ADAPTER *ioc = shost_priv(scmd->device->host);
  2013. struct MPT3SAS_DEVICE *sas_device_priv_data;
  2014. u16 smid;
  2015. u16 handle;
  2016. int r;
  2017. sdev_printk(KERN_INFO, scmd->device,
  2018. "attempting task abort! scmd(%p)\n", scmd);
  2019. _scsih_tm_display_info(ioc, scmd);
  2020. sas_device_priv_data = scmd->device->hostdata;
  2021. if (!sas_device_priv_data || !sas_device_priv_data->sas_target) {
  2022. sdev_printk(KERN_INFO, scmd->device,
  2023. "device been deleted! scmd(%p)\n", scmd);
  2024. scmd->result = DID_NO_CONNECT << 16;
  2025. scmd->scsi_done(scmd);
  2026. r = SUCCESS;
  2027. goto out;
  2028. }
  2029. /* search for the command */
  2030. smid = _scsih_scsi_lookup_find_by_scmd(ioc, scmd);
  2031. if (!smid) {
  2032. scmd->result = DID_RESET << 16;
  2033. r = SUCCESS;
  2034. goto out;
  2035. }
  2036. /* for hidden raid components and volumes this is not supported */
  2037. if (sas_device_priv_data->sas_target->flags &
  2038. MPT_TARGET_FLAGS_RAID_COMPONENT ||
  2039. sas_device_priv_data->sas_target->flags & MPT_TARGET_FLAGS_VOLUME) {
  2040. scmd->result = DID_RESET << 16;
  2041. r = FAILED;
  2042. goto out;
  2043. }
  2044. mpt3sas_halt_firmware(ioc);
  2045. handle = sas_device_priv_data->sas_target->handle;
  2046. r = mpt3sas_scsih_issue_tm(ioc, handle, scmd->device->channel,
  2047. scmd->device->id, scmd->device->lun,
  2048. MPI2_SCSITASKMGMT_TASKTYPE_ABORT_TASK, smid, 30,
  2049. scmd->serial_number, TM_MUTEX_ON);
  2050. out:
  2051. sdev_printk(KERN_INFO, scmd->device, "task abort: %s scmd(%p)\n",
  2052. ((r == SUCCESS) ? "SUCCESS" : "FAILED"), scmd);
  2053. return r;
  2054. }
  2055. /**
  2056. * _scsih_dev_reset - eh threads main device reset routine
  2057. * @scmd: pointer to scsi command object
  2058. *
  2059. * Returns SUCCESS if command aborted else FAILED
  2060. */
  2061. static int
  2062. _scsih_dev_reset(struct scsi_cmnd *scmd)
  2063. {
  2064. struct MPT3SAS_ADAPTER *ioc = shost_priv(scmd->device->host);
  2065. struct MPT3SAS_DEVICE *sas_device_priv_data;
  2066. struct _sas_device *sas_device;
  2067. unsigned long flags;
  2068. u16 handle;
  2069. int r;
  2070. sdev_printk(KERN_INFO, scmd->device,
  2071. "attempting device reset! scmd(%p)\n", scmd);
  2072. _scsih_tm_display_info(ioc, scmd);
  2073. sas_device_priv_data = scmd->device->hostdata;
  2074. if (!sas_device_priv_data || !sas_device_priv_data->sas_target) {
  2075. sdev_printk(KERN_INFO, scmd->device,
  2076. "device been deleted! scmd(%p)\n", scmd);
  2077. scmd->result = DID_NO_CONNECT << 16;
  2078. scmd->scsi_done(scmd);
  2079. r = SUCCESS;
  2080. goto out;
  2081. }
  2082. /* for hidden raid components obtain the volume_handle */
  2083. handle = 0;
  2084. if (sas_device_priv_data->sas_target->flags &
  2085. MPT_TARGET_FLAGS_RAID_COMPONENT) {
  2086. spin_lock_irqsave(&ioc->sas_device_lock, flags);
  2087. sas_device = _scsih_sas_device_find_by_handle(ioc,
  2088. sas_device_priv_data->sas_target->handle);
  2089. if (sas_device)
  2090. handle = sas_device->volume_handle;
  2091. spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
  2092. } else
  2093. handle = sas_device_priv_data->sas_target->handle;
  2094. if (!handle) {
  2095. scmd->result = DID_RESET << 16;
  2096. r = FAILED;
  2097. goto out;
  2098. }
  2099. r = mpt3sas_scsih_issue_tm(ioc, handle, scmd->device->channel,
  2100. scmd->device->id, scmd->device->lun,
  2101. MPI2_SCSITASKMGMT_TASKTYPE_LOGICAL_UNIT_RESET, 0, 30, 0,
  2102. TM_MUTEX_ON);
  2103. out:
  2104. sdev_printk(KERN_INFO, scmd->device, "device reset: %s scmd(%p)\n",
  2105. ((r == SUCCESS) ? "SUCCESS" : "FAILED"), scmd);
  2106. return r;
  2107. }
  2108. /**
  2109. * _scsih_target_reset - eh threads main target reset routine
  2110. * @scmd: pointer to scsi command object
  2111. *
  2112. * Returns SUCCESS if command aborted else FAILED
  2113. */
  2114. static int
  2115. _scsih_target_reset(struct scsi_cmnd *scmd)
  2116. {
  2117. struct MPT3SAS_ADAPTER *ioc = shost_priv(scmd->device->host);
  2118. struct MPT3SAS_DEVICE *sas_device_priv_data;
  2119. struct _sas_device *sas_device;
  2120. unsigned long flags;
  2121. u16 handle;
  2122. int r;
  2123. struct scsi_target *starget = scmd->device->sdev_target;
  2124. starget_printk(KERN_INFO, starget, "attempting target reset! scmd(%p)\n",
  2125. scmd);
  2126. _scsih_tm_display_info(ioc, scmd);
  2127. sas_device_priv_data = scmd->device->hostdata;
  2128. if (!sas_device_priv_data || !sas_device_priv_data->sas_target) {
  2129. starget_printk(KERN_INFO, starget, "target been deleted! scmd(%p)\n",
  2130. scmd);
  2131. scmd->result = DID_NO_CONNECT << 16;
  2132. scmd->scsi_done(scmd);
  2133. r = SUCCESS;
  2134. goto out;
  2135. }
  2136. /* for hidden raid components obtain the volume_handle */
  2137. handle = 0;
  2138. if (sas_device_priv_data->sas_target->flags &
  2139. MPT_TARGET_FLAGS_RAID_COMPONENT) {
  2140. spin_lock_irqsave(&ioc->sas_device_lock, flags);
  2141. sas_device = _scsih_sas_device_find_by_handle(ioc,
  2142. sas_device_priv_data->sas_target->handle);
  2143. if (sas_device)
  2144. handle = sas_device->volume_handle;
  2145. spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
  2146. } else
  2147. handle = sas_device_priv_data->sas_target->handle;
  2148. if (!handle) {
  2149. scmd->result = DID_RESET << 16;
  2150. r = FAILED;
  2151. goto out;
  2152. }
  2153. r = mpt3sas_scsih_issue_tm(ioc, handle, scmd->device->channel,
  2154. scmd->device->id, 0, MPI2_SCSITASKMGMT_TASKTYPE_TARGET_RESET, 0,
  2155. 30, 0, TM_MUTEX_ON);
  2156. out:
  2157. starget_printk(KERN_INFO, starget, "target reset: %s scmd(%p)\n",
  2158. ((r == SUCCESS) ? "SUCCESS" : "FAILED"), scmd);
  2159. return r;
  2160. }
  2161. /**
  2162. * _scsih_host_reset - eh threads main host reset routine
  2163. * @scmd: pointer to scsi command object
  2164. *
  2165. * Returns SUCCESS if command aborted else FAILED
  2166. */
  2167. static int
  2168. _scsih_host_reset(struct scsi_cmnd *scmd)
  2169. {
  2170. struct MPT3SAS_ADAPTER *ioc = shost_priv(scmd->device->host);
  2171. int r, retval;
  2172. pr_info(MPT3SAS_FMT "attempting host reset! scmd(%p)\n",
  2173. ioc->name, scmd);
  2174. scsi_print_command(scmd);
  2175. retval = mpt3sas_base_hard_reset_handler(ioc, CAN_SLEEP,
  2176. FORCE_BIG_HAMMER);
  2177. r = (retval < 0) ? FAILED : SUCCESS;
  2178. pr_info(MPT3SAS_FMT "host reset: %s scmd(%p)\n",
  2179. ioc->name, ((r == SUCCESS) ? "SUCCESS" : "FAILED"), scmd);
  2180. return r;
  2181. }
  2182. /**
  2183. * _scsih_fw_event_add - insert and queue up fw_event
  2184. * @ioc: per adapter object
  2185. * @fw_event: object describing the event
  2186. * Context: This function will acquire ioc->fw_event_lock.
  2187. *
  2188. * This adds the firmware event object into link list, then queues it up to
  2189. * be processed from user context.
  2190. *
  2191. * Return nothing.
  2192. */
  2193. static void
  2194. _scsih_fw_event_add(struct MPT3SAS_ADAPTER *ioc, struct fw_event_work *fw_event)
  2195. {
  2196. unsigned long flags;
  2197. if (ioc->firmware_event_thread == NULL)
  2198. return;
  2199. spin_lock_irqsave(&ioc->fw_event_lock, flags);
  2200. INIT_LIST_HEAD(&fw_event->list);
  2201. list_add_tail(&fw_event->list, &ioc->fw_event_list);
  2202. INIT_WORK(&fw_event->work, _firmware_event_work);
  2203. queue_work(ioc->firmware_event_thread, &fw_event->work);
  2204. spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
  2205. }
  2206. /**
  2207. * _scsih_fw_event_free - delete fw_event
  2208. * @ioc: per adapter object
  2209. * @fw_event: object describing the event
  2210. * Context: This function will acquire ioc->fw_event_lock.
  2211. *
  2212. * This removes firmware event object from link list, frees associated memory.
  2213. *
  2214. * Return nothing.
  2215. */
  2216. static void
  2217. _scsih_fw_event_free(struct MPT3SAS_ADAPTER *ioc, struct fw_event_work
  2218. *fw_event)
  2219. {
  2220. unsigned long flags;
  2221. spin_lock_irqsave(&ioc->fw_event_lock, flags);
  2222. list_del(&fw_event->list);
  2223. kfree(fw_event->event_data);
  2224. kfree(fw_event);
  2225. spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
  2226. }
  2227. /**
  2228. * mpt3sas_send_trigger_data_event - send event for processing trigger data
  2229. * @ioc: per adapter object
  2230. * @event_data: trigger event data
  2231. *
  2232. * Return nothing.
  2233. */
  2234. void
  2235. mpt3sas_send_trigger_data_event(struct MPT3SAS_ADAPTER *ioc,
  2236. struct SL_WH_TRIGGERS_EVENT_DATA_T *event_data)
  2237. {
  2238. struct fw_event_work *fw_event;
  2239. if (ioc->is_driver_loading)
  2240. return;
  2241. fw_event = kzalloc(sizeof(struct fw_event_work), GFP_ATOMIC);
  2242. if (!fw_event)
  2243. return;
  2244. fw_event->event_data = kzalloc(sizeof(*event_data), GFP_ATOMIC);
  2245. if (!fw_event->event_data)
  2246. return;
  2247. fw_event->event = MPT3SAS_PROCESS_TRIGGER_DIAG;
  2248. fw_event->ioc = ioc;
  2249. memcpy(fw_event->event_data, event_data, sizeof(*event_data));
  2250. _scsih_fw_event_add(ioc, fw_event);
  2251. }
  2252. /**
  2253. * _scsih_error_recovery_delete_devices - remove devices not responding
  2254. * @ioc: per adapter object
  2255. *
  2256. * Return nothing.
  2257. */
  2258. static void
  2259. _scsih_error_recovery_delete_devices(struct MPT3SAS_ADAPTER *ioc)
  2260. {
  2261. struct fw_event_work *fw_event;
  2262. if (ioc->is_driver_loading)
  2263. return;
  2264. fw_event = kzalloc(sizeof(struct fw_event_work), GFP_ATOMIC);
  2265. if (!fw_event)
  2266. return;
  2267. fw_event->event = MPT3SAS_REMOVE_UNRESPONDING_DEVICES;
  2268. fw_event->ioc = ioc;
  2269. _scsih_fw_event_add(ioc, fw_event);
  2270. }
  2271. /**
  2272. * mpt3sas_port_enable_complete - port enable completed (fake event)
  2273. * @ioc: per adapter object
  2274. *
  2275. * Return nothing.
  2276. */
  2277. void
  2278. mpt3sas_port_enable_complete(struct MPT3SAS_ADAPTER *ioc)
  2279. {
  2280. struct fw_event_work *fw_event;
  2281. fw_event = kzalloc(sizeof(struct fw_event_work), GFP_ATOMIC);
  2282. if (!fw_event)
  2283. return;
  2284. fw_event->event = MPT3SAS_PORT_ENABLE_COMPLETE;
  2285. fw_event->ioc = ioc;
  2286. _scsih_fw_event_add(ioc, fw_event);
  2287. }
  2288. /**
  2289. * _scsih_fw_event_cleanup_queue - cleanup event queue
  2290. * @ioc: per adapter object
  2291. *
  2292. * Walk the firmware event queue, either killing timers, or waiting
  2293. * for outstanding events to complete
  2294. *
  2295. * Return nothing.
  2296. */
  2297. static void
  2298. _scsih_fw_event_cleanup_queue(struct MPT3SAS_ADAPTER *ioc)
  2299. {
  2300. struct fw_event_work *fw_event, *next;
  2301. if (list_empty(&ioc->fw_event_list) ||
  2302. !ioc->firmware_event_thread || in_interrupt())
  2303. return;
  2304. list_for_each_entry_safe(fw_event, next, &ioc->fw_event_list, list) {
  2305. if (cancel_delayed_work(&fw_event->delayed_work)) {
  2306. _scsih_fw_event_free(ioc, fw_event);
  2307. continue;
  2308. }
  2309. fw_event->cancel_pending_work = 1;
  2310. }
  2311. }
  2312. /**
  2313. * _scsih_ublock_io_all_device - unblock every device
  2314. * @ioc: per adapter object
  2315. *
  2316. * change the device state from block to running
  2317. */
  2318. static void
  2319. _scsih_ublock_io_all_device(struct MPT3SAS_ADAPTER *ioc)
  2320. {
  2321. struct MPT3SAS_DEVICE *sas_device_priv_data;
  2322. struct scsi_device *sdev;
  2323. shost_for_each_device(sdev, ioc->shost) {
  2324. sas_device_priv_data = sdev->hostdata;
  2325. if (!sas_device_priv_data)
  2326. continue;
  2327. if (!sas_device_priv_data->block)
  2328. continue;
  2329. sas_device_priv_data->block = 0;
  2330. dewtprintk(ioc, sdev_printk(KERN_INFO, sdev,
  2331. "device_running, handle(0x%04x)\n",
  2332. sas_device_priv_data->sas_target->handle));
  2333. scsi_internal_device_unblock(sdev, SDEV_RUNNING);
  2334. }
  2335. }
  2336. /**
  2337. * _scsih_ublock_io_device - prepare device to be deleted
  2338. * @ioc: per adapter object
  2339. * @sas_addr: sas address
  2340. *
  2341. * unblock then put device in offline state
  2342. */
  2343. static void
  2344. _scsih_ublock_io_device(struct MPT3SAS_ADAPTER *ioc, u64 sas_address)
  2345. {
  2346. struct MPT3SAS_DEVICE *sas_device_priv_data;
  2347. struct scsi_device *sdev;
  2348. shost_for_each_device(sdev, ioc->shost) {
  2349. sas_device_priv_data = sdev->hostdata;
  2350. if (!sas_device_priv_data)
  2351. continue;
  2352. if (sas_device_priv_data->sas_target->sas_address
  2353. != sas_address)
  2354. continue;
  2355. if (sas_device_priv_data->block) {
  2356. sas_device_priv_data->block = 0;
  2357. scsi_internal_device_unblock(sdev, SDEV_RUNNING);
  2358. }
  2359. }
  2360. }
  2361. /**
  2362. * _scsih_block_io_all_device - set the device state to SDEV_BLOCK
  2363. * @ioc: per adapter object
  2364. * @handle: device handle
  2365. *
  2366. * During device pull we need to appropiately set the sdev state.
  2367. */
  2368. static void
  2369. _scsih_block_io_all_device(struct MPT3SAS_ADAPTER *ioc)
  2370. {
  2371. struct MPT3SAS_DEVICE *sas_device_priv_data;
  2372. struct scsi_device *sdev;
  2373. shost_for_each_device(sdev, ioc->shost) {
  2374. sas_device_priv_data = sdev->hostdata;
  2375. if (!sas_device_priv_data)
  2376. continue;
  2377. if (sas_device_priv_data->block)
  2378. continue;
  2379. sas_device_priv_data->block = 1;
  2380. scsi_internal_device_block(sdev);
  2381. sdev_printk(KERN_INFO, sdev, "device_blocked, handle(0x%04x)\n",
  2382. sas_device_priv_data->sas_target->handle);
  2383. }
  2384. }
  2385. /**
  2386. * _scsih_block_io_device - set the device state to SDEV_BLOCK
  2387. * @ioc: per adapter object
  2388. * @handle: device handle
  2389. *
  2390. * During device pull we need to appropiately set the sdev state.
  2391. */
  2392. static void
  2393. _scsih_block_io_device(struct MPT3SAS_ADAPTER *ioc, u16 handle)
  2394. {
  2395. struct MPT3SAS_DEVICE *sas_device_priv_data;
  2396. struct scsi_device *sdev;
  2397. shost_for_each_device(sdev, ioc->shost) {
  2398. sas_device_priv_data = sdev->hostdata;
  2399. if (!sas_device_priv_data)
  2400. continue;
  2401. if (sas_device_priv_data->sas_target->handle != handle)
  2402. continue;
  2403. if (sas_device_priv_data->block)
  2404. continue;
  2405. sas_device_priv_data->block = 1;
  2406. scsi_internal_device_block(sdev);
  2407. sdev_printk(KERN_INFO, sdev,
  2408. "device_blocked, handle(0x%04x)\n", handle);
  2409. }
  2410. }
  2411. /**
  2412. * _scsih_block_io_to_children_attached_to_ex
  2413. * @ioc: per adapter object
  2414. * @sas_expander: the sas_device object
  2415. *
  2416. * This routine set sdev state to SDEV_BLOCK for all devices
  2417. * attached to this expander. This function called when expander is
  2418. * pulled.
  2419. */
  2420. static void
  2421. _scsih_block_io_to_children_attached_to_ex(struct MPT3SAS_ADAPTER *ioc,
  2422. struct _sas_node *sas_expander)
  2423. {
  2424. struct _sas_port *mpt3sas_port;
  2425. struct _sas_device *sas_device;
  2426. struct _sas_node *expander_sibling;
  2427. unsigned long flags;
  2428. if (!sas_expander)
  2429. return;
  2430. list_for_each_entry(mpt3sas_port,
  2431. &sas_expander->sas_port_list, port_list) {
  2432. if (mpt3sas_port->remote_identify.device_type ==
  2433. SAS_END_DEVICE) {
  2434. spin_lock_irqsave(&ioc->sas_device_lock, flags);
  2435. sas_device =
  2436. mpt3sas_scsih_sas_device_find_by_sas_address(ioc,
  2437. mpt3sas_port->remote_identify.sas_address);
  2438. if (sas_device)
  2439. set_bit(sas_device->handle,
  2440. ioc->blocking_handles);
  2441. spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
  2442. }
  2443. }
  2444. list_for_each_entry(mpt3sas_port,
  2445. &sas_expander->sas_port_list, port_list) {
  2446. if (mpt3sas_port->remote_identify.device_type ==
  2447. SAS_EDGE_EXPANDER_DEVICE ||
  2448. mpt3sas_port->remote_identify.device_type ==
  2449. SAS_FANOUT_EXPANDER_DEVICE) {
  2450. expander_sibling =
  2451. mpt3sas_scsih_expander_find_by_sas_address(
  2452. ioc, mpt3sas_port->remote_identify.sas_address);
  2453. _scsih_block_io_to_children_attached_to_ex(ioc,
  2454. expander_sibling);
  2455. }
  2456. }
  2457. }
  2458. /**
  2459. * _scsih_block_io_to_children_attached_directly
  2460. * @ioc: per adapter object
  2461. * @event_data: topology change event data
  2462. *
  2463. * This routine set sdev state to SDEV_BLOCK for all devices
  2464. * direct attached during device pull.
  2465. */
  2466. static void
  2467. _scsih_block_io_to_children_attached_directly(struct MPT3SAS_ADAPTER *ioc,
  2468. Mpi2EventDataSasTopologyChangeList_t *event_data)
  2469. {
  2470. int i;
  2471. u16 handle;
  2472. u16 reason_code;
  2473. for (i = 0; i < event_data->NumEntries; i++) {
  2474. handle = le16_to_cpu(event_data->PHY[i].AttachedDevHandle);
  2475. if (!handle)
  2476. continue;
  2477. reason_code = event_data->PHY[i].PhyStatus &
  2478. MPI2_EVENT_SAS_TOPO_RC_MASK;
  2479. if (reason_code == MPI2_EVENT_SAS_TOPO_RC_DELAY_NOT_RESPONDING)
  2480. _scsih_block_io_device(ioc, handle);
  2481. }
  2482. }
  2483. /**
  2484. * _scsih_tm_tr_send - send task management request
  2485. * @ioc: per adapter object
  2486. * @handle: device handle
  2487. * Context: interrupt time.
  2488. *
  2489. * This code is to initiate the device removal handshake protocol
  2490. * with controller firmware. This function will issue target reset
  2491. * using high priority request queue. It will send a sas iounit
  2492. * control request (MPI2_SAS_OP_REMOVE_DEVICE) from this completion.
  2493. *
  2494. * This is designed to send muliple task management request at the same
  2495. * time to the fifo. If the fifo is full, we will append the request,
  2496. * and process it in a future completion.
  2497. */
  2498. static void
  2499. _scsih_tm_tr_send(struct MPT3SAS_ADAPTER *ioc, u16 handle)
  2500. {
  2501. Mpi2SCSITaskManagementRequest_t *mpi_request;
  2502. u16 smid;
  2503. struct _sas_device *sas_device;
  2504. struct MPT3SAS_TARGET *sas_target_priv_data = NULL;
  2505. u64 sas_address = 0;
  2506. unsigned long flags;
  2507. struct _tr_list *delayed_tr;
  2508. u32 ioc_state;
  2509. if (ioc->remove_host) {
  2510. dewtprintk(ioc, pr_info(MPT3SAS_FMT
  2511. "%s: host has been removed: handle(0x%04x)\n",
  2512. __func__, ioc->name, handle));
  2513. return;
  2514. } else if (ioc->pci_error_recovery) {
  2515. dewtprintk(ioc, pr_info(MPT3SAS_FMT
  2516. "%s: host in pci error recovery: handle(0x%04x)\n",
  2517. __func__, ioc->name,
  2518. handle));
  2519. return;
  2520. }
  2521. ioc_state = mpt3sas_base_get_iocstate(ioc, 1);
  2522. if (ioc_state != MPI2_IOC_STATE_OPERATIONAL) {
  2523. dewtprintk(ioc, pr_info(MPT3SAS_FMT
  2524. "%s: host is not operational: handle(0x%04x)\n",
  2525. __func__, ioc->name,
  2526. handle));
  2527. return;
  2528. }
  2529. /* if PD, then return */
  2530. if (test_bit(handle, ioc->pd_handles))
  2531. return;
  2532. spin_lock_irqsave(&ioc->sas_device_lock, flags);
  2533. sas_device = _scsih_sas_device_find_by_handle(ioc, handle);
  2534. if (sas_device && sas_device->starget &&
  2535. sas_device->starget->hostdata) {
  2536. sas_target_priv_data = sas_device->starget->hostdata;
  2537. sas_target_priv_data->deleted = 1;
  2538. sas_address = sas_device->sas_address;
  2539. }
  2540. spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
  2541. if (sas_target_priv_data) {
  2542. dewtprintk(ioc, pr_info(MPT3SAS_FMT
  2543. "setting delete flag: handle(0x%04x), sas_addr(0x%016llx)\n",
  2544. ioc->name, handle,
  2545. (unsigned long long)sas_address));
  2546. _scsih_ublock_io_device(ioc, sas_address);
  2547. sas_target_priv_data->handle = MPT3SAS_INVALID_DEVICE_HANDLE;
  2548. }
  2549. smid = mpt3sas_base_get_smid_hpr(ioc, ioc->tm_tr_cb_idx);
  2550. if (!smid) {
  2551. delayed_tr = kzalloc(sizeof(*delayed_tr), GFP_ATOMIC);
  2552. if (!delayed_tr)
  2553. return;
  2554. INIT_LIST_HEAD(&delayed_tr->list);
  2555. delayed_tr->handle = handle;
  2556. list_add_tail(&delayed_tr->list, &ioc->delayed_tr_list);
  2557. dewtprintk(ioc, pr_info(MPT3SAS_FMT
  2558. "DELAYED:tr:handle(0x%04x), (open)\n",
  2559. ioc->name, handle));
  2560. return;
  2561. }
  2562. dewtprintk(ioc, pr_info(MPT3SAS_FMT
  2563. "tr_send:handle(0x%04x), (open), smid(%d), cb(%d)\n",
  2564. ioc->name, handle, smid,
  2565. ioc->tm_tr_cb_idx));
  2566. mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
  2567. memset(mpi_request, 0, sizeof(Mpi2SCSITaskManagementRequest_t));
  2568. mpi_request->Function = MPI2_FUNCTION_SCSI_TASK_MGMT;
  2569. mpi_request->DevHandle = cpu_to_le16(handle);
  2570. mpi_request->TaskType = MPI2_SCSITASKMGMT_TASKTYPE_TARGET_RESET;
  2571. mpt3sas_base_put_smid_hi_priority(ioc, smid);
  2572. mpt3sas_trigger_master(ioc, MASTER_TRIGGER_DEVICE_REMOVAL);
  2573. }
  2574. /**
  2575. * _scsih_tm_tr_complete -
  2576. * @ioc: per adapter object
  2577. * @smid: system request message index
  2578. * @msix_index: MSIX table index supplied by the OS
  2579. * @reply: reply message frame(lower 32bit addr)
  2580. * Context: interrupt time.
  2581. *
  2582. * This is the target reset completion routine.
  2583. * This code is part of the code to initiate the device removal
  2584. * handshake protocol with controller firmware.
  2585. * It will send a sas iounit control request (MPI2_SAS_OP_REMOVE_DEVICE)
  2586. *
  2587. * Return 1 meaning mf should be freed from _base_interrupt
  2588. * 0 means the mf is freed from this function.
  2589. */
  2590. static u8
  2591. _scsih_tm_tr_complete(struct MPT3SAS_ADAPTER *ioc, u16 smid, u8 msix_index,
  2592. u32 reply)
  2593. {
  2594. u16 handle;
  2595. Mpi2SCSITaskManagementRequest_t *mpi_request_tm;
  2596. Mpi2SCSITaskManagementReply_t *mpi_reply =
  2597. mpt3sas_base_get_reply_virt_addr(ioc, reply);
  2598. Mpi2SasIoUnitControlRequest_t *mpi_request;
  2599. u16 smid_sas_ctrl;
  2600. u32 ioc_state;
  2601. if (ioc->remove_host) {
  2602. dewtprintk(ioc, pr_info(MPT3SAS_FMT
  2603. "%s: host has been removed\n", __func__, ioc->name));
  2604. return 1;
  2605. } else if (ioc->pci_error_recovery) {
  2606. dewtprintk(ioc, pr_info(MPT3SAS_FMT
  2607. "%s: host in pci error recovery\n", __func__,
  2608. ioc->name));
  2609. return 1;
  2610. }
  2611. ioc_state = mpt3sas_base_get_iocstate(ioc, 1);
  2612. if (ioc_state != MPI2_IOC_STATE_OPERATIONAL) {
  2613. dewtprintk(ioc, pr_info(MPT3SAS_FMT
  2614. "%s: host is not operational\n", __func__, ioc->name));
  2615. return 1;
  2616. }
  2617. if (unlikely(!mpi_reply)) {
  2618. pr_err(MPT3SAS_FMT "mpi_reply not valid at %s:%d/%s()!\n",
  2619. ioc->name, __FILE__, __LINE__, __func__);
  2620. return 1;
  2621. }
  2622. mpi_request_tm = mpt3sas_base_get_msg_frame(ioc, smid);
  2623. handle = le16_to_cpu(mpi_request_tm->DevHandle);
  2624. if (handle != le16_to_cpu(mpi_reply->DevHandle)) {
  2625. dewtprintk(ioc, pr_err(MPT3SAS_FMT
  2626. "spurious interrupt: handle(0x%04x:0x%04x), smid(%d)!!!\n",
  2627. ioc->name, handle,
  2628. le16_to_cpu(mpi_reply->DevHandle), smid));
  2629. return 0;
  2630. }
  2631. mpt3sas_trigger_master(ioc, MASTER_TRIGGER_TASK_MANAGMENT);
  2632. dewtprintk(ioc, pr_info(MPT3SAS_FMT
  2633. "tr_complete:handle(0x%04x), (open) smid(%d), ioc_status(0x%04x), "
  2634. "loginfo(0x%08x), completed(%d)\n", ioc->name,
  2635. handle, smid, le16_to_cpu(mpi_reply->IOCStatus),
  2636. le32_to_cpu(mpi_reply->IOCLogInfo),
  2637. le32_to_cpu(mpi_reply->TerminationCount)));
  2638. smid_sas_ctrl = mpt3sas_base_get_smid(ioc, ioc->tm_sas_control_cb_idx);
  2639. if (!smid_sas_ctrl) {
  2640. pr_err(MPT3SAS_FMT "%s: failed obtaining a smid\n",
  2641. ioc->name, __func__);
  2642. return 1;
  2643. }
  2644. dewtprintk(ioc, pr_info(MPT3SAS_FMT
  2645. "sc_send:handle(0x%04x), (open), smid(%d), cb(%d)\n",
  2646. ioc->name, handle, smid_sas_ctrl,
  2647. ioc->tm_sas_control_cb_idx));
  2648. mpi_request = mpt3sas_base_get_msg_frame(ioc, smid_sas_ctrl);
  2649. memset(mpi_request, 0, sizeof(Mpi2SasIoUnitControlRequest_t));
  2650. mpi_request->Function = MPI2_FUNCTION_SAS_IO_UNIT_CONTROL;
  2651. mpi_request->Operation = MPI2_SAS_OP_REMOVE_DEVICE;
  2652. mpi_request->DevHandle = mpi_request_tm->DevHandle;
  2653. mpt3sas_base_put_smid_default(ioc, smid_sas_ctrl);
  2654. return _scsih_check_for_pending_tm(ioc, smid);
  2655. }
  2656. /**
  2657. * _scsih_sas_control_complete - completion routine
  2658. * @ioc: per adapter object
  2659. * @smid: system request message index
  2660. * @msix_index: MSIX table index supplied by the OS
  2661. * @reply: reply message frame(lower 32bit addr)
  2662. * Context: interrupt time.
  2663. *
  2664. * This is the sas iounit control completion routine.
  2665. * This code is part of the code to initiate the device removal
  2666. * handshake protocol with controller firmware.
  2667. *
  2668. * Return 1 meaning mf should be freed from _base_interrupt
  2669. * 0 means the mf is freed from this function.
  2670. */
  2671. static u8
  2672. _scsih_sas_control_complete(struct MPT3SAS_ADAPTER *ioc, u16 smid,
  2673. u8 msix_index, u32 reply)
  2674. {
  2675. Mpi2SasIoUnitControlReply_t *mpi_reply =
  2676. mpt3sas_base_get_reply_virt_addr(ioc, reply);
  2677. if (likely(mpi_reply)) {
  2678. dewtprintk(ioc, pr_info(MPT3SAS_FMT
  2679. "sc_complete:handle(0x%04x), (open) "
  2680. "smid(%d), ioc_status(0x%04x), loginfo(0x%08x)\n",
  2681. ioc->name, le16_to_cpu(mpi_reply->DevHandle), smid,
  2682. le16_to_cpu(mpi_reply->IOCStatus),
  2683. le32_to_cpu(mpi_reply->IOCLogInfo)));
  2684. } else {
  2685. pr_err(MPT3SAS_FMT "mpi_reply not valid at %s:%d/%s()!\n",
  2686. ioc->name, __FILE__, __LINE__, __func__);
  2687. }
  2688. return 1;
  2689. }
  2690. /**
  2691. * _scsih_tm_tr_volume_send - send target reset request for volumes
  2692. * @ioc: per adapter object
  2693. * @handle: device handle
  2694. * Context: interrupt time.
  2695. *
  2696. * This is designed to send muliple task management request at the same
  2697. * time to the fifo. If the fifo is full, we will append the request,
  2698. * and process it in a future completion.
  2699. */
  2700. static void
  2701. _scsih_tm_tr_volume_send(struct MPT3SAS_ADAPTER *ioc, u16 handle)
  2702. {
  2703. Mpi2SCSITaskManagementRequest_t *mpi_request;
  2704. u16 smid;
  2705. struct _tr_list *delayed_tr;
  2706. if (ioc->shost_recovery || ioc->remove_host ||
  2707. ioc->pci_error_recovery) {
  2708. dewtprintk(ioc, pr_info(MPT3SAS_FMT
  2709. "%s: host reset in progress!\n",
  2710. __func__, ioc->name));
  2711. return;
  2712. }
  2713. smid = mpt3sas_base_get_smid_hpr(ioc, ioc->tm_tr_volume_cb_idx);
  2714. if (!smid) {
  2715. delayed_tr = kzalloc(sizeof(*delayed_tr), GFP_ATOMIC);
  2716. if (!delayed_tr)
  2717. return;
  2718. INIT_LIST_HEAD(&delayed_tr->list);
  2719. delayed_tr->handle = handle;
  2720. list_add_tail(&delayed_tr->list, &ioc->delayed_tr_volume_list);
  2721. dewtprintk(ioc, pr_info(MPT3SAS_FMT
  2722. "DELAYED:tr:handle(0x%04x), (open)\n",
  2723. ioc->name, handle));
  2724. return;
  2725. }
  2726. dewtprintk(ioc, pr_info(MPT3SAS_FMT
  2727. "tr_send:handle(0x%04x), (open), smid(%d), cb(%d)\n",
  2728. ioc->name, handle, smid,
  2729. ioc->tm_tr_volume_cb_idx));
  2730. mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
  2731. memset(mpi_request, 0, sizeof(Mpi2SCSITaskManagementRequest_t));
  2732. mpi_request->Function = MPI2_FUNCTION_SCSI_TASK_MGMT;
  2733. mpi_request->DevHandle = cpu_to_le16(handle);
  2734. mpi_request->TaskType = MPI2_SCSITASKMGMT_TASKTYPE_TARGET_RESET;
  2735. mpt3sas_base_put_smid_hi_priority(ioc, smid);
  2736. }
  2737. /**
  2738. * _scsih_tm_volume_tr_complete - target reset completion
  2739. * @ioc: per adapter object
  2740. * @smid: system request message index
  2741. * @msix_index: MSIX table index supplied by the OS
  2742. * @reply: reply message frame(lower 32bit addr)
  2743. * Context: interrupt time.
  2744. *
  2745. * Return 1 meaning mf should be freed from _base_interrupt
  2746. * 0 means the mf is freed from this function.
  2747. */
  2748. static u8
  2749. _scsih_tm_volume_tr_complete(struct MPT3SAS_ADAPTER *ioc, u16 smid,
  2750. u8 msix_index, u32 reply)
  2751. {
  2752. u16 handle;
  2753. Mpi2SCSITaskManagementRequest_t *mpi_request_tm;
  2754. Mpi2SCSITaskManagementReply_t *mpi_reply =
  2755. mpt3sas_base_get_reply_virt_addr(ioc, reply);
  2756. if (ioc->shost_recovery || ioc->remove_host ||
  2757. ioc->pci_error_recovery) {
  2758. dewtprintk(ioc, pr_info(MPT3SAS_FMT
  2759. "%s: host reset in progress!\n",
  2760. __func__, ioc->name));
  2761. return 1;
  2762. }
  2763. if (unlikely(!mpi_reply)) {
  2764. pr_err(MPT3SAS_FMT "mpi_reply not valid at %s:%d/%s()!\n",
  2765. ioc->name, __FILE__, __LINE__, __func__);
  2766. return 1;
  2767. }
  2768. mpi_request_tm = mpt3sas_base_get_msg_frame(ioc, smid);
  2769. handle = le16_to_cpu(mpi_request_tm->DevHandle);
  2770. if (handle != le16_to_cpu(mpi_reply->DevHandle)) {
  2771. dewtprintk(ioc, pr_err(MPT3SAS_FMT
  2772. "spurious interrupt: handle(0x%04x:0x%04x), smid(%d)!!!\n",
  2773. ioc->name, handle,
  2774. le16_to_cpu(mpi_reply->DevHandle), smid));
  2775. return 0;
  2776. }
  2777. dewtprintk(ioc, pr_info(MPT3SAS_FMT
  2778. "tr_complete:handle(0x%04x), (open) smid(%d), ioc_status(0x%04x), "
  2779. "loginfo(0x%08x), completed(%d)\n", ioc->name,
  2780. handle, smid, le16_to_cpu(mpi_reply->IOCStatus),
  2781. le32_to_cpu(mpi_reply->IOCLogInfo),
  2782. le32_to_cpu(mpi_reply->TerminationCount)));
  2783. return _scsih_check_for_pending_tm(ioc, smid);
  2784. }
  2785. /**
  2786. * _scsih_check_for_pending_tm - check for pending task management
  2787. * @ioc: per adapter object
  2788. * @smid: system request message index
  2789. *
  2790. * This will check delayed target reset list, and feed the
  2791. * next reqeust.
  2792. *
  2793. * Return 1 meaning mf should be freed from _base_interrupt
  2794. * 0 means the mf is freed from this function.
  2795. */
  2796. static u8
  2797. _scsih_check_for_pending_tm(struct MPT3SAS_ADAPTER *ioc, u16 smid)
  2798. {
  2799. struct _tr_list *delayed_tr;
  2800. if (!list_empty(&ioc->delayed_tr_volume_list)) {
  2801. delayed_tr = list_entry(ioc->delayed_tr_volume_list.next,
  2802. struct _tr_list, list);
  2803. mpt3sas_base_free_smid(ioc, smid);
  2804. _scsih_tm_tr_volume_send(ioc, delayed_tr->handle);
  2805. list_del(&delayed_tr->list);
  2806. kfree(delayed_tr);
  2807. return 0;
  2808. }
  2809. if (!list_empty(&ioc->delayed_tr_list)) {
  2810. delayed_tr = list_entry(ioc->delayed_tr_list.next,
  2811. struct _tr_list, list);
  2812. mpt3sas_base_free_smid(ioc, smid);
  2813. _scsih_tm_tr_send(ioc, delayed_tr->handle);
  2814. list_del(&delayed_tr->list);
  2815. kfree(delayed_tr);
  2816. return 0;
  2817. }
  2818. return 1;
  2819. }
  2820. /**
  2821. * _scsih_check_topo_delete_events - sanity check on topo events
  2822. * @ioc: per adapter object
  2823. * @event_data: the event data payload
  2824. *
  2825. * This routine added to better handle cable breaker.
  2826. *
  2827. * This handles the case where driver receives multiple expander
  2828. * add and delete events in a single shot. When there is a delete event
  2829. * the routine will void any pending add events waiting in the event queue.
  2830. *
  2831. * Return nothing.
  2832. */
  2833. static void
  2834. _scsih_check_topo_delete_events(struct MPT3SAS_ADAPTER *ioc,
  2835. Mpi2EventDataSasTopologyChangeList_t *event_data)
  2836. {
  2837. struct fw_event_work *fw_event;
  2838. Mpi2EventDataSasTopologyChangeList_t *local_event_data;
  2839. u16 expander_handle;
  2840. struct _sas_node *sas_expander;
  2841. unsigned long flags;
  2842. int i, reason_code;
  2843. u16 handle;
  2844. for (i = 0 ; i < event_data->NumEntries; i++) {
  2845. handle = le16_to_cpu(event_data->PHY[i].AttachedDevHandle);
  2846. if (!handle)
  2847. continue;
  2848. reason_code = event_data->PHY[i].PhyStatus &
  2849. MPI2_EVENT_SAS_TOPO_RC_MASK;
  2850. if (reason_code == MPI2_EVENT_SAS_TOPO_RC_TARG_NOT_RESPONDING)
  2851. _scsih_tm_tr_send(ioc, handle);
  2852. }
  2853. expander_handle = le16_to_cpu(event_data->ExpanderDevHandle);
  2854. if (expander_handle < ioc->sas_hba.num_phys) {
  2855. _scsih_block_io_to_children_attached_directly(ioc, event_data);
  2856. return;
  2857. }
  2858. if (event_data->ExpStatus ==
  2859. MPI2_EVENT_SAS_TOPO_ES_DELAY_NOT_RESPONDING) {
  2860. /* put expander attached devices into blocking state */
  2861. spin_lock_irqsave(&ioc->sas_node_lock, flags);
  2862. sas_expander = mpt3sas_scsih_expander_find_by_handle(ioc,
  2863. expander_handle);
  2864. _scsih_block_io_to_children_attached_to_ex(ioc, sas_expander);
  2865. spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
  2866. do {
  2867. handle = find_first_bit(ioc->blocking_handles,
  2868. ioc->facts.MaxDevHandle);
  2869. if (handle < ioc->facts.MaxDevHandle)
  2870. _scsih_block_io_device(ioc, handle);
  2871. } while (test_and_clear_bit(handle, ioc->blocking_handles));
  2872. } else if (event_data->ExpStatus == MPI2_EVENT_SAS_TOPO_ES_RESPONDING)
  2873. _scsih_block_io_to_children_attached_directly(ioc, event_data);
  2874. if (event_data->ExpStatus != MPI2_EVENT_SAS_TOPO_ES_NOT_RESPONDING)
  2875. return;
  2876. /* mark ignore flag for pending events */
  2877. spin_lock_irqsave(&ioc->fw_event_lock, flags);
  2878. list_for_each_entry(fw_event, &ioc->fw_event_list, list) {
  2879. if (fw_event->event != MPI2_EVENT_SAS_TOPOLOGY_CHANGE_LIST ||
  2880. fw_event->ignore)
  2881. continue;
  2882. local_event_data = fw_event->event_data;
  2883. if (local_event_data->ExpStatus ==
  2884. MPI2_EVENT_SAS_TOPO_ES_ADDED ||
  2885. local_event_data->ExpStatus ==
  2886. MPI2_EVENT_SAS_TOPO_ES_RESPONDING) {
  2887. if (le16_to_cpu(local_event_data->ExpanderDevHandle) ==
  2888. expander_handle) {
  2889. dewtprintk(ioc, pr_info(MPT3SAS_FMT
  2890. "setting ignoring flag\n", ioc->name));
  2891. fw_event->ignore = 1;
  2892. }
  2893. }
  2894. }
  2895. spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
  2896. }
  2897. /**
  2898. * _scsih_set_volume_delete_flag - setting volume delete flag
  2899. * @ioc: per adapter object
  2900. * @handle: device handle
  2901. *
  2902. * This returns nothing.
  2903. */
  2904. static void
  2905. _scsih_set_volume_delete_flag(struct MPT3SAS_ADAPTER *ioc, u16 handle)
  2906. {
  2907. struct _raid_device *raid_device;
  2908. struct MPT3SAS_TARGET *sas_target_priv_data;
  2909. unsigned long flags;
  2910. spin_lock_irqsave(&ioc->raid_device_lock, flags);
  2911. raid_device = _scsih_raid_device_find_by_handle(ioc, handle);
  2912. if (raid_device && raid_device->starget &&
  2913. raid_device->starget->hostdata) {
  2914. sas_target_priv_data =
  2915. raid_device->starget->hostdata;
  2916. sas_target_priv_data->deleted = 1;
  2917. dewtprintk(ioc, pr_info(MPT3SAS_FMT
  2918. "setting delete flag: handle(0x%04x), "
  2919. "wwid(0x%016llx)\n", ioc->name, handle,
  2920. (unsigned long long) raid_device->wwid));
  2921. }
  2922. spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
  2923. }
  2924. /**
  2925. * _scsih_set_volume_handle_for_tr - set handle for target reset to volume
  2926. * @handle: input handle
  2927. * @a: handle for volume a
  2928. * @b: handle for volume b
  2929. *
  2930. * IR firmware only supports two raid volumes. The purpose of this
  2931. * routine is to set the volume handle in either a or b. When the given
  2932. * input handle is non-zero, or when a and b have not been set before.
  2933. */
  2934. static void
  2935. _scsih_set_volume_handle_for_tr(u16 handle, u16 *a, u16 *b)
  2936. {
  2937. if (!handle || handle == *a || handle == *b)
  2938. return;
  2939. if (!*a)
  2940. *a = handle;
  2941. else if (!*b)
  2942. *b = handle;
  2943. }
  2944. /**
  2945. * _scsih_check_ir_config_unhide_events - check for UNHIDE events
  2946. * @ioc: per adapter object
  2947. * @event_data: the event data payload
  2948. * Context: interrupt time.
  2949. *
  2950. * This routine will send target reset to volume, followed by target
  2951. * resets to the PDs. This is called when a PD has been removed, or
  2952. * volume has been deleted or removed. When the target reset is sent
  2953. * to volume, the PD target resets need to be queued to start upon
  2954. * completion of the volume target reset.
  2955. *
  2956. * Return nothing.
  2957. */
  2958. static void
  2959. _scsih_check_ir_config_unhide_events(struct MPT3SAS_ADAPTER *ioc,
  2960. Mpi2EventDataIrConfigChangeList_t *event_data)
  2961. {
  2962. Mpi2EventIrConfigElement_t *element;
  2963. int i;
  2964. u16 handle, volume_handle, a, b;
  2965. struct _tr_list *delayed_tr;
  2966. a = 0;
  2967. b = 0;
  2968. /* Volume Resets for Deleted or Removed */
  2969. element = (Mpi2EventIrConfigElement_t *)&event_data->ConfigElement[0];
  2970. for (i = 0; i < event_data->NumElements; i++, element++) {
  2971. if (le32_to_cpu(event_data->Flags) &
  2972. MPI2_EVENT_IR_CHANGE_FLAGS_FOREIGN_CONFIG)
  2973. continue;
  2974. if (element->ReasonCode ==
  2975. MPI2_EVENT_IR_CHANGE_RC_VOLUME_DELETED ||
  2976. element->ReasonCode ==
  2977. MPI2_EVENT_IR_CHANGE_RC_REMOVED) {
  2978. volume_handle = le16_to_cpu(element->VolDevHandle);
  2979. _scsih_set_volume_delete_flag(ioc, volume_handle);
  2980. _scsih_set_volume_handle_for_tr(volume_handle, &a, &b);
  2981. }
  2982. }
  2983. /* Volume Resets for UNHIDE events */
  2984. element = (Mpi2EventIrConfigElement_t *)&event_data->ConfigElement[0];
  2985. for (i = 0; i < event_data->NumElements; i++, element++) {
  2986. if (le32_to_cpu(event_data->Flags) &
  2987. MPI2_EVENT_IR_CHANGE_FLAGS_FOREIGN_CONFIG)
  2988. continue;
  2989. if (element->ReasonCode == MPI2_EVENT_IR_CHANGE_RC_UNHIDE) {
  2990. volume_handle = le16_to_cpu(element->VolDevHandle);
  2991. _scsih_set_volume_handle_for_tr(volume_handle, &a, &b);
  2992. }
  2993. }
  2994. if (a)
  2995. _scsih_tm_tr_volume_send(ioc, a);
  2996. if (b)
  2997. _scsih_tm_tr_volume_send(ioc, b);
  2998. /* PD target resets */
  2999. element = (Mpi2EventIrConfigElement_t *)&event_data->ConfigElement[0];
  3000. for (i = 0; i < event_data->NumElements; i++, element++) {
  3001. if (element->ReasonCode != MPI2_EVENT_IR_CHANGE_RC_UNHIDE)
  3002. continue;
  3003. handle = le16_to_cpu(element->PhysDiskDevHandle);
  3004. volume_handle = le16_to_cpu(element->VolDevHandle);
  3005. clear_bit(handle, ioc->pd_handles);
  3006. if (!volume_handle)
  3007. _scsih_tm_tr_send(ioc, handle);
  3008. else if (volume_handle == a || volume_handle == b) {
  3009. delayed_tr = kzalloc(sizeof(*delayed_tr), GFP_ATOMIC);
  3010. BUG_ON(!delayed_tr);
  3011. INIT_LIST_HEAD(&delayed_tr->list);
  3012. delayed_tr->handle = handle;
  3013. list_add_tail(&delayed_tr->list, &ioc->delayed_tr_list);
  3014. dewtprintk(ioc, pr_info(MPT3SAS_FMT
  3015. "DELAYED:tr:handle(0x%04x), (open)\n", ioc->name,
  3016. handle));
  3017. } else
  3018. _scsih_tm_tr_send(ioc, handle);
  3019. }
  3020. }
  3021. /**
  3022. * _scsih_check_volume_delete_events - set delete flag for volumes
  3023. * @ioc: per adapter object
  3024. * @event_data: the event data payload
  3025. * Context: interrupt time.
  3026. *
  3027. * This will handle the case when the cable connected to entire volume is
  3028. * pulled. We will take care of setting the deleted flag so normal IO will
  3029. * not be sent.
  3030. *
  3031. * Return nothing.
  3032. */
  3033. static void
  3034. _scsih_check_volume_delete_events(struct MPT3SAS_ADAPTER *ioc,
  3035. Mpi2EventDataIrVolume_t *event_data)
  3036. {
  3037. u32 state;
  3038. if (event_data->ReasonCode != MPI2_EVENT_IR_VOLUME_RC_STATE_CHANGED)
  3039. return;
  3040. state = le32_to_cpu(event_data->NewValue);
  3041. if (state == MPI2_RAID_VOL_STATE_MISSING || state ==
  3042. MPI2_RAID_VOL_STATE_FAILED)
  3043. _scsih_set_volume_delete_flag(ioc,
  3044. le16_to_cpu(event_data->VolDevHandle));
  3045. }
  3046. /**
  3047. * _scsih_flush_running_cmds - completing outstanding commands.
  3048. * @ioc: per adapter object
  3049. *
  3050. * The flushing out of all pending scmd commands following host reset,
  3051. * where all IO is dropped to the floor.
  3052. *
  3053. * Return nothing.
  3054. */
  3055. static void
  3056. _scsih_flush_running_cmds(struct MPT3SAS_ADAPTER *ioc)
  3057. {
  3058. struct scsi_cmnd *scmd;
  3059. u16 smid;
  3060. u16 count = 0;
  3061. for (smid = 1; smid <= ioc->scsiio_depth; smid++) {
  3062. scmd = _scsih_scsi_lookup_get_clear(ioc, smid);
  3063. if (!scmd)
  3064. continue;
  3065. count++;
  3066. mpt3sas_base_free_smid(ioc, smid);
  3067. scsi_dma_unmap(scmd);
  3068. if (ioc->pci_error_recovery)
  3069. scmd->result = DID_NO_CONNECT << 16;
  3070. else
  3071. scmd->result = DID_RESET << 16;
  3072. scmd->scsi_done(scmd);
  3073. }
  3074. dtmprintk(ioc, pr_info(MPT3SAS_FMT "completing %d cmds\n",
  3075. ioc->name, count));
  3076. }
  3077. /**
  3078. * _scsih_setup_eedp - setup MPI request for EEDP transfer
  3079. * @ioc: per adapter object
  3080. * @scmd: pointer to scsi command object
  3081. * @mpi_request: pointer to the SCSI_IO reqest message frame
  3082. *
  3083. * Supporting protection 1 and 3.
  3084. *
  3085. * Returns nothing
  3086. */
  3087. static void
  3088. _scsih_setup_eedp(struct MPT3SAS_ADAPTER *ioc, struct scsi_cmnd *scmd,
  3089. Mpi2SCSIIORequest_t *mpi_request)
  3090. {
  3091. u16 eedp_flags;
  3092. unsigned char prot_op = scsi_get_prot_op(scmd);
  3093. unsigned char prot_type = scsi_get_prot_type(scmd);
  3094. Mpi25SCSIIORequest_t *mpi_request_3v =
  3095. (Mpi25SCSIIORequest_t *)mpi_request;
  3096. if (prot_type == SCSI_PROT_DIF_TYPE0 || prot_op == SCSI_PROT_NORMAL)
  3097. return;
  3098. if (prot_op == SCSI_PROT_READ_STRIP)
  3099. eedp_flags = MPI2_SCSIIO_EEDPFLAGS_CHECK_REMOVE_OP;
  3100. else if (prot_op == SCSI_PROT_WRITE_INSERT)
  3101. eedp_flags = MPI2_SCSIIO_EEDPFLAGS_INSERT_OP;
  3102. else
  3103. return;
  3104. switch (prot_type) {
  3105. case SCSI_PROT_DIF_TYPE1:
  3106. case SCSI_PROT_DIF_TYPE2:
  3107. /*
  3108. * enable ref/guard checking
  3109. * auto increment ref tag
  3110. */
  3111. eedp_flags |= MPI2_SCSIIO_EEDPFLAGS_INC_PRI_REFTAG |
  3112. MPI2_SCSIIO_EEDPFLAGS_CHECK_REFTAG |
  3113. MPI2_SCSIIO_EEDPFLAGS_CHECK_GUARD;
  3114. mpi_request->CDB.EEDP32.PrimaryReferenceTag =
  3115. cpu_to_be32(scsi_get_lba(scmd));
  3116. break;
  3117. case SCSI_PROT_DIF_TYPE3:
  3118. /*
  3119. * enable guard checking
  3120. */
  3121. eedp_flags |= MPI2_SCSIIO_EEDPFLAGS_CHECK_GUARD;
  3122. break;
  3123. }
  3124. mpi_request_3v->EEDPBlockSize =
  3125. cpu_to_le16(scmd->device->sector_size);
  3126. mpi_request->EEDPFlags = cpu_to_le16(eedp_flags);
  3127. }
  3128. /**
  3129. * _scsih_eedp_error_handling - return sense code for EEDP errors
  3130. * @scmd: pointer to scsi command object
  3131. * @ioc_status: ioc status
  3132. *
  3133. * Returns nothing
  3134. */
  3135. static void
  3136. _scsih_eedp_error_handling(struct scsi_cmnd *scmd, u16 ioc_status)
  3137. {
  3138. u8 ascq;
  3139. switch (ioc_status) {
  3140. case MPI2_IOCSTATUS_EEDP_GUARD_ERROR:
  3141. ascq = 0x01;
  3142. break;
  3143. case MPI2_IOCSTATUS_EEDP_APP_TAG_ERROR:
  3144. ascq = 0x02;
  3145. break;
  3146. case MPI2_IOCSTATUS_EEDP_REF_TAG_ERROR:
  3147. ascq = 0x03;
  3148. break;
  3149. default:
  3150. ascq = 0x00;
  3151. break;
  3152. }
  3153. scsi_build_sense_buffer(0, scmd->sense_buffer, ILLEGAL_REQUEST, 0x10,
  3154. ascq);
  3155. scmd->result = DRIVER_SENSE << 24 | (DID_ABORT << 16) |
  3156. SAM_STAT_CHECK_CONDITION;
  3157. }
  3158. /**
  3159. * _scsih_qcmd_lck - main scsi request entry point
  3160. * @scmd: pointer to scsi command object
  3161. * @done: function pointer to be invoked on completion
  3162. *
  3163. * The callback index is set inside `ioc->scsi_io_cb_idx`.
  3164. *
  3165. * Returns 0 on success. If there's a failure, return either:
  3166. * SCSI_MLQUEUE_DEVICE_BUSY if the device queue is full, or
  3167. * SCSI_MLQUEUE_HOST_BUSY if the entire host queue is full
  3168. */
  3169. static int
  3170. _scsih_qcmd_lck(struct scsi_cmnd *scmd, void (*done)(struct scsi_cmnd *))
  3171. {
  3172. struct MPT3SAS_ADAPTER *ioc = shost_priv(scmd->device->host);
  3173. struct MPT3SAS_DEVICE *sas_device_priv_data;
  3174. struct MPT3SAS_TARGET *sas_target_priv_data;
  3175. Mpi2SCSIIORequest_t *mpi_request;
  3176. u32 mpi_control;
  3177. u16 smid;
  3178. u16 handle;
  3179. #ifdef CONFIG_SCSI_MPT3SAS_LOGGING
  3180. if (ioc->logging_level & MPT_DEBUG_SCSI)
  3181. scsi_print_command(scmd);
  3182. #endif
  3183. scmd->scsi_done = done;
  3184. sas_device_priv_data = scmd->device->hostdata;
  3185. if (!sas_device_priv_data || !sas_device_priv_data->sas_target) {
  3186. scmd->result = DID_NO_CONNECT << 16;
  3187. scmd->scsi_done(scmd);
  3188. return 0;
  3189. }
  3190. if (ioc->pci_error_recovery || ioc->remove_host) {
  3191. scmd->result = DID_NO_CONNECT << 16;
  3192. scmd->scsi_done(scmd);
  3193. return 0;
  3194. }
  3195. sas_target_priv_data = sas_device_priv_data->sas_target;
  3196. /* invalid device handle */
  3197. handle = sas_target_priv_data->handle;
  3198. if (handle == MPT3SAS_INVALID_DEVICE_HANDLE) {
  3199. scmd->result = DID_NO_CONNECT << 16;
  3200. scmd->scsi_done(scmd);
  3201. return 0;
  3202. }
  3203. /* host recovery or link resets sent via IOCTLs */
  3204. if (ioc->shost_recovery || ioc->ioc_link_reset_in_progress)
  3205. return SCSI_MLQUEUE_HOST_BUSY;
  3206. /* device has been deleted */
  3207. else if (sas_target_priv_data->deleted) {
  3208. scmd->result = DID_NO_CONNECT << 16;
  3209. scmd->scsi_done(scmd);
  3210. return 0;
  3211. /* device busy with task managment */
  3212. } else if (sas_target_priv_data->tm_busy ||
  3213. sas_device_priv_data->block)
  3214. return SCSI_MLQUEUE_DEVICE_BUSY;
  3215. if (scmd->sc_data_direction == DMA_FROM_DEVICE)
  3216. mpi_control = MPI2_SCSIIO_CONTROL_READ;
  3217. else if (scmd->sc_data_direction == DMA_TO_DEVICE)
  3218. mpi_control = MPI2_SCSIIO_CONTROL_WRITE;
  3219. else
  3220. mpi_control = MPI2_SCSIIO_CONTROL_NODATATRANSFER;
  3221. /* set tags */
  3222. if (!(sas_device_priv_data->flags & MPT_DEVICE_FLAGS_INIT)) {
  3223. if (scmd->device->tagged_supported) {
  3224. if (scmd->device->ordered_tags)
  3225. mpi_control |= MPI2_SCSIIO_CONTROL_ORDEREDQ;
  3226. else
  3227. mpi_control |= MPI2_SCSIIO_CONTROL_SIMPLEQ;
  3228. } else
  3229. mpi_control |= MPI2_SCSIIO_CONTROL_SIMPLEQ;
  3230. } else
  3231. mpi_control |= MPI2_SCSIIO_CONTROL_SIMPLEQ;
  3232. if ((sas_device_priv_data->flags & MPT_DEVICE_TLR_ON) &&
  3233. scmd->cmd_len != 32)
  3234. mpi_control |= MPI2_SCSIIO_CONTROL_TLR_ON;
  3235. smid = mpt3sas_base_get_smid_scsiio(ioc, ioc->scsi_io_cb_idx, scmd);
  3236. if (!smid) {
  3237. pr_err(MPT3SAS_FMT "%s: failed obtaining a smid\n",
  3238. ioc->name, __func__);
  3239. goto out;
  3240. }
  3241. mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
  3242. memset(mpi_request, 0, sizeof(Mpi2SCSIIORequest_t));
  3243. _scsih_setup_eedp(ioc, scmd, mpi_request);
  3244. if (scmd->cmd_len == 32)
  3245. mpi_control |= 4 << MPI2_SCSIIO_CONTROL_ADDCDBLEN_SHIFT;
  3246. mpi_request->Function = MPI2_FUNCTION_SCSI_IO_REQUEST;
  3247. if (sas_device_priv_data->sas_target->flags &
  3248. MPT_TARGET_FLAGS_RAID_COMPONENT)
  3249. mpi_request->Function = MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH;
  3250. else
  3251. mpi_request->Function = MPI2_FUNCTION_SCSI_IO_REQUEST;
  3252. mpi_request->DevHandle = cpu_to_le16(handle);
  3253. mpi_request->DataLength = cpu_to_le32(scsi_bufflen(scmd));
  3254. mpi_request->Control = cpu_to_le32(mpi_control);
  3255. mpi_request->IoFlags = cpu_to_le16(scmd->cmd_len);
  3256. mpi_request->MsgFlags = MPI2_SCSIIO_MSGFLAGS_SYSTEM_SENSE_ADDR;
  3257. mpi_request->SenseBufferLength = SCSI_SENSE_BUFFERSIZE;
  3258. mpi_request->SenseBufferLowAddress =
  3259. mpt3sas_base_get_sense_buffer_dma(ioc, smid);
  3260. mpi_request->SGLOffset0 = offsetof(Mpi2SCSIIORequest_t, SGL) / 4;
  3261. int_to_scsilun(sas_device_priv_data->lun, (struct scsi_lun *)
  3262. mpi_request->LUN);
  3263. memcpy(mpi_request->CDB.CDB32, scmd->cmnd, scmd->cmd_len);
  3264. if (mpi_request->DataLength) {
  3265. if (ioc->build_sg_scmd(ioc, scmd, smid)) {
  3266. mpt3sas_base_free_smid(ioc, smid);
  3267. goto out;
  3268. }
  3269. } else
  3270. ioc->build_zero_len_sge(ioc, &mpi_request->SGL);
  3271. if (likely(mpi_request->Function == MPI2_FUNCTION_SCSI_IO_REQUEST)) {
  3272. if (sas_target_priv_data->flags & MPT_TARGET_FASTPATH_IO) {
  3273. mpi_request->IoFlags = cpu_to_le16(scmd->cmd_len |
  3274. MPI25_SCSIIO_IOFLAGS_FAST_PATH);
  3275. mpt3sas_base_put_smid_fast_path(ioc, smid, handle);
  3276. } else
  3277. mpt3sas_base_put_smid_scsi_io(ioc, smid, handle);
  3278. } else
  3279. mpt3sas_base_put_smid_default(ioc, smid);
  3280. return 0;
  3281. out:
  3282. return SCSI_MLQUEUE_HOST_BUSY;
  3283. }
  3284. static DEF_SCSI_QCMD(_scsih_qcmd)
  3285. /**
  3286. * _scsih_normalize_sense - normalize descriptor and fixed format sense data
  3287. * @sense_buffer: sense data returned by target
  3288. * @data: normalized skey/asc/ascq
  3289. *
  3290. * Return nothing.
  3291. */
  3292. static void
  3293. _scsih_normalize_sense(char *sense_buffer, struct sense_info *data)
  3294. {
  3295. if ((sense_buffer[0] & 0x7F) >= 0x72) {
  3296. /* descriptor format */
  3297. data->skey = sense_buffer[1] & 0x0F;
  3298. data->asc = sense_buffer[2];
  3299. data->ascq = sense_buffer[3];
  3300. } else {
  3301. /* fixed format */
  3302. data->skey = sense_buffer[2] & 0x0F;
  3303. data->asc = sense_buffer[12];
  3304. data->ascq = sense_buffer[13];
  3305. }
  3306. }
  3307. #ifdef CONFIG_SCSI_MPT3SAS_LOGGING
  3308. /**
  3309. * _scsih_scsi_ioc_info - translated non-succesfull SCSI_IO request
  3310. * @ioc: per adapter object
  3311. * @scmd: pointer to scsi command object
  3312. * @mpi_reply: reply mf payload returned from firmware
  3313. *
  3314. * scsi_status - SCSI Status code returned from target device
  3315. * scsi_state - state info associated with SCSI_IO determined by ioc
  3316. * ioc_status - ioc supplied status info
  3317. *
  3318. * Return nothing.
  3319. */
  3320. static void
  3321. _scsih_scsi_ioc_info(struct MPT3SAS_ADAPTER *ioc, struct scsi_cmnd *scmd,
  3322. Mpi2SCSIIOReply_t *mpi_reply, u16 smid)
  3323. {
  3324. u32 response_info;
  3325. u8 *response_bytes;
  3326. u16 ioc_status = le16_to_cpu(mpi_reply->IOCStatus) &
  3327. MPI2_IOCSTATUS_MASK;
  3328. u8 scsi_state = mpi_reply->SCSIState;
  3329. u8 scsi_status = mpi_reply->SCSIStatus;
  3330. char *desc_ioc_state = NULL;
  3331. char *desc_scsi_status = NULL;
  3332. char *desc_scsi_state = ioc->tmp_string;
  3333. u32 log_info = le32_to_cpu(mpi_reply->IOCLogInfo);
  3334. struct _sas_device *sas_device = NULL;
  3335. unsigned long flags;
  3336. struct scsi_target *starget = scmd->device->sdev_target;
  3337. struct MPT3SAS_TARGET *priv_target = starget->hostdata;
  3338. char *device_str = NULL;
  3339. if (!priv_target)
  3340. return;
  3341. device_str = "volume";
  3342. if (log_info == 0x31170000)
  3343. return;
  3344. switch (ioc_status) {
  3345. case MPI2_IOCSTATUS_SUCCESS:
  3346. desc_ioc_state = "success";
  3347. break;
  3348. case MPI2_IOCSTATUS_INVALID_FUNCTION:
  3349. desc_ioc_state = "invalid function";
  3350. break;
  3351. case MPI2_IOCSTATUS_SCSI_RECOVERED_ERROR:
  3352. desc_ioc_state = "scsi recovered error";
  3353. break;
  3354. case MPI2_IOCSTATUS_SCSI_INVALID_DEVHANDLE:
  3355. desc_ioc_state = "scsi invalid dev handle";
  3356. break;
  3357. case MPI2_IOCSTATUS_SCSI_DEVICE_NOT_THERE:
  3358. desc_ioc_state = "scsi device not there";
  3359. break;
  3360. case MPI2_IOCSTATUS_SCSI_DATA_OVERRUN:
  3361. desc_ioc_state = "scsi data overrun";
  3362. break;
  3363. case MPI2_IOCSTATUS_SCSI_DATA_UNDERRUN:
  3364. desc_ioc_state = "scsi data underrun";
  3365. break;
  3366. case MPI2_IOCSTATUS_SCSI_IO_DATA_ERROR:
  3367. desc_ioc_state = "scsi io data error";
  3368. break;
  3369. case MPI2_IOCSTATUS_SCSI_PROTOCOL_ERROR:
  3370. desc_ioc_state = "scsi protocol error";
  3371. break;
  3372. case MPI2_IOCSTATUS_SCSI_TASK_TERMINATED:
  3373. desc_ioc_state = "scsi task terminated";
  3374. break;
  3375. case MPI2_IOCSTATUS_SCSI_RESIDUAL_MISMATCH:
  3376. desc_ioc_state = "scsi residual mismatch";
  3377. break;
  3378. case MPI2_IOCSTATUS_SCSI_TASK_MGMT_FAILED:
  3379. desc_ioc_state = "scsi task mgmt failed";
  3380. break;
  3381. case MPI2_IOCSTATUS_SCSI_IOC_TERMINATED:
  3382. desc_ioc_state = "scsi ioc terminated";
  3383. break;
  3384. case MPI2_IOCSTATUS_SCSI_EXT_TERMINATED:
  3385. desc_ioc_state = "scsi ext terminated";
  3386. break;
  3387. case MPI2_IOCSTATUS_EEDP_GUARD_ERROR:
  3388. desc_ioc_state = "eedp guard error";
  3389. break;
  3390. case MPI2_IOCSTATUS_EEDP_REF_TAG_ERROR:
  3391. desc_ioc_state = "eedp ref tag error";
  3392. break;
  3393. case MPI2_IOCSTATUS_EEDP_APP_TAG_ERROR:
  3394. desc_ioc_state = "eedp app tag error";
  3395. break;
  3396. default:
  3397. desc_ioc_state = "unknown";
  3398. break;
  3399. }
  3400. switch (scsi_status) {
  3401. case MPI2_SCSI_STATUS_GOOD:
  3402. desc_scsi_status = "good";
  3403. break;
  3404. case MPI2_SCSI_STATUS_CHECK_CONDITION:
  3405. desc_scsi_status = "check condition";
  3406. break;
  3407. case MPI2_SCSI_STATUS_CONDITION_MET:
  3408. desc_scsi_status = "condition met";
  3409. break;
  3410. case MPI2_SCSI_STATUS_BUSY:
  3411. desc_scsi_status = "busy";
  3412. break;
  3413. case MPI2_SCSI_STATUS_INTERMEDIATE:
  3414. desc_scsi_status = "intermediate";
  3415. break;
  3416. case MPI2_SCSI_STATUS_INTERMEDIATE_CONDMET:
  3417. desc_scsi_status = "intermediate condmet";
  3418. break;
  3419. case MPI2_SCSI_STATUS_RESERVATION_CONFLICT:
  3420. desc_scsi_status = "reservation conflict";
  3421. break;
  3422. case MPI2_SCSI_STATUS_COMMAND_TERMINATED:
  3423. desc_scsi_status = "command terminated";
  3424. break;
  3425. case MPI2_SCSI_STATUS_TASK_SET_FULL:
  3426. desc_scsi_status = "task set full";
  3427. break;
  3428. case MPI2_SCSI_STATUS_ACA_ACTIVE:
  3429. desc_scsi_status = "aca active";
  3430. break;
  3431. case MPI2_SCSI_STATUS_TASK_ABORTED:
  3432. desc_scsi_status = "task aborted";
  3433. break;
  3434. default:
  3435. desc_scsi_status = "unknown";
  3436. break;
  3437. }
  3438. desc_scsi_state[0] = '\0';
  3439. if (!scsi_state)
  3440. desc_scsi_state = " ";
  3441. if (scsi_state & MPI2_SCSI_STATE_RESPONSE_INFO_VALID)
  3442. strcat(desc_scsi_state, "response info ");
  3443. if (scsi_state & MPI2_SCSI_STATE_TERMINATED)
  3444. strcat(desc_scsi_state, "state terminated ");
  3445. if (scsi_state & MPI2_SCSI_STATE_NO_SCSI_STATUS)
  3446. strcat(desc_scsi_state, "no status ");
  3447. if (scsi_state & MPI2_SCSI_STATE_AUTOSENSE_FAILED)
  3448. strcat(desc_scsi_state, "autosense failed ");
  3449. if (scsi_state & MPI2_SCSI_STATE_AUTOSENSE_VALID)
  3450. strcat(desc_scsi_state, "autosense valid ");
  3451. scsi_print_command(scmd);
  3452. if (priv_target->flags & MPT_TARGET_FLAGS_VOLUME) {
  3453. pr_warn(MPT3SAS_FMT "\t%s wwid(0x%016llx)\n", ioc->name,
  3454. device_str, (unsigned long long)priv_target->sas_address);
  3455. } else {
  3456. spin_lock_irqsave(&ioc->sas_device_lock, flags);
  3457. sas_device = mpt3sas_scsih_sas_device_find_by_sas_address(ioc,
  3458. priv_target->sas_address);
  3459. if (sas_device) {
  3460. pr_warn(MPT3SAS_FMT
  3461. "\tsas_address(0x%016llx), phy(%d)\n",
  3462. ioc->name, (unsigned long long)
  3463. sas_device->sas_address, sas_device->phy);
  3464. pr_warn(MPT3SAS_FMT
  3465. "\tenclosure_logical_id(0x%016llx), slot(%d)\n",
  3466. ioc->name, (unsigned long long)
  3467. sas_device->enclosure_logical_id, sas_device->slot);
  3468. }
  3469. spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
  3470. }
  3471. pr_warn(MPT3SAS_FMT
  3472. "\thandle(0x%04x), ioc_status(%s)(0x%04x), smid(%d)\n",
  3473. ioc->name, le16_to_cpu(mpi_reply->DevHandle),
  3474. desc_ioc_state, ioc_status, smid);
  3475. pr_warn(MPT3SAS_FMT
  3476. "\trequest_len(%d), underflow(%d), resid(%d)\n",
  3477. ioc->name, scsi_bufflen(scmd), scmd->underflow,
  3478. scsi_get_resid(scmd));
  3479. pr_warn(MPT3SAS_FMT
  3480. "\ttag(%d), transfer_count(%d), sc->result(0x%08x)\n",
  3481. ioc->name, le16_to_cpu(mpi_reply->TaskTag),
  3482. le32_to_cpu(mpi_reply->TransferCount), scmd->result);
  3483. pr_warn(MPT3SAS_FMT
  3484. "\tscsi_status(%s)(0x%02x), scsi_state(%s)(0x%02x)\n",
  3485. ioc->name, desc_scsi_status,
  3486. scsi_status, desc_scsi_state, scsi_state);
  3487. if (scsi_state & MPI2_SCSI_STATE_AUTOSENSE_VALID) {
  3488. struct sense_info data;
  3489. _scsih_normalize_sense(scmd->sense_buffer, &data);
  3490. pr_warn(MPT3SAS_FMT
  3491. "\t[sense_key,asc,ascq]: [0x%02x,0x%02x,0x%02x], count(%d)\n",
  3492. ioc->name, data.skey,
  3493. data.asc, data.ascq, le32_to_cpu(mpi_reply->SenseCount));
  3494. }
  3495. if (scsi_state & MPI2_SCSI_STATE_RESPONSE_INFO_VALID) {
  3496. response_info = le32_to_cpu(mpi_reply->ResponseInfo);
  3497. response_bytes = (u8 *)&response_info;
  3498. _scsih_response_code(ioc, response_bytes[0]);
  3499. }
  3500. }
  3501. #endif
  3502. /**
  3503. * _scsih_turn_on_fault_led - illuminate Fault LED
  3504. * @ioc: per adapter object
  3505. * @handle: device handle
  3506. * Context: process
  3507. *
  3508. * Return nothing.
  3509. */
  3510. static void
  3511. _scsih_turn_on_fault_led(struct MPT3SAS_ADAPTER *ioc, u16 handle)
  3512. {
  3513. Mpi2SepReply_t mpi_reply;
  3514. Mpi2SepRequest_t mpi_request;
  3515. memset(&mpi_request, 0, sizeof(Mpi2SepRequest_t));
  3516. mpi_request.Function = MPI2_FUNCTION_SCSI_ENCLOSURE_PROCESSOR;
  3517. mpi_request.Action = MPI2_SEP_REQ_ACTION_WRITE_STATUS;
  3518. mpi_request.SlotStatus =
  3519. cpu_to_le32(MPI2_SEP_REQ_SLOTSTATUS_PREDICTED_FAULT);
  3520. mpi_request.DevHandle = cpu_to_le16(handle);
  3521. mpi_request.Flags = MPI2_SEP_REQ_FLAGS_DEVHANDLE_ADDRESS;
  3522. if ((mpt3sas_base_scsi_enclosure_processor(ioc, &mpi_reply,
  3523. &mpi_request)) != 0) {
  3524. pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n", ioc->name,
  3525. __FILE__, __LINE__, __func__);
  3526. return;
  3527. }
  3528. if (mpi_reply.IOCStatus || mpi_reply.IOCLogInfo) {
  3529. dewtprintk(ioc, pr_info(MPT3SAS_FMT
  3530. "enclosure_processor: ioc_status (0x%04x), loginfo(0x%08x)\n",
  3531. ioc->name, le16_to_cpu(mpi_reply.IOCStatus),
  3532. le32_to_cpu(mpi_reply.IOCLogInfo)));
  3533. return;
  3534. }
  3535. }
  3536. /**
  3537. * _scsih_send_event_to_turn_on_fault_led - fire delayed event
  3538. * @ioc: per adapter object
  3539. * @handle: device handle
  3540. * Context: interrupt.
  3541. *
  3542. * Return nothing.
  3543. */
  3544. static void
  3545. _scsih_send_event_to_turn_on_fault_led(struct MPT3SAS_ADAPTER *ioc, u16 handle)
  3546. {
  3547. struct fw_event_work *fw_event;
  3548. fw_event = kzalloc(sizeof(struct fw_event_work), GFP_ATOMIC);
  3549. if (!fw_event)
  3550. return;
  3551. fw_event->event = MPT3SAS_TURN_ON_FAULT_LED;
  3552. fw_event->device_handle = handle;
  3553. fw_event->ioc = ioc;
  3554. _scsih_fw_event_add(ioc, fw_event);
  3555. }
  3556. /**
  3557. * _scsih_smart_predicted_fault - process smart errors
  3558. * @ioc: per adapter object
  3559. * @handle: device handle
  3560. * Context: interrupt.
  3561. *
  3562. * Return nothing.
  3563. */
  3564. static void
  3565. _scsih_smart_predicted_fault(struct MPT3SAS_ADAPTER *ioc, u16 handle)
  3566. {
  3567. struct scsi_target *starget;
  3568. struct MPT3SAS_TARGET *sas_target_priv_data;
  3569. Mpi2EventNotificationReply_t *event_reply;
  3570. Mpi2EventDataSasDeviceStatusChange_t *event_data;
  3571. struct _sas_device *sas_device;
  3572. ssize_t sz;
  3573. unsigned long flags;
  3574. /* only handle non-raid devices */
  3575. spin_lock_irqsave(&ioc->sas_device_lock, flags);
  3576. sas_device = _scsih_sas_device_find_by_handle(ioc, handle);
  3577. if (!sas_device) {
  3578. spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
  3579. return;
  3580. }
  3581. starget = sas_device->starget;
  3582. sas_target_priv_data = starget->hostdata;
  3583. if ((sas_target_priv_data->flags & MPT_TARGET_FLAGS_RAID_COMPONENT) ||
  3584. ((sas_target_priv_data->flags & MPT_TARGET_FLAGS_VOLUME))) {
  3585. spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
  3586. return;
  3587. }
  3588. starget_printk(KERN_WARNING, starget, "predicted fault\n");
  3589. spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
  3590. if (ioc->pdev->subsystem_vendor == PCI_VENDOR_ID_IBM)
  3591. _scsih_send_event_to_turn_on_fault_led(ioc, handle);
  3592. /* insert into event log */
  3593. sz = offsetof(Mpi2EventNotificationReply_t, EventData) +
  3594. sizeof(Mpi2EventDataSasDeviceStatusChange_t);
  3595. event_reply = kzalloc(sz, GFP_KERNEL);
  3596. if (!event_reply) {
  3597. pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
  3598. ioc->name, __FILE__, __LINE__, __func__);
  3599. return;
  3600. }
  3601. event_reply->Function = MPI2_FUNCTION_EVENT_NOTIFICATION;
  3602. event_reply->Event =
  3603. cpu_to_le16(MPI2_EVENT_SAS_DEVICE_STATUS_CHANGE);
  3604. event_reply->MsgLength = sz/4;
  3605. event_reply->EventDataLength =
  3606. cpu_to_le16(sizeof(Mpi2EventDataSasDeviceStatusChange_t)/4);
  3607. event_data = (Mpi2EventDataSasDeviceStatusChange_t *)
  3608. event_reply->EventData;
  3609. event_data->ReasonCode = MPI2_EVENT_SAS_DEV_STAT_RC_SMART_DATA;
  3610. event_data->ASC = 0x5D;
  3611. event_data->DevHandle = cpu_to_le16(handle);
  3612. event_data->SASAddress = cpu_to_le64(sas_target_priv_data->sas_address);
  3613. mpt3sas_ctl_add_to_event_log(ioc, event_reply);
  3614. kfree(event_reply);
  3615. }
  3616. /**
  3617. * _scsih_io_done - scsi request callback
  3618. * @ioc: per adapter object
  3619. * @smid: system request message index
  3620. * @msix_index: MSIX table index supplied by the OS
  3621. * @reply: reply message frame(lower 32bit addr)
  3622. *
  3623. * Callback handler when using _scsih_qcmd.
  3624. *
  3625. * Return 1 meaning mf should be freed from _base_interrupt
  3626. * 0 means the mf is freed from this function.
  3627. */
  3628. static u8
  3629. _scsih_io_done(struct MPT3SAS_ADAPTER *ioc, u16 smid, u8 msix_index, u32 reply)
  3630. {
  3631. Mpi2SCSIIORequest_t *mpi_request;
  3632. Mpi2SCSIIOReply_t *mpi_reply;
  3633. struct scsi_cmnd *scmd;
  3634. u16 ioc_status;
  3635. u32 xfer_cnt;
  3636. u8 scsi_state;
  3637. u8 scsi_status;
  3638. u32 log_info;
  3639. struct MPT3SAS_DEVICE *sas_device_priv_data;
  3640. u32 response_code = 0;
  3641. mpi_reply = mpt3sas_base_get_reply_virt_addr(ioc, reply);
  3642. scmd = _scsih_scsi_lookup_get_clear(ioc, smid);
  3643. if (scmd == NULL)
  3644. return 1;
  3645. mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
  3646. if (mpi_reply == NULL) {
  3647. scmd->result = DID_OK << 16;
  3648. goto out;
  3649. }
  3650. sas_device_priv_data = scmd->device->hostdata;
  3651. if (!sas_device_priv_data || !sas_device_priv_data->sas_target ||
  3652. sas_device_priv_data->sas_target->deleted) {
  3653. scmd->result = DID_NO_CONNECT << 16;
  3654. goto out;
  3655. }
  3656. ioc_status = le16_to_cpu(mpi_reply->IOCStatus);
  3657. /* turning off TLR */
  3658. scsi_state = mpi_reply->SCSIState;
  3659. if (scsi_state & MPI2_SCSI_STATE_RESPONSE_INFO_VALID)
  3660. response_code =
  3661. le32_to_cpu(mpi_reply->ResponseInfo) & 0xFF;
  3662. if (!sas_device_priv_data->tlr_snoop_check) {
  3663. sas_device_priv_data->tlr_snoop_check++;
  3664. if ((sas_device_priv_data->flags & MPT_DEVICE_TLR_ON) &&
  3665. response_code == MPI2_SCSITASKMGMT_RSP_INVALID_FRAME)
  3666. sas_device_priv_data->flags &=
  3667. ~MPT_DEVICE_TLR_ON;
  3668. }
  3669. xfer_cnt = le32_to_cpu(mpi_reply->TransferCount);
  3670. scsi_set_resid(scmd, scsi_bufflen(scmd) - xfer_cnt);
  3671. if (ioc_status & MPI2_IOCSTATUS_FLAG_LOG_INFO_AVAILABLE)
  3672. log_info = le32_to_cpu(mpi_reply->IOCLogInfo);
  3673. else
  3674. log_info = 0;
  3675. ioc_status &= MPI2_IOCSTATUS_MASK;
  3676. scsi_status = mpi_reply->SCSIStatus;
  3677. if (ioc_status == MPI2_IOCSTATUS_SCSI_DATA_UNDERRUN && xfer_cnt == 0 &&
  3678. (scsi_status == MPI2_SCSI_STATUS_BUSY ||
  3679. scsi_status == MPI2_SCSI_STATUS_RESERVATION_CONFLICT ||
  3680. scsi_status == MPI2_SCSI_STATUS_TASK_SET_FULL)) {
  3681. ioc_status = MPI2_IOCSTATUS_SUCCESS;
  3682. }
  3683. if (scsi_state & MPI2_SCSI_STATE_AUTOSENSE_VALID) {
  3684. struct sense_info data;
  3685. const void *sense_data = mpt3sas_base_get_sense_buffer(ioc,
  3686. smid);
  3687. u32 sz = min_t(u32, SCSI_SENSE_BUFFERSIZE,
  3688. le32_to_cpu(mpi_reply->SenseCount));
  3689. memcpy(scmd->sense_buffer, sense_data, sz);
  3690. _scsih_normalize_sense(scmd->sense_buffer, &data);
  3691. /* failure prediction threshold exceeded */
  3692. if (data.asc == 0x5D)
  3693. _scsih_smart_predicted_fault(ioc,
  3694. le16_to_cpu(mpi_reply->DevHandle));
  3695. mpt3sas_trigger_scsi(ioc, data.skey, data.asc, data.ascq);
  3696. }
  3697. switch (ioc_status) {
  3698. case MPI2_IOCSTATUS_BUSY:
  3699. case MPI2_IOCSTATUS_INSUFFICIENT_RESOURCES:
  3700. scmd->result = SAM_STAT_BUSY;
  3701. break;
  3702. case MPI2_IOCSTATUS_SCSI_DEVICE_NOT_THERE:
  3703. scmd->result = DID_NO_CONNECT << 16;
  3704. break;
  3705. case MPI2_IOCSTATUS_SCSI_IOC_TERMINATED:
  3706. if (sas_device_priv_data->block) {
  3707. scmd->result = DID_TRANSPORT_DISRUPTED << 16;
  3708. goto out;
  3709. }
  3710. if (log_info == 0x31110630) {
  3711. if (scmd->retries > 2) {
  3712. scmd->result = DID_NO_CONNECT << 16;
  3713. scsi_device_set_state(scmd->device,
  3714. SDEV_OFFLINE);
  3715. } else {
  3716. scmd->result = DID_SOFT_ERROR << 16;
  3717. scmd->device->expecting_cc_ua = 1;
  3718. }
  3719. break;
  3720. }
  3721. scmd->result = DID_SOFT_ERROR << 16;
  3722. break;
  3723. case MPI2_IOCSTATUS_SCSI_TASK_TERMINATED:
  3724. case MPI2_IOCSTATUS_SCSI_EXT_TERMINATED:
  3725. scmd->result = DID_RESET << 16;
  3726. break;
  3727. case MPI2_IOCSTATUS_SCSI_RESIDUAL_MISMATCH:
  3728. if ((xfer_cnt == 0) || (scmd->underflow > xfer_cnt))
  3729. scmd->result = DID_SOFT_ERROR << 16;
  3730. else
  3731. scmd->result = (DID_OK << 16) | scsi_status;
  3732. break;
  3733. case MPI2_IOCSTATUS_SCSI_DATA_UNDERRUN:
  3734. scmd->result = (DID_OK << 16) | scsi_status;
  3735. if ((scsi_state & MPI2_SCSI_STATE_AUTOSENSE_VALID))
  3736. break;
  3737. if (xfer_cnt < scmd->underflow) {
  3738. if (scsi_status == SAM_STAT_BUSY)
  3739. scmd->result = SAM_STAT_BUSY;
  3740. else
  3741. scmd->result = DID_SOFT_ERROR << 16;
  3742. } else if (scsi_state & (MPI2_SCSI_STATE_AUTOSENSE_FAILED |
  3743. MPI2_SCSI_STATE_NO_SCSI_STATUS))
  3744. scmd->result = DID_SOFT_ERROR << 16;
  3745. else if (scsi_state & MPI2_SCSI_STATE_TERMINATED)
  3746. scmd->result = DID_RESET << 16;
  3747. else if (!xfer_cnt && scmd->cmnd[0] == REPORT_LUNS) {
  3748. mpi_reply->SCSIState = MPI2_SCSI_STATE_AUTOSENSE_VALID;
  3749. mpi_reply->SCSIStatus = SAM_STAT_CHECK_CONDITION;
  3750. scmd->result = (DRIVER_SENSE << 24) |
  3751. SAM_STAT_CHECK_CONDITION;
  3752. scmd->sense_buffer[0] = 0x70;
  3753. scmd->sense_buffer[2] = ILLEGAL_REQUEST;
  3754. scmd->sense_buffer[12] = 0x20;
  3755. scmd->sense_buffer[13] = 0;
  3756. }
  3757. break;
  3758. case MPI2_IOCSTATUS_SCSI_DATA_OVERRUN:
  3759. scsi_set_resid(scmd, 0);
  3760. case MPI2_IOCSTATUS_SCSI_RECOVERED_ERROR:
  3761. case MPI2_IOCSTATUS_SUCCESS:
  3762. scmd->result = (DID_OK << 16) | scsi_status;
  3763. if (response_code ==
  3764. MPI2_SCSITASKMGMT_RSP_INVALID_FRAME ||
  3765. (scsi_state & (MPI2_SCSI_STATE_AUTOSENSE_FAILED |
  3766. MPI2_SCSI_STATE_NO_SCSI_STATUS)))
  3767. scmd->result = DID_SOFT_ERROR << 16;
  3768. else if (scsi_state & MPI2_SCSI_STATE_TERMINATED)
  3769. scmd->result = DID_RESET << 16;
  3770. break;
  3771. case MPI2_IOCSTATUS_EEDP_GUARD_ERROR:
  3772. case MPI2_IOCSTATUS_EEDP_REF_TAG_ERROR:
  3773. case MPI2_IOCSTATUS_EEDP_APP_TAG_ERROR:
  3774. _scsih_eedp_error_handling(scmd, ioc_status);
  3775. break;
  3776. case MPI2_IOCSTATUS_SCSI_PROTOCOL_ERROR:
  3777. case MPI2_IOCSTATUS_INVALID_FUNCTION:
  3778. case MPI2_IOCSTATUS_INVALID_SGL:
  3779. case MPI2_IOCSTATUS_INTERNAL_ERROR:
  3780. case MPI2_IOCSTATUS_INVALID_FIELD:
  3781. case MPI2_IOCSTATUS_INVALID_STATE:
  3782. case MPI2_IOCSTATUS_SCSI_IO_DATA_ERROR:
  3783. case MPI2_IOCSTATUS_SCSI_TASK_MGMT_FAILED:
  3784. default:
  3785. scmd->result = DID_SOFT_ERROR << 16;
  3786. break;
  3787. }
  3788. #ifdef CONFIG_SCSI_MPT3SAS_LOGGING
  3789. if (scmd->result && (ioc->logging_level & MPT_DEBUG_REPLY))
  3790. _scsih_scsi_ioc_info(ioc , scmd, mpi_reply, smid);
  3791. #endif
  3792. out:
  3793. scsi_dma_unmap(scmd);
  3794. scmd->scsi_done(scmd);
  3795. return 1;
  3796. }
  3797. /**
  3798. * _scsih_sas_host_refresh - refreshing sas host object contents
  3799. * @ioc: per adapter object
  3800. * Context: user
  3801. *
  3802. * During port enable, fw will send topology events for every device. Its
  3803. * possible that the handles may change from the previous setting, so this
  3804. * code keeping handles updating if changed.
  3805. *
  3806. * Return nothing.
  3807. */
  3808. static void
  3809. _scsih_sas_host_refresh(struct MPT3SAS_ADAPTER *ioc)
  3810. {
  3811. u16 sz;
  3812. u16 ioc_status;
  3813. int i;
  3814. Mpi2ConfigReply_t mpi_reply;
  3815. Mpi2SasIOUnitPage0_t *sas_iounit_pg0 = NULL;
  3816. u16 attached_handle;
  3817. u8 link_rate;
  3818. dtmprintk(ioc, pr_info(MPT3SAS_FMT
  3819. "updating handles for sas_host(0x%016llx)\n",
  3820. ioc->name, (unsigned long long)ioc->sas_hba.sas_address));
  3821. sz = offsetof(Mpi2SasIOUnitPage0_t, PhyData) + (ioc->sas_hba.num_phys
  3822. * sizeof(Mpi2SasIOUnit0PhyData_t));
  3823. sas_iounit_pg0 = kzalloc(sz, GFP_KERNEL);
  3824. if (!sas_iounit_pg0) {
  3825. pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
  3826. ioc->name, __FILE__, __LINE__, __func__);
  3827. return;
  3828. }
  3829. if ((mpt3sas_config_get_sas_iounit_pg0(ioc, &mpi_reply,
  3830. sas_iounit_pg0, sz)) != 0)
  3831. goto out;
  3832. ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & MPI2_IOCSTATUS_MASK;
  3833. if (ioc_status != MPI2_IOCSTATUS_SUCCESS)
  3834. goto out;
  3835. for (i = 0; i < ioc->sas_hba.num_phys ; i++) {
  3836. link_rate = sas_iounit_pg0->PhyData[i].NegotiatedLinkRate >> 4;
  3837. if (i == 0)
  3838. ioc->sas_hba.handle = le16_to_cpu(sas_iounit_pg0->
  3839. PhyData[0].ControllerDevHandle);
  3840. ioc->sas_hba.phy[i].handle = ioc->sas_hba.handle;
  3841. attached_handle = le16_to_cpu(sas_iounit_pg0->PhyData[i].
  3842. AttachedDevHandle);
  3843. if (attached_handle && link_rate < MPI2_SAS_NEG_LINK_RATE_1_5)
  3844. link_rate = MPI2_SAS_NEG_LINK_RATE_1_5;
  3845. mpt3sas_transport_update_links(ioc, ioc->sas_hba.sas_address,
  3846. attached_handle, i, link_rate);
  3847. }
  3848. out:
  3849. kfree(sas_iounit_pg0);
  3850. }
  3851. /**
  3852. * _scsih_sas_host_add - create sas host object
  3853. * @ioc: per adapter object
  3854. *
  3855. * Creating host side data object, stored in ioc->sas_hba
  3856. *
  3857. * Return nothing.
  3858. */
  3859. static void
  3860. _scsih_sas_host_add(struct MPT3SAS_ADAPTER *ioc)
  3861. {
  3862. int i;
  3863. Mpi2ConfigReply_t mpi_reply;
  3864. Mpi2SasIOUnitPage0_t *sas_iounit_pg0 = NULL;
  3865. Mpi2SasIOUnitPage1_t *sas_iounit_pg1 = NULL;
  3866. Mpi2SasPhyPage0_t phy_pg0;
  3867. Mpi2SasDevicePage0_t sas_device_pg0;
  3868. Mpi2SasEnclosurePage0_t enclosure_pg0;
  3869. u16 ioc_status;
  3870. u16 sz;
  3871. u8 device_missing_delay;
  3872. mpt3sas_config_get_number_hba_phys(ioc, &ioc->sas_hba.num_phys);
  3873. if (!ioc->sas_hba.num_phys) {
  3874. pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
  3875. ioc->name, __FILE__, __LINE__, __func__);
  3876. return;
  3877. }
  3878. /* sas_iounit page 0 */
  3879. sz = offsetof(Mpi2SasIOUnitPage0_t, PhyData) + (ioc->sas_hba.num_phys *
  3880. sizeof(Mpi2SasIOUnit0PhyData_t));
  3881. sas_iounit_pg0 = kzalloc(sz, GFP_KERNEL);
  3882. if (!sas_iounit_pg0) {
  3883. pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
  3884. ioc->name, __FILE__, __LINE__, __func__);
  3885. return;
  3886. }
  3887. if ((mpt3sas_config_get_sas_iounit_pg0(ioc, &mpi_reply,
  3888. sas_iounit_pg0, sz))) {
  3889. pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
  3890. ioc->name, __FILE__, __LINE__, __func__);
  3891. goto out;
  3892. }
  3893. ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
  3894. MPI2_IOCSTATUS_MASK;
  3895. if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
  3896. pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
  3897. ioc->name, __FILE__, __LINE__, __func__);
  3898. goto out;
  3899. }
  3900. /* sas_iounit page 1 */
  3901. sz = offsetof(Mpi2SasIOUnitPage1_t, PhyData) + (ioc->sas_hba.num_phys *
  3902. sizeof(Mpi2SasIOUnit1PhyData_t));
  3903. sas_iounit_pg1 = kzalloc(sz, GFP_KERNEL);
  3904. if (!sas_iounit_pg1) {
  3905. pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
  3906. ioc->name, __FILE__, __LINE__, __func__);
  3907. goto out;
  3908. }
  3909. if ((mpt3sas_config_get_sas_iounit_pg1(ioc, &mpi_reply,
  3910. sas_iounit_pg1, sz))) {
  3911. pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
  3912. ioc->name, __FILE__, __LINE__, __func__);
  3913. goto out;
  3914. }
  3915. ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
  3916. MPI2_IOCSTATUS_MASK;
  3917. if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
  3918. pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
  3919. ioc->name, __FILE__, __LINE__, __func__);
  3920. goto out;
  3921. }
  3922. ioc->io_missing_delay =
  3923. sas_iounit_pg1->IODeviceMissingDelay;
  3924. device_missing_delay =
  3925. sas_iounit_pg1->ReportDeviceMissingDelay;
  3926. if (device_missing_delay & MPI2_SASIOUNIT1_REPORT_MISSING_UNIT_16)
  3927. ioc->device_missing_delay = (device_missing_delay &
  3928. MPI2_SASIOUNIT1_REPORT_MISSING_TIMEOUT_MASK) * 16;
  3929. else
  3930. ioc->device_missing_delay = device_missing_delay &
  3931. MPI2_SASIOUNIT1_REPORT_MISSING_TIMEOUT_MASK;
  3932. ioc->sas_hba.parent_dev = &ioc->shost->shost_gendev;
  3933. ioc->sas_hba.phy = kcalloc(ioc->sas_hba.num_phys,
  3934. sizeof(struct _sas_phy), GFP_KERNEL);
  3935. if (!ioc->sas_hba.phy) {
  3936. pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
  3937. ioc->name, __FILE__, __LINE__, __func__);
  3938. goto out;
  3939. }
  3940. for (i = 0; i < ioc->sas_hba.num_phys ; i++) {
  3941. if ((mpt3sas_config_get_phy_pg0(ioc, &mpi_reply, &phy_pg0,
  3942. i))) {
  3943. pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
  3944. ioc->name, __FILE__, __LINE__, __func__);
  3945. goto out;
  3946. }
  3947. ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
  3948. MPI2_IOCSTATUS_MASK;
  3949. if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
  3950. pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
  3951. ioc->name, __FILE__, __LINE__, __func__);
  3952. goto out;
  3953. }
  3954. if (i == 0)
  3955. ioc->sas_hba.handle = le16_to_cpu(sas_iounit_pg0->
  3956. PhyData[0].ControllerDevHandle);
  3957. ioc->sas_hba.phy[i].handle = ioc->sas_hba.handle;
  3958. ioc->sas_hba.phy[i].phy_id = i;
  3959. mpt3sas_transport_add_host_phy(ioc, &ioc->sas_hba.phy[i],
  3960. phy_pg0, ioc->sas_hba.parent_dev);
  3961. }
  3962. if ((mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0,
  3963. MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, ioc->sas_hba.handle))) {
  3964. pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
  3965. ioc->name, __FILE__, __LINE__, __func__);
  3966. goto out;
  3967. }
  3968. ioc->sas_hba.enclosure_handle =
  3969. le16_to_cpu(sas_device_pg0.EnclosureHandle);
  3970. ioc->sas_hba.sas_address = le64_to_cpu(sas_device_pg0.SASAddress);
  3971. pr_info(MPT3SAS_FMT
  3972. "host_add: handle(0x%04x), sas_addr(0x%016llx), phys(%d)\n",
  3973. ioc->name, ioc->sas_hba.handle,
  3974. (unsigned long long) ioc->sas_hba.sas_address,
  3975. ioc->sas_hba.num_phys) ;
  3976. if (ioc->sas_hba.enclosure_handle) {
  3977. if (!(mpt3sas_config_get_enclosure_pg0(ioc, &mpi_reply,
  3978. &enclosure_pg0, MPI2_SAS_ENCLOS_PGAD_FORM_HANDLE,
  3979. ioc->sas_hba.enclosure_handle)))
  3980. ioc->sas_hba.enclosure_logical_id =
  3981. le64_to_cpu(enclosure_pg0.EnclosureLogicalID);
  3982. }
  3983. out:
  3984. kfree(sas_iounit_pg1);
  3985. kfree(sas_iounit_pg0);
  3986. }
  3987. /**
  3988. * _scsih_expander_add - creating expander object
  3989. * @ioc: per adapter object
  3990. * @handle: expander handle
  3991. *
  3992. * Creating expander object, stored in ioc->sas_expander_list.
  3993. *
  3994. * Return 0 for success, else error.
  3995. */
  3996. static int
  3997. _scsih_expander_add(struct MPT3SAS_ADAPTER *ioc, u16 handle)
  3998. {
  3999. struct _sas_node *sas_expander;
  4000. Mpi2ConfigReply_t mpi_reply;
  4001. Mpi2ExpanderPage0_t expander_pg0;
  4002. Mpi2ExpanderPage1_t expander_pg1;
  4003. Mpi2SasEnclosurePage0_t enclosure_pg0;
  4004. u32 ioc_status;
  4005. u16 parent_handle;
  4006. u64 sas_address, sas_address_parent = 0;
  4007. int i;
  4008. unsigned long flags;
  4009. struct _sas_port *mpt3sas_port = NULL;
  4010. int rc = 0;
  4011. if (!handle)
  4012. return -1;
  4013. if (ioc->shost_recovery || ioc->pci_error_recovery)
  4014. return -1;
  4015. if ((mpt3sas_config_get_expander_pg0(ioc, &mpi_reply, &expander_pg0,
  4016. MPI2_SAS_EXPAND_PGAD_FORM_HNDL, handle))) {
  4017. pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
  4018. ioc->name, __FILE__, __LINE__, __func__);
  4019. return -1;
  4020. }
  4021. ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
  4022. MPI2_IOCSTATUS_MASK;
  4023. if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
  4024. pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
  4025. ioc->name, __FILE__, __LINE__, __func__);
  4026. return -1;
  4027. }
  4028. /* handle out of order topology events */
  4029. parent_handle = le16_to_cpu(expander_pg0.ParentDevHandle);
  4030. if (_scsih_get_sas_address(ioc, parent_handle, &sas_address_parent)
  4031. != 0) {
  4032. pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
  4033. ioc->name, __FILE__, __LINE__, __func__);
  4034. return -1;
  4035. }
  4036. if (sas_address_parent != ioc->sas_hba.sas_address) {
  4037. spin_lock_irqsave(&ioc->sas_node_lock, flags);
  4038. sas_expander = mpt3sas_scsih_expander_find_by_sas_address(ioc,
  4039. sas_address_parent);
  4040. spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
  4041. if (!sas_expander) {
  4042. rc = _scsih_expander_add(ioc, parent_handle);
  4043. if (rc != 0)
  4044. return rc;
  4045. }
  4046. }
  4047. spin_lock_irqsave(&ioc->sas_node_lock, flags);
  4048. sas_address = le64_to_cpu(expander_pg0.SASAddress);
  4049. sas_expander = mpt3sas_scsih_expander_find_by_sas_address(ioc,
  4050. sas_address);
  4051. spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
  4052. if (sas_expander)
  4053. return 0;
  4054. sas_expander = kzalloc(sizeof(struct _sas_node),
  4055. GFP_KERNEL);
  4056. if (!sas_expander) {
  4057. pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
  4058. ioc->name, __FILE__, __LINE__, __func__);
  4059. return -1;
  4060. }
  4061. sas_expander->handle = handle;
  4062. sas_expander->num_phys = expander_pg0.NumPhys;
  4063. sas_expander->sas_address_parent = sas_address_parent;
  4064. sas_expander->sas_address = sas_address;
  4065. pr_info(MPT3SAS_FMT "expander_add: handle(0x%04x)," \
  4066. " parent(0x%04x), sas_addr(0x%016llx), phys(%d)\n", ioc->name,
  4067. handle, parent_handle, (unsigned long long)
  4068. sas_expander->sas_address, sas_expander->num_phys);
  4069. if (!sas_expander->num_phys)
  4070. goto out_fail;
  4071. sas_expander->phy = kcalloc(sas_expander->num_phys,
  4072. sizeof(struct _sas_phy), GFP_KERNEL);
  4073. if (!sas_expander->phy) {
  4074. pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
  4075. ioc->name, __FILE__, __LINE__, __func__);
  4076. rc = -1;
  4077. goto out_fail;
  4078. }
  4079. INIT_LIST_HEAD(&sas_expander->sas_port_list);
  4080. mpt3sas_port = mpt3sas_transport_port_add(ioc, handle,
  4081. sas_address_parent);
  4082. if (!mpt3sas_port) {
  4083. pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
  4084. ioc->name, __FILE__, __LINE__, __func__);
  4085. rc = -1;
  4086. goto out_fail;
  4087. }
  4088. sas_expander->parent_dev = &mpt3sas_port->rphy->dev;
  4089. for (i = 0 ; i < sas_expander->num_phys ; i++) {
  4090. if ((mpt3sas_config_get_expander_pg1(ioc, &mpi_reply,
  4091. &expander_pg1, i, handle))) {
  4092. pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
  4093. ioc->name, __FILE__, __LINE__, __func__);
  4094. rc = -1;
  4095. goto out_fail;
  4096. }
  4097. sas_expander->phy[i].handle = handle;
  4098. sas_expander->phy[i].phy_id = i;
  4099. if ((mpt3sas_transport_add_expander_phy(ioc,
  4100. &sas_expander->phy[i], expander_pg1,
  4101. sas_expander->parent_dev))) {
  4102. pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
  4103. ioc->name, __FILE__, __LINE__, __func__);
  4104. rc = -1;
  4105. goto out_fail;
  4106. }
  4107. }
  4108. if (sas_expander->enclosure_handle) {
  4109. if (!(mpt3sas_config_get_enclosure_pg0(ioc, &mpi_reply,
  4110. &enclosure_pg0, MPI2_SAS_ENCLOS_PGAD_FORM_HANDLE,
  4111. sas_expander->enclosure_handle)))
  4112. sas_expander->enclosure_logical_id =
  4113. le64_to_cpu(enclosure_pg0.EnclosureLogicalID);
  4114. }
  4115. _scsih_expander_node_add(ioc, sas_expander);
  4116. return 0;
  4117. out_fail:
  4118. if (mpt3sas_port)
  4119. mpt3sas_transport_port_remove(ioc, sas_expander->sas_address,
  4120. sas_address_parent);
  4121. kfree(sas_expander);
  4122. return rc;
  4123. }
  4124. /**
  4125. * mpt3sas_expander_remove - removing expander object
  4126. * @ioc: per adapter object
  4127. * @sas_address: expander sas_address
  4128. *
  4129. * Return nothing.
  4130. */
  4131. void
  4132. mpt3sas_expander_remove(struct MPT3SAS_ADAPTER *ioc, u64 sas_address)
  4133. {
  4134. struct _sas_node *sas_expander;
  4135. unsigned long flags;
  4136. if (ioc->shost_recovery)
  4137. return;
  4138. spin_lock_irqsave(&ioc->sas_node_lock, flags);
  4139. sas_expander = mpt3sas_scsih_expander_find_by_sas_address(ioc,
  4140. sas_address);
  4141. if (sas_expander)
  4142. list_del(&sas_expander->list);
  4143. spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
  4144. if (sas_expander)
  4145. _scsih_expander_node_remove(ioc, sas_expander);
  4146. }
  4147. /**
  4148. * _scsih_done - internal SCSI_IO callback handler.
  4149. * @ioc: per adapter object
  4150. * @smid: system request message index
  4151. * @msix_index: MSIX table index supplied by the OS
  4152. * @reply: reply message frame(lower 32bit addr)
  4153. *
  4154. * Callback handler when sending internal generated SCSI_IO.
  4155. * The callback index passed is `ioc->scsih_cb_idx`
  4156. *
  4157. * Return 1 meaning mf should be freed from _base_interrupt
  4158. * 0 means the mf is freed from this function.
  4159. */
  4160. static u8
  4161. _scsih_done(struct MPT3SAS_ADAPTER *ioc, u16 smid, u8 msix_index, u32 reply)
  4162. {
  4163. MPI2DefaultReply_t *mpi_reply;
  4164. mpi_reply = mpt3sas_base_get_reply_virt_addr(ioc, reply);
  4165. if (ioc->scsih_cmds.status == MPT3_CMD_NOT_USED)
  4166. return 1;
  4167. if (ioc->scsih_cmds.smid != smid)
  4168. return 1;
  4169. ioc->scsih_cmds.status |= MPT3_CMD_COMPLETE;
  4170. if (mpi_reply) {
  4171. memcpy(ioc->scsih_cmds.reply, mpi_reply,
  4172. mpi_reply->MsgLength*4);
  4173. ioc->scsih_cmds.status |= MPT3_CMD_REPLY_VALID;
  4174. }
  4175. ioc->scsih_cmds.status &= ~MPT3_CMD_PENDING;
  4176. complete(&ioc->scsih_cmds.done);
  4177. return 1;
  4178. }
  4179. #define MPT3_MAX_LUNS (255)
  4180. /**
  4181. * _scsih_check_access_status - check access flags
  4182. * @ioc: per adapter object
  4183. * @sas_address: sas address
  4184. * @handle: sas device handle
  4185. * @access_flags: errors returned during discovery of the device
  4186. *
  4187. * Return 0 for success, else failure
  4188. */
  4189. static u8
  4190. _scsih_check_access_status(struct MPT3SAS_ADAPTER *ioc, u64 sas_address,
  4191. u16 handle, u8 access_status)
  4192. {
  4193. u8 rc = 1;
  4194. char *desc = NULL;
  4195. switch (access_status) {
  4196. case MPI2_SAS_DEVICE0_ASTATUS_NO_ERRORS:
  4197. case MPI2_SAS_DEVICE0_ASTATUS_SATA_NEEDS_INITIALIZATION:
  4198. rc = 0;
  4199. break;
  4200. case MPI2_SAS_DEVICE0_ASTATUS_SATA_CAPABILITY_FAILED:
  4201. desc = "sata capability failed";
  4202. break;
  4203. case MPI2_SAS_DEVICE0_ASTATUS_SATA_AFFILIATION_CONFLICT:
  4204. desc = "sata affiliation conflict";
  4205. break;
  4206. case MPI2_SAS_DEVICE0_ASTATUS_ROUTE_NOT_ADDRESSABLE:
  4207. desc = "route not addressable";
  4208. break;
  4209. case MPI2_SAS_DEVICE0_ASTATUS_SMP_ERROR_NOT_ADDRESSABLE:
  4210. desc = "smp error not addressable";
  4211. break;
  4212. case MPI2_SAS_DEVICE0_ASTATUS_DEVICE_BLOCKED:
  4213. desc = "device blocked";
  4214. break;
  4215. case MPI2_SAS_DEVICE0_ASTATUS_SATA_INIT_FAILED:
  4216. case MPI2_SAS_DEVICE0_ASTATUS_SIF_UNKNOWN:
  4217. case MPI2_SAS_DEVICE0_ASTATUS_SIF_AFFILIATION_CONFLICT:
  4218. case MPI2_SAS_DEVICE0_ASTATUS_SIF_DIAG:
  4219. case MPI2_SAS_DEVICE0_ASTATUS_SIF_IDENTIFICATION:
  4220. case MPI2_SAS_DEVICE0_ASTATUS_SIF_CHECK_POWER:
  4221. case MPI2_SAS_DEVICE0_ASTATUS_SIF_PIO_SN:
  4222. case MPI2_SAS_DEVICE0_ASTATUS_SIF_MDMA_SN:
  4223. case MPI2_SAS_DEVICE0_ASTATUS_SIF_UDMA_SN:
  4224. case MPI2_SAS_DEVICE0_ASTATUS_SIF_ZONING_VIOLATION:
  4225. case MPI2_SAS_DEVICE0_ASTATUS_SIF_NOT_ADDRESSABLE:
  4226. case MPI2_SAS_DEVICE0_ASTATUS_SIF_MAX:
  4227. desc = "sata initialization failed";
  4228. break;
  4229. default:
  4230. desc = "unknown";
  4231. break;
  4232. }
  4233. if (!rc)
  4234. return 0;
  4235. pr_err(MPT3SAS_FMT
  4236. "discovery errors(%s): sas_address(0x%016llx), handle(0x%04x)\n",
  4237. ioc->name, desc, (unsigned long long)sas_address, handle);
  4238. return rc;
  4239. }
  4240. /**
  4241. * _scsih_check_device - checking device responsiveness
  4242. * @ioc: per adapter object
  4243. * @parent_sas_address: sas address of parent expander or sas host
  4244. * @handle: attached device handle
  4245. * @phy_numberv: phy number
  4246. * @link_rate: new link rate
  4247. *
  4248. * Returns nothing.
  4249. */
  4250. static void
  4251. _scsih_check_device(struct MPT3SAS_ADAPTER *ioc,
  4252. u64 parent_sas_address, u16 handle, u8 phy_number, u8 link_rate)
  4253. {
  4254. Mpi2ConfigReply_t mpi_reply;
  4255. Mpi2SasDevicePage0_t sas_device_pg0;
  4256. struct _sas_device *sas_device;
  4257. u32 ioc_status;
  4258. unsigned long flags;
  4259. u64 sas_address;
  4260. struct scsi_target *starget;
  4261. struct MPT3SAS_TARGET *sas_target_priv_data;
  4262. u32 device_info;
  4263. if ((mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0,
  4264. MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, handle)))
  4265. return;
  4266. ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & MPI2_IOCSTATUS_MASK;
  4267. if (ioc_status != MPI2_IOCSTATUS_SUCCESS)
  4268. return;
  4269. /* wide port handling ~ we need only handle device once for the phy that
  4270. * is matched in sas device page zero
  4271. */
  4272. if (phy_number != sas_device_pg0.PhyNum)
  4273. return;
  4274. /* check if this is end device */
  4275. device_info = le32_to_cpu(sas_device_pg0.DeviceInfo);
  4276. if (!(_scsih_is_end_device(device_info)))
  4277. return;
  4278. spin_lock_irqsave(&ioc->sas_device_lock, flags);
  4279. sas_address = le64_to_cpu(sas_device_pg0.SASAddress);
  4280. sas_device = mpt3sas_scsih_sas_device_find_by_sas_address(ioc,
  4281. sas_address);
  4282. if (!sas_device) {
  4283. spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
  4284. return;
  4285. }
  4286. if (unlikely(sas_device->handle != handle)) {
  4287. starget = sas_device->starget;
  4288. sas_target_priv_data = starget->hostdata;
  4289. starget_printk(KERN_INFO, starget,
  4290. "handle changed from(0x%04x) to (0x%04x)!!!\n",
  4291. sas_device->handle, handle);
  4292. sas_target_priv_data->handle = handle;
  4293. sas_device->handle = handle;
  4294. }
  4295. /* check if device is present */
  4296. if (!(le16_to_cpu(sas_device_pg0.Flags) &
  4297. MPI2_SAS_DEVICE0_FLAGS_DEVICE_PRESENT)) {
  4298. pr_err(MPT3SAS_FMT
  4299. "device is not present handle(0x%04x), flags!!!\n",
  4300. ioc->name, handle);
  4301. spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
  4302. return;
  4303. }
  4304. /* check if there were any issues with discovery */
  4305. if (_scsih_check_access_status(ioc, sas_address, handle,
  4306. sas_device_pg0.AccessStatus)) {
  4307. spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
  4308. return;
  4309. }
  4310. spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
  4311. _scsih_ublock_io_device(ioc, sas_address);
  4312. }
  4313. /**
  4314. * _scsih_add_device - creating sas device object
  4315. * @ioc: per adapter object
  4316. * @handle: sas device handle
  4317. * @phy_num: phy number end device attached to
  4318. * @is_pd: is this hidden raid component
  4319. *
  4320. * Creating end device object, stored in ioc->sas_device_list.
  4321. *
  4322. * Returns 0 for success, non-zero for failure.
  4323. */
  4324. static int
  4325. _scsih_add_device(struct MPT3SAS_ADAPTER *ioc, u16 handle, u8 phy_num,
  4326. u8 is_pd)
  4327. {
  4328. Mpi2ConfigReply_t mpi_reply;
  4329. Mpi2SasDevicePage0_t sas_device_pg0;
  4330. Mpi2SasEnclosurePage0_t enclosure_pg0;
  4331. struct _sas_device *sas_device;
  4332. u32 ioc_status;
  4333. u64 sas_address;
  4334. u32 device_info;
  4335. unsigned long flags;
  4336. if ((mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0,
  4337. MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, handle))) {
  4338. pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
  4339. ioc->name, __FILE__, __LINE__, __func__);
  4340. return -1;
  4341. }
  4342. ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
  4343. MPI2_IOCSTATUS_MASK;
  4344. if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
  4345. pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
  4346. ioc->name, __FILE__, __LINE__, __func__);
  4347. return -1;
  4348. }
  4349. /* check if this is end device */
  4350. device_info = le32_to_cpu(sas_device_pg0.DeviceInfo);
  4351. if (!(_scsih_is_end_device(device_info)))
  4352. return -1;
  4353. sas_address = le64_to_cpu(sas_device_pg0.SASAddress);
  4354. /* check if device is present */
  4355. if (!(le16_to_cpu(sas_device_pg0.Flags) &
  4356. MPI2_SAS_DEVICE0_FLAGS_DEVICE_PRESENT)) {
  4357. pr_err(MPT3SAS_FMT "device is not present handle(0x04%x)!!!\n",
  4358. ioc->name, handle);
  4359. return -1;
  4360. }
  4361. /* check if there were any issues with discovery */
  4362. if (_scsih_check_access_status(ioc, sas_address, handle,
  4363. sas_device_pg0.AccessStatus))
  4364. return -1;
  4365. spin_lock_irqsave(&ioc->sas_device_lock, flags);
  4366. sas_device = mpt3sas_scsih_sas_device_find_by_sas_address(ioc,
  4367. sas_address);
  4368. spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
  4369. if (sas_device)
  4370. return -1;
  4371. sas_device = kzalloc(sizeof(struct _sas_device),
  4372. GFP_KERNEL);
  4373. if (!sas_device) {
  4374. pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
  4375. ioc->name, __FILE__, __LINE__, __func__);
  4376. return 0;
  4377. }
  4378. sas_device->handle = handle;
  4379. if (_scsih_get_sas_address(ioc,
  4380. le16_to_cpu(sas_device_pg0.ParentDevHandle),
  4381. &sas_device->sas_address_parent) != 0)
  4382. pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
  4383. ioc->name, __FILE__, __LINE__, __func__);
  4384. sas_device->enclosure_handle =
  4385. le16_to_cpu(sas_device_pg0.EnclosureHandle);
  4386. sas_device->slot =
  4387. le16_to_cpu(sas_device_pg0.Slot);
  4388. sas_device->device_info = device_info;
  4389. sas_device->sas_address = sas_address;
  4390. sas_device->phy = sas_device_pg0.PhyNum;
  4391. sas_device->fast_path = (le16_to_cpu(sas_device_pg0.Flags) &
  4392. MPI25_SAS_DEVICE0_FLAGS_FAST_PATH_CAPABLE) ? 1 : 0;
  4393. /* get enclosure_logical_id */
  4394. if (sas_device->enclosure_handle && !(mpt3sas_config_get_enclosure_pg0(
  4395. ioc, &mpi_reply, &enclosure_pg0, MPI2_SAS_ENCLOS_PGAD_FORM_HANDLE,
  4396. sas_device->enclosure_handle)))
  4397. sas_device->enclosure_logical_id =
  4398. le64_to_cpu(enclosure_pg0.EnclosureLogicalID);
  4399. /* get device name */
  4400. sas_device->device_name = le64_to_cpu(sas_device_pg0.DeviceName);
  4401. if (ioc->wait_for_discovery_to_complete)
  4402. _scsih_sas_device_init_add(ioc, sas_device);
  4403. else
  4404. _scsih_sas_device_add(ioc, sas_device);
  4405. return 0;
  4406. }
  4407. /**
  4408. * _scsih_remove_device - removing sas device object
  4409. * @ioc: per adapter object
  4410. * @sas_device_delete: the sas_device object
  4411. *
  4412. * Return nothing.
  4413. */
  4414. static void
  4415. _scsih_remove_device(struct MPT3SAS_ADAPTER *ioc,
  4416. struct _sas_device *sas_device)
  4417. {
  4418. struct MPT3SAS_TARGET *sas_target_priv_data;
  4419. dewtprintk(ioc, pr_info(MPT3SAS_FMT
  4420. "%s: enter: handle(0x%04x), sas_addr(0x%016llx)\n",
  4421. ioc->name, __func__,
  4422. sas_device->handle, (unsigned long long)
  4423. sas_device->sas_address));
  4424. if (sas_device->starget && sas_device->starget->hostdata) {
  4425. sas_target_priv_data = sas_device->starget->hostdata;
  4426. sas_target_priv_data->deleted = 1;
  4427. _scsih_ublock_io_device(ioc, sas_device->sas_address);
  4428. sas_target_priv_data->handle =
  4429. MPT3SAS_INVALID_DEVICE_HANDLE;
  4430. }
  4431. mpt3sas_transport_port_remove(ioc,
  4432. sas_device->sas_address,
  4433. sas_device->sas_address_parent);
  4434. pr_info(MPT3SAS_FMT
  4435. "removing handle(0x%04x), sas_addr(0x%016llx)\n",
  4436. ioc->name, sas_device->handle,
  4437. (unsigned long long) sas_device->sas_address);
  4438. dewtprintk(ioc, pr_info(MPT3SAS_FMT
  4439. "%s: exit: handle(0x%04x), sas_addr(0x%016llx)\n",
  4440. ioc->name, __func__,
  4441. sas_device->handle, (unsigned long long)
  4442. sas_device->sas_address));
  4443. kfree(sas_device);
  4444. }
  4445. #ifdef CONFIG_SCSI_MPT3SAS_LOGGING
  4446. /**
  4447. * _scsih_sas_topology_change_event_debug - debug for topology event
  4448. * @ioc: per adapter object
  4449. * @event_data: event data payload
  4450. * Context: user.
  4451. */
  4452. static void
  4453. _scsih_sas_topology_change_event_debug(struct MPT3SAS_ADAPTER *ioc,
  4454. Mpi2EventDataSasTopologyChangeList_t *event_data)
  4455. {
  4456. int i;
  4457. u16 handle;
  4458. u16 reason_code;
  4459. u8 phy_number;
  4460. char *status_str = NULL;
  4461. u8 link_rate, prev_link_rate;
  4462. switch (event_data->ExpStatus) {
  4463. case MPI2_EVENT_SAS_TOPO_ES_ADDED:
  4464. status_str = "add";
  4465. break;
  4466. case MPI2_EVENT_SAS_TOPO_ES_NOT_RESPONDING:
  4467. status_str = "remove";
  4468. break;
  4469. case MPI2_EVENT_SAS_TOPO_ES_RESPONDING:
  4470. case 0:
  4471. status_str = "responding";
  4472. break;
  4473. case MPI2_EVENT_SAS_TOPO_ES_DELAY_NOT_RESPONDING:
  4474. status_str = "remove delay";
  4475. break;
  4476. default:
  4477. status_str = "unknown status";
  4478. break;
  4479. }
  4480. pr_info(MPT3SAS_FMT "sas topology change: (%s)\n",
  4481. ioc->name, status_str);
  4482. pr_info("\thandle(0x%04x), enclosure_handle(0x%04x) " \
  4483. "start_phy(%02d), count(%d)\n",
  4484. le16_to_cpu(event_data->ExpanderDevHandle),
  4485. le16_to_cpu(event_data->EnclosureHandle),
  4486. event_data->StartPhyNum, event_data->NumEntries);
  4487. for (i = 0; i < event_data->NumEntries; i++) {
  4488. handle = le16_to_cpu(event_data->PHY[i].AttachedDevHandle);
  4489. if (!handle)
  4490. continue;
  4491. phy_number = event_data->StartPhyNum + i;
  4492. reason_code = event_data->PHY[i].PhyStatus &
  4493. MPI2_EVENT_SAS_TOPO_RC_MASK;
  4494. switch (reason_code) {
  4495. case MPI2_EVENT_SAS_TOPO_RC_TARG_ADDED:
  4496. status_str = "target add";
  4497. break;
  4498. case MPI2_EVENT_SAS_TOPO_RC_TARG_NOT_RESPONDING:
  4499. status_str = "target remove";
  4500. break;
  4501. case MPI2_EVENT_SAS_TOPO_RC_DELAY_NOT_RESPONDING:
  4502. status_str = "delay target remove";
  4503. break;
  4504. case MPI2_EVENT_SAS_TOPO_RC_PHY_CHANGED:
  4505. status_str = "link rate change";
  4506. break;
  4507. case MPI2_EVENT_SAS_TOPO_RC_NO_CHANGE:
  4508. status_str = "target responding";
  4509. break;
  4510. default:
  4511. status_str = "unknown";
  4512. break;
  4513. }
  4514. link_rate = event_data->PHY[i].LinkRate >> 4;
  4515. prev_link_rate = event_data->PHY[i].LinkRate & 0xF;
  4516. pr_info("\tphy(%02d), attached_handle(0x%04x): %s:" \
  4517. " link rate: new(0x%02x), old(0x%02x)\n", phy_number,
  4518. handle, status_str, link_rate, prev_link_rate);
  4519. }
  4520. }
  4521. #endif
  4522. /**
  4523. * _scsih_sas_topology_change_event - handle topology changes
  4524. * @ioc: per adapter object
  4525. * @fw_event: The fw_event_work object
  4526. * Context: user.
  4527. *
  4528. */
  4529. static int
  4530. _scsih_sas_topology_change_event(struct MPT3SAS_ADAPTER *ioc,
  4531. struct fw_event_work *fw_event)
  4532. {
  4533. int i;
  4534. u16 parent_handle, handle;
  4535. u16 reason_code;
  4536. u8 phy_number, max_phys;
  4537. struct _sas_node *sas_expander;
  4538. u64 sas_address;
  4539. unsigned long flags;
  4540. u8 link_rate, prev_link_rate;
  4541. Mpi2EventDataSasTopologyChangeList_t *event_data = fw_event->event_data;
  4542. #ifdef CONFIG_SCSI_MPT3SAS_LOGGING
  4543. if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK)
  4544. _scsih_sas_topology_change_event_debug(ioc, event_data);
  4545. #endif
  4546. if (ioc->shost_recovery || ioc->remove_host || ioc->pci_error_recovery)
  4547. return 0;
  4548. if (!ioc->sas_hba.num_phys)
  4549. _scsih_sas_host_add(ioc);
  4550. else
  4551. _scsih_sas_host_refresh(ioc);
  4552. if (fw_event->ignore) {
  4553. dewtprintk(ioc, pr_info(MPT3SAS_FMT
  4554. "ignoring expander event\n", ioc->name));
  4555. return 0;
  4556. }
  4557. parent_handle = le16_to_cpu(event_data->ExpanderDevHandle);
  4558. /* handle expander add */
  4559. if (event_data->ExpStatus == MPI2_EVENT_SAS_TOPO_ES_ADDED)
  4560. if (_scsih_expander_add(ioc, parent_handle) != 0)
  4561. return 0;
  4562. spin_lock_irqsave(&ioc->sas_node_lock, flags);
  4563. sas_expander = mpt3sas_scsih_expander_find_by_handle(ioc,
  4564. parent_handle);
  4565. if (sas_expander) {
  4566. sas_address = sas_expander->sas_address;
  4567. max_phys = sas_expander->num_phys;
  4568. } else if (parent_handle < ioc->sas_hba.num_phys) {
  4569. sas_address = ioc->sas_hba.sas_address;
  4570. max_phys = ioc->sas_hba.num_phys;
  4571. } else {
  4572. spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
  4573. return 0;
  4574. }
  4575. spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
  4576. /* handle siblings events */
  4577. for (i = 0; i < event_data->NumEntries; i++) {
  4578. if (fw_event->ignore) {
  4579. dewtprintk(ioc, pr_info(MPT3SAS_FMT
  4580. "ignoring expander event\n", ioc->name));
  4581. return 0;
  4582. }
  4583. if (ioc->remove_host || ioc->pci_error_recovery)
  4584. return 0;
  4585. phy_number = event_data->StartPhyNum + i;
  4586. if (phy_number >= max_phys)
  4587. continue;
  4588. reason_code = event_data->PHY[i].PhyStatus &
  4589. MPI2_EVENT_SAS_TOPO_RC_MASK;
  4590. if ((event_data->PHY[i].PhyStatus &
  4591. MPI2_EVENT_SAS_TOPO_PHYSTATUS_VACANT) && (reason_code !=
  4592. MPI2_EVENT_SAS_TOPO_RC_TARG_NOT_RESPONDING))
  4593. continue;
  4594. handle = le16_to_cpu(event_data->PHY[i].AttachedDevHandle);
  4595. if (!handle)
  4596. continue;
  4597. link_rate = event_data->PHY[i].LinkRate >> 4;
  4598. prev_link_rate = event_data->PHY[i].LinkRate & 0xF;
  4599. switch (reason_code) {
  4600. case MPI2_EVENT_SAS_TOPO_RC_PHY_CHANGED:
  4601. if (ioc->shost_recovery)
  4602. break;
  4603. if (link_rate == prev_link_rate)
  4604. break;
  4605. mpt3sas_transport_update_links(ioc, sas_address,
  4606. handle, phy_number, link_rate);
  4607. if (link_rate < MPI2_SAS_NEG_LINK_RATE_1_5)
  4608. break;
  4609. _scsih_check_device(ioc, sas_address, handle,
  4610. phy_number, link_rate);
  4611. case MPI2_EVENT_SAS_TOPO_RC_TARG_ADDED:
  4612. if (ioc->shost_recovery)
  4613. break;
  4614. mpt3sas_transport_update_links(ioc, sas_address,
  4615. handle, phy_number, link_rate);
  4616. _scsih_add_device(ioc, handle, phy_number, 0);
  4617. break;
  4618. case MPI2_EVENT_SAS_TOPO_RC_TARG_NOT_RESPONDING:
  4619. _scsih_device_remove_by_handle(ioc, handle);
  4620. break;
  4621. }
  4622. }
  4623. /* handle expander removal */
  4624. if (event_data->ExpStatus == MPI2_EVENT_SAS_TOPO_ES_NOT_RESPONDING &&
  4625. sas_expander)
  4626. mpt3sas_expander_remove(ioc, sas_address);
  4627. return 0;
  4628. }
  4629. #ifdef CONFIG_SCSI_MPT3SAS_LOGGING
  4630. /**
  4631. * _scsih_sas_device_status_change_event_debug - debug for device event
  4632. * @event_data: event data payload
  4633. * Context: user.
  4634. *
  4635. * Return nothing.
  4636. */
  4637. static void
  4638. _scsih_sas_device_status_change_event_debug(struct MPT3SAS_ADAPTER *ioc,
  4639. Mpi2EventDataSasDeviceStatusChange_t *event_data)
  4640. {
  4641. char *reason_str = NULL;
  4642. switch (event_data->ReasonCode) {
  4643. case MPI2_EVENT_SAS_DEV_STAT_RC_SMART_DATA:
  4644. reason_str = "smart data";
  4645. break;
  4646. case MPI2_EVENT_SAS_DEV_STAT_RC_UNSUPPORTED:
  4647. reason_str = "unsupported device discovered";
  4648. break;
  4649. case MPI2_EVENT_SAS_DEV_STAT_RC_INTERNAL_DEVICE_RESET:
  4650. reason_str = "internal device reset";
  4651. break;
  4652. case MPI2_EVENT_SAS_DEV_STAT_RC_TASK_ABORT_INTERNAL:
  4653. reason_str = "internal task abort";
  4654. break;
  4655. case MPI2_EVENT_SAS_DEV_STAT_RC_ABORT_TASK_SET_INTERNAL:
  4656. reason_str = "internal task abort set";
  4657. break;
  4658. case MPI2_EVENT_SAS_DEV_STAT_RC_CLEAR_TASK_SET_INTERNAL:
  4659. reason_str = "internal clear task set";
  4660. break;
  4661. case MPI2_EVENT_SAS_DEV_STAT_RC_QUERY_TASK_INTERNAL:
  4662. reason_str = "internal query task";
  4663. break;
  4664. case MPI2_EVENT_SAS_DEV_STAT_RC_SATA_INIT_FAILURE:
  4665. reason_str = "sata init failure";
  4666. break;
  4667. case MPI2_EVENT_SAS_DEV_STAT_RC_CMP_INTERNAL_DEV_RESET:
  4668. reason_str = "internal device reset complete";
  4669. break;
  4670. case MPI2_EVENT_SAS_DEV_STAT_RC_CMP_TASK_ABORT_INTERNAL:
  4671. reason_str = "internal task abort complete";
  4672. break;
  4673. case MPI2_EVENT_SAS_DEV_STAT_RC_ASYNC_NOTIFICATION:
  4674. reason_str = "internal async notification";
  4675. break;
  4676. case MPI2_EVENT_SAS_DEV_STAT_RC_EXPANDER_REDUCED_FUNCTIONALITY:
  4677. reason_str = "expander reduced functionality";
  4678. break;
  4679. case MPI2_EVENT_SAS_DEV_STAT_RC_CMP_EXPANDER_REDUCED_FUNCTIONALITY:
  4680. reason_str = "expander reduced functionality complete";
  4681. break;
  4682. default:
  4683. reason_str = "unknown reason";
  4684. break;
  4685. }
  4686. pr_info(MPT3SAS_FMT "device status change: (%s)\n"
  4687. "\thandle(0x%04x), sas address(0x%016llx), tag(%d)",
  4688. ioc->name, reason_str, le16_to_cpu(event_data->DevHandle),
  4689. (unsigned long long)le64_to_cpu(event_data->SASAddress),
  4690. le16_to_cpu(event_data->TaskTag));
  4691. if (event_data->ReasonCode == MPI2_EVENT_SAS_DEV_STAT_RC_SMART_DATA)
  4692. pr_info(MPT3SAS_FMT ", ASC(0x%x), ASCQ(0x%x)\n", ioc->name,
  4693. event_data->ASC, event_data->ASCQ);
  4694. pr_info("\n");
  4695. }
  4696. #endif
  4697. /**
  4698. * _scsih_sas_device_status_change_event - handle device status change
  4699. * @ioc: per adapter object
  4700. * @fw_event: The fw_event_work object
  4701. * Context: user.
  4702. *
  4703. * Return nothing.
  4704. */
  4705. static void
  4706. _scsih_sas_device_status_change_event(struct MPT3SAS_ADAPTER *ioc,
  4707. struct fw_event_work *fw_event)
  4708. {
  4709. struct MPT3SAS_TARGET *target_priv_data;
  4710. struct _sas_device *sas_device;
  4711. u64 sas_address;
  4712. unsigned long flags;
  4713. Mpi2EventDataSasDeviceStatusChange_t *event_data =
  4714. fw_event->event_data;
  4715. #ifdef CONFIG_SCSI_MPT3SAS_LOGGING
  4716. if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK)
  4717. _scsih_sas_device_status_change_event_debug(ioc,
  4718. event_data);
  4719. #endif
  4720. /* In MPI Revision K (0xC), the internal device reset complete was
  4721. * implemented, so avoid setting tm_busy flag for older firmware.
  4722. */
  4723. if ((ioc->facts.HeaderVersion >> 8) < 0xC)
  4724. return;
  4725. if (event_data->ReasonCode !=
  4726. MPI2_EVENT_SAS_DEV_STAT_RC_INTERNAL_DEVICE_RESET &&
  4727. event_data->ReasonCode !=
  4728. MPI2_EVENT_SAS_DEV_STAT_RC_CMP_INTERNAL_DEV_RESET)
  4729. return;
  4730. spin_lock_irqsave(&ioc->sas_device_lock, flags);
  4731. sas_address = le64_to_cpu(event_data->SASAddress);
  4732. sas_device = mpt3sas_scsih_sas_device_find_by_sas_address(ioc,
  4733. sas_address);
  4734. if (!sas_device || !sas_device->starget) {
  4735. spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
  4736. return;
  4737. }
  4738. target_priv_data = sas_device->starget->hostdata;
  4739. if (!target_priv_data) {
  4740. spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
  4741. return;
  4742. }
  4743. if (event_data->ReasonCode ==
  4744. MPI2_EVENT_SAS_DEV_STAT_RC_INTERNAL_DEVICE_RESET)
  4745. target_priv_data->tm_busy = 1;
  4746. else
  4747. target_priv_data->tm_busy = 0;
  4748. spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
  4749. }
  4750. #ifdef CONFIG_SCSI_MPT3SAS_LOGGING
  4751. /**
  4752. * _scsih_sas_enclosure_dev_status_change_event_debug - debug for enclosure
  4753. * event
  4754. * @ioc: per adapter object
  4755. * @event_data: event data payload
  4756. * Context: user.
  4757. *
  4758. * Return nothing.
  4759. */
  4760. static void
  4761. _scsih_sas_enclosure_dev_status_change_event_debug(struct MPT3SAS_ADAPTER *ioc,
  4762. Mpi2EventDataSasEnclDevStatusChange_t *event_data)
  4763. {
  4764. char *reason_str = NULL;
  4765. switch (event_data->ReasonCode) {
  4766. case MPI2_EVENT_SAS_ENCL_RC_ADDED:
  4767. reason_str = "enclosure add";
  4768. break;
  4769. case MPI2_EVENT_SAS_ENCL_RC_NOT_RESPONDING:
  4770. reason_str = "enclosure remove";
  4771. break;
  4772. default:
  4773. reason_str = "unknown reason";
  4774. break;
  4775. }
  4776. pr_info(MPT3SAS_FMT "enclosure status change: (%s)\n"
  4777. "\thandle(0x%04x), enclosure logical id(0x%016llx)"
  4778. " number slots(%d)\n", ioc->name, reason_str,
  4779. le16_to_cpu(event_data->EnclosureHandle),
  4780. (unsigned long long)le64_to_cpu(event_data->EnclosureLogicalID),
  4781. le16_to_cpu(event_data->StartSlot));
  4782. }
  4783. #endif
  4784. /**
  4785. * _scsih_sas_enclosure_dev_status_change_event - handle enclosure events
  4786. * @ioc: per adapter object
  4787. * @fw_event: The fw_event_work object
  4788. * Context: user.
  4789. *
  4790. * Return nothing.
  4791. */
  4792. static void
  4793. _scsih_sas_enclosure_dev_status_change_event(struct MPT3SAS_ADAPTER *ioc,
  4794. struct fw_event_work *fw_event)
  4795. {
  4796. #ifdef CONFIG_SCSI_MPT3SAS_LOGGING
  4797. if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK)
  4798. _scsih_sas_enclosure_dev_status_change_event_debug(ioc,
  4799. fw_event->event_data);
  4800. #endif
  4801. }
  4802. /**
  4803. * _scsih_sas_broadcast_primitive_event - handle broadcast events
  4804. * @ioc: per adapter object
  4805. * @fw_event: The fw_event_work object
  4806. * Context: user.
  4807. *
  4808. * Return nothing.
  4809. */
  4810. static void
  4811. _scsih_sas_broadcast_primitive_event(struct MPT3SAS_ADAPTER *ioc,
  4812. struct fw_event_work *fw_event)
  4813. {
  4814. struct scsi_cmnd *scmd;
  4815. struct scsi_device *sdev;
  4816. u16 smid, handle;
  4817. u32 lun;
  4818. struct MPT3SAS_DEVICE *sas_device_priv_data;
  4819. u32 termination_count;
  4820. u32 query_count;
  4821. Mpi2SCSITaskManagementReply_t *mpi_reply;
  4822. Mpi2EventDataSasBroadcastPrimitive_t *event_data = fw_event->event_data;
  4823. u16 ioc_status;
  4824. unsigned long flags;
  4825. int r;
  4826. u8 max_retries = 0;
  4827. u8 task_abort_retries;
  4828. mutex_lock(&ioc->tm_cmds.mutex);
  4829. pr_info(MPT3SAS_FMT
  4830. "%s: enter: phy number(%d), width(%d)\n",
  4831. ioc->name, __func__, event_data->PhyNum,
  4832. event_data->PortWidth);
  4833. _scsih_block_io_all_device(ioc);
  4834. spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
  4835. mpi_reply = ioc->tm_cmds.reply;
  4836. broadcast_aen_retry:
  4837. /* sanity checks for retrying this loop */
  4838. if (max_retries++ == 5) {
  4839. dewtprintk(ioc, pr_info(MPT3SAS_FMT "%s: giving up\n",
  4840. ioc->name, __func__));
  4841. goto out;
  4842. } else if (max_retries > 1)
  4843. dewtprintk(ioc, pr_info(MPT3SAS_FMT "%s: %d retry\n",
  4844. ioc->name, __func__, max_retries - 1));
  4845. termination_count = 0;
  4846. query_count = 0;
  4847. for (smid = 1; smid <= ioc->scsiio_depth; smid++) {
  4848. if (ioc->shost_recovery)
  4849. goto out;
  4850. scmd = _scsih_scsi_lookup_get(ioc, smid);
  4851. if (!scmd)
  4852. continue;
  4853. sdev = scmd->device;
  4854. sas_device_priv_data = sdev->hostdata;
  4855. if (!sas_device_priv_data || !sas_device_priv_data->sas_target)
  4856. continue;
  4857. /* skip hidden raid components */
  4858. if (sas_device_priv_data->sas_target->flags &
  4859. MPT_TARGET_FLAGS_RAID_COMPONENT)
  4860. continue;
  4861. /* skip volumes */
  4862. if (sas_device_priv_data->sas_target->flags &
  4863. MPT_TARGET_FLAGS_VOLUME)
  4864. continue;
  4865. handle = sas_device_priv_data->sas_target->handle;
  4866. lun = sas_device_priv_data->lun;
  4867. query_count++;
  4868. if (ioc->shost_recovery)
  4869. goto out;
  4870. spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
  4871. r = mpt3sas_scsih_issue_tm(ioc, handle, 0, 0, lun,
  4872. MPI2_SCSITASKMGMT_TASKTYPE_QUERY_TASK, smid, 30, 0,
  4873. TM_MUTEX_OFF);
  4874. if (r == FAILED) {
  4875. sdev_printk(KERN_WARNING, sdev,
  4876. "mpt3sas_scsih_issue_tm: FAILED when sending "
  4877. "QUERY_TASK: scmd(%p)\n", scmd);
  4878. spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
  4879. goto broadcast_aen_retry;
  4880. }
  4881. ioc_status = le16_to_cpu(mpi_reply->IOCStatus)
  4882. & MPI2_IOCSTATUS_MASK;
  4883. if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
  4884. sdev_printk(KERN_WARNING, sdev,
  4885. "query task: FAILED with IOCSTATUS(0x%04x), scmd(%p)\n",
  4886. ioc_status, scmd);
  4887. spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
  4888. goto broadcast_aen_retry;
  4889. }
  4890. /* see if IO is still owned by IOC and target */
  4891. if (mpi_reply->ResponseCode ==
  4892. MPI2_SCSITASKMGMT_RSP_TM_SUCCEEDED ||
  4893. mpi_reply->ResponseCode ==
  4894. MPI2_SCSITASKMGMT_RSP_IO_QUEUED_ON_IOC) {
  4895. spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
  4896. continue;
  4897. }
  4898. task_abort_retries = 0;
  4899. tm_retry:
  4900. if (task_abort_retries++ == 60) {
  4901. dewtprintk(ioc, pr_info(MPT3SAS_FMT
  4902. "%s: ABORT_TASK: giving up\n", ioc->name,
  4903. __func__));
  4904. spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
  4905. goto broadcast_aen_retry;
  4906. }
  4907. if (ioc->shost_recovery)
  4908. goto out_no_lock;
  4909. r = mpt3sas_scsih_issue_tm(ioc, handle, sdev->channel, sdev->id,
  4910. sdev->lun, MPI2_SCSITASKMGMT_TASKTYPE_ABORT_TASK, smid, 30,
  4911. scmd->serial_number, TM_MUTEX_OFF);
  4912. if (r == FAILED) {
  4913. sdev_printk(KERN_WARNING, sdev,
  4914. "mpt3sas_scsih_issue_tm: ABORT_TASK: FAILED : "
  4915. "scmd(%p)\n", scmd);
  4916. goto tm_retry;
  4917. }
  4918. if (task_abort_retries > 1)
  4919. sdev_printk(KERN_WARNING, sdev,
  4920. "mpt3sas_scsih_issue_tm: ABORT_TASK: RETRIES (%d):"
  4921. " scmd(%p)\n",
  4922. task_abort_retries - 1, scmd);
  4923. termination_count += le32_to_cpu(mpi_reply->TerminationCount);
  4924. spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
  4925. }
  4926. if (ioc->broadcast_aen_pending) {
  4927. dewtprintk(ioc, pr_info(MPT3SAS_FMT
  4928. "%s: loop back due to pending AEN\n",
  4929. ioc->name, __func__));
  4930. ioc->broadcast_aen_pending = 0;
  4931. goto broadcast_aen_retry;
  4932. }
  4933. out:
  4934. spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
  4935. out_no_lock:
  4936. dewtprintk(ioc, pr_info(MPT3SAS_FMT
  4937. "%s - exit, query_count = %d termination_count = %d\n",
  4938. ioc->name, __func__, query_count, termination_count));
  4939. ioc->broadcast_aen_busy = 0;
  4940. if (!ioc->shost_recovery)
  4941. _scsih_ublock_io_all_device(ioc);
  4942. mutex_unlock(&ioc->tm_cmds.mutex);
  4943. }
  4944. /**
  4945. * _scsih_sas_discovery_event - handle discovery events
  4946. * @ioc: per adapter object
  4947. * @fw_event: The fw_event_work object
  4948. * Context: user.
  4949. *
  4950. * Return nothing.
  4951. */
  4952. static void
  4953. _scsih_sas_discovery_event(struct MPT3SAS_ADAPTER *ioc,
  4954. struct fw_event_work *fw_event)
  4955. {
  4956. Mpi2EventDataSasDiscovery_t *event_data = fw_event->event_data;
  4957. #ifdef CONFIG_SCSI_MPT3SAS_LOGGING
  4958. if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK) {
  4959. pr_info(MPT3SAS_FMT "discovery event: (%s)", ioc->name,
  4960. (event_data->ReasonCode == MPI2_EVENT_SAS_DISC_RC_STARTED) ?
  4961. "start" : "stop");
  4962. if (event_data->DiscoveryStatus)
  4963. pr_info("discovery_status(0x%08x)",
  4964. le32_to_cpu(event_data->DiscoveryStatus));
  4965. pr_info("\n");
  4966. }
  4967. #endif
  4968. if (event_data->ReasonCode == MPI2_EVENT_SAS_DISC_RC_STARTED &&
  4969. !ioc->sas_hba.num_phys) {
  4970. if (disable_discovery > 0 && ioc->shost_recovery) {
  4971. /* Wait for the reset to complete */
  4972. while (ioc->shost_recovery)
  4973. ssleep(1);
  4974. }
  4975. _scsih_sas_host_add(ioc);
  4976. }
  4977. }
  4978. /**
  4979. * _scsih_ir_fastpath - turn on fastpath for IR physdisk
  4980. * @ioc: per adapter object
  4981. * @handle: device handle for physical disk
  4982. * @phys_disk_num: physical disk number
  4983. *
  4984. * Return 0 for success, else failure.
  4985. */
  4986. static int
  4987. _scsih_ir_fastpath(struct MPT3SAS_ADAPTER *ioc, u16 handle, u8 phys_disk_num)
  4988. {
  4989. Mpi2RaidActionRequest_t *mpi_request;
  4990. Mpi2RaidActionReply_t *mpi_reply;
  4991. u16 smid;
  4992. u8 issue_reset = 0;
  4993. int rc = 0;
  4994. u16 ioc_status;
  4995. u32 log_info;
  4996. mutex_lock(&ioc->scsih_cmds.mutex);
  4997. if (ioc->scsih_cmds.status != MPT3_CMD_NOT_USED) {
  4998. pr_err(MPT3SAS_FMT "%s: scsih_cmd in use\n",
  4999. ioc->name, __func__);
  5000. rc = -EAGAIN;
  5001. goto out;
  5002. }
  5003. ioc->scsih_cmds.status = MPT3_CMD_PENDING;
  5004. smid = mpt3sas_base_get_smid(ioc, ioc->scsih_cb_idx);
  5005. if (!smid) {
  5006. pr_err(MPT3SAS_FMT "%s: failed obtaining a smid\n",
  5007. ioc->name, __func__);
  5008. ioc->scsih_cmds.status = MPT3_CMD_NOT_USED;
  5009. rc = -EAGAIN;
  5010. goto out;
  5011. }
  5012. mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
  5013. ioc->scsih_cmds.smid = smid;
  5014. memset(mpi_request, 0, sizeof(Mpi2RaidActionRequest_t));
  5015. mpi_request->Function = MPI2_FUNCTION_RAID_ACTION;
  5016. mpi_request->Action = MPI2_RAID_ACTION_PHYSDISK_HIDDEN;
  5017. mpi_request->PhysDiskNum = phys_disk_num;
  5018. dewtprintk(ioc, pr_info(MPT3SAS_FMT "IR RAID_ACTION: turning fast "\
  5019. "path on for handle(0x%04x), phys_disk_num (0x%02x)\n", ioc->name,
  5020. handle, phys_disk_num));
  5021. init_completion(&ioc->scsih_cmds.done);
  5022. mpt3sas_base_put_smid_default(ioc, smid);
  5023. wait_for_completion_timeout(&ioc->scsih_cmds.done, 10*HZ);
  5024. if (!(ioc->scsih_cmds.status & MPT3_CMD_COMPLETE)) {
  5025. pr_err(MPT3SAS_FMT "%s: timeout\n",
  5026. ioc->name, __func__);
  5027. if (!(ioc->scsih_cmds.status & MPT3_CMD_RESET))
  5028. issue_reset = 1;
  5029. rc = -EFAULT;
  5030. goto out;
  5031. }
  5032. if (ioc->scsih_cmds.status & MPT3_CMD_REPLY_VALID) {
  5033. mpi_reply = ioc->scsih_cmds.reply;
  5034. ioc_status = le16_to_cpu(mpi_reply->IOCStatus);
  5035. if (ioc_status & MPI2_IOCSTATUS_FLAG_LOG_INFO_AVAILABLE)
  5036. log_info = le32_to_cpu(mpi_reply->IOCLogInfo);
  5037. else
  5038. log_info = 0;
  5039. ioc_status &= MPI2_IOCSTATUS_MASK;
  5040. if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
  5041. dewtprintk(ioc, pr_info(MPT3SAS_FMT
  5042. "IR RAID_ACTION: failed: ioc_status(0x%04x), "
  5043. "loginfo(0x%08x)!!!\n", ioc->name, ioc_status,
  5044. log_info));
  5045. rc = -EFAULT;
  5046. } else
  5047. dewtprintk(ioc, pr_info(MPT3SAS_FMT
  5048. "IR RAID_ACTION: completed successfully\n",
  5049. ioc->name));
  5050. }
  5051. out:
  5052. ioc->scsih_cmds.status = MPT3_CMD_NOT_USED;
  5053. mutex_unlock(&ioc->scsih_cmds.mutex);
  5054. if (issue_reset)
  5055. mpt3sas_base_hard_reset_handler(ioc, CAN_SLEEP,
  5056. FORCE_BIG_HAMMER);
  5057. return rc;
  5058. }
  5059. /**
  5060. * _scsih_reprobe_lun - reprobing lun
  5061. * @sdev: scsi device struct
  5062. * @no_uld_attach: sdev->no_uld_attach flag setting
  5063. *
  5064. **/
  5065. static void
  5066. _scsih_reprobe_lun(struct scsi_device *sdev, void *no_uld_attach)
  5067. {
  5068. int rc;
  5069. sdev->no_uld_attach = no_uld_attach ? 1 : 0;
  5070. sdev_printk(KERN_INFO, sdev, "%s raid component\n",
  5071. sdev->no_uld_attach ? "hidding" : "exposing");
  5072. rc = scsi_device_reprobe(sdev);
  5073. }
  5074. /**
  5075. * _scsih_sas_volume_add - add new volume
  5076. * @ioc: per adapter object
  5077. * @element: IR config element data
  5078. * Context: user.
  5079. *
  5080. * Return nothing.
  5081. */
  5082. static void
  5083. _scsih_sas_volume_add(struct MPT3SAS_ADAPTER *ioc,
  5084. Mpi2EventIrConfigElement_t *element)
  5085. {
  5086. struct _raid_device *raid_device;
  5087. unsigned long flags;
  5088. u64 wwid;
  5089. u16 handle = le16_to_cpu(element->VolDevHandle);
  5090. int rc;
  5091. mpt3sas_config_get_volume_wwid(ioc, handle, &wwid);
  5092. if (!wwid) {
  5093. pr_err(MPT3SAS_FMT
  5094. "failure at %s:%d/%s()!\n", ioc->name,
  5095. __FILE__, __LINE__, __func__);
  5096. return;
  5097. }
  5098. spin_lock_irqsave(&ioc->raid_device_lock, flags);
  5099. raid_device = _scsih_raid_device_find_by_wwid(ioc, wwid);
  5100. spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
  5101. if (raid_device)
  5102. return;
  5103. raid_device = kzalloc(sizeof(struct _raid_device), GFP_KERNEL);
  5104. if (!raid_device) {
  5105. pr_err(MPT3SAS_FMT
  5106. "failure at %s:%d/%s()!\n", ioc->name,
  5107. __FILE__, __LINE__, __func__);
  5108. return;
  5109. }
  5110. raid_device->id = ioc->sas_id++;
  5111. raid_device->channel = RAID_CHANNEL;
  5112. raid_device->handle = handle;
  5113. raid_device->wwid = wwid;
  5114. _scsih_raid_device_add(ioc, raid_device);
  5115. if (!ioc->wait_for_discovery_to_complete) {
  5116. rc = scsi_add_device(ioc->shost, RAID_CHANNEL,
  5117. raid_device->id, 0);
  5118. if (rc)
  5119. _scsih_raid_device_remove(ioc, raid_device);
  5120. } else {
  5121. spin_lock_irqsave(&ioc->raid_device_lock, flags);
  5122. _scsih_determine_boot_device(ioc, raid_device, 1);
  5123. spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
  5124. }
  5125. }
  5126. /**
  5127. * _scsih_sas_volume_delete - delete volume
  5128. * @ioc: per adapter object
  5129. * @handle: volume device handle
  5130. * Context: user.
  5131. *
  5132. * Return nothing.
  5133. */
  5134. static void
  5135. _scsih_sas_volume_delete(struct MPT3SAS_ADAPTER *ioc, u16 handle)
  5136. {
  5137. struct _raid_device *raid_device;
  5138. unsigned long flags;
  5139. struct MPT3SAS_TARGET *sas_target_priv_data;
  5140. struct scsi_target *starget = NULL;
  5141. spin_lock_irqsave(&ioc->raid_device_lock, flags);
  5142. raid_device = _scsih_raid_device_find_by_handle(ioc, handle);
  5143. if (raid_device) {
  5144. if (raid_device->starget) {
  5145. starget = raid_device->starget;
  5146. sas_target_priv_data = starget->hostdata;
  5147. sas_target_priv_data->deleted = 1;
  5148. }
  5149. pr_info(MPT3SAS_FMT "removing handle(0x%04x), wwid(0x%016llx)\n",
  5150. ioc->name, raid_device->handle,
  5151. (unsigned long long) raid_device->wwid);
  5152. list_del(&raid_device->list);
  5153. kfree(raid_device);
  5154. }
  5155. spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
  5156. if (starget)
  5157. scsi_remove_target(&starget->dev);
  5158. }
  5159. /**
  5160. * _scsih_sas_pd_expose - expose pd component to /dev/sdX
  5161. * @ioc: per adapter object
  5162. * @element: IR config element data
  5163. * Context: user.
  5164. *
  5165. * Return nothing.
  5166. */
  5167. static void
  5168. _scsih_sas_pd_expose(struct MPT3SAS_ADAPTER *ioc,
  5169. Mpi2EventIrConfigElement_t *element)
  5170. {
  5171. struct _sas_device *sas_device;
  5172. struct scsi_target *starget = NULL;
  5173. struct MPT3SAS_TARGET *sas_target_priv_data;
  5174. unsigned long flags;
  5175. u16 handle = le16_to_cpu(element->PhysDiskDevHandle);
  5176. spin_lock_irqsave(&ioc->sas_device_lock, flags);
  5177. sas_device = _scsih_sas_device_find_by_handle(ioc, handle);
  5178. if (sas_device) {
  5179. sas_device->volume_handle = 0;
  5180. sas_device->volume_wwid = 0;
  5181. clear_bit(handle, ioc->pd_handles);
  5182. if (sas_device->starget && sas_device->starget->hostdata) {
  5183. starget = sas_device->starget;
  5184. sas_target_priv_data = starget->hostdata;
  5185. sas_target_priv_data->flags &=
  5186. ~MPT_TARGET_FLAGS_RAID_COMPONENT;
  5187. }
  5188. }
  5189. spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
  5190. if (!sas_device)
  5191. return;
  5192. /* exposing raid component */
  5193. if (starget)
  5194. starget_for_each_device(starget, NULL, _scsih_reprobe_lun);
  5195. }
  5196. /**
  5197. * _scsih_sas_pd_hide - hide pd component from /dev/sdX
  5198. * @ioc: per adapter object
  5199. * @element: IR config element data
  5200. * Context: user.
  5201. *
  5202. * Return nothing.
  5203. */
  5204. static void
  5205. _scsih_sas_pd_hide(struct MPT3SAS_ADAPTER *ioc,
  5206. Mpi2EventIrConfigElement_t *element)
  5207. {
  5208. struct _sas_device *sas_device;
  5209. struct scsi_target *starget = NULL;
  5210. struct MPT3SAS_TARGET *sas_target_priv_data;
  5211. unsigned long flags;
  5212. u16 handle = le16_to_cpu(element->PhysDiskDevHandle);
  5213. u16 volume_handle = 0;
  5214. u64 volume_wwid = 0;
  5215. mpt3sas_config_get_volume_handle(ioc, handle, &volume_handle);
  5216. if (volume_handle)
  5217. mpt3sas_config_get_volume_wwid(ioc, volume_handle,
  5218. &volume_wwid);
  5219. spin_lock_irqsave(&ioc->sas_device_lock, flags);
  5220. sas_device = _scsih_sas_device_find_by_handle(ioc, handle);
  5221. if (sas_device) {
  5222. set_bit(handle, ioc->pd_handles);
  5223. if (sas_device->starget && sas_device->starget->hostdata) {
  5224. starget = sas_device->starget;
  5225. sas_target_priv_data = starget->hostdata;
  5226. sas_target_priv_data->flags |=
  5227. MPT_TARGET_FLAGS_RAID_COMPONENT;
  5228. sas_device->volume_handle = volume_handle;
  5229. sas_device->volume_wwid = volume_wwid;
  5230. }
  5231. }
  5232. spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
  5233. if (!sas_device)
  5234. return;
  5235. /* hiding raid component */
  5236. _scsih_ir_fastpath(ioc, handle, element->PhysDiskNum);
  5237. if (starget)
  5238. starget_for_each_device(starget, (void *)1, _scsih_reprobe_lun);
  5239. }
  5240. /**
  5241. * _scsih_sas_pd_delete - delete pd component
  5242. * @ioc: per adapter object
  5243. * @element: IR config element data
  5244. * Context: user.
  5245. *
  5246. * Return nothing.
  5247. */
  5248. static void
  5249. _scsih_sas_pd_delete(struct MPT3SAS_ADAPTER *ioc,
  5250. Mpi2EventIrConfigElement_t *element)
  5251. {
  5252. u16 handle = le16_to_cpu(element->PhysDiskDevHandle);
  5253. _scsih_device_remove_by_handle(ioc, handle);
  5254. }
  5255. /**
  5256. * _scsih_sas_pd_add - remove pd component
  5257. * @ioc: per adapter object
  5258. * @element: IR config element data
  5259. * Context: user.
  5260. *
  5261. * Return nothing.
  5262. */
  5263. static void
  5264. _scsih_sas_pd_add(struct MPT3SAS_ADAPTER *ioc,
  5265. Mpi2EventIrConfigElement_t *element)
  5266. {
  5267. struct _sas_device *sas_device;
  5268. unsigned long flags;
  5269. u16 handle = le16_to_cpu(element->PhysDiskDevHandle);
  5270. Mpi2ConfigReply_t mpi_reply;
  5271. Mpi2SasDevicePage0_t sas_device_pg0;
  5272. u32 ioc_status;
  5273. u64 sas_address;
  5274. u16 parent_handle;
  5275. set_bit(handle, ioc->pd_handles);
  5276. spin_lock_irqsave(&ioc->sas_device_lock, flags);
  5277. sas_device = _scsih_sas_device_find_by_handle(ioc, handle);
  5278. spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
  5279. if (sas_device) {
  5280. _scsih_ir_fastpath(ioc, handle, element->PhysDiskNum);
  5281. return;
  5282. }
  5283. if ((mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0,
  5284. MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, handle))) {
  5285. pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
  5286. ioc->name, __FILE__, __LINE__, __func__);
  5287. return;
  5288. }
  5289. ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
  5290. MPI2_IOCSTATUS_MASK;
  5291. if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
  5292. pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
  5293. ioc->name, __FILE__, __LINE__, __func__);
  5294. return;
  5295. }
  5296. parent_handle = le16_to_cpu(sas_device_pg0.ParentDevHandle);
  5297. if (!_scsih_get_sas_address(ioc, parent_handle, &sas_address))
  5298. mpt3sas_transport_update_links(ioc, sas_address, handle,
  5299. sas_device_pg0.PhyNum, MPI2_SAS_NEG_LINK_RATE_1_5);
  5300. _scsih_ir_fastpath(ioc, handle, element->PhysDiskNum);
  5301. _scsih_add_device(ioc, handle, 0, 1);
  5302. }
  5303. #ifdef CONFIG_SCSI_MPT3SAS_LOGGING
  5304. /**
  5305. * _scsih_sas_ir_config_change_event_debug - debug for IR Config Change events
  5306. * @ioc: per adapter object
  5307. * @event_data: event data payload
  5308. * Context: user.
  5309. *
  5310. * Return nothing.
  5311. */
  5312. static void
  5313. _scsih_sas_ir_config_change_event_debug(struct MPT3SAS_ADAPTER *ioc,
  5314. Mpi2EventDataIrConfigChangeList_t *event_data)
  5315. {
  5316. Mpi2EventIrConfigElement_t *element;
  5317. u8 element_type;
  5318. int i;
  5319. char *reason_str = NULL, *element_str = NULL;
  5320. element = (Mpi2EventIrConfigElement_t *)&event_data->ConfigElement[0];
  5321. pr_info(MPT3SAS_FMT "raid config change: (%s), elements(%d)\n",
  5322. ioc->name, (le32_to_cpu(event_data->Flags) &
  5323. MPI2_EVENT_IR_CHANGE_FLAGS_FOREIGN_CONFIG) ?
  5324. "foreign" : "native", event_data->NumElements);
  5325. for (i = 0; i < event_data->NumElements; i++, element++) {
  5326. switch (element->ReasonCode) {
  5327. case MPI2_EVENT_IR_CHANGE_RC_ADDED:
  5328. reason_str = "add";
  5329. break;
  5330. case MPI2_EVENT_IR_CHANGE_RC_REMOVED:
  5331. reason_str = "remove";
  5332. break;
  5333. case MPI2_EVENT_IR_CHANGE_RC_NO_CHANGE:
  5334. reason_str = "no change";
  5335. break;
  5336. case MPI2_EVENT_IR_CHANGE_RC_HIDE:
  5337. reason_str = "hide";
  5338. break;
  5339. case MPI2_EVENT_IR_CHANGE_RC_UNHIDE:
  5340. reason_str = "unhide";
  5341. break;
  5342. case MPI2_EVENT_IR_CHANGE_RC_VOLUME_CREATED:
  5343. reason_str = "volume_created";
  5344. break;
  5345. case MPI2_EVENT_IR_CHANGE_RC_VOLUME_DELETED:
  5346. reason_str = "volume_deleted";
  5347. break;
  5348. case MPI2_EVENT_IR_CHANGE_RC_PD_CREATED:
  5349. reason_str = "pd_created";
  5350. break;
  5351. case MPI2_EVENT_IR_CHANGE_RC_PD_DELETED:
  5352. reason_str = "pd_deleted";
  5353. break;
  5354. default:
  5355. reason_str = "unknown reason";
  5356. break;
  5357. }
  5358. element_type = le16_to_cpu(element->ElementFlags) &
  5359. MPI2_EVENT_IR_CHANGE_EFLAGS_ELEMENT_TYPE_MASK;
  5360. switch (element_type) {
  5361. case MPI2_EVENT_IR_CHANGE_EFLAGS_VOLUME_ELEMENT:
  5362. element_str = "volume";
  5363. break;
  5364. case MPI2_EVENT_IR_CHANGE_EFLAGS_VOLPHYSDISK_ELEMENT:
  5365. element_str = "phys disk";
  5366. break;
  5367. case MPI2_EVENT_IR_CHANGE_EFLAGS_HOTSPARE_ELEMENT:
  5368. element_str = "hot spare";
  5369. break;
  5370. default:
  5371. element_str = "unknown element";
  5372. break;
  5373. }
  5374. pr_info("\t(%s:%s), vol handle(0x%04x), " \
  5375. "pd handle(0x%04x), pd num(0x%02x)\n", element_str,
  5376. reason_str, le16_to_cpu(element->VolDevHandle),
  5377. le16_to_cpu(element->PhysDiskDevHandle),
  5378. element->PhysDiskNum);
  5379. }
  5380. }
  5381. #endif
  5382. /**
  5383. * _scsih_sas_ir_config_change_event - handle ir configuration change events
  5384. * @ioc: per adapter object
  5385. * @fw_event: The fw_event_work object
  5386. * Context: user.
  5387. *
  5388. * Return nothing.
  5389. */
  5390. static void
  5391. _scsih_sas_ir_config_change_event(struct MPT3SAS_ADAPTER *ioc,
  5392. struct fw_event_work *fw_event)
  5393. {
  5394. Mpi2EventIrConfigElement_t *element;
  5395. int i;
  5396. u8 foreign_config;
  5397. Mpi2EventDataIrConfigChangeList_t *event_data = fw_event->event_data;
  5398. #ifdef CONFIG_SCSI_MPT3SAS_LOGGING
  5399. if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK)
  5400. _scsih_sas_ir_config_change_event_debug(ioc, event_data);
  5401. #endif
  5402. foreign_config = (le32_to_cpu(event_data->Flags) &
  5403. MPI2_EVENT_IR_CHANGE_FLAGS_FOREIGN_CONFIG) ? 1 : 0;
  5404. element = (Mpi2EventIrConfigElement_t *)&event_data->ConfigElement[0];
  5405. if (ioc->shost_recovery) {
  5406. for (i = 0; i < event_data->NumElements; i++, element++) {
  5407. if (element->ReasonCode == MPI2_EVENT_IR_CHANGE_RC_HIDE)
  5408. _scsih_ir_fastpath(ioc,
  5409. le16_to_cpu(element->PhysDiskDevHandle),
  5410. element->PhysDiskNum);
  5411. }
  5412. return;
  5413. }
  5414. for (i = 0; i < event_data->NumElements; i++, element++) {
  5415. switch (element->ReasonCode) {
  5416. case MPI2_EVENT_IR_CHANGE_RC_VOLUME_CREATED:
  5417. case MPI2_EVENT_IR_CHANGE_RC_ADDED:
  5418. if (!foreign_config)
  5419. _scsih_sas_volume_add(ioc, element);
  5420. break;
  5421. case MPI2_EVENT_IR_CHANGE_RC_VOLUME_DELETED:
  5422. case MPI2_EVENT_IR_CHANGE_RC_REMOVED:
  5423. if (!foreign_config)
  5424. _scsih_sas_volume_delete(ioc,
  5425. le16_to_cpu(element->VolDevHandle));
  5426. break;
  5427. case MPI2_EVENT_IR_CHANGE_RC_PD_CREATED:
  5428. _scsih_sas_pd_hide(ioc, element);
  5429. break;
  5430. case MPI2_EVENT_IR_CHANGE_RC_PD_DELETED:
  5431. _scsih_sas_pd_expose(ioc, element);
  5432. break;
  5433. case MPI2_EVENT_IR_CHANGE_RC_HIDE:
  5434. _scsih_sas_pd_add(ioc, element);
  5435. break;
  5436. case MPI2_EVENT_IR_CHANGE_RC_UNHIDE:
  5437. _scsih_sas_pd_delete(ioc, element);
  5438. break;
  5439. }
  5440. }
  5441. }
  5442. /**
  5443. * _scsih_sas_ir_volume_event - IR volume event
  5444. * @ioc: per adapter object
  5445. * @fw_event: The fw_event_work object
  5446. * Context: user.
  5447. *
  5448. * Return nothing.
  5449. */
  5450. static void
  5451. _scsih_sas_ir_volume_event(struct MPT3SAS_ADAPTER *ioc,
  5452. struct fw_event_work *fw_event)
  5453. {
  5454. u64 wwid;
  5455. unsigned long flags;
  5456. struct _raid_device *raid_device;
  5457. u16 handle;
  5458. u32 state;
  5459. int rc;
  5460. Mpi2EventDataIrVolume_t *event_data = fw_event->event_data;
  5461. if (ioc->shost_recovery)
  5462. return;
  5463. if (event_data->ReasonCode != MPI2_EVENT_IR_VOLUME_RC_STATE_CHANGED)
  5464. return;
  5465. handle = le16_to_cpu(event_data->VolDevHandle);
  5466. state = le32_to_cpu(event_data->NewValue);
  5467. dewtprintk(ioc, pr_info(MPT3SAS_FMT
  5468. "%s: handle(0x%04x), old(0x%08x), new(0x%08x)\n",
  5469. ioc->name, __func__, handle,
  5470. le32_to_cpu(event_data->PreviousValue), state));
  5471. switch (state) {
  5472. case MPI2_RAID_VOL_STATE_MISSING:
  5473. case MPI2_RAID_VOL_STATE_FAILED:
  5474. _scsih_sas_volume_delete(ioc, handle);
  5475. break;
  5476. case MPI2_RAID_VOL_STATE_ONLINE:
  5477. case MPI2_RAID_VOL_STATE_DEGRADED:
  5478. case MPI2_RAID_VOL_STATE_OPTIMAL:
  5479. spin_lock_irqsave(&ioc->raid_device_lock, flags);
  5480. raid_device = _scsih_raid_device_find_by_handle(ioc, handle);
  5481. spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
  5482. if (raid_device)
  5483. break;
  5484. mpt3sas_config_get_volume_wwid(ioc, handle, &wwid);
  5485. if (!wwid) {
  5486. pr_err(MPT3SAS_FMT
  5487. "failure at %s:%d/%s()!\n", ioc->name,
  5488. __FILE__, __LINE__, __func__);
  5489. break;
  5490. }
  5491. raid_device = kzalloc(sizeof(struct _raid_device), GFP_KERNEL);
  5492. if (!raid_device) {
  5493. pr_err(MPT3SAS_FMT
  5494. "failure at %s:%d/%s()!\n", ioc->name,
  5495. __FILE__, __LINE__, __func__);
  5496. break;
  5497. }
  5498. raid_device->id = ioc->sas_id++;
  5499. raid_device->channel = RAID_CHANNEL;
  5500. raid_device->handle = handle;
  5501. raid_device->wwid = wwid;
  5502. _scsih_raid_device_add(ioc, raid_device);
  5503. rc = scsi_add_device(ioc->shost, RAID_CHANNEL,
  5504. raid_device->id, 0);
  5505. if (rc)
  5506. _scsih_raid_device_remove(ioc, raid_device);
  5507. break;
  5508. case MPI2_RAID_VOL_STATE_INITIALIZING:
  5509. default:
  5510. break;
  5511. }
  5512. }
  5513. /**
  5514. * _scsih_sas_ir_physical_disk_event - PD event
  5515. * @ioc: per adapter object
  5516. * @fw_event: The fw_event_work object
  5517. * Context: user.
  5518. *
  5519. * Return nothing.
  5520. */
  5521. static void
  5522. _scsih_sas_ir_physical_disk_event(struct MPT3SAS_ADAPTER *ioc,
  5523. struct fw_event_work *fw_event)
  5524. {
  5525. u16 handle, parent_handle;
  5526. u32 state;
  5527. struct _sas_device *sas_device;
  5528. unsigned long flags;
  5529. Mpi2ConfigReply_t mpi_reply;
  5530. Mpi2SasDevicePage0_t sas_device_pg0;
  5531. u32 ioc_status;
  5532. Mpi2EventDataIrPhysicalDisk_t *event_data = fw_event->event_data;
  5533. u64 sas_address;
  5534. if (ioc->shost_recovery)
  5535. return;
  5536. if (event_data->ReasonCode != MPI2_EVENT_IR_PHYSDISK_RC_STATE_CHANGED)
  5537. return;
  5538. handle = le16_to_cpu(event_data->PhysDiskDevHandle);
  5539. state = le32_to_cpu(event_data->NewValue);
  5540. dewtprintk(ioc, pr_info(MPT3SAS_FMT
  5541. "%s: handle(0x%04x), old(0x%08x), new(0x%08x)\n",
  5542. ioc->name, __func__, handle,
  5543. le32_to_cpu(event_data->PreviousValue), state));
  5544. switch (state) {
  5545. case MPI2_RAID_PD_STATE_ONLINE:
  5546. case MPI2_RAID_PD_STATE_DEGRADED:
  5547. case MPI2_RAID_PD_STATE_REBUILDING:
  5548. case MPI2_RAID_PD_STATE_OPTIMAL:
  5549. case MPI2_RAID_PD_STATE_HOT_SPARE:
  5550. set_bit(handle, ioc->pd_handles);
  5551. spin_lock_irqsave(&ioc->sas_device_lock, flags);
  5552. sas_device = _scsih_sas_device_find_by_handle(ioc, handle);
  5553. spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
  5554. if (sas_device)
  5555. return;
  5556. if ((mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply,
  5557. &sas_device_pg0, MPI2_SAS_DEVICE_PGAD_FORM_HANDLE,
  5558. handle))) {
  5559. pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
  5560. ioc->name, __FILE__, __LINE__, __func__);
  5561. return;
  5562. }
  5563. ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
  5564. MPI2_IOCSTATUS_MASK;
  5565. if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
  5566. pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
  5567. ioc->name, __FILE__, __LINE__, __func__);
  5568. return;
  5569. }
  5570. parent_handle = le16_to_cpu(sas_device_pg0.ParentDevHandle);
  5571. if (!_scsih_get_sas_address(ioc, parent_handle, &sas_address))
  5572. mpt3sas_transport_update_links(ioc, sas_address, handle,
  5573. sas_device_pg0.PhyNum, MPI2_SAS_NEG_LINK_RATE_1_5);
  5574. _scsih_add_device(ioc, handle, 0, 1);
  5575. break;
  5576. case MPI2_RAID_PD_STATE_OFFLINE:
  5577. case MPI2_RAID_PD_STATE_NOT_CONFIGURED:
  5578. case MPI2_RAID_PD_STATE_NOT_COMPATIBLE:
  5579. default:
  5580. break;
  5581. }
  5582. }
  5583. #ifdef CONFIG_SCSI_MPT3SAS_LOGGING
  5584. /**
  5585. * _scsih_sas_ir_operation_status_event_debug - debug for IR op event
  5586. * @ioc: per adapter object
  5587. * @event_data: event data payload
  5588. * Context: user.
  5589. *
  5590. * Return nothing.
  5591. */
  5592. static void
  5593. _scsih_sas_ir_operation_status_event_debug(struct MPT3SAS_ADAPTER *ioc,
  5594. Mpi2EventDataIrOperationStatus_t *event_data)
  5595. {
  5596. char *reason_str = NULL;
  5597. switch (event_data->RAIDOperation) {
  5598. case MPI2_EVENT_IR_RAIDOP_RESYNC:
  5599. reason_str = "resync";
  5600. break;
  5601. case MPI2_EVENT_IR_RAIDOP_ONLINE_CAP_EXPANSION:
  5602. reason_str = "online capacity expansion";
  5603. break;
  5604. case MPI2_EVENT_IR_RAIDOP_CONSISTENCY_CHECK:
  5605. reason_str = "consistency check";
  5606. break;
  5607. case MPI2_EVENT_IR_RAIDOP_BACKGROUND_INIT:
  5608. reason_str = "background init";
  5609. break;
  5610. case MPI2_EVENT_IR_RAIDOP_MAKE_DATA_CONSISTENT:
  5611. reason_str = "make data consistent";
  5612. break;
  5613. }
  5614. if (!reason_str)
  5615. return;
  5616. pr_info(MPT3SAS_FMT "raid operational status: (%s)" \
  5617. "\thandle(0x%04x), percent complete(%d)\n",
  5618. ioc->name, reason_str,
  5619. le16_to_cpu(event_data->VolDevHandle),
  5620. event_data->PercentComplete);
  5621. }
  5622. #endif
  5623. /**
  5624. * _scsih_sas_ir_operation_status_event - handle RAID operation events
  5625. * @ioc: per adapter object
  5626. * @fw_event: The fw_event_work object
  5627. * Context: user.
  5628. *
  5629. * Return nothing.
  5630. */
  5631. static void
  5632. _scsih_sas_ir_operation_status_event(struct MPT3SAS_ADAPTER *ioc,
  5633. struct fw_event_work *fw_event)
  5634. {
  5635. Mpi2EventDataIrOperationStatus_t *event_data = fw_event->event_data;
  5636. static struct _raid_device *raid_device;
  5637. unsigned long flags;
  5638. u16 handle;
  5639. #ifdef CONFIG_SCSI_MPT3SAS_LOGGING
  5640. if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK)
  5641. _scsih_sas_ir_operation_status_event_debug(ioc,
  5642. event_data);
  5643. #endif
  5644. /* code added for raid transport support */
  5645. if (event_data->RAIDOperation == MPI2_EVENT_IR_RAIDOP_RESYNC) {
  5646. spin_lock_irqsave(&ioc->raid_device_lock, flags);
  5647. handle = le16_to_cpu(event_data->VolDevHandle);
  5648. raid_device = _scsih_raid_device_find_by_handle(ioc, handle);
  5649. if (raid_device)
  5650. raid_device->percent_complete =
  5651. event_data->PercentComplete;
  5652. spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
  5653. }
  5654. }
  5655. /**
  5656. * _scsih_prep_device_scan - initialize parameters prior to device scan
  5657. * @ioc: per adapter object
  5658. *
  5659. * Set the deleted flag prior to device scan. If the device is found during
  5660. * the scan, then we clear the deleted flag.
  5661. */
  5662. static void
  5663. _scsih_prep_device_scan(struct MPT3SAS_ADAPTER *ioc)
  5664. {
  5665. struct MPT3SAS_DEVICE *sas_device_priv_data;
  5666. struct scsi_device *sdev;
  5667. shost_for_each_device(sdev, ioc->shost) {
  5668. sas_device_priv_data = sdev->hostdata;
  5669. if (sas_device_priv_data && sas_device_priv_data->sas_target)
  5670. sas_device_priv_data->sas_target->deleted = 1;
  5671. }
  5672. }
  5673. /**
  5674. * _scsih_mark_responding_sas_device - mark a sas_devices as responding
  5675. * @ioc: per adapter object
  5676. * @sas_address: sas address
  5677. * @slot: enclosure slot id
  5678. * @handle: device handle
  5679. *
  5680. * After host reset, find out whether devices are still responding.
  5681. * Used in _scsih_remove_unresponsive_sas_devices.
  5682. *
  5683. * Return nothing.
  5684. */
  5685. static void
  5686. _scsih_mark_responding_sas_device(struct MPT3SAS_ADAPTER *ioc, u64 sas_address,
  5687. u16 slot, u16 handle)
  5688. {
  5689. struct MPT3SAS_TARGET *sas_target_priv_data = NULL;
  5690. struct scsi_target *starget;
  5691. struct _sas_device *sas_device;
  5692. unsigned long flags;
  5693. spin_lock_irqsave(&ioc->sas_device_lock, flags);
  5694. list_for_each_entry(sas_device, &ioc->sas_device_list, list) {
  5695. if (sas_device->sas_address == sas_address &&
  5696. sas_device->slot == slot) {
  5697. sas_device->responding = 1;
  5698. starget = sas_device->starget;
  5699. if (starget && starget->hostdata) {
  5700. sas_target_priv_data = starget->hostdata;
  5701. sas_target_priv_data->tm_busy = 0;
  5702. sas_target_priv_data->deleted = 0;
  5703. } else
  5704. sas_target_priv_data = NULL;
  5705. if (starget)
  5706. starget_printk(KERN_INFO, starget,
  5707. "handle(0x%04x), sas_addr(0x%016llx), "
  5708. "enclosure logical id(0x%016llx), "
  5709. "slot(%d)\n", handle,
  5710. (unsigned long long)sas_device->sas_address,
  5711. (unsigned long long)
  5712. sas_device->enclosure_logical_id,
  5713. sas_device->slot);
  5714. if (sas_device->handle == handle)
  5715. goto out;
  5716. pr_info("\thandle changed from(0x%04x)!!!\n",
  5717. sas_device->handle);
  5718. sas_device->handle = handle;
  5719. if (sas_target_priv_data)
  5720. sas_target_priv_data->handle = handle;
  5721. goto out;
  5722. }
  5723. }
  5724. out:
  5725. spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
  5726. }
  5727. /**
  5728. * _scsih_search_responding_sas_devices -
  5729. * @ioc: per adapter object
  5730. *
  5731. * After host reset, find out whether devices are still responding.
  5732. * If not remove.
  5733. *
  5734. * Return nothing.
  5735. */
  5736. static void
  5737. _scsih_search_responding_sas_devices(struct MPT3SAS_ADAPTER *ioc)
  5738. {
  5739. Mpi2SasDevicePage0_t sas_device_pg0;
  5740. Mpi2ConfigReply_t mpi_reply;
  5741. u16 ioc_status;
  5742. u16 handle;
  5743. u32 device_info;
  5744. pr_info(MPT3SAS_FMT "search for end-devices: start\n", ioc->name);
  5745. if (list_empty(&ioc->sas_device_list))
  5746. goto out;
  5747. handle = 0xFFFF;
  5748. while (!(mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply,
  5749. &sas_device_pg0, MPI2_SAS_DEVICE_PGAD_FORM_GET_NEXT_HANDLE,
  5750. handle))) {
  5751. ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
  5752. MPI2_IOCSTATUS_MASK;
  5753. if (ioc_status != MPI2_IOCSTATUS_SUCCESS)
  5754. break;
  5755. handle = le16_to_cpu(sas_device_pg0.DevHandle);
  5756. device_info = le32_to_cpu(sas_device_pg0.DeviceInfo);
  5757. if (!(_scsih_is_end_device(device_info)))
  5758. continue;
  5759. _scsih_mark_responding_sas_device(ioc,
  5760. le64_to_cpu(sas_device_pg0.SASAddress),
  5761. le16_to_cpu(sas_device_pg0.Slot), handle);
  5762. }
  5763. out:
  5764. pr_info(MPT3SAS_FMT "search for end-devices: complete\n",
  5765. ioc->name);
  5766. }
  5767. /**
  5768. * _scsih_mark_responding_raid_device - mark a raid_device as responding
  5769. * @ioc: per adapter object
  5770. * @wwid: world wide identifier for raid volume
  5771. * @handle: device handle
  5772. *
  5773. * After host reset, find out whether devices are still responding.
  5774. * Used in _scsih_remove_unresponsive_raid_devices.
  5775. *
  5776. * Return nothing.
  5777. */
  5778. static void
  5779. _scsih_mark_responding_raid_device(struct MPT3SAS_ADAPTER *ioc, u64 wwid,
  5780. u16 handle)
  5781. {
  5782. struct MPT3SAS_TARGET *sas_target_priv_data;
  5783. struct scsi_target *starget;
  5784. struct _raid_device *raid_device;
  5785. unsigned long flags;
  5786. spin_lock_irqsave(&ioc->raid_device_lock, flags);
  5787. list_for_each_entry(raid_device, &ioc->raid_device_list, list) {
  5788. if (raid_device->wwid == wwid && raid_device->starget) {
  5789. starget = raid_device->starget;
  5790. if (starget && starget->hostdata) {
  5791. sas_target_priv_data = starget->hostdata;
  5792. sas_target_priv_data->deleted = 0;
  5793. } else
  5794. sas_target_priv_data = NULL;
  5795. raid_device->responding = 1;
  5796. spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
  5797. starget_printk(KERN_INFO, raid_device->starget,
  5798. "handle(0x%04x), wwid(0x%016llx)\n", handle,
  5799. (unsigned long long)raid_device->wwid);
  5800. spin_lock_irqsave(&ioc->raid_device_lock, flags);
  5801. if (raid_device->handle == handle) {
  5802. spin_unlock_irqrestore(&ioc->raid_device_lock,
  5803. flags);
  5804. return;
  5805. }
  5806. pr_info("\thandle changed from(0x%04x)!!!\n",
  5807. raid_device->handle);
  5808. raid_device->handle = handle;
  5809. if (sas_target_priv_data)
  5810. sas_target_priv_data->handle = handle;
  5811. spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
  5812. return;
  5813. }
  5814. }
  5815. spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
  5816. }
  5817. /**
  5818. * _scsih_search_responding_raid_devices -
  5819. * @ioc: per adapter object
  5820. *
  5821. * After host reset, find out whether devices are still responding.
  5822. * If not remove.
  5823. *
  5824. * Return nothing.
  5825. */
  5826. static void
  5827. _scsih_search_responding_raid_devices(struct MPT3SAS_ADAPTER *ioc)
  5828. {
  5829. Mpi2RaidVolPage1_t volume_pg1;
  5830. Mpi2RaidVolPage0_t volume_pg0;
  5831. Mpi2RaidPhysDiskPage0_t pd_pg0;
  5832. Mpi2ConfigReply_t mpi_reply;
  5833. u16 ioc_status;
  5834. u16 handle;
  5835. u8 phys_disk_num;
  5836. if (!ioc->ir_firmware)
  5837. return;
  5838. pr_info(MPT3SAS_FMT "search for raid volumes: start\n",
  5839. ioc->name);
  5840. if (list_empty(&ioc->raid_device_list))
  5841. goto out;
  5842. handle = 0xFFFF;
  5843. while (!(mpt3sas_config_get_raid_volume_pg1(ioc, &mpi_reply,
  5844. &volume_pg1, MPI2_RAID_VOLUME_PGAD_FORM_GET_NEXT_HANDLE, handle))) {
  5845. ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
  5846. MPI2_IOCSTATUS_MASK;
  5847. if (ioc_status != MPI2_IOCSTATUS_SUCCESS)
  5848. break;
  5849. handle = le16_to_cpu(volume_pg1.DevHandle);
  5850. if (mpt3sas_config_get_raid_volume_pg0(ioc, &mpi_reply,
  5851. &volume_pg0, MPI2_RAID_VOLUME_PGAD_FORM_HANDLE, handle,
  5852. sizeof(Mpi2RaidVolPage0_t)))
  5853. continue;
  5854. if (volume_pg0.VolumeState == MPI2_RAID_VOL_STATE_OPTIMAL ||
  5855. volume_pg0.VolumeState == MPI2_RAID_VOL_STATE_ONLINE ||
  5856. volume_pg0.VolumeState == MPI2_RAID_VOL_STATE_DEGRADED)
  5857. _scsih_mark_responding_raid_device(ioc,
  5858. le64_to_cpu(volume_pg1.WWID), handle);
  5859. }
  5860. /* refresh the pd_handles */
  5861. phys_disk_num = 0xFF;
  5862. memset(ioc->pd_handles, 0, ioc->pd_handles_sz);
  5863. while (!(mpt3sas_config_get_phys_disk_pg0(ioc, &mpi_reply,
  5864. &pd_pg0, MPI2_PHYSDISK_PGAD_FORM_GET_NEXT_PHYSDISKNUM,
  5865. phys_disk_num))) {
  5866. ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
  5867. MPI2_IOCSTATUS_MASK;
  5868. if (ioc_status != MPI2_IOCSTATUS_SUCCESS)
  5869. break;
  5870. phys_disk_num = pd_pg0.PhysDiskNum;
  5871. handle = le16_to_cpu(pd_pg0.DevHandle);
  5872. set_bit(handle, ioc->pd_handles);
  5873. }
  5874. out:
  5875. pr_info(MPT3SAS_FMT "search for responding raid volumes: complete\n",
  5876. ioc->name);
  5877. }
  5878. /**
  5879. * _scsih_mark_responding_expander - mark a expander as responding
  5880. * @ioc: per adapter object
  5881. * @sas_address: sas address
  5882. * @handle:
  5883. *
  5884. * After host reset, find out whether devices are still responding.
  5885. * Used in _scsih_remove_unresponsive_expanders.
  5886. *
  5887. * Return nothing.
  5888. */
  5889. static void
  5890. _scsih_mark_responding_expander(struct MPT3SAS_ADAPTER *ioc, u64 sas_address,
  5891. u16 handle)
  5892. {
  5893. struct _sas_node *sas_expander;
  5894. unsigned long flags;
  5895. int i;
  5896. spin_lock_irqsave(&ioc->sas_node_lock, flags);
  5897. list_for_each_entry(sas_expander, &ioc->sas_expander_list, list) {
  5898. if (sas_expander->sas_address != sas_address)
  5899. continue;
  5900. sas_expander->responding = 1;
  5901. if (sas_expander->handle == handle)
  5902. goto out;
  5903. pr_info("\texpander(0x%016llx): handle changed" \
  5904. " from(0x%04x) to (0x%04x)!!!\n",
  5905. (unsigned long long)sas_expander->sas_address,
  5906. sas_expander->handle, handle);
  5907. sas_expander->handle = handle;
  5908. for (i = 0 ; i < sas_expander->num_phys ; i++)
  5909. sas_expander->phy[i].handle = handle;
  5910. goto out;
  5911. }
  5912. out:
  5913. spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
  5914. }
  5915. /**
  5916. * _scsih_search_responding_expanders -
  5917. * @ioc: per adapter object
  5918. *
  5919. * After host reset, find out whether devices are still responding.
  5920. * If not remove.
  5921. *
  5922. * Return nothing.
  5923. */
  5924. static void
  5925. _scsih_search_responding_expanders(struct MPT3SAS_ADAPTER *ioc)
  5926. {
  5927. Mpi2ExpanderPage0_t expander_pg0;
  5928. Mpi2ConfigReply_t mpi_reply;
  5929. u16 ioc_status;
  5930. u64 sas_address;
  5931. u16 handle;
  5932. pr_info(MPT3SAS_FMT "search for expanders: start\n", ioc->name);
  5933. if (list_empty(&ioc->sas_expander_list))
  5934. goto out;
  5935. handle = 0xFFFF;
  5936. while (!(mpt3sas_config_get_expander_pg0(ioc, &mpi_reply, &expander_pg0,
  5937. MPI2_SAS_EXPAND_PGAD_FORM_GET_NEXT_HNDL, handle))) {
  5938. ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
  5939. MPI2_IOCSTATUS_MASK;
  5940. if (ioc_status != MPI2_IOCSTATUS_SUCCESS)
  5941. break;
  5942. handle = le16_to_cpu(expander_pg0.DevHandle);
  5943. sas_address = le64_to_cpu(expander_pg0.SASAddress);
  5944. pr_info("\texpander present: handle(0x%04x), sas_addr(0x%016llx)\n",
  5945. handle,
  5946. (unsigned long long)sas_address);
  5947. _scsih_mark_responding_expander(ioc, sas_address, handle);
  5948. }
  5949. out:
  5950. pr_info(MPT3SAS_FMT "search for expanders: complete\n", ioc->name);
  5951. }
  5952. /**
  5953. * _scsih_remove_unresponding_sas_devices - removing unresponding devices
  5954. * @ioc: per adapter object
  5955. *
  5956. * Return nothing.
  5957. */
  5958. static void
  5959. _scsih_remove_unresponding_sas_devices(struct MPT3SAS_ADAPTER *ioc)
  5960. {
  5961. struct _sas_device *sas_device, *sas_device_next;
  5962. struct _sas_node *sas_expander, *sas_expander_next;
  5963. struct _raid_device *raid_device, *raid_device_next;
  5964. struct list_head tmp_list;
  5965. unsigned long flags;
  5966. pr_info(MPT3SAS_FMT "removing unresponding devices: start\n",
  5967. ioc->name);
  5968. /* removing unresponding end devices */
  5969. pr_info(MPT3SAS_FMT "removing unresponding devices: end-devices\n",
  5970. ioc->name);
  5971. list_for_each_entry_safe(sas_device, sas_device_next,
  5972. &ioc->sas_device_list, list) {
  5973. if (!sas_device->responding)
  5974. mpt3sas_device_remove_by_sas_address(ioc,
  5975. sas_device->sas_address);
  5976. else
  5977. sas_device->responding = 0;
  5978. }
  5979. /* removing unresponding volumes */
  5980. if (ioc->ir_firmware) {
  5981. pr_info(MPT3SAS_FMT "removing unresponding devices: volumes\n",
  5982. ioc->name);
  5983. list_for_each_entry_safe(raid_device, raid_device_next,
  5984. &ioc->raid_device_list, list) {
  5985. if (!raid_device->responding)
  5986. _scsih_sas_volume_delete(ioc,
  5987. raid_device->handle);
  5988. else
  5989. raid_device->responding = 0;
  5990. }
  5991. }
  5992. /* removing unresponding expanders */
  5993. pr_info(MPT3SAS_FMT "removing unresponding devices: expanders\n",
  5994. ioc->name);
  5995. spin_lock_irqsave(&ioc->sas_node_lock, flags);
  5996. INIT_LIST_HEAD(&tmp_list);
  5997. list_for_each_entry_safe(sas_expander, sas_expander_next,
  5998. &ioc->sas_expander_list, list) {
  5999. if (!sas_expander->responding)
  6000. list_move_tail(&sas_expander->list, &tmp_list);
  6001. else
  6002. sas_expander->responding = 0;
  6003. }
  6004. spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
  6005. list_for_each_entry_safe(sas_expander, sas_expander_next, &tmp_list,
  6006. list) {
  6007. list_del(&sas_expander->list);
  6008. _scsih_expander_node_remove(ioc, sas_expander);
  6009. }
  6010. pr_info(MPT3SAS_FMT "removing unresponding devices: complete\n",
  6011. ioc->name);
  6012. /* unblock devices */
  6013. _scsih_ublock_io_all_device(ioc);
  6014. }
  6015. static void
  6016. _scsih_refresh_expander_links(struct MPT3SAS_ADAPTER *ioc,
  6017. struct _sas_node *sas_expander, u16 handle)
  6018. {
  6019. Mpi2ExpanderPage1_t expander_pg1;
  6020. Mpi2ConfigReply_t mpi_reply;
  6021. int i;
  6022. for (i = 0 ; i < sas_expander->num_phys ; i++) {
  6023. if ((mpt3sas_config_get_expander_pg1(ioc, &mpi_reply,
  6024. &expander_pg1, i, handle))) {
  6025. pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
  6026. ioc->name, __FILE__, __LINE__, __func__);
  6027. return;
  6028. }
  6029. mpt3sas_transport_update_links(ioc, sas_expander->sas_address,
  6030. le16_to_cpu(expander_pg1.AttachedDevHandle), i,
  6031. expander_pg1.NegotiatedLinkRate >> 4);
  6032. }
  6033. }
  6034. /**
  6035. * _scsih_scan_for_devices_after_reset - scan for devices after host reset
  6036. * @ioc: per adapter object
  6037. *
  6038. * Return nothing.
  6039. */
  6040. static void
  6041. _scsih_scan_for_devices_after_reset(struct MPT3SAS_ADAPTER *ioc)
  6042. {
  6043. Mpi2ExpanderPage0_t expander_pg0;
  6044. Mpi2SasDevicePage0_t sas_device_pg0;
  6045. Mpi2RaidVolPage1_t volume_pg1;
  6046. Mpi2RaidVolPage0_t volume_pg0;
  6047. Mpi2RaidPhysDiskPage0_t pd_pg0;
  6048. Mpi2EventIrConfigElement_t element;
  6049. Mpi2ConfigReply_t mpi_reply;
  6050. u8 phys_disk_num;
  6051. u16 ioc_status;
  6052. u16 handle, parent_handle;
  6053. u64 sas_address;
  6054. struct _sas_device *sas_device;
  6055. struct _sas_node *expander_device;
  6056. static struct _raid_device *raid_device;
  6057. u8 retry_count;
  6058. unsigned long flags;
  6059. pr_info(MPT3SAS_FMT "scan devices: start\n", ioc->name);
  6060. _scsih_sas_host_refresh(ioc);
  6061. pr_info(MPT3SAS_FMT "\tscan devices: expanders start\n", ioc->name);
  6062. /* expanders */
  6063. handle = 0xFFFF;
  6064. while (!(mpt3sas_config_get_expander_pg0(ioc, &mpi_reply, &expander_pg0,
  6065. MPI2_SAS_EXPAND_PGAD_FORM_GET_NEXT_HNDL, handle))) {
  6066. ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
  6067. MPI2_IOCSTATUS_MASK;
  6068. if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
  6069. pr_info(MPT3SAS_FMT "\tbreak from expander scan: " \
  6070. "ioc_status(0x%04x), loginfo(0x%08x)\n",
  6071. ioc->name, ioc_status,
  6072. le32_to_cpu(mpi_reply.IOCLogInfo));
  6073. break;
  6074. }
  6075. handle = le16_to_cpu(expander_pg0.DevHandle);
  6076. spin_lock_irqsave(&ioc->sas_node_lock, flags);
  6077. expander_device = mpt3sas_scsih_expander_find_by_sas_address(
  6078. ioc, le64_to_cpu(expander_pg0.SASAddress));
  6079. spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
  6080. if (expander_device)
  6081. _scsih_refresh_expander_links(ioc, expander_device,
  6082. handle);
  6083. else {
  6084. pr_info(MPT3SAS_FMT "\tBEFORE adding expander: " \
  6085. "handle (0x%04x), sas_addr(0x%016llx)\n", ioc->name,
  6086. handle, (unsigned long long)
  6087. le64_to_cpu(expander_pg0.SASAddress));
  6088. _scsih_expander_add(ioc, handle);
  6089. pr_info(MPT3SAS_FMT "\tAFTER adding expander: " \
  6090. "handle (0x%04x), sas_addr(0x%016llx)\n", ioc->name,
  6091. handle, (unsigned long long)
  6092. le64_to_cpu(expander_pg0.SASAddress));
  6093. }
  6094. }
  6095. pr_info(MPT3SAS_FMT "\tscan devices: expanders complete\n",
  6096. ioc->name);
  6097. if (!ioc->ir_firmware)
  6098. goto skip_to_sas;
  6099. pr_info(MPT3SAS_FMT "\tscan devices: phys disk start\n", ioc->name);
  6100. /* phys disk */
  6101. phys_disk_num = 0xFF;
  6102. while (!(mpt3sas_config_get_phys_disk_pg0(ioc, &mpi_reply,
  6103. &pd_pg0, MPI2_PHYSDISK_PGAD_FORM_GET_NEXT_PHYSDISKNUM,
  6104. phys_disk_num))) {
  6105. ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
  6106. MPI2_IOCSTATUS_MASK;
  6107. if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
  6108. pr_info(MPT3SAS_FMT "\tbreak from phys disk scan: "\
  6109. "ioc_status(0x%04x), loginfo(0x%08x)\n",
  6110. ioc->name, ioc_status,
  6111. le32_to_cpu(mpi_reply.IOCLogInfo));
  6112. break;
  6113. }
  6114. phys_disk_num = pd_pg0.PhysDiskNum;
  6115. handle = le16_to_cpu(pd_pg0.DevHandle);
  6116. spin_lock_irqsave(&ioc->sas_device_lock, flags);
  6117. sas_device = _scsih_sas_device_find_by_handle(ioc, handle);
  6118. spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
  6119. if (sas_device)
  6120. continue;
  6121. if (mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply,
  6122. &sas_device_pg0, MPI2_SAS_DEVICE_PGAD_FORM_HANDLE,
  6123. handle) != 0)
  6124. continue;
  6125. ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
  6126. MPI2_IOCSTATUS_MASK;
  6127. if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
  6128. pr_info(MPT3SAS_FMT "\tbreak from phys disk scan " \
  6129. "ioc_status(0x%04x), loginfo(0x%08x)\n",
  6130. ioc->name, ioc_status,
  6131. le32_to_cpu(mpi_reply.IOCLogInfo));
  6132. break;
  6133. }
  6134. parent_handle = le16_to_cpu(sas_device_pg0.ParentDevHandle);
  6135. if (!_scsih_get_sas_address(ioc, parent_handle,
  6136. &sas_address)) {
  6137. pr_info(MPT3SAS_FMT "\tBEFORE adding phys disk: " \
  6138. " handle (0x%04x), sas_addr(0x%016llx)\n",
  6139. ioc->name, handle, (unsigned long long)
  6140. le64_to_cpu(sas_device_pg0.SASAddress));
  6141. mpt3sas_transport_update_links(ioc, sas_address,
  6142. handle, sas_device_pg0.PhyNum,
  6143. MPI2_SAS_NEG_LINK_RATE_1_5);
  6144. set_bit(handle, ioc->pd_handles);
  6145. retry_count = 0;
  6146. /* This will retry adding the end device.
  6147. * _scsih_add_device() will decide on retries and
  6148. * return "1" when it should be retried
  6149. */
  6150. while (_scsih_add_device(ioc, handle, retry_count++,
  6151. 1)) {
  6152. ssleep(1);
  6153. }
  6154. pr_info(MPT3SAS_FMT "\tAFTER adding phys disk: " \
  6155. " handle (0x%04x), sas_addr(0x%016llx)\n",
  6156. ioc->name, handle, (unsigned long long)
  6157. le64_to_cpu(sas_device_pg0.SASAddress));
  6158. }
  6159. }
  6160. pr_info(MPT3SAS_FMT "\tscan devices: phys disk complete\n",
  6161. ioc->name);
  6162. pr_info(MPT3SAS_FMT "\tscan devices: volumes start\n", ioc->name);
  6163. /* volumes */
  6164. handle = 0xFFFF;
  6165. while (!(mpt3sas_config_get_raid_volume_pg1(ioc, &mpi_reply,
  6166. &volume_pg1, MPI2_RAID_VOLUME_PGAD_FORM_GET_NEXT_HANDLE, handle))) {
  6167. ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
  6168. MPI2_IOCSTATUS_MASK;
  6169. if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
  6170. pr_info(MPT3SAS_FMT "\tbreak from volume scan: " \
  6171. "ioc_status(0x%04x), loginfo(0x%08x)\n",
  6172. ioc->name, ioc_status,
  6173. le32_to_cpu(mpi_reply.IOCLogInfo));
  6174. break;
  6175. }
  6176. handle = le16_to_cpu(volume_pg1.DevHandle);
  6177. spin_lock_irqsave(&ioc->raid_device_lock, flags);
  6178. raid_device = _scsih_raid_device_find_by_wwid(ioc,
  6179. le64_to_cpu(volume_pg1.WWID));
  6180. spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
  6181. if (raid_device)
  6182. continue;
  6183. if (mpt3sas_config_get_raid_volume_pg0(ioc, &mpi_reply,
  6184. &volume_pg0, MPI2_RAID_VOLUME_PGAD_FORM_HANDLE, handle,
  6185. sizeof(Mpi2RaidVolPage0_t)))
  6186. continue;
  6187. ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
  6188. MPI2_IOCSTATUS_MASK;
  6189. if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
  6190. pr_info(MPT3SAS_FMT "\tbreak from volume scan: " \
  6191. "ioc_status(0x%04x), loginfo(0x%08x)\n",
  6192. ioc->name, ioc_status,
  6193. le32_to_cpu(mpi_reply.IOCLogInfo));
  6194. break;
  6195. }
  6196. if (volume_pg0.VolumeState == MPI2_RAID_VOL_STATE_OPTIMAL ||
  6197. volume_pg0.VolumeState == MPI2_RAID_VOL_STATE_ONLINE ||
  6198. volume_pg0.VolumeState == MPI2_RAID_VOL_STATE_DEGRADED) {
  6199. memset(&element, 0, sizeof(Mpi2EventIrConfigElement_t));
  6200. element.ReasonCode = MPI2_EVENT_IR_CHANGE_RC_ADDED;
  6201. element.VolDevHandle = volume_pg1.DevHandle;
  6202. pr_info(MPT3SAS_FMT
  6203. "\tBEFORE adding volume: handle (0x%04x)\n",
  6204. ioc->name, volume_pg1.DevHandle);
  6205. _scsih_sas_volume_add(ioc, &element);
  6206. pr_info(MPT3SAS_FMT
  6207. "\tAFTER adding volume: handle (0x%04x)\n",
  6208. ioc->name, volume_pg1.DevHandle);
  6209. }
  6210. }
  6211. pr_info(MPT3SAS_FMT "\tscan devices: volumes complete\n",
  6212. ioc->name);
  6213. skip_to_sas:
  6214. pr_info(MPT3SAS_FMT "\tscan devices: end devices start\n",
  6215. ioc->name);
  6216. /* sas devices */
  6217. handle = 0xFFFF;
  6218. while (!(mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply,
  6219. &sas_device_pg0, MPI2_SAS_DEVICE_PGAD_FORM_GET_NEXT_HANDLE,
  6220. handle))) {
  6221. ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
  6222. MPI2_IOCSTATUS_MASK;
  6223. if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
  6224. pr_info(MPT3SAS_FMT "\tbreak from end device scan:"\
  6225. " ioc_status(0x%04x), loginfo(0x%08x)\n",
  6226. ioc->name, ioc_status,
  6227. le32_to_cpu(mpi_reply.IOCLogInfo));
  6228. break;
  6229. }
  6230. handle = le16_to_cpu(sas_device_pg0.DevHandle);
  6231. if (!(_scsih_is_end_device(
  6232. le32_to_cpu(sas_device_pg0.DeviceInfo))))
  6233. continue;
  6234. spin_lock_irqsave(&ioc->sas_device_lock, flags);
  6235. sas_device = mpt3sas_scsih_sas_device_find_by_sas_address(ioc,
  6236. le64_to_cpu(sas_device_pg0.SASAddress));
  6237. spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
  6238. if (sas_device)
  6239. continue;
  6240. parent_handle = le16_to_cpu(sas_device_pg0.ParentDevHandle);
  6241. if (!_scsih_get_sas_address(ioc, parent_handle, &sas_address)) {
  6242. pr_info(MPT3SAS_FMT "\tBEFORE adding end device: " \
  6243. "handle (0x%04x), sas_addr(0x%016llx)\n", ioc->name,
  6244. handle, (unsigned long long)
  6245. le64_to_cpu(sas_device_pg0.SASAddress));
  6246. mpt3sas_transport_update_links(ioc, sas_address, handle,
  6247. sas_device_pg0.PhyNum, MPI2_SAS_NEG_LINK_RATE_1_5);
  6248. retry_count = 0;
  6249. /* This will retry adding the end device.
  6250. * _scsih_add_device() will decide on retries and
  6251. * return "1" when it should be retried
  6252. */
  6253. while (_scsih_add_device(ioc, handle, retry_count++,
  6254. 0)) {
  6255. ssleep(1);
  6256. }
  6257. pr_info(MPT3SAS_FMT "\tAFTER adding end device: " \
  6258. "handle (0x%04x), sas_addr(0x%016llx)\n", ioc->name,
  6259. handle, (unsigned long long)
  6260. le64_to_cpu(sas_device_pg0.SASAddress));
  6261. }
  6262. }
  6263. pr_info(MPT3SAS_FMT "\tscan devices: end devices complete\n",
  6264. ioc->name);
  6265. pr_info(MPT3SAS_FMT "scan devices: complete\n", ioc->name);
  6266. }
  6267. /**
  6268. * mpt3sas_scsih_reset_handler - reset callback handler (for scsih)
  6269. * @ioc: per adapter object
  6270. * @reset_phase: phase
  6271. *
  6272. * The handler for doing any required cleanup or initialization.
  6273. *
  6274. * The reset phase can be MPT3_IOC_PRE_RESET, MPT3_IOC_AFTER_RESET,
  6275. * MPT3_IOC_DONE_RESET
  6276. *
  6277. * Return nothing.
  6278. */
  6279. void
  6280. mpt3sas_scsih_reset_handler(struct MPT3SAS_ADAPTER *ioc, int reset_phase)
  6281. {
  6282. switch (reset_phase) {
  6283. case MPT3_IOC_PRE_RESET:
  6284. dtmprintk(ioc, pr_info(MPT3SAS_FMT
  6285. "%s: MPT3_IOC_PRE_RESET\n", ioc->name, __func__));
  6286. break;
  6287. case MPT3_IOC_AFTER_RESET:
  6288. dtmprintk(ioc, pr_info(MPT3SAS_FMT
  6289. "%s: MPT3_IOC_AFTER_RESET\n", ioc->name, __func__));
  6290. if (ioc->scsih_cmds.status & MPT3_CMD_PENDING) {
  6291. ioc->scsih_cmds.status |= MPT3_CMD_RESET;
  6292. mpt3sas_base_free_smid(ioc, ioc->scsih_cmds.smid);
  6293. complete(&ioc->scsih_cmds.done);
  6294. }
  6295. if (ioc->tm_cmds.status & MPT3_CMD_PENDING) {
  6296. ioc->tm_cmds.status |= MPT3_CMD_RESET;
  6297. mpt3sas_base_free_smid(ioc, ioc->tm_cmds.smid);
  6298. complete(&ioc->tm_cmds.done);
  6299. }
  6300. _scsih_fw_event_cleanup_queue(ioc);
  6301. _scsih_flush_running_cmds(ioc);
  6302. break;
  6303. case MPT3_IOC_DONE_RESET:
  6304. dtmprintk(ioc, pr_info(MPT3SAS_FMT
  6305. "%s: MPT3_IOC_DONE_RESET\n", ioc->name, __func__));
  6306. if ((!ioc->is_driver_loading) && !(disable_discovery > 0 &&
  6307. !ioc->sas_hba.num_phys)) {
  6308. _scsih_prep_device_scan(ioc);
  6309. _scsih_search_responding_sas_devices(ioc);
  6310. _scsih_search_responding_raid_devices(ioc);
  6311. _scsih_search_responding_expanders(ioc);
  6312. _scsih_error_recovery_delete_devices(ioc);
  6313. }
  6314. break;
  6315. }
  6316. }
  6317. /**
  6318. * _mpt3sas_fw_work - delayed task for processing firmware events
  6319. * @ioc: per adapter object
  6320. * @fw_event: The fw_event_work object
  6321. * Context: user.
  6322. *
  6323. * Return nothing.
  6324. */
  6325. static void
  6326. _mpt3sas_fw_work(struct MPT3SAS_ADAPTER *ioc, struct fw_event_work *fw_event)
  6327. {
  6328. /* the queue is being flushed so ignore this event */
  6329. if (ioc->remove_host || fw_event->cancel_pending_work ||
  6330. ioc->pci_error_recovery) {
  6331. _scsih_fw_event_free(ioc, fw_event);
  6332. return;
  6333. }
  6334. switch (fw_event->event) {
  6335. case MPT3SAS_PROCESS_TRIGGER_DIAG:
  6336. mpt3sas_process_trigger_data(ioc, fw_event->event_data);
  6337. break;
  6338. case MPT3SAS_REMOVE_UNRESPONDING_DEVICES:
  6339. while (scsi_host_in_recovery(ioc->shost) || ioc->shost_recovery)
  6340. ssleep(1);
  6341. _scsih_remove_unresponding_sas_devices(ioc);
  6342. _scsih_scan_for_devices_after_reset(ioc);
  6343. break;
  6344. case MPT3SAS_PORT_ENABLE_COMPLETE:
  6345. ioc->start_scan = 0;
  6346. if (missing_delay[0] != -1 && missing_delay[1] != -1)
  6347. mpt3sas_base_update_missing_delay(ioc, missing_delay[0],
  6348. missing_delay[1]);
  6349. dewtprintk(ioc, pr_info(MPT3SAS_FMT
  6350. "port enable: complete from worker thread\n",
  6351. ioc->name));
  6352. break;
  6353. case MPT3SAS_TURN_ON_FAULT_LED:
  6354. _scsih_turn_on_fault_led(ioc, fw_event->device_handle);
  6355. break;
  6356. case MPI2_EVENT_SAS_TOPOLOGY_CHANGE_LIST:
  6357. _scsih_sas_topology_change_event(ioc, fw_event);
  6358. break;
  6359. case MPI2_EVENT_SAS_DEVICE_STATUS_CHANGE:
  6360. _scsih_sas_device_status_change_event(ioc, fw_event);
  6361. break;
  6362. case MPI2_EVENT_SAS_DISCOVERY:
  6363. _scsih_sas_discovery_event(ioc, fw_event);
  6364. break;
  6365. case MPI2_EVENT_SAS_BROADCAST_PRIMITIVE:
  6366. _scsih_sas_broadcast_primitive_event(ioc, fw_event);
  6367. break;
  6368. case MPI2_EVENT_SAS_ENCL_DEVICE_STATUS_CHANGE:
  6369. _scsih_sas_enclosure_dev_status_change_event(ioc,
  6370. fw_event);
  6371. break;
  6372. case MPI2_EVENT_IR_CONFIGURATION_CHANGE_LIST:
  6373. _scsih_sas_ir_config_change_event(ioc, fw_event);
  6374. break;
  6375. case MPI2_EVENT_IR_VOLUME:
  6376. _scsih_sas_ir_volume_event(ioc, fw_event);
  6377. break;
  6378. case MPI2_EVENT_IR_PHYSICAL_DISK:
  6379. _scsih_sas_ir_physical_disk_event(ioc, fw_event);
  6380. break;
  6381. case MPI2_EVENT_IR_OPERATION_STATUS:
  6382. _scsih_sas_ir_operation_status_event(ioc, fw_event);
  6383. break;
  6384. }
  6385. _scsih_fw_event_free(ioc, fw_event);
  6386. }
  6387. /**
  6388. * _firmware_event_work
  6389. * @ioc: per adapter object
  6390. * @work: The fw_event_work object
  6391. * Context: user.
  6392. *
  6393. * wrappers for the work thread handling firmware events
  6394. *
  6395. * Return nothing.
  6396. */
  6397. static void
  6398. _firmware_event_work(struct work_struct *work)
  6399. {
  6400. struct fw_event_work *fw_event = container_of(work,
  6401. struct fw_event_work, work);
  6402. _mpt3sas_fw_work(fw_event->ioc, fw_event);
  6403. }
  6404. /**
  6405. * mpt3sas_scsih_event_callback - firmware event handler (called at ISR time)
  6406. * @ioc: per adapter object
  6407. * @msix_index: MSIX table index supplied by the OS
  6408. * @reply: reply message frame(lower 32bit addr)
  6409. * Context: interrupt.
  6410. *
  6411. * This function merely adds a new work task into ioc->firmware_event_thread.
  6412. * The tasks are worked from _firmware_event_work in user context.
  6413. *
  6414. * Return 1 meaning mf should be freed from _base_interrupt
  6415. * 0 means the mf is freed from this function.
  6416. */
  6417. u8
  6418. mpt3sas_scsih_event_callback(struct MPT3SAS_ADAPTER *ioc, u8 msix_index,
  6419. u32 reply)
  6420. {
  6421. struct fw_event_work *fw_event;
  6422. Mpi2EventNotificationReply_t *mpi_reply;
  6423. u16 event;
  6424. u16 sz;
  6425. /* events turned off due to host reset or driver unloading */
  6426. if (ioc->remove_host || ioc->pci_error_recovery)
  6427. return 1;
  6428. mpi_reply = mpt3sas_base_get_reply_virt_addr(ioc, reply);
  6429. if (unlikely(!mpi_reply)) {
  6430. pr_err(MPT3SAS_FMT "mpi_reply not valid at %s:%d/%s()!\n",
  6431. ioc->name, __FILE__, __LINE__, __func__);
  6432. return 1;
  6433. }
  6434. event = le16_to_cpu(mpi_reply->Event);
  6435. if (event != MPI2_EVENT_LOG_ENTRY_ADDED)
  6436. mpt3sas_trigger_event(ioc, event, 0);
  6437. switch (event) {
  6438. /* handle these */
  6439. case MPI2_EVENT_SAS_BROADCAST_PRIMITIVE:
  6440. {
  6441. Mpi2EventDataSasBroadcastPrimitive_t *baen_data =
  6442. (Mpi2EventDataSasBroadcastPrimitive_t *)
  6443. mpi_reply->EventData;
  6444. if (baen_data->Primitive !=
  6445. MPI2_EVENT_PRIMITIVE_ASYNCHRONOUS_EVENT)
  6446. return 1;
  6447. if (ioc->broadcast_aen_busy) {
  6448. ioc->broadcast_aen_pending++;
  6449. return 1;
  6450. } else
  6451. ioc->broadcast_aen_busy = 1;
  6452. break;
  6453. }
  6454. case MPI2_EVENT_SAS_TOPOLOGY_CHANGE_LIST:
  6455. _scsih_check_topo_delete_events(ioc,
  6456. (Mpi2EventDataSasTopologyChangeList_t *)
  6457. mpi_reply->EventData);
  6458. break;
  6459. case MPI2_EVENT_IR_CONFIGURATION_CHANGE_LIST:
  6460. _scsih_check_ir_config_unhide_events(ioc,
  6461. (Mpi2EventDataIrConfigChangeList_t *)
  6462. mpi_reply->EventData);
  6463. break;
  6464. case MPI2_EVENT_IR_VOLUME:
  6465. _scsih_check_volume_delete_events(ioc,
  6466. (Mpi2EventDataIrVolume_t *)
  6467. mpi_reply->EventData);
  6468. break;
  6469. case MPI2_EVENT_SAS_DEVICE_STATUS_CHANGE:
  6470. case MPI2_EVENT_IR_OPERATION_STATUS:
  6471. case MPI2_EVENT_SAS_DISCOVERY:
  6472. case MPI2_EVENT_SAS_ENCL_DEVICE_STATUS_CHANGE:
  6473. case MPI2_EVENT_IR_PHYSICAL_DISK:
  6474. break;
  6475. default: /* ignore the rest */
  6476. return 1;
  6477. }
  6478. fw_event = kzalloc(sizeof(struct fw_event_work), GFP_ATOMIC);
  6479. if (!fw_event) {
  6480. pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
  6481. ioc->name, __FILE__, __LINE__, __func__);
  6482. return 1;
  6483. }
  6484. sz = le16_to_cpu(mpi_reply->EventDataLength) * 4;
  6485. fw_event->event_data = kzalloc(sz, GFP_ATOMIC);
  6486. if (!fw_event->event_data) {
  6487. pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
  6488. ioc->name, __FILE__, __LINE__, __func__);
  6489. kfree(fw_event);
  6490. return 1;
  6491. }
  6492. memcpy(fw_event->event_data, mpi_reply->EventData, sz);
  6493. fw_event->ioc = ioc;
  6494. fw_event->VF_ID = mpi_reply->VF_ID;
  6495. fw_event->VP_ID = mpi_reply->VP_ID;
  6496. fw_event->event = event;
  6497. _scsih_fw_event_add(ioc, fw_event);
  6498. return 1;
  6499. }
  6500. /* shost template */
  6501. static struct scsi_host_template scsih_driver_template = {
  6502. .module = THIS_MODULE,
  6503. .name = "Fusion MPT SAS Host",
  6504. .proc_name = MPT3SAS_DRIVER_NAME,
  6505. .queuecommand = _scsih_qcmd,
  6506. .target_alloc = _scsih_target_alloc,
  6507. .slave_alloc = _scsih_slave_alloc,
  6508. .slave_configure = _scsih_slave_configure,
  6509. .target_destroy = _scsih_target_destroy,
  6510. .slave_destroy = _scsih_slave_destroy,
  6511. .scan_finished = _scsih_scan_finished,
  6512. .scan_start = _scsih_scan_start,
  6513. .change_queue_depth = _scsih_change_queue_depth,
  6514. .change_queue_type = _scsih_change_queue_type,
  6515. .eh_abort_handler = _scsih_abort,
  6516. .eh_device_reset_handler = _scsih_dev_reset,
  6517. .eh_target_reset_handler = _scsih_target_reset,
  6518. .eh_host_reset_handler = _scsih_host_reset,
  6519. .bios_param = _scsih_bios_param,
  6520. .can_queue = 1,
  6521. .this_id = -1,
  6522. .sg_tablesize = MPT3SAS_SG_DEPTH,
  6523. .max_sectors = 32767,
  6524. .cmd_per_lun = 7,
  6525. .use_clustering = ENABLE_CLUSTERING,
  6526. .shost_attrs = mpt3sas_host_attrs,
  6527. .sdev_attrs = mpt3sas_dev_attrs,
  6528. };
  6529. /**
  6530. * _scsih_expander_node_remove - removing expander device from list.
  6531. * @ioc: per adapter object
  6532. * @sas_expander: the sas_device object
  6533. * Context: Calling function should acquire ioc->sas_node_lock.
  6534. *
  6535. * Removing object and freeing associated memory from the
  6536. * ioc->sas_expander_list.
  6537. *
  6538. * Return nothing.
  6539. */
  6540. static void
  6541. _scsih_expander_node_remove(struct MPT3SAS_ADAPTER *ioc,
  6542. struct _sas_node *sas_expander)
  6543. {
  6544. struct _sas_port *mpt3sas_port, *next;
  6545. /* remove sibling ports attached to this expander */
  6546. list_for_each_entry_safe(mpt3sas_port, next,
  6547. &sas_expander->sas_port_list, port_list) {
  6548. if (ioc->shost_recovery)
  6549. return;
  6550. if (mpt3sas_port->remote_identify.device_type ==
  6551. SAS_END_DEVICE)
  6552. mpt3sas_device_remove_by_sas_address(ioc,
  6553. mpt3sas_port->remote_identify.sas_address);
  6554. else if (mpt3sas_port->remote_identify.device_type ==
  6555. SAS_EDGE_EXPANDER_DEVICE ||
  6556. mpt3sas_port->remote_identify.device_type ==
  6557. SAS_FANOUT_EXPANDER_DEVICE)
  6558. mpt3sas_expander_remove(ioc,
  6559. mpt3sas_port->remote_identify.sas_address);
  6560. }
  6561. mpt3sas_transport_port_remove(ioc, sas_expander->sas_address,
  6562. sas_expander->sas_address_parent);
  6563. pr_info(MPT3SAS_FMT
  6564. "expander_remove: handle(0x%04x), sas_addr(0x%016llx)\n",
  6565. ioc->name,
  6566. sas_expander->handle, (unsigned long long)
  6567. sas_expander->sas_address);
  6568. kfree(sas_expander->phy);
  6569. kfree(sas_expander);
  6570. }
  6571. /**
  6572. * _scsih_ir_shutdown - IR shutdown notification
  6573. * @ioc: per adapter object
  6574. *
  6575. * Sending RAID Action to alert the Integrated RAID subsystem of the IOC that
  6576. * the host system is shutting down.
  6577. *
  6578. * Return nothing.
  6579. */
  6580. static void
  6581. _scsih_ir_shutdown(struct MPT3SAS_ADAPTER *ioc)
  6582. {
  6583. Mpi2RaidActionRequest_t *mpi_request;
  6584. Mpi2RaidActionReply_t *mpi_reply;
  6585. u16 smid;
  6586. /* is IR firmware build loaded ? */
  6587. if (!ioc->ir_firmware)
  6588. return;
  6589. /* are there any volumes ? */
  6590. if (list_empty(&ioc->raid_device_list))
  6591. return;
  6592. mutex_lock(&ioc->scsih_cmds.mutex);
  6593. if (ioc->scsih_cmds.status != MPT3_CMD_NOT_USED) {
  6594. pr_err(MPT3SAS_FMT "%s: scsih_cmd in use\n",
  6595. ioc->name, __func__);
  6596. goto out;
  6597. }
  6598. ioc->scsih_cmds.status = MPT3_CMD_PENDING;
  6599. smid = mpt3sas_base_get_smid(ioc, ioc->scsih_cb_idx);
  6600. if (!smid) {
  6601. pr_err(MPT3SAS_FMT "%s: failed obtaining a smid\n",
  6602. ioc->name, __func__);
  6603. ioc->scsih_cmds.status = MPT3_CMD_NOT_USED;
  6604. goto out;
  6605. }
  6606. mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
  6607. ioc->scsih_cmds.smid = smid;
  6608. memset(mpi_request, 0, sizeof(Mpi2RaidActionRequest_t));
  6609. mpi_request->Function = MPI2_FUNCTION_RAID_ACTION;
  6610. mpi_request->Action = MPI2_RAID_ACTION_SYSTEM_SHUTDOWN_INITIATED;
  6611. pr_info(MPT3SAS_FMT "IR shutdown (sending)\n", ioc->name);
  6612. init_completion(&ioc->scsih_cmds.done);
  6613. mpt3sas_base_put_smid_default(ioc, smid);
  6614. wait_for_completion_timeout(&ioc->scsih_cmds.done, 10*HZ);
  6615. if (!(ioc->scsih_cmds.status & MPT3_CMD_COMPLETE)) {
  6616. pr_err(MPT3SAS_FMT "%s: timeout\n",
  6617. ioc->name, __func__);
  6618. goto out;
  6619. }
  6620. if (ioc->scsih_cmds.status & MPT3_CMD_REPLY_VALID) {
  6621. mpi_reply = ioc->scsih_cmds.reply;
  6622. pr_info(MPT3SAS_FMT
  6623. "IR shutdown (complete): ioc_status(0x%04x), loginfo(0x%08x)\n",
  6624. ioc->name, le16_to_cpu(mpi_reply->IOCStatus),
  6625. le32_to_cpu(mpi_reply->IOCLogInfo));
  6626. }
  6627. out:
  6628. ioc->scsih_cmds.status = MPT3_CMD_NOT_USED;
  6629. mutex_unlock(&ioc->scsih_cmds.mutex);
  6630. }
  6631. /**
  6632. * _scsih_remove - detach and remove add host
  6633. * @pdev: PCI device struct
  6634. *
  6635. * Routine called when unloading the driver.
  6636. * Return nothing.
  6637. */
  6638. static void _scsih_remove(struct pci_dev *pdev)
  6639. {
  6640. struct Scsi_Host *shost = pci_get_drvdata(pdev);
  6641. struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
  6642. struct _sas_port *mpt3sas_port, *next_port;
  6643. struct _raid_device *raid_device, *next;
  6644. struct MPT3SAS_TARGET *sas_target_priv_data;
  6645. struct workqueue_struct *wq;
  6646. unsigned long flags;
  6647. ioc->remove_host = 1;
  6648. _scsih_fw_event_cleanup_queue(ioc);
  6649. spin_lock_irqsave(&ioc->fw_event_lock, flags);
  6650. wq = ioc->firmware_event_thread;
  6651. ioc->firmware_event_thread = NULL;
  6652. spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
  6653. if (wq)
  6654. destroy_workqueue(wq);
  6655. /* release all the volumes */
  6656. _scsih_ir_shutdown(ioc);
  6657. list_for_each_entry_safe(raid_device, next, &ioc->raid_device_list,
  6658. list) {
  6659. if (raid_device->starget) {
  6660. sas_target_priv_data =
  6661. raid_device->starget->hostdata;
  6662. sas_target_priv_data->deleted = 1;
  6663. scsi_remove_target(&raid_device->starget->dev);
  6664. }
  6665. pr_info(MPT3SAS_FMT "removing handle(0x%04x), wwid(0x%016llx)\n",
  6666. ioc->name, raid_device->handle,
  6667. (unsigned long long) raid_device->wwid);
  6668. _scsih_raid_device_remove(ioc, raid_device);
  6669. }
  6670. /* free ports attached to the sas_host */
  6671. list_for_each_entry_safe(mpt3sas_port, next_port,
  6672. &ioc->sas_hba.sas_port_list, port_list) {
  6673. if (mpt3sas_port->remote_identify.device_type ==
  6674. SAS_END_DEVICE)
  6675. mpt3sas_device_remove_by_sas_address(ioc,
  6676. mpt3sas_port->remote_identify.sas_address);
  6677. else if (mpt3sas_port->remote_identify.device_type ==
  6678. SAS_EDGE_EXPANDER_DEVICE ||
  6679. mpt3sas_port->remote_identify.device_type ==
  6680. SAS_FANOUT_EXPANDER_DEVICE)
  6681. mpt3sas_expander_remove(ioc,
  6682. mpt3sas_port->remote_identify.sas_address);
  6683. }
  6684. /* free phys attached to the sas_host */
  6685. if (ioc->sas_hba.num_phys) {
  6686. kfree(ioc->sas_hba.phy);
  6687. ioc->sas_hba.phy = NULL;
  6688. ioc->sas_hba.num_phys = 0;
  6689. }
  6690. sas_remove_host(shost);
  6691. mpt3sas_base_detach(ioc);
  6692. list_del(&ioc->list);
  6693. scsi_remove_host(shost);
  6694. scsi_host_put(shost);
  6695. }
  6696. /**
  6697. * _scsih_shutdown - routine call during system shutdown
  6698. * @pdev: PCI device struct
  6699. *
  6700. * Return nothing.
  6701. */
  6702. static void
  6703. _scsih_shutdown(struct pci_dev *pdev)
  6704. {
  6705. struct Scsi_Host *shost = pci_get_drvdata(pdev);
  6706. struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
  6707. struct workqueue_struct *wq;
  6708. unsigned long flags;
  6709. ioc->remove_host = 1;
  6710. _scsih_fw_event_cleanup_queue(ioc);
  6711. spin_lock_irqsave(&ioc->fw_event_lock, flags);
  6712. wq = ioc->firmware_event_thread;
  6713. ioc->firmware_event_thread = NULL;
  6714. spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
  6715. if (wq)
  6716. destroy_workqueue(wq);
  6717. _scsih_ir_shutdown(ioc);
  6718. mpt3sas_base_detach(ioc);
  6719. }
  6720. /**
  6721. * _scsih_probe_boot_devices - reports 1st device
  6722. * @ioc: per adapter object
  6723. *
  6724. * If specified in bios page 2, this routine reports the 1st
  6725. * device scsi-ml or sas transport for persistent boot device
  6726. * purposes. Please refer to function _scsih_determine_boot_device()
  6727. */
  6728. static void
  6729. _scsih_probe_boot_devices(struct MPT3SAS_ADAPTER *ioc)
  6730. {
  6731. u8 is_raid;
  6732. void *device;
  6733. struct _sas_device *sas_device;
  6734. struct _raid_device *raid_device;
  6735. u16 handle;
  6736. u64 sas_address_parent;
  6737. u64 sas_address;
  6738. unsigned long flags;
  6739. int rc;
  6740. /* no Bios, return immediately */
  6741. if (!ioc->bios_pg3.BiosVersion)
  6742. return;
  6743. device = NULL;
  6744. is_raid = 0;
  6745. if (ioc->req_boot_device.device) {
  6746. device = ioc->req_boot_device.device;
  6747. is_raid = ioc->req_boot_device.is_raid;
  6748. } else if (ioc->req_alt_boot_device.device) {
  6749. device = ioc->req_alt_boot_device.device;
  6750. is_raid = ioc->req_alt_boot_device.is_raid;
  6751. } else if (ioc->current_boot_device.device) {
  6752. device = ioc->current_boot_device.device;
  6753. is_raid = ioc->current_boot_device.is_raid;
  6754. }
  6755. if (!device)
  6756. return;
  6757. if (is_raid) {
  6758. raid_device = device;
  6759. rc = scsi_add_device(ioc->shost, RAID_CHANNEL,
  6760. raid_device->id, 0);
  6761. if (rc)
  6762. _scsih_raid_device_remove(ioc, raid_device);
  6763. } else {
  6764. spin_lock_irqsave(&ioc->sas_device_lock, flags);
  6765. sas_device = device;
  6766. handle = sas_device->handle;
  6767. sas_address_parent = sas_device->sas_address_parent;
  6768. sas_address = sas_device->sas_address;
  6769. list_move_tail(&sas_device->list, &ioc->sas_device_list);
  6770. spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
  6771. if (!mpt3sas_transport_port_add(ioc, handle,
  6772. sas_address_parent)) {
  6773. _scsih_sas_device_remove(ioc, sas_device);
  6774. } else if (!sas_device->starget) {
  6775. if (!ioc->is_driver_loading) {
  6776. mpt3sas_transport_port_remove(ioc,
  6777. sas_address,
  6778. sas_address_parent);
  6779. _scsih_sas_device_remove(ioc, sas_device);
  6780. }
  6781. }
  6782. }
  6783. }
  6784. /**
  6785. * _scsih_probe_raid - reporting raid volumes to scsi-ml
  6786. * @ioc: per adapter object
  6787. *
  6788. * Called during initial loading of the driver.
  6789. */
  6790. static void
  6791. _scsih_probe_raid(struct MPT3SAS_ADAPTER *ioc)
  6792. {
  6793. struct _raid_device *raid_device, *raid_next;
  6794. int rc;
  6795. list_for_each_entry_safe(raid_device, raid_next,
  6796. &ioc->raid_device_list, list) {
  6797. if (raid_device->starget)
  6798. continue;
  6799. rc = scsi_add_device(ioc->shost, RAID_CHANNEL,
  6800. raid_device->id, 0);
  6801. if (rc)
  6802. _scsih_raid_device_remove(ioc, raid_device);
  6803. }
  6804. }
  6805. /**
  6806. * _scsih_probe_sas - reporting sas devices to sas transport
  6807. * @ioc: per adapter object
  6808. *
  6809. * Called during initial loading of the driver.
  6810. */
  6811. static void
  6812. _scsih_probe_sas(struct MPT3SAS_ADAPTER *ioc)
  6813. {
  6814. struct _sas_device *sas_device, *next;
  6815. unsigned long flags;
  6816. /* SAS Device List */
  6817. list_for_each_entry_safe(sas_device, next, &ioc->sas_device_init_list,
  6818. list) {
  6819. if (!mpt3sas_transport_port_add(ioc, sas_device->handle,
  6820. sas_device->sas_address_parent)) {
  6821. list_del(&sas_device->list);
  6822. kfree(sas_device);
  6823. continue;
  6824. } else if (!sas_device->starget) {
  6825. /*
  6826. * When asyn scanning is enabled, its not possible to
  6827. * remove devices while scanning is turned on due to an
  6828. * oops in scsi_sysfs_add_sdev()->add_device()->
  6829. * sysfs_addrm_start()
  6830. */
  6831. if (!ioc->is_driver_loading) {
  6832. mpt3sas_transport_port_remove(ioc,
  6833. sas_device->sas_address,
  6834. sas_device->sas_address_parent);
  6835. list_del(&sas_device->list);
  6836. kfree(sas_device);
  6837. continue;
  6838. }
  6839. }
  6840. spin_lock_irqsave(&ioc->sas_device_lock, flags);
  6841. list_move_tail(&sas_device->list, &ioc->sas_device_list);
  6842. spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
  6843. }
  6844. }
  6845. /**
  6846. * _scsih_probe_devices - probing for devices
  6847. * @ioc: per adapter object
  6848. *
  6849. * Called during initial loading of the driver.
  6850. */
  6851. static void
  6852. _scsih_probe_devices(struct MPT3SAS_ADAPTER *ioc)
  6853. {
  6854. u16 volume_mapping_flags;
  6855. if (!(ioc->facts.ProtocolFlags & MPI2_IOCFACTS_PROTOCOL_SCSI_INITIATOR))
  6856. return; /* return when IOC doesn't support initiator mode */
  6857. _scsih_probe_boot_devices(ioc);
  6858. if (ioc->ir_firmware) {
  6859. volume_mapping_flags =
  6860. le16_to_cpu(ioc->ioc_pg8.IRVolumeMappingFlags) &
  6861. MPI2_IOCPAGE8_IRFLAGS_MASK_VOLUME_MAPPING_MODE;
  6862. if (volume_mapping_flags ==
  6863. MPI2_IOCPAGE8_IRFLAGS_LOW_VOLUME_MAPPING) {
  6864. _scsih_probe_raid(ioc);
  6865. _scsih_probe_sas(ioc);
  6866. } else {
  6867. _scsih_probe_sas(ioc);
  6868. _scsih_probe_raid(ioc);
  6869. }
  6870. } else
  6871. _scsih_probe_sas(ioc);
  6872. }
  6873. /**
  6874. * _scsih_scan_start - scsi lld callback for .scan_start
  6875. * @shost: SCSI host pointer
  6876. *
  6877. * The shost has the ability to discover targets on its own instead
  6878. * of scanning the entire bus. In our implemention, we will kick off
  6879. * firmware discovery.
  6880. */
  6881. static void
  6882. _scsih_scan_start(struct Scsi_Host *shost)
  6883. {
  6884. struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
  6885. int rc;
  6886. if (diag_buffer_enable != -1 && diag_buffer_enable != 0)
  6887. mpt3sas_enable_diag_buffer(ioc, diag_buffer_enable);
  6888. if (disable_discovery > 0)
  6889. return;
  6890. ioc->start_scan = 1;
  6891. rc = mpt3sas_port_enable(ioc);
  6892. if (rc != 0)
  6893. pr_info(MPT3SAS_FMT "port enable: FAILED\n", ioc->name);
  6894. }
  6895. /**
  6896. * _scsih_scan_finished - scsi lld callback for .scan_finished
  6897. * @shost: SCSI host pointer
  6898. * @time: elapsed time of the scan in jiffies
  6899. *
  6900. * This function will be called periodicallyn until it returns 1 with the
  6901. * scsi_host and the elapsed time of the scan in jiffies. In our implemention,
  6902. * we wait for firmware discovery to complete, then return 1.
  6903. */
  6904. static int
  6905. _scsih_scan_finished(struct Scsi_Host *shost, unsigned long time)
  6906. {
  6907. struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
  6908. if (disable_discovery > 0) {
  6909. ioc->is_driver_loading = 0;
  6910. ioc->wait_for_discovery_to_complete = 0;
  6911. return 1;
  6912. }
  6913. if (time >= (300 * HZ)) {
  6914. ioc->base_cmds.status = MPT3_CMD_NOT_USED;
  6915. pr_info(MPT3SAS_FMT
  6916. "port enable: FAILED with timeout (timeout=300s)\n",
  6917. ioc->name);
  6918. ioc->is_driver_loading = 0;
  6919. return 1;
  6920. }
  6921. if (ioc->start_scan)
  6922. return 0;
  6923. if (ioc->start_scan_failed) {
  6924. pr_info(MPT3SAS_FMT
  6925. "port enable: FAILED with (ioc_status=0x%08x)\n",
  6926. ioc->name, ioc->start_scan_failed);
  6927. ioc->is_driver_loading = 0;
  6928. ioc->wait_for_discovery_to_complete = 0;
  6929. ioc->remove_host = 1;
  6930. return 1;
  6931. }
  6932. pr_info(MPT3SAS_FMT "port enable: SUCCESS\n", ioc->name);
  6933. ioc->base_cmds.status = MPT3_CMD_NOT_USED;
  6934. if (ioc->wait_for_discovery_to_complete) {
  6935. ioc->wait_for_discovery_to_complete = 0;
  6936. _scsih_probe_devices(ioc);
  6937. }
  6938. mpt3sas_base_start_watchdog(ioc);
  6939. ioc->is_driver_loading = 0;
  6940. return 1;
  6941. }
  6942. /**
  6943. * _scsih_probe - attach and add scsi host
  6944. * @pdev: PCI device struct
  6945. * @id: pci device id
  6946. *
  6947. * Returns 0 success, anything else error.
  6948. */
  6949. static int
  6950. _scsih_probe(struct pci_dev *pdev, const struct pci_device_id *id)
  6951. {
  6952. struct MPT3SAS_ADAPTER *ioc;
  6953. struct Scsi_Host *shost;
  6954. shost = scsi_host_alloc(&scsih_driver_template,
  6955. sizeof(struct MPT3SAS_ADAPTER));
  6956. if (!shost)
  6957. return -ENODEV;
  6958. /* init local params */
  6959. ioc = shost_priv(shost);
  6960. memset(ioc, 0, sizeof(struct MPT3SAS_ADAPTER));
  6961. INIT_LIST_HEAD(&ioc->list);
  6962. list_add_tail(&ioc->list, &mpt3sas_ioc_list);
  6963. ioc->shost = shost;
  6964. ioc->id = mpt_ids++;
  6965. sprintf(ioc->name, "%s%d", MPT3SAS_DRIVER_NAME, ioc->id);
  6966. ioc->pdev = pdev;
  6967. ioc->scsi_io_cb_idx = scsi_io_cb_idx;
  6968. ioc->tm_cb_idx = tm_cb_idx;
  6969. ioc->ctl_cb_idx = ctl_cb_idx;
  6970. ioc->base_cb_idx = base_cb_idx;
  6971. ioc->port_enable_cb_idx = port_enable_cb_idx;
  6972. ioc->transport_cb_idx = transport_cb_idx;
  6973. ioc->scsih_cb_idx = scsih_cb_idx;
  6974. ioc->config_cb_idx = config_cb_idx;
  6975. ioc->tm_tr_cb_idx = tm_tr_cb_idx;
  6976. ioc->tm_tr_volume_cb_idx = tm_tr_volume_cb_idx;
  6977. ioc->tm_sas_control_cb_idx = tm_sas_control_cb_idx;
  6978. ioc->logging_level = logging_level;
  6979. ioc->schedule_dead_ioc_flush_running_cmds = &_scsih_flush_running_cmds;
  6980. /* misc semaphores and spin locks */
  6981. mutex_init(&ioc->reset_in_progress_mutex);
  6982. spin_lock_init(&ioc->ioc_reset_in_progress_lock);
  6983. spin_lock_init(&ioc->scsi_lookup_lock);
  6984. spin_lock_init(&ioc->sas_device_lock);
  6985. spin_lock_init(&ioc->sas_node_lock);
  6986. spin_lock_init(&ioc->fw_event_lock);
  6987. spin_lock_init(&ioc->raid_device_lock);
  6988. spin_lock_init(&ioc->diag_trigger_lock);
  6989. INIT_LIST_HEAD(&ioc->sas_device_list);
  6990. INIT_LIST_HEAD(&ioc->sas_device_init_list);
  6991. INIT_LIST_HEAD(&ioc->sas_expander_list);
  6992. INIT_LIST_HEAD(&ioc->fw_event_list);
  6993. INIT_LIST_HEAD(&ioc->raid_device_list);
  6994. INIT_LIST_HEAD(&ioc->sas_hba.sas_port_list);
  6995. INIT_LIST_HEAD(&ioc->delayed_tr_list);
  6996. INIT_LIST_HEAD(&ioc->delayed_tr_volume_list);
  6997. INIT_LIST_HEAD(&ioc->reply_queue_list);
  6998. /* init shost parameters */
  6999. shost->max_cmd_len = 32;
  7000. shost->max_lun = max_lun;
  7001. shost->transportt = mpt3sas_transport_template;
  7002. shost->unique_id = ioc->id;
  7003. if (max_sectors != 0xFFFF) {
  7004. if (max_sectors < 64) {
  7005. shost->max_sectors = 64;
  7006. pr_warn(MPT3SAS_FMT "Invalid value %d passed " \
  7007. "for max_sectors, range is 64 to 32767. Assigning "
  7008. "value of 64.\n", ioc->name, max_sectors);
  7009. } else if (max_sectors > 32767) {
  7010. shost->max_sectors = 32767;
  7011. pr_warn(MPT3SAS_FMT "Invalid value %d passed " \
  7012. "for max_sectors, range is 64 to 32767. Assigning "
  7013. "default value of 32767.\n", ioc->name,
  7014. max_sectors);
  7015. } else {
  7016. shost->max_sectors = max_sectors & 0xFFFE;
  7017. pr_info(MPT3SAS_FMT
  7018. "The max_sectors value is set to %d\n",
  7019. ioc->name, shost->max_sectors);
  7020. }
  7021. }
  7022. if ((scsi_add_host(shost, &pdev->dev))) {
  7023. pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
  7024. ioc->name, __FILE__, __LINE__, __func__);
  7025. list_del(&ioc->list);
  7026. goto out_add_shost_fail;
  7027. }
  7028. /* register EEDP capabilities with SCSI layer */
  7029. if (prot_mask > 0)
  7030. scsi_host_set_prot(shost, prot_mask);
  7031. else
  7032. scsi_host_set_prot(shost, SHOST_DIF_TYPE1_PROTECTION
  7033. | SHOST_DIF_TYPE2_PROTECTION
  7034. | SHOST_DIF_TYPE3_PROTECTION);
  7035. scsi_host_set_guard(shost, SHOST_DIX_GUARD_CRC);
  7036. /* event thread */
  7037. snprintf(ioc->firmware_event_name, sizeof(ioc->firmware_event_name),
  7038. "fw_event%d", ioc->id);
  7039. ioc->firmware_event_thread = create_singlethread_workqueue(
  7040. ioc->firmware_event_name);
  7041. if (!ioc->firmware_event_thread) {
  7042. pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
  7043. ioc->name, __FILE__, __LINE__, __func__);
  7044. goto out_thread_fail;
  7045. }
  7046. ioc->is_driver_loading = 1;
  7047. if ((mpt3sas_base_attach(ioc))) {
  7048. pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
  7049. ioc->name, __FILE__, __LINE__, __func__);
  7050. goto out_attach_fail;
  7051. }
  7052. scsi_scan_host(shost);
  7053. return 0;
  7054. out_attach_fail:
  7055. destroy_workqueue(ioc->firmware_event_thread);
  7056. out_thread_fail:
  7057. list_del(&ioc->list);
  7058. scsi_remove_host(shost);
  7059. out_add_shost_fail:
  7060. scsi_host_put(shost);
  7061. return -ENODEV;
  7062. }
  7063. #ifdef CONFIG_PM
  7064. /**
  7065. * _scsih_suspend - power management suspend main entry point
  7066. * @pdev: PCI device struct
  7067. * @state: PM state change to (usually PCI_D3)
  7068. *
  7069. * Returns 0 success, anything else error.
  7070. */
  7071. static int
  7072. _scsih_suspend(struct pci_dev *pdev, pm_message_t state)
  7073. {
  7074. struct Scsi_Host *shost = pci_get_drvdata(pdev);
  7075. struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
  7076. pci_power_t device_state;
  7077. mpt3sas_base_stop_watchdog(ioc);
  7078. flush_scheduled_work();
  7079. scsi_block_requests(shost);
  7080. device_state = pci_choose_state(pdev, state);
  7081. pr_info(MPT3SAS_FMT
  7082. "pdev=0x%p, slot=%s, entering operating state [D%d]\n",
  7083. ioc->name, pdev, pci_name(pdev), device_state);
  7084. pci_save_state(pdev);
  7085. mpt3sas_base_free_resources(ioc);
  7086. pci_set_power_state(pdev, device_state);
  7087. return 0;
  7088. }
  7089. /**
  7090. * _scsih_resume - power management resume main entry point
  7091. * @pdev: PCI device struct
  7092. *
  7093. * Returns 0 success, anything else error.
  7094. */
  7095. static int
  7096. _scsih_resume(struct pci_dev *pdev)
  7097. {
  7098. struct Scsi_Host *shost = pci_get_drvdata(pdev);
  7099. struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
  7100. pci_power_t device_state = pdev->current_state;
  7101. int r;
  7102. pr_info(MPT3SAS_FMT
  7103. "pdev=0x%p, slot=%s, previous operating state [D%d]\n",
  7104. ioc->name, pdev, pci_name(pdev), device_state);
  7105. pci_set_power_state(pdev, PCI_D0);
  7106. pci_enable_wake(pdev, PCI_D0, 0);
  7107. pci_restore_state(pdev);
  7108. ioc->pdev = pdev;
  7109. r = mpt3sas_base_map_resources(ioc);
  7110. if (r)
  7111. return r;
  7112. mpt3sas_base_hard_reset_handler(ioc, CAN_SLEEP, SOFT_RESET);
  7113. scsi_unblock_requests(shost);
  7114. mpt3sas_base_start_watchdog(ioc);
  7115. return 0;
  7116. }
  7117. #endif /* CONFIG_PM */
  7118. /**
  7119. * _scsih_pci_error_detected - Called when a PCI error is detected.
  7120. * @pdev: PCI device struct
  7121. * @state: PCI channel state
  7122. *
  7123. * Description: Called when a PCI error is detected.
  7124. *
  7125. * Return value:
  7126. * PCI_ERS_RESULT_NEED_RESET or PCI_ERS_RESULT_DISCONNECT
  7127. */
  7128. static pci_ers_result_t
  7129. _scsih_pci_error_detected(struct pci_dev *pdev, pci_channel_state_t state)
  7130. {
  7131. struct Scsi_Host *shost = pci_get_drvdata(pdev);
  7132. struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
  7133. pr_info(MPT3SAS_FMT "PCI error: detected callback, state(%d)!!\n",
  7134. ioc->name, state);
  7135. switch (state) {
  7136. case pci_channel_io_normal:
  7137. return PCI_ERS_RESULT_CAN_RECOVER;
  7138. case pci_channel_io_frozen:
  7139. /* Fatal error, prepare for slot reset */
  7140. ioc->pci_error_recovery = 1;
  7141. scsi_block_requests(ioc->shost);
  7142. mpt3sas_base_stop_watchdog(ioc);
  7143. mpt3sas_base_free_resources(ioc);
  7144. return PCI_ERS_RESULT_NEED_RESET;
  7145. case pci_channel_io_perm_failure:
  7146. /* Permanent error, prepare for device removal */
  7147. ioc->pci_error_recovery = 1;
  7148. mpt3sas_base_stop_watchdog(ioc);
  7149. _scsih_flush_running_cmds(ioc);
  7150. return PCI_ERS_RESULT_DISCONNECT;
  7151. }
  7152. return PCI_ERS_RESULT_NEED_RESET;
  7153. }
  7154. /**
  7155. * _scsih_pci_slot_reset - Called when PCI slot has been reset.
  7156. * @pdev: PCI device struct
  7157. *
  7158. * Description: This routine is called by the pci error recovery
  7159. * code after the PCI slot has been reset, just before we
  7160. * should resume normal operations.
  7161. */
  7162. static pci_ers_result_t
  7163. _scsih_pci_slot_reset(struct pci_dev *pdev)
  7164. {
  7165. struct Scsi_Host *shost = pci_get_drvdata(pdev);
  7166. struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
  7167. int rc;
  7168. pr_info(MPT3SAS_FMT "PCI error: slot reset callback!!\n",
  7169. ioc->name);
  7170. ioc->pci_error_recovery = 0;
  7171. ioc->pdev = pdev;
  7172. pci_restore_state(pdev);
  7173. rc = mpt3sas_base_map_resources(ioc);
  7174. if (rc)
  7175. return PCI_ERS_RESULT_DISCONNECT;
  7176. rc = mpt3sas_base_hard_reset_handler(ioc, CAN_SLEEP,
  7177. FORCE_BIG_HAMMER);
  7178. pr_warn(MPT3SAS_FMT "hard reset: %s\n", ioc->name,
  7179. (rc == 0) ? "success" : "failed");
  7180. if (!rc)
  7181. return PCI_ERS_RESULT_RECOVERED;
  7182. else
  7183. return PCI_ERS_RESULT_DISCONNECT;
  7184. }
  7185. /**
  7186. * _scsih_pci_resume() - resume normal ops after PCI reset
  7187. * @pdev: pointer to PCI device
  7188. *
  7189. * Called when the error recovery driver tells us that its
  7190. * OK to resume normal operation. Use completion to allow
  7191. * halted scsi ops to resume.
  7192. */
  7193. static void
  7194. _scsih_pci_resume(struct pci_dev *pdev)
  7195. {
  7196. struct Scsi_Host *shost = pci_get_drvdata(pdev);
  7197. struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
  7198. pr_info(MPT3SAS_FMT "PCI error: resume callback!!\n", ioc->name);
  7199. pci_cleanup_aer_uncorrect_error_status(pdev);
  7200. mpt3sas_base_start_watchdog(ioc);
  7201. scsi_unblock_requests(ioc->shost);
  7202. }
  7203. /**
  7204. * _scsih_pci_mmio_enabled - Enable MMIO and dump debug registers
  7205. * @pdev: pointer to PCI device
  7206. */
  7207. static pci_ers_result_t
  7208. _scsih_pci_mmio_enabled(struct pci_dev *pdev)
  7209. {
  7210. struct Scsi_Host *shost = pci_get_drvdata(pdev);
  7211. struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
  7212. pr_info(MPT3SAS_FMT "PCI error: mmio enabled callback!!\n",
  7213. ioc->name);
  7214. /* TODO - dump whatever for debugging purposes */
  7215. /* Request a slot reset. */
  7216. return PCI_ERS_RESULT_NEED_RESET;
  7217. }
  7218. /* raid transport support */
  7219. static struct raid_function_template mpt3sas_raid_functions = {
  7220. .cookie = &scsih_driver_template,
  7221. .is_raid = _scsih_is_raid,
  7222. .get_resync = _scsih_get_resync,
  7223. .get_state = _scsih_get_state,
  7224. };
  7225. static struct pci_error_handlers _scsih_err_handler = {
  7226. .error_detected = _scsih_pci_error_detected,
  7227. .mmio_enabled = _scsih_pci_mmio_enabled,
  7228. .slot_reset = _scsih_pci_slot_reset,
  7229. .resume = _scsih_pci_resume,
  7230. };
  7231. static struct pci_driver scsih_driver = {
  7232. .name = MPT3SAS_DRIVER_NAME,
  7233. .id_table = scsih_pci_table,
  7234. .probe = _scsih_probe,
  7235. .remove = _scsih_remove,
  7236. .shutdown = _scsih_shutdown,
  7237. .err_handler = &_scsih_err_handler,
  7238. #ifdef CONFIG_PM
  7239. .suspend = _scsih_suspend,
  7240. .resume = _scsih_resume,
  7241. #endif
  7242. };
  7243. /**
  7244. * _scsih_init - main entry point for this driver.
  7245. *
  7246. * Returns 0 success, anything else error.
  7247. */
  7248. static int __init
  7249. _scsih_init(void)
  7250. {
  7251. int error;
  7252. mpt_ids = 0;
  7253. pr_info("%s version %s loaded\n", MPT3SAS_DRIVER_NAME,
  7254. MPT3SAS_DRIVER_VERSION);
  7255. mpt3sas_transport_template =
  7256. sas_attach_transport(&mpt3sas_transport_functions);
  7257. if (!mpt3sas_transport_template)
  7258. return -ENODEV;
  7259. /* raid transport support */
  7260. mpt3sas_raid_template = raid_class_attach(&mpt3sas_raid_functions);
  7261. if (!mpt3sas_raid_template) {
  7262. sas_release_transport(mpt3sas_transport_template);
  7263. return -ENODEV;
  7264. }
  7265. mpt3sas_base_initialize_callback_handler();
  7266. /* queuecommand callback hander */
  7267. scsi_io_cb_idx = mpt3sas_base_register_callback_handler(_scsih_io_done);
  7268. /* task managment callback handler */
  7269. tm_cb_idx = mpt3sas_base_register_callback_handler(_scsih_tm_done);
  7270. /* base internal commands callback handler */
  7271. base_cb_idx = mpt3sas_base_register_callback_handler(mpt3sas_base_done);
  7272. port_enable_cb_idx = mpt3sas_base_register_callback_handler(
  7273. mpt3sas_port_enable_done);
  7274. /* transport internal commands callback handler */
  7275. transport_cb_idx = mpt3sas_base_register_callback_handler(
  7276. mpt3sas_transport_done);
  7277. /* scsih internal commands callback handler */
  7278. scsih_cb_idx = mpt3sas_base_register_callback_handler(_scsih_done);
  7279. /* configuration page API internal commands callback handler */
  7280. config_cb_idx = mpt3sas_base_register_callback_handler(
  7281. mpt3sas_config_done);
  7282. /* ctl module callback handler */
  7283. ctl_cb_idx = mpt3sas_base_register_callback_handler(mpt3sas_ctl_done);
  7284. tm_tr_cb_idx = mpt3sas_base_register_callback_handler(
  7285. _scsih_tm_tr_complete);
  7286. tm_tr_volume_cb_idx = mpt3sas_base_register_callback_handler(
  7287. _scsih_tm_volume_tr_complete);
  7288. tm_sas_control_cb_idx = mpt3sas_base_register_callback_handler(
  7289. _scsih_sas_control_complete);
  7290. mpt3sas_ctl_init();
  7291. error = pci_register_driver(&scsih_driver);
  7292. if (error) {
  7293. /* raid transport support */
  7294. raid_class_release(mpt3sas_raid_template);
  7295. sas_release_transport(mpt3sas_transport_template);
  7296. }
  7297. return error;
  7298. }
  7299. /**
  7300. * _scsih_exit - exit point for this driver (when it is a module).
  7301. *
  7302. * Returns 0 success, anything else error.
  7303. */
  7304. static void __exit
  7305. _scsih_exit(void)
  7306. {
  7307. pr_info("mpt3sas version %s unloading\n",
  7308. MPT3SAS_DRIVER_VERSION);
  7309. mpt3sas_ctl_exit();
  7310. pci_unregister_driver(&scsih_driver);
  7311. mpt3sas_base_release_callback_handler(scsi_io_cb_idx);
  7312. mpt3sas_base_release_callback_handler(tm_cb_idx);
  7313. mpt3sas_base_release_callback_handler(base_cb_idx);
  7314. mpt3sas_base_release_callback_handler(port_enable_cb_idx);
  7315. mpt3sas_base_release_callback_handler(transport_cb_idx);
  7316. mpt3sas_base_release_callback_handler(scsih_cb_idx);
  7317. mpt3sas_base_release_callback_handler(config_cb_idx);
  7318. mpt3sas_base_release_callback_handler(ctl_cb_idx);
  7319. mpt3sas_base_release_callback_handler(tm_tr_cb_idx);
  7320. mpt3sas_base_release_callback_handler(tm_tr_volume_cb_idx);
  7321. mpt3sas_base_release_callback_handler(tm_sas_control_cb_idx);
  7322. /* raid transport support */
  7323. raid_class_release(mpt3sas_raid_template);
  7324. sas_release_transport(mpt3sas_transport_template);
  7325. }
  7326. module_init(_scsih_init);
  7327. module_exit(_scsih_exit);